From abf327664226b7b534c1b210cec8db11ebdcdc0d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Sun, 25 Oct 2020 18:06:13 +0100 Subject: [PATCH] ksys/gdt: Implement more parts of TriggerParam (notably setters) --- data/uking_functions.csv | 171 +++--- lib/sead | 2 +- src/KingSystem/GameData/gdtTriggerParam.cpp | 598 +++++++++++++++++++- src/KingSystem/GameData/gdtTriggerParam.h | 163 +++++- 4 files changed, 846 insertions(+), 88 deletions(-) diff --git a/data/uking_functions.csv b/data/uking_functions.csv index 1d55711f..c0d70d0a 100644 --- a/data/uking_functions.csv +++ b/data/uking_functions.csv @@ -74412,59 +74412,65 @@ 0x0000007100de17e4,TriggerParam::getVec3fArraySizeByKey,248,_ZNK4ksys3gdt12TriggerParam17getVec3fArraySizeEPiRKN4sead14SafeStringBaseIcEE 0x0000007100DE18DC,_ZNK4ksys3gdt12TriggerParam17getMinValueForS32EPiRKN4sead14SafeStringBaseIcEE,0x144,_ZNK4ksys3gdt12TriggerParam17getMinValueForS32EPiRKN4sead14SafeStringBaseIcEE 0x0000007100de1a20,TriggerParam::getS32Max,324,_ZNK4ksys3gdt12TriggerParam17getMaxValueForS32EPiRKN4sead14SafeStringBaseIcEE -0x0000007100de1b64,TriggerParam::setBoolByIndex,236, -0x0000007100de1c50,sub_7100DE1C50,260, -0x0000007100de1d54,TriggerParam::postSetFlagMaybe,360,_ZN4ksys3gdt12TriggerParam16recordFlagChangeEPKNS0_8FlagBaseEis -0x0000007100de1ebc,GameDataFlagBool::reportUpdate,1084, -0x0000007100de22f8,TriggerParam::setS32ByIdx,332, -0x0000007100de2444,sub_7100DE2444,1220, -0x0000007100de2908,TriggerParam::setF32ByIdx,340, -0x0000007100de2a5c,sub_7100DE2A5C,1220, -0x0000007100de2f20,TriggerParam::setString32ByIdx,432, -0x0000007100de30d0,sub_7100DE30D0,540, -0x0000007100de32ec,sub_7100DE32EC,1220, -0x0000007100de37b0,TriggerParam::setString64ByIdx,432, -0x0000007100de3960,sub_7100DE3960,540, -0x0000007100de3b7c,sub_7100DE3B7C,1220, -0x0000007100de4040,TriggerParam::setString256ByIdx,440, -0x0000007100de41f8,sub_7100DE41F8,540, -0x0000007100de4414,sub_7100DE4414,1220, -0x0000007100de48d8,sub_7100DE48D8,260, -0x0000007100de49dc,sub_7100DE49DC,1220, -0x0000007100de4ea0,sub_7100DE4EA0,180, -0x0000007100de4f54,sub_7100DE4F54,264, -0x0000007100de505c,sub_7100DE505C,1220, -0x0000007100de5520,sub_7100DE5520,1220, -0x0000007100de59e4,TriggerParam::setBoolByKey,296, -0x0000007100de5b0c,TriggerParam::setIntByKey,296, -0x0000007100de5c34,TriggerParam::setF32ByKey,304, -0x0000007100de5d64,TriggerParam::setString32ByKey,296, -0x0000007100de5e8c,TriggerParam::setString64ByKey,296, -0x0000007100de5fb4,TriggerParam::setVec3ByKey,444, -0x0000007100de6170,sub_7100DE6170,236, -0x0000007100de625c,TriggerParam::x_2,388, -0x0000007100de63e0,TriggerParam::x_4,396, -0x0000007100de656c,sub_7100DE656C,492, -0x0000007100de6758,sub_7100DE6758,492, -0x0000007100de6944,sub_7100DE6944,224, -0x0000007100de6a24,sub_7100DE6A24,224, -0x0000007100de6b04,TriggerParam::setBoolInArrayByKey,260, -0x0000007100de6c08,sub_7100DE6C08,260, -0x0000007100de6d0c,sub_7100DE6D0C,268, -0x0000007100de6e18,TriggerParam::setString64InArrayByKey,260, -0x0000007100de7004,TriggerParam::resetS32,232, -0x0000007100de70ec,TriggerParam::resetF32,232, -0x0000007100de71d4,TriggerParam::resetString64,232, -0x0000007100de74b4,TriggerParam::resetS32ByKey,272, -0x0000007100de77e4,TriggerParam::resetBoolArray,284, -0x0000007100de7900,TriggerParam::resetS32Array,284, -0x0000007100de7a1c,TriggerParam::resetF32Array,284, -0x0000007100de7b38,TriggerParam::resetString32Array,284, -0x0000007100de7c54,TriggerParam::resetString64Array,284, -0x0000007100de7d70,TriggerParam::resetString256Array,284, -0x0000007100de7e8c,TriggerParam::resetVec2fArray,284, -0x0000007100de7fa8,TriggerParam::resetVec3fArray,284, -0x0000007100de80c4,TriggerParam::resetVec4fArray,284, +0x0000007100de1b64,TriggerParam::setBoolByIndex,236,_ZN4ksys3gdt12TriggerParam7setBoolEbibb +0x0000007100de1c50,sub_7100DE1C50,260,_ZN4ksys3gdt12_GLOBAL__N_114doSetFlagValueIbEEbPbRKT_RKN4sead8PtrArrayINS0_8FlagBaseEEEibb +0x0000007100de1d54,TriggerParam::postSetFlagMaybe,360,_ZN4ksys3gdt12TriggerParam16recordFlagChangeEPKNS0_8FlagBaseEii +0x0000007100de1ebc,GameDataFlagBool::reportUpdate,1084,_ZN4ksys3gdt12_GLOBAL__N_116reportFlagChangeIbEEvPKNS0_8FlagBaseEi +0x0000007100de22f8,TriggerParam::setS32ByIdx,332,_ZN4ksys3gdt12TriggerParam6setS32Eiibb +0x0000007100de2444,sub_7100DE2444,1220,_ZN4ksys3gdt12_GLOBAL__N_116reportFlagChangeIiEEvPKNS0_8FlagBaseEi +0x0000007100de2908,TriggerParam::setF32ByIdx,340,_ZN4ksys3gdt12TriggerParam6setF32Efibb +0x0000007100de2a5c,sub_7100DE2A5C,1220,_ZN4ksys3gdt12_GLOBAL__N_116reportFlagChangeIfEEvPKNS0_8FlagBaseEi +0x0000007100de2f20,TriggerParam::setString32ByIdx,432,_ZN4ksys3gdt12TriggerParam6setStrEPKcibb +0x0000007100de30d0,sub_7100DE30D0,540,_ZN4ksys3gdt12_GLOBAL__N_114doSetFlagValueIN4sead15FixedSafeStringILi32EEEEEbPbRKT_RKNS3_8PtrArrayINS0_8FlagBaseEEEibb +0x0000007100de32ec,sub_7100DE32EC,1220,_ZN4ksys3gdt12_GLOBAL__N_116reportFlagChangeIN4sead15FixedSafeStringILi32EEEEEvPKNS0_8FlagBaseEi +0x0000007100de37b0,TriggerParam::setString64ByIdx,432,_ZN4ksys3gdt12TriggerParam8setStr64EPKcibb +0x0000007100de3960,sub_7100DE3960,540,_ZN4ksys3gdt12_GLOBAL__N_114doSetFlagValueIN4sead15FixedSafeStringILi64EEEEEbPbRKT_RKNS3_8PtrArrayINS0_8FlagBaseEEEibb +0x0000007100de3b7c,sub_7100DE3B7C,1220,_ZN4ksys3gdt12_GLOBAL__N_116reportFlagChangeIN4sead15FixedSafeStringILi64EEEEEvPKNS0_8FlagBaseEi +0x0000007100de4040,TriggerParam::setString256ByIdx,440,_ZN4ksys3gdt12TriggerParam9setStr256EPKcibb +0x0000007100de41f8,sub_7100DE41F8,540,_ZN4ksys3gdt12_GLOBAL__N_114doSetFlagValueIN4sead15FixedSafeStringILi256EEEEEbPbRKT_RKNS3_8PtrArrayINS0_8FlagBaseEEEibb +0x0000007100de4414,sub_7100DE4414,1220,_ZN4ksys3gdt12_GLOBAL__N_116reportFlagChangeIN4sead15FixedSafeStringILi256EEEEEvPKNS0_8FlagBaseEi +0x0000007100de48d8,sub_7100DE48D8,260,_ZN4ksys3gdt12_GLOBAL__N_114doSetFlagValueIN4sead7Vector2IfEEEEbPbRKT_RKNS3_8PtrArrayINS0_8FlagBaseEEEibb +0x0000007100de49dc,sub_7100DE49DC,1220,_ZN4ksys3gdt12_GLOBAL__N_116reportFlagChangeIN4sead7Vector2IfEEEEvPKNS0_8FlagBaseEi +0x0000007100de4ea0,sub_7100DE4EA0,180,_ZN4ksys3gdt12TriggerParam8setVec3fERKN4sead7Vector3IfEEibb +0x0000007100de4f54,sub_7100DE4F54,264,_ZN4ksys3gdt12_GLOBAL__N_114doSetFlagValueIN4sead7Vector3IfEEEEbPbRKT_RKNS3_8PtrArrayINS0_8FlagBaseEEEibb +0x0000007100de505c,sub_7100DE505C,1220,_ZN4ksys3gdt12_GLOBAL__N_116reportFlagChangeIN4sead7Vector3IfEEEEvPKNS0_8FlagBaseEi +0x0000007100de5520,sub_7100DE5520,1220,_ZN4ksys3gdt12_GLOBAL__N_116reportFlagChangeIN4sead7Vector4IfEEEEvPKNS0_8FlagBaseEi +0x0000007100de59e4,TriggerParam::setBoolByKey,296,_ZN4ksys3gdt12TriggerParam7setBoolEbRKN4sead14SafeStringBaseIcEEbbb +0x0000007100de5b0c,TriggerParam::setIntByKey,296,_ZN4ksys3gdt12TriggerParam6setS32EiRKN4sead14SafeStringBaseIcEEbbb +0x0000007100de5c34,TriggerParam::setF32ByKey,304,_ZN4ksys3gdt12TriggerParam6setF32EfRKN4sead14SafeStringBaseIcEEbbb +0x0000007100de5d64,TriggerParam::setString32ByKey,296,_ZN4ksys3gdt12TriggerParam6setStrEPKcRKN4sead14SafeStringBaseIcEEbbb +0x0000007100de5e8c,TriggerParam::setString64ByKey,296,_ZN4ksys3gdt12TriggerParam8setStr64EPKcRKN4sead14SafeStringBaseIcEEbbb +0x0000007100de5fb4,TriggerParam::setVec3ByKey,444,_ZN4ksys3gdt12TriggerParam8setVec3fERKN4sead7Vector3IfEERKNS2_14SafeStringBaseIcEEbbb? +0x0000007100de6170,sub_7100DE6170,236,_ZN4ksys3gdt12TriggerParam7setBoolEbiibb +0x0000007100de625c,TriggerParam::x_2,388,_ZN4ksys3gdt12TriggerParam6setS32Eiiibb +0x0000007100de63e0,TriggerParam::x_4,396,_ZN4ksys3gdt12TriggerParam6setF32Efiibb +0x0000007100de656c,sub_7100DE656C,492,_ZN4ksys3gdt12TriggerParam8setStr64EPKciibb +0x0000007100de6758,sub_7100DE6758,492,_ZN4ksys3gdt12TriggerParam9setStr256EPKciibb +0x0000007100de6944,sub_7100DE6944,224,_ZN4ksys3gdt12TriggerParam8setVec2fERKN4sead7Vector2IfEEiibb +0x0000007100de6a24,sub_7100DE6A24,224,_ZN4ksys3gdt12TriggerParam8setVec3fERKN4sead7Vector3IfEEiibb +0x0000007100de6b04,TriggerParam::setBoolInArrayByKey,260,_ZN4ksys3gdt12TriggerParam7setBoolEbRKN4sead14SafeStringBaseIcEEibbb +0x0000007100de6c08,sub_7100DE6C08,260,_ZN4ksys3gdt12TriggerParam6setS32EiRKN4sead14SafeStringBaseIcEEibbb +0x0000007100de6d0c,sub_7100DE6D0C,268,_ZN4ksys3gdt12TriggerParam6setF32EfRKN4sead14SafeStringBaseIcEEibbb +0x0000007100de6e18,TriggerParam::setString64InArrayByKey,260,_ZN4ksys3gdt12TriggerParam8setStr64EPKcRKN4sead14SafeStringBaseIcEEibbb +0x0000007100de6f1c,TriggerParam::resetBool,232,_ZN4ksys3gdt12TriggerParam9resetBoolEib +0x0000007100de7004,TriggerParam::resetS32,232,_ZN4ksys3gdt12TriggerParam8resetS32Eib +0x0000007100de70ec,TriggerParam::resetF32,232,_ZN4ksys3gdt12TriggerParam8resetF32Eib +0x0000007100de71d4,TriggerParam::resetString64,232,_ZN4ksys3gdt12TriggerParam10resetStr64Eib +0x0000007100de72bc,_ZN4ksys3gdt12TriggerParam10resetVec3fEib,232,_ZN4ksys3gdt12TriggerParam10resetVec3fEib +0x0000007100de73a4,resetBoolByKey,0x110,_ZN4ksys3gdt12TriggerParam9resetBoolERKN4sead14SafeStringBaseIcEEb +0x0000007100de74b4,TriggerParam::resetS32ByKey,272,_ZN4ksys3gdt12TriggerParam8resetS32ERKN4sead14SafeStringBaseIcEEb +0x0000007100de75c4,_ZN4ksys3gdt12TriggerParam10resetStr64ERKN4sead14SafeStringBaseIcEEb,0x110,_ZN4ksys3gdt12TriggerParam10resetStr64ERKN4sead14SafeStringBaseIcEEb +0x0000007100de76d4,_ZN4ksys3gdt12TriggerParam10resetVec3fERKN4sead14SafeStringBaseIcEEb,0x110,_ZN4ksys3gdt12TriggerParam10resetVec3fERKN4sead14SafeStringBaseIcEEb +0x0000007100de77e4,TriggerParam::resetBoolArray,284,_ZN4ksys3gdt12TriggerParam9resetBoolEiib +0x0000007100de7900,TriggerParam::resetS32Array,284,_ZN4ksys3gdt12TriggerParam8resetS32Eiib +0x0000007100de7a1c,TriggerParam::resetF32Array,284,_ZN4ksys3gdt12TriggerParam8resetF32Eiib +0x0000007100de7b38,TriggerParam::resetString32Array,284,_ZN4ksys3gdt12TriggerParam8resetStrEiib +0x0000007100de7c54,TriggerParam::resetString64Array,284,_ZN4ksys3gdt12TriggerParam10resetStr64Eiib +0x0000007100de7d70,TriggerParam::resetString256Array,284,_ZN4ksys3gdt12TriggerParam11resetStr256Eiib +0x0000007100de7e8c,TriggerParam::resetVec2fArray,284,_ZN4ksys3gdt12TriggerParam10resetVec2fEiib +0x0000007100de7fa8,TriggerParam::resetVec3fArray,284,_ZN4ksys3gdt12TriggerParam10resetVec3fEiib +0x0000007100de80c4,TriggerParam::resetVec4fArray,284,_ZN4ksys3gdt12TriggerParam10resetVec4fEiib +0x0000007100de81e0,_ZN4ksys3gdt12TriggerParam8resetS32ERKN4sead14SafeStringBaseIcEEib,0xEC,_ZN4ksys3gdt12TriggerParam8resetS32ERKN4sead14SafeStringBaseIcEEib 0x0000007100de82cc,TriggerParam::getArray158Flag,364, 0x0000007100de8438,TriggerParam::getHorseIntByKeyMaybe,360, 0x0000007100de85a0,sub_7100DE85A0,360, @@ -74488,12 +74494,12 @@ 0x0000007100dee238,sub_7100DEE238,796, 0x0000007100dee554,sub_7100DEE554,796, 0x0000007100dee870,sub_7100DEE870,796, -0x0000007100deeb8c,TriggerParam::resetToInitialValues,2628, +0x0000007100deeb8c,TriggerParam::resetToInitialValues,2628,_ZN4ksys3gdt12TriggerParam28resetAllFlagsToInitialValuesEv 0x0000007100def5d0,shouldSkipReviveShopItem,868, 0x0000007100def934,TriggerParam::reset,3652, -0x0000007100df0778,TriggerParam::getGameDataFlagBool,32, +0x0000007100df0778,TriggerParam::getGameDataFlagBool,32,_ZNK4ksys3gdt12TriggerParam11getBoolFlagEi 0x0000007100df0798,TriggerParam::getBoolFlag,256, -0x0000007100df0898,sub_7100DF0898,32, +0x0000007100df0898,sub_7100DF0898,32,_ZNK4ksys3gdt12TriggerParam10getS32FlagEi 0x0000007100df08b8,TriggerParam::getBoolIdx,184,_ZNK4ksys3gdt12TriggerParam10getBoolIdxEj 0x0000007100df0970,TriggerParam::getS32Idx,184,_ZNK4ksys3gdt12TriggerParam9getS32IdxEj 0x0000007100df0a28,TriggerParam::getF32Idx,184,_ZNK4ksys3gdt12TriggerParam9getF32IdxEj @@ -74527,32 +74533,33 @@ 0x0000007100df210c,sub_7100DF210C,244, 0x0000007100df2200,sub_7100DF2200,244, 0x0000007100df22f4,sub_7100DF22F4,244, -0x0000007100df23e8,sub_7100DF23E8,32, -0x0000007100df2408,sub_7100DF2408,32, -0x0000007100df2428,sub_7100DF2428,32, -0x0000007100df2448,sub_7100DF2448,32, -0x0000007100df2468,sub_7100DF2468,32, -0x0000007100df2488,sub_7100DF2488,32, -0x0000007100df24a8,sub_7100DF24A8,32, -0x0000007100df24c8,sub_7100DF24C8,60, -0x0000007100df2504,sub_7100DF2504,60, -0x0000007100df2540,sub_7100DF2540,60, -0x0000007100df257c,sub_7100DF257C,60, -0x0000007100df25b8,sub_7100DF25B8,60, -0x0000007100df25f4,sub_7100DF25F4,60, -0x0000007100df2630,sub_7100DF2630,60, -0x0000007100df266c,sub_7100DF266C,60, -0x0000007100df26a8,sub_7100DF26A8,60, +0x0000007100df23e8,sub_7100DF23E8,32,_ZNK4ksys3gdt12TriggerParam10getF32FlagEi +0x0000007100df2408,sub_7100DF2408,32,_ZNK4ksys3gdt12TriggerParam10getStrFlagEi +0x0000007100df2428,sub_7100DF2428,32,_ZNK4ksys3gdt12TriggerParam12getStr64FlagEi +0x0000007100df2448,sub_7100DF2448,32,_ZNK4ksys3gdt12TriggerParam13getStr256FlagEi +0x0000007100df2468,sub_7100DF2468,32,_ZNK4ksys3gdt12TriggerParam12getVec2fFlagEi +0x0000007100df2488,sub_7100DF2488,32,_ZNK4ksys3gdt12TriggerParam12getVec3fFlagEi +0x0000007100df24a8,sub_7100DF24A8,32,_ZNK4ksys3gdt12TriggerParam12getVec4fFlagEi +0x0000007100df24c8,sub_7100DF24C8,60,_ZNK4ksys3gdt12TriggerParam11getBoolFlagEii +0x0000007100df2504,sub_7100DF2504,60,_ZNK4ksys3gdt12TriggerParam10getS32FlagEii +0x0000007100df2540,sub_7100DF2540,60,_ZNK4ksys3gdt12TriggerParam10getF32FlagEii +0x0000007100df257c,sub_7100DF257C,60,_ZNK4ksys3gdt12TriggerParam10getStrFlagEii +0x0000007100df25b8,sub_7100DF25B8,60,_ZNK4ksys3gdt12TriggerParam12getStr64FlagEii +0x0000007100df25f4,sub_7100DF25F4,60,_ZNK4ksys3gdt12TriggerParam13getStr256FlagEii +0x0000007100df2630,sub_7100DF2630,60,_ZNK4ksys3gdt12TriggerParam12getVec2fFlagEii +0x0000007100df266c,sub_7100DF266C,60,_ZNK4ksys3gdt12TriggerParam12getVec3fFlagEii +0x0000007100df26a8,sub_7100DF26A8,60,_ZNK4ksys3gdt12TriggerParam12getVec4fFlagEii +0x0000007100df26e4,_ZN4ksys3gdt12TriggerParam26onResetBoolFlagForRadarMgrEPNS0_8FlagBaseEi,12,_ZN4ksys3gdt12TriggerParam26onResetBoolFlagForRadarMgrEPNS0_8FlagBaseEi 0x0000007100df26f0,_ZN4ksys3gdt12TriggerParam23setCurrentRupeeFlagNameERKN4sead14SafeStringBaseIcEE,0x48,_ZN4ksys3gdt12TriggerParam23setCurrentRupeeFlagNameERKN4sead14SafeStringBaseIcEE 0x0000007100df2738,sub_7100DF2738,460,_ZN4ksys3gdt19shouldLogFlagChangeERKN4sead14SafeStringBaseIcEENS0_8FlagTypeE 0x0000007100df2904,sub_7100DF2904,360,_ZN4ksys3gdt12getFlagColorENS0_8FlagTypeE? -0x0000007100df2a6c,sub_7100DF2A6C,8, -0x0000007100df2a74,sub_7100DF2A74,44, -0x0000007100df2aa0,nullsub_3859,4, -0x0000007100df2aa4,j__ZdlPv_895,4, -0x0000007100df2aa8,sub_7100DF2AA8,8, -0x0000007100df2ab0,sub_7100DF2AB0,36, -0x0000007100df2ad4,sub_7100DF2AD4,16, +0x0000007100df2a6c,sub_7100DF2A6C,8,_ZNK4sead10StackTraceILi50EE4sizeEv +0x0000007100df2a74,sub_7100DF2A74,44,_ZNK4sead10StackTraceILi50EE3getEi +0x0000007100df2aa0,nullsub_3859,4,_ZN4sead14StackTraceBaseD2Ev +0x0000007100df2aa4,j__ZdlPv_895,4,_ZN4sead10StackTraceILi50EED0Ev +0x0000007100df2aa8,sub_7100DF2AA8,8,_ZN4sead10StackTraceILi50EE6clear_Ev +0x0000007100df2ab0,sub_7100DF2AB0,36,_ZN4sead10StackTraceILi50EE5push_Em +0x0000007100df2ad4,sub_7100DF2AD4,16,_ZN4sead10StackTraceILi50EE7isFull_Ev 0x0000007100df2ae4,nullsub_3860,4,_ZN4ksys3gdt8FlagBaseD2Ev 0x0000007100df2ae8,j__ZdlPv_896,4,_ZN4ksys3gdt9FlagProxyIbED0Ev 0x0000007100df2aec,sub_7100DF2AEC,16,_ZNK4ksys3gdt9FlagProxyIbE7getHashEv @@ -74755,7 +74762,7 @@ 0x0000007100df5cd8,sub_7100DF5CD8,96,_ZNK4ksys3gdt9FlagProxyIN4sead7Vector4IfEEE8hasValueERKS4_ 0x0000007100df5d38,sub_7100DF5D38,272,_ZN4ksys3gdt9FlagProxyIN4sead7Vector4IfEEE8setValueES4_ 0x0000007100df5e48,sub_7100DF5E48,16,_ZNK4ksys3gdt9FlagProxyIN4sead7Vector4IfEEE12getDebugDataEv -0x0000007100df5e58,gdm::debugReportFlagChange,792, +0x0000007100df5e58,gdm::debugReportFlagChange,792,_ZN4ksys3gdt12_GLOBAL__N_124sendFlagChangePlayReportERKN4sead14SafeStringBaseIcEEPKNS0_8FlagBaseE 0x0000007100df6170,sub_7100DF6170,268, 0x0000007100df627c,sub_7100DF627C,268, 0x0000007100df6388,sub_7100DF6388,268, @@ -96762,10 +96769,10 @@ 0x00000071013680b8,sub_71013680B8,148, 0x000000710136814c,sub_710136814C,56, 0x0000007101368184,parseOptionsInternal,724, -0x0000007101368458,sub_7101368458,20, +0x0000007101368458,sub_7101368458,20,_ZN4sead14StackTraceBaseC2Ev 0x000000710136846c,_ZN4sead14StackTraceBase5traceEPKv,144, 0x00000071013684fc,_ZN4sead19StackSymbolResolver22isIllegalSymbolAddressEmm,64, -0x000000710136853c,j__ZdlPv_1403,4, +0x000000710136853c,j__ZdlPv_1403,4,_ZN4sead14StackTraceBaseD0Ev 0x0000007101368540,_ZN4sead16NinAocFileDeviceC1ERKNS_14SafeStringBaseIcEE,96,_ZN4sead16NinAocFileDeviceC1ERKNS_14SafeStringBaseIcEE 0x00000071013685a0,sub_71013685A0,36,_ZN4sead16NinAocFileDeviceD0Ev 0x00000071013685c4,sub_71013685C4,288,_ZNK4sead16NinAocFileDevice27checkDerivedRuntimeTypeInfoEPKNS_15RuntimeTypeInfo9InterfaceE diff --git a/lib/sead b/lib/sead index e0f91577..7127999d 160000 --- a/lib/sead +++ b/lib/sead @@ -1 +1 @@ -Subproject commit e0f91577f3df97c41f4a91493dc06b208387963b +Subproject commit 7127999dca9335ddfbd28c81bccb8d368b706c8a diff --git a/src/KingSystem/GameData/gdtTriggerParam.cpp b/src/KingSystem/GameData/gdtTriggerParam.cpp index d400eff7..669d78da 100644 --- a/src/KingSystem/GameData/gdtTriggerParam.cpp +++ b/src/KingSystem/GameData/gdtTriggerParam.cpp @@ -1,8 +1,11 @@ #include "KingSystem/GameData/gdtTriggerParam.h" #include +#include #include #include "KingSystem/GameData/gdtFlagProxy.h" #include "KingSystem/Resource/resResourceGameData.h" +#include "KingSystem/System/PlayReportMgr.h" +#include "KingSystem/Utils/Debug.h" #include "KingSystem/Utils/InitTimeInfo.h" #include "KingSystem/Utils/SafeDelete.h" @@ -81,11 +84,15 @@ inline s32 getFlagIndex(const sead::PtrArray>& flags, u return -1; } -template -inline Flag* getFlagByIndex(const sead::PtrArray& flags, s32 index) { +inline FlagBase* getFlagByIndexBase(const sead::PtrArray& flags, s32 index) { if (index < 0 || index >= flags.size()) return nullptr; - return static_cast*>(flags[index]); + return flags[index]; +} + +template +inline Flag* getFlagByIndex(const sead::PtrArray& flags, s32 index) { + return static_cast*>(getFlagByIndexBase(flags, index)); } template @@ -147,6 +154,219 @@ inline bool getFlagValue(const sead::PtrArray>& arrays, return true; } +/// Modifies the value of a flag. +/// @param success A non-null pointer to a boolean that is set to true if an attempt was made to +/// change the value. +/// @return whether the flag contains the specified value at the end of this function. +template +bool doSetFlagValue(bool* success, const T& value, const sead::PtrArray& flags, s32 idx, + bool check_permissions, bool bypass_one_trigger_check) { + *success = false; + + auto* flag = getFlagByIndex(flags, idx); + if (!flag) + return false; + + if (check_permissions && !flags[idx]->isProgramWritable()) + return false; + + if constexpr (IsAnyOfType()) { + if (!flags[idx]->isOneTrigger() || bypass_one_trigger_check || flag->isInitialValue()) + *success = flag->setValue(value); + else if (!flag->hasValue(value)) + return false; + return true; + } else { + bool can_set_value = false; + if (!flags[idx]->isOneTrigger() || bypass_one_trigger_check || flag->isInitialValue()) { + can_set_value = true; + *success = flag->setValue(value); + } else if (flag->hasValue(value)) { + return true; + } + return can_set_value; + } +} + +void sendFlagChangePlayReport(const sead::SafeString& name, const FlagBase* flag) { + if (!PlayReportMgr::instance()) + return; + + for (s32 i = 0; i < sConfig.num_current_rupee_flag_name_changes; ++i) { + if (name == sConfig.current_rupee_flag_name) { + sead::FixedSafeString<64> value_str; + switch (s32(flag->getType())) { + case FlagType::Bool: + case FlagType::BoolArray: + if (static_cast(flag)->getValue()) + value_str.format("true"); + else + value_str.format("false"); + break; + case FlagType::S32: + case FlagType::S32Array: + value_str.format("%d", static_cast(flag)->getValue()); + break; + case FlagType::F32: + case FlagType::F32Array: + value_str.format("%f", static_cast(flag)->getValue()); + break; + case FlagType::String: + case FlagType::StringArray: + value_str.format("%s", static_cast(flag)->getValueRef().cstr()); + break; + case FlagType::String64: + case FlagType::String64Array: + value_str.format("%s", + static_cast(flag)->getValueRef().cstr()); + break; + case FlagType::String256: + case FlagType::String256Array: + value_str.format("%s", + static_cast(flag)->getValueRef().cstr()); + break; + case FlagType::Vector2f: + case FlagType::Vector2fArray: { + const auto& vector = static_cast(flag)->getValueRef(); + value_str.format("%f %f", vector.x, vector.y); + break; + } + case FlagType::Vector3f: + case FlagType::Vector3fArray: { + const auto& vector = static_cast(flag)->getValueRef(); + value_str.format("%f %f %f", vector.x, vector.y, vector.z); + break; + } + case FlagType::Vector4f: + case FlagType::Vector4fArray: { + const auto& vector = static_cast(flag)->getValueRef(); + value_str.format("%f %f %f %f", vector.x, vector.y, vector.z, vector.w); + break; + } + default: + break; + } + PlayReportMgr::instance()->reportDebug(name, value_str); + break; + } + } +} + +template +void reportFlagChange(const FlagBase* flag, s32 sub_idx = -1) { + auto* flag_ = static_cast*>(flag); + + const sead::SafeString& name = flag->getName(); + const FlagType type = flag->getType(); + + if constexpr (std::is_same()) { + if ((s32(type) == FlagType::Bool || s32(type) == FlagType::BoolArray) && + PlayReportMgr::instance()) { + if (flag_->getValue()) + PlayReportMgr::instance()->reportDebug("FlagOn", name); + else + PlayReportMgr::instance()->reportDebug("FlagOff", name); + } + } else { + sendFlagChangePlayReport(name, flag); + } + + if (sConfig.shouldPrintStackTrace(name)) { + sead::StackTrace<50> stack_trace; + stack_trace.trace(nullptr); + } + + if (!shouldLogFlagChange(name, type)) + return; + + if constexpr (std::is_same()) { + sead::FixedSafeString<128> message; + const char* name_cstr = flag->getName().cstr(); + const auto type_ = flag->getType(); + if (sub_idx < 0 || type_ != FlagType::BoolArray) + message.format("%s", name_cstr); + else + message.format("%s [%3d]", name_cstr, sub_idx); + + switch (s32(flag->getType())) { + case FlagType::Bool: + case FlagType::BoolArray: + if (flag_->getValue()) + message.append(" : true"); + else + message.append(" : false"); + break; + default: + break; + } + util::PrintDebug(message); + } else { + const char* name_cstr = flag->getName().cstr(); + sead::FixedSafeString<128> message; + const s32 type_ = flag->getType(); + if (sub_idx >= 0 && type_ >= FlagType::BoolArray) + message.format("%s [%3d] :", name_cstr, sub_idx); + else + message.format("%s :", name_cstr); + + sead::FixedSafeString<64> value_str; + switch (s32(flag->getType())) { + case FlagType::Bool: + case FlagType::BoolArray: + if (static_cast(flag)->getValue()) + value_str.format("true"); + else + value_str.format("false"); + break; + case FlagType::S32: + case FlagType::S32Array: + value_str.format("%d", static_cast(flag)->getValue()); + break; + case FlagType::F32: + case FlagType::F32Array: + value_str.format("%f", static_cast(flag)->getValue()); + break; + case FlagType::String: + case FlagType::StringArray: + value_str.format("%s", static_cast(flag)->getValueRef().cstr()); + break; + case FlagType::String64: + case FlagType::String64Array: + value_str.format("%s", static_cast(flag)->getValueRef().cstr()); + break; + case FlagType::String256: + case FlagType::String256Array: + value_str.format("%s", static_cast(flag)->getValueRef().cstr()); + break; + case FlagType::Vector2f: + case FlagType::Vector2fArray: { + const auto& vector = static_cast(flag)->getValueRef(); + value_str.format("%f %f", vector.x, vector.y); + break; + } + case FlagType::Vector3f: + case FlagType::Vector3fArray: { + const auto& vector = static_cast(flag)->getValueRef(); + value_str.format("%f %f %f", vector.x, vector.y, vector.z); + break; + } + case FlagType::Vector4f: + case FlagType::Vector4fArray: { + const auto& vector = static_cast(flag)->getValueRef(); + value_str.format("%f %f %f %f", vector.x, vector.y, vector.z, vector.w); + break; + } + default: + break; + } + message.append(value_str); + util::PrintDebug(message); + } + + static_cast(getFlagColor(type)); + sConfig.index = sConfig.index >= 32 ? 0 : sConfig.index + 1; +} + bool getFlagArraySize(const sead::PtrArray>& arrays, s32 index, s32* out) { if (index < 0 || index >= arrays.size()) return false; @@ -885,7 +1105,93 @@ bool TriggerParam::getMaxValueForS32(s32* max, const sead::SafeString& name) con return true; } -void TriggerParam::recordFlagChange(const FlagBase* flag, s32 idx, s16 sub_idx) { +#define SET_FLAG_VALUE_IMPL_(FUNCTION_NAME, ARG_VALUE_TYPE, FLAGS, T, VALUE) \ + bool FUNCTION_NAME(ARG_VALUE_TYPE value, s32 idx, bool check_permissions, \ + bool bypass_one_trigger_check) { \ + bool success = false; \ + const bool ret = doSetFlagValue(&success, VALUE, FLAGS, idx, check_permissions, \ + bypass_one_trigger_check); \ + if (!success) \ + return ret; \ + \ + recordFlagChange(FLAGS[idx], idx); \ + reportFlagChange(FLAGS[idx]); \ + \ + if constexpr (std::is_same()) { \ + if (FLAGS[idx]->getProperties().isEventAssociated()) \ + mBitFlags.ref().set(BitFlag::EventAssociatedFlagModified); \ + } \ + \ + return ret; \ + } + +#define SET_FLAG_VALUE_BY_KEY_IMPL_(FUNCTION_NAME, GET_INDEX_FN, ARG_VALUE_TYPE) \ + bool FUNCTION_NAME(ARG_VALUE_TYPE value, const sead::SafeString& name, bool check_permissions, \ + bool, bool bypass_one_trigger_check) { \ + return FUNCTION_NAME(value, GET_INDEX_FN(name), check_permissions, \ + bypass_one_trigger_check); \ + } + +#define SET_ARRAY_FLAG_VALUE_IMPL_(FUNCTION_NAME, ARG_VALUE_TYPE, FLAGS, T, VALUE) \ + bool FUNCTION_NAME(ARG_VALUE_TYPE value, s32 idx, s32 sub_idx, bool check_permissions, \ + bool bypass_one_trigger_check) { \ + bool success = false; \ + \ + if (idx < 0 || idx >= FLAGS.size()) \ + return false; \ + \ + const auto* array = FLAGS[idx]; \ + if (!array) \ + return false; \ + \ + const bool ret = doSetFlagValue(&success, VALUE, *array, sub_idx, check_permissions, \ + bypass_one_trigger_check); \ + if (!success) \ + return ret; \ + \ + const auto* flag = (*FLAGS[idx])[sub_idx]; \ + recordFlagChange(flag, idx, sub_idx); \ + reportFlagChange(flag, sub_idx); \ + \ + return ret; \ + } + +#define SET_STRING_ARRAY_FLAG_VALUE_IMPL_(FUNCTION_NAME, FLAGS, T) \ + bool FUNCTION_NAME(const char* value, s32 idx, s32 sub_idx, bool check_permissions, \ + bool bypass_one_trigger_check) { \ + bool success = false; \ + T value_{value}; \ + success = false; \ + \ + if (idx < 0 || idx >= FLAGS.size()) \ + return false; \ + \ + const auto* array = FLAGS[idx]; \ + if (!array) \ + return false; \ + \ + const bool ret = doSetFlagValue(&success, value_, *array, sub_idx, check_permissions, \ + bypass_one_trigger_check); \ + if (!success) \ + return ret; \ + \ + const auto* flag = (*FLAGS[idx])[sub_idx]; \ + recordFlagChange(flag, idx, sub_idx); \ + reportFlagChange(flag, sub_idx); \ + \ + return ret; \ + } + +#define SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(FUNCTION_NAME, GET_INDEX_FN, ARG_VALUE_TYPE) \ + bool FUNCTION_NAME(ARG_VALUE_TYPE value, const sead::SafeString& name, s32 sub_idx, \ + bool check_permissions, bool, bool bypass_one_trigger_check) { \ + return FUNCTION_NAME(value, GET_INDEX_FN(name), sub_idx, check_permissions, \ + bypass_one_trigger_check); \ + } + +SET_FLAG_VALUE_IMPL_(TriggerParam::setBool, bool, mBoolFlags, bool, value) + +void TriggerParam::recordFlagChange(const FlagBase* flag, s32 idx, s32 sub_idx) { const auto core = sead::CoreInfo::getCurrentCoreId(); const u32 platform_core_id = sead::CoreInfo::getPlatformCoreId(core); @@ -904,6 +1210,214 @@ void TriggerParam::recordFlagChange(const FlagBase* flag, s32 idx, s16 sub_idx) mBitFlags.ref().set(BitFlag::_8); } +SET_FLAG_VALUE_IMPL_(TriggerParam::setS32, s32, mS32Flags, s32, value) +SET_FLAG_VALUE_IMPL_(TriggerParam::setF32, f32, mF32Flags, f32, value) +SET_FLAG_VALUE_IMPL_(TriggerParam::setStr, const char*, mStringFlags, sead::FixedSafeString<32>, + sead::FixedSafeString<32>(value)) +SET_FLAG_VALUE_IMPL_(TriggerParam::setStr64, const char*, mString64Flags, sead::FixedSafeString<64>, + sead::FixedSafeString<64>(value)) +SET_FLAG_VALUE_IMPL_(TriggerParam::setStr256, const char*, mString256Flags, + sead::FixedSafeString<256>, sead::FixedSafeString<256>(value)) +SET_FLAG_VALUE_IMPL_(TriggerParam::setVec2f, const sead::Vector2f&, mVector2fFlags, sead::Vector2f, + value) +SET_FLAG_VALUE_IMPL_(TriggerParam::setVec3f, const sead::Vector3f&, mVector3fFlags, sead::Vector3f, + value) +SET_FLAG_VALUE_IMPL_(TriggerParam::setVec4f, const sead::Vector4f&, mVector4fFlags, sead::Vector4f, + value) + +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setBool, getBoolIdx, bool) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setS32, getS32Idx, s32) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setF32, getF32Idx, f32) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setStr, getStrIdx, const char*) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setStr64, getStr64Idx, const char*) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setStr256, getStr256Idx, const char*) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec2f, getVec2fIdx, const sead::Vector2f&) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec3f, getVec3fIdx, const sead::Vector3f&) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec4f, getVec4fIdx, const sead::Vector4f&) + +SET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setBool, bool, mBoolArrayFlags, bool, value) +SET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setS32, s32, mS32ArrayFlags, s32, value) +SET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setF32, f32, mF32ArrayFlags, f32, value) +SET_STRING_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setStr, mStringArrayFlags, + sead::FixedSafeString<32>) +SET_STRING_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setStr64, mString64ArrayFlags, + sead::FixedSafeString<64>) +SET_STRING_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setStr256, mString256ArrayFlags, + sead::FixedSafeString<256>) +SET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setVec2f, const sead::Vector2f&, mVector2fArrayFlags, + sead::Vector2f, value) +SET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setVec3f, const sead::Vector3f&, mVector3fArrayFlags, + sead::Vector3f, value) +SET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setVec4f, const sead::Vector4f&, mVector4fArrayFlags, + sead::Vector4f, value) + +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setBool, getBoolArrayIdx, bool) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setS32, getS32ArrayIdx, s32) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setF32, getF32ArrayIdx, f32) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setStr, getStrArrayIdx, const char*) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setStr64, getStr64ArrayIdx, const char*) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setStr256, getStr256ArrayIdx, const char*) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec2f, getVec2fArrayIdx, const sead::Vector2f&) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec3f, getVec3fArrayIdx, const sead::Vector3f&) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec4f, getVec4fArrayIdx, const sead::Vector4f&) + +#define RESET_FLAG_VALUE_IMPL_(FUNCTION_NAME, FLAGS, T) \ + bool FUNCTION_NAME(s32 idx, bool check_permissions) { \ + auto* flag = getFlagByIndexBase(FLAGS, idx); \ + if (!flag) \ + return false; \ + \ + if (check_permissions && !flag->isProgramWritable()) \ + return false; \ + \ + if (flag->isInitialValue()) \ + return true; \ + \ + flag->resetToInitialValue(); \ + recordFlagChange(FLAGS[idx], idx); \ + reportFlagChange(FLAGS[idx]); \ + \ + return true; \ + } + +#define RESET_FLAG_VALUE_BY_KEY_IMPL_(FUNCTION_NAME, FLAGS, GET_IDX_FN) \ + bool FUNCTION_NAME(const sead::SafeString& name, bool check_permissions) { \ + return FUNCTION_NAME(GET_IDX_FN(name), check_permissions); \ + } + +#define RESET_ARRAY_FLAG_VALUE_IMPL_(FUNCTION_NAME, ARRAYS, T) \ + bool FUNCTION_NAME(s32 idx, s32 sub_idx, bool check_permissions) { \ + if (idx < 0 || idx >= ARRAYS.size()) \ + return false; \ + \ + const auto* array = ARRAYS[idx]; \ + if (!array) \ + return false; \ + \ + auto* flag = getFlagByIndexBase(*array, sub_idx); \ + if (!flag) \ + return false; \ + \ + if (check_permissions && !flag->isProgramWritable()) \ + return false; \ + \ + if (flag->isInitialValue()) \ + return true; \ + \ + flag->resetToInitialValue(); \ + const auto* flag_ = [&] { return ARRAYS.at(idx)->at(sub_idx); }(); \ + recordFlagChange(flag_, idx, sub_idx); \ + reportFlagChange(flag_, sub_idx); \ + \ + return true; \ + } + +#define RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(FUNCTION_NAME, FLAGS, GET_IDX_FN) \ + bool FUNCTION_NAME(const sead::SafeString& name, s32 sub_idx, bool check_permissions) { \ + return FUNCTION_NAME(GET_IDX_FN(name), sub_idx, check_permissions); \ + } + +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetBool, mBoolFlags, bool) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetS32, mS32Flags, s32) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetF32, mF32Flags, f32) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetStr, mStringFlags, sead::FixedSafeString<32>) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetStr64, mString64Flags, sead::FixedSafeString<64>) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetStr256, mString256Flags, sead::FixedSafeString<256>) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetVec2f, mVector2fFlags, sead::Vector2f) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetVec3f, mVector3fFlags, sead::Vector3f) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetVec4f, mVector4fFlags, sead::Vector4f) + +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetBool, mBoolFlags, getBoolIdx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetS32, mS32Flags, getS32Idx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetF32, mF32Flags, getF32Idx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetStr, mStringFlags, getStrIdx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetStr64, mString64Flags, getStr64Idx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetStr256, mString256Flags, getStr256Idx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetVec2f, mVector2fFlags, getVec2fIdx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetVec3f, mVector3fFlags, getVec3fIdx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetVec4f, mVector4fFlags, getVec4fIdx) + +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetBool, mBoolArrayFlags, bool) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetS32, mS32ArrayFlags, s32) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetF32, mF32ArrayFlags, f32) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetStr, mStringArrayFlags, sead::FixedSafeString<32>) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetStr64, mString64ArrayFlags, + sead::FixedSafeString<64>) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetStr256, mString256ArrayFlags, + sead::FixedSafeString<256>) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetVec2f, mVector2fArrayFlags, sead::Vector2f) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetVec3f, mVector3fArrayFlags, sead::Vector3f) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetVec4f, mVector4fArrayFlags, sead::Vector4f) + +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetBool, mBoolArrayFlags, getBoolArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetS32, mS32ArrayFlags, getS32ArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetF32, mF32ArrayFlags, getF32ArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetStr, mStringArrayFlags, getStrArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetStr64, mString64ArrayFlags, getStr64ArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetStr256, mString256ArrayFlags, + getStr256ArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetVec2f, mVector2fArrayFlags, getVec2fArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetVec3f, mVector3fArrayFlags, getVec3fArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetVec4f, mVector4fArrayFlags, getVec4fArrayIdx) + +void TriggerParam::resetAllFlagsToInitialValues() { + for (s32 i = 0; i < mBoolFlags.size(); ++i) + resetBool(i, false); + for (s32 i = 0; i < mS32Flags.size(); ++i) + resetS32(i, false); + for (s32 i = 0; i < mF32Flags.size(); ++i) + resetF32(i, false); + for (s32 i = 0; i < mStringFlags.size(); ++i) + resetStr(i, false); + for (s32 i = 0; i < mString64Flags.size(); ++i) + resetStr64(i, false); + for (s32 i = 0; i < mString256Flags.size(); ++i) + resetStr256(i, false); + for (s32 i = 0; i < mVector2fFlags.size(); ++i) + resetVec2f(i, false); + for (s32 i = 0; i < mVector3fFlags.size(); ++i) + resetVec3f(i, false); + for (s32 i = 0; i < mVector4fFlags.size(); ++i) + resetVec4f(i, false); + + for (s32 i = 0; i < mBoolArrayFlags.size(); ++i) { + for (s32 j = 0; j < mBoolArrayFlags[i]->size(); ++j) + resetBool(i, j, false); + } + for (s32 i = 0; i < mS32ArrayFlags.size(); ++i) { + for (s32 j = 0; j < mS32ArrayFlags[i]->size(); ++j) + resetS32(i, j, false); + } + for (s32 i = 0; i < mF32ArrayFlags.size(); ++i) { + for (s32 j = 0; j < mF32ArrayFlags[i]->size(); ++j) + resetF32(i, j, false); + } + for (s32 i = 0; i < mStringArrayFlags.size(); ++i) { + for (s32 j = 0; j < mStringArrayFlags[i]->size(); ++j) + resetStr(i, j, false); + } + for (s32 i = 0; i < mString64ArrayFlags.size(); ++i) { + for (s32 j = 0; j < mString64ArrayFlags[i]->size(); ++j) + resetStr64(i, j, false); + } + for (s32 i = 0; i < mString256ArrayFlags.size(); ++i) { + for (s32 j = 0; j < mString256ArrayFlags[i]->size(); ++j) + resetStr256(i, j, false); + } + for (s32 i = 0; i < mVector2fArrayFlags.size(); ++i) { + for (s32 j = 0; j < mVector2fArrayFlags[i]->size(); ++j) + resetVec2f(i, j, false); + } + for (s32 i = 0; i < mVector3fArrayFlags.size(); ++i) { + for (s32 j = 0; j < mVector3fArrayFlags[i]->size(); ++j) + resetVec3f(i, j, false); + } + for (s32 i = 0; i < mVector4fArrayFlags.size(); ++i) { + for (s32 j = 0; j < mVector4fArrayFlags[i]->size(); ++j) + resetVec4f(i, j, false); + } +} + s32 TriggerParam::getBoolIdx(u32 name) const { return getFlagIndex(mBoolFlags, name); } @@ -976,6 +1490,82 @@ s32 TriggerParam::getVec4fArrayIdx(u32 name) const { return getFlagIndex(mVector4fArrayFlags, name); } +FlagBool* TriggerParam::getBoolFlag(s32 idx) const { + return static_cast(mBoolFlags[idx]); +} + +FlagS32* TriggerParam::getS32Flag(s32 idx) const { + return static_cast(mS32Flags[idx]); +} + +FlagF32* TriggerParam::getF32Flag(s32 idx) const { + return static_cast(mF32Flags[idx]); +} + +FlagString* TriggerParam::getStrFlag(s32 idx) const { + return static_cast(mStringFlags[idx]); +} + +FlagString64* TriggerParam::getStr64Flag(s32 idx) const { + return static_cast(mString64Flags[idx]); +} + +FlagString256* TriggerParam::getStr256Flag(s32 idx) const { + return static_cast(mString256Flags[idx]); +} + +FlagVector2f* TriggerParam::getVec2fFlag(s32 idx) const { + return static_cast(mVector2fFlags[idx]); +} + +FlagVector3f* TriggerParam::getVec3fFlag(s32 idx) const { + return static_cast(mVector3fFlags[idx]); +} + +FlagVector4f* TriggerParam::getVec4fFlag(s32 idx) const { + return static_cast(mVector4fFlags[idx]); +} + +FlagBool* TriggerParam::getBoolFlag(s32 idx, s32 sub_idx) const { + return static_cast(mBoolArrayFlags[idx]->at(sub_idx)); +} + +FlagS32* TriggerParam::getS32Flag(s32 idx, s32 sub_idx) const { + return static_cast(mS32ArrayFlags[idx]->at(sub_idx)); +} + +FlagF32* TriggerParam::getF32Flag(s32 idx, s32 sub_idx) const { + return static_cast(mF32ArrayFlags[idx]->at(sub_idx)); +} + +FlagString* TriggerParam::getStrFlag(s32 idx, s32 sub_idx) const { + return static_cast(mStringArrayFlags[idx]->at(sub_idx)); +} + +FlagString64* TriggerParam::getStr64Flag(s32 idx, s32 sub_idx) const { + return static_cast(mString64ArrayFlags[idx]->at(sub_idx)); +} + +FlagString256* TriggerParam::getStr256Flag(s32 idx, s32 sub_idx) const { + return static_cast(mString256ArrayFlags[idx]->at(sub_idx)); +} + +FlagVector2f* TriggerParam::getVec2fFlag(s32 idx, s32 sub_idx) const { + return static_cast(mVector2fArrayFlags[idx]->at(sub_idx)); +} + +FlagVector3f* TriggerParam::getVec3fFlag(s32 idx, s32 sub_idx) const { + return static_cast(mVector3fArrayFlags[idx]->at(sub_idx)); +} + +FlagVector4f* TriggerParam::getVec4fFlag(s32 idx, s32 sub_idx) const { + return static_cast(mVector4fArrayFlags[idx]->at(sub_idx)); +} + +void TriggerParam::onResetBoolFlagForRadarMgr(FlagBase* flag, s32 sub_idx) { + reportFlagChange(flag, sub_idx); +} + void TriggerParam::setCurrentRupeeFlagName(const sead::SafeString& name) { if (sConfig.num_current_rupee_flag_name_changes <= 0) { sConfig.getCurrentRupeeFlagName() = name; diff --git a/src/KingSystem/GameData/gdtTriggerParam.h b/src/KingSystem/GameData/gdtTriggerParam.h index b307d499..c98b3b9d 100644 --- a/src/KingSystem/GameData/gdtTriggerParam.h +++ b/src/KingSystem/GameData/gdtTriggerParam.h @@ -225,9 +225,170 @@ public: bool getMinValueForS32(s32* min, const sead::SafeString& name) const; bool getMaxValueForS32(s32* max, const sead::SafeString& name) const; + // region Value setters + + bool setBool(bool value, s32 idx, bool check_permissions, bool bypass_one_trigger_check); + bool setS32(s32 value, s32 idx, bool check_permissions, bool bypass_one_trigger_check); + bool setF32(f32 value, s32 idx, bool check_permissions, bool bypass_one_trigger_check); + bool setStr(const char* value, s32 idx, bool check_permissions, bool bypass_one_trigger_check); + bool setStr64(const char* value, s32 idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setStr256(const char* value, s32 idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setVec2f(const sead::Vector2f& value, s32 idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setVec3f(const sead::Vector3f& value, s32 idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setVec4f(const sead::Vector4f& value, s32 idx, bool check_permissions, + bool bypass_one_trigger_check); + + bool setBool(bool value, const sead::SafeString& name, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setS32(s32 value, const sead::SafeString& name, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setF32(f32 value, const sead::SafeString& name, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setStr(const char* value, const sead::SafeString& name, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setStr64(const char* value, const sead::SafeString& name, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setStr256(const char* value, const sead::SafeString& name, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setVec2f(const sead::Vector2f& value, const sead::SafeString& name, bool check_permissions, + bool, bool bypass_one_trigger_check); + bool setVec3f(const sead::Vector3f& value, const sead::SafeString& name, bool check_permissions, + bool, bool bypass_one_trigger_check); + bool setVec4f(const sead::Vector4f& value, const sead::SafeString& name, bool check_permissions, + bool, bool bypass_one_trigger_check); + + // endregion + + // region Value setters (array) + + bool setBool(bool value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setS32(s32 value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setF32(f32 value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setStr(const char* value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setStr64(const char* value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setStr256(const char* value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setVec2f(const sead::Vector2f& value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setVec3f(const sead::Vector3f& value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setVec4f(const sead::Vector4f& value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + + bool setBool(bool value, const sead::SafeString& name, s32 sub_idx, bool check_permissions, + bool, bool bypass_one_trigger_check); + bool setS32(s32 value, const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setF32(f32 value, const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setStr(const char* value, const sead::SafeString& name, s32 sub_idx, + bool check_permissions, bool, bool bypass_one_trigger_check); + bool setStr64(const char* value, const sead::SafeString& name, s32 sub_idx, + bool check_permissions, bool, bool bypass_one_trigger_check); + bool setStr256(const char* value, const sead::SafeString& name, s32 sub_idx, + bool check_permissions, bool, bool bypass_one_trigger_check); + bool setVec2f(const sead::Vector2f& value, const sead::SafeString& name, s32 sub_idx, + bool check_permissions, bool, bool bypass_one_trigger_check); + bool setVec3f(const sead::Vector3f& value, const sead::SafeString& name, s32 sub_idx, + bool check_permissions, bool, bool bypass_one_trigger_check); + bool setVec4f(const sead::Vector4f& value, const sead::SafeString& name, s32 sub_idx, + bool check_permissions, bool, bool bypass_one_trigger_check); + + // endregion + + // region Resetting values + + bool resetBool(s32 idx, bool check_permissions); + bool resetS32(s32 idx, bool check_permissions); + bool resetF32(s32 idx, bool check_permissions); + bool resetStr(s32 idx, bool check_permissions); + bool resetStr64(s32 idx, bool check_permissions); + bool resetStr256(s32 idx, bool check_permissions); + bool resetVec2f(s32 idx, bool check_permissions); + bool resetVec3f(s32 idx, bool check_permissions); + bool resetVec4f(s32 idx, bool check_permissions); + + bool resetBool(const sead::SafeString& name, bool check_permissions); + bool resetS32(const sead::SafeString& name, bool check_permissions); + bool resetF32(const sead::SafeString& name, bool check_permissions); + bool resetStr(const sead::SafeString& name, bool check_permissions); + bool resetStr64(const sead::SafeString& name, bool check_permissions); + bool resetStr256(const sead::SafeString& name, bool check_permissions); + bool resetVec2f(const sead::SafeString& name, bool check_permissions); + bool resetVec3f(const sead::SafeString& name, bool check_permissions); + bool resetVec4f(const sead::SafeString& name, bool check_permissions); + + // endregion + + // region Resetting values (array) + + bool resetBool(s32 idx, s32 sub_idx, bool check_permissions); + bool resetS32(s32 idx, s32 sub_idx, bool check_permissions); + bool resetF32(s32 idx, s32 sub_idx, bool check_permissions); + bool resetStr(s32 idx, s32 sub_idx, bool check_permissions); + bool resetStr64(s32 idx, s32 sub_idx, bool check_permissions); + bool resetStr256(s32 idx, s32 sub_idx, bool check_permissions); + bool resetVec2f(s32 idx, s32 sub_idx, bool check_permissions); + bool resetVec3f(s32 idx, s32 sub_idx, bool check_permissions); + bool resetVec4f(s32 idx, s32 sub_idx, bool check_permissions); + + bool resetBool(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetS32(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetF32(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetStr(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetStr64(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetStr256(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetVec2f(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetVec3f(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetVec4f(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + + // endregion + + void resetAllFlagsToInitialValues(); + + // region Flag getters + + FlagBool* getBoolFlag(s32 idx) const; + FlagS32* getS32Flag(s32 idx) const; + FlagF32* getF32Flag(s32 idx) const; + FlagString* getStrFlag(s32 idx) const; + FlagString64* getStr64Flag(s32 idx) const; + FlagString256* getStr256Flag(s32 idx) const; + FlagVector2f* getVec2fFlag(s32 idx) const; + FlagVector3f* getVec3fFlag(s32 idx) const; + FlagVector4f* getVec4fFlag(s32 idx) const; + + // endregion + + // region Flag getters (array) + + FlagBool* getBoolFlag(s32 idx, s32 sub_idx) const; + FlagS32* getS32Flag(s32 idx, s32 sub_idx) const; + FlagF32* getF32Flag(s32 idx, s32 sub_idx) const; + FlagString* getStrFlag(s32 idx, s32 sub_idx) const; + FlagString64* getStr64Flag(s32 idx, s32 sub_idx) const; + FlagString256* getStr256Flag(s32 idx, s32 sub_idx) const; + FlagVector2f* getVec2fFlag(s32 idx, s32 sub_idx) const; + FlagVector3f* getVec3fFlag(s32 idx, s32 sub_idx) const; + FlagVector4f* getVec4fFlag(s32 idx, s32 sub_idx) const; + + // endregion + + void onResetBoolFlagForRadarMgr(FlagBase* flag, s32 sub_idx = -1); + private: enum class BitFlag : u8 { _8 = 8, + EventAssociatedFlagModified = 0x10, }; void allocCombinedFlagArrays(sead::Heap* heap); @@ -235,7 +396,7 @@ private: void initResetData(sead::Heap* heap); void initRevivalRandomBools(sead::Heap* heap); - void recordFlagChange(const FlagBase* flag, s32 idx, s16 sub_idx); + void recordFlagChange(const FlagBase* flag, s32 idx, s32 sub_idx = -1); u32 mResourceFlags = 0;