Mercurial > vba-clojure

     1 #include <cstdio>

     2 #include <cstdlib>

     3 #include <cctype>

     4 #include <cstring>

     5 

     6 #include "../NLS.h"

     7 #include "../common/System.h"

     8 #include "../common/Util.h"

     9 

    10 #include "gbCheats.h"

    11 #include "gbGlobals.h"

    12 

    13 gbCheat gbCheatList[100];

    14 int     gbCheatNumber = 0;

    15 bool    gbCheatMap[0x10000];

    16 

    17 extern bool8 cheatsEnabled;

    18 

    19 #define GBCHEAT_IS_HEX(a) (((a) >= 'A' && (a) <= 'F') || ((a) >= '0' && (a) <= '9'))

    20 #define GBCHEAT_HEX_VALUE(a) ((a) >= 'A' ? (a) - 'A' + 10 : (a) - '0')

    21 

    22 void gbCheatUpdateMap()

    23 {

    24   memset(gbCheatMap, 0, 0x10000);

    25 

    26   for (int i = 0; i < gbCheatNumber; i++)

    27     {

    28       if (gbCheatList[i].enabled)

    29 	gbCheatMap[gbCheatList[i].address] = true;

    30     }

    31 }

    32 

    33 void gbCheatsSaveGame(gzFile gzFile)

    34 {

    35   utilWriteInt(gzFile, gbCheatNumber);

    36   if (gbCheatNumber)

    37     utilGzWrite(gzFile, &gbCheatList[0], sizeof(gbCheat)*gbCheatNumber);

    38 }

    39 

    40 void gbCheatsReadGame(gzFile gzFile, int version)

    41 {

    42   if (version <= 8)

    43     {

    44       int gbGgOn = utilReadInt(gzFile);

    45 

    46       if (gbGgOn)

    47 	{

    48 	  int       n = utilReadInt(gzFile);

    49 	  gbXxCheat tmpCheat;

    50 	  for (int i = 0; i < n; i++)

    51 	    {

    52 	      utilGzRead(gzFile, &tmpCheat, sizeof(gbXxCheat));

    53 	      gbAddGgCheat(tmpCheat.cheatCode, tmpCheat.cheatDesc);

    54 	    }

    55 	}

    56 

    57       int gbGsOn = utilReadInt(gzFile);

    58 

    59       if (gbGsOn)

    60 	{

    61 	  int       n = utilReadInt(gzFile);

    62 	  gbXxCheat tmpCheat;

    63 	  for (int i = 0; i < n; i++)

    64 	    {

    65 	      utilGzRead(gzFile, &tmpCheat, sizeof(gbXxCheat));

    66 	      gbAddGsCheat(tmpCheat.cheatCode, tmpCheat.cheatDesc);

    67 	    }

    68 	}

    69     }

    70   else

    71     {

    72       gbCheatNumber = utilReadInt(gzFile);

    73 

    74       if (gbCheatNumber)

    75 	{

    76 	  utilGzRead(gzFile, &gbCheatList[0], sizeof(gbCheat)*gbCheatNumber);

    77 	}

    78     }

    79 

    80   gbCheatUpdateMap();

    81 }

    82 

    83 void gbCheatsSaveCheatList(const char *file)

    84 {

    85   if (gbCheatNumber == 0)

    86     return;

    87   FILE *f = fopen(file, "wb");

    88   if (f == NULL)

    89     return;

    90   int version = 1;

    91   fwrite(&version, 1, sizeof(version), f);

    92   int type = 1;

    93   fwrite(&type, 1, sizeof(type), f);

    94   fwrite(&gbCheatNumber, 1, sizeof(gbCheatNumber), f);

    95   fwrite(gbCheatList, 1, sizeof(gbCheatList), f);

    96   fclose(f);

    97 }

    98 

    99 bool gbCheatsLoadCheatList(const char *file)

   100 {

   101   gbCheatNumber = 0;

   102 

   103   gbCheatUpdateMap();

   104 

   105   int count = 0;

   106 

   107   FILE *f = fopen(file, "rb");

   108 

   109   if (f == NULL)

   110     return false;

   111 

   112   int version = 0;

   113 

   114   if (fread(&version, 1, sizeof(version), f) != sizeof(version))

   115     {

   116       fclose(f);

   117       return false;

   118     }

   119 

   120   if (version != 1)

   121     {

   122       systemMessage(MSG_UNSUPPORTED_CHEAT_LIST_VERSION,

   123 		    N_("Unsupported cheat list version %d"), version);

   124       fclose(f);

   125       return false;

   126     }

   127 

   128   int type = 0;

   129   if (fread(&type, 1, sizeof(type), f) != sizeof(type))

   130     {

   131       fclose(f);

   132       return false;

   133     }

   134 

   135   if (type != 1)

   136     {

   137       systemMessage(MSG_UNSUPPORTED_CHEAT_LIST_TYPE,

   138 		    N_("Unsupported cheat list type %d"), type);

   139       fclose(f);

   140       return false;

   141     }

   142 

   143   if (fread(&count, 1, sizeof(count), f) != sizeof(count))

   144     {

   145       fclose(f);

   146       return false;

   147     }

   148 

   149   if (fread(gbCheatList, 1, sizeof(gbCheatList), f) != sizeof(gbCheatList))

   150     {

   151       fclose(f);

   152       return false;

   153     }

   154 

   155   fclose(f);

   156   gbCheatNumber = count;

   157   gbCheatUpdateMap();

   158 

   159   return true;

   160 }

   161 

   162 bool gbVerifyGsCode(const char *code)

   163 {

   164   int len = strlen(code);

   165 

   166   if (len == 0)

   167     return true;

   168 

   169   if (len != 8)

   170     return false;

   171 

   172   for (int i = 0; i < 8; i++)

   173     if (!GBCHEAT_IS_HEX(code[i]))

   174       return false;

   175 

   176   int address = GBCHEAT_HEX_VALUE(code[6]) << 12 |

   177     GBCHEAT_HEX_VALUE(code[7]) << 8 |

   178     GBCHEAT_HEX_VALUE(code[4]) << 4 |

   179     GBCHEAT_HEX_VALUE(code[5]);

   180 

   181   if (address < 0xa000 ||

   182       address > 0xdfff)

   183     return false;

   184 

   185   return true;

   186 }

   187 

   188 void gbAddGsCheat(const char *code, const char *desc)

   189 {

   190   if (gbCheatNumber > 99)

   191     {

   192       systemMessage(MSG_MAXIMUM_NUMBER_OF_CHEATS,

   193 		    N_("Maximum number of cheats reached."));

   194       return;

   195     }

   196 

   197   if (!gbVerifyGsCode(code))

   198     {

   199       systemMessage(MSG_INVALID_GAMESHARK_CODE,

   200 		    N_("Invalid GameShark code: %s"), code);

   201       return;

   202     }

   203 

   204   int i = gbCheatNumber;

   205 

   206   strcpy(gbCheatList[i].cheatCode, code);

   207   strcpy(gbCheatList[i].cheatDesc, desc);

   208 

   209   gbCheatList[i].code = GBCHEAT_HEX_VALUE(code[0]) << 4 |

   210     GBCHEAT_HEX_VALUE(code[1]);

   211 

   212   gbCheatList[i].value = GBCHEAT_HEX_VALUE(code[2]) << 4 |

   213     GBCHEAT_HEX_VALUE(code[3]);

   214 

   215   gbCheatList[i].address = GBCHEAT_HEX_VALUE(code[6]) << 12 |

   216     GBCHEAT_HEX_VALUE(code[7]) << 8 |

   217     GBCHEAT_HEX_VALUE(code[4]) << 4 |

   218     GBCHEAT_HEX_VALUE(code[5]);

   219 

   220   gbCheatList[i].compare = 0;

   221 

   222   gbCheatList[i].enabled = true;

   223 

   224   gbCheatMap[gbCheatList[i].address] = true;

   225 

   226   gbCheatNumber++;

   227 }

   228 

   229 bool gbVerifyGgCode(const char *code)

   230 {

   231   int len = strlen(code);

   232 

   233   if (len != 11 &&

   234       len != 7 &&

   235       len != 6 &&

   236       len != 0)

   237     return false;

   238 

   239   if (len == 0)

   240     return true;

   241 

   242   if (!GBCHEAT_IS_HEX(code[0]))

   243     return false;

   244   if (!GBCHEAT_IS_HEX(code[1]))

   245     return false;

   246   if (!GBCHEAT_IS_HEX(code[2]))

   247     return false;

   248   if (code[3] != '-')

   249     return false;

   250   if (!GBCHEAT_IS_HEX(code[4]))

   251     return false;

   252   if (!GBCHEAT_IS_HEX(code[5]))

   253     return false;

   254   if (!GBCHEAT_IS_HEX(code[6]))

   255     return false;

   256   if (code[7] != 0)

   257     {

   258       if (code[7] != '-')

   259 	return false;

   260       if (code[8] != 0)

   261 	{

   262 	  if (!GBCHEAT_IS_HEX(code[8]))

   263 	    return false;

   264 	  if (!GBCHEAT_IS_HEX(code[9]))

   265 	    return false;

   266 	  if (!GBCHEAT_IS_HEX(code[10]))

   267 	    return false;

   268 	}

   269     }

   270 

   271   //  int replace = (GBCHEAT_HEX_VALUE(code[0]) << 4) +

   272   //    GBCHEAT_HEX_VALUE(code[1]);

   273 

   274   int address = (GBCHEAT_HEX_VALUE(code[2]) << 8) +

   275     (GBCHEAT_HEX_VALUE(code[4]) << 4) +

   276     (GBCHEAT_HEX_VALUE(code[5])) +

   277     ((GBCHEAT_HEX_VALUE(code[6]) ^ 0x0f) << 12);

   278 

   279   if (address >= 0x8000 && address <= 0x9fff)

   280     return false;

   281 

   282   if (address >= 0xc000)

   283     return false;

   284 

   285   if (code[7] == 0 || code[8] == '0')

   286     return true;

   287 

   288   int compare = (GBCHEAT_HEX_VALUE(code[8]) << 4) +

   289     (GBCHEAT_HEX_VALUE(code[10]));

   290   compare  = compare ^ 0xff;

   291   compare  = (compare >> 2) | ((compare << 6) & 0xc0);

   292   compare ^= 0x45;

   293 

   294   int cloak = (GBCHEAT_HEX_VALUE(code[8])) ^ (GBCHEAT_HEX_VALUE(code[9]));

   295 

   296   if (cloak >= 1 && cloak <= 7)

   297     return false;

   298 

   299   return true;

   300 }

   301 

   302 void gbAddGgCheat(const char *code, const char *desc)

   303 {

   304   if (gbCheatNumber > 99)

   305     {

   306       systemMessage(MSG_MAXIMUM_NUMBER_OF_CHEATS,

   307 		    N_("Maximum number of cheats reached."));

   308       return;

   309     }

   310 

   311   if (!gbVerifyGgCode(code))

   312     {

   313       systemMessage(MSG_INVALID_GAMEGENIE_CODE,

   314 		    N_("Invalid GameGenie code: %s"), code);

   315       return;

   316     }

   317 

   318   int i = gbCheatNumber;

   319 

   320   int len = strlen(code);

   321 

   322   strcpy(gbCheatList[i].cheatCode, code);

   323   strcpy(gbCheatList[i].cheatDesc, desc);

   324 

   325   gbCheatList[i].code  = 1;

   326   gbCheatList[i].value = (GBCHEAT_HEX_VALUE(code[0]) << 4) +

   327     GBCHEAT_HEX_VALUE(code[1]);

   328 

   329   gbCheatList[i].address = (GBCHEAT_HEX_VALUE(code[2]) << 8) +

   330     (GBCHEAT_HEX_VALUE(code[4]) << 4) +

   331     (GBCHEAT_HEX_VALUE(code[5])) +

   332     ((GBCHEAT_HEX_VALUE(code[6]) ^ 0x0f) << 12);

   333 

   334   gbCheatList[i].compare = 0;

   335 

   336   if (len != 7 && len != 8)

   337     {

   338       int compare = (GBCHEAT_HEX_VALUE(code[8]) << 4) +

   339 	(GBCHEAT_HEX_VALUE(code[10]));

   340       compare  = compare ^ 0xff;

   341       compare  = (compare >> 2) | ((compare << 6) & 0xc0);

   342       compare ^= 0x45;

   343 

   344       gbCheatList[i].compare = compare;

   345       gbCheatList[i].code    = 0;

   346     }

   347 

   348   gbCheatList[i].enabled = true;

   349 

   350   gbCheatMap[gbCheatList[i].address] = true;

   351 

   352   gbCheatNumber++;

   353 }

   354 

   355 void gbCheatRemove(int i)

   356 {

   357   if (i < 0 || i >= gbCheatNumber)

   358     {

   359       systemMessage(MSG_INVALID_CHEAT_TO_REMOVE,

   360 		    N_("Invalid cheat to remove %d"), i);

   361       return;

   362     }

   363 

   364   if ((i+1) <  gbCheatNumber)

   365     {

   366       memcpy(&gbCheatList[i], &gbCheatList[i+1], sizeof(gbCheat)*

   367 	     (gbCheatNumber-i-1));

   368     }

   369 

   370   gbCheatNumber--;

   371 

   372   gbCheatUpdateMap();

   373 }

   374 

   375 void gbCheatRemoveAll()

   376 {

   377   gbCheatNumber = 0;

   378   gbCheatUpdateMap();

   379 }

   380 

   381 void gbCheatEnable(int i)

   382 {

   383   if (i >= 0 && i < gbCheatNumber)

   384     {

   385       if (!gbCheatList[i].enabled)

   386 	{

   387 	  gbCheatList[i].enabled = true;

   388 	  gbCheatUpdateMap();

   389 	}

   390     }

   391 }

   392 

   393 void gbCheatDisable(int i)

   394 {

   395   if (i >= 0 && i < gbCheatNumber)

   396     {

   397       if (gbCheatList[i].enabled)

   398 	{

   399 	  gbCheatList[i].enabled = false;

   400 	  gbCheatUpdateMap();

   401 	}

   402     }

   403 }

   404 

   405 bool gbCheatReadGSCodeFile(const char *fileName)

   406 {

   407   FILE *file = fopen(fileName, "rb");

   408 

   409   if (!file)

   410     return false;

   411 

   412   fseek(file, 0x18, SEEK_SET);

   413   int count = 0;

   414   fread(&count, 1, 2, file);

   415   int dummy = 0;

   416   gbCheatRemoveAll();

   417   char desc[13];

   418   char code[9];

   419   int  i;

   420   for (i = 0; i < count; i++)

   421     {

   422       fread(&dummy, 1, 2, file);

   423       fread(desc, 1, 12, file);

   424       desc[12] = 0;

   425       fread(code, 1, 8, file);

   426       code[8] = 0;

   427       gbAddGsCheat(code, desc);

   428     }

   429 

   430   for (i = 0; i < gbCheatNumber; i++)

   431     gbCheatDisable(i);

   432 

   433   fclose(file);

   434   return true;

   435 }

   436 

   437 u8 gbCheatRead(u16 address)

   438 {

   439   if (!cheatsEnabled)

   440     return gbReadMemoryQuick(address);

   441 

   442   for (int i = 0; i < gbCheatNumber; i++)

   443     {

   444       if (gbCheatList[i].enabled && gbCheatList[i].address == address)

   445 	{

   446 	  switch (gbCheatList[i].code)

   447 	    {

   448 	    case 0x100: // GameGenie support

   449 	      if (gbReadMemoryQuick(address) == gbCheatList[i].compare)

   450 		return gbCheatList[i].value;

   451 	      break;

   452 	    case 0x00:

   453 	    case 0x01:

   454 	    case 0x80:

   455 	      return gbCheatList[i].value;

   456 	    case 0x90:

   457 	    case 0x91:

   458 	    case 0x92:

   459 	    case 0x93:

   460 	    case 0x94:

   461 	    case 0x95:

   462 	    case 0x96:

   463 	    case 0x97:

   464 	      if (address >= 0xd000 && address < 0xe000)

   465 		{

   466 		  if (((gbMemoryMap[0x0d] - gbWram)/0x1000) ==

   467 		      (gbCheatList[i].code - 0x90))

   468 		    return gbCheatList[i].value;

   469 		}

   470 	      else

   471 		return gbCheatList[i].value;

   472 	    }

   473 	}

   474     }

   475   return gbReadMemoryQuick(address);

   476 }

   477
author	Robert McIntyre <rlm@mit.edu>
date	Mon, 25 Jun 2012 14:55:55 -0500
parents	5e8e5083da94
children