romdevtools 0.44.0 → 0.70.0

package/examples/n64/platformer/main.c

@@ -0,0 +1,158 @@
+/*
+ * platformer/main.c — BLOCK HOP: a 3D Nintendo 64 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:"n64", 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 "n64.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 short 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;
+    n64_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;
+    n64_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 short 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};
+    n64_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;}
+    n64_quad3d(v[0],v[1],v[2],v[3],col); n64_quad3d(v[5],v[4],v[7],v[6],col);
+    n64_quad3d(v[4],v[0],v[3],v[7],col); n64_quad3d(v[1],v[5],v[6],v[2],col);
+    n64_quad3d(v[4],v[5],v[1],v[0],col); n64_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 = n64_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_A) && !(prev_pad & PAD_A) && 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;
+    n64_clear(RGB(40, 60, 120));   /* sky */
+    n64_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));
+
+    n64_number(8, 6, (unsigned)score, RGB(255,255,255));
+    for (i = 0; i < lives; i++) n64_rect(290 - i*10, 8, 6, 6, RGB(230, 90, 60));
+}
+
+int main(void)
+{
+    n64_init();
+    n64_srand(0xBEEF);
+    state = TITLE; prev_pad = 0; cam_x = 0;
+    for (;;) {
+        unsigned int pad = n64_pad();
+        if (state == TITLE) {
+            n64_clear(RGB(20, 30, 60));
+            n64_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 {
+            n64_clear(RGB(8, 8, 30));
+            n64_number(110, 100, (unsigned)score, RGB(255, 220, 40));
+            n64_number(120, 130, (unsigned)hi, RGB(255, 255, 120));
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_game(); state = PLAY; }
+            prev_pad = pad;
+        }
+        n64_flip();
+    }
+    return 0;
+}

package/examples/n64/puzzle/main.c

@@ -0,0 +1,117 @@
+/*
+ * puzzle/main.c — DROP GRID 64: a 3D Nintendo 64 falling-block puzzle.
+ *
+ * Unlike the PS1 puzzle (flat 2D), this is rendered in 3D — the N64 was a 3D-first
+ * machine, so the well is a perspective box and the blocks are shaded cubes you
+ * watch fall in depth. Same falling-block logic (move, drop, clear full rows, ramp
+ * speed, stack-out = game over) but presented through the 3D pipeline at an angle.
+ *
+ * Build: build({ platform:"n64", language:"c" }). Controls: LEFT/RIGHT move the
+ * falling block, DOWN soft-drop, START begin/restart.
+ *
+ * 3D technique: each grid cell is a cube at (col, -row, 0) in world space; a tilted
+ * camera looks into the well so you see depth. The board logic is plain integers.
+ */
+#include "n64.h"
+
+#define GW 6
+#define GH 10
+enum { TITLE, PLAY, OVER };
+
+static unsigned char grid[GH][GW];
+static int fx, fy, fc;
+static int tick, fall_period;
+static int state, score, hi;
+static unsigned int prev_pad;
+
+static const unsigned short PAL[5] = {
+    0, RGB(230,60,60), RGB(60,200,90), RGB(80,150,255), RGB(240,200,60)
+};
+
+static void cube_at(fix x, fix y, fix z, fix s, unsigned short 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};
+    n64_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;}
+    n64_quad3d(v[0],v[1],v[2],v[3],col); n64_quad3d(v[5],v[4],v[7],v[6],col);
+    n64_quad3d(v[4],v[0],v[3],v[7],col); n64_quad3d(v[1],v[5],v[6],v[2],col);
+    n64_quad3d(v[4],v[5],v[1],v[0],col); n64_quad3d(v[3],v[2],v[6],v[7],col);
+}
+
+/* grid cell (c,r) → world position (centered, y up). */
+static fix cellx(int c) { return (fix)(c - GW/2) << 16; }
+static fix celly(int r) { return (fix)((GH/2) - r) << 16; }
+
+static void new_block(void)
+{ fx=GW/2; fy=0; fc=1+(n64_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;
+    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++; }
+    }
+    new_block();
+}
+static void step_fall(void){ if(!blocked(fx,fy+1)) fy++; else lock_and_clear(); }
+
+static void update(void)
+{
+    unsigned int pad = n64_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;
+    n64_clear(RGB(12,12,24));
+    n64_camera(0,0,FIX(-12),0,FIXF(-0.05f));   /* look into the well */
+    /* settled blocks */
+    for(r=0;r<GH;r++) for(c=0;c<GW;c++) if(grid[r][c])
+        cube_at(cellx(c), celly(r), 0, FIXF(0.45f), PAL[grid[r][c]]);
+    /* falling block */
+    if(fy>=0) cube_at(cellx(fx), celly(fy), 0, FIXF(0.45f), PAL[fc]);
+    /* well floor + walls as dim cubes for depth cue */
+    for(c=-1;c<=GW;c++){ cube_at(cellx(c), celly(GH), 0, FIXF(0.45f), RGB(50,50,70)); }
+    for(r=0;r<=GH;r++){ cube_at(cellx(-1), celly(r), 0, FIXF(0.45f), RGB(40,40,60)); cube_at(cellx(GW), celly(r), 0, FIXF(0.45f), RGB(40,40,60)); }
+    n64_number(8,6,(unsigned)score,RGB(255,255,255));
+}
+
+int main(void)
+{
+    n64_init();
+    n64_srand(0xD0D0);
+    state=TITLE; prev_pad=0;
+    for(;;){
+        unsigned int pad = n64_pad();
+        if(state==TITLE){
+            static fix t; t+=FIX(3);
+            n64_clear(RGB(20,12,30));
+            n64_camera(0,0,FIX(-6),0,0);
+            n64_model(0,0,0,t); cube_at(0,0,0,FIX(1),RGB(80,150,255));
+            if((pad&PAD_START)&&!(prev_pad&PAD_START)){ reset_game(); state=PLAY; }
+            prev_pad=pad;
+        } else if(state==PLAY){ update(); render(); }
+        else {
+            n64_clear(RGB(30,8,8));
+            n64_number(110,100,(unsigned)score,RGB(255,120,120));
+            n64_number(120,130,(unsigned)hi,RGB(255,255,120));
+            if((pad&PAD_START)&&!(prev_pad&PAD_START)){ reset_game(); state=PLAY; }
+            prev_pad=pad;
+        }
+        n64_flip();
+    }
+    return 0;
+}

package/examples/n64/racing/main.c

@@ -0,0 +1,147 @@
+/*
+ * racing/main.c — POLE BENDER: a 3D Nintendo 64 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:"n64", 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 "n64.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 short 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). */
+    n64_quad3d_nc(a, b, c, d, col);
+}
+
+static void draw_cube_at(fix x, fix y, fix z, fix s, unsigned short 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};
+    n64_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; }
+    n64_quad3d(v[0],v[1],v[2],v[3],col); n64_quad3d(v[5],v[4],v[7],v[6],col);
+    n64_quad3d(v[4],v[0],v[3],v[7],col); n64_quad3d(v[1],v[5],v[6],v[2],col);
+    n64_quad3d(v[4],v[5],v[1],v[0],col); n64_quad3d(v[3],v[2],v[6],v[7],col);
+}
+
+static void update(void)
+{
+    unsigned int pad = n64_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 = n64_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 + (n64_rand() % 12); rival_x[i] = (int)(n64_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;
+    n64_clear(RGB(70, 130, 200));   /* sky */
+    /* far ground band */
+    n64_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 short 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));
+
+    n64_number(8, 6, (unsigned)score, RGB(255, 255, 255));
+}
+
+int main(void)
+{
+    n64_init();
+    n64_srand(0x1337);
+    n64_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 = n64_pad();
+        if (state == TITLE) {
+            static fix t; t += FIX(3);
+            n64_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 {
+            n64_clear(RGB(8, 30, 8));
+            n64_number(110, 100, (unsigned)score, RGB(120, 255, 120));
+            n64_number(120, 130, (unsigned)best, RGB(255, 255, 120));
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_race(); state = RACE; }
+        }
+        prev_pad = pad;
+        n64_flip();
+    }
+    return 0;
+}

package/examples/n64/shmup/main.c

@@ -0,0 +1,122 @@
+/*
+ * shmup/main.c — STARFALL 64: a 3D Nintendo 64 vertical shooter.
+ *
+ * The N64 twin of the PS1 STARFALL — same software 3D engine, N64 backend. The
+ * playfield recedes into the screen; enemy cubes fly in from the far distance and
+ * grow under perspective. Shoot them with bullets that fly into Z. Title -> play ->
+ * game-over, score + lives, AABB collision, xorshift wave spawner, starfield.
+ *
+ * Build: build({ platform:"n64", language:"c" }) → a self-booting .z64. Controls:
+ * d-pad/stick move, A fires, START begins/restarts. Renders through the software
+ * rasterizer + angrylion VI scanout (no GL).
+ */
+#include "n64.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;
+static int state, score, lives, hi;
+static unsigned int prev_pad;
+
+static void draw_cube(fix s, unsigned short 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};
+    for(i=0;i<8;i++){v[i].x=sx[i]*s;v[i].y=sy[i]*s;v[i].z=sz[i]*s;}
+    n64_quad3d(v[0],v[1],v[2],v[3],col); n64_quad3d(v[5],v[4],v[7],v[6],col);
+    n64_quad3d(v[4],v[0],v[3],v[7],col); n64_quad3d(v[1],v[5],v[6],v[2],col);
+    n64_quad3d(v[4],v[5],v[1],v[0],col); n64_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)((n64_rand()%7)-3)<<16;
+        enemy[i].y=(fix)((n64_rand()%5)-1)<<16;
+        enemy[i].z=FIX(40); 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; }
+}
+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 = n64_pad();
+    int i,j;
+    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);
+    if((pad&PAD_A)&&!(prev_pad&PAD_A)) fire();
+    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; }
+    if((n64_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)){ enemy[i].alive=0; if(--lives<=0){ if(score>hi)hi=score; state=OVER; } }
+        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;
+    n64_clear(RGB(6,8,24));
+    for(i=0;i<12;i++){ fix sx=(fix)(((i*53)%9)-4)<<16, sy=(fix)(((i*37)%7)-3)<<16; n64_model(sx,sy,FIX(50),0); draw_cube(FIXF(0.15f),RGB(40,40,70)); }
+    for(i=0;i<MAX_E;i++) if(enemy[i].alive){ n64_model(enemy[i].x,enemy[i].y,enemy[i].z,enemy[i].z<<2); draw_cube(FIXF(0.7f),RGB(230,60,60)); }
+    for(i=0;i<MAX_B;i++) if(bullet[i].alive){ n64_model(bullet[i].x,bullet[i].y,bullet[i].z,0); draw_cube(FIXF(0.18f),RGB(255,240,80)); }
+    n64_model(px,py,FIX(3),0); draw_cube(FIXF(0.5f),RGB(80,200,255));
+    n64_number(8,6,(unsigned)score,RGB(255,255,255));
+    for(i=0;i<lives;i++) n64_rect(290-i*10,8,6,6,RGB(80,200,255));
+}
+
+int main(void)
+{
+    static fix t;
+    n64_init();
+    n64_srand(0xC0FFEE);
+    n64_camera(0,0,FIX(-2),0,FIXF(-0.08f));
+    state=TITLE; prev_pad=0;
+    for(;;){
+        unsigned int pad = n64_pad();
+        if(state==TITLE){
+            n64_clear(RGB(10,10,40));
+            t+=FIX(2); n64_model(0,0,FIX(6),t); draw_cube(FIX(1),RGB(80,200,255));
+            if((pad&PAD_START)&&!(prev_pad&PAD_START)){ reset_game(); state=PLAY; }
+            prev_pad=pad;
+        } else if(state==PLAY){ update(); render(); }
+        else {
+            n64_clear(RGB(40,8,8));
+            n64_number(110,100,(unsigned)score,RGB(255,80,80));
+            n64_number(120,130,(unsigned)hi,RGB(255,255,120));
+            if((pad&PAD_START)&&!(prev_pad&PAD_START)){ reset_game(); state=PLAY; }
+            prev_pad=pad;
+        }
+        n64_flip();
+    }
+    return 0;
+}

package/examples/n64/sports/main.c

@@ -0,0 +1,127 @@
+/*
+ * sports/main.c — SLAM COURT: a 3D Nintendo 64 sports game (air-hockey / pong).
+ *
+ * A 3D playfield seen in perspective: you control the near paddle, the CPU the far
+ * one. A ball bounces down the court in 3D (X across, Z into the screen); rally it
+ * past the CPU to score, miss and the CPU scores. First to 7. Title -> match ->
+ * game-over. The whole court is drawn with the perspective pipeline; the ball's
+ * size changes with depth, selling the 3D.
+ *
+ * Build: build({ platform:"n64", language:"c" }). Controls: LEFT/RIGHT move your
+ * paddle, START begin/restart.
+ *
+ * 3D technique: the court floor is a big no-cull quad; paddles + ball are cubes at
+ * world positions. The CPU paddle tracks the ball's X with a capped speed. 16.16 fp.
+ */
+#include "n64.h"
+
+enum { TITLE, PLAY, OVER };
+
+static fix px;               /* player paddle X (near, z = small) */
+static fix cx;               /* cpu paddle X (far, z = big) */
+static fix bx, bz, bvx, bvz; /* ball position + velocity */
+static int you, cpu, state;
+static unsigned int prev_pad;
+
+#define COURT_HW  FIX(5)     /* court half-width */
+#define NEAR_Z    FIX(3)
+#define FAR_Z     FIX(22)
+
+static void draw_cube_at(fix x, fix y, fix z, fix s, unsigned short 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};
+    n64_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;}
+    n64_quad3d(v[0],v[1],v[2],v[3],col); n64_quad3d(v[5],v[4],v[7],v[6],col);
+    n64_quad3d(v[4],v[0],v[3],v[7],col); n64_quad3d(v[1],v[5],v[6],v[2],col);
+    n64_quad3d(v[4],v[5],v[1],v[0],col); n64_quad3d(v[3],v[2],v[6],v[7],col);
+}
+
+static void serve(int toward_cpu)
+{
+    bx = 0; bz = (NEAR_Z + FAR_Z) >> 1;
+    bvx = (n64_rand() & 1) ? FIXF(0.12f) : FIXF(-0.12f);
+    bvz = toward_cpu ? FIXF(0.45f) : FIXF(-0.45f);
+}
+
+static void reset_game(void) { px = 0; cx = 0; you = 0; cpu = 0; serve(1); }
+
+static void update(void)
+{
+    unsigned int pad = n64_pad();
+    if (pad & PAD_LEFT)  px -= FIXF(0.22f);
+    if (pad & PAD_RIGHT) px += FIXF(0.22f);
+    if (px < -COURT_HW) px = -COURT_HW; if (px > COURT_HW) px = COURT_HW;
+
+    /* cpu tracks the ball, capped */
+    { fix d = bx - cx; if (d > FIXF(0.16f)) d = FIXF(0.16f); if (d < -FIXF(0.16f)) d = -FIXF(0.16f); cx += d; }
+
+    bx += bvx; bz += bvz;
+    if (bx < -COURT_HW || bx > COURT_HW) bvx = -bvx;  /* side walls */
+
+    /* near paddle (player) */
+    if (bz <= NEAR_Z) {
+        fix d = bx - px; if (d < 0) d = -d;
+        if (d < FIX(2)) { bvz = -bvz; bz = NEAR_Z; bvx += (bx - px) >> 4; }
+        else { cpu++; if (cpu >= 7) { state = OVER; } else serve(1); }
+    }
+    /* far paddle (cpu) */
+    if (bz >= FAR_Z) {
+        fix d = bx - cx; if (d < 0) d = -d;
+        if (d < FIX(2)) { bvz = -bvz; bz = FAR_Z; }
+        else { you++; if (you >= 7) { state = OVER; } else serve(0); }
+    }
+    prev_pad = pad;
+}
+
+static void render(void)
+{
+    Vec3 a,b,c,d;
+    n64_clear(RGB(20, 40, 30));
+    n64_camera(0, FIX(4), FIX(-1), 0, FIXF(-0.30f)); /* look down the court */
+
+    /* court floor */
+    a.x=-COURT_HW; a.y=0; a.z=NEAR_Z; b.x=COURT_HW; b.y=0; b.z=NEAR_Z;
+    c.x=COURT_HW;  c.y=0; c.z=FAR_Z;  d.x=-COURT_HW; d.y=0; d.z=FAR_Z;
+    n64_quad3d_nc(a,b,c,d, RGB(40, 90, 60));
+    /* center line */
+    a.x=-COURT_HW; a.z=(NEAR_Z+FAR_Z)>>1; b.x=COURT_HW; b.z=a.z;
+    c.x=COURT_HW; c.z=a.z+FIXF(0.3f); d.x=-COURT_HW; d.z=c.z;
+    a.y=FIXF(0.02f);b.y=a.y;c.y=a.y;d.y=a.y;
+    n64_quad3d_nc(a,b,c,d, RGB(220,220,220));
+
+    draw_cube_at(px, FIXF(0.5f), NEAR_Z, FIXF(0.9f), RGB(80, 180, 255)); /* you */
+    draw_cube_at(cx, FIXF(0.5f), FAR_Z,  FIXF(0.9f), RGB(255, 100, 80)); /* cpu */
+    draw_cube_at(bx, FIXF(0.5f), bz, FIXF(0.4f), RGB(255, 240, 120));    /* ball */
+
+    n64_number(40, 8, (unsigned)you, RGB(80, 180, 255));
+    n64_number(240, 8, (unsigned)cpu, RGB(255, 100, 80));
+}
+
+int main(void)
+{
+    n64_init();
+    n64_srand(0x5A11);
+    state = TITLE; prev_pad = 0;
+    for (;;) {
+        unsigned int pad = n64_pad();
+        if (state == TITLE) {
+            static fix t; t += FIX(3);
+            n64_clear(RGB(15, 30, 25));
+            n64_camera(0, 0, FIX(-1), 0, 0);
+            draw_cube_at(0, 0, FIX(6), FIX(1), RGB(80, 180, 255));
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_game(); state = PLAY; }
+            prev_pad = pad;
+        } else if (state == PLAY) { update(); render(); }
+        else {
+            n64_clear(RGB(8, 20, 16));
+            n64_number(120, 100, (unsigned)you, RGB(80, 180, 255));
+            n64_number(160, 100, (unsigned)cpu, RGB(255, 100, 80));
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_game(); state = PLAY; }
+            prev_pad = pad;
+        }
+        n64_flip();
+    }
+    return 0;
+}