romdevtools 0.43.0 → 0.56.1

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;
+}

package/examples/ps1/sports/main.c

@@ -0,0 +1,127 @@
+/*
+ * sports/main.c — SLAM COURT: a 3D PlayStation 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:"ps1", 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 "psx.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 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 serve(int toward_cpu)
+{
+    bx = 0; bz = (NEAR_Z + FAR_Z) >> 1;
+    bvx = (psx_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 = psx_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;
+    psx_clear(RGB(20, 40, 30));
+    psx_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;
+    psx_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;
+    psx_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 */
+
+    psx_number(40, 8, (unsigned)you, RGB(80, 180, 255));
+    psx_number(240, 8, (unsigned)cpu, RGB(255, 100, 80));
+}
+
+int main(void)
+{
+    psx_init();
+    psx_srand(0x5A11);
+    state = TITLE; prev_pad = 0;
+    for (;;) {
+        unsigned int pad = psx_pad();
+        if (state == TITLE) {
+            static fix t; t += FIX(3);
+            psx_clear(RGB(15, 30, 25));
+            psx_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 {
+            psx_clear(RGB(8, 20, 16));
+            psx_number(120, 100, (unsigned)you, RGB(80, 180, 255));
+            psx_number(160, 100, (unsigned)cpu, RGB(255, 100, 80));
+            if ((pad & PAD_START) && !(prev_pad & PAD_START)) { reset_game(); state = PLAY; }
+            prev_pad = pad;
+        }
+        psx_vsync();
+    }
+    return 0;
+}

package/examples/ps1/sprite_move/main.c

@@ -0,0 +1,38 @@
+/*
+ * sprite_move/main.c — PS1 starter (mips-elf-gcc + the bundled psx.h helper).
+ *
+ * Boots a visible 320x240 display and animates a colored box bouncing around the
+ * screen — the canonical "GPU is alive, here's a moving primitive" PS1 starter.
+ * Exercises the whole helper lib: psx_init (GPU bring-up), psx_clear + psx_rect
+ * (flat polygons), psx_vsync (pacing).
+ *
+ * Build with: build({ platform:"ps1", language:"c" }) — language defaults to C.
+ * Output is a PS-EXE the HLE BIOS loads at 0x80010000; main() loops forever
+ * (no OS to return to).
+ *
+ * PS1 NOTE: there is no tile/sprite/nametable hardware — the GPU draws polygons
+ * into a framebuffer. A "sprite" here is a textured/flat quad you draw each frame.
+ */
+#include "psx.h"
+
+int main(void)
+{
+    int x = 40, y = 40, dx = 2, dy = 2;
+    const int W = 32, H = 32;
+
+    psx_init();
+
+    for (;;) {
+        /* move + bounce */
+        x += dx; y += dy;
+        if (x < 0 || x + W > 320) dx = -dx;
+        if (y < 0 || y + H > 240) dy = -dy;
+        if (x < 0) x = 0; if (x + W > 320) x = 320 - W;
+        if (y < 0) y = 0; if (y + H > 240) y = 240 - H;
+
+        psx_clear(RGB(20, 30, 60));            /* deep-blue background */
+        psx_rect(x, y, W, H, RGB(255, 180, 40)); /* the bouncing box */
+        psx_vsync();
+    }
+    return 0;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "romdevtools",
-  "version": "0.43.0",
-  "description": "Tool server giving coding agents full control of homebrew ROM development AND reverse-engineering/romhacking across 14 retro platforms (NES, SNES, GB, Genesis, Atari, C64, PC Engine, MSX, ...) via WASM toolchains + emulator cores. Use over plain HTTP, as an Agent Skill, or as an MCP server.",
+  "version": "0.56.1",
+  "description": "Tool server giving coding agents full control of homebrew ROM development AND reverse-engineering/romhacking across 16 retro platforms (NES, SNES, GB, Genesis, Atari, C64, PC Engine, MSX, PlayStation, N64, ...) via WASM toolchains + emulator cores. Use over plain HTTP, as an Agent Skill, or as an MCP server.",
   "type": "module",
   "main": "src/mcp/server.js",
   "bin": {
@@ -58,6 +58,8 @@
     "romdev-core-geargrafx": "0.7.0",
     "romdev-core-gpgx": "0.12.0",
     "romdev-core-handy": "0.7.0",
+    "romdev-core-parallel-n64": "0.1.0",
+    "romdev-core-pcsx-rearmed": "0.1.0",
     "romdev-core-prosystem": "0.8.0",
     "romdev-core-vice": "0.9.0",
     "romdev-famitone": "0.1.0",
@@ -67,6 +69,7 @@
     "romdev-platform-snes": "0.8.0",
     "romdev-toolchain-cc65": "0.1.1",
     "romdev-toolchain-m68k-gcc": "0.2.0",
+    "romdev-toolchain-mips-gcc": "0.1.0",
     "romdev-toolchain-rgbds": "0.1.0",
     "romdev-toolchain-sdcc": "0.2.0",
     "romdev-toolchain-vasm": "0.1.0",
@@ -77,6 +80,10 @@
     "yauzl": "^3.3.1",
     "zod": "^4.4.3"
   },
+  "optionalDependencies": {
+    "native-gles": "^0.5.0",
+    "webgl-node": "^1.2.0"
+  },
   "files": [
     "src",
     "!src/**/*.test.js",