1 /* Cheat Support for PCSX-Reloaded
2 * Copyright (c) 2009, Wei Mingzhi <whistler_wmz@users.sf.net>.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA
19 #include "psxcommon.h"
27 int NumCheatsAllocated = 0;
29 CheatCode *CheatCodes = NULL;
31 int NumCodesAllocated = 0;
34 u32 *SearchResults = NULL;
35 int NumSearchResults = 0;
36 static int NumSearchResultsAllocated = 0;
38 #define ALLOC_INCREMENT 100
40 void ClearAllCheats() {
44 for (i = 0; i < NumCheats; i++) {
45 free(Cheats[i].Descr);
52 NumCheatsAllocated = 0;
54 if (CheatCodes != NULL) {
60 NumCodesAllocated = 0;
63 // load cheats from the specific filename
64 void LoadCheats(const char *filename) {
70 fp = fopen(filename, "r");
77 while (fgets(buf, 255, fp) != NULL) {
81 // Skip comment or blank lines
82 if (buf[0] == '#' || buf[0] == ';' || buf[0] == '/' || buf[0] == '\"' || buf[0] == '\0')
85 if (buf[0] == '[' && buf[strlen(buf) - 1] == ']') {
87 Cheats[NumCheats - 1].n = count;
89 if (NumCheats >= NumCheatsAllocated) {
90 NumCheatsAllocated += ALLOC_INCREMENT;
93 assert(NumCheats == 0);
94 assert(NumCheatsAllocated == ALLOC_INCREMENT);
95 Cheats = (Cheat *)malloc(sizeof(Cheat) * NumCheatsAllocated);
97 Cheats = (Cheat *)realloc(Cheats, sizeof(Cheat) * NumCheatsAllocated);
101 buf[strlen(buf) - 1] = '\0';
105 Cheats[NumCheats].Descr = strdup(buf + 2);
106 Cheats[NumCheats].Enabled = 1;
108 Cheats[NumCheats].Descr = strdup(buf + 1);
109 Cheats[NumCheats].Enabled = 0;
111 Cheats[NumCheats].WasEnabled = 0;
113 Cheats[NumCheats].First = NumCodes;
122 if (NumCodes >= NumCodesAllocated) {
123 NumCodesAllocated += ALLOC_INCREMENT;
125 if (CheatCodes == NULL) {
126 assert(NumCodes == 0);
127 assert(NumCodesAllocated == ALLOC_INCREMENT);
128 CheatCodes = (CheatCode *)malloc(sizeof(CheatCode) * NumCodesAllocated);
130 CheatCodes = (CheatCode *)realloc(CheatCodes, sizeof(CheatCode) * NumCodesAllocated);
134 sscanf(buf, "%x %x", &t1, &t2);
136 CheatCodes[NumCodes].Addr = t1;
137 CheatCodes[NumCodes].Val = t2;
144 Cheats[NumCheats - 1].n = count;
148 SysPrintf(_("Cheats loaded from: %s\n"), filename);
151 // save all cheats to the specified filename
152 void SaveCheats(const char *filename) {
156 fp = fopen(filename, "w");
161 for (i = 0; i < NumCheats; i++) {
162 // write the description
163 if (Cheats[i].Enabled)
164 fprintf(fp, "[*%s]\n", Cheats[i].Descr);
166 fprintf(fp, "[%s]\n", Cheats[i].Descr);
168 // write all cheat codes
169 for (j = 0; j < Cheats[i].n; j++) {
170 fprintf(fp, "%.8X %.4X\n",
171 CheatCodes[Cheats[i].First + j].Addr,
172 CheatCodes[Cheats[i].First + j].Val);
180 SysPrintf(_("Cheats saved to: %s\n"), filename);
183 // apply all enabled cheats
185 int i, j, k, endindex;
188 for (i = 0; i < NumCheats; i++) {
189 was_enabled = Cheats[i].WasEnabled;
190 if (!Cheats[i].Enabled) {
191 if (!Cheats[i].WasEnabled)
194 Cheats[i].WasEnabled = Cheats[i].Enabled;
196 // process all cheat codes
197 endindex = Cheats[i].First + Cheats[i].n;
199 for (j = Cheats[i].First; j < endindex; j++) {
200 u8 type = (uint8_t)(CheatCodes[j].Addr >> 24);
201 u32 addr = (CheatCodes[j].Addr & 0x001FFFFF);
202 u16 val = CheatCodes[j].Val;
208 CheatCodes[j].OldVal = psxMu16(addr);
211 CheatCodes[j].OldVal = psxMu8(addr);
215 else if (!Cheats[i].Enabled) {
216 val = CheatCodes[j].OldVal;
217 if (type != CHEAT_CONST16 && type != CHEAT_CONST8)
223 psxMu8ref(addr) = (u8)val;
227 psxMu16ref(addr) = SWAPu16(val);
231 psxMu16ref(addr) = SWAPu16(psxMu16(addr) + val);
235 psxMu16ref(addr) = SWAPu16(psxMu16(addr) - val);
239 psxMu8ref(addr) += (u8)val;
243 psxMu8ref(addr) -= (u8)val;
251 type = (uint8_t)(CheatCodes[j].Addr >> 24);
252 taddr = (CheatCodes[j].Addr & 0x001FFFFF);
253 val = CheatCodes[j].Val;
255 if (type == CHEAT_CONST8) {
256 for (k = 0; k < ((addr >> 8) & 0xFF); k++) {
257 psxMu8ref(taddr) = (u8)val;
258 taddr += (s8)(addr & 0xFF);
259 val += (s8)(CheatCodes[j - 1].Val & 0xFF);
262 else if (type == CHEAT_CONST16) {
263 for (k = 0; k < ((addr >> 8) & 0xFF); k++) {
264 psxMu16ref(taddr) = SWAPu16(val);
265 taddr += (s8)(addr & 0xFF);
266 val += (s8)(CheatCodes[j - 1].Val & 0xFF);
276 taddr = (CheatCodes[j].Addr & 0x001FFFFF);
277 for (k = 0; k < val; k++) {
278 psxMu8ref(taddr + k) = PSXMu8(addr + k);
283 if (PSXMu8(addr) != (u8)val)
284 j++; // skip the next code
288 if (PSXMu8(addr) == (u8)val)
289 j++; // skip the next code
292 case CHEAT_LESSTHAN8:
293 if (PSXMu8(addr) >= (u8)val)
294 j++; // skip the next code
297 case CHEAT_GREATERTHAN8:
298 if (PSXMu8(addr) <= (u8)val)
299 j++; // skip the next code
303 if (PSXMu16(addr) != val)
304 j++; // skip the next code
308 if (PSXMu16(addr) == val)
309 j++; // skip the next code
312 case CHEAT_LESSTHAN16:
313 if (PSXMu16(addr) >= val)
314 j++; // skip the next code
317 case CHEAT_GREATERTHAN16:
318 if (PSXMu16(addr) <= val)
319 j++; // skip the next code
326 int AddCheat(const char *descr, char *code) {
330 if (NumCheats >= NumCheatsAllocated) {
331 NumCheatsAllocated += ALLOC_INCREMENT;
333 if (Cheats == NULL) {
334 assert(NumCheats == 0);
335 assert(NumCheatsAllocated == ALLOC_INCREMENT);
336 Cheats = (Cheat *)malloc(sizeof(Cheat) * NumCheatsAllocated);
339 Cheats = (Cheat *)realloc(Cheats, sizeof(Cheat) * NumCheatsAllocated);
343 Cheats[NumCheats].Descr = strdup(descr[0] ? descr : _("(Untitled)"));
344 Cheats[NumCheats].Enabled = 0;
345 Cheats[NumCheats].WasEnabled = 0;
346 Cheats[NumCheats].First = NumCodes;
347 Cheats[NumCheats].n = 0;
355 while (*p2 != '\n' && *p2 != '\0')
366 sscanf(p1, "%x %x", &t1, &t2);
368 if (t1 > 0x10000000) {
369 if (NumCodes >= NumCodesAllocated) {
370 NumCodesAllocated += ALLOC_INCREMENT;
372 if (CheatCodes == NULL) {
373 assert(NumCodes == 0);
374 assert(NumCodesAllocated == ALLOC_INCREMENT);
375 CheatCodes = (CheatCode *)malloc(sizeof(CheatCode) * NumCodesAllocated);
378 CheatCodes = (CheatCode *)realloc(CheatCodes, sizeof(CheatCode) * NumCodesAllocated);
382 CheatCodes[NumCodes].Addr = t1;
383 CheatCodes[NumCodes].Val = t2;
385 Cheats[NumCheats].n++;
391 if (Cheats[NumCheats].n == 0) {
399 void RemoveCheat(int index) {
400 assert(index >= 0 && index < NumCheats);
402 free(Cheats[index].Descr);
404 while (index < NumCheats - 1) {
405 Cheats[index] = Cheats[index + 1];
412 int EditCheat(int index, const char *descr, char *code) {
417 assert(index >= 0 && index < NumCheats);
425 while (*p2 != '\n' && *p2 != '\0')
436 sscanf(p1, "%x %x", &t1, &t2);
438 if (t1 > 0x10000000) {
439 if (NumCodes >= NumCodesAllocated) {
440 NumCodesAllocated += ALLOC_INCREMENT;
442 if (CheatCodes == NULL) {
443 assert(NumCodes == 0);
444 assert(NumCodesAllocated == ALLOC_INCREMENT);
445 CheatCodes = (CheatCode *)malloc(sizeof(CheatCode) * NumCodesAllocated);
448 CheatCodes = (CheatCode *)realloc(CheatCodes, sizeof(CheatCode) * NumCodesAllocated);
452 CheatCodes[NumCodes].Addr = t1;
453 CheatCodes[NumCodes].Val = t2;
460 if (NumCodes == prev) {
464 free(Cheats[index].Descr);
465 Cheats[index].Descr = strdup(descr[0] ? descr : _("(Untitled)"));
466 Cheats[index].First = prev;
467 Cheats[index].n = NumCodes - prev;
472 void FreeCheatSearchResults() {
473 if (SearchResults != NULL) {
476 SearchResults = NULL;
478 NumSearchResults = 0;
479 NumSearchResultsAllocated = 0;
482 void FreeCheatSearchMem() {
489 void CheatSearchBackupMemory() {
491 memcpy(prevM, psxM, 0x200000);
495 static void CheatSearchInitBackupMemory() {
497 prevM = (s8 *)malloc(0x200000);
498 CheatSearchBackupMemory();
502 static void CheatSearchAddResult(u32 addr) {
503 if (NumSearchResults >= NumSearchResultsAllocated) {
504 NumSearchResultsAllocated += ALLOC_INCREMENT;
506 if (SearchResults == NULL) {
507 SearchResults = (u32 *)malloc(sizeof(u32) * NumSearchResultsAllocated);
510 SearchResults = (u32 *)realloc(SearchResults, sizeof(u32) * NumSearchResultsAllocated);
514 SearchResults[NumSearchResults++] = addr;
517 void CheatSearchEqual8(u8 val) {
520 CheatSearchInitBackupMemory();
522 if (SearchResults == NULL) {
523 // search the whole memory
524 for (i = 0; i < 0x200000; i++) {
525 if (PSXMu8(i) == val) {
526 CheatSearchAddResult(i);
531 // only search within the previous results
534 for (i = 0; i < NumSearchResults; i++) {
535 if (PSXMu8(SearchResults[i]) == val) {
536 SearchResults[j++] = SearchResults[i];
540 NumSearchResults = j;
544 void CheatSearchEqual16(u16 val) {
547 CheatSearchInitBackupMemory();
549 if (SearchResults == NULL) {
550 // search the whole memory
551 for (i = 0; i < 0x200000; i += 2) {
552 if (PSXMu16(i) == val) {
553 CheatSearchAddResult(i);
558 // only search within the previous results
561 for (i = 0; i < NumSearchResults; i++) {
562 if (PSXMu16(SearchResults[i]) == val) {
563 SearchResults[j++] = SearchResults[i];
567 NumSearchResults = j;
571 void CheatSearchEqual32(u32 val) {
574 CheatSearchInitBackupMemory();
576 if (SearchResults == NULL) {
577 // search the whole memory
578 for (i = 0; i < 0x200000; i += 4) {
579 if (PSXMu32(i) == val) {
580 CheatSearchAddResult(i);
585 // only search within the previous results
588 for (i = 0; i < NumSearchResults; i++) {
589 if (PSXMu32(SearchResults[i]) == val) {
590 SearchResults[j++] = SearchResults[i];
594 NumSearchResults = j;
598 void CheatSearchNotEqual8(u8 val) {
601 CheatSearchInitBackupMemory();
603 if (SearchResults == NULL) {
604 // search the whole memory
605 for (i = 0; i < 0x200000; i++) {
606 if (PSXMu8(i) != val) {
607 CheatSearchAddResult(i);
612 // only search within the previous results
615 for (i = 0; i < NumSearchResults; i++) {
616 if (PSXMu8(SearchResults[i]) != val) {
617 SearchResults[j++] = SearchResults[i];
621 NumSearchResults = j;
625 void CheatSearchNotEqual16(u16 val) {
628 CheatSearchInitBackupMemory();
630 if (SearchResults == NULL) {
631 // search the whole memory
632 for (i = 0; i < 0x200000; i += 2) {
633 if (PSXMu16(i) != val) {
634 CheatSearchAddResult(i);
639 // only search within the previous results
642 for (i = 0; i < NumSearchResults; i++) {
643 if (PSXMu16(SearchResults[i]) != val) {
644 SearchResults[j++] = SearchResults[i];
648 NumSearchResults = j;
652 void CheatSearchNotEqual32(u32 val) {
655 CheatSearchInitBackupMemory();
657 if (SearchResults == NULL) {
658 // search the whole memory
659 for (i = 0; i < 0x200000; i += 4) {
660 if (PSXMu32(i) != val) {
661 CheatSearchAddResult(i);
666 // only search within the previous results
669 for (i = 0; i < NumSearchResults; i++) {
670 if (PSXMu32(SearchResults[i]) != val) {
671 SearchResults[j++] = SearchResults[i];
675 NumSearchResults = j;
679 void CheatSearchRange8(u8 min, u8 max) {
682 CheatSearchInitBackupMemory();
684 if (SearchResults == NULL) {
685 // search the whole memory
686 for (i = 0; i < 0x200000; i++) {
687 if (PSXMu8(i) >= min && PSXMu8(i) <= max) {
688 CheatSearchAddResult(i);
693 // only search within the previous results
696 for (i = 0; i < NumSearchResults; i++) {
697 if (PSXMu8(SearchResults[i]) >= min && PSXMu8(SearchResults[i]) <= max) {
698 SearchResults[j++] = SearchResults[i];
702 NumSearchResults = j;
706 void CheatSearchRange16(u16 min, u16 max) {
709 CheatSearchInitBackupMemory();
711 if (SearchResults == NULL) {
712 // search the whole memory
713 for (i = 0; i < 0x200000; i += 2) {
714 if (PSXMu16(i) >= min && PSXMu16(i) <= max) {
715 CheatSearchAddResult(i);
720 // only search within the previous results
723 for (i = 0; i < NumSearchResults; i++) {
724 if (PSXMu16(SearchResults[i]) >= min && PSXMu16(SearchResults[i]) <= max) {
725 SearchResults[j++] = SearchResults[i];
729 NumSearchResults = j;
733 void CheatSearchRange32(u32 min, u32 max) {
736 CheatSearchInitBackupMemory();
738 if (SearchResults == NULL) {
739 // search the whole memory
740 for (i = 0; i < 0x200000; i += 4) {
741 if (PSXMu32(i) >= min && PSXMu32(i) <= max) {
742 CheatSearchAddResult(i);
747 // only search within the previous results
750 for (i = 0; i < NumSearchResults; i++) {
751 if (PSXMu32(SearchResults[i]) >= min && PSXMu32(SearchResults[i]) <= max) {
752 SearchResults[j++] = SearchResults[i];
756 NumSearchResults = j;
760 void CheatSearchIncreasedBy8(u8 val) {
763 assert(prevM != NULL); // not possible for the first search
767 for (i = 0; i < NumSearchResults; i++) {
768 if (PSXMu8(SearchResults[i]) - PrevMu8(SearchResults[i]) == val) {
769 SearchResults[j++] = SearchResults[i];
773 NumSearchResults = j;
776 void CheatSearchIncreasedBy16(u16 val) {
779 assert(prevM != NULL); // not possible for the first search
783 for (i = 0; i < NumSearchResults; i++) {
784 if (PSXMu16(SearchResults[i]) - PrevMu16(SearchResults[i]) == val) {
785 SearchResults[j++] = SearchResults[i];
789 NumSearchResults = j;
792 void CheatSearchIncreasedBy32(u32 val) {
795 assert(prevM != NULL); // not possible for the first search
799 for (i = 0; i < NumSearchResults; i++) {
800 if (PSXMu32(SearchResults[i]) - PrevMu32(SearchResults[i]) == val) {
801 SearchResults[j++] = SearchResults[i];
805 NumSearchResults = j;
808 void CheatSearchDecreasedBy8(u8 val) {
811 assert(prevM != NULL); // not possible for the first search
815 for (i = 0; i < NumSearchResults; i++) {
816 if (PrevMu8(SearchResults[i]) - PSXMu8(SearchResults[i]) == val) {
817 SearchResults[j++] = SearchResults[i];
821 NumSearchResults = j;
824 void CheatSearchDecreasedBy16(u16 val) {
827 assert(prevM != NULL); // not possible for the first search
831 for (i = 0; i < NumSearchResults; i++) {
832 if (PrevMu16(SearchResults[i]) - PSXMu16(SearchResults[i]) == val) {
833 SearchResults[j++] = SearchResults[i];
837 NumSearchResults = j;
840 void CheatSearchDecreasedBy32(u32 val) {
843 assert(prevM != NULL); // not possible for the first search
847 for (i = 0; i < NumSearchResults; i++) {
848 if (PrevMu32(SearchResults[i]) - PSXMu32(SearchResults[i]) == val) {
849 SearchResults[j++] = SearchResults[i];
853 NumSearchResults = j;
856 void CheatSearchIncreased8() {
859 assert(prevM != NULL); // not possible for the first search
863 for (i = 0; i < NumSearchResults; i++) {
864 if (PrevMu8(SearchResults[i]) < PSXMu8(SearchResults[i])) {
865 SearchResults[j++] = SearchResults[i];
869 NumSearchResults = j;
872 void CheatSearchIncreased16() {
875 assert(prevM != NULL); // not possible for the first search
879 for (i = 0; i < NumSearchResults; i++) {
880 if (PrevMu16(SearchResults[i]) < PSXMu16(SearchResults[i])) {
881 SearchResults[j++] = SearchResults[i];
885 NumSearchResults = j;
888 void CheatSearchIncreased32() {
891 assert(prevM != NULL); // not possible for the first search
895 for (i = 0; i < NumSearchResults; i++) {
896 if (PrevMu32(SearchResults[i]) < PSXMu32(SearchResults[i])) {
897 SearchResults[j++] = SearchResults[i];
901 NumSearchResults = j;
904 void CheatSearchDecreased8() {
907 assert(prevM != NULL); // not possible for the first search
911 for (i = 0; i < NumSearchResults; i++) {
912 if (PrevMu8(SearchResults[i]) > PSXMu8(SearchResults[i])) {
913 SearchResults[j++] = SearchResults[i];
917 NumSearchResults = j;
920 void CheatSearchDecreased16() {
923 assert(prevM != NULL); // not possible for the first search
927 for (i = 0; i < NumSearchResults; i++) {
928 if (PrevMu16(SearchResults[i]) > PSXMu16(SearchResults[i])) {
929 SearchResults[j++] = SearchResults[i];
933 NumSearchResults = j;
936 void CheatSearchDecreased32() {
939 assert(prevM != NULL); // not possible for the first search
943 for (i = 0; i < NumSearchResults; i++) {
944 if (PrevMu32(SearchResults[i]) > PSXMu32(SearchResults[i])) {
945 SearchResults[j++] = SearchResults[i];
949 NumSearchResults = j;
952 void CheatSearchDifferent8() {
955 assert(prevM != NULL); // not possible for the first search
959 for (i = 0; i < NumSearchResults; i++) {
960 if (PrevMu8(SearchResults[i]) != PSXMu8(SearchResults[i])) {
961 SearchResults[j++] = SearchResults[i];
965 NumSearchResults = j;
968 void CheatSearchDifferent16() {
971 assert(prevM != NULL); // not possible for the first search
975 for (i = 0; i < NumSearchResults; i++) {
976 if (PrevMu16(SearchResults[i]) != PSXMu16(SearchResults[i])) {
977 SearchResults[j++] = SearchResults[i];
981 NumSearchResults = j;
984 void CheatSearchDifferent32() {
987 assert(prevM != NULL); // not possible for the first search
991 for (i = 0; i < NumSearchResults; i++) {
992 if (PrevMu32(SearchResults[i]) != PSXMu32(SearchResults[i])) {
993 SearchResults[j++] = SearchResults[i];
997 NumSearchResults = j;
1000 void CheatSearchNoChange8() {
1003 assert(prevM != NULL); // not possible for the first search
1007 for (i = 0; i < NumSearchResults; i++) {
1008 if (PrevMu8(SearchResults[i]) == PSXMu8(SearchResults[i])) {
1009 SearchResults[j++] = SearchResults[i];
1013 NumSearchResults = j;
1016 void CheatSearchNoChange16() {
1019 assert(prevM != NULL); // not possible for the first search
1023 for (i = 0; i < NumSearchResults; i++) {
1024 if (PrevMu16(SearchResults[i]) == PSXMu16(SearchResults[i])) {
1025 SearchResults[j++] = SearchResults[i];
1029 NumSearchResults = j;
1032 void CheatSearchNoChange32() {
1035 assert(prevM != NULL); // not possible for the first search
1039 for (i = 0; i < NumSearchResults; i++) {
1040 if (PrevMu32(SearchResults[i]) == PSXMu32(SearchResults[i])) {
1041 SearchResults[j++] = SearchResults[i];
1045 NumSearchResults = j;