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 Manager functions

This commit is contained in:
Léo Lam 2021-04-03 12:57:11 +02:00
parent 1b280ba633
commit 62181dd4db
No known key found for this signature in database
GPG Key ID: 0DF30F9081000741
7 changed files with 786 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
data/uking_functions.csv
View File

@ -241,7 +241,7 @@
0x0000007100004194,DamageMgrBow::m52,8,
0x000000710000419c,DamageMgrBow::m53,8,
0x00000071000041a4,nullsub_40,4,
0x00000071000041a8,_ZN4sead19FixedSafeStringBaseIcLi64EED0Ev,8,
0x00000071000041a8,x,8,
0x00000071000041b0,sub_71000041B0,372,
0x0000007100004324,_ZNK4sead15RuntimeTypeInfo6DeriveINS_13ControlDeviceEE9isDerivedEPKNS0_9InterfaceE,140,
0x00000071000043b0,sub_71000043B0,140,
@ -395,10 +395,10 @@
0x000000710000a9dc,sub_710000A9DC,40,
0x000000710000aa04,sub_710000AA04,8,
0x000000710000aa0c,_ZThn8_N3agl6detail20GPUMemBlockMgrHeapExD0Ev,40,
0x000000710000aa34,j__ZdlPv_1,4,
0x000000710000aa38,sead::SafeStringX::assign,240,
0x000000710000ab28,j__ZdlPv_2,4,
0x000000710000ab2c,_ZN4sead15FixedSafeStringILi64EEaSERKNS_14SafeStringBaseIcEE,240,
0x000000710000aa34,j__ZdlPv_1,4,_ZN4sead15FixedSafeStringILi64EED0Ev
0x000000710000aa38,sead::SafeStringX::assign,240,_ZN4sead15FixedSafeStringILi64EEaSERKNS_14SafeStringBaseIcEE
0x000000710000ab28,j__ZdlPv_2,4,_ZN4sead19FixedSafeStringBaseIcLi64EED0Ev
0x000000710000ab2c,_ZN4sead19FixedSafeStringBaseIcLi64EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead19FixedSafeStringBaseIcLi64EEaSERKNS_14SafeStringBaseIcEE
0x000000710000ac1c,j__ZdlPv_3,4,
0x000000710000ac20,sub_710000AC20,140,
0x000000710000acac,sub_710000ACAC,372,
@ -437,7 +437,7 @@
0x000000710000ded8,sub_710000DED8,1412,
0x000000710000e45c,Dragon::m78,164,
0x000000710000e500,sub_710000E500,756,
0x000000710000e7f4,_ZN4sead15FixedSafeStringILi128EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead15FixedSafeStringILi16EEaSERKNS_14SafeStringBaseIcEE
0x000000710000e7f4,xxx,240,_ZN4sead15FixedSafeStringILi16EEaSERKNS_14SafeStringBaseIcEE
0x000000710000e8e4,sub_710000E8E4,420,
0x000000710000ea88,sub_710000EA88,456,
0x000000710000ec50,sub_710000EC50,84,
@ -490,8 +490,8 @@
0x0000007100011f30,sub_7100011F30,200,
0x0000007100011ff8,sub_7100011FF8,192,
0x00000071000120b8,sub_71000120B8,200,
0x0000007100012180,j__ZdlPv_4,4,
0x0000007100012184,_ZN4sead15FixedSafeStringILi20EEaSERKNS_14SafeStringBaseIcEE_0,240,
0x0000007100012180,j__ZdlPv_4,4,_ZN4sead15FixedSafeStringILi32EED0Ev
0x0000007100012184,_ZN4sead15FixedSafeStringILi32EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead15FixedSafeStringILi32EEaSERKNS_14SafeStringBaseIcEE
0x0000007100012274,sub_7100012274,20,
0x0000007100012288,j__ZdlPv_5,4,
0x000000710001228c,sub_710001228C,8,
@ -504,8 +504,8 @@
0x000000710001260c,j__ZdlPv_6,4,_ZN4sead15FixedSafeStringILi16EED0Ev
0x0000007100012610,_ZNK4sead14SafeStringBaseIcE9findIndexERKS1_,468,_ZNK4sead14SafeStringBaseIcE9findIndexERKS1_
0x00000071000127e4,_ZN4sead18Matrix34CalcCommonIfE7inverseERNS_9BaseMtx34IfEERKS3_,336,
0x0000007100012934,j__ZdlPv_7,4,
0x0000007100012938,xxxx,240,
0x0000007100012934,j__ZdlPv_7,4,_ZN4sead21FormatFixedSafeStringILi128EED0Ev
0x0000007100012938,_ZN4sead15FixedSafeStringILi128EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead15FixedSafeStringILi128EEaSERKNS_14SafeStringBaseIcEE
0x0000007100012a28,sub_7100012A28,600,
0x0000007100012c80,Enemy::construct,68,
0x0000007100012cc4,sub_7100012CC4,44,
@ -619,7 +619,7 @@
0x000000710001b1b8,nullsub_53,4,
0x000000710001b1bc,_ZNK4sead15RuntimeTypeInfo6DeriveINS_6CameraEE9isDerivedEPKNS0_9InterfaceE,140,
0x000000710001b248,j__ZdlPv_11,4,
0x000000710001b24c,_ZN4sead19FixedSafeStringBaseIcLi64EEaSERKNS_14SafeStringBaseIcEE,240,
0x000000710001b24c,x,240,
0x000000710001b33c,sub_710001B33C,88,
0x000000710001b394,sub_710001B394,96,
0x000000710001b3f4,sub_710001B3F4,40,
@ -2393,10 +2393,10 @@
0x000000710007fd84,_ZN4sead10FileHandleD0Ev,64,_ZN4sead10FileHandleD0Ev
0x000000710007fdc4,sub_710007FDC4,140,
0x000000710007fe50,sub_710007FE50,372,
0x000000710007ffc4,j__ZdlPv_29,4,
0x000000710007ffc8,_ZN4sead19FixedSafeStringBaseIcLi128EEaSERKNS_14SafeStringBaseIcEE,240,
0x00000071000800b8,j__ZdlPv_30,4,
0x00000071000800bc,_ZN4sead15FixedSafeStringILi256EEaSERKNS_14SafeStringBaseIcEE,240,
0x000000710007ffc4,j__ZdlPv_29,4,_ZN4sead15FixedSafeStringILi256EED0Ev
0x000000710007ffc8,_ZN4sead15FixedSafeStringIcLi256EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead15FixedSafeStringILi256EEaSERKNS_14SafeStringBaseIcEE
0x00000071000800b8,j__ZdlPv_30,4,_ZN4sead19FixedSafeStringBaseIcLi256EED0Ev
0x00000071000800bc,_ZN4sead19FixedSafeStringBaseIcLi256EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead19FixedSafeStringBaseIcLi256EEaSERKNS_14SafeStringBaseIcEE
0x00000071000801ac,_ZN4sead18HeapSafeStringBaseIcED0Ev,60,
0x00000071000801e8,j__ZdlPv_31,4,
0x00000071000801ec,_ZN4sead15FixedSafeStringILi32EEaSERKNS_14SafeStringBaseIcEE,240,
@ -6792,8 +6792,8 @@
0x000000710011ffbc,_ZNK5uking6action28EventPlayUiOneTimeAnimAction27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE,288,_ZNK5uking6action28EventPlayUiOneTimeAnimAction27checkDerivedRuntimeTypeInfoEPKN4sead15RuntimeTypeInfo9InterfaceE
0x00000071001200dc,_ZNK5uking6action28EventPlayUiOneTimeAnimAction18getRuntimeTypeInfoEv,92,_ZNK5uking6action28EventPlayUiOneTimeAnimAction18getRuntimeTypeInfoEv
0x0000007100120138,j__ZdlPv_46,4,
0x000000710012013c,j__ZdlPv_47,4,
0x0000007100120140,_ZN4sead19FixedSafeStringBaseIcLi155EEaSERKNS_14SafeStringBaseIcEE,240,
0x000000710012013c,j__ZdlPv_47,4,_ZN4sead19FixedSafeStringBaseIcLi32EED0Ev
0x0000007100120140,_ZN4sead19FixedSafeStringBaseIcLi32EEaSERKNS_14SafeStringBaseIcEE,240,_ZN4sead19FixedSafeStringBaseIcLi32EEaSERKNS_14SafeStringBaseIcEE
0x0000007100120230,AI_Action_EventPlayUiOPTextAction::ctor,56,
0x0000007100120268,_ZN5uking6action23EventPlayUiOPTextActionD1Ev,20,_ZN5uking6action23EventPlayUiOPTextActionD1Ev
0x000000710012027c,_ZN5uking6action23EventPlayUiOPTextActionD0Ev,52,_ZN5uking6action23EventPlayUiOPTextActionD0Ev
@ -28503,7 +28503,7 @@
0x0000007100480840,j__ZdlPv_112,4,
0x0000007100480844,_ZN4sead15FixedSafeStringILi512EEaSERKNS_14SafeStringBaseIcEE,240,
0x0000007100480934,j__ZdlPv_113,4,
0x0000007100480938,_ZN4sead19FixedSafeStringBaseIcLi256EEaSERKNS_14SafeStringBaseIcEE,240,
0x0000007100480938,x,240,
0x0000007100480a28,AI_AI_LeaveFromTarget::ctor,52,_ZN5uking2ai15LeaveFromTargetC1ERKN4ksys3act2ai10ActionBase7InitArgE
0x0000007100480a5c,_ZN5uking2ai15LeaveFromTargetD1Ev,4,_ZN5uking2ai15LeaveFromTargetD1Ev
0x0000007100480a60,_ZN5uking2ai15LeaveFromTargetD0Ev,36,_ZN5uking2ai15LeaveFromTargetD0Ev
@ -76059,37 +76059,37 @@
0x0000007100dd2ba8,GameDataMgr::increaseInt,232,_ZN4ksys3gdt7Manager12incrementS32EiRKN4sead14SafeStringBaseIcEE
0x0000007100dd2c90,GameDataMgr::__auto1,72,_ZN4ksys3gdt7Manager13wasFlagCopiedERKN4sead14SafeStringBaseIcEE
0x0000007100dd2cd8,GameDataMgr::__auto6,72,_ZN4ksys3gdt7Manager16wasFlagNotCopiedERKN4sead14SafeStringBaseIcEE
0x0000007100dd2d20,GameDataMgr::copyParamToParam1,28,
0x0000007100dd2d3c,GameDataMgr::getBoolIdxForMapUnitObject,272,
0x0000007100dd2e4c,GameDataMgr::allocParam1,180,
0x0000007100dd2f00,getShopInfoByHash,140,
0x0000007100dd2d20,GameDataMgr::copyParamToParam1,28,_ZN4ksys3gdt7Manager17copyParamToParam1Ev
0x0000007100dd2d3c,GameDataMgr::getBoolIdxForMapUnitObject,272,_ZN4ksys3gdt7Manager20getRevivalFlagHandleERKN4sead14SafeStringBaseIcEERKNS_3map9MubinIterE
0x0000007100dd2e4c,GameDataMgr::allocParam1,180,_ZN4ksys3gdt7Manager11allocParam1Ev
0x0000007100dd2f00,getShopInfoByHash,140,_ZN4ksys3gdt7Manager15getShopInfoIterEjPN2al9ByamlIterERKS3_PKj
0x0000007100dd2f8c,GameDataMgr::resetBoolFlagForRadarMgr,208,
0x0000007100dd305c,allocRetryBuffer,176,
0x0000007100dd310c,GameDataMgr::destroyTriggerParamC08IfNeeded,52,
0x0000007100dd3140,GameDataMgr::syncData,368,
0x0000007100dd32b0,GameDataMgr::syncStart,1084,
0x0000007100dd36ec,GameDataMgr::syncDataX,8392,
0x0000007100dd57b4,sub_7100DD57B4,8,
0x0000007100dd57bc,GameDataMgr::syncStartOnLoadEnd,136,
0x0000007100dd5844,sub_7100DD5844,752,
0x0000007100dd5b34,GameDataMgr::doSyncDataBool,368,
0x0000007100dd5ca4,GameDataMgr::doSyncDataS32,368,
0x0000007100dd5e14,GameDataMgr::doSyncDataF32,368,
0x0000007100dd5f84,GameDataMgr::doSyncDataString,616,
0x0000007100dd61ec,GameDataMgr::doSyncDataString64,616,
0x0000007100dd6454,GameDataMgr::doSyncDataString256,616,
0x0000007100dd66bc,GameDataMgr::doSyncDataVec2f,568,
0x0000007100dd68f4,GameDataMgr::doSyncDataVec3f,568,
0x0000007100dd6b2c,GameDataMgr::doSyncDataVec4f,568,
0x0000007100dd6d64,GameDataMgr::doSyncDataBoolArray,388,
0x0000007100dd6ee8,GameDataMgr::doSyncDataS32Array,352,
0x0000007100dd7048,GameDataMgr::doSyncDataF32Array,352,
0x0000007100dd71a8,GameDataMgr::doSyncDataStringArray,584,
0x0000007100dd73f0,GameDataMgr::doSyncDataString64Array,584,
0x0000007100dd7638,GameDataMgr::doSyncDataString256Array,584,
0x0000007100dd7880,GameDataMgr::doSyncDataVec2fArray,528,
0x0000007100dd7a90,GameDataMgr::doSyncDataVec3fArray,528,
0x0000007100dd7ca0,GameDataMgr::doSyncDataVec4fArray,528,
0x0000007100dd305c,allocRetryBuffer,176,_ZN4ksys3gdt7Manager16allocRetryBufferEPN4sead4HeapE
0x0000007100dd310c,GameDataMgr::destroyTriggerParamC08IfNeeded,52,_ZN4ksys3gdt7Manager18destroyRetryBufferEv
0x0000007100dd3140,GameDataMgr::syncData,368,_ZN4ksys3gdt7Manager8syncDataEPKc
0x0000007100dd32b0,GameDataMgr::syncStart,1084,_ZN4ksys3gdt7Manager9syncStartEv
0x0000007100dd36ec,GameDataMgr::syncDataX,8392,_ZN4ksys3gdt7Manager10syncUpdateEPKc!
0x0000007100dd57b4,sub_7100DD57B4,8,_ZThn8_N4ksys3gdt7Manager8syncDataEPKc
0x0000007100dd57bc,GameDataMgr::syncStartOnLoadEnd,136,_ZN4ksys3gdt7Manager18startSyncOnLoadEndEv
0x0000007100dd5844,sub_7100DD5844,752,_ZN4ksys3gdt7Manager11parseFloatsERKN4sead14SafeStringBaseIcEEPfj
0x0000007100dd5b34,GameDataMgr::doSyncDataBool,368,_ZN4ksys3gdt7Manager11doSyncArrayIbEEvRKN4sead8PtrArrayINS0_8FlagBaseEEEPhPKc
0x0000007100dd5ca4,GameDataMgr::doSyncDataS32,368,_ZN4ksys3gdt7Manager11doSyncArrayIiEEvRKN4sead8PtrArrayINS0_8FlagBaseEEEPhPKc
0x0000007100dd5e14,GameDataMgr::doSyncDataF32,368,_ZN4ksys3gdt7Manager11doSyncArrayIfEEvRKN4sead8PtrArrayINS0_8FlagBaseEEEPhPKc
0x0000007100dd5f84,GameDataMgr::doSyncDataString,616,_ZN4ksys3gdt7Manager14doSyncArrayStrILi32EEEvRKN4sead8PtrArrayINS0_8FlagBaseEEEPhPKcj
0x0000007100dd61ec,GameDataMgr::doSyncDataString64,616,_ZN4ksys3gdt7Manager14doSyncArrayStrILi64EEEvRKN4sead8PtrArrayINS0_8FlagBaseEEEPhPKcj
0x0000007100dd6454,GameDataMgr::doSyncDataString256,616,_ZN4ksys3gdt7Manager14doSyncArrayStrILi256EEEvRKN4sead8PtrArrayINS0_8FlagBaseEEEPhPKcj
0x0000007100dd66bc,GameDataMgr::doSyncDataVec2f,568,_ZN4ksys3gdt7Manager14doSyncArrayVecIN4sead7Vector2IfEEEEvRKNS3_8PtrArrayINS0_8FlagBaseEEEPhPKcj
0x0000007100dd68f4,GameDataMgr::doSyncDataVec3f,568,_ZN4ksys3gdt7Manager14doSyncArrayVecIN4sead7Vector3IfEEEEvRKNS3_8PtrArrayINS0_8FlagBaseEEEPhPKcj
0x0000007100dd6b2c,GameDataMgr::doSyncDataVec4f,568,_ZN4ksys3gdt7Manager14doSyncArrayVecIN4sead7Vector4IfEEEEvRKNS3_8PtrArrayINS0_8FlagBaseEEEPhPKcj
0x0000007100dd6d64,GameDataMgr::doSyncDataBoolArray,388,_ZN4ksys3gdt7Manager11doSyncArrayIbEEvRKN4sead8PtrArrayINS4_INS0_8FlagBaseEEEEEPhPKc
0x0000007100dd6ee8,GameDataMgr::doSyncDataS32Array,352,_ZN4ksys3gdt7Manager11doSyncArrayIiEEvRKN4sead8PtrArrayINS4_INS0_8FlagBaseEEEEEPhPKc
0x0000007100dd7048,GameDataMgr::doSyncDataF32Array,352,_ZN4ksys3gdt7Manager11doSyncArrayIfEEvRKN4sead8PtrArrayINS4_INS0_8FlagBaseEEEEEPhPKc
0x0000007100dd71a8,GameDataMgr::doSyncDataStringArray,584,_ZN4ksys3gdt7Manager14doSyncArrayStrILi32EEEvRKN4sead8PtrArrayINS4_INS0_8FlagBaseEEEEEPhPKcj
0x0000007100dd73f0,GameDataMgr::doSyncDataString64Array,584,_ZN4ksys3gdt7Manager14doSyncArrayStrILi64EEEvRKN4sead8PtrArrayINS4_INS0_8FlagBaseEEEEEPhPKcj
0x0000007100dd7638,GameDataMgr::doSyncDataString256Array,584,_ZN4ksys3gdt7Manager14doSyncArrayStrILi256EEEvRKN4sead8PtrArrayINS4_INS0_8FlagBaseEEEEEPhPKcj
0x0000007100dd7880,GameDataMgr::doSyncDataVec2fArray,528,_ZN4ksys3gdt7Manager14doSyncArrayVecIN4sead7Vector2IfEEEEvRKNS3_8PtrArrayINS6_INS0_8FlagBaseEEEEEPhPKcj
0x0000007100dd7a90,GameDataMgr::doSyncDataVec3fArray,528,_ZN4ksys3gdt7Manager14doSyncArrayVecIN4sead7Vector3IfEEEEvRKNS3_8PtrArrayINS6_INS0_8FlagBaseEEEEEPhPKcj
0x0000007100dd7ca0,GameDataMgr::doSyncDataVec4fArray,528,_ZN4ksys3gdt7Manager14doSyncArrayVecIN4sead7Vector4IfEEEEvRKNS3_8PtrArrayINS6_INS0_8FlagBaseEEEEEPhPKcj
0x0000007100dd7eb0,GameDataMgr::getName,12,_ZNK4ksys3gdt7Manager7getNameEv
0x0000007100dd7ebc,sub_7100DD7EBC,12,_ZThn8_NK4ksys3gdt7Manager7getNameEv
0x0000007100dd7ec8,j__ZdlPv_893,4,_ZN4ksys3gdt15TriggerParamRefD0Ev
@ -79185,7 +79185,7 @@
0x0000007100e8de68,sub_7100E8DE68,40,
0x0000007100e8de90,sub_7100E8DE90,40,
0x0000007100e8deb8,MapConst::m1,64,
0x0000007100e8def8,_ZN4sead15FixedSafeStringILi64EED0Ev,68,
0x0000007100e8def8,x,68,
0x0000007100e8df3c,sub_7100E8DF3C,68,
0x0000007100e8df80,MapConst::m18,8,
0x0000007100e8df88,nullsub_4002,4,

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

2
lib/sead

@ -1 +1 @@
Subproject commit dfbcf903b8543c5f85fe166eaf8d4bc92c9c93ba
Subproject commit 9ac7ac68fb0cd1adbb62fb2bfb52d56db3c5cc90

675
src/KingSystem/GameData/gdtManager.cpp
View File

@ -1,18 +1,24 @@
#include "KingSystem/GameData/gdtManager.h"
#include <algorithm>
#include <cstring>
#include <devenv/seadEnvUtil.h>
#include <framework/seadFramework.h>
#include <mc/seadCoreInfo.h>
#include <prim/seadStringUtil.h>
#include <thread/seadThreadUtil.h>
#include <time/seadTickTime.h>
#include <type_traits>
#include "Game/DLC/aocManager.h"
#include "KingSystem/GameData/gdtSaveMgr.h"
#include "KingSystem/GameData/gdtTriggerParam.h"
#include "KingSystem/Map/mapMubinIter.h"
#include "KingSystem/Resource/resEntryFactory.h"
#include "KingSystem/Resource/resResourceGameData.h"
#include "KingSystem/Resource/resSystem.h"
#include "KingSystem/System/OverlayArenaSystem.h"
#include "KingSystem/Utils/HeapUtil.h"
#include "KingSystem/Utils/InitTimeInfo.h"
#include "KingSystem/Utils/SafeDelete.h"
namespace ksys::gdt {
@ -554,4 +560,673 @@ bool Manager::wasFlagNotCopied(const sead::SafeString& name) {
return getParam().get().getBuffer()->getBoolIfCopied(&value, name, false, true) && !value;
}
void Manager::copyParamToParam1() {
mFlagBuffer1->copyChangedFlags(*mFlagBuffer, true, false, false);
}
FlagHandle Manager::getRevivalFlagHandle(const sead::SafeString& object_name,
const map::MubinIter& iter) {
if (mBitFlags.isOn(BitFlag::_40000))
return InvalidHandle;
const sead::SafeString& map_name =
mGetMapNameDelegate ? mGetMapNameDelegate->invoke() : sead::SafeString::cEmptyString;
u32 hash_id = 0;
iter.tryGetParamUIntByKey(&hash_id, "HashId");
sead::FormatFixedSafeString<128> flag_name("%s_%s_%u", map_name.cstr(), object_name.cstr(),
hash_id);
if (mBitFlags.isOn(BitFlag::_2000))
return InvalidHandle;
return getBoolHandle(flag_name);
}
void Manager::allocParam1() {
auto* parent_heap = OverlayArenaSystem::instance()->getGameDataWorkHeap();
auto* heap = util::tryCreateDualHeap(0, "param1", parent_heap, nullptr,
sead::Heap::cHeapDirection_Forward, false);
mFlagBuffer1 = new (heap) TriggerParam;
mFlagBuffer1->copyAllFlags(*mFlagBuffer, heap, true);
heap->adjust();
}
bool Manager::getShopInfoIter(u32 hash, al::ByamlIter* out, const al::ByamlIter& iter,
const u32* hashes) {
int a = 0;
int b = iter.getSize();
while (a < b) {
const auto m = (a + b) / 2;
if (hashes[m] == hash)
return iter.tryGetIterByIndex(out, m);
if (hashes[m] < hash)
a = m + 1;
else
b = m;
}
return false;
}
void Manager::allocRetryBuffer(sead::Heap* heap) {
if (mRetryBuffer)
return;
auto* buffer_heap = util::tryCreateDualHeap(0x100000, "RetryBuffer", heap, nullptr,
sead::Heap::cHeapDirection_Reverse, false);
mRetryBuffer = new (buffer_heap) TriggerParam;
mRetryBuffer->copyPermanentFlags(*mFlagBuffer1, buffer_heap);
buffer_heap->adjust();
}
void Manager::destroyRetryBuffer() {
if (mBitFlags.isOn(BitFlag::_80000))
return;
if (mRetryBuffer) {
mRetryBuffer->destroyHeap();
mRetryBuffer = nullptr;
}
}
void Manager::syncData(const char* data) {
const sead::SafeString cmd = data;
if (cmd.compare("SyncStart") == 0) {
if (util::getDebugHeap()) {
if (mBitFlags.testAndClear(BitFlag::_100)) {
mSyncStep = 0;
}
mBitFlags.set(BitFlag::_200);
syncStart();
}
} else if (cmd.compare("SyncEnd") == 0) {
mSyncStep = 0;
mBitFlags.reset(BitFlag::_100);
mBitFlags.reset(BitFlag::_200);
} else {
syncUpdate(data);
onChangedByDebug();
}
}
constexpr size_t ComBufferSize = 0x1a000;
void Manager::syncStart() {
if (KingEditor::instance()->get88() == 0 || util::getDebugHeap() == nullptr)
return;
if (mGameDataComHeap) {
if (mGameDataComHeap->getFreeSize() < ComBufferSize)
return;
} else {
mGameDataComHeap =
sead::ExpHeap::tryCreate(ComBufferSize + 0x400, "GameDataCom", util::getDebugHeap(),
sizeof(void*), sead::Heap::cHeapDirection_Forward, false);
if (!mGameDataComHeap)
return;
}
u8* buffer = new (mGameDataComHeap) u8[ComBufferSize];
auto* flag_buffer = mFlagBuffer;
const int step = mSyncStep;
switch (mSyncStep) {
case 0:
doSyncArray<bool>(flag_buffer->mBoolFlags, buffer, "[SyncData][AllData][bool]");
mSyncStep = step + 1;
break;
case 1:
doSyncArray<s32>(flag_buffer->mS32Flags, buffer, "[SyncData][AllData][s32]");
mSyncStep = step + 1;
break;
case 2:
doSyncArray<f32>(flag_buffer->mF32Flags, buffer, "[SyncData][AllData][f32]");
mSyncStep = step + 1;
break;
case 3:
doSyncArrayStr<32>(flag_buffer->mStringFlags, buffer, "[SyncData][AllData][string]");
mSyncStep = step + 1;
break;
case 4:
doSyncArrayStr<64>(flag_buffer->mString64Flags, buffer, "[SyncData][AllData][string64]");
mSyncStep = step + 1;
break;
case 5:
doSyncArrayStr<256>(flag_buffer->mString256Flags, buffer, "[SyncData][AllData][string256]");
mSyncStep = step + 1;
break;
case 6:
doSyncArrayVec<sead::Vector2f>(flag_buffer->mVector2fFlags, buffer,
"[SyncData][AllData][vector2f]", 2);
mSyncStep = step + 1;
break;
case 7:
doSyncArrayVec<sead::Vector3f>(flag_buffer->mVector3fFlags, buffer,
"[SyncData][AllData][vector3f]", 3);
mSyncStep = step + 1;
break;
case 8:
doSyncArrayVec<sead::Vector4f>(flag_buffer->mVector4fFlags, buffer,
"[SyncData][AllData][vector4f]", 4);
mSyncStep = step + 1;
break;
case 9:
doSyncArray<bool>(flag_buffer->mBoolArrayFlags, buffer, "[SyncData][AllData][boolarray]");
mSyncStep = step + 1;
break;
case 10:
doSyncArray<s32>(flag_buffer->mS32ArrayFlags, buffer, "[SyncData][AllData][s32array]");
mSyncStep = step + 1;
break;
case 11:
doSyncArray<f32>(flag_buffer->mF32ArrayFlags, buffer, "[SyncData][AllData][f32array]");
mSyncStep = step + 1;
break;
case 12:
doSyncArrayStr<32>(flag_buffer->mStringArrayFlags, buffer,
"[SyncData][AllData][stringarray]");
mSyncStep = step + 1;
break;
case 13:
doSyncArrayStr<64>(flag_buffer->mString64ArrayFlags, buffer,
"[SyncData][AllData][string64array]");
mSyncStep = step + 1;
break;
case 14:
doSyncArrayStr<256>(flag_buffer->mString256ArrayFlags, buffer,
"[SyncData][AllData][string256array]");
mSyncStep = step + 1;
break;
case 15:
doSyncArrayVec<sead::Vector2f>(flag_buffer->mVector2fArrayFlags, buffer,
"[SyncData][AllData][vector2farray]", 2);
mSyncStep = step + 1;
break;
case 16:
doSyncArrayVec<sead::Vector3f>(flag_buffer->mVector3fArrayFlags, buffer,
"[SyncData][AllData][vector3farray]", 3);
mSyncStep = step + 1;
break;
case 17:
doSyncArrayVec<sead::Vector4f>(flag_buffer->mVector4fArrayFlags, buffer,
"[SyncData][AllData][vector4farray]", 4);
mSyncStep = step + 1;
break;
default:
KingEditor::instance()->log(getName(), "[SendAllData]");
mBitFlags.reset(BitFlag::SyncFlags);
mBitFlags.set(BitFlag::_100);
break;
}
util::safeDeleteArray(buffer);
}
// NON_MATCHING: recordFlagChange calls not being merged, or merged in the wrong way
void Manager::syncUpdate(const char* data) {
const sead::SafeString cmd = data;
auto it = cmd.tokenBegin("|");
const auto end = cmd.tokenEnd("|");
if (it == end)
return;
sead::FixedSafeString<256> name;
it.getAndForward(&name);
sead::FixedSafeString<256> type;
it.getAndForward(&type);
sead::FixedSafeString<256> value;
it.getAndForward(&value);
auto* tparam = mFlagBuffer1;
int idx = -1;
const u32 pl_core_id = sead::CoreInfo::getPlatformCoreId(sead::CoreInfo::getCurrentCoreId());
const auto calc_hash = [&] { return sead::HashCRC32::calcStringHash(name); };
if (type.compare("bool") == 0) {
auto* flag = tparam->getBoolFlagAndIdx(&idx, calc_hash());
if (!flag)
return;
bool v = false;
if (value == "true")
v = true;
flag->setValue(v);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
return;
}
if (type.compare("s32") == 0) {
auto* flag = tparam->getS32FlagAndIdx(&idx, calc_hash());
if (!flag)
return;
s32 v = 0;
sead::StringUtil::tryParseS32(&v, value, sead::StringUtil::CardinalNumber::BaseAuto);
flag->setValue(v);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
return;
}
if (type.compare("f32") == 0) {
auto* flag = tparam->getF32FlagAndIdx(&idx, calc_hash());
if (!flag)
return;
f32 v = 0;
sead::StringUtil::tryParseF32(&v, value);
flag->setValue(v);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
return;
}
if (type.compare("string") == 0) {
auto* flag = tparam->getStrFlagAndIdx(&idx, calc_hash());
if (!flag)
return;
flag->setValue(value);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
return;
}
if (type.compare("string64") == 0) {
auto* flag = tparam->getStr64FlagAndIdx(&idx, calc_hash());
if (!flag)
return;
flag->setValue(value);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
return;
}
if (type.compare("string256") == 0) {
auto* flag = tparam->getStr256FlagAndIdx(&idx, calc_hash());
if (!flag)
return;
flag->setValue(value);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
return;
}
if (type.compare("vector2f") == 0) {
auto* flag = tparam->getVec2fFlagAndIdx(&idx, calc_hash());
if (!flag)
return;
sead::Vector2f v;
parseFloats(value, v.e.data(), v.e.size());
flag->setValue(v);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
return;
}
if (type.compare("vector3f") == 0) {
auto* flag = tparam->getVec3fFlagAndIdx(&idx, calc_hash());
if (!flag)
return;
sead::Vector3f v;
parseFloats(value, v.e.data(), v.e.size());
flag->setValue(v);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
return;
}
if (type.compare("vector4f") == 0) {
auto* flag = tparam->getVec4fFlagAndIdx(&idx, calc_hash());
if (!flag)
return;
sead::Vector4f v;
parseFloats(value, v.e.data(), v.e.size());
flag->setValue(v);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx);
return;
}
sead::FixedSafeString<64> sub_idx_str{"-1"};
if (it != end)
it.getAndForward(&sub_idx_str);
const int sub_idx =
sead::StringUtil::parseS32(sub_idx_str, sead::StringUtil::CardinalNumber::BaseAuto);
if (type.compare("boolarray") == 0) {
auto* flag = tparam->getBoolFlagAndIdx(&idx, calc_hash(), sub_idx);
if (!flag)
return;
bool v = false;
if (value == "true")
v = true;
flag->setValue(v);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
return;
}
if (type.compare("s32array") == 0) {
auto* flag = tparam->getS32FlagAndIdx(&idx, calc_hash(), sub_idx);
if (!flag)
return;
s32 v = 0;
sead::StringUtil::tryParseS32(&v, value, sead::StringUtil::CardinalNumber::BaseAuto);
flag->setValue(v);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
return;
}
if (type.compare("f32array") == 0) {
auto* flag = tparam->getF32FlagAndIdx(&idx, calc_hash(), sub_idx);
if (!flag)
return;
f32 v = 0;
sead::StringUtil::tryParseF32(&v, value);
flag->setValue(v);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
return;
}
if (type.compare("stringarray") == 0) {
auto* flag = tparam->getStrFlagAndIdx(&idx, calc_hash(), sub_idx);
if (!flag)
return;
flag->setValue(value);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
return;
}
if (type.compare("string64array") == 0) {
auto* flag = tparam->getStr64FlagAndIdx(&idx, calc_hash(), sub_idx);
if (!flag)
return;
flag->setValue(value);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
return;
}
if (type.compare("string256array") == 0) {
auto* flag = tparam->getStr256FlagAndIdx(&idx, calc_hash(), sub_idx);
if (!flag)
return;
flag->setValue(value);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
return;
}
if (type.compare("vector2farray") == 0) {
auto* flag = tparam->getVec2fFlagAndIdx(&idx, calc_hash(), sub_idx);
if (!flag)
return;
sead::Vector2f v;
parseFloats(value, v.e.data(), v.e.size());
flag->setValue(v);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
return;
}
if (type.compare("vector3farray") == 0) {
auto* flag = tparam->getVec3fFlagAndIdx(&idx, calc_hash(), sub_idx);
if (!flag)
return;
sead::Vector3f v;
parseFloats(value, v.e.data(), v.e.size());
flag->setValue(v);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
return;
}
if (type.compare("vector4farray") == 0) {
auto* flag = tparam->getVec4fFlagAndIdx(&idx, calc_hash(), sub_idx);
if (!flag)
return;
sead::Vector4f v;
parseFloats(value, v.e.data(), v.e.size());
flag->setValue(v);
recordFlagChange(pl_core_id, tparam, flag->getType(), idx, sub_idx);
return;
}
}
void Manager::recordFlagChange(u32 platform_core_id, TriggerParam* tparam, u8 type, const s32& idx,
const s32& sub_idx) {
auto& buffer = tparam->mFlagChangeRecords[platform_core_id].ref();
buffer[tparam->mFlagChangeRecordIndices[platform_core_id]].type.mValue = type;
buffer[tparam->mFlagChangeRecordIndices[platform_core_id]].index = idx;
buffer[tparam->mFlagChangeRecordIndices[platform_core_id]].sub_index = sub_idx;
++tparam->mFlagChangeRecordIndices[platform_core_id];
}
void Manager::startSyncOnLoadEnd() {
if (!mBitFlags.isOn(BitFlag::_100) || mBitFlags.isOn(BitFlag::_200))
return;
KingEditor::instance()->log(getName(), "[LoadEnd]");
mBitFlags.reset(BitFlag::SyncFlags);
mBitFlags.set(BitFlag::_200);
mSyncStep = 0;
syncStart();
}
void Manager::parseFloats(const sead::SafeString& str, f32* values, u32 n) {
auto it = str.tokenBegin(" ");
const auto end = str.tokenEnd(" ");
u32 i = 0;
while (end != it) {
sead::FixedSafeString<256> part;
it.getAndForward(&part);
f32 value;
if (!sead::StringUtil::tryParseF32(&value, part))
value = 0.0;
values[i++] = value;
if (i == n)
break;
}
}
namespace {
template <typename T>
void writeToBuffer(u8* buffer, u32* written, const T& value) {
static_assert(std::is_trivially_copyable<T>());
std::memcpy(buffer + *written, &value, sizeof(value));
*written += u32(sizeof(value));
}
} // namespace
template <typename T>
void Manager::doSyncArray(const sead::PtrArray<FlagBase>& array, u8* buffer,
const char* description) {
KingEditor::instance()->log(getName(), "[ArrayStart]");
u32 offset = 0;
const auto flush = [&] {
KingEditor::instance()->log(getName(), description, buffer, offset);
offset = 0;
};
for (FlagBase& flag : array) {
u32 written = 0;
writeToBuffer(buffer + offset, &written, flag.getHash());
if constexpr (std::is_same<bool, T>()) {
writeToBuffer(buffer + offset, &written, static_cast<Flag<T>&>(flag).getValue());
} else {
writeToBuffer(buffer + offset, &written, static_cast<Flag<T>&>(flag).getValueRef());
}
offset += written;
if (offset >= ComBufferSize - written)
flush();
}
if (offset != 0)
flush();
KingEditor::instance()->log(getName(), "[ArrayEnd]");
}
template <int N>
void Manager::doSyncArrayStr(const sead::PtrArray<FlagBase>& array, u8* buffer,
const char* description, u32 n) {
KingEditor::instance()->log(getName(), "[ArrayStart]");
u32 offset = 0;
const auto flush = [&] {
KingEditor::instance()->log(getName(), description, buffer, offset);
offset = 0;
};
for (FlagBase& flag : array) {
const auto& flag_ = static_cast<const Flag<sead::FixedSafeString<N>>&>(flag);
u8* entry = buffer + offset;
const u32 hash = flag.getHash();
std::memcpy(entry, &hash, sizeof(hash));
const auto len = flag_.getValueRef().calcLength();
sead::MemUtil::copy(entry + sizeof(hash), flag_.getValueRef().cstr(), len);
sead::MemUtil::fillZero(entry + u32(sizeof(hash) + len), n - len);
offset += u32(sizeof(hash) + n);
if (offset >= ComBufferSize - sizeof(hash) - n)
flush();
}
if (offset != 0)
flush();
KingEditor::instance()->log(getName(), "[ArrayEnd]");
}
template <typename T>
void Manager::doSyncArrayVec(const sead::PtrArray<FlagBase>& array, u8* buffer,
const char* description, u32 n) {
KingEditor::instance()->log(getName(), "[ArrayStart]");
u32 offset = 0;
const auto flush = [&] {
KingEditor::instance()->log(getName(), description, buffer, offset);
offset = 0;
};
for (FlagBase& flag : array) {
const auto& flag_ = static_cast<const Flag<T>&>(flag);
u32 written = 0;
writeToBuffer(buffer + offset, &written, flag.getHash());
for (u32 i = 0; i != n; ++i)
writeToBuffer(buffer + offset, &written, flag_.getValueRef().e[i]);
offset += written;
/// @bug "n" should be "sizeof(f32) * n" instead.
if (offset >= ComBufferSize - sizeof(u32) - n)
flush();
}
if (offset != 0)
flush();
KingEditor::instance()->log(getName(), "[ArrayEnd]");
}
template <typename T>
void Manager::doSyncArray(const sead::PtrArray<sead::PtrArray<FlagBase>>& array, u8* buffer,
const char* description) {
KingEditor::instance()->log(getName(), "[ArrayStart]");
for (auto& flags : array) {
u32 written = [&] {
u32 offset = 0;
auto it = flags.begin();
const auto end = flags.end();
writeToBuffer(buffer, &offset, flags[0]->getHash());
for (; it != end; ++it) {
writeToBuffer(buffer, &offset, static_cast<Flag<T>&>(*it).getValueRef());
if (offset >= ComBufferSize - sizeof(T))
break;
}
return offset;
}();
if (written != 0)
KingEditor::instance()->log(getName(), description, buffer, written);
}
KingEditor::instance()->log(getName(), "[ArrayEnd]");
}
template <int N>
void Manager::doSyncArrayStr(const sead::PtrArray<sead::PtrArray<FlagBase>>& array, u8* buffer,
const char* description, u32 n) {
KingEditor::instance()->log(getName(), "[ArrayStart]");
for (auto& flags : array) {
u32 written = [&] {
u32 offset = 0;
auto it = flags.begin();
const auto end = flags.end();
writeToBuffer(buffer, &offset, flags[0]->getHash());
for (; it != end; ++it) {
const auto& flag = static_cast<const Flag<sead::FixedSafeString<N>>&>(*it);
const auto len = flag.getValueRef().calcLength();
sead::MemUtil::copy(buffer + offset, flag.getValueRef().cstr(), len);
sead::MemUtil::fillZero(buffer + u32(offset + len), n - len);
offset += n;
if (offset >= u32(ComBufferSize) - n)
break;
}
return offset;
}();
if (written != 0)
KingEditor::instance()->log(getName(), description, buffer, written);
}
KingEditor::instance()->log(getName(), "[ArrayEnd]");
}
template <typename T>
static u32 syncOneVec(Manager*, u8* buffer, const sead::PtrArray<FlagBase>& flags, u32 n) {
u32 offset = 0;
auto it = flags.begin();
const auto end = flags.end();
writeToBuffer(buffer, &offset, flags[0]->getHash());
for (; it != end; ++it) {
for (u32 i = 0; i < n; ++i)
writeToBuffer(buffer, &offset, static_cast<const Flag<T>&>(*it).getValueRef().e[i]);
if (offset >= u32(ComBufferSize) - n)
break;
}
return offset;
}
template <typename T>
void Manager::doSyncArrayVec(const sead::PtrArray<sead::PtrArray<FlagBase>>& array, u8* buffer,
const char* description, u32 n) {
KingEditor::instance()->log(getName(), "[ArrayStart]");
for (auto& flags : array) {
u32 written = syncOneVec<T>(this, buffer, flags, n);
if (written != 0)
KingEditor::instance()->log(getName(), description, buffer, written);
}
KingEditor::instance()->log(getName(), "[ArrayEnd]");
}
} // namespace ksys::gdt

46
src/KingSystem/GameData/gdtManager.h
View File

@ -20,6 +20,10 @@ class Framework;
class MethodTreeMgr;
} // namespace sead
namespace ksys::map {
class MubinIter;
}
namespace ksys::gdt {
namespace detail {
@ -230,6 +234,7 @@ public:
using ReinitSignal = sead::DelegateEvent<ReinitEvent*>;
void init(sead::Heap* heap, sead::Framework* framework);
void calc();
void addReinitCallback(ReinitSignal::Slot& slot);
void removeReinitCallback(ReinitSignal::Slot& slot);
@ -485,6 +490,20 @@ public:
bool wasFlagCopied(const sead::SafeString& name);
bool wasFlagNotCopied(const sead::SafeString& name);
void copyParamToParam1();
void allocParam1();
FlagHandle getRevivalFlagHandle(const sead::SafeString& object_name,
const map::MubinIter& iter);
static bool getShopInfoIter(u32 hash, al::ByamlIter* out, const al::ByamlIter& iter,
const u32* hashes);
void resetBoolFlagForRadarMgr(FlagBool& flag);
void allocRetryBuffer(sead::Heap* heap);
void destroyRetryBuffer();
void startSyncOnLoadEnd();
private:
enum class BitFlag {
_1 = 0x1,
@ -497,6 +516,7 @@ private:
_80 = 0x80,
_100 = 0x100,
_200 = 0x200,
SyncFlags = _100 | _200,
_400 = 0x400,
_800 = 0x800,
_1000 = 0x1000,
@ -506,6 +526,7 @@ private:
_10000 = 0x10000,
_20000 = 0x20000,
_40000 = 0x40000,
_80000 = 0x80000,
};
enum class ResetFlag {
@ -569,6 +590,31 @@ private:
void loadShopGameDataInfo(const sead::SafeString& path);
void unloadResources();
void syncStart();
void syncUpdate(const char* data);
static void parseFloats(const sead::SafeString& str, f32* values, u32 n);
static inline void recordFlagChange(u32 platform_core_id, TriggerParam* tparam, u8 type,
const s32& idx, const s32& sub_idx = -1);
template <typename T>
void doSyncArray(const sead::PtrArray<FlagBase>& array, u8* buffer, const char* description);
template <int N>
void doSyncArrayStr(const sead::PtrArray<FlagBase>& array, u8* buffer, const char* description,
u32 n = N);
template <typename T>
void doSyncArrayVec(const sead::PtrArray<FlagBase>& array, u8* buffer, const char* description,
u32 n);
template <typename T>
void doSyncArray(const sead::PtrArray<sead::PtrArray<FlagBase>>& array, u8* buffer,
const char* description);
template <int N>
void doSyncArrayStr(const sead::PtrArray<sead::PtrArray<FlagBase>>& array, u8* buffer,
const char* description, u32 n = N);
template <typename T>
void doSyncArrayVec(const sead::PtrArray<sead::PtrArray<FlagBase>>& array, u8* buffer,
const char* description, u32 n);
sead::Heap* mGameDataHeap = nullptr;
sead::Heap* mSaveAreaHeap = nullptr;
sead::Heap* mGameDataComHeap = nullptr;

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

@ -24,6 +24,7 @@ public:
struct ResetEntry {
sead::SizedEnum<FlagType::ValueType, u8> type;
sead::SizedEnum<ResetType, u8> reset_type;
s16 sub_index;
s32 index;
};
KSYS_CHECK_SIZE_NX150(ResetEntry, 0x8);
@ -453,6 +454,8 @@ public:
bool ignore_temp_flags);
private:
friend class Manager;
enum class BitFlag : u8 {
_1 = 1,
_2 = 2,

2
src/KingSystem/System/KingEditor.h
View File

@ -31,6 +31,8 @@ public:
void registerComponent(KingEditorComponent* component);
void log(const char* system, const char* message, void* = {}, int = {});
u32 get88() const { return _88; }
private:
sead::OffsetList<KingEditorComponent> mComponents;
sead::ListNode mListNode;

10
src/KingSystem/System/OverlayArenaSystem.h
View File

@ -45,6 +45,16 @@ public:
OverlayArena* getAudioArena() const;
OverlayArena* getUnknownArena() const;
sead::Heap* getFixedHeap() const { return mFixedHeap; }
sead::Heap* getMovableMemoryHeap() const { return mMovableMemoryHeap; }
sead::Heap* getGameDataWorkHeap() const { return mGameDataWorkHeap; }
sead::Heap* getMovieHeap() const { return mMovieHeap; }
sead::Heap* getPlacementTreeHeap() const { return mPlacementTreeHeap; }
sead::Heap* getTeraWorkHeap() const { return mTeraWorkHeap; }
sead::Heap* getSzsDecompressorInstHeap() const { return mSzsDecompressorInstHeap; }
sead::Heap* getSzsHeap() const { return mSzsHeap; }
sead::Heap* getTexArcWorkHeap() const { return mTexArcWorkHeap; }
void createTeraWorkHeap();
void createStubbed();
void createMovieHeap();