13. Scoring¶

Now we have all our moving parts, it's time to reward the player for their efforts, and what better reward than a score?

GameFrame is event-driven, so the easiest way to add scoring is to connect it to events. We'll give the player both positive and negative scoring events:

• rescuing an astronaut → +50 points
• shooting an asteroid → +5 points
• shooting an astronaut → −10 points

Let's work out how to add this to our code.

Display the score¶

Planning¶

First we need somewhere to keep the score. The Globals variables include SCORE, so we can use that.

Next we need a way to draw the score on the screen. The Text Object is a special kind of RoomObject that displays text, so we can treat it like any other RoomObject. Its __init__ method takes some extra arguments, and it has an update_text method that redraws the text.

So we have a way to record the score and a way to display it. Before we start changing the score, let's display the current SCORE on the screen.

Create the Score class¶

Create a new file in the Objects folder, add the code below and save it as Hud.py.

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

from GameFrame import TextObject, Globals

class Score(TextObject):
    """
    A class for displaying the current score
    """
    def __init__(self, room, x: int, y: int, text=None):
        """
        Initialises the score object
        """         
        # include attributes and methods from TextObject
        TextObject.__init__(self, room, x, y, text)

        # set values         
        self.size = 60
        self.font = 'Arial Black'
        self.colour = (255,255,255)
        self.bold = False
        self.update_text()

Open Objects/__init__.py, add the highlighted code below and save it.

1
2
3
4
5
6
7

from Objects.Title import Title
from Objects.Ship import Ship
from Objects.Zork import Zork
from Objects.Asteroid import Asteroid
from Objects.Laser import Laser
from Objects.Astronaut import Astronaut
from Objects.Hud import Score

Add the score to the Room¶

Now we need to add a Score to the GamePlay Room. Open Rooms/GamePlay.py, add the highlighted code below and save it.

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

from GameFrame import Level, Globals
from Objects.Ship import Ship
from Objects.Zork import Zork
from Objects.Hud import Score

class GamePlay(Level):
    def __init__(self, screen, joysticks):
        Level.__init__(self, screen, joysticks)

        # set background image
        self.set_background_image("background.png")

        # add objects
        self.add_room_object(Ship(self, 25, 50))
        self.add_room_object(Zork(self,1120, 50))

        # add HUD items
        self.score = Score(self, 
                           Globals.SCREEN_WIDTH/2 - 20, 20, 
                           str(Globals.SCORE))
        self.add_room_object(self.score)

Change the score¶

We have a score on the screen. Now we need a way to change it. Several different collisions change the score, so the easiest way is a method that any object can call to update it.

Planning¶

The method needs to do two things:

1. change the value of Globals.SCORE
2. write the new score on the screen

Coding¶

Open Objects/Hud.py and add the code below to the end of the Score class, then save it.

21
22
23
24
25
26
27

    def update_score(self, change):
        """
        Updates the score and redraws the text
        """
        Globals.SCORE += change
        self.text = str(Globals.SCORE)
        self.update_text()

Run MainController.py to check there are no errors.

Add scores to collisions¶

Our plan has three collisions that change the score:

1. Laser → Asteroid
2. Laser → Astronaut
3. Astronaut → Ship

We already have event handlers for all three, so we just need to add to them. Let's start with the Laser.

Open Objects/Laser.py, add the highlighted code below to the handle_collision method and save it.

39
40
41
42
43
44
45
46
47
48
49

    # --- Event handlers
    def handle_collision(self, other, other_type):
        """
        Handles laser collisions with other registered objects
        """
        if other_type == "Asteroid":
            self.room.delete_object(other)
            self.room.score.update_score(5)
        elif other_type == "Astronaut":
            self.room.delete_object(other)
            self.room.score.update_score(-10)

Now open Objects/Astronaut.py, add the highlighted code below to the handle_collision method and save it.

31
32
33
34
35
36
37
38
39

    # --- Event Handlers
    def handle_collision(self, other, other_type):
        """
        Handles the collision event for Astronaut objects
        """
        # ship collision
        if other_type == "Ship":
            self.room.delete_object(self)
            self.room.score.update_score(50)

Testing¶

We've made three changes, so we need to test all three. We'll use a testing table with four columns:

• Test: what we're testing
• Expected result: what we expect to happen
• Actual result: what actually happened when we tested
• Remedy: if the actual result was different, how we fixed it

Here's our testing table with the first two columns filled in. Copy it, then run the game and finish it off.

Commit and push¶

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