Chapter 12: A Ship That Fires Bullets

We’ll make an empty Pygame window by creating a class to represent the game. In your text editor, create a new file and save it as alien_invasion.py; then enter the following:

First, we import the sys and pygame modules. We’ll use tools in the sys module to exit the game when the player quits.

The object we assigned to self.screen is called a surface. A surface in Pygame is a part of the screen where a game element can be displayed. The surface returned by display.set_mode() represents the entire game window. When we activate the game’s animation loop, this surface will be redrawn on every pass through the loop, so it can be updated with any changes triggered by user input.

When you run this alien_invasion.py file, you should see an empty Pygame window.

Ideally, games should run at the same speed, or frame rate, on all systems. Controlling the frame rate of a game that can run on multiple systems is a complex issue, but Pygame offers a relatively simple way to accomplish this goal. We’ll make a clock, and ensure the clock ticks once on each pass through the main loop. Anytime the loop processes faster than the rate we define, Pygame will calculate the correct amount of time to pause so that the game runs at a consistent rate.

We’ll define the clock in the init() method:

After initializing pygame, we create an instance of the class Clock, from the pygame.time module. Then we’ll make the clock tick at the end of the while loop in run_game():

The tick() method takes one argument: the frame rate for the game. Here I’m using a value of 60, so Pygame will do its best to make the loop run exactly 60 times per second.

Pygame creates a black screen by default, but that’s boring. Let’s set a different background color. We’ll do this at the end of the init() method.

Each time we introduce new functionality into the game, we’ll typically create some new settings as well. Instead of adding settings throughout the code, let’s write a module called settings that contains a class called Settings to store all these values in one place. This approach allows us to work with just one settings object anytime we need to access an individual setting. This also makes it easier to modify the game’s appearance and behavior as our project grows. To modify the game, we’ll change the relevant values in settings.py instead of searching for different settings throughout the project.

Create a new file named settings.py inside your alien_invasion folder, and add this initial Settings class:

To make an instance of Settings in the project and use it to access our settings, we need to modify alien_invasion.py as follows:

When you run alien_invasion.py now you won’t yet see any changes, because all we’ve done is move the settings we were already using elsewhere. Now we’re ready to start adding new elements to the screen.

After choosing an image for the ship, we need to display it on the screen. To use our ship, we’ll create a new ship module that will contain the class Ship. This class will manage most of the behavior of the player’s ship:

Pygame is efficient because it lets you treat all game elements like rectangles (rects), even if they’re not exactly shaped like rectangles. Treating an element as a rectangle is efficient because rectangles are simple geometric shapes. When Pygame needs to figure out whether two game elements have collided, for example, it can do this more quickly if it treats each object as a rectangle.

When you’re working with a rect object, you can use the x- and y-coordinates of the top, bottom, left, and right edges of the rectangle, as well as the center, to place the object. You can set any of these values to establish the current position of the rect. When you’re centering a game element, work with the center, centerx, or centery attributes of a rect. When you’re working at an edge of the screen, work with the top, bottom, left, or right attributes. There are also attributes that combine these properties, such as midbottom, midtop, midleft, and midright. When you’re adjusting the horizontal or vertical placement of the rect, you can just use the x and y attributes, which are the x- and y-coordinates of its top-left corner.

Now let’s update alien_invasion.py so it creates a ship and calls the ship’s blitme() method:

When you run alien_invasion.py now, you should see an empty game screen with the rocket ship sitting at the bottom center of the screen.

We’ll move the code that manages events to a separate method called _check_events(). This will simplify run_game() and isolate the event management loop. Isolating the event loop allows you to manage events separately from other aspects of the game, such as updating the screen.

To further simplify run_game(), we’ll move the code for updating the screen to a separate method called _update_screen():

We moved the code that draws the background and the ship and flips the screen to _update_screen(). Now the body of the main loop in run_game() is much simpler. It’s easy to see that we’re looking for new events, updating the screen, and ticking the clock on each pass through the loop.

If you’ve already built a number of games, you’ll probably start out by breaking your code into methods like these. But if you’ve never tackled a project like this, you probably won’t know exactly how to structure your code at first. This approach gives you an idea of a realistic development process: you start out writing your code as simply as possible, and then refactor it as your project becomes more complex.

12-1. Blue Sky: Make a Pygame window with a blue background.

12-2. Game Character: Find a bitmap image of a game character you like or convert an image to a bitmap. Make a class that draws the character at the center of the screen, then match the background color of the image to the background color of the screen or vice versa.

Whenever the player presses a key, that keypress is registered in Pygame as an event. Each event is picked up by the pygame.event.get() method. We need to specify in our _check_events() method what kinds of events we want the game to check for. Each keypress is registered as a KEYDOWN event.

When Pygame detects a KEYDOWN event, we need to check whether the key that was pressed is one that triggers a certain action. For example, if the player presses the right arrow key, we want to increase the ship’s rect.x value to move the ship to the right:

When you run alien_invasion.py now, the ship should move to the right one pixel every time you press the right arrow key. That’s a start, but it’s not an efficient way to control the ship. Let’s improve this control by allowing continuous movement.

When the player holds down the right arrow key, we want the ship to continue moving right until the player releases the key. We’ll have the game detect a pygame.KEYUP event so we’ll know when the right arrow key is released; then we’ll use the KEYDOWN and KEYUP events together with a flag called moving_right to implement continuous motion.

When the moving_right flag is False, the ship will be motionless. When the player presses the right arrow key, we’ll set the flag to True, and when the player releases the key, we’ll set the flag to False again.

The Ship class controls all attributes of the ship, so we’ll give it an attribute called moving_right and an update() method to check the status of the moving_right flag. The update() method will change the position of the ship if the flag is set to True. We’ll call this method once on each pass through the while loop to update the position of the ship.

Here are the changes to Ship:

Now we need to modify _check_events() so that moving_right is set to True when the right arrow key is pressed and False when the key is released:

Next, we modify the while loop in run_game() so it calls the ship’s update() method on each pass through the loop:

The ship’s position will be updated after we’ve checked for keyboard events and before we update the screen. This allows the ship’s position to be updated in response to player input and ensures the updated position will be used when drawing the ship to the screen.

Now that the ship can move continuously to the right, adding movement to the left is straightforward. Again, we’ll modify the Ship class and the _check_events() method. Here are the relevant changes to init() and update() in Ship:

In init(), we add a self.moving_left flag. In update(), we use two separate if blocks, rather than an elif, to allow the ship’s rect.x value to be increased and then decreased when both arrow keys are held down. This results in the ship standing still. If we used elif for motion to the left, the right arrow key would always have priority. Using two if blocks makes the movements more accurate when the player might momentarily hold down both keys when changing directions.

We have to make two additions to _check_events():

If a KEYDOWN event occurs for the K_LEFT key, we set moving_left to True. If a KEYUP event occurs for the K_LEFT key, we set moving_left to False.

Currently, the ship moves one pixel per cycle through the while loop, but we can take finer control of the ship’s speed by adding a ship_speed attribute to the Settings class. We’ll use this attribute to determine how far to move the ship on each pass through the loop:

We set the initial value of ship_speed to 1.5. When the ship moves now, its position is adjusted by 1.5 pixels on each pass through the loop.

We’re using a float for the speed setting to give us finer control of the ship’s speed when we increase the tempo of the game later on. However, rect attributes such as x store only integer values, so we need to make some modifications to Ship:

At this point, the ship will disappear off either edge of the screen if you hold down an arrow key long enough. Let’s correct this so the ship stops moving when it reaches the screen’s edge. We do this by modifying the update() method in Ship:

The _check_events() method will increase in length as we continue to develop the game, so let’s break _check_events() into two separate methods: one that handles KEYDOWN events and another that handles KEYUP events:

We make two new helper methods: _check_keydown_events() and _check_keyup_events(). Each needs a self parameter and an event parameter. The bodies of these two methods are copied from _check_events(), and we’ve replaced the old code with calls to the new methods. The _check_events() method is simpler now with this cleaner code structure, which will make it easier to develop further responses to player input.

Now that we’re responding to keypresses efficiently, we can add another way to quit the game. It gets tedious to click the X at the top of the game window to end the game every time you test a new feature, so we’ll add a keyboard shortcut to end the game when the player presses Q:

In _check_keydown_events(), we add a new block that ends the game when the player presses Q. Now, when testing, you can press Q to close the game instead of using your cursor to close the window.

Pygame has a fullscreen mode that you might like better than running the game in a regular window. Some games look better in fullscreen mode, and on some systems, the game may perform better overall in fullscreen mode.

To run the game in fullscreen mode, make the following changes in init():

The main file, alien_invasion.py, contains the AlienInvasion class. This class creates a number of important attributes used throughout the game: the settings are assigned to settings, the main display surface is assigned to screen, and a ship instance is created in this file as well. The main loop of the game, a while loop, is also stored in this module. The while loop calls _check_events(), ship.update(), and _update_screen(). It also ticks the clock on each pass through the loop.

The _check_events() method detects relevant events, such as keypresses and releases, and processes each of these types of events through the methods _check_keydown_events() and _check_keyup_events(). For now, these methods manage the ship’s movement. The AlienInvasion class also contains _update_screen(), which redraws the screen on each pass through the main loop.

The alien_invasion.py file is the only file you need to run when you want to play Alien Invasion. The other files, settings.py and ship.py, contain code that is imported into this file.

The settings.py file contains the Settings class. This class only has an init() method, which initializes attributes controlling the game’s appearance and the ship’s speed.

The ship.py file contains the Ship class. The Ship class has an init() method, an update() method to manage the ship’s position, and a blitme() method to draw the ship to the screen. The image of the ship is stored in ship.bmp, which is in the images folder.

12-3. Pygame Documentation: We’re far enough into the game now that you might want to look at some of the Pygame documentation. The Pygame home page is at pygame.org, and the home page for the documentation is at pygame.org/docs. Just skim the documentation for now. You won’t need it to complete this project, but it will help if you want to modify Alien Invasion or make your own game afterward.

12-4. Rocket: Make a game that begins with a rocket in the center of the screen. Allow the player to move the rocket up, down, left, or right using the four arrow keys. Make sure the rocket never moves beyond any edge of the screen.

12-5. Keys: Make a Pygame file that creates an empty screen. In the event loop, print the event.key attribute whenever a pygame.KEYDOWN event is detected. Run the program and press various keys to see how Pygame responds.

At the end of the init() method, we’ll update settings.py to include the values we’ll need for a new Bullet class:

These settings create dark gray bullets with a width of 3 pixels and a height of 15 pixels. The bullets will travel slightly faster than the ship.

Now create a bullet.py file to store our Bullet class. Here’s the first part of bullet.py:

Here’s the second part of bullet.py, update() and draw_bullet():

Now that we have a Bullet class and the necessary settings defined, we can write code to fire a bullet each time the player presses the spacebar. We’ll create a group in AlienInvasion to store all the active bullets so we can manage the bullets that have already been fired. This group will be an instance of the pygame.sprite.Group class, which behaves like a list with some extra functionality that’s helpful when building games.

First, we’ll import the new Bullet class:

Next we’ll create the group that holds the bullets in init():

Then we need to update the position of the bullets on each pass through the while loop:

When you call update() on a group, the group automatically calls update() for each sprite in the group. The line self.bullets.update() calls bullet.update() for each bullet we place in the group bullets.

In AlienInvasion, we need to modify _check_keydown_events() to fire a bullet when the player presses the spacebar. We also need to modify _update_screen() to make sure each bullet is drawn to the screen before we call flip().

There will be a bit of work to do when we fire a bullet, so let’s write a new method, _fire_bullet(), to handle this work:

When you run alien_invasion.py now, you should be able to move the ship right and left and fire as many bullets as you want. The bullets travel up the screen and disappear when they reach the top.

At the moment, the bullets disappear when they reach the top, but only because Pygame can’t draw them above the top of the screen. The bullets actually continue to exist; their y-coordinate values just grow increasingly negative. This is a problem because they continue to consume memory and processing power.

We need to get rid of these old bullets, or the game will slow down from doing so much unnecessary work. To do this, we need to detect when the bottom value of a bullet’s rect has a value of 0, which indicates the bullet has passed off the top of the screen:

If this code works correctly, we can watch the terminal output while firing bullets and see that the number of bullets decreases to zero after each series of bullets has cleared the top of the screen. After you run the game and verify that bullets are being deleted properly, remove the print() call. If you leave it in, the game will slow down significantly because it takes more time to write output to the terminal than it does to draw graphics to the game window.

Many shooting games limit the number of bullets a player can have on the screen at one time; doing so encourages players to shoot accurately. We’ll do the same in Alien Invasion.

First, store the number of bullets allowed in settings.py:

This limits the player to three bullets at a time. We’ll use this setting in AlienInvasion to check how many bullets exist before creating a new bullet in _fire_bullet():

When the player presses the spacebar, we check the length of bullets. If len(self.bullets) is less than three, we create a new bullet. But if three bullets are already active, nothing happens when the spacebar is pressed. When you run the game now, you should only be able to fire bullets in groups of three.

We want to keep the AlienInvasion class reasonably well organized, so now that we’ve written and checked the bullet management code, we can move it to a separate method. We’ll create a new method called _update_bullets() and add it just before _update_screen():

The code for _update_bullets() is cut and pasted from run_game(); all we’ve done here is clarify the comments.

The while loop in run_game() looks simple again:

Now our main loop contains only minimal code, so we can quickly read the method names and understand what’s happening in the game. The main loop checks for player input, and then updates the position of the ship and any bullets that have been fired. We then use the updated positions to draw a new screen and tick the clock at the end of each pass through the loop.

12-6. Sideways Shooter: Write a game that places a ship on the left side of the screen and allows the player to move the ship up and down. Make the ship fire a bullet that travels right across the screen when the player presses the spacebar. Make sure bullets are deleted once they disappear off the screen.

D12-1. Node Movement Simulator: Without Pygame, write a class called NodeCursor that represents a selection cursor moving through a list of node hostnames. Give it moving_forward and moving_backward boolean flags, a position integer starting at 0, and an update() method that increments or decrements the position. Add boundary logic so position never goes below 0 or above len(nodes) - 1. Write a loop that simulates 10 update cycles and prints the current node at each step.

D12-2. Service Packet Simulator: Write a class called Packet that represents a log packet in transit through a pipeline stage. Give it a y float position starting at 100.0, a speed float, and an update() method that decrements y by speed each cycle. Write a loop that updates the packet until y reaches 0 or below, printing the position each step. Count how many cycles it took.

D12-3. VLAN Firewall Bounds: Write a class called VLANTraversal with a current_vlan integer and a vlan_range tuple (min_id, max_id). Add move_up() and move_down() methods that increment or decrement current_vlan only if within the range. Write a settings dictionary with traversal_speed = 1 and use it in the methods. Test by simulating 15 traversal steps with both directions.

D12-4. Stack Deploy Queue: Write a class called DeployQueue with a pending list and a deployed list. Add a method fire_deploy() that pops from pending and appends to deployed, but only if len(deployed) < max_concurrent (store max_concurrent in a settings dict). Add a method cleanup_deployed() that removes all items from deployed once they’ve been processed (simulate with a flag). Test with a queue of 6 services and a limit of 3.

D12-5. BGP Event Loop Refactor: Write a class called BGPMonitor with a _check_events() method that reads from a list of simulated events (strings like 'peer_up', 'peer_down', 'quit'), a _update_state() method that updates a peer_status dict, and a run() method that calls both in a loop until 'quit' is encountered. Demonstrate the single-responsibility refactoring pattern from the chapter.

C12-1. Auth Request Movement: Write a class called AuthRequest with a stage integer (0 = received, max = authorized), moving_forward and moving_backward flags, and an update() method that advances or retreats the stage based on flags with boundary enforcement. Use a settings dict with stage_speed = 1. Simulate 8 update cycles.

C12-2. Syslog Packet Lifecycle: Write a class called SyslogPacket with a y float position, a speed float, and a boolean active flag. The update() method should decrement y by speed; when y ⇐ 0, set active = False. Write a loop that creates 5 packets at staggered positions, updates them each cycle, removes inactive ones (using a copy loop), and prints the count of active packets per cycle.

C12-3. Policy Evaluation Bounds: Write a class called PolicyEvaluator with a current_policy integer index into a policy_list. Add move_next() and move_prev() methods with boundary enforcement. Add a settings dict with eval_speed = 1. Add a fire_evaluation() method that creates an evaluation record if len(active_evals) < max_evals. Simulate 10 evaluation cycles.

C12-4. Pipeline Stage Manager: Write a class called PipelineManager with a stages list and active_stages list. Add _fire_stage() that adds a stage to active_stages only if below max_concurrent. Add _update_stages() that decrements a progress counter on each active stage and removes it when complete (simulate with a counter starting at 3). Add a run() method that calls both each cycle for 8 cycles.

C12-5. ISE Event Loop Pattern: Write a class called ISEEventLoop with _check_keydown_events(event), _check_keyup_events(event), and _update_screen() as separate methods. Simulate with a list of dicts like {'type': 'KEYDOWN', 'key': 'AUTH'}. The _check_events() method should dispatch to the appropriate handler. The run() method should call _check_events(), update state, and call _update_screen() each cycle for 6 cycles.

L12-1. Service Cursor: Write a class called ServiceSelector that moves through a list of service names. Give it moving_up and moving_down boolean flags, a position integer, and an update() method with boundary enforcement. Use a settings dict with cursor_speed = 1. Simulate 12 update cycles alternating direction.

L12-2. Log Line Processor: Write a class called LogLine with a progress float starting at 0.0, a speed float, and an active flag. The update() method increments progress by speed; when progress >= 100.0, set active = False. Create 5 log line objects with different speeds, update them in a loop, remove inactive ones using a copy loop, and print the count each cycle until all are done.

L12-3. Filesystem Traversal Bounds: Write a class called FsTraversal with a depth integer and a max_depth setting. Add descend() and ascend() methods that change depth with boundary enforcement (0 to max_depth). Add a settings dict. Simulate 10 traversal steps and print the current depth each time.

L12-4. Package Install Queue: Write a class called InstallQueue with a pending list and an installing list. Add _fire_install() that moves a package from pending to installing only if len(installing) < max_concurrent. Add _update_installs() that removes completed installs (simulate with a countdown). Add a run() method for 8 cycles.

L12-5. Sysadmin Event Dispatcher: Write a class called SysadminMonitor modeled on the refactored AlienInvasion structure. Implement _check_events(event), _check_keydown(event), _check_keyup(event), and _update_state() as separate methods. Use a list of simulated event dicts. The run() method calls all methods each cycle for 6 cycles and prints the current state.

E12-1. Vocabulary Navigator: Write a class called VocabNavigator that moves through a list of Spanish vocabulary words. Give it moving_forward and moving_backward boolean flags, a position integer, and an update() method with boundary enforcement. Use a settings dict with nav_speed = 1. Simulate 10 update cycles and print the current word each step.

E12-2. Study Session Timer: Write a class called StudyTimer with a time_remaining float, a speed float (minutes per cycle), and an active flag. The update() method decrements time_remaining by speed; when time_remaining ⇐ 0, set active = False. Simulate with 3 study topics at different durations. Update them in a loop, remove completed ones using a copy loop, and print the count each cycle.

E12-3. Chapter Bounds: Write a class called ChapterNavigator with a current_chapter integer (1–126 for Don Quijote). Add next_chapter() and prev_chapter() methods with boundary enforcement. Use a settings dict with nav_speed = 1. Simulate 15 navigation steps and print the chapter number each time.

E12-4. DELE Exercise Queue: Write a class called ExerciseQueue with a pending list and an active list. Add _fire_exercise() that moves an exercise from pending to active only if len(active) < max_active. Add _update_exercises() that removes completed exercises (simulate with a countdown). Add a run() method for 8 cycles.

E12-5. Study Event Loop: Write a class called StudySession modeled on the refactored game event loop. Implement _check_events(event), _check_start_events(event), _check_stop_events(event), and _update_progress() as separate methods. Use a list of simulated study events. The run() method calls all methods each cycle for 6 cycles and prints the current progress state.