ref: 8f31584de42c033b91c2426775cae17090f0e5e3
dir: /zelda_rtl.c/
#include "zelda_rtl.h" #include "variables.h" #include "misc.h" #include "nmi.h" #include "poly.h" #include "attract.h" #include "snes/ppu.h" #include "snes/snes_regs.h" #include "snes/dma.h" #include "spc_player.h" ZeldaEnv g_zenv; uint8 g_ram[131072]; uint32 g_wanted_zelda_features; static void Startup_InitializeMemory(); typedef struct SimpleHdma { const uint8 *table; const uint8 *indir_ptr; uint8 rep_count; uint8 mode; uint8 ppu_addr; uint8 indir_bank; } SimpleHdma; static void SimpleHdma_Init(SimpleHdma *c, DmaChannel *dc); static void SimpleHdma_DoLine(SimpleHdma *c); static const uint8 bAdrOffsets[8][4] = { {0, 0, 0, 0}, {0, 1, 0, 1}, {0, 0, 0, 0}, {0, 0, 1, 1}, {0, 1, 2, 3}, {0, 1, 0, 1}, {0, 0, 0, 0}, {0, 0, 1, 1} }; static const uint8 transferLength[8] = { 1, 2, 2, 4, 4, 4, 2, 4 }; const uint16 kUpperBitmasks[] = { 0x8000, 0x4000, 0x2000, 0x1000, 0x800, 0x400, 0x200, 0x100, 0x80, 0x40, 0x20, 0x10, 8, 4, 2, 1 }; const uint8 kLitTorchesColorPlus[] = {31, 8, 4, 0}; const uint8 kDungeonCrystalPendantBit[13] = {0, 0, 4, 2, 0, 16, 2, 1, 64, 4, 1, 32, 8}; const int8 kGetBestActionToPerformOnTile_x[4] = { 7, 7, -3, 16 }; const int8 kGetBestActionToPerformOnTile_y[4] = { 6, 24, 12, 12 }; #define AT_WORD(x) (uint8)(x), (x)>>8 // direct static const uint8 kAttractDmaTable0[13] = {0x20, AT_WORD(0x00ff), 0x50, AT_WORD(0xe018), 0x50, AT_WORD(0xe018), 1, AT_WORD(0x00ff), 0}; static const uint8 kAttractDmaTable1[10] = {0x48, AT_WORD(0x00ff), 0x30, AT_WORD(0xd830), 1, AT_WORD(0x00ff), 0}; static const uint8 kHdmaTableForEnding[19] = { 0x52, AT_WORD(0x600), 8, AT_WORD(0xe2), 8, AT_WORD(0x602), 5, AT_WORD(0x604), 0x10, AT_WORD(0x606), 0x81, AT_WORD(0xe2), 0, }; static const uint8 kSpotlightIndirectHdma[7] = {0xf8, AT_WORD(0x1b00), 0xf8, AT_WORD(0x1bf0), 0}; static const uint8 kMapModeHdma0[7] = {0xf0, AT_WORD(0xdd27), 0xf0, AT_WORD(0xde07), 0}; static const uint8 kMapModeHdma1[7] = {0xf0, AT_WORD(0xdee7), 0xf0, AT_WORD(0xdfc7), 0}; static const uint8 kAttractIndirectHdmaTab[7] = {0xf0, AT_WORD(0x1b00), 0xf0, AT_WORD(0x1be0), 0}; static const uint8 kHdmaTableForPrayingScene[7] = {0xf8, AT_WORD(0x1b00), 0xf8, AT_WORD(0x1bf0), 0}; // Maintain a queue cause the snes and audio callback are not in sync. struct ApuWriteEnt { uint8 ports[4]; }; static struct ApuWriteEnt g_apu_write_ents[16], g_apu_write; static uint8 g_apu_write_ent_pos, g_apu_write_count, g_apu_total_write; void zelda_apu_write(uint32_t adr, uint8_t val) { g_apu_write.ports[adr & 0x3] = val; } void ZeldaPushApuState() { g_apu_write_ents[g_apu_write_ent_pos++ & 0xf] = g_apu_write; if (g_apu_write_count < 16) g_apu_write_count++; g_apu_total_write++; } void ZeldaPopApuState() { if (g_apu_write_count != 0) memcpy(g_zenv.player->input_ports, &g_apu_write_ents[(g_apu_write_ent_pos - g_apu_write_count--) & 0xf], 4); } void ZeldaDiscardUnusedAudioFrames() { if (g_apu_write_count != 0 && memcmp(g_zenv.player->input_ports, &g_apu_write_ents[(g_apu_write_ent_pos - g_apu_write_count) & 0xf], 4) == 0) { if (g_apu_total_write >= 16) { g_apu_total_write = 14; g_apu_write_count--; } } else { g_apu_total_write = 0; } } uint8_t zelda_read_apui00() { // This needs to be here because the ancilla code reads // from the apu and we don't want to make the core code // dependent on the apu timings, so relocated this value // to 0x648. return g_ram[kRam_APUI00]; } uint8_t zelda_apu_read(uint32_t adr) { return g_zenv.player->port_to_snes[adr & 0x3]; } void zelda_ppu_write(uint32_t adr, uint8_t val) { assert(adr >= INIDISP && adr <= STAT78); ppu_write(g_zenv.ppu, (uint8)adr, val); } void zelda_ppu_write_word(uint32_t adr, uint16_t val) { zelda_ppu_write(adr, val); zelda_ppu_write(adr + 1, val >> 8); } static const uint8 *SimpleHdma_GetPtr(uint32 p) { switch (p) { case 0xCFA87: return kAttractDmaTable0; case 0xCFA94: return kAttractDmaTable1; case 0xebd53: return kHdmaTableForEnding; case 0x0F2FB: return kSpotlightIndirectHdma; case 0xabdcf: return kMapModeHdma0; // mode7 case 0xabdd6: return kMapModeHdma1; // mode7 case 0xABDDD: return kAttractIndirectHdmaTab; // mode7 case 0x2c80c: return kHdmaTableForPrayingScene; case 0x1b00: return (uint8 *)hdma_table_dynamic; case 0x1be0: return (uint8 *)hdma_table_dynamic + 0xe0; case 0x1bf0: return (uint8 *)hdma_table_dynamic + 0xf0; case 0xadd27: return (uint8*)kMapMode_Zooms1; case 0xade07: return (uint8*)kMapMode_Zooms1 + 0xe0; case 0xadee7: return (uint8*)kMapMode_Zooms2; case 0xadfc7: return (uint8*)kMapMode_Zooms2 + 0xe0; case 0x600: return &g_ram[0x600]; case 0x602: return &g_ram[0x602]; case 0x604: return &g_ram[0x604]; case 0x606: return &g_ram[0x606]; case 0xe2: return &g_ram[0xe2]; default: assert(0); return NULL; } } static void SimpleHdma_Init(SimpleHdma *c, DmaChannel *dc) { if (!dc->hdmaActive) { c->table = 0; return; } c->table = SimpleHdma_GetPtr(dc->aAdr | dc->aBank << 16); c->rep_count = 0; c->mode = dc->mode | dc->indirect << 6; c->ppu_addr = dc->bAdr; c->indir_bank = dc->indBank; } static void SimpleHdma_DoLine(SimpleHdma *c) { if (c->table == NULL) return; bool do_transfer = false; if ((c->rep_count & 0x7f) == 0) { c->rep_count = *c->table++; if (c->rep_count == 0) { c->table = NULL; return; } if(c->mode & 0x40) { c->indir_ptr = SimpleHdma_GetPtr(c->indir_bank << 16 | c->table[0] | c->table[1] * 256); c->table += 2; } do_transfer = true; } if(do_transfer || c->rep_count & 0x80) { for(int j = 0, j_end = transferLength[c->mode & 7]; j < j_end; j++) { uint8 v = c->mode & 0x40 ? *c->indir_ptr++ : *c->table++; zelda_ppu_write(0x2100 + c->ppu_addr + bAdrOffsets[c->mode & 7][j], v); } } c->rep_count--; } static void ConfigurePpuSideSpace() { // Let PPU impl know about the maximum allowed extra space on the sides and bottom int extra_right = 0, extra_left = 0, extra_bottom = 0; // printf("main %d, sub %d (%d, %d, %d)\n", main_module_index, submodule_index, BG2HOFS_copy2, room_bounds_x.v[2 | (quadrant_fullsize_x >> 1)], quadrant_fullsize_x >> 1); int mod = main_module_index; if (mod == 14) mod = saved_module_for_menu; if (mod == 9) { // outdoors extra_left = BG2HOFS_copy2 - ow_scroll_vars0.xstart; extra_right = ow_scroll_vars0.xend - BG2HOFS_copy2; extra_bottom = ow_scroll_vars0.yend - BG2VOFS_copy2; } else if (mod == 7) { // indoors, except when the light cone is in use if (!(hdr_dungeon_dark_with_lantern && TS_copy != 0)) { int qm = quadrant_fullsize_x >> 1; extra_left = IntMax(BG2HOFS_copy2 - room_bounds_x.v[qm], 0); extra_right = IntMax(room_bounds_x.v[qm + 2] - BG2HOFS_copy2, 0); } int qy = quadrant_fullsize_y >> 1; extra_bottom = IntMax(room_bounds_y.v[qy + 2] - BG2VOFS_copy2, 0); } else if (mod == 20 || mod == 0 || mod == 1) { extra_left = kPpuExtraLeftRight, extra_right = kPpuExtraLeftRight; extra_bottom = 16; } PpuSetExtraSideSpace(g_zenv.ppu, extra_left, extra_right, extra_bottom); } bool ZeldaDrawPpuFrame(uint8 *pixel_buffer, size_t pitch, uint32 render_flags) { SimpleHdma hdma_chans[2]; bool rv = PpuBeginDrawing(g_zenv.ppu, pixel_buffer, pitch, render_flags); dma_startDma(g_zenv.dma, HDMAEN_copy, true); SimpleHdma_Init(&hdma_chans[0], &g_zenv.dma->channel[6]); SimpleHdma_Init(&hdma_chans[1], &g_zenv.dma->channel[7]); // Cheat: Let the PPU impl know about the hdma perspective correction so it can avoid guessing. if ((render_flags & kPpuRenderFlags_4x4Mode7) && g_zenv.ppu->mode == 7) { if (hdma_chans[0].table == kMapModeHdma0) PpuSetMode7PerspectiveCorrection(g_zenv.ppu, kMapMode_Zooms1[0], kMapMode_Zooms1[223]); else if (hdma_chans[0].table == kMapModeHdma1) PpuSetMode7PerspectiveCorrection(g_zenv.ppu, kMapMode_Zooms2[0], kMapMode_Zooms2[223]); else if (hdma_chans[0].table == kAttractIndirectHdmaTab) PpuSetMode7PerspectiveCorrection(g_zenv.ppu, hdma_table_dynamic[0], hdma_table_dynamic[223]); else PpuSetMode7PerspectiveCorrection(g_zenv.ppu, 0, 0); } if (g_zenv.ppu->extraLeftRight != 0 || render_flags & kPpuRenderFlags_Height240) ConfigurePpuSideSpace(); int height = render_flags & kPpuRenderFlags_Height240 ? 240 : 224; for (int i = 0; i <= height; i++) { if (i == 128 && irq_flag) { zelda_ppu_write(BG3HOFS, selectfile_var8); zelda_ppu_write(BG3HOFS, selectfile_var8 >> 8); zelda_ppu_write(BG3VOFS, 0); zelda_ppu_write(BG3VOFS, 0); if (irq_flag & 0x80) { irq_flag = 0; zelda_snes_dummy_write(NMITIMEN, 0x81); } } ppu_runLine(g_zenv.ppu, i); SimpleHdma_DoLine(&hdma_chans[0]); SimpleHdma_DoLine(&hdma_chans[1]); } return rv; } void HdmaSetup(uint32 addr6, uint32 addr7, uint8 transfer_unit, uint8 reg6, uint8 reg7, uint8 indirect_bank) { Dma *dma = g_zenv.dma; if (addr6) { dma_write(dma, DMAP6, transfer_unit); dma_write(dma, BBAD6, reg6); dma_write(dma, A1T6L, addr6); dma_write(dma, A1T6H, addr6 >> 8); dma_write(dma, A1B6, addr6 >> 16); dma_write(dma, DAS60, indirect_bank); } dma_write(dma, DMAP7, transfer_unit); dma_write(dma, BBAD7, reg7); dma_write(dma, A1T7L, addr7); dma_write(dma, A1T7H, addr7 >> 8); dma_write(dma, A1B7, addr7 >> 16); dma_write(dma, DAS70, indirect_bank); } static void ZeldaInitializationCode() { zelda_snes_dummy_write(NMITIMEN, 0); zelda_snes_dummy_write(HDMAEN, 0); zelda_snes_dummy_write(MDMAEN, 0); zelda_apu_write(APUI00, 0); zelda_apu_write(APUI01, 0); zelda_apu_write(APUI02, 0); zelda_apu_write(APUI03, 0); zelda_ppu_write(INIDISP, 0x80); Sound_LoadIntroSongBank(); Startup_InitializeMemory(); animated_tile_data_src = 0xa680; dma_source_addr_9 = 0xb280; dma_source_addr_14 = 0xb280 + 0x60; zelda_snes_dummy_write(NMITIMEN, 0x81); } static void ClearOamBuffer() { // 80841e for (int i = 0; i < 128; i++) oam_buf[i].y = 0xf0; } static void ZeldaRunGameLoop() { frame_counter++; ClearOamBuffer(); Module_MainRouting(); NMI_PrepareSprites(); nmi_boolean = 0; } void ZeldaInitialize() { g_zenv.dma = dma_init(NULL); g_zenv.ppu = ppu_init(NULL); g_zenv.ram = g_ram; g_zenv.sram = (uint8*)calloc(8192, 1); g_zenv.vram = g_zenv.ppu->vram; g_zenv.player = SpcPlayer_Create(); SpcPlayer_Initialize(g_zenv.player); dma_reset(g_zenv.dma); ppu_reset(g_zenv.ppu); } static void ZeldaRunPolyLoop() { if (intro_did_run_step && !nmi_flag_update_polyhedral) { Poly_RunFrame(); intro_did_run_step = 0; nmi_flag_update_polyhedral = 0xff; } } void ZeldaRunFrameInternal(uint16 input, int run_what) { if (animated_tile_data_src == 0) ZeldaInitializationCode(); if (run_what & 2) ZeldaRunPolyLoop(); if (run_what & 1) ZeldaRunGameLoop(); Interrupt_NMI(input); } static int IncrementCrystalCountdown(uint8 *a, int v) { int t = *a + v; *a = t; return t >> 8; } int frame_ctr_dbg; static uint8 *g_emu_memory_ptr; static ZeldaRunFrameFunc *g_emu_runframe; static ZeldaSyncAllFunc *g_emu_syncall; void ZeldaSetupEmuCallbacks(uint8 *emu_ram, ZeldaRunFrameFunc *func, ZeldaSyncAllFunc *sync_all) { g_emu_memory_ptr = emu_ram; g_emu_runframe = func; g_emu_syncall = sync_all; } static void EmuSynchronizeWholeState() { if (g_emu_syncall) g_emu_syncall(); } // |ptr| must be a pointer into g_ram, will synchronize the RAM memory with the // emulator. static void EmuSyncMemoryRegion(void *ptr, size_t n) { uint8 *data = (uint8 *)ptr; assert(data >= g_ram && data < g_ram + 0x20000); if (g_emu_memory_ptr) memcpy(g_emu_memory_ptr + (data - g_ram), data, n); } static void Startup_InitializeMemory() { // 8087c0 memset(g_ram + 0x0, 0, 0x2000); main_palette_buffer[0] = 0; srm_var1 = 0; uint8 *sram = g_zenv.sram; if (WORD(sram[0x3e5]) != 0x55aa) WORD(sram[0x3e5]) = 0; if (WORD(sram[0x8e5]) != 0x55aa) WORD(sram[0x8e5]) = 0; if (WORD(sram[0xde5]) != 0x55aa) WORD(sram[0xde5]) = 0; zelda_ppu_write(TMW, 0); INIDISP_copy = 0x80; flag_update_cgram_in_nmi++; } typedef struct ByteArray { uint8 *data; size_t size, capacity; } ByteArray; void ByteArray_Resize(ByteArray *arr, size_t new_size) { arr->size = new_size; if (new_size > arr->capacity) { size_t minsize = arr->capacity + (arr->capacity >> 1) + 8; arr->capacity = new_size < minsize ? minsize : new_size; void *data = realloc(arr->data, arr->capacity); if (!data) Die("memory allocation failed"); arr->data = data; } } void ByteArray_Destroy(ByteArray *arr) { free(arr->data); arr->data = NULL; } void ByteArray_AppendData(ByteArray *arr, const uint8 *data, size_t data_size) { ByteArray_Resize(arr, arr->size + data_size); memcpy(arr->data + arr->size - data_size, data, data_size); } void ByteArray_AppendByte(ByteArray *arr, uint8 v) { ByteArray_Resize(arr, arr->size + 1); arr->data[arr->size - 1] = v; } void ByteArray_AppendVl(ByteArray *arr, uint32 v) { for (; v >= 255; v -= 255) ByteArray_AppendByte(arr, 255); ByteArray_AppendByte(arr, v); } void saveFunc(void *ctx_in, void *data, size_t data_size) { ByteArray_AppendData((ByteArray *)ctx_in, data, data_size); } typedef struct LoadFuncState { uint8 *p, *pend; } LoadFuncState; void loadFunc(void *ctx, void *data, size_t data_size) { LoadFuncState *st = (LoadFuncState *)ctx; assert(st->pend - st->p >= data_size); memcpy(data, st->p, data_size); st->p += data_size; } static void InternalSaveLoad(SaveLoadFunc *func, void *ctx) { uint8 junk[58] = { 0 }; func(ctx, junk, 27); func(ctx, g_zenv.player->ram, 0x10000); // apu ram func(ctx, junk, 40); // junk dsp_saveload(g_zenv.player->dsp, func, ctx); // 3024 bytes of dsp func(ctx, junk, 15); // spc junk dma_saveload(g_zenv.dma, func, ctx); // 192 bytes of dma state ppu_saveload(g_zenv.ppu, func, ctx); // 66619 + 512 + 174 func(ctx, g_zenv.sram, 0x2000); // 8192 bytes of sram func(ctx, junk, 58); // snes junk func(ctx, g_zenv.ram, 0x20000); // 0x20000 bytes of ram func(ctx, junk, 4); // snes junk } void ZeldaReset(bool preserve_sram) { frame_ctr_dbg = 0; dma_reset(g_zenv.dma); ppu_reset(g_zenv.ppu); memset(g_zenv.ram, 0, 0x20000); if (!preserve_sram) memset(g_zenv.sram, 0, 0x2000); SpcPlayer_Initialize(g_zenv.player); EmuSynchronizeWholeState(); } static void LoadSnesState(SaveLoadFunc *func, void *ctx) { // Do the actual loading InternalSaveLoad(func, ctx); memcpy(g_zenv.ram + 0x1DBA0, g_zenv.ram + 0x1b00, 224 * 2); // hdma table was moved // Restore spc variables from the ram dump. SpcPlayer_CopyVariablesFromRam(g_zenv.player); // This is not stored in the snapshot g_zenv.player->timer_cycles = 0; // Ensure emulator has the up-to-date state too EmuSynchronizeWholeState(); // Ensure we load any msu files ZeldaOpenMsuFile(); } static void SaveSnesState(SaveLoadFunc *func, void *ctx) { memcpy(g_zenv.ram + 0x1b00, g_zenv.ram + 0x1DBA0, 224 * 2); // hdma table was moved SpcPlayer_CopyVariablesToRam(g_zenv.player); InternalSaveLoad(func, ctx); } typedef struct StateRecorder { uint16 last_inputs; uint32 frames_since_last; uint32 total_frames; // For replay uint32 replay_pos, replay_pos_last_complete; uint32 replay_frame_counter; uint32 replay_next_cmd_at; uint8 replay_cmd; bool replay_mode; ByteArray log; ByteArray base_snapshot; } StateRecorder; static StateRecorder state_recorder; void StateRecorder_Init(StateRecorder *sr) { memset(sr, 0, sizeof(*sr)); } void StateRecorder_RecordCmd(StateRecorder *sr, uint8 cmd) { int frames = sr->frames_since_last; sr->frames_since_last = 0; int x = (cmd < 0xc0) ? 0xf : 0x1; ByteArray_AppendByte(&sr->log, cmd | (frames < x ? frames : x)); if (frames >= x) ByteArray_AppendVl(&sr->log, frames - x); } void StateRecorder_Record(StateRecorder *sr, uint16 inputs) { uint16 diff = inputs ^ sr->last_inputs; if (diff != 0) { sr->last_inputs = inputs; // printf("0x%.4x %d: ", diff, sr->frames_since_last); // size_t lb = sr->log.size; for (int i = 0; i < 12; i++) { if ((diff >> i) & 1) StateRecorder_RecordCmd(sr, i << 4); } // while (lb < sr->log.size) // printf("%.2x ", sr->log.data[lb++]); // printf("\n"); } sr->frames_since_last++; sr->total_frames++; } void StateRecorder_RecordPatchByte(StateRecorder *sr, uint32 addr, const uint8 *value, int num) { assert(addr < 0x20000); // printf("%d: PatchByte(0x%x, 0x%x. %d): ", sr->frames_since_last, addr, *value, num); // size_t lb = sr->log.size; int lq = (num - 1) <= 3 ? (num - 1) : 3; StateRecorder_RecordCmd(sr, 0xc0 | (addr & 0x10000 ? 2 : 0) | lq << 2); if (lq == 3) ByteArray_AppendVl(&sr->log, num - 1 - 3); ByteArray_AppendByte(&sr->log, addr >> 8); ByteArray_AppendByte(&sr->log, addr); for (int i = 0; i < num; i++) ByteArray_AppendByte(&sr->log, value[i]); // while (lb < sr->log.size) // printf("%.2x ", sr->log.data[lb++]); // printf("\n"); } void StateRecorder_Load(StateRecorder *sr, FILE *f, bool replay_mode) { // todo: fix robustness on invalid data. uint32 hdr[8] = { 0 }; fread(hdr, 1, sizeof(hdr), f); assert(hdr[0] == 1); sr->total_frames = hdr[1]; ByteArray_Resize(&sr->log, hdr[2]); fread(sr->log.data, 1, sr->log.size, f); sr->last_inputs = hdr[3]; sr->frames_since_last = hdr[4]; ByteArray_Resize(&sr->base_snapshot, (hdr[5] & 1) ? hdr[6] : 0); fread(sr->base_snapshot.data, 1, sr->base_snapshot.size, f); sr->replay_next_cmd_at = 0; bool is_reset = false; sr->replay_mode = replay_mode; if (replay_mode) { sr->frames_since_last = 0; sr->last_inputs = 0; sr->replay_pos = sr->replay_pos_last_complete = 0; sr->replay_frame_counter = 0; // Load snapshot from |base_snapshot_|, or reset if empty. if (sr->base_snapshot.size) { LoadFuncState state = { sr->base_snapshot.data, sr->base_snapshot.data + sr->base_snapshot.size }; LoadSnesState(&loadFunc, &state); assert(state.p == state.pend); } else { ZeldaReset(false); is_reset = true; } } else { // Resume replay from the saved position? sr->replay_pos = sr->replay_pos_last_complete = hdr[5] >> 1; sr->replay_frame_counter = hdr[7]; sr->replay_mode = (sr->replay_frame_counter != 0); ByteArray arr = { 0 }; ByteArray_Resize(&arr, hdr[6]); fread(arr.data, 1, arr.size, f); LoadFuncState state = { arr.data, arr.data + arr.size }; LoadSnesState(&loadFunc, &state); ByteArray_Destroy(&arr); assert(state.p == state.pend); } } void StateRecorder_Save(StateRecorder *sr, FILE *f) { uint32 hdr[8] = { 0 }; ByteArray arr = { 0 }; SaveSnesState(&saveFunc, &arr); assert(sr->base_snapshot.size == 0 || sr->base_snapshot.size == arr.size); hdr[0] = 1; hdr[1] = sr->total_frames; hdr[2] = (uint32)sr->log.size; hdr[3] = sr->last_inputs; hdr[4] = sr->frames_since_last; hdr[5] = sr->base_snapshot.size ? 1 : 0; hdr[6] = (uint32)arr.size; // If saving while in replay mode, also need to persist // sr->replay_pos_last_complete and sr->replay_frame_counter // so the replaying can be resumed. if (sr->replay_mode) { hdr[5] |= sr->replay_pos_last_complete << 1; hdr[7] = sr->replay_frame_counter; } fwrite(hdr, 1, sizeof(hdr), f); fwrite(sr->log.data, 1, hdr[2], f); fwrite(sr->base_snapshot.data, 1, sr->base_snapshot.size, f); fwrite(arr.data, 1, arr.size, f); ByteArray_Destroy(&arr); } void StateRecorder_ClearKeyLog(StateRecorder *sr) { printf("Clearing key log!\n"); sr->base_snapshot.size = 0; SaveSnesState(&saveFunc, &sr->base_snapshot); ByteArray old_log = sr->log; int old_frames_since_last = sr->frames_since_last; memset(&sr->log, 0, sizeof(sr->log)); // If there are currently any active inputs, record them initially at timestamp 0. sr->frames_since_last = 0; if (sr->last_inputs) { for (int i = 0; i < 12; i++) { if ((sr->last_inputs >> i) & 1) StateRecorder_RecordCmd(sr, i << 4); } } if (sr->replay_mode) { // When clearing the key log while in replay mode, we want to keep // replaying but discarding all key history up until this point. if (sr->replay_next_cmd_at != 0xffffffff) { sr->replay_next_cmd_at -= old_frames_since_last; sr->frames_since_last = sr->replay_next_cmd_at; sr->replay_pos_last_complete = (uint32)sr->log.size; StateRecorder_RecordCmd(sr, sr->replay_cmd); int old_replay_pos = sr->replay_pos; sr->replay_pos = (uint32)sr->log.size; ByteArray_AppendData(&sr->log, old_log.data + old_replay_pos, old_log.size - old_replay_pos); } sr->total_frames -= sr->replay_frame_counter; sr->replay_frame_counter = 0; } else { sr->total_frames = 0; } ByteArray_Destroy(&old_log); sr->frames_since_last = 0; } uint16 StateRecorder_ReadNextReplayState(StateRecorder *sr) { assert(sr->replay_mode); while (sr->frames_since_last >= sr->replay_next_cmd_at) { int replay_pos = sr->replay_pos; if (replay_pos != sr->replay_pos_last_complete) { // Apply next command sr->frames_since_last = 0; if (sr->replay_cmd < 0xc0) { sr->last_inputs ^= 1 << (sr->replay_cmd >> 4); } else if (sr->replay_cmd < 0xd0) { int nb = 1 + ((sr->replay_cmd >> 2) & 3); uint8 t; if (nb == 4) do { nb += t = sr->log.data[replay_pos++]; } while (t == 255); uint32 addr = ((sr->replay_cmd >> 1) & 1) << 16; addr |= sr->log.data[replay_pos++] << 8; addr |= sr->log.data[replay_pos++]; do { g_ram[addr & 0x1ffff] = sr->log.data[replay_pos++]; EmuSyncMemoryRegion(&g_ram[addr & 0x1ffff], 1); } while (addr++, --nb); } else { assert(0); } } sr->replay_pos_last_complete = replay_pos; if (replay_pos >= sr->log.size) { sr->replay_pos = replay_pos; sr->replay_next_cmd_at = 0xffffffff; break; } // Read the next one uint8 cmd = sr->log.data[replay_pos++], t; int mask = (cmd < 0xc0) ? 0xf : 0x1; int frames = cmd & mask; if (frames == mask) do { frames += t = sr->log.data[replay_pos++]; } while (t == 255); sr->replay_next_cmd_at = frames; sr->replay_cmd = cmd; sr->replay_pos = replay_pos; } sr->frames_since_last++; // Turn off replay mode after we reached the final frame position if (++sr->replay_frame_counter >= sr->total_frames) { sr->replay_mode = false; } return sr->last_inputs; } void StateRecorder_StopReplay(StateRecorder *sr) { if (!sr->replay_mode) return; sr->replay_mode = false; sr->total_frames = sr->replay_frame_counter; sr->log.size = sr->replay_pos_last_complete; } #ifdef _DEBUG // This can be used to read inputs from a text file for easier debugging int InputStateReadFromFile() { static FILE *f; static uint32 next_ts, next_keys, cur_keys; char buf[64]; char keys[64]; while (state_recorder.total_frames == next_ts) { cur_keys = next_keys; if (!f) f = fopen("boss_bug.txt", "r"); if (fgets(buf, sizeof(buf), f)) { if (sscanf(buf, "%d: %s", &next_ts, keys) == 1) keys[0] = 0; int i = 0; for (const char *s = keys; *s; s++) { static const char kKeys[] = "AXsSUDLRBY"; const char *t = strchr(kKeys, *s); assert(t); i |= 1 << (t - kKeys); } next_keys = i; } else { next_ts = 0xffffffff; } } return cur_keys; } #endif bool ZeldaRunFrame(int inputs) { // Avoid up/down and left/right from being pressed at the same time if ((inputs & 0x30) == 0x30) inputs ^= 0x30; if ((inputs & 0xc0) == 0xc0) inputs ^= 0xc0; frame_ctr_dbg++; bool is_replay = state_recorder.replay_mode; // Either copy state or apply state if (is_replay) { inputs = StateRecorder_ReadNextReplayState(&state_recorder); } else { // input_state = InputStateReadFromFile(); StateRecorder_Record(&state_recorder, inputs); // This is whether APUI00 is true or false, this is used by the ancilla code. uint8 apui00 = ZeldaIsMusicPlaying(); if (apui00 != g_ram[kRam_APUI00]) { g_ram[kRam_APUI00] = apui00; EmuSyncMemoryRegion(&g_ram[kRam_APUI00], 1); StateRecorder_RecordPatchByte(&state_recorder, 0x648, &apui00, 1); } if (animated_tile_data_src != 0) { // Whenever we're no longer replaying, we'll remember what bugs were fixed, // but only if game is initialized. if (g_ram[kRam_BugsFixed] < kBugFix_Latest) { g_ram[kRam_BugsFixed] = kBugFix_Latest; EmuSyncMemoryRegion(&g_ram[kRam_BugsFixed], 1); StateRecorder_RecordPatchByte(&state_recorder, kRam_BugsFixed, &g_ram[kRam_BugsFixed], 1); } if (enhanced_features0 != g_wanted_zelda_features) { enhanced_features0 = g_wanted_zelda_features; EmuSyncMemoryRegion(&enhanced_features0, sizeof(enhanced_features0)); StateRecorder_RecordPatchByte(&state_recorder, kRam_Features0, (uint8 *)&enhanced_features0, 4); } } } int run_what; if (g_ram[kRam_BugsFixed] < kBugFix_PolyRenderer) { // A previous version of this code alternated the game loop with // the poly renderer. run_what = (is_nmi_thread_active && thread_other_stack != 0x1f31) ? 2 : 1; } else { // The snes seems to let poly rendering run for a little // while each fram until it eventually completes a frame. // Simulate this by rendering the poly every n:th frame. run_what = (is_nmi_thread_active && IncrementCrystalCountdown(&g_ram[kRam_CrystalRotateCounter], virq_trigger)) ? 3 : 1; EmuSyncMemoryRegion(&g_ram[kRam_CrystalRotateCounter], 1); } if (g_emu_runframe == NULL || enhanced_features0 != 0) { // can't compare against real impl when running with extra features. ZeldaRunFrameInternal(inputs, run_what); } else { g_emu_runframe(inputs, run_what); } ZeldaPushApuState(); return is_replay; } static const char *const kReferenceSaves[] = { "Chapter 1 - Zelda's Rescue.sav", "Chapter 2 - After Eastern Palace.sav", "Chapter 3 - After Desert Palace.sav", "Chapter 4 - After Tower of Hera.sav", "Chapter 5 - After Hyrule Castle Tower.sav", "Chapter 6 - After Dark Palace.sav", "Chapter 7 - After Swamp Palace.sav", "Chapter 8 - After Skull Woods.sav", "Chapter 9 - After Gargoyle's Domain.sav", "Chapter 10 - After Ice Palace.sav", "Chapter 11 - After Misery Mire.sav", "Chapter 12 - After Turtle Rock.sav", "Chapter 13 - After Ganon's Tower.sav", }; void SaveLoadSlot(int cmd, int which) { char name[128]; if (which & 256) { if (cmd == kSaveLoad_Save) return; sprintf(name, "saves/ref/%s", kReferenceSaves[which - 256]); } else { sprintf(name, "saves/save%d.sav", which); } FILE *f = fopen(name, cmd != kSaveLoad_Save ? "rb" : "wb"); if (f) { printf("*** %s slot %d\n", cmd == kSaveLoad_Save ? "Saving" : cmd == kSaveLoad_Load ? "Loading" : "Replaying", which); if (cmd != kSaveLoad_Save) StateRecorder_Load(&state_recorder, f, cmd == kSaveLoad_Replay); else StateRecorder_Save(&state_recorder, f); fclose(f); } } typedef struct StateRecoderMultiPatch { uint32 count; uint32 addr; uint8 vals[256]; } StateRecoderMultiPatch; void StateRecoderMultiPatch_Init(StateRecoderMultiPatch *mp) { mp->count = mp->addr = 0; } void StateRecoderMultiPatch_Commit(StateRecoderMultiPatch *mp) { if (mp->count) StateRecorder_RecordPatchByte(&state_recorder, mp->addr, mp->vals, mp->count); } void StateRecoderMultiPatch_Patch(StateRecoderMultiPatch *mp, uint32 addr, uint8 value) { if (mp->count >= 256 || addr != mp->addr + mp->count) { StateRecoderMultiPatch_Commit(mp); mp->addr = addr; mp->count = 0; } mp->vals[mp->count++] = value; g_ram[addr] = value; EmuSyncMemoryRegion(&g_ram[addr], 1); } void PatchCommand(char c) { StateRecoderMultiPatch mp; StateRecoderMultiPatch_Init(&mp); if (c == 'w') { StateRecoderMultiPatch_Patch(&mp, 0xf372, 80); // health filler StateRecoderMultiPatch_Patch(&mp, 0xf373, 80); // magic filler // b.Patch(0x1FE01, 25); } else if (c == 'W') { StateRecoderMultiPatch_Patch(&mp, 0xf375, 10); // link_bomb_filler StateRecoderMultiPatch_Patch(&mp, 0xf376, 10); // link_arrow_filler uint16 rupees = link_rupees_goal + 100; StateRecoderMultiPatch_Patch(&mp, 0xf360, rupees); // link_rupees_goal StateRecoderMultiPatch_Patch(&mp, 0xf361, rupees >> 8); // link_rupees_goal } else if (c == 'k') { StateRecorder_ClearKeyLog(&state_recorder); } else if (c == 'o') { StateRecoderMultiPatch_Patch(&mp, 0xf36f, 1); } else if (c == 'l') { StateRecorder_StopReplay(&state_recorder); } else if (c == 'E') { StateRecoderMultiPatch_Patch(&mp, 0x37f, g_ram[0x37f] ^ 1); } StateRecoderMultiPatch_Commit(&mp); } void LoadSongBank(const uint8 *p) { // 808888 SpcPlayer_Upload(g_zenv.player, p); } bool msu_enabled; static FILE *msu_file; static uint32 msu_loop_start; static uint32 msu_buffer_size, msu_buffer_pos; static uint8 msu_buffer[65536]; static const uint8 kMsuTracksWithRepeat[48] = { 1,0,1,1,1,1,1,1,0,1,0,1,1,1,1,0, 1,1,1,0,1,1,1,1,1,1,1,1,1,0,1,1, 1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1, }; bool ZeldaIsMusicPlaying() { if (msu_track) { return msu_file != NULL; } else { return g_zenv.player->port_to_snes[0] != 0; } } void ZeldaOpenMsuFile() { if (msu_file) fclose(msu_file), msu_file = NULL; if (msu_track == 0) return; char buf[40], hdr[8]; sprintf(buf, "msu/alttp_msu-%d.pcm", msu_track); msu_file = fopen(buf, "rb"); if (msu_file == NULL || fread(hdr, 1, 8, msu_file) != 8 || *(uint32 *)(hdr + 0) != (('1' << 24) | ('U' << 16) | ('S' << 8) | 'M')) { if (msu_file != NULL) fclose(msu_file), msu_file = NULL; zelda_apu_write(APUI00, msu_track); msu_track = 0; return; } if (msu_curr_sample != 0) fseek(msu_file, msu_curr_sample * 4 + 8, SEEK_SET); printf("Loading MSU PCM file: %s\n", buf); msu_loop_start = *(uint32 *)(hdr + 4); msu_buffer_size = msu_buffer_pos = 0; } void ZeldaPlayMsuAudioTrack() { if (!msu_enabled) normal_playback: { msu_track = 0; zelda_apu_write(APUI00, music_control); return; } if ((music_control & 0xf0) != 0xf0) { msu_track = music_control; msu_volume = 255; msu_curr_sample = 0; ZeldaOpenMsuFile(); } else if (msu_file == NULL) { goto normal_playback; } zelda_apu_write(APUI00, 0xf1); // pause spc player } void MixinMsuAudioData(int16 *audio_buffer, int audio_samples) { if (msu_file == NULL) return; // msu inactive // handle volume fade if (last_music_control >= 0xf1) { if (last_music_control == 0xf1) msu_volume = IntMax(msu_volume - 3, 0); else if (last_music_control == 0xf2) msu_volume = IntMax(msu_volume - 3, 0x40); else if (last_music_control == 0xf3) msu_volume = IntMin(msu_volume + 3, 0xff); } if (msu_volume == 0) return; int last_audio_samples = 0; for (;;) { if (msu_buffer_pos >= msu_buffer_size) { msu_buffer_size = (int)fread(msu_buffer, 4, sizeof(msu_buffer) / 4, msu_file); msu_buffer_pos = 0; } int nr = IntMin(audio_samples, msu_buffer_size - msu_buffer_pos); uint8 *buf = msu_buffer + msu_buffer_pos * 4; msu_buffer_pos += nr; msu_curr_sample += nr; int volume = msu_volume + 1; if (volume == 256) { for (int i = 0; i < nr; i++) { audio_buffer[i * 2 + 0] += ((int16 *)buf)[i * 2 + 0]; audio_buffer[i * 2 + 1] += ((int16 *)buf)[i * 2 + 1]; } } else { for (int i = 0; i < nr; i++) { audio_buffer[i * 2 + 0] += ((int16 *)buf)[i * 2 + 0] * volume >> 8; audio_buffer[i * 2 + 1] += ((int16 *)buf)[i * 2 + 1] * volume >> 8; } } audio_samples -= nr, audio_buffer += nr * 2; if (audio_samples == 0) break; if (nr != 0) continue; if (last_audio_samples == audio_samples) { // error? zelda_apu_write(APUI00, msu_track); fclose(msu_file), msu_file = NULL; return; } last_audio_samples = audio_samples; if (!kMsuTracksWithRepeat[msu_track]) { fclose(msu_file), msu_file = NULL; return; } fseek(msu_file, msu_loop_start * 4 + 8, SEEK_SET); msu_curr_sample = msu_loop_start; } } void ZeldaRenderAudio(int16 *audio_buffer, int samples, int channels) { ZeldaPopApuState(); SpcPlayer_GenerateSamples(g_zenv.player); dsp_getSamples(g_zenv.player->dsp, audio_buffer, samples, channels); if (channels == 2) MixinMsuAudioData(audio_buffer, samples); } void ZeldaReadSram() { FILE *f = fopen("saves/sram.dat", "rb"); if (f) { fread(g_zenv.sram, 1, 8192, f); fclose(f); EmuSynchronizeWholeState(); } } void ZeldaWriteSram() { rename("saves/sram.dat", "saves/sram.bak"); FILE *f = fopen("saves/sram.dat", "wb"); if (f) { fwrite(g_zenv.sram, 1, 8192, f); fclose(f); } else { fprintf(stderr, "Unable to write saves/sram.dat\n"); } }