8. Moving Asteroids¶

In this lesson we'll add all the movement for the asteroids:

• moving left at a random angle when they spawn
• bouncing off the top and bottom of the screen
• de-spawning when they move past the left of the screen

Let's get going.

Starting movement¶

Planning¶

So far, our objects have only moved up and down the y-axis. We want the asteroids to move diagonally, on both the x-axis and the y-axis. We could use trigonometry to work out the x_speed and y_speed we need, but Steven Tucker has already done the hard work for us.

The RoomObject methods include set_direction, which makes an object move at an angle and a speed. In GameFrame, 0° is moving right, and the angles go clockwise (because y increases going down the screen): 90° is down, 180° is left and 270° is up.

We want some randomness in the direction, so we'll choose an angle from a range. Let's look at our options.

• 180° (black line) moves straight across the screen
• 135° (red line) is 45° less than 180° and gives a nice bounce across the screen
• 260° (blue line) is 80° more than 180° and mostly bounces up and down, barely crossing the screen

So the best range is 180° plus or minus 45°, which is 135 to 225.

Coding¶

Open Objects/Asteroid.py and add the highlighted code below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

from GameFrame import RoomObject
import random

class Asteroid(RoomObject):
    """
    A class for Zork's dangerous obstacles
    """

    def __init__(self, room, x, y):
        """
        Initialise the Asteroid object
        """
        # include attributes and methods from RoomObject
        RoomObject.__init__(self, room, x, y)

        # set image
        image = self.load_image("asteroid.png")
        self.set_image(image,50,49)

        # set travel direction
        angle = random.randint(135,225)
        self.set_direction(angle, 10)

Bouncing off the top and bottom¶

Planning¶

We want the asteroids to bounce off the top and bottom of the screen so they stay in the window. To do that, we need to understand how set_direction works.

The screen is a Cartesian plane (it has x and y coordinates), so any movement is made of an x component and a y component.

When we use set_direction, GameFrame uses trigonometry to work out the x_speed and y_speed. That means we already know how to bounce an object off the top and bottom, because we did it for Zork: negate its y_speed. The only difference is that Zork's x_speed is 0.

Coding¶

Just like Zork, we need:

• a keep_in_room method that negates the asteroid's y_speed if it's touching the top or bottom of the screen
• a step method that calls keep_in_room on every tick

Go back to Objects/Asteroid.py and add the highlighted code below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

from GameFrame import RoomObject, Globals
import random

class Asteroid(RoomObject):
    """
    A class for Zork's dangerous obstacles
    """

    def __init__(self, room, x, y):
        """
        Initialise the Asteroid object
        """
        # include attributes and methods from RoomObject
        RoomObject.__init__(self, room, x, y)

        # set image
        image = self.load_image("asteroid.png")
        self.set_image(image,50,49)

        # set travel direction
        angle = random.randint(135,225)
        self.set_direction(angle, 10)

    def step(self):
        """
        Determines what happens to the asteroid on each tick of the game clock
        """
        self.keep_in_room()

    def keep_in_room(self):
        """
        Keeps the asteroid inside the top and bottom room limits
        """
        if self.y < 0:
            self.y = 0
            self.y_speed *= -1
        elif self.y > Globals.SCREEN_HEIGHT - self.height:
            self.y = Globals.SCREEN_HEIGHT - self.height
            self.y_speed *= -1

De-spawning asteroids¶

When an asteroid leaves the screen on the left, we want to destroy it. Why? Each object uses a little bit of memory. If we never destroy them, all those little bits add up, slow the computer down and can eventually crash it. That's called a memory leak. It would take a very long game for our asteroids to do that, but it's good programming practice to destroy objects we no longer need.

Planning¶

We know how to tell when an object touches the top or bottom of the screen, but how do we know when it has gone past the left edge? Let's work it out:

• left and right is the x-axis, so we're looking at x values
• the left edge of the screen is at x = 0
• an object has left the Room when its right-hand side is less than 0
• the right-hand side of an object is x + width (see below)

So the trigger is self.x + self.width < 0.

Now, how do we de-spawn an object? Looking at the RoomObject methods, there's a delete_object method. That sounds about right.

Coding¶

Still in Objects/Asteroid.py, add the highlighted code below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

from GameFrame import RoomObject, Globals
import random

class Asteroid(RoomObject):
    """
    A class for Zork's dangerous obstacles
    """

    def __init__(self, room, x, y):
        """
        Initialise the Asteroid object
        """
        # include attributes and methods from RoomObject
        RoomObject.__init__(self, room, x, y)

        # set image
        image = self.load_image("asteroid.png")
        self.set_image(image,50,49)

        # set travel direction
        angle = random.randint(135,225)
        self.set_direction(angle, 10)

    def step(self):
        """
        Determines what happens to the asteroid on each tick of the game clock
        """
        self.keep_in_room()
        self.outside_of_room()

    def keep_in_room(self):
        """
        Keeps the asteroid inside the top and bottom room limits
        """
        if self.y < 0:
            self.y = 0
            self.y_speed *= -1
        elif self.y > Globals.SCREEN_HEIGHT - self.height:
            self.y = Globals.SCREEN_HEIGHT - self.height
            self.y_speed *= -1

    def outside_of_room(self):
        """
        removes asteroids that have exited the room
        """
        if self.x + self.width < 0:
            self.room.delete_object(self)

How did it go? Were the asteroids deleted? How could you tell?

The problem is that the asteroid is already off the screen when outside_of_room deletes it, so we can't see anything happen. In situations like this, it's useful to print to the terminal to see what's going on inside our program.

Go back to Objects/Asteroid.py and add the highlighted line below.

42
43
44
45
46
47
48

    def outside_of_room(self):
        """
        removes asteroids that have exited the room
        """
        if self.x + self.width < 0:
            print("asteroid deleted")
            self.room.delete_object(self)

Commit and push¶

1. In GitHub Desktop, type Moved asteroids in the Summary box.
2. Click Commit to main.
3. Click Push origin.