From f18e913429a9eeff92006df12fb974261aa49093 Mon Sep 17 00:00:00 2001 From: Steven Cherry Date: Thu, 16 May 2013 15:42:25 -0500 Subject: [PATCH 1/6] Add Cwcheat support --- Core/CwCheat.h | 494 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 494 insertions(+) create mode 100644 Core/CwCheat.h diff --git a/Core/CwCheat.h b/Core/CwCheat.h new file mode 100644 index 0000000000..e04945da71 --- /dev/null +++ b/Core/CwCheat.h @@ -0,0 +1,494 @@ + +#include +#include +#include +#include +#include + +#include "Core\MemMap.h" + +using namespace std; +class CheatsThread; +class CheatsGUI; +vector makeCodeParts(string l); +void trim2(string& str); +static long parseLong(string s); +static long parseHexLong(string s); + + +class CheatsGUI { +private: + + static long const serialVersionUID = 6791588139795694296L; + static long const int cheatsThreadSleepMillis = 5; + bool cheatsOn; + CheatsThread cheatsThread; +public: + CheatsGUI(); + string String(); + void addCheatLine(string& line); + void onCheatsThreadEnded(); + void dispose(); + vector getCodesList(); +}; +class CheatsThread { + private: + std::vector codes; + int currentCode; + CheatsGUI cheats; + bool exit2; + void skipCodes(int count); + void skipAllCodes(); + int getAddress(int value); + + + public: + CheatsThread(CheatsGUI cheats); + void exit(); + void run(); + string getNextCode(); +}; + +CheatsThread::CheatsThread(CheatsGUI cheats){ + this->cheats = cheats; +} + +void CheatsThread::exit() { + exit2 = true; +} + +string CheatsThread::getNextCode() { + string code; + string modifier = "_L"; + while (true) { + if (currentCode >= codes.size()) { + code.clear(); + break; + } + + code = codes[currentCode++]; + trim2(code); + + if (code.substr(0,2) == modifier) { + code = code.substr(3,21); + } + else if (code[0] == '0') { + break; + } + } + return code; +} + +void CheatsThread::skipCodes(int count) { + for (int i = 0; i < count; i ++) { + if (getNextCode() == "") { + break; + } + } +} + +void CheatsThread::skipAllCodes() { + currentCode = codes.size(); +} + +int CheatsThread::getAddress(int value) { + // The User space base address has to be added to given value + return (value + 0x08800000) & 0x3FFFFFFF; +} + +void CheatsThread::run() { + while (!exit2) { + codes = cheats.getCodesList(); //UI Member + currentCode = 0; + + while (true) { + string code = getNextCode(); + vectorparts = makeCodeParts(code); + int value; + trim2(parts[0]); + trim2(parts[1]); + int comm = (int)parseHexLong(parts[0]); + int arg = (int)parseHexLong(parts[1]); + int addr = getAddress(comm & 0x0FFFFFFF); + + switch (comm >> 28) { + case 0: // 8-bit write. + if (Memory::IsValidAddress(addr)){ + Memory::Write_U8((u8) arg, addr); + } + break; + case 0x1: // 16-bit write + if (Memory::IsValidAddress(addr)){ + Memory::Write_U16((u16) arg, addr); + } + break; + case 0x2: // 32-bit write + if (Memory::IsValidAddress(addr)){ + Memory::Write_U32((u32) arg, addr); + } + break; + case 0x3: // Increment/Decrement + { + addr = getAddress(arg); + value = 0; + int increment = 0; + // Read value from memory + switch ((comm >> 20) & 0xF) { + case 1: + case 2: // 8-bit + value = Memory::Read_U8(addr); + increment = comm & 0xFF; + break; + case 3: + case 4: // 16-bit + value = Memory::Read_U16(addr); + increment = comm & 0xFFFF; + break; + case 5: + case 6: // 32-bit + value = Memory::Read_U32(addr); + code = getNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + if ( parts[0] != "") { + increment = (int) parseHexLong(parts[0]); + } + break; + } + // Increment/Decrement value + switch ((comm >> 20) & 0xF) { + case 1: + case 3: + case 5: // increment + value += increment; + break; + case 2: + case 4: + case 6: // Decrement + value -= increment; + break; + } + // Write value back to memory + switch ((comm >> 20) & 0xF) { + case 1: + case 2: // 8-bit + Memory::Write_U8((u8) value, addr); + break; + case 3: + case 4: // 16-bit + Memory::Write_U16((u16) value, addr); + break; + case 5: + case 6: // 32-bit + Memory::Write_U32((u32) value, addr); + break; + } + break; } + case 0x4: // 32-bit patch code + code = getNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + trim2(parts[1]); + if (parts[0] != "") { + int data = (int) parseHexLong(parts[0]); + int dataAdd = (int) parseHexLong(parts[1]); + + int maxAddr = (arg >> 16) & 0xFFFF; + int stepAddr = (arg & 0xFFFF) * 4; + for (int a = 0; a < maxAddr; a++) { + if (Memory::IsValidAddress(addr)) { + Memory::Write_U32((u32) data, addr); + } + addr += stepAddr; + data += dataAdd; + } + } + break; + case 0x5: // Memcpy command + code = getNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + trim2(parts[1]); + if (parts[0] != "") { + int destAddr = (int) parseHexLong(parts[0]); + if (Memory::IsValidAddress(addr) && Memory::IsValidAddress(destAddr)) { + Memory::Memcpy(destAddr, Memory::GetPointer(addr), arg); + } + } + break; + case 0x6: // Pointer commands + code = getNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + trim2(parts[1]); + if (parts[0] != "") { + int arg2 = (int) parseHexLong(parts[0]); + int offset = (int) parseHexLong(parts[1]); + int baseOffset = (arg2 >> 20) * 4; + int base = Memory::Read_U32(addr + baseOffset); + int count = arg2 & 0xFFFF; + int type = (arg2 >> 16) & 0xF; + for (int i = 1; i < count; i ++ ) { + if (i+1 < count) { + code = getNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + trim2(parts[1]); + int arg3 = (int) parseHexLong(parts[0]); + int arg4 = (int) parseHexLong(parts[1]); + int comm3 = arg3 >> 28; + switch (comm3) { + case 0x1: // type copy byte + { + int srcAddr = Memory::Read_U32(addr) + offset; + int dstAddr = Memory::Read_U16(addr + baseOffset) + (arg3 & 0x0FFFFFFF); + Memory::Memcpy(dstAddr, Memory::GetPointer(srcAddr), arg); + type = -1; //Done + break; } + case 0x2: + case 0x3: // type pointer walk + { + int walkOffset = arg3 & 0x0FFFFFFF; + if (comm3 == 0x3) { + walkOffset = -walkOffset; + } + base = Memory::Read_U32(base + walkOffset); + int comm4 = arg4 >> 28; + switch (comm4) { + case 0x2: + case 0x3: // type pointer walk + walkOffset = arg4 & 0x0FFFFFFF; + if (comm4 == 0x3) { + walkOffset = -walkOffset; + } + base = Memory::Read_U32(base + walkOffset); + break; + } + break; } + case 0x9: // type multi address write + base += arg3 & 0x0FFFFFFF; + arg += arg4; + break; + } + } + } + + switch (type) { + case 0: // 8 bit write + Memory::Write_U8((u8) arg, base + offset); + break; + case 1: // 16-bit write + Memory::Write_U16((u16) arg, base + offset); + break; + case 2: // 32-bit write + Memory::Write_U32((u32) arg, base + offset); + break; + case 3: // 8 bit inverse write + Memory::Write_U8((u8) arg, base - offset); + break; + case 4: // 16-bit inverse write + Memory::Write_U16((u16) arg, base - offset); + break; + case 5: // 32-bit inverse write + Memory::Write_U32((u32) arg, base - offset); + break; + case -1: // Operation already performed, nothing to do + break; + } + } + break; + case 0x7: // Boolean commands. + switch (arg >> 16) { + case 0x0000: // 8-bit OR. + if (Memory::IsValidAddress(addr)) { + int val1 = (int) (arg & 0xFF); + int val2 = (int) Memory::Read_U8(addr); + Memory::Write_U8((u8) (val1 | val2), addr); + } + break; + case 0x0002: // 8-bit AND. + if (Memory::IsValidAddress(addr)) { + int val1 = (int) (arg & 0xFF); + int val2 = (int) Memory::Read_U8(addr); + Memory::Write_U8((u8) (val1 & val2), addr); + } + break; + case 0x0004: // 8-bit XOR. + if (Memory::IsValidAddress(addr)) { + int val1 = (int) (arg & 0xFF); + int val2 = (int) Memory::Read_U8(addr); + Memory::Write_U8((u8) (val1 ^ val2), addr); + } + break; + case 0x0001: // 16-bit OR. + if (Memory::IsValidAddress(addr)) { + short val1 = (short) (arg & 0xFFFF); + short val2 = (short) Memory::Read_U16(addr); + Memory::Write_U16((u16) (val1 | val2), addr); + } + break; + case 0x0003: // 16-bit AND. + if (Memory::IsValidAddress(addr)) { + short val1 = (short) (arg & 0xFFFF); + short val2 = (short) Memory::Read_U16(addr); + Memory::Write_U16((u16) (val1 & val2), addr); + } + break; + case 0x0005: // 16-bit OR. + if (Memory::IsValidAddress(addr)) { + short val1 = (short) (arg & 0xFFFF); + short val2 = (short) Memory::Read_U16(addr); + Memory::Write_U16((u16) (val1 ^ val2), addr); + } + break; + } + break; + case 0x8: // 8-bit and 16-bit patch code + code = getNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + trim2(parts[1]); + if (parts[0] != "") { + int data = (int) parseHexLong(parts[0]); + int dataAdd = (int) parseHexLong(parts[1]); + + bool is8Bit = (data >> 16) == 0x0000; + int maxAddr = (arg >> 16) & 0xFFFF; + int stepAddr = (arg & 0xFFFF) * (is8Bit ? 1 : 2); + for (int a = 0; a < maxAddr; a++) { + if (Memory::IsValidAddress(addr)) { + if (is8Bit) { + Memory::Write_U8((u8) (data & 0xFF), addr); + } + else { + Memory::Write_U16((u16) (data & 0xFFFF), addr); + } + } + addr += stepAddr; + data += dataAdd; + } + } + break; + case 0xB: // Time command (not sure what to do?) + break; + case 0xC: // Code stopper + if (Memory::IsValidAddress(addr)) { + value = Memory::Read_U32(addr); + if (value != arg) { + skipAllCodes(); + } + } + break; + case 0xD: // Test commands & Jocker codes ( Someone will have to help me with these) + break; + case 0xE: // Test commands, multiple skip + bool is8Bit = (comm >> 24) == 0x1; + addr = getAddress(arg & 0x0FFFFFFF); + if (Memory::IsValidAddress(addr)) { + int memoryValue = is8Bit ? Memory::Read_U8(addr) : Memory::Read_U16(addr); + int testValue = comm & (is8Bit ? 0xFF : 0xFFFF); + bool executeNextLines = false; + switch ( arg >> 28) { + case 0x0: // Equal + executeNextLines = memoryValue == testValue; + break; + case 0x1: // Not Equal + executeNextLines = memoryValue != testValue; + break; + case 0x2: // Less Than + executeNextLines = memoryValue < testValue; + break; + case 0x3: // Greater Than + executeNextLines = memoryValue > testValue; + break; + } + if (!executeNextLines) { + int skip = (comm >> 16) & (is8Bit ? 0xFF : 0xFFF); + skipCodes(skip); + } + } + break; + } + } + } + // exiting... + cheats.onCheatsThreadEnded(); + } + +CheatsGUI::CheatsGUI() { +} + +void CheatsGUI::addCheatLine(string& line) { + //Need GUI text area here + string cheatCodes; + if (cheatCodes.length() <= 0) { + cheatCodes = line; + } else { + cheatCodes += "/n" + line; + } + } + + +static long parseHexLong(string s) { + long value = 0; + + if (s.substr(0,2) == "0x") { + s = s.substr(2); + } + value = strtol(s.c_str(),NULL, 16); + return value; + } +static long parseLong(string s) { + long value = 0; + if (s.substr(0,2) == "0x") { + s = s.substr(2); + value = strtol(s.c_str(),NULL, 16); + } else { + value = strtol(s.c_str(),NULL, 10); + } + return value; + } + + +void trim2(string& str) +{ + string::size_type pos = str.find_last_not_of(' '); + if(pos != string::npos) { + str.erase(pos + 1); + pos = str.find_first_not_of(' '); + if(pos != string::npos) str.erase(0, pos); + } + else str.erase(str.begin(), str.end()); +} + +vector makeCodeParts(string l) { + vector parts; + char split_char = '/n'; + char empty = ' '; + + for (int i=0; i < l.length(); i++) { + if (l[i] == empty) { + l[i] = '\n'; + } + } + trim2(l); + istringstream iss (l); + for (std::string each; std::getline(iss, each, split_char);parts.push_back(each)) + {} + return parts; +} + +vector CheatsGUI::getCodesList() { + string text = "0x203BFA00 0x3B9AC9FF"; + vector codes; + trim2(text); + codes = makeCodeParts(text); + return codes; +} + +void CheatsGUI::onCheatsThreadEnded() { + cheatsThread = NULL; + } +void CheatsGUI::dispose() { +} + From 253493c5ce1313f3e8dfc06bd1ddafbd62f141f9 Mon Sep 17 00:00:00 2001 From: Steven Cherry Date: Thu, 16 May 2013 15:43:06 -0500 Subject: [PATCH 2/6] Add more --- Core/CwCheat.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 Core/CwCheat.cpp diff --git a/Core/CwCheat.cpp b/Core/CwCheat.cpp new file mode 100644 index 0000000000..8749e8f96c --- /dev/null +++ b/Core/CwCheat.cpp @@ -0,0 +1,10 @@ +#include "CwCheat.h" +#include "Config.h" +#include "UI\MenuScreens.cpp" +using namespace std; + +void runCheats() { + +} + + From 446d2930acabed665c6fc362af6aa06637b32842 Mon Sep 17 00:00:00 2001 From: Steven Cherry Date: Fri, 17 May 2013 23:49:44 -0500 Subject: [PATCH 3/6] Some progress, I think? Program crashes when trying to run a game. If you comment out member.Run(); it will run fine, but cwcheat doesnt work. --- Core/Core.vcxproj | 3 + Core/Core.vcxproj.filters | 6 + Core/CwCheat.cpp | 467 +++++++++++++++++++++++++++++++++++- Core/CwCheat.h | 487 ++------------------------------------ Core/HLE/sceKernel.cpp | 3 + 5 files changed, 497 insertions(+), 469 deletions(-) diff --git a/Core/Core.vcxproj b/Core/Core.vcxproj index 75fd9ac8cd..af3e6d053d 100644 --- a/Core/Core.vcxproj +++ b/Core/Core.vcxproj @@ -109,6 +109,7 @@ Fast USE_FFMPEG;_MBCS;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS Speed + MultiThreadedDLL true @@ -157,6 +158,7 @@ + @@ -330,6 +332,7 @@ + diff --git a/Core/Core.vcxproj.filters b/Core/Core.vcxproj.filters index 1d7eafeb18..fb483ba538 100644 --- a/Core/Core.vcxproj.filters +++ b/Core/Core.vcxproj.filters @@ -417,6 +417,9 @@ FileSystems + + Core + @@ -769,6 +772,9 @@ HLE\Libraries + + Core + diff --git a/Core/CwCheat.cpp b/Core/CwCheat.cpp index 8749e8f96c..a6ee85f621 100644 --- a/Core/CwCheat.cpp +++ b/Core/CwCheat.cpp @@ -1,10 +1,471 @@ #include "CwCheat.h" -#include "Config.h" -#include "UI\MenuScreens.cpp" +#include "../Core/CoreTiming.h" +#include "../Core/CoreParameter.h" using namespace std; -void runCheats() { +static int CheatEvent = -1; +CheatsGUI member; + +void hleCheat(u64 userdata, int cyclesLate); + + +void __CheatInit() { + + CheatEvent = CoreTiming::RegisterEvent("CheatEvent", &hleCheat); + CoreTiming::ScheduleEvent(msToCycles(66), CheatEvent, 0); +} +void __CheatShutdown() { + member.Exit(); +} + +void hleCheat(u64 userdata, int cyclesLate) { + CoreTiming::ScheduleEvent(msToCycles(66), CheatEvent, 0); + member.Run(); +} +CheatsGUI::CheatsGUI() { } +void CheatsGUI::Exit() { + exit2 = true; +} + +string CheatsGUI::GetNextCode() { + string code; + string modifier = "_L"; + while (true) { + if (currentCode >= codes.size()) { + code.clear(); + break; + } + + code = codes[currentCode++]; + trim2(code); + + if (code.substr(0,2) == modifier) { + code = code.substr(3,21); + } + else if (code[0] == '0') { + break; + } + } + return code; +} + +void CheatsGUI::skipCodes(int count) { + for (int i = 0; i < count; i ++) { + if (GetNextCode() == "") { + break; + } + } +} + +void CheatsGUI::skipAllCodes() { + currentCode = codes.size(); +} + +int CheatsGUI::getAddress(int value) { + // The User space base address has to be added to given value + return (value + 0x08800000) & 0x3FFFFFFF; +} + + + + +void CheatsGUI::AddCheatLine(string& line) { + //Need GUI text area here + string cheatCodes; + if (cheatCodes.length() <= 0) { + cheatCodes = line; + } else { + cheatCodes += "/n" + line; + } + } + + +inline static long parseHexLong(string s) { + long value = 0; + + if (s.substr(0,2) == "0x") { + s = s.substr(2); + } + value = strtol(s.c_str(),NULL, 16); + return value; + } +inline static long parseLong(string s) { + long value = 0; + if (s.substr(0,2) == "0x") { + s = s.substr(2); + value = strtol(s.c_str(),NULL, 16); + } else { + value = strtol(s.c_str(),NULL, 10); + } + return value; + } + + +inline void trim2(string& str) +{ + string::size_type pos = str.find_last_not_of(' '); + if(pos != string::npos) { + str.erase(pos + 1); + pos = str.find_first_not_of(' '); + if(pos != string::npos) str.erase(0, pos); + } + else str.erase(str.begin(), str.end()); +} + +inline vector makeCodeParts(string l) { + vector parts; + char split_char = '/n'; + char empty = ' '; + + for (int i=0; i < l.length(); i++) { + if (l[i] == empty) { + l[i] = '\n'; + } + } + trim2(l); + istringstream iss (l); + for (std::string each; std::getline(iss, each, split_char);parts.push_back(each)) + {} + return parts; +} + +vector CheatsGUI::GetCodesList() { + string text = "0x203BFA00 0x05F5E0FF"; + vector codeslist; + codeslist = makeCodeParts(text); + trim2(codeslist[0]); + trim2(codeslist[1]); + return codeslist; +} + +void CheatsGUI::OnCheatsThreadEnded() { + cheatsThread = false; + } +void CheatsGUI::Dispose() { +} + +void CheatsGUI::Run() { + CheatsGUI cheats; + while (!exit2) { + codes = cheats.GetCodesList(); //UI Member + currentCode = 0; + + while (true) { + string code = GetNextCode(); + vectorparts = makeCodeParts(code); + int value; + trim2(parts[0]); + trim2(parts[1]); + int comm = (int)parseHexLong(parts[0]); + int arg = (int)parseHexLong(parts[1]); + int addr = getAddress(comm & 0x0FFFFFFF); + + switch (comm >> 28) { + case 0: // 8-bit write. + if (Memory::IsValidAddress(addr)){ + Memory::Write_U8((u8) arg, addr); + } + break; + case 0x1: // 16-bit write + if (Memory::IsValidAddress(addr)){ + Memory::Write_U16((u16) arg, addr); + } + break; + case 0x2: // 32-bit write + if (Memory::IsValidAddress(addr)){ + Memory::Write_U32((u32) arg, addr); + } + break; + case 0x3: // Increment/Decrement + { + addr = getAddress(arg); + value = 0; + int increment = 0; + // Read value from memory + switch ((comm >> 20) & 0xF) { + case 1: + case 2: // 8-bit + value = Memory::Read_U8(addr); + increment = comm & 0xFF; + break; + case 3: + case 4: // 16-bit + value = Memory::Read_U16(addr); + increment = comm & 0xFFFF; + break; + case 5: + case 6: // 32-bit + value = Memory::Read_U32(addr); + code = GetNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + if ( parts[0] != "") { + increment = (int) parseHexLong(parts[0]); + } + break; + } + // Increment/Decrement value + switch ((comm >> 20) & 0xF) { + case 1: + case 3: + case 5: // increment + value += increment; + break; + case 2: + case 4: + case 6: // Decrement + value -= increment; + break; + } + // Write value back to memory + switch ((comm >> 20) & 0xF) { + case 1: + case 2: // 8-bit + Memory::Write_U8((u8) value, addr); + break; + case 3: + case 4: // 16-bit + Memory::Write_U16((u16) value, addr); + break; + case 5: + case 6: // 32-bit + Memory::Write_U32((u32) value, addr); + break; + } + break; } + case 0x4: // 32-bit patch code + code = GetNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + trim2(parts[1]); + if (parts[0] != "") { + int data = (int) parseHexLong(parts[0]); + int dataAdd = (int) parseHexLong(parts[1]); + + int maxAddr = (arg >> 16) & 0xFFFF; + int stepAddr = (arg & 0xFFFF) * 4; + for (int a = 0; a < maxAddr; a++) { + if (Memory::IsValidAddress(addr)) { + Memory::Write_U32((u32) data, addr); + } + addr += stepAddr; + data += dataAdd; + } + } + break; + case 0x5: // Memcpy command + code = GetNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + trim2(parts[1]); + if (parts[0] != "") { + int destAddr = (int) parseHexLong(parts[0]); + if (Memory::IsValidAddress(addr) && Memory::IsValidAddress(destAddr)) { + Memory::Memcpy(destAddr, Memory::GetPointer(addr), arg); + } + } + break; + case 0x6: // Pointer commands + code = GetNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + trim2(parts[1]); + if (parts[0] != "") { + int arg2 = (int) parseHexLong(parts[0]); + int offset = (int) parseHexLong(parts[1]); + int baseOffset = (arg2 >> 20) * 4; + int base = Memory::Read_U32(addr + baseOffset); + int count = arg2 & 0xFFFF; + int type = (arg2 >> 16) & 0xF; + for (int i = 1; i < count; i ++ ) { + if (i+1 < count) { + code = GetNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + trim2(parts[1]); + int arg3 = (int) parseHexLong(parts[0]); + int arg4 = (int) parseHexLong(parts[1]); + int comm3 = arg3 >> 28; + switch (comm3) { + case 0x1: // type copy byte + { + int srcAddr = Memory::Read_U32(addr) + offset; + int dstAddr = Memory::Read_U16(addr + baseOffset) + (arg3 & 0x0FFFFFFF); + Memory::Memcpy(dstAddr, Memory::GetPointer(srcAddr), arg); + type = -1; //Done + break; } + case 0x2: + case 0x3: // type pointer walk + { + int walkOffset = arg3 & 0x0FFFFFFF; + if (comm3 == 0x3) { + walkOffset = -walkOffset; + } + base = Memory::Read_U32(base + walkOffset); + int comm4 = arg4 >> 28; + switch (comm4) { + case 0x2: + case 0x3: // type pointer walk + walkOffset = arg4 & 0x0FFFFFFF; + if (comm4 == 0x3) { + walkOffset = -walkOffset; + } + base = Memory::Read_U32(base + walkOffset); + break; + } + break; } + case 0x9: // type multi address write + base += arg3 & 0x0FFFFFFF; + arg += arg4; + break; + } + } + } + + switch (type) { + case 0: // 8 bit write + Memory::Write_U8((u8) arg, base + offset); + break; + case 1: // 16-bit write + Memory::Write_U16((u16) arg, base + offset); + break; + case 2: // 32-bit write + Memory::Write_U32((u32) arg, base + offset); + break; + case 3: // 8 bit inverse write + Memory::Write_U8((u8) arg, base - offset); + break; + case 4: // 16-bit inverse write + Memory::Write_U16((u16) arg, base - offset); + break; + case 5: // 32-bit inverse write + Memory::Write_U32((u32) arg, base - offset); + break; + case -1: // Operation already performed, nothing to do + break; + } + } + break; + case 0x7: // Boolean commands. + switch (arg >> 16) { + case 0x0000: // 8-bit OR. + if (Memory::IsValidAddress(addr)) { + int val1 = (int) (arg & 0xFF); + int val2 = (int) Memory::Read_U8(addr); + Memory::Write_U8((u8) (val1 | val2), addr); + } + break; + case 0x0002: // 8-bit AND. + if (Memory::IsValidAddress(addr)) { + int val1 = (int) (arg & 0xFF); + int val2 = (int) Memory::Read_U8(addr); + Memory::Write_U8((u8) (val1 & val2), addr); + } + break; + case 0x0004: // 8-bit XOR. + if (Memory::IsValidAddress(addr)) { + int val1 = (int) (arg & 0xFF); + int val2 = (int) Memory::Read_U8(addr); + Memory::Write_U8((u8) (val1 ^ val2), addr); + } + break; + case 0x0001: // 16-bit OR. + if (Memory::IsValidAddress(addr)) { + short val1 = (short) (arg & 0xFFFF); + short val2 = (short) Memory::Read_U16(addr); + Memory::Write_U16((u16) (val1 | val2), addr); + } + break; + case 0x0003: // 16-bit AND. + if (Memory::IsValidAddress(addr)) { + short val1 = (short) (arg & 0xFFFF); + short val2 = (short) Memory::Read_U16(addr); + Memory::Write_U16((u16) (val1 & val2), addr); + } + break; + case 0x0005: // 16-bit OR. + if (Memory::IsValidAddress(addr)) { + short val1 = (short) (arg & 0xFFFF); + short val2 = (short) Memory::Read_U16(addr); + Memory::Write_U16((u16) (val1 ^ val2), addr); + } + break; + } + break; + case 0x8: // 8-bit and 16-bit patch code + code = GetNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + trim2(parts[1]); + if (parts[0] != "") { + int data = (int) parseHexLong(parts[0]); + int dataAdd = (int) parseHexLong(parts[1]); + + bool is8Bit = (data >> 16) == 0x0000; + int maxAddr = (arg >> 16) & 0xFFFF; + int stepAddr = (arg & 0xFFFF) * (is8Bit ? 1 : 2); + for (int a = 0; a < maxAddr; a++) { + if (Memory::IsValidAddress(addr)) { + if (is8Bit) { + Memory::Write_U8((u8) (data & 0xFF), addr); + } + else { + Memory::Write_U16((u16) (data & 0xFFFF), addr); + } + } + addr += stepAddr; + data += dataAdd; + } + } + break; + case 0xB: // Time command (not sure what to do?) + break; + case 0xC: // Code stopper + if (Memory::IsValidAddress(addr)) { + value = Memory::Read_U32(addr); + if (value != arg) { + skipAllCodes(); + } + } + break; + case 0xD: // Test commands & Jocker codes ( Someone will have to help me with these) + break; + case 0xE: // Test commands, multiple skip + bool is8Bit = (comm >> 24) == 0x1; + addr = getAddress(arg & 0x0FFFFFFF); + if (Memory::IsValidAddress(addr)) { + int memoryValue = is8Bit ? Memory::Read_U8(addr) : Memory::Read_U16(addr); + int testValue = comm & (is8Bit ? 0xFF : 0xFFFF); + bool executeNextLines = false; + switch ( arg >> 28) { + case 0x0: // Equal + executeNextLines = memoryValue == testValue; + break; + case 0x1: // Not Equal + executeNextLines = memoryValue != testValue; + break; + case 0x2: // Less Than + executeNextLines = memoryValue < testValue; + break; + case 0x3: // Greater Than + executeNextLines = memoryValue > testValue; + break; + } + if (!executeNextLines) { + int skip = (comm >> 16) & (is8Bit ? 0xFF : 0xFFF); + skipCodes(skip); + } + } + break; + } + } + } + // exiting... + cheats.OnCheatsThreadEnded(); + } + + diff --git a/Core/CwCheat.h b/Core/CwCheat.h index e04945da71..8ab46fbb86 100644 --- a/Core/CwCheat.h +++ b/Core/CwCheat.h @@ -1,15 +1,17 @@ #include #include -#include #include #include - #include "Core\MemMap.h" +void __CheatInit(); +void __CheatShutdown(); +//void Register_CwCheat(); using namespace std; -class CheatsThread; -class CheatsGUI; + + + vector makeCodeParts(string l); void trim2(string& str); static long parseLong(string s); @@ -18,477 +20,30 @@ static long parseHexLong(string s); class CheatsGUI { private: - static long const serialVersionUID = 6791588139795694296L; static long const int cheatsThreadSleepMillis = 5; bool cheatsOn; - CheatsThread cheatsThread; + std::vector codes; + int currentCode; + bool exit2; + void skipCodes(int count); + void skipAllCodes(); + int getAddress(int value); + bool cheatsThread; + public: CheatsGUI(); string String(); - void addCheatLine(string& line); - void onCheatsThreadEnded(); - void dispose(); - vector getCodesList(); -}; -class CheatsThread { - private: - std::vector codes; - int currentCode; - CheatsGUI cheats; - bool exit2; - void skipCodes(int count); - void skipAllCodes(); - int getAddress(int value); + void AddCheatLine(string& line); + void OnCheatsThreadEnded(); + void Dispose(); + vector GetCodesList(); - - public: - CheatsThread(CheatsGUI cheats); - void exit(); - void run(); - string getNextCode(); + void Exit(); + void Run(); + string GetNextCode(); }; -CheatsThread::CheatsThread(CheatsGUI cheats){ - this->cheats = cheats; -} - -void CheatsThread::exit() { - exit2 = true; -} - -string CheatsThread::getNextCode() { - string code; - string modifier = "_L"; - while (true) { - if (currentCode >= codes.size()) { - code.clear(); - break; - } - - code = codes[currentCode++]; - trim2(code); - - if (code.substr(0,2) == modifier) { - code = code.substr(3,21); - } - else if (code[0] == '0') { - break; - } - } - return code; -} - -void CheatsThread::skipCodes(int count) { - for (int i = 0; i < count; i ++) { - if (getNextCode() == "") { - break; - } - } -} - -void CheatsThread::skipAllCodes() { - currentCode = codes.size(); -} - -int CheatsThread::getAddress(int value) { - // The User space base address has to be added to given value - return (value + 0x08800000) & 0x3FFFFFFF; -} - -void CheatsThread::run() { - while (!exit2) { - codes = cheats.getCodesList(); //UI Member - currentCode = 0; - - while (true) { - string code = getNextCode(); - vectorparts = makeCodeParts(code); - int value; - trim2(parts[0]); - trim2(parts[1]); - int comm = (int)parseHexLong(parts[0]); - int arg = (int)parseHexLong(parts[1]); - int addr = getAddress(comm & 0x0FFFFFFF); - - switch (comm >> 28) { - case 0: // 8-bit write. - if (Memory::IsValidAddress(addr)){ - Memory::Write_U8((u8) arg, addr); - } - break; - case 0x1: // 16-bit write - if (Memory::IsValidAddress(addr)){ - Memory::Write_U16((u16) arg, addr); - } - break; - case 0x2: // 32-bit write - if (Memory::IsValidAddress(addr)){ - Memory::Write_U32((u32) arg, addr); - } - break; - case 0x3: // Increment/Decrement - { - addr = getAddress(arg); - value = 0; - int increment = 0; - // Read value from memory - switch ((comm >> 20) & 0xF) { - case 1: - case 2: // 8-bit - value = Memory::Read_U8(addr); - increment = comm & 0xFF; - break; - case 3: - case 4: // 16-bit - value = Memory::Read_U16(addr); - increment = comm & 0xFFFF; - break; - case 5: - case 6: // 32-bit - value = Memory::Read_U32(addr); - code = getNextCode(); - parts = makeCodeParts(code); - trim2(parts[0]); - if ( parts[0] != "") { - increment = (int) parseHexLong(parts[0]); - } - break; - } - // Increment/Decrement value - switch ((comm >> 20) & 0xF) { - case 1: - case 3: - case 5: // increment - value += increment; - break; - case 2: - case 4: - case 6: // Decrement - value -= increment; - break; - } - // Write value back to memory - switch ((comm >> 20) & 0xF) { - case 1: - case 2: // 8-bit - Memory::Write_U8((u8) value, addr); - break; - case 3: - case 4: // 16-bit - Memory::Write_U16((u16) value, addr); - break; - case 5: - case 6: // 32-bit - Memory::Write_U32((u32) value, addr); - break; - } - break; } - case 0x4: // 32-bit patch code - code = getNextCode(); - parts = makeCodeParts(code); - trim2(parts[0]); - trim2(parts[1]); - if (parts[0] != "") { - int data = (int) parseHexLong(parts[0]); - int dataAdd = (int) parseHexLong(parts[1]); - - int maxAddr = (arg >> 16) & 0xFFFF; - int stepAddr = (arg & 0xFFFF) * 4; - for (int a = 0; a < maxAddr; a++) { - if (Memory::IsValidAddress(addr)) { - Memory::Write_U32((u32) data, addr); - } - addr += stepAddr; - data += dataAdd; - } - } - break; - case 0x5: // Memcpy command - code = getNextCode(); - parts = makeCodeParts(code); - trim2(parts[0]); - trim2(parts[1]); - if (parts[0] != "") { - int destAddr = (int) parseHexLong(parts[0]); - if (Memory::IsValidAddress(addr) && Memory::IsValidAddress(destAddr)) { - Memory::Memcpy(destAddr, Memory::GetPointer(addr), arg); - } - } - break; - case 0x6: // Pointer commands - code = getNextCode(); - parts = makeCodeParts(code); - trim2(parts[0]); - trim2(parts[1]); - if (parts[0] != "") { - int arg2 = (int) parseHexLong(parts[0]); - int offset = (int) parseHexLong(parts[1]); - int baseOffset = (arg2 >> 20) * 4; - int base = Memory::Read_U32(addr + baseOffset); - int count = arg2 & 0xFFFF; - int type = (arg2 >> 16) & 0xF; - for (int i = 1; i < count; i ++ ) { - if (i+1 < count) { - code = getNextCode(); - parts = makeCodeParts(code); - trim2(parts[0]); - trim2(parts[1]); - int arg3 = (int) parseHexLong(parts[0]); - int arg4 = (int) parseHexLong(parts[1]); - int comm3 = arg3 >> 28; - switch (comm3) { - case 0x1: // type copy byte - { - int srcAddr = Memory::Read_U32(addr) + offset; - int dstAddr = Memory::Read_U16(addr + baseOffset) + (arg3 & 0x0FFFFFFF); - Memory::Memcpy(dstAddr, Memory::GetPointer(srcAddr), arg); - type = -1; //Done - break; } - case 0x2: - case 0x3: // type pointer walk - { - int walkOffset = arg3 & 0x0FFFFFFF; - if (comm3 == 0x3) { - walkOffset = -walkOffset; - } - base = Memory::Read_U32(base + walkOffset); - int comm4 = arg4 >> 28; - switch (comm4) { - case 0x2: - case 0x3: // type pointer walk - walkOffset = arg4 & 0x0FFFFFFF; - if (comm4 == 0x3) { - walkOffset = -walkOffset; - } - base = Memory::Read_U32(base + walkOffset); - break; - } - break; } - case 0x9: // type multi address write - base += arg3 & 0x0FFFFFFF; - arg += arg4; - break; - } - } - } - - switch (type) { - case 0: // 8 bit write - Memory::Write_U8((u8) arg, base + offset); - break; - case 1: // 16-bit write - Memory::Write_U16((u16) arg, base + offset); - break; - case 2: // 32-bit write - Memory::Write_U32((u32) arg, base + offset); - break; - case 3: // 8 bit inverse write - Memory::Write_U8((u8) arg, base - offset); - break; - case 4: // 16-bit inverse write - Memory::Write_U16((u16) arg, base - offset); - break; - case 5: // 32-bit inverse write - Memory::Write_U32((u32) arg, base - offset); - break; - case -1: // Operation already performed, nothing to do - break; - } - } - break; - case 0x7: // Boolean commands. - switch (arg >> 16) { - case 0x0000: // 8-bit OR. - if (Memory::IsValidAddress(addr)) { - int val1 = (int) (arg & 0xFF); - int val2 = (int) Memory::Read_U8(addr); - Memory::Write_U8((u8) (val1 | val2), addr); - } - break; - case 0x0002: // 8-bit AND. - if (Memory::IsValidAddress(addr)) { - int val1 = (int) (arg & 0xFF); - int val2 = (int) Memory::Read_U8(addr); - Memory::Write_U8((u8) (val1 & val2), addr); - } - break; - case 0x0004: // 8-bit XOR. - if (Memory::IsValidAddress(addr)) { - int val1 = (int) (arg & 0xFF); - int val2 = (int) Memory::Read_U8(addr); - Memory::Write_U8((u8) (val1 ^ val2), addr); - } - break; - case 0x0001: // 16-bit OR. - if (Memory::IsValidAddress(addr)) { - short val1 = (short) (arg & 0xFFFF); - short val2 = (short) Memory::Read_U16(addr); - Memory::Write_U16((u16) (val1 | val2), addr); - } - break; - case 0x0003: // 16-bit AND. - if (Memory::IsValidAddress(addr)) { - short val1 = (short) (arg & 0xFFFF); - short val2 = (short) Memory::Read_U16(addr); - Memory::Write_U16((u16) (val1 & val2), addr); - } - break; - case 0x0005: // 16-bit OR. - if (Memory::IsValidAddress(addr)) { - short val1 = (short) (arg & 0xFFFF); - short val2 = (short) Memory::Read_U16(addr); - Memory::Write_U16((u16) (val1 ^ val2), addr); - } - break; - } - break; - case 0x8: // 8-bit and 16-bit patch code - code = getNextCode(); - parts = makeCodeParts(code); - trim2(parts[0]); - trim2(parts[1]); - if (parts[0] != "") { - int data = (int) parseHexLong(parts[0]); - int dataAdd = (int) parseHexLong(parts[1]); - - bool is8Bit = (data >> 16) == 0x0000; - int maxAddr = (arg >> 16) & 0xFFFF; - int stepAddr = (arg & 0xFFFF) * (is8Bit ? 1 : 2); - for (int a = 0; a < maxAddr; a++) { - if (Memory::IsValidAddress(addr)) { - if (is8Bit) { - Memory::Write_U8((u8) (data & 0xFF), addr); - } - else { - Memory::Write_U16((u16) (data & 0xFFFF), addr); - } - } - addr += stepAddr; - data += dataAdd; - } - } - break; - case 0xB: // Time command (not sure what to do?) - break; - case 0xC: // Code stopper - if (Memory::IsValidAddress(addr)) { - value = Memory::Read_U32(addr); - if (value != arg) { - skipAllCodes(); - } - } - break; - case 0xD: // Test commands & Jocker codes ( Someone will have to help me with these) - break; - case 0xE: // Test commands, multiple skip - bool is8Bit = (comm >> 24) == 0x1; - addr = getAddress(arg & 0x0FFFFFFF); - if (Memory::IsValidAddress(addr)) { - int memoryValue = is8Bit ? Memory::Read_U8(addr) : Memory::Read_U16(addr); - int testValue = comm & (is8Bit ? 0xFF : 0xFFFF); - bool executeNextLines = false; - switch ( arg >> 28) { - case 0x0: // Equal - executeNextLines = memoryValue == testValue; - break; - case 0x1: // Not Equal - executeNextLines = memoryValue != testValue; - break; - case 0x2: // Less Than - executeNextLines = memoryValue < testValue; - break; - case 0x3: // Greater Than - executeNextLines = memoryValue > testValue; - break; - } - if (!executeNextLines) { - int skip = (comm >> 16) & (is8Bit ? 0xFF : 0xFFF); - skipCodes(skip); - } - } - break; - } - } - } - // exiting... - cheats.onCheatsThreadEnded(); - } - -CheatsGUI::CheatsGUI() { -} - -void CheatsGUI::addCheatLine(string& line) { - //Need GUI text area here - string cheatCodes; - if (cheatCodes.length() <= 0) { - cheatCodes = line; - } else { - cheatCodes += "/n" + line; - } - } -static long parseHexLong(string s) { - long value = 0; - - if (s.substr(0,2) == "0x") { - s = s.substr(2); - } - value = strtol(s.c_str(),NULL, 16); - return value; - } -static long parseLong(string s) { - long value = 0; - if (s.substr(0,2) == "0x") { - s = s.substr(2); - value = strtol(s.c_str(),NULL, 16); - } else { - value = strtol(s.c_str(),NULL, 10); - } - return value; - } - - -void trim2(string& str) -{ - string::size_type pos = str.find_last_not_of(' '); - if(pos != string::npos) { - str.erase(pos + 1); - pos = str.find_first_not_of(' '); - if(pos != string::npos) str.erase(0, pos); - } - else str.erase(str.begin(), str.end()); -} - -vector makeCodeParts(string l) { - vector parts; - char split_char = '/n'; - char empty = ' '; - - for (int i=0; i < l.length(); i++) { - if (l[i] == empty) { - l[i] = '\n'; - } - } - trim2(l); - istringstream iss (l); - for (std::string each; std::getline(iss, each, split_char);parts.push_back(each)) - {} - return parts; -} - -vector CheatsGUI::getCodesList() { - string text = "0x203BFA00 0x3B9AC9FF"; - vector codes; - trim2(text); - codes = makeCodeParts(text); - return codes; -} - -void CheatsGUI::onCheatsThreadEnded() { - cheatsThread = NULL; - } -void CheatsGUI::dispose() { -} diff --git a/Core/HLE/sceKernel.cpp b/Core/HLE/sceKernel.cpp index b29f964133..42741e901c 100644 --- a/Core/HLE/sceKernel.cpp +++ b/Core/HLE/sceKernel.cpp @@ -16,6 +16,7 @@ // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. #include "Core/Config.h" +#include "Core/Cwcheat.h" #include "Core/HLE/HLE.h" #include "Core/MIPS/MIPS.h" #include "Core/MIPS/MIPSCodeUtils.h" @@ -115,6 +116,7 @@ void __KernelInit() __UsbInit(); __FontInit(); __NetInit(); + __CheatInit(); SaveState::Init(); // Must be after IO, as it may create a directory @@ -156,6 +158,7 @@ void __KernelShutdown() __KernelThreadingShutdown(); __KernelMemoryShutdown(); __InterruptsShutdown(); + __CheatShutdown(); CoreTiming::ClearPendingEvents(); CoreTiming::UnregisterAllEvents(); From 0b2885c2fe9ff84f3b3daabcc416dee8f207c4fe Mon Sep 17 00:00:00 2001 From: Steven Cherry Date: Sat, 18 May 2013 03:21:57 -0500 Subject: [PATCH 4/6] First working version --- Core/CwCheat.cpp | 29 +++++++++++++++++++---------- Core/CwCheat.h | 2 +- 2 files changed, 20 insertions(+), 11 deletions(-) diff --git a/Core/CwCheat.cpp b/Core/CwCheat.cpp index a6ee85f621..70a5df287f 100644 --- a/Core/CwCheat.cpp +++ b/Core/CwCheat.cpp @@ -5,6 +5,7 @@ using namespace std; static int CheatEvent = -1; CheatsGUI member; +CheatsGUI cheatsThread; void hleCheat(u64 userdata, int cyclesLate); @@ -12,18 +13,17 @@ void hleCheat(u64 userdata, int cyclesLate); void __CheatInit() { CheatEvent = CoreTiming::RegisterEvent("CheatEvent", &hleCheat); - CoreTiming::ScheduleEvent(msToCycles(66), CheatEvent, 0); + CoreTiming::ScheduleEvent(msToCycles(600), CheatEvent, 0); } void __CheatShutdown() { member.Exit(); } void hleCheat(u64 userdata, int cyclesLate) { - CoreTiming::ScheduleEvent(msToCycles(66), CheatEvent, 0); + CoreTiming::ScheduleEvent(msToCycles(660), CheatEvent, 0); member.Run(); } CheatsGUI::CheatsGUI() { - } void CheatsGUI::Exit() { @@ -33,6 +33,7 @@ void CheatsGUI::Exit() { string CheatsGUI::GetNextCode() { string code; string modifier = "_L"; + char modifier2 = ' '; while (true) { if (currentCode >= codes.size()) { code.clear(); @@ -43,9 +44,9 @@ string CheatsGUI::GetNextCode() { trim2(code); if (code.substr(0,2) == modifier) { - code = code.substr(3,21); + code = code.substr(3); } - else if (code[0] == '0') { + else if (code[0] == modifier2) { break; } } @@ -78,7 +79,7 @@ void CheatsGUI::AddCheatLine(string& line) { if (cheatCodes.length() <= 0) { cheatCodes = line; } else { - cheatCodes += "/n" + line; + cheatCodes += "\n" + line; } } @@ -117,7 +118,7 @@ inline void trim2(string& str) inline vector makeCodeParts(string l) { vector parts; - char split_char = '/n'; + char split_char = '\n'; char empty = ' '; for (int i=0; i < l.length(); i++) { @@ -142,24 +143,26 @@ vector CheatsGUI::GetCodesList() { } void CheatsGUI::OnCheatsThreadEnded() { - cheatsThread = false; + test = 0; } void CheatsGUI::Dispose() { } void CheatsGUI::Run() { CheatsGUI cheats; + exit2 = false; while (!exit2) { codes = cheats.GetCodesList(); //UI Member currentCode = 0; while (true) { - string code = GetNextCode(); + string code = "0x203BFA00 0x05F5E0FF"; vectorparts = makeCodeParts(code); int value; trim2(parts[0]); trim2(parts[1]); - int comm = (int)parseHexLong(parts[0]); + cout << parts[0] << endl << parts[1]; + unsigned int comm = (unsigned int)parseHexLong(parts[0]); int arg = (int)parseHexLong(parts[1]); int addr = getAddress(comm & 0x0FFFFFFF); @@ -434,6 +437,7 @@ void CheatsGUI::Run() { case 0xD: // Test commands & Jocker codes ( Someone will have to help me with these) break; case 0xE: // Test commands, multiple skip + { bool is8Bit = (comm >> 24) == 0x1; addr = getAddress(arg & 0x0FFFFFFF); if (Memory::IsValidAddress(addr)) { @@ -461,6 +465,11 @@ void CheatsGUI::Run() { } break; } + default: + break; + } + Exit(); + break; } } // exiting... diff --git a/Core/CwCheat.h b/Core/CwCheat.h index 8ab46fbb86..393e58feb4 100644 --- a/Core/CwCheat.h +++ b/Core/CwCheat.h @@ -29,7 +29,7 @@ private: void skipCodes(int count); void skipAllCodes(); int getAddress(int value); - bool cheatsThread; + bool test; public: CheatsGUI(); From 9d2667fc0dab97b57e2edf2815bef7ab4429f29a Mon Sep 17 00:00:00 2001 From: Steven Cherry Date: Sat, 18 May 2013 17:04:01 -0500 Subject: [PATCH 5/6] Second to last commit Everything but getting ISO name --- Common/StringUtils.cpp | 21 ++ Common/StringUtils.h | 3 +- Core/Config.h | 1 + Core/CwCheat.cpp | 412 +++++++++++++++++++------------------- Core/CwCheat.h | 9 +- UI/MenuScreens.cpp | 10 +- Windows/WndMainWindow.cpp | 3 + 7 files changed, 243 insertions(+), 216 deletions(-) diff --git a/Common/StringUtils.cpp b/Common/StringUtils.cpp index b3b720bad1..992e6ce208 100644 --- a/Common/StringUtils.cpp +++ b/Common/StringUtils.cpp @@ -22,6 +22,27 @@ #include "CommonPaths.h" #include "StringUtils.h" +long parseHexLong(std::string s) { + long value = 0; + + if (s.substr(0,2) == "0x") { + //s = s.substr(2); + } + value = strtoul(s.c_str(),0, 0); + return value; +} +long parseLong(std::string s) { + long value = 0; + if (s.substr(0,2) == "0x") { + s = s.substr(2); + value = strtol(s.c_str(),NULL, 16); + } else { + value = strtol(s.c_str(),NULL, 10); + } + return value; +} + + // faster than sscanf bool AsciiToHex(const char* _szValue, u32& result) { diff --git a/Common/StringUtils.h b/Common/StringUtils.h index 220b70f8c4..0c27481d88 100644 --- a/Common/StringUtils.h +++ b/Common/StringUtils.h @@ -22,7 +22,8 @@ #include #include "Common.h" - +long parseHexLong(std::string s); +long parseLong(std::string s); std::string StringFromFormat(const char* format, ...); // Cheap! bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list args); diff --git a/Core/Config.h b/Core/Config.h index 2643f25471..1bef4806ab 100644 --- a/Core/Config.h +++ b/Core/Config.h @@ -80,6 +80,7 @@ public: bool bTexDeposterize; int iFpsLimit; u32 iMaxRecent; + int iEnableCheats; // Sound bool bEnableSound; diff --git a/Core/CwCheat.cpp b/Core/CwCheat.cpp index 70a5df287f..1b8bf66221 100644 --- a/Core/CwCheat.cpp +++ b/Core/CwCheat.cpp @@ -1,39 +1,48 @@ #include "CwCheat.h" #include "../Core/CoreTiming.h" #include "../Core/CoreParameter.h" +#include "StringUtils.h" +#include "Common/FileUtil.h" +#include "Config.h" using namespace std; static int CheatEvent = -1; -CheatsGUI member; -CheatsGUI cheatsThread; - +CWCheatEngine member; +CWCheatEngine cheatsThread; void hleCheat(u64 userdata, int cyclesLate); void __CheatInit() { - + CheatEvent = CoreTiming::RegisterEvent("CheatEvent", &hleCheat); - CoreTiming::ScheduleEvent(msToCycles(600), CheatEvent, 0); + CoreTiming::ScheduleEvent(msToCycles(77), CheatEvent, 0); + File::CreateFullPath("Cheats"); + if (!File::Exists("Cheats/Cheats.ini")) { + File::CreateEmptyFile("Cheats/Cheats.ini"); + } } void __CheatShutdown() { member.Exit(); } void hleCheat(u64 userdata, int cyclesLate) { - CoreTiming::ScheduleEvent(msToCycles(660), CheatEvent, 0); + CoreTiming::ScheduleEvent(msToCycles(77), CheatEvent, 0); + if (g_Config.iEnableCheats == 1) { member.Run(); -} -CheatsGUI::CheatsGUI() { + } } -void CheatsGUI::Exit() { +CWCheatEngine::CWCheatEngine() { +} + +void CWCheatEngine::Exit() { exit2 = true; } -string CheatsGUI::GetNextCode() { +string CWCheatEngine::GetNextCode() { string code; string modifier = "_L"; - char modifier2 = ' '; + char modifier2 = '0'; while (true) { if (currentCode >= codes.size()) { code.clear(); @@ -53,74 +62,52 @@ string CheatsGUI::GetNextCode() { return code; } -void CheatsGUI::skipCodes(int count) { +void CWCheatEngine::skipCodes(int count) { for (int i = 0; i < count; i ++) { if (GetNextCode() == "") { break; } } } - -void CheatsGUI::skipAllCodes() { + +void CWCheatEngine::skipAllCodes() { currentCode = codes.size(); } -int CheatsGUI::getAddress(int value) { +int CWCheatEngine::getAddress(int value) { // The User space base address has to be added to given value return (value + 0x08800000) & 0x3FFFFFFF; } - -void CheatsGUI::AddCheatLine(string& line) { - //Need GUI text area here - string cheatCodes; - if (cheatCodes.length() <= 0) { - cheatCodes = line; - } else { - cheatCodes += "\n" + line; - } + +void CWCheatEngine::AddCheatLine(string& line) { + //Need GUI text area here + string cheatCodes; + if (cheatCodes.length() <= 0) { + cheatCodes = line; + } else { + cheatCodes += "\n" + line; } - - -inline static long parseHexLong(string s) { - long value = 0; - - if (s.substr(0,2) == "0x") { - s = s.substr(2); - } - value = strtol(s.c_str(),NULL, 16); - return value; - } -inline static long parseLong(string s) { - long value = 0; - if (s.substr(0,2) == "0x") { - s = s.substr(2); - value = strtol(s.c_str(),NULL, 16); - } else { - value = strtol(s.c_str(),NULL, 10); - } - return value; - } - +} inline void trim2(string& str) { - string::size_type pos = str.find_last_not_of(' '); - if(pos != string::npos) { - str.erase(pos + 1); - pos = str.find_first_not_of(' '); - if(pos != string::npos) str.erase(0, pos); - } - else str.erase(str.begin(), str.end()); + string::size_type pos = str.find_last_not_of(' '); + if(pos != string::npos) { + str.erase(pos + 1); + pos = str.find_first_not_of(' '); + if(pos != string::npos) str.erase(0, pos); + } + else str.erase(str.begin(), str.end()); } inline vector makeCodeParts(string l) { vector parts; char split_char = '\n'; char empty = ' '; - + for (int i=0; i < l.length(); i++) { if (l[i] == empty) { l[i] = '\n'; @@ -128,40 +115,55 @@ inline vector makeCodeParts(string l) { } trim2(l); istringstream iss (l); - for (std::string each; std::getline(iss, each, split_char);parts.push_back(each)) - {} + std::string each; + while (std::getline(iss, each, split_char)) { + parts.push_back(each); + } return parts; } -vector CheatsGUI::GetCodesList() { - string text = "0x203BFA00 0x05F5E0FF"; - vector codeslist; - codeslist = makeCodeParts(text); - trim2(codeslist[0]); - trim2(codeslist[1]); - return codeslist; +vector CWCheatEngine::GetCodesList() { + string line; + char* skip = "//"; + vector codesList; //Read from INI here + ifstream list("D:\\User\\Steven\\Documents\\GitHub\\ppsspp\\Cheats\\Cheats.ini"); + for (int i = 0; !list.eof(); i ++) { + getline(list,line, '\n'); + if (line.substr(0,2) == skip) + {line.clear(); + } + else { + codesList.push_back(line); + } + } + for( int i = 0; i < codesList.size(); i++) { + trim2(codesList[i]); + } + return codesList; } -void CheatsGUI::OnCheatsThreadEnded() { - test = 0; - } -void CheatsGUI::Dispose() { -} - -void CheatsGUI::Run() { - CheatsGUI cheats; +void CWCheatEngine::Run() { + CWCheatEngine cheats; exit2 = false; while (!exit2) { codes = cheats.GetCodesList(); //UI Member currentCode = 0; - + while (true) { - string code = "0x203BFA00 0x05F5E0FF"; + string code = GetNextCode(); + if (code == "") { + Exit(); + break; + } vectorparts = makeCodeParts(code); + if (parts[0] == "" || parts.size() < 2) { + continue; + } + int value; trim2(parts[0]); trim2(parts[1]); - cout << parts[0] << endl << parts[1]; + //cout << parts[0] << endl << parts[1]; unsigned int comm = (unsigned int)parseHexLong(parts[0]); int arg = (int)parseHexLong(parts[1]); int addr = getAddress(comm & 0x0FFFFFFF); @@ -184,61 +186,61 @@ void CheatsGUI::Run() { break; case 0x3: // Increment/Decrement { - addr = getAddress(arg); - value = 0; - int increment = 0; - // Read value from memory - switch ((comm >> 20) & 0xF) { - case 1: - case 2: // 8-bit - value = Memory::Read_U8(addr); - increment = comm & 0xFF; - break; - case 3: - case 4: // 16-bit - value = Memory::Read_U16(addr); - increment = comm & 0xFFFF; - break; - case 5: - case 6: // 32-bit - value = Memory::Read_U32(addr); - code = GetNextCode(); - parts = makeCodeParts(code); - trim2(parts[0]); - if ( parts[0] != "") { - increment = (int) parseHexLong(parts[0]); + addr = getAddress(arg); + value = 0; + int increment = 0; + // Read value from memory + switch ((comm >> 20) & 0xF) { + case 1: + case 2: // 8-bit + value = Memory::Read_U8(addr); + increment = comm & 0xFF; + break; + case 3: + case 4: // 16-bit + value = Memory::Read_U16(addr); + increment = comm & 0xFFFF; + break; + case 5: + case 6: // 32-bit + value = Memory::Read_U32(addr); + code = GetNextCode(); + parts = makeCodeParts(code); + trim2(parts[0]); + if ( parts[0] != "") { + increment = (int) parseHexLong(parts[0]); + } + break; } - break; - } - // Increment/Decrement value - switch ((comm >> 20) & 0xF) { - case 1: - case 3: - case 5: // increment - value += increment; - break; - case 2: - case 4: - case 6: // Decrement - value -= increment; - break; - } - // Write value back to memory - switch ((comm >> 20) & 0xF) { - case 1: - case 2: // 8-bit - Memory::Write_U8((u8) value, addr); - break; - case 3: - case 4: // 16-bit - Memory::Write_U16((u16) value, addr); - break; - case 5: - case 6: // 32-bit - Memory::Write_U32((u32) value, addr); - break; - } - break; } + // Increment/Decrement value + switch ((comm >> 20) & 0xF) { + case 1: + case 3: + case 5: // increment + value += increment; + break; + case 2: + case 4: + case 6: // Decrement + value -= increment; + break; + } + // Write value back to memory + switch ((comm >> 20) & 0xF) { + case 1: + case 2: // 8-bit + Memory::Write_U8((u8) value, addr); + break; + case 3: + case 4: // 16-bit + Memory::Write_U16((u16) value, addr); + break; + case 5: + case 6: // 32-bit + Memory::Write_U32((u32) value, addr); + break; + } + break; } case 0x4: // 32-bit patch code code = GetNextCode(); parts = makeCodeParts(code); @@ -295,31 +297,31 @@ void CheatsGUI::Run() { switch (comm3) { case 0x1: // type copy byte { - int srcAddr = Memory::Read_U32(addr) + offset; - int dstAddr = Memory::Read_U16(addr + baseOffset) + (arg3 & 0x0FFFFFFF); - Memory::Memcpy(dstAddr, Memory::GetPointer(srcAddr), arg); - type = -1; //Done - break; } + int srcAddr = Memory::Read_U32(addr) + offset; + int dstAddr = Memory::Read_U16(addr + baseOffset) + (arg3 & 0x0FFFFFFF); + Memory::Memcpy(dstAddr, Memory::GetPointer(srcAddr), arg); + type = -1; //Done + break; } case 0x2: case 0x3: // type pointer walk { - int walkOffset = arg3 & 0x0FFFFFFF; - if (comm3 == 0x3) { - walkOffset = -walkOffset; - } - base = Memory::Read_U32(base + walkOffset); - int comm4 = arg4 >> 28; - switch (comm4) { - case 0x2: - case 0x3: // type pointer walk - walkOffset = arg4 & 0x0FFFFFFF; - if (comm4 == 0x3) { + int walkOffset = arg3 & 0x0FFFFFFF; + if (comm3 == 0x3) { walkOffset = -walkOffset; } base = Memory::Read_U32(base + walkOffset); - break; - } - break; } + int comm4 = arg4 >> 28; + switch (comm4) { + case 0x2: + case 0x3: // type pointer walk + walkOffset = arg4 & 0x0FFFFFFF; + if (comm4 == 0x3) { + walkOffset = -walkOffset; + } + base = Memory::Read_U32(base + walkOffset); + break; + } + break; } case 0x9: // type multi address write base += arg3 & 0x0FFFFFFF; arg += arg4; @@ -327,29 +329,29 @@ void CheatsGUI::Run() { } } } - - switch (type) { - case 0: // 8 bit write - Memory::Write_U8((u8) arg, base + offset); - break; - case 1: // 16-bit write - Memory::Write_U16((u16) arg, base + offset); - break; - case 2: // 32-bit write - Memory::Write_U32((u32) arg, base + offset); - break; - case 3: // 8 bit inverse write - Memory::Write_U8((u8) arg, base - offset); - break; - case 4: // 16-bit inverse write - Memory::Write_U16((u16) arg, base - offset); - break; - case 5: // 32-bit inverse write - Memory::Write_U32((u32) arg, base - offset); - break; - case -1: // Operation already performed, nothing to do - break; - } + + switch (type) { + case 0: // 8 bit write + Memory::Write_U8((u8) arg, base + offset); + break; + case 1: // 16-bit write + Memory::Write_U16((u16) arg, base + offset); + break; + case 2: // 32-bit write + Memory::Write_U32((u32) arg, base + offset); + break; + case 3: // 8 bit inverse write + Memory::Write_U8((u8) arg, base - offset); + break; + case 4: // 16-bit inverse write + Memory::Write_U16((u16) arg, base - offset); + break; + case 5: // 32-bit inverse write + Memory::Write_U32((u32) arg, base - offset); + break; + case -1: // Operation already performed, nothing to do + break; + } } break; case 0x7: // Boolean commands. @@ -413,10 +415,10 @@ void CheatsGUI::Run() { for (int a = 0; a < maxAddr; a++) { if (Memory::IsValidAddress(addr)) { if (is8Bit) { - Memory::Write_U8((u8) (data & 0xFF), addr); + Memory::Write_U8((u8) (data & 0xFF), addr); } else { - Memory::Write_U16((u16) (data & 0xFFFF), addr); + Memory::Write_U16((u16) (data & 0xFFFF), addr); } } addr += stepAddr; @@ -438,43 +440,39 @@ void CheatsGUI::Run() { break; case 0xE: // Test commands, multiple skip { - bool is8Bit = (comm >> 24) == 0x1; - addr = getAddress(arg & 0x0FFFFFFF); - if (Memory::IsValidAddress(addr)) { - int memoryValue = is8Bit ? Memory::Read_U8(addr) : Memory::Read_U16(addr); - int testValue = comm & (is8Bit ? 0xFF : 0xFFFF); - bool executeNextLines = false; - switch ( arg >> 28) { - case 0x0: // Equal - executeNextLines = memoryValue == testValue; - break; - case 0x1: // Not Equal - executeNextLines = memoryValue != testValue; - break; - case 0x2: // Less Than - executeNextLines = memoryValue < testValue; - break; - case 0x3: // Greater Than - executeNextLines = memoryValue > testValue; - break; - } - if (!executeNextLines) { - int skip = (comm >> 16) & (is8Bit ? 0xFF : 0xFFF); - skipCodes(skip); + bool is8Bit = (comm >> 24) == 0x1; + addr = getAddress(arg & 0x0FFFFFFF); + if (Memory::IsValidAddress(addr)) { + int memoryValue = is8Bit ? Memory::Read_U8(addr) : Memory::Read_U16(addr); + int testValue = comm & (is8Bit ? 0xFF : 0xFFFF); + bool executeNextLines = false; + switch ( arg >> 28) { + case 0x0: // Equal + executeNextLines = memoryValue == testValue; + break; + case 0x1: // Not Equal + executeNextLines = memoryValue != testValue; + break; + case 0x2: // Less Than + executeNextLines = memoryValue < testValue; + break; + case 0x3: // Greater Than + executeNextLines = memoryValue > testValue; + break; + } + if (!executeNextLines) { + int skip = (comm >> 16) & (is8Bit ? 0xFF : 0xFFF); + skipCodes(skip); + } } + break; } - break; - } - default: - break; - } - Exit(); - break; - } - } - // exiting... - cheats.OnCheatsThreadEnded(); - } + } + } + } + // exiting... + Exit(); +} diff --git a/Core/CwCheat.h b/Core/CwCheat.h index 393e58feb4..5454c8d75f 100644 --- a/Core/CwCheat.h +++ b/Core/CwCheat.h @@ -14,11 +14,9 @@ using namespace std; vector makeCodeParts(string l); void trim2(string& str); -static long parseLong(string s); -static long parseHexLong(string s); -class CheatsGUI { +class CWCheatEngine { private: static long const serialVersionUID = 6791588139795694296L; static long const int cheatsThreadSleepMillis = 5; @@ -29,14 +27,11 @@ private: void skipCodes(int count); void skipAllCodes(); int getAddress(int value); - bool test; public: - CheatsGUI(); + CWCheatEngine(); string String(); void AddCheatLine(string& line); - void OnCheatsThreadEnded(); - void Dispose(); vector GetCodesList(); void Exit(); diff --git a/UI/MenuScreens.cpp b/UI/MenuScreens.cpp index 5606c4c585..bfe7ec1f30 100644 --- a/UI/MenuScreens.cpp +++ b/UI/MenuScreens.cpp @@ -939,7 +939,15 @@ void SystemScreen::render() { if (UICheckBox(GEN_ID, x, y += stride, s->T("12HR Time Format"), ALIGN_TOPLEFT, &tf)) { g_Config.itimeformat = tf ? 1 : 0; } - + bool bEnableCheats = g_Config.iEnableCheats != 0; + UICheckBox(GEN_ID, x, y += stride, s->T("Enable Cheats"), ALIGN_TOPLEFT, &bEnableCheats); + if (bEnableCheats) { + g_Config.iEnableCheats = 1; + } + else { + g_Config.iEnableCheats = 0; + } + bool reportingEnabled = Reporting::IsEnabled(); const static std::string reportHostOfficial = "report.ppsspp.org"; if (UICheckBox(GEN_ID, x, y += stride, s->T("Enable Compatibility Server Reports"), ALIGN_TOPLEFT, &reportingEnabled)) { diff --git a/Windows/WndMainWindow.cpp b/Windows/WndMainWindow.cpp index efddffe1a4..5ae55a7a45 100644 --- a/Windows/WndMainWindow.cpp +++ b/Windows/WndMainWindow.cpp @@ -186,6 +186,9 @@ namespace MainWindow void setFpsLimit(int fps) { g_Config.iFpsLimit = fps; } + void enableCheats(int cheats){ + g_Config.iEnableCheats = cheats; + } BOOL Show(HINSTANCE hInstance, int nCmdShow) { From eaf060015d9dc1ec3caf2f9f576b62eb5c5572f4 Mon Sep 17 00:00:00 2001 From: Steven Cherry Date: Sat, 18 May 2013 17:52:24 -0500 Subject: [PATCH 6/6] Final Version --- Core/Config.cpp | 2 ++ Core/CwCheat.cpp | 22 +++++++++++++++------- 2 files changed, 17 insertions(+), 7 deletions(-) diff --git a/Core/Config.cpp b/Core/Config.cpp index 995231f6d8..85492d9ff9 100644 --- a/Core/Config.cpp +++ b/Core/Config.cpp @@ -64,6 +64,7 @@ void Config::Load(const char *iniFileName) general->Get("Language", &languageIni, "en_US"); general->Get("NumWorkerThreads", &iNumWorkerThreads, cpu_info.num_cores); general->Get("MaxRecent", &iMaxRecent, 12); + general->Get("EnableCheats", &iEnableCheats, 0); // "default" means let emulator decide, "" means disable. general->Get("ReportHost", &sReportHost, "default"); @@ -180,6 +181,7 @@ void Config::Save() general->Set("Language", languageIni); general->Set("NumWorkerThreads", iNumWorkerThreads); general->Set("MaxRecent", iMaxRecent); + general->Set("EnableCheats", iEnableCheats); IniFile::Section *cpu = iniFile.GetOrCreateSection("CPU"); cpu->Set("Jit", bJit); diff --git a/Core/CwCheat.cpp b/Core/CwCheat.cpp index 1b8bf66221..35bcfe3b77 100644 --- a/Core/CwCheat.cpp +++ b/Core/CwCheat.cpp @@ -4,8 +4,11 @@ #include "StringUtils.h" #include "Common/FileUtil.h" #include "Config.h" +#include "MIPS/MIPS.h" + using namespace std; +string title, title2, title3; static int CheatEvent = -1; CWCheatEngine member; CWCheatEngine cheatsThread; @@ -13,12 +16,14 @@ void hleCheat(u64 userdata, int cyclesLate); void __CheatInit() { - + title ="Cheats/"; + title2 = g_paramSFO.GetValueString("DISC_ID").c_str(); + title3 = title + title2 + ".ini"; CheatEvent = CoreTiming::RegisterEvent("CheatEvent", &hleCheat); CoreTiming::ScheduleEvent(msToCycles(77), CheatEvent, 0); File::CreateFullPath("Cheats"); - if (!File::Exists("Cheats/Cheats.ini")) { - File::CreateEmptyFile("Cheats/Cheats.ini"); + if (!File::Exists(title3)) { + File::CreateEmptyFile(title3); } } void __CheatShutdown() { @@ -28,7 +33,7 @@ void __CheatShutdown() { void hleCheat(u64 userdata, int cyclesLate) { CoreTiming::ScheduleEvent(msToCycles(77), CheatEvent, 0); if (g_Config.iEnableCheats == 1) { - member.Run(); + member.Run(); } } @@ -124,20 +129,23 @@ inline vector makeCodeParts(string l) { vector CWCheatEngine::GetCodesList() { string line; + string path = __FILE__; + path = path.substr(0,1+path.find_last_of('\\')); + path+= title3; char* skip = "//"; vector codesList; //Read from INI here - ifstream list("D:\\User\\Steven\\Documents\\GitHub\\ppsspp\\Cheats\\Cheats.ini"); + ifstream list(title3); for (int i = 0; !list.eof(); i ++) { getline(list,line, '\n'); if (line.substr(0,2) == skip) {line.clear(); } else { - codesList.push_back(line); + codesList.push_back(line); } } for( int i = 0; i < codesList.size(); i++) { - trim2(codesList[i]); + trim2(codesList[i]); } return codesList; }