Capstone: A Complete 2D Game

fn main() {
    let mut platform = Platform::new();              // window + event pump
    let mut input = InputState::default();
    let mut renderer = Renderer::new(&platform);     // device, swapchain, batcher
    let assets = Assets::mount("assets.pak");
    let (mut audio_ring, audio) = AudioEngine::spawn(1024); // producer end + engine; the audio thread is the one consumer
    let mut world = load_arena(&assets, &mut renderer);
    let mut state = GameState::Menu;

    let dt = 1.0 / 60.0;                          // fixed simulation step
    let mut accumulator = 0.0;
    let mut current_time = Instant::now();

    while platform.running() {
        let new_time = Instant::now();
        let mut frame_time = (new_time - current_time).as_secs_f64();
        if frame_time > 0.25 { frame_time = 0.25; }   // spiral-of-death clamp
        current_time = new_time;

        platform.pump_events(&mut input);             // OS events -> snapshot
        accumulator += frame_time;
        while accumulator >= dt {                  // 0, 1, or N steps
            world.save_previous_transforms();       // last tick's transforms, for interpolation
            simulate(&mut world, &input, &mut audio_ring, dt, &mut state);
            accumulator -= dt;
        }
        let alpha = accumulator / dt;             // 0..1
        build_batch(&world, alpha as f32, renderer.batch_mut());   // interpolated, read-only (§5)
        renderer.render();
    }
    // Drop runs in reverse declaration order: world, then audio (joins its thread)
    // before audio_ring, assets, renderer (GPU objects before the device), platform.
}

if input.action(Action::Fire) && ship.cooldown <= 0.0 {
    spawn_bullet(world, ship);
    let _ = audio_ring.try_push(AudioCommand { sound: SoundId::Shot, volume: 1.0, pan: pan_for(ship.x) });   // full ring: drop the sound, don't stall the sim
    ship.cooldown = FIRE_INTERVAL;
}

// The arena shooter's simulation, complete and headless: one fixed-step loop,
// a scripted input snapshot, a uniform-grid broadphase, the game-state machine,
// a lock-free ring to a real audio thread, and a read-only pass that builds the
// render description. The window and GPU are the platform and renderer's job.
use std::cell::UnsafeCell;
use std::f64::consts::PI;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;
use std::time::Duration;

const DT: f64 = 1.0 / 60.0;
const ARENA_W: f64 = 800.0;
const ARENA_H: f64 = 600.0;
const CELL: f64 = 64.0;
const FIRE_INTERVAL: f64 = 0.1;
const BULLET_SPEED: f64 = 480.0;
const ENEMY_SPEED: f64 = 100.0;
const GRID_W: usize = 13; // 800 / 64 and 600 / 64, rounded up
const GRID_H: usize = 10;

// One producer (the sim), one consumer (the audio thread). Each side loads its own
// index relaxed, the other side's index acquire, and publishes its own with release.
#[repr(align(64))]
struct PaddedIndex(AtomicUsize); // its own cache line, so the two sides don't share one
struct SpscRing<T, const CAPACITY: usize> {
    slots: [UnsafeCell<T>; CAPACITY],
    read_index: PaddedIndex,  // advanced only by the consumer
    write_index: PaddedIndex, // advanced only by the producer
}
// Safe to share because only the producer writes a slot before publishing it,
// and only the consumer reads it after the acquire that observes that publish.
unsafe impl<T: Send, const CAPACITY: usize> Sync for SpscRing<T, CAPACITY> {}

// The ring is used only through these two handles. Neither can be cloned, so there is
// exactly one producer and one consumer, which is what makes the plain loads and stores safe.
struct Producer<T, const CAPACITY: usize>(Arc<SpscRing<T, CAPACITY>>);
struct Consumer<T, const CAPACITY: usize>(Arc<SpscRing<T, CAPACITY>>);

fn spsc_ring<T: Copy + Default, const CAPACITY: usize>() -> (Producer<T, CAPACITY>, Consumer<T, CAPACITY>) {
    let ring = Arc::new(SpscRing {
        slots: std::array::from_fn(|_| UnsafeCell::new(T::default())),
        read_index: PaddedIndex(AtomicUsize::new(0)),
        write_index: PaddedIndex(AtomicUsize::new(0)),
    });
    (Producer(Arc::clone(&ring)), Consumer(ring))
}

impl<T: Copy, const CAPACITY: usize> Producer<T, CAPACITY> {
    fn try_push(&mut self, value: T) -> bool {
        let ring = &*self.0;
        let write = ring.write_index.0.load(Ordering::Relaxed);
        if write - ring.read_index.0.load(Ordering::Acquire) == CAPACITY { return false; } // full: drop it
        unsafe { *ring.slots[write % CAPACITY].get() = value; }
        ring.write_index.0.store(write + 1, Ordering::Release); // the slot is now visible to the consumer
        true
    }
}

impl<T: Copy, const CAPACITY: usize> Consumer<T, CAPACITY> {
    fn try_pop(&mut self) -> Option<T> {
        let ring = &*self.0;
        let read = ring.read_index.0.load(Ordering::Relaxed);
        if read == ring.write_index.0.load(Ordering::Acquire) { return None; } // empty
        let value = unsafe { *ring.slots[read % CAPACITY].get() };
        ring.read_index.0.store(read + 1, Ordering::Release); // the slot can be reused
        Some(value)
    }
}

#[derive(Clone, Copy, Default)]
enum Sound { #[default] Shot, Hit, Wave }
#[derive(Clone, Copy, PartialEq, Debug)]
enum State { Menu, Playing, WaveClear, Won, GameOver }

#[derive(Clone, Copy)]
struct Body { x: f64, y: f64, previous_x: f64, previous_y: f64, vx: f64, vy: f64 }
impl Body { fn at(x: f64, y: f64) -> Body { Body { x, y, previous_x: x, previous_y: y, vx: 0.0, vy: 0.0 } } }
struct Enemy { body: Body, alive: bool }
struct Bullet { body: Body, life: f64 }
struct World {
    ship: Body, health: f64, cooldown: f64, state_time: f64, time: f64,
    state: State, wave: i32, kills: i32, shots: i32,
    enemies: Vec<Enemy>, bullets: Vec<Bullet>,
    grid_tests: u64, brute_force_tests: u64, sounds_dropped: u64,
}
struct Input { move_x: f64, move_y: f64, fire: bool, start: bool } // one snapshot per frame
#[allow(dead_code)]                                         // nothing draws the quads in this headless build
struct Quad { x: f32, y: f32, sprite: u16 }                        // the render description

type AudioProducer = Producer<Sound, 1024>;

fn set_state(world: &mut World, next: State) {
    println!("{:6.2} s  {:?} -> {:?}", world.time, world.state, next);
    world.state = next;
    world.state_time = 0.0;
}

fn spawn_wave(world: &mut World, audio: &mut AudioProducer) {
    world.wave += 1;
    let count = 2 + 6 * world.wave; // 8, 14, 20
    for i in 0..count { // just outside the arena, spread around it
        let angle = 2.0 * PI * i as f64 / count as f64 + 0.3 * world.wave as f64;
        let body = Body::at(400.0 + 420.0 * angle.cos(), 300.0 + 320.0 * angle.sin());
        world.enemies.push(Enemy { body, alive: true });
    }
    if !audio.try_push(Sound::Wave) { world.sounds_dropped += 1; }
}

fn simulate(world: &mut World, input: &Input, audio: &mut AudioProducer) {
    world.time += DT;
    world.state_time += DT;
    // Keep this step's starting positions: the renderer blends from them to the new ones.
    let remember = |body: &mut Body| { body.previous_x = body.x; body.previous_y = body.y; };
    remember(&mut world.ship);
    world.enemies.iter_mut().for_each(|enemy| remember(&mut enemy.body));
    world.bullets.iter_mut().for_each(|bullet| remember(&mut bullet.body));

    match world.state { // the game-state machine gates everything below
        State::Menu => {
            if input.start { set_state(world, State::Playing); spawn_wave(world, audio); }
            return;
        }
        State::WaveClear => {
            if world.state_time >= 1.0 { set_state(world, State::Playing); spawn_wave(world, audio); }
        }
        State::Won | State::GameOver => return, // the world stops; the renderer keeps drawing it
        State::Playing => {}
    }

    // The ship moves from the input snapshot and auto-aims at the nearest enemy.
    world.ship.x = (world.ship.x + input.move_x * 220.0 * DT).clamp(12.0, ARENA_W - 12.0);
    world.ship.y = (world.ship.y + input.move_y * 220.0 * DT).clamp(12.0, ARENA_H - 12.0);
    world.cooldown -= DT;
    let mut nearest: Option<usize> = None;
    let mut nearest_distance2 = 1e18;
    for (index, enemy) in world.enemies.iter().enumerate() {
        let (dx, dy) = (enemy.body.x - world.ship.x, enemy.body.y - world.ship.y);
        if dx * dx + dy * dy < nearest_distance2 { nearest_distance2 = dx * dx + dy * dy; nearest = Some(index); }
    }
    if let (true, Some(index), true) = (input.fire, nearest, world.cooldown <= 0.0) {
        let target = world.enemies[index].body;
        let (dx, dy) = (target.x - world.ship.x, target.y - world.ship.y);
        let length = nearest_distance2.sqrt();
        let mut body = Body::at(world.ship.x, world.ship.y);
        body.vx = dx / length * BULLET_SPEED;
        body.vy = dy / length * BULLET_SPEED;
        world.bullets.push(Bullet { body, life: 1.5 });
        world.cooldown = FIRE_INTERVAL;
        world.shots += 1;
        if !audio.try_push(Sound::Shot) { world.sounds_dropped += 1; } // never wait on the audio thread
    }

    for enemy in &mut world.enemies { // enemies close in; touching the ship hurts
        let (dx, dy) = (world.ship.x - enemy.body.x, world.ship.y - enemy.body.y);
        let length = (dx * dx + dy * dy).sqrt();
        if length > 1e-9 {
            enemy.body.x += dx / length * ENEMY_SPEED * DT;
            enemy.body.y += dy / length * ENEMY_SPEED * DT;
        }
        if length < 22.0 { world.health -= 20.0 * DT; }
    }
    for bullet in &mut world.bullets {
        bullet.body.x += bullet.body.vx * DT;
        bullet.body.y += bullet.body.vy * DT;
        bullet.life -= DT;
    }

    // Broadphase: bucket enemies into 64-pixel cells; each bullet tests only the 3x3 cells around it.
    let mut cells: Vec<Vec<usize>> = vec![Vec::new(); GRID_W * GRID_H];
    let cell_of = |value: f64, size: usize| ((value / CELL).floor() as i64).clamp(0, size as i64 - 1) as usize;
    for (index, enemy) in world.enemies.iter().enumerate() {
        cells[cell_of(enemy.body.y, GRID_H) * GRID_W + cell_of(enemy.body.x, GRID_W)].push(index);
    }
    for bullet in &mut world.bullets {
        if bullet.life <= 0.0 { continue; } // expired this step: it can't hit anything
        world.brute_force_tests += world.enemies.len() as u64;
        let (cell_x, cell_y) = (cell_of(bullet.body.x, GRID_W), cell_of(bullet.body.y, GRID_H));
        'search: for y in cell_y.saturating_sub(1)..=(cell_y + 1).min(GRID_H - 1) {
            for x in cell_x.saturating_sub(1)..=(cell_x + 1).min(GRID_W - 1) {
                for &index in &cells[y * GRID_W + x] {
                    let enemy = &mut world.enemies[index];
                    if !enemy.alive { continue; }
                    world.grid_tests += 1;
                    let (dx, dy) = (enemy.body.x - bullet.body.x, enemy.body.y - bullet.body.y);
                    if dx * dx + dy * dy < 13.0 * 13.0 { // radii 10 + 3, compared squared
                        enemy.alive = false;
                        bullet.life = 0.0;
                        world.kills += 1;
                        if !audio.try_push(Sound::Hit) { world.sounds_dropped += 1; }
                        break 'search;
                    }
                }
            }
        }
    }
    // Remove the dead at the end of the step, never mid-iteration.
    world.enemies.retain(|enemy| enemy.alive);
    world.bullets.retain(|bullet| bullet.life > 0.0);

    if world.health <= 0.0 { set_state(world, State::GameOver); }
    else if world.state == State::Playing && world.enemies.is_empty() {
        set_state(world, if world.wave == 3 { State::Won } else { State::WaveClear });
    }
}

// Read-only: interpolate between the last two steps and emit quads. Changes nothing in the world.
fn build_render(world: &World, alpha: f64, quads: &mut Vec<Quad>) {
    quads.clear();
    let mut emit = |body: &Body, sprite: u16| quads.push(Quad {
        x: (body.previous_x + (body.x - body.previous_x) * alpha) as f32,
        y: (body.previous_y + (body.y - body.previous_y) * alpha) as f32,
        sprite,
    });
    emit(&world.ship, 0);
    world.enemies.iter().for_each(|enemy| emit(&enemy.body, 1));
    world.bullets.iter().for_each(|bullet| emit(&bullet.body, 2));
}

fn main() {
    let (mut audio_producer, mut audio_consumer) = spsc_ring::<Sound, 1024>();
    let audio_running = Arc::new(AtomicBool::new(true));
    let audio_thread = { // stands in for the audio callback
        let running = Arc::clone(&audio_running);
        thread::spawn(move || {
            let mut heard = [0u64; 3];
            while running.load(Ordering::Acquire) {
                while let Some(sound) = audio_consumer.try_pop() {
                    heard[sound as usize] += 1; // a mixer would start a voice here
                }
                thread::sleep(Duration::from_millis(2));
            }
            while let Some(sound) = audio_consumer.try_pop() { heard[sound as usize] += 1; } // drain what's left
            heard
        })
    };

    let mut world = World {
        ship: Body::at(400.0, 300.0), health: 100.0, cooldown: 0.0, state_time: 0.0, time: 0.0,
        state: State::Menu, wave: 0, kills: 0, shots: 0, enemies: Vec::new(), bullets: Vec::new(),
        grid_tests: 0, brute_force_tests: 0, sounds_dropped: 0,
    };
    let mut quads = Vec::new();
    let (mut accumulator, mut frames, mut steps, mut most_steps, mut most_quads) = (0.0, 0u64, 0u64, 0u64, 0usize);
    while world.state != State::Won && world.state != State::GameOver && world.time < 120.0 {
        // A scripted 144 Hz display with one 400 ms hitch, so the run is the same every time.
        let frame_time: f64 = if frames == 900 { 0.4 } else { 1.0 / 144.0 };
        let angle = world.time * 0.8; // the "player" circles the arena and holds fire
        let input = Input { move_x: -angle.sin(), move_y: angle.cos(), fire: true, start: world.time >= 0.5 };
        accumulator += frame_time.min(0.25); // spiral-of-death clamp: the hitch counts as 0.25 s
        let mut steps_this_frame = 0;
        while accumulator >= DT {
            simulate(&mut world, &input, &mut audio_producer);
            accumulator -= DT;
            steps_this_frame += 1;
        }
        build_render(&world, accumulator / DT, &mut quads);
        frames += 1;
        steps += steps_this_frame;
        most_steps = most_steps.max(steps_this_frame);
        most_quads = most_quads.max(quads.len());
    }
    audio_running.store(false, Ordering::Release);
    let heard = audio_thread.join().expect("audio thread"); // the consumer stops before the program ends

    println!("{frames} frames, {steps} steps, at most {most_steps} steps in one frame, at most {most_quads} quads");
    println!("{} shots, {} kills, health {:.1}", world.shots, world.kills, world.health);
    println!("bullet-enemy tests: {} with the grid, {} brute force", world.grid_tests, world.brute_force_tests);
    println!("sounds heard: {} shot, {} hit, {} wave; dropped {}", heard[0], heard[1], heard[2], world.sounds_dropped);
}