Max/esuo1198_TaikoArcadeLoader
1
0
Fork 0
mirror of https://github.com/esuo1198/TaikoArcadeLoader.git synced 2026-09-28 17:58:11 +03:00
Code Issues Packages Projects Releases Wiki Activity

bnusio_original refactor | auto fullscreen use 16:9 calc | language fix enso 良 issue

Browse Source
This commit is contained in:
ptmaster
2025-01-08 09:52:21 +08:00
parent 95b3fec76f
commit 7967dfd845
8 changed files with 172 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/bnusio.cpp
+78 -167
View File
@@ -56,60 +56,65 @@ u8 inputState = 1 | (1 << 2);
bool globalKeyboard = false;
namespace bnusio {
#define RETURN_FALSE(returnType, functionName, ...) \
returnType functionName (__VA_ARGS__) { return 0; }
HMODULE bnusioOriginal = LoadLibrary ("bnusio_original.dll");
#define BNUSIO_EXPORT(returnType, functionName, ...) \
typedef returnType (*type_##functionName) (__VA_ARGS__); \
type_##functionName ori_##functionName = bnusioOriginal == nullptr ? nullptr : (type_##functionName)GetProcAddress (bnusioOriginal, #functionName); \
returnType functionName (__VA_ARGS__)
#define CALL_BNUSIO_FALSE(functionName, ...) \
{ if (!emulateUsio && ori_##functionName) return ori_##functionName (__VA_ARGS__); else return 0; }
typedef u16 (__fastcall *AnalogMethod) (const u8);
AnalogMethod analogMethod = nullptr;
extern "C" {
RETURN_FALSE (i64, bnusio_Open);
RETURN_FALSE (i64, bnusio_Close);
RETURN_FALSE (i64, bnusio_Communication, i32 a1);
RETURN_FALSE (u8, bnusio_IsConnected);
RETURN_FALSE (i32, bnusio_ResetIoBoard);
RETURN_FALSE (u16, bnusio_GetStatusU16, u16 a1);
RETURN_FALSE (u8, bnusio_GetStatusU8, u16 a1);
RETURN_FALSE (u16, bnusio_GetRegisterU16, i16 a1);
RETURN_FALSE (u8, bnusio_GetRegisterU8, u16 a1);
RETURN_FALSE (void *, bnusio_GetBuffer, u16 a1, i64 a2, i16 a3);
RETURN_FALSE (i64, bnusio_SetRegisterU16, u16 a1, u16 a2);
RETURN_FALSE (i64, bnusio_SetRegisterU8, u16 a1, u8 a2);
RETURN_FALSE (i64, bnusio_SetBuffer, u16 a1, i32 a2, i16 a3);
RETURN_FALSE (void *, bnusio_GetSystemError);
RETURN_FALSE (i64, bnusio_SetSystemError, i16 a1);
RETURN_FALSE (i64, bnusio_ClearSram);
RETURN_FALSE (void *, bnusio_GetExpansionMode);
RETURN_FALSE (i64, bnusio_SetExpansionMode, i16 a1);
RETURN_FALSE (u8, bnusio_IsWideUsio);
RETURN_FALSE (u64, bnusio_GetSwIn64);
RETURN_FALSE (u8, bnusio_GetGout, u8 a1);
RETURN_FALSE (i64, bnusio_SetGout, u8 a1, u8 a2);
RETURN_FALSE (u64, bnusio_GetEncoder);
RETURN_FALSE (i64, bnusio_GetCoinLock, u8 a1);
RETURN_FALSE (i64, bnusio_SetCoinLock, u8 a1, u8 a2);
RETURN_FALSE (i64, bnusio_GetCDOut, u8 a1);
RETURN_FALSE (i64, bnusio_SetCDOut, u8 a1, u8 a2);
RETURN_FALSE (i64, bnusio_GetHopOut, u8 a1);
RETURN_FALSE (i64, bnusio_SetHopOut, u8 a1, u8 a2);
RETURN_FALSE (void *, bnusio_SetPLCounter, i16 a1);
RETURN_FALSE (char *, bnusio_GetIoBoardName);
RETURN_FALSE (i64, bnusio_SetHopperRequest, u16 a1, i16 a2);
RETURN_FALSE (i64, bnusio_SetHopperLimit, u16 a1, i16 a2);
RETURN_FALSE (i64, bnusio_SramRead, i32 a1, u8 a2, i32 a3, u16 a4);
RETURN_FALSE (i64, bnusio_SramWrite, i32 a1, u8 a2, i32 a3, u16 a4);
RETURN_FALSE (void *, bnusio_GetCoinError, i32 a1);
RETURN_FALSE (void *, bnusio_GetServiceError, i32 a1);
RETURN_FALSE (i64, bnusio_DecCoin, i32 a1, u16 a2);
RETURN_FALSE (i64, bnusio_DecService, i32 a1, u16 a2);
RETURN_FALSE (i64, bnusio_ResetCoin);
size_t
bnusio_GetFirmwareVersion () {
return 126;
BNUSIO_EXPORT (i64, bnusio_Open) CALL_BNUSIO_FALSE (bnusio_Open)
BNUSIO_EXPORT (i64, bnusio_Close) CALL_BNUSIO_FALSE (bnusio_Close)
BNUSIO_EXPORT (i64, bnusio_Communication, i32 a1) CALL_BNUSIO_FALSE (bnusio_Communication, a1)
BNUSIO_EXPORT (u8, bnusio_IsConnected) CALL_BNUSIO_FALSE (bnusio_IsConnected)
BNUSIO_EXPORT (i32, bnusio_ResetIoBoard) CALL_BNUSIO_FALSE (bnusio_ResetIoBoard)
BNUSIO_EXPORT (u16, bnusio_GetStatusU16, u16 a1) CALL_BNUSIO_FALSE (bnusio_GetStatusU16, a1)
BNUSIO_EXPORT (u8, bnusio_GetStatusU8, u16 a1) CALL_BNUSIO_FALSE (bnusio_GetStatusU8, a1)
BNUSIO_EXPORT (u16, bnusio_GetRegisterU16, i16 a1) CALL_BNUSIO_FALSE (bnusio_GetRegisterU16, a1)
BNUSIO_EXPORT (u8, bnusio_GetRegisterU8, u16 a1) CALL_BNUSIO_FALSE (bnusio_GetRegisterU8, a1)
BNUSIO_EXPORT (void *, bnusio_GetBuffer, u16 a1, i64 a2, i16 a3) CALL_BNUSIO_FALSE (bnusio_GetBuffer, a1, a2, a3)
BNUSIO_EXPORT (i64, bnusio_SetRegisterU16, u16 a1, u16 a2) CALL_BNUSIO_FALSE (bnusio_SetRegisterU16, a1, a2)
BNUSIO_EXPORT (i64, bnusio_SetRegisterU8, u16 a1, u8 a2) CALL_BNUSIO_FALSE (bnusio_SetRegisterU8, a1, a2)
BNUSIO_EXPORT (i64, bnusio_SetBuffer, u16 a1, i32 a2, i16 a3) CALL_BNUSIO_FALSE (bnusio_SetBuffer, a1, a2, a3)
BNUSIO_EXPORT (void *, bnusio_GetSystemError) CALL_BNUSIO_FALSE (bnusio_GetSystemError)
BNUSIO_EXPORT (i64, bnusio_SetSystemError, i16 a1) CALL_BNUSIO_FALSE (bnusio_SetSystemError, a1)
BNUSIO_EXPORT (i64, bnusio_ClearSram) CALL_BNUSIO_FALSE (bnusio_ClearSram)
BNUSIO_EXPORT (void *, bnusio_GetExpansionMode) CALL_BNUSIO_FALSE (bnusio_GetExpansionMode)
BNUSIO_EXPORT (i64, bnusio_SetExpansionMode, i16 a1) CALL_BNUSIO_FALSE (bnusio_SetExpansionMode, a1)
BNUSIO_EXPORT (u8, bnusio_IsWideUsio) CALL_BNUSIO_FALSE (bnusio_IsWideUsio)
BNUSIO_EXPORT (u64, bnusio_GetSwIn64) CALL_BNUSIO_FALSE (bnusio_GetSwIn64)
BNUSIO_EXPORT (u8, bnusio_GetGout, u8 a1) CALL_BNUSIO_FALSE (bnusio_GetGout, a1)
BNUSIO_EXPORT (i64, bnusio_SetGout, u8 a1, u8 a2) CALL_BNUSIO_FALSE (bnusio_SetGout, a1, a2)
BNUSIO_EXPORT (u64, bnusio_GetEncoder) CALL_BNUSIO_FALSE (bnusio_GetEncoder)
BNUSIO_EXPORT (i64, bnusio_GetCoinLock, u8 a1) CALL_BNUSIO_FALSE (bnusio_GetCoinLock, a1)
BNUSIO_EXPORT (i64, bnusio_SetCoinLock, u8 a1, u8 a2) CALL_BNUSIO_FALSE (bnusio_SetCoinLock, a1, a2)
BNUSIO_EXPORT (i64, bnusio_GetCDOut, u8 a1) CALL_BNUSIO_FALSE (bnusio_GetCDOut, a1)
BNUSIO_EXPORT (i64, bnusio_SetCDOut, u8 a1, u8 a2) CALL_BNUSIO_FALSE (bnusio_SetCDOut, a1, a2)
BNUSIO_EXPORT (i64, bnusio_GetHopOut, u8 a1) CALL_BNUSIO_FALSE (bnusio_GetHopOut, a1)
BNUSIO_EXPORT (i64, bnusio_SetHopOut, u8 a1, u8 a2) CALL_BNUSIO_FALSE (bnusio_SetHopOut, a1, a2)
BNUSIO_EXPORT (void *, bnusio_SetPLCounter, i16 a1) CALL_BNUSIO_FALSE (bnusio_SetPLCounter, a1)
BNUSIO_EXPORT (char *, bnusio_GetIoBoardName) CALL_BNUSIO_FALSE (bnusio_GetIoBoardName)
BNUSIO_EXPORT (i64, bnusio_SetHopperRequest, u16 a1, i16 a2) CALL_BNUSIO_FALSE (bnusio_SetHopperRequest, a1, a2)
BNUSIO_EXPORT (i64, bnusio_SetHopperLimit, u16 a1, i16 a2) CALL_BNUSIO_FALSE (bnusio_SetHopperLimit, a1, a2)
BNUSIO_EXPORT (i64, bnusio_SramRead, i32 a1, u8 a2, i32 a3, u16 a4) CALL_BNUSIO_FALSE (bnusio_SramRead, a1, a2, a3, a4)
BNUSIO_EXPORT (i64, bnusio_SramWrite, i32 a1, u8 a2, i32 a3, u16 a4) CALL_BNUSIO_FALSE (bnusio_SramWrite, a1, a2, a3, a4)
BNUSIO_EXPORT (void *, bnusio_GetCoinError, i32 a1) CALL_BNUSIO_FALSE (bnusio_GetCoinError, a1)
BNUSIO_EXPORT (void *, bnusio_GetServiceError, i32 a1) CALL_BNUSIO_FALSE (bnusio_GetServiceError, a1)
BNUSIO_EXPORT (i64, bnusio_DecCoin, i32 a1, u16 a2) CALL_BNUSIO_FALSE (bnusio_DecCoin, a1, a2)
BNUSIO_EXPORT (i64, bnusio_DecService, i32 a1, u16 a2) CALL_BNUSIO_FALSE (bnusio_DecService, a1, a2)
BNUSIO_EXPORT (i64, bnusio_ResetCoin) CALL_BNUSIO_FALSE (bnusio_ResetCoin)
BNUSIO_EXPORT (size_t, bnusio_GetFirmwareVersion) {
if (!emulateUsio && ori_bnusio_GetFirmwareVersion) return ori_bnusio_GetFirmwareVersion();
else return 126;
}
u32
bnusio_GetSwIn () {
BNUSIO_EXPORT (u32, bnusio_GetSwIn) {
if (!emulateUsio && ori_bnusio_GetSwIn) return ori_bnusio_GetSwIn ();
u32 sw = 0;
sw |= static_cast<u32> (testEnabled) << 7;
sw |= static_cast<u32> (IsButtonDown (DEBUG_ENTER)) << 9;
@@ -118,91 +123,41 @@ bnusio_GetSwIn () {
sw |= static_cast<u32> (IsButtonDown (SERVICE)) << 14;
return sw;
}
BNUSIO_EXPORT (u16, bnusio_GetAnalogIn, const u8 which) {
if (!emulateUsio && ori_bnusio_GetAnalogIn) return ori_bnusio_GetAnalogIn (which);
if (analogMethod) return analogMethod (which);
else return 0;
}
BNUSIO_EXPORT (u16, bnusio_GetCoin, i32 a1) {
if (updateByCoin && a1 == 1) bnusio::Update ();
if (!emulateUsio && ori_bnusio_GetCoin) return ori_bnusio_GetCoin (a1);
return coin_count;
}
BNUSIO_EXPORT (u16, bnusio_GetService, i32 a1) {
if (!emulateUsio && ori_bnusio_GetService) return ori_bnusio_GetService (a1);
return service_count;
}
}
bool waitAll = false;
short drumWaitPeriod = 0;
bool analogInput = false;
bool valueStates[] = {false, false, false, false, false, false, false, false};
Keybindings *analogButtons[]
= {&P1_LEFT_BLUE, &P1_LEFT_RED, &P1_RIGHT_RED, &P1_RIGHT_BLUE, &P2_LEFT_BLUE, &P2_LEFT_RED, &P2_RIGHT_RED, &P2_RIGHT_BLUE};
u8 cooldown[8] = { 0 };
u16 buttonWaitPeriod[] = { 0, 0 };
std::queue<u8> buttonQueue[] = { {}, {} };
SDLAxis analogBindings[] = {
SDL_AXIS_LEFT_LEFT, SDL_AXIS_LEFT_RIGHT, SDL_AXIS_LEFT_DOWN, SDL_AXIS_LEFT_UP, // P1: LB, LR, RR, RB
SDL_AXIS_RIGHT_LEFT, SDL_AXIS_RIGHT_RIGHT, SDL_AXIS_RIGHT_DOWN, SDL_AXIS_RIGHT_UP, // P2: LB, LR, RR, RB
};
u16
bnusio_GetAnalogIn (const u8 which) {
// LogMessage (LogLevel::DEBUG, "GetAnalogIn p={}", which);
if (analogMethod) return analogMethod (which);
else return 0;
}
u16 __fastcall bnusio_GetCoin (i32 a1) {
// LogMessage (LogLevel::DEBUG, "GetCoin p={}", a1);
if (updateByCoin && a1 == 1) bnusio::Update ();
return coin_count;
}
u16 __fastcall bnusio_GetService (i32 a1) { return service_count; }
}
FUNCTION_PTR (i64, bnusio_Open_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_Open"));
FUNCTION_PTR (i64, bnusio_Close_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_Close"));
FUNCTION_PTR (u64, bnusio_Communication_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_Communication"), i32);
FUNCTION_PTR (u8, bnusio_IsConnected_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_IsConnected"));
FUNCTION_PTR (i32, bnusio_ResetIoBoard_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_ResetIoBoard"));
FUNCTION_PTR (u16, bnusio_GetStatusU16_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetStatusU16"), u16);
FUNCTION_PTR (u8, bnusio_GetStatusU8_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetStatusU8"), u16);
FUNCTION_PTR (u16, bnusio_GetRegisterU16_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetRegisterU16"), i16);
FUNCTION_PTR (u8, bnusio_GetRegisterU8_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetRegisterU8"), i16);
FUNCTION_PTR (void *, bnusio_GetBuffer_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetBuffer"), u16, i64, i16);
FUNCTION_PTR (i64, bnusio_SetRegisterU16_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetRegisterU16"), u16, u16);
FUNCTION_PTR (i64, bnusio_SetRegisterU8_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetRegisterU8"), u16, u8);
FUNCTION_PTR (i64, bnusio_SetBuffer_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetBuffer"), u16, i32, i16);
FUNCTION_PTR (void *, bnusio_GetSystemError_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetSystemError"));
FUNCTION_PTR (i64, bnusio_SetSystemError_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetSystemError"), i16);
FUNCTION_PTR (size_t, bnusio_GetFirmwareVersion_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetFirmwareVersion"));
FUNCTION_PTR (i64, bnusio_ClearSram_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_ClearSram"));
FUNCTION_PTR (void *, bnusio_GetExpansionMode_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetExpansionMode"));
FUNCTION_PTR (i64, bnusio_SetExpansionMode_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetExpansionMode"), i16);
FUNCTION_PTR (u8, bnusio_IsWideUsio_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_IsWideUsio"));
FUNCTION_PTR (u32, bnusio_GetSwIn_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetSwIn"));
FUNCTION_PTR (u64, bnusio_GetSwIn64_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetSwIn64"));
FUNCTION_PTR (u16, bnusio_GetAnalogIn_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetAnalogIn"), u8);
FUNCTION_PTR (u8, bnusio_GetGout_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetGout"), u8);
FUNCTION_PTR (i64, bnusio_SetGout_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetGout"), u8, u8);
FUNCTION_PTR (u64, bnusio_GetEncoder_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetEncoder"));
FUNCTION_PTR (i64, bnusio_GetCoinLock_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetCoinLock"), u8);
FUNCTION_PTR (i64, bnusio_SetCoinLock_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetCoinLock"), u8, u8);
FUNCTION_PTR (i64, bnusio_GetCDOut_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetCDOut"), u8);
FUNCTION_PTR (i64, bnusio_SetCDOut_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetCDOut"), u8, u8);
FUNCTION_PTR (i64, bnusio_GetHopOut_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetHopOut"), u8);
FUNCTION_PTR (i64, bnusio_SetHopOut_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetHopOut"), u8, u8);
FUNCTION_PTR (void *, bnusio_SetPLCounter_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetPLCounter"), i16);
FUNCTION_PTR (char *, bnusio_GetIoBoardName_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetIoBoardName"));
FUNCTION_PTR (i64, bnusio_SetHopperRequest_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetHopperRequest"), u16, i16);
FUNCTION_PTR (i64, bnusio_SetHopperLimit_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetHopperLimit"), u16, i16);
FUNCTION_PTR (i64, bnusio_SramRead_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SramRead"), i32, u8, i32, u16);
FUNCTION_PTR (i64, bnusio_SramWrite_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SramWrite"), i32, u8, i32, u16);
FUNCTION_PTR (u16, bnusio_GetCoin_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetCoin"), i32);
FUNCTION_PTR (void *, bnusio_GetCoinError_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetCoinError"), i32);
FUNCTION_PTR (void *, bnusio_GetService_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetService"), i32);
FUNCTION_PTR (void *, bnusio_GetServiceError_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetServiceError"), i32);
FUNCTION_PTR (i64, bnusio_DecCoin_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_DecCoin"), i32, u16);
FUNCTION_PTR (u64, bnusio_DecService_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_DecService"), i32, u16);
FUNCTION_PTR (i64, bnusio_ResetCoin_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_ResetCoin"));
u16 __fastcall
AnalogInputAxis (const u8 which) {
u16 analogIn = (u16)(32768 * ControllerAxisIsDown (analogBindings[which])) + 1;
return analogIn > 100 ? analogIn : 0;
}
bool waitAll = false;
short drumWaitPeriod = 0;
u16 buttonWaitPeriod[] = { 0, 0 };
std::queue<u8> buttonQueue[] = { {}, {} };
bool valueStates[] = {false, false, false, false, false, false, false, false};
Keybindings *analogButtons[] = {
&P1_LEFT_BLUE, &P1_LEFT_RED, &P1_RIGHT_RED, &P1_RIGHT_BLUE, &P2_LEFT_BLUE, &P2_LEFT_RED, &P2_RIGHT_RED, &P2_RIGHT_BLUE
};
u16 __fastcall
AnalogInputWaitPeriod (const u8 which) {
const auto button = analogButtons[which];
@@ -233,6 +188,7 @@ AnalogInputWaitPeriod (const u8 which) {
return analogValue;
}
int cooldown[8] = { 0 };
u8 blueCooldown = 1, redCooldown = 1;
u16 __fastcall
AnalogInputCooldown (const u8 which) {
@@ -337,52 +293,7 @@ Init () {
LogMessage (LogLevel::ERROR, "bnusio_original.dll not found! usio emulation enabled");
}
if (!emulateUsio) {
INSTALL_HOOK_DIRECT (bnusio_Open, bnusio_Open_Original);
INSTALL_HOOK_DIRECT (bnusio_Close, bnusio_Close_Original);
INSTALL_HOOK_DIRECT (bnusio_Communication, bnusio_Communication_Original);
INSTALL_HOOK_DIRECT (bnusio_IsConnected, bnusio_IsConnected_Original);
INSTALL_HOOK_DIRECT (bnusio_ResetIoBoard, bnusio_ResetIoBoard_Original);
INSTALL_HOOK_DIRECT (bnusio_GetStatusU16, bnusio_GetStatusU16_Original);
INSTALL_HOOK_DIRECT (bnusio_GetStatusU8, bnusio_GetStatusU8_Original);
INSTALL_HOOK_DIRECT (bnusio_GetRegisterU16, bnusio_GetRegisterU16_Original);
INSTALL_HOOK_DIRECT (bnusio_GetRegisterU8, bnusio_GetRegisterU8_Original);
INSTALL_HOOK_DIRECT (bnusio_GetBuffer, bnusio_GetBuffer_Original);
INSTALL_HOOK_DIRECT (bnusio_SetRegisterU16, bnusio_SetRegisterU16_Original);
INSTALL_HOOK_DIRECT (bnusio_SetRegisterU8, bnusio_SetRegisterU8_Original);
INSTALL_HOOK_DIRECT (bnusio_SetBuffer, bnusio_SetBuffer_Original);
INSTALL_HOOK_DIRECT (bnusio_GetSystemError, bnusio_GetSystemError_Original);
INSTALL_HOOK_DIRECT (bnusio_SetSystemError, bnusio_SetSystemError_Original);
INSTALL_HOOK_DIRECT (bnusio_GetFirmwareVersion, bnusio_GetFirmwareVersion_Original);
INSTALL_HOOK_DIRECT (bnusio_ClearSram, bnusio_ClearSram_Original);
INSTALL_HOOK_DIRECT (bnusio_GetExpansionMode, bnusio_GetExpansionMode_Original);
INSTALL_HOOK_DIRECT (bnusio_SetExpansionMode, bnusio_SetExpansionMode_Original);
INSTALL_HOOK_DIRECT (bnusio_IsWideUsio, bnusio_IsWideUsio_Original);
INSTALL_HOOK_DIRECT (bnusio_GetSwIn, bnusio_GetSwIn_Original);
INSTALL_HOOK_DIRECT (bnusio_GetSwIn64, bnusio_GetSwIn64_Original);
INSTALL_HOOK_DIRECT (bnusio_GetAnalogIn, bnusio_GetAnalogIn_Original);
INSTALL_HOOK_DIRECT (bnusio_GetGout, bnusio_GetGout_Original);
INSTALL_HOOK_DIRECT (bnusio_SetGout, bnusio_SetGout_Original);
INSTALL_HOOK_DIRECT (bnusio_GetEncoder, bnusio_GetEncoder_Original);
INSTALL_HOOK_DIRECT (bnusio_GetCoinLock, bnusio_GetCoinLock_Original);
INSTALL_HOOK_DIRECT (bnusio_SetCoinLock, bnusio_SetCoinLock_Original);
INSTALL_HOOK_DIRECT (bnusio_GetCDOut, bnusio_GetCDOut_Original);
INSTALL_HOOK_DIRECT (bnusio_SetCDOut, bnusio_SetCDOut_Original);
INSTALL_HOOK_DIRECT (bnusio_GetHopOut, bnusio_GetHopOut_Original);
INSTALL_HOOK_DIRECT (bnusio_SetHopOut, bnusio_SetHopOut_Original);
INSTALL_HOOK_DIRECT (bnusio_SetPLCounter, bnusio_SetPLCounter_Original);
INSTALL_HOOK_DIRECT (bnusio_GetIoBoardName, bnusio_GetIoBoardName_Original);
INSTALL_HOOK_DIRECT (bnusio_SetHopperRequest, bnusio_SetHopperRequest_Original);
INSTALL_HOOK_DIRECT (bnusio_SetHopperLimit, bnusio_SetHopperLimit_Original);
INSTALL_HOOK_DIRECT (bnusio_SramRead, bnusio_SramRead_Original);
INSTALL_HOOK_DIRECT (bnusio_SramWrite, bnusio_SramWrite_Original);
INSTALL_HOOK_DIRECT (bnusio_GetCoin, bnusio_GetCoin_Original);
INSTALL_HOOK_DIRECT (bnusio_GetCoinError, bnusio_GetCoinError_Original);
INSTALL_HOOK_DIRECT (bnusio_GetService, bnusio_GetService_Original);
INSTALL_HOOK_DIRECT (bnusio_GetServiceError, bnusio_GetServiceError_Original);
INSTALL_HOOK_DIRECT (bnusio_DecCoin, bnusio_DecCoin_Original);
INSTALL_HOOK_DIRECT (bnusio_DecService, bnusio_DecService_Original);
INSTALL_HOOK_DIRECT (bnusio_ResetCoin, bnusio_ResetCoin_Original);
if (!emulateUsio && bnusioOriginal) {
LogMessage (LogLevel::WARN, "USIO emulation disabled");
}
}
src/dllmain.cpp
+2 -4
View File
@@ -155,10 +155,6 @@ DllMain (HMODULE module, const DWORD reason, LPVOID reserved) {
InitializeLogger (GetLogLevel (logLevelStr), logToFile);
patches::Timer::Init ();
// #ifdef ASYNC_IO
// InitializeKeyboard ();
// #endif
LogMessage (LogLevel::INFO, "Loading config...");
std::string version = "auto";
@@ -239,6 +235,8 @@ DllMain (HMODULE module, const DWORD reason, LPVOID reserved) {
} else {
xRes = cxLogical;
yRes = cyLogical;
if (yRes * 16 > xRes * 9) yRes = (int)(xRes * 9.0 / 16.0);
else if (yRes * 16 < xRes * 9) xRes = (int)(yRes * 16.0 / 9.0);
}
LogMessage (LogLevel::INFO, "Scale Rate: x={} y={}", horizontalScale, verticalScale);
src/helpers.h
-44
View File
@@ -128,50 +128,6 @@ const HMODULE MODULE_HANDLE = GetModuleHandle (nullptr);
original##functionName = safetyhook::create_inline ((void *)location, (void*)implOf##functionName); \
}
inline bool sendFlag = false;
#define SCENE_RESULT_HOOK(functionName, location) \
FAST_HOOK (void, functionName, location, i64 a1, i64 a2, i64 a3) { \
if (TestMode::ReadTestModeValue (L"ModInstantResult") != 1 && TestMode::ReadTestModeValue (L"NumberOfStageItem") <= 4) { \
original##functionName.fastcall (a1, a2, a3); \
return; \
} \
sendFlag = true; \
original##functionName.fastcall (a1, a2, a3); \
ExecuteSendResultData (); \
}
#define SEND_RESULT_HOOK(functionName, location) \
FAST_HOOK (void, functionName, location, i64 a1) { \
if (TestMode::ReadTestModeValue (L"ModInstantResult") != 1 && TestMode::ReadTestModeValue (L"NumberOfStageItem") <= 4) { \
original##functionName.fastcall (a1); \
return; \
} \
if (sendFlag) { \
sendFlag = false; \
original##functionName.fastcall (a1); \
} \
}
#define CHANGE_RESULT_SIZE_HOOK(functionName, location, target) \
MID_HOOK (functionName, location, SafetyHookContext &ctx) { \
if (TestMode::ReadTestModeValue (L"ModInstantResult") != 1 && TestMode::ReadTestModeValue (L"NumberOfStageItem") <= 4) { return; } \
i64 instance = RefPlayDataManager (*(i64 *)ctx.r12); \
u32 currentStageCount = *(u32 *)(instance + 8); \
ctx.target &= 0xFFFFFFFF00000000; \
ctx.target |= currentStageCount; \
}
#define CHANGE_RESULT_INDEX_HOOK(functionName, location, target, offset, skip) \
MID_HOOK (functionName, location, SafetyHookContext &ctx) { \
if (TestMode::ReadTestModeValue (L"ModInstantResult") != 1 && TestMode::ReadTestModeValue (L"NumberOfStageItem") <= 4) { return; } \
i64 instance = RefPlayDataManager (*(i64 *)ctx.r12); \
u32 currentStageCount = *(u32 *)(instance + 8); \
ctx.target &= 0xFFFFFFFF00000000; \
ctx.target |= currentStageCount - 1; \
*(u32 *)(ctx.rsp + offset) = currentStageCount - 1; \
ctx.rip += skip; \
}
#define READ_MEMORY(location, type) *(type *)location
#define WRITE_MEMORY(location, type, ...) \
src/patches/language.cpp
+16 -19
View File
@@ -9,6 +9,7 @@ namespace patches::Language {
const std::vector<std::string> languages = { "jpn", "en_us", "cn_tw", "kor", "cn_cn" };
std::vector<SafetyHookMid> language_patch = { };
boolean cnFontPatches = false;
// TestMode::Value *languageItem = TestMode::CreateValue (L"LanguageItem");
int language = 0;
FUNCTION_PTR (void, lua_settop, PROC_ADDRESS ("lua51.dll", "lua_settop"), i64, i32);
@@ -359,22 +360,12 @@ MID_HOOK_DYNAMIC (ChangeOnpFile, SafetyHookContext &ctx) {
ctx.rdx = (uintptr_t) onpCn.c_str ();
ctx.r8 = 0x1F;
}
void *
GetLanguageType (Taiko_assign assign, int language, void *buf) {
int langFix = languageFix (language);
return assign (buf, languageStr (langFix), (langFix == 0 || langFix == 3) ? 3 : 5);
}
void
InjectLanguageType (uintptr_t language, uintptr_t &reg) {
int langFix = languageFix ((int)language);
reg = (uintptr_t)languageStr (langFix);
}
FAST_HOOK_DYNAMIC (u64, GraphicBaseGetLanguageType, u64 a1, void *a2) {
int language = *(int *)(a1 + 56);
return (u64)GetLanguageType (taiko_assign, language, a2);
}
bool titleExistSeason = true, titleExistMaid = true, titleExistMaidCn = true;
std::string seasonNulm = "title_season.nulm", seasonNutexb = "title_" + season () + ".nutexb";
std::string maidNulmCn = "title_maid.nulm", maidNutexbCn = "title_maid.nutexb";
@@ -408,19 +399,18 @@ Init () {
ctx.rip = ASLR (0x140134E29);
}));
INSTALL_FAST_HOOK_DYNAMIC (GraphicBaseGetLanguageType, ASLR (0x1400E8740));
language_patch.push_back (safetyhook::create_mid (ASLR (0x1400E8791), [](SafetyHookContext &ctx)
{ InjectLanguageType (ctx.rsp + 0x58 + ctx.rax * 8, ctx.rdx); ctx.rip = ASLR (0x1400E8796); })); // HitEffectGetLanguageType
{ InjectLanguageType (ctx.rax, ctx.rdx); ctx.rip = ASLR (0x1400E8796); })); // HitEffectGetLanguageType
language_patch.push_back (safetyhook::create_mid (ASLR (0x14011F8E4), [](SafetyHookContext &ctx)
{ InjectLanguageType (ctx.rbp + 0x57 + ctx.rax * 8, ctx.rdx); ctx.rip = ASLR (0x14011F8E9); })); // KusudamaGetLanguageType
{ InjectLanguageType (ctx.rax, ctx.rdx); ctx.rip = ASLR (0x14011F8E9); })); // KusudamaGetLanguageType
language_patch.push_back (safetyhook::create_mid (ASLR (0x140122404), [](SafetyHookContext &ctx)
{ InjectLanguageType (ctx.rbp + 0x140 + ctx.rax * 8, ctx.rdx); ctx.rip = ASLR (0x14012240C); })); // NoteJumpGetLanguageType
{ InjectLanguageType (ctx.rax, ctx.rdx); ctx.rip = ASLR (0x14012240C); })); // NoteJumpGetLanguageType
language_patch.push_back (safetyhook::create_mid (ASLR (0x14012425E), [](SafetyHookContext &ctx)
{ InjectLanguageType (ctx.rbp + 0x57 + ctx.rax * 8, ctx.rdx); ctx.rip = ASLR (0x140124263); })); // RendaEffectGetLanguageType
{ InjectLanguageType (ctx.rax, ctx.rdx); ctx.rip = ASLR (0x140124263); })); // RendaEffectGetLanguageType
language_patch.push_back (safetyhook::create_mid (ASLR (0x140129450), [](SafetyHookContext &ctx)
{ InjectLanguageType (ctx.rbp + 0x57 + ctx.rax * 8, ctx.rdx); ctx.rip = ASLR (0x140129455); })); // RendaEffectGetLanguageType
{ InjectLanguageType (ctx.rax, ctx.rdx); ctx.rip = ASLR (0x140129455); })); // RendaEffectGetLanguageType
language_patch.push_back (safetyhook::create_mid (ASLR (0x14012B8C8), [](SafetyHookContext &ctx)
{ InjectLanguageType (ctx.rbp + 0x180 + ctx.rax * 8, ctx.rdx); ctx.rip = ASLR (0x14012B8D0); })); // ScoreGetLanguageType
{ InjectLanguageType (ctx.rax, ctx.rdx); ctx.rip = ASLR (0x14012B8D0); })); // ScoreGetLanguageType
LayeredFs::RegisterBefore ([&] (const std::string &originalFileName, const std::string &currentFileName) -> std::string {
if (language != 4 || currentFileName.starts_with ("F:\\lumen\\") || currentFileName.find ("\\lumen\\") == std::string::npos) return "";
std::string fileName = std::string (currentFileName);
@@ -454,11 +444,11 @@ Init () {
[&](){
LayeredFs::RegisterBefore ([&] (const std::string &originalFileName, const std::string &currentFileName) -> std::string {
if (currentFileName.starts_with ("F:\\lumen\\") || currentFileName.find ("title") == std::string::npos) return "";
if (currentFileName.ends_with ("title.nulm")) {
if (currentFileName.ends_with ("\\title.nulm")) {
if (language == 4 && titleScreen->Read () == 1 && titleExistSeason) return seasonNulm;
if (language == 4 && titleScreen->Read () == 2 && titleExistMaidCn) return maidNulmCn;
if (titleScreen->Read () == 2 && titleExistMaid) return maidNulm;
} else if (currentFileName.ends_with ("title.nutexb")) {
} else if (currentFileName.ends_with ("\\title.nutexb")) {
LogMessage (LogLevel::DEBUG, "nutexb");
if (language == 4 && titleScreen->Read () == 1 && titleExistSeason) return seasonNutexb;
if (language == 4 && titleScreen->Read () == 2 && titleExistMaidCn) return maidNutexbCn;
@@ -466,6 +456,13 @@ Init () {
}
return "";
});
LayeredFs::RegisterBefore ([&] (const std::string &originalFileName, const std::string &currentFileName) -> std::string {
if (titleScreen->Read () != 2 || currentFileName.starts_with ("F:\\lumen\\") || currentFileName.find ("\\lumen\\") == std::string::npos) return "";
std::string fileName = std::string (currentFileName);
fileName = replace (fileName, "\\lumen\\", "\\lumen_maid\\");
if (std::filesystem::exists (fileName)) return fileName;
return "";
});
});
}
} break;
src/patches/patches.h
+1 -1
View File
@@ -52,7 +52,7 @@ public:
};
class Value {
public:
virtual int Read() = 0;
virtual int Read(int value = -1) = 0;
virtual void Write(int value) = 0;
virtual void Reset() = 0;
};
src/patches/testmode.cpp
+15 -7
View File
@@ -18,6 +18,7 @@ std::mutex hooksMutex;
std::condition_variable hooksCV;
std::vector<SafetyHookMid> patches = {};
std::vector<Value *> values = {};
std::map<std::wstring, Value *> valueMap = {};
std::wstring
mergeCondition (std::wstring original, std::wstring addition, std::wstring value) {
@@ -214,7 +215,7 @@ public:
this->reset = true;
}
int
Read () override {
Read (int value) override {
if (reset) {
this->value = ReadTestModeValue (key.c_str ());
if (this->value != -1) {
@@ -222,7 +223,8 @@ public:
reset = false;
}
}
return this->value;
if (this->value == -1) return value;
else return this->value;
}
void
Write (int value) override {
@@ -521,11 +523,15 @@ SetupAccessor (const u64 appAccessor, const RefTestModeMain refTestMode) {
int
ReadTestModeValue (const wchar_t *itemId) {
if (appAccessor) {
if (const u64 testModeMain = refTestMode (appAccessor)) {
int value = 0;
u64 *reader = *reinterpret_cast<u64 **> (testModeMain + 16);
(*reinterpret_cast<void (__fastcall **) (u64 *, const wchar_t *, int *)> (*reader + 256)) (reader, itemId, &value);
return value;
try {
if (const u64 testModeMain = refTestMode (appAccessor)) {
int value = 0;
u64 *reader = *reinterpret_cast<u64 **> (testModeMain + 16);
(*reinterpret_cast<void (__fastcall **) (u64 *, const wchar_t *, int *)> (*reader + 256)) (reader, itemId, &value);
return value;
}
} catch ([[maybe_unused]] std::exception &e) {
LogMessage (LogLevel::ERROR, L"Reading Value({}) Error!", itemId);
}
}
return -1;
@@ -550,8 +556,10 @@ CreateMenu (const std::wstring &menuName, const std::wstring &menuId) {
Value *
CreateValue (const std::wstring &key) {
LogMessage (LogLevel::DEBUG, L"Create TestMode Value key: {}", key);
// if (valueMap.count (key)) return valueMap[key];
Value *value = (Value *)(new TestModeValue (key));
values.push_back ((Value *)value);
// valueMap[key] = value;
return value;
}
src/patches/versions/JPN39.cpp
+55 -2
View File
@@ -43,7 +43,7 @@ FUNCTION_PTR (i32, luaL_loadstring, PROC_ADDRESS ("lua51.dll", "luaL_loadstring"
FUNCTION_PTR (u64, RefTestModeMain, ASLR (0x1400337C0), u64);
FUNCTION_PTR (u64, RefPlayDataManager, ASLR (0x140024AC0), u64);
FUNCTION_PTR (i64, GetUserCount, ASLR (0x1403F1020), u64);
FUNCTION_PTR (i64, GetUserCount, ASLR (0x1403F1080), u64);
i64
lua_pushbool (const i64 a1, const bool val) {
@@ -62,6 +62,11 @@ FAST_HOOK (i64, DeviceCheck, ASLR (0x140464FC0), i64 a1, i64 a2, i64 a3) {
return originalDeviceCheck.fastcall<i64> (a1, a2, a3);
}
FAST_HOOK (void, SetupCoinUser, ASLR (0x1403F0CA0), void *a1, void *a2, int a3) {
LogMessage (LogLevel::ERROR, "SetupCoinUser side={}", a3);
originalSetupCoinUser.fastcall<void> (a1, a2, a3);
}
i64
GetPlayererCount () {
if (appAccessor) {
@@ -200,6 +205,52 @@ ExecuteSendResultData () {
);
}
bool sendFlag = false;
TestMode::Value *instantResult = TestMode::CreateValue (L"ModInstantResult");
TestMode::Value *stageNumber = TestMode::CreateValue (L"NumberOfStageItem");
#define SCENE_RESULT_HOOK(functionName, location) \
FAST_HOOK (void, functionName, location, i64 a1, i64 a2, i64 a3) { \
if (instantResult->Read () != 1 && stageNumber->Read () <= 4) { \
original##functionName.fastcall (a1, a2, a3); \
return; \
} \
sendFlag = true; \
original##functionName.fastcall (a1, a2, a3); \
ExecuteSendResultData (); \
}
#define SEND_RESULT_HOOK(functionName, location) \
FAST_HOOK (void, functionName, location, i64 a1) { \
if (instantResult->Read () != 1 && stageNumber->Read () <= 4) { \
original##functionName.fastcall (a1); \
return; \
} \
if (sendFlag) { \
sendFlag = false; \
original##functionName.fastcall (a1); \
} \
}
#define CHANGE_RESULT_SIZE_HOOK(functionName, location, target) \
MID_HOOK (functionName, location, SafetyHookContext &ctx) { \
if (instantResult->Read () != 1 && stageNumber->Read () <= 4) { return; } \
i64 instance = RefPlayDataManager (*(i64 *)ctx.r12); \
u32 currentStageCount = *(u32 *)(instance + 8); \
ctx.target &= 0xFFFFFFFF00000000; \
ctx.target |= currentStageCount; \
}
#define CHANGE_RESULT_INDEX_HOOK(functionName, location, target, offset, skip) \
MID_HOOK (functionName, location, SafetyHookContext &ctx) { \
if (instantResult->Read () != 1 && stageNumber->Read () <= 4) { return; } \
i64 instance = RefPlayDataManager (*(i64 *)ctx.r12); \
u32 currentStageCount = *(u32 *)(instance + 8); \
ctx.target &= 0xFFFFFFFF00000000; \
ctx.target |= currentStageCount - 1; \
*(u32 *)(ctx.rsp + offset) = currentStageCount - 1; \
ctx.rip += skip; \
}
SCENE_RESULT_HOOK (SceneResultInitialize_Enso, ASLR (0x140411FD0));
SCENE_RESULT_HOOK (SceneResultInitialize_AI, ASLR (0x140411FD0));
SCENE_RESULT_HOOK (SceneResultInitialize_Collabo025, ASLR (0x140411FD0));
@@ -300,7 +351,9 @@ Init () {
INSTALL_FAST_HOOK (luaL_newstate);
// INSTALL_HOOK (AcquireMostCompatibleDisplayMode);
// Apply common config patch
INSTALL_FAST_HOOK (SetupCoinUser);
// Apply graphic patch
WRITE_MEMORY (ASLR (0x140494533), i32, xRes);
WRITE_MEMORY (ASLR (0x14049453A), i32, yRes);
if (!vsync) WRITE_MEMORY (ASLR (0x14064C7E9), u8, 0xBA, 0x00, 0x00, 0x00, 0x00, 0x90);
src/pollasync.cpp
+5 -1
View File
@@ -12,6 +12,7 @@ extern float axisThreshold;
extern bool globalKeyboardInput;
extern bool autoIme;
extern HKL currentLayout;
extern bool emulateUsio;
bool wndForeground = false;
bool usingKeyboard = false;
@@ -198,6 +199,9 @@ CheckFlipped (uint32_t which, SDL_Gamepad *gamepad) {
bool
InitializePoll (HWND windowHandle) {
wndForeground = windowHandle == GetForegroundWindow ();
if (!emulateUsio) return false;
usingKeyboard = inputState & 1;
usingMouse = inputState & (1 << 1);
usingController = inputState & (1 << 2);
@@ -208,7 +212,6 @@ InitializePoll (HWND windowHandle) {
if (usingSDLEvent) {
LogMessage (LogLevel::DEBUG, "InitializePoll");
bool hasRumble = true;
wndForeground = windowHandle == GetForegroundWindow ();
SDL_SetMainReady ();
SDL_SetHint (SDL_HINT_JOYSTICK_HIDAPI_PS4, "1");
@@ -324,6 +327,7 @@ CleanPoll () {
void
UpdatePoll (HWND windowHandle) {
if (!CheckForegroundWindow (windowHandle)) return;
if (!emulateUsio) return;
CleanPoll ();
if (usingSDLEvent) {
SDL_Event event;