raspberry pi port
[gpsp.git] / cheats.c
1 /* gameplaySP
2  *
3  * Copyright (C) 2006 Exophase <exophase@gmail.com>
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation; either version 2 of
8  * the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18  */
19
20 #include "common.h"
21
22 cheat_type cheats[MAX_CHEATS];
23 u32 num_cheats;
24
25 void decrypt_gsa_code(u32 *address_ptr, u32 *value_ptr, cheat_variant_enum
26  cheat_variant)
27 {
28   u32 i;
29   u32 address = *address_ptr;
30   u32 value = *value_ptr;
31   u32 r = 0xc6ef3720;
32
33   u32 seeds_v1[4] =
34   {
35     0x09f4fbbd, 0x9681884a, 0x352027e9, 0xf3dee5a7
36   };
37   u32 seeds_v3[4] =
38   {
39     0x7aa9648f, 0x7fae6994, 0xc0efaad5, 0x42712c57
40   };
41   u32 *seeds;
42
43   if(cheat_variant == CHEAT_TYPE_GAMESHARK_V1)
44     seeds = seeds_v1;
45   else
46     seeds = seeds_v3;
47
48   for(i = 0; i < 32; i++)
49   {
50     value -= ((address << 4) + seeds[2]) ^ (address + r) ^
51      ((address >> 5) + seeds[3]);
52     address -= ((value << 4) + seeds[0]) ^ (value + r) ^
53      ((value >> 5) + seeds[1]);
54     r -= 0x9e3779b9;
55   }
56
57   *address_ptr = address;
58   *value_ptr = value;
59 }
60
61 void add_cheats(char *cheats_filename)
62 {
63   FILE *cheats_file;
64   char current_line[256];
65   char *name_ptr;
66   u32 *cheat_code_ptr;
67   u32 address, value;
68   u32 num_cheat_lines;
69   u32 cheat_name_length;
70   cheat_variant_enum current_cheat_variant;
71
72   num_cheats = 0;
73
74   cheats_file = fopen(cheats_filename, "rb");
75
76   if(cheats_file)
77   {
78     while(fgets(current_line, 256, cheats_file))
79     {
80       // Get the header line first
81       name_ptr = strchr(current_line, ' ');
82       if(name_ptr)
83       {
84         *name_ptr = 0;
85         name_ptr++;
86       }
87
88       if(!strcasecmp(current_line, "gameshark_v1") ||
89        !strcasecmp(current_line, "gameshark_v2") ||
90        !strcasecmp(current_line, "PAR_v1") ||
91        !strcasecmp(current_line, "PAR_v2"))
92       {
93         current_cheat_variant = CHEAT_TYPE_GAMESHARK_V1;
94       }
95       else
96
97       if(!strcasecmp(current_line, "gameshark_v3") ||
98        !strcasecmp(current_line, "PAR_v3"))
99       {
100         current_cheat_variant = CHEAT_TYPE_GAMESHARK_V3;
101       }
102       else
103       {
104         current_cheat_variant = CHEAT_TYPE_INVALID;
105       }
106
107       if(current_cheat_variant != CHEAT_TYPE_INVALID)
108       {
109         strncpy(cheats[num_cheats].cheat_name, name_ptr, CHEAT_NAME_LENGTH - 1);
110         cheats[num_cheats].cheat_name[CHEAT_NAME_LENGTH - 1] = 0;
111         cheat_name_length = strlen(cheats[num_cheats].cheat_name);
112         if(cheat_name_length &&
113          ((cheats[num_cheats].cheat_name[cheat_name_length - 1] == '\n') ||
114           (cheats[num_cheats].cheat_name[cheat_name_length - 1] == '\r')))
115         {
116           cheats[num_cheats].cheat_name[cheat_name_length - 1] = 0;
117           cheat_name_length--;
118         }
119
120         if(cheat_name_length &&
121          cheats[num_cheats].cheat_name[cheat_name_length - 1] == '\r')
122         {
123           cheats[num_cheats].cheat_name[cheat_name_length - 1] = 0;
124         }
125
126         cheats[num_cheats].cheat_variant = current_cheat_variant;
127         cheat_code_ptr = cheats[num_cheats].cheat_codes;
128         num_cheat_lines = 0;
129
130         while(fgets(current_line, 256, cheats_file))
131         {
132           if(strlen(current_line) < 3)
133             break;
134
135           sscanf(current_line, "%08x %08x", &address, &value);
136
137           decrypt_gsa_code(&address, &value, current_cheat_variant);
138
139           cheat_code_ptr[0] = address;
140           cheat_code_ptr[1] = value;
141
142           cheat_code_ptr += 2;
143           num_cheat_lines++;
144         }
145
146         cheats[num_cheats].num_cheat_lines = num_cheat_lines;
147
148         num_cheats++;
149       }
150     }
151
152     fclose(cheats_file);
153   }
154 }
155
156 void process_cheat_gs1(cheat_type *cheat)
157 {
158   u32 cheat_opcode;
159   u32 *code_ptr = cheat->cheat_codes;
160   u32 address, value;
161   u32 i;
162
163   for(i = 0; i < cheat->num_cheat_lines; i++)
164   {
165     address = code_ptr[0];
166     value = code_ptr[1];
167
168     code_ptr += 2;
169
170     cheat_opcode = address >> 28;
171     address &= 0xFFFFFFF;
172
173     switch(cheat_opcode)
174     {
175       case 0x0:
176         write_memory8(address, value);
177         break;
178
179       case 0x1:
180         write_memory16(address, value);
181         break;
182
183       case 0x2:
184         write_memory32(address, value);
185         break;
186
187       case 0x3:
188       {
189         u32 num_addresses = address & 0xFFFF;
190         u32 address1, address2;
191         u32 i2;
192
193         for(i2 = 0; i2 < num_addresses; i2++)
194         {
195           address1 = code_ptr[0];
196           address2 = code_ptr[1];
197           code_ptr += 2;
198           i++;
199
200           write_memory32(address1, value);
201           if(address2 != 0)
202             write_memory32(address2, value);
203         }
204         break;
205       }
206
207       // ROM patch not supported yet
208       case 0x6:
209         break;
210
211       // GS button down not supported yet
212       case 0x8:
213         break;
214
215       // Reencryption (DEADFACE) not supported yet
216       case 0xD:
217         if(read_memory16(address) != (value & 0xFFFF))
218         {
219           code_ptr += 2;
220           i++;
221         }
222         break;
223
224       case 0xE:
225         if(read_memory16(value & 0xFFFFFFF) != (address & 0xFFFF))
226         {
227           u32 skip = ((address >> 16) & 0x03);
228           code_ptr += skip * 2;
229           i += skip;
230         }
231         break;
232
233       // Hook routine not supported yet (not important??)
234       case 0x0F:
235         break;
236     }
237   }
238 }
239
240 // These are especially incomplete.
241
242 void process_cheat_gs3(cheat_type *cheat)
243 {
244   u32 cheat_opcode;
245   u32 *code_ptr = cheat->cheat_codes;
246   u32 address, value;
247   u32 i;
248
249   for(i = 0; i < cheat->num_cheat_lines; i++)
250   {
251     address = code_ptr[0];
252     value = code_ptr[1];
253
254     code_ptr += 2;
255
256     cheat_opcode = address >> 28;
257     address &= 0xFFFFFFF;
258
259     switch(cheat_opcode)
260     {
261       case 0x0:
262         cheat_opcode = address >> 24;
263         address = (address & 0xFFFFF) + ((address << 4) & 0xF000000);
264
265         switch(cheat_opcode)
266         {
267           case 0x0:
268           {
269             u32 iterations = value >> 24;
270             u32 i2;
271
272             value &= 0xFF;
273
274             for(i2 = 0; i2 <= iterations; i2++, address++)
275             {
276               write_memory8(address, value);
277             }
278             break;
279           }
280
281           case 0x2:
282           {
283             u32 iterations = value >> 16;
284             u32 i2;
285
286             value &= 0xFFFF;
287
288             for(i2 = 0; i2 <= iterations; i2++, address += 2)
289             {
290               write_memory16(address, value);
291             }
292             break;
293           }
294
295           case 0x4:
296             write_memory32(address, value);
297             break;
298         }
299         break;
300
301       case 0x4:
302         cheat_opcode = address >> 24;
303         address = (address & 0xFFFFF) + ((address << 4) & 0xF000000);
304
305         switch(cheat_opcode)
306         {
307           case 0x0:
308             address = read_memory32(address) + (value >> 24);
309             write_memory8(address, value & 0xFF);
310             break;
311
312           case 0x2:
313             address = read_memory32(address) + ((value >> 16) * 2);
314             write_memory16(address, value & 0xFFFF);
315             break;
316
317           case 0x4:
318             address = read_memory32(address);
319             write_memory32(address, value);
320             break;
321
322         }
323         break;
324
325       case 0x8:
326         cheat_opcode = address >> 24;
327         address = (address & 0xFFFFF) + ((address << 4) & 0xF000000);
328
329         switch(cheat_opcode)
330         {
331           case 0x0:
332             value = (value & 0xFF) + read_memory8(address);
333             write_memory8(address, value);
334             break;
335
336           case 0x2:
337             value = (value & 0xFFFF) + read_memory16(address);
338             write_memory16(address, value);
339             break;
340
341           case 0x4:
342             value = value + read_memory32(address);
343             write_memory32(address, value);
344             break;
345         }
346         break;
347
348       case 0xC:
349         cheat_opcode = address >> 24;
350         address = (address & 0xFFFFFF) + 0x4000000;
351
352         switch(cheat_opcode)
353         {
354           case 0x6:
355             write_memory16(address, value);
356             break;
357
358           case 0x7:
359             write_memory32(address, value);
360             break;
361         }
362         break;
363     }
364   }
365 }
366
367
368 void process_cheats()
369 {
370   u32 i;
371
372   for(i = 0; i < num_cheats; i++)
373   {
374     if(cheats[i].cheat_active)
375     {
376       switch(cheats[i].cheat_variant)
377       {
378         case CHEAT_TYPE_GAMESHARK_V1:
379           process_cheat_gs1(cheats + i);
380           break;
381
382         case CHEAT_TYPE_GAMESHARK_V3:
383           process_cheat_gs3(cheats + i);
384           break;
385
386         default:
387           break;
388       }
389     }
390   }
391 }