Step 11 - Using a Scene

So far in our game, we have three SpriteLists. One for our player, one for our walls(ground and boxes), and one for our coins. This is still manageable, but whatabout as our game grows? You can probably imagine a game could end up with hundreds of SpriteLists. Using just our current approach, we would have to keep track of variables for each one, and ensure we’re drawing them in the proper order.

Arcade provides a better way to handle this, with the arcade.Scene class. This class will hold all of our spritelists for us, allow us to create new ones, change around the order they get drawn in, and more. In later chapters we will we use a special function to load a map from a map editor tool, and automatically create a Scene based on the map.

At the end of this chapter, you will have the same result as before, but the code will be a bit different to use the Scene object.

First-off, we can remove all of our SpriteList variables from __init__ and replace them with on variable to hold the scene object:

self.scene = None

Now at the very top of our setup function we can initialize the scene by doing:

self.scene = arcade.Scene()

Next, we will remove the line in setup that initializes our Player spritelist, that line looked like this:

self.player_list = arcade.SpriteList()

Then, instead of adding our player to the SpriteList using self.player_sprite.append(). We will add the player to the Scene directly:

self.player_sprite = arcade.Sprite(self.player_texture)
self.player_sprite.center_x = 64
self.player_sprite.center_y = 128
self.scene.add_sprite("Player", self.player_sprite)

Let’s analyze what happens when we do arcade.Scene.add_sprite(). The first parameter to it is a String, this defines the layer name that we want to add a Sprite to. This can be an already existing layer or a new one. If the layer already exists, the Sprite will be added to it, and if it doesn’t, Scene will automatically create it. Under the hood, a layer is just a SpriteList with a name. So when we specify Player as our Layer. Scene is creating a new SpriteList, giving it that name, and then adding our Player Sprite to it.

Next we will replace our initialization of the wall and coin SpriteLists with these functions:

self.scene.add_sprite_list("Walls", use_spatial_hash=True)
self.scene.add_sprite_list("Coins", use_spatial_hash=True)

Here we are taking a little bit different approach than we did for our Player layer. For our player, we just added a Sprite directly. Here we are initialization new empty layers, named Walls and Coins. The advantage to this approach is that we can specify that this layer should use spatial hashing, like we specified for those SpriteLists before.

Now when we use the add_sprite function on these lists later, those Sprites will be added into these existing layers.

In order to add Sprites to these, let’s modify the self.wall_list.append() functions within the for loops for placing our walls and coins in the setup function. The only part we’re actually changing of these loops is the last line where we were adding it to the SpriteList, but I’ve included the loops so you can see where all it should be changed.

# Create the ground
for x in range(0, 1250, 64):
    wall = arcade.Sprite(":resources:images/tiles/grassMid.png", scale=TILE_SCALING)
    wall.center_x = x
    wall.center_y = 32
    self.scene.add_sprite("Walls", wall)

# Putting Crates on the Ground
coordinate_list = [[512, 96], [256, 96], [768, 96]]

for coordinate in coordinate_li
    wall = arcade.Sprite(
        ":resources:images/tiles/boxCrate_double.png", scale=TILE_SCALING
    )
    wall.position = coordinate
    self.scene.add_sprite("Walls", wall)

# Add coins to the world
for x in range(128, 1250, 256):
    coin = arcade.Sprite(":resources:images/items/coinGold.png", scale=COIN_SCALING)
    coin.center_x = x
    coin.center_y = 96
    self.scene.add_sprite("Coins", coin)

The next thing we need to do is fix our Physics Engine. If you remember back in Chapter 4, we added a physics engine and sent our Wall spritelist to in the walls parameter.

We’ll need to modify that our PhysicsEnginePlatformer initialization to this:

self.physics_engine = arcade.PhysicsEnginePlatformer(
    self.player_sprite, walls=self.scene["Walls"], gravity_constant=GRAVITY
)

This is mostly the same as before, but we are pulling the Walls SpriteList from our Scene. If you are familiar with Python dictionaries, the arcade.Scene class can be interacted with in a very similar way. You can get any specific SpriteList within the scene by passing the name in brackets to the scene.

We need to also change our arcade.check_for_collision_with_list() function in on_update that we are using to get the coins we hit to use this new syntax.

coin_hit_list = arcade.check_for_collision_with_list(
    self.player_sprite, self.scene["Coins"]
)

The last thing that we need to do is update our on_draw function. In here we will remove all our SpriteLists draws, and replace them with one line drawing our Scene.

self.scene.draw()

Note

Make sure to keep this after our world camera is activated and before our GUI camera is activated. If you draw the scene while the GUI camera is activated, the centering on the player and scrolling will not work.

Source Code

Using a Scene

"""
Platformer Game

python -m arcade.examples.platform_tutorial.11_scene
"""
import arcade

# Constants
WINDOW_WIDTH = 1280
WINDOW_HEIGHT = 720
WINDOW_TITLE = "Platformer"

# Constants used to scale our sprites from their original size
TILE_SCALING = 0.5
COIN_SCALING = 0.5

# Movement speed of player, in pixels per frame
PLAYER_MOVEMENT_SPEED = 5
GRAVITY = 1
PLAYER_JUMP_SPEED = 20


class GameView(arcade.Window):
    """
    Main application class.
    """

    def __init__(self):

        # Call the parent class and set up the window
        super().__init__(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE)

        # Variable to hold our texture for our player
        self.player_texture = None

        # Separate variable that holds the player sprite
        self.player_sprite = None

        # Replacing all of our SpriteLists with a Scene variable
        self.scene = None

        # A variable to store our camera object
        self.camera = None

        # A variable to store our gui camera object
        self.gui_camera = None

        # This variable will store our score as an integer.
        self.score = 0

        # This variable will store the text for score that we will draw to the screen.
        self.score_text = None

        # Load sounds
        self.collect_coin_sound = arcade.load_sound(":resources:sounds/coin1.wav")
        self.jump_sound = arcade.load_sound(":resources:sounds/jump1.wav")

    def setup(self):
        """Set up the game here. Call this function to restart the game."""
        self.scene = arcade.Scene()

        self.player_texture = arcade.load_texture(
            ":resources:images/animated_characters/female_adventurer/femaleAdventurer_idle.png"
        )

        self.player_sprite = arcade.Sprite(self.player_texture)
        self.player_sprite.center_x = 64
        self.player_sprite.center_y = 128
        self.scene.add_sprite("Player", self.player_sprite)

        self.scene.add_sprite_list("Walls", use_spatial_hash=True)
        self.scene.add_sprite_list("Coins", use_spatial_hash=True)

        # Create the ground
        # This shows using a loop to place multiple sprites horizontally
        for x in range(0, 1250, 64):
            wall = arcade.Sprite(":resources:images/tiles/grassMid.png", scale=TILE_SCALING)
            wall.center_x = x
            wall.center_y = 32
            self.scene.add_sprite("Walls", wall)

        # Put some crates on the ground
        # This shows using a coordinate list to place sprites
        coordinate_list = [[512, 96], [256, 96], [768, 96]]

        for coordinate in coordinate_list:
            # Add a crate on the ground
            wall = arcade.Sprite(
                ":resources:images/tiles/boxCrate_double.png", scale=TILE_SCALING
            )
            wall.position = coordinate
            self.scene.add_sprite("Walls", wall)

        # Add coins to the world
        for x in range(128, 1250, 256):
            coin = arcade.Sprite(":resources:images/items/coinGold.png", scale=COIN_SCALING)
            coin.center_x = x
            coin.center_y = 96
            self.scene.add_sprite("Coins", coin)

        # Create a Platformer Physics Engine, this will handle moving our
        # player as well as collisions between the player sprite and
        # whatever SpriteList we specify for the walls.
        # It is important to supply static to the walls parameter. There is a
        # platforms parameter that is intended for moving platforms.
        # If a platform is supposed to move, and is added to the walls list,
        # it will not be moved.
        self.physics_engine = arcade.PhysicsEnginePlatformer(
            self.player_sprite, walls=self.scene["Walls"], gravity_constant=GRAVITY
        )

        # Initialize our camera, setting a viewport the size of our window.
        self.camera = arcade.camera.Camera2D()

        # Initialize our gui camera, initial settings are the same as our world camera.
        self.gui_camera = arcade.camera.Camera2D()

        # Reset our score to 0
        self.score = 0

        # Initialize our arcade.Text object for score
        self.score_text = arcade.Text(f"Score: {self.score}", x=0, y=5)

        self.background_color = arcade.csscolor.CORNFLOWER_BLUE

    def on_draw(self):
        """Render the screen."""

        # Clear the screen to the background color
        self.clear()

        # Activate our camera before drawing
        self.camera.use()

        # Draw our Scene
        self.scene.draw()

        # Activate our GUI camera
        self.gui_camera.use()

        # Draw our Score
        self.score_text.draw()

    def on_update(self, delta_time):
        """Movement and Game Logic"""

        # Move the player using our physics engine
        self.physics_engine.update()

        # See if we hit any coins
        coin_hit_list = arcade.check_for_collision_with_list(
            self.player_sprite, self.scene["Coins"]
        )

        # Loop through each coin we hit (if any) and remove it
        for coin in coin_hit_list:
            # Remove the coin
            coin.remove_from_sprite_lists()
            arcade.play_sound(self.collect_coin_sound)
            self.score += 75
            self.score_text.text = f"Score: {self.score}"

        # Center our camera on the player
        self.camera.position = self.player_sprite.position

    def on_key_press(self, key, modifiers):
        """Called whenever a key is pressed."""

        if key == arcade.key.ESCAPE:
            self.setup()

        if key == arcade.key.UP or key == arcade.key.W:
            if self.physics_engine.can_jump():
                self.player_sprite.change_y = PLAYER_JUMP_SPEED
                arcade.play_sound(self.jump_sound)

        if key == arcade.key.LEFT or key == arcade.key.A:
            self.player_sprite.change_x = -PLAYER_MOVEMENT_SPEED
        elif key == arcade.key.RIGHT or key == arcade.key.D:
            self.player_sprite.change_x = PLAYER_MOVEMENT_SPEED

    def on_key_release(self, key, modifiers):
        """Called whenever a key is released."""

        if key == arcade.key.LEFT or key == arcade.key.A:
            self.player_sprite.change_x = 0
        elif key == arcade.key.RIGHT or key == arcade.key.D:
            self.player_sprite.change_x = 0


def main():
    """Main function"""
    window = GameView()
    window.setup()
    arcade.run()


if __name__ == "__main__":
    main()

Run This Chapter

python -m arcade.examples.platform_tutorial.11_scene