Mercurial > vba-linux

annotate src/gb/GB.cpp @ 3:b05d00f19d80

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fix some formatting
author Robert McIntyre <rlm@mit.edu>
date Sat, 03 Mar 2012 10:33:11 -0600
parents f9f4f1b99eed
children 44974c3e093b
rev   line source
rlm@1 1 #include <cstdio>
rlm@1 2 #include <cstdlib>
rlm@1 3 #include <cstring>
rlm@1 4 #include <cassert>
rlm@1 5
rlm@1 6 #include "../Port.h"
rlm@1 7 #include "../NLS.h"
rlm@1 8 #include "GB.h"
rlm@1 9 #include "gbCheats.h"
rlm@1 10 #include "gbGlobals.h"
rlm@1 11 #include "gbMemory.h"
rlm@1 12 #include "gbSGB.h"
rlm@1 13 #include "gbSound.h"
rlm@1 14 #include "../common/unzip.h"
rlm@1 15 #include "../common/Util.h"
rlm@1 16 #include "../common/System.h"
rlm@1 17 #include "../common/movie.h"
rlm@1 18 #include "../common/vbalua.h"
rlm@1 19
rlm@1 20 #ifdef __GNUC__
rlm@1 21 #define _stricmp strcasecmp
rlm@1 22 #endif
rlm@1 23
rlm@1 24 // FIXME: constant (GB) or boolean (GBA)?!
rlm@1 25 #define C_FLAG 0x10
rlm@1 26 #define H_FLAG 0x20
rlm@1 27 #define N_FLAG 0x40
rlm@1 28 #define Z_FLAG 0x80
rlm@1 29 extern soundtick_t GB_USE_TICKS_AS;
rlm@1 30
rlm@1 31 u8 * origPix = NULL;
rlm@1 32 extern u8 * pix;
rlm@1 33 extern u32 extButtons;
rlm@1 34 extern bool8 capturePrevious;
rlm@1 35 extern int32 captureNumber;
rlm@1 36 extern bool8 speedup;
rlm@1 37
rlm@1 38 bool gbUpdateSizes();
rlm@1 39
rlm@1 40 // debugging
rlm@1 41 bool memorydebug = false;
rlm@1 42 char gbBuffer[2048];
rlm@1 43
rlm@1 44 extern u16 gbLineMix[160];
rlm@1 45
rlm@1 46 // mappers
rlm@1 47 void (*mapper)(u16, u8) = NULL;
rlm@1 48 void (*mapperRAM)(u16, u8) = NULL;
rlm@1 49 u8 (*mapperReadRAM)(u16) = NULL;
rlm@1 50
rlm@1 51 // registers
rlm@1 52 gbRegister PC;
rlm@1 53 gbRegister SP;
rlm@1 54 gbRegister AF;
rlm@1 55 gbRegister BC;
rlm@1 56 gbRegister DE;
rlm@1 57 gbRegister HL;
rlm@1 58 u16 IFF;
rlm@1 59 // 0xff04
rlm@1 60 u8 register_DIV = 0;
rlm@1 61 // 0xff05
rlm@1 62 u8 register_TIMA = 0;
rlm@1 63 // 0xff06
rlm@1 64 u8 register_TMA = 0;
rlm@1 65 // 0xff07
rlm@1 66 u8 register_TAC = 0;
rlm@1 67 // 0xff0f
rlm@1 68 u8 register_IF = 0;
rlm@1 69 // 0xff40
rlm@1 70 u8 register_LCDC = 0;
rlm@1 71 // 0xff41
rlm@1 72 u8 register_STAT = 0;
rlm@1 73 // 0xff42
rlm@1 74 u8 register_SCY = 0;
rlm@1 75 // 0xff43
rlm@1 76 u8 register_SCX = 0;
rlm@1 77 // 0xff44
rlm@1 78 u8 register_LY = 0;
rlm@1 79 // 0xff45
rlm@1 80 u8 register_LYC = 0;
rlm@1 81 // 0xff46
rlm@1 82 u8 register_DMA = 0;
rlm@1 83 // 0xff4a
rlm@1 84 u8 register_WY = 0;
rlm@1 85 // 0xff4b
rlm@1 86 u8 register_WX = 0;
rlm@1 87 // 0xff4f
rlm@1 88 u8 register_VBK = 0;
rlm@1 89 // 0xff51
rlm@1 90 u8 register_HDMA1 = 0;
rlm@1 91 // 0xff52
rlm@1 92 u8 register_HDMA2 = 0;
rlm@1 93 // 0xff53
rlm@1 94 u8 register_HDMA3 = 0;
rlm@1 95 // 0xff54
rlm@1 96 u8 register_HDMA4 = 0;
rlm@1 97 // 0xff55
rlm@1 98 u8 register_HDMA5 = 0;
rlm@1 99 // 0xff70
rlm@1 100 u8 register_SVBK = 0;
rlm@1 101 // 0xffff
rlm@1 102 u8 register_IE = 0;
rlm@1 103
rlm@1 104 // ticks definition
rlm@1 105 int32 GBDIV_CLOCK_TICKS = 64;
rlm@1 106 int32 GBLCD_MODE_0_CLOCK_TICKS = 51;
rlm@1 107 int32 GBLCD_MODE_1_CLOCK_TICKS = 1140;
rlm@1 108 int32 GBLCD_MODE_2_CLOCK_TICKS = 20;
rlm@1 109 int32 GBLCD_MODE_3_CLOCK_TICKS = 43;
rlm@1 110 int32 GBLY_INCREMENT_CLOCK_TICKS = 114;
rlm@1 111 int32 GBTIMER_MODE_0_CLOCK_TICKS = 256;
rlm@1 112 int32 GBTIMER_MODE_1_CLOCK_TICKS = 4;
rlm@1 113 int32 GBTIMER_MODE_2_CLOCK_TICKS = 16;
rlm@1 114 int32 GBTIMER_MODE_3_CLOCK_TICKS = 64;
rlm@1 115 int32 GBSERIAL_CLOCK_TICKS = 128;
rlm@1 116 int32 GBSYNCHRONIZE_CLOCK_TICKS = 52920;
rlm@1 117
rlm@1 118 // state variables
rlm@1 119
rlm@1 120 // interrupt
rlm@1 121 int32 gbInterrupt = 0;
rlm@1 122 int32 gbInterruptWait = 0;
rlm@1 123 // serial
rlm@1 124 int32 gbSerialOn = 0;
rlm@1 125 int32 gbSerialTicks = 0;
rlm@1 126 int32 gbSerialBits = 0;
rlm@1 127 // timer
rlm@1 128 int32 gbTimerOn = 0;
rlm@1 129 int32 gbTimerTicks = 0;
rlm@1 130 int32 gbTimerClockTicks = 0;
rlm@1 131 int32 gbTimerMode = 0;
rlm@1 132 // lcd
rlm@1 133 int32 gbLcdMode = 2;
rlm@1 134 int32 gbLcdTicks = GBLCD_MODE_2_CLOCK_TICKS;
rlm@1 135 int32 gbLcdLYIncrementTicks = 0;
rlm@1 136 // div
rlm@1 137 int32 gbDivTicks = GBDIV_CLOCK_TICKS;
rlm@1 138 // cgb
rlm@1 139 int32 gbVramBank = 0;
rlm@1 140 int32 gbWramBank = 1;
rlm@1 141 int32 gbHdmaSource = 0x0000;
rlm@1 142 int32 gbHdmaDestination = 0x8000;
rlm@1 143 int32 gbHdmaBytes = 0x0000;
rlm@1 144 int32 gbHdmaOn = 0;
rlm@1 145 int32 gbSpeed = 0;
rlm@1 146 // frame counting
rlm@1 147 int32 gbFrameCount = 0;
rlm@1 148 int32 gbFrameSkip = 0;
rlm@1 149 int32 gbFrameSkipCount = 0;
rlm@1 150 // timing
rlm@1 151 u32 gbLastTime = 0;
rlm@1 152 u32 gbElapsedTime = 0;
rlm@1 153 u32 gbTimeNow = 0;
rlm@1 154 int32 gbSynchronizeTicks = GBSYNCHRONIZE_CLOCK_TICKS;
rlm@1 155 int32 gbDMASpeedVersion = 1;
rlm@1 156 // emulator features
rlm@1 157 int32 gbBattery = 0;
rlm@1 158 int32 gbJoymask[4] = { 0, 0, 0, 0 };
rlm@1 159
rlm@1 160 int32 gbEchoRAMFixOn = 1;
rlm@1 161
rlm@1 162 static bool newFrame = true;
rlm@1 163 static bool pauseAfterFrameAdvance = false;
rlm@1 164
rlm@1 165 int32 gbRomSizes[] = { 0x00008000, // 32K
rlm@1 166 0x00010000, // 64K
rlm@1 167 0x00020000, // 128K
rlm@1 168 0x00040000, // 256K
rlm@1 169 0x00080000, // 512K
rlm@1 170 0x00100000, // 1024K
rlm@1 171 0x00200000, // 2048K
rlm@1 172 0x00400000, // 4096K
rlm@1 173 0x00800000 // 8192K
rlm@1 174 };
rlm@1 175 int32 gbRomSizesMasks[] = { 0x00007fff,
rlm@1 176 0x0000ffff,
rlm@1 177 0x0001ffff,
rlm@1 178 0x0003ffff,
rlm@1 179 0x0007ffff,
rlm@1 180 0x000fffff,
rlm@1 181 0x001fffff,
rlm@1 182 0x003fffff,
rlm@1 183 0x007fffff };
rlm@1 184
rlm@1 185 int32 gbRamSizes[6] = { 0x00000000, // 0K
rlm@1 186 0x00000800, // 2K
rlm@1 187 0x00002000, // 8K
rlm@1 188 0x00008000, // 32K
rlm@1 189 0x00020000, // 128K
rlm@1 190 0x00010000 // 64K
rlm@1 191 };
rlm@1 192
rlm@1 193 int32 gbRamSizesMasks[6] = { 0x00000000,
rlm@1 194 0x000007ff,
rlm@1 195 0x00001fff,
rlm@1 196 0x00007fff,
rlm@1 197 0x0001ffff,
rlm@1 198 0x0000ffff };
rlm@1 199
rlm@1 200 int32 gbCycles[] =
rlm@1 201 {
rlm@1 202 // 0 1 2 3 4 5 6 7 8 9 a b c d e f
rlm@1 203 1, 3, 2, 2, 1, 1, 2, 1, 5, 2, 2, 2, 1, 1, 2, 1, // 0
rlm@1 204 1, 3, 2, 2, 1, 1, 2, 1, 3, 2, 2, 2, 1, 1, 2, 1, // 1
rlm@1 205 2, 3, 2, 2, 1, 1, 2, 1, 2, 2, 2, 2, 1, 1, 2, 1, // 2
rlm@1 206 2, 3, 2, 2, 3, 3, 3, 1, 2, 2, 2, 2, 1, 1, 2, 1, // 3
rlm@1 207 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, // 4
rlm@1 208 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, // 5
rlm@1 209 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, // 6
rlm@1 210 2, 2, 2, 2, 2, 2, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1, // 7
rlm@1 211 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, // 8
rlm@1 212 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, // 9
rlm@1 213 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, // a
rlm@1 214 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, // b
rlm@1 215 2, 3, 3, 4, 3, 4, 2, 4, 2, 4, 3, 2, 3, 6, 2, 4, // c
rlm@1 216 2, 3, 3, 0, 3, 4, 2, 4, 2, 4, 3, 0, 3, 0, 2, 4, // d
rlm@1 217 3, 3, 2, 0, 0, 4, 2, 4, 4, 1, 4, 0, 0, 0, 2, 4, // e
rlm@1 218 3, 3, 2, 1, 0, 4, 2, 4, 3, 2, 4, 1, 0, 0, 2, 4 // f
rlm@1 219 };
rlm@1 220
rlm@1 221 int32 gbCyclesCB[] =
rlm@1 222 {
rlm@1 223 // 0 1 2 3 4 5 6 7 8 9 a b c d e f
rlm@1 224 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, // 0
rlm@1 225 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, // 1
rlm@1 226 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, // 2
rlm@1 227 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 4, 2, // 3
rlm@1 228 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, // 4
rlm@1 229 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, // 5
rlm@1 230 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, // 6
rlm@1 231 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, // 7
rlm@1 232 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, // 8
rlm@1 233 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, // 9
rlm@1 234 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, // a
rlm@1 235 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, // b
rlm@1 236 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, // c
rlm@1 237 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, // d
rlm@1 238 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, // e
rlm@1 239 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2 // f
rlm@1 240 };
rlm@1 241
rlm@1 242 u16 DAATable[] =
rlm@1 243 {
rlm@1 244 0x0080, 0x0100, 0x0200, 0x0300, 0x0400, 0x0500, 0x0600, 0x0700,
rlm@1 245 0x0800, 0x0900, 0x1020, 0x1120, 0x1220, 0x1320, 0x1420, 0x1520,
rlm@1 246 0x1000, 0x1100, 0x1200, 0x1300, 0x1400, 0x1500, 0x1600, 0x1700,
rlm@1 247 0x1800, 0x1900, 0x2020, 0x2120, 0x2220, 0x2320, 0x2420, 0x2520,
rlm@1 248 0x2000, 0x2100, 0x2200, 0x2300, 0x2400, 0x2500, 0x2600, 0x2700,
rlm@1 249 0x2800, 0x2900, 0x3020, 0x3120, 0x3220, 0x3320, 0x3420, 0x3520,
rlm@1 250 0x3000, 0x3100, 0x3200, 0x3300, 0x3400, 0x3500, 0x3600, 0x3700,
rlm@1 251 0x3800, 0x3900, 0x4020, 0x4120, 0x4220, 0x4320, 0x4420, 0x4520,
rlm@1 252 0x4000, 0x4100, 0x4200, 0x4300, 0x4400, 0x4500, 0x4600, 0x4700,
rlm@1 253 0x4800, 0x4900, 0x5020, 0x5120, 0x5220, 0x5320, 0x5420, 0x5520,
rlm@1 254 0x5000, 0x5100, 0x5200, 0x5300, 0x5400, 0x5500, 0x5600, 0x5700,
rlm@1 255 0x5800, 0x5900, 0x6020, 0x6120, 0x6220, 0x6320, 0x6420, 0x6520,
rlm@1 256 0x6000, 0x6100, 0x6200, 0x6300, 0x6400, 0x6500, 0x6600, 0x6700,
rlm@1 257 0x6800, 0x6900, 0x7020, 0x7120, 0x7220, 0x7320, 0x7420, 0x7520,
rlm@1 258 0x7000, 0x7100, 0x7200, 0x7300, 0x7400, 0x7500, 0x7600, 0x7700,
rlm@1 259 0x7800, 0x7900, 0x8020, 0x8120, 0x8220, 0x8320, 0x8420, 0x8520,
rlm@1 260 0x8000, 0x8100, 0x8200, 0x8300, 0x8400, 0x8500, 0x8600, 0x8700,
rlm@1 261 0x8800, 0x8900, 0x9020, 0x9120, 0x9220, 0x9320, 0x9420, 0x9520,
rlm@1 262 0x9000, 0x9100, 0x9200, 0x9300, 0x9400, 0x9500, 0x9600, 0x9700,
rlm@1 263 0x9800, 0x9900, 0x00B0, 0x0130, 0x0230, 0x0330, 0x0430, 0x0530,
rlm@1 264 0x0090, 0x0110, 0x0210, 0x0310, 0x0410, 0x0510, 0x0610, 0x0710,
rlm@1 265 0x0810, 0x0910, 0x1030, 0x1130, 0x1230, 0x1330, 0x1430, 0x1530,
rlm@1 266 0x1010, 0x1110, 0x1210, 0x1310, 0x1410, 0x1510, 0x1610, 0x1710,
rlm@1 267 0x1810, 0x1910, 0x2030, 0x2130, 0x2230, 0x2330, 0x2430, 0x2530,
rlm@1 268 0x2010, 0x2110, 0x2210, 0x2310, 0x2410, 0x2510, 0x2610, 0x2710,
rlm@1 269 0x2810, 0x2910, 0x3030, 0x3130, 0x3230, 0x3330, 0x3430, 0x3530,
rlm@1 270 0x3010, 0x3110, 0x3210, 0x3310, 0x3410, 0x3510, 0x3610, 0x3710,
rlm@1 271 0x3810, 0x3910, 0x4030, 0x4130, 0x4230, 0x4330, 0x4430, 0x4530,
rlm@1 272 0x4010, 0x4110, 0x4210, 0x4310, 0x4410, 0x4510, 0x4610, 0x4710,
rlm@1 273 0x4810, 0x4910, 0x5030, 0x5130, 0x5230, 0x5330, 0x5430, 0x5530,
rlm@1 274 0x5010, 0x5110, 0x5210, 0x5310, 0x5410, 0x5510, 0x5610, 0x5710,
rlm@1 275 0x5810, 0x5910, 0x6030, 0x6130, 0x6230, 0x6330, 0x6430, 0x6530,
rlm@1 276 0x6010, 0x6110, 0x6210, 0x6310, 0x6410, 0x6510, 0x6610, 0x6710,
rlm@1 277 0x6810, 0x6910, 0x7030, 0x7130, 0x7230, 0x7330, 0x7430, 0x7530,
rlm@1 278 0x7010, 0x7110, 0x7210, 0x7310, 0x7410, 0x7510, 0x7610, 0x7710,
rlm@1 279 0x7810, 0x7910, 0x8030, 0x8130, 0x8230, 0x8330, 0x8430, 0x8530,
rlm@1 280 0x8010, 0x8110, 0x8210, 0x8310, 0x8410, 0x8510, 0x8610, 0x8710,
rlm@1 281 0x8810, 0x8910, 0x9030, 0x9130, 0x9230, 0x9330, 0x9430, 0x9530,
rlm@1 282 0x9010, 0x9110, 0x9210, 0x9310, 0x9410, 0x9510, 0x9610, 0x9710,
rlm@1 283 0x9810, 0x9910, 0xA030, 0xA130, 0xA230, 0xA330, 0xA430, 0xA530,
rlm@1 284 0xA010, 0xA110, 0xA210, 0xA310, 0xA410, 0xA510, 0xA610, 0xA710,
rlm@1 285 0xA810, 0xA910, 0xB030, 0xB130, 0xB230, 0xB330, 0xB430, 0xB530,
rlm@1 286 0xB010, 0xB110, 0xB210, 0xB310, 0xB410, 0xB510, 0xB610, 0xB710,
rlm@1 287 0xB810, 0xB910, 0xC030, 0xC130, 0xC230, 0xC330, 0xC430, 0xC530,
rlm@1 288 0xC010, 0xC110, 0xC210, 0xC310, 0xC410, 0xC510, 0xC610, 0xC710,
rlm@1 289 0xC810, 0xC910, 0xD030, 0xD130, 0xD230, 0xD330, 0xD430, 0xD530,
rlm@1 290 0xD010, 0xD110, 0xD210, 0xD310, 0xD410, 0xD510, 0xD610, 0xD710,
rlm@1 291 0xD810, 0xD910, 0xE030, 0xE130, 0xE230, 0xE330, 0xE430, 0xE530,
rlm@1 292 0xE010, 0xE110, 0xE210, 0xE310, 0xE410, 0xE510, 0xE610, 0xE710,
rlm@1 293 0xE810, 0xE910, 0xF030, 0xF130, 0xF230, 0xF330, 0xF430, 0xF530,
rlm@1 294 0xF010, 0xF110, 0xF210, 0xF310, 0xF410, 0xF510, 0xF610, 0xF710,
rlm@1 295 0xF810, 0xF910, 0x00B0, 0x0130, 0x0230, 0x0330, 0x0430, 0x0530,
rlm@1 296 0x0090, 0x0110, 0x0210, 0x0310, 0x0410, 0x0510, 0x0610, 0x0710,
rlm@1 297 0x0810, 0x0910, 0x1030, 0x1130, 0x1230, 0x1330, 0x1430, 0x1530,
rlm@1 298 0x1010, 0x1110, 0x1210, 0x1310, 0x1410, 0x1510, 0x1610, 0x1710,
rlm@1 299 0x1810, 0x1910, 0x2030, 0x2130, 0x2230, 0x2330, 0x2430, 0x2530,
rlm@1 300 0x2010, 0x2110, 0x2210, 0x2310, 0x2410, 0x2510, 0x2610, 0x2710,
rlm@1 301 0x2810, 0x2910, 0x3030, 0x3130, 0x3230, 0x3330, 0x3430, 0x3530,
rlm@1 302 0x3010, 0x3110, 0x3210, 0x3310, 0x3410, 0x3510, 0x3610, 0x3710,
rlm@1 303 0x3810, 0x3910, 0x4030, 0x4130, 0x4230, 0x4330, 0x4430, 0x4530,
rlm@1 304 0x4010, 0x4110, 0x4210, 0x4310, 0x4410, 0x4510, 0x4610, 0x4710,
rlm@1 305 0x4810, 0x4910, 0x5030, 0x5130, 0x5230, 0x5330, 0x5430, 0x5530,
rlm@1 306 0x5010, 0x5110, 0x5210, 0x5310, 0x5410, 0x5510, 0x5610, 0x5710,
rlm@1 307 0x5810, 0x5910, 0x6030, 0x6130, 0x6230, 0x6330, 0x6430, 0x6530,
rlm@1 308 0x0600, 0x0700, 0x0800, 0x0900, 0x0A00, 0x0B00, 0x0C00, 0x0D00,
rlm@1 309 0x0E00, 0x0F00, 0x1020, 0x1120, 0x1220, 0x1320, 0x1420, 0x1520,
rlm@1 310 0x1600, 0x1700, 0x1800, 0x1900, 0x1A00, 0x1B00, 0x1C00, 0x1D00,
rlm@1 311 0x1E00, 0x1F00, 0x2020, 0x2120, 0x2220, 0x2320, 0x2420, 0x2520,
rlm@1 312 0x2600, 0x2700, 0x2800, 0x2900, 0x2A00, 0x2B00, 0x2C00, 0x2D00,
rlm@1 313 0x2E00, 0x2F00, 0x3020, 0x3120, 0x3220, 0x3320, 0x3420, 0x3520,
rlm@1 314 0x3600, 0x3700, 0x3800, 0x3900, 0x3A00, 0x3B00, 0x3C00, 0x3D00,
rlm@1 315 0x3E00, 0x3F00, 0x4020, 0x4120, 0x4220, 0x4320, 0x4420, 0x4520,
rlm@1 316 0x4600, 0x4700, 0x4800, 0x4900, 0x4A00, 0x4B00, 0x4C00, 0x4D00,
rlm@1 317 0x4E00, 0x4F00, 0x5020, 0x5120, 0x5220, 0x5320, 0x5420, 0x5520,
rlm@1 318 0x5600, 0x5700, 0x5800, 0x5900, 0x5A00, 0x5B00, 0x5C00, 0x5D00,
rlm@1 319 0x5E00, 0x5F00, 0x6020, 0x6120, 0x6220, 0x6320, 0x6420, 0x6520,
rlm@1 320 0x6600, 0x6700, 0x6800, 0x6900, 0x6A00, 0x6B00, 0x6C00, 0x6D00,
rlm@1 321 0x6E00, 0x6F00, 0x7020, 0x7120, 0x7220, 0x7320, 0x7420, 0x7520,
rlm@1 322 0x7600, 0x7700, 0x7800, 0x7900, 0x7A00, 0x7B00, 0x7C00, 0x7D00,
rlm@1 323 0x7E00, 0x7F00, 0x8020, 0x8120, 0x8220, 0x8320, 0x8420, 0x8520,
rlm@1 324 0x8600, 0x8700, 0x8800, 0x8900, 0x8A00, 0x8B00, 0x8C00, 0x8D00,
rlm@1 325 0x8E00, 0x8F00, 0x9020, 0x9120, 0x9220, 0x9320, 0x9420, 0x9520,
rlm@1 326 0x9600, 0x9700, 0x9800, 0x9900, 0x9A00, 0x9B00, 0x9C00, 0x9D00,
rlm@1 327 0x9E00, 0x9F00, 0x00B0, 0x0130, 0x0230, 0x0330, 0x0430, 0x0530,
rlm@1 328 0x0610, 0x0710, 0x0810, 0x0910, 0x0A10, 0x0B10, 0x0C10, 0x0D10,
rlm@1 329 0x0E10, 0x0F10, 0x1030, 0x1130, 0x1230, 0x1330, 0x1430, 0x1530,
rlm@1 330 0x1610, 0x1710, 0x1810, 0x1910, 0x1A10, 0x1B10, 0x1C10, 0x1D10,
rlm@1 331 0x1E10, 0x1F10, 0x2030, 0x2130, 0x2230, 0x2330, 0x2430, 0x2530,
rlm@1 332 0x2610, 0x2710, 0x2810, 0x2910, 0x2A10, 0x2B10, 0x2C10, 0x2D10,
rlm@1 333 0x2E10, 0x2F10, 0x3030, 0x3130, 0x3230, 0x3330, 0x3430, 0x3530,
rlm@1 334 0x3610, 0x3710, 0x3810, 0x3910, 0x3A10, 0x3B10, 0x3C10, 0x3D10,
rlm@1 335 0x3E10, 0x3F10, 0x4030, 0x4130, 0x4230, 0x4330, 0x4430, 0x4530,
rlm@1 336 0x4610, 0x4710, 0x4810, 0x4910, 0x4A10, 0x4B10, 0x4C10, 0x4D10,
rlm@1 337 0x4E10, 0x4F10, 0x5030, 0x5130, 0x5230, 0x5330, 0x5430, 0x5530,
rlm@1 338 0x5610, 0x5710, 0x5810, 0x5910, 0x5A10, 0x5B10, 0x5C10, 0x5D10,
rlm@1 339 0x5E10, 0x5F10, 0x6030, 0x6130, 0x6230, 0x6330, 0x6430, 0x6530,
rlm@1 340 0x6610, 0x6710, 0x6810, 0x6910, 0x6A10, 0x6B10, 0x6C10, 0x6D10,
rlm@1 341 0x6E10, 0x6F10, 0x7030, 0x7130, 0x7230, 0x7330, 0x7430, 0x7530,
rlm@1 342 0x7610, 0x7710, 0x7810, 0x7910, 0x7A10, 0x7B10, 0x7C10, 0x7D10,
rlm@1 343 0x7E10, 0x7F10, 0x8030, 0x8130, 0x8230, 0x8330, 0x8430, 0x8530,
rlm@1 344 0x8610, 0x8710, 0x8810, 0x8910, 0x8A10, 0x8B10, 0x8C10, 0x8D10,
rlm@1 345 0x8E10, 0x8F10, 0x9030, 0x9130, 0x9230, 0x9330, 0x9430, 0x9530,
rlm@1 346 0x9610, 0x9710, 0x9810, 0x9910, 0x9A10, 0x9B10, 0x9C10, 0x9D10,
rlm@1 347 0x9E10, 0x9F10, 0xA030, 0xA130, 0xA230, 0xA330, 0xA430, 0xA530,
rlm@1 348 0xA610, 0xA710, 0xA810, 0xA910, 0xAA10, 0xAB10, 0xAC10, 0xAD10,
rlm@1 349 0xAE10, 0xAF10, 0xB030, 0xB130, 0xB230, 0xB330, 0xB430, 0xB530,
rlm@1 350 0xB610, 0xB710, 0xB810, 0xB910, 0xBA10, 0xBB10, 0xBC10, 0xBD10,
rlm@1 351 0xBE10, 0xBF10, 0xC030, 0xC130, 0xC230, 0xC330, 0xC430, 0xC530,
rlm@1 352 0xC610, 0xC710, 0xC810, 0xC910, 0xCA10, 0xCB10, 0xCC10, 0xCD10,
rlm@1 353 0xCE10, 0xCF10, 0xD030, 0xD130, 0xD230, 0xD330, 0xD430, 0xD530,
rlm@1 354 0xD610, 0xD710, 0xD810, 0xD910, 0xDA10, 0xDB10, 0xDC10, 0xDD10,
rlm@1 355 0xDE10, 0xDF10, 0xE030, 0xE130, 0xE230, 0xE330, 0xE430, 0xE530,
rlm@1 356 0xE610, 0xE710, 0xE810, 0xE910, 0xEA10, 0xEB10, 0xEC10, 0xED10,
rlm@1 357 0xEE10, 0xEF10, 0xF030, 0xF130, 0xF230, 0xF330, 0xF430, 0xF530,
rlm@1 358 0xF610, 0xF710, 0xF810, 0xF910, 0xFA10, 0xFB10, 0xFC10, 0xFD10,
rlm@1 359 0xFE10, 0xFF10, 0x00B0, 0x0130, 0x0230, 0x0330, 0x0430, 0x0530,
rlm@1 360 0x0610, 0x0710, 0x0810, 0x0910, 0x0A10, 0x0B10, 0x0C10, 0x0D10,
rlm@1 361 0x0E10, 0x0F10, 0x1030, 0x1130, 0x1230, 0x1330, 0x1430, 0x1530,
rlm@1 362 0x1610, 0x1710, 0x1810, 0x1910, 0x1A10, 0x1B10, 0x1C10, 0x1D10,
rlm@1 363 0x1E10, 0x1F10, 0x2030, 0x2130, 0x2230, 0x2330, 0x2430, 0x2530,
rlm@1 364 0x2610, 0x2710, 0x2810, 0x2910, 0x2A10, 0x2B10, 0x2C10, 0x2D10,
rlm@1 365 0x2E10, 0x2F10, 0x3030, 0x3130, 0x3230, 0x3330, 0x3430, 0x3530,
rlm@1 366 0x3610, 0x3710, 0x3810, 0x3910, 0x3A10, 0x3B10, 0x3C10, 0x3D10,
rlm@1 367 0x3E10, 0x3F10, 0x4030, 0x4130, 0x4230, 0x4330, 0x4430, 0x4530,
rlm@1 368 0x4610, 0x4710, 0x4810, 0x4910, 0x4A10, 0x4B10, 0x4C10, 0x4D10,
rlm@1 369 0x4E10, 0x4F10, 0x5030, 0x5130, 0x5230, 0x5330, 0x5430, 0x5530,
rlm@1 370 0x5610, 0x5710, 0x5810, 0x5910, 0x5A10, 0x5B10, 0x5C10, 0x5D10,
rlm@1 371 0x5E10, 0x5F10, 0x6030, 0x6130, 0x6230, 0x6330, 0x6430, 0x6530,
rlm@1 372 0x00C0, 0x0140, 0x0240, 0x0340, 0x0440, 0x0540, 0x0640, 0x0740,
rlm@1 373 0x0840, 0x0940, 0x0440, 0x0540, 0x0640, 0x0740, 0x0840, 0x0940,
rlm@1 374 0x1040, 0x1140, 0x1240, 0x1340, 0x1440, 0x1540, 0x1640, 0x1740,
rlm@1 375 0x1840, 0x1940, 0x1440, 0x1540, 0x1640, 0x1740, 0x1840, 0x1940,
rlm@1 376 0x2040, 0x2140, 0x2240, 0x2340, 0x2440, 0x2540, 0x2640, 0x2740,
rlm@1 377 0x2840, 0x2940, 0x2440, 0x2540, 0x2640, 0x2740, 0x2840, 0x2940,
rlm@1 378 0x3040, 0x3140, 0x3240, 0x3340, 0x3440, 0x3540, 0x3640, 0x3740,
rlm@1 379 0x3840, 0x3940, 0x3440, 0x3540, 0x3640, 0x3740, 0x3840, 0x3940,
rlm@1 380 0x4040, 0x4140, 0x4240, 0x4340, 0x4440, 0x4540, 0x4640, 0x4740,
rlm@1 381 0x4840, 0x4940, 0x4440, 0x4540, 0x4640, 0x4740, 0x4840, 0x4940,
rlm@1 382 0x5040, 0x5140, 0x5240, 0x5340, 0x5440, 0x5540, 0x5640, 0x5740,
rlm@1 383 0x5840, 0x5940, 0x5440, 0x5540, 0x5640, 0x5740, 0x5840, 0x5940,
rlm@1 384 0x6040, 0x6140, 0x6240, 0x6340, 0x6440, 0x6540, 0x6640, 0x6740,
rlm@1 385 0x6840, 0x6940, 0x6440, 0x6540, 0x6640, 0x6740, 0x6840, 0x6940,
rlm@1 386 0x7040, 0x7140, 0x7240, 0x7340, 0x7440, 0x7540, 0x7640, 0x7740,
rlm@1 387 0x7840, 0x7940, 0x7440, 0x7540, 0x7640, 0x7740, 0x7840, 0x7940,
rlm@1 388 0x8040, 0x8140, 0x8240, 0x8340, 0x8440, 0x8540, 0x8640, 0x8740,
rlm@1 389 0x8840, 0x8940, 0x8440, 0x8540, 0x8640, 0x8740, 0x8840, 0x8940,
rlm@1 390 0x9040, 0x9140, 0x9240, 0x9340, 0x9440, 0x9540, 0x9640, 0x9740,
rlm@1 391 0x9840, 0x9940, 0x3450, 0x3550, 0x3650, 0x3750, 0x3850, 0x3950,
rlm@1 392 0x4050, 0x4150, 0x4250, 0x4350, 0x4450, 0x4550, 0x4650, 0x4750,
rlm@1 393 0x4850, 0x4950, 0x4450, 0x4550, 0x4650, 0x4750, 0x4850, 0x4950,
rlm@1 394 0x5050, 0x5150, 0x5250, 0x5350, 0x5450, 0x5550, 0x5650, 0x5750,
rlm@1 395 0x5850, 0x5950, 0x5450, 0x5550, 0x5650, 0x5750, 0x5850, 0x5950,
rlm@1 396 0x6050, 0x6150, 0x6250, 0x6350, 0x6450, 0x6550, 0x6650, 0x6750,
rlm@1 397 0x6850, 0x6950, 0x6450, 0x6550, 0x6650, 0x6750, 0x6850, 0x6950,
rlm@1 398 0x7050, 0x7150, 0x7250, 0x7350, 0x7450, 0x7550, 0x7650, 0x7750,
rlm@1 399 0x7850, 0x7950, 0x7450, 0x7550, 0x7650, 0x7750, 0x7850, 0x7950,
rlm@1 400 0x8050, 0x8150, 0x8250, 0x8350, 0x8450, 0x8550, 0x8650, 0x8750,
rlm@1 401 0x8850, 0x8950, 0x8450, 0x8550, 0x8650, 0x8750, 0x8850, 0x8950,
rlm@1 402 0x9050, 0x9150, 0x9250, 0x9350, 0x9450, 0x9550, 0x9650, 0x9750,
rlm@1 403 0x9850, 0x9950, 0x9450, 0x9550, 0x9650, 0x9750, 0x9850, 0x9950,
rlm@1 404 0xA050, 0xA150, 0xA250, 0xA350, 0xA450, 0xA550, 0xA650, 0xA750,
rlm@1 405 0xA850, 0xA950, 0xA450, 0xA550, 0xA650, 0xA750, 0xA850, 0xA950,
rlm@1 406 0xB050, 0xB150, 0xB250, 0xB350, 0xB450, 0xB550, 0xB650, 0xB750,
rlm@1 407 0xB850, 0xB950, 0xB450, 0xB550, 0xB650, 0xB750, 0xB850, 0xB950,
rlm@1 408 0xC050, 0xC150, 0xC250, 0xC350, 0xC450, 0xC550, 0xC650, 0xC750,
rlm@1 409 0xC850, 0xC950, 0xC450, 0xC550, 0xC650, 0xC750, 0xC850, 0xC950,
rlm@1 410 0xD050, 0xD150, 0xD250, 0xD350, 0xD450, 0xD550, 0xD650, 0xD750,
rlm@1 411 0xD850, 0xD950, 0xD450, 0xD550, 0xD650, 0xD750, 0xD850, 0xD950,
rlm@1 412 0xE050, 0xE150, 0xE250, 0xE350, 0xE450, 0xE550, 0xE650, 0xE750,
rlm@1 413 0xE850, 0xE950, 0xE450, 0xE550, 0xE650, 0xE750, 0xE850, 0xE950,
rlm@1 414 0xF050, 0xF150, 0xF250, 0xF350, 0xF450, 0xF550, 0xF650, 0xF750,
rlm@1 415 0xF850, 0xF950, 0xF450, 0xF550, 0xF650, 0xF750, 0xF850, 0xF950,
rlm@1 416 0x00D0, 0x0150, 0x0250, 0x0350, 0x0450, 0x0550, 0x0650, 0x0750,
rlm@1 417 0x0850, 0x0950, 0x0450, 0x0550, 0x0650, 0x0750, 0x0850, 0x0950,
rlm@1 418 0x1050, 0x1150, 0x1250, 0x1350, 0x1450, 0x1550, 0x1650, 0x1750,
rlm@1 419 0x1850, 0x1950, 0x1450, 0x1550, 0x1650, 0x1750, 0x1850, 0x1950,
rlm@1 420 0x2050, 0x2150, 0x2250, 0x2350, 0x2450, 0x2550, 0x2650, 0x2750,
rlm@1 421 0x2850, 0x2950, 0x2450, 0x2550, 0x2650, 0x2750, 0x2850, 0x2950,
rlm@1 422 0x3050, 0x3150, 0x3250, 0x3350, 0x3450, 0x3550, 0x3650, 0x3750,
rlm@1 423 0x3850, 0x3950, 0x3450, 0x3550, 0x3650, 0x3750, 0x3850, 0x3950,
rlm@1 424 0x4050, 0x4150, 0x4250, 0x4350, 0x4450, 0x4550, 0x4650, 0x4750,
rlm@1 425 0x4850, 0x4950, 0x4450, 0x4550, 0x4650, 0x4750, 0x4850, 0x4950,
rlm@1 426 0x5050, 0x5150, 0x5250, 0x5350, 0x5450, 0x5550, 0x5650, 0x5750,
rlm@1 427 0x5850, 0x5950, 0x5450, 0x5550, 0x5650, 0x5750, 0x5850, 0x5950,
rlm@1 428 0x6050, 0x6150, 0x6250, 0x6350, 0x6450, 0x6550, 0x6650, 0x6750,
rlm@1 429 0x6850, 0x6950, 0x6450, 0x6550, 0x6650, 0x6750, 0x6850, 0x6950,
rlm@1 430 0x7050, 0x7150, 0x7250, 0x7350, 0x7450, 0x7550, 0x7650, 0x7750,
rlm@1 431 0x7850, 0x7950, 0x7450, 0x7550, 0x7650, 0x7750, 0x7850, 0x7950,
rlm@1 432 0x8050, 0x8150, 0x8250, 0x8350, 0x8450, 0x8550, 0x8650, 0x8750,
rlm@1 433 0x8850, 0x8950, 0x8450, 0x8550, 0x8650, 0x8750, 0x8850, 0x8950,
rlm@1 434 0x9050, 0x9150, 0x9250, 0x9350, 0x9450, 0x9550, 0x9650, 0x9750,
rlm@1 435 0x9850, 0x9950, 0x9450, 0x9550, 0x9650, 0x9750, 0x9850, 0x9950,
rlm@1 436 0xFA60, 0xFB60, 0xFC60, 0xFD60, 0xFE60, 0xFF60, 0x00C0, 0x0140,
rlm@1 437 0x0240, 0x0340, 0x0440, 0x0540, 0x0640, 0x0740, 0x0840, 0x0940,
rlm@1 438 0x0A60, 0x0B60, 0x0C60, 0x0D60, 0x0E60, 0x0F60, 0x1040, 0x1140,
rlm@1 439 0x1240, 0x1340, 0x1440, 0x1540, 0x1640, 0x1740, 0x1840, 0x1940,
rlm@1 440 0x1A60, 0x1B60, 0x1C60, 0x1D60, 0x1E60, 0x1F60, 0x2040, 0x2140,
rlm@1 441 0x2240, 0x2340, 0x2440, 0x2540, 0x2640, 0x2740, 0x2840, 0x2940,
rlm@1 442 0x2A60, 0x2B60, 0x2C60, 0x2D60, 0x2E60, 0x2F60, 0x3040, 0x3140,
rlm@1 443 0x3240, 0x3340, 0x3440, 0x3540, 0x3640, 0x3740, 0x3840, 0x3940,
rlm@1 444 0x3A60, 0x3B60, 0x3C60, 0x3D60, 0x3E60, 0x3F60, 0x4040, 0x4140,
rlm@1 445 0x4240, 0x4340, 0x4440, 0x4540, 0x4640, 0x4740, 0x4840, 0x4940,
rlm@1 446 0x4A60, 0x4B60, 0x4C60, 0x4D60, 0x4E60, 0x4F60, 0x5040, 0x5140,
rlm@1 447 0x5240, 0x5340, 0x5440, 0x5540, 0x5640, 0x5740, 0x5840, 0x5940,
rlm@1 448 0x5A60, 0x5B60, 0x5C60, 0x5D60, 0x5E60, 0x5F60, 0x6040, 0x6140,
rlm@1 449 0x6240, 0x6340, 0x6440, 0x6540, 0x6640, 0x6740, 0x6840, 0x6940,
rlm@1 450 0x6A60, 0x6B60, 0x6C60, 0x6D60, 0x6E60, 0x6F60, 0x7040, 0x7140,
rlm@1 451 0x7240, 0x7340, 0x7440, 0x7540, 0x7640, 0x7740, 0x7840, 0x7940,
rlm@1 452 0x7A60, 0x7B60, 0x7C60, 0x7D60, 0x7E60, 0x7F60, 0x8040, 0x8140,
rlm@1 453 0x8240, 0x8340, 0x8440, 0x8540, 0x8640, 0x8740, 0x8840, 0x8940,
rlm@1 454 0x8A60, 0x8B60, 0x8C60, 0x8D60, 0x8E60, 0x8F60, 0x9040, 0x9140,
rlm@1 455 0x9240, 0x9340, 0x3450, 0x3550, 0x3650, 0x3750, 0x3850, 0x3950,
rlm@1 456 0x3A70, 0x3B70, 0x3C70, 0x3D70, 0x3E70, 0x3F70, 0x4050, 0x4150,
rlm@1 457 0x4250, 0x4350, 0x4450, 0x4550, 0x4650, 0x4750, 0x4850, 0x4950,
rlm@1 458 0x4A70, 0x4B70, 0x4C70, 0x4D70, 0x4E70, 0x4F70, 0x5050, 0x5150,
rlm@1 459 0x5250, 0x5350, 0x5450, 0x5550, 0x5650, 0x5750, 0x5850, 0x5950,
rlm@1 460 0x5A70, 0x5B70, 0x5C70, 0x5D70, 0x5E70, 0x5F70, 0x6050, 0x6150,
rlm@1 461 0x6250, 0x6350, 0x6450, 0x6550, 0x6650, 0x6750, 0x6850, 0x6950,
rlm@1 462 0x6A70, 0x6B70, 0x6C70, 0x6D70, 0x6E70, 0x6F70, 0x7050, 0x7150,
rlm@1 463 0x7250, 0x7350, 0x7450, 0x7550, 0x7650, 0x7750, 0x7850, 0x7950,
rlm@1 464 0x7A70, 0x7B70, 0x7C70, 0x7D70, 0x7E70, 0x7F70, 0x8050, 0x8150,
rlm@1 465 0x8250, 0x8350, 0x8450, 0x8550, 0x8650, 0x8750, 0x8850, 0x8950,
rlm@1 466 0x8A70, 0x8B70, 0x8C70, 0x8D70, 0x8E70, 0x8F70, 0x9050, 0x9150,
rlm@1 467 0x9250, 0x9350, 0x9450, 0x9550, 0x9650, 0x9750, 0x9850, 0x9950,
rlm@1 468 0x9A70, 0x9B70, 0x9C70, 0x9D70, 0x9E70, 0x9F70, 0xA050, 0xA150,
rlm@1 469 0xA250, 0xA350, 0xA450, 0xA550, 0xA650, 0xA750, 0xA850, 0xA950,
rlm@1 470 0xAA70, 0xAB70, 0xAC70, 0xAD70, 0xAE70, 0xAF70, 0xB050, 0xB150,
rlm@1 471 0xB250, 0xB350, 0xB450, 0xB550, 0xB650, 0xB750, 0xB850, 0xB950,
rlm@1 472 0xBA70, 0xBB70, 0xBC70, 0xBD70, 0xBE70, 0xBF70, 0xC050, 0xC150,
rlm@1 473 0xC250, 0xC350, 0xC450, 0xC550, 0xC650, 0xC750, 0xC850, 0xC950,
rlm@1 474 0xCA70, 0xCB70, 0xCC70, 0xCD70, 0xCE70, 0xCF70, 0xD050, 0xD150,
rlm@1 475 0xD250, 0xD350, 0xD450, 0xD550, 0xD650, 0xD750, 0xD850, 0xD950,
rlm@1 476 0xDA70, 0xDB70, 0xDC70, 0xDD70, 0xDE70, 0xDF70, 0xE050, 0xE150,
rlm@1 477 0xE250, 0xE350, 0xE450, 0xE550, 0xE650, 0xE750, 0xE850, 0xE950,
rlm@1 478 0xEA70, 0xEB70, 0xEC70, 0xED70, 0xEE70, 0xEF70, 0xF050, 0xF150,
rlm@1 479 0xF250, 0xF350, 0xF450, 0xF550, 0xF650, 0xF750, 0xF850, 0xF950,
rlm@1 480 0xFA70, 0xFB70, 0xFC70, 0xFD70, 0xFE70, 0xFF70, 0x00D0, 0x0150,
rlm@1 481 0x0250, 0x0350, 0x0450, 0x0550, 0x0650, 0x0750, 0x0850, 0x0950,
rlm@1 482 0x0A70, 0x0B70, 0x0C70, 0x0D70, 0x0E70, 0x0F70, 0x1050, 0x1150,
rlm@1 483 0x1250, 0x1350, 0x1450, 0x1550, 0x1650, 0x1750, 0x1850, 0x1950,
rlm@1 484 0x1A70, 0x1B70, 0x1C70, 0x1D70, 0x1E70, 0x1F70, 0x2050, 0x2150,
rlm@1 485 0x2250, 0x2350, 0x2450, 0x2550, 0x2650, 0x2750, 0x2850, 0x2950,
rlm@1 486 0x2A70, 0x2B70, 0x2C70, 0x2D70, 0x2E70, 0x2F70, 0x3050, 0x3150,
rlm@1 487 0x3250, 0x3350, 0x3450, 0x3550, 0x3650, 0x3750, 0x3850, 0x3950,
rlm@1 488 0x3A70, 0x3B70, 0x3C70, 0x3D70, 0x3E70, 0x3F70, 0x4050, 0x4150,
rlm@1 489 0x4250, 0x4350, 0x4450, 0x4550, 0x4650, 0x4750, 0x4850, 0x4950,
rlm@1 490 0x4A70, 0x4B70, 0x4C70, 0x4D70, 0x4E70, 0x4F70, 0x5050, 0x5150,
rlm@1 491 0x5250, 0x5350, 0x5450, 0x5550, 0x5650, 0x5750, 0x5850, 0x5950,
rlm@1 492 0x5A70, 0x5B70, 0x5C70, 0x5D70, 0x5E70, 0x5F70, 0x6050, 0x6150,
rlm@1 493 0x6250, 0x6350, 0x6450, 0x6550, 0x6650, 0x6750, 0x6850, 0x6950,
rlm@1 494 0x6A70, 0x6B70, 0x6C70, 0x6D70, 0x6E70, 0x6F70, 0x7050, 0x7150,
rlm@1 495 0x7250, 0x7350, 0x7450, 0x7550, 0x7650, 0x7750, 0x7850, 0x7950,
rlm@1 496 0x7A70, 0x7B70, 0x7C70, 0x7D70, 0x7E70, 0x7F70, 0x8050, 0x8150,
rlm@1 497 0x8250, 0x8350, 0x8450, 0x8550, 0x8650, 0x8750, 0x8850, 0x8950,
rlm@1 498 0x8A70, 0x8B70, 0x8C70, 0x8D70, 0x8E70, 0x8F70, 0x9050, 0x9150,
rlm@1 499 0x9250, 0x9350, 0x9450, 0x9550, 0x9650, 0x9750, 0x9850, 0x9950,
rlm@1 500 };
rlm@1 501
rlm@1 502 u8 ZeroTable[] =
rlm@1 503 {
rlm@1 504 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 505 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 506 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 507 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 508 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 509 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 510 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 511 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 512 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 513 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 514 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 515 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 516 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 517 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 518 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
rlm@1 519 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
rlm@1 520 };
rlm@1 521
rlm@1 522 #define GBSAVE_GAME_VERSION_1 1
rlm@1 523 #define GBSAVE_GAME_VERSION_2 2
rlm@1 524 #define GBSAVE_GAME_VERSION_3 3
rlm@1 525 #define GBSAVE_GAME_VERSION_4 4
rlm@1 526 #define GBSAVE_GAME_VERSION_5 5
rlm@1 527 #define GBSAVE_GAME_VERSION_6 6
rlm@1 528 #define GBSAVE_GAME_VERSION_7 7
rlm@1 529 #define GBSAVE_GAME_VERSION_8 8
rlm@1 530 #define GBSAVE_GAME_VERSION_9 9
rlm@1 531 #define GBSAVE_GAME_VERSION_10 10
rlm@1 532 #define GBSAVE_GAME_VERSION_11 11
rlm@1 533 #define GBSAVE_GAME_VERSION_12 12
rlm@1 534 #define GBSAVE_GAME_VERSION_13 13
rlm@1 535 #define GBSAVE_GAME_VERSION GBSAVE_GAME_VERSION_13
rlm@1 536
rlm@1 537 int inline gbGetValue(int min, int max, int v)
rlm@1 538 {
rlm@1 539 return (int)(min + (float)(max - min) * (2.0 * (v / 31.0) - (v / 31.0) * (v / 31.0)));
rlm@1 540 }
rlm@1 541
rlm@1 542 void gbGenFilter()
rlm@1 543 {
rlm@1 544 for (int r = 0; r < 32; r++)
rlm@1 545 {
rlm@1 546 for (int g = 0; g < 32; g++)
rlm@1 547 {
rlm@1 548 for (int b = 0; b < 32; b++)
rlm@1 549 {
rlm@1 550 int nr = gbGetValue(gbGetValue(4, 14, g),
rlm@1 551 gbGetValue(24, 29, g), r) - 4;
rlm@1 552 int ng = gbGetValue(gbGetValue(4 + gbGetValue(0, 5, r),
rlm@1 553 14 + gbGetValue(0, 3, r), b),
rlm@1 554 gbGetValue(24 + gbGetValue(0, 3, r),
rlm@1 555 29 + gbGetValue(0, 1, r), b), g) - 4;
rlm@1 556 int nb = gbGetValue(gbGetValue(4 + gbGetValue(0, 5, r),
rlm@1 557 14 + gbGetValue(0, 3, r), g),
rlm@1 558 gbGetValue(24 + gbGetValue(0, 3, r),
rlm@1 559 29 + gbGetValue(0, 1, r), g), b) - 4;
rlm@1 560 gbColorFilter[(b << 10) | (g << 5) | r] = (nb << 10) | (ng << 5) | nr;
rlm@1 561 }
rlm@1 562 }
rlm@1 563 }
rlm@1 564 }
rlm@1 565
rlm@1 566 void gbCopyMemory(u16 d, u16 s, int count)
rlm@1 567 {
rlm@1 568 while (count)
rlm@1 569 {
rlm@1 570 gbWriteMemoryQuick(d, gbReadMemoryQuick(s));
rlm@1 571 s++;
rlm@1 572 d++;
rlm@1 573 count--;
rlm@1 574 }
rlm@1 575 }
rlm@1 576
rlm@1 577 void gbDoHdma()
rlm@1 578 {
rlm@1 579 gbCopyMemory(gbHdmaDestination, gbHdmaSource, 0x10);
rlm@1 580
rlm@1 581 gbHdmaDestination += 0x10;
rlm@1 582 gbHdmaSource += 0x10;
rlm@1 583
rlm@1 584 register_HDMA2 = (register_HDMA2 + 0x10) & 0xFF;
rlm@1 585 if (register_HDMA2 == 0x00)
rlm@1 586 register_HDMA1++;
rlm@1 587
rlm@1 588 register_HDMA4 = (register_HDMA4 + 0x10) & 0xFF;
rlm@1 589 if (register_HDMA4 == 0x00)
rlm@1 590 register_HDMA3++;
rlm@1 591
rlm@1 592 if (gbHdmaDestination == 0x96b0)
rlm@1 593 gbHdmaBytes = gbHdmaBytes;
rlm@1 594 gbHdmaBytes -= 0x10;
rlm@1 595 register_HDMA5--;
rlm@1 596 if (register_HDMA5 == 0xff)
rlm@1 597 gbHdmaOn = 0;
rlm@1 598 }
rlm@1 599
rlm@1 600 // fix for Harley and Lego Racers
rlm@1 601 void gbCompareLYToLYC()
rlm@1 602 {
rlm@1 603 if (register_LY == register_LYC)
rlm@1 604 {
rlm@1 605 // mark that we have a match
rlm@1 606 register_STAT |= 4;
rlm@1 607
rlm@1 608 // check if we need an interrupt
rlm@1 609 if ((register_STAT & 0x40) && (register_IE & 2))
rlm@1 610 gbInterrupt |= 2;
rlm@1 611 }
rlm@1 612 else // no match
rlm@1 613 register_STAT &= 0xfb;
rlm@1 614 }
rlm@1 615
rlm@1 616 // FIXME: horrible kludge to workaround the frame timing bug
rlm@1 617 static int32 s_gbJoymask[4] = { 0, 0, 0, 0 };
rlm@1 618
rlm@1 619 void gbWriteMemoryWrapped(register u16 address, register u8 value)
rlm@1 620 {
rlm@1 621 if (address < 0x8000)
rlm@1 622 {
rlm@1 623 #ifndef FINAL_VERSION
rlm@1 624 if (memorydebug && (address > 0x3fff || address < 0x2000))
rlm@1 625 {
rlm@1 626 log("Memory register write %04x=%02x PC=%04x\n",
rlm@1 627 address,
rlm@1 628 value,
rlm@1 629 PC.W);
rlm@1 630 }
rlm@1 631 #endif
rlm@1 632 if (mapper)
rlm@1 633 (*mapper)(address, value);
rlm@1 634 return;
rlm@1 635 }
rlm@1 636
rlm@1 637 if (address < 0xa000)
rlm@1 638 {
rlm@1 639 gbWriteMemoryQuick(address, value);
rlm@1 640 return;
rlm@1 641 }
rlm@1 642
rlm@1 643 if (address < 0xc000)
rlm@1 644 {
rlm@1 645 #ifndef FINAL_VERSION
rlm@1 646 if (memorydebug)
rlm@1 647 {
rlm@1 648 log("Memory register write %04x=%02x PC=%04x\n",
rlm@1 649 address,
rlm@1 650 value,
rlm@1 651 PC.W);
rlm@1 652 }
rlm@1 653 #endif
rlm@1 654
rlm@1 655 if (mapper)
rlm@1 656 (*mapperRAM)(address, value);
rlm@1 657 return;
rlm@1 658 }
rlm@1 659
rlm@1 660 if (address < 0xfe00)
rlm@1 661 {
rlm@1 662 gbWriteMemoryQuick(address, value);
rlm@1 663 return;
rlm@1 664 }
rlm@1 665
rlm@1 666 if (address < 0xff00)
rlm@1 667 {
rlm@1 668 gbMemory[address] = value;
rlm@1 669 return;
rlm@1 670 }
rlm@1 671
rlm@1 672 switch (address & 0x00ff)
rlm@1 673 {
rlm@1 674 case 0x00:
rlm@1 675 {
rlm@1 676 gbMemory[0xff00] = ((gbMemory[0xff00] & 0xcf) |
rlm@1 677 (value & 0x30));
rlm@1 678 if (gbSgbMode)
rlm@1 679 {
rlm@1 680 gbSgbDoBitTransfer(value);
rlm@1 681 }
rlm@1 682
rlm@1 683 return;
rlm@1 684 }
rlm@1 685
rlm@1 686 case 0x01:
rlm@1 687 {
rlm@1 688 gbMemory[0xff01] = value;
rlm@1 689 return;
rlm@1 690 }
rlm@1 691
rlm@1 692 // serial control
rlm@1 693 case 0x02:
rlm@1 694 {
rlm@1 695 gbSerialOn = (value & 0x80);
rlm@1 696 gbMemory[0xff02] = value;
rlm@1 697 if (gbSerialOn)
rlm@1 698 {
rlm@1 699 gbSerialTicks = GBSERIAL_CLOCK_TICKS;
rlm@1 700 #ifdef LINK_EMULATION
rlm@1 701 if (linkConnected)
rlm@1 702 {
rlm@1 703 if (value & 1)
rlm@1 704 {
rlm@1 705 linkSendByte(0x100 | gbMemory[0xFF01]);
rlm@1 706 Sleep(5);
rlm@1 707 }
rlm@1 708 }
rlm@1 709 #endif
rlm@1 710 }
rlm@1 711
rlm@1 712 gbSerialBits = 0;
rlm@1 713 return;
rlm@1 714 }
rlm@1 715
rlm@1 716 // DIV register resets on any write
rlm@1 717 case 0x04:
rlm@1 718 {
rlm@1 719 register_DIV = 0;
rlm@1 720 return;
rlm@1 721 }
rlm@1 722 case 0x05:
rlm@1 723 register_TIMA = value;
rlm@1 724 return;
rlm@1 725
rlm@1 726 case 0x06:
rlm@1 727 register_TMA = value;
rlm@1 728 return;
rlm@1 729
rlm@1 730 // TIMER control
rlm@1 731 case 0x07:
rlm@1 732 {
rlm@1 733 register_TAC = value;
rlm@1 734
rlm@1 735 gbTimerOn = (value & 4);
rlm@1 736 gbTimerMode = value & 3;
rlm@1 737 // register_TIMA = register_TMA;
rlm@1 738 switch (gbTimerMode)
rlm@1 739 {
rlm@1 740 case 0:
rlm@1 741 gbTimerClockTicks = gbTimerTicks = GBTIMER_MODE_0_CLOCK_TICKS;
rlm@1 742 break;
rlm@1 743 case 1:
rlm@1 744 gbTimerClockTicks = gbTimerTicks = GBTIMER_MODE_1_CLOCK_TICKS;
rlm@1 745 break;
rlm@1 746 case 2:
rlm@1 747 gbTimerClockTicks = gbTimerTicks = GBTIMER_MODE_2_CLOCK_TICKS;
rlm@1 748 break;
rlm@1 749 case 3:
rlm@1 750 gbTimerClockTicks = gbTimerTicks = GBTIMER_MODE_3_CLOCK_TICKS;
rlm@1 751 break;
rlm@1 752 }
rlm@1 753 return;
rlm@1 754 }
rlm@1 755
rlm@1 756 case 0x0f:
rlm@1 757 {
rlm@1 758 register_IF = value;
rlm@1 759 gbInterrupt = value;
rlm@1 760 return;
rlm@1 761 }
rlm@1 762
rlm@1 763 case 0x10:
rlm@1 764 case 0x11:
rlm@1 765 case 0x12:
rlm@1 766 case 0x13:
rlm@1 767 case 0x14:
rlm@1 768 case 0x15:
rlm@1 769 case 0x16:
rlm@1 770 case 0x17:
rlm@1 771 case 0x18:
rlm@1 772 case 0x19:
rlm@1 773 case 0x1a:
rlm@1 774 case 0x1b:
rlm@1 775 case 0x1c:
rlm@1 776 case 0x1d:
rlm@1 777 case 0x1e:
rlm@1 778 case 0x1f:
rlm@1 779 case 0x20:
rlm@1 780 case 0x21:
rlm@1 781 case 0x22:
rlm@1 782 case 0x23:
rlm@1 783 case 0x24:
rlm@1 784 case 0x25:
rlm@1 785 case 0x26:
rlm@1 786 {
rlm@1 787 SOUND_EVENT(address, value);
rlm@1 788 return;
rlm@1 789 }
rlm@1 790 case 0x40:
rlm@1 791 {
rlm@1 792 int lcdChange = (register_LCDC & 0x80) ^ (value & 0x80);
rlm@1 793
rlm@1 794 if (lcdChange)
rlm@1 795 {
rlm@1 796 if (value & 0x80)
rlm@1 797 {
rlm@1 798 gbLcdTicks = GBLCD_MODE_1_CLOCK_TICKS;
rlm@1 799 gbLcdMode = 0;
rlm@1 800 register_STAT &= 0xfc;
rlm@1 801 register_LY = 0x00;
rlm@1 802 // FIXME: horrible workaround
rlm@1 803 if (gbNullInputHackTempEnabled && !useOldFrameTiming)
rlm@1 804 memcpy(gbJoymask, s_gbJoymask, sizeof(gbJoymask));
rlm@1 805 }
rlm@1 806 else
rlm@1 807 {
rlm@1 808 gbLcdTicks = 0;
rlm@1 809 gbLcdMode = 0;
rlm@1 810 register_STAT &= 0xfc;
rlm@1 811 register_LY = 0x00;
rlm@1 812 // FIXME: horrible workaround
rlm@1 813 memcpy(s_gbJoymask, gbJoymask, sizeof(gbJoymask));
rlm@1 814 if (gbNullInputHackTempEnabled && !useOldFrameTiming)
rlm@1 815 memset(gbJoymask, 0, sizeof(gbJoymask));
rlm@1 816 }
rlm@1 817 // compareLYToLYC();
rlm@1 818 }
rlm@1 819 // don't draw the window if it was not enabled and not being drawn before
rlm@1 820 if (!(register_LCDC & 0x20) && (value & 0x20) && gbWindowLine == -1 &&
rlm@1 821 register_LY > register_WY)
rlm@1 822 gbWindowLine = 144;
rlm@1 823
rlm@1 824 register_LCDC = value;
rlm@1 825
rlm@1 826 return;
rlm@1 827 }
rlm@1 828
rlm@1 829 // STAT
rlm@1 830 case 0x41:
rlm@1 831 {
rlm@1 832 //register_STAT = (register_STAT & 0x87) |
rlm@1 833 // (value & 0x7c);
rlm@1 834 register_STAT = (value & 0xf8) | (register_STAT & 0x07); // fix ?
rlm@1 835 // GB bug from Devrs FAQ
rlm@1 836 if (!gbCgbMode && (register_LCDC & 0x80) && gbLcdMode < 2)
rlm@1 837 gbInterrupt |= 2;
rlm@1 838 return;
rlm@1 839 }
rlm@1 840
rlm@1 841 // SCY
rlm@1 842 case 0x42:
rlm@1 843 {
rlm@1 844 register_SCY = value;
rlm@1 845 return;
rlm@1 846 }
rlm@1 847
rlm@1 848 // SCX
rlm@1 849 case 0x43:
rlm@1 850 {
rlm@1 851 register_SCX = value;
rlm@1 852 return;
rlm@1 853 }
rlm@1 854
rlm@1 855 // LY
rlm@1 856 case 0x44:
rlm@1 857 {
rlm@1 858 // read only
rlm@1 859 return;
rlm@1 860 }
rlm@1 861
rlm@1 862 // LYC
rlm@1 863 case 0x45:
rlm@1 864 {
rlm@1 865 register_LYC = value;
rlm@1 866 if ((register_LCDC & 0x80))
rlm@1 867 {
rlm@1 868 gbCompareLYToLYC();
rlm@1 869 }
rlm@1 870 return;
rlm@1 871 }
rlm@1 872
rlm@1 873 // DMA!
rlm@1 874 case 0x46:
rlm@1 875 {
rlm@1 876 int source = value * 0x0100;
rlm@1 877
rlm@1 878 gbCopyMemory(0xfe00,
rlm@1 879 source,
rlm@1 880 0xa0);
rlm@1 881 register_DMA = value;
rlm@1 882 return;
rlm@1 883 }
rlm@1 884
rlm@1 885 // BGP
rlm@1 886 case 0x47:
rlm@1 887 {
rlm@1 888 gbBgp[0] = value & 0x03;
rlm@1 889 gbBgp[1] = (value & 0x0c) >> 2;
rlm@1 890 gbBgp[2] = (value & 0x30) >> 4;
rlm@1 891 gbBgp[3] = (value & 0xc0) >> 6;
rlm@1 892 break;
rlm@1 893 }
rlm@1 894
rlm@1 895 // OBP0
rlm@1 896 case 0x48:
rlm@1 897 {
rlm@1 898 gbObp0[0] = value & 0x03;
rlm@1 899 gbObp0[1] = (value & 0x0c) >> 2;
rlm@1 900 gbObp0[2] = (value & 0x30) >> 4;
rlm@1 901 gbObp0[3] = (value & 0xc0) >> 6;
rlm@1 902 break;
rlm@1 903 }
rlm@1 904
rlm@1 905 // OBP1
rlm@1 906 case 0x49:
rlm@1 907 {
rlm@1 908 gbObp1[0] = value & 0x03;
rlm@1 909 gbObp1[1] = (value & 0x0c) >> 2;
rlm@1 910 gbObp1[2] = (value & 0x30) >> 4;
rlm@1 911 gbObp1[3] = (value & 0xc0) >> 6;
rlm@1 912 break;
rlm@1 913 }
rlm@1 914
rlm@1 915 case 0x4a:
rlm@1 916 register_WY = value;
rlm@1 917 return;
rlm@1 918
rlm@1 919 case 0x4b:
rlm@1 920 register_WX = value;
rlm@1 921 return;
rlm@1 922
rlm@1 923 // KEY1
rlm@1 924 case 0x4d:
rlm@1 925 {
rlm@1 926 if (gbCgbMode)
rlm@1 927 {
rlm@1 928 gbMemory[0xff4d] = (gbMemory[0xff4d] & 0x80) | (value & 1);
rlm@1 929 return;
rlm@1 930 }
rlm@1 931 break;
rlm@1 932 }
rlm@1 933
rlm@1 934 // VBK
rlm@1 935 case 0x4f:
rlm@1 936 {
rlm@1 937 if (gbCgbMode)
rlm@1 938 {
rlm@1 939 value = value & 1;
rlm@1 940 if (value == gbVramBank)
rlm@1 941 return;
rlm@1 942
rlm@1 943 int vramAddress = value * 0x2000;
rlm@1 944 gbMemoryMap[0x08] = &gbVram[vramAddress];
rlm@1 945 gbMemoryMap[0x09] = &gbVram[vramAddress + 0x1000];
rlm@1 946
rlm@1 947 gbVramBank = value;
rlm@1 948 register_VBK = value;
rlm@1 949 }
rlm@1 950 return;
rlm@1 951 break;
rlm@1 952 }
rlm@1 953
rlm@1 954 // HDMA1
rlm@1 955 case 0x51:
rlm@1 956 {
rlm@1 957 if (gbCgbMode)
rlm@1 958 {
rlm@1 959 if (value > 0x7f && value < 0xa0)
rlm@1 960 value = 0;
rlm@1 961
rlm@1 962 gbHdmaSource = (value << 8) | (register_HDMA2 & 0xf0);
rlm@1 963
rlm@1 964 register_HDMA1 = value;
rlm@1 965 return;
rlm@1 966 }
rlm@1 967 break;
rlm@1 968 }
rlm@1 969
rlm@1 970 // HDMA2
rlm@1 971 case 0x52:
rlm@1 972 {
rlm@1 973 if (gbCgbMode)
rlm@1 974 {
rlm@1 975 value = value & 0xf0;
rlm@1 976
rlm@1 977 gbHdmaSource = (register_HDMA1 << 8) | (value);
rlm@1 978
rlm@1 979 register_HDMA2 = value;
rlm@1 980 return;
rlm@1 981 }
rlm@1 982 break;
rlm@1 983 }
rlm@1 984
rlm@1 985 // HDMA3
rlm@1 986 case 0x53:
rlm@1 987 {
rlm@1 988 if (gbCgbMode)
rlm@1 989 {
rlm@1 990 value = value & 0x1f;
rlm@1 991 gbHdmaDestination = (value << 8) | (register_HDMA4 & 0xf0);
rlm@1 992 gbHdmaDestination += 0x8000;
rlm@1 993 register_HDMA3 = value;
rlm@1 994 return;
rlm@1 995 }
rlm@1 996 break;
rlm@1 997 }
rlm@1 998
rlm@1 999 // HDMA4
rlm@1 1000 case 0x54:
rlm@1 1001 {
rlm@1 1002 if (gbCgbMode)
rlm@1 1003 {
rlm@1 1004 value = value & 0xf0;
rlm@1 1005 gbHdmaDestination = ((register_HDMA3 & 0x1f) << 8) | value;
rlm@1 1006 gbHdmaDestination += 0x8000;
rlm@1 1007 register_HDMA4 = value;
rlm@1 1008 return;
rlm@1 1009 }
rlm@1 1010 break;
rlm@1 1011 }
rlm@1 1012
rlm@1 1013 // HDMA5
rlm@1 1014 case 0x55:
rlm@1 1015 {
rlm@1 1016 if (gbCgbMode)
rlm@1 1017 {
rlm@1 1018 gbHdmaBytes = 16 + (value & 0x7f) * 16;
rlm@1 1019 if (gbHdmaOn)
rlm@1 1020 {
rlm@1 1021 if (value & 0x80)
rlm@1 1022 {
rlm@1 1023 register_HDMA5 = (value & 0x7f);
rlm@1 1024 }
rlm@1 1025 else
rlm@1 1026 {
rlm@1 1027 register_HDMA5 = 0xff;
rlm@1 1028 gbHdmaOn = 0;
rlm@1 1029 }
rlm@1 1030 }
rlm@1 1031 else
rlm@1 1032 {
rlm@1 1033 if (value & 0x80)
rlm@1 1034 {
rlm@1 1035 gbHdmaOn = 1;
rlm@1 1036 register_HDMA5 = value & 0x7f;
rlm@1 1037 if (gbLcdMode == 0)
rlm@1 1038 gbDoHdma();
rlm@1 1039 }
rlm@1 1040 else
rlm@1 1041 {
rlm@1 1042 // we need to take the time it takes to complete the transfer into
rlm@1 1043 // account... according to GB DEV FAQs, the setup time is the same
rlm@1 1044 // for single and double speed, but the actual transfer takes the
rlm@1 1045 // same time // (is that a typo?)
rlm@1 1046 switch (gbDMASpeedVersion)
rlm@1 1047 {
rlm@1 1048 case 1: // I believe this is more correct
rlm@1 1049 // the lower 7 bits of FF55 specify the Transfer Length (divided by 16, minus 1)
rlm@1 1050 // and we make gbDmaTicks twice as many cycles at double speed to make the transfer take the same time
rlm@1 1051 if (gbSpeed)
rlm@1 1052 gbDmaTicks = 16 * ((value & 0x7f) + 1);
rlm@1 1053 else
rlm@1 1054 gbDmaTicks = 8 * ((value & 0x7f) + 1);
rlm@1 1055 break;
rlm@1 1056 case 0: // here for backward compatibility
rlm@1 1057 // I think this was a guess that approximates the above in most but not all games
rlm@1 1058 if (gbSpeed)
rlm@1 1059 gbDmaTicks = 231 + 16 * (value & 0x7f);
rlm@1 1060 else
rlm@1 1061 gbDmaTicks = 231 + 8 * (value & 0x7f);
rlm@1 1062 break;
rlm@1 1063 default: // shouldn't happen
rlm@1 1064 //assert(0);
rlm@1 1065 break;
rlm@1 1066 }
rlm@1 1067 gbCopyMemory(gbHdmaDestination, gbHdmaSource, gbHdmaBytes);
rlm@1 1068 gbHdmaDestination += gbHdmaBytes;
rlm@1 1069 gbHdmaSource += gbHdmaBytes;
rlm@1 1070
rlm@1 1071 register_HDMA3 = ((gbHdmaDestination - 0x8000) >> 8) & 0x1f;
rlm@1 1072 register_HDMA4 = gbHdmaDestination & 0xf0;
rlm@1 1073 register_HDMA1 = (gbHdmaSource >> 8) & 0xff;
rlm@1 1074 register_HDMA2 = gbHdmaSource & 0xf0;
rlm@1 1075 }
rlm@1 1076 }
rlm@1 1077 return;
rlm@1 1078 }
rlm@1 1079 break;
rlm@1 1080 }
rlm@1 1081
rlm@1 1082 // BCPS
rlm@1 1083 case 0x68:
rlm@1 1084 {
rlm@1 1085 if (gbCgbMode)
rlm@1 1086 {
rlm@1 1087 int paletteIndex = (value & 0x3f) >> 1;
rlm@1 1088 int paletteHiLo = (value & 0x01);
rlm@1 1089
rlm@1 1090 gbMemory[0xff68] = value;
rlm@1 1091 gbMemory[0xff69] = (paletteHiLo ?
rlm@1 1092 (gbPalette[paletteIndex] >> 8) :
rlm@1 1093 (gbPalette[paletteIndex] & 0x00ff));
rlm@1 1094 return;
rlm@1 1095 }
rlm@1 1096 break;
rlm@1 1097 }
rlm@1 1098
rlm@1 1099 // BCPD
rlm@1 1100 case 0x69:
rlm@1 1101 {
rlm@1 1102 if (gbCgbMode)
rlm@1 1103 {
rlm@1 1104 int v = gbMemory[0xff68];
rlm@1 1105 int paletteIndex = (v & 0x3f) >> 1;
rlm@1 1106 int paletteHiLo = (v & 0x01);
rlm@1 1107 gbMemory[0xff69] = value;
rlm@1 1108 gbPalette[paletteIndex] = (paletteHiLo ?
rlm@1 1109 ((value << 8) | (gbPalette[paletteIndex] & 0xff)) :
rlm@1 1110 ((gbPalette[paletteIndex] & 0xff00) | (value))) & 0x7fff;
rlm@1 1111
rlm@1 1112 if (gbMemory[0xff68] & 0x80)
rlm@1 1113 {
rlm@1 1114 int index = ((gbMemory[0xff68] & 0x3f) + 1) & 0x3f;
rlm@1 1115
rlm@1 1116 gbMemory[0xff68] = (gbMemory[0xff68] & 0x80) | index;
rlm@1 1117
rlm@1 1118 gbMemory[0xff69] = (index & 1 ?
rlm@1 1119 (gbPalette[index >> 1] >> 8) :
rlm@1 1120 (gbPalette[index >> 1] & 0x00ff));
rlm@1 1121 }
rlm@1 1122 return;
rlm@1 1123 }
rlm@1 1124 break;
rlm@1 1125 }
rlm@1 1126
rlm@1 1127 // OCPS
rlm@1 1128 case 0x6a:
rlm@1 1129 {
rlm@1 1130 if (gbCgbMode)
rlm@1 1131 {
rlm@1 1132 int paletteIndex = (value & 0x3f) >> 1;
rlm@1 1133 int paletteHiLo = (value & 0x01);
rlm@1 1134
rlm@1 1135 paletteIndex += 32;
rlm@1 1136
rlm@1 1137 gbMemory[0xff6a] = value;
rlm@1 1138 gbMemory[0xff6b] = (paletteHiLo ?
rlm@1 1139 (gbPalette[paletteIndex] >> 8) :
rlm@1 1140 (gbPalette[paletteIndex] & 0x00ff));
rlm@1 1141 return;
rlm@1 1142 }
rlm@1 1143 break;
rlm@1 1144 }
rlm@1 1145
rlm@1 1146 // OCPD
rlm@1 1147 case 0x6b:
rlm@1 1148 {
rlm@1 1149 if (gbCgbMode)
rlm@1 1150 {
rlm@1 1151 int v = gbMemory[0xff6a];
rlm@1 1152 int paletteIndex = (v & 0x3f) >> 1;
rlm@1 1153 int paletteHiLo = (v & 0x01);
rlm@1 1154
rlm@1 1155 paletteIndex += 32;
rlm@1 1156
rlm@1 1157 gbMemory[0xff6b] = value;
rlm@1 1158 gbPalette[paletteIndex] = (paletteHiLo ?
rlm@1 1159 ((value << 8) | (gbPalette[paletteIndex] & 0xff)) :
rlm@1 1160 ((gbPalette[paletteIndex] & 0xff00) | (value))) & 0x7fff;
rlm@1 1161 if (gbMemory[0xff6a] & 0x80)
rlm@1 1162 {
rlm@1 1163 int index = ((gbMemory[0xff6a] & 0x3f) + 1) & 0x3f;
rlm@1 1164
rlm@1 1165 gbMemory[0xff6a] = (gbMemory[0xff6a] & 0x80) | index;
rlm@1 1166
rlm@1 1167 gbMemory[0xff6b] = (index & 1 ?
rlm@1 1168 (gbPalette[(index >> 1) + 32] >> 8) :
rlm@1 1169 (gbPalette[(index >> 1) + 32] & 0x00ff));
rlm@1 1170 }
rlm@1 1171 return;
rlm@1 1172 }
rlm@1 1173 break;
rlm@1 1174 }
rlm@1 1175
rlm@1 1176 // SVBK
rlm@1 1177 case 0x70:
rlm@1 1178 {
rlm@1 1179 if (gbCgbMode)
rlm@1 1180 {
rlm@1 1181 value = value & 7;
rlm@1 1182
rlm@1 1183 int bank = value;
rlm@1 1184 if (value == 0)
rlm@1 1185 bank = 1;
rlm@1 1186
rlm@1 1187 if (bank == gbWramBank)
rlm@1 1188 return;
rlm@1 1189
rlm@1 1190 int wramAddress = bank * 0x1000;
rlm@1 1191 gbMemoryMap[0x0d] = &gbWram[wramAddress];
rlm@1 1192
rlm@1 1193 gbWramBank = bank;
rlm@1 1194 register_SVBK = value;
rlm@1 1195 return;
rlm@1 1196 }
rlm@1 1197 break;
rlm@1 1198 }
rlm@1 1199
rlm@1 1200 case 0xff:
rlm@1 1201 {
rlm@1 1202 register_IE = value;
rlm@1 1203 register_IF &= value;
rlm@1 1204 return;
rlm@1 1205 }
rlm@1 1206 }
rlm@1 1207
rlm@1 1208 gbWriteMemoryQuick(address, value);
rlm@1 1209 }
rlm@1 1210
rlm@1 1211 u8 gbReadOpcode(register u16 address)
rlm@1 1212 {
rlm@1 1213 if (gbCheatMap[address])
rlm@1 1214 return gbCheatRead(address);
rlm@1 1215
rlm@1 1216 // the following fix does more than Echo RAM fix, anyway...
rlm@1 1217 switch (gbEchoRAMFixOn ? (address >> 12) & 0x000f : address & 0xf000)
rlm@1 1218 {
rlm@1 1219 case 0x0a:
rlm@1 1220 case 0x0b:
rlm@1 1221 if (mapperReadRAM)
rlm@1 1222 return mapperReadRAM(address);
rlm@1 1223 break;
rlm@1 1224 case 0x0f:
rlm@1 1225 if (address > 0xff00)
rlm@1 1226 {
rlm@1 1227 switch (address & 0x00ff)
rlm@1 1228 {
rlm@1 1229 case 0x04:
rlm@1 1230 return register_DIV;
rlm@1 1231 case 0x05:
rlm@1 1232 return register_TIMA;
rlm@1 1233 case 0x06:
rlm@1 1234 return register_TMA;
rlm@1 1235 case 0x07:
rlm@1 1236 return (0xf8 | register_TAC);
rlm@1 1237 case 0x0f:
rlm@1 1238 return (0xe0 | register_IF);
rlm@1 1239 case 0x40:
rlm@1 1240 return register_LCDC;
rlm@1 1241 case 0x41:
rlm@1 1242 return (0x80 | register_STAT);
rlm@1 1243 case 0x42:
rlm@1 1244 return register_SCY;
rlm@1 1245 case 0x43:
rlm@1 1246 return register_SCX;
rlm@1 1247 case 0x44:
rlm@1 1248 return register_LY;
rlm@1 1249 case 0x45:
rlm@1 1250 return register_LYC;
rlm@1 1251 case 0x46:
rlm@1 1252 return register_DMA;
rlm@1 1253 case 0x4a:
rlm@1 1254 return register_WY;
rlm@1 1255 case 0x4b:
rlm@1 1256 return register_WX;
rlm@1 1257 case 0x4f:
rlm@1 1258 return (0xfe | register_VBK);
rlm@1 1259 case 0x51:
rlm@1 1260 return register_HDMA1;
rlm@1 1261 case 0x52:
rlm@1 1262 return register_HDMA2;
rlm@1 1263 case 0x53:
rlm@1 1264 return register_HDMA3;
rlm@1 1265 case 0x54:
rlm@1 1266 return register_HDMA4;
rlm@1 1267 case 0x55:
rlm@1 1268 return register_HDMA5;
rlm@1 1269 case 0x70:
rlm@1 1270 return (0xf8 | register_SVBK);
rlm@1 1271 case 0xff:
rlm@1 1272 return register_IE;
rlm@1 1273 }
rlm@1 1274 }
rlm@1 1275 break;
rlm@1 1276 }
rlm@1 1277 return gbReadMemoryQuick(address);
rlm@1 1278 }
rlm@1 1279
rlm@1 1280 void gbWriteMemory(register u16 address, register u8 value)
rlm@1 1281 {
rlm@1 1282 gbWriteMemoryWrapped(address, value);
rlm@1 1283 CallRegisteredLuaMemHook(address, 1, value, LUAMEMHOOK_WRITE);
rlm@1 1284 }
rlm@1 1285
rlm@1 1286 u8 gbReadMemory(register u16 address)
rlm@1 1287 {
rlm@1 1288 if (gbCheatMap[address])
rlm@1 1289 return gbCheatRead(address);
rlm@1 1290
rlm@1 1291 if (address < 0xa000)
rlm@1 1292 return gbReadMemoryQuick(address);
rlm@1 1293
rlm@1 1294 if (address < 0xc000)
rlm@1 1295 {
rlm@1 1296 #ifndef FINAL_VERSION
rlm@1 1297 if (memorydebug)
rlm@1 1298 {
rlm@1 1299 log("Memory register read %04x PC=%04x\n",
rlm@1 1300 address,
rlm@1 1301 PC.W);
rlm@1 1302 }
rlm@1 1303 #endif
rlm@1 1304
rlm@1 1305 if (mapperReadRAM)
rlm@1 1306 return mapperReadRAM(address);
rlm@1 1307 return gbReadMemoryQuick(address);
rlm@1 1308 }
rlm@1 1309
rlm@1 1310 if (address >= 0xff00)
rlm@1 1311 {
rlm@1 1312 switch (address & 0x00ff)
rlm@1 1313 {
rlm@1 1314 case 0x00:
rlm@1 1315 {
rlm@1 1316 if (gbSgbMode)
rlm@1 1317 {
rlm@1 1318 gbSgbReadingController |= 4;
rlm@1 1319 gbSgbResetPacketState();
rlm@1 1320 }
rlm@1 1321
rlm@1 1322 int b = gbMemory[0xff00];
rlm@1 1323
rlm@1 1324 if ((b & 0x30) == 0x20)
rlm@1 1325 {
rlm@1 1326 b &= 0xf0;
rlm@1 1327
rlm@1 1328 int joy = 0;
rlm@1 1329 if (gbSgbMode && gbSgbMultiplayer)
rlm@1 1330 {
rlm@1 1331 switch (gbSgbNextController)
rlm@1 1332 {
rlm@1 1333 case 0x0f:
rlm@1 1334 joy = 0;
rlm@1 1335 break;
rlm@1 1336 case 0x0e:
rlm@1 1337 joy = 1;
rlm@1 1338 break;
rlm@1 1339 case 0x0d:
rlm@1 1340 joy = 2;
rlm@1 1341 break;
rlm@1 1342 case 0x0c:
rlm@1 1343 joy = 3;
rlm@1 1344 break;
rlm@1 1345 default:
rlm@1 1346 joy = 0;
rlm@1 1347 }
rlm@1 1348 }
rlm@1 1349 int joystate = gbJoymask[joy];
rlm@1 1350 if (!(joystate & 128))
rlm@1 1351 b |= 0x08;
rlm@1 1352 if (!(joystate & 64))
rlm@1 1353 b |= 0x04;
rlm@1 1354 if (!(joystate & 32))
rlm@1 1355 b |= 0x02;
rlm@1 1356 if (!(joystate & 16))
rlm@1 1357 b |= 0x01;
rlm@1 1358
rlm@1 1359 gbMemory[0xff00] = b;
rlm@1 1360 }
rlm@1 1361 else if ((b & 0x30) == 0x10)
rlm@1 1362 {
rlm@1 1363 b &= 0xf0;
rlm@1 1364
rlm@1 1365 int joy = 0;
rlm@1 1366 if (gbSgbMode && gbSgbMultiplayer)
rlm@1 1367 {
rlm@1 1368 switch (gbSgbNextController)
rlm@1 1369 {
rlm@1 1370 case 0x0f:
rlm@1 1371 joy = 0;
rlm@1 1372 break;
rlm@1 1373 case 0x0e:
rlm@1 1374 joy = 1;
rlm@1 1375 break;
rlm@1 1376 case 0x0d:
rlm@1 1377 joy = 2;
rlm@1 1378 break;
rlm@1 1379 case 0x0c:
rlm@1 1380 joy = 3;
rlm@1 1381 break;
rlm@1 1382 default:
rlm@1 1383 joy = 0;
rlm@1 1384 }
rlm@1 1385 }
rlm@1 1386 int joystate = gbJoymask[joy];
rlm@1 1387 if (!(joystate & 8))
rlm@1 1388 b |= 0x08;
rlm@1 1389 if (!(joystate & 4))
rlm@1 1390 b |= 0x04;
rlm@1 1391 if (!(joystate & 2))
rlm@1 1392 b |= 0x02;
rlm@1 1393 if (!(joystate & 1))
rlm@1 1394 b |= 0x01;
rlm@1 1395
rlm@1 1396 gbMemory[0xff00] = b;
rlm@1 1397 }
rlm@1 1398 else
rlm@1 1399 {
rlm@1 1400 if (gbSgbMode && gbSgbMultiplayer)
rlm@1 1401 {
rlm@1 1402 gbMemory[0xff00] = 0xf0 | gbSgbNextController;
rlm@1 1403 }
rlm@1 1404 else
rlm@1 1405 {
rlm@1 1406 gbMemory[0xff00] = 0xff;
rlm@1 1407 }
rlm@1 1408 }
rlm@1 1409 }
rlm@1 1410 GBSystemCounters.lagged = false;
rlm@1 1411 return gbMemory[0xff00];
rlm@1 1412 break;
rlm@1 1413 case 0x01:
rlm@1 1414 return gbMemory[0xff01];
rlm@1 1415 case 0x04:
rlm@1 1416 return register_DIV;
rlm@1 1417 case 0x05:
rlm@1 1418 return register_TIMA;
rlm@1 1419 case 0x06:
rlm@1 1420 return register_TMA;
rlm@1 1421 case 0x07:
rlm@1 1422 return (0xf8 | register_TAC);
rlm@1 1423 case 0x0f:
rlm@1 1424 return (0xe0 | register_IF);
rlm@1 1425 case 0x40:
rlm@1 1426 return register_LCDC;
rlm@1 1427 case 0x41:
rlm@1 1428 return (0x80 | register_STAT);
rlm@1 1429 case 0x42:
rlm@1 1430 return register_SCY;
rlm@1 1431 case 0x43:
rlm@1 1432 return register_SCX;
rlm@1 1433 case 0x44:
rlm@1 1434 return register_LY;
rlm@1 1435 case 0x45:
rlm@1 1436 return register_LYC;
rlm@1 1437 case 0x46:
rlm@1 1438 return register_DMA;
rlm@1 1439 case 0x4a:
rlm@1 1440 return register_WY;
rlm@1 1441 case 0x4b:
rlm@1 1442 return register_WX;
rlm@1 1443 case 0x4f:
rlm@1 1444 return (0xfe | register_VBK);
rlm@1 1445 case 0x51:
rlm@1 1446 return register_HDMA1;
rlm@1 1447 case 0x52:
rlm@1 1448 return register_HDMA2;
rlm@1 1449 case 0x53:
rlm@1 1450 return register_HDMA3;
rlm@1 1451 case 0x54:
rlm@1 1452 return register_HDMA4;
rlm@1 1453 case 0x55:
rlm@1 1454 return register_HDMA5;
rlm@1 1455 case 0x70:
rlm@1 1456 return (0xf8 | register_SVBK);
rlm@1 1457 case 0xff:
rlm@1 1458 return register_IE;
rlm@1 1459 }
rlm@1 1460 }
rlm@1 1461
rlm@1 1462 return gbReadMemoryQuick(address);
rlm@1 1463 }
rlm@1 1464
rlm@1 1465 void gbVblank_interrupt()
rlm@1 1466 {
rlm@1 1467 if (IFF & 0x80)
rlm@1 1468 {
rlm@1 1469 PC.W++;
rlm@1 1470 IFF &= 0x7f;
rlm@1 1471 }
rlm@1 1472 gbInterrupt &= 0xfe;
rlm@1 1473
rlm@1 1474 IFF &= 0x7e;
rlm@1 1475 register_IF &= 0xfe;
rlm@1 1476
rlm@1 1477 gbWriteMemory(--SP.W, PC.B.B1);
rlm@1 1478 gbWriteMemory(--SP.W, PC.B.B0);
rlm@1 1479 PC.W = 0x40;
rlm@1 1480 }
rlm@1 1481
rlm@1 1482 void gbLcd_interrupt()
rlm@1 1483 {
rlm@1 1484 if (IFF & 0x80)
rlm@1 1485 {
rlm@1 1486 PC.W++;
rlm@1 1487 IFF &= 0x7f;
rlm@1 1488 }
rlm@1 1489 gbInterrupt &= 0xfd;
rlm@1 1490 IFF &= 0x7e;
rlm@1 1491 register_IF &= 0xfd;
rlm@1 1492
rlm@1 1493 gbWriteMemory(--SP.W, PC.B.B1);
rlm@1 1494 gbWriteMemory(--SP.W, PC.B.B0);
rlm@1 1495
rlm@1 1496 PC.W = 0x48;
rlm@1 1497 }
rlm@1 1498
rlm@1 1499 void gbTimer_interrupt()
rlm@1 1500 {
rlm@1 1501 if (IFF & 0x80)
rlm@1 1502 {
rlm@1 1503 PC.W++;
rlm@1 1504 IFF &= 0x7f;
rlm@1 1505 }
rlm@1 1506 IFF &= 0x7e;
rlm@1 1507 gbInterrupt &= 0xfb;
rlm@1 1508 register_IF &= 0xfb;
rlm@1 1509
rlm@1 1510 gbWriteMemory(--SP.W, PC.B.B1);
rlm@1 1511 gbWriteMemory(--SP.W, PC.B.B0);
rlm@1 1512
rlm@1 1513 PC.W = 0x50;
rlm@1 1514 }
rlm@1 1515
rlm@1 1516 void gbSerial_interrupt()
rlm@1 1517 {
rlm@1 1518 if (IFF & 0x80)
rlm@1 1519 {
rlm@1 1520 PC.W++;
rlm@1 1521 IFF &= 0x7f;
rlm@1 1522 }
rlm@1 1523 IFF &= 0x7e;
rlm@1 1524 gbInterrupt &= 0xf7;
rlm@1 1525 register_IF &= 0xf7;
rlm@1 1526
rlm@1 1527 gbWriteMemory(--SP.W, PC.B.B1);
rlm@1 1528 gbWriteMemory(--SP.W, PC.B.B0);
rlm@1 1529
rlm@1 1530 PC.W = 0x58;
rlm@1 1531 }
rlm@1 1532
rlm@1 1533 void gbJoypad_interrupt()
rlm@1 1534 {
rlm@1 1535 if (IFF & 0x80)
rlm@1 1536 {
rlm@1 1537 PC.W++;
rlm@1 1538 IFF &= 0x7f;
rlm@1 1539 }
rlm@1 1540 IFF &= 0x7e;
rlm@1 1541 gbInterrupt &= 0xef;
rlm@1 1542 register_IF &= 0xef;
rlm@1 1543
rlm@1 1544 gbWriteMemory(--SP.W, PC.B.B1);
rlm@1 1545 gbWriteMemory(--SP.W, PC.B.B0);
rlm@1 1546
rlm@1 1547 PC.W = 0x60;
rlm@1 1548 }
rlm@1 1549
rlm@1 1550 void gbSpeedSwitch()
rlm@1 1551 {
rlm@1 1552 if (gbSpeed == 0)
rlm@1 1553 {
rlm@1 1554 gbSpeed = 1;
rlm@1 1555 GBLCD_MODE_0_CLOCK_TICKS = 51 * 2; //127; //51 * 2;
rlm@1 1556 GBLCD_MODE_1_CLOCK_TICKS = 1140 * 2;
rlm@1 1557 GBLCD_MODE_2_CLOCK_TICKS = 20 * 2; //52; //20 * 2;
rlm@1 1558 GBLCD_MODE_3_CLOCK_TICKS = 43 * 2; //99; //43 * 2;
rlm@1 1559 GBDIV_CLOCK_TICKS = 64 * 2;
rlm@1 1560 GBLY_INCREMENT_CLOCK_TICKS = 114 * 2;
rlm@1 1561 GBTIMER_MODE_0_CLOCK_TICKS = 256; //256*2;
rlm@1 1562 GBTIMER_MODE_1_CLOCK_TICKS = 4; //4*2;
rlm@1 1563 GBTIMER_MODE_2_CLOCK_TICKS = 16; //16*2;
rlm@1 1564 GBTIMER_MODE_3_CLOCK_TICKS = 64; //64*2;
rlm@1 1565 GBSERIAL_CLOCK_TICKS = 128 * 2;
rlm@1 1566 gbDivTicks *= 2;
rlm@1 1567 gbLcdTicks *= 2;
rlm@1 1568 gbLcdLYIncrementTicks *= 2;
rlm@1 1569 // timerTicks *= 2;
rlm@1 1570 // timerClockTicks *= 2;
rlm@1 1571 gbSerialTicks *= 2;
rlm@1 1572 SOUND_CLOCK_TICKS = soundQuality * GB_USE_TICKS_AS * 2;
rlm@1 1573 soundTicks *= 2;
rlm@1 1574 // synchronizeTicks *= 2;
rlm@1 1575 // SYNCHRONIZE_CLOCK_TICKS *= 2;
rlm@1 1576 }
rlm@1 1577 else
rlm@1 1578 {
rlm@1 1579 gbSpeed = 0;
rlm@1 1580 GBLCD_MODE_0_CLOCK_TICKS = 51;
rlm@1 1581 GBLCD_MODE_1_CLOCK_TICKS = 1140;
rlm@1 1582 GBLCD_MODE_2_CLOCK_TICKS = 20;
rlm@1 1583 GBLCD_MODE_3_CLOCK_TICKS = 43;
rlm@1 1584 GBDIV_CLOCK_TICKS = 64;
rlm@1 1585 GBLY_INCREMENT_CLOCK_TICKS = 114;
rlm@1 1586 GBTIMER_MODE_0_CLOCK_TICKS = 256;
rlm@1 1587 GBTIMER_MODE_1_CLOCK_TICKS = 4;
rlm@1 1588 GBTIMER_MODE_2_CLOCK_TICKS = 16;
rlm@1 1589 GBTIMER_MODE_3_CLOCK_TICKS = 64;
rlm@1 1590 GBSERIAL_CLOCK_TICKS = 128;
rlm@1 1591 gbDivTicks /= 2;
rlm@1 1592 gbLcdTicks /= 2;
rlm@1 1593 gbLcdLYIncrementTicks /= 2;
rlm@1 1594 // timerTicks /= 2;
rlm@1 1595 // timerClockTicks /= 2;
rlm@1 1596 gbSerialTicks /= 2;
rlm@1 1597 SOUND_CLOCK_TICKS = soundQuality * GB_USE_TICKS_AS;
rlm@1 1598 soundTicks /= 2;
rlm@1 1599 // synchronizeTicks /= 2;
rlm@1 1600 // SYNCHRONIZE_CLOCK_TICKS /= 2;
rlm@1 1601 }
rlm@1 1602 }
rlm@1 1603
rlm@1 1604 void gbGetHardwareType()
rlm@1 1605 {
rlm@1 1606 gbCgbMode = 0;
rlm@1 1607 if (gbRom[0x143] & 0x80)
rlm@1 1608 {
rlm@1 1609 if (gbEmulatorType == 0 ||
rlm@1 1610 gbEmulatorType == 1 ||
rlm@1 1611 gbEmulatorType == 4 ||
rlm@1 1612 gbEmulatorType == 5 ||
rlm@1 1613 (gbRom[0x146] != 0x03 && (gbEmulatorType == 2)))
rlm@1 1614 {
rlm@1 1615 gbCgbMode = 1;
rlm@1 1616 }
rlm@1 1617 }
rlm@1 1618
rlm@1 1619 if (gbSgbMode == 2)
rlm@1 1620 {
rlm@1 1621 gbSgbMode = 0;
rlm@1 1622 return;
rlm@1 1623 }
rlm@1 1624
rlm@1 1625 gbSgbMode = 0;
rlm@1 1626 if (gbRom[0x146] == 0x03)
rlm@1 1627 {
rlm@1 1628 if (gbEmulatorType == 0 ||
rlm@1 1629 gbEmulatorType == 2 ||
rlm@1 1630 gbEmulatorType == 5 ||
rlm@1 1631 (!(gbRom[0x143] & 0x80) && (gbEmulatorType == 1 || gbEmulatorType == 4)))
rlm@1 1632 gbSgbMode = 1;
rlm@1 1633 }
rlm@1 1634 }
rlm@1 1635
rlm@1 1636 void gbReset(bool userReset)
rlm@1 1637 {
rlm@1 1638 // movie must be closed while opening/creating a movie
rlm@1 1639 if (userReset && VBAMovieRecording())
rlm@1 1640 {
rlm@1 1641 VBAMovieSignalReset();
rlm@1 1642 return;
rlm@1 1643 }
rlm@1 1644
rlm@1 1645 if (!VBAMovieActive())
rlm@1 1646 {
rlm@1 1647 GBSystemCounters.frameCount = 0;
rlm@1 1648 GBSystemCounters.lagCount = 0;
rlm@1 1649 GBSystemCounters.extraCount = 0;
rlm@1 1650 GBSystemCounters.lagged = true;
rlm@1 1651 GBSystemCounters.laggedLast = true;
rlm@1 1652 }
rlm@1 1653
rlm@1 1654 SP.W = 0xfffe;
rlm@1 1655 AF.W = 0x01b0;
rlm@1 1656 BC.W = 0x0013;
rlm@1 1657 DE.W = 0x00d8;
rlm@1 1658 HL.W = 0x014d;
rlm@1 1659 PC.W = 0x0100;
rlm@1 1660 IFF = 0;
rlm@1 1661 gbInterrupt = 1;
rlm@1 1662 gbInterruptWait = 0;
rlm@1 1663
rlm@1 1664 register_DIV = 0;
rlm@1 1665 register_TIMA = 0;
rlm@1 1666 register_TMA = 0;
rlm@1 1667 register_TAC = 0;
rlm@1 1668 register_IF = 1;
rlm@1 1669 register_LCDC = 0x91;
rlm@1 1670 register_STAT = 0;
rlm@1 1671 register_SCY = 0;
rlm@1 1672 register_SCX = 0;
rlm@1 1673 register_LY = 0;
rlm@1 1674 register_LYC = 0;
rlm@1 1675 register_DMA = 0;
rlm@1 1676 register_WY = 0;
rlm@1 1677 register_WX = 0;
rlm@1 1678 register_VBK = 0;
rlm@1 1679 register_HDMA1 = 0;
rlm@1 1680 register_HDMA2 = 0;
rlm@1 1681 register_HDMA3 = 0;
rlm@1 1682 register_HDMA4 = 0;
rlm@1 1683 register_HDMA5 = 0;
rlm@1 1684 register_SVBK = 0;
rlm@1 1685 register_IE = 0;
rlm@1 1686
rlm@1 1687 gbGetHardwareType();
rlm@1 1688 if (gbCgbMode)
rlm@1 1689 {
rlm@1 1690 if (!gbVram)
rlm@1 1691 gbVram = (u8 *)malloc(0x4000 + 4);
rlm@1 1692 if (!gbWram)
rlm@1 1693 gbWram = (u8 *)malloc(0x8000 + 4);
rlm@1 1694 memset(gbVram, 0, 0x4000 + 4);
rlm@1 1695 memset(gbWram, 0, 0x8000 + 4);
rlm@1 1696 }
rlm@1 1697 else
rlm@1 1698 {
rlm@1 1699 if (gbVram)
rlm@1 1700 {
rlm@1 1701 free(gbVram);
rlm@1 1702 gbVram = NULL;
rlm@1 1703 }
rlm@1 1704 if (gbWram)
rlm@1 1705 {
rlm@1 1706 free(gbWram);
rlm@1 1707 gbWram = NULL;
rlm@1 1708 }
rlm@1 1709 }
rlm@1 1710
rlm@1 1711 // clean LineBuffer
rlm@1 1712 if (gbLineBuffer)
rlm@1 1713 memset(gbLineBuffer, 0, 160 * sizeof(u16));
rlm@1 1714 // clean Pix
rlm@1 1715 if (pix)
rlm@1 1716 memset(pix, 0, 4 * 257 * 226);
rlm@1 1717
rlm@1 1718 if (gbCgbMode)
rlm@1 1719 {
rlm@1 1720 if (gbSgbMode)
rlm@1 1721 {
rlm@1 1722 if (gbEmulatorType == 5)
rlm@1 1723 AF.W = 0xffb0;
rlm@1 1724 else
rlm@1 1725 AF.W = 0x01b0;
rlm@1 1726 BC.W = 0x0013;
rlm@1 1727 DE.W = 0x00d8;
rlm@1 1728 HL.W = 0x014d;
rlm@1 1729 }
rlm@1 1730 else
rlm@1 1731 {
rlm@1 1732 AF.W = 0x11b0;
rlm@1 1733 BC.W = 0x0000;
rlm@1 1734 DE.W = 0xff56;
rlm@1 1735 HL.W = 0x000d;
rlm@1 1736 }
rlm@1 1737 if (gbEmulatorType == 4)
rlm@1 1738 BC.B.B1 |= 0x01;
rlm@1 1739
rlm@1 1740 register_HDMA5 = 0xff;
rlm@1 1741 gbMemory[0xff68] = 0xc0;
rlm@1 1742 gbMemory[0xff6a] = 0xc0;
rlm@1 1743
rlm@1 1744 for (int i = 0; i < 64; i++)
rlm@1 1745 gbPalette[i] = 0x7fff;
rlm@1 1746 }
rlm@1 1747 else
rlm@1 1748 {
rlm@1 1749 for (int i = 0; i < 8; i++)
rlm@1 1750 gbPalette[i] = systemGbPalette[gbPaletteOption * 8 + i];
rlm@1 1751 }
rlm@1 1752
rlm@1 1753 if (gbSpeed)
rlm@1 1754 {
rlm@1 1755 gbSpeedSwitch();
rlm@1 1756 gbMemory[0xff4d] = 0;
rlm@1 1757 }
rlm@1 1758
rlm@1 1759 gbDivTicks = GBDIV_CLOCK_TICKS;
rlm@1 1760 gbLcdMode = 2;
rlm@1 1761 gbLcdTicks = GBLCD_MODE_2_CLOCK_TICKS;
rlm@1 1762 gbLcdLYIncrementTicks = 0;
rlm@1 1763 gbTimerTicks = 0;
rlm@1 1764 gbTimerClockTicks = 0;
rlm@1 1765 gbSerialTicks = 0;
rlm@1 1766 gbSerialBits = 0;
rlm@1 1767 gbSerialOn = 0;
rlm@1 1768 gbWindowLine = -1;
rlm@1 1769 gbTimerOn = 0;
rlm@1 1770 gbTimerMode = 0;
rlm@1 1771 // gbSynchronizeTicks = GBSYNCHRONIZE_CLOCK_TICKS;
rlm@1 1772 gbSpeed = 0;
rlm@1 1773 gbJoymask[0] = gbJoymask[1] = gbJoymask[2] = gbJoymask[3] = 0;
rlm@1 1774
rlm@1 1775 // FIXME: horrible kludge
rlm@1 1776 memset(s_gbJoymask, 0, sizeof(s_gbJoymask));
rlm@1 1777
rlm@1 1778 if (gbCgbMode)
rlm@1 1779 {
rlm@1 1780 gbSpeed = 0;
rlm@1 1781 gbHdmaOn = 0;
rlm@1 1782 gbHdmaSource = 0x0000;
rlm@1 1783 gbHdmaDestination = 0x8000;
rlm@1 1784 gbVramBank = 0;
rlm@1 1785 gbWramBank = 1;
rlm@1 1786 register_LY = 0x90;
rlm@1 1787 gbLcdMode = 1;
rlm@1 1788 }
rlm@1 1789
rlm@1 1790 if (gbSgbMode)
rlm@1 1791 {
rlm@1 1792 gbSgbReset();
rlm@1 1793 }
rlm@1 1794
rlm@1 1795 for (int i = 0; i < 4; i++)
rlm@1 1796 gbBgp[i] = gbObp0[i] = gbObp1[i] = i;
rlm@1 1797
rlm@1 1798 memset(&gbDataMBC1, 0, sizeof(gbDataMBC1));
rlm@1 1799 gbDataMBC1.mapperROMBank = 1;
rlm@1 1800
rlm@1 1801 gbDataMBC2.mapperRAMEnable = 0;
rlm@1 1802 gbDataMBC2.mapperROMBank = 1;
rlm@1 1803
rlm@1 1804 memset(&gbDataMBC3, 0, 6 * sizeof(int32));
rlm@1 1805 gbDataMBC3.mapperROMBank = 1;
rlm@1 1806
rlm@1 1807 memset(&gbDataMBC5, 0, sizeof(gbDataMBC5));
rlm@1 1808 gbDataMBC5.mapperROMBank = 1;
rlm@1 1809 switch (gbRom[0x147])
rlm@1 1810 {
rlm@1 1811 case 0x1c:
rlm@1 1812 case 0x1d:
rlm@1 1813 case 0x1e:
rlm@1 1814 gbDataMBC5.isRumbleCartridge = 1;
rlm@1 1815 }
rlm@1 1816
rlm@1 1817 memset(&gbDataHuC1, 0, sizeof(gbDataHuC1));
rlm@1 1818 gbDataHuC1.mapperROMBank = 1;
rlm@1 1819
rlm@1 1820 memset(&gbDataHuC3, 0, sizeof(gbDataHuC3));
rlm@1 1821 gbDataHuC3.mapperROMBank = 1;
rlm@1 1822
rlm@1 1823 gbMemoryMap[0x00] = &gbRom[0x0000];
rlm@1 1824 gbMemoryMap[0x01] = &gbRom[0x1000];
rlm@1 1825 gbMemoryMap[0x02] = &gbRom[0x2000];
rlm@1 1826 gbMemoryMap[0x03] = &gbRom[0x3000];
rlm@1 1827 gbMemoryMap[0x04] = &gbRom[0x4000];
rlm@1 1828 gbMemoryMap[0x05] = &gbRom[0x5000];
rlm@1 1829 gbMemoryMap[0x06] = &gbRom[0x6000];
rlm@1 1830 gbMemoryMap[0x07] = &gbRom[0x7000];
rlm@1 1831 if (gbCgbMode)
rlm@1 1832 {
rlm@1 1833 gbMemoryMap[0x08] = &gbVram[0x0000];
rlm@1 1834 gbMemoryMap[0x09] = &gbVram[0x1000];
rlm@1 1835 gbMemoryMap[0x0a] = &gbMemory[0xa000];
rlm@1 1836 gbMemoryMap[0x0b] = &gbMemory[0xb000];
rlm@1 1837 gbMemoryMap[0x0c] = &gbMemory[0xc000];
rlm@1 1838 gbMemoryMap[0x0d] = &gbWram[0x1000];
rlm@1 1839 gbMemoryMap[0x0e] = &gbMemory[0xe000];
rlm@1 1840 gbMemoryMap[0x0f] = &gbMemory[0xf000];
rlm@1 1841 }
rlm@1 1842 else
rlm@1 1843 {
rlm@1 1844 gbMemoryMap[0x08] = &gbMemory[0x8000];
rlm@1 1845 gbMemoryMap[0x09] = &gbMemory[0x9000];
rlm@1 1846 gbMemoryMap[0x0a] = &gbMemory[0xa000];
rlm@1 1847 gbMemoryMap[0x0b] = &gbMemory[0xb000];
rlm@1 1848 gbMemoryMap[0x0c] = &gbMemory[0xc000];
rlm@1 1849 gbMemoryMap[0x0d] = &gbMemory[0xd000];
rlm@1 1850 gbMemoryMap[0x0e] = &gbMemory[0xe000];
rlm@1 1851 gbMemoryMap[0x0f] = &gbMemory[0xf000];
rlm@1 1852 }
rlm@1 1853
rlm@1 1854 if (gbRam)
rlm@1 1855 {
rlm@1 1856 gbMemoryMap[0x0a] = &gbRam[0x0000];
rlm@1 1857 gbMemoryMap[0x0b] = &gbRam[0x1000];
rlm@1 1858 }
rlm@1 1859
rlm@1 1860 gbSoundReset();
rlm@1 1861
rlm@1 1862 systemResetSensor();
rlm@1 1863
rlm@1 1864 systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED;
rlm@1 1865
rlm@1 1866 gbLastTime = systemGetClock();
rlm@1 1867 gbFrameCount = 0;
rlm@1 1868
rlm@1 1869 systemRefreshScreen();
rlm@1 1870 }
rlm@1 1871
rlm@1 1872 void gbWriteSaveMBC1(const char *name)
rlm@1 1873 {
rlm@1 1874 FILE *gzFile = fopen(name, "wb");
rlm@1 1875
rlm@1 1876 if (gzFile == NULL)
rlm@1 1877 {
rlm@1 1878 systemMessage(MSG_ERROR_CREATING_FILE, N_("Error creating file %s"), name);
rlm@1 1879 return;
rlm@1 1880 }
rlm@1 1881
rlm@1 1882 fwrite(gbRam,
rlm@1 1883 1,
rlm@1 1884 gbRamSize,
rlm@1 1885 gzFile);
rlm@1 1886
rlm@1 1887 fclose(gzFile);
rlm@1 1888 }
rlm@1 1889
rlm@1 1890 void gbWriteSaveMBC2(const char *name)
rlm@1 1891 {
rlm@1 1892 FILE *file = fopen(name, "wb");
rlm@1 1893
rlm@1 1894 if (file == NULL)
rlm@1 1895 {
rlm@1 1896 systemMessage(MSG_ERROR_CREATING_FILE, N_("Error creating file %s"), name);
rlm@1 1897 return;
rlm@1 1898 }
rlm@1 1899
rlm@1 1900 fwrite(&gbMemory[0xa000],
rlm@1 1901 1,
rlm@1 1902 256,
rlm@1 1903 file);
rlm@1 1904
rlm@1 1905 fclose(file);
rlm@1 1906 }
rlm@1 1907
rlm@1 1908 void gbWriteSaveMBC3(const char *name, bool extendedSave)
rlm@1 1909 {
rlm@1 1910 FILE *gzFile = fopen(name, "wb");
rlm@1 1911
rlm@1 1912 if (gzFile == NULL)
rlm@1 1913 {
rlm@1 1914 systemMessage(MSG_ERROR_CREATING_FILE, N_("Error creating file %s"), name);
rlm@1 1915 return;
rlm@1 1916 }
rlm@1 1917
rlm@1 1918 fwrite(gbRam,
rlm@1 1919 1,
rlm@1 1920 gbRamSize,
rlm@1 1921 gzFile);
rlm@1 1922
rlm@1 1923 if (extendedSave)
rlm@1 1924 {
rlm@1 1925 //assert(sizeof(time_t) == 4);
rlm@1 1926 fwrite(&gbDataMBC3.mapperSeconds,
rlm@1 1927 1,
rlm@1 1928 10 * sizeof(int32) + /*sizeof(time_t)*/4,
rlm@1 1929 gzFile);
rlm@1 1930 }
rlm@1 1931
rlm@1 1932 fclose(gzFile);
rlm@1 1933 }
rlm@1 1934
rlm@1 1935 void gbWriteSaveMBC5(const char *name)
rlm@1 1936 {
rlm@1 1937 FILE *gzFile = fopen(name, "wb");
rlm@1 1938
rlm@1 1939 if (gzFile == NULL)
rlm@1 1940 {
rlm@1 1941 systemMessage(MSG_ERROR_CREATING_FILE, N_("Error creating file %s"), name);
rlm@1 1942 return;
rlm@1 1943 }
rlm@1 1944
rlm@1 1945 fwrite(gbRam,
rlm@1 1946 1,
rlm@1 1947 gbRamSize,
rlm@1 1948 gzFile);
rlm@1 1949
rlm@1 1950 fclose(gzFile);
rlm@1 1951 }
rlm@1 1952
rlm@1 1953 void gbWriteSaveMBC7(const char *name)
rlm@1 1954 {
rlm@1 1955 FILE *file = fopen(name, "wb");
rlm@1 1956
rlm@1 1957 if (file == NULL)
rlm@1 1958 {
rlm@1 1959 systemMessage(MSG_ERROR_CREATING_FILE, N_("Error creating file %s"), name);
rlm@1 1960 return;
rlm@1 1961 }
rlm@1 1962
rlm@1 1963 fwrite(&gbMemory[0xa000],
rlm@1 1964 1,
rlm@1 1965 256,
rlm@1 1966 file);
rlm@1 1967
rlm@1 1968 fclose(file);
rlm@1 1969 }
rlm@1 1970
rlm@1 1971 bool gbReadSaveMBC1(const char *name)
rlm@1 1972 {
rlm@1 1973 gzFile gzFile = gzopen(name, "rb");
rlm@1 1974
rlm@1 1975 if (gzFile == NULL)
rlm@1 1976 {
rlm@1 1977 return false;
rlm@1 1978 }
rlm@1 1979
rlm@1 1980 int read = gzread(gzFile,
rlm@1 1981 gbRam,
rlm@1 1982 gbRamSize);
rlm@1 1983
rlm@1 1984 if (read != gbRamSize)
rlm@1 1985 {
rlm@1 1986 systemMessage(MSG_FAILED_TO_READ_SGM, N_("Failed to read complete save game %s (%d)"), name, read);
rlm@1 1987 gzclose(gzFile);
rlm@1 1988 return false;
rlm@1 1989 }
rlm@1 1990
rlm@1 1991 gzclose(gzFile);
rlm@1 1992 return true;
rlm@1 1993 }
rlm@1 1994
rlm@1 1995 bool gbReadSaveMBC2(const char *name)
rlm@1 1996 {
rlm@1 1997 FILE *file = fopen(name, "rb");
rlm@1 1998
rlm@1 1999 if (file == NULL)
rlm@1 2000 {
rlm@1 2001 return false;
rlm@1 2002 }
rlm@1 2003
rlm@1 2004 int read = fread(&gbMemory[0xa000],
rlm@1 2005 1,
rlm@1 2006 256,
rlm@1 2007 file);
rlm@1 2008
rlm@1 2009 if (read != 256)
rlm@1 2010 {
rlm@1 2011 systemMessage(MSG_FAILED_TO_READ_SGM,
rlm@1 2012 N_("Failed to read complete save game %s (%d)"), name, read);
rlm@1 2013 fclose(file);
rlm@1 2014 return false;
rlm@1 2015 }
rlm@1 2016
rlm@1 2017 fclose(file);
rlm@1 2018 return true;
rlm@1 2019 }
rlm@1 2020
rlm@1 2021 bool gbReadSaveMBC3(const char *name)
rlm@1 2022 {
rlm@1 2023 gzFile gzFile = gzopen(name, "rb");
rlm@1 2024
rlm@1 2025 if (gzFile == NULL)
rlm@1 2026 {
rlm@1 2027 return false;
rlm@1 2028 }
rlm@1 2029
rlm@1 2030 int read = gzread(gzFile,
rlm@1 2031 gbRam,
rlm@1 2032 gbRamSize);
rlm@1 2033
rlm@1 2034 bool res = true;
rlm@1 2035
rlm@1 2036 if (read != gbRamSize)
rlm@1 2037 {
rlm@1 2038 systemMessage(MSG_FAILED_TO_READ_SGM,
rlm@1 2039 N_("Failed to read complete save game %s (%d)"), name, read);
rlm@1 2040 }
rlm@1 2041 else
rlm@1 2042 {
rlm@1 2043 //assert(sizeof(time_t) == 4);
rlm@1 2044 read = gzread(gzFile,
rlm@1 2045 &gbDataMBC3.mapperSeconds,
rlm@1 2046 sizeof(int32) * 10 + /*sizeof(time_t)*/4);
rlm@1 2047
rlm@1 2048 if (read != (sizeof(int32) * 10 + /*sizeof(time_t)*/4) && read != 0)
rlm@1 2049 {
rlm@1 2050 systemMessage(MSG_FAILED_TO_READ_RTC,
rlm@1 2051 N_("Failed to read RTC from save game %s (continuing)"),
rlm@1 2052 name);
rlm@1 2053 res = false;
rlm@1 2054 }
rlm@1 2055 }
rlm@1 2056
rlm@1 2057 gzclose(gzFile);
rlm@1 2058 return res;
rlm@1 2059 }
rlm@1 2060
rlm@1 2061 bool gbReadSaveMBC5(const char *name)
rlm@1 2062 {
rlm@1 2063 gzFile gzFile = gzopen(name, "rb");
rlm@1 2064
rlm@1 2065 if (gzFile == NULL)
rlm@1 2066 {
rlm@1 2067 return false;
rlm@1 2068 }
rlm@1 2069
rlm@1 2070 int read = gzread(gzFile,
rlm@1 2071 gbRam,
rlm@1 2072 gbRamSize);
rlm@1 2073
rlm@1 2074 if (read != gbRamSize)
rlm@1 2075 {
rlm@1 2076 systemMessage(MSG_FAILED_TO_READ_SGM,
rlm@1 2077 N_("Failed to read complete save game %s (%d)"), name, read);
rlm@1 2078 gzclose(gzFile);
rlm@1 2079 return false;
rlm@1 2080 }
rlm@1 2081
rlm@1 2082 gzclose(gzFile);
rlm@1 2083 return true;
rlm@1 2084 }
rlm@1 2085
rlm@1 2086 bool gbReadSaveMBC7(const char *name)
rlm@1 2087 {
rlm@1 2088 FILE *file = fopen(name, "rb");
rlm@1 2089
rlm@1 2090 if (file == NULL)
rlm@1 2091 {
rlm@1 2092 return false;
rlm@1 2093 }
rlm@1 2094
rlm@1 2095 int read = fread(&gbMemory[0xa000],
rlm@1 2096 1,
rlm@1 2097 256,
rlm@1 2098 file);
rlm@1 2099
rlm@1 2100 if (read != 256)
rlm@1 2101 {
rlm@1 2102 systemMessage(MSG_FAILED_TO_READ_SGM,
rlm@1 2103 N_("Failed to read complete save game %s (%d)"), name, read);
rlm@1 2104 fclose(file);
rlm@1 2105 return false;
rlm@1 2106 }
rlm@1 2107
rlm@1 2108 fclose(file);
rlm@1 2109 return true;
rlm@1 2110 }
rlm@1 2111
rlm@1 2112 #if 0
rlm@1 2113 bool gbLoadBIOS(const char *biosFileName, bool useBiosFile)
rlm@1 2114 {
rlm@1 2115 useBios = false;
rlm@1 2116 if (useBiosFile)
rlm@1 2117 {
rlm@1 2118 useBios = utilLoadBIOS(bios, biosFileName, gbEmulatorType);
rlm@1 2119 if (!useBios)
rlm@1 2120 {
rlm@1 2121 systemMessage(MSG_INVALID_BIOS_FILE_SIZE, N_("Invalid BOOTROM file"));
rlm@1 2122 }
rlm@1 2123 }
rlm@1 2124 return useBios;
rlm@1 2125 }
rlm@1 2126 #endif
rlm@1 2127
rlm@1 2128 void gbInit()
rlm@1 2129 {
rlm@1 2130 gbGenFilter();
rlm@1 2131 gbSgbInit(); // calls gbSgbReset()... whatever
rlm@1 2132
rlm@1 2133 gbMemory = (u8 *)malloc(65536 + 4);
rlm@1 2134 memset(gbMemory, 0, 65536 + 4);
rlm@1 2135 memset(gbPalette, 0, 2 * 128);
rlm@1 2136
rlm@1 2137 // HACK: +4 at start to accomodate the 2xSaI filter reading out of bounds of the leftmost pixel
rlm@1 2138 origPix = (u8 *)calloc(1, 4 * 257 * 226 + 4);
rlm@1 2139 pix = origPix + 4;
rlm@1 2140
rlm@1 2141 gbLineBuffer = (u16 *)malloc(160 * sizeof(u16));
rlm@1 2142 }
rlm@1 2143
rlm@1 2144 bool gbWriteBatteryFile(const char *file, bool extendedSave)
rlm@1 2145 {
rlm@1 2146 if (gbBattery)
rlm@1 2147 {
rlm@1 2148 int type = gbRom[0x147];
rlm@1 2149
rlm@1 2150 switch (type)
rlm@1 2151 {
rlm@1 2152 case 0x03:
rlm@1 2153 gbWriteSaveMBC1(file);
rlm@1 2154 break;
rlm@1 2155 case 0x06:
rlm@1 2156 gbWriteSaveMBC2(file);
rlm@1 2157 break;
rlm@1 2158 case 0x0f:
rlm@1 2159 case 0x10:
rlm@1 2160 case 0x13:
rlm@1 2161 gbWriteSaveMBC3(file, extendedSave);
rlm@1 2162 break;
rlm@1 2163 case 0x1b:
rlm@1 2164 case 0x1e:
rlm@1 2165 gbWriteSaveMBC5(file);
rlm@1 2166 break;
rlm@1 2167 case 0x22:
rlm@1 2168 gbWriteSaveMBC7(file);
rlm@1 2169 break;
rlm@1 2170 case 0xff:
rlm@1 2171 gbWriteSaveMBC1(file);
rlm@1 2172 break;
rlm@1 2173 }
rlm@1 2174 }
rlm@1 2175 return true;
rlm@1 2176 }
rlm@1 2177
rlm@1 2178 bool gbWriteBatteryFile(const char *file)
rlm@1 2179 {
rlm@1 2180 gbWriteBatteryFile(file, true);
rlm@1 2181 return true;
rlm@1 2182 }
rlm@1 2183
rlm@1 2184 bool gbWriteBatteryToStream(gzFile gzfile)
rlm@1 2185 {
rlm@1 2186 // the GB save code is ugly, so rather than convert it all to use gzFiles, just save it to a temp file...
rlm@1 2187 #define TEMP_SAVE_FNAME ("tempvbawrite.sav")
rlm@1 2188 bool retVal = gbWriteBatteryFile(TEMP_SAVE_FNAME, true);
rlm@1 2189
rlm@1 2190 // ...open the temp file and figure out its size...
rlm@1 2191 FILE *fileTemp = fopen(TEMP_SAVE_FNAME, "rb");
rlm@1 2192 if (fileTemp == NULL)
rlm@1 2193 return false;
rlm@1 2194 fseek(fileTemp, 0, SEEK_END);
rlm@1 2195 int len = (int) ftell(fileTemp);
rlm@1 2196
rlm@1 2197 // ...copy over the temp file...
rlm@1 2198 char *temp = new char [len];
rlm@1 2199 fseek(fileTemp, 0, SEEK_SET);
rlm@1 2200 if (fread(temp, len, 1, fileTemp) != 1)
rlm@1 2201 {
rlm@1 2202 delete [] temp;
rlm@1 2203 fclose(fileTemp);
rlm@1 2204 return false;
rlm@1 2205 }
rlm@1 2206 fclose(fileTemp);
rlm@1 2207 utilGzWrite(gzfile, temp, len);
rlm@1 2208 delete [] temp;
rlm@1 2209
rlm@1 2210 // ... and delete the temp file
rlm@1 2211 remove(TEMP_SAVE_FNAME);
rlm@1 2212 #undef TEMP_SAVE_FNAME
rlm@1 2213
rlm@1 2214 return retVal;
rlm@1 2215 }
rlm@1 2216
rlm@1 2217 bool gbReadBatteryFile(const char *file)
rlm@1 2218 {
rlm@1 2219 bool res = false;
rlm@1 2220 if (gbBattery)
rlm@1 2221 {
rlm@1 2222 int type = gbRom[0x147];
rlm@1 2223
rlm@1 2224 switch (type)
rlm@1 2225 {
rlm@1 2226 case 0x03:
rlm@1 2227 res = gbReadSaveMBC1(file);
rlm@1 2228 break;
rlm@1 2229 case 0x06:
rlm@1 2230 res = gbReadSaveMBC2(file);
rlm@1 2231 break;
rlm@1 2232 case 0x0f:
rlm@1 2233 case 0x10:
rlm@1 2234 case 0x13:
rlm@1 2235 if (!gbReadSaveMBC3(file))
rlm@1 2236 {
rlm@1 2237 struct tm *lt;
rlm@1 2238 time_t tmp; //Small kludge to get it working on some systems where time_t has size 8.
rlm@1 2239
rlm@1 2240 if (VBAMovieActive() || VBAMovieLoading())
rlm@1 2241 {
rlm@1 2242 gbDataMBC3.mapperLastTime = VBAMovieGetId() + VBAMovieGetFrameCounter() / 60;
rlm@1 2243 lt = gmtime(&tmp);
rlm@1 2244 gbDataMBC3.mapperLastTime=(u32)tmp;
rlm@1 2245 }
rlm@1 2246 else
rlm@1 2247 {
rlm@1 2248 time(&tmp);
rlm@1 2249 gbDataMBC3.mapperLastTime=(u32)tmp;
rlm@1 2250 lt = localtime(&tmp);
rlm@1 2251 }
rlm@1 2252 systemScreenMessage(ctime(&tmp), 4);
rlm@1 2253 gbDataMBC3.mapperLastTime=(u32)tmp;
rlm@1 2254
rlm@1 2255 gbDataMBC3.mapperSeconds = lt->tm_sec;
rlm@1 2256 gbDataMBC3.mapperMinutes = lt->tm_min;
rlm@1 2257 gbDataMBC3.mapperHours = lt->tm_hour;
rlm@1 2258 gbDataMBC3.mapperDays = lt->tm_yday & 255;
rlm@1 2259 gbDataMBC3.mapperControl = (gbDataMBC3.mapperControl & 0xfe) |
rlm@1 2260 (lt->tm_yday > 255 ? 1 : 0);
rlm@1 2261 res = false;
rlm@1 2262 break;
rlm@1 2263 }
rlm@1 2264 time_t tmp;
rlm@1 2265 systemScreenMessage(ctime(&tmp), 4);
rlm@1 2266 gbDataMBC3.mapperLastTime=(u32)tmp;
rlm@1 2267 res = true;
rlm@1 2268 break;
rlm@1 2269 case 0x1b:
rlm@1 2270 case 0x1e:
rlm@1 2271 res = gbReadSaveMBC5(file);
rlm@1 2272 break;
rlm@1 2273 case 0x22:
rlm@1 2274 res = gbReadSaveMBC7(file);
rlm@1 2275 case 0xff:
rlm@1 2276 res = gbReadSaveMBC1(file);
rlm@1 2277 break;
rlm@1 2278 }
rlm@1 2279 }
rlm@1 2280 systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED;
rlm@1 2281 return res;
rlm@1 2282 }
rlm@1 2283
rlm@1 2284 bool gbReadBatteryFromStream(gzFile gzfile)
rlm@1 2285 {
rlm@1 2286 // the GB save code is ugly, so rather than convert it all to use gzFiles, just copy it to temp RAM...
rlm@1 2287 #define TEMP_SAVE_FNAME ("tempvbaread.sav")
rlm@1 2288 int pos = gztell(gzfile);
rlm@1 2289 int buflen = 1024;
rlm@1 2290 // ...make a temp file and write it there...
rlm@1 2291 FILE *fileTemp = fopen(TEMP_SAVE_FNAME, "wb");
rlm@1 2292 if (fileTemp == NULL)
rlm@1 2293 return false;
rlm@1 2294 int gzDeflated;
rlm@1 2295 char *temp = new char [buflen];
rlm@1 2296 while ((gzDeflated = utilGzRead(gzfile, temp, buflen)) != 0)
rlm@1 2297 {
rlm@1 2298 if (gzDeflated == -1 || fwrite(temp, gzDeflated, 1, fileTemp) != 1)
rlm@1 2299 {
rlm@1 2300 delete [] temp;
rlm@1 2301 fclose(fileTemp);
rlm@1 2302 gzseek(gzfile, pos, SEEK_SET); /// FIXME: leaves pos in gzfile before save instead of after it (everything that
rlm@1 2303 // calls this right now does a seek afterwards so it doesn't matter for now, but it's
rlm@1 2304 // still bad)
rlm@1 2305 return false;
rlm@1 2306 }
rlm@1 2307 }
rlm@1 2308 gzseek(gzfile, pos, SEEK_SET); /// FIXME: leaves pos in gzfile before save instead of after it (everything that calls this
rlm@1 2309 // right now does a seek afterwards so it doesn't matter for now, but it's still bad)
rlm@1 2310 fclose(fileTemp);
rlm@1 2311 delete [] temp;
rlm@1 2312
rlm@1 2313 // ... load from the temp file...
rlm@1 2314 bool retVal = gbReadBatteryFile(TEMP_SAVE_FNAME);
rlm@1 2315
rlm@1 2316 // ... and delete the temp file
rlm@1 2317 remove(TEMP_SAVE_FNAME);
rlm@1 2318 #undef TEMP_SAVE_FNAME
rlm@1 2319
rlm@1 2320 return retVal;
rlm@1 2321 }
rlm@1 2322
rlm@1 2323 bool gbReadGSASnapshot(const char *fileName)
rlm@1 2324 {
rlm@1 2325 FILE *file = fopen(fileName, "rb");
rlm@1 2326
rlm@1 2327 if (!file)
rlm@1 2328 {
rlm@1 2329 systemMessage(MSG_CANNOT_OPEN_FILE, N_("Cannot open file %s"), fileName);
rlm@1 2330 return false;
rlm@1 2331 }
rlm@1 2332
rlm@1 2333 // long size = ftell(file);
rlm@1 2334 fseek(file, 0x4, SEEK_SET);
rlm@1 2335 char buffer[16];
rlm@1 2336 char buffer2[16];
rlm@1 2337 fread(buffer, 1, 15, file);
rlm@1 2338 buffer[15] = 0;
rlm@1 2339 memcpy(buffer2, &gbRom[0x134], 15);
rlm@1 2340 buffer2[15] = 0;
rlm@1 2341 if (memcmp(buffer, buffer2, 15))
rlm@1 2342 {
rlm@1 2343 systemMessage(MSG_CANNOT_IMPORT_SNAPSHOT_FOR,
rlm@1 2344 N_("Cannot import snapshot for %s. Current game is %s"),
rlm@1 2345 buffer,
rlm@1 2346 buffer2);
rlm@1 2347 fclose(file);
rlm@1 2348 return false;
rlm@1 2349 }
rlm@1 2350 fseek(file, 0x13, SEEK_SET);
rlm@1 2351 int read = 0;
rlm@1 2352 int toRead = 0;
rlm@1 2353 switch (gbRom[0x147])
rlm@1 2354 {
rlm@1 2355 case 0x03:
rlm@1 2356 case 0x0f:
rlm@1 2357 case 0x10:
rlm@1 2358 case 0x13:
rlm@1 2359 case 0x1b:
rlm@1 2360 case 0x1e:
rlm@1 2361 case 0xff:
rlm@1 2362 read = fread(gbRam, 1, gbRamSize, file);
rlm@1 2363 toRead = gbRamSize;
rlm@1 2364 break;
rlm@1 2365 case 0x06:
rlm@1 2366 case 0x22:
rlm@1 2367 read = fread(&gbMemory[0xa000], 1, 256, file);
rlm@1 2368 toRead = 256;
rlm@1 2369 break;
rlm@1 2370 default:
rlm@1 2371 systemMessage(MSG_UNSUPPORTED_SNAPSHOT_FILE,
rlm@1 2372 N_("Unsupported snapshot file %s"),
rlm@1 2373 fileName);
rlm@1 2374 fclose(file);
rlm@1 2375 return false;
rlm@1 2376 }
rlm@1 2377 fclose(file);
rlm@1 2378 gbReset();
rlm@1 2379 return true;
rlm@1 2380 }
rlm@1 2381
rlm@1 2382 variable_desc gbSaveGameStruct[] =
rlm@1 2383 {
rlm@1 2384 { &PC.W, sizeof(u16) },
rlm@1 2385 { &SP.W, sizeof(u16) },
rlm@1 2386 { &AF.W, sizeof(u16) },
rlm@1 2387 { &BC.W, sizeof(u16) },
rlm@1 2388 { &DE.W, sizeof(u16) },
rlm@1 2389 { &HL.W, sizeof(u16) },
rlm@1 2390 { &IFF, sizeof(u8) },
rlm@1 2391 { &GBLCD_MODE_0_CLOCK_TICKS, sizeof(int32) },
rlm@1 2392 { &GBLCD_MODE_1_CLOCK_TICKS, sizeof(int32) },
rlm@1 2393 { &GBLCD_MODE_2_CLOCK_TICKS, sizeof(int32) },
rlm@1 2394 { &GBLCD_MODE_3_CLOCK_TICKS, sizeof(int32) },
rlm@1 2395 { &GBDIV_CLOCK_TICKS, sizeof(int32) },
rlm@1 2396 { &GBLY_INCREMENT_CLOCK_TICKS, sizeof(int32) },
rlm@1 2397 { &GBTIMER_MODE_0_CLOCK_TICKS, sizeof(int32) },
rlm@1 2398 { &GBTIMER_MODE_1_CLOCK_TICKS, sizeof(int32) },
rlm@1 2399 { &GBTIMER_MODE_2_CLOCK_TICKS, sizeof(int32) },
rlm@1 2400 { &GBTIMER_MODE_3_CLOCK_TICKS, sizeof(int32) },
rlm@1 2401 { &GBSERIAL_CLOCK_TICKS, sizeof(int32) },
rlm@1 2402 { &GBSYNCHRONIZE_CLOCK_TICKS, sizeof(int32) },
rlm@1 2403 { &gbDivTicks, sizeof(int32) },
rlm@1 2404 { &gbLcdMode, sizeof(int32) },
rlm@1 2405 { &gbLcdTicks, sizeof(int32) },
rlm@1 2406 { &gbLcdLYIncrementTicks, sizeof(int32) },
rlm@1 2407 { &gbTimerTicks, sizeof(int32) },
rlm@1 2408 { &gbTimerClockTicks, sizeof(int32) },
rlm@1 2409 { &gbSerialTicks, sizeof(int32) },
rlm@1 2410 { &gbSerialBits, sizeof(int32) },
rlm@1 2411 { &gbInterrupt, sizeof(int32) },
rlm@1 2412 { &gbInterruptWait, sizeof(int32) },
rlm@1 2413 { &gbSynchronizeTicks, sizeof(int32) },
rlm@1 2414 { &gbTimerOn, sizeof(int32) },
rlm@1 2415 { &gbTimerMode, sizeof(int32) },
rlm@1 2416 { &gbSerialOn, sizeof(int32) },
rlm@1 2417 { &gbWindowLine, sizeof(int32) },
rlm@1 2418 { &gbCgbMode, sizeof(int32) },
rlm@1 2419 { &gbVramBank, sizeof(int32) },
rlm@1 2420 { &gbWramBank, sizeof(int32) },
rlm@1 2421 { &gbHdmaSource, sizeof(int32) },
rlm@1 2422 { &gbHdmaDestination, sizeof(int32) },
rlm@1 2423 { &gbHdmaBytes, sizeof(int32) },
rlm@1 2424 { &gbHdmaOn, sizeof(int32) },
rlm@1 2425 { &gbSpeed, sizeof(int32) },
rlm@1 2426 { &gbSgbMode, sizeof(int32) },
rlm@1 2427 { &register_DIV, sizeof(u8) },
rlm@1 2428 { &register_TIMA, sizeof(u8) },
rlm@1 2429 { &register_TMA, sizeof(u8) },
rlm@1 2430 { &register_TAC, sizeof(u8) },
rlm@1 2431 { &register_IF, sizeof(u8) },
rlm@1 2432 { &register_LCDC, sizeof(u8) },
rlm@1 2433 { &register_STAT, sizeof(u8) },
rlm@1 2434 { &register_SCY, sizeof(u8) },
rlm@1 2435 { &register_SCX, sizeof(u8) },
rlm@1 2436 { &register_LY, sizeof(u8) },
rlm@1 2437 { &register_LYC, sizeof(u8) },
rlm@1 2438 { &register_DMA, sizeof(u8) },
rlm@1 2439 { &register_WY, sizeof(u8) },
rlm@1 2440 { &register_WX, sizeof(u8) },
rlm@1 2441 { &register_VBK, sizeof(u8) },
rlm@1 2442 { &register_HDMA1, sizeof(u8) },
rlm@1 2443 { &register_HDMA2, sizeof(u8) },
rlm@1 2444 { &register_HDMA3, sizeof(u8) },
rlm@1 2445 { &register_HDMA4, sizeof(u8) },
rlm@1 2446 { &register_HDMA5, sizeof(u8) },
rlm@1 2447 { &register_SVBK, sizeof(u8) },
rlm@1 2448 { &register_IE, sizeof(u8) },
rlm@1 2449 { &gbBgp[0], sizeof(u8) },
rlm@1 2450 { &gbBgp[1], sizeof(u8) },
rlm@1 2451 { &gbBgp[2], sizeof(u8) },
rlm@1 2452 { &gbBgp[3], sizeof(u8) },
rlm@1 2453 { &gbObp0[0], sizeof(u8) },
rlm@1 2454 { &gbObp0[1], sizeof(u8) },
rlm@1 2455 { &gbObp0[2], sizeof(u8) },
rlm@1 2456 { &gbObp0[3], sizeof(u8) },
rlm@1 2457 { &gbObp1[0], sizeof(u8) },
rlm@1 2458 { &gbObp1[1], sizeof(u8) },
rlm@1 2459 { &gbObp1[2], sizeof(u8) },
rlm@1 2460 { &gbObp1[3], sizeof(u8) },
rlm@1 2461 { NULL, 0 }
rlm@1 2462 };
rlm@1 2463
rlm@1 2464 bool gbWriteSaveStateToStream(gzFile gzFile)
rlm@1 2465 {
rlm@1 2466 utilWriteInt(gzFile, GBSAVE_GAME_VERSION);
rlm@1 2467
rlm@1 2468 utilGzWrite(gzFile, &gbRom[0x134], 15);
rlm@1 2469
rlm@1 2470 utilWriteData(gzFile, gbSaveGameStruct);
rlm@1 2471
rlm@1 2472 utilGzWrite(gzFile, &IFF, 2);
rlm@1 2473
rlm@1 2474 if (gbSgbMode)
rlm@1 2475 {
rlm@1 2476 gbSgbSaveGame(gzFile);
rlm@1 2477 }
rlm@1 2478
rlm@1 2479 utilGzWrite(gzFile, &gbDataMBC1, sizeof(gbDataMBC1));
rlm@1 2480 utilGzWrite(gzFile, &gbDataMBC2, sizeof(gbDataMBC2));
rlm@1 2481 //assert(sizeof(time_t) == 4);
rlm@1 2482 utilGzWrite(gzFile, &gbDataMBC3, sizeof(gbDataMBC3));
rlm@1 2483 utilGzWrite(gzFile, &gbDataMBC5, sizeof(gbDataMBC5));
rlm@1 2484 utilGzWrite(gzFile, &gbDataHuC1, sizeof(gbDataHuC1));
rlm@1 2485 utilGzWrite(gzFile, &gbDataHuC3, sizeof(gbDataHuC3));
rlm@1 2486
rlm@1 2487 // yes, this definitely needs to be saved, or loading paused games will show a black screen
rlm@1 2488 // this is also necessary to be consistent with what the GBA saving does
rlm@1 2489 utilGzWrite(gzFile, pix, 4 * 257 * 226);
rlm@1 2490
rlm@1 2491 utilGzWrite(gzFile, gbPalette, 128 * sizeof(u16));
rlm@1 2492 // todo: remove
rlm@1 2493 utilGzWrite(gzFile, gbPalette, 128 * sizeof(u16));
rlm@1 2494
rlm@1 2495 utilGzWrite(gzFile, &gbMemory[0x8000], 0x8000);
rlm@1 2496
rlm@1 2497 if (gbRamSize && gbRam)
rlm@1 2498 {
rlm@1 2499 utilGzWrite(gzFile, gbRam, gbRamSize);
rlm@1 2500 }
rlm@1 2501
rlm@1 2502 if (gbCgbMode)
rlm@1 2503 {
rlm@1 2504 utilGzWrite(gzFile, gbVram, 0x4000);
rlm@1 2505 utilGzWrite(gzFile, gbWram, 0x8000);
rlm@1 2506 }
rlm@1 2507
rlm@1 2508 gbSoundSaveGame(gzFile);
rlm@1 2509
rlm@1 2510 gbCheatsSaveGame(gzFile);
rlm@1 2511
rlm@1 2512 // new to re-recording version:
rlm@1 2513 {
rlm@1 2514 extern int32 sensorX, sensorY;
rlm@1 2515 utilGzWrite(gzFile, &sensorX, sizeof(sensorX));
rlm@1 2516 utilGzWrite(gzFile, &sensorY, sizeof(sensorY));
rlm@1 2517 utilGzWrite(gzFile, gbJoymask, 4 * sizeof(*gbJoymask)); // this has to be saved or old input will incorrectly get
rlm@1 2518 // carried
rlm@1 2519 // back on loading a snapshot!
rlm@1 2520
rlm@1 2521 bool8 movieActive = VBAMovieActive();
rlm@1 2522 utilGzWrite(gzFile, &movieActive, sizeof(movieActive));
rlm@1 2523 if (movieActive)
rlm@1 2524 {
rlm@1 2525 uint8 *movie_freeze_buf = NULL;
rlm@1 2526 uint32 movie_freeze_size = 0;
rlm@1 2527
rlm@1 2528 VBAMovieFreeze(&movie_freeze_buf, &movie_freeze_size);
rlm@1 2529 if (movie_freeze_buf)
rlm@1 2530 {
rlm@1 2531 utilGzWrite(gzFile, &movie_freeze_size, sizeof(movie_freeze_size));
rlm@1 2532 utilGzWrite(gzFile, movie_freeze_buf, movie_freeze_size);
rlm@1 2533 delete [] movie_freeze_buf;
rlm@1 2534 }
rlm@1 2535 else
rlm@1 2536 {
rlm@1 2537 systemMessage(0, N_("Failed to save movie snapshot."));
rlm@1 2538 return false;
rlm@1 2539 }
rlm@1 2540 }
rlm@1 2541 utilGzWrite(gzFile, &GBSystemCounters.frameCount, sizeof(GBSystemCounters.frameCount));
rlm@1 2542 }
rlm@1 2543
rlm@1 2544 // new to rerecording 19.4 wip (svn r22+):
rlm@1 2545 {
rlm@1 2546 utilGzWrite(gzFile, &GBSystemCounters.lagCount, sizeof(GBSystemCounters.lagCount));
rlm@1 2547 utilGzWrite(gzFile, &GBSystemCounters.lagged, sizeof(GBSystemCounters.lagged));
rlm@1 2548 utilGzWrite(gzFile, &GBSystemCounters.laggedLast, sizeof(GBSystemCounters.laggedLast));
rlm@1 2549 }
rlm@1 2550
rlm@1 2551 return true;
rlm@1 2552 }
rlm@1 2553
rlm@1 2554 bool gbWriteMemSaveState(char *memory, int available)
rlm@1 2555 {
rlm@1 2556 gzFile gzFile = utilMemGzOpen(memory, available, "w");
rlm@1 2557
rlm@1 2558 if (gzFile == NULL)
rlm@1 2559 {
rlm@1 2560 return false;
rlm@1 2561 }
rlm@1 2562
rlm@1 2563 bool res = gbWriteSaveStateToStream(gzFile);
rlm@1 2564
rlm@1 2565 long pos = utilGzTell(gzFile) + 8;
rlm@1 2566
rlm@1 2567 if (pos >= (available))
rlm@1 2568 res = false;
rlm@1 2569
rlm@1 2570 utilGzClose(gzFile);
rlm@1 2571
rlm@1 2572 return res;
rlm@1 2573 }
rlm@1 2574
rlm@1 2575 bool gbWriteSaveState(const char *name)
rlm@1 2576 {
rlm@1 2577 gzFile gzFile = utilGzOpen(name, "wb");
rlm@1 2578
rlm@1 2579 if (gzFile == NULL)
rlm@1 2580 return false;
rlm@1 2581
rlm@1 2582 bool res = gbWriteSaveStateToStream(gzFile);
rlm@1 2583
rlm@1 2584 utilGzClose(gzFile);
rlm@1 2585 return res;
rlm@1 2586 }
rlm@1 2587
rlm@1 2588 static int tempStateID = 0;
rlm@1 2589 static int tempFailCount = 0;
rlm@1 2590 static bool backupSafe = true;
rlm@1 2591
rlm@1 2592 bool gbReadSaveStateFromStream(gzFile gzFile)
rlm@1 2593 {
rlm@1 2594 int type;
rlm@1 2595 char tempBackupName [128];
rlm@1 2596 if (backupSafe)
rlm@1 2597 {
rlm@1 2598 sprintf(tempBackupName, "gbatempsave%d.sav", tempStateID++);
rlm@1 2599 gbWriteSaveState(tempBackupName);
rlm@1 2600 }
rlm@1 2601
rlm@1 2602 int version = utilReadInt(gzFile);
rlm@1 2603
rlm@1 2604 if (version > GBSAVE_GAME_VERSION || version < 0)
rlm@1 2605 {
rlm@1 2606 systemMessage(MSG_UNSUPPORTED_VB_SGM,
rlm@1 2607 N_("Unsupported VisualBoy save game version %d"), version);
rlm@1 2608 goto failedLoadGB;
rlm@1 2609 }
rlm@1 2610
rlm@1 2611 u8 romname[20];
rlm@1 2612
rlm@1 2613 utilGzRead(gzFile, romname, 15);
rlm@1 2614
rlm@1 2615 if (memcmp(&gbRom[0x134], romname, 15) != 0)
rlm@1 2616 {
rlm@1 2617 systemMessage(MSG_CANNOT_LOAD_SGM_FOR,
rlm@1 2618 N_("Cannot load save game for %s. Playing %s"),
rlm@1 2619 romname, &gbRom[0x134]);
rlm@1 2620 goto failedLoadGB;
rlm@1 2621 }
rlm@1 2622
rlm@1 2623 utilReadData(gzFile, gbSaveGameStruct);
rlm@1 2624
rlm@1 2625 if (version >= GBSAVE_GAME_VERSION_7)
rlm@1 2626 {
rlm@1 2627 utilGzRead(gzFile, &IFF, 2);
rlm@1 2628 }
rlm@1 2629
rlm@1 2630 if (gbSgbMode)
rlm@1 2631 {
rlm@1 2632 gbSgbReadGame(gzFile, version);
rlm@1 2633 }
rlm@1 2634 else
rlm@1 2635 {
rlm@1 2636 gbSgbMask = 0; // loading a game at the wrong time causes no display
rlm@1 2637 }
rlm@1 2638
rlm@1 2639 utilGzRead(gzFile, &gbDataMBC1, sizeof(gbDataMBC1));
rlm@1 2640 utilGzRead(gzFile, &gbDataMBC2, sizeof(gbDataMBC2));
rlm@1 2641 if (version < GBSAVE_GAME_VERSION_4)
rlm@1 2642 // prior to version 4, there was no adjustment for the time the game
rlm@1 2643 // was last played, so we have less to read. This needs update if the
rlm@1 2644 // structure changes again.
rlm@1 2645 utilGzRead(gzFile, &gbDataMBC3, sizeof(int32) * 10);
rlm@1 2646 else
rlm@1 2647 {
rlm@1 2648 //assert(sizeof(time_t) == 4);
rlm@1 2649 utilGzRead(gzFile, &gbDataMBC3, sizeof(gbDataMBC3));
rlm@1 2650 }
rlm@1 2651 utilGzRead(gzFile, &gbDataMBC5, sizeof(gbDataMBC5));
rlm@1 2652 utilGzRead(gzFile, &gbDataHuC1, sizeof(gbDataHuC1));
rlm@1 2653 utilGzRead(gzFile, &gbDataHuC3, sizeof(gbDataHuC3));
rlm@1 2654
rlm@1 2655 if (version >= GBSAVE_GAME_VERSION_12)
rlm@1 2656 {
rlm@1 2657 utilGzRead(gzFile, pix, 4 * 257 * 226);
rlm@1 2658 }
rlm@1 2659 else
rlm@1 2660 {
rlm@1 2661 memset(pix, 0, 257 * 226 * sizeof(u32));
rlm@1 2662 // if(version < GBSAVE_GAME_VERSION_5)
rlm@1 2663 // utilGzRead(gzFile, pix, 256*224*sizeof(u16));
rlm@1 2664 }
rlm@1 2665
rlm@1 2666 if (version < GBSAVE_GAME_VERSION_6)
rlm@1 2667 {
rlm@1 2668 utilGzRead(gzFile, gbPalette, 64 * sizeof(u16));
rlm@1 2669 }
rlm@1 2670 else
rlm@1 2671 utilGzRead(gzFile, gbPalette, 128 * sizeof(u16));
rlm@1 2672
rlm@1 2673 // todo: remove
rlm@1 2674 utilGzRead(gzFile, gbPalette, 128 * sizeof(u16));
rlm@1 2675
rlm@1 2676 if (version < GBSAVE_GAME_VERSION_10)
rlm@1 2677 {
rlm@1 2678 if (!gbCgbMode && !gbSgbMode)
rlm@1 2679 {
rlm@1 2680 for (int i = 0; i < 8; i++)
rlm@1 2681 gbPalette[i] = systemGbPalette[gbPaletteOption * 8 + i];
rlm@1 2682 }
rlm@1 2683 }
rlm@1 2684
rlm@1 2685 utilGzRead(gzFile, &gbMemory[0x8000], 0x8000);
rlm@1 2686
rlm@1 2687 if (gbRamSize && gbRam)
rlm@1 2688 {
rlm@1 2689 utilGzRead(gzFile, gbRam, gbRamSize);
rlm@1 2690 }
rlm@1 2691
rlm@1 2692 gbMemoryMap[0x00] = &gbRom[0x0000];
rlm@1 2693 gbMemoryMap[0x01] = &gbRom[0x1000];
rlm@1 2694 gbMemoryMap[0x02] = &gbRom[0x2000];
rlm@1 2695 gbMemoryMap[0x03] = &gbRom[0x3000];
rlm@1 2696 gbMemoryMap[0x04] = &gbRom[0x4000];
rlm@1 2697 gbMemoryMap[0x05] = &gbRom[0x5000];
rlm@1 2698 gbMemoryMap[0x06] = &gbRom[0x6000];
rlm@1 2699 gbMemoryMap[0x07] = &gbRom[0x7000];
rlm@1 2700 gbMemoryMap[0x08] = &gbMemory[0x8000];
rlm@1 2701 gbMemoryMap[0x09] = &gbMemory[0x9000];
rlm@1 2702 gbMemoryMap[0x0a] = &gbMemory[0xa000];
rlm@1 2703 gbMemoryMap[0x0b] = &gbMemory[0xb000];
rlm@1 2704 gbMemoryMap[0x0c] = &gbMemory[0xc000];
rlm@1 2705 gbMemoryMap[0x0d] = &gbMemory[0xd000];
rlm@1 2706 gbMemoryMap[0x0e] = &gbMemory[0xe000];
rlm@1 2707 gbMemoryMap[0x0f] = &gbMemory[0xf000];
rlm@1 2708
rlm@1 2709 type = gbRom[0x147];
rlm@1 2710
rlm@1 2711 switch (type)
rlm@1 2712 {
rlm@1 2713 case 0x00:
rlm@1 2714 case 0x01:
rlm@1 2715 case 0x02:
rlm@1 2716 case 0x03:
rlm@1 2717 // MBC 1
rlm@1 2718 memoryUpdateMapMBC1();
rlm@1 2719 break;
rlm@1 2720 case 0x05:
rlm@1 2721 case 0x06:
rlm@1 2722 // MBC2
rlm@1 2723 memoryUpdateMapMBC2();
rlm@1 2724 break;
rlm@1 2725 case 0x0f:
rlm@1 2726 case 0x10:
rlm@1 2727 case 0x11:
rlm@1 2728 case 0x12:
rlm@1 2729 case 0x13:
rlm@1 2730 // MBC 3
rlm@1 2731 memoryUpdateMapMBC3();
rlm@1 2732 break;
rlm@1 2733 case 0x19:
rlm@1 2734 case 0x1a:
rlm@1 2735 case 0x1b:
rlm@1 2736 // MBC5
rlm@1 2737 memoryUpdateMapMBC5();
rlm@1 2738 break;
rlm@1 2739 case 0x1c:
rlm@1 2740 case 0x1d:
rlm@1 2741 case 0x1e:
rlm@1 2742 // MBC 5 Rumble
rlm@1 2743 memoryUpdateMapMBC5();
rlm@1 2744 break;
rlm@1 2745 case 0x22:
rlm@1 2746 // MBC 7
rlm@1 2747 memoryUpdateMapMBC7();
rlm@1 2748 break;
rlm@1 2749 case 0xfe:
rlm@1 2750 // HuC3
rlm@1 2751 memoryUpdateMapHuC3();
rlm@1 2752 break;
rlm@1 2753 case 0xff:
rlm@1 2754 // HuC1
rlm@1 2755 memoryUpdateMapHuC1();
rlm@1 2756 break;
rlm@1 2757 }
rlm@1 2758
rlm@1 2759 if (gbCgbMode)
rlm@1 2760 {
rlm@1 2761 if (!gbVram)
rlm@1 2762 gbVram = (u8 *)malloc(0x4000 + 4);
rlm@1 2763 if (!gbWram)
rlm@1 2764 gbWram = (u8 *)malloc(0x8000 + 4);
rlm@1 2765 utilGzRead(gzFile, gbVram, 0x4000);
rlm@1 2766 utilGzRead(gzFile, gbWram, 0x8000);
rlm@1 2767
rlm@1 2768 int value = register_SVBK;
rlm@1 2769 if (value == 0)
rlm@1 2770 value = 1;
rlm@1 2771
rlm@1 2772 gbMemoryMap[0x08] = &gbVram[register_VBK * 0x2000];
rlm@1 2773 gbMemoryMap[0x09] = &gbVram[register_VBK * 0x2000 + 0x1000];
rlm@1 2774 gbMemoryMap[0x0d] = &gbWram[value * 0x1000];
rlm@1 2775 }
rlm@1 2776 else
rlm@1 2777 {
rlm@1 2778 if (gbVram)
rlm@1 2779 {
rlm@1 2780 free(gbVram);
rlm@1 2781 gbVram = NULL;
rlm@1 2782 }
rlm@1 2783 if (gbWram)
rlm@1 2784 {
rlm@1 2785 free(gbWram);
rlm@1 2786 gbWram = NULL;
rlm@1 2787 }
rlm@1 2788 }
rlm@1 2789
rlm@1 2790 gbSoundReadGame(version, gzFile);
rlm@1 2791
rlm@1 2792 #if 0
rlm@1 2793 if (gbBorderOn)
rlm@1 2794 {
rlm@1 2795 gbSgbRenderBorder();
rlm@1 2796 }
rlm@1 2797
rlm@1 2798 systemRefreshScreen();
rlm@1 2799 #endif
rlm@1 2800
rlm@1 2801 if (version > GBSAVE_GAME_VERSION_1)
rlm@1 2802 gbCheatsReadGame(gzFile, version);
rlm@1 2803
rlm@1 2804 systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED;
rlm@1 2805
rlm@1 2806 if (version >= GBSAVE_GAME_VERSION_11) // new to re-recording version:
rlm@1 2807 {
rlm@1 2808 extern int32 sensorX, sensorY; // from SDL.cpp
rlm@1 2809 utilGzRead(gzFile, &sensorX, sizeof(sensorX));
rlm@1 2810 utilGzRead(gzFile, &sensorY, sizeof(sensorY));
rlm@1 2811 utilGzRead(gzFile, gbJoymask, 4 * sizeof(*gbJoymask)); // this has to be saved or old input will incorrectly get carried
rlm@1 2812 // back on loading a snapshot!
rlm@1 2813
rlm@1 2814 bool8 movieSnapshot;
rlm@1 2815 utilGzRead(gzFile, &movieSnapshot, sizeof(movieSnapshot));
rlm@1 2816 if (VBAMovieActive() && !movieSnapshot)
rlm@1 2817 {
rlm@1 2818 systemMessage(0, N_("Can't load a non-movie snapshot while a movie is active."));
rlm@1 2819 goto failedLoadGB;
rlm@1 2820 }
rlm@1 2821
rlm@1 2822 if (movieSnapshot) // even if a movie isn't active we still want to parse through this in case other stuff is added
rlm@1 2823 // later on in the save format
rlm@1 2824 {
rlm@1 2825 uint32 movieInputDataSize = 0;
rlm@1 2826 utilGzRead(gzFile, &movieInputDataSize, sizeof(movieInputDataSize));
rlm@1 2827 uint8 *local_movie_data = new uint8 [movieInputDataSize];
rlm@1 2828 int readBytes = utilGzRead(gzFile, local_movie_data, movieInputDataSize);
rlm@1 2829 if (readBytes != movieInputDataSize)
rlm@1 2830 {
rlm@1 2831 systemMessage(0, N_("Corrupt movie snapshot."));
rlm@1 2832 if (local_movie_data)
rlm@1 2833 delete [] local_movie_data;
rlm@1 2834 goto failedLoadGB;
rlm@1 2835 }
rlm@1 2836 int code = VBAMovieUnfreeze(local_movie_data, movieInputDataSize);
rlm@1 2837 if (local_movie_data)
rlm@1 2838 delete [] local_movie_data;
rlm@1 2839 if (code != MOVIE_SUCCESS && VBAMovieActive())
rlm@1 2840 {
rlm@1 2841 char errStr [1024];
rlm@1 2842 strcpy(errStr, "Failed to load movie snapshot");
rlm@1 2843 switch (code)
rlm@1 2844 {
rlm@1 2845 case MOVIE_NOT_FROM_THIS_MOVIE:
rlm@1 2846 strcat(errStr, ";\nSnapshot not from this movie"); break;
rlm@1 2847 case MOVIE_NOT_FROM_A_MOVIE:
rlm@1 2848 strcat(errStr, ";\nNot a movie snapshot"); break; // shouldn't get here...
rlm@1 2849 case MOVIE_SNAPSHOT_INCONSISTENT:
rlm@1 2850 strcat(errStr, ";\nSnapshot inconsistent with movie"); break;
rlm@1 2851 case MOVIE_WRONG_FORMAT:
rlm@1 2852 strcat(errStr, ";\nWrong format"); break;
rlm@1 2853 }
rlm@1 2854 strcat(errStr, ".");
rlm@1 2855 systemMessage(0, N_(errStr));
rlm@1 2856 goto failedLoadGB;
rlm@1 2857 }
rlm@1 2858 }
rlm@1 2859 utilGzRead(gzFile, &GBSystemCounters.frameCount, sizeof(GBSystemCounters.frameCount));
rlm@1 2860 }
rlm@1 2861
rlm@1 2862 if (version >= GBSAVE_GAME_VERSION_13) // new to rerecording 19.4 wip (svn r22+):
rlm@1 2863 {
rlm@1 2864 utilGzRead(gzFile, &GBSystemCounters.lagCount, sizeof(GBSystemCounters.lagCount));
rlm@1 2865 utilGzRead(gzFile, &GBSystemCounters.lagged, sizeof(GBSystemCounters.lagged));
rlm@1 2866 utilGzRead(gzFile, &GBSystemCounters.laggedLast, sizeof(GBSystemCounters.laggedLast));
rlm@1 2867 }
rlm@1 2868
rlm@1 2869 if (backupSafe)
rlm@1 2870 {
rlm@1 2871 remove(tempBackupName);
rlm@1 2872 tempFailCount = 0;
rlm@1 2873 }
rlm@1 2874
rlm@1 2875 for (int i = 0; i < 4; ++i)
rlm@1 2876 systemSetJoypad(i, gbJoymask[i] & 0xFFFF);
rlm@1 2877
rlm@1 2878 // FIXME: horrible kludge
rlm@1 2879 memcpy(s_gbJoymask, gbJoymask, sizeof(gbJoymask));
rlm@1 2880
rlm@1 2881 VBAUpdateButtonPressDisplay();
rlm@1 2882 VBAUpdateFrameCountDisplay();
rlm@1 2883 systemRefreshScreen();
rlm@1 2884 return true;
rlm@1 2885
rlm@1 2886 failedLoadGB:
rlm@1 2887 if (backupSafe)
rlm@1 2888 {
rlm@1 2889 tempFailCount++;
rlm@1 2890 if (tempFailCount < 3) // fail no more than 2 times in a row
rlm@1 2891 gbReadSaveState(tempBackupName);
rlm@1 2892 remove(tempBackupName);
rlm@1 2893 }
rlm@1 2894 return false;
rlm@1 2895 }
rlm@1 2896
rlm@1 2897 bool gbReadMemSaveState(char *memory, int available)
rlm@1 2898 {
rlm@1 2899 gzFile gzFile = utilMemGzOpen(memory, available, "r");
rlm@1 2900
rlm@1 2901 backupSafe = false;
rlm@1 2902 bool res = gbReadSaveStateFromStream(gzFile);
rlm@1 2903 backupSafe = true;
rlm@1 2904
rlm@1 2905 utilGzClose(gzFile);
rlm@1 2906
rlm@1 2907 return res;
rlm@1 2908 }
rlm@1 2909
rlm@1 2910 bool gbReadSaveState(const char *name)
rlm@1 2911 {
rlm@1 2912 gzFile gzFile = utilGzOpen(name, "rb");
rlm@1 2913
rlm@1 2914 if (gzFile == NULL)
rlm@1 2915 {
rlm@1 2916 return false;
rlm@1 2917 }
rlm@1 2918
rlm@1 2919 bool res = gbReadSaveStateFromStream(gzFile);
rlm@1 2920
rlm@1 2921 utilGzClose(gzFile);
rlm@1 2922
rlm@1 2923 return res;
rlm@1 2924 }
rlm@1 2925
rlm@1 2926 bool gbWritePNGFile(const char *fileName)
rlm@1 2927 {
rlm@1 2928 if (gbBorderOn)
rlm@1 2929 return utilWritePNGFile(fileName, 256, 224, pix);
rlm@1 2930 return utilWritePNGFile(fileName, 160, 144, pix);
rlm@1 2931 }
rlm@1 2932
rlm@1 2933 bool gbWriteBMPFile(const char *fileName)
rlm@1 2934 {
rlm@1 2935 if (gbBorderOn)
rlm@1 2936 return utilWriteBMPFile(fileName, 256, 224, pix);
rlm@1 2937 return utilWriteBMPFile(fileName, 160, 144, pix);
rlm@1 2938 }
rlm@1 2939
rlm@1 2940 void gbCleanUp()
rlm@1 2941 {
rlm@1 2942 newFrame = true;
rlm@1 2943
rlm@1 2944 GBSystemCounters.frameCount = 0;
rlm@1 2945 GBSystemCounters.lagCount = 0;
rlm@1 2946 GBSystemCounters.extraCount = 0;
rlm@1 2947 GBSystemCounters.lagged = true;
rlm@1 2948 GBSystemCounters.laggedLast = true;
rlm@1 2949
rlm@1 2950 if (gbRam != NULL)
rlm@1 2951 {
rlm@1 2952 free(gbRam);
rlm@1 2953 gbRam = NULL;
rlm@1 2954 }
rlm@1 2955
rlm@1 2956 if (gbRom != NULL)
rlm@1 2957 {
rlm@1 2958 free(gbRom);
rlm@1 2959 gbRom = NULL;
rlm@1 2960 }
rlm@1 2961
rlm@1 2962 if (gbMemory != NULL)
rlm@1 2963 {
rlm@1 2964 free(gbMemory);
rlm@1 2965 gbMemory = NULL;
rlm@1 2966 }
rlm@1 2967
rlm@1 2968 if (gbLineBuffer != NULL)
rlm@1 2969 {
rlm@1 2970 free(gbLineBuffer);
rlm@1 2971 gbLineBuffer = NULL;
rlm@1 2972 }
rlm@1 2973
rlm@1 2974 if (origPix != NULL)
rlm@1 2975 {
rlm@1 2976 free(origPix);
rlm@1 2977 origPix = NULL;
rlm@1 2978 }
rlm@1 2979 pix = NULL;
rlm@1 2980
rlm@1 2981 gbSgbShutdown();
rlm@1 2982
rlm@1 2983 if (gbVram != NULL)
rlm@1 2984 {
rlm@1 2985 free(gbVram);
rlm@1 2986 gbVram = NULL;
rlm@1 2987 }
rlm@1 2988
rlm@1 2989 if (gbWram != NULL)
rlm@1 2990 {
rlm@1 2991 free(gbWram);
rlm@1 2992 gbWram = NULL;
rlm@1 2993 }
rlm@1 2994
rlm@1 2995 systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED;
rlm@1 2996
rlm@1 2997 memset(gbJoymask, 0, sizeof(gbJoymask));
rlm@1 2998 // FIXME: horrible kludge
rlm@1 2999 memset(s_gbJoymask, 0, sizeof(s_gbJoymask));
rlm@1 3000
rlm@1 3001 systemClearJoypads();
rlm@1 3002 systemResetSensor();
rlm@1 3003
rlm@1 3004 // gbLastTime = gbFrameCount = 0;
rlm@1 3005 systemRefreshScreen();
rlm@1 3006 }
rlm@1 3007
rlm@1 3008 bool gbLoadRom(const char *szFile)
rlm@1 3009 {
rlm@1 3010 int size = 0;
rlm@1 3011
rlm@1 3012 if (gbRom != NULL)
rlm@1 3013 {
rlm@1 3014 gbCleanUp();
rlm@1 3015 }
rlm@1 3016
rlm@1 3017 systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED;
rlm@1 3018
rlm@1 3019 gbRom = utilLoad(szFile,
rlm@1 3020 utilIsGBImage,
rlm@1 3021 NULL,
rlm@1 3022 size);
rlm@1 3023 if (!gbRom)
rlm@1 3024 return false;
rlm@1 3025
rlm@1 3026 gbRomSize = size;
rlm@1 3027
rlm@1 3028 return gbUpdateSizes();
rlm@1 3029 }
rlm@1 3030
rlm@1 3031 bool gbUpdateSizes()
rlm@1 3032 {
rlm@1 3033 if (gbRom[0x148] > 8)
rlm@1 3034 {
rlm@1 3035 systemMessage(MSG_UNSUPPORTED_ROM_SIZE,
rlm@1 3036 N_("Unsupported rom size %02x"), gbRom[0x148]);
rlm@1 3037 return false;
rlm@1 3038 }
rlm@1 3039
rlm@1 3040 if (gbRomSize < gbRomSizes[gbRom[0x148]])
rlm@1 3041 {
rlm@1 3042 gbRom = (u8 *)realloc(gbRom, gbRomSizes[gbRom[0x148]]);
rlm@1 3043 }
rlm@1 3044 gbRomSize = gbRomSizes[gbRom[0x148]];
rlm@1 3045 gbRomSizeMask = gbRomSizesMasks[gbRom[0x148]];
rlm@1 3046
rlm@1 3047 if (gbRom[0x149] > 5)
rlm@1 3048 {
rlm@1 3049 systemMessage(MSG_UNSUPPORTED_RAM_SIZE,
rlm@1 3050 N_("Unsupported ram size %02x"), gbRom[0x149]);
rlm@1 3051 return false;
rlm@1 3052 }
rlm@1 3053
rlm@1 3054 gbRamSize = gbRamSizes[gbRom[0x149]];
rlm@1 3055 gbRamSizeMask = gbRamSizesMasks[gbRom[0x149]];
rlm@1 3056
rlm@1 3057 if (gbRamSize)
rlm@1 3058 {
rlm@1 3059 gbRam = (u8 *)malloc(gbRamSize + 4);
rlm@1 3060 memset(gbRam, 0xFF, gbRamSize + 4);
rlm@1 3061 }
rlm@1 3062
rlm@1 3063 int type = gbRom[0x147];
rlm@1 3064
rlm@1 3065 mapperReadRAM = NULL;
rlm@1 3066
rlm@1 3067 switch (type)
rlm@1 3068 {
rlm@1 3069 case 0x00:
rlm@1 3070 case 0x01:
rlm@1 3071 case 0x02:
rlm@1 3072 case 0x03:
rlm@1 3073 // MBC 1
rlm@1 3074 mapper = mapperMBC1ROM;
rlm@1 3075 mapperRAM = mapperMBC1RAM;
rlm@1 3076 break;
rlm@1 3077 case 0x05:
rlm@1 3078 case 0x06:
rlm@1 3079 // MBC2
rlm@1 3080 mapper = mapperMBC2ROM;
rlm@1 3081 mapperRAM = mapperMBC2RAM;
rlm@1 3082 gbRamSize = 0x200;
rlm@1 3083 gbRamSizeMask = 0x1ff;
rlm@1 3084 break;
rlm@1 3085 case 0x0f:
rlm@1 3086 case 0x10:
rlm@1 3087 case 0x11:
rlm@1 3088 case 0x12:
rlm@1 3089 case 0x13:
rlm@1 3090 // MBC 3
rlm@1 3091 mapper = mapperMBC3ROM;
rlm@1 3092 mapperRAM = mapperMBC3RAM;
rlm@1 3093 mapperReadRAM = mapperMBC3ReadRAM;
rlm@1 3094 break;
rlm@1 3095 case 0x19:
rlm@1 3096 case 0x1a:
rlm@1 3097 case 0x1b:
rlm@1 3098 // MBC5
rlm@1 3099 mapper = mapperMBC5ROM;
rlm@1 3100 mapperRAM = mapperMBC5RAM;
rlm@1 3101 break;
rlm@1 3102 case 0x1c:
rlm@1 3103 case 0x1d:
rlm@1 3104 case 0x1e:
rlm@1 3105 // MBC 5 Rumble
rlm@1 3106 mapper = mapperMBC5ROM;
rlm@1 3107 mapperRAM = mapperMBC5RAM;
rlm@1 3108 break;
rlm@1 3109 case 0x22:
rlm@1 3110 // MBC 7
rlm@1 3111 mapper = mapperMBC7ROM;
rlm@1 3112 mapperRAM = mapperMBC7RAM;
rlm@1 3113 mapperReadRAM = mapperMBC7ReadRAM;
rlm@1 3114 break;
rlm@1 3115 case 0xfe:
rlm@1 3116 // HuC3
rlm@1 3117 mapper = mapperHuC3ROM;
rlm@1 3118 mapperRAM = mapperHuC3RAM;
rlm@1 3119 mapperReadRAM = mapperHuC3ReadRAM;
rlm@1 3120 break;
rlm@1 3121 case 0xff:
rlm@1 3122 // HuC1
rlm@1 3123 mapper = mapperHuC1ROM;
rlm@1 3124 mapperRAM = mapperHuC1RAM;
rlm@1 3125 break;
rlm@1 3126 default:
rlm@1 3127 systemMessage(MSG_UNKNOWN_CARTRIDGE_TYPE,
rlm@1 3128 N_("Unknown cartridge type %02x"), type);
rlm@1 3129 return false;
rlm@1 3130 }
rlm@1 3131
rlm@1 3132 switch (type)
rlm@1 3133 {
rlm@1 3134 case 0x03:
rlm@1 3135 case 0x06:
rlm@1 3136 case 0x0f:
rlm@1 3137 case 0x10:
rlm@1 3138 case 0x13:
rlm@1 3139 case 0x1b:
rlm@1 3140 case 0x1d:
rlm@1 3141 case 0x1e:
rlm@1 3142 case 0x22:
rlm@1 3143 case 0xff:
rlm@1 3144 gbBattery = 1;
rlm@1 3145 break;
rlm@1 3146 }
rlm@1 3147
rlm@1 3148 gbInit();
rlm@1 3149 gbReset();
rlm@1 3150
rlm@1 3151 return true;
rlm@1 3152 }
rlm@1 3153
rlm@1 3154 void gbEmulate(int ticksToStop)
rlm@1 3155 {
rlm@1 3156 gbRegister tempRegister;
rlm@1 3157 u8 tempValue;
rlm@1 3158 s8 offset;
rlm@1 3159
rlm@1 3160 int clockTicks = 0;
rlm@1 3161 gbDmaTicks = 0;
rlm@1 3162
rlm@1 3163 register int opcode = 0;
rlm@1 3164
rlm@1 3165 u32 newmask = 0;
rlm@1 3166 if (newFrame)
rlm@1 3167 {
rlm@1 3168 extern void VBAOnExitingFrameBoundary();
rlm@1 3169 VBAOnExitingFrameBoundary();
rlm@1 3170
rlm@1 3171 // update joystick information
rlm@1 3172 systemReadJoypads();
rlm@1 3173
rlm@1 3174 bool sensor = (gbRom[0x147] == 0x22);
rlm@1 3175
rlm@1 3176 // read joystick
rlm@1 3177 if (gbSgbMode && gbSgbMultiplayer)
rlm@1 3178 {
rlm@1 3179 if (gbSgbFourPlayers)
rlm@1 3180 {
rlm@1 3181 gbJoymask[0] = systemGetJoypad(0, sensor);
rlm@1 3182 gbJoymask[1] = systemGetJoypad(1, false);
rlm@1 3183 gbJoymask[2] = systemGetJoypad(2, false);
rlm@1 3184 gbJoymask[3] = systemGetJoypad(3, false);
rlm@1 3185 }
rlm@1 3186 else
rlm@1 3187 {
rlm@1 3188 gbJoymask[0] = systemGetJoypad(0, sensor);
rlm@1 3189 gbJoymask[1] = systemGetJoypad(1, false);
rlm@1 3190 }
rlm@1 3191 }
rlm@1 3192 else
rlm@1 3193 {
rlm@1 3194 gbJoymask[0] = systemGetJoypad(0, sensor);
rlm@1 3195 }
rlm@1 3196
rlm@1 3197 // FIXME: horrible kludge
rlm@1 3198 memcpy(s_gbJoymask, gbJoymask, sizeof(gbJoymask));
rlm@1 3199
rlm@1 3200 // if (sensor)
rlm@1 3201 // systemUpdateMotionSensor(0);
rlm@1 3202
rlm@1 3203 newmask = gbJoymask[0];
rlm@1 3204 if (newmask & 0xFF)
rlm@1 3205 {
rlm@1 3206 gbInterrupt |= 16;
rlm@1 3207 }
rlm@1 3208
rlm@1 3209 extButtons = (newmask >> 18);
rlm@1 3210 speedup = (extButtons & 1) != 0;
rlm@1 3211
rlm@1 3212 VBAMovieResetIfRequested();
rlm@1 3213
rlm@1 3214 CallRegisteredLuaFunctions(LUACALL_BEFOREEMULATION);
rlm@1 3215
rlm@1 3216 newFrame = false;
rlm@1 3217 }
rlm@1 3218
rlm@1 3219 for (;; )
rlm@1 3220 {
rlm@1 3221 #ifndef FINAL_VERSION
rlm@1 3222 if (systemDebug)
rlm@1 3223 {
rlm@1 3224 if (!(IFF & 0x80))
rlm@1 3225 {
rlm@1 3226 if (systemDebug > 1)
rlm@1 3227 {
rlm@1 3228 sprintf(gbBuffer, "PC=%04x AF=%04x BC=%04x DE=%04x HL=%04x SP=%04x I=%04x\n",
rlm@1 3229 PC.W, AF.W, BC.W, DE.W, HL.W, SP.W, IFF);
rlm@1 3230 }
rlm@1 3231 else
rlm@1 3232 {
rlm@1 3233 sprintf(gbBuffer, "PC=%04x I=%02x\n", PC.W, IFF);
rlm@1 3234 }
rlm@1 3235 log(gbBuffer);
rlm@1 3236 }
rlm@1 3237 }
rlm@1 3238 #endif
rlm@1 3239 if (IFF & 0x80)
rlm@1 3240 {
rlm@1 3241 if (register_LCDC & 0x80)
rlm@1 3242 {
rlm@1 3243 clockTicks = gbLcdTicks;
rlm@1 3244 }
rlm@1 3245 else
rlm@1 3246 clockTicks = 100;
rlm@1 3247
rlm@1 3248 if (gbLcdMode == 1 && (gbLcdLYIncrementTicks < clockTicks))
rlm@1 3249 clockTicks = gbLcdLYIncrementTicks;
rlm@1 3250
rlm@1 3251 if (gbSerialOn && (gbSerialTicks < clockTicks))
rlm@1 3252 clockTicks = gbSerialTicks;
rlm@1 3253
rlm@1 3254 if (gbTimerOn && (gbTimerTicks < clockTicks))
rlm@1 3255 clockTicks = gbTimerTicks;
rlm@1 3256
rlm@1 3257 if (soundTicks && (soundTicks < clockTicks))
rlm@1 3258 clockTicks = soundTicks;
rlm@1 3259 }
rlm@1 3260 else
rlm@1 3261 {
rlm@1 3262 opcode = gbReadOpcode(PC.W);
rlm@1 3263 CallRegisteredLuaMemHook(PC.W, 1, opcode, LUAMEMHOOK_EXEC);
rlm@1 3264 PC.W++;
rlm@1 3265
rlm@1 3266 if (IFF & 0x100)
rlm@1 3267 {
rlm@1 3268 IFF &= 0xff;
rlm@1 3269 PC.W--;
rlm@1 3270 }
rlm@1 3271
rlm@1 3272 clockTicks = gbCycles[opcode];
rlm@1 3273
rlm@1 3274 switch (opcode)
rlm@1 3275 {
rlm@1 3276 case 0xCB:
rlm@1 3277 // extended opcode
rlm@1 3278 //CallRegisteredLuaMemHook(PC.W, 1, opcode, LUAMEMHOOK_EXEC); // is this desired?
rlm@1 3279 opcode = gbReadOpcode(PC.W++);
rlm@1 3280 clockTicks = gbCyclesCB[opcode];
rlm@1 3281 switch (opcode)
rlm@1 3282 {
rlm@1 3283 #include "gbCodesCB.h"
rlm@1 3284 }
rlm@1 3285 break;
rlm@1 3286 #include "gbCodes.h"
rlm@1 3287 }
rlm@1 3288 }
rlm@1 3289
rlm@1 3290 if (!emulating)
rlm@1 3291 return;
rlm@1 3292
rlm@1 3293 if (gbDmaTicks)
rlm@1 3294 {
rlm@1 3295 clockTicks += gbDmaTicks;
rlm@1 3296 gbDmaTicks = 0;
rlm@1 3297 }
rlm@1 3298
rlm@1 3299 if (gbSgbMode)
rlm@1 3300 {
rlm@1 3301 if (gbSgbPacketTimeout)
rlm@1 3302 {
rlm@1 3303 gbSgbPacketTimeout -= clockTicks;
rlm@1 3304
rlm@1 3305 if (gbSgbPacketTimeout <= 0)
rlm@1 3306 gbSgbResetPacketState();
rlm@1 3307 }
rlm@1 3308 }
rlm@1 3309
rlm@1 3310 ticksToStop -= clockTicks;
rlm@1 3311
rlm@1 3312 // DIV register emulation
rlm@1 3313 gbDivTicks -= clockTicks;
rlm@1 3314 while (gbDivTicks <= 0)
rlm@1 3315 {
rlm@1 3316 register_DIV++;
rlm@1 3317 gbDivTicks += GBDIV_CLOCK_TICKS;
rlm@1 3318 }
rlm@1 3319
rlm@1 3320 if (register_LCDC & 0x80)
rlm@1 3321 {
rlm@1 3322 // LCD stuff
rlm@1 3323 gbLcdTicks -= clockTicks;
rlm@1 3324 if (gbLcdMode == 1)
rlm@1 3325 {
rlm@1 3326 // during V-BLANK,we need to increment LY at the same rate!
rlm@1 3327 gbLcdLYIncrementTicks -= clockTicks;
rlm@1 3328 while (gbLcdLYIncrementTicks <= 0)
rlm@1 3329 {
rlm@1 3330 gbLcdLYIncrementTicks += GBLY_INCREMENT_CLOCK_TICKS;
rlm@1 3331
rlm@1 3332 if (register_LY < 153)
rlm@1 3333 {
rlm@1 3334 register_LY++;
rlm@1 3335
rlm@1 3336 gbCompareLYToLYC();
rlm@1 3337
rlm@1 3338 if (register_LY >= 153)
rlm@1 3339 gbLcdLYIncrementTicks = 6;
rlm@1 3340 }
rlm@1 3341 else
rlm@1 3342 {
rlm@1 3343 register_LY = 0x00;
rlm@1 3344 // reset the window line
rlm@1 3345 gbWindowLine = -1;
rlm@1 3346 gbLcdLYIncrementTicks = GBLY_INCREMENT_CLOCK_TICKS * 2;
rlm@1 3347 gbCompareLYToLYC();
rlm@1 3348 }
rlm@1 3349 }
rlm@1 3350 }
rlm@1 3351
rlm@1 3352 // our counter is off, see what we need to do
rlm@1 3353 while (gbLcdTicks <= 0)
rlm@1 3354 {
rlm@1 3355 int framesToSkip = systemFramesToSkip();
rlm@1 3356
rlm@1 3357 switch (gbLcdMode)
rlm@1 3358 {
rlm@1 3359 case 0:
rlm@1 3360 // H-Blank
rlm@1 3361 register_LY++;
rlm@1 3362
rlm@1 3363 gbCompareLYToLYC();
rlm@1 3364
rlm@1 3365 // check if we reached the V-Blank period
rlm@1 3366 if (register_LY == 144)
rlm@1 3367 {
rlm@1 3368 // Yes, V-Blank
rlm@1 3369 // set the LY increment counter
rlm@1 3370 gbLcdLYIncrementTicks = gbLcdTicks + GBLY_INCREMENT_CLOCK_TICKS;
rlm@1 3371 gbLcdTicks += GBLCD_MODE_1_CLOCK_TICKS;
rlm@1 3372 gbLcdMode = 1;
rlm@1 3373 if (register_LCDC & 0x80)
rlm@1 3374 {
rlm@1 3375 gbInterrupt |= 1; // V-Blank interrupt
rlm@1 3376 gbInterruptWait = 6;
rlm@1 3377 if (register_STAT & 0x10)
rlm@1 3378 gbInterrupt |= 2;
rlm@1 3379 }
rlm@1 3380
rlm@1 3381 systemFrame();
rlm@1 3382
rlm@1 3383 ++gbFrameCount;
rlm@1 3384 u32 currentTime = systemGetClock();
rlm@1 3385 if (currentTime - gbLastTime >= 1000)
rlm@1 3386 {
rlm@1 3387 systemShowSpeed(int(float(gbFrameCount) * 100000 / (float(currentTime - gbLastTime) * 60) + .5f));
rlm@1 3388 gbLastTime = currentTime;
rlm@1 3389 gbFrameCount = 0;
rlm@1 3390 }
rlm@1 3391
rlm@1 3392 ++GBSystemCounters.frameCount;
rlm@1 3393 if (GBSystemCounters.lagged)
rlm@1 3394 {
rlm@1 3395 ++GBSystemCounters.lagCount;
rlm@1 3396 }
rlm@1 3397 GBSystemCounters.laggedLast = GBSystemCounters.lagged;
rlm@1 3398 GBSystemCounters.lagged = true;
rlm@1 3399
rlm@1 3400 extern void VBAOnEnteringFrameBoundary();
rlm@1 3401 VBAOnEnteringFrameBoundary();
rlm@1 3402
rlm@1 3403 newFrame = true;
rlm@1 3404
rlm@1 3405 pauseAfterFrameAdvance = systemPauseOnFrame();
rlm@1 3406
rlm@1 3407 if (gbFrameSkipCount >= framesToSkip || pauseAfterFrameAdvance)
rlm@1 3408 {
rlm@1 3409 if (gbBorderOn)
rlm@1 3410 gbSgbRenderBorder(); // clear unnecessary things on border (e.g. in-game text message)
rlm@1 3411
rlm@1 3412 systemRenderFrame();
rlm@1 3413 gbFrameSkipCount = 0;
rlm@1 3414
rlm@1 3415 bool capturePressed = (extButtons & 2) != 0;
rlm@1 3416 if (capturePressed && !capturePrevious)
rlm@1 3417 {
rlm@1 3418 captureNumber = systemScreenCapture(captureNumber);
rlm@1 3419 }
rlm@1 3420 capturePrevious = capturePressed && !pauseAfterFrameAdvance;
rlm@1 3421 }
rlm@1 3422 else
rlm@1 3423 {
rlm@1 3424 ++gbFrameSkipCount;
rlm@1 3425 }
rlm@1 3426
rlm@1 3427 if (pauseAfterFrameAdvance)
rlm@1 3428 {
rlm@1 3429 systemSetPause(true);
rlm@1 3430 }
rlm@1 3431 }
rlm@1 3432 else
rlm@1 3433 {
rlm@1 3434 // go the the OAM being accessed mode
rlm@1 3435 gbLcdTicks += GBLCD_MODE_2_CLOCK_TICKS;
rlm@1 3436 gbLcdMode = 2;
rlm@1 3437
rlm@1 3438 // only one LCD interrupt per line. may need to generalize...
rlm@1 3439 if (!(register_STAT & 0x40) ||
rlm@1 3440 (register_LY != register_LYC))
rlm@1 3441 {
rlm@1 3442 if ((register_STAT & 0x28) == 0x20)
rlm@1 3443 gbInterrupt |= 2;
rlm@1 3444 }
rlm@1 3445 }
rlm@1 3446
rlm@1 3447 break;
rlm@1 3448 case 1:
rlm@1 3449 // V-Blank
rlm@1 3450 // next mode is OAM being accessed mode
rlm@1 3451 gbLcdTicks += GBLCD_MODE_2_CLOCK_TICKS;
rlm@1 3452 gbLcdMode = 2;
rlm@1 3453 if (!(register_STAT & 0x40) ||
rlm@1 3454 (register_LY != register_LYC))
rlm@1 3455 {
rlm@1 3456 if ((register_STAT & 0x28) == 0x20)
rlm@1 3457 gbInterrupt |= 2;
rlm@1 3458 }
rlm@1 3459 break;
rlm@1 3460 case 2:
rlm@1 3461 // OAM being accessed mode
rlm@1 3462
rlm@1 3463 // next mode is OAM and VRAM in use
rlm@1 3464 gbLcdTicks += GBLCD_MODE_3_CLOCK_TICKS;
rlm@1 3465 gbLcdMode = 3;
rlm@1 3466 break;
rlm@1 3467 case 3:
rlm@1 3468 // OAM and VRAM in use
rlm@1 3469 // next mode is H-Blank
rlm@1 3470 if (register_LY < 144)
rlm@1 3471 {
rlm@1 3472 if (!gbSgbMask)
rlm@1 3473 {
rlm@1 3474 if (gbFrameSkipCount >= framesToSkip || pauseAfterFrameAdvance)
rlm@1 3475 {
rlm@1 3476 gbRenderLine();
rlm@1 3477 gbDrawSprites();
rlm@1 3478
rlm@1 3479 switch (systemColorDepth)
rlm@1 3480 {
rlm@1 3481 case 16:
rlm@1 3482
rlm@1 3483 {
rlm@1 3484 u16 *dest = (u16 *)pix +
rlm@1 3485 (gbBorderLineSkip + 2) * (register_LY + gbBorderRowSkip + 1)
rlm@1 3486 + gbBorderColumnSkip;
rlm@1 3487 for (int x = 0; x < 160; )
rlm@1 3488 {
rlm@1 3489 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3490 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3491 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3492 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3493
rlm@1 3494 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3495 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3496 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3497 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3498
rlm@1 3499 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3500 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3501 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3502 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3503
rlm@1 3504 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3505 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3506 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3507 *dest++ = systemColorMap16[gbLineMix[x++]];
rlm@1 3508 }
rlm@1 3509 if (gbBorderOn)
rlm@1 3510 dest += gbBorderColumnSkip;
rlm@1 3511 *dest++ = 0; // for filters that read one pixel more
rlm@1 3512 break;
rlm@1 3513 }
rlm@1 3514 case 24:
rlm@1 3515
rlm@1 3516 {
rlm@1 3517 u8 *dest = (u8 *)pix +
rlm@1 3518 3 * (gbBorderLineSkip * (register_LY + gbBorderRowSkip) +
rlm@1 3519 gbBorderColumnSkip);
rlm@1 3520 for (int x = 0; x < 160; )
rlm@1 3521 {
rlm@1 3522 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3523 dest += 3;
rlm@1 3524 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3525 dest += 3;
rlm@1 3526 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3527 dest += 3;
rlm@1 3528 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3529 dest += 3;
rlm@1 3530
rlm@1 3531 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3532 dest += 3;
rlm@1 3533 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3534 dest += 3;
rlm@1 3535 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3536 dest += 3;
rlm@1 3537 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3538 dest += 3;
rlm@1 3539
rlm@1 3540 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3541 dest += 3;
rlm@1 3542 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3543 dest += 3;
rlm@1 3544 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3545 dest += 3;
rlm@1 3546 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3547 dest += 3;
rlm@1 3548
rlm@1 3549 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3550 dest += 3;
rlm@1 3551 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3552 dest += 3;
rlm@1 3553 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3554 dest += 3;
rlm@1 3555 *((u32 *)dest) = systemColorMap32[gbLineMix[x++]];
rlm@1 3556 dest += 3;
rlm@1 3557 }
rlm@1 3558 break;
rlm@1 3559 }
rlm@1 3560 case 32:
rlm@1 3561
rlm@1 3562 {
rlm@1 3563 u32 *dest = (u32 *)pix +
rlm@1 3564 (gbBorderLineSkip + 1) * (register_LY + gbBorderRowSkip + 1)
rlm@1 3565 + gbBorderColumnSkip;
rlm@1 3566 for (int x = 0; x < 160; )
rlm@1 3567 {
rlm@1 3568 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3569 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3570 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3571 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3572
rlm@1 3573 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3574 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3575 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3576 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3577
rlm@1 3578 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3579 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3580 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3581 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3582
rlm@1 3583 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3584 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3585 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3586 *dest++ = systemColorMap32[gbLineMix[x++]];
rlm@1 3587 }
rlm@1 3588 break;
rlm@1 3589 }
rlm@1 3590 }
rlm@1 3591 }
rlm@1 3592 }
rlm@1 3593 }
rlm@1 3594 gbLcdTicks += GBLCD_MODE_0_CLOCK_TICKS;
rlm@1 3595 gbLcdMode = 0;
rlm@1 3596 // only one LCD interrupt per line. may need to generalize...
rlm@1 3597 if (!(register_STAT & 0x40) ||
rlm@1 3598 (register_LY != register_LYC))
rlm@1 3599 {
rlm@1 3600 if (register_STAT & 0x08)
rlm@1 3601 gbInterrupt |= 2;
rlm@1 3602 }
rlm@1 3603 if (gbHdmaOn)
rlm@1 3604 {
rlm@1 3605 gbDoHdma();
rlm@1 3606 }
rlm@1 3607 break;
rlm@1 3608 }
rlm@1 3609 // mark the correct lcd mode on STAT register
rlm@1 3610 register_STAT = (register_STAT & 0xfc) | gbLcdMode;
rlm@1 3611 }
rlm@1 3612 }
rlm@1 3613
rlm@1 3614 // serial emulation
rlm@1 3615 if (gbSerialOn)
rlm@1 3616 {
rlm@1 3617 #ifdef LINK_EMULATION
rlm@1 3618 if (linkConnected)
rlm@1 3619 {
rlm@1 3620 gbSerialTicks -= clockTicks;
rlm@1 3621
rlm@1 3622 while (gbSerialTicks <= 0)
rlm@1 3623 {
rlm@1 3624 // increment number of shifted bits
rlm@1 3625 gbSerialBits++;
rlm@1 3626 linkProc();
rlm@1 3627 if (gbSerialOn && (gbMemory[0xff02] & 1))
rlm@1 3628 {
rlm@1 3629 if (gbSerialBits == 8)
rlm@1 3630 {
rlm@1 3631 gbSerialBits = 0;
rlm@1 3632 gbMemory[0xff01] = 0xff;
rlm@1 3633 gbMemory[0xff02] &= 0x7f;
rlm@1 3634 gbSerialOn = 0;
rlm@1 3635 gbInterrupt |= 8;
rlm@1 3636 gbSerialTicks = 0;
rlm@1 3637 }
rlm@1 3638 }
rlm@1 3639 gbSerialTicks += GBSERIAL_CLOCK_TICKS;
rlm@1 3640 }
rlm@1 3641 }
rlm@1 3642 else
rlm@1 3643 {
rlm@1 3644 #endif
rlm@1 3645 if (gbMemory[0xff02] & 1)
rlm@1 3646 {
rlm@1 3647 gbSerialTicks -= clockTicks;
rlm@1 3648
rlm@1 3649 // overflow
rlm@1 3650 while (gbSerialTicks <= 0)
rlm@1 3651 {
rlm@1 3652 // shift serial byte to right and put a 1 bit in its place
rlm@1 3653 // gbMemory[0xff01] = 0x80 | (gbMemory[0xff01]>>1);
rlm@1 3654 // increment number of shifted bits
rlm@1 3655 gbSerialBits++;
rlm@1 3656 if (gbSerialBits == 8)
rlm@1 3657 {
rlm@1 3658 // end of transmission
rlm@1 3659 if (gbSerialFunction) // external device
rlm@1 3660 gbMemory[0xff01] = gbSerialFunction(gbMemory[0xff01]);
rlm@1 3661 else
rlm@1 3662 gbMemory[0xff01] = 0xff;
rlm@1 3663 gbSerialTicks = 0;
rlm@1 3664 gbMemory[0xff02] &= 0x7f;
rlm@1 3665 gbSerialOn = 0;
rlm@1 3666 gbInterrupt |= 8;
rlm@1 3667 gbSerialBits = 0;
rlm@1 3668 }
rlm@1 3669 else
rlm@1 3670 gbSerialTicks += GBSERIAL_CLOCK_TICKS;
rlm@1 3671 }
rlm@1 3672 }
rlm@1 3673 #ifdef LINK_EMULATION
rlm@1 3674 }
rlm@1 3675 #endif
rlm@1 3676 }
rlm@1 3677
rlm@1 3678 // timer emulation
rlm@1 3679 if (gbTimerOn)
rlm@1 3680 {
rlm@1 3681 gbTimerTicks -= clockTicks;
rlm@1 3682
rlm@1 3683 while (gbTimerTicks <= 0)
rlm@1 3684 {
rlm@1 3685 register_TIMA++;
rlm@1 3686
rlm@1 3687 if (register_TIMA == 0)
rlm@1 3688 {
rlm@1 3689 // timer overflow!
rlm@1 3690
rlm@1 3691 // reload timer modulo
rlm@1 3692 register_TIMA = register_TMA;
rlm@1 3693
rlm@1 3694 // flag interrupt
rlm@1 3695 gbInterrupt |= 4;
rlm@1 3696 }
rlm@1 3697
rlm@1 3698 gbTimerTicks += gbTimerClockTicks;
rlm@1 3699 }
rlm@1 3700 }
rlm@1 3701
rlm@1 3702 /*
rlm@1 3703 if(soundOffFlag)
rlm@1 3704 {
rlm@1 3705 if(synchronize && !speedup)
rlm@1 3706 {
rlm@1 3707 synchronizeTicks -= clockTicks;
rlm@1 3708
rlm@1 3709 while(synchronizeTicks < 0)
rlm@1 3710 {
rlm@1 3711 synchronizeTicks += SYNCHRONIZE_CLOCK_TICKS;
rlm@1 3712
rlm@1 3713 DWORD now = timeGetTime();
rlm@1 3714 gbElapsedTime += (now - timeNow);
rlm@1 3715
rlm@1 3716 if(gbElapsedTime < 50)
rlm@1 3717 {
rlm@1 3718 DWORD diff = 50 - gbElapsedTime;
rlm@1 3719 Sleep(diff);
rlm@1 3720 timeNow = timeGetTime();
rlm@1 3721 elapsedTime = timeNow - now - diff;
rlm@1 3722 if((int)elapsedTime < 0)
rlm@1 3723 elapsedTime = 0;
rlm@1 3724 } else
rlm@1 3725 {
rlm@1 3726 timeNow = timeGetTime();
rlm@1 3727 elapsedTime = 0;
rlm@1 3728 }
rlm@1 3729 }
rlm@1 3730 }
rlm@1 3731 }
rlm@1 3732 */
rlm@1 3733
rlm@1 3734 soundTicks -= clockTicks;
rlm@1 3735 while (soundTicks < 0) // must be < 1 when soundtick_t is real data type
rlm@1 3736 {
rlm@1 3737 soundTicks += SOUND_CLOCK_TICKS;
rlm@1 3738
rlm@1 3739 gbSoundTick();
rlm@1 3740 }
rlm@1 3741
rlm@1 3742 register_IF = gbInterrupt;
rlm@1 3743
rlm@1 3744 if (IFF & 0x20)
rlm@1 3745 {
rlm@1 3746 IFF &= 0xdf;
rlm@1 3747 IFF |= 0x01;
rlm@1 3748 gbInterruptWait = 0;
rlm@1 3749 }
rlm@1 3750 else if (gbInterrupt)
rlm@1 3751 {
rlm@1 3752 if (gbInterruptWait == 0)
rlm@1 3753 {
rlm@1 3754 // gbInterruptWait = 0;
rlm@1 3755
rlm@1 3756 if (IFF & 0x01)
rlm@1 3757 {
rlm@1 3758 if ((gbInterrupt & 1) && (register_IE & 1))
rlm@1 3759 {
rlm@1 3760 gbVblank_interrupt();
rlm@1 3761 continue;
rlm@1 3762 }
rlm@1 3763
rlm@1 3764 if ((gbInterrupt & 2) && (register_IE & 2))
rlm@1 3765 {
rlm@1 3766 gbLcd_interrupt();
rlm@1 3767 continue;
rlm@1 3768 }
rlm@1 3769
rlm@1 3770 if ((gbInterrupt & 4) && (register_IE & 4))
rlm@1 3771 {
rlm@1 3772 gbTimer_interrupt();
rlm@1 3773 continue;
rlm@1 3774 }
rlm@1 3775
rlm@1 3776 if ((gbInterrupt & 8) && (register_IE & 8))
rlm@1 3777 {
rlm@1 3778 gbSerial_interrupt();
rlm@1 3779 continue;
rlm@1 3780 }
rlm@1 3781
rlm@1 3782 if ((gbInterrupt & 16) && (register_IE & 16))
rlm@1 3783 {
rlm@1 3784 gbJoypad_interrupt();
rlm@1 3785 continue;
rlm@1 3786 }
rlm@1 3787 }
rlm@1 3788 }
rlm@1 3789 else
rlm@1 3790 {
rlm@1 3791 gbInterruptWait -= clockTicks;
rlm@1 3792 if (gbInterruptWait < 0)
rlm@1 3793 gbInterruptWait = 0;
rlm@1 3794 }
rlm@1 3795 }
rlm@1 3796
rlm@1 3797 if (useOldFrameTiming)
rlm@1 3798 {
rlm@1 3799 // old timing code
rlm@1 3800 if (ticksToStop > 0)
rlm@1 3801 continue;
rlm@1 3802 }
rlm@1 3803 else
rlm@1 3804 {
rlm@1 3805 if (!newFrame && (register_LCDC & 0x80) != 0)
rlm@1 3806 continue;
rlm@1 3807 }
rlm@1 3808
rlm@1 3809 if (!(register_LCDC & 0x80))
rlm@1 3810 {
rlm@1 3811 if (!useOldFrameTiming)
rlm@1 3812 {
rlm@1 3813 // FIXME: since register_LY can be reset to 0 by some games, frame length is variable
rlm@1 3814 // and infinite loops can occurr
rlm@1 3815 // for now, it IS necessary to do something on this condition or games like
rlm@1 3816 // Megaman would freeze upon low-level restart interrupt sequence (Start+Select+A+B).
rlm@1 3817 // the only sensible way to fix this issue is to implement the RIGHT frame timing
rlm@1 3818 #ifdef WANTS_INCOMPLETE_WORKAROUND
rlm@1 3819 if (systemReadJoypads())
rlm@1 3820 {
rlm@1 3821 if (gbSgbMode && gbSgbMultiplayer)
rlm@1 3822 {
rlm@1 3823 if (gbSgbFourPlayers)
rlm@1 3824 {
rlm@1 3825 gbJoymask[0] = systemGetJoypad(0, false);
rlm@1 3826 gbJoymask[1] = systemGetJoypad(1, false);
rlm@1 3827 gbJoymask[2] = systemGetJoypad(2, false);
rlm@1 3828 gbJoymask[3] = systemGetJoypad(3, false);
rlm@1 3829 }
rlm@1 3830 else
rlm@1 3831 {
rlm@1 3832 gbJoymask[0] = systemGetJoypad(0, false);
rlm@1 3833 gbJoymask[1] = systemGetJoypad(1, false);
rlm@1 3834 }
rlm@1 3835 }
rlm@1 3836 else
rlm@1 3837 {
rlm@1 3838 gbJoymask[0] = systemGetJoypad(0, false);
rlm@1 3839 }
rlm@1 3840 }
rlm@1 3841 else
rlm@1 3842 gbJoymask[0] = gbJoymask[1] = gbJoymask[2] = gbJoymask[3] = 0;
rlm@1 3843 #else
rlm@1 3844 #endif
rlm@1 3845 }
rlm@1 3846 }
rlm@1 3847
rlm@1 3848 // makes sure frames are really divided across input sampling boundaries which occur at a constant rate
rlm@1 3849 if (newFrame || useOldFrameTiming)
rlm@1 3850 {
rlm@1 3851 /// extern void VBAOnEnteringFrameBoundary();
rlm@1 3852 /// VBAOnEnteringFrameBoundary();
rlm@1 3853
rlm@1 3854 break;
rlm@1 3855 }
rlm@1 3856 }
rlm@1 3857 }
rlm@1 3858
rlm@1 3859 struct EmulatedSystem GBSystem =
rlm@1 3860 {
rlm@1 3861 // emuMain
rlm@1 3862 gbEmulate,
rlm@1 3863 // emuReset
rlm@1 3864 gbReset,
rlm@1 3865 // emuCleanUp
rlm@1 3866 gbCleanUp,
rlm@1 3867 // emuReadBattery
rlm@1 3868 gbReadBatteryFile,
rlm@1 3869 // emuWriteBattery
rlm@1 3870 gbWriteBatteryFile,
rlm@1 3871 // emuReadBatteryFromStream
rlm@1 3872 gbReadBatteryFromStream,
rlm@1 3873 // emuWriteBatteryToStream
rlm@1 3874 gbWriteBatteryToStream,
rlm@1 3875 // emuReadState
rlm@1 3876 gbReadSaveState,
rlm@1 3877 // emuWriteState
rlm@1 3878 gbWriteSaveState,
rlm@1 3879 // emuReadStateFromStream
rlm@1 3880 gbReadSaveStateFromStream,
rlm@1 3881 // emuWriteStateToStream
rlm@1 3882 gbWriteSaveStateToStream,
rlm@1 3883 // emuReadMemState
rlm@1 3884 gbReadMemSaveState,
rlm@1 3885 // emuWriteMemState
rlm@1 3886 gbWriteMemSaveState,
rlm@1 3887 // emuWritePNG
rlm@1 3888 gbWritePNGFile,
rlm@1 3889 // emuWriteBMP
rlm@1 3890 gbWriteBMPFile,
rlm@1 3891 // emuUpdateCPSR
rlm@1 3892 NULL,
rlm@1 3893 // emuHasDebugger
rlm@1 3894 false,
rlm@1 3895 // emuCount
rlm@1 3896 #ifdef FINAL_VERSION
rlm@1 3897 70000 / 4,
rlm@1 3898 #else
rlm@1 3899 1000,
rlm@1 3900 #endif
rlm@1 3901 };
rlm@1 3902
rlm@1 3903 // is there a reason to use more than one set of counters?
rlm@1 3904 EmulatedSystemCounters &GBSystemCounters = systemCounters;
rlm@1 3905
rlm@1 3906 /*
rlm@1 3907 EmulatedSystemCounters GBSystemCounters =
rlm@1 3908 {
rlm@1 3909 // frameCount
rlm@1 3910 0,
rlm@1 3911 // lagCount
rlm@1 3912 0,
rlm@1 3913 // lagged
rlm@1 3914 true,
rlm@1 3915 // laggedLast
rlm@1 3916 true,
rlm@1 3917 };
rlm@1 3918 */