mirror of
https://github.com/RaySollium99/picodrive.git
synced 2025-09-05 15:27:46 -04:00
517 lines
13 KiB
C
517 lines
13 KiB
C
/* Decode a Game Genie code into an M68000 address/data pair.
|
|
* The Game Genie code is made of the characters
|
|
* ABCDEFGHJKLMNPRSTVWXYZ0123456789 (notice the missing I, O, Q and U).
|
|
* Where A = 00000, B = 00001, C = 00010, ... , on to 9 = 11111.
|
|
*
|
|
* These come out to a very scrambled bit pattern like this:
|
|
* (SCRA-MBLE is just an example)
|
|
*
|
|
* S C R A - M B L E
|
|
* 01111 00010 01110 00000 01011 00001 01010 00100
|
|
* ijklm nopIJ KLMNO PABCD EFGHd efgha bcQRS TUVWX
|
|
*
|
|
* Our goal is to rearrange that to this:
|
|
*
|
|
* 0000 0101 1001 1100 0100 0100 : 1011 0000 0111 1000
|
|
* ABCD EFGH IJKL MNOP QRST UVWX : abcd efgh ijkl mnop
|
|
*
|
|
* which in Hexadecimal is 059C44:B078. Simple, huh? ;)
|
|
*
|
|
* So, then, we dutifully change memory location 059C44 to B078!
|
|
* (of course, that's handled by a different source file :)
|
|
*/
|
|
|
|
#include "pico_int.h"
|
|
#include "memory.h"
|
|
#include "patch.h"
|
|
|
|
struct patch
|
|
{
|
|
unsigned int addr;
|
|
unsigned short data;
|
|
unsigned char comp;
|
|
};
|
|
|
|
struct patch_inst *PicoPatches = NULL;
|
|
int PicoPatchCount = 0;
|
|
|
|
static char genie_chars_md[] = "AaBbCcDdEeFfGgHhJjKkLlMmNnPpRrSsTtVvWwXxYyZz0O1I2233445566778899";
|
|
|
|
/* genie_decode
|
|
* This function converts a Game Genie code to an address:data pair.
|
|
* The code is given as an 8-character string, like "BJX0SA1C". It need not
|
|
* be null terminated, since only the first 8 characters are taken. It is
|
|
* assumed that the code is already made of valid characters, i.e. there are no
|
|
* Q's, U's, or symbols. If such a character is
|
|
* encountered, the function will return with a warning on stderr.
|
|
*
|
|
* The resulting address:data pair is returned in the struct patch pointed to
|
|
* by result. If an error results, both the address and data will be set to -1.
|
|
*/
|
|
|
|
static void genie_decode_md(const char* code, struct patch* result)
|
|
{
|
|
int i = 0, n;
|
|
char* x;
|
|
|
|
for(; i < 9; ++i)
|
|
{
|
|
/* Skip i=4; it's going to be the separating hyphen */
|
|
if (i==4) continue;
|
|
|
|
/* If strchr returns NULL, we were given a bad character */
|
|
if(!(x = strchr(genie_chars_md, code[i])))
|
|
{
|
|
result->addr = -1; result->data = -1;
|
|
return;
|
|
}
|
|
n = (x - genie_chars_md) >> 1;
|
|
/* Now, based on which character this is, fit it into the result */
|
|
switch(i)
|
|
{
|
|
case 0:
|
|
/* ____ ____ ____ ____ ____ ____ : ____ ____ ABCD E___ */
|
|
result->data |= n << 3;
|
|
break;
|
|
case 1:
|
|
/* ____ ____ DE__ ____ ____ ____ : ____ ____ ____ _ABC */
|
|
result->data |= n >> 2;
|
|
result->addr |= (n & 3) << 14;
|
|
break;
|
|
case 2:
|
|
/* ____ ____ __AB CDE_ ____ ____ : ____ ____ ____ ____ */
|
|
result->addr |= n << 9;
|
|
break;
|
|
case 3:
|
|
/* BCDE ____ ____ ___A ____ ____ : ____ ____ ____ ____ */
|
|
result->addr |= (n & 0xF) << 20 | (n >> 4) << 8;
|
|
break;
|
|
case 5:
|
|
/* ____ ABCD ____ ____ ____ ____ : ___E ____ ____ ____ */
|
|
result->data |= (n & 1) << 12;
|
|
result->addr |= (n >> 1) << 16;
|
|
break;
|
|
case 6:
|
|
/* ____ ____ ____ ____ ____ ____ : E___ ABCD ____ ____ */
|
|
result->data |= (n & 1) << 15 | (n >> 1) << 8;
|
|
break;
|
|
case 7:
|
|
/* ____ ____ ____ ____ CDE_ ____ : _AB_ ____ ____ ____ */
|
|
result->data |= (n >> 3) << 13;
|
|
result->addr |= (n & 7) << 5;
|
|
break;
|
|
case 8:
|
|
/* ____ ____ ____ ____ ___A BCDE : ____ ____ ____ ____ */
|
|
result->addr |= n;
|
|
break;
|
|
}
|
|
/* Go around again */
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* "Decode" an address/data pair into a structure. This is for "012345:ABCD"
|
|
* type codes. You're more likely to find Genie codes circulating around, but
|
|
* there's a chance you could come on to one of these. Which is nice, since
|
|
* they're MUCH easier to implement ;) Once again, the input should be depunc-
|
|
* tuated already. */
|
|
|
|
static char hex_chars[] = "00112233445566778899AaBbCcDdEeFf";
|
|
|
|
static void hex_decode_md(const char *code, struct patch *result)
|
|
{
|
|
char *x;
|
|
int i;
|
|
/* 6 digits for address */
|
|
for(i = 0; i < 6; ++i)
|
|
{
|
|
if(!(x = strchr(hex_chars, code[i])))
|
|
{
|
|
result->addr = result->data = -1;
|
|
return;
|
|
}
|
|
result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
|
|
}
|
|
/* 4 digits for data */
|
|
for(i = 7; i < 11; ++i)
|
|
{
|
|
if(!(x = strchr(hex_chars, code[i])))
|
|
{
|
|
if (i==8) break;
|
|
result->addr = result->data = -1;
|
|
return;
|
|
}
|
|
result->data = (result->data << 4) | ((x - hex_chars) >> 1);
|
|
}
|
|
}
|
|
|
|
void genie_decode_ms(const char *code, struct patch *result)
|
|
{
|
|
char *x;
|
|
int i;
|
|
/* 2 digits for data */
|
|
for(i=0;i<2;++i)
|
|
{
|
|
if(!(x = strchr(hex_chars, code[i])))
|
|
{
|
|
result->addr = result->data = -1;
|
|
return;
|
|
}
|
|
result->data = (result->data << 4) | ((x - hex_chars) >> 1);
|
|
}
|
|
/* 4 digits for address */
|
|
for(i=2;i<7;++i)
|
|
{
|
|
/* 4th character is hyphen and can be skipped*/
|
|
if (i==3) continue;
|
|
if(!(x = strchr(hex_chars, code[i])))
|
|
{
|
|
result->addr = result->data = -1;
|
|
return;
|
|
}
|
|
result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
|
|
}
|
|
/* Correct the address */
|
|
result->addr = ((result->addr >> 4) | (result->addr << 12 & 0xF000)) ^ 0xF000;
|
|
/* Optional: 3 digits for comp */
|
|
if (code[7]=='-')
|
|
{
|
|
for(i=8;i<11;++i)
|
|
{
|
|
if (i==9) continue; /* 2nd character is ignored */
|
|
if(!(x = strchr(hex_chars, code[i])))
|
|
{
|
|
result->addr = result->data = -1;
|
|
return;
|
|
}
|
|
result->comp = (result->comp << 4) | ((x - hex_chars) >> 1);
|
|
}
|
|
/* Correct the comp */
|
|
result->comp = ((result->comp >> 2) | ((result->comp << 6) & 0xC0)) ^ 0xBA;
|
|
}
|
|
}
|
|
|
|
void ar_decode_ms(const char *code, struct patch *result){
|
|
char *x;
|
|
int i;
|
|
/* 2 digits of padding*/
|
|
/* 4 digits for address */
|
|
for(i=2;i<7;++i)
|
|
{
|
|
/* 5th character is hyphen and can be skipped*/
|
|
if (i==4) continue;
|
|
if(!(x = strchr(hex_chars, code[i])))
|
|
{
|
|
result->addr = result->data = -1;
|
|
return;
|
|
}
|
|
result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
|
|
}
|
|
/* 2 digits for data */
|
|
for(i=7;i<9;++i)
|
|
{
|
|
if(!(x = strchr(hex_chars, code[i])))
|
|
{
|
|
result->addr = result->data = -1;
|
|
return;
|
|
}
|
|
result->data = (result->data << 4) | ((x - hex_chars) >> 1);
|
|
}
|
|
}
|
|
|
|
void fusion_ram_decode(const char *code, struct patch *result){
|
|
char *x;
|
|
int i;
|
|
/* 4 digits for address */
|
|
for(i=0;i<4;++i)
|
|
{
|
|
if(!(x = strchr(hex_chars, code[i])))
|
|
{
|
|
result->addr = result->data = -1;
|
|
return;
|
|
}
|
|
result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
|
|
}
|
|
/* Skip the ':' */
|
|
/* 2 digits for data */
|
|
for(i=5;i<7;++i)
|
|
{
|
|
if(!(x = strchr(hex_chars, code[i])))
|
|
{
|
|
result->addr = result->data = -1;
|
|
return;
|
|
}
|
|
result->data = (result->data << 4) | ((x - hex_chars) >> 1);
|
|
}
|
|
}
|
|
|
|
void fusion_rom_decode(const char *code, struct patch *result){
|
|
char *x;
|
|
int i;
|
|
/* 2 digits for comp */
|
|
for(i=0;i<2;++i)
|
|
{
|
|
if(!(x = strchr(hex_chars, code[i])))
|
|
{
|
|
result->addr = result->data = -1;
|
|
return;
|
|
}
|
|
result->comp = (result->comp << 4) | ((x - hex_chars) >> 1);
|
|
}
|
|
/* 4 digits for address */
|
|
for(i=2;i<6;++i)
|
|
{
|
|
if(!(x = strchr(hex_chars, code[i])))
|
|
{
|
|
result->addr = result->data = -1;
|
|
return;
|
|
}
|
|
result->addr = (result->addr << 4) | ((x - hex_chars) >> 1);
|
|
}
|
|
/* 2 digits for data */
|
|
for(i=7;i<9;++i)
|
|
{
|
|
if(!(x = strchr(hex_chars, code[i])))
|
|
{
|
|
result->addr = result->data = -1;
|
|
return;
|
|
}
|
|
result->data = (result->data << 4) | ((x - hex_chars) >> 1);
|
|
}
|
|
}
|
|
|
|
/* THIS is the function you call from the MegaDrive or whatever. This figures
|
|
* out whether it's a genie or hex code, depunctuates it, and calls the proper
|
|
* decoder. */
|
|
void decode(const char* code, struct patch* result)
|
|
{
|
|
int len = strlen(code);
|
|
|
|
/* Initialize the result */
|
|
result->addr = result->data = result->comp = 0;
|
|
|
|
if(!(PicoAHW & PAHW_SMS))
|
|
{
|
|
//If Genesis
|
|
|
|
//Game Genie
|
|
if(len == 9 && code[4] == '-')
|
|
{
|
|
genie_decode_md(code, result);
|
|
return;
|
|
}
|
|
|
|
//Master
|
|
else if(len >=9 && code[6] == ':')
|
|
{
|
|
hex_decode_md(code, result);
|
|
}
|
|
|
|
else
|
|
{
|
|
goto bad_code;
|
|
}
|
|
} else {
|
|
//If Master System
|
|
|
|
//Genie
|
|
if(len >= 7 && code[3] == '-')
|
|
{
|
|
genie_decode_ms(code, result);
|
|
}
|
|
|
|
//AR
|
|
else if(len == 9 && code[4] == '-')
|
|
{
|
|
ar_decode_ms(code, result);
|
|
}
|
|
|
|
//Fusion RAM
|
|
else if(len == 7 && code[4] == ':')
|
|
{
|
|
fusion_ram_decode(code, result);
|
|
}
|
|
|
|
//Fusion ROM
|
|
else if(len == 9 && code[6] == ':')
|
|
{
|
|
fusion_rom_decode(code, result);
|
|
}
|
|
|
|
else
|
|
{
|
|
goto bad_code;
|
|
}
|
|
|
|
//Convert RAM address space to Genesis location.
|
|
if (result->addr>=0xC000)
|
|
result->addr= 0xFF0000 | (0x1FFF & result->addr);
|
|
}
|
|
|
|
return;
|
|
|
|
bad_code:
|
|
result->data = result->addr = -1;
|
|
return;
|
|
}
|
|
|
|
void PicoPatchUnload(void)
|
|
{
|
|
if (PicoPatches != NULL)
|
|
{
|
|
free(PicoPatches);
|
|
PicoPatches = NULL;
|
|
}
|
|
PicoPatchCount = 0;
|
|
}
|
|
|
|
int PicoPatchLoad(const char *fname)
|
|
{
|
|
FILE *f;
|
|
char buff[256];
|
|
struct patch pt;
|
|
int array_len = 0;
|
|
|
|
PicoPatchUnload();
|
|
|
|
f = fopen(fname, "r");
|
|
if (f == NULL)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
while (fgets(buff, sizeof(buff), f))
|
|
{
|
|
int llen, clen;
|
|
|
|
llen = strlen(buff);
|
|
for (clen = 0; clen < llen; clen++)
|
|
if (isspace_(buff[clen]))
|
|
break;
|
|
buff[clen] = 0;
|
|
|
|
if (clen > 11 || clen < 8)
|
|
continue;
|
|
|
|
decode(buff, &pt);
|
|
if (pt.addr == (unsigned int)-1 || pt.data == (unsigned short)-1)
|
|
continue;
|
|
|
|
/* code was good, add it */
|
|
if (array_len < PicoPatchCount + 1)
|
|
{
|
|
void *ptr;
|
|
array_len *= 2;
|
|
array_len++;
|
|
ptr = realloc(PicoPatches, array_len * sizeof(PicoPatches[0]));
|
|
if (ptr == NULL) break;
|
|
PicoPatches = ptr;
|
|
}
|
|
strcpy(PicoPatches[PicoPatchCount].code, buff);
|
|
/* strip */
|
|
for (clen++; clen < llen; clen++)
|
|
if (!isspace_(buff[clen]))
|
|
break;
|
|
for (llen--; llen > 0; llen--)
|
|
if (!isspace_(buff[llen]))
|
|
break;
|
|
buff[llen+1] = 0;
|
|
strncpy(PicoPatches[PicoPatchCount].name, buff + clen, 51);
|
|
PicoPatches[PicoPatchCount].name[51] = 0;
|
|
PicoPatches[PicoPatchCount].active = 0;
|
|
PicoPatches[PicoPatchCount].addr = pt.addr;
|
|
PicoPatches[PicoPatchCount].data = pt.data;
|
|
PicoPatches[PicoPatchCount].data_old = 0;
|
|
PicoPatchCount++;
|
|
// fprintf(stderr, "loaded patch #%i: %06x:%04x \"%s\"\n", PicoPatchCount-1, pt.addr, pt.data,
|
|
// PicoPatches[PicoPatchCount-1].name);
|
|
}
|
|
fclose(f);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* to be called when the Rom is loaded and byteswapped */
|
|
void PicoPatchPrepare(void)
|
|
{
|
|
int i;
|
|
int addr;
|
|
|
|
for (i = 0; i < PicoPatchCount; i++)
|
|
{
|
|
addr=PicoPatches[i].addr;
|
|
addr &= ~1;
|
|
if (addr < Pico.romsize)
|
|
PicoPatches[i].data_old = *(unsigned short *)(Pico.rom + addr);
|
|
else
|
|
{
|
|
if(!(PicoAHW & PAHW_SMS))
|
|
PicoPatches[i].data_old = (unsigned short) m68k_read16(addr);
|
|
else
|
|
;// wrong: PicoPatches[i].data_old = (unsigned char) PicoRead8_z80(addr);
|
|
}
|
|
if (strstr(PicoPatches[i].name, "AUTO"))
|
|
PicoPatches[i].active = 1;
|
|
}
|
|
}
|
|
|
|
void PicoPatchApply(void)
|
|
{
|
|
int i, u;
|
|
unsigned int addr;
|
|
|
|
for (i = 0; i < PicoPatchCount; i++)
|
|
{
|
|
addr = PicoPatches[i].addr;
|
|
|
|
if (addr < Pico.romsize)
|
|
{
|
|
if (PicoPatches[i].active)
|
|
{
|
|
if (!(PicoAHW & PAHW_SMS))
|
|
*(unsigned short *)(Pico.rom + addr) = PicoPatches[i].data;
|
|
else if (!PicoPatches[i].comp || PicoPatches[i].comp == *(char *)(Pico.rom + addr))
|
|
*(char *)(Pico.rom + addr) = (char) PicoPatches[i].data;
|
|
}
|
|
else
|
|
{
|
|
// if current addr is not patched by older patch, write back original val
|
|
for (u = 0; u < i; u++)
|
|
if (PicoPatches[u].addr == addr) break;
|
|
if (u == i)
|
|
{
|
|
if (!(PicoAHW & PAHW_SMS))
|
|
*(unsigned short *)(Pico.rom + addr) = PicoPatches[i].data_old;
|
|
else
|
|
*(char *)(Pico.rom + addr) = (char) PicoPatches[i].data_old;
|
|
}
|
|
}
|
|
// fprintf(stderr, "patched %i: %06x:%04x\n", PicoPatches[i].active, addr,
|
|
// *(unsigned short *)(Pico.rom + addr));
|
|
}
|
|
else
|
|
{
|
|
if (PicoPatches[i].active)
|
|
{
|
|
if (!(PicoAHW & PAHW_SMS))
|
|
m68k_write16(addr,PicoPatches[i].data);
|
|
else
|
|
;// wrong: PicoWrite8_z80(addr,PicoPatches[i].data);
|
|
}
|
|
else
|
|
{
|
|
// if current addr is not patched by older patch, write back original val
|
|
for (u = 0; u < i; u++)
|
|
if (PicoPatches[u].addr == addr) break;
|
|
if (u == i)
|
|
{
|
|
if (!(PicoAHW & PAHW_SMS))
|
|
m68k_write16(PicoPatches[i].addr,PicoPatches[i].data_old);
|
|
else
|
|
;// wrong: PicoWrite8_z80(PicoPatches[i].addr,PicoPatches[i].data_old);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|