diff --git a/config/SOME01/splits.txt b/config/SOME01/splits.txt index 5cc798b..6f672e2 100644 --- a/config/SOME01/splits.txt +++ b/config/SOME01/splits.txt @@ -3112,6 +3112,10 @@ GameUtil/List.cpp: GameUtil/CheckPointManager.cpp: .text start:0x801EAC38 end:0x801EC2B4 + .rodata start:0x802E50C0 end:0x802E5160 + .data start:0x8031EA58 end:0x8031EA90 + .sdata start:0x803200B8 end:0x803200D0 + .sdata2 start:0x803297A0 end:0x803297B8 GameUtil/SDManager.cpp: .text start:0x801EC2B4 end:0x801EC3B0 diff --git a/config/SOME01/symbols.txt b/config/SOME01/symbols.txt index 8c93f21..d6c8062 100644 --- a/config/SOME01/symbols.txt +++ b/config/SOME01/symbols.txt @@ -8183,37 +8183,37 @@ insertAfter__5CListFP5CList = .text:0x801EAB2C; // type:function size:0x48 removeCurrent__5CListFv = .text:0x801EAB74; // type:function size:0x44 removeAll__5CListFv = .text:0x801EABB8; // type:function size:0x80 __ct__18CCheckPointManagerFv = .text:0x801EAC38; // type:function size:0x10 -fn_801EAC48 = .text:0x801EAC48; // type:function size:0x68 -fn_801EACB0 = .text:0x801EACB0; // type:function size:0x4 -fn_801EACB4 = .text:0x801EACB4; // type:function size:0x90 -fn_801EAD44 = .text:0x801EAD44; // type:function size:0x4 -fn_801EAD48 = .text:0x801EAD48; // type:function size:0x4 -fn_801EAD4C = .text:0x801EAD4C; // type:function size:0xD4 +__dt__32TSingleton<18CCheckPointManager>Fv = .text:0x801EAC48; // type:function size:0x68 +_08__32TSingleton<18CCheckPointManager>Fv = .text:0x801EACB0; // type:function size:0x4 +__dt__18CCheckPointManagerFv = .text:0x801EACB4; // type:function size:0x90 +_10__18CCheckPointManagerFv = .text:0x801EAD44; // type:function size:0x4 +_08__18CCheckPointManagerFv = .text:0x801EAD48; // type:function size:0x4 +_14__18CCheckPointManagerFv = .text:0x801EAD4C; // type:function size:0xD4 fn_801EAE20__18CCheckPointManagerFv = .text:0x801EAE20; // type:function size:0x4C -fn_801EAE6C = .text:0x801EAE6C; // type:function size:0x38 -fn_801EAEA4 = .text:0x801EAEA4; // type:function size:0x88 -fn_801EAF2C__18CCheckPointManagerFUcUl = .text:0x801EAF2C; // type:function size:0xE0 -fn_801EB00C__18CCheckPointManagerFUcUl = .text:0x801EB00C; // type:function size:0x100 -fn_801EB10C = .text:0x801EB10C; // type:function size:0x10 -fn_801EB11C = .text:0x801EB11C; // type:function size:0x14 -fn_801EB130 = .text:0x801EB130; // type:function size:0x678 -fn_801EB7A8 = .text:0x801EB7A8; // type:function size:0x8 -fn_801EB7B0 = .text:0x801EB7B0; // type:function size:0x20 -fn_801EB7D0 = .text:0x801EB7D0; // type:function size:0x10 -fn_801EB7E0 = .text:0x801EB7E0; // type:function size:0x18 -fn_801EB7F8 = .text:0x801EB7F8; // type:function size:0x8 -fn_801EB800 = .text:0x801EB800; // type:function size:0x8 -fn_801EB808 = .text:0x801EB808; // type:function size:0xF4 -fn_801EB8FC = .text:0x801EB8FC; // type:function size:0xF4 -fn_801EB9F0 = .text:0x801EB9F0; // type:function size:0xF4 -fn_801EBAE4 = .text:0x801EBAE4; // type:function size:0xF4 -fn_801EBBD8 = .text:0x801EBBD8; // type:function size:0x228 -fn_801EBE00 = .text:0x801EBE00; // type:function size:0x228 -fn_801EC028 = .text:0x801EC028; // type:function size:0x228 -fn_801EC250 = .text:0x801EC250; // type:function size:0x10 -fn_801EC260 = .text:0x801EC260; // type:function size:0x8 -fn_801EC268 = .text:0x801EC268; // type:function size:0x8 -fn_801EC270 = .text:0x801EC270; // type:function size:0x44 +fn_801EAE6C__18CCheckPointManagerFP15GradingCriteria = .text:0x801EAE6C; // type:function size:0x38 +fn_801EAEA4__18CCheckPointManagerFv = .text:0x801EAEA4; // type:function size:0x88 +fn_801EAF2C__18CCheckPointManagerFUc15ECheckInputType = .text:0x801EAF2C; // type:function size:0xE0 +fn_801EB00C__18CCheckPointManagerFUc15ECheckInputType = .text:0x801EB00C; // type:function size:0x100 +fn_801EB10C__18CCheckPointManagerFf = .text:0x801EB10C; // type:function size:0x10 +fn_801EB11C__18CCheckPointManagerFv = .text:0x801EB11C; // type:function size:0x14 +fn_801EB130__18CCheckPointManagerFv = .text:0x801EB130; // type:function size:0x678 +fn_801EB7A8__18CCheckPointManagerFv = .text:0x801EB7A8; // type:function size:0x8 +fn_801EB7B0__18CCheckPointManagerFv = .text:0x801EB7B0; // type:function size:0x20 +fn_801EB7D0__18CCheckPointManagerFl = .text:0x801EB7D0; // type:function size:0x10 +fn_801EB7E0__18CCheckPointManagerFv = .text:0x801EB7E0; // type:function size:0x18 +fn_801EB7F8__18CCheckPointManagerFv = .text:0x801EB7F8; // type:function size:0x8 +fn_801EB800__18CCheckPointManagerFv = .text:0x801EB800; // type:function size:0x8 +fn_801EB808__18CCheckPointManagerFl = .text:0x801EB808; // type:function size:0xF4 +fn_801EB8FC__18CCheckPointManagerFl = .text:0x801EB8FC; // type:function size:0xF4 +fn_801EB9F0__18CCheckPointManagerFl = .text:0x801EB9F0; // type:function size:0xF4 +fn_801EBAE4__18CCheckPointManagerFl = .text:0x801EBAE4; // type:function size:0xF4 +fn_801EBBD8__18CCheckPointManagerFl = .text:0x801EBBD8; // type:function size:0x228 +fn_801EBE00__18CCheckPointManagerFl = .text:0x801EBE00; // type:function size:0x228 +fn_801EC028__18CCheckPointManagerFl = .text:0x801EC028; // type:function size:0x228 +fn_801EC250__18CCheckPointManagerFlPw = .text:0x801EC250; // type:function size:0x10 +fn_801EC260__18CCheckPointManagerFPw = .text:0x801EC260; // type:function size:0x8 +fn_801EC268__18CCheckPointManagerFPw = .text:0x801EC268; // type:function size:0x8 +fn_801EC270__18CCheckPointManagerFw = .text:0x801EC270; // type:function size:0x44 __ct__10CSDManagerFv = .text:0x801EC2B4; // type:function size:0x10 __dt__24TSingleton<10CSDManager>Fv = .text:0x801EC2C4; // type:function size:0x68 _08__24TSingleton<10CSDManager>Fv = .text:0x801EC32C; // type:function size:0x4 @@ -14448,9 +14448,9 @@ lbl_8031EA00 = .data:0x8031EA00; // type:object size:0x18 lbl_8031EA18 = .data:0x8031EA18; // type:object size:0x18 lbl_8031EA30 = .data:0x8031EA30; // type:object size:0x10 __vt__5CList = .data:0x8031EA40; // type:object size:0x14 -lbl_8031EA58 = .data:0x8031EA58; // type:object size:0x18 +__vt__18CCheckPointManager = .data:0x8031EA58; // type:object size:0x18 lbl_8031EA70 = .data:0x8031EA70; // type:object size:0x10 -lbl_8031EA80 = .data:0x8031EA80; // type:object size:0x10 +__vt__32TSingleton<18CCheckPointManager> = .data:0x8031EA80; // type:object size:0x10 __vt__10CSDManager = .data:0x8031EA90; // type:object size:0x18 lbl_8031EAA8 = .data:0x8031EAA8; // type:object size:0xC scope:local __vt__24TSingleton<10CSDManager> = .data:0x8031EAB8; // type:object size:0x10 @@ -15157,8 +15157,8 @@ lbl_803200A0 = .sdata:0x803200A0; // type:object size:0x8 lbl_803200A8 = .sdata:0x803200A8; // type:object size:0x8 lbl_803200B0 = .sdata:0x803200B0; // type:object size:0x8 lbl_803200B8 = .sdata:0x803200B8; // type:object size:0x8 data:4byte -lbl_803200C0 = .sdata:0x803200C0; // type:object size:0x8 -lbl_803200C8 = .sdata:0x803200C8; // type:object size:0x8 +__RTTI__18CCheckPointManager = .sdata:0x803200C0; // type:object size:0x8 +__RTTI__32TSingleton<18CCheckPointManager> = .sdata:0x803200C8; // type:object size:0x8 __RTTI__10CSDManager = .sdata:0x803200D0; // type:object size:0x8 __RTTI__24TSingleton<10CSDManager> = .sdata:0x803200D8; // type:object size:0x8 __RTTI__11CDebugPrint = .sdata:0x803200E0; // type:object size:0x8 diff --git a/src/GameUtil/CheckPointManager.cpp b/src/GameUtil/CheckPointManager.cpp new file mode 100644 index 0000000..b8e9ee4 --- /dev/null +++ b/src/GameUtil/CheckPointManager.cpp @@ -0,0 +1,375 @@ +#include "CheckPointManager.hpp" + +#include +#include + +#include "TickFlowManager.hpp" +#include "InputCheckManager.hpp" + +CCheckPointManager::CCheckPointManager(void) { + +} + +CCheckPointManager::~CCheckPointManager(void) { + _08(); +} + +void CCheckPointManager::_10(void) { + +} + +void CCheckPointManager::_08(void) { + +} + +// not matching (instruction reordering at start) +void CCheckPointManager::_14(void) { + static wchar_t *empty = L""; + + unkC4 = 0; + fn_801EAEA4(); + unkC5 = 0; + unkCC = 0; + unkD0 = 0; + fn_801EB11C(); + unkDD = 0; + + for (s32 i = 0; i < ARRAY_LENGTH(unk2E8); i++) { + fn_801EC250(i, empty); + } + fn_801EC268(empty); +} + +void CCheckPointManager::fn_801EAE20(void) { + if (unkD8 > 0.0f) { + unkD8 -= gTickFlowManager->fn_801E2698(); + } +} + +void CCheckPointManager::fn_801EAE6C(GradingCriteria *criteria) { + unkC4 = 0; + while (!(criteria->flags & GRADE_CRITERIA_FLAG_END)) { + unkA4[unkC4++] = criteria++; + } +} + +void CCheckPointManager::fn_801EAEA4(void) { + for (s32 i = 0; i < ARRAY_LENGTH(unk04); i++) { + unk04[i].reset(); + } +} + +void CCheckPointManager::fn_801EAF2C(u8 arg0, ECheckInputType type) { + if (!unkDD) { + return; + } + + if (type == eCheckInputType_Through) { + if ((unkD8 > 0.0f) && (unkDC == arg0)) { + return; + } + unkD8 = unkD4; + unkDC = arg0; + } else { + unkD8 = 0.0f; + } + + if (type == eCheckInputType_Through) { + if ((unkCC > 0) && (!(unkA4[arg0]->flags & GRADE_CRITERIA_FLAG_UNK1))) { + unkCC--; + return; + } + } + + unk04[arg0].unk0++; + switch (type) { + case eCheckInputType_Hit: + unk04[arg0].unk2++; + break; + case eCheckInputType_Miss: + unk04[arg0].unk4++; + break; + case eCheckInputType_Through: + unk04[arg0].unk6++; + break; + } +} + +void CCheckPointManager::fn_801EB00C(u8 arg0, ECheckInputType type) { + if (!unkDD) { + return; + } + + gInputCheckManager->fn_801E9488(0); + switch (type) { + case eCheckInputType_Hit: + unk04[arg0].unk2--; + unk04[arg0].unk0--; + break; + case eCheckInputType_Miss: + unk04[arg0].unk4--; + unk04[arg0].unk0--; + break; + } + + if ((unkCC > 0) && (!(unkA4[arg0]->flags & GRADE_CRITERIA_FLAG_UNK1))) { + unkCC--; + } else { + unk04[arg0].unk6++; + unk04[arg0].unk0++; + } +} + +void CCheckPointManager::fn_801EB10C(f32 arg0) { + unkD4 = arg0; + unkD8 = 0.0f; +} + +void CCheckPointManager::fn_801EB11C(void) { + fn_801EB10C(60.0f); +} + +// not matching (regswaps) +void CCheckPointManager::fn_801EB130(void) { + unkC8 = 0; + unkDE = 0; + + for (s32 i = 0; i < ARRAY_LENGTH(unk04); i++) { + if (unk04[i].unk0) { + unk04[i].unk8 = (unk04[i].unk2 * 100) / unk04[i].unk0; + unk04[i].unkC = (unk04[i].unk4 * 100) / unk04[i].unk0; + unk04[i].unk10 = (unk04[i].unk6 * 100) / unk04[i].unk0; + } + } + + for (s32 i = 0; i < unkC4; i++) { + if (!unk04[i].unk0) { + continue; + } + + bool check = (!doUnkCheck(unkA4[i]->unk0C, unk04[i].unk6, unk04[i].unk10)) || + (doUnkCheck(unkA4[i]->unk0A, unk04[i].unk2, unk04[i].unk8)); + if (!check) { + continue; + } + + if (unkA4[i]->flags & GRADE_CRITERIA_FLAG_UNK0) { + unkC8 = 1; + memset(unkE0[0], 0, sizeof(unkE0[0]) - 2); + wcscat(unkE0[0], reinterpret_cast(unkA4[i]->mesgNegative)); + break; + } + + if (unkC8 < 3) { + memset(unkE0[unkC8], 0, sizeof(unkE0[unkC8]) - 2); + wcscat(unkE0[unkC8], unk2E8[unkC8]); + wcscat(unkE0[unkC8], reinterpret_cast(unkA4[i]->mesgNegative)); + + if (unkC8 > 0) { + s32 chari = wcslen(unk2E8[unkC8]); + unkE0[unkC8][chari] = fn_801EC270(unkE0[unkC8][chari]); + } + + unkC8++; + } + } + + bool goodC8 = unkC8 > 0; + s32 unki = 0; + s32 unkj = 0; + s32 sp8[3]; + for (s32 i = 0; i < unkC4; i++) { + if (!unk04[i].unk0) { + continue; + } + if (unkA4[i]->checkUnk08()) { + continue; + } + unki++; + + if (unk04[i].unk6) { + continue; + } + if (doUnkCheck(unkA4[i]->unk08, unk04[i].unk2, unk04[i].unk8)) { + continue; + } + unkj++; + + if (goodC8) { + if (unkDE) { + unkC8--; + } + memset(unkE0[unkC8], 0, sizeof(unkE0[unkC8]) - 2); + wcscat(unkE0[unkC8], reinterpret_cast(unkA4[i]->mesgPositive)); + unkDE = 1; + unkC8++; + } else { + if (unkC8 < 3) { + sp8[unkC8] = i; + unkC8++; + } else { + sp8[0] = sp8[1]; + sp8[1] = sp8[2]; + sp8[2] = i; + } + } + } + + if (!goodC8) { + for (s32 i = 0; i < unkC8; i++) { + memset(unkE0[i], 0, sizeof(unkE0[i]) - 2); + wcscat(unkE0[i], unk2E8[i]); + wcscat(unkE0[i], reinterpret_cast(unkA4[sp8[i]]->mesgPositive)); + if (i > 0) { + s32 chari = wcslen(unk2E8[i]); + unkE0[i][chari] = fn_801EC270(unkE0[i][chari]); + } + } + } + + bool isHi = false; + bool tempbool = false; + + bool badC8 = !goodC8; + if (badC8 && (unki > 0)) { + tempbool = true; + } + if (tempbool && (unkj == unki)) { + isHi = true; + } + + unkDF = ((unkj > 0) && (!isHi) && badC8) ? 1 : 0; + + unk2FC = getUnk2FCGrade(isHi, goodC8); + + if (unkC8 == 0) { + memset(unkE0[0], 0, sizeof(unkE0[0]) - 2); + wcscat(unkE0[0], unk2F8); + unkC8 = 1; + } +} + +u8 CCheckPointManager::fn_801EB7A8(void) { + return unkDE; +} + +u32 CCheckPointManager::fn_801EB7B0(void) { + return (unkDE != 0) ? (unkC8 - 1) : unkC8; +} + +wchar_t *CCheckPointManager::fn_801EB7D0(s32 i) { + return unkE0[i]; +} + +wchar_t *CCheckPointManager::fn_801EB7E0(void) { + return fn_801EB7D0(unkC8 - 1); +} + +wchar_t *CCheckPointManager::fn_801EB7F8(void) { + return unk2E8[3]; +} + +u8 CCheckPointManager::fn_801EB800(void) { + return unkDF; +} + +s32 CCheckPointManager::fn_801EB808(s32 i) { + s32 retVal = 0; + if (i == -1) { + for (s32 j = 0; j < unkC4; j++) { + retVal += unk04[j].unk0; + } + } else { + retVal = unk04[i].unk0; + } + return retVal; +} + +s32 CCheckPointManager::fn_801EB8FC(s32 i) { + s32 retVal = 0; + if (i == -1) { + for (s32 j = 0; j < unkC4; j++) { + retVal += unk04[j].unk2; + } + } else { + retVal = unk04[i].unk2; + } + return retVal; +} + +s32 CCheckPointManager::fn_801EB9F0(s32 i) { + s32 retVal = 0; + if (i == -1) { + for (s32 j = 0; j < unkC4; j++) { + retVal += unk04[j].unk4; + } + } else { + retVal = unk04[i].unk4; + } + return retVal; +} + +s32 CCheckPointManager::fn_801EBAE4(s32 i) { + s32 retVal = 0; + if (i == -1) { + for (s32 j = 0; j < unkC4; j++) { + retVal += unk04[j].unk6; + } + } else { + retVal = unk04[i].unk6; + } + return retVal; +} + +f32 CCheckPointManager::fn_801EBBD8(s32 i) { + s32 temp0 = fn_801EB808(i); + s32 temp1 = fn_801EB8FC(i); + + return (temp0 == 0) ? 0.0f : ((f32)temp1 / (f32)temp0); +} + +f32 CCheckPointManager::fn_801EBE00(s32 i) { + s32 temp0 = fn_801EB808(i); + s32 temp1 = fn_801EB9F0(i); + + return (temp0 == 0) ? 0.0f : ((f32)temp1 / (f32)temp0); +} + +f32 CCheckPointManager::fn_801EC028(s32 i) { + s32 temp0 = fn_801EB808(i); + s32 temp1 = fn_801EBAE4(i); + + return (temp0 == 0) ? 0.0f : ((f32)temp1 / (f32)temp0); +} + +void CCheckPointManager::fn_801EC250(s32 i, wchar_t *string) { + unk2E8[i] = string; +} + +void CCheckPointManager::fn_801EC260(wchar_t *string) { + unk2E8[3] = string; +} + +void CCheckPointManager::fn_801EC268(wchar_t *string) { + unk2F8 = string; +} + +wchar_t CCheckPointManager::fn_801EC270(wchar_t c) { + static const wchar_t upper[26] = { + 'A', 'B', 'C', 'D', 'E', 'F', 'G', + 'H', 'I', 'J', 'K', 'L', 'M', 'N', + 'O', 'P', 'Q', 'R', 'S', 'T', 'U', + 'V', 'W', 'X', 'Y', 'Z' }; + static const wchar_t lower[26] = { + 'a', 'b', 'c', 'd', 'e', 'f', 'g', + 'h', 'i', 'j', 'k', 'l', 'm', 'n', + 'o', 'p', 'q', 'r', 's', 't', 'u', + 'v', 'w', 'x', 'y', 'z' }; + + for (int i = 0; i < 26; i++) { + if (c == upper[i]) { + return lower[i]; + } + } + return c; +} diff --git a/src/GameUtil/CheckPointManager.hpp b/src/GameUtil/CheckPointManager.hpp index babd935..e723974 100644 --- a/src/GameUtil/CheckPointManager.hpp +++ b/src/GameUtil/CheckPointManager.hpp @@ -12,6 +12,13 @@ struct GradingCriteria { u16 unk0A; u16 unk0C; u16 flags; + + bool checkUnk08(void) { + if ((unk08 & 0x8000) && ((unk08 & ~0x8000) > 100)) { + return true; + } + return false; + } }; #define GRADE_CRITERIA_FLAG_NONE ((u16)(0)) @@ -29,6 +36,12 @@ struct GradingCriteria { { NULL, NULL, 0, 0, 0, GRADE_CRITERIA_FLAG_END } \ }; +enum ECheckInputType { + eCheckInputType_Hit = 0, + eCheckInputType_Miss, + eCheckInputType_Through, +}; + class CCheckPointManager : public TSingleton { public: @@ -39,9 +52,41 @@ class CCheckPointManager : public TSingleton { CCheckPointManager(void); - void fn_801EAE20(); - void fn_801EAF2C(u8, u32); - void fn_801EB00C(u8, u32); + void fn_801EAE20(void); + void fn_801EAE6C(GradingCriteria *); + void fn_801EAEA4(void); + + void fn_801EAF2C(u8, ECheckInputType); + void fn_801EB00C(u8, ECheckInputType); + + void fn_801EB10C(f32); + void fn_801EB11C(void); + + void fn_801EB130(void); + + u8 fn_801EB7A8(void); + u32 fn_801EB7B0(void); + + wchar_t *fn_801EB7D0(s32); + wchar_t *fn_801EB7E0(void); + wchar_t *fn_801EB7F8(void); + + u8 fn_801EB800(void); + + s32 fn_801EB808(s32); + s32 fn_801EB8FC(s32); + s32 fn_801EB9F0(s32); + s32 fn_801EBAE4(s32); + + f32 fn_801EBBD8(s32); + f32 fn_801EBE00(s32); + f32 fn_801EC028(s32); + + void fn_801EC250(s32, wchar_t *); + void fn_801EC260(wchar_t *); + void fn_801EC268(wchar_t *); + + static wchar_t fn_801EC270(wchar_t c); void setUnk2FC(u32 arg1) { unk2FC = arg1; @@ -49,9 +94,8 @@ class CCheckPointManager : public TSingleton { s32 getUnk2FC(void) const { return unk2FC; } - - u8 getUnk78(void) { - return unk78; + void setUnkC4(u8 arg0) { + unkC4 = arg0; } u8 getUnkC5(void) { return unkC5; @@ -59,18 +103,68 @@ class CCheckPointManager : public TSingleton { void setUnkDD(u8 unk) { unkDD = unk; } u8 getUnkDD(void) const { return unkDD; } + + bool doUnkCheck(u16 arg0, u16 arg1, f32 arg2) { + s32 temp1 = arg0 & ~0x8000; + if (arg0 & 0x8000) { + return arg2 < temp1; + } else { + return arg1 < temp1; + } + } + + u32 getUnk2FCGrade(bool arg0, bool arg1) { + u32 temp; + + if (arg0) { + temp = 0; + } else { + temp = 1; + if (arg1) { + temp = 2; + } + } + + return temp; + } private: - u8 pad04[0x78 - 4]; - u8 unk78; - u8 pad79[0xc5 - 0x79]; + struct GradingState { + u16 unk0; + u16 unk2; + u16 unk4; + u16 unk6; + f32 unk8; + f32 unkC; + f32 unk10; + + void reset(void) { + unk0 = 0; + unk2 = 0; + unk4 = 0; + unk6 = 0; + } + }; + + GradingState unk04[8]; + GradingCriteria *unkA4[8]; + u8 unkC4; u8 unkC5; - u8 unkC6[0xdd - 0xc6]; + s32 unkC8; + s32 unkCC; + u32 unkD0; + f32 unkD4; + f32 unkD8; + u8 unkDC; u8 unkDD; - u8 padDE[0x2fc - 0xde]; + u8 unkDE; + u8 unkDF; + wchar_t unkE0[4][64 + 1]; + wchar_t *unk2E8[4]; + wchar_t *unk2F8; u32 unk2FC; }; extern CCheckPointManager *gCheckPointManager; -#endif \ No newline at end of file +#endif diff --git a/src/GameUtil/InputCheckManager.cpp b/src/GameUtil/InputCheckManager.cpp index 1c33e23..dff5b8d 100644 --- a/src/GameUtil/InputCheckManager.cpp +++ b/src/GameUtil/InputCheckManager.cpp @@ -251,7 +251,7 @@ void CInputCheckManager::fn_801E8BD0(void) { break; } fn_801E9488(sp8); - gCheckPointManager->fn_801EAF2C(cur->getUnk78(), 0); + gCheckPointManager->fn_801EAF2C(cur->getUnk78(), eCheckInputType_Hit); break; case 1: temp_r23 = 1; @@ -259,7 +259,7 @@ void CInputCheckManager::fn_801E8BD0(void) { break; } fn_801E9488(sp8); - gCheckPointManager->fn_801EAF2C(cur->getUnk78(), 1); + gCheckPointManager->fn_801EAF2C(cur->getUnk78(), eCheckInputType_Miss); break; default: break; @@ -283,10 +283,10 @@ void CInputCheckManager::fn_801E8BD0(void) { if (cur->_30(temp_r20)) { switch ((s32)cur->getUnk74()) { case 0: - gCheckPointManager->fn_801EB00C(cur->getUnk78(), 0); + gCheckPointManager->fn_801EB00C(cur->getUnk78(), eCheckInputType_Hit); break; case 1: - gCheckPointManager->fn_801EB00C(cur->getUnk78(), 1); + gCheckPointManager->fn_801EB00C(cur->getUnk78(), eCheckInputType_Miss); break; default: break; diff --git a/src/GameUtil/InputChecker.cpp b/src/GameUtil/InputChecker.cpp index f41dd4f..8f7ba10 100644 --- a/src/GameUtil/InputChecker.cpp +++ b/src/GameUtil/InputChecker.cpp @@ -34,7 +34,7 @@ u32 CInputChecker::_18(void) { if (!unk71 && (mTickPass > (mTickJust + mRangeMissB))) { unk71 = true; gInputCheckManager->fn_801E9488(0); - gCheckPointManager->fn_801EAF2C(unk78, 2); + gCheckPointManager->fn_801EAF2C(unk78, eCheckInputType_Through); if (_2C()) { return 1; }