Classes and Games

Part 5’s Word Practice connected file functions to a supplied Pyxel interface. Asteroids now gives you responsibility for the game model itself.

Turn the spaceship, fire bullets, and clear a field of moving asteroids before the ship loses its three health points. Each asteroid has one size and a constant velocity. A bullet moves for a limited number of steps. Objects wrap around the playfield when they cross an edge.

The controls, drawing, starting field, collision geometry, and file operations are supplied. You will implement how individual objects behave and how the game coordinates their interactions. This version keeps the mechanics small: the ship stops when you release Up, and asteroids disappear when hit without splitting into smaller pieces.

Both programming exercises include a Pyxel window. Run main.py in the Inline Editor to open it. Left/Right turn the ship, Up moves it, and Space fires. P pauses or resumes; R restarts. The first exercise is a flight-practice scene for trying your moving objects. The second adds collisions, score, health, and saved games.

Start with One Moving Object

An asteroid stores its position and velocity. The position describes where it is now. The velocity describes how far each coordinate changes during one tick, a fixed step of the simulation.

Predict the next position:

Screen coordinates increase to the right and downward. A negative y velocity therefore moves upward. The supplied playfield is 240 pixels wide and 160 pixels high. The expression (self.x + self.vx) % WIDTH wraps x at either edge; use the same pattern for y and HEIGHT.

Each asteroid owns its coordinates. Moving one instance must leave another instance unchanged, even when they started with equal values.

Give Bullets a Lifetime

A bullet also stores position and velocity, plus a remaining lifetime. Its move() advances its position and subtracts one from lifetime while lifetime is positive. Once lifetime is zero, further calls leave it unchanged.

is_expired() answers a question about that state. hits(asteroid) answers another: does a live bullet touch this asteroid? Use the supplied overlaps helper for the geometry. It handles touching circles and objects near opposite edges of the wrapped playfield.

The query does not remove anything. An individual bullet does not own the game’s asteroid collection.

A Spaceship Can Create a Bullet

The ship’s fire() method returns a new Bullet. It uses the ship’s current position and the velocity returned by velocity_for(self.angle, BULLET_SPEED). The helper supplies the direction calculation.

For a ship facing up, the following calls should leave the ship still and move only the first shot:

ship = Spaceship(100, 80, angle=0)
first = ship.fire()
second = ship.fire()
first.move()

assert first.y == 76
assert first.lifetime == 44
assert second.y == 80
assert ship.y == 80
assert first is not second

The first exercise supplies initializers, record methods, ship controls, and geometry. Complete five methods in objects.py, then extend check.py with an expired bullet and a position that crosses an edge.

Run main.py and press P to try your objects in flight practice. Fire several bullets to see them move independently. Watch the latest shot’s position and remaining lifetime. Aim at the marked target to see the result of hits. Targets stay in the scene: this exercise does not yet remove asteroids or keep score. If an invoked method is unfinished, the scene pauses and names the method. Complete it and run the program again.

To run the sample checks, open Show file tree, select check.py, and choose Run as Python. This shows the check output without opening a Pyxel window. The checks and the preview both use your methods; passing every check is not required to open the preview.

Let the Game Coordinate the Objects

The next exercise supplies completed moving objects, so it does not depend on copying your previous submission.

This is composition. The game contains a ship and collections of bullets and asteroids. Each object’s methods perform work on that object’s state.

Game.fire() has a different responsibility from Spaceship.fire(): it checks whether the game is active, asks its ship to create a bullet, and appends that returned object. It returns True for an accepted shot and False while paused or after the game ends. Firing does not itself advance time.

Resolve Each Hit Once

The supplied Game.step() advances one tick in this order:

1. Move every asteroid, then every bullet.
2. Remove expired bullets and resolve collisions between bullets and asteroids using your method.
3. Resolve collisions between the ship and asteroids using the supplied method.
4. Pause if the ship has no health or no asteroids remain.

A bullet whose lifetime reaches zero during movement cannot score on that tick. Bullet hits are resolved before ship contacts, so destroying an asteroid can protect the ship from it.

Process bullets in list order. For each live bullet, find the first remaining asteroid its hits method accepts. Remove that one asteroid and the bullet, and add 10 to the score. A missed bullet survives. Two bullets aimed at one asteroid must not award points twice.

Recall Part 2’s warning about changing a list’s length while traversing it. Keep the search and removal in this order:

1. Build a separate list for surviving bullets. For asteroids, start with remaining = self.asteroids.copy(). This copies the list while retaining references to the existing asteroid objects.
2. For each live bullet, search remaining in order for the first asteroid its hits method accepts. End the inner search loop before removing anything.
3. If the search found hit, use remaining.remove(hit) to remove that asteroid from the separate list. Later bullets then search only the asteroids still present.
4. Keep missed bullets in the survivor list. Preserve the order and identity of survivors in both lists.

Predict the Survivors

Before implementing collision resolution, work through these two separate situations. Each starts with score 0. All bullets are live, and the stated hits have already been determined. This is a call to resolve_bullet_hits() alone, so nothing moves. B1, B2, A1, and A2 label existing objects; the lists show their processing order.

For each row, predict the surviving bullet list, asteroid list, and score. Explain when the search stops and which objects the next search can still find.

In the first situation, B1 removes A1 and is removed too. B2 finds no remaining asteroid, so the result is bullets [B2], asteroids [], and score 10. In the second situation, B1 removes only the first matching asteroid, A1. The result is bullets [], asteroids [A2], and score 10. The survivors are the same instances as before the call.

Check One Tick

Use known positions and velocities in check.py. For example, place a stationary asteroid at (30, 20), a second asteroid at (200, 120) moving right by one, and a bullet at (16, 20) moving right by four with lifetime 3. Keep the ship at its default (120, 80) and resume the game.

The collision radii are 8 for an asteroid and 2 for a bullet. A distance of 10 counts as touching:

Repeat with initial lifetime 1. The bullet reaches zero and is removed before testing hits, so the first asteroid remains and score stays zero.

No real-time wait or random input is needed. The same sequence of model calls gives the same result even when no graphical window is open.

Play Asteroids

Complete the next exercise in stages. Start with firing and collision resolution; these two methods make the full game playable. Snapshots and restoration add saving and loading afterward.

At the bottom of check.py, replace the run_checks() call with the check named for your current stage. Select that file and choose Run as Python. Submit after each stage to receive credit for its completed behavior. Firing, collisions, and snapshots can earn their points while later methods are unfinished. The last 10 points require restoration to work with the earlier methods and the supplied save/load and graphical code.

After completing firing and collisions, select main.py and choose Run. P starts or pauses the game. Left/Right turn the ship; Up moves it; each Space press fires. R starts a fresh paused field. Try clearing the asteroids before the ship loses its three health points. Saving and loading can remain unfinished while you play.

The supplied AsteroidsApp in pyxel_graphics.py registers screen.run(self.update, self.draw), where screen is the Pyxel module. These are bound methods, each retaining its application instance for a later call. Writing self.update() would call the method immediately instead of passing it.

Snapshot and Restore the Game

The save document describes objects using plain records:

{
    "ship": {"x": 120, "y": 80, "angle": 0, "health": 3},
    "asteroids": [{"x": 30, "y": 20, "vx": 0, "vy": 0}],
    "bullets": [{"x": 16, "y": 20, "vx": 4, "vy": 0, "lifetime": 3}],
    "score": 0
}

Game.to_record() calls each object’s record method and builds new lists. Changing a saved record must not change a live object, and later movement must not change an earlier snapshot. Velocities and remaining lifetimes matter as well as positions: they determine what happens next.

Game.restore(document) first calls the supplied checked_state validator. Build all replacement objects before changing the current game. A bad final bullet record must leave every existing object and list in place, just as a rejected library load preserved the current library in Objects and Persistent Data.

Successful restoration creates new objects and pauses the game so the player can inspect it before resuming. Pause state is a control decision here and is not stored in the document. Overlapping objects are valid saved data; collisions are resolved on the next active tick.

Save and Restore During Play

Complete to_record and restore in the same exercise. Run their stage checks with Run as Python. The restoration check uses your completed snapshot method and includes a JSON round trip. Once all four stages pass, put run_checks() back to check them together. Extend the samples with more positions, collision cases, and damaged records.

Run main.py to try saving and loading. While paused, S saves and L loads. Before the relevant method is complete, the control names the unfinished method and keeps the current game. R starts a fresh paused field without deleting the saved game.

Save with bullets in flight, resume, pause again, and load. Compare positions, health, score, and remaining lifetimes with your saved situation. In the Inline Editor, save and load during the same game execution; rerunning the code can remove generated files.

To check that a save survives closing and reopening the program, download the exercise into its own folder and use your IDE with Part 5’s Pyxel setup. Save, close the game, run main.py again, and load. The local practice_asteroids.json remains in the exercise folder.

Review what a saved document must contain and what a rejected load must preserve.

Check Your Understanding

1. Why do two shots from the same ship need separate bullet instances?
2. Why does Bullet.hits report a collision while Game removes objects and changes score?
3. What prevents two bullets from scoring for the same asteroid?
4. Why must expiry be checked after movement and before collision resolution?
5. How can resolving bullet hits before ship contacts protect the ship?
6. Why does a save need velocities and remaining lifetimes as well as positions?
7. What must remain unchanged after a rejected restoration, and which tests still work with another interface?