falso
/
botw
mirror of https://github.com/zeldaret/botw.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ksys/gdt: Implement more parts of TriggerParam (notably setters)

This commit is contained in:
Léo Lam 2020-10-25 18:06:13 +01:00
parent fd9b8ad11d
commit abf3276642
No known key found for this signature in database
GPG Key ID: 0DF30F9081000741
4 changed files with 846 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

171
data/uking_functions.csv
View File

@ -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

Can't render this file because it is too large.

2
lib/sead

@ -1 +1 @@
Subproject commit e0f91577f3df97c41f4a91493dc06b208387963b
Subproject commit 7127999dca9335ddfbd28c81bccb8d368b706c8a

598
src/KingSystem/GameData/gdtTriggerParam.cpp
View File

@ -1,8 +1,11 @@
#include "KingSystem/GameData/gdtTriggerParam.h"
#include <algorithm>
#include <devenv/seadStackTrace.h>
#include <mc/seadCoreInfo.h>
#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<sead::PtrArray<FlagBase>>& flags, u
return -1;
}
template <typename T>
inline Flag<T>* getFlagByIndex(const sead::PtrArray<FlagBase>& flags, s32 index) {
inline FlagBase* getFlagByIndexBase(const sead::PtrArray<FlagBase>& flags, s32 index) {
if (index < 0 || index >= flags.size())
return nullptr;
return static_cast<Flag<T>*>(flags[index]);
return flags[index];
}
template <typename T>
inline Flag<T>* getFlagByIndex(const sead::PtrArray<FlagBase>& flags, s32 index) {
return static_cast<Flag<T>*>(getFlagByIndexBase(flags, index));
}
template <typename T>
@ -147,6 +154,219 @@ inline bool getFlagValue(const sead::PtrArray<sead::PtrArray<FlagBase>>& 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 <typename T>
bool doSetFlagValue(bool* success, const T& value, const sead::PtrArray<FlagBase>& flags, s32 idx,
bool check_permissions, bool bypass_one_trigger_check) {
*success = false;
auto* flag = getFlagByIndex<T>(flags, idx);
if (!flag)
return false;
if (check_permissions && !flags[idx]->isProgramWritable())
return false;
if constexpr (IsAnyOfType<T, s32, f32>()) {
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<const FlagBool*>(flag)->getValue())
value_str.format("true");
else
value_str.format("false");
break;
case FlagType::S32:
case FlagType::S32Array:
value_str.format("%d", static_cast<const FlagS32*>(flag)->getValue());
break;
case FlagType::F32:
case FlagType::F32Array:
value_str.format("%f", static_cast<const FlagF32*>(flag)->getValue());
break;
case FlagType::String:
case FlagType::StringArray:
value_str.format("%s", static_cast<const FlagString*>(flag)->getValueRef().cstr());
break;
case FlagType::String64:
case FlagType::String64Array:
value_str.format("%s",
static_cast<const FlagString64*>(flag)->getValueRef().cstr());
break;
case FlagType::String256:
case FlagType::String256Array:
value_str.format("%s",
static_cast<const FlagString256*>(flag)->getValueRef().cstr());
break;
case FlagType::Vector2f:
case FlagType::Vector2fArray: {
const auto& vector = static_cast<const FlagVector2f*>(flag)->getValueRef();
value_str.format("%f %f", vector.x, vector.y);
break;
}
case FlagType::Vector3f:
case FlagType::Vector3fArray: {
const auto& vector = static_cast<const FlagVector3f*>(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<const FlagVector4f*>(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 <typename T>
void reportFlagChange(const FlagBase* flag, s32 sub_idx = -1) {
auto* flag_ = static_cast<const Flag<T>*>(flag);
const sead::SafeString& name = flag->getName();
const FlagType type = flag->getType();
if constexpr (std::is_same<T, bool>()) {
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<T, bool>()) {
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<const FlagBool*>(flag)->getValue())
value_str.format("true");
else
value_str.format("false");
break;
case FlagType::S32:
case FlagType::S32Array:
value_str.format("%d", static_cast<const FlagS32*>(flag)->getValue());
break;
case FlagType::F32:
case FlagType::F32Array:
value_str.format("%f", static_cast<const FlagF32*>(flag)->getValue());
break;
case FlagType::String:
case FlagType::StringArray:
value_str.format("%s", static_cast<const FlagString*>(flag)->getValueRef().cstr());
break;
case FlagType::String64:
case FlagType::String64Array:
value_str.format("%s", static_cast<const FlagString64*>(flag)->getValueRef().cstr());
break;
case FlagType::String256:
case FlagType::String256Array:
value_str.format("%s", static_cast<const FlagString256*>(flag)->getValueRef().cstr());
break;
case FlagType::Vector2f:
case FlagType::Vector2fArray: {
const auto& vector = static_cast<const FlagVector2f*>(flag)->getValueRef();
value_str.format("%f %f", vector.x, vector.y);
break;
}
case FlagType::Vector3f:
case FlagType::Vector3fArray: {
const auto& vector = static_cast<const FlagVector3f*>(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<const FlagVector4f*>(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<void>(getFlagColor(type));
sConfig.index = sConfig.index >= 32 ? 0 : sConfig.index + 1;
}
bool getFlagArraySize(const sead::PtrArray<sead::PtrArray<FlagBase>>& 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<T>(&success, VALUE, FLAGS, idx, check_permissions, \
bypass_one_trigger_check); \
if (!success) \
return ret; \
\
recordFlagChange(FLAGS[idx], idx); \
reportFlagChange<T>(FLAGS[idx]); \
\
if constexpr (std::is_same<T, bool>()) { \
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<T>(&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<T>(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<T>(&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<T>(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<T>(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<T>(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<FlagBool*>(mBoolFlags[idx]);
}
FlagS32* TriggerParam::getS32Flag(s32 idx) const {
return static_cast<FlagS32*>(mS32Flags[idx]);
}
FlagF32* TriggerParam::getF32Flag(s32 idx) const {
return static_cast<FlagF32*>(mF32Flags[idx]);
}
FlagString* TriggerParam::getStrFlag(s32 idx) const {
return static_cast<FlagString*>(mStringFlags[idx]);
}
FlagString64* TriggerParam::getStr64Flag(s32 idx) const {
return static_cast<FlagString64*>(mString64Flags[idx]);
}
FlagString256* TriggerParam::getStr256Flag(s32 idx) const {
return static_cast<FlagString256*>(mString256Flags[idx]);
}
FlagVector2f* TriggerParam::getVec2fFlag(s32 idx) const {
return static_cast<FlagVector2f*>(mVector2fFlags[idx]);
}
FlagVector3f* TriggerParam::getVec3fFlag(s32 idx) const {
return static_cast<FlagVector3f*>(mVector3fFlags[idx]);
}
FlagVector4f* TriggerParam::getVec4fFlag(s32 idx) const {
return static_cast<FlagVector4f*>(mVector4fFlags[idx]);
}
FlagBool* TriggerParam::getBoolFlag(s32 idx, s32 sub_idx) const {
return static_cast<FlagBool*>(mBoolArrayFlags[idx]->at(sub_idx));
}
FlagS32* TriggerParam::getS32Flag(s32 idx, s32 sub_idx) const {
return static_cast<FlagS32*>(mS32ArrayFlags[idx]->at(sub_idx));
}
FlagF32* TriggerParam::getF32Flag(s32 idx, s32 sub_idx) const {
return static_cast<FlagF32*>(mF32ArrayFlags[idx]->at(sub_idx));
}
FlagString* TriggerParam::getStrFlag(s32 idx, s32 sub_idx) const {
return static_cast<FlagString*>(mStringArrayFlags[idx]->at(sub_idx));
}
FlagString64* TriggerParam::getStr64Flag(s32 idx, s32 sub_idx) const {
return static_cast<FlagString64*>(mString64ArrayFlags[idx]->at(sub_idx));
}
FlagString256* TriggerParam::getStr256Flag(s32 idx, s32 sub_idx) const {
return static_cast<FlagString256*>(mString256ArrayFlags[idx]->at(sub_idx));
}
FlagVector2f* TriggerParam::getVec2fFlag(s32 idx, s32 sub_idx) const {
return static_cast<FlagVector2f*>(mVector2fArrayFlags[idx]->at(sub_idx));
}
FlagVector3f* TriggerParam::getVec3fFlag(s32 idx, s32 sub_idx) const {
return static_cast<FlagVector3f*>(mVector3fArrayFlags[idx]->at(sub_idx));
}
FlagVector4f* TriggerParam::getVec4fFlag(s32 idx, s32 sub_idx) const {
return static_cast<FlagVector4f*>(mVector4fArrayFlags[idx]->at(sub_idx));
}
void TriggerParam::onResetBoolFlagForRadarMgr(FlagBase* flag, s32 sub_idx) {
reportFlagChange<bool>(flag, sub_idx);
}
void TriggerParam::setCurrentRupeeFlagName(const sead::SafeString& name) {
if (sConfig.num_current_rupee_flag_name_changes <= 0) {
sConfig.getCurrentRupeeFlagName() = name;

163
src/KingSystem/GameData/gdtTriggerParam.h
View File

@ -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;