ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #6843 from lioncash/patch 

PatchEngine: Minor changes
This commit is contained in:
Léo Lam 2018-05-13 21:58:55 +02:00 committed by GitHub
parent e67cbd462b 5fd8cec7ea
commit 07b57c7ac6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 73 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
Source/Core/Core/PatchEngine.cpp
View File

@ -9,6 +9,8 @@
#include "Core/PatchEngine.h"
#include <algorithm>
#include <array>
#include <iterator>
#include <map>
#include <set>
#include <string>
@ -26,14 +28,19 @@
namespace PatchEngine
{
const char* PatchTypeStrings[] = {
constexpr std::array<const char*, 3> s_patch_type_strings{{
"byte",
"word",
"dword",
};
}};
static std::vector<Patch> onFrame;
static std::map<u32, int> speedHacks;
static std::vector<Patch> s_on_frame;
static std::map<u32, int> s_speed_hacks;
const char* PatchTypeAsString(PatchType type)
{
return s_patch_type_strings.at(static_cast<int>(type));
}
void LoadPatchSection(const std::string& section, std::vector<Patch>& patches, IniFile& globalIni,
IniFile& localIni)
@ -97,8 +104,10 @@ void LoadPatchSection(const std::string& section, std::vector<Patch>& patches, I
success &= TryParse(items[0], &pE.address);
success &= TryParse(items[2], &pE.value);
pE.type = PatchType(std::find(PatchTypeStrings, PatchTypeStrings + 3, items[1]) -
PatchTypeStrings);
const auto iter =
std::find(s_patch_type_strings.begin(), s_patch_type_strings.end(), items[1]);
pE.type = PatchType(std::distance(s_patch_type_strings.begin(), iter));
success &= (pE.type != (PatchType)3);
if (success)
{
@ -132,7 +141,7 @@ static void LoadSpeedhacks(const std::string& section, IniFile& ini)
success &= TryParse(value, &cycles);
if (success)
{
speedHacks[address] = (int)cycles;
s_speed_hacks[address] = static_cast<int>(cycles);
}
}
}
@ -140,11 +149,11 @@ static void LoadSpeedhacks(const std::string& section, IniFile& ini)
int GetSpeedhackCycles(const u32 addr)
{
std::map<u32, int>::const_iterator iter = speedHacks.find(addr);
if (iter == speedHacks.end())
const auto iter = s_speed_hacks.find(addr);
if (iter == s_speed_hacks.end())
return 0;
else
return iter->second;
return iter->second;
}
void LoadPatches()
@ -153,7 +162,7 @@ void LoadPatches()
IniFile globalIni = SConfig::GetInstance().LoadDefaultGameIni();
IniFile localIni = SConfig::GetInstance().LoadLocalGameIni();
LoadPatchSection("OnFrame", onFrame, globalIni, localIni);
LoadPatchSection("OnFrame", s_on_frame, globalIni, localIni);
ActionReplay::LoadAndApplyCodes(globalIni, localIni);
Gecko::SetActiveCodes(Gecko::LoadCodes(globalIni, localIni));
@ -173,13 +182,13 @@ static void ApplyPatches(const std::vector<Patch>& patches)
u32 value = entry.value;
switch (entry.type)
{
case PATCH_8BIT:
PowerPC::HostWrite_U8((u8)value, addr);
case PatchType::Patch8Bit:
PowerPC::HostWrite_U8(static_cast<u8>(value), addr);
break;
case PATCH_16BIT:
PowerPC::HostWrite_U16((u16)value, addr);
case PatchType::Patch16Bit:
PowerPC::HostWrite_U16(static_cast<u16>(value), addr);
break;
case PATCH_32BIT:
case PatchType::Patch32Bit:
PowerPC::HostWrite_U32(value, addr);
break;
default:
@ -229,7 +238,7 @@ bool ApplyFramePatches()
return false;
}
ApplyPatches(onFrame);
ApplyPatches(s_on_frame);
// Run the Gecko code handler
Gecko::RunCodeHandler();
@ -240,8 +249,8 @@ bool ApplyFramePatches()
void Shutdown()
{
onFrame.clear();
speedHacks.clear();
s_on_frame.clear();
s_speed_hacks.clear();
ActionReplay::ApplyCodes({});
Gecko::Shutdown();
}

32
Source/Core/Core/PatchEngine.h
View File

@ -13,32 +13,32 @@ class IniFile;
namespace PatchEngine
{
enum PatchType
enum class PatchType
{
PATCH_8BIT,
PATCH_16BIT,
PATCH_32BIT,
Patch8Bit,
Patch16Bit,
Patch32Bit,
};
extern const char* PatchTypeStrings[];
struct PatchEntry
{
PatchEntry() {}
PatchEntry(PatchType _t, u32 _addr, u32 _value) : type(_t), address(_addr), value(_value) {}
PatchType type;
u32 address;
u32 value;
PatchEntry() = default;
PatchEntry(PatchType t, u32 addr, u32 value_) : type(t), address(addr), value(value_) {}
PatchType type = PatchType::Patch8Bit;
u32 address = 0;
u32 value = 0;
};
struct Patch
{
std::string name;
std::vector<PatchEntry> entries;
bool active;
bool user_defined; // False if this code is shipped with Dolphin.
bool active = false;
bool user_defined = false; // False if this code is shipped with Dolphin.
};
const char* PatchTypeAsString(PatchType type);
int GetSpeedhackCycles(const u32 addr);
void LoadPatchSection(const std::string& section, std::vector<Patch>& patches, IniFile& globalIni,
IniFile& localIni);
@ -52,15 +52,15 @@ inline int GetPatchTypeCharLength(PatchType type)
int size = 8;
switch (type)
{
case PatchEngine::PATCH_8BIT:
case PatchType::Patch8Bit:
size = 2;
break;
case PatchEngine::PATCH_16BIT:
case PatchType::Patch16Bit:
size = 4;
break;
case PatchEngine::PATCH_32BIT:
case PatchType::Patch32Bit:
size = 8;
break;
}

18
Source/Core/DolphinQt2/Config/NewPatchDialog.cpp
View File

@ -77,11 +77,7 @@ void NewPatchDialog::ConnectWidgets()
void NewPatchDialog::AddEntry()
{
PatchEngine::PatchEntry entry;
entry.type = PatchEngine::PATCH_8BIT;
entry.address = entry.value = 0;
m_patch.entries.push_back(entry);
m_patch.entries.emplace_back();
m_entry_layout->addWidget(CreateEntry(static_cast<int>(m_patch.entries.size() - 1)));
}
@ -163,24 +159,24 @@ QGroupBox* NewPatchDialog::CreateEntry(int index)
connect(byte, &QRadioButton::toggled, [this, index](bool checked) {
if (checked)
m_patch.entries[index].type = PatchEngine::PATCH_8BIT;
m_patch.entries[index].type = PatchEngine::PatchType::Patch8Bit;
});
connect(word, &QRadioButton::toggled, [this, index](bool checked) {
if (checked)
m_patch.entries[index].type = PatchEngine::PATCH_16BIT;
m_patch.entries[index].type = PatchEngine::PatchType::Patch16Bit;
});
connect(dword, &QRadioButton::toggled, [this, index](bool checked) {
if (checked)
m_patch.entries[index].type = PatchEngine::PATCH_32BIT;
m_patch.entries[index].type = PatchEngine::PatchType::Patch32Bit;
});
auto entry_type = m_patch.entries[index].type;
byte->setChecked(entry_type == PatchEngine::PATCH_8BIT);
word->setChecked(entry_type == PatchEngine::PATCH_16BIT);
dword->setChecked(entry_type == PatchEngine::PATCH_32BIT);
byte->setChecked(entry_type == PatchEngine::PatchType::Patch8Bit);
word->setChecked(entry_type == PatchEngine::PatchType::Patch16Bit);
dword->setChecked(entry_type == PatchEngine::PatchType::Patch32Bit);
offset->setText(
QStringLiteral("%1").arg(m_patch.entries[index].address, 10, 16, QLatin1Char('0')));

2
Source/Core/DolphinQt2/Config/PatchesWidget.cpp
View File

@ -138,7 +138,7 @@ void PatchesWidget::SavePatches()
for (const auto& entry : patch.entries)
{
lines.push_back(StringFromFormat("0x%08X:%s:0x%08X", entry.address,
PatchEngine::PatchTypeStrings[entry.type], entry.value));
PatchEngine::PatchTypeAsString(entry.type), entry.value));
}
}

7
Source/Core/DolphinWX/ISOProperties/ISOProperties.cpp
View File

@ -755,9 +755,10 @@ void CISOProperties::PatchList_Save()
lines.push_back("$" + p.name);
for (const PatchEngine::PatchEntry& entry : p.entries)
{
std::string temp = StringFromFormat("0x%08X:%s:0x%08X", entry.address,
PatchEngine::PatchTypeStrings[entry.type], entry.value);
lines.push_back(temp);
std::string temp =
StringFromFormat("0x%08X:%s:0x%08X", entry.address,
PatchEngine::PatchTypeAsString(entry.type), entry.value);
lines.push_back(std::move(temp));
}
}
++index;

29
Source/Core/DolphinWX/PatchAddEdit.cpp
View File

@ -42,7 +42,7 @@ void CPatchAddEdit::CreateGUIControls(int _selection)
if (_selection == -1)
{
tempEntries.clear();
tempEntries.emplace_back(PatchEngine::PATCH_8BIT, 0x00000000, 0x00000000);
tempEntries.emplace_back();
}
else
{
@ -68,11 +68,14 @@ void CPatchAddEdit::CreateGUIControls(int _selection)
EntrySelection->SetRange(0, (int)tempEntries.size() - 1);
EntrySelection->SetValue((int)tempEntries.size() - 1);
wxArrayString wxArrayStringFor_EditPatchType;
wxArrayString patch_types;
for (int i = 0; i < 3; ++i)
wxArrayStringFor_EditPatchType.Add(StrToWxStr(PatchEngine::PatchTypeStrings[i]));
EditPatchType = new wxRadioBox(this, wxID_ANY, _("Type"), wxDefaultPosition, wxDefaultSize,
wxArrayStringFor_EditPatchType, 3, wxRA_SPECIFY_COLS);
{
patch_types.Add(
StrToWxStr(PatchEngine::PatchTypeAsString(static_cast<PatchEngine::PatchType>(i))));
}
EditPatchType =
new wxRadioBox(this, wxID_ANY, _("Type"), wxDefaultPosition, wxDefaultSize, patch_types);
EditPatchType->SetSelection((int)tempEntries.at(0).type);
wxStaticText* EditPatchValueText = new wxStaticText(this, wxID_ANY, _("Value:"));
@ -165,7 +168,7 @@ void CPatchAddEdit::AddEntry(wxCommandEvent& event)
if (!UpdateTempEntryData(itCurEntry))
return;
PatchEngine::PatchEntry peEmptyEntry(PatchEngine::PATCH_8BIT, 0x00000000, 0x00000000);
PatchEngine::PatchEntry peEmptyEntry;
++itCurEntry;
currentItem++;
itCurEntry = tempEntries.insert(itCurEntry, peEmptyEntry);
@ -206,7 +209,7 @@ void CPatchAddEdit::UpdateEntryCtrls(PatchEngine::PatchEntry pE)
sbEntry->GetStaticBox()->SetLabel(
wxString::Format(_("Entry %d/%d"), currentItem, (int)tempEntries.size()));
EditPatchOffset->SetValue(wxString::Format("%08X", pE.address));
EditPatchType->SetSelection(pE.type);
EditPatchType->SetSelection(static_cast<int>(pE.type));
EditPatchValue->SetValue(
wxString::Format("%0*X", PatchEngine::GetPatchTypeCharLength(pE.type), pE.value));
}
@ -217,19 +220,19 @@ bool CPatchAddEdit::UpdateTempEntryData(std::vector<PatchEngine::PatchEntry>::it
bool parsed_ok = true;
if (EditPatchOffset->GetValue().ToULong(&value, 16))
(*iterEntry).address = value;
iterEntry->address = value;
else
parsed_ok = false;
PatchEngine::PatchType tempType = (*iterEntry).type =
(PatchEngine::PatchType)EditPatchType->GetSelection();
const auto tempType = iterEntry->type =
static_cast<PatchEngine::PatchType>(EditPatchType->GetSelection());
if (EditPatchValue->GetValue().ToULong(&value, 16))
{
(*iterEntry).value = value;
if (tempType == PatchEngine::PATCH_8BIT && value > 0xff)
iterEntry->value = value;
if (tempType == PatchEngine::PatchType::Patch8Bit && value > 0xff)
parsed_ok = false;
else if (tempType == PatchEngine::PATCH_16BIT && value > 0xffff)
else if (tempType == PatchEngine::PatchType::Patch16Bit && value > 0xffff)
parsed_ok = false;
}
else