如何寫一個單機遊戲修改器？

CCard::CCard() : m_dwCardID(NULL), m_emCardAttribute(em_CardAttribute::em_CardAttribute_Unknow)
{

}

CCard::CCard(_In_ DWORD64 dwCardId) : m_dwCardID(dwCardId), m_emCardAttribute(em_CardAttribute::em_CardAttribute_Unknow)
{
if (GetCardAttribute() != em_CardAttribute::em_CardAttribute_Unknow)
{
SetCardName();
SetCardDetail();
}
}

DWORD64 CCard::GetCardID() CONST
{
return m_dwCardID 0xFFFF;
}

CONST std::wstring CCard::GetCardDetail() CONST
{
return m_wsCardDetail;
}

CONST std::wstring CCard::GetCardName() CONST
{
return m_wsCardName;
}

em_CardAttribute CCard::GetCardAttribute() CONST
{
if (m_emCardAttribute != em_CardAttribute::em_CardAttribute_Unknow)
return m_emCardAttribute;

if (!IsCard())
return em_CardAttribute::em_CardAttribute_Unknow;

DWORD64 ulValue = GetCardID() * 3;
ulValue *= 2;

m_emCardAttribute = static_cast&(ReadDWORD64(CARD_ATTRIBUTE_BASE + ulValue * 8 + 0x14));
return m_emCardAttribute;
}

VOID CCard::SetCardName()
{
DWORD64 r8 = ReadDWORD64(ReadDWORD64(CARD_NAME_BASE) + 0x18);
DWORD64 rdx = ReadDWORD64(ReadDWORD64(CARD_NAME_BASE) + 0x28);
if (r8 == NULL || rdx == NULL)
return;

if (!IsCard())
return;

auto ulCardID = GetCardID() - 0xF3C;
DWORD64 ulNamePtr = ReadDWORD64((ReadDWORD64(CARD_NAME_INDEX_BASE + ulCardID * 2) 0xFFFF) * 8 + rdx) + r8;
if (ulNamePtr == NULL)
return;

WCHAR wszCardName[512] = { 0 };
memcpy(wszCardName, reinterpret_cast&(ulNamePtr 0xFFFFFFFF), _countof(wszCardName) - 1);
m_wsCardName = wszCardName;
}

bool CCard::IsCard() CONST
{
return GetCardID() &<= 0x3091 GetCardID() &>= 0xF3C;
}

VOID CCard::SetCardDetail()
{
DWORD64 r8 = ReadDWORD64(ReadDWORD64(CARD_NAME_BASE) + 0x38);
DWORD64 rdx = ReadDWORD64(ReadDWORD64(CARD_NAME_BASE) + 0x28);
if (r8 == NULL || rdx == NULL)
return;

if (!IsCard())
return;

auto ulCardID = GetCardID() - 0xF3C;
DWORD64 ulDetailPtr = ReadDWORD64((ReadDWORD64(CARD_NAME_INDEX_BASE + ulCardID * 2) 0xFFFF) * 8 + 0x4 + rdx) + r8;
if (ulDetailPtr == NULL)
return;

WCHAR wszDetailText[512] = { 0 };
memcpy(wszDetailText, reinterpret_cast&(ulDetailPtr 0xFFFFFFFF), _countof(wszDetailText) - 1);
m_wsCardDetail = wszDetailText;
}

DWORD CCard::GetPower() CONST
{
if (!IsCard())
return 0;

auto RCX = GetCardID() * 3;
RCX &<&<= 0x4; auto EAX = ReadDWORD64(CARD_ATTRIBUTE_BASE + RCX + 0x4); if (EAX == 0x1FF) return 0; EAX *= 5; EAX *= 2; return static_cast&(EAX);
}

DWORD CCard::GetDefence() CONST
{
if (!IsCard())
return 0;

auto RCX = GetCardID() * 3;
RCX &<&<= 0x4; auto EAX = ReadDWORD64(CARD_ATTRIBUTE_BASE + RCX + 0x8); if (EAX == 0x1FF) return 0; EAX *= 5; EAX *= 2; return static_cast&(EAX);
}

DWORD CCard::GetStarCount() CONST
{
if (!IsCard())
return 0;

auto RCX = GetCardID() * 3;
RCX &<&<= 0x4; auto EAX = ReadDWORD64(CARD_ATTRIBUTE_BASE + RCX + 0xC) 0xFFFFFFFF; return static_cast&(ReadDWORD64(CARD_ATTRIBUTE_BASE + RCX + 0x18) 0xFFFFFFFF);
}

CONST std::wstring CCard::GetCardAttributeText() CONST
{
struct AttributeText
{
em_CardAttribute emCardAttribute;
std::wstring wsText;
};

CONST static std::vector& VecAttributeText =
{
{ em_CardAttribute::em_CardAttribute_Magic, L"魔法卡" },
{ em_CardAttribute::em_CardAttribute_Trap, L"陷阱卡" },
{ em_CardAttribute::em_CardAttribute_Land, L"地" },
{ em_CardAttribute::em_CardAttribute_Dark, L"暗" },
{ em_CardAttribute::em_CardAttribute_Light, L"光" },
{ em_CardAttribute::em_CardAttribute_Water, L"水" },
{ em_CardAttribute::em_CardAttribute_Wind, L"風" },
{ em_CardAttribute::em_CardAttribute_Fire, L"炎" },
{ em_CardAttribute::em_CardAttribute_God, L"神" },
{ em_CardAttribute::em_CardAttribute_Dark2, L"暗" },
};
CONST static std::wstring wsUnknow = L"未知";

auto itr = std::find_if(VecAttributeText.begin(), VecAttributeText.end(), [this](CONST AttributeText AttributeText_){ return AttributeText_.emCardAttribute == m_emCardAttribute; });
return itr == VecAttributeText.end() ? wsUnknow : itr-&>wsText;
}

#include "Card.h"
#include &

class CCardExtend
{
public:
CCardExtend() = defau< ~CCardExtend() = defau< static CCardExtend GetInstance(); // Get ALL Card UINT64 GetALLCard(_Out_opt_ std::vector& VecCard) CONST;

// Get Count of CurrentCardGroup
UINT64 GetCurrentCardGroup(_Out_opt_ std::vector& VecCard) CONST;

// Set Next Card by CardID
BOOL SetNextCard(_In_ DWORD dwCardId) CONST;

// Set Card To Desk
BOOL SetCardToDesk(_In_ DWORD dwCardId) CONST;

BOOL SetIniazleCard(_In_ CONST std::vector& VecCard) CONST;
private:
BOOL ExistCardInCardGroup(_In_ DWORD dwCardId) CONST;
};

#endif // !__NEWYUGIOH_CHEATDLL_X64_CARD_CARDEXTEND_H__

#include "stdafx.h"
#include "CardExtend.h"
#include &
#include &
#include &

#define _SELF L"CardExtend.cpp"
CCardExtend CCardExtend::GetInstance()
{
static CCardExtend CCardExtend_;
return CCardExtend_;
}

UINT64 CCardExtend::GetALLCard(_Out_opt_ std::vector& VecCard) CONST
{
for (DWORD dwCardId = 0xF3C; dwCardId &< 0x3091; ++dwCardId) { CCard Card(dwCardId); if (Card.GetCardAttribute() != em_CardAttribute::em_CardAttribute_Unknow) VecCard.push_back(std::move(Card)); } return VecCard.size(); } UINT64 CCardExtend::GetCurrentCardGroup(_Out_opt_ std::vector& VecCard) CONST
{
auto ulAddr = CURRENT_CARD_GROUP_BASE - 0x438;
for (int i = 0; i &< 60; ++i, ulAddr += 4) { if (ReadDWORD64(ulAddr) == NULL) continue; CCard Card(CCharacter::ReadDWORD(ulAddr) 0xFFFFFFFF); if (Card.GetCardAttribute() != em_CardAttribute::em_CardAttribute_Unknow) VecCard.push_back(std::move(Card)); } return VecCard.size(); } BOOL CCardExtend::SetNextCard(_In_ DWORD dwCardId) CONST { /*if (!ExistCardInCardGroup(dwCardId)) { //::MessageBoxW(NULL, L"該ID不存在卡組裡面!", L"", NULL); return FALSE; }*/ auto ulAddr = CURRENT_CARD_GROUP_BASE - 0x438; auto dwValue = ReadDWORD64(ulAddr); dwValue &>&>= 0x10;
dwValue &<&<= 0x10; dwValue += dwCardId; *reinterpret_cast&(ulAddr) = dwValue;
return FALSE;
}

BOOL CCardExtend::ExistCardInCardGroup(_In_ DWORD dwCardId) CONST
{
std::vector& VecCard;
GetCurrentCardGroup(VecCard);

auto itr = std::find_if(VecCard.begin(), VecCard.end(), [dwCardId](CONST CCard Card){ return static_cast&(Card.GetFullID()) == dwCardId; });
return itr != VecCard.end();
}

BOOL CCardExtend::SetCardToDesk(_In_ DWORD dwCardId) CONST
{
auto ulAddr = CURRENT_CARD_DESK_BASE + 0x30 + 0x48;
for (DWORD64 i = 0; i &<= 20; ++i) { DWORD64 ulCardAddr = ulAddr + i * 4 * 6; LOG_CF_D(L"ulCardAddr=%lX, CardId=%lX", ulCardAddr, (ReadDWORD64(ulCardAddr) 0xFFFF)); if ((ReadDWORD64(ulCardAddr) 0xFFFF) == NULL) continue; dwCardId += static_cast&(ReadDWORD64(ulCardAddr) 0xFFFF0000);
LOG_CF_D(L"Set Value ulCardAddr=%lX, CardId=%X", ulCardAddr, dwCardId);
WriteValue(ulCardAddr, dwCardId);
return TRUE;
}
return FALSE;
}

BOOL CCardExtend::SetIniazleCard(_In_ CONST std::vector& VecCard) CONST
{
if (VecCard.size() &> 5)
{
MsgBoxLog(L"VecCard.size=%d &> 5!", VecCard.size());
return FALSE;
}

std::vector& VecGroupCard;
GetCurrentCardGroup(VecGroupCard);

DWORD64 ulGroupAddr = CURRENT_CARD_GROUP_BASE - 0x438;
for (size_t i = 0;i &< VecCard.size(); ++i) { DWORD dwCardId = VecCard.at(i); auto p = CLPublic::Vec_find_if(VecGroupCard, [dwCardId](CONST CCard Card) { return static_cast&(Card.GetCardID() 0xFFFF) == (dwCardId 0xFFFF); });
if (p == nullptr)
continue;

// swap
for (size_t j = 0; j &< 60; ++j) { DWORD dwGroupCardId = static_cast&(CCharacter::ReadDWORD(ulGroupAddr + j * 4));
if ((dwGroupCardId 0xFFFF) == dwCardId)
{
DWORD dwHandCardId = static_cast&(CCharacter::ReadDWORD(CURRENT_HAND_CARD_BASE + i * 4));
LOG_CF_D(L"OldHandID=%X, OldGroupID=%X", dwHandCardId, dwGroupCardId);

// Set Select Card Id to Hand Card
LOG_CF_D(L"SetHandCardId=%X", dwGroupCardId);
WriteValue(CURRENT_HAND_CARD_BASE + i * 4, dwGroupCardId);

// Set Old HandCard to Group
LOG_CF_D(L"SetGroupCardId=%X", dwHandCardId);
WriteValue(ulGroupAddr + j * 4, dwHandCardId);

LOG_CF_D(L"NewHandID=%X, NewGroupID=%X", static_cast&(CCharacter::ReadDWORD(CURRENT_HAND_CARD_BASE + i * 4)), static_cast&(CCharacter::ReadDWORD(ulGroupAddr + j * 4)));
break;
}
}
}

#include &
#include &
#include &

class CExpr : public CExprFunBase, virtual public CClassInstance&
{
public:
CExpr();
virtual ~CExpr();
public:
virtual VOID Release();

virtual std::vector& GetVec();

private:
virtual VOID Help(_In_ CONST std::vector&);

//
VOID FindCard(_In_ CONST std::vector&);

// Set Next Card
VOID SetDeskCard(_In_ CONST std::vector&);

// Set 5 Card when Start Game
VOID SetInitialCard(_In_ CONST std::vector&);
};

#endif // !__NEWYUGIOH_CHEATDLL_X64_EXPR_EXPR_H__

#include "stdafx.h"
#include "Expr.h"
#include &
#include &
#include "CardExtend.h"

#define _SELF L"Expr.cpp"
CExpr::CExpr()
{

}

CExpr::~CExpr()
{

}

VOID CExpr::Release()
{

}

std::vector& CExpr::GetVec()
{
static std::vector& Vec =
{
{ std::bind(CExpr::Help, this, std::placeholders::_1), L"Help" },
{ std::bind(CExpr::FindCard, this, std::placeholders::_1), L"FindCard" },
{ std::bind(CExpr::SetDeskCard, this, std::placeholders::_1), L"SetDeskCard" },
{ std::bind(CExpr::SetInitialCard, this, std::placeholders::_1), L"SetInitialCard" },
};
return Vec;
}

VOID CExpr::Help(_In_ CONST std::vector&)
{
auto Vec = GetVec();
for (CONST auto itm : Vec)
LOG_C(CLog::em_Log_Type::em_Log_Type_Custome, L"FunctionName=%s", itm.wsFunName.c_str());
}

VOID CExpr::FindCard(_In_ CONST std::vector& VecParm)
{
if (VecParm.size() == 0)
{
LOG_CF_E(L"Parameter.size=0!");
return;
}

CONST std::wstring wsFindType = CCharacter::MakeTextToUpper(VecParm.at(0));
if (wsFindType == L"ALL")
{
std::vector& VecCard;
CCardExtend::GetInstance().GetALLCard(VecCard);
for (CONST auto itm : VecCard)
LOG_CF_D(L"ID=%X,Name=%s,Detail=%s", static_cast&(itm.GetCardID()), itm.GetCardName().c_str(), itm.GetCardDetail().c_str());
}
if (wsFindType == L"GROUP")
{
std::vector& VecCard;
CCardExtend::GetInstance().GetCurrentCardGroup(VecCard);
LOG_CF_D(L"GroupSize=%d", static_cast&(VecCard.size()));
for (CONST auto itm : VecCard)
LOG_CF_D(L"ID=%X,Name=%s,Detail=%s", static_cast&(itm.GetCardID()), itm.GetCardName().c_str(), itm.GetCardDetail().c_str());
}
else if (wsFindType == L"CARDNAME")
{
if (VecParm.size() == 1)
{
LOG_CF_E(L"Parameter.size=1!");
return;
}

CONST std::wstring wsFindText = VecParm.at(1);

std::vector& VecCard;
CCardExtend::GetInstance().GetALLCard(VecCard);
for (CONST auto itm : VecCard)
{
if (itm.GetCardName().find(wsFindText) != -1)
{
LOG_CF_D(L"ID=%X,Name=%s,Detail=%s", static_cast&(itm.GetCardID()), itm.GetCardName().c_str(), itm.GetCardDetail().c_str());
}
}
}
else if (wsFindType == L"CARDID")
{
if (VecParm.size() == 1)
{
LOG_CF_E(L"Parameter.size=1!");
return;
}

DWORD dwCardId = wcstol(VecParm.at(1).c_str(), nullptr, 16);

std::vector& VecCard;
CCardExtend::GetInstance().GetALLCard(VecCard);
for (CONST auto itm : VecCard)
{
if (static_cast&(itm.GetCardID()) == dwCardId)
{
LOG_CF_D(L"ID=%X,Name=%s,Detail=%s", static_cast&(itm.GetCardID()), itm.GetCardName().c_str(), itm.GetCardDetail().c_str());
}
}
}
}

VOID CExpr::SetDeskCard(_In_ CONST std::vector& VecParm)
{
if (VecParm.size() &< 2) { LOG_CF_E(L"Parameter.size&<2!"); return; } CONST std::wstring wsFindType = CCharacter::MakeTextToUpper(VecParm.at(0)); if (wsFindType == L"CARDID") { DWORD dwCardId = static_cast&(wcstol(VecParm.at(1).c_str(), NULL, 16));
CCardExtend::GetInstance().SetCardToDesk(dwCardId);
}
}

VOID CExpr::SetInitialCard(_In_ CONST std::vector& VecParm)
{
std::vector& VecCard;
for (CONST auto itm : VecParm)
VecCard.push_back(wcstol(itm.c_str(), nullptr, 16));

CCardExtend::GetInstance().SetIniazleCard(VecCard);
}

extern DWORD64 ReadDWORD64(_In_ DWORD64 dwAddr)
{
__try
{
if (!::IsBadCodePtr(FARPROC(dwAddr)))
return *reinterpret_cast&(dwAddr);
}
__except (1)
{

}
return NULL;
}

extern VOID WriteValue(_In_ DWORD64 ulAddr, _In_ DWORD dwValue)
{
auto dwCardValue = ReadDWORD64(ulAddr);