Space Invaders 3D

the arcade classic built from 3D meshes.

▶ Run in browser

Tags: game 3d collision waves

Five rows of aliens march in formation, speed up as their ranks thin, drop a step closer every time the formation touches an edge, and shoot back at random. Four barriers soak up fire block by block. Clear the fleet and a fresh one takes its place; lose three lives, or let the fleet reach you, and it is over.

Every actor is a plain Node3D moved by setting position directly (bullets and the cannon move themselves, the game marches the fleet), seen from a Camera3D looking straight down: there is no physics world. Collision is a sphere test, first_hit(node, group), which compares radii against the nodes in a scene-tree group; tree.group leaves out a node destroyed earlier in the frame, so two bullets arriving in the same tick never score the same alien. The demo also shows:

• Procedural meshes (Mesh.cone, Mesh.box, Mesh.sphere) built once at import and shared by every alien, bullet and barrier block, with one Material per alien kind

• Camera3D.ray_at and Ray.intersect_plane, which turn the pointer into a point on the play plane so a mouse or a finger steers the cannon

• A class-level Signal: the cannon calls fired() and the game decides what a shot means

• Timer children for the cannon’s cooldown and the aliens’ volleys

• AudioSynth baking the shoot, explosion and hit sounds when a game starts, with no asset files, played through one AudioPlayer per sound

• Scene flow with tree.change_scene between the title card, the game and the game-over card, each declaring the same input_context; move is a single Axis1D action that keys and a stick both drive

• An anchored Label HUD on a CanvasLayer, and immediate-mode text on the cards, shrunk by fit_scale to fit a narrow window

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

Controls: A/D or Left/Right move, Space fires, Enter starts. On a controller or the on-screen pad the stick moves and A fires. Hold the mouse, or a single finger away from the on-screen pad, to slide the cannon toward the pointer and fire. A click or tap starts the game.

Source

# /// simvx
# tags = ["game", "3d", "collision", "waves"]
# web = { width = 1024, height = 768 }
# ///
"""Space Invaders 3D: the arcade classic built from 3D meshes.

Five rows of aliens march in formation, speed up as their ranks thin, drop a
step closer every time the formation touches an edge, and shoot back at random.
Four barriers soak up fire block by block. Clear the fleet and a fresh one
takes its place; lose three lives, or let the fleet reach you, and it is over.

Every actor is a plain ``Node3D`` moved by setting ``position`` directly
(bullets and the cannon move themselves, the game marches the fleet), seen from
a ``Camera3D`` looking straight down: there is no physics world. Collision is a
sphere test, ``first_hit(node, group)``, which compares radii against the
nodes in a scene-tree group; ``tree.group`` leaves out a node destroyed earlier
in the frame, so two bullets arriving in the same tick never score the same
alien. The demo also shows:

- Procedural meshes (``Mesh.cone``, ``Mesh.box``, ``Mesh.sphere``) built once
  at import and shared by every alien, bullet and barrier block, with one
  ``Material`` per alien kind
- ``Camera3D.ray_at`` and ``Ray.intersect_plane``, which turn the pointer into
  a point on the play plane so a mouse or a finger steers the cannon
- A class-level ``Signal``: the cannon calls ``fired()`` and the game decides
  what a shot means
- ``Timer`` children for the cannon's cooldown and the aliens' volleys
- ``AudioSynth`` baking the shoot, explosion and hit sounds when a game starts,
  with no asset files, played through one ``AudioPlayer`` per sound
- Scene flow with ``tree.change_scene`` between the title card, the game and
  the game-over card, each declaring the same ``input_context``; ``move`` is a
  single ``Axis1D`` action that keys and a stick both drive
- An anchored ``Label`` HUD on a ``CanvasLayer``, and immediate-mode text on
  the cards, shrunk by ``fit_scale`` to fit a narrow window
- A ``TouchController`` in the game, so a phone plays it with two thumbs

Controls: A/D or Left/Right move, Space fires, Enter starts. On a controller or
the on-screen pad the stick moves and A fires. Hold the mouse, or a single
finger away from the on-screen pad, to slide the cannon toward the pointer and
fire. A click or tap starts the game.
"""

import random
from typing import NamedTuple

from simvx.core import (
    ADSR,
    AudioPlayer,
    AudioSynth,
    Axis1D,
    Camera3D,
    CanvasLayer,
    Controller,
    Input,
    Key,
    Linear,
    Material,
    Mesh,
    MeshInstance3D,
    Node,
    Node3D,
    Oscillator,
    Pointer,
    Property,
    Signal,
    Timer,
    Vec3,
    on_input,
)
from simvx.core.ui import Anchor, Label, TouchController
from simvx.graphics import App

INPUT_ACTIONS = {
    "move": [Axis1D(low=Key.A, high=Key.D), Axis1D(low=Key.LEFT, high=Key.RIGHT), Controller.LEFT_X],
    "fire": [Key.SPACE, Controller.A],
    "steer": [Pointer.PRIMARY],
    "start": [Key.ENTER, Pointer.PRIMARY, Controller.A, Controller.START],
}

HALF_W, HALF_H = 15.0, 12.0  # the play area spans x in [-15, 15] and z in [-12, 12]
PLAYER_START = Vec3(0, 0, HALF_H - 2)
WHITE = (1.0, 1.0, 1.0, 1.0)
GREY = (0.75, 0.75, 0.75, 1.0)


class AlienKind(NamedTuple):
    name: str
    mesh: Mesh
    material: Material
    points: int


SQUID = AlienKind("SQUID", Mesh.cone(0.4, 0.8, segments=8), Material(colour=(1.0, 0.3, 0.3, 1.0)), 30)
CRAB = AlienKind("CRAB", Mesh.box(0.7), Material(colour=(0.3, 1.0, 0.3, 1.0)), 20)
OCTO = AlienKind("OCTO", Mesh.sphere(0.4, rings=6, segments=8), Material(colour=(0.3, 0.5, 1.0, 1.0)), 10)
FLEET_ROWS = [SQUID, CRAB, CRAB, OCTO, OCTO]  # back rank first
FLEET_COLS = 11
FLEET_SIZE = len(FLEET_ROWS) * FLEET_COLS

BULLET_MESH = Mesh.sphere(0.12, rings=4, segments=4)
BLOCK_MESH = Mesh.box(0.35)
BLOCK_MATERIAL = Material(colour=(0.2, 0.8, 0.4, 1.0))
BARRIER_PATTERN = [
    "  #####  ",
    " ####### ",
    "#########",
    "#########",
    "###   ###",
    "##     ##",
]


def bake_sfx() -> dict:
    shoot = AudioSynth()
    blip = ADSR(attack=0.002, decay=0.08, sustain=0.0, release=0.02)
    shoot.add(Oscillator.square(660.0, duty=0.35), envelope=blip, gain=0.35)
    explosion = AudioSynth()
    explosion.add(Oscillator.noise.white(), envelope=Linear(start=1.0, end=0.0), gain=0.45)
    explosion.add(Oscillator.square(90.0), envelope=Linear(start=0.8, end=0.0), gain=0.25)
    hit = AudioSynth()
    hit.add(Oscillator.noise.white(), envelope=Linear(start=1.0, end=0.0), gain=0.4)
    hit.add(Oscillator.saw(70.0), envelope=Linear(start=1.0, end=0.0), gain=0.3)
    return {"shoot": shoot.bake(0.12), "explosion": explosion.bake(0.3), "hit": hit.bake(0.6)}


def first_hit(node, group: str):
    """The first node in ``group`` whose sphere overlaps ``node``'s, or None."""
    for other in node.tree.group(group):
        if (other.world_position - node.world_position).length() < other.radius + node.radius:
            return other
    return None


class Alien(Node3D):
    radius = 0.5

    def __init__(self, kind: AlienKind, **kwargs):
        super().__init__(**kwargs)
        self.kind = kind

    def on_ready(self):
        self.add_to_group("aliens")
        self.add_child(MeshInstance3D(mesh=self.kind.mesh, material=self.kind.material))


class Bullet(Node3D):
    radius = 0.15
    direction = Property(-1.0, hint="-1 flies up the screen (the player's), +1 down (an alien's)")
    speed = Property(25.0)

    def on_ready(self):
        mine = self.direction < 0
        self.add_to_group("player_bullets" if mine else "alien_bullets")
        colour = (1.0, 1.0, 0.3, 1.0) if mine else (1.0, 0.5, 0.2, 1.0)
        self.add_child(MeshInstance3D(mesh=BULLET_MESH, material=Material(colour=colour)))

    def on_fixed_update(self, dt):
        self.position.z += self.direction * self.speed * dt
        if abs(self.position.z) > HALF_H + 2:
            self.destroy()


class Player(Node3D):
    fired = Signal()

    radius = 0.5
    speed = Property(15.0, range=(1, 50))

    def __init__(self, camera: Camera3D, **kwargs):
        super().__init__(**kwargs)
        self.camera = camera

    def on_ready(self):
        self.add_to_group("player")
        self.gun = self.add_child(Timer(duration=0.4))
        self.add_child(MeshInstance3D(mesh=Mesh.box(0.8), material=Material(colour=(0.3, 1.0, 0.3, 1.0))))

    def on_fixed_update(self, dt):
        step = self.speed * dt
        x = self.position.x + Input.value("move") * step
        steering = Input.pressed("steer")
        if steering:
            target = self.camera.ray_at(Input.mouse_position).intersect_plane((0, 0, 0), (0, 1, 0))
            if target is not None:
                x += max(-step, min(step, target.x - x))
        self.position.x = max(-HALF_W + 1, min(HALF_W - 1, x))

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


class Barrier(Node3D):
    """A bunker of small blocks; a bullet knocks out the blocks around where it lands."""

    def on_ready(self):
        spacing = 0.4
        left = -(len(BARRIER_PATTERN[0]) - 1) * spacing / 2
        top = -(len(BARRIER_PATTERN) - 1) * spacing / 2
        for row, line in enumerate(BARRIER_PATTERN):
            for col, cell in enumerate(line):
                if cell == "#":
                    position = (left + col * spacing, 0, top + row * spacing)
                    self.add_child(MeshInstance3D(mesh=BLOCK_MESH, material=BLOCK_MATERIAL, position=position))

    def hit(self, point) -> bool:
        """Knock out the blocks within reach of ``point``; True if there were any."""
        blocks = [b for b in self.children if not b.destroying and (b.world_position - point).length() < 0.7]
        for block in blocks:
            block.destroy()
        return bool(blocks)


class Game(Node3D):
    input_context = INPUT_ACTIONS

    lives = Property(3, range=(1, 10))

    def on_ready(self):
        self.score = 0
        self.lives_left = self.lives
        self.march = 1.0  # +1 while the fleet marches right, -1 left

        camera = self.add_child(Camera3D(position=(0, 35, 0), fov=60))
        camera.look_at((0, 0, 0), up=Vec3(0, 0, -1))
        self.player = self.add_child(Player(camera, name="Player", position=PLAYER_START))
        self.player.fired.connect(self.player_fire)
        for i in range(4):
            self.add_child(Barrier(position=(-HALF_W + (i + 1) * 2 * HALF_W / 5, 0, HALF_H - 5)))
        self.spawn_fleet()
        self.add_child(Timer(duration=1.0, one_shot=False, autostart=True)).timeout.connect(self.alien_fire)

        # One player per sound: replaying restarts it, as the arcade's single voice did.
        self.sfx = {name: self.add_child(AudioPlayer(stream=clip, bus="SFX")) for name, clip in bake_sfx().items()}

        hud = self.add_child(CanvasLayer())
        self.score_label = hud.add_child(Label(anchor=Anchor.TOP_LEFT, inset=10, font_size=28))
        self.lives_label = hud.add_child(Label(anchor=Anchor.TOP_RIGHT, inset=10, font_size=28))
        self.show_hud()
        self.add_child(TouchController(buttons=(Controller.A,)))

    def show_hud(self):
        self.score_label.text = f"SCORE {self.score:05d}"
        self.lives_label.text = f"LIVES {self.lives_left}"

    def spawn_fleet(self):
        for row, kind in enumerate(FLEET_ROWS):
            for col in range(FLEET_COLS):
                position = ((col - (FLEET_COLS - 1) / 2) * 1.5, 0, -HALF_H + 3 + row * 1.4)
                self.add_child(Alien(kind, position=position))

    def player_fire(self):
        self.add_child(Bullet(direction=-1, position=self.player.position - Vec3(0, 0, 1)))
        self.sfx["shoot"].play()

    def alien_fire(self):
        if aliens := self.tree.group("aliens"):
            shooter = random.choice(aliens)
            self.add_child(Bullet(direction=1, position=shooter.position + Vec3(0, 0, 0.5)))

    def on_fixed_update(self, dt):
        aliens = self.tree.group("aliens")
        if not aliens:
            self.spawn_fleet()
            return

        # The fleet speeds up as it thins, and steps down each time it touches an edge.
        speed = 2.0 + (FLEET_SIZE - len(aliens)) * 0.3
        for alien in aliens:
            alien.position.x += self.march * speed * dt
        if any(abs(alien.position.x) > HALF_W - 1 for alien in aliens):
            self.march = -self.march
            for alien in aliens:
                alien.position.z += 0.8
            if any(alien.position.z > HALF_H - 3 for alien in aliens):
                self.tree.change_scene(game_over(self.score))
                return

        barriers = self.find_all(Barrier, direct=True)
        for bullet in self.tree.group("player_bullets"):
            if alien := first_hit(bullet, "aliens"):
                self.score += alien.kind.points
                self.show_hud()
                alien.destroy()
                bullet.destroy()
                self.sfx["explosion"].play()
            elif any(barrier.hit(bullet.world_position) for barrier in barriers):
                bullet.destroy()

        for bullet in self.tree.group("alien_bullets"):
            if first_hit(bullet, "player"):
                bullet.destroy()
                self.lose_life()
                return
            if any(barrier.hit(bullet.world_position) for barrier in barriers):
                bullet.destroy()

    def lose_life(self):
        self.lives_left -= 1
        self.show_hud()
        self.sfx["hit"].play()
        if self.lives_left == 0:
            self.tree.change_scene(game_over(self.score))
        else:
            self.player.position = PLAYER_START


class Card(Node):
    """A full-screen text card, the title and the game over: a press moves on to ``then()``."""

    dynamic = True  # the prompt blinks
    input_context = INPUT_ACTIONS

    def __init__(self, lines, prompt: str, then, **kwargs):
        super().__init__(**kwargs)
        self.lines = lines  # (text, height fraction, scale, colour)
        self.prompt = prompt
        self.then = then

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

    def on_draw(self, renderer):
        width, height = self.viewport_size
        lines = list(self.lines)
        if int(self.tree.now * 2) % 2 == 0:
            lines.append((self.prompt, 0.62, 2, WHITE))
        for text, y, scale, colour in lines:
            fitted = renderer.fit_scale(text, width * 0.9, base_scale=scale)
            renderer.text(text, (width / 2, height * y), fill=colour, scale=fitted, align="centre")


def title_screen() -> Card:
    legend = [
        (f"{kind.name} = {kind.points} PTS", 0.3 + 0.07 * i, 2, kind.material.colour)
        for i, kind in enumerate((SQUID, CRAB, OCTO))
    ]
    lines = [("SPACE INVADERS 3D", 0.12, 4, WHITE), *legend, (CONTROLS_HELP, 0.82, 1.4, GREY)]
    return Card(lines, "PRESS ENTER OR TAP TO START", then=Game, name="TitleScreen")


def game_over(score: int) -> Card:
    lines = [("GAME OVER", 0.28, 4, (1.0, 0.2, 0.2, 1.0)), (f"SCORE  {score:05d}", 0.46, 2.5, WHITE)]
    return Card(lines, "PRESS ENTER OR TAP TO CONTINUE", then=title_screen, name="GameOver")


# Example help overlay: not part of the technique shown.
CONTROLS_HELP = (
    "A/D OR ARROWS MOVE    SPACE FIRES\nHOLD THE MOUSE OR A FINGER TO STEER AND FIRE\nPAD: STICK MOVES, A FIRES"
)


if __name__ == "__main__":
    App(title="Space Invaders 3D", width=1024, height=768).run(title_screen())