195 lines
8.7 KiB
C
195 lines
8.7 KiB
C
// recorder -- search for a demo input stream that exercises a level.
|
|
//
|
|
// The C64 ships attract recordings for four screens (H, W, T, X). The
|
|
// other levels have none, so a refactor of their hooks had nothing to be
|
|
// checked against. This searches for a synthetic ride instead: random
|
|
// restarts plus hill climbing over (joystick mask, duration) pairs,
|
|
// scored on how long the cab survives and how much of the level it
|
|
// reaches -- hook state bytes written, fare-machine stages entered,
|
|
// distinct pictures drawn, pads landed on.
|
|
//
|
|
// The result is a REGRESSION fixture, not a recording: it pins current
|
|
// behaviour so a refactor that changes nothing observable leaves the
|
|
// trace identical. It says nothing about matching the real C64.
|
|
//
|
|
// Usage: recorder <level.dat> <letter> <seed> > stream.h
|
|
// Then assemble the per-level outputs into gateStreams.h.
|
|
//
|
|
// Determinism: a candidate is only useful if it replays identically from
|
|
// a cold start, so every evaluation clears the whole StSimT (see the note
|
|
// in evaluate) -- stSimNewGame deliberately preserves some cross-screen
|
|
// state, which would otherwise leak between candidates.
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "stSim.h"
|
|
#include "stDemoStreams.h"
|
|
|
|
static StLevelT gLevel;
|
|
static StSimT gSim;
|
|
|
|
void stAudioSfx(const uint8_t *p){(void)p;}
|
|
void stAudioNoise(bool o){(void)o;}
|
|
void stAudioThrustSweep(uint8_t v){(void)v;}
|
|
void stAudioSpeech(uint8_t c){(void)c;}
|
|
void stAudioSpeechPhrase(const uint8_t *s){(void)s;}
|
|
void stAudioSilence(void){}
|
|
void stAudioVoice2(uint8_t a,uint8_t b,uint8_t c){(void)a;(void)b;(void)c;}
|
|
void stAudioVoice1Freq(uint8_t v){(void)v;}
|
|
|
|
#define PAIRS 160
|
|
#define STREAMLEN (PAIRS * 2)
|
|
#define MAXTICKS 1400
|
|
|
|
typedef struct { uint32_t score; uint32_t ticks; uint32_t cover; uint32_t lands; uint32_t stages; uint32_t scr; uint32_t near; } ResT;
|
|
|
|
static uint32_t rs = 1;
|
|
static uint32_t rnd(void){ rs = rs*1664525u + 1013904223u; return rs>>8; }
|
|
|
|
static ResT evaluate(const uint8_t *stream, uint8_t *touchOut)
|
|
{
|
|
uint8_t touched[sizeof(StHookScratchT)];
|
|
uint8_t base[sizeof(StHookScratchT)];
|
|
uint8_t stageSeen[16];
|
|
uint32_t t, cover = 0, lands = 0, stages = 0, scrSeen = 0;
|
|
uint32_t nearest = 255u;
|
|
uint32_t scrHash[256];
|
|
uint8_t lastPad = 0;
|
|
ResT r;
|
|
|
|
memset(stageSeen, 0, sizeof(stageSeen));
|
|
memset(touched, 0, sizeof(touched));
|
|
// stSimNewGame deliberately PRESERVES flameParity, waveIdx and
|
|
// walkParity (the C64 carries them from screen to screen), so a
|
|
// search that reuses one StSimT would score each candidate against
|
|
// whatever the previous ride left behind -- and the winning stream
|
|
// would then not reproduce from a cold start. Clear the whole struct
|
|
// so every evaluation begins exactly where the gate will.
|
|
memset(&gSim, 0, sizeof(gSim));
|
|
stSimNewGame(&gSim, 1u, true);
|
|
stSimSeedDemoBuffer(&gSim, kDemoBufferInit, ST_DEMO_BUFFER_BYTES);
|
|
stSimEnterLevel(&gSim, &gLevel);
|
|
stSimSetDemoStream(&gSim, stream, STREAMLEN);
|
|
memcpy(base, &gSim.hookScratch, sizeof(base));
|
|
for (t = 0; t < MAXTICKS; t++) {
|
|
uint16_t k;
|
|
if (stSimTick(&gSim) != ST_TICK_CONTINUE) { break; }
|
|
{ const uint8_t *cur = (const uint8_t *)&gSim.hookScratch;
|
|
for (k = 0; k < (uint16_t)sizeof(base); k++) {
|
|
if (cur[k] != base[k]) { touched[k] = 1; } } }
|
|
if (gSim.activePad != 0u && lastPad == 0u) { lands++; }
|
|
lastPad = gSim.activePad;
|
|
if (gSim.stage < 16u) { stageSeen[gSim.stage] = 1u; }
|
|
/* Shaping: how close the ride came to an actual touchdown. Some
|
|
levels (R) only run their hook once a passenger has boarded,
|
|
which needs a landing, and a landing is far too precise for a
|
|
blind search to stumble on -- so reward getting near one. */
|
|
if (gSim.activePad == 0u && (gSim.spr[0].ptr & 1u) != 0u) {
|
|
int16_t tx = (int16_t)(((uint16_t)gSim.posXmsb << 8) | gSim.posXcol);
|
|
uint8_t pi;
|
|
for (pi = 0u; pi < gLevel.padCount && pi < ST_MAX_PADS; pi++) {
|
|
int16_t x1 = (int16_t)(((uint16_t)gSim.pads[pi].x1Hi << 8) | gSim.pads[pi].x1Lo);
|
|
int16_t x2 = (int16_t)(((uint16_t)gSim.pads[pi].x2Hi << 8) | gSim.pads[pi].x2Lo);
|
|
int16_t dr = (int16_t)((int16_t)gSim.spr[0].row - (int16_t)gSim.pads[pi].row);
|
|
uint32_t ar = (uint32_t)(dr < 0 ? -dr : dr);
|
|
uint32_t ax = 0u;
|
|
uint32_t d;
|
|
if (tx < x1) { ax = (uint32_t)(x1 - tx); }
|
|
else if (tx > x2) { ax = (uint32_t)(tx - x2); }
|
|
/* Both axes matter: the row alone is easy to hit while
|
|
the cab sits at the far side of the screen. */
|
|
d = ar * 4u + ax;
|
|
if (d < nearest) { nearest = d; }
|
|
}
|
|
}
|
|
/* distinct pictures the hook has produced (screen + colour) */
|
|
{ uint32_t h = 2166136261u; uint16_t c; uint32_t i2; int dup = 0;
|
|
for (c = 0; c < ST_SCREEN_CELLS; c++) { h = (h ^ gSim.screen[c]) * 16777619u; }
|
|
for (c = 0; c < ST_SCREEN_CELLS; c++) { h = (h ^ gSim.color[c]) * 16777619u; }
|
|
for (i2 = 0; i2 < scrSeen; i2++) { if (scrHash[i2] == h) { dup = 1; break; } }
|
|
if (!dup && scrSeen < 256u) { scrHash[scrSeen++] = h; } }
|
|
}
|
|
{ uint16_t k; for (k = 0; k < (uint16_t)sizeof(touched); k++) { if (touched[k]) { cover++; } } }
|
|
{ int k; for (k = 0; k < 16; k++) { if (stageSeen[k]) { stages++; } } }
|
|
if (touchOut) { memcpy(touchOut, touched, sizeof(touched)); }
|
|
r.ticks = t; r.cover = cover; r.lands = lands; r.stages = stages; r.scr = scrSeen;
|
|
r.near = nearest;
|
|
r.score = cover * 30000u + stages * 30000u + lands * 4000u + t * 100u + scrSeen * 200u
|
|
+ (255u - nearest) * 60u;
|
|
return r;
|
|
}
|
|
|
|
static void randomise(uint8_t *s, int from)
|
|
{
|
|
int i;
|
|
for (i = from; i < PAIRS; i++) {
|
|
uint32_t d = rnd() % 100u;
|
|
uint8_t m = 0x80u;
|
|
if (d < 45u) { m |= 0x01u; } /* thrust up a lot */
|
|
else if (d < 60u) { m |= 0x04u; }
|
|
else if (d < 75u) { m |= 0x08u; }
|
|
else if (d < 82u) { m |= 0x02u; }
|
|
else if (d < 88u) { m |= 0x10u; }
|
|
if (rnd() % 5u == 0u) { m |= (uint8_t)(1u << (rnd() % 4u)); }
|
|
s[i*2] = m;
|
|
s[i*2 + 1] = (uint8_t)(1u + rnd() % 14u);
|
|
}
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
uint8_t best[STREAMLEN], cur[STREAMLEN], touched[ST_HOOK_BYTES];
|
|
ResT bestR, curR;
|
|
FILE *fp;
|
|
int restart, iter;
|
|
|
|
if (argc < 4) { fprintf(stderr, "usage: recorder <level.dat> <name> <seed>\n"); return 2; }
|
|
fp = fopen(argv[1], "rb");
|
|
if (!fp || !stLevelParse(&gLevel, fp)) { fprintf(stderr, "cannot load %s\n", argv[1]); return 1; }
|
|
fclose(fp);
|
|
rs = (uint32_t)strtoul(argv[3], NULL, 0);
|
|
|
|
randomise(best, 0);
|
|
bestR = evaluate(best, NULL);
|
|
for (restart = 0; restart < 120; restart++) {
|
|
memcpy(cur, best, STREAMLEN);
|
|
if (restart > 0) { randomise(cur, (int)(rnd() % PAIRS)); }
|
|
curR = evaluate(cur, NULL);
|
|
for (iter = 0; iter < 3000; iter++) {
|
|
uint8_t trial[STREAMLEN];
|
|
ResT tr;
|
|
int j, nmut = 1 + (int)(rnd() % 3u);
|
|
memcpy(trial, cur, STREAMLEN);
|
|
for (j = 0; j < nmut; j++) {
|
|
int i = (int)(rnd() % PAIRS);
|
|
if (rnd() % 2u) {
|
|
uint8_t m = 0x80u;
|
|
uint32_t d = rnd() % 100u;
|
|
if (d < 45u) { m |= 0x01u; }
|
|
else if (d < 62u) { m |= 0x04u; }
|
|
else if (d < 79u) { m |= 0x08u; }
|
|
else if (d < 88u) { m |= 0x02u; }
|
|
else { m |= 0x10u; }
|
|
trial[i*2] = m;
|
|
} else {
|
|
trial[i*2 + 1] = (uint8_t)(1u + rnd() % 14u);
|
|
}
|
|
}
|
|
tr = evaluate(trial, NULL);
|
|
if (tr.score >= curR.score) { memcpy(cur, trial, STREAMLEN); curR = tr; }
|
|
}
|
|
if (curR.score > bestR.score) { memcpy(best, cur, STREAMLEN); bestR = curR; }
|
|
}
|
|
bestR = evaluate(best, touched);
|
|
fprintf(stderr, "%s: ticks=%u hookBytes=%u stages=%u pictures=%u lands=%u nearPad=%u\n",
|
|
argv[2], bestR.ticks, bestR.cover, bestR.stages, bestR.scr, bestR.lands, bestR.near);
|
|
printf("// %s: %u ticks, %u hook bytes, %u fare stages, %u pictures, %u landings\n",
|
|
argv[2], bestR.ticks, bestR.cover, bestR.stages, bestR.scr, bestR.lands);
|
|
printf("static const uint8_t kGateStream%s[%d] = {", argv[2], STREAMLEN);
|
|
{ int i; for (i = 0; i < STREAMLEN; i++) {
|
|
if (i % 12 == 0) { printf("\n "); }
|
|
printf("0x%02X,%s", best[i], (i % 12 == 11) ? "" : " "); } }
|
|
printf("\n};\n");
|
|
return 0;
|
|
}
|