AI_Slop/joeylib2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
joeylib2/examples/spacetaxi/stRender.c

1395 lines
60 KiB
C
Raw Blame History

// Space Taxi -- tile bank + sprite rendering.
//
// Loads native (.tbk / .spr) assets at startup via jlTileBankLoad
// and jlSpriteBankLoad. Tile bytes are per-target planar; sprite
// data is cross-target chunky 4bpp (the Phase 11 walker reads
// chunky and c2p's inline at draw time). Per-frame work: save-
// under for moving sprites, draw, restore-under next frame. The
// static tilemap is committed once per scene change.
//
// Source PNGs live in assets/ and are baked at build time by
// tools/assetbake/assetbake.py:
// font.png -> font.tbk (1000-tile 40x25 glyph sheet)
// tiles/tbankN.png -> tiles/tbankN.tbk (256-tile playfield bank)
// sprites/sprites.png -> sprites/sprites.spr (9x3 grid of 3x3
// 24x24 cels: row 0 taxi, row 1 passenger, row 2 flame)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "spacetaxi.h"
// All STAXI example sources share the STAXI load segment so the
// IIgs binary's _ROOT bank stays under 64 KB. No-op on other ports.
// Tile bank files are per-level: each level's .dat references a
// numeric bank id, and the host loads tiles/tbankN.tbk on demand
// (cached so re-entry on the same id is free).
//
// Per JoeyLib convention: each app installs into its own subdir
// of bin/, with runtime assets under DATA/. The DOS binary cwd's
// to the app dir when launched, so these paths are relative.
// DOS 8.3 filename limit: "tilebank0.tbk" is 9.3, fopen fails under
// DOSBox strict 8.3. Shortened to "tbank%u.tbk" (6.3) so all four
// targets can use the same filenames without per-platform aliasing.
#define ST_TILE_BANK_PATH_FMT "tiles/tbank%u.tbk"
#define ST_SPRITE_SHEET_PATH "sprites/sprites.spr"
#define ST_SPRITE_SHEET_SPC "sprites/sprites.spc"
#define ST_FONT_PATH "font.tbk"
#define ST_TILE_BANK_MAX 256u
// Font sheet layout: 320x200 indexed PNG = 40x25 grid of 8x8 glyphs,
// 1000 tiles total. asciiMap[c] packs the (col, row) location for
// ASCII c into a uint16_t; jlDrawText looks the tile up and pastes
// it as a transparent-on-color-0 glyph.
#define ST_FONT_COLS 40
#define ST_FONT_ROWS 25
#define ST_FONT_TILES_MAX (ST_FONT_COLS * ST_FONT_ROWS)
// Sprite sheet is 9 cols x 3 rows of 24x24 (= 3x3 tile) cels. Row 0
// is the taxi (4 cels used, rest blank), row 1 is the passenger (9
// cels), row 2 is the flame (8 cels). Cells lay out left-to-right
// top-to-bottom in the .spr blob's cellCount = 27.
#define ST_SPRITE_SHEET_COLS 9
#define ST_SPRITE_SHEET_CELS 55 /* 11 cols x 5 rows: taxi, passenger, flame, warp, death */
#define ST_SPRITE_TAXI_FIRST 0
#define ST_SPRITE_PASS_FIRST 11
#define ST_SPRITE_FLAME_FIRST 22
// Taxi sprite: 24x24 px = 3 tiles wide x 3 tiles tall. The port's
// sprite asset (extractSprites.py, real C64 art from raw.bin) lays
// out sheet row 0 in the live sprite-pointer order:
// cel 0 = $C1 (right, gear DOWN) cel 1 = $C0 (right, gear up)
// cel 2 = $DC (left, gear up) cel 3 = $DD (left, gear DOWN)
// $619B selects the base pair by held direction (LEFT -> $DC pair,
// RIGHT -> $C0 pair, otherwise keep the last facing) and preserves
// bit 0 = the LANDING GEAR state (fire-toggled, $63DD). The in-
// flight body NEVER animates -- the cel is a static function of
// (facing, gearDown):
// cel = facingLeft ? (2 + gearDown) : (1 - gearDown)
// (The $6A95 EOR that an earlier port version modeled as a flicker
// is the crash-debris animation, $CC<->$CD during the fall.)
#define ST_TAXI_W_PX 24
#define ST_TAXI_H_PX 24
#define ST_TAXI_CEL_COUNT 4
// Transporter shrink-warp cels (sheet row 3): the SEVEN drawn cels
// $E2..$E8 of the $5CB9 chain, identity-mapped to warp steps 0..6.
// $5CDA ends the warp when the pointer REACHES $E9 and hides the
// sprite ($718E = 0) -- $E9 is never displayed, so step 7 draws
// nothing at all.
#define ST_SPRITE_WARP_FIRST 33
#define ST_WARP_CEL_COUNT 7
// Flame placeholder fallback (only used if real sprite-2 cel is
// missing): a small bright rectangle below the cab while thrusting.
// $6D6A in the asm positions sprite 2 at (taxi_col - 2, taxi_row);
// the real cels are extracted at runtime as flameCels[0..7].
#define ST_FLAME_W_PX 8
#define ST_FLAME_H_PX 8
#define ST_FLAME_OFFSET_X_PX ((ST_TAXI_W_PX / 2) - (ST_FLAME_W_PX / 2))
#define ST_FLAME_OFFSET_Y_PX (ST_TAXI_H_PX - 2)
// Real flame sprite cels (24x24, from raw.bin sprite ptrs in $6DB0
// table). Indexed by direction-mask -> cel via kFlameCelByDirMask
// below. $6D6A's parity bit ($716C) flickers the flame off every
// other GAME TICK (2 video frames, so a 12.5Hz PAL strobe that fuses
// on a CRT). The port reproduces the LOOK with a wall-clock virtual
// strobe (flameStrobeOn): at high frame rates it yields the authentic
// shimmer; a rendered frame long enough to span a whole strobe phase
// (low-fps IIgs) shows the flame continuously instead of a 7.5Hz
// blink that reads as "no flame".
#define ST_FLAME_CEL_W_PX 24
#define ST_FLAME_CEL_H_PX 24
#define ST_FLAME_CEL_COUNT 8
#define ST_FLAME_STROBE_MS 40u /* one $716C phase = 1 PAL game tick */
// Passenger: 24x24 (C64 hardware sprite size is 24x21; we pad 3 rows
// transparent at the bottom in the asset extraction to keep a square
// cell). Cels:
// 0/1 = walk-LEFT alternation ($C4 / $C5) for the title walk
// 2-7 = boarding sequence ($C6 / $C7 / $C8 / $C9 / $CA / $CB) per
// $67A6 incrementing gSpr1PtrShadow from $C6 toward $CC.
#define ST_PASSENGER_W_PX 24
#define ST_PASSENGER_H_PX 24
#define ST_PASSENGER_CEL_COUNT 11
#define ST_PASSENGER_CEL_WALK0 0 /* $C4 walk LEFT a */
#define ST_PASSENGER_CEL_WALK1 1 /* $C5 walk LEFT b */
#define ST_PASSENGER_CEL_BOARD0 2 /* maps to C64 ptr $C6 */
#define ST_PASSENGER_CEL_SPARKLE 8 /* C64 ptr $D9 -- 3rd sparkle cel */
#define ST_PASSENGER_CEL_WALKR0 9 /* $C2 walk RIGHT a */
#define ST_PASSENGER_CEL_WALKR1 10 /* $C3 walk RIGHT b */
// Crash-death cels (sheet row 4): $CC/$CD debris alternation during
// the fall, then the $CE..$D1 ground-impact walk, then hidden.
#define ST_DEATH_CEL_COUNT 6
#define ST_SPRITE_DEATH_FIRST 44
// Startup progress bar: 2 load steps (font, sprite bank) + the 36
// per-cel compiles (4 taxi + 11 passenger + 8 flame + 7 warp +
// 6 death).
#define ST_LOAD_STEPS_TOTAL 38
#define ST_LOAD_BAR_X 60
#define ST_LOAD_BAR_Y 110
#define ST_LOAD_BAR_H 6
#define ST_LOAD_BAR_COLOR 1u /* white fill */
#define ST_LOAD_BAR_FRAME_COLOR 6u /* blue frame, cab color */
// Library-wide worst case (16-px-group window on planar ports).
#define ST_SPRITE_BACKUP_BYTES JOEY_SPRITE_BACKUP_BYTES(ST_TAXI_W_PX / 8, ST_TAXI_H_PX / 8)
typedef struct {
jlTileT tiles[ST_TILE_BANK_MAX];
bool tileValid[ST_TILE_BANK_MAX];
uint8_t currentBankId; // which tbank%u.tbk is loaded (0xFF = none)
bool bankLoaded;
jlSpriteT *taxiCels[ST_TAXI_CEL_COUNT];
jlSpriteT *warpCels[ST_WARP_CEL_COUNT];
jlSpriteT *deathCels[ST_DEATH_CEL_COUNT];
jlSpriteT *flameCels[ST_FLAME_CEL_COUNT];
jlSpriteBackupT flameBackup;
uint8_t flameBackupMem[ST_SPRITE_BACKUP_BYTES] __attribute__((aligned(2)));
bool flameHasBackup;
jlSpriteT *passengerCels[ST_PASSENGER_CEL_COUNT];
jlSurfaceT *fontSurface; // glyph surface, built from font.tbk at load
uint16_t asciiMap[128];
bool fontReady;
jlSpriteBackupT taxiBackup;
uint8_t taxiBackupMem[ST_SPRITE_BACKUP_BYTES] __attribute__((aligned(2)));
jlSpriteBackupT passengerBackup[ST_MAX_PASSENGERS];
uint8_t passengerBackupMem[ST_MAX_PASSENGERS][ST_SPRITE_BACKUP_BYTES] __attribute__((aligned(2)));
bool taxiHasBackup;
bool passengerHasBackup[ST_MAX_PASSENGERS];
uint32_t flamePrevMs; // flameStrobeOn frame-span tracker
uint32_t deathMs; // crash-anim step anchor
uint8_t deathStep; // impact-walk position (0..4)
bool deathActive; // crash anim state latched
// Tilemap repaint gating: the static playfield art only needs to
// be blitted to the stage once per scene change, not every frame.
// Per-frame full repaint blows the per-frame budget on emulated
// 386 in DOSBox and exposes tearing as the paint races the raster.
bool tilemapDirty;
const StLevelT *lastLevel;
} StRenderStateT;
static StRenderStateT gRender;
static bool loadTileBank(uint8_t bankId);
static bool loadSpriteSheet(jlSurfaceT *stage);
static bool loadFontSheet(jlSurfaceT *stage);
static void loadProgress(jlSurfaceT *stage, uint8_t step);
static bool flameStrobeOn(void);
static int16_t passCelForPtr(uint8_t ptr);
static void buildAsciiMap(void);
static void destroySprites(void);
// ---- Title intro + demo --------------------------------------------------
//
// Faithful to the C64 sequence (see disassembly $4A03 et al):
//
// Stage 2 ($4A17): wait $5A=90 frames running $66B7 (sparkle/effect)
// before the passenger appears.
// Stage 3 ($4A24): passenger sprite walks horizontally toward the cab,
// one tick per $715D countdown. $6D0D moves $7176
// (passenger col) +/- 2 each tick based on relative
// pad-hover X, toggling sprite cel via $7161 parity.
// Advances when passenger col == $28 (= 40, at cab).
// Stage 4 ($4A45): JMP $67A6 (transition).
// Stage 5 ($4A48): forces gInputDirMask = $01 (UP). Calls flameSpriteUpdate.
// Cab climbs until gTaxiRow < $14 = 20, then silences
// voice 3 and advances. This is the takeoff.
// Stage 6+: physicsTick now sources its input from the script at
// $0902 via $48F2. The recorded demo plays.
//
// Single cab, single passenger. The 7-sprite init at $4555-$456F just
// parks all hardware sprite slots at (col $AA, row $8C) so they don't
// flash garbage when the title is first shown.
// (The fabricated title "demo physics" stage and its truncated copy
// of demo stream 01 were deleted 2026-07-21: the real C64 never flies
// the cab around the title after takeoff -- it enters the ATTRACT
// DEMO, now a proper game state (ST_STATE_DEMO) driven by the full
// recorded input streams in stDemoStreams.h.)
// C64 reference values straight from the asm at $4A03 dispatch +
// titleSpriteSetup ($4525) + sprite-init tables ($4994/$49AC).
#define ST_TITLE_STAGE_SPARKLE 2u // gDeathStage value, $4A17
#define ST_TITLE_STAGE_WALK 3u // $4A24
#define ST_TITLE_STAGE_HANDOFF 4u // $4A45 -> $67A6
#define ST_TITLE_STAGE_LIFTOFF 5u // $4A48
#define ST_TITLE_STAGE_DONE 6u // intro over; attract demo takes over
#define ST_TITLE_SPARKLE_FRAMES 0x5Au // $47CC LDA #$5A STA $473F
#define ST_TITLE_WALK_TICK_RELOAD 3u // $715E observed in raw.bin
// Walk target = gPadHoverXCol ($715F) = $28 set at $47D8.
// In C64 sprite-X coords. Visible col = sprite-X - 24.
#define ST_TITLE_PAD_HOVER_SX 0x28u
// Cab init from table $4994/$49AC: sprite-X=$28, sprite-Y=$84, ptr=$C1.
#define ST_TITLE_CAB_SX_INIT 0x28
#define ST_TITLE_CAB_SY_INIT 0x84
// Passenger init from table: sprite-X=$32 + frac=$01 -> X=$32+$100=306,
// sprite-Y=$84, ptr=$C7.
#define ST_TITLE_PASS_SX_INIT ((int16_t)0x132) // $32 + $100
#define ST_TITLE_PASS_SY_INIT 0x84
#define ST_TITLE_PASS_PTR_INIT 0xC7 // $49B4[1]: initial passenger sprite ptr
#define ST_TITLE_PASS_PTR_WALK_LO 0xC4 // $6D68: walk-LEFT cel A
#define ST_TITLE_PASS_PTR_WALK_HI 0xC5 // $6D69: walk-LEFT cel B
#define ST_TITLE_PASS_PTR_BOARD0 0xC6 // boarding sequence start
#define ST_TITLE_PASS_PTR_BOARDED 0xCC // $67B8: advance when ptr == $CC
// $66D6 sparkle cel table -- cycled by $66B7 during stage 2.
// Each entry shown for $715E (= 3) frames; one full cycle = 12 frames.
// The $66D6 wave/sparkle cycle {$C6,$C7,$D9,$C7}: the title sparkle
// AND the waiting passenger's in-place wave both step through it (the
// gameplay passenger never moves -- he stands at standX and waves).
static const uint8_t kPassengerWaveCels[4] = { 0xC6, 0xC7, 0xD9, 0xC7 };
// Crash impact walk cadence ($6B2A: reload starts at 2 ticks and
// INCs each step -- 2,3,4,5 ticks for cels $CE..$D1 at the NTSC
// 33 ms game tick), then the sprite hides.
static const uint16_t kDeathStepMs[4] = { 66u, 100u, 133u, 166u };
#define ST_DEATH_TUMBLE_MS 66u /* $CC/$CD swap every 2 game ticks */
// Map direction-mask (CIA1 PortA bits after EOR #$FF: bit0=UP bit1=DOWN
// bit2=LEFT bit3=RIGHT) to a flameCels[] index, mirroring the C64
// table at $6DB0. Entries with no flame (no input, or invalid combos
// like UP+DOWN / LEFT+RIGHT / four-way) return -1.
static const int8_t kFlameCelByDirMask[16] = {
-1, /* 0 no input */
0, /* 1 UP -> $D8 */
1, /* 2 DOWN -> $D4 */
-1, /* 3 UP+DOWN invalid */
2, /* 4 LEFT -> $D5 */
3, /* 5 UP+LEFT -> $D2 */
4, /* 6 DOWN+LEFT -> $D1 */
-1, /* 7 */
5, /* 8 RIGHT -> $D7 */
6, /* 9 UP+RIGHT -> $D3 */
7, /* 10 DOWN+RIGHT -> $D6 */
-1, -1, -1, -1, -1
};
// Stage-5 advance gate: $4A5F CMP #$14 BCC $4A64. Cab row in sprite-Y
// coords; visible row = sprite-Y - 50, so $14 = 20 = visible row -30.
#define ST_TITLE_CAB_TAKEOFF_SY 0x14
// C64-to-visible conversion offsets (sprite hardware borders).
#define ST_SPRITE_X_OFFSET 24
#define ST_SPRITE_Y_OFFSET 50
typedef struct {
uint8_t stage; // mirrors gDeathStage during intro
uint8_t introFrameCount; // mirrors $473F (stage 2 countdown)
uint8_t decayReload; // mirrors $715E
uint8_t decayTimer; // mirrors $715D (countdown per tick)
uint8_t passengerCelParity;// mirrors $7161 (toggled each walk step)
uint8_t sparkleIdx; // mirrors $716E (sparkle cel index 0..3)
uint8_t passengerPtr; // mirrors gSpr1PtrShadow $7198
uint8_t cabPtr; // mirrors gSpr0PtrShadow $7197
// Sprite positions in C64 sprite-X / sprite-Y space (16-bit because
// sprite-X is 9 bits when MSB latched). Convert with the OFFSET
// constants above when rendering.
int16_t cabSx;
int16_t cabSy;
int16_t passengerSx;
int16_t passengerSy;
bool passengerVisible;
bool cabVisible;
bool flameVisible; // sprite 2 from $6D6A flameSpriteUpdate
uint8_t flameDirMask; // mirrors $716A passed into $6DB0,X
// Demo (post-intro stage 6) playback state -- script from $0902.
// Logo flip-book + color cycle. The "SPACE TAXI" logo is 103 cells
// of char $84; the C64 ($4827) copies one of the flip frames
// $85..$88 over char $84's bitmap every 4th frame, walking the
// ping-pong table $48A7 = {1,2,3,4,3,2} so each dot rotates end over
// end, and advances the 8-color cycle $489C when the index hits 4.
uint8_t logoFlipDiv; // mirrors $48A6 (mod-4 tick divider)
uint8_t logoFlipIdx; // mirrors $48A5 (0..5 ping-pong index)
uint8_t logoColorIdx; // mirrors $48A4 (0..7 color cycle index)
bool logoNeedsPaint; // flip/color changed (or tilemap repainted)
} StTitleStateT;
// The single animated logo character. Its bitmap is flip-booked through
// the four frames that follow it in the charset ($85..$88).
#define ST_LOGO_CHAR 0x84u
static StTitleStateT gTitle;
static void titleReset(void);
static void titleTick(void);
// Public so stLevel.c can ask "give me the tile object for index N".
const jlTileT *stRenderTileForIndex(uint8_t tileIdx) {
if (!gRender.tileValid[tileIdx]) {
return NULL;
}
return &gRender.tiles[tileIdx];
}
// Default 16-entry palette: matches the C64 VIC-II color register
// order so that an asset extracted with the C64 palette (via the
// extractFromDump.py tool) renders with the right colors here. The
// JoeyLib value format is $0RGB (4 bits per channel, top nibble
// unused). Index 0 black, 1 white, then C64 standard order.
static const uint16_t kDefaultPalette[16] = {
0x0000, // 0 black
0x0FFF, // 1 white
0x0833, // 2 red
0x06BB, // 3 cyan
0x0839, // 4 purple
0x05A4, // 5 green
0x0438, // 6 blue
0x0BC7, // 7 yellow
0x0852, // 8 orange
0x0540, // 9 brown
0x0B66, // 10 light red
0x0555, // 11 dark gray
0x0777, // 12 mid gray
0x09E8, // 13 light green
0x076C, // 14 light blue
0x09AA // 15 light gray
};
// Tile-index range -> placeholder fill color (used when no tile bank
// is loaded). Matches the engine's index-range convention.
static uint8_t placeholderColorFor(uint8_t tileIdx, uint8_t bgColor) {
// Used only when no tile bank is loaded -- debug-rendering. Slot
// indices reference kDefaultPalette above.
if (tileIdx == 0u) { return bgColor; }
if (tileIdx < 64u) { return 6u; } // walls -> blue
if (tileIdx < 128u) { return 5u; } // pads -> green
return 14u; // decor -> light blue
}
void stRenderInit(jlSurfaceT *stage) {
memset(&gRender, 0, sizeof(gRender));
gRender.taxiBackup.bytes = gRender.taxiBackupMem;
gRender.flameBackup.bytes = gRender.flameBackupMem;
gRender.currentBankId = 0xFFu; // no bank loaded yet
for (uint8_t i = 0u; i < ST_MAX_PASSENGERS; i++) {
gRender.passengerBackup[i].bytes = gRender.passengerBackupMem[i];
}
// Install the default 16-color palette on slot 0 and route the
// whole screen through it. Subsequent asset palettes can override
// by writing into slot 1+ via jlPaletteSet / jlScbSetRange.
jlPaletteSet(stage, 0u, kDefaultPalette);
jlScbSetRange(stage, 0u, (uint16_t)(SURFACE_HEIGHT - 1u), 0u);
// Startup feedback: the IIgs spends several seconds streaming the
// banks and compiling sprite cels to their asm routines, all of
// which used to happen against a black screen. Show a growing bar
// immediately; once the font is in, add the LOADING caption. The
// font loads FIRST because text needs its glyph surface.
jlSurfaceClear(stage, 0u);
loadProgress(stage, 0u);
if (!loadFontSheet(stage)) {
jlLogF("stRender: ! font load failed (%s)", ST_FONT_PATH);
}
buildAsciiMap();
loadProgress(stage, 1u);
// Tile bank is loaded on demand in stRenderLevel (per-level).
if (!loadSpriteSheet(stage)) {
jlLogF("stRender: ! sprite sheet load failed (%s)", ST_SPRITE_SHEET_PATH);
}
titleReset();
}
bool stRenderTitleIntroDone(void) {
return gTitle.stage == ST_TITLE_STAGE_DONE;
}
// Advance the title intro by ONE game tick. The main loop calls this
// on the fixed 30 Hz accumulator (not once per rendered frame) so the
// sparkle / walk / takeoff sequence and the logo flip run at the C64's
// rate on every port -- identical pre-game timing everywhere.
void stRenderTitleAdvance(void) {
titleTick();
}
// Restart the title intro (sparkle -> walk -> takeoff). Called on
// every return to the title so the attract cycle replays -- the C64
// re-enters the intro the same way after a demo exits.
void stRenderTitleReset(void) {
titleReset();
}
void stRenderShutdown(void) {
destroySprites();
if (gRender.fontSurface != NULL) {
jlSurfaceDestroy(gRender.fontSurface);
gRender.fontSurface = NULL;
}
}
void stRenderDrawText(jlSurfaceT *stage, uint8_t bx, uint8_t by, const char *s) {
if (!gRender.fontReady || gRender.fontSurface == NULL || s == NULL) {
return;
}
jlDrawText(stage, bx, by, gRender.fontSurface, gRender.asciiMap, s);
}
void stRenderLevel(jlSurfaceT *stage, const StLevelT *level) {
const jlTileT *tile;
uint8_t bx;
uint8_t by;
uint8_t tileIdx;
size_t i;
// Swap to the level's tile bank if it's not already loaded.
// First call lands here and pulls tbank<id>.tbk off disk.
if (!gRender.bankLoaded || gRender.currentBankId != level->tileBankId) {
(void)loadTileBank(level->tileBankId);
gRender.tilemapDirty = true;
}
// Scene change detected -> force a repaint. Otherwise this is a
// no-op (the level tilemap data is static between calls).
if (gRender.lastLevel != level) {
gRender.tilemapDirty = true;
gRender.lastLevel = level;
}
if (!gRender.tilemapDirty) {
return;
}
gRender.tilemapDirty = false;
jlSurfaceClear(stage, level->bgColor);
for (by = 0u; by < ST_PLAYFIELD_ROWS; by++) {
for (bx = 0u; bx < ST_TILEMAP_W; bx++) {
i = (size_t)by * ST_TILEMAP_W + bx;
tileIdx = level->tilemap[i];
// tileIdx is uint8_t, naturally bounded to ST_TILE_BANK_MAX=256.
tile = gRender.tileValid[tileIdx] ? &gRender.tiles[tileIdx] : NULL;
if (tile != NULL) {
// C64-style per-cell coloring: tile bitmap is a fixed
// glyph from the charset, colormap[i] is the foreground
// color from color RAM ($D800). Empty tile (idx 0)
// still goes through here as bgColor on both fg/bg --
// jlTileFill is left for the no-bank-loaded fallback.
uint8_t fg = (uint8_t)(level->colormap[i] & 0x0Fu);
jlTilePasteMono(stage, bx, by, tile, fg, level->bgColor);
} else {
jlTileFill(stage, bx, by, placeholderColorFor(tileIdx, level->bgColor));
}
}
}
}
void stRenderLevelChanged(void) {
// Force the next stRenderLevel call to repaint. Needed because the
// dirty-cache compares lastLevel by pointer, but stLevelLoad
// overwrites *game.level in place -- the pointer stays equal and
// the cache would otherwise skip the new tilemap.
gRender.tilemapDirty = true;
gRender.lastLevel = NULL;
}
// $4A03 dispatcher entry state, from $47C9 postInitPressFire:
// $47C7: A9 02 LDA #$02
// $47C9: 8D 63 71 STA $7163 ; gDeathStage = 2
// $47CC: A9 5A LDA #$5A
// $47CE: 8D 3F 47 STA $473F ; gIntroFrameCount
// $47D1: A9 00 LDA #$00
// $47D3: 8D 60 71 STA $7160 ; gPadHoverXFrac
// $47D6: A9 28 LDA #$28
// $47D8: 8D 5F 71 STA $715F ; gPadHoverXCol
// $47DB: AD 5E 71 LDA $715E ; decayReload (snapshot $03)
// $47DE: 8D 5D 71 STA $715D ; decayTimer
// Sprite positions from the $49BC table-loop, X=0..7:
// $4994 col[] = 28 32 00 86 9C A2 BA D4
// $499C frac[] = 00 01 00 00 00 00 00 00
// $49AC row[] = 84 84 00 E2 E2 E2 E2 E2
// $49B4 ptr[] = C1 C7 00 DB DE DF E0 E1
// Sprite 0 (cab) sprite-X = $28 = 40, sprite-Y = $84, ptr $C1.
// Sprite 1 (passenger) sprite-X = $32 + $100 = 306, sprite-Y = $84,
// ptr $C7. (frac=1 latches the X-MSB.)
static void titleReset(void) {
memset(&gTitle, 0, sizeof(gTitle));
gTitle.stage = ST_TITLE_STAGE_SPARKLE;
gTitle.introFrameCount = ST_TITLE_SPARKLE_FRAMES;
gTitle.decayReload = ST_TITLE_WALK_TICK_RELOAD;
gTitle.decayTimer = ST_TITLE_WALK_TICK_RELOAD;
gTitle.passengerCelParity = 0u;
gTitle.passengerPtr = ST_TITLE_PASS_PTR_INIT;
gTitle.cabPtr = 0xC1; // sprite 0 init ptr
gTitle.cabSx = ST_TITLE_CAB_SX_INIT;
gTitle.cabSy = ST_TITLE_CAB_SY_INIT;
gTitle.passengerSx = ST_TITLE_PASS_SX_INIT;
gTitle.passengerSy = ST_TITLE_PASS_SY_INIT;
gTitle.cabVisible = true;
gTitle.passengerVisible = true;
gTitle.flameVisible = false;
// Force the first tick to be an animation step (3 -> 0 on first ++)
// AND force a logo paint on the first render frame so the flip
// frame + color appear immediately (the tilemap was just repainted
// by stRenderLevelChanged, erasing any prior logo cells).
gTitle.logoFlipDiv = 3u;
gTitle.logoNeedsPaint = true;
}
// $4827 logo flip-book + $4861 color cycle. The title's "SPACE TAXI"
// logo is 103 cells of char $84 (verified in the title dump). Every 4th
// frame ($4827: INC $48A6 / AND #$03 / BEQ) the C64 copies one flip
// frame ($85..$88) over char $84's bitmap, walking the ping-pong table
// $48A7 = {1,2,3,4,3,2} -> frames $85,$86,$87,$88,$87,$86 so each dot
// rotates end over end; when the index reaches 4 it advances the 8-entry
// color cycle $489C = {red,orange,yellow,green,blue,lt-blue,cyan,purple}
// (C64 codes, which are this port's palette indices). We reproduce it by
// re-pasting every $84 cell with the current flip-frame tile + color.
// Flip/color advance ($4827 divider + $484D/$4853 index+color). Runs
// once per GAME TICK (called from titleTick), so the flip-book steps
// every 4 game ticks -- the C64's $48A6 mod-4 gate at the 30 Hz main-
// loop rate, frame-rate-independent. Sets logoNeedsPaint when it steps;
// the actual re-paste is deferred to titlePaintLogo in the render pass.
static void titleAdvanceLogo(void) {
gTitle.logoFlipDiv = (uint8_t)((gTitle.logoFlipDiv + 1u) & 3u);
if (gTitle.logoFlipDiv != 0u) {
return;
}
gTitle.logoFlipIdx++;
if (gTitle.logoFlipIdx == 6u) {
gTitle.logoFlipIdx = 0u;
}
if (gTitle.logoFlipIdx == 4u) {
gTitle.logoColorIdx = (uint8_t)((gTitle.logoColorIdx + 1u) & 7u);
}
gTitle.logoNeedsPaint = true;
}
// Re-paste every $84 logo cell with the current flip-frame tile + color
// ($489C palette codes = the port's indices). Render-pass only, and only
// when the flip advanced or the tilemap was just repainted -- between
// steps the logo cells sit static on the tilemap.
static void titlePaintLogo(jlSurfaceT *stage, const StLevelT *level) {
static const uint8_t kFlip[6] = { 1u, 2u, 3u, 4u, 3u, 2u }; // $48A7
static const uint8_t kColor[8] = { 0x02u, 0x08u, 0x07u, 0x05u,
0x06u, 0x0Eu, 0x03u, 0x04u }; // $489C
const jlTileT *tile;
uint8_t ch;
uint8_t fg;
uint8_t bx;
uint8_t by;
size_t i;
if (!gTitle.logoNeedsPaint) {
return;
}
gTitle.logoNeedsPaint = false;
ch = (uint8_t)(ST_LOGO_CHAR + kFlip[gTitle.logoFlipIdx]);
fg = kColor[gTitle.logoColorIdx];
tile = gRender.tileValid[ch] ? &gRender.tiles[ch] : NULL;
if (tile != NULL) {
for (by = 0u; by < ST_PLAYFIELD_ROWS; by++) {
for (bx = 0u; bx < ST_TILEMAP_W; bx++) {
i = (size_t)by * ST_TILEMAP_W + bx;
if (level->tilemap[i] == ST_LOGO_CHAR) {
jlTilePasteMono(stage, bx, by, tile, fg, level->bgColor);
}
}
}
}
}
// $6D0D passenger-walk: toggle $7161 cel parity, compute sign of
// (passenger_X - pad_hover_X), branch to walk-LEFT or walk-RIGHT
// helper. Both load gSpr1PtrShadow from a 2-entry ptr table indexed
// by the cel-parity bit, then advance the column by +/- 2.
// $6D30 LDX $7161 / LDA $6D66,X / STA $7198 (walk RIGHT)
// $6D33: $6D66 = $C2, $6D67 = $C3
// $6D4B LDX $7161 / LDA $6D68,X / STA $7198 (walk LEFT)
// $6D4E: $6D68 = $C4, $6D69 = $C5
// In the title intro the passenger starts at sprite-X 306 and walks
// LEFT toward $28, so the LEFT cel table ($C4 / $C5) is the one in
// use. We track the live ptr in gTitle.passengerPtr so the boarding
// stage can keep incrementing from wherever the walk left off.
static void titleStepPassenger(void) {
gTitle.passengerCelParity ^= 1u;
if (gTitle.passengerSx > (int16_t)ST_TITLE_PAD_HOVER_SX) {
gTitle.passengerSx -= 2;
gTitle.passengerPtr = (gTitle.passengerCelParity & 1u)
? ST_TITLE_PASS_PTR_WALK_HI
: ST_TITLE_PASS_PTR_WALK_LO;
} else if (gTitle.passengerSx < (int16_t)ST_TITLE_PAD_HOVER_SX) {
gTitle.passengerSx += 2;
// Walk-RIGHT path uses $C2/$C3; not used by the title, but
// include it for completeness so any side-entry passenger
// would render correctly.
gTitle.passengerPtr = (gTitle.passengerCelParity & 1u)
? 0xC3
: 0xC2;
}
}
// $4A03 dispatcher. One iteration per host frame, exactly as the C64
// runs $4A03 from $47E4 each iteration of the title intro loop.
static void titleTick(void) {
// Logo flip-book + color cycle advance once per game tick (its own
// mod-4 divider gates the actual step), independent of the intro
// stage machine below.
titleAdvanceLogo();
switch (gTitle.stage) {
case ST_TITLE_STAGE_SPARKLE:
// $4A17: JSR $66B7 / DEC $473F / BEQ -> INC $7163.
// $66B7 logic (per the asm):
// DEC $715D ; gIntroDecayTimer
// BEQ $66BD ; hit-zero -> cycle a cel
// RTS ; else keep current cel
// $66BD: LDA $715E STA $715D ; reload from gIntroDecayReload
// INC $716E ; sparkleIdx
// LDA $716E AND #$03 STA $716E ; mask 0..3
// TAX
// LDA $66D6,X STA $7198 ; passenger ptr = sparkle table
// So the passenger ptr cycles $C6 / $C7 / $D9 / $C7 every reload
// frames during the 90-frame sparkle wait, AND the decay timer
// is left in the middle of its countdown when stage 3 takes
// over -- which is why the walk starts after 0-2 frames, not
// the full 3-frame reload.
if (gTitle.decayTimer > 0u) {
gTitle.decayTimer--;
}
if (gTitle.decayTimer == 0u) {
gTitle.decayTimer = gTitle.decayReload;
gTitle.sparkleIdx = (uint8_t)((gTitle.sparkleIdx + 1u) & 0x03u);
gTitle.passengerPtr = kPassengerWaveCels[gTitle.sparkleIdx];
}
if (gTitle.introFrameCount > 0u) {
gTitle.introFrameCount--;
}
if (gTitle.introFrameCount == 0u) {
gTitle.stage = ST_TITLE_STAGE_WALK;
}
break;
case ST_TITLE_STAGE_WALK:
// $4A24: DEC $715D / BEQ -> reload from $715E + JSR $6D0D /
// then check (passenger col == $28) && ($7186 == 0) -> advance.
if (gTitle.decayTimer > 0u) {
gTitle.decayTimer--;
}
if (gTitle.decayTimer == 0u) {
gTitle.decayTimer = gTitle.decayReload;
titleStepPassenger();
if (gTitle.passengerSx == (int16_t)ST_TITLE_PAD_HOVER_SX) {
gTitle.stage = ST_TITLE_STAGE_HANDOFF;
}
}
break;
case ST_TITLE_STAGE_HANDOFF:
// $4A45: JMP $67A6.
// $67A6: DEC $715D / BEQ -> reload + INC $7198 (passenger
// sprite cel ptr). Advance when ptr == $CC.
if (gTitle.decayTimer > 0u) {
gTitle.decayTimer--;
}
if (gTitle.decayTimer == 0u) {
gTitle.decayTimer = gTitle.decayReload;
gTitle.passengerPtr++;
if (gTitle.passengerPtr >= ST_TITLE_PASS_PTR_BOARDED) {
// $67BD: STA $718F = 0 (pad hover off); INC $7163 to 5.
gTitle.passengerVisible = false;
gTitle.stage = ST_TITLE_STAGE_LIFTOFF;
}
}
break;
case ST_TITLE_STAGE_LIFTOFF:
// $4A48: LDX #0; LDA #$FE; JSR $4113 (gTaxiRow[0] += -2).
// LDA #$01; STA gInputDirMask. LDA #$C0; STA gSpr0Ptr.
// JSR $6D6A (flame sprite update -- sprite 2 visible).
// LDA gTaxiRow[0]; CMP #$14; BCC $4A64.
gTitle.cabSy -= 2;
gTitle.cabPtr = 0xC0;
gTitle.flameDirMask = 0x01; // UP only
gTitle.flameVisible = true;
if (gTitle.cabSy < (int16_t)ST_TITLE_CAB_TAKEOFF_SY) {
// $4A64-$4A6C: INC gDeathStage; silence voice 3.
gTitle.cabVisible = false;
gTitle.flameVisible = false;
// $4A64 INCs gDeathStage out of the intro: on the C64 the
// machine now enters the rolling attract demo. The port
// signals spacetaxi.c via stRenderTitleIntroDone().
gTitle.stage = ST_TITLE_STAGE_DONE;
}
break;
case ST_TITLE_STAGE_DONE:
default:
// Intro finished -- the title art sits static (logo cycle
// continues); spacetaxi.c switches to ST_STATE_DEMO.
break;
}
}
void stRenderFrame(jlSurfaceT *stage, const StGameT *game) {
int16_t px;
int16_t py;
uint8_t taxiCel;
uint8_t i;
char buf[32];
// Title screen: render the title tilemap (extracted from the C64
// game's screen RAM at $0400). The "SPACE TAXI" logo is animated by
// titleAnimateLogo below -- the C64 flip-books char $84's bitmap
// ($4827) so each dot rotates end over end while an 8-color cycle
// ($4861) runs; both were missing before.
if (game->state == ST_STATE_TITLE) {
// Restore the area saved under the prev-frame sprites BEFORE
// anything else paints. Without this, jlSpriteDraw leaves the
// old sprite pixels on the stage and the cab/passenger smear
// across the screen as they move ("5 cabs then erase" was the
// titleCycleTick periodic tilemap re-blit fighting the
// accumulated trails).
// C64 sprite priority: sprite 0 (cab) > 1 (passenger) > 2 (flame).
// Draw order each frame: flame, passenger, cab (lowest priority
// first). Restore is the reverse: cab, passenger, flame -- so
// overlapping saved underlays peel off in the right sequence.
if (gRender.taxiHasBackup) {
jlSpriteRestoreUnder(stage, &gRender.taxiBackup);
gRender.taxiHasBackup = false;
}
if (gRender.passengerHasBackup[0]) {
jlSpriteRestoreUnder(stage, &gRender.passengerBackup[0]);
gRender.passengerHasBackup[0] = false;
}
if (gRender.flameHasBackup) {
jlSpriteRestoreUnder(stage, &gRender.flameBackup);
gRender.flameHasBackup = false;
}
// stRenderLevel only re-paints the tilemap when lastLevel changed
// (e.g., transitioned from gameplay back to title) -- otherwise
// it's a fast no-op.
stRenderLevel(stage, &game->level);
// Paint the "SPACE TAXI" logo (char $84 cells) at its current
// flip frame + color over the freshly-painted tilemap, BEFORE
// the sprites save-under and draw so they overlay it. The flip
// ADVANCE happens on the game-tick clock (titleAdvanceLogo);
// this only re-pastes when it changed or the tilemap repainted.
titlePaintLogo(stage, &game->level);
// No "fares per game" overlay on the title: the C64 has a
// separate options/menu scene driven by $5295 (header text)
// and $52E1 / $533C (the "1 2 3 4" digit row at row 2 col 28
// with the selected digit highlighted in color RAM at $D86C).
// The main title's screen RAM at $0400 contains no game-option
// text -- only "BY JOHN F. BUTCHER" credits and the
// UP=hiscore / DOWN=instructions / FIRE=begin joystick line.
// Options-menu scene is a separate state to be built later.
// The intro state machine (sparkle -> passenger walk -> taxi
// takeoff) is advanced on the fixed game-tick clock in the main
// loop (stRenderTitleAdvance), not here -- this pass only DRAWS
// whichever sprites the current intro state has visible.
// sprite-X -> visible col = sprite-X - 24 (C64 border offset).
// sprite-Y -> visible row = sprite-Y - 50 (top border).
// Draw lowest priority first: flame (sprite 2), then passenger
// (sprite 1), then cab (sprite 0) on top.
if (gTitle.flameVisible && flameStrobeOn() &&
gTitle.flameDirMask < 16u) {
int8_t cel = kFlameCelByDirMask[gTitle.flameDirMask];
if (cel >= 0 && gRender.flameCels[cel] != NULL) {
// $6D74-$6D82: flame sprite-X = cab sprite-X - 2.
// $6D85-$6D88: flame sprite-Y = cab sprite-Y.
int16_t fx = (int16_t)(gTitle.cabSx - 2 - ST_SPRITE_X_OFFSET);
int16_t fy = (int16_t)(gTitle.cabSy - ST_SPRITE_Y_OFFSET);
jlSpriteSaveAndDraw(stage, gRender.flameCels[cel],
fx, fy, &gRender.flameBackup);
gRender.flameHasBackup = true;
}
}
if (gTitle.passengerVisible) {
int16_t cel = passCelForPtr(gTitle.passengerPtr);
if (cel < 0) {
cel = 0;
}
if (cel >= ST_PASSENGER_CEL_COUNT) {
cel = ST_PASSENGER_CEL_COUNT - 1;
}
if (gRender.passengerCels[cel] != NULL) {
jlSpriteSaveAndDraw(stage, gRender.passengerCels[cel],
(int16_t)(gTitle.passengerSx - ST_SPRITE_X_OFFSET),
(int16_t)(gTitle.passengerSy - ST_SPRITE_Y_OFFSET),
&gRender.passengerBackup[0]);
gRender.passengerHasBackup[0] = true;
}
}
if (gTitle.cabVisible) {
// $4A54 sets gSpr0PtrShadow = $C0 (cab with landing gear
// RETRACTED) during takeoff. Stages 2-4 use the init ptr
// $C1 (gear extended). We track the live ptr in
// gTitle.cabPtr and map: $C1 -> cel 0, $C0 -> cel 1.
int16_t cel = (gTitle.cabPtr == 0xC0) ? 1 : 0;
if (gRender.taxiCels[cel] == NULL) {
cel = 0;
}
if (gRender.taxiCels[cel] != NULL) {
jlSpriteSaveAndDraw(stage, gRender.taxiCels[cel],
(int16_t)(gTitle.cabSx - ST_SPRITE_X_OFFSET),
(int16_t)(gTitle.cabSy - ST_SPRITE_Y_OFFSET),
&gRender.taxiBackup);
gRender.taxiHasBackup = true;
}
}
jlWaitVBL();
jlStagePresent();
return;
}
if (game->state == ST_STATE_HIGHSCORES) {
// "THE IMMORTAL CABBIES" high-score screen ($4C1F). Header +
// the game's default 8-entry table, transcribed from $4A89
// (score string + 15-char name). Persistent scoring isn't wired
// up, so we show the original default table.
static const char *kHighScores[8] = {
"3877.56 MICHAEL PLATE",
"1809.51 MICHAEL PLATE",
"1179.87 ANDREAS PLATE",
" 892.65 MICHAEL PLATE",
" 685.37 ANDREAS PLATE",
" 629.45 MICHAEL PLATE",
" 569.50 MICHAEL PLATE",
" 504.97 ANDREAS PLATE",
};
uint8_t i;
jlSurfaceClear(stage, 0u);
stRenderDrawText(stage, 10u, 1u, "THE IMMORTAL CABBIES");
for (i = 0u; i < 8u; i++) {
stRenderDrawText(stage, 9u, (uint8_t)(4u + i * 2u), kHighScores[i]);
}
stRenderDrawText(stage, 10u, 22u, "PRESS FIRE TO RETURN");
jlWaitVBL();
jlStagePresent();
return;
}
if (game->state == ST_STATE_INSTRUCTIONS) {
// Author/about screen ($556A, reached via DOWN). Text transcribed
// verbatim from $56D4-$57A6.
jlSurfaceClear(stage, 0u);
stRenderDrawText(stage, 1u, 3u, "THIS PROGRAM DEVELOPED AND WRITTEN BY");
stRenderDrawText(stage, 12u, 5u, "JOHN F. KUTCHER");
stRenderDrawText(stage, 15u, 7u, "11/21/65");
stRenderDrawText(stage, 4u, 10u, "CURRENTLY, AS OF JANUARY 1984,");
stRenderDrawText(stage, 5u, 12u, "HE IS ATTENDING JOHNS HOPKINS");
stRenderDrawText(stage, 6u, 14u, "UNIVERSITY IN BALTIMORE, MD");
stRenderDrawText(stage, 1u, 18u, "ALSO TRY RESCUE SQUAD BY JOHN KUTCHER");
stRenderDrawText(stage, 10u, 22u, "PRESS FIRE TO RETURN");
jlWaitVBL();
jlStagePresent();
return;
}
if (game->state == ST_STATE_OPTIONS) {
// "GAME VARIATIONS" menu ($5295). Text + positions transcribed
// from the C64: header (13,0), prompt (1,2), digits (28,2),
// instructions (5,4) and (19,5). The C64 recolors the selected
// digit via color RAM ($D86C + sel*2); we mark it with a
// highlight box behind the digit cell (row 2, col 28 + sel*2).
uint8_t sel = (uint8_t)((game->fareTarget - 1u) & 3u); // 0..3
int16_t hx = (int16_t)((28 + (int)sel * 2) * (int)ST_TILE_PIXELS);
jlSurfaceClear(stage, 0u);
jlFillRect(stage, hx, (int16_t)(2 * ST_TILE_PIXELS),
(int16_t)ST_TILE_PIXELS, (int16_t)ST_TILE_PIXELS, 6u);
stRenderDrawText(stage, 13u, 0u, "GAME VARIATIONS");
stRenderDrawText(stage, 1u, 2u, "SELECT NUMBER OF CABBIES:");
stRenderDrawText(stage, 28u, 2u, "1 2 3 4");
stRenderDrawText(stage, 5u, 4u, "USE JOYSTICK: LEFT OR RIGHT,");
stRenderDrawText(stage, 19u, 5u, "FIRE TO SELECT");
jlWaitVBL();
jlStagePresent();
return;
}
if (game->state == ST_STATE_GAME_OVER) {
jlSurfaceClear(stage, 0u);
stRenderDrawText(stage, 15u, 8u, "GAME OVER");
snprintf(buf, sizeof(buf), "FINAL SCORE %06lu",
(unsigned long)game->score);
stRenderDrawText(stage, 12u, 11u, buf);
stRenderDrawText(stage, 9u, 16u, "PRESS SPACE TO RESTART");
jlWaitVBL();
jlStagePresent();
return;
}
// Restore prev-frame sprite backups FIRST so the static tilemap
// shows through where the taxi/passenger/flame used to be. Then
// we'll save+draw at the new positions below. LIFO order: the cab
// was saved AFTER the flame (its backup holds flame pixels), so
// the cab restores first and the flame restore then cleans the
// re-deposited flame pixels.
if (gRender.taxiHasBackup) {
jlSpriteRestoreUnder(stage, &gRender.taxiBackup);
gRender.taxiHasBackup = false;
}
if (gRender.flameHasBackup) {
jlSpriteRestoreUnder(stage, &gRender.flameBackup);
gRender.flameHasBackup = false;
}
for (i = 0u; i < ST_MAX_PASSENGERS; i++) {
if (gRender.passengerHasBackup[i]) {
jlSpriteRestoreUnder(stage, &gRender.passengerBackup[i]);
gRender.passengerHasBackup[i] = false;
}
}
// Static tilemap commit (no-op after first frame in a scene).
stRenderLevel(stage, &game->level);
// Re-draw HUD strip (cheap; just a few characters per cycle).
stHudDraw(stage, game);
px = (int16_t)(game->taxi.x >> ST_SUBPIXEL_SHIFT);
py = (int16_t)(game->taxi.y >> ST_SUBPIXEL_SHIFT);
// $619B cel select: facing picks the $C0/$C1 (right) or $DC/$DD
// (left) pair; bit 0 is the LANDING GEAR state. The body is a
// STATIC cel -- no flicker of any kind. Sheet order
// [$C1,$C0,$DC,$DD]:
// right: ptr = $C0|gear -> cel 1 - gear
// left: ptr = $DC|gear -> cel 2 + gear
// (The crash anim uses the dedicated death cels below.)
if (game->taxi.facing == ST_DIR_LEFT) {
taxiCel = (uint8_t)(game->taxi.gearDown ? 3u : 2u);
} else {
taxiCel = (uint8_t)(game->taxi.gearDown ? 0u : 1u);
}
if (gRender.taxiCels[taxiCel] == NULL) {
taxiCel = 0u;
}
// Engine flame: C64 sprite 2 ($6D6A) at (cab_x - 2, cab_y),
// cel indexed by the $716A direction mask through the $6DB0
// table, drawn on alternate frames only (the parity flicker),
// hidden when no input is held. Drawn BEFORE the cab so the cab
// (sprite 0) keeps VIC priority on top.
if (game->taxi.warpFrame == 0u && game->taxi.thrusting &&
!game->taxi.landed && flameStrobeOn() &&
game->taxi.dirMask < 16u) {
int8_t fcel = kFlameCelByDirMask[game->taxi.dirMask];
if (fcel >= 0 && gRender.flameCels[fcel] != NULL) {
jlSpriteSaveAndDraw(stage, gRender.flameCels[fcel],
(int16_t)(px - 2), py,
&gRender.flameBackup);
gRender.flameHasBackup = true;
}
}
if (game->taxi.crashTicks > 0u) {
// Crash death: phase 1 tumbles the $CC/$CD debris pair while
// falling; the floor hit ($6ACC row $DA) starts the $CE..$D1
// impact walk at the slowing $6B2A cadence, then the wreck
// hides until respawn.
uint32_t nowMs = jlMillisElapsed();
int16_t dcel = -1;
if (!gRender.deathActive) {
gRender.deathActive = true;
gRender.deathMs = nowMs;
gRender.deathStep = 0u;
}
if (!game->taxi.crashImpacted) {
dcel = (int16_t)((nowMs / ST_DEATH_TUMBLE_MS) & 1u);
gRender.deathMs = nowMs; // re-anchor for the walk
gRender.deathStep = 0u;
} else {
if (gRender.deathStep < 4u &&
nowMs - gRender.deathMs >= kDeathStepMs[gRender.deathStep]) {
gRender.deathMs = nowMs;
gRender.deathStep++;
}
if (gRender.deathStep < 4u) {
dcel = (int16_t)(2u + gRender.deathStep);
}
}
if (dcel >= 0 && gRender.deathCels[dcel] != NULL) {
jlSpriteSaveAndDraw(stage, gRender.deathCels[dcel], px, py,
&gRender.taxiBackup);
gRender.taxiHasBackup = true;
}
} else if (game->taxi.warpFrame > 0u) {
// Transporter shrink-warp: identity map onto the SEVEN drawn
// chain cels $E2..$E8; step 7 (pointer reaching $E9) hides
// the sprite entirely, exactly like $5CDA/$718E.
uint8_t step = stEngineWarpStep(game); /* 0..7 */
if (step < ST_WARP_CEL_COUNT && gRender.warpCels[step] != NULL) {
jlSpriteSaveAndDraw(stage, gRender.warpCels[step], px, py,
&gRender.taxiBackup);
gRender.taxiHasBackup = true;
}
} else if (gRender.taxiCels[taxiCel] != NULL) {
// Save-under + draw. Backup is replayed at the start of next
// frame above to undraw cleanly.
gRender.deathActive = false;
jlSpriteSaveAndDraw(stage, gRender.taxiCels[taxiCel], px, py,
&gRender.taxiBackup);
gRender.taxiHasBackup = true;
} else {
// No sprite asset: fall back to a placeholder rect AND mark
// the tilemap dirty so the level repaints over us next frame.
// Use the level's per-level sprite0Color ($D027) so the cab
// tint matches the level palette.
jlFillRect(stage, px, py, ST_TAXI_W_PX, ST_TAXI_H_PX,
game->level.sprite0Color);
gRender.tilemapDirty = true;
if (game->taxi.thrusting) {
jlFillRect(stage,
(int16_t)(px + ST_FLAME_OFFSET_X_PX),
(int16_t)(py + ST_FLAME_OFFSET_Y_PX),
ST_FLAME_W_PX,
ST_FLAME_H_PX,
game->level.sprite1Color);
}
}
// Passengers (waiting or being carried)
for (i = 0u; i < ST_MAX_PASSENGERS; i++) {
const StPassengerT *p = &game->passengers[i];
jlSpriteT *cel;
int16_t pcel;
if (!p->active || p->phase == ST_PASS_RIDING) {
continue; // riding passengers are invisible in the cab
}
// Cel by lifecycle phase (see StPassPhaseE): beams shrink or
// grow through $C7..$CB, the wait wave cycles $66D6, walks
// alternate the direction's stride pair.
switch (p->phase) {
case ST_PASS_BEAM_IN:
case ST_PASS_DROP_IN:
pcel = (int16_t)(7 - (p->waitPhase > 4u ? 4u : p->waitPhase));
break;
case ST_PASS_BOARD_OUT:
case ST_PASS_DROP_OUT:
pcel = (int16_t)(3 + (p->waitPhase > 4u ? 4u : p->waitPhase));
break;
case ST_PASS_WALK_TO_CAB:
case ST_PASS_WALK_TO_PAD:
if (p->targetX < p->x) {
pcel = (int16_t)((p->waitPhase & 1u) ? ST_PASSENGER_CEL_WALK1
: ST_PASSENGER_CEL_WALK0);
} else {
pcel = (int16_t)((p->waitPhase & 1u) ? ST_PASSENGER_CEL_WALKR1
: ST_PASSENGER_CEL_WALKR0);
}
break;
case ST_PASS_WAIT:
default:
pcel = passCelForPtr(kPassengerWaveCels[p->waitPhase & 3u]);
break;
}
cel = gRender.passengerCels[pcel];
if (cel == NULL) {
jlFillRect(stage, p->x, p->y,
ST_PASSENGER_W_PX, ST_PASSENGER_H_PX, 8u);
gRender.tilemapDirty = true;
continue;
}
jlSpriteSaveAndDraw(stage, cel, p->x, p->y,
&gRender.passengerBackup[i]);
gRender.passengerHasBackup[i] = true;
}
if (game->state == ST_STATE_DEMO) {
// Attract banners ($45A7-$4614 text): drawn every frame over
// the live demo, before the present.
stRenderDrawText(stage, 7u, 3u, "DEMO, USE JOYSTICK TO EXIT");
stRenderDrawText(stage, 3u, 24u, "THIS IS 1 OF 25 DIFFERENT SCREENS!");
}
if (game->state == ST_STATE_LEVEL_DONE) {
int16_t midY = (int16_t)(10 * ST_TILE_PIXELS);
jlFillRect(stage, 0, midY, SURFACE_WIDTH,
(int16_t)(2 * ST_TILE_PIXELS), 0u);
stRenderDrawText(stage, 13u, 10u, "LEVEL COMPLETE");
}
jlWaitVBL();
jlStagePresent();
}
// ----- internal helpers -----
static bool loadTileBank(uint8_t bankId) {
uint16_t idx;
uint16_t loaded;
char path[64];
snprintf(path, sizeof(path), ST_TILE_BANK_PATH_FMT, (unsigned)bankId);
jlLogF("stRender: loadTileBank(%u) -> %s", (unsigned)bankId, path);
// Reset the previous bank's validity bits so a smaller new bank
// doesn't inherit stale tiles past its end.
for (idx = 0u; idx < ST_TILE_BANK_MAX; idx++) {
gRender.tileValid[idx] = false;
}
gRender.bankLoaded = false;
gRender.currentBankId = bankId;
// Native bake: jlTileBankLoad fread's per-target planar tile
// bytes straight into gRender.tiles[].pixels with no chunky <->
// planar conversion. Replaces the JAS-load + jlSurfaceCreate +
// jlSurfaceBlit + per-tile jlTileSnap path, which was the
// dominant startup cost.
loaded = jlTileBankLoad(path, gRender.tiles, ST_TILE_BANK_MAX,
gRender.tileValid, NULL);
if (loaded == 0u) {
jlLogF("stRender: ! tile bank load failed (%s)", path);
return false;
}
jlLogF("stRender: tile bank loaded (%u tiles)", (unsigned)loaded);
gRender.bankLoaded = true;
return true;
}
static bool loadSpriteSheet(jlSurfaceT *stage) {
jlSpriteT *cels[ST_SPRITE_SHEET_CELS];
uint16_t count;
uint16_t i;
uint8_t step;
bool precompiled;
// .spr blob carries all 36 cels (9 cols x 4 rows of 3x3-tile
// chunky 4bpp blobs) in PNG reading order: row 0 taxi, row 1
// passenger, row 2 flame, row 3 warp. The padding slots between
// named sprites are loaded but never referenced; they leak a few
// KB at startup which is well below the cost of writing a
// free-loop here (extra code in _ROOT eats the IIgs cluster
// budget more than the heap fragments hurt).
memset(cels, 0, sizeof(cels));
// Prefer the pre-compiled bank: its cels arrive already compiled (native
// routines dropped straight into the codegen arena), so the jlSpriteCompile
// loop below is a no-op fast path. Fall back to the portable .spr + runtime
// JIT if no .spc is staged for this build.
count = jlSpriteBankLoadPrecompiled(ST_SPRITE_SHEET_SPC, cels, ST_SPRITE_SHEET_CELS, NULL);
precompiled = (count != 0u);
if (count == 0u) {
count = jlSpriteBankLoad(ST_SPRITE_SHEET_PATH, cels, ST_SPRITE_SHEET_CELS, NULL);
}
if (count == 0u) {
return false;
}
jlLogF("stRender: sprite sheet loaded (%u cels, %s)", (unsigned)count,
precompiled ? "PRECOMPILED" : "jit");
loadProgress(stage, 2u);
// Compile every drawn cel to its per-shift asm routine. Without
// this, jlSprite{Draw,SaveUnder,SaveAndDraw} fall to the per-pixel
// interpreter (sp->slot stays NULL) -- catastrophic on the IIgs
// 65816: the 3 title sprites alone cost ~200 ms/frame interpreted
// (~3.7 fps). Compiling routes them to the fast path (UBER's
// benchmarks prove codegen works on every port). jlSpriteCompile is
// a no-op fallback if the arena is exhausted (cel stays interpreted).
{
uint16_t compiled = 0u;
// Assign all cels first, then compile title-critical ones
// (taxi, passenger, flame) before the gameplay-only warp cels so
// a tight arena still fast-paths the title.
for (i = 0u; i < ST_TAXI_CEL_COUNT; i++) {
gRender.taxiCels[i] = cels[ST_SPRITE_TAXI_FIRST + i];
}
for (i = 0u; i < ST_WARP_CEL_COUNT; i++) {
gRender.warpCels[i] = cels[ST_SPRITE_WARP_FIRST + i];
}
for (i = 0u; i < ST_DEATH_CEL_COUNT; i++) {
gRender.deathCels[i] = cels[ST_SPRITE_DEATH_FIRST + i];
}
for (i = 0u; i < ST_PASSENGER_CEL_COUNT; i++) {
gRender.passengerCels[i] = cels[ST_SPRITE_PASS_FIRST + i];
}
for (i = 0u; i < ST_FLAME_CEL_COUNT; i++) {
gRender.flameCels[i] = cels[ST_SPRITE_FLAME_FIRST + i];
}
step = 3u;
for (i = 0u; i < ST_TAXI_CEL_COUNT; i++) {
compiled = (uint16_t)(compiled + (jlSpriteCompile(gRender.taxiCels[i]) ? 1u : 0u));
loadProgress(stage, step++);
}
for (i = 0u; i < ST_PASSENGER_CEL_COUNT; i++) {
compiled = (uint16_t)(compiled + (jlSpriteCompile(gRender.passengerCels[i]) ? 1u : 0u));
loadProgress(stage, step++);
}
for (i = 0u; i < ST_FLAME_CEL_COUNT; i++) {
compiled = (uint16_t)(compiled + (jlSpriteCompile(gRender.flameCels[i]) ? 1u : 0u));
loadProgress(stage, step++);
}
for (i = 0u; i < ST_WARP_CEL_COUNT; i++) {
compiled = (uint16_t)(compiled + (jlSpriteCompile(gRender.warpCels[i]) ? 1u : 0u));
loadProgress(stage, step++);
}
for (i = 0u; i < ST_DEATH_CEL_COUNT; i++) {
compiled = (uint16_t)(compiled + (jlSpriteCompile(gRender.deathCels[i]) ? 1u : 0u));
loadProgress(stage, step++);
}
jlLogF("stRender: sprite cels compiled: %u/%u", (unsigned)compiled,
(unsigned)(ST_TAXI_CEL_COUNT + ST_PASSENGER_CEL_COUNT + ST_FLAME_CEL_COUNT + ST_WARP_CEL_COUNT + ST_DEATH_CEL_COUNT));
}
// First-run cache: having just JIT-compiled the bank, write it out as a
// .spc so the next launch loads the compiled routines and skips the JIT
// (ship the small .spr, cache the big per-platform compiled bank). Best-
// effort -- a read-only/write-protected disk just means we JIT again.
if (!precompiled) {
if (jlSpriteBankSavePrecompiled(ST_SPRITE_SHEET_SPC, cels, count, NULL)) {
jlLogF("stRender: cached compiled bank -> %s", ST_SPRITE_SHEET_SPC);
}
}
return true;
}
static void destroySprites(void) {
uint8_t i;
for (i = 0u; i < ST_TAXI_CEL_COUNT; i++) {
if (gRender.taxiCels[i] != NULL) {
jlSpriteDestroy(gRender.taxiCels[i]);
gRender.taxiCels[i] = NULL;
}
}
for (i = 0u; i < ST_DEATH_CEL_COUNT; i++) {
if (gRender.deathCels[i] != NULL) {
jlSpriteDestroy(gRender.deathCels[i]);
gRender.deathCels[i] = NULL;
}
}
for (i = 0u; i < ST_WARP_CEL_COUNT; i++) {
if (gRender.warpCels[i] != NULL) {
jlSpriteDestroy(gRender.warpCels[i]);
gRender.warpCels[i] = NULL;
}
}
for (i = 0u; i < ST_PASSENGER_CEL_COUNT; i++) {
if (gRender.passengerCels[i] != NULL) {
jlSpriteDestroy(gRender.passengerCels[i]);
gRender.passengerCels[i] = NULL;
}
}
}
// The 1000-glyph font streams straight onto the font surface via
// jlTileBankLoadToSurface -- no 32KB staging buffer. The old
// malloc(32000) was lethal on IIgs (the clang libc heap is ~665
// bytes and malloc returns 1, not NULL, at exhaustion -- LLVM816-ASKS
// item 4 -- so jlTileBankLoad fread the payload through pointer 1 and
// shredded bank 0 before the first present), and a 32KB static blows
// the bank-0 BSS ceiling. The streaming loader exists for exactly
// this case; its block grid matches ST_FONT_COLS row-major layout.
static bool loadFontSheet(jlSurfaceT *stage) {
uint16_t count;
uint16_t palette[16];
(void)stage;
gRender.fontSurface = jlSurfaceCreate();
if (gRender.fontSurface == NULL) {
return false;
}
count = jlTileBankLoadToSurface(ST_FONT_PATH, gRender.fontSurface, palette);
if (count == 0u) {
jlSurfaceDestroy(gRender.fontSurface);
gRender.fontSurface = NULL;
return false;
}
// Font palette is authoritative for the font surface so jlDrawText
// reads back the authored colors. Stage palette is untouched.
jlPaletteSet(gRender.fontSurface, 0u, palette);
jlScbSetRange(gRender.fontSurface, 0, SURFACE_HEIGHT - 1, 0);
gRender.fontReady = true;
return true;
}
// The C64 flame strobe ($716C: one game tick on, one off) mapped to
// wall-clock so every port shows the intended LOOK: at >=50fps this
// is the authentic 12.5Hz shimmer; when a rendered frame spans a
// whole strobe phase (low fps) the flame draws every frame -- the
// CRT-fusion appearance instead of an unreadable slow blink.
static bool flameStrobeOn(void) {
uint32_t nowMs = jlMillisElapsed();
bool phase = ((nowMs / ST_FLAME_STROBE_MS) & 1u) != 0u;
bool spans = (nowMs - gRender.flamePrevMs) >= ST_FLAME_STROBE_MS;
gRender.flamePrevMs = nowMs;
return phase || spans;
}
// Map a live C64 sprite-1 pointer value onto the sheet's passenger
// row (extractSprites.py pass_ptrs order):
// $C4..$CB -> cels 0..7 (walk cels, boarding shrink)
// $D9 -> cel 8 (the wave/sparkle cel)
// Single source of truth for the title path and the gameplay wave.
static int16_t passCelForPtr(uint8_t ptr) {
if (ptr == 0xD9u) {
return ST_PASSENGER_CEL_SPARKLE;
}
if (ptr == 0xC2u) {
return ST_PASSENGER_CEL_WALKR0;
}
if (ptr == 0xC3u) {
return ST_PASSENGER_CEL_WALKR1;
}
return (int16_t)ptr - 0xC4;
}
// Startup progress: outline drawn on step 0 so the screen shows life
// the moment stRenderInit runs, bar grows per completed step, LOADING
// caption appears once the font glyphs exist. Cheap enough to call
// per sprite compile even on the IIgs (present base ~3 ms).
static void loadProgress(jlSurfaceT *stage, uint8_t step) {
int16_t w;
if (step > (uint8_t)ST_LOAD_STEPS_TOTAL) {
step = (uint8_t)ST_LOAD_STEPS_TOTAL;
}
if (step == 0u) {
jlFillRect(stage, ST_LOAD_BAR_X - 2, ST_LOAD_BAR_Y - 2,
(uint16_t)(SURFACE_WIDTH - 2 * ST_LOAD_BAR_X + 4),
ST_LOAD_BAR_H + 4, ST_LOAD_BAR_FRAME_COLOR);
jlFillRect(stage, ST_LOAD_BAR_X - 1, ST_LOAD_BAR_Y - 1,
(uint16_t)(SURFACE_WIDTH - 2 * ST_LOAD_BAR_X + 2),
ST_LOAD_BAR_H + 2, 0u);
}
w = (int16_t)(((int32_t)step * (SURFACE_WIDTH - 2 * ST_LOAD_BAR_X)) / ST_LOAD_STEPS_TOTAL);
if (w > 0) {
jlFillRect(stage, ST_LOAD_BAR_X, ST_LOAD_BAR_Y, (uint16_t)w,
ST_LOAD_BAR_H, ST_LOAD_BAR_COLOR);
}
if (gRender.fontReady) {
stRenderDrawText(stage, 16u, 11u, "LOADING");
}
jlStagePresent();
}
// Build the ASCII -> (blockX | blockY << 8) lookup table used by
// jlDrawText. The font sheet was authored with each ASCII glyph at
// cell (ascii % 40, ascii / 40) (see assets/genPlaceholderArt.py),
// so the map is a direct computation. Control characters and DEL
// (0..31, 127) are marked TILE_NO_GLYPH so jlDrawText skips them.
static void buildAsciiMap(void) {
uint16_t i;
for (i = 0u; i < 128u; i++) {
if (i < 32u || i == 127u) {
gRender.asciiMap[i] = TILE_NO_GLYPH;
} else {
uint16_t col = (uint16_t)(i % ST_FONT_COLS);
uint16_t row = (uint16_t)(i / ST_FONT_COLS);
gRender.asciiMap[i] = (uint16_t)(col | (row << 8));
}
}
}
Reference in a new issue View git blame Copy permalink