1 /* Decode a Game Genie code into an M68000 address/data pair.
2 * The Game Genie code is made of the characters
3 * ABCDEFGHJKLMNPRSTVWXYZ0123456789 (notice the missing I, O, Q and U).
4 * Where A = 00000, B = 00001, C = 00010, ... , on to 9 = 11111.
6 * These come out to a very scrambled bit pattern like this:
7 * (SCRA-MBLE is just an example)
10 * 01111 00010 01110 00000 01011 00001 01010 00100
11 * ijklm nopIJ KLMNO PABCD EFGHd efgha bcQRS TUVWX
13 * Our goal is to rearrange that to this:
15 * 0000 0101 1001 1100 0100 0100 : 1011 0000 0111 1000
16 * ABCD EFGH IJKL MNOP QRST UVWX : abcd efgh ijkl mnop
18 * which in Hexadecimal is 059C44:B078. Simple, huh? ;)
20 * So, then, we dutifully change memory location 059C44 to B078!
21 * (of course, that's handled by a different source file :)
34 struct patch_inst *PicoPatches = NULL;
35 int PicoPatchCount = 0;
37 static char genie_chars_md[] = "AaBbCcDdEeFfGgHhJjKkLlMmNnPpRrSsTtVvWwXxYyZz0O1I2233445566778899";
40 * This function converts a Game Genie code to an address:data pair.
41 * The code is given as an 8-character string, like "BJX0SA1C". It need not
42 * be null terminated, since only the first 8 characters are taken. It is
43 * assumed that the code is already made of valid characters, i.e. there are no
44 * Q's, U's, or symbols. If such a character is
45 * encountered, the function will return with a warning on stderr.
47 * The resulting address:data pair is returned in the struct patch pointed to
48 * by result. If an error results, both the address and data will be set to -1.
51 static void genie_decode_md(const char* code, struct patch* result)
58 /* Skip i=4; it's going to be the separating hyphen */
61 /* If strchr returns NULL, we were given a bad character */
62 if(!(x = strchr(genie_chars_md, code[i])))
64 result->addr = -1; result->data = -1;
67 n = (x - genie_chars_md) >> 1;
68 /* Now, based on which character this is, fit it into the result */
72 /* ____ ____ ____ ____ ____ ____ : ____ ____ ABCD E___ */
73 result->data |= n << 3;
76 /* ____ ____ DE__ ____ ____ ____ : ____ ____ ____ _ABC */
77 result->data |= n >> 2;
78 result->addr |= (n & 3) << 14;
81 /* ____ ____ __AB CDE_ ____ ____ : ____ ____ ____ ____ */
82 result->addr |= n << 9;
85 /* BCDE ____ ____ ___A ____ ____ : ____ ____ ____ ____ */
86 result->addr |= (n & 0xF) << 20 | (n >> 4) << 8;
89 /* ____ ABCD ____ ____ ____ ____ : ___E ____ ____ ____ */
90 result->data |= (n & 1) << 12;
91 result->addr |= (n >> 1) << 16;
94 /* ____ ____ ____ ____ ____ ____ : E___ ABCD ____ ____ */
95 result->data |= (n & 1) << 15 | (n >> 1) << 8;
98 /* ____ ____ ____ ____ CDE_ ____ : _AB_ ____ ____ ____ */
99 result->data |= (n >> 3) << 13;
100 result->addr |= (n & 7) << 5;
103 /* ____ ____ ____ ____ ___A BCDE : ____ ____ ____ ____ */
107 /* Go around again */
112 /* "Decode" an address/data pair into a structure. This is for "012345:ABCD"
113 * type codes. You're more likely to find Genie codes circulating around, but
114 * there's a chance you could come on to one of these. Which is nice, since
115 * they're MUCH easier to implement ;) Once again, the input should be depunc-
118 static char hex_chars[] = "00112233445566778899AaBbCcDdEeFf";
120 static void hex_decode_md(const char *code, struct patch *result)
124 /* 6 digits for address */
125 for(i = 0; i < 6; ++i)
127 if(!(x = strchr(hex_chars, code[i])))
129 result->addr = result->data = -1;
132 result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
134 /* 4 digits for data */
135 for(i = 7; i < 11; ++i)
137 if(!(x = strchr(hex_chars, code[i])))
140 result->addr = result->data = -1;
143 result->data = (result->data << 4) | ((x - hex_chars) >> 1);
147 void genie_decode_ms(const char *code, struct patch *result)
151 /* 2 digits for data */
154 if(!(x = strchr(hex_chars, code[i])))
156 result->addr = result->data = -1;
159 result->data = (result->data << 4) | ((x - hex_chars) >> 1);
161 /* 4 digits for address */
164 /* 4th character is hyphen and can be skipped*/
166 if(!(x = strchr(hex_chars, code[i])))
168 result->addr = result->data = -1;
171 result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
173 /* Correct the address */
174 result->addr = ((result->addr >> 4) | (result->addr << 12 & 0xF000)) ^ 0xF000;
175 /* Optional: 3 digits for comp */
176 printf("CHEAT: code[8]==%c\n",code[8]);
180 if (i==9) continue; /* 2nd character is ignored */
181 if(!(x = strchr(hex_chars, code[i])))
183 result->addr = result->data = -1;
186 result->comp = (result->comp << 4) | ((x - hex_chars) >> 1);
188 /* Correct the comp */
189 result->comp = ((result->comp >> 2) | ((result->comp << 6) & 0xC0)) ^ 0xBA;
193 void ar_decode_ms(const char *code, struct patch *result){
196 /* 2 digits of padding*/
197 /* 4 digits for address */
200 /* 5th character is hyphen and can be skipped*/
202 if(!(x = strchr(hex_chars, code[i])))
204 result->addr = result->data = -1;
207 result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
209 /* 2 digits for data */
212 if(!(x = strchr(hex_chars, code[i])))
214 result->addr = result->data = -1;
217 result->data = (result->data << 4) | ((x - hex_chars) >> 1);
221 void fusion_ram_decode(const char *code, struct patch *result){
224 /* 4 digits for address */
227 if(!(x = strchr(hex_chars, code[i])))
229 result->addr = result->data = -1;
232 result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
235 /* 2 digits for data */
238 if(!(x = strchr(hex_chars, code[i])))
240 result->addr = result->data = -1;
243 result->data = (result->data << 4) | ((x - hex_chars) >> 1);
247 void fusion_rom_decode(const char *code, struct patch *result){
250 /* 2 digits for comp */
253 if(!(x = strchr(hex_chars, code[i])))
255 result->addr = result->data = -1;
258 result->comp = (result->comp << 4) | ((x - hex_chars) >> 1);
260 /* 4 digits for address */
263 if(!(x = strchr(hex_chars, code[i])))
265 result->addr = result->data = -1;
268 result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
270 /* 2 digits for data */
273 if(!(x = strchr(hex_chars, code[i])))
275 result->addr = result->data = -1;
278 result->data = (result->data << 4) | ((x - hex_chars) >> 1);
282 /* THIS is the function you call from the MegaDrive or whatever. This figures
283 * out whether it's a genie or hex code, depunctuates it, and calls the proper
285 void decode(const char* code, struct patch* result)
287 int len = strlen(code);
289 /* Initialize the result */
290 result->addr = result->data = result->comp = 0;
292 if(!(PicoAHW & PAHW_SMS))
297 if(len == 9 && code[4] == '-')
299 genie_decode_md(code, result);
304 else if(len >=9 && code[6] == ':')
306 hex_decode_md(code, result);
317 if(len >= 7 && code[3] == '-')
319 genie_decode_ms(code, result);
323 else if(len == 9 && code[4] == '-')
325 ar_decode_ms(code, result);
329 else if(len == 7 && code[4] == ':')
331 fusion_ram_decode(code, result);
335 else if(len == 9 && code[6] == ':')
337 fusion_rom_decode(code, result);
345 //Convert RAM address space to Genesis location.
346 if (result->addr>=0xC000)
347 result->addr= 0xFF0000 | (0x1FFF & result->addr);
353 result->data = result->addr = -1;
359 unsigned int PicoRead16(unsigned int a);
360 void PicoWrite16(unsigned int a, unsigned short d);
361 extern unsigned short m68k_read16(unsigned int a);
362 extern void m68k_write16(unsigned int a, unsigned short d);
363 extern char PicoRead8_z80(unsigned short a);
364 extern void PicoWrite8_z80(unsigned short a, char d);
366 void PicoPatchUnload(void)
368 if (PicoPatches != NULL)
376 int PicoPatchLoad(const char *fname)
385 f = fopen(fname, "r");
391 while (fgets(buff, sizeof(buff), f))
396 for (clen = 0; clen < llen; clen++)
397 if (isspace_(buff[clen]))
401 if (clen > 11 || clen < 8)
405 if (pt.addr == (unsigned int)-1 || pt.data == (unsigned short)-1)
408 /* code was good, add it */
409 if (array_len < PicoPatchCount + 1)
414 ptr = realloc(PicoPatches, array_len * sizeof(PicoPatches[0]));
415 if (ptr == NULL) break;
418 strcpy(PicoPatches[PicoPatchCount].code, buff);
420 for (clen++; clen < llen; clen++)
421 if (!isspace_(buff[clen]))
423 for (llen--; llen > 0; llen--)
424 if (!isspace_(buff[llen]))
427 strncpy(PicoPatches[PicoPatchCount].name, buff + clen, 51);
428 PicoPatches[PicoPatchCount].name[51] = 0;
429 PicoPatches[PicoPatchCount].active = 0;
430 PicoPatches[PicoPatchCount].addr = pt.addr;
431 PicoPatches[PicoPatchCount].data = pt.data;
432 PicoPatches[PicoPatchCount].data_old = 0;
434 // fprintf(stderr, "loaded patch #%i: %06x:%04x \"%s\"\n", PicoPatchCount-1, pt.addr, pt.data,
435 // PicoPatches[PicoPatchCount-1].name);
442 /* to be called when the Rom is loaded and byteswapped */
443 void PicoPatchPrepare(void)
448 for (i = 0; i < PicoPatchCount; i++)
450 addr=PicoPatches[i].addr;
452 if (addr < Pico.romsize)
453 PicoPatches[i].data_old = *(unsigned short *)(Pico.rom + addr);
456 if(!(PicoAHW & PAHW_SMS))
457 PicoPatches[i].data_old = (unsigned short) m68k_read16(addr);
459 PicoPatches[i].data_old = (unsigned char) PicoRead8_z80(addr);
461 if (strstr(PicoPatches[i].name, "AUTO"))
462 PicoPatches[i].active = 1;
466 void PicoPatchApply(void)
471 for (i = 0; i < PicoPatchCount; i++)
473 addr = PicoPatches[i].addr;
475 if (addr < Pico.romsize)
477 if (PicoPatches[i].active)
479 if (!(PicoAHW & PAHW_SMS))
480 *(unsigned short *)(Pico.rom + addr) = PicoPatches[i].data;
481 else if (!PicoPatches[i].comp || PicoPatches[i].comp == *(char *)(Pico.rom + addr))
482 *(char *)(Pico.rom + addr) = (char) PicoPatches[i].data;
486 // if current addr is not patched by older patch, write back original val
487 for (u = 0; u < i; u++)
488 if (PicoPatches[u].addr == addr) break;
491 if (!(PicoAHW & PAHW_SMS))
492 *(unsigned short *)(Pico.rom + addr) = PicoPatches[i].data_old;
494 *(char *)(Pico.rom + addr) = (char) PicoPatches[i].data_old;
497 // fprintf(stderr, "patched %i: %06x:%04x\n", PicoPatches[i].active, addr,
498 // *(unsigned short *)(Pico.rom + addr));
502 if (PicoPatches[i].active)
504 if (!(PicoAHW & PAHW_SMS))
505 m68k_write16(addr,PicoPatches[i].data);
507 PicoWrite8_z80(addr,PicoPatches[i].data);
511 // if current addr is not patched by older patch, write back original val
512 for (u = 0; u < i; u++)
513 if (PicoPatches[u].addr == addr) break;
516 if (!(PicoAHW & PAHW_SMS))
517 m68k_write16(PicoPatches[i].addr,PicoPatches[i].data_old);
519 PicoWrite8_z80(PicoPatches[i].addr,PicoPatches[i].data_old);