mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-07-23 14:19:46 -06:00
ActionReplay: UI Consistency and Cleanup
Cleanup code style. Move ActionReplay code->INI saving into ActionReplay namespace. Threadsafety Cleanup: ActionReplay is accessed from the Host, Emu and CPU Threads so the internal storage needs to be protected by a lock to prevent vectors/strings being deleted/moved while in use by the CPU Thread. UI Consistency: Make ARCodes behave like Gecko Codes - only apply changes when Apply is pressed. Save changes to INI from CheatsWindow. ISOProperties/CheatsWindow now synchronize with each other.
This commit is contained in:
EmptyChaos
@ -19,9 +19,12 @@
|
||||
// Zero Codes: any code with no address. These codes are used to do special operations like memory copy, etc
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
|
||||
#include <list>
|
||||
#include <algorithm>
|
||||
#include <atomic>
|
||||
#include <iterator>
|
||||
#include <mutex>
|
||||
#include <string>
|
||||
#include <unordered_set>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
@ -75,17 +78,14 @@ enum
|
||||
SUB_MASTER_CODE = 0x03,
|
||||
};
|
||||
|
||||
// General lock. Protects codes list and internal log.
|
||||
static std::mutex s_lock;
|
||||
static std::vector<ARCode> s_active_codes;
|
||||
static std::vector<std::string> s_internal_log;
|
||||
static std::atomic<bool> s_use_internal_log{ false };
|
||||
// pointer to the code currently being run, (used by log messages that include the code name)
|
||||
static ARCode const* current_code = nullptr;
|
||||
|
||||
static bool b_RanOnce = false;
|
||||
static std::vector<ARCode> arCodes;
|
||||
static std::vector<ARCode> activeCodes;
|
||||
static bool logSelf = false;
|
||||
static std::vector<std::string> arLog;
|
||||
|
||||
static std::mutex s_callbacks_lock;
|
||||
static std::list<std::function<void()>> s_callbacks;
|
||||
static const ARCode* s_current_code = nullptr;
|
||||
static bool s_disable_logging = false;
|
||||
|
||||
struct ARAddr
|
||||
{
|
||||
@ -106,13 +106,6 @@ struct ARAddr
|
||||
operator u32() const { return address; }
|
||||
};
|
||||
|
||||
static void RunCodeChangeCallbacks()
|
||||
{
|
||||
std::lock_guard<std::mutex> guard(s_callbacks_lock);
|
||||
for (const auto& cb : s_callbacks)
|
||||
cb();
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
// AR Remote Functions
|
||||
void ApplyCodes(const std::vector<ARCode>& codes)
|
||||
@ -120,73 +113,59 @@ void ApplyCodes(const std::vector<ARCode>& codes)
|
||||
if (!SConfig::GetInstance().bEnableCheats)
|
||||
return;
|
||||
|
||||
arCodes = codes;
|
||||
UpdateActiveList();
|
||||
RunCodeChangeCallbacks();
|
||||
std::lock_guard<std::mutex> guard(s_lock);
|
||||
s_disable_logging = false;
|
||||
s_active_codes.clear();
|
||||
std::copy_if(codes.begin(), codes.end(), std::back_inserter(s_active_codes), [](const ARCode& code)
|
||||
{
|
||||
return code.active;
|
||||
});
|
||||
s_active_codes.shrink_to_fit();
|
||||
}
|
||||
|
||||
void AddCode(const ARCode& code)
|
||||
void AddCode(ARCode code)
|
||||
{
|
||||
if (!SConfig::GetInstance().bEnableCheats)
|
||||
return;
|
||||
|
||||
arCodes.push_back(code);
|
||||
if (code.active)
|
||||
UpdateActiveList();
|
||||
RunCodeChangeCallbacks();
|
||||
}
|
||||
|
||||
void* RegisterCodeChangeCallback(std::function<void()> callback)
|
||||
{
|
||||
if (!callback)
|
||||
return nullptr;
|
||||
|
||||
std::lock_guard<std::mutex> guard(s_callbacks_lock);
|
||||
s_callbacks.emplace_back(std::move(callback));
|
||||
return &s_callbacks.back();
|
||||
}
|
||||
|
||||
void UnregisterCodeChangeCallback(void* token)
|
||||
{
|
||||
std::lock_guard<std::mutex> guard(s_callbacks_lock);
|
||||
for (auto i = s_callbacks.begin(); i != s_callbacks.end(); ++i)
|
||||
{
|
||||
if (&*i == token)
|
||||
{
|
||||
s_callbacks.erase(i);
|
||||
break;
|
||||
}
|
||||
std::lock_guard<std::mutex> guard(s_lock);
|
||||
s_disable_logging = false;
|
||||
s_active_codes.emplace_back(std::move(code));
|
||||
}
|
||||
}
|
||||
|
||||
void LoadAndApplyCodes(const IniFile& globalIni, const IniFile& localIni)
|
||||
void LoadAndApplyCodes(const IniFile& global_ini, const IniFile& local_ini)
|
||||
{
|
||||
ApplyCodes(LoadCodes(globalIni, localIni));
|
||||
ApplyCodes(LoadCodes(global_ini, local_ini));
|
||||
}
|
||||
|
||||
// Parses the Action Replay section of a game ini file.
|
||||
std::vector<ARCode> LoadCodes(const IniFile& globalIni, const IniFile& localIni)
|
||||
std::vector<ARCode> LoadCodes(const IniFile& global_ini, const IniFile& local_ini)
|
||||
{
|
||||
std::vector<ARCode> codes;
|
||||
|
||||
std::vector<std::string> enabledLines;
|
||||
std::set<std::string> enabledNames;
|
||||
localIni.GetLines("ActionReplay_Enabled", &enabledLines);
|
||||
for (const std::string& line : enabledLines)
|
||||
std::unordered_set<std::string> enabled_names;
|
||||
{
|
||||
if (line.size() != 0 && line[0] == '$')
|
||||
std::vector<std::string> enabled_lines;
|
||||
local_ini.GetLines("ActionReplay_Enabled", &enabled_lines);
|
||||
for (const std::string& line : enabled_lines)
|
||||
{
|
||||
std::string name = line.substr(1, line.size() - 1);
|
||||
enabledNames.insert(name);
|
||||
if (line.size() != 0 && line[0] == '$')
|
||||
{
|
||||
std::string name = line.substr(1, line.size() - 1);
|
||||
enabled_names.insert(name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const IniFile* inis[2] = {&globalIni, &localIni};
|
||||
const IniFile* inis[2] = {&global_ini, &local_ini};
|
||||
for (const IniFile* ini : inis)
|
||||
{
|
||||
std::vector<std::string> lines;
|
||||
std::vector<std::string> encryptedLines;
|
||||
ARCode currentCode;
|
||||
std::vector<std::string> encrypted_lines;
|
||||
ARCode current_code;
|
||||
|
||||
ini->GetLines("ActionReplay", &lines);
|
||||
|
||||
@ -202,22 +181,22 @@ std::vector<ARCode> LoadCodes(const IniFile& globalIni, const IniFile& localIni)
|
||||
// Check if the line is a name of the code
|
||||
if (line[0] == '$')
|
||||
{
|
||||
if (currentCode.ops.size())
|
||||
if (current_code.ops.size())
|
||||
{
|
||||
codes.push_back(currentCode);
|
||||
currentCode.ops.clear();
|
||||
codes.push_back(current_code);
|
||||
current_code.ops.clear();
|
||||
}
|
||||
if (encryptedLines.size())
|
||||
if (encrypted_lines.size())
|
||||
{
|
||||
DecryptARCode(encryptedLines, currentCode.ops);
|
||||
codes.push_back(currentCode);
|
||||
currentCode.ops.clear();
|
||||
encryptedLines.clear();
|
||||
DecryptARCode(encrypted_lines, current_code.ops);
|
||||
codes.push_back(current_code);
|
||||
current_code.ops.clear();
|
||||
encrypted_lines.clear();
|
||||
}
|
||||
|
||||
currentCode.name = line.substr(1, line.size() - 1);
|
||||
currentCode.active = enabledNames.find(currentCode.name) != enabledNames.end();
|
||||
currentCode.user_defined = (ini == &localIni);
|
||||
current_code.name = line.substr(1, line.size() - 1);
|
||||
current_code.active = enabled_names.find(current_code.name) != enabled_names.end();
|
||||
current_code.user_defined = (ini == &local_ini);
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -232,7 +211,7 @@ std::vector<ARCode> LoadCodes(const IniFile& globalIni, const IniFile& localIni)
|
||||
|
||||
if (success_addr && success_val)
|
||||
{
|
||||
currentCode.ops.push_back(op);
|
||||
current_code.ops.push_back(op);
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -253,105 +232,91 @@ std::vector<ARCode> LoadCodes(const IniFile& globalIni, const IniFile& localIni)
|
||||
// Encrypted AR code
|
||||
// Decryption is done in "blocks", so we must push blocks into a vector,
|
||||
// then send to decrypt when a new block is encountered, or if it's the last block.
|
||||
encryptedLines.push_back(pieces[0]+pieces[1]+pieces[2]);
|
||||
encrypted_lines.emplace_back(pieces[0] + pieces[1] + pieces[2]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Handle the last code correctly.
|
||||
if (currentCode.ops.size())
|
||||
if (current_code.ops.size())
|
||||
{
|
||||
codes.push_back(currentCode);
|
||||
codes.push_back(current_code);
|
||||
}
|
||||
if (encryptedLines.size())
|
||||
if (encrypted_lines.size())
|
||||
{
|
||||
DecryptARCode(encryptedLines, currentCode.ops);
|
||||
codes.push_back(currentCode);
|
||||
DecryptARCode(encrypted_lines, current_code.ops);
|
||||
codes.push_back(current_code);
|
||||
}
|
||||
}
|
||||
|
||||
return codes;
|
||||
}
|
||||
|
||||
|
||||
static void LogInfo(const char *format, ...)
|
||||
void SaveCodes(IniFile* local_ini, const std::vector<ARCode>& codes)
|
||||
{
|
||||
if (!b_RanOnce)
|
||||
std::vector<std::string> lines;
|
||||
std::vector<std::string> enabled_lines;
|
||||
for (const ActionReplay::ARCode& code : codes)
|
||||
{
|
||||
if (LogManager::GetMaxLevel() >= LogTypes::LINFO || logSelf)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
std::string text = StringFromFormatV(format, args);
|
||||
va_end(args);
|
||||
INFO_LOG(ACTIONREPLAY, "%s", text.c_str());
|
||||
if (code.active)
|
||||
enabled_lines.emplace_back("$" + code.name);
|
||||
|
||||
if (logSelf)
|
||||
if (code.user_defined)
|
||||
{
|
||||
lines.emplace_back("$" + code.name);
|
||||
for (const ActionReplay::AREntry& op : code.ops)
|
||||
{
|
||||
text += '\n';
|
||||
arLog.push_back(text);
|
||||
lines.emplace_back(StringFromFormat("%08X %08X", op.cmd_addr, op.value));
|
||||
}
|
||||
}
|
||||
}
|
||||
local_ini->SetLines("ActionReplay_Enabled", enabled_lines);
|
||||
local_ini->SetLines("ActionReplay", lines);
|
||||
}
|
||||
|
||||
size_t GetCodeListSize()
|
||||
{
|
||||
return arCodes.size();
|
||||
}
|
||||
|
||||
ARCode GetARCode(size_t index)
|
||||
static void LogInfo(const char* format, ...)
|
||||
{
|
||||
if (index > arCodes.size())
|
||||
{
|
||||
PanicAlertT("GetARCode: Index is greater than "
|
||||
"ar code list size %zu", index);
|
||||
return ARCode();
|
||||
}
|
||||
return arCodes[index];
|
||||
}
|
||||
|
||||
void SetARCode_IsActive(bool active, size_t index)
|
||||
{
|
||||
if (index > arCodes.size())
|
||||
{
|
||||
PanicAlertT("SetARCode_IsActive: Index is greater than "
|
||||
"ar code list size %zu", index);
|
||||
if (s_disable_logging)
|
||||
return;
|
||||
bool use_internal_log = s_use_internal_log.load(std::memory_order_relaxed);
|
||||
if (LogManager::GetMaxLevel() < LogTypes::LINFO && !use_internal_log)
|
||||
return;
|
||||
}
|
||||
arCodes[index].active = active;
|
||||
UpdateActiveList();
|
||||
RunCodeChangeCallbacks();
|
||||
}
|
||||
|
||||
void UpdateActiveList()
|
||||
{
|
||||
bool old_value = SConfig::GetInstance().bEnableCheats;
|
||||
SConfig::GetInstance().bEnableCheats = false;
|
||||
b_RanOnce = false;
|
||||
activeCodes.clear();
|
||||
for (auto& arCode : arCodes)
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
std::string text = StringFromFormatV(format, args);
|
||||
va_end(args);
|
||||
INFO_LOG(ACTIONREPLAY, "%s", text.c_str());
|
||||
|
||||
if (use_internal_log)
|
||||
{
|
||||
if (arCode.active)
|
||||
activeCodes.push_back(arCode);
|
||||
text += '\n';
|
||||
s_internal_log.emplace_back(std::move(text));
|
||||
}
|
||||
SConfig::GetInstance().bEnableCheats = old_value;
|
||||
}
|
||||
|
||||
void EnableSelfLogging(bool enable)
|
||||
{
|
||||
logSelf = enable;
|
||||
s_use_internal_log.store(enable, std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
const std::vector<std::string> &GetSelfLog()
|
||||
std::vector<std::string> GetSelfLog()
|
||||
{
|
||||
return arLog;
|
||||
std::lock_guard<std::mutex> guard(s_lock);
|
||||
return s_internal_log;
|
||||
}
|
||||
|
||||
void ClearSelfLog()
|
||||
{
|
||||
std::lock_guard<std::mutex> guard(s_lock);
|
||||
s_internal_log.clear();
|
||||
}
|
||||
|
||||
bool IsSelfLogging()
|
||||
{
|
||||
return logSelf;
|
||||
return s_use_internal_log.load(std::memory_order_relaxed);
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
@ -405,8 +370,8 @@ static bool Subtype_RamWriteAndFill(const ARAddr& addr, const u32 data)
|
||||
default:
|
||||
LogInfo("Bad Size");
|
||||
PanicAlertT("Action Replay Error: Invalid size "
|
||||
"(%08x : address = %08x) in Ram Write And Fill (%s)",
|
||||
addr.size, addr.gcaddr, current_code->name.c_str());
|
||||
"(%08x : address = %08x) in Ram Write And Fill (%s)",
|
||||
addr.size, addr.gcaddr, s_current_code->name.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -443,7 +408,7 @@ static bool Subtype_WriteToPointer(const ARAddr& addr, const u32 data)
|
||||
LogInfo("Write 16-bit to pointer");
|
||||
LogInfo("--------");
|
||||
const u16 theshort = data & 0xFFFF;
|
||||
const u32 offset = (data >> 16) << 1;
|
||||
const u32 offset = (data >> 16) << 1;
|
||||
LogInfo("Pointer: %08x", ptr);
|
||||
LogInfo("Byte: %08x", theshort);
|
||||
LogInfo("Offset: %08x", offset);
|
||||
@ -465,8 +430,8 @@ static bool Subtype_WriteToPointer(const ARAddr& addr, const u32 data)
|
||||
default:
|
||||
LogInfo("Bad Size");
|
||||
PanicAlertT("Action Replay Error: Invalid size "
|
||||
"(%08x : address = %08x) in Write To Pointer (%s)",
|
||||
addr.size, addr.gcaddr, current_code->name.c_str());
|
||||
"(%08x : address = %08x) in Write To Pointer (%s)",
|
||||
addr.size, addr.gcaddr, s_current_code->name.c_str());
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
@ -512,8 +477,10 @@ static bool Subtype_AddCode(const ARAddr& addr, const u32 data)
|
||||
LogInfo("--------");
|
||||
|
||||
const u32 read = PowerPC::HostRead_U32(new_addr);
|
||||
const float fread = *((float*)&read) + (float)data; // data contains an integer value
|
||||
const u32 newval = *((u32*)&fread);
|
||||
const float read_float = reinterpret_cast<const float&>(read);
|
||||
// data contains an (unsigned?) integer value
|
||||
const float fread = read_float + static_cast<float>(data);
|
||||
const u32 newval = reinterpret_cast<const u32&>(fread);
|
||||
PowerPC::HostWrite_U32(newval, new_addr);
|
||||
LogInfo("Old Value %08x", read);
|
||||
LogInfo("Increment %08x", data);
|
||||
@ -525,8 +492,8 @@ static bool Subtype_AddCode(const ARAddr& addr, const u32 data)
|
||||
default:
|
||||
LogInfo("Bad Size");
|
||||
PanicAlertT("Action Replay Error: Invalid size "
|
||||
"(%08x : address = %08x) in Add Code (%s)",
|
||||
addr.size, addr.gcaddr, current_code->name.c_str());
|
||||
"(%08x : address = %08x) in Add Code (%s)",
|
||||
addr.size, addr.gcaddr, s_current_code->name.c_str());
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
@ -540,18 +507,20 @@ static bool Subtype_MasterCodeAndWriteToCCXXXXXX(const ARAddr& addr, const u32 d
|
||||
// u8 mcode_count = (data & 0xFF00) >> 8;
|
||||
// u8 mcode_number = data & 0xFF;
|
||||
PanicAlertT("Action Replay Error: Master Code and Write To CCXXXXXX not implemented (%s)\n"
|
||||
"Master codes are not needed. Do not use master codes.", current_code->name.c_str());
|
||||
"Master codes are not needed. Do not use master codes.",
|
||||
s_current_code->name.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool ZeroCode_FillAndSlide(const u32 val_last, const ARAddr& addr, const u32 data) // This needs more testing
|
||||
// This needs more testing
|
||||
static bool ZeroCode_FillAndSlide(const u32 val_last, const ARAddr& addr, const u32 data)
|
||||
{
|
||||
const u32 new_addr = ((ARAddr*)&val_last)->GCAddress();
|
||||
const u8 size = ((ARAddr*)&val_last)->size;
|
||||
const u32 new_addr = ARAddr(val_last).GCAddress();
|
||||
const u8 size = ARAddr(val_last).size;
|
||||
|
||||
const s16 addr_incr = (s16)(data & 0xFFFF);
|
||||
const s8 val_incr = (s8)(data >> 24);
|
||||
const u8 write_num = (data & 0xFF0000) >> 16;
|
||||
const s16 addr_incr = static_cast<s16>(data & 0xFFFF);
|
||||
const s8 val_incr = static_cast<s8>(data >> 24);
|
||||
const u8 write_num = static_cast<u8>((data & 0xFF0000) >> 16);
|
||||
|
||||
u32 val = addr;
|
||||
u32 curr_addr = new_addr;
|
||||
@ -612,7 +581,8 @@ static bool ZeroCode_FillAndSlide(const u32 val_last, const ARAddr& addr, const
|
||||
|
||||
default:
|
||||
LogInfo("Bad Size");
|
||||
PanicAlertT("Action Replay Error: Invalid size (%08x : address = %08x) in Fill and Slide (%s)", size, new_addr, current_code->name.c_str());
|
||||
PanicAlertT("Action Replay Error: Invalid size (%08x : address = %08x) in Fill and Slide (%s)",
|
||||
size, new_addr, s_current_code->name.c_str());
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
@ -659,7 +629,8 @@ static bool ZeroCode_MemoryCopy(const u32 val_last, const ARAddr& addr, const u3
|
||||
else
|
||||
{
|
||||
LogInfo("Bad Value");
|
||||
PanicAlertT("Action Replay Error: Invalid value (%08x) in Memory Copy (%s)", (data & ~0x7FFF), current_code->name.c_str());
|
||||
PanicAlertT("Action Replay Error: Invalid value (%08x) in Memory Copy (%s)",
|
||||
(data & ~0x7FFF), s_current_code->name.c_str());
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
@ -695,9 +666,9 @@ static bool NormalCode(const ARAddr& addr, const u32 data)
|
||||
|
||||
default:
|
||||
LogInfo("Bad Subtype");
|
||||
PanicAlertT("Action Replay: Normal Code 0: Invalid Subtype %08x (%s)", addr.subtype, current_code->name.c_str());
|
||||
PanicAlertT("Action Replay: Normal Code 0: Invalid Subtype %08x (%s)", addr.subtype,
|
||||
s_current_code->name.c_str());
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
@ -709,43 +680,36 @@ static bool CompareValues(const u32 val1, const u32 val2, const int type)
|
||||
{
|
||||
case CONDTIONAL_EQUAL:
|
||||
LogInfo("Type 1: If Equal");
|
||||
return (val1 == val2);
|
||||
break;
|
||||
return val1 == val2;
|
||||
|
||||
case CONDTIONAL_NOT_EQUAL:
|
||||
LogInfo("Type 2: If Not Equal");
|
||||
return (val1 != val2);
|
||||
break;
|
||||
return val1 != val2;
|
||||
|
||||
case CONDTIONAL_LESS_THAN_SIGNED:
|
||||
LogInfo("Type 3: If Less Than (Signed)");
|
||||
return ((int)val1 < (int)val2);
|
||||
break;
|
||||
return static_cast<s32>(val1) < static_cast<s32>(val2);
|
||||
|
||||
case CONDTIONAL_GREATER_THAN_SIGNED:
|
||||
LogInfo("Type 4: If Greater Than (Signed)");
|
||||
return ((int)val1 >(int)val2);
|
||||
break;
|
||||
return static_cast<s32>(val1) > static_cast<s32>(val2);
|
||||
|
||||
case CONDTIONAL_LESS_THAN_UNSIGNED:
|
||||
LogInfo("Type 5: If Less Than (Unsigned)");
|
||||
return (val1 < val2);
|
||||
break;
|
||||
return val1 < val2;
|
||||
|
||||
case CONDTIONAL_GREATER_THAN_UNSIGNED:
|
||||
LogInfo("Type 6: If Greater Than (Unsigned)");
|
||||
return (val1 > val2);
|
||||
break;
|
||||
return val1 > val2;
|
||||
|
||||
case CONDTIONAL_AND:
|
||||
LogInfo("Type 7: If And");
|
||||
return !!(val1 & val2); // bitwise AND
|
||||
break;
|
||||
|
||||
default: LogInfo("Unknown Compare type");
|
||||
PanicAlertT("Action Replay: Invalid Normal Code Type %08x (%s)", type, current_code->name.c_str());
|
||||
PanicAlertT("Action Replay: Invalid Normal Code Type %08x (%s)",
|
||||
type, s_current_code->name.c_str());
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@ -761,11 +725,11 @@ static bool ConditionalCode(const ARAddr& addr, const u32 data, int* const pSkip
|
||||
switch (addr.size)
|
||||
{
|
||||
case DATATYPE_8BIT:
|
||||
result = CompareValues((u32)PowerPC::HostRead_U8(new_addr), (data & 0xFF), addr.type);
|
||||
result = CompareValues(PowerPC::HostRead_U8(new_addr), (data & 0xFF), addr.type);
|
||||
break;
|
||||
|
||||
case DATATYPE_16BIT:
|
||||
result = CompareValues((u32)PowerPC::HostRead_U16(new_addr), (data & 0xFFFF), addr.type);
|
||||
result = CompareValues(PowerPC::HostRead_U16(new_addr), (data & 0xFFFF), addr.type);
|
||||
break;
|
||||
|
||||
case DATATYPE_32BIT_FLOAT:
|
||||
@ -775,9 +739,9 @@ static bool ConditionalCode(const ARAddr& addr, const u32 data, int* const pSkip
|
||||
|
||||
default:
|
||||
LogInfo("Bad Size");
|
||||
PanicAlertT("Action Replay: Conditional Code: Invalid Size %08x (%s)", addr.size, current_code->name.c_str());
|
||||
PanicAlertT("Action Replay: Conditional Code: Invalid Size %08x (%s)", addr.size,
|
||||
s_current_code->name.c_str());
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
|
||||
// if the comparison failed we need to skip some lines
|
||||
@ -794,58 +758,41 @@ static bool ConditionalCode(const ARAddr& addr, const u32 data, int* const pSkip
|
||||
// Skip lines until a "00000000 40000000" line is reached
|
||||
case CONDTIONAL_ALL_LINES:
|
||||
case CONDTIONAL_ALL_LINES_UNTIL:
|
||||
*pSkipCount = -(int) addr.subtype;
|
||||
*pSkipCount = -static_cast<int>(addr.subtype);
|
||||
break;
|
||||
|
||||
default:
|
||||
LogInfo("Bad Subtype");
|
||||
PanicAlertT("Action Replay: Normal Code %i: Invalid subtype %08x (%s)", 1, addr.subtype, current_code->name.c_str());
|
||||
PanicAlertT("Action Replay: Normal Code %i: Invalid subtype %08x (%s)",
|
||||
1, addr.subtype, s_current_code->name.c_str());
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void RunAllActive()
|
||||
{
|
||||
if (SConfig::GetInstance().bEnableCheats)
|
||||
{
|
||||
for (auto& activeCode : activeCodes)
|
||||
{
|
||||
if (activeCode.active)
|
||||
{
|
||||
activeCode.active = RunCode(activeCode);
|
||||
LogInfo("\n");
|
||||
}
|
||||
}
|
||||
|
||||
b_RanOnce = true;
|
||||
}
|
||||
}
|
||||
|
||||
bool RunCode(const ARCode &arcode)
|
||||
// NOTE: Lock needed to give mutual exclusion to s_current_code and LogInfo
|
||||
static bool RunCodeLocked(const ARCode& arcode)
|
||||
{
|
||||
// The mechanism is different than what the real AR uses, so there may be compatibility problems.
|
||||
|
||||
bool doFillNSlide = false;
|
||||
bool doMemoryCopy = false;
|
||||
bool do_fill_and_slide = false;
|
||||
bool do_memory_copy = false;
|
||||
|
||||
// used for conditional codes
|
||||
int skip_count = 0;
|
||||
|
||||
u32 val_last = 0;
|
||||
|
||||
current_code = &arcode;
|
||||
s_current_code = &arcode;
|
||||
|
||||
LogInfo("Code Name: %s", arcode.name.c_str());
|
||||
LogInfo("Number of codes: %zu", arcode.ops.size());
|
||||
|
||||
for (const AREntry& entry : arcode.ops)
|
||||
{
|
||||
const ARAddr& addr = *(ARAddr*)&entry.cmd_addr;
|
||||
const ARAddr addr(entry.cmd_addr);
|
||||
const u32 data = entry.value;
|
||||
|
||||
// after a conditional code, skip lines if needed
|
||||
@ -877,9 +824,9 @@ bool RunCode(const ARCode &arcode)
|
||||
//LogInfo("Command: %08x", cmd);
|
||||
|
||||
// Do Fill & Slide
|
||||
if (doFillNSlide)
|
||||
if (do_fill_and_slide)
|
||||
{
|
||||
doFillNSlide = false;
|
||||
do_fill_and_slide = false;
|
||||
LogInfo("Doing Fill And Slide");
|
||||
if (false == ZeroCode_FillAndSlide(val_last, addr, data))
|
||||
return false;
|
||||
@ -887,9 +834,9 @@ bool RunCode(const ARCode &arcode)
|
||||
}
|
||||
|
||||
// Memory Copy
|
||||
if (doMemoryCopy)
|
||||
if (do_memory_copy)
|
||||
{
|
||||
doMemoryCopy = false;
|
||||
do_memory_copy = false;
|
||||
LogInfo("Doing Memory Copy");
|
||||
if (false == ZeroCode_MemoryCopy(val_last, addr, data))
|
||||
return false;
|
||||
@ -912,7 +859,7 @@ bool RunCode(const ARCode &arcode)
|
||||
// Zero codes
|
||||
if (0x0 == addr) // Check if the code is a zero code
|
||||
{
|
||||
const u8 zcode = (data >> 29);
|
||||
const u8 zcode = data >> 29;
|
||||
|
||||
LogInfo("Doing Zero Code %08x", zcode);
|
||||
|
||||
@ -921,7 +868,6 @@ bool RunCode(const ARCode &arcode)
|
||||
case ZCODE_END: // END OF CODES
|
||||
LogInfo("ZCode: End Of Codes");
|
||||
return true;
|
||||
break;
|
||||
|
||||
// TODO: the "00000000 40000000"(end if) codes fall into this case, I don't think that is correct
|
||||
case ZCODE_NORM: // Normal execution of codes
|
||||
@ -934,19 +880,18 @@ bool RunCode(const ARCode &arcode)
|
||||
LogInfo("ZCode: Executes all codes in the same row, Set register 1BB4 to 1 (zcode not supported)");
|
||||
PanicAlertT("Zero 3 code not supported");
|
||||
return false;
|
||||
break;
|
||||
|
||||
case ZCODE_04: // Fill & Slide or Memory Copy
|
||||
if (0x3 == ((data >> 25) & 0x03))
|
||||
{
|
||||
LogInfo("ZCode: Memory Copy");
|
||||
doMemoryCopy = true;
|
||||
do_memory_copy = true;
|
||||
val_last = data;
|
||||
}
|
||||
else
|
||||
{
|
||||
LogInfo("ZCode: Fill And Slide");
|
||||
doFillNSlide = true;
|
||||
do_fill_and_slide = true;
|
||||
val_last = data;
|
||||
}
|
||||
break;
|
||||
@ -955,7 +900,6 @@ bool RunCode(const ARCode &arcode)
|
||||
LogInfo("ZCode: Unknown");
|
||||
PanicAlertT("Zero code unknown to Dolphin: %08x", zcode);
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
|
||||
// done handling zero codes
|
||||
@ -981,9 +925,25 @@ bool RunCode(const ARCode &arcode)
|
||||
}
|
||||
}
|
||||
|
||||
b_RanOnce = true;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void RunAllActive()
|
||||
{
|
||||
if (!SConfig::GetInstance().bEnableCheats)
|
||||
return;
|
||||
|
||||
// If the mutex is idle then acquiring it should be cheap, fast mutexes
|
||||
// are only atomic ops unless contested. It should be rare for this to
|
||||
// be contested.
|
||||
std::lock_guard<std::mutex> guard(s_lock);
|
||||
s_active_codes.erase(std::remove_if(s_active_codes.begin(), s_active_codes.end(), [](const ARCode& code)
|
||||
{
|
||||
bool success = RunCodeLocked(code);
|
||||
LogInfo("\n");
|
||||
return !success;
|
||||
}), s_active_codes.end());
|
||||
s_disable_logging = true;
|
||||
}
|
||||
|
||||
} // namespace ActionReplay
|
||||
|
||||
Reference in New Issue
Block a user