Asteroids 2D

The classic arcade shooter in one small file.

▶ Run in browser

Tags: game collision wrap shooting

Thrust, turn and shoot through waves of splitting asteroids on a wrap-around playfield, with a title screen, a HUD, lives and a game-over screen: a whole arcade game loop with no physics engine.

Every actor is a plain Node2D that integrates its own velocity and calls wrap_screen to come back on the far edge. Collision is a circle test: Body2D.overlapping(group) compares radii against the nodes in a scene-tree group, which leaves out a node destroyed earlier in the frame. The demo also shows:

• Immediate-mode drawing from on_draw: polygons, circles and centred text anchored on a point with align="centre", shrunk by fit_scale to fit a narrow window

• Scene flow with tree.change_scene between title, game and game over

• Class-level Signals: the ship calls fired() and died() and the game decides what a shot and a death mean

• Timer children for the fire cooldown, the bullet lifetime and the respawn shield

• Property descriptors for the ship’s handling and the difficulty

• The same input_context on every scene, with turn a single signed Axis1D action that keys and a stick both drive

• A TouchController in the game scene, so a phone plays it with two thumbs

Controls: W or Up thrusts, A/D or Left/Right turn, Space fires, Enter starts. On a controller or the on-screen pad the stick turns, B thrusts and A fires. Hold the mouse, or a finger anywhere off the on-screen pad, to steer toward the pointer while thrusting and firing. A click or tap starts the game.

Source

#!/usr/bin/env python3
# /// simvx
# tags = ["game", "collision", "wrap", "shooting"]
# ///
"""Asteroids 2D: The classic arcade shooter in one small file.

Thrust, turn and shoot through waves of splitting asteroids on a wrap-around
playfield, with a title screen, a HUD, lives and a game-over screen: a whole
arcade game loop with no physics engine.

Every actor is a plain ``Node2D`` that integrates its own ``velocity`` and
calls ``wrap_screen`` to come back on the far edge. Collision is a circle test:
``Body2D.overlapping(group)`` compares radii against the nodes in a scene-tree
group, which leaves out a node destroyed earlier in the frame. The demo also shows:

- Immediate-mode drawing from ``on_draw``: polygons, circles and centred text
  anchored on a point with ``align="centre"``, shrunk by ``fit_scale`` to fit
  a narrow window
- Scene flow with ``tree.change_scene`` between title, game and game over
- Class-level ``Signal``s: the ship calls ``fired()`` and ``died()`` and the
  game decides what a shot and a death mean
- ``Timer`` children for the fire cooldown, the bullet lifetime and the
  respawn shield
- ``Property`` descriptors for the ship's handling and the difficulty
- The same ``input_context`` on every scene, with ``turn`` a single signed
  ``Axis1D`` action that keys and a stick both drive
- A ``TouchController`` in the game scene, so a phone plays it with two thumbs

Controls: W or Up thrusts, A/D or Left/Right turn, Space fires, Enter starts.
On a controller or the on-screen pad the stick turns, B thrusts and A fires.
Hold the mouse, or a finger anywhere off the on-screen pad, to steer toward the
pointer while thrusting and firing. A click or tap starts the game.
"""

import math
import random

from simvx.core import Axis1D, Controller, Input, Key, Node, Node2D, Pointer, Property, Signal, Timer, Vec2, on_input
from simvx.core.ui import TouchController
from simvx.graphics import App

INPUT_ACTIONS = {
    "thrust": [Key.W, Key.UP, Controller.B],
    "turn": [Axis1D(low=Key.A, high=Key.D), Axis1D(low=Key.LEFT, high=Key.RIGHT), Controller.LEFT_X],
    "fire": [Key.SPACE, Controller.A],
    "pointer_fly": [Pointer.PRIMARY],
    "start": [Key.ENTER, Pointer.PRIMARY, Controller.A, Controller.START],
}

WHITE = (1.0, 1.0, 1.0, 1.0)
GREY = (0.75, 0.75, 0.75, 1.0)
SHIP_SHAPE = [Vec2(0, -12), Vec2(-8, 10), Vec2(8, 10)]
FLAME_SHAPE = [Vec2(-5, 10), Vec2(0, 18), Vec2(5, 10)]
# Asteroid radius -> points for shooting one; anything larger than the smallest splits in two.
SCORES = {40: 20, 20: 50, 10: 100}


def centred_text(renderer, node, text, y, scale, colour):
    """Draw each line of ``text`` centred at the fraction ``y`` of the height, shrunk to fit the width."""
    width, height = node.viewport_size
    scale = renderer.fit_scale(text, width * 0.9, base_scale=scale)
    renderer.text(text, (width / 2, height * y), fill=colour, scale=scale, align="centre")


class Body2D(Node2D):
    """An actor that moves by its own velocity, wraps at the edges and has a round hitbox."""

    radius = Property(8.0)

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.velocity = Vec2()

    def on_fixed_update(self, dt: float):
        self.position += self.velocity * dt
        self.wrap_screen(margin=self.radius)

    def overlapping(self, group: str) -> list[Body2D]:
        # A body destroyed this frame still runs until the frame ends, so it
        # stops colliding here: one bullet must not score twice.
        if self.destroying:
            return []
        return [
            body
            for body in self.tree.group(group)
            if (body.world_position - self.world_position).length() < body.radius + self.radius
        ]


class Ship(Body2D):
    fired = Signal()
    died = Signal()

    radius = Property(10.0)
    # Written in degrees, stored in radians like every engine angle.
    turn_speed = Property(200.0, coerce=math.radians, range=(math.radians(50), math.radians(400)))
    thrust_power = Property(300.0, range=(50, 800))
    max_speed = Property(400.0, range=(100, 1000))
    drag = Property(0.98, range=(0.9, 1.0))

    def on_ready(self):
        self.thrusting = False
        self.gun = self.add_child(Timer(duration=0.15))
        self.shield = self.add_child(Timer(duration=2.0))
        self.position = self.viewport_size / 2

    def on_fixed_update(self, dt: float):
        self.rotation += self.turn_speed * Input.value("turn") * dt

        pointer_held = Input.pressed("pointer_fly")
        if pointer_held:
            to_pointer = Input.mouse_position - self.world_position
            if to_pointer.length() > self.radius * 2:
                target = math.atan2(to_pointer.x, -to_pointer.y)
                diff = (target - self.rotation + math.pi) % math.tau - math.pi
                step = self.turn_speed * dt
                self.rotation += max(-step, min(step, diff))

        self.thrusting = Input.pressed("thrust") or pointer_held
        if self.thrusting:
            self.velocity += self.forward * (self.thrust_power * dt)
            if self.velocity.length() > self.max_speed:
                self.velocity = self.velocity.normalized() * self.max_speed
        self.velocity *= self.drag
        super().on_fixed_update(dt)

        if (Input.pressed("fire") or pointer_held) and self.gun.stopped:
            self.gun.start()
            self.fired.emit()

        if self.shield.stopped and self.overlapping("asteroids"):
            self.died.emit()
            self.position = self.viewport_size / 2
            self.velocity = Vec2()
            self.rotation = 0.0
            self.shield.start()

    def on_draw(self, renderer):
        if int(self.shield.time_left * 10) % 2:
            return  # blink while the shield is up
        renderer.polygon(SHIP_SHAPE, stroke=WHITE)
        if self.thrusting:
            renderer.polygon(FLAME_SHAPE, stroke=WHITE)


class Bullet(Body2D):
    radius = Property(2.0)
    speed = Property(500.0)

    def on_ready(self):
        self.add_to_group("bullets")
        self.velocity = self.forward * self.speed
        self.add_child(Timer(duration=1.5, autostart=True)).timeout.connect(self.destroy)

    def on_draw(self, renderer):
        renderer.circle((0, 0), self.radius, stroke=WHITE, segments=6)


class Asteroid(Body2D):
    radius = Property(40.0)

    def on_ready(self):
        self.add_to_group("asteroids")
        self.velocity = Vec2.from_angle(random.uniform(0, math.tau)) * random.uniform(40, 120)
        self.spin = math.radians(random.uniform(-90, 90))
        corners = [i / 10 * math.tau for i in range(10)]
        self.shape = [Vec2.from_angle(a) * self.radius * random.uniform(0.7, 1.3) for a in corners]

    def on_fixed_update(self, dt: float):
        super().on_fixed_update(dt)
        self.rotation += self.spin * dt

    def on_draw(self, renderer):
        renderer.polygon(self.shape, stroke=WHITE)


class MainMenu(Node):
    dynamic = True  # the prompt blinks
    input_context = INPUT_ACTIONS

    @on_input("start")
    def start(self, event):
        self.tree.change_scene(AsteroidsGame())

    def on_draw(self, renderer):
        width, height = self.viewport_size
        centred_text(renderer, self, "ASTEROIDS", 0.12, 6, WHITE)
        size = min(width, height) / 250
        renderer.polygon([p * size + Vec2(width / 2, height * 0.42) for p in SHIP_SHAPE], stroke=WHITE)
        centred_text(renderer, self, CONTROLS_HELP, 0.62, 2, GREY)
        if int(self.tree.now * 2) % 2 == 0:
            centred_text(renderer, self, "PRESS ENTER OR TAP TO START", 0.85, 3, GREY)


class AsteroidsGame(Node2D):
    dynamic = True  # the HUD reads plain counters
    input_context = INPUT_ACTIONS

    start_asteroids = Property(4, range=(1, 12))
    lives = Property(3, range=(1, 10))

    def on_ready(self):
        self.score = 0
        self.lives_left = self.lives
        self.wave = 0
        self.ship = self.add_child(Ship(name="Ship"))
        self.ship.fired.connect(self.shoot)
        self.ship.died.connect(self.lose_life)
        self.add_child(TouchController())

    def shoot(self):
        self.add_child(Bullet(position=self.ship.position + self.ship.forward * 15, rotation=self.ship.rotation))

    def lose_life(self):
        self.lives_left -= 1
        if self.lives_left == 0:
            self.tree.change_scene(GameOver(score=self.score))

    def spawn_wave(self):
        self.wave += 1
        width, height = self.viewport_size
        band = min(width, height) * 0.2
        for _ in range(self.start_asteroids + self.wave - 1):
            # Spawn near the corners, away from the ship in the middle.
            x = random.choice([random.uniform(0, band), random.uniform(width - band, width)])
            y = random.choice([random.uniform(0, band), random.uniform(height - band, height)])
            self.add_child(Asteroid(position=(x, y)))

    def on_fixed_update(self, dt: float):
        for bullet in self.tree.group("bullets"):
            if hits := bullet.overlapping("asteroids"):
                rock = hits[0]
                self.score += SCORES[rock.radius]
                if rock.radius > min(SCORES):
                    for _ in range(2):
                        self.add_child(Asteroid(radius=rock.radius / 2, position=rock.position))
                rock.destroy()
                bullet.destroy()
        if not self.tree.group("asteroids"):
            self.spawn_wave()

    def on_draw(self, renderer):
        renderer.text(f"SCORE {self.score:05d}", (10, 10), fill=WHITE, scale=2)
        width = self.viewport_size.x
        for i in range(self.lives_left):
            renderer.polygon([p + Vec2(width - 30 - i * 25, 18) for p in SHIP_SHAPE], stroke=WHITE)


class GameOver(Node):
    dynamic = True  # the prompt blinks
    input_context = INPUT_ACTIONS

    score = Property(0)

    @on_input("start")
    def start(self, event):
        self.tree.change_scene(MainMenu())

    def on_draw(self, renderer):
        centred_text(renderer, self, "GAME OVER", 0.28, 5, (1.0, 0.2, 0.2, 1.0))
        centred_text(renderer, self, f"SCORE  {self.score:05d}", 0.5, 3, WHITE)
        if int(self.tree.now * 2) % 2 == 0:
            centred_text(renderer, self, "PRESS ENTER OR TAP TO CONTINUE", 0.68, 2, GREY)


# Example help overlay: not part of the technique shown.
CONTROLS_HELP = (
    "W/UP THRUST    A/D TURN    SPACE FIRE\nHOLD OR DRAG ANYWHERE TO FLY AND FIRE\nPAD: STICK TURNS, B THRUSTS, A FIRES"
)


if __name__ == "__main__":
    App(title="Asteroids", width=800, height=600).run(MainMenu())