2069 lines
75 KiB
C
2069 lines
75 KiB
C
/*
|
|
* This file is part of Luma3DS
|
|
* Copyright (C) 2016-2019 Aurora Wright, TuxSH
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* Additional Terms 7.b and 7.c of GPLv3 apply to this file:
|
|
* * Requiring preservation of specified reasonable legal notices or
|
|
* author attributions in that material or in the Appropriate Legal
|
|
* Notices displayed by works containing it.
|
|
* * Prohibiting misrepresentation of the origin of that material,
|
|
* or requiring that modified versions of such material be marked in
|
|
* reasonable ways as different from the original version.
|
|
*/
|
|
|
|
#include <3ds.h>
|
|
#include <stdlib.h>
|
|
#include "menus/cheats.h"
|
|
#include "memory.h"
|
|
#include "draw.h"
|
|
#include "menu.h"
|
|
#include "utils.h"
|
|
#include "fmt.h"
|
|
#include "ifile.h"
|
|
|
|
#define MAKE_QWORD(hi,low) \
|
|
((u64) ((((u64)(hi)) << 32) | (low)))
|
|
|
|
typedef struct CheatProcessInfo
|
|
{
|
|
u32 pid;
|
|
u64 titleId;
|
|
} CheatProcessInfo;
|
|
|
|
typedef struct CheatDescription
|
|
{
|
|
struct {
|
|
u8 active : 1;
|
|
u8 valid : 1;
|
|
u8 hasKeyCode : 1;
|
|
u8 activeStorage : 1;
|
|
};
|
|
char name[39];
|
|
u32 codesCount;
|
|
u32 storage1;
|
|
u32 storage2;
|
|
u64 codes[0];
|
|
} CheatDescription;
|
|
|
|
typedef struct BufferedFile
|
|
{
|
|
IFile file;
|
|
u64 curPos;
|
|
u64 maxPos;
|
|
char buffer[512];
|
|
} BufferedFile;
|
|
|
|
CheatDescription* cheats[1024] = { 0 };
|
|
u8 cheatBuffer[32768] = { 0 };
|
|
u8 cheatPage[0x1000] = { 0 };
|
|
|
|
static CheatProcessInfo cheatinfo[0x40] = { 0 };
|
|
|
|
static s32 Cheats_FetchProcessInfo(void)
|
|
{
|
|
u32 pidList[0x40];
|
|
s32 processAmount;
|
|
|
|
s64 sa, textTotalRoundedSize, rodataTotalRoundedSize, dataTotalRoundedSize;
|
|
|
|
svcGetProcessList(&processAmount, pidList, 0x40);
|
|
|
|
for (s32 i = 0; i < processAmount; i++)
|
|
{
|
|
Handle processHandle;
|
|
Result res = svcOpenProcess(&processHandle, pidList[i]);
|
|
if (R_FAILED(res)) continue;
|
|
|
|
cheatinfo[i].pid = pidList[i];
|
|
svcGetProcessInfo((s64 *) &cheatinfo[i].titleId, processHandle, 0x10001);
|
|
svcGetProcessInfo(&textTotalRoundedSize, processHandle, 0x10002);
|
|
svcGetProcessInfo(&rodataTotalRoundedSize, processHandle, 0x10003);
|
|
svcGetProcessInfo(&dataTotalRoundedSize, processHandle, 0x10004);
|
|
svcGetProcessInfo(&sa, processHandle, 0x10005);
|
|
|
|
svcCloseHandle(processHandle);
|
|
}
|
|
|
|
return processAmount;
|
|
}
|
|
|
|
typedef struct CheatState
|
|
{
|
|
u32 index;
|
|
u32 offset1;
|
|
u32 offset2;
|
|
u32 data1;
|
|
u32 data2;
|
|
struct {
|
|
u8 activeOffset : 1;
|
|
u8 activeData : 1;
|
|
u8 conditionalMode : 3;
|
|
u8 data1Mode : 1;
|
|
u8 data2Mode : 1;
|
|
u8 floatMode : 1;
|
|
};
|
|
u8 typeELine;
|
|
u8 typeEIdx;
|
|
|
|
s8 loopLine;
|
|
u32 loopCount;
|
|
|
|
u32 ifStack;
|
|
u32 storedStack;
|
|
u8 ifCount;
|
|
u8 storedIfCount;
|
|
|
|
} CheatState;
|
|
|
|
CheatState cheat_state = { 0 };
|
|
u8 cheatCount = 0;
|
|
u64 cheatTitleInfo = -1ULL;
|
|
|
|
static inline u32* activeOffset()
|
|
{
|
|
return cheat_state.activeOffset ? &cheat_state.offset2 : &cheat_state.offset1;
|
|
}
|
|
|
|
static inline u32* activeData()
|
|
{
|
|
return cheat_state.activeData ? &cheat_state.data2 : &cheat_state.data1;
|
|
}
|
|
|
|
static inline u32* activeStorage(CheatDescription* desc)
|
|
{
|
|
return desc->activeStorage ? &desc->storage2 : &desc->storage1;
|
|
}
|
|
|
|
char failureReason[64];
|
|
|
|
static bool Cheat_IsValidAddress(const Handle processHandle, u32 address, u32 size)
|
|
{
|
|
MemInfo info;
|
|
PageInfo out;
|
|
|
|
Result res = svcQueryDebugProcessMemory(&info, &out, processHandle, address);
|
|
if (R_SUCCEEDED(res) && info.state != MEMSTATE_FREE && info.base_addr > 0 && info.base_addr <= address && address <= info.base_addr + info.size - size) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static u32 ReadWriteBuffer32 = 0;
|
|
static u16 ReadWriteBuffer16 = 0;
|
|
static u8 ReadWriteBuffer8 = 0;
|
|
|
|
static bool Cheat_Write8(const Handle processHandle, u32 offset, u8 value)
|
|
{
|
|
u32 addr = *activeOffset() + offset;
|
|
if (addr >= 0x01E81000 && addr + 1 < 0x01E82000)
|
|
{
|
|
cheatPage[addr - 0x01E81000] = value;
|
|
return true;
|
|
}
|
|
if (Cheat_IsValidAddress(processHandle, addr, 1))
|
|
{
|
|
*((u8*) (&ReadWriteBuffer8)) = value;
|
|
return R_SUCCEEDED(svcWriteProcessMemory(processHandle, &ReadWriteBuffer8, addr, 1));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool Cheat_Write16(const Handle processHandle, u32 offset, u16 value)
|
|
{
|
|
u32 addr = *activeOffset() + offset;
|
|
if (addr >= 0x01E81000 && addr + 2 < 0x01E82000)
|
|
{
|
|
*(u16*)(cheatPage + addr - 0x01E81000) = value;
|
|
return true;
|
|
}
|
|
if (Cheat_IsValidAddress(processHandle, addr, 2))
|
|
{
|
|
*((u16*) (&ReadWriteBuffer16)) = value;
|
|
return R_SUCCEEDED(svcWriteProcessMemory(processHandle, &ReadWriteBuffer16, addr, 2));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool Cheat_Write32(const Handle processHandle, u32 offset, u32 value)
|
|
{
|
|
u32 addr = *activeOffset() + offset;
|
|
if (addr >= 0x01E81000 && addr + 4 < 0x01E82000)
|
|
{
|
|
*(u32*)(cheatPage + addr - 0x01E81000) = value;
|
|
return true;
|
|
}
|
|
if (Cheat_IsValidAddress(processHandle, addr, 4))
|
|
{
|
|
*((u32*) (&ReadWriteBuffer32)) = value;
|
|
return R_SUCCEEDED(svcWriteProcessMemory(processHandle, &ReadWriteBuffer32, addr, 4));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool Cheat_Read8(const Handle processHandle, u32 offset, u8* retValue)
|
|
{
|
|
u32 addr = *activeOffset() + offset;
|
|
if (addr >= 0x01E81000 && addr + 1 < 0x01E82000)
|
|
{
|
|
*retValue = cheatPage[addr - 0x01E81000];
|
|
return true;
|
|
}
|
|
if (Cheat_IsValidAddress(processHandle, addr, 1))
|
|
{
|
|
Result res = svcReadProcessMemory(&ReadWriteBuffer8, processHandle, addr, 1);
|
|
*retValue = *((u8*) (&ReadWriteBuffer8));
|
|
return R_SUCCEEDED(res);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool Cheat_Read16(const Handle processHandle, u32 offset, u16* retValue)
|
|
{
|
|
u32 addr = *activeOffset() + offset;
|
|
if (addr >= 0x01E81000 && addr + 2 < 0x01E82000)
|
|
{
|
|
*retValue = *(u16*)(cheatPage + addr - 0x01E81000);
|
|
return true;
|
|
}
|
|
if (Cheat_IsValidAddress(processHandle, addr, 2))
|
|
{
|
|
Result res = svcReadProcessMemory(&ReadWriteBuffer16, processHandle, addr, 2);
|
|
*retValue = *((u16*) (&ReadWriteBuffer16));
|
|
return R_SUCCEEDED(res);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool Cheat_Read32(const Handle processHandle, u32 offset, u32* retValue)
|
|
{
|
|
u32 addr = *activeOffset() + offset;
|
|
if (addr >= 0x01E81000 && addr + 4 < 0x01E82000)
|
|
{
|
|
*retValue = *(u32*)(cheatPage + addr - 0x01E81000);
|
|
return true;
|
|
}
|
|
if (Cheat_IsValidAddress(processHandle, addr, 4))
|
|
{
|
|
Result res = svcReadProcessMemory(&ReadWriteBuffer32, processHandle, addr, 4);
|
|
*retValue = *((u32*) (&ReadWriteBuffer32));
|
|
return R_SUCCEEDED(res);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static u8 typeEMapping[] = { 4 << 3, 5 << 3, 6 << 3, 7 << 3, 0 << 3, 1 << 3, 2 << 3, 3 << 3 };
|
|
|
|
static u8 Cheat_GetNextTypeE(const CheatDescription* cheat)
|
|
{
|
|
|
|
if (cheat_state.typeEIdx == 7)
|
|
{
|
|
cheat_state.typeEIdx = 0;
|
|
cheat_state.typeELine++;
|
|
}
|
|
else
|
|
{
|
|
cheat_state.typeEIdx++;
|
|
}
|
|
return (u8) ((cheat->codes[cheat_state.typeELine] >> (typeEMapping[cheat_state.typeEIdx])) & 0xFF);
|
|
}
|
|
|
|
static u32 Cheat_ApplyCheat(const Handle processHandle, CheatDescription* const cheat)
|
|
{
|
|
cheat_state.index = 0;
|
|
cheat_state.offset1 = 0;
|
|
cheat_state.offset2 = 0;
|
|
cheat_state.data1 = 0;
|
|
cheat_state.data2 = 0;
|
|
cheat_state.activeOffset = 0;
|
|
cheat_state.activeData = 0;
|
|
cheat_state.conditionalMode = 0;
|
|
cheat_state.data1Mode = 0;
|
|
cheat_state.data2Mode = 0;
|
|
cheat_state.floatMode = 0;
|
|
cheat_state.loopCount = 0;
|
|
cheat_state.loopLine = -1;
|
|
cheat_state.ifStack = 0;
|
|
cheat_state.storedStack = 0;
|
|
cheat_state.ifCount = 0;
|
|
cheat_state.storedIfCount = 0;
|
|
|
|
while (cheat_state.index < cheat->codesCount)
|
|
{
|
|
bool skipExecution = (cheat_state.ifStack & 0x00000001) != 0;
|
|
u32 arg0 = (u32) ((cheat->codes[cheat_state.index] >> 32) & 0x00000000FFFFFFFFULL);
|
|
u32 arg1 = (u32) ((cheat->codes[cheat_state.index]) & 0x00000000FFFFFFFFULL);
|
|
if (arg0 == 0 && arg1 == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
u32 code = ((arg0 >> 28) & 0x0F);
|
|
u32 subcode = ((arg0 >> 24) & 0x0F);
|
|
u32 codeArg = arg0 & 0x0F;
|
|
|
|
switch (code)
|
|
{
|
|
case 0x0:
|
|
// 0 Type
|
|
// Format: 0XXXXXXX YYYYYYYY
|
|
// Description: 32bit write of YYYYYYYY to 0XXXXXXX.
|
|
if (!skipExecution)
|
|
{
|
|
if (!Cheat_Write32(processHandle, (arg0 & 0x0FFFFFFF), arg1)) return 0;
|
|
}
|
|
break;
|
|
case 0x1:
|
|
// 1 Type
|
|
// Format: 1XXXXXXX 0000YYYY
|
|
// Description: 16bit write of YYYY to 0XXXXXXX.
|
|
if (!skipExecution)
|
|
{
|
|
if (!Cheat_Write16(processHandle, (arg0 & 0x0FFFFFFF), (u16) (arg1 & 0xFFFF))) return 0;
|
|
}
|
|
break;
|
|
case 0x2:
|
|
// 2 Type
|
|
// Format: 2XXXXXXX 000000YY
|
|
// Description: 8bit write of YY to 0XXXXXXX.
|
|
if (!skipExecution)
|
|
{
|
|
if (!Cheat_Write8(processHandle, (arg0 & 0x0FFFFFFF), (u8) (arg1 & 0xFF))) return 0;
|
|
}
|
|
break;
|
|
case 0x3:
|
|
// 3 Type
|
|
// Format: 3XXXXXXXX YYYYYYYY
|
|
// Description: 32bit if less than.
|
|
// Simple: If the value at address 0XXXXXXX is less than the value YYYYYYYY.
|
|
// Example: 323D6B28 10000000
|
|
{
|
|
u32 value = 0;
|
|
if (!Cheat_Read32(processHandle, arg0 & 0x0FFFFFFF, &value)) return 0;
|
|
|
|
cheat_state.ifStack <<= 1;
|
|
if (value < arg1)
|
|
{
|
|
cheat_state.ifStack |= skipExecution ? 1 : 0;
|
|
}
|
|
else
|
|
{
|
|
cheat_state.ifStack |= 1;
|
|
}
|
|
cheat_state.ifCount++;
|
|
}
|
|
break;
|
|
case 0x4:
|
|
// 4 Type
|
|
// Format: 4XXXXXXXX YYYYYYYY
|
|
// Description: 32bit if greater than.
|
|
// Simple: If the value at address 0XXXXXXX is greater than the value YYYYYYYY.
|
|
// Example: 423D6B28 10000000
|
|
{
|
|
u32 value = 0;
|
|
if (!Cheat_Read32(processHandle, arg0 & 0x0FFFFFFF, &value)) return 0;
|
|
|
|
cheat_state.ifStack <<= 1;
|
|
if (value > arg1)
|
|
{
|
|
cheat_state.ifStack |= skipExecution ? 1 : 0;
|
|
}
|
|
else
|
|
{
|
|
cheat_state.ifStack |= 1;
|
|
}
|
|
cheat_state.ifCount++;
|
|
}
|
|
break;
|
|
case 0x5:
|
|
// 5 Type
|
|
// Format: 5XXXXXXXX YYYYYYYY
|
|
// Description: 32bit if equal to.
|
|
// Simple: If the value at address 0XXXXXXX is equal to the value YYYYYYYY.
|
|
// Example: 523D6B28 10000000
|
|
{
|
|
u32 value = 0;
|
|
if (!Cheat_Read32(processHandle, arg0 & 0x0FFFFFFF, &value)) return 0;
|
|
|
|
cheat_state.ifStack <<= 1;
|
|
if (value == arg1)
|
|
{
|
|
cheat_state.ifStack |= skipExecution ? 1 : 0;
|
|
}
|
|
else
|
|
{
|
|
cheat_state.ifStack |= 1;
|
|
}
|
|
cheat_state.ifCount++;
|
|
}
|
|
break;
|
|
case 0x6:
|
|
// 6 Type
|
|
// Format: 3XXXXXXXX YYYYYYYY
|
|
// Description: 32bit if not equal to.
|
|
// Simple: If the value at address 0XXXXXXX is not equal to the value YYYYYYYY.
|
|
// Example: 623D6B28 10000000
|
|
{
|
|
u32 value = 0;
|
|
if (!Cheat_Read32(processHandle, arg0 & 0x0FFFFFFF, &value)) return 0;
|
|
|
|
cheat_state.ifStack <<= 1;
|
|
if (value != arg1)
|
|
{
|
|
cheat_state.ifStack |= skipExecution ? 1 : 0;
|
|
}
|
|
else
|
|
{
|
|
cheat_state.ifStack |= 1;
|
|
}
|
|
cheat_state.ifCount++;
|
|
}
|
|
break;
|
|
case 0x7:
|
|
// 7 Type
|
|
// Format: 7XXXXXXXX 0000YYYY
|
|
// Description: 16bit if less than.
|
|
// Simple: If the value at address 0XXXXXXX is less than the value YYYY.
|
|
// Example: 723D6B28 00005400
|
|
{
|
|
bool newSkip;
|
|
u16 mask = (u16) ((arg1 >> 16) & 0xFFFF);
|
|
u16 value = 0;
|
|
if (!Cheat_Read16(processHandle, arg0 & 0x0FFFFFFF, &value)) return 0;
|
|
switch (cheat_state.conditionalMode)
|
|
{
|
|
case 0x0:
|
|
newSkip = !((value & (~mask)) < (arg1 & 0xFFFF));
|
|
break;
|
|
case 0x1:
|
|
newSkip = !((value & (~mask)) < (*activeData() & (~mask)));
|
|
break;
|
|
case 0x2:
|
|
newSkip = !((*activeData() & (~mask)) < (arg1 & 0xFFFF));
|
|
break;
|
|
case 0x3:
|
|
newSkip = !((*activeStorage(cheat) & (~mask)) < (arg1 & 0xFFFF));
|
|
break;
|
|
case 0x4:
|
|
newSkip = !((*activeData() & (~mask)) < (*activeStorage(cheat) & (~mask)));
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
cheat_state.ifStack <<= 1;
|
|
cheat_state.ifStack |= (newSkip || skipExecution) ? 1 : 0;
|
|
cheat_state.ifCount++;
|
|
}
|
|
break;
|
|
case 0x8:
|
|
// 8 Type
|
|
// Format: 8XXXXXXXX 0000YYYY
|
|
// Description: 16bit if greater than.
|
|
// Simple: If the value at address 0XXXXXXX is greater than the value YYYY.
|
|
// Example: 823D6B28 00005400
|
|
{
|
|
bool newSkip;
|
|
u16 mask = (u16) ((arg1 >> 16) & 0xFFFF);
|
|
u16 value = 0;
|
|
if (!Cheat_Read16(processHandle, arg0 & 0x0FFFFFFF, &value)) return 0;
|
|
switch (cheat_state.conditionalMode)
|
|
{
|
|
case 0x0:
|
|
newSkip = !((value & (~mask)) > (arg1 & 0xFFFF));
|
|
break;
|
|
case 0x1:
|
|
newSkip = !((value & (~mask)) > (*activeData() & (~mask)));
|
|
break;
|
|
case 0x2:
|
|
newSkip = !((*activeData() & (~mask)) > (arg1 & 0xFFFF));
|
|
break;
|
|
case 0x3:
|
|
newSkip = !((*activeStorage(cheat) & (~mask)) > (arg1 & 0xFFFF));
|
|
break;
|
|
case 0x4:
|
|
newSkip = !((*activeData() & (~mask)) > (*activeStorage(cheat) & (~mask)));
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
cheat_state.ifStack <<= 1;
|
|
cheat_state.ifStack |= (newSkip || skipExecution) ? 1 : 0;
|
|
cheat_state.ifCount++;
|
|
}
|
|
break;
|
|
case 0x9:
|
|
// 9 Type
|
|
// Format: 9XXXXXXXX 0000YYYY
|
|
// Description: 16bit if equal to.
|
|
// Simple: If the value at address 0XXXXXXX is equal to the value YYYY.
|
|
// Example: 923D6B28 00005400
|
|
{
|
|
bool newSkip;
|
|
u16 mask = (u16) ((arg1 >> 16) & 0xFFFF);
|
|
u16 value = 0;
|
|
if (!Cheat_Read16(processHandle, arg0 & 0x0FFFFFFF, &value)) return 0;
|
|
switch (cheat_state.conditionalMode)
|
|
{
|
|
case 0x0:
|
|
newSkip = !((value & (~mask)) == (arg1 & 0xFFFF));
|
|
break;
|
|
case 0x1:
|
|
newSkip = !((value & (~mask)) == (*activeData() & (~mask)));
|
|
break;
|
|
case 0x2:
|
|
newSkip = !((*activeData() & (~mask)) == (arg1 & 0xFFFF));
|
|
break;
|
|
case 0x3:
|
|
newSkip = !((*activeStorage(cheat) & (~mask)) == (arg1 & 0xFFFF));
|
|
break;
|
|
case 0x4:
|
|
newSkip = !((*activeData() & (~mask)) == (*activeStorage(cheat) & (~mask)));
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
cheat_state.ifStack <<= 1;
|
|
cheat_state.ifStack |= (newSkip || skipExecution) ? 1 : 0;
|
|
cheat_state.ifCount++;
|
|
}
|
|
break;
|
|
case 0xA:
|
|
// A Type
|
|
// Format: AXXXXXXXX 0000YYYY
|
|
// Description: 16bit if not equal to.
|
|
// Simple: If the value at address 0XXXXXXX is not equal to the value YYYY.
|
|
// Example: A23D6B28 00005400
|
|
{
|
|
bool newSkip;
|
|
u16 mask = (u16) ((arg1 >> 16) & 0xFFFF);
|
|
u16 value = 0;
|
|
if (!Cheat_Read16(processHandle, arg0 & 0x0FFFFFFF, &value)) return 0;
|
|
switch (cheat_state.conditionalMode)
|
|
{
|
|
case 0x0:
|
|
newSkip = !((value & (~mask)) != (arg1 & 0xFFFF));
|
|
break;
|
|
case 0x1:
|
|
newSkip = !((value & (~mask)) != (*activeData() & (~mask)));
|
|
break;
|
|
case 0x2:
|
|
newSkip = !((*activeData() & (~mask)) != (arg1 & 0xFFFF));
|
|
break;
|
|
case 0x3:
|
|
newSkip = !((*activeStorage(cheat) & (~mask)) != (arg1 & 0xFFFF));
|
|
break;
|
|
case 0x4:
|
|
newSkip = !((*activeData() & (~mask)) != (*activeStorage(cheat) & (~mask)));
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
cheat_state.ifStack <<= 1;
|
|
cheat_state.ifStack |= (newSkip || skipExecution) ? 1 : 0;
|
|
cheat_state.ifCount++;
|
|
}
|
|
break;
|
|
|
|
case 0xB:
|
|
// B Type
|
|
// Format: BXXXXXXX 00000000
|
|
// Description: Loads offset register with value at given XXXXXXX
|
|
if (!skipExecution)
|
|
{
|
|
u32 value;
|
|
if (!Cheat_Read32(processHandle, arg0 & 0x0FFFFFFF, &value)) return 0;
|
|
*activeOffset() = value;
|
|
}
|
|
break;
|
|
case 0xC:
|
|
// C Type
|
|
// Format: C0000000 ZZZZZZZZ
|
|
// Description: Repeat following lines at specified offset.
|
|
// Simple: used to write a value to an address, and then continues to write that value Z number of times to all addresses at an offset determined by the (D6, D7, D8, or DC) type following it.
|
|
// Note: used with the D6, D7, D8, and DC types. C types can not be nested.
|
|
// Example:
|
|
|
|
// C0000000 00000005
|
|
// 023D6B28 0009896C
|
|
// DC000000 00000010
|
|
// D2000000 00000000
|
|
switch (subcode)
|
|
{
|
|
case 0x00:
|
|
cheat_state.loopLine = cheat_state.index;
|
|
cheat_state.loopCount = arg1;
|
|
cheat_state.storedStack = cheat_state.ifStack;
|
|
cheat_state.storedIfCount = cheat_state.ifCount;
|
|
break;
|
|
case 0x01:
|
|
cheat_state.loopLine = cheat_state.index;
|
|
cheat_state.loopCount = cheat_state.data1;
|
|
cheat_state.storedStack = cheat_state.ifStack;
|
|
cheat_state.storedIfCount = cheat_state.ifCount;
|
|
break;
|
|
case 0x02:
|
|
cheat_state.loopLine = cheat_state.index;
|
|
cheat_state.loopCount = cheat_state.data2;
|
|
cheat_state.storedStack = cheat_state.ifStack;
|
|
cheat_state.storedIfCount = cheat_state.ifCount;
|
|
break;
|
|
}
|
|
break;
|
|
case 0xD:
|
|
switch (subcode)
|
|
{
|
|
case 0x00:
|
|
// D0 Type
|
|
// Format: D0000000 00000000
|
|
// Description: ends most recent conditional.
|
|
// Simple: type 3 through A are all "conditionals," the conditional most recently executed before this line will be terminated by it.
|
|
// Example:
|
|
|
|
// 94000130 FFFB0000
|
|
// 74000100 FF00000C
|
|
// 023D6B28 0009896C
|
|
// D0000000 00000000
|
|
|
|
// The 7 type line would be terminated.
|
|
if (arg1 == 0)
|
|
{
|
|
if (cheat_state.loopLine != -1)
|
|
{
|
|
if (cheat_state.ifCount > 0 && cheat_state.ifCount > cheat_state.storedIfCount)
|
|
{
|
|
cheat_state.ifStack >>= 1;
|
|
cheat_state.ifCount--;
|
|
}
|
|
else
|
|
{
|
|
|
|
if (cheat_state.loopCount > 0)
|
|
{
|
|
cheat_state.loopCount--;
|
|
if (cheat_state.loopCount == 0)
|
|
{
|
|
cheat_state.loopLine = -1;
|
|
}
|
|
else if (cheat_state.loopLine != -1)
|
|
{
|
|
cheat_state.index = cheat_state.loopLine;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (cheat_state.ifCount > 0)
|
|
{
|
|
cheat_state.ifStack >>= 1;
|
|
cheat_state.ifCount--;
|
|
}
|
|
}
|
|
}
|
|
// D0000000 00000001
|
|
// Loop break
|
|
else if (!skipExecution && arg1 == 1)
|
|
{
|
|
cheat_state.loopCount = 0;
|
|
cheat_state.loopLine = -1;
|
|
cheat_state.index++;
|
|
while (cheat_state.index < cheat->codesCount)
|
|
{
|
|
u64 code = cheat->codes[cheat_state.index++];
|
|
if (code == 0xD100000000000000ull || code == 0xD200000000000000ull)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 0x01:
|
|
// D1 Type
|
|
// Format: D1000000 00000000
|
|
// Description: ends repeat block.
|
|
// Simple: will end all conditionals within a C type code, along with the C type itself.
|
|
// Example:
|
|
|
|
// 94000130 FFFB0000
|
|
// C0000000 00000010
|
|
// 8453DA0C 00000200
|
|
// 023D6B28 0009896C
|
|
// D6000000 00000005
|
|
// D1000000 00000000
|
|
|
|
// The C line, 8 line, 0 line, and D6 line would be terminated.
|
|
if (cheat_state.loopCount > 0)
|
|
{
|
|
cheat_state.ifStack = cheat_state.storedStack;
|
|
cheat_state.ifCount = cheat_state.storedIfCount;
|
|
cheat_state.loopCount--;
|
|
if (cheat_state.loopCount == 0)
|
|
{
|
|
cheat_state.loopLine = -1;
|
|
}
|
|
else
|
|
{
|
|
if (cheat_state.loopLine != -1)
|
|
{
|
|
cheat_state.index = cheat_state.loopLine;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 0x02:
|
|
// D2 Type
|
|
// Format: D2000000 00000000
|
|
// Description: ends all conditionals/repeats before it and sets offset and stored to zero.
|
|
// Simple: ends all lines.
|
|
// Example:
|
|
|
|
// 94000130 FEEF0000
|
|
// C0000000 00000010
|
|
// 8453DA0C 00000200
|
|
// 023D6B28 0009896C
|
|
// D6000000 00000005
|
|
// D2000000 00000000
|
|
|
|
// All lines would terminate.
|
|
if (arg1 == 0)
|
|
{
|
|
if (cheat_state.loopCount > 0)
|
|
{
|
|
cheat_state.loopCount--;
|
|
if (cheat_state.loopCount == 0)
|
|
{
|
|
*activeData() = 0;
|
|
*activeOffset() = 0;
|
|
cheat_state.loopLine = -1;
|
|
|
|
cheat_state.ifStack = 0;
|
|
cheat_state.ifCount = 0;
|
|
}
|
|
else
|
|
{
|
|
if (cheat_state.loopLine != -1)
|
|
{
|
|
cheat_state.index = cheat_state.loopLine;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*activeData() = 0;
|
|
*activeOffset() = 0;
|
|
cheat_state.ifStack = 0;
|
|
cheat_state.ifCount = 0;
|
|
}
|
|
}
|
|
// D2000000 00000001
|
|
// Return
|
|
else if (!skipExecution && arg1 == 1)
|
|
{
|
|
cheat_state.index = cheat->codesCount;
|
|
}
|
|
break;
|
|
case 0x03:
|
|
// D3 Type
|
|
// Format: D3000000 XXXXXXXX
|
|
// Description: sets offset.
|
|
// Simple: loads the address X so that lines after can modify the value at address X.
|
|
// Note: used with the D4, D5, D6, D7, D8, and DC types.
|
|
// Example: D3000000 023D6B28
|
|
if (!skipExecution)
|
|
{
|
|
if (codeArg == 0)
|
|
{
|
|
cheat_state.offset1 = arg1;
|
|
}
|
|
else if (codeArg == 1)
|
|
{
|
|
cheat_state.offset2 = arg1;
|
|
}
|
|
}
|
|
break;
|
|
case 0x04:
|
|
// D4 Type
|
|
// Format: D4000000 YYYYYYYY
|
|
// Description: adds to the stored address' value.
|
|
// Simple: adds to the value at the address defined by lines D3, D9, DA, and DB.
|
|
// Note: used with the D3, D9, DA, DB, DC types.
|
|
// Example: D4000000 00000025
|
|
if (!skipExecution)
|
|
{
|
|
if (codeArg == 0)
|
|
{
|
|
*activeData() += arg1;
|
|
}
|
|
else if (codeArg == 1)
|
|
{
|
|
cheat_state.data1 += arg1 + cheat_state.data2;
|
|
}
|
|
else if (codeArg == 2)
|
|
{
|
|
cheat_state.data2 += arg1 + cheat_state.data1;
|
|
}
|
|
}
|
|
break;
|
|
case 0x05:
|
|
// D5 Type
|
|
// Format: D5000000 YYYYYYYY
|
|
// Description: sets the stored address' value.
|
|
// Simple: makes the value at the address defined by lines D3, D9, DA, and DB to YYYYYYYY.
|
|
// Note: used with the D3, D9, DA, DB, and DC types.
|
|
// Example: D5000000 34540099
|
|
if (!skipExecution)
|
|
{
|
|
if (codeArg == 0)
|
|
{
|
|
*activeData() = arg1;
|
|
}
|
|
else if (codeArg == 1)
|
|
{
|
|
cheat_state.data1 = arg1;
|
|
}
|
|
else if (codeArg == 2)
|
|
{
|
|
cheat_state.data2 = arg1;
|
|
}
|
|
}
|
|
break;
|
|
case 0x06:
|
|
// D6 Type
|
|
// Format: D6000000 XXXXXXXX
|
|
// Description: 32bit store and increment by 4.
|
|
// Simple: stores the value at address XXXXXXXX and to addresses in increments of 4.
|
|
// Note: used with the C, D3, and D9 types.
|
|
// Example: D3000000 023D6B28
|
|
if (!skipExecution)
|
|
{
|
|
if (codeArg == 0)
|
|
{
|
|
if (!Cheat_Write32(processHandle, arg1, *activeData())) return 0;
|
|
*activeOffset() += 4;
|
|
}
|
|
else if (codeArg == 1)
|
|
{
|
|
if (!Cheat_Write32(processHandle, arg1, cheat_state.data1)) return 0;
|
|
*activeOffset() += 4;
|
|
}
|
|
else if (codeArg == 2)
|
|
{
|
|
if (!Cheat_Write32(processHandle, arg1, cheat_state.data2)) return 0;
|
|
*activeOffset() += 4;
|
|
}
|
|
}
|
|
break;
|
|
case 0x07:
|
|
// D7 Type
|
|
// Format: D7000000 XXXXXXXX
|
|
// Description: 16bit store and increment by 2.
|
|
// Simple: stores 2 bytes of the value at address XXXXXXXX and to addresses in increments of 2.
|
|
// Note: used with the C, D3, and DA types.
|
|
// Example: D7000000 023D6B28
|
|
if (!skipExecution)
|
|
{
|
|
if (codeArg == 0)
|
|
{
|
|
if (!Cheat_Write16(processHandle, arg1, (u16) (*activeData() & 0xFFFF))) return 0;
|
|
*activeOffset() += 2;
|
|
}
|
|
else if (codeArg == 1)
|
|
{
|
|
if (!Cheat_Write16(processHandle, arg1, (u16) (cheat_state.data1 & 0xFFFF))) return 0;
|
|
*activeOffset() += 2;
|
|
}
|
|
else if (codeArg == 2)
|
|
{
|
|
if (!Cheat_Write16(processHandle, arg1, (u16) (cheat_state.data2 & 0xFFFF))) return 0;
|
|
*activeOffset() += 2;
|
|
}
|
|
}
|
|
break;
|
|
case 0x08:
|
|
// D8 Type
|
|
// Format: D8000000 XXXXXXXX
|
|
// Description: 8bit store and increment by 1.
|
|
// Simple: stores 1 byte of the value at address XXXXXXXX and to addresses in increments of 1.
|
|
// Note: used with the C, D3, and DB types.
|
|
// Example: D8000000 023D6B28
|
|
if (!skipExecution)
|
|
{
|
|
if (codeArg == 0)
|
|
{
|
|
if (!Cheat_Write8(processHandle, arg1, (u8) (*activeData() & 0xFF))) return 0;
|
|
*activeOffset() += 1;
|
|
}
|
|
else if (codeArg == 1)
|
|
{
|
|
if (!Cheat_Write8(processHandle, arg1, (u8) (cheat_state.data1 & 0xFF))) return 0;
|
|
*activeOffset() += 1;
|
|
}
|
|
else if (codeArg == 2)
|
|
{
|
|
if (!Cheat_Write8(processHandle, arg1, (u8) (cheat_state.data2 & 0xFF))) return 0;
|
|
*activeOffset() += 1;
|
|
}
|
|
}
|
|
break;
|
|
case 0x09:
|
|
// D9 Type
|
|
// Format: D9000000 XXXXXXXX
|
|
// Description: 32bit load.
|
|
// Simple: loads the value from address X.
|
|
// Note: used with the D5 and D6 types.
|
|
// Example: D9000000 023D6B28
|
|
if (!skipExecution)
|
|
{
|
|
if (codeArg == 0)
|
|
{
|
|
u32 value = 0;
|
|
if (!Cheat_Read32(processHandle, arg1, &value)) return 0;
|
|
*activeData() = value;
|
|
}
|
|
else if (codeArg == 1)
|
|
{
|
|
u32 value = 0;
|
|
if (!Cheat_Read32(processHandle, arg1, &value)) return 0;
|
|
cheat_state.data1 = value;
|
|
}
|
|
else if (codeArg == 2)
|
|
{
|
|
u32 value = 0;
|
|
if (!Cheat_Read32(processHandle, arg1, &value)) return 0;
|
|
cheat_state.data2 = value;
|
|
}
|
|
}
|
|
break;
|
|
case 0x0A:
|
|
// DA Type
|
|
// Format: DA000000 XXXXXXXX
|
|
// Description: 16bit load.
|
|
// Simple: loads 2 bytes from address X.
|
|
// Note: used with the D5 and D7 types.
|
|
// Example: DA000000 023D6B28
|
|
if (!skipExecution)
|
|
{
|
|
if (codeArg == 0)
|
|
{
|
|
u16 value = 0;
|
|
if (!Cheat_Read16(processHandle, arg1, &value)) return 0;
|
|
*activeData() = value;
|
|
}
|
|
else if (codeArg == 1)
|
|
{
|
|
u16 value = 0;
|
|
if (!Cheat_Read16(processHandle, arg1, &value)) return 0;
|
|
cheat_state.data1 = value;
|
|
}
|
|
else if (codeArg == 2)
|
|
{
|
|
u16 value = 0;
|
|
if (!Cheat_Read16(processHandle, arg1, &value)) return 0;
|
|
cheat_state.data2 = value;
|
|
}
|
|
}
|
|
break;
|
|
case 0x0B:
|
|
// DB Type
|
|
// Format: DB000000 XXXXXXXX
|
|
// Description: 8bit load.
|
|
// Simple: loads 1 byte from address X.
|
|
// Note: used with the D5 and D8 types.
|
|
// Example: DB000000 023D6B28
|
|
if (!skipExecution)
|
|
{
|
|
if (codeArg == 0)
|
|
{
|
|
u8 value = 0;
|
|
if (!Cheat_Read8(processHandle, arg1, &value)) return 0;
|
|
*activeData() = value;
|
|
}
|
|
else if (codeArg == 1)
|
|
{
|
|
u8 value = 0;
|
|
if (!Cheat_Read8(processHandle, arg1, &value)) return 0;
|
|
cheat_state.data1 = value;
|
|
}
|
|
else if (codeArg == 2)
|
|
{
|
|
u8 value = 0;
|
|
if (!Cheat_Read8(processHandle, arg1, &value)) return 0;
|
|
cheat_state.data2 = value;
|
|
}
|
|
}
|
|
break;
|
|
case 0x0C:
|
|
// DC Type
|
|
// Format: DC000000 VVVVVVVV
|
|
// Description: 32bit store and increment by V.
|
|
// Simple: stores the value at address(es) before it and to addresses in increments of V.
|
|
// Note: used with the C, D3, D5, D9, D8, DB types.
|
|
// Example: DC000000 00000100
|
|
if (!skipExecution)
|
|
{
|
|
*activeOffset() += arg1;
|
|
}
|
|
break;
|
|
case 0x0D:
|
|
// DD Type
|
|
{
|
|
bool newSkip = !(arg1 == 0 || (HID_PAD & arg1) == arg1);
|
|
|
|
cheat_state.ifStack <<= 1;
|
|
cheat_state.ifStack |= (newSkip || skipExecution) ? 1 : 0;;
|
|
cheat_state.ifCount++;
|
|
}
|
|
break;
|
|
case 0x0E:
|
|
// Touchpad conditional
|
|
// DE000000 AAAABBBB: AAAA >= X position >= BBBB
|
|
// DE000001 AAAABBBB: AAAA >= Y position >= BBBB
|
|
{
|
|
bool newSkip;
|
|
u32 highBound = arg1 >> 16;
|
|
u32 lowBound = arg1 & 0xFFFF;
|
|
touchPosition touch;
|
|
hidTouchRead(&touch);
|
|
if (codeArg == 0)
|
|
{
|
|
newSkip = !(lowBound <= touch.px && highBound >= touch.px);
|
|
}
|
|
else if (codeArg == 1)
|
|
{
|
|
newSkip = !(lowBound <= touch.py && highBound >= touch.py);
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
cheat_state.ifStack <<= 1;
|
|
cheat_state.ifStack |= (newSkip || skipExecution) ? 1 : 0;
|
|
cheat_state.ifCount++;
|
|
}
|
|
break;
|
|
case 0x0F:
|
|
{
|
|
switch (codeArg)
|
|
{
|
|
case 0x00:
|
|
{
|
|
if (arg1 & 0x00010000)
|
|
{
|
|
if (arg1 & 0x1)
|
|
{
|
|
cheat_state.offset2 = cheat_state.offset1;
|
|
}
|
|
else
|
|
{
|
|
cheat_state.offset1 = cheat_state.offset2;
|
|
}
|
|
}
|
|
else if (arg1 & 0x00020000)
|
|
{
|
|
if (arg1 & 0x1)
|
|
{
|
|
cheat_state.data2 = cheat_state.offset2;
|
|
}
|
|
else
|
|
{
|
|
cheat_state.data1 = cheat_state.offset1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cheat_state.activeOffset = arg1 & 0x1;
|
|
}
|
|
}
|
|
break;
|
|
case 0x01:
|
|
{
|
|
if (arg1 & 0x00010000)
|
|
{
|
|
if (arg1 & 0x1)
|
|
{
|
|
cheat_state.data2 = cheat_state.data1;
|
|
}
|
|
else
|
|
{
|
|
cheat_state.data1 = cheat_state.data2;
|
|
}
|
|
}
|
|
else if (arg1 & 0x00020000)
|
|
{
|
|
if (arg1 & 0x1)
|
|
{
|
|
cheat_state.offset2 = cheat_state.data2;
|
|
}
|
|
else
|
|
{
|
|
cheat_state.offset1 = cheat_state.data1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cheat_state.activeData = arg1 & 0x1;
|
|
}
|
|
}
|
|
break;
|
|
case 0x02:
|
|
{
|
|
if (arg1 & 0x00010000)
|
|
{
|
|
if (arg1 & 0x1)
|
|
{
|
|
cheat_state.data2 = cheat->storage2;
|
|
}
|
|
else
|
|
{
|
|
cheat_state.data1 = cheat->storage1;
|
|
}
|
|
}
|
|
else if (arg1 & 0x00020000)
|
|
{
|
|
if (arg1 & 0x1)
|
|
{
|
|
cheat->storage2 = cheat_state.data2;
|
|
}
|
|
else
|
|
{
|
|
cheat->storage1 = cheat_state.data1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cheat->activeStorage = arg1 & 0x1;
|
|
}
|
|
}
|
|
break;
|
|
case 0x0E:
|
|
{
|
|
if (cheat_state.activeData)
|
|
{
|
|
switch (arg1)
|
|
{
|
|
case 0x0:
|
|
{
|
|
cheat_state.data2Mode = 0;
|
|
}
|
|
break;
|
|
case 0x1:
|
|
{
|
|
cheat_state.data2Mode = 1;
|
|
}
|
|
break;
|
|
case 0x10:
|
|
{
|
|
cheat_state.data2Mode = 0;
|
|
float val;
|
|
memcpy(&val, &cheat_state.data2, sizeof(float));
|
|
cheat_state.data2 = val;
|
|
}
|
|
break;
|
|
case 0x11:
|
|
{
|
|
cheat_state.data2Mode = 1;
|
|
float val = cheat_state.data2;
|
|
memcpy(&cheat_state.data2, &val, sizeof(float));
|
|
}
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (arg1)
|
|
{
|
|
case 0x0:
|
|
{
|
|
cheat_state.data1Mode = 0;
|
|
}
|
|
break;
|
|
case 0x1:
|
|
{
|
|
cheat_state.data1Mode = 1;
|
|
}
|
|
break;
|
|
case 0x10:
|
|
{
|
|
cheat_state.data1Mode = 0;
|
|
float val;
|
|
memcpy(&val, &cheat_state.data1, sizeof(float));
|
|
cheat_state.data1 = val;
|
|
}
|
|
break;
|
|
case 0x11:
|
|
{
|
|
cheat_state.data1Mode = 1;
|
|
float val = cheat_state.data1;
|
|
memcpy(&cheat_state.data1, &val, sizeof(float));
|
|
}
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 0x0F:
|
|
{
|
|
if (arg1 < 5)
|
|
{
|
|
cheat_state.conditionalMode = (u8)arg1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
break;
|
|
case 0xE:
|
|
// E Type
|
|
// Format:
|
|
// EXXXXXXX UUUUUUUU
|
|
// YYYYYYYY YYYYYYYY
|
|
|
|
// Description: writes Y to X for U bytes.
|
|
|
|
{
|
|
u32 beginOffset = (arg0 & 0x0FFFFFFF);
|
|
u32 count = arg1;
|
|
cheat_state.typeELine = cheat_state.index;
|
|
cheat_state.typeEIdx = 7;
|
|
for (u32 i = 0; i < count; i++)
|
|
{
|
|
u8 byte = Cheat_GetNextTypeE(cheat);
|
|
if (!skipExecution)
|
|
{
|
|
if (!Cheat_Write8(processHandle, beginOffset + i, byte)) return 0;
|
|
}
|
|
}
|
|
cheat_state.index = cheat_state.typeELine;
|
|
}
|
|
break;
|
|
case 0xF:
|
|
{
|
|
if (arg0 == 0xF0F00000)
|
|
{
|
|
// I have no clue how to implement this, or if it's even possible. Needs research.
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
switch (subcode)
|
|
{
|
|
case 0x0:
|
|
{
|
|
cheat_state.floatMode = arg1 & 0x1;
|
|
}
|
|
break;
|
|
case 0x1:
|
|
{
|
|
if (cheat_state.floatMode)
|
|
{
|
|
u32 tmp;
|
|
if (!Cheat_Read32(processHandle, arg0 & 0x00FFFFFF, &tmp))
|
|
{
|
|
return 0;
|
|
}
|
|
float value;
|
|
memcpy(&value, &tmp, sizeof(float));
|
|
value += arg1;
|
|
memcpy(&tmp, &value, sizeof(u32));
|
|
if (!Cheat_Write32(processHandle, arg0 & 0x00FFFFFF, tmp))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
u32 tmp;
|
|
if (!Cheat_Read32(processHandle, arg0 & 0x00FFFFFF, &tmp))
|
|
{
|
|
return 0;
|
|
}
|
|
tmp += arg1;
|
|
if (!Cheat_Write32(processHandle, arg0 & 0x00FFFFFF, tmp))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 0x2:
|
|
{
|
|
if (cheat_state.floatMode)
|
|
{
|
|
u32 tmp;
|
|
if (!Cheat_Read32(processHandle, arg0 & 0x00FFFFFF, &tmp))
|
|
{
|
|
return 0;
|
|
}
|
|
float value;
|
|
memcpy(&value, &tmp, sizeof(float));
|
|
value *= arg1;
|
|
memcpy(&tmp, &value, sizeof(u32));
|
|
if (!Cheat_Write32(processHandle, arg0 & 0x00FFFFFF, tmp))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
u32 tmp;
|
|
if (!Cheat_Read32(processHandle, arg0 & 0x00FFFFFF, &tmp))
|
|
{
|
|
return 0;
|
|
}
|
|
tmp *= arg1;
|
|
if (!Cheat_Write32(processHandle, arg0 & 0x00FFFFFF, tmp))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 0x3:
|
|
{
|
|
if (cheat_state.floatMode)
|
|
{
|
|
u32 tmp;
|
|
if (!Cheat_Read32(processHandle, arg0 & 0x00FFFFFF, &tmp))
|
|
{
|
|
return 0;
|
|
}
|
|
float value;
|
|
memcpy(&value, &tmp, sizeof(float));
|
|
value /= arg1;
|
|
memcpy(&tmp, &value, sizeof(u32));
|
|
if (!Cheat_Write32(processHandle, arg0 & 0x00FFFFFF, tmp))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
u32 tmp;
|
|
if (!Cheat_Read32(processHandle, arg0 & 0x00FFFFFF, &tmp))
|
|
{
|
|
return 0;
|
|
}
|
|
tmp /= arg1;
|
|
if (!Cheat_Write32(processHandle, arg0 & 0x00FFFFFF, tmp))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 0x4:
|
|
{
|
|
if (cheat_state.data1Mode)
|
|
{
|
|
float value;
|
|
memcpy(&value, activeData(), sizeof(float));
|
|
value *= arg1;
|
|
memcpy(activeData(), &value, sizeof(float));
|
|
}
|
|
else
|
|
{
|
|
*activeData() *= arg1;
|
|
}
|
|
}
|
|
break;
|
|
case 0x5:
|
|
{
|
|
if (cheat_state.data1Mode)
|
|
{
|
|
float value;
|
|
memcpy(&value, activeData(), sizeof(float));
|
|
value /= arg1;
|
|
memcpy(activeData(), &value, sizeof(float));
|
|
}
|
|
else
|
|
{
|
|
*activeData() /= arg1;
|
|
}
|
|
}
|
|
break;
|
|
case 0x6:
|
|
{
|
|
*activeData() &= arg1;
|
|
}
|
|
break;
|
|
case 0x7:
|
|
{
|
|
*activeData() |= arg1;
|
|
}
|
|
break;
|
|
case 0x8:
|
|
{
|
|
*activeData() ^= arg1;
|
|
}
|
|
break;
|
|
case 0x9:
|
|
{
|
|
*activeData() = ~*activeData();
|
|
}
|
|
break;
|
|
case 0xA:
|
|
{
|
|
*activeData() <<= arg1;
|
|
}
|
|
break;
|
|
case 0xB:
|
|
{
|
|
*activeData() >>= arg1;
|
|
}
|
|
break;
|
|
case 0xC:
|
|
{
|
|
u8 origActiveOffset = cheat_state.activeOffset;
|
|
for (size_t i = 0; i < arg1; i++)
|
|
{
|
|
u8 data;
|
|
cheat_state.activeOffset = 1;
|
|
if (!Cheat_Read8(processHandle, 0, &data))
|
|
{
|
|
return 0;
|
|
}
|
|
cheat_state.activeOffset = 0;
|
|
if (!Cheat_Write8(processHandle, 0, data))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
cheat_state.activeOffset = origActiveOffset;
|
|
}
|
|
break;
|
|
// Search for pattern
|
|
case 0xE:
|
|
{
|
|
u32 searchSize = arg0 & 0xFFFF;
|
|
if (searchSize <= arg1 && searchSize + cheat_state.index < cheat->codesCount)
|
|
{
|
|
bool newSkip = true;
|
|
if (!skipExecution) // Don't do an expensive operation if we don't have to
|
|
{
|
|
u8* searchData = (u8*)(cheat->codes + cheat_state.index + 1);
|
|
cheat_state.index += searchSize / 8;
|
|
if (searchSize & 0x7)
|
|
{
|
|
cheat_state.index++;
|
|
}
|
|
for (size_t i = 0; i < arg1 - searchSize; i++)
|
|
{
|
|
u8 curVal;
|
|
newSkip = false;
|
|
for (size_t j = 0; j < searchSize; j++)
|
|
{
|
|
if (!Cheat_Read8(processHandle, i + j, &curVal))
|
|
{
|
|
return 0;
|
|
}
|
|
if (curVal != searchData[j])
|
|
{
|
|
newSkip = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (!newSkip)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
cheat_state.ifStack <<= 1;
|
|
cheat_state.ifStack |= (newSkip || skipExecution) ? 1 : 0;
|
|
cheat_state.ifCount++;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
break;
|
|
case 0xF:
|
|
{
|
|
u32 range = arg1 - (arg0 & 0xFFFFFF);
|
|
u32 number = rand() % range;
|
|
*activeData() = (arg0 & 0xFFFFFF) + number;
|
|
}
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
// This should now not be possible
|
|
default:
|
|
return 0;
|
|
}
|
|
cheat_state.index++;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void Cheat_EatEvents(Handle debug)
|
|
{
|
|
DebugEventInfo info;
|
|
Result r;
|
|
|
|
while(true)
|
|
{
|
|
if((r = svcGetProcessDebugEvent(&info, debug)) != 0)
|
|
{
|
|
if(r == (s32)(0xd8402009))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
svcContinueDebugEvent(debug, 3);
|
|
}
|
|
}
|
|
|
|
static Result Cheat_MapMemoryAndApplyCheat(u32 pid, CheatDescription* const cheat)
|
|
{
|
|
Handle processHandle;
|
|
Handle debugHandle;
|
|
Result res;
|
|
res = svcOpenProcess(&processHandle, pid);
|
|
if (R_SUCCEEDED(res))
|
|
{
|
|
res = svcDebugActiveProcess(&debugHandle, pid);
|
|
if (R_SUCCEEDED(res))
|
|
{
|
|
Cheat_EatEvents(debugHandle);
|
|
cheat->valid = Cheat_ApplyCheat(debugHandle, cheat);
|
|
|
|
svcCloseHandle(debugHandle);
|
|
svcCloseHandle(processHandle);
|
|
cheat->active = 1;
|
|
}
|
|
else
|
|
{
|
|
sprintf(failureReason, "Debug process failed");
|
|
svcCloseHandle(processHandle);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sprintf(failureReason, "Open process failed");
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static CheatDescription* Cheat_AllocCheat()
|
|
{
|
|
CheatDescription* cheat;
|
|
if (cheatCount == 0)
|
|
{
|
|
cheat = (CheatDescription*) cheatBuffer;
|
|
}
|
|
else
|
|
{
|
|
CheatDescription* prev = cheats[cheatCount - 1];
|
|
cheat = (CheatDescription *) ((u8*) (prev) + sizeof(CheatDescription) + sizeof(u64) * (prev->codesCount));
|
|
}
|
|
cheat->active = 0;
|
|
cheat->valid = 1;
|
|
cheat->codesCount = 0;
|
|
cheat->hasKeyCode = 0;
|
|
cheat->storage1 = 0;
|
|
cheat->storage2 = 0;
|
|
cheat->name[0] = '\0';
|
|
|
|
cheats[cheatCount] = cheat;
|
|
cheatCount++;
|
|
return cheat;
|
|
}
|
|
|
|
static void Cheat_AddCode(CheatDescription* cheat, u64 code)
|
|
{
|
|
if (cheat)
|
|
{
|
|
cheat->codes[cheat->codesCount] = code;
|
|
(cheat->codesCount)++;
|
|
}
|
|
}
|
|
|
|
static Result BufferedFile_Open(BufferedFile* file, FS_ArchiveID archiveId, FS_Path archivePath, FS_Path filePath, u32 flags)
|
|
{
|
|
Result res = 0;
|
|
memset(file->buffer, '\0', sizeof(file->buffer));
|
|
res = IFile_Open(&file->file, archiveId, archivePath, filePath, flags);
|
|
if (R_SUCCEEDED(res))
|
|
{
|
|
file->curPos = 0;
|
|
res = IFile_Read(&file->file, &file->maxPos, file->buffer, sizeof(file->buffer));
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static Result BufferedFile_Read(BufferedFile* file, u64* totalRead, void* buffer, u32 len)
|
|
{
|
|
Result res = 0;
|
|
if (len == 0)
|
|
{
|
|
*totalRead = 0;
|
|
return 0;
|
|
}
|
|
else if (file->curPos + len < file->maxPos)
|
|
{
|
|
memcpy(buffer, file->buffer + file->curPos, len);
|
|
file->curPos += len;
|
|
*totalRead = len;
|
|
}
|
|
else
|
|
{
|
|
*totalRead = 0;
|
|
while(R_SUCCEEDED(res) && file->maxPos != 0 && *totalRead < len)
|
|
{
|
|
u32 toRead = file->maxPos - file->curPos < len - *totalRead ? file->maxPos - file->curPos : len - *totalRead;
|
|
memcpy(buffer + *totalRead, file->buffer + file->curPos, toRead);
|
|
*totalRead += toRead;
|
|
file->curPos += toRead;
|
|
if (file->curPos >= file->maxPos)
|
|
{
|
|
res = IFile_Read(&file->file, &file->maxPos, file->buffer, sizeof(file->buffer));
|
|
file->curPos = 0;
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static Result Cheat_ReadLine(BufferedFile* file, char* line, u32 lineSize)
|
|
{
|
|
Result res = 0;
|
|
|
|
u32 idx = 0;
|
|
u64 total = 0;
|
|
bool lastWasCarriageReturn = false;
|
|
while (R_SUCCEEDED(res) && idx < lineSize)
|
|
{
|
|
res = BufferedFile_Read(file, &total, line + idx, 1);
|
|
if (total == 0)
|
|
{
|
|
line[idx] = '\0';
|
|
return -1;
|
|
}
|
|
if (R_SUCCEEDED(res))
|
|
{
|
|
if (line[idx] == '\r')
|
|
{
|
|
lastWasCarriageReturn = true;
|
|
}
|
|
else if (line[idx] == '\n')
|
|
{
|
|
if (lastWasCarriageReturn)
|
|
{
|
|
line[--idx] = '\0';
|
|
return idx;
|
|
}
|
|
else
|
|
{
|
|
line[idx] = '\0';
|
|
return idx;
|
|
}
|
|
}
|
|
else if (line[idx] == '\0')
|
|
{
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
lastWasCarriageReturn = false;
|
|
}
|
|
idx++;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static bool Cheat_IsCodeLine(const char *line)
|
|
{
|
|
s32 len = strnlen(line, 1023);
|
|
if (len != 17)
|
|
{
|
|
return false;
|
|
}
|
|
if (line[8] != ' ')
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int i;
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
char c = line[i];
|
|
if (!(('0' <= c && c <= '9') || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f')))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
for (i = 9; i < 17; i++)
|
|
{
|
|
char c = line[i];
|
|
if (!(('0' <= c && c <= '9') || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f')))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static u64 Cheat_GetCode(const char *line)
|
|
{
|
|
u64 tmp = 0;
|
|
int i;
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
char c = line[i];
|
|
u8 code = 0;
|
|
if ('0' <= c && c <= '9')
|
|
{
|
|
code = c - '0';
|
|
}
|
|
if ('A' <= c && c <= 'F')
|
|
{
|
|
code = c - 'A' + 10;
|
|
}
|
|
if ('a' <= c && c <= 'f')
|
|
{
|
|
code = c - 'a' + 10;
|
|
}
|
|
tmp <<= 4;
|
|
tmp |= (code & 0xF);
|
|
}
|
|
|
|
for (i = 9; i < 17; i++)
|
|
{
|
|
char c = line[i];
|
|
u8 code = 0;
|
|
if ('0' <= c && c <= '9')
|
|
{
|
|
code = c - '0';
|
|
}
|
|
if ('A' <= c && c <= 'F')
|
|
{
|
|
code = c - 'A' + 10;
|
|
}
|
|
if ('a' <= c && c <= 'f')
|
|
{
|
|
code = c - 'a' + 10;
|
|
}
|
|
tmp <<= 4;
|
|
tmp |= (code & 0xF);
|
|
}
|
|
|
|
return tmp;
|
|
}
|
|
|
|
static char* stripWhitespace(char* in)
|
|
{
|
|
char* ret = in;
|
|
while (*ret == ' ' || *ret == '\t')
|
|
{
|
|
ret++;
|
|
}
|
|
int back = strlen(ret) - 1;
|
|
while (back > 0 && (ret[back] == ' ' || ret[back] == '\t'))
|
|
{
|
|
back--;
|
|
}
|
|
ret[back+1] = '\0';
|
|
return ret;
|
|
}
|
|
|
|
static void Cheat_LoadCheatsIntoMemory(u64 titleId)
|
|
{
|
|
cheatCount = 0;
|
|
cheatTitleInfo = titleId;
|
|
|
|
char path[64] = { 0 };
|
|
sprintf(path, "/luma/titles/%016llX/cheats.txt", titleId);
|
|
|
|
BufferedFile file;
|
|
|
|
if (R_FAILED(BufferedFile_Open(&file, ARCHIVE_SDMC, fsMakePath(PATH_EMPTY, ""), fsMakePath(PATH_ASCII, path), FS_OPEN_READ)))
|
|
{
|
|
// OK, let's try another source
|
|
sprintf(path, "/cheats/%016llX.txt", titleId);
|
|
if (R_FAILED(BufferedFile_Open(&file, ARCHIVE_SDMC, fsMakePath(PATH_EMPTY, ""), fsMakePath(PATH_ASCII, path), FS_OPEN_READ))) return;
|
|
};
|
|
|
|
char line[1024] = { 0 };
|
|
Result res = 0;
|
|
CheatDescription* cheat = 0;
|
|
u32 cheatSize = 0;
|
|
do
|
|
{
|
|
res = Cheat_ReadLine(&file, line, 1024);
|
|
if (R_SUCCEEDED(res))
|
|
{
|
|
char* strippedLine = stripWhitespace(line);
|
|
s32 lineLen = strnlen(strippedLine, 1023);
|
|
if (!lineLen)
|
|
{
|
|
continue;
|
|
}
|
|
if (strippedLine[0] == '#')
|
|
{
|
|
continue;
|
|
}
|
|
if (Cheat_IsCodeLine(strippedLine))
|
|
{
|
|
if (cheatSize + sizeof(u64) >= sizeof(cheatBuffer))
|
|
{
|
|
cheatCount--;
|
|
break;
|
|
}
|
|
if (cheat)
|
|
{
|
|
u64 tmp = Cheat_GetCode(strippedLine);
|
|
Cheat_AddCode(cheat, tmp);
|
|
cheatSize += sizeof(u64);
|
|
if (((tmp >> 32) & 0xFFFFFFFF) == 0xDD000000)
|
|
{
|
|
cheat->hasKeyCode = 1;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!cheat || cheat->codesCount > 0)
|
|
{
|
|
if (cheatSize + sizeof(CheatDescription) >= sizeof(cheatBuffer))
|
|
{
|
|
break;
|
|
}
|
|
cheat = Cheat_AllocCheat();
|
|
cheatSize += sizeof(CheatDescription);
|
|
}
|
|
strncpy(cheat->name, line, 38);
|
|
cheat->name[38] = '\0';
|
|
}
|
|
}
|
|
} while (R_SUCCEEDED(res) && cheatSize < sizeof(cheatBuffer));
|
|
|
|
IFile_Close(&file.file);
|
|
|
|
if ((cheatCount > 0) && (cheats[cheatCount - 1]->codesCount == 0))
|
|
{
|
|
cheatCount--; // Remove last empty cheat
|
|
}
|
|
|
|
memset(cheatPage, 0, 0x1000);
|
|
}
|
|
|
|
static u32 Cheat_GetCurrentPID(u64* titleId)
|
|
{
|
|
s32 processAmount = Cheats_FetchProcessInfo();
|
|
|
|
s32 index = -1;
|
|
|
|
for (s32 i = 0; i < processAmount; i++)
|
|
{
|
|
|
|
if (((u32) (cheatinfo[i].titleId >> 32)) == 0x00040010 || ((u32) (cheatinfo[i].titleId >> 32) == 0x00040000))
|
|
{
|
|
index = i;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (index != -1)
|
|
{
|
|
*titleId = cheatinfo[index].titleId;
|
|
return cheatinfo[index].pid;
|
|
}
|
|
else
|
|
{
|
|
*titleId = 0;
|
|
return 0xFFFFFFFF;
|
|
}
|
|
}
|
|
|
|
void Cheat_ApplyCheats(void)
|
|
{
|
|
if (!cheatCount)
|
|
{
|
|
return;
|
|
}
|
|
|
|
u64 titleId = 0;
|
|
u32 pid = Cheat_GetCurrentPID(&titleId);
|
|
|
|
if (!titleId)
|
|
{
|
|
cheatCount = 0;
|
|
return;
|
|
}
|
|
|
|
if (titleId != cheatTitleInfo)
|
|
{
|
|
cheatCount = 0;
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < cheatCount; i++)
|
|
{
|
|
if (cheats[i]->active)
|
|
{
|
|
Cheat_MapMemoryAndApplyCheat(pid, cheats[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void RosalinaMenu_Cheats(void)
|
|
{
|
|
u64 titleId = 0;
|
|
u32 pid = Cheat_GetCurrentPID(&titleId);
|
|
|
|
if (titleId != 0)
|
|
{
|
|
if (cheatTitleInfo != titleId || cheatCount == 0)
|
|
{
|
|
Cheat_LoadCheatsIntoMemory(titleId);
|
|
}
|
|
}
|
|
|
|
Draw_Lock();
|
|
Draw_ClearFramebuffer();
|
|
Draw_FlushFramebuffer();
|
|
Draw_Unlock();
|
|
|
|
if (titleId == 0 || cheatCount == 0)
|
|
{
|
|
do
|
|
{
|
|
Draw_Lock();
|
|
Draw_DrawString(10, 10, COLOR_TITLE, "Cheats");
|
|
if (titleId == 0)
|
|
{
|
|
Draw_DrawString(10, 30, COLOR_WHITE, "No suitable title found");
|
|
}
|
|
else
|
|
{
|
|
Draw_DrawFormattedString(10, 30, COLOR_WHITE, "No cheats found for title %016llX", titleId);
|
|
}
|
|
|
|
Draw_FlushFramebuffer();
|
|
Draw_Unlock();
|
|
} while (!(waitInput() & BUTTON_B) && !terminationRequest);
|
|
}
|
|
else
|
|
{
|
|
s32 selected = 0, page = 0, pagePrev = 0;
|
|
|
|
Result r = 0;
|
|
do
|
|
{
|
|
Draw_Lock();
|
|
if (page != pagePrev || R_FAILED(r))
|
|
{
|
|
Draw_ClearFramebuffer();
|
|
}
|
|
if (R_SUCCEEDED(r))
|
|
{
|
|
Draw_DrawFormattedString(10, 10, COLOR_TITLE, "Cheat list");
|
|
|
|
for (s32 i = 0; i < CHEATS_PER_MENU_PAGE && page * CHEATS_PER_MENU_PAGE + i < cheatCount; i++)
|
|
{
|
|
char buf[65] = { 0 };
|
|
s32 j = page * CHEATS_PER_MENU_PAGE + i;
|
|
const char * checkbox = (cheats[j]->active ? "(x) " : "( ) ");
|
|
const char * keyAct = (cheats[j]->hasKeyCode ? "*" : " ");
|
|
sprintf(buf, "%s%s%s", checkbox, keyAct, cheats[j]->name);
|
|
|
|
Draw_DrawString(30, 30 + i * SPACING_Y, cheats[j]->valid ? COLOR_WHITE : COLOR_RED, buf);
|
|
Draw_DrawCharacter(10, 30 + i * SPACING_Y, COLOR_TITLE, j == selected ? '>' : ' ');
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Draw_DrawFormattedString(10, 10, COLOR_TITLE, "ERROR: %08lx", r);
|
|
Draw_DrawFormattedString(10, 30, COLOR_RED, failureReason);
|
|
}
|
|
Draw_FlushFramebuffer();
|
|
Draw_Unlock();
|
|
|
|
if (terminationRequest) break;
|
|
|
|
u32 pressed;
|
|
do
|
|
{
|
|
pressed = waitInputWithTimeout(50);
|
|
if (pressed != 0) break;
|
|
} while (pressed == 0 && !terminationRequest);
|
|
|
|
if (pressed & BUTTON_B)
|
|
break;
|
|
else if ((pressed & BUTTON_A) && R_SUCCEEDED(r))
|
|
{
|
|
if (cheats[selected]->active)
|
|
{
|
|
cheats[selected]->active = 0;
|
|
}
|
|
else
|
|
{
|
|
r = Cheat_MapMemoryAndApplyCheat(pid, cheats[selected]);
|
|
}
|
|
}
|
|
else if (pressed & BUTTON_DOWN)
|
|
selected++;
|
|
else if (pressed & BUTTON_UP)
|
|
selected--;
|
|
else if (pressed & BUTTON_LEFT)
|
|
selected -= CHEATS_PER_MENU_PAGE;
|
|
else if (pressed & BUTTON_RIGHT)
|
|
{
|
|
if (selected + CHEATS_PER_MENU_PAGE < cheatCount)
|
|
selected += CHEATS_PER_MENU_PAGE;
|
|
else if ((cheatCount - 1) / CHEATS_PER_MENU_PAGE == page)
|
|
selected %= CHEATS_PER_MENU_PAGE;
|
|
else selected = cheatCount - 1;
|
|
}
|
|
|
|
if (selected < 0)
|
|
selected = cheatCount - 1;
|
|
else if (selected >= cheatCount) selected = 0;
|
|
|
|
pagePrev = page;
|
|
page = selected / CHEATS_PER_MENU_PAGE;
|
|
} while (!terminationRequest);
|
|
}
|
|
|
|
}
|