Mercurial > vba-clojure

     1 #include <cstdio>

     2 #include <cctype>

     3 #include <cstring>

     4 

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

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

     7 #include "../NLS.h"

     8 #include "GBACheats.h"

     9 #include "GBA.h"

    10 #include "GBAinline.h"

    11 #include "GBAGlobals.h"

    12 

    13 /**

    14  * Gameshark code types:

    15  *

    16  * NNNNNNNN 001DC0DE - ID code for the game (game 4 character name) from ROM

    17  * DEADFACE XXXXXXXX - changes decryption seeds

    18  * 0AAAAAAA 000000YY - 8-bit constant write

    19  * 1AAAAAAA 0000YYYY - 16-bit constant write

    20  * 2AAAAAAA YYYYYYYY - 32-bit constant write

    21  * 3AAAAAAA YYYYYYYY - ??

    22  * 6AAAAAAA 0000YYYY - 16-bit ROM Patch (address >> 1)

    23  * 6AAAAAAA 1000YYYY - 16-bit ROM Patch ? (address >> 1)

    24  * 6AAAAAAA 2000YYYY - 16-bit ROM Patch ? (address >> 1)

    25  * 8A1AAAAA 000000YY - 8-bit button write

    26  * 8A2AAAAA 0000YYYY - 16-bit button write

    27  * 8A3AAAAA YYYYYYYY - 32-bit button write

    28  * 80F00000 0000YYYY - button slow motion

    29  * DAAAAAAA 0000YYYY - if address contains 16-bit value enable next code

    30  * FAAAAAAA 0000YYYY - Master code function

    31  *

    32  * CodeBreaker codes types:

    33  *

    34  * 0000AAAA 000Y - Game CRC (Y are flags: 8 - CRC, 2 - DI)

    35  * 1AAAAAAA YYYY - Master Code function (store address at ((YYYY << 0x16)

    36  *                 + 0x08000100))

    37  * 2AAAAAAA YYYY - 16-bit or

    38  * 3AAAAAAA YYYY - 8-bit constant write

    39  * 4AAAAAAA YYYY - Slide code

    40  * XXXXCCCC IIII   (C is count and I is address increment, X is value incr.)

    41  * 5AAAAAAA CCCC - Super code (Write bytes to address, CCCC is count)

    42  * BBBBBBBB BBBB

    43  * 6AAAAAAA YYYY - 16-bit and

    44  * 7AAAAAAA YYYY - if address contains 16-bit value enable next code

    45  * 8AAAAAAA YYYY - 16-bit constant write

    46  * 9AAAAAAA YYYY - change decryption (when first code only?)

    47  * AAAAAAAA YYYY - if address does not contain 16-bit value enable next code

    48  * BAAAAAAA YYYY - if 16-bit < YYYY

    49  * CAAAAAAA YYYY - if 16-bit > YYYY

    50  * D0000020 YYYY - if button keys equal value enable next code

    51  * EAAAAAAA YYYY - increase value stored in address

    52  */

    53 #define UNKNOWN_CODE           -1

    54 #define INT_8_BIT_WRITE        0

    55 #define INT_16_BIT_WRITE       1

    56 #define INT_32_BIT_WRITE       2

    57 #define GSA_16_BIT_ROM_PATCH   3

    58 #define GSA_8_BIT_GS_WRITE     4

    59 #define GSA_16_BIT_GS_WRITE    5

    60 #define GSA_32_BIT_GS_WRITE    6

    61 #define CBA_IF_KEYS_PRESSED    7

    62 #define CBA_IF_TRUE            8

    63 #define CBA_SLIDE_CODE         9

    64 #define CBA_IF_FALSE           10

    65 #define CBA_AND                11

    66 #define GSA_8_BIT_GS_WRITE2    12

    67 #define GSA_16_BIT_GS_WRITE2   13

    68 #define GSA_32_BIT_GS_WRITE2   14

    69 #define GSA_16_BIT_ROM_PATCH2  15

    70 #define GSA_8_BIT_SLIDE        16

    71 #define GSA_16_BIT_SLIDE       17

    72 #define GSA_32_BIT_SLIDE       18

    73 #define GSA_8_BIT_IF_TRUE      19

    74 #define GSA_32_BIT_IF_TRUE     20

    75 #define GSA_8_BIT_IF_FALSE     21

    76 #define GSA_32_BIT_IF_FALSE    22

    77 #define GSA_8_BIT_FILL         23

    78 #define GSA_16_BIT_FILL        24

    79 #define GSA_8_BIT_IF_TRUE2     25

    80 #define GSA_16_BIT_IF_TRUE2    26

    81 #define GSA_32_BIT_IF_TRUE2    27

    82 #define GSA_8_BIT_IF_FALSE2    28

    83 #define GSA_16_BIT_IF_FALSE2   29

    84 #define GSA_32_BIT_IF_FALSE2   30

    85 #define GSA_SLOWDOWN           31

    86 #define CBA_ADD                32

    87 #define CBA_OR                 33

    88 #define CBA_LT                 34

    89 #define CBA_GT                 35

    90 #define CBA_SUPER              36

    91 

    92 CheatsData cheatsList[100];

    93 int        cheatsNumber = 0;

    94 

    95 u8   cheatsCBASeedBuffer[0x30];

    96 u32  cheatsCBASeed[4];

    97 u32  cheatsCBATemporaryValue = 0;

    98 u16  cheatsCBATable[256];

    99 bool cheatsCBATableGenerated = false;

   100 

   101 u8 cheatsCBACurrentSeed[12] = {

   102 	0x00, 0x00, 0x00, 0x00,

   103 	0x00, 0x00, 0x00, 0x00,

   104 	0x00, 0x00, 0x00, 0x00

   105 };

   106 

   107 #define CHEAT_IS_HEX(a) (((a) >= 'A' && (a) <= 'F') || ((a) >= '0' && (a) <= '9'))

   108 

   109 #define CHEAT_PATCH_ROM_16BIT(a, v) \

   110     WRITE16LE(((u16 *)&rom[(a) & 0x1ffffff]), v);

   111 

   112 static bool isMultilineWithData(int i)

   113 {

   114 	// we consider it a multiline code if it has more than one line of data

   115 	// otherwise, it can still be considered a single code

   116 	if (i < cheatsNumber && i >= 0)

   117 		switch (cheatsList[i].size)

   118 		{

   119 		case INT_8_BIT_WRITE:

   120 		case INT_16_BIT_WRITE:

   121 		case INT_32_BIT_WRITE:

   122 		case GSA_16_BIT_ROM_PATCH:

   123 		case GSA_8_BIT_GS_WRITE:

   124 		case GSA_16_BIT_GS_WRITE:

   125 		case GSA_32_BIT_GS_WRITE:

   126 		case CBA_AND:

   127 		case CBA_IF_KEYS_PRESSED:

   128 		case CBA_IF_TRUE:

   129 		case CBA_IF_FALSE:

   130 		case GSA_8_BIT_IF_TRUE:

   131 		case GSA_32_BIT_IF_TRUE:

   132 		case GSA_8_BIT_IF_FALSE:

   133 		case GSA_32_BIT_IF_FALSE:

   134 		case GSA_8_BIT_FILL:

   135 		case GSA_16_BIT_FILL:

   136 		case GSA_8_BIT_IF_TRUE2:

   137 		case GSA_16_BIT_IF_TRUE2:

   138 		case GSA_32_BIT_IF_TRUE2:

   139 		case GSA_8_BIT_IF_FALSE2:

   140 		case GSA_16_BIT_IF_FALSE2:

   141 		case GSA_32_BIT_IF_FALSE2:

   142 		case GSA_SLOWDOWN:

   143 		case CBA_ADD:

   144 		case CBA_OR:

   145 			return false;

   146 		// the codes below have two lines of data

   147 		case CBA_SLIDE_CODE:

   148 		case GSA_8_BIT_GS_WRITE2:

   149 		case GSA_16_BIT_GS_WRITE2:

   150 		case GSA_32_BIT_GS_WRITE2:

   151 		case GSA_16_BIT_ROM_PATCH2:

   152 		case GSA_8_BIT_SLIDE:

   153 		case GSA_16_BIT_SLIDE:

   154 		case GSA_32_BIT_SLIDE:

   155 		case CBA_LT:

   156 		case CBA_GT:

   157 		case CBA_SUPER:

   158 			return true;

   159 		}

   160 	return false;

   161 }

   162 

   163 static int getCodeLength(int num)

   164 {

   165 	if (num >= cheatsNumber || num < 0)

   166 		return 1;

   167 

   168 	// this is for all the codes that are true multiline

   169 	switch (cheatsList[num].size)

   170 	{

   171 	case INT_8_BIT_WRITE:

   172 	case INT_16_BIT_WRITE:

   173 	case INT_32_BIT_WRITE:

   174 	case GSA_16_BIT_ROM_PATCH:

   175 	case GSA_8_BIT_GS_WRITE:

   176 	case GSA_16_BIT_GS_WRITE:

   177 	case GSA_32_BIT_GS_WRITE:

   178 	case CBA_AND:

   179 	case GSA_8_BIT_FILL:

   180 	case GSA_16_BIT_FILL:

   181 	case GSA_SLOWDOWN:

   182 	case CBA_ADD:

   183 	case CBA_OR:

   184 		return 1;

   185 	case CBA_IF_KEYS_PRESSED:

   186 	case CBA_IF_TRUE:

   187 	case CBA_IF_FALSE:

   188 	case CBA_SLIDE_CODE:

   189 	case GSA_8_BIT_GS_WRITE2:

   190 	case GSA_16_BIT_GS_WRITE2:

   191 	case GSA_32_BIT_GS_WRITE2:

   192 	case GSA_16_BIT_ROM_PATCH2:

   193 	case GSA_8_BIT_SLIDE:

   194 	case GSA_16_BIT_SLIDE:

   195 	case GSA_32_BIT_SLIDE:

   196 	case GSA_8_BIT_IF_TRUE:

   197 	case GSA_32_BIT_IF_TRUE:

   198 	case GSA_8_BIT_IF_FALSE:

   199 	case GSA_32_BIT_IF_FALSE:

   200 	case CBA_LT:

   201 	case CBA_GT:

   202 		return 2;

   203 	case GSA_8_BIT_IF_TRUE2:

   204 	case GSA_16_BIT_IF_TRUE2:

   205 	case GSA_32_BIT_IF_TRUE2:

   206 	case GSA_8_BIT_IF_FALSE2:

   207 	case GSA_16_BIT_IF_FALSE2:

   208 	case GSA_32_BIT_IF_FALSE2:

   209 		return 3;

   210 	case CBA_SUPER:

   211 		return (cheatsList[num].value+5)/6;

   212 	}

   213 	return 1;

   214 }

   215 

   216 int cheatsCheckKeys(u32 keys, u32 extended)

   217 {

   218 	int ticks = 0;

   219 	for (int i = 0; i < cheatsNumber; i++)

   220 	{

   221 		if (!cheatsList[i].enabled)

   222 		{

   223 			// make sure we skip other lines in this code

   224 			i += getCodeLength(i)-1;

   225 			continue;

   226 		}

   227 		switch (cheatsList[i].size)

   228 		{

   229 		case INT_8_BIT_WRITE:

   230 			CPUWriteByte(cheatsList[i].address, cheatsList[i].value);

   231 			break;

   232 		case INT_16_BIT_WRITE:

   233 			CPUWriteHalfWord(cheatsList[i].address, cheatsList[i].value);

   234 			break;

   235 		case INT_32_BIT_WRITE:

   236 			CPUWriteMemory(cheatsList[i].address, cheatsList[i].value);

   237 			break;

   238 		case GSA_16_BIT_ROM_PATCH:

   239 			if ((cheatsList[i].status & 1) == 0)

   240 			{

   241 				if (CPUReadHalfWord(cheatsList[i].address) != cheatsList[i].value)

   242 				{

   243 					cheatsList[i].oldValue = CPUReadHalfWord(cheatsList[i].address);

   244 					cheatsList[i].status  |= 1;

   245 					CHEAT_PATCH_ROM_16BIT(cheatsList[i].address, cheatsList[i].value);

   246 				}

   247 			}

   248 			break;

   249 		case GSA_8_BIT_GS_WRITE:

   250 			if (extended & 4)

   251 			{

   252 				CPUWriteByte(cheatsList[i].address, cheatsList[i].value);

   253 			}

   254 			break;

   255 		case GSA_16_BIT_GS_WRITE:

   256 			if (extended & 4)

   257 			{

   258 				CPUWriteHalfWord(cheatsList[i].address, cheatsList[i].value);

   259 			}

   260 			break;

   261 		case GSA_32_BIT_GS_WRITE:

   262 			if (extended & 4)

   263 			{

   264 				CPUWriteMemory(cheatsList[i].address, cheatsList[i].value);

   265 			}

   266 			break;

   267 		case CBA_IF_KEYS_PRESSED:

   268 		{

   269 			u16 value = cheatsList[i].value;

   270 			u32 addr  = cheatsList[i].address;

   271 			if ((addr & 0x30) == 0x20)

   272 			{

   273 				if ((keys & value) != value)

   274 				{

   275 					i++;

   276 				}

   277 			}

   278 			else if ((addr & 0x30) == 0x10)

   279 			{

   280 				if ((keys & value) == value)

   281 				{

   282 					i++;

   283 				}

   284 			}

   285 			break;

   286 		}

   287 		case CBA_IF_TRUE:

   288 			if (CPUReadHalfWord(cheatsList[i].address) != cheatsList[i].value)

   289 			{

   290 				i++;

   291 			}

   292 			break;

   293 		case CBA_SLIDE_CODE:

   294 		{

   295 			u32 address = cheatsList[i].address;

   296 			u16 value   = cheatsList[i].value;

   297 			i++;

   298 			if (i < cheatsNumber)

   299 			{

   300 				int count = (cheatsList[i].address & 0xFFFF);

   301 				u16 vinc  = (cheatsList[i].address >> 16) & 0xFFFF;

   302 				int inc   = cheatsList[i].value;

   303 

   304 				for (int x = 0; x < count; x++)

   305 				{

   306 					CPUWriteHalfWord(address, value);

   307 					address += inc;

   308 					value   += vinc;

   309 				}

   310 			}

   311 			break;

   312 		}

   313 		case CBA_IF_FALSE:

   314 			if (CPUReadHalfWord(cheatsList[i].address) == cheatsList[i].value)

   315 			{

   316 				i++;

   317 			}

   318 			break;

   319 		case CBA_AND:

   320 			CPUWriteHalfWord(cheatsList[i].address,

   321 			                 CPUReadHalfWord(cheatsList[i].address) &

   322 			                 cheatsList[i].value);

   323 			break;

   324 		case GSA_8_BIT_GS_WRITE2:

   325 			i++;

   326 			if (i < cheatsNumber)

   327 			{

   328 				if (extended & 4)

   329 				{

   330 					CPUWriteByte(cheatsList[i-1].value, cheatsList[i].address);

   331 				}

   332 			}

   333 			break;

   334 		case GSA_16_BIT_GS_WRITE2:

   335 			i++;

   336 			if (i < cheatsNumber)

   337 			{

   338 				if (extended & 4)

   339 				{

   340 					CPUWriteHalfWord(cheatsList[i-1].value, cheatsList[i].address);

   341 				}

   342 			}

   343 			break;

   344 		case GSA_32_BIT_GS_WRITE2:

   345 			i++;

   346 			if (i < cheatsNumber)

   347 			{

   348 				if (extended & 4)

   349 				{

   350 					CPUWriteMemory(cheatsList[i-1].value, cheatsList[i].address);

   351 				}

   352 			}

   353 			break;

   354 		case GSA_16_BIT_ROM_PATCH2:

   355 			i++;

   356 			if (i < cheatsNumber)

   357 			{

   358 				if ((cheatsList[i-1].status & 1) == 0)

   359 				{

   360 					u32 addr = ((cheatsList[i-1].value & 0x00FFFFFF) << 1) + 0x8000000;

   361 					if (CPUReadHalfWord(addr) != (cheatsList[i].address & 0xFFFF))

   362 					{

   363 						cheatsList[i-1].oldValue = CPUReadHalfWord(addr);

   364 						cheatsList[i-1].status  |= 1;

   365 						CHEAT_PATCH_ROM_16BIT(addr, cheatsList[i].address & 0xFFFF);

   366 					}

   367 				}

   368 			}

   369 			break;

   370 		case GSA_8_BIT_SLIDE:

   371 			i++;

   372 			if (i < cheatsNumber)

   373 			{

   374 				u32 addr  = cheatsList[i-1].value;

   375 				u8  value = cheatsList[i].address;

   376 				int vinc  = (cheatsList[i].value >> 24) & 255;

   377 				int count = (cheatsList[i].value >> 16) & 255;

   378 				int ainc  = (cheatsList[i].value & 0xffff);

   379 				while (count > 0)

   380 				{

   381 					CPUWriteByte(addr, value);

   382 					value += vinc;

   383 					addr  += ainc;

   384 					count--;

   385 				}

   386 			}

   387 			break;

   388 		case GSA_16_BIT_SLIDE:

   389 			i++;

   390 			if (i < cheatsNumber)

   391 			{

   392 				u32 addr  = cheatsList[i-1].value;

   393 				u16 value = cheatsList[i].address;

   394 				int vinc  = (cheatsList[i].value >> 24) & 255;

   395 				int count = (cheatsList[i].value >> 16) & 255;

   396 				int ainc  = (cheatsList[i].value & 0xffff)*2;

   397 				while (count > 0)

   398 				{

   399 					CPUWriteHalfWord(addr, value);

   400 					value += vinc;

   401 					addr  += ainc;

   402 					count--;

   403 				}

   404 			}

   405 			break;

   406 		case GSA_32_BIT_SLIDE:

   407 			i++;

   408 			if (i < cheatsNumber)

   409 			{

   410 				u32 addr  = cheatsList[i-1].value;

   411 				u32 value = cheatsList[i].address;

   412 				int vinc  = (cheatsList[i].value >> 24) & 255;

   413 				int count = (cheatsList[i].value >> 16) & 255;

   414 				int ainc  = (cheatsList[i].value & 0xffff)*4;

   415 				while (count > 0)

   416 				{

   417 					CPUWriteMemory(addr, value);

   418 					value += vinc;

   419 					addr  += ainc;

   420 					count--;

   421 				}

   422 			}

   423 			break;

   424 		case GSA_8_BIT_IF_TRUE:

   425 			if (CPUReadByte(cheatsList[i].address) != cheatsList[i].value)

   426 			{

   427 				i++;

   428 			}

   429 			break;

   430 		case GSA_32_BIT_IF_TRUE:

   431 			if (CPUReadMemory(cheatsList[i].address) != cheatsList[i].value)

   432 			{

   433 				i++;

   434 			}

   435 			break;

   436 		case GSA_8_BIT_IF_FALSE:

   437 			if (CPUReadByte(cheatsList[i].address) == cheatsList[i].value)

   438 			{

   439 				i++;

   440 			}

   441 			break;

   442 		case GSA_32_BIT_IF_FALSE:

   443 			if (CPUReadMemory(cheatsList[i].address) == cheatsList[i].value)

   444 			{

   445 				i++;

   446 			}

   447 			break;

   448 		case GSA_8_BIT_FILL:

   449 		{

   450 			u32 addr = cheatsList[i].address;

   451 			u8  v    = cheatsList[i].value & 0xff;

   452 			u32 end  = addr + (cheatsList[i].value >> 8);

   453 			do

   454 			{

   455 				CPUWriteByte(addr, v);

   456 				addr++;

   457 			}

   458 			while (addr <= end);

   459 			break;

   460 		}

   461 		case GSA_16_BIT_FILL:

   462 		{

   463 			u32 addr = cheatsList[i].address;

   464 			u16 v    = cheatsList[i].value & 0xffff;

   465 			u32 end  = addr + ((cheatsList[i].value >> 16) << 1);

   466 			do

   467 			{

   468 				CPUWriteHalfWord(addr, v);

   469 				addr += 2;

   470 			}

   471 			while (addr <= end);

   472 			break;

   473 		}

   474 		case GSA_8_BIT_IF_TRUE2:

   475 			if (CPUReadByte(cheatsList[i].address) != cheatsList[i].value)

   476 			{

   477 				i += 2;

   478 			}

   479 			break;

   480 		case GSA_16_BIT_IF_TRUE2:

   481 			if (CPUReadHalfWord(cheatsList[i].address) != cheatsList[i].value)

   482 			{

   483 				i += 2;

   484 			}

   485 			break;

   486 		case GSA_32_BIT_IF_TRUE2:

   487 			if (CPUReadMemory(cheatsList[i].address) != cheatsList[i].value)

   488 			{

   489 				i += 2;

   490 			}

   491 			break;

   492 		case GSA_8_BIT_IF_FALSE2:

   493 			if (CPUReadByte(cheatsList[i].address) == cheatsList[i].value)

   494 			{

   495 				i += 2;

   496 			}

   497 			break;

   498 		case GSA_16_BIT_IF_FALSE2:

   499 			if (CPUReadHalfWord(cheatsList[i].address) == cheatsList[i].value)

   500 			{

   501 				i += 2;

   502 			}

   503 			break;

   504 		case GSA_32_BIT_IF_FALSE2:

   505 			if (CPUReadMemory(cheatsList[i].address) == cheatsList[i].value)

   506 			{

   507 				i += 2;

   508 			}

   509 			break;

   510 		case GSA_SLOWDOWN:

   511 			// check if button was pressed and released, if so toggle our state

   512 			if ((cheatsList[i].status & 4) && !(extended & 4))

   513 				cheatsList[i].status ^= 1;

   514 			if (extended & 4)

   515 				cheatsList[i].status |= 4;

   516 			else

   517 				cheatsList[i].status &= ~4;

   518 

   519 			if (cheatsList[i].status & 1)

   520 				ticks += 2*256*((cheatsList[i].value >> 8) & 255);

   521 			break;

   522 		case CBA_ADD:

   523 			CPUWriteHalfWord(cheatsList[i].address,

   524 			                 CPUReadHalfWord(cheatsList[i].address) +

   525 			                 (u16)cheatsList[i].value);

   526 			break;

   527 		case CBA_OR:

   528 			CPUWriteHalfWord(cheatsList[i].address,

   529 			                 CPUReadHalfWord(cheatsList[i].address) |

   530 			                 cheatsList[i].value);

   531 			break;

   532 		case CBA_LT:

   533 			if (CPUReadHalfWord(cheatsList[i].address) >= cheatsList[i].value)

   534 				i++;

   535 			break;

   536 		case CBA_GT:

   537 			if (CPUReadHalfWord(cheatsList[i].address) <= cheatsList[i].value)

   538 				i++;

   539 			break;

   540 		case CBA_SUPER:

   541 		{

   542 			int count   = 2*cheatsList[i].value;

   543 			u32 address = cheatsList[i].address;

   544 			for (int x = 0; x < count; x++)

   545 			{

   546 				u8  b;

   547 				int res = x % 6;

   548 				if (res < 4)

   549 					b = (cheatsList[i].address >> (24-8*res)) & 0xFF;

   550 				else

   551 					b = (cheatsList[i].value >> (8 - 8*(res-4))) & 0x0FF;

   552 				CPUWriteByte(address, b);

   553 				address++;

   554 				if (x && !res)

   555 					i++;

   556 			}

   557 			if (count % 6)

   558 				i++;

   559 			break;

   560 		}

   561 		}

   562 	}

   563 	return ticks;

   564 }

   565 

   566 void cheatsAdd(const char *codeStr,

   567                const char *desc,

   568                u32 address,

   569                u32 value,

   570                int code,

   571                int size)

   572 {

   573 	if (cheatsNumber < 100)

   574 	{

   575 		int x = cheatsNumber;

   576 		cheatsList[x].code    = code;

   577 		cheatsList[x].size    = size;

   578 		cheatsList[x].address = address;

   579 		cheatsList[x].value   = value;

   580 		strcpy(cheatsList[x].codestring, codeStr);

   581 		strcpy(cheatsList[x].desc, desc);

   582 		cheatsList[x].enabled = true;

   583 		cheatsList[x].status  = 0;

   584 

   585 		// we only store the old value for this simple codes. ROM patching

   586 		// is taken care when it actually patches the ROM

   587 		switch (cheatsList[x].size)

   588 		{

   589 		case INT_8_BIT_WRITE:

   590 			cheatsList[x].oldValue = CPUReadByte(address);

   591 			break;

   592 		case INT_16_BIT_WRITE:

   593 			cheatsList[x].oldValue = CPUReadHalfWord(address);

   594 			break;

   595 		case INT_32_BIT_WRITE:

   596 			cheatsList[x].oldValue = CPUReadMemory(address);

   597 			break;

   598 		}

   599 		cheatsNumber++;

   600 	}

   601 }

   602 

   603 void cheatsDelete(int number, bool restore)

   604 {

   605 	if (number < cheatsNumber && number >= 0)

   606 	{

   607 		int x = number;

   608 

   609 		if (restore)

   610 		{

   611 			switch (cheatsList[x].size)

   612 			{

   613 			case INT_8_BIT_WRITE:

   614 				CPUWriteByte(cheatsList[x].address, (u8)cheatsList[x].oldValue);

   615 				break;

   616 			case INT_16_BIT_WRITE:

   617 				CPUWriteHalfWord(cheatsList[x].address, (u16)cheatsList[x].oldValue);

   618 				break;

   619 			case INT_32_BIT_WRITE:

   620 				CPUWriteMemory(cheatsList[x].address, cheatsList[x].oldValue);

   621 				break;

   622 			case GSA_16_BIT_ROM_PATCH:

   623 				if (cheatsList[x].status & 1)

   624 				{

   625 					cheatsList[x].status &= ~1;

   626 					CHEAT_PATCH_ROM_16BIT(cheatsList[x].address,

   627 					                      cheatsList[x].oldValue);

   628 				}

   629 				break;

   630 			case GSA_16_BIT_ROM_PATCH2:

   631 				if (cheatsList[x].status & 1)

   632 				{

   633 					cheatsList[x].status &= ~1;

   634 					CHEAT_PATCH_ROM_16BIT(((cheatsList[x].value & 0x00FFFFFF) << 1)+

   635 					                      0x8000000,

   636 					                      cheatsList[x].oldValue);

   637 				}

   638 				break;

   639 			}

   640 		}

   641 		if ((x+1) <  cheatsNumber)

   642 		{

   643 			memcpy(&cheatsList[x], &cheatsList[x+1], sizeof(CheatsData)*

   644 			       (cheatsNumber-x-1));

   645 		}

   646 		cheatsNumber--;

   647 	}

   648 }

   649 

   650 void cheatsDeleteAll(bool restore)

   651 {

   652 	for (int i = cheatsNumber-1; i >= 0; i--)

   653 	{

   654 		cheatsDelete(i, restore);

   655 	}

   656 }

   657 

   658 void cheatsEnable(int i)

   659 {

   660 	if (i >= 0 && i < cheatsNumber)

   661 	{

   662 		cheatsList[i].enabled = true;

   663 	}

   664 }

   665 

   666 void cheatsDisable(int i)

   667 {

   668 	if (i >= 0 && i < cheatsNumber)

   669 	{

   670 		switch (cheatsList[i].size)

   671 		{

   672 		case GSA_16_BIT_ROM_PATCH:

   673 			if (cheatsList[i].status & 1)

   674 			{

   675 				cheatsList[i].status &= ~1;

   676 				CHEAT_PATCH_ROM_16BIT(cheatsList[i].address,

   677 				                      cheatsList[i].oldValue);

   678 			}

   679 			break;

   680 		case GSA_16_BIT_ROM_PATCH2:

   681 			if (cheatsList[i].status & 1)

   682 			{

   683 				cheatsList[i].status &= ~1;

   684 				CHEAT_PATCH_ROM_16BIT(((cheatsList[i].value & 0x00FFFFFF) << 1)+

   685 				                      0x8000000,

   686 				                      cheatsList[i].oldValue);

   687 			}

   688 			break;

   689 		}

   690 		cheatsList[i].enabled = false;

   691 	}

   692 }

   693 

   694 bool cheatsVerifyCheatCode(const char *code, const char *desc)

   695 {

   696 	int len = strlen(code);

   697 	if (len != 11 && len != 13 && len != 17)

   698 	{

   699 		systemMessage(MSG_INVALID_CHEAT_CODE, N_("Invalid cheat code '%s'"), code);

   700 		return false;

   701 	}

   702 

   703 	if (code[8] != ':')

   704 	{

   705 		systemMessage(MSG_INVALID_CHEAT_CODE, N_("Invalid cheat code '%s'"), code);

   706 		return false;

   707 	}

   708 

   709 	int i;

   710 	for (i = 0; i < 8; i++)

   711 	{

   712 		if (!CHEAT_IS_HEX(code[i]))

   713 		{

   714 			// wrong cheat

   715 			systemMessage(MSG_INVALID_CHEAT_CODE,

   716 			              N_("Invalid cheat code '%s'"), code);

   717 			return false;

   718 		}

   719 	}

   720 	for (i = 9; i < len; i++)

   721 	{

   722 		if (!CHEAT_IS_HEX(code[i]))

   723 		{

   724 			// wrong cheat

   725 			systemMessage(MSG_INVALID_CHEAT_CODE,

   726 			              N_("Invalid cheat code '%s'"), code);

   727 			return false;

   728 		}

   729 	}

   730 

   731 	u32 address = 0;

   732 	u32 value   = 0;

   733 

   734 	char buffer[10];

   735 	strncpy(buffer, code, 8);

   736 	buffer[8] = 0;

   737 	sscanf(buffer, "%x", &address);

   738 

   739 	switch (address >> 24)

   740 	{

   741 	case 2:

   742 	case 3:

   743 		break;

   744 	default:

   745 		systemMessage(MSG_INVALID_CHEAT_CODE_ADDRESS,

   746 		              N_("Invalid cheat code address: %08x"),

   747 		              address);

   748 		return false;

   749 	}

   750 

   751 	strncpy(buffer, &code[9], 8);

   752 	sscanf(buffer, "%x", &value);

   753 	int type = 0;

   754 	if (len == 13)

   755 		type = 1;

   756 	if (len == 17)

   757 		type = 2;

   758 	cheatsAdd(code, desc, address, value, type, type);

   759 	return true;

   760 }

   761 

   762 void cheatsAddCheatCode(const char *code, const char *desc)

   763 {

   764 	cheatsVerifyCheatCode(code, desc);

   765 }

   766 

   767 void cheatsDecryptGSACode(u32& address, u32& value, bool v3)

   768 {

   769 	u32  rollingseed = 0xC6EF3720;

   770 	u32  seeds_v1[]  =  { 0x09F4FBBD, 0x9681884A, 0x352027E9, 0xF3DEE5A7 };

   771 	u32  seeds_v3[]  = { 0x7AA9648F, 0x7FAE6994, 0xC0EFAAD5, 0x42712C57 };

   772 	u32 *seeds       = v3 ? seeds_v3 : seeds_v1;

   773 

   774 	int bitsleft = 32;

   775 	while (bitsleft > 0)

   776 	{

   777 		value -= ((((address << 4) + seeds[2]) ^ (address + rollingseed)) ^

   778 		          ((address >> 5) + seeds[3]));

   779 		address -= ((((value << 4) + seeds[0]) ^ (value + rollingseed)) ^

   780 		            ((value >> 5) + seeds[1]));

   781 		rollingseed -= 0x9E3779B9;

   782 		bitsleft--;

   783 	}

   784 }

   785 

   786 void cheatsAddGSACode(const char *code, const char *desc, bool v3)

   787 {

   788 	if (strlen(code) != 16)

   789 	{

   790 		// wrong cheat

   791 		systemMessage(MSG_INVALID_GSA_CODE,

   792 		              N_("Invalid GSA code. Format is XXXXXXXXYYYYYYYY"));

   793 		return;

   794 	}

   795 

   796 	int i;

   797 	for (i = 0; i < 16; i++)

   798 	{

   799 		if (!CHEAT_IS_HEX(code[i]))

   800 		{

   801 			// wrong cheat

   802 			systemMessage(MSG_INVALID_GSA_CODE,

   803 			              N_("Invalid GSA code. Format is XXXXXXXXYYYYYYYY"));

   804 			return;

   805 		}

   806 	}

   807 

   808 	char buffer[10];

   809 	strncpy(buffer, code, 8);

   810 	buffer[8] = 0;

   811 	u32 address;

   812 	sscanf(buffer, "%x", &address);

   813 	strncpy(buffer, &code[8], 8);

   814 	buffer[8] = 0;

   815 	u32 value;

   816 	sscanf(buffer, "%x", &value);

   817 

   818 	cheatsDecryptGSACode(address, value, v3);

   819 

   820 	if (value == 0x1DC0DE)

   821 	{

   822 		u32 gamecode = READ32LE(((u32 *)&rom[0xac]));

   823 		if (gamecode != address)

   824 		{

   825 			char buffer[5];

   826 			*((u32 *)buffer) = address;

   827 			buffer[4]        = 0;

   828 			char buffer2[5];

   829 			*((u32 *)buffer2) = READ32LE(((u32 *)&rom[0xac]));

   830 			buffer2[4]        = 0;

   831 			systemMessage(MSG_GBA_CODE_WARNING,

   832 			              N_("Warning: cheats are for game %s. Current game is %s.\nCodes may not work correctly."),

   833 			              buffer, buffer2);

   834 		}

   835 		cheatsAdd(code, desc, address & 0x0FFFFFFF, value, v3 ? 257 : 256,

   836 		          UNKNOWN_CODE);

   837 		return;

   838 	}

   839 	if (isMultilineWithData(cheatsNumber-1))

   840 	{

   841 		cheatsAdd(code, desc, address, value, v3 ? 257 : 256, UNKNOWN_CODE);

   842 		return;

   843 	}

   844 	if (v3)

   845 	{

   846 		int type = (address >> 25) & 127;

   847 		u32 addr = (address & 0x00F00000) << 4 | (address & 0x0003FFFF);

   848 		switch (type)

   849 		{

   850 		case 0x00:

   851 			if (address == 0)

   852 			{

   853 				type = (value >> 25) & 127;

   854 				addr = (value & 0x00F00000) << 4 | (value & 0x0003FFFF);

   855 				switch (type)

   856 				{

   857 				case 0x04:

   858 					cheatsAdd(code, desc, 0, value & 0x00FFFFFF, 257, GSA_SLOWDOWN);

   859 					break;

   860 				case 0x08:

   861 					cheatsAdd(code, desc, 0, addr, 257, GSA_8_BIT_GS_WRITE2);

   862 					break;

   863 				case 0x09:

   864 					cheatsAdd(code, desc, 0, addr, 257, GSA_16_BIT_GS_WRITE2);

   865 					break;

   866 				case 0x0a:

   867 					cheatsAdd(code, desc, 0, addr, 257, GSA_32_BIT_GS_WRITE2);

   868 					break;

   869 				case 0x0c:

   870 				case 0x0d:

   871 				case 0x0e:

   872 				case 0x0f:

   873 					cheatsAdd(code, desc, 0, value & 0x00FFFFFF, 257, GSA_16_BIT_ROM_PATCH2);

   874 					break;

   875 				case 0x40:

   876 					cheatsAdd(code, desc, 0, addr, 257, GSA_8_BIT_SLIDE);

   877 					break;

   878 				case 0x41:

   879 					cheatsAdd(code, desc, 0, addr, 257, GSA_16_BIT_SLIDE);

   880 					break;

   881 				case 0x42:

   882 					cheatsAdd(code, desc, 0, addr, 257, GSA_32_BIT_SLIDE);

   883 					break;

   884 				default:

   885 					cheatsAdd(code, desc, address, value, 257, UNKNOWN_CODE);

   886 					break;

   887 				}

   888 			}

   889 			else

   890 				cheatsAdd(code, desc, addr, value, 257, GSA_8_BIT_FILL);

   891 			break;

   892 		case 0x01:

   893 			cheatsAdd(code, desc, addr, value, 257, GSA_16_BIT_FILL);

   894 			break;

   895 		case 0x02:

   896 			cheatsAdd(code, desc, addr, value, 257, INT_32_BIT_WRITE);

   897 			break;

   898 		case 0x04:

   899 			cheatsAdd(code, desc, addr, value, 257, GSA_8_BIT_IF_TRUE);

   900 			break;

   901 		case 0x05:

   902 			cheatsAdd(code, desc, addr, value, 257, CBA_IF_TRUE);

   903 			break;

   904 		case 0x06:

   905 			cheatsAdd(code, desc, addr, value, 257, GSA_32_BIT_IF_TRUE);

   906 			break;

   907 		case 0x08:

   908 			cheatsAdd(code, desc, addr, value, 257, GSA_8_BIT_IF_FALSE);

   909 			break;

   910 		case 0x09:

   911 			cheatsAdd(code, desc, addr, value, 257, CBA_IF_FALSE);

   912 			break;

   913 		case 0x0a:

   914 			cheatsAdd(code, desc, addr, value, 257, GSA_32_BIT_IF_FALSE);

   915 			break;

   916 		case 0x24:

   917 			cheatsAdd(code, desc, addr, value, 257, GSA_8_BIT_IF_TRUE2);

   918 			break;

   919 		case 0x25:

   920 			cheatsAdd(code, desc, addr, value, 257, GSA_16_BIT_IF_TRUE2);

   921 			break;

   922 		case 0x26:

   923 			cheatsAdd(code, desc, addr, value, 257, GSA_32_BIT_IF_TRUE2);

   924 			break;

   925 		case 0x28:

   926 			cheatsAdd(code, desc, addr, value, 257, GSA_8_BIT_IF_FALSE2);

   927 			break;

   928 		case 0x29:

   929 			cheatsAdd(code, desc, addr, value, 257, GSA_16_BIT_IF_FALSE2);

   930 			break;

   931 		case 0x2a:

   932 			cheatsAdd(code, desc, addr, value, 257, GSA_32_BIT_IF_FALSE2);

   933 			break;

   934 		default:

   935 			cheatsAdd(code, desc, address, value, 257, UNKNOWN_CODE);

   936 			break;

   937 		}

   938 	}

   939 	else

   940 	{

   941 		int type = (address >> 28) & 15;

   942 		switch (type)

   943 		{

   944 		case 0:

   945 		case 1:

   946 		case 2:

   947 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 256, type);

   948 			break;

   949 		case 6:

   950 			address <<= 1;

   951 			type      = (address >> 28) & 15;

   952 			if (type == 0x0c)

   953 			{

   954 				cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 256,

   955 				          GSA_16_BIT_ROM_PATCH);

   956 				break;

   957 			}

   958 			// unsupported code

   959 			cheatsAdd(code, desc, address, value, 256,

   960 			          UNKNOWN_CODE);

   961 			break;

   962 		case 8:

   963 			switch ((address >> 20) & 15)

   964 			{

   965 			case 1:

   966 				cheatsAdd(code, desc, address & 0x0F0FFFFF, value, 256,

   967 				          GSA_8_BIT_GS_WRITE);

   968 				break;

   969 			case 2:

   970 				cheatsAdd(code, desc, address & 0x0F0FFFFF, value, 256,

   971 				          GSA_16_BIT_GS_WRITE);

   972 				break;

   973 			case 3:

   974 				cheatsAdd(code, desc, address & 0x0F0FFFFF, value, 256,

   975 				          GSA_32_BIT_GS_WRITE);

   976 			case 15:

   977 				cheatsAdd(code, desc, 0, value & 0xFF00, 256, GSA_SLOWDOWN);

   978 				break;

   979 			default:

   980 				// unsupported code

   981 				cheatsAdd(code, desc, address, value, 256,

   982 				          UNKNOWN_CODE);

   983 				break;

   984 			}

   985 			break;

   986 		case 0x0d:

   987 			if (address != 0xDEADFACE)

   988 			{

   989 				cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 256,

   990 				          CBA_IF_TRUE);

   991 			}

   992 			else

   993 				cheatsAdd(code, desc, address, value, 256,

   994 				          UNKNOWN_CODE);

   995 			break;

   996 		default:

   997 			// unsupported code

   998 			cheatsAdd(code, desc, address, value, 256,

   999 			          UNKNOWN_CODE);

  1000 			break;

  1001 		}

  1002 	}

  1003 }

  1004 

  1005 bool cheatsImportGSACodeFile(const char *name, int game, bool v3)

  1006 {

  1007 	FILE *f = fopen(name, "rb");

  1008 	if (!f)

  1009 		return false;

  1010 

  1011 	int games = 0;

  1012 	int len   = 0;

  1013 	fseek(f, 0x1e, SEEK_CUR);

  1014 	fread(&games, 1, 4, f);

  1015 	bool found = false;

  1016 	int  g     = 0;

  1017 	while (games > 0)

  1018 	{

  1019 		if (g == game)

  1020 		{

  1021 			found = true;

  1022 			break;

  1023 		}

  1024 		fread(&len, 1, 4, f);

  1025 		fseek(f, len, SEEK_CUR);

  1026 		int codes = 0;

  1027 		fread(&codes, 1, 4, f);

  1028 		while (codes > 0)

  1029 		{

  1030 			fread(&len, 1, 4, f);

  1031 			fseek(f, len, SEEK_CUR);

  1032 			fseek(f, 8, SEEK_CUR);

  1033 			fread(&len, 1, 4, f);

  1034 			fseek(f, len*12, SEEK_CUR);

  1035 			codes--;

  1036 		}

  1037 		games--;

  1038 		g++;

  1039 	}

  1040 	if (found)

  1041 	{

  1042 		char desc[256];

  1043 		char code[17];

  1044 		fread(&len, 1, 4, f);

  1045 		fseek(f, len, SEEK_CUR);

  1046 		int codes = 0;

  1047 		fread(&codes, 1, 4, f);

  1048 		while (codes > 0)

  1049 		{

  1050 			fread(&len, 1, 4, f);

  1051 			fread(desc, 1, len, f);

  1052 			desc[len] = 0;

  1053 			desc[31]  = 0;

  1054 			fread(&len, 1, 4, f);

  1055 			fseek(f, len, SEEK_CUR);

  1056 			fseek(f, 4, SEEK_CUR);

  1057 			fread(&len, 1, 4, f);

  1058 			while (len)

  1059 			{

  1060 				fseek(f, 4, SEEK_CUR);

  1061 				fread(code, 1, 8, f);

  1062 				fseek(f, 4, SEEK_CUR);

  1063 				fread(&code[8], 1, 8, f);

  1064 				code[16] = 0;

  1065 				cheatsAddGSACode(code, desc, v3);

  1066 				len -= 2;

  1067 			}

  1068 			codes--;

  1069 		}

  1070 	}

  1071 	fclose(f);

  1072 	return false;

  1073 }

  1074 

  1075 void cheatsCBAReverseArray(u8 *array, u8 *dest)

  1076 {

  1077 	dest[0] = array[3];

  1078 	dest[1] = array[2];

  1079 	dest[2] = array[1];

  1080 	dest[3] = array[0];

  1081 	dest[4] = array[5];

  1082 	dest[5] = array[4];

  1083 }

  1084 

  1085 void chatsCBAScramble(u8 *array, int count, u8 b)

  1086 {

  1087 	u8 *x  = array + (count >> 3);

  1088 	u8 *y  = array + (b >> 3);

  1089 	u32 z  = *x & (1 << (count & 7));

  1090 	u32 x0 = (*x & (~(1 << (count & 7))));

  1091 	if (z != 0)

  1092 		z = 1;

  1093 	if ((*y & (1 << (b & 7))) != 0)

  1094 		x0 |= (1 << (count & 7));

  1095 	*x = x0;

  1096 	u32 temp = *y & (~(1 << (b & 7)));

  1097 	if (z != 0)

  1098 		temp |= (1 << (b & 7));

  1099 	*y = temp;

  1100 }

  1101 

  1102 u32 cheatsCBAGetValue(u8 *array)

  1103 {

  1104 	return array[0] | array[1]<<8 | array[2] << 16 | array[3]<<24;

  1105 }

  1106 

  1107 u16 cheatsCBAGetData(u8 *array)

  1108 {

  1109 	return array[4] | array[5]<<8;

  1110 }

  1111 

  1112 void cheatsCBAArrayToValue(u8 *array, u8 *dest)

  1113 {

  1114 	dest[0] = array[3];

  1115 	dest[1] = array[2];

  1116 	dest[2] = array[1];

  1117 	dest[3] = array[0];

  1118 	dest[4] = array[5];

  1119 	dest[5] = array[4];

  1120 }

  1121 

  1122 void cheatsCBAParseSeedCode(u32 address, u32 value, u32 *array)

  1123 {

  1124 	array[0] = 1;

  1125 	array[1] = value & 0xFF;

  1126 	array[2] = (address >> 0x10) & 0xFF;

  1127 	array[3] = (value >> 8) & 0xFF;

  1128 	array[4] = (address >> 0x18) & 0x0F;

  1129 	array[5] = address & 0xFFFF;

  1130 	array[6] = address;

  1131 	array[7] = value;

  1132 }

  1133 

  1134 u32 cheatsCBAEncWorker()

  1135 {

  1136 	u32 x = (cheatsCBATemporaryValue * 0x41c64e6d) + 0x3039;

  1137 	u32 y = (x * 0x41c64e6d) + 0x3039;

  1138 	u32 z = x >> 0x10;

  1139 	x = ((y >> 0x10) & 0x7fff) << 0x0f;

  1140 	z = (z << 0x1e) | x;

  1141 	x = (y * 0x41c64e6d) + 0x3039;

  1142 	cheatsCBATemporaryValue = x;

  1143 	return z | ((x >> 0x10) & 0x7fff);

  1144 }

  1145 

  1146 #define ROR(v, s) \

  1147     (((v) >> (s)) | (((v) & ((1 << (s))-1)) << (32 - (s))))

  1148 

  1149 u32 cheatsCBACalcIndex(u32 x, u32 y)

  1150 {

  1151 	if (y != 0)

  1152 	{

  1153 		if (y == 1)

  1154 			x = 0;

  1155 		else if (x == y)

  1156 			x = 0;

  1157 		if (y < 1)

  1158 			return x;

  1159 		else if (x < y)

  1160 			return x;

  1161 		u32 x0 = 1;

  1162 

  1163 		while (y < 0x10000000)

  1164 		{

  1165 			if (y < x)

  1166 			{

  1167 				y  = y << 4;

  1168 				x0 = x0 << 4;

  1169 			}

  1170 			else

  1171 				break;

  1172 		}

  1173 

  1174 		while (y < 0x80000000)

  1175 		{

  1176 			if (y < x)

  1177 			{

  1178 				y  = y << 1;

  1179 				x0 = x0 << 1;

  1180 			}

  1181 			else

  1182 				break;

  1183 		}

  1184 

  1185 loop:

  1186 		u32 z = 0;

  1187 		if (x >= y)

  1188 			x -= y;

  1189 		if (x >= (y >> 1))

  1190 		{

  1191 			x -= (y >> 1);

  1192 			z |= ROR(x0, 1);

  1193 		}

  1194 		if (x >= (y >> 2))

  1195 		{

  1196 			x -= (y >> 2);

  1197 			z |= ROR(x0, 2);

  1198 		}

  1199 		if (x >= (y >> 3))

  1200 		{

  1201 			x -= (y >> 3);

  1202 			z |= ROR(x0, 3);

  1203 		}

  1204 

  1205 		u32 temp = x0;

  1206 

  1207 		if (x != 0)

  1208 		{

  1209 			x0 = x0 >> 4;

  1210 			if (x0 != 0)

  1211 			{

  1212 				y = y >> 4;

  1213 				goto loop;

  1214 			}

  1215 		}

  1216 

  1217 		z = z & 0xe0000000;

  1218 

  1219 		if (z != 0)

  1220 		{

  1221 			if ((temp & 7) == 0)

  1222 				return x;

  1223 		}

  1224 		else

  1225 			return x;

  1226 

  1227 		if ((z & ROR(temp, 3)) != 0)

  1228 			x += y >> 3;

  1229 		if ((z & ROR(temp, 2)) != 0)

  1230 			x += y >> 2;

  1231 		if ((z & ROR(temp, 1)) != 0)

  1232 			x += y >> 1;

  1233 		return x;

  1234 	}

  1235 	else

  1236 	{}

  1237 	// should not happen in the current code

  1238 	return 0;

  1239 }

  1240 

  1241 void cheatsCBAUpdateSeedBuffer(u32 a, u8 *buffer, int count)

  1242 {

  1243 	int i;

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

  1245 		buffer[i] = i;

  1246 	for (i = 0; (u32)i < a; i++)

  1247 	{

  1248 		u32 a = cheatsCBACalcIndex(cheatsCBAEncWorker(), count);

  1249 		u32 b = cheatsCBACalcIndex(cheatsCBAEncWorker(), count);

  1250 		u32 t = buffer[a];

  1251 		buffer[a] = buffer[b];

  1252 		buffer[b] = t;

  1253 	}

  1254 }

  1255 

  1256 void cheatsCBAChangeEncryption(u32 *seed)

  1257 {

  1258 	int i;

  1259 

  1260 	cheatsCBATemporaryValue = (seed[1] ^ 0x1111);

  1261 	cheatsCBAUpdateSeedBuffer(0x50, cheatsCBASeedBuffer, 0x30);

  1262 	cheatsCBATemporaryValue = 0x4efad1c3;

  1263 

  1264 	for (i = 0; (u32)i < seed[4]; i++)

  1265 	{

  1266 		cheatsCBATemporaryValue = cheatsCBAEncWorker();

  1267 	}

  1268 	cheatsCBASeed[2] = cheatsCBAEncWorker();

  1269 	cheatsCBASeed[3] = cheatsCBAEncWorker();

  1270 

  1271 	cheatsCBATemporaryValue = seed[3] ^ 0xf254;

  1272 

  1273 	for (i = 0; (u32)i < seed[3]; i++)

  1274 	{

  1275 		cheatsCBATemporaryValue = cheatsCBAEncWorker();

  1276 	}

  1277 

  1278 	cheatsCBASeed[0] = cheatsCBAEncWorker();

  1279 	cheatsCBASeed[1] = cheatsCBAEncWorker();

  1280 

  1281 	*((u32 *)&cheatsCBACurrentSeed[0]) = seed[6];

  1282 	*((u32 *)&cheatsCBACurrentSeed[4]) = seed[7];

  1283 	*((u32 *)&cheatsCBACurrentSeed[8]) = 0;

  1284 }

  1285 

  1286 u16 cheatsCBAGenValue(u32 x, u32 y, u32 z)

  1287 {

  1288 	y <<= 0x10;

  1289 	z <<= 0x10;

  1290 	x <<= 0x18;

  1291 	u32 x0 = (int)y >> 0x10;

  1292 	z = (int)z >> 0x10;

  1293 	x = (int)x >> 0x10;

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

  1295 	{

  1296 		u32 temp = z ^ x;

  1297 		if ((int)temp >= 0)

  1298 		{

  1299 			temp = z << 0x11;

  1300 		}

  1301 		else

  1302 		{

  1303 			temp  = z << 0x01;

  1304 			temp ^= x0;

  1305 			temp  = temp << 0x10;

  1306 		}

  1307 		z    = (int)temp >> 0x10;

  1308 		temp = x << 0x11;

  1309 		x    = (int)temp >> 0x10;

  1310 	}

  1311 	return z & 0xffff;

  1312 }

  1313 

  1314 void cheatsCBAGenTable()

  1315 {

  1316 	for (int i = 0; i < 0x100; i++)

  1317 	{

  1318 		cheatsCBATable[i] = cheatsCBAGenValue(i, 0x1021, 0);

  1319 	}

  1320 	cheatsCBATableGenerated = true;

  1321 }

  1322 

  1323 u16 cheatsCBACalcCRC(u8 *rom, int count)

  1324 {

  1325 	u32 crc = 0xffffffff;

  1326 

  1327 	if (count & 3)

  1328 	{

  1329 		// 0x08000EAE

  1330 	}

  1331 	else

  1332 	{

  1333 		count = (count >> 2) - 1;

  1334 		if (count != -1)

  1335 		{

  1336 			while (count != -1)

  1337 			{

  1338 				crc = (((crc << 0x08) ^ cheatsCBATable[(((u32)crc << 0x10) >> 0x18)

  1339 				                                       ^ *rom++]) << 0x10) >> 0x10;

  1340 				crc = (((crc << 0x08) ^ cheatsCBATable[(((u32)crc << 0x10) >> 0x18)

  1341 				                                       ^ *rom++]) << 0x10) >> 0x10;

  1342 				crc = (((crc << 0x08) ^ cheatsCBATable[(((u32)crc << 0x10) >> 0x18)

  1343 				                                       ^ *rom++]) << 0x10) >> 0x10;

  1344 				crc = (((crc << 0x08) ^ cheatsCBATable[(((u32)crc << 0x10) >> 0x18)

  1345 				                                       ^ *rom++]) << 0x10) >> 0x10;

  1346 				count--;

  1347 			}

  1348 		}

  1349 	}

  1350 	return crc & 0xffff;

  1351 }

  1352 

  1353 void cheatsCBADecrypt(u8 *decrypt)

  1354 {

  1355 	u8  buffer[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };

  1356 	u8 *array     = &buffer[1];

  1357 

  1358 	cheatsCBAReverseArray(decrypt, array);

  1359 

  1360 	for (int count = 0x2f; count >= 0; count--)

  1361 	{

  1362 		chatsCBAScramble(array, count, cheatsCBASeedBuffer[count]);

  1363 	}

  1364 	cheatsCBAArrayToValue(array, decrypt);

  1365 	*((u32 *)decrypt) = cheatsCBAGetValue(decrypt) ^

  1366 	                    cheatsCBASeed[0];

  1367 	*((u16 *)(decrypt+4)) = (cheatsCBAGetData(decrypt) ^

  1368 	                         cheatsCBASeed[1]) & 0xffff;

  1369 

  1370 	cheatsCBAReverseArray(decrypt, array);

  1371 

  1372 	u32 cs = cheatsCBAGetValue(cheatsCBACurrentSeed);

  1373 	for (int i = 0; i <= 4; i++)

  1374 	{

  1375 		array[i] = ((cs >> 8) ^ array[i+1]) ^ array[i] ;

  1376 	}

  1377 

  1378 	array[5] = (cs >> 8) ^ array[5];

  1379 

  1380 	for (int j = 5; j >= 0; j--)

  1381 	{

  1382 		array[j] = (cs ^ array[j-1]) ^ array[j];

  1383 	}

  1384 

  1385 	cheatsCBAArrayToValue(array, decrypt);

  1386 

  1387 	*((u32 *)decrypt) = cheatsCBAGetValue(decrypt)

  1388 	                    ^ cheatsCBASeed[2];

  1389 	*((u16 *)(decrypt+4)) = (cheatsCBAGetData(decrypt)

  1390 	                         ^ cheatsCBASeed[3]) & 0xffff;

  1391 }

  1392 

  1393 int cheatsCBAGetCount()

  1394 {

  1395 	int count = 0;

  1396 	for (int i = 0; i < cheatsNumber; i++)

  1397 	{

  1398 		if (cheatsList[i].code == 512)

  1399 			count++;

  1400 	}

  1401 	return count;

  1402 }

  1403 

  1404 bool cheatsCBAShouldDecrypt()

  1405 {

  1406 	for (int i = 0; i < cheatsNumber; i++)

  1407 	{

  1408 		if (cheatsList[i].code == 512)

  1409 		{

  1410 			return (cheatsList[i].codestring[0] == '9');

  1411 		}

  1412 	}

  1413 	return false;

  1414 }

  1415 

  1416 void cheatsAddCBACode(const char *code, const char *desc)

  1417 {

  1418 	if (strlen(code) != 13)

  1419 	{

  1420 		// wrong cheat

  1421 		systemMessage(MSG_INVALID_CBA_CODE,

  1422 		              N_("Invalid CBA code. Format is XXXXXXXX YYYY."));

  1423 		return;

  1424 	}

  1425 

  1426 	int i;

  1427 	for (i = 0; i < 8; i++)

  1428 	{

  1429 		if (!CHEAT_IS_HEX(code[i]))

  1430 		{

  1431 			// wrong cheat

  1432 			systemMessage(MSG_INVALID_CBA_CODE,

  1433 			              N_("Invalid CBA code. Format is XXXXXXXX YYYY."));

  1434 			return;

  1435 		}

  1436 	}

  1437 

  1438 	if (code[8] != ' ')

  1439 	{

  1440 		systemMessage(MSG_INVALID_CBA_CODE,

  1441 		              N_("Invalid CBA code. Format is XXXXXXXX YYYY."));

  1442 		return;

  1443 	}

  1444 

  1445 	for (i = 9; i < 13; i++)

  1446 	{

  1447 		if (!CHEAT_IS_HEX(code[i]))

  1448 		{

  1449 			// wrong cheat

  1450 			systemMessage(MSG_INVALID_CBA_CODE,

  1451 			              N_("Invalid CBA code. Format is XXXXXXXX YYYY."));

  1452 			return;

  1453 		}

  1454 	}

  1455 

  1456 	char buffer[10];

  1457 	strncpy(buffer, code, 8);

  1458 	buffer[8] = 0;

  1459 	u32 address;

  1460 	sscanf(buffer, "%x", &address);

  1461 	strncpy(buffer, &code[9], 4);

  1462 	buffer[4] = 0;

  1463 	u32 value;

  1464 	sscanf(buffer, "%x", &value);

  1465 

  1466 	u8 array[8] = {

  1467 		address &255,

  1468 		(address >> 8) & 255,

  1469 		(address >> 16) & 255,

  1470 		(address >> 24) & 255,

  1471 		(value & 255),

  1472 		(value >> 8) & 255,

  1473 		0,

  1474 		0

  1475 	};

  1476 

  1477 	if (cheatsCBAGetCount() == 0 &&

  1478 	    (address >> 28) == 9)

  1479 	{

  1480 		u32 seed[8];

  1481 		cheatsCBAParseSeedCode(address, value, seed);

  1482 		cheatsCBAChangeEncryption(seed);

  1483 		cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512, UNKNOWN_CODE);

  1484 	}

  1485 	else

  1486 	{

  1487 		if (cheatsCBAShouldDecrypt())

  1488 			cheatsCBADecrypt(array);

  1489 

  1490 		address = READ32LE(((u32 *)array));

  1491 		value   = READ16LE(((u16 *)&array[4]));

  1492 

  1493 		int type = (address >> 28) & 15;

  1494 

  1495 		if (isMultilineWithData(cheatsNumber-1))

  1496 		{

  1497 			cheatsAdd(code, desc, address, value, 512, UNKNOWN_CODE);

  1498 			return;

  1499 		}

  1500 

  1501 		switch (type)

  1502 		{

  1503 		case 0x00:

  1504 		{

  1505 			if (!cheatsCBATableGenerated)

  1506 				cheatsCBAGenTable();

  1507 			u32 crc = cheatsCBACalcCRC(rom, 0x10000);

  1508 			if (crc != address)

  1509 			{

  1510 				systemMessage(MSG_CBA_CODE_WARNING,

  1511 				              N_("Warning: Codes seem to be for a different game.\nCodes may not work correctly."));

  1512 			}

  1513 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1514 			          UNKNOWN_CODE);

  1515 			break;

  1516 		}

  1517 		case 0x02:

  1518 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1519 			          CBA_OR);

  1520 			break;

  1521 		case 0x03:

  1522 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1523 			          INT_8_BIT_WRITE);

  1524 			break;

  1525 		case 0x04:

  1526 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1527 			          CBA_SLIDE_CODE);

  1528 			break;

  1529 		case 0x05:

  1530 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1531 			          CBA_SUPER);

  1532 			break;

  1533 		case 0x06:

  1534 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1535 			          CBA_AND);

  1536 			break;

  1537 		case 0x07:

  1538 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1539 			          CBA_IF_TRUE);

  1540 			break;

  1541 		case 0x08:

  1542 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1543 			          INT_16_BIT_WRITE);

  1544 			break;

  1545 		case 0x0a:

  1546 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1547 			          CBA_IF_FALSE);

  1548 			break;

  1549 		case 0x0b:

  1550 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1551 			          CBA_LT);

  1552 			break;

  1553 		case 0x0c:

  1554 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1555 			          CBA_GT);

  1556 			break;

  1557 		case 0x0d:

  1558 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1559 			          CBA_IF_KEYS_PRESSED);

  1560 			break;

  1561 		case 0x0e:

  1562 			cheatsAdd(code, desc, address & 0x0FFFFFFF, value, 512,

  1563 			          CBA_ADD);

  1564 			break;

  1565 		default:

  1566 			// unsupported code

  1567 			cheatsAdd(code, desc, address & 0xFFFFFFFF, value, 512,

  1568 			          UNKNOWN_CODE);

  1569 			break;

  1570 		}

  1571 	}

  1572 }

  1573 

  1574 void cheatsSaveGame(gzFile file)

  1575 {

  1576 	utilWriteInt(file, cheatsNumber);

  1577 

  1578 	utilGzWrite(file, cheatsList, sizeof(cheatsList));

  1579 }

  1580 

  1581 void cheatsReadGame(gzFile file)

  1582 {

  1583 	cheatsNumber = 0;

  1584 

  1585 	cheatsNumber = utilReadInt(file);

  1586 

  1587 	utilGzRead(file, cheatsList, sizeof(cheatsList));

  1588 

  1589 	bool firstCodeBreaker = true;

  1590 

  1591 	for (int i = 0; i < cheatsNumber; i++)

  1592 	{

  1593 		cheatsList[i].status = 0;

  1594 		if (!cheatsList[i].codestring[0])

  1595 		{

  1596 			switch (cheatsList[i].size)

  1597 			{

  1598 			case 0:

  1599 				sprintf(cheatsList[i].codestring, "%08x:%02x", cheatsList[i].address,

  1600 				        cheatsList[i].value);

  1601 				break;

  1602 			case 1:

  1603 				sprintf(cheatsList[i].codestring, "%08x:%04x", cheatsList[i].address,

  1604 				        cheatsList[i].value);

  1605 				break;

  1606 			case 2:

  1607 				sprintf(cheatsList[i].codestring, "%08x:%08x", cheatsList[i].address,

  1608 				        cheatsList[i].value);

  1609 				break;

  1610 			}

  1611 		}

  1612 

  1613 		if (cheatsList[i].enabled)

  1614 		{

  1615 			cheatsEnable(i);

  1616 		}

  1617 

  1618 		if (cheatsList[i].code == 512 && firstCodeBreaker)

  1619 		{

  1620 			firstCodeBreaker = false;

  1621 			char buffer[10];

  1622 			strncpy(buffer, cheatsList[i].codestring, 8);

  1623 			buffer[8] = 0;

  1624 			u32 address;

  1625 			sscanf(buffer, "%x", &address);

  1626 			if ((address >> 28) == 9)

  1627 			{

  1628 				strncpy(buffer, &cheatsList[i].codestring[9], 4);

  1629 				buffer[4] = 0;

  1630 				u32 value;

  1631 				sscanf(buffer, "%x", &value);

  1632 

  1633 				u32 seed[8];

  1634 				cheatsCBAParseSeedCode(address, value, seed);

  1635 				cheatsCBAChangeEncryption(seed);

  1636 			}

  1637 		}

  1638 	}

  1639 }

  1640 

  1641 void cheatsSaveCheatList(const char *file)

  1642 {

  1643 	if (cheatsNumber == 0)

  1644 		return;

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

  1646 	if (f == NULL)

  1647 		return;

  1648 	int version = 1;

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

  1650 	int type = 0;

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

  1652 	fwrite(&cheatsNumber, 1, sizeof(cheatsNumber), f);

  1653 	fwrite(cheatsList, 1, sizeof(cheatsList), f);

  1654 	fclose(f);

  1655 }

  1656 

  1657 bool cheatsLoadCheatList(const char *file)

  1658 {

  1659 	cheatsNumber = 0;

  1660 

  1661 	int count = 0;

  1662 

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

  1664 

  1665 	if (f == NULL)

  1666 		return false;

  1667 

  1668 	int version = 0;

  1669 

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

  1671 	{

  1672 		fclose(f);

  1673 		return false;

  1674 	}

  1675 

  1676 	if (version != 1)

  1677 	{

  1678 		systemMessage(MSG_UNSUPPORTED_CHEAT_LIST_VERSION,

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

  1680 		fclose(f);

  1681 		return false;

  1682 	}

  1683 

  1684 	int type = 0;

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

  1686 	{

  1687 		fclose(f);

  1688 		return false;

  1689 	}

  1690 

  1691 	if (type != 0)

  1692 	{

  1693 		systemMessage(MSG_UNSUPPORTED_CHEAT_LIST_TYPE,

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

  1695 		fclose(f);

  1696 		return false;

  1697 	}

  1698 

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

  1700 	{

  1701 		fclose(f);

  1702 		return false;

  1703 	}

  1704 

  1705 	if (fread(cheatsList, 1, sizeof(cheatsList), f) != sizeof(cheatsList))

  1706 	{

  1707 		fclose(f);

  1708 		return false;

  1709 	}

  1710 

  1711 	bool firstCodeBreaker = true;

  1712 

  1713 	for (int i = 0; i < count; i++)

  1714 	{

  1715 		cheatsList[i].status = 0; // remove old status as it is not used

  1716 		if (!cheatsList[i].codestring[0])

  1717 		{

  1718 			switch (cheatsList[i].size)

  1719 			{

  1720 			case 0:

  1721 				sprintf(cheatsList[i].codestring, "%08x:%02x", cheatsList[i].address,

  1722 				        cheatsList[i].value);

  1723 				break;

  1724 			case 1:

  1725 				sprintf(cheatsList[i].codestring, "%08x:%04x", cheatsList[i].address,

  1726 				        cheatsList[i].value);

  1727 				break;

  1728 			case 2:

  1729 				sprintf(cheatsList[i].codestring, "%08x:%08x", cheatsList[i].address,

  1730 				        cheatsList[i].value);

  1731 				break;

  1732 			}

  1733 		}

  1734 

  1735 		if (cheatsList[i].code == 512 && firstCodeBreaker)

  1736 		{

  1737 			firstCodeBreaker = false;

  1738 			char buffer[10];

  1739 			strncpy(buffer, cheatsList[i].codestring, 8);

  1740 			buffer[8] = 0;

  1741 			u32 address;

  1742 			sscanf(buffer, "%x", &address);

  1743 			if ((address >> 28) == 9)

  1744 			{

  1745 				strncpy(buffer, &cheatsList[i].codestring[9], 4);

  1746 				buffer[4] = 0;

  1747 				u32 value;

  1748 				sscanf(buffer, "%x", &value);

  1749 

  1750 				u32 seed[8];

  1751 				cheatsCBAParseSeedCode(address, value, seed);

  1752 				cheatsCBAChangeEncryption(seed);

  1753 			}

  1754 		}

  1755 	}

  1756 	cheatsNumber = count;

  1757 	fclose(f);

  1758 	return true;

  1759 }

  1760 

  1761 extern int *extCpuLoopTicks;

  1762 extern int *extClockTicks;

  1763 extern int *extTicks;

  1764 extern int  cpuSavedTicks;

  1765 

  1766 extern void debuggerBreakOnWrite(u32 *, u32, u32, int);

  1767 

  1768 #define CPU_BREAK_LOOP2 \

  1769     cpuSavedTicks    = cpuSavedTicks - *extCpuLoopTicks; \

  1770     *extCpuLoopTicks = *extClockTicks; \

  1771     *extTicks        = *extClockTicks;

  1772 

  1773 void cheatsWriteMemory(u32 *address, u32 value, u32 mask)

  1774 {

  1775 #ifdef BKPT_SUPPORT

  1776 #ifdef SDL

  1777 	if (cheatsNumber == 0)

  1778 	{

  1779 		debuggerBreakOnWrite(address, *address, value, 2);

  1780 		CPU_BREAK_LOOP2;

  1781 		*address = value;

  1782 		return;

  1783 	}

  1784 #endif

  1785 #endif

  1786 }

  1787 

  1788 void cheatsWriteHalfWord(u16 *address, u16 value, u16 mask)

  1789 {

  1790 #ifdef BKPT_SUPPORT

  1791 #ifdef SDL

  1792 	if (cheatsNumber == 0)

  1793 	{

  1794 		debuggerBreakOnWrite((u32 *)address, *address, value, 1);

  1795 		CPU_BREAK_LOOP2;

  1796 		*address = value;

  1797 		return;

  1798 	}

  1799 #endif

  1800 #endif

  1801 }

  1802 

  1803 #if defined BKPT_SUPPORT && defined SDL

  1804 void cheatsWriteByte(u8 *address, u8 value)

  1805 #else

  1806 void cheatsWriteByte(u8 *, u8)

  1807 #endif

  1808 {

  1809 #ifdef BKPT_SUPPORT

  1810 #ifdef SDL

  1811 	if (cheatsNumber == 0)

  1812 	{

  1813 		debuggerBreakOnWrite((u32 *)address, *address, value, 0);

  1814 		CPU_BREAK_LOOP2;

  1815 		*address = value;

  1816 		return;

  1817 	}

  1818 #endif

  1819 #endif

  1820 }

  1821 

  1822 #undef CPU_BREAK_LOOP2
author	Robert McIntyre <rlm@mit.edu>
date	Fri, 31 Aug 2012 09:22:52 -0500
parents	f9f4f1b99eed
children