romdevtools 0.44.0 → 0.70.0

package/examples/ps1/platformer/main.c

@@ -0,0 +1,158 @@
+/*
+ * platformer/main.c — BLOCK HOP: a 3D PlayStation platformer.
+ *
+ * A 3D character (cube hero) runs and jumps across floating platforms rendered in
+ * perspective. Gravity + jump physics in 16.16 fixed point, AABB landing tests
+ * against platform tops, coins to collect, a pit you can fall into (lose a life),
+ * a chase camera that follows the hero. Title -> play -> game-over, score + lives.
+ *
+ * Build: build({ platform:"ps1", language:"c" }). Controls: LEFT/RIGHT run,
+ * CROSS jump, START begin/restart.
+ *
+ * 3D technique: platforms are flat-topped boxes drawn as no-cull quads; the hero
+ * is a culled cube. The camera tracks the hero's X with a slight downward tilt so
+ * you see the platform tops. Coins are small spinning cubes.
+ */
+#include "psx.h"
+
+#define NPLAT 6
+#define NCOIN 6
+enum { TITLE, PLAY, OVER };
+
+typedef struct { fix x, y, z, w; } Plat;   /* top-center + half-width */
+static Plat plat[NPLAT];
+static struct { fix x, y, z; int got; } coin[NCOIN];
+
+static fix hx, hy, vy;       /* hero pos + vertical velocity */
+static int onground;
+static int state, score, lives, hi;
+static fix cam_x, spin;
+static unsigned int prev_pad;
+
+static void box_top(fix cx, fix top, fix z, fix hw, fix depth, unsigned int col)
+{
+    Vec3 a,b,c,d;
+    a.x=cx-hw; a.y=top; a.z=z-depth; b.x=cx+hw; b.y=top; b.z=z-depth;
+    c.x=cx+hw; c.y=top; c.z=z+depth; d.x=cx-hw; d.y=top; d.z=z+depth;
+    psx_quad3d_nc(a,b,c,d,col);                       /* top face */
+    /* front face for thickness */
+    a.y=top; b.y=top; c.y=top-FIX(2); d.y=top-FIX(2);
+    a.x=cx-hw; a.z=z+depth; b.x=cx+hw; b.z=z+depth; c.x=cx+hw; c.z=z+depth; d.x=cx-hw; d.z=z+depth;
+    psx_quad3d_nc(a,b,c,d, col - RGB(20,20,20));
+}
+
+static void draw_cube_at(fix x, fix y, fix z, fix s, fix yaw, unsigned int col)
+{
+    Vec3 v[8]; int i;
+    static const int sx[8]={-1,1,1,-1,-1,1,1,-1},sy[8]={-1,-1,1,1,-1,-1,1,1},sz[8]={-1,-1,-1,-1,1,1,1,1};
+    psx_model(x,y,z,yaw);
+    for(i=0;i<8;i++){v[i].x=sx[i]*s;v[i].y=sy[i]*s;v[i].z=sz[i]*s;}
+    psx_quad3d(v[0],v[1],v[2],v[3],col); psx_quad3d(v[5],v[4],v[7],v[6],col);
+    psx_quad3d(v[4],v[0],v[3],v[7],col); psx_quad3d(v[1],v[5],v[6],v[2],col);
+    psx_quad3d(v[4],v[5],v[1],v[0],col); psx_quad3d(v[3],v[2],v[6],v[7],col);
+}
+
+static void reset_game(void)
+{
+    int i;
+    /* a run of platforms along +X with a gap (pit) in the middle */
+    for (i = 0; i < NPLAT; i++) {
+        plat[i].x = (fix)(i * 4 - 4) << 16;
+        plat[i].y = (fix)((i % 3) - 1) << 16;
+        plat[i].z = FIX(8);
+        plat[i].w = FIX(2);
+    }
+    plat[3].y = FIX(-6);          /* the pit: a platform dropped far below */
+    for (i = 0; i < NCOIN; i++) { coin[i].x = (fix)(i*4-3)<<16; coin[i].y = plat[i].y + FIX(2); coin[i].z = FIX(8); coin[i].got = 0; }
+    hx = FIX(-4); hy = FIX(2); vy = 0; onground = 0;
+    score = 0; lives = 3;
+}
+
+/* find the platform top under the hero's x (or a very low floor = pit). */
+static fix ground_at(fix x)
+{
+    int i; fix best = FIX(-20);
+    for (i = 0; i < NPLAT; i++) {
+        fix dx = x - plat[i].x; if (dx < 0) dx = -dx;
+        if (dx < plat[i].w) { if (plat[i].y > best) best = plat[i].y; }
+    }
+    return best;
+}
+
+static void update(void)
+{
+    unsigned int pad = psx_pad();
+    int i;
+    if (pad & PAD_LEFT)  hx -= FIXF(0.18f);
+    if (pad & PAD_RIGHT) hx += FIXF(0.18f);
+    if (hx < FIX(-6)) hx = FIX(-6); if (hx > FIX(14)) hx = FIX(14);
+
+    if ((pad & PAD_CROSS) && !(prev_pad & PAD_CROSS) && onground) { vy = FIXF(0.55f); onground = 0; }
+
+    vy -= FIXF(0.04f);            /* gravity */
+    hy += vy;
+    {
+        fix g = ground_at(hx) + FIX(1);  /* hero sits 1 unit above the platform top */
+        if (hy <= g && vy <= 0) {
+            if (g < FIX(-8)) { /* fell in the pit */
+                if (--lives <= 0) { if (score>hi) hi=score; state = OVER; }
+                hx = FIX(-4); hy = FIX(4); vy = 0;
+            } else { hy = g; vy = 0; onground = 1; }
+        } else onground = 0;
+    }
+
+    for (i = 0; i < NCOIN; i++) if (!coin[i].got) {
+        fix dx = hx - coin[i].x, dy = hy - coin[i].y;
+        if (dx<0)dx=-dx; if (dy<0)dy=-dy;
+        if (dx < FIX(1) && dy < FIX(2)) { coin[i].got = 1; score += 100; }
+    }
+
+    cam_x += (hx - cam_x) >> 3;   /* smooth follow */
+    spin += FIX(4);
+    prev_pad = pad;
+}
+
+static void render(void)
+{
+    int i;
+    psx_clear(RGB(40, 60, 120));   /* sky */
+    psx_camera(cam_x, FIX(2), FIX(-1), 0, FIXF(-0.22f));
+
+    for (i = 0; i < NPLAT; i++)
+        box_top(plat[i].x, plat[i].y, plat[i].z, plat[i].w, FIX(2),
+                (i==3)?RGB(120,40,40):RGB(90, 150, 70));
+    for (i = 0; i < NCOIN; i++) if (!coin[i].got)
+        draw_cube_at(coin[i].x, coin[i].y, coin[i].z, FIXF(0.3f), spin, RGB(255, 220, 40));
+
+    draw_cube_at(hx, hy, FIX(8), FIXF(0.6f), 0, RGB(230, 90, 60));
+
+    psx_number(8, 6, (unsigned)score, RGB(255,255,255));
+    for (i = 0; i < lives; i++) psx_rect(290 - i*10, 8, 6, 6, RGB(230, 90, 60));
+}
+
+int main(void)
+{
+    psx_init();
+    psx_srand(0xBEEF);
+    state = TITLE; prev_pad = 0; cam_x = 0;
+    for (;;) {
+        unsigned int pad = psx_pad();
+        if (state == TITLE) {
+            psx_clear(RGB(20, 30, 60));
+            psx_camera(0, 0, FIX(-1), 0, 0);
+            spin += FIX(3);
+            draw_cube_at(0, 0, FIX(6), FIX(1), spin, RGB(230, 90, 60));
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_game(); state = PLAY; }
+            prev_pad = pad;
+        } else if (state == PLAY) { update(); render(); }
+        else {
+            psx_clear(RGB(8, 8, 30));
+            psx_number(110, 100, (unsigned)score, RGB(255, 220, 40));
+            psx_number(120, 130, (unsigned)hi, RGB(255, 255, 120));
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_game(); state = PLAY; }
+            prev_pad = pad;
+        }
+        psx_vsync();
+    }
+    return 0;
+}

package/examples/ps1/puzzle/main.c

@@ -0,0 +1,125 @@
+/*
+ * puzzle/main.c — DROP GRID: a 2D PlayStation falling-block puzzle.
+ *
+ * The one 2D game in the PS1 set — a grid puzzle is naturally flat, so it's drawn
+ * with the GPU's 2D rectangles (no 3D pipeline). Colored blocks fall down a well;
+ * steer + drop them; a full row clears and scores. Speed ramps up. Title -> play ->
+ * game-over (stack reaches the top). 16.16 not needed — plain integer grid logic.
+ *
+ * Build: build({ platform:"ps1", language:"c" }). Controls: LEFT/RIGHT move the
+ * falling block, DOWN soft-drop, START begin/restart.
+ *
+ * 2D technique: an integer GRID is the model; render() paints each filled cell as a
+ * psx_rect. This is the right tool for a flat board even on a 3D machine.
+ */
+#include "psx.h"
+
+#define GW 8
+#define GH 12
+#define CELL 16
+#define OX 96    /* board origin on screen */
+#define OY 24
+
+enum { TITLE, PLAY, OVER };
+
+static unsigned char grid[GH][GW];   /* 0 empty, else color index 1..4 */
+static int fx, fy, fc;               /* falling block cell + color */
+static int tick, fall_period;
+static int state, score, hi;
+static unsigned int prev_pad;
+
+static const unsigned int PAL[5] = {
+    0, RGB(230,60,60), RGB(60,200,90), RGB(80,150,255), RGB(240,200,60)
+};
+
+static void new_block(void)
+{
+    fx = GW/2; fy = 0; fc = 1 + (psx_rand() % 4);
+    if (grid[0][fx]) { if (score>hi) hi=score; state = OVER; }
+}
+
+static void reset_game(void)
+{
+    int r,c;
+    for (r=0;r<GH;r++) for(c=0;c<GW;c++) grid[r][c]=0;
+    score = 0; tick = 0; fall_period = 30;
+    new_block();
+}
+
+static int blocked(int x, int y) { return x<0 || x>=GW || y>=GH || (y>=0 && grid[y][x]); }
+
+static void lock_and_clear(void)
+{
+    int r,c,rr;
+    grid[fy][fx] = fc;
+    /* clear full rows */
+    for (r = GH-1; r >= 0; r--) {
+        int full = 1;
+        for (c=0;c<GW;c++) if (!grid[r][c]) { full = 0; break; }
+        if (full) {
+            for (rr = r; rr > 0; rr--) for(c=0;c<GW;c++) grid[rr][c]=grid[rr-1][c];
+            for (c=0;c<GW;c++) grid[0][c]=0;
+            score += 100;
+            if (fall_period > 8) fall_period--;
+            r++; /* recheck this row */
+        }
+    }
+    new_block();
+}
+
+static void step_fall(void)
+{
+    if (!blocked(fx, fy+1)) fy++;
+    else lock_and_clear();
+}
+
+static void update(void)
+{
+    unsigned int pad = psx_pad();
+    if ((pad & PAD_LEFT)  && !(prev_pad & PAD_LEFT)  && !blocked(fx-1, fy)) fx--;
+    if ((pad & PAD_RIGHT) && !(prev_pad & PAD_RIGHT) && !blocked(fx+1, fy)) fx++;
+    if (pad & PAD_DOWN) { step_fall(); tick = 0; }
+    if (++tick >= fall_period) { step_fall(); tick = 0; }
+    prev_pad = pad;
+}
+
+static void render(void)
+{
+    int r,c;
+    psx_clear(RGB(12, 12, 24));
+    /* well border */
+    psx_rect(OX-3, OY-3, GW*CELL+6, GH*CELL+6, RGB(60,60,90));
+    psx_rect(OX, OY, GW*CELL, GH*CELL, RGB(20,20,36));
+    /* settled blocks */
+    for (r=0;r<GH;r++) for(c=0;c<GW;c++) if (grid[r][c])
+        psx_rect(OX+c*CELL+1, OY+r*CELL+1, CELL-2, CELL-2, PAL[grid[r][c]]);
+    /* falling block */
+    if (fy>=0) psx_rect(OX+fx*CELL+1, OY+fy*CELL+1, CELL-2, CELL-2, PAL[fc]);
+    psx_number(8, 6, (unsigned)score, RGB(255,255,255));
+}
+
+int main(void)
+{
+    psx_init();
+    psx_srand(0xD0D0);
+    state = TITLE; prev_pad = 0;
+    for (;;) {
+        unsigned int pad = psx_pad();
+        if (state == TITLE) {
+            psx_clear(RGB(20, 12, 30));
+            psx_rect(110, 90, 100, 60, RGB(80,150,255));
+            psx_rect(120, 100, 80, 40, RGB(230,60,60));
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_game(); state = PLAY; }
+            prev_pad = pad;
+        } else if (state == PLAY) { update(); render(); }
+        else {
+            psx_clear(RGB(30, 8, 8));
+            psx_number(110, 100, (unsigned)score, RGB(255, 120, 120));
+            psx_number(120, 130, (unsigned)hi, RGB(255, 255, 120));
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_game(); state = PLAY; }
+            prev_pad = pad;
+        }
+        psx_vsync();
+    }
+    return 0;
+}

package/examples/ps1/racing/main.c

@@ -0,0 +1,147 @@
+/*
+ * racing/main.c — POLE BENDER: a 3D PlayStation racer.
+ *
+ * The road is a ribbon of quads receding to the horizon (real perspective, drawn
+ * far-to-near). You steer a car near the camera between the verges; the world
+ * scrolls toward you and the track curves. Rival cars (cubes) sit further up the
+ * road and grow as you close on them — collide and you spin out (lose time/score).
+ * Title -> race -> results state machine, distance score, a lap timer.
+ *
+ * Build: build({ platform:"ps1", language:"c" }). Controls: LEFT/RIGHT steer,
+ * UP accelerate, DOWN brake, START begins/restarts.
+ *
+ * 3D technique: the track is N segments ahead; each segment is a quad between two
+ * road-edge pairs, its centerline x driven by a curve value so the road bends. The
+ * camera sits just behind/above the car. All 16.16 fixed point.
+ */
+#include "psx.h"
+
+#define SEGS 14
+enum { TITLE, RACE, DONE };
+
+static fix car_x;          /* lateral position of the car */
+static fix scroll;         /* how far we've travelled (for segment phase) */
+static fix curve;          /* current road curvature */
+static fix speed;
+static int state, score, best;
+static int rivals_z[3], rival_x[3];
+static unsigned int prev_pad;
+
+static void reset_race(void)
+{
+    int i;
+    car_x = 0; scroll = 0; curve = 0; speed = FIXF(0.4f); score = 0;
+    for (i = 0; i < 3; i++) { rivals_z[i] = 8 + i * 5; rival_x[i] = ((i * 97) % 5) - 2; }
+}
+
+/* a flat ground-plane quad at depth z0..z1, centered at lateral cx with half-width hw. */
+static void road_quad(fix cx0, fix z0, fix cx1, fix z1, fix hw, unsigned int col)
+{
+    Vec3 a, b, c, d;
+    a.x = cx0 - hw; a.y = FIXF(-2.0f); a.z = z0;
+    b.x = cx0 + hw; b.y = FIXF(-2.0f); b.z = z0;
+    c.x = cx1 + hw; c.y = FIXF(-2.0f); c.z = z1;
+    d.x = cx1 - hw; d.y = FIXF(-2.0f); d.z = z1;
+    /* ground plane: no back-face cull (a flat floor's winding is ambiguous). */
+    psx_quad3d_nc(a, b, c, d, col);
+}
+
+static void draw_cube_at(fix x, fix y, fix z, fix s, unsigned int col)
+{
+    Vec3 v[8]; int i;
+    static const int sx[8]={-1,1,1,-1,-1,1,1,-1},sy[8]={-1,-1,1,1,-1,-1,1,1},sz[8]={-1,-1,-1,-1,1,1,1,1};
+    psx_model(x, y, z, 0);
+    for (i = 0; i < 8; i++){ v[i].x=sx[i]*s; v[i].y=sy[i]*s; v[i].z=sz[i]*s; }
+    psx_quad3d(v[0],v[1],v[2],v[3],col); psx_quad3d(v[5],v[4],v[7],v[6],col);
+    psx_quad3d(v[4],v[0],v[3],v[7],col); psx_quad3d(v[1],v[5],v[6],v[2],col);
+    psx_quad3d(v[4],v[5],v[1],v[0],col); psx_quad3d(v[3],v[2],v[6],v[7],col);
+}
+
+static void update(void)
+{
+    unsigned int pad = psx_pad();
+    int i;
+    if (pad & PAD_LEFT)  car_x -= FMUL(speed, FIXF(0.4f));
+    if (pad & PAD_RIGHT) car_x += FMUL(speed, FIXF(0.4f));
+    if (pad & PAD_UP)    { speed += FIXF(0.01f); if (speed > FIX(1)) speed = FIX(1); }
+    if (pad & PAD_DOWN)  { speed -= FIXF(0.03f); if (speed < FIXF(0.1f)) speed = FIXF(0.1f); }
+    if (car_x < FIX(-4)) car_x = FIX(-4); if (car_x > FIX(4)) car_x = FIX(4);
+
+    /* advance the world + wander the curve */
+    scroll += speed;
+    curve = psx_sin(scroll >> 2);                 /* the road bends with a sine */
+    curve = FMUL(curve, FIX(3));
+    score += F2I(speed << 2);
+
+    /* rivals roll toward us; collide = spin (reset speed + small score penalty) */
+    for (i = 0; i < 3; i++) {
+        rivals_z[i] -= F2I(speed << 1) + 1;
+        if (rivals_z[i] < 2) { rivals_z[i] = 30 + (psx_rand() % 12); rival_x[i] = (int)(psx_rand() % 5) - 2; }
+        if (rivals_z[i] < 4) {
+            fix rx = (fix)rival_x[i] << 16;
+            fix dx = rx - car_x; if (dx < 0) dx = -dx;
+            if (dx < FIX(1)) { speed = FIXF(0.15f); if (score > 30) score -= 30; }
+        }
+    }
+}
+
+static void render(void)
+{
+    int s, i;
+    psx_clear(RGB(70, 130, 200));   /* sky */
+    /* far ground band */
+    psx_rect(0, 120, 320, 120, RGB(40, 90, 40));
+
+    /* draw road segments far -> near; centerline curves with depth */
+    for (s = SEGS - 1; s >= 0; s--) {
+        fix z0 = FIX(2 + s * 3);
+        fix z1 = FIX(2 + (s + 1) * 3);
+        /* centerline x grows with depth*curve for the bend */
+        fix cx0 = FMUL(curve, FMUL(z0, z0)) >> 6;
+        fix cx1 = FMUL(curve, FMUL(z1, z1)) >> 6;
+        unsigned int col = (s & 1) ? RGB(60, 60, 70) : RGB(80, 80, 90);
+        road_quad(cx0 - car_x, z0, cx1 - car_x, z1, FIX(3), col);
+        /* verges */
+        road_quad(cx0 - car_x - FIX(3), z0, cx1 - car_x - FIX(3), z1, FIXF(0.4f), RGB(220,220,220));
+        road_quad(cx0 - car_x + FIX(3), z0, cx1 - car_x + FIX(3), z1, FIXF(0.4f), RGB(220,60,60));
+    }
+    /* rivals on the road */
+    for (i = 0; i < 3; i++) if (rivals_z[i] >= 2 && rivals_z[i] < 40) {
+        fix z = (fix)rivals_z[i] << 16;
+        fix cx = FMUL(curve, FMUL(z, z)) >> 6;
+        draw_cube_at(((fix)rival_x[i] << 16) + cx - car_x, FIXF(-1.4f), z, FIXF(0.5f), RGB(230, 200, 40));
+    }
+    /* the player's car, near the camera */
+    draw_cube_at(0, FIXF(-1.4f), FIX(3), FIXF(0.6f), RGB(220, 40, 40));
+
+    psx_number(8, 6, (unsigned)score, RGB(255, 255, 255));
+}
+
+int main(void)
+{
+    psx_init();
+    psx_srand(0x1337);
+    psx_camera(0, FIXF(-0.5f), FIX(-1), 0, FIXF(-0.18f)); /* low chase cam, looking down */
+    state = TITLE; prev_pad = 0;
+
+    for (;;) {
+        unsigned int pad = psx_pad();
+        if (state == TITLE) {
+            static fix t; t += FIX(3);
+            psx_clear(RGB(20, 20, 50));
+            draw_cube_at(0, 0, FIX(6), FIX(1), RGB(220, 40, 40));
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_race(); state = RACE; }
+        } else if (state == RACE) {
+            update(); render();
+            if (score > 4000) { if (score > best) best = score; state = DONE; }
+        } else {
+            psx_clear(RGB(8, 30, 8));
+            psx_number(110, 100, (unsigned)score, RGB(120, 255, 120));
+            psx_number(120, 130, (unsigned)best, RGB(255, 255, 120));
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_race(); state = RACE; }
+        }
+        prev_pad = pad;
+        psx_vsync();
+    }
+    return 0;
+}

package/examples/ps1/shmup/main.c

@@ -0,0 +1,192 @@
+/*
+ * shmup/main.c — STARFALL: a 3D PlayStation vertical shooter.
+ *
+ * Idiomatic PS1 3D: the playfield recedes into the screen. You pilot a ship near
+ * the camera; enemy cubes fly IN from the far distance toward you, growing as the
+ * perspective projection scales them up. Shoot them with a stream of bullets that
+ * fire away into Z. Title -> play -> game-over state machine, score + lives,
+ * AABB-in-screen-space collision, an xorshift wave spawner, a parallax starfield.
+ *
+ * Build: build({ platform:"ps1", language:"c" }). Controls: d-pad/stick move,
+ * CROSS fires, START begins / restarts. Runs on the romdev pcsx_rearmed core.
+ *
+ * Pipeline: psx_camera fixes the eye; each entity is a small cube drawn via
+ * psx_model (translate to its world pos) + psx_quad3d faces. Depth sort is implicit
+ * (we draw far enemies first by iterating; the painter order is good enough for
+ * non-overlapping cubes). All math is 16.16 fixed point.
+ */
+#include "psx.h"
+
+#define MAX_E 8
+#define MAX_B 6
+
+enum { TITLE, PLAY, OVER };
+
+typedef struct { int alive; fix x, y, z; } Ent;
+
+static Ent enemy[MAX_E];
+static Ent bullet[MAX_B];
+static fix px, py;          /* player position (x,y); z fixed near camera */
+static int state, score, lives, hi;
+static unsigned int prev_pad;
+
+/* a unit cube's 6 faces, drawn at the current psx_model origin, scaled by `s`. */
+static void draw_cube(fix s, unsigned int col)
+{
+    Vec3 v[8];
+    int i;
+    static const int sx[8] = {-1, 1, 1,-1,-1, 1, 1,-1};
+    static const int sy[8] = {-1,-1, 1, 1,-1,-1, 1, 1};
+    static const int sz[8] = {-1,-1,-1,-1, 1, 1, 1, 1};
+    for (i = 0; i < 8; i++) { v[i].x = sx[i] * s; v[i].y = sy[i] * s; v[i].z = sz[i] * s; }
+    psx_quad3d(v[0],v[1],v[2],v[3], col);
+    psx_quad3d(v[5],v[4],v[7],v[6], col);
+    psx_quad3d(v[4],v[0],v[3],v[7], col);
+    psx_quad3d(v[1],v[5],v[6],v[2], col);
+    psx_quad3d(v[4],v[5],v[1],v[0], col);
+    psx_quad3d(v[3],v[2],v[6],v[7], col);
+}
+
+static void reset_game(void)
+{
+    int i;
+    for (i = 0; i < MAX_E; i++) enemy[i].alive = 0;
+    for (i = 0; i < MAX_B; i++) bullet[i].alive = 0;
+    px = 0; py = FIXF(-1.5f);
+    score = 0; lives = 3;
+}
+
+static void spawn_enemy(void)
+{
+    int i;
+    for (i = 0; i < MAX_E; i++) if (!enemy[i].alive) {
+        enemy[i].alive = 1;
+        enemy[i].x = (fix)((psx_rand() % 7) - 3) << 16;   /* -3..3 */
+        enemy[i].y = (fix)((psx_rand() % 5) - 1) << 16;    /* -1..3 */
+        enemy[i].z = FIX(40);                              /* far away */
+        return;
+    }
+}
+
+static void fire(void)
+{
+    int i;
+    for (i = 0; i < MAX_B; i++) if (!bullet[i].alive) {
+        bullet[i].alive = 1; bullet[i].x = px; bullet[i].y = py; bullet[i].z = FIX(4);
+        return;
+    }
+}
+
+/* AABB overlap of two world points in the XY plane within `r`. */
+static int hit(fix ax, fix ay, fix bx, fix by, fix r)
+{
+    fix dx = ax - bx, dy = ay - by;
+    if (dx < 0) dx = -dx; if (dy < 0) dy = -dy;
+    return dx < r && dy < r;
+}
+
+static void update(void)
+{
+    unsigned int pad = psx_pad();
+    int i, j;
+
+    /* move ship */
+    if (pad & PAD_LEFT)  px -= FIXF(0.18f);
+    if (pad & PAD_RIGHT) px += FIXF(0.18f);
+    if (pad & PAD_UP)    py += FIXF(0.14f);
+    if (pad & PAD_DOWN)  py -= FIXF(0.14f);
+    if (px < FIX(-4)) px = FIX(-4); if (px > FIX(4)) px = FIX(4);
+    if (py < FIX(-3)) py = FIX(-3); if (py > FIX(2)) py = FIX(2);
+
+    /* fire on CROSS edge */
+    if ((pad & PAD_CROSS) && !(prev_pad & PAD_CROSS)) fire();
+
+    /* bullets fly into Z */
+    for (i = 0; i < MAX_B; i++) if (bullet[i].alive) {
+        bullet[i].z += FIX(2);
+        if (bullet[i].z > FIX(45)) bullet[i].alive = 0;
+    }
+
+    /* enemies approach */
+    if ((psx_rand() & 31) == 0) spawn_enemy();
+    for (i = 0; i < MAX_E; i++) if (enemy[i].alive) {
+        enemy[i].z -= FIXF(0.5f);
+        if (enemy[i].z < FIX(3)) {           /* reached the ship plane */
+            enemy[i].alive = 0;
+            if (--lives <= 0) { if (score > hi) hi = score; state = OVER; }
+        }
+        /* bullet collisions */
+        for (j = 0; j < MAX_B; j++) if (bullet[j].alive) {
+            fix dz = enemy[i].z - bullet[j].z; if (dz < 0) dz = -dz;
+            if (dz < FIX(2) && hit(enemy[i].x, enemy[i].y, bullet[j].x, bullet[j].y, FIX(1))) {
+                enemy[i].alive = 0; bullet[j].alive = 0; score += 10;
+            }
+        }
+    }
+    prev_pad = pad;
+}
+
+static void render(void)
+{
+    int i;
+    psx_clear(RGB(6, 8, 24));
+
+    /* starfield: a few far cubes as backdrop sparkle */
+    for (i = 0; i < 12; i++) {
+        fix sx = (fix)(((i * 53) % 9) - 4) << 16;
+        fix sy = (fix)(((i * 37) % 7) - 3) << 16;
+        psx_model(sx, sy, FIX(50), 0);
+        draw_cube(FIXF(0.15f), RGB(40, 40, 70));
+    }
+    /* enemies (draw far -> near for painter order) */
+    for (i = 0; i < MAX_E; i++) if (enemy[i].alive) {
+        psx_model(enemy[i].x, enemy[i].y, enemy[i].z, enemy[i].z << 2);
+        draw_cube(FIXF(0.7f), RGB(230, 60, 60));
+    }
+    /* bullets */
+    for (i = 0; i < MAX_B; i++) if (bullet[i].alive) {
+        psx_model(bullet[i].x, bullet[i].y, bullet[i].z, 0);
+        draw_cube(FIXF(0.18f), RGB(255, 240, 80));
+    }
+    /* player ship near the camera */
+    psx_model(px, py, FIX(3), 0);
+    draw_cube(FIXF(0.5f), RGB(80, 200, 255));
+
+    /* HUD: score + lives */
+    psx_number(8, 6, (unsigned)score, RGB(255, 255, 255));
+    for (i = 0; i < lives; i++) psx_rect(290 - i*10, 8, 6, 6, RGB(80, 200, 255));
+}
+
+int main(void)
+{
+    psx_init();
+    psx_srand(0xC0FFEE);
+    psx_camera(0, 0, FIX(-2), 0, FIXF(-0.08f)); /* slight downward tilt over the field */
+    state = TITLE;
+    prev_pad = 0;
+
+    for (;;) {
+        unsigned int pad = psx_pad();
+        if (state == TITLE) {
+            psx_clear(RGB(10, 10, 40));
+            /* a spinning hero cube as the title art */
+            static fix t; t += FIX(2);
+            psx_model(0, 0, FIX(6), t);
+            draw_cube(FIX(1), RGB(80, 200, 255));
+            psx_number(120, 200, 0, RGB(255, 255, 255)); /* press start cue: shows "0" */
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_game(); state = PLAY; }
+            prev_pad = pad;
+        } else if (state == PLAY) {
+            update();
+            render();
+        } else { /* OVER */
+            psx_clear(RGB(40, 8, 8));
+            psx_number(110, 100, (unsigned)score, RGB(255, 80, 80));
+            psx_number(120, 130, (unsigned)hi, RGB(255, 255, 120));
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_game(); state = PLAY; }
+            prev_pad = pad;
+        }
+        psx_vsync();
+    }
+    return 0;
+}