diff --git a/data/uking_functions.csv b/data/uking_functions.csv index fcd7f139..c7be9c39 100644 --- a/data/uking_functions.csv +++ b/data/uking_functions.csv @@ -74342,7 +74342,7 @@ 0x0000007100dd84b0,TriggerParam::copyFromBgdata,3644,_ZN4ksys3gdt12TriggerParam19copyFromGameDataResEPNS_3res8GameDataEPN4sead4HeapE 0x0000007100dd92ec,TriggerParam::init,128,_ZN4ksys3gdt12TriggerParam4initEPN4sead4HeapE 0x0000007100dd936c,TriggerParam::Buffer::sort,760,_ZN4ksys3gdt12_GLOBAL__N_116sortFlagPtrArrayERN4sead8PtrArrayINS0_8FlagBaseEEE! -0x0000007100dd9664,TriggerParam::d_0,2536,_ZN4ksys3gdt12TriggerParam23allocCombinedFlagArraysEPN4sead4HeapE +0x0000007100dd9664,TriggerParam::d_0,2536,_ZN4ksys3gdt12TriggerParam21allocCopyRecordArraysEPN4sead4HeapE 0x0000007100dda04c,TriggerParam::d_1,260,_ZN4ksys3gdt12TriggerParam20updateBoolFlagCountsEv 0x0000007100dda150,TriggerParam::destroyHeap,52,_ZN4ksys3gdt12TriggerParam11destroyHeapEv 0x0000007100dda184,TriggerParam::allocBuffer,12,_ZN4ksys3gdt12TriggerParam10allocBoolsEiPN4sead4HeapE @@ -74474,7 +74474,7 @@ 0x0000007100de82cc,TriggerParam::getArray158Flag,364, 0x0000007100de8438,TriggerParam::getHorseIntByKeyMaybe,360, 0x0000007100de85a0,sub_7100DE85A0,360, -0x0000007100de8708,sub_7100DE8708,268, +0x0000007100de8708,sub_7100DE8708,268,_ZN4ksys3gdt12_GLOBAL__N_117addFlagCopyRecordIbEEvRN4sead8ObjArrayINS0_12TriggerParam14FlagCopyRecordEEEPNS0_4FlagIT_EEib 0x0000007100de8814,TriggerParam::copyAndInit,8556, 0x0000007100dea980,sub_7100DEA980,1124, 0x0000007100deade4,sub_7100DEADE4,1052, diff --git a/lib/sead b/lib/sead index 7127999d..dc07028a 160000 --- a/lib/sead +++ b/lib/sead @@ -1 +1 @@ -Subproject commit 7127999dca9335ddfbd28c81bccb8d368b706c8a +Subproject commit dc07028aea683d720c8b49703134c70240760f22 diff --git a/src/KingSystem/GameData/gdtTriggerParam.cpp b/src/KingSystem/GameData/gdtTriggerParam.cpp index c1ccd732..aceeed8d 100644 --- a/src/KingSystem/GameData/gdtTriggerParam.cpp +++ b/src/KingSystem/GameData/gdtTriggerParam.cpp @@ -430,6 +430,36 @@ void makeFlagProxies(sead::PtrArray& dest, const sead::PtrArray +[[gnu::noinline]] void addFlagCopyRecord(sead::ObjArray& records, + Flag* flag, s32 sub_index, bool find_existing_record) { + if (records.isFull()) + return; + + TriggerParam::FlagCopyRecord* record; + + s32 record_idx = -1; + if (find_existing_record) { + const u32 hash = flag->getHash(); + for (s32 i = 0; i < records.size(); ++i) { + if (records[i]->name_hash == hash && records[i]->sub_index == s16(sub_index)) { + record_idx = i; + break; + } + } + } + + if (record_idx != -1) { + record = records[record_idx]; + } else { + record = records.emplaceBack(); + record->name_hash = flag->getHash(); + record->sub_index = sub_index; + } + record->bit_flag.makeAllZero(); +} } // namespace void TriggerParam::copyFromGameDataRes(res::GameData* gdata, sead::Heap* heap) { @@ -469,13 +499,13 @@ void TriggerParam::init(sead::Heap* heap) { sortFlagPtrArray(mVector2fFlags); sortFlagPtrArray(mVector3fFlags); sortFlagPtrArray(mVector4fFlags); - allocCombinedFlagArrays(heap); + allocCopyRecordArrays(heap); updateBoolFlagCounts(); mHeap = heap; } -void TriggerParam::allocCombinedFlagArrays(sead::Heap* heap) { -#define ALLOC_COMBINED_ARRAY_(FLAGS, FLAG_ARRAYS, DEST) \ +void TriggerParam::allocCopyRecordArrays(sead::Heap* heap) { +#define ALLOC_ARRAY_(FLAGS, FLAG_ARRAYS, DEST) \ { \ s32 size = FLAGS.size(); \ for (s32 i = 0; i < FLAG_ARRAYS.size(); ++i) \ @@ -484,17 +514,17 @@ void TriggerParam::allocCombinedFlagArrays(sead::Heap* heap) { DEST.allocBuffer(size, heap); \ } - ALLOC_COMBINED_ARRAY_(mBoolFlags, mBoolArrayFlags, mCombinedBoolFlags); - ALLOC_COMBINED_ARRAY_(mS32Flags, mS32ArrayFlags, mCombinedS32Flags); - ALLOC_COMBINED_ARRAY_(mF32Flags, mF32ArrayFlags, mCombinedF32Flags); - ALLOC_COMBINED_ARRAY_(mStringFlags, mStringArrayFlags, mCombinedStringFlags); - ALLOC_COMBINED_ARRAY_(mString64Flags, mString64ArrayFlags, mCombinedString64Flags); - ALLOC_COMBINED_ARRAY_(mString256Flags, mString256ArrayFlags, mCombinedString256Flags); - ALLOC_COMBINED_ARRAY_(mVector2fFlags, mVector2fArrayFlags, mCombinedVector2fFlags); - ALLOC_COMBINED_ARRAY_(mVector3fFlags, mVector3fArrayFlags, mCombinedVector3fFlags); - ALLOC_COMBINED_ARRAY_(mVector4fFlags, mVector4fArrayFlags, mCombinedVector4fFlags); + ALLOC_ARRAY_(mBoolFlags, mBoolArrayFlags, mCopiedBoolFlags); + ALLOC_ARRAY_(mS32Flags, mS32ArrayFlags, mCopiedS32Flags); + ALLOC_ARRAY_(mF32Flags, mF32ArrayFlags, mCopiedF32Flags); + ALLOC_ARRAY_(mStringFlags, mStringArrayFlags, mCopiedStringFlags); + ALLOC_ARRAY_(mString64Flags, mString64ArrayFlags, mCopiedString64Flags); + ALLOC_ARRAY_(mString256Flags, mString256ArrayFlags, mCopiedString256Flags); + ALLOC_ARRAY_(mVector2fFlags, mVector2fArrayFlags, mCopiedVector2fFlags); + ALLOC_ARRAY_(mVector3fFlags, mVector3fArrayFlags, mCopiedVector3fFlags); + ALLOC_ARRAY_(mVector4fFlags, mVector4fArrayFlags, mCopiedVector4fFlags); -#undef ALLOC_COMBINED_ARRAY_ +#undef ALLOC_ARRAY_ } void TriggerParam::updateBoolFlagCounts() { @@ -1418,6 +1448,59 @@ void TriggerParam::resetAllFlagsToInitialValues() { } } +// FIXME: very incomplete +void TriggerParam::copyChangedFlags(TriggerParam& other, bool set_all_flags, bool y, bool z) { + if (!set_all_flags) { + for (s32 i = 0; i < 3; ++i) { + auto lock = sead::makeScopedLock(other.mCriticalSections[i].ref()); + + for (s32 j = 0; j < mFlagChangeRecordIndices[i]; ++i) { + const FlagChangeRecord& record = mFlagChangeRecords[i].ref()[j]; + switch (record.type) { + case FlagType::Bool: { + auto* flag = static_cast(mBoolFlags[record.index]); + const bool find_existing = mBitFlags.ref().isOn(BitFlag::_7); + flag->setValue( + static_cast(other.mBoolFlags[record.index])->getValue()); + const auto category = flag->getCategory(); + addFlagCopyRecord(mCopiedBoolFlags, flag, -1, find_existing); + + if (category > 0) { + if (flag->getValue()) + ++mNumBoolFlagsPerCategory[category - 1]; + else + --mNumBoolFlagsPerCategory[category - 1]; + } + break; + } + case FlagType::BoolArray: { + auto* flag = + static_cast((*mBoolArrayFlags[record.index])[record.sub_index]); + const bool find_existing = mBitFlags.ref().isOn(BitFlag::_7); + flag->setValue(static_cast( + (*other.mBoolArrayFlags[record.index])[record.sub_index]) + ->getValue()); + const auto category = flag->getCategory(); + addFlagCopyRecord(mCopiedBoolFlags, flag, record.sub_index, find_existing); + + if (category > 0) { + if (flag->getValue()) + ++mNumBoolFlagsPerCategory[category - 1]; + else + --mNumBoolFlagsPerCategory[category - 1]; + } + break; + } + } + } + + mFlagChangeRecordIndices[i] = 0; + other.mBitFlags.ref().reset(BitFlag::_8); + } + return; + } +} + s32 TriggerParam::getBoolIdx(u32 name) const { return getFlagIndex(mBoolFlags, name); } diff --git a/src/KingSystem/GameData/gdtTriggerParam.h b/src/KingSystem/GameData/gdtTriggerParam.h index 4a86160a..c122e739 100644 --- a/src/KingSystem/GameData/gdtTriggerParam.h +++ b/src/KingSystem/GameData/gdtTriggerParam.h @@ -39,6 +39,21 @@ public: }; KSYS_CHECK_SIZE_NX150(FlagChangeRecord, 0x8); + struct FlagCopyRecord { + enum class BitFlag : u8 { + _1 = 1, + _2 = 2, + _4 = 4, + _7 = _1 | _2 | _4, + _8 = 8, + }; + + sead::TypedBitFlag bit_flag; + s16 sub_index; + u32 name_hash; + }; + KSYS_CHECK_SIZE_NX150(FlagCopyRecord, 0x8); + TriggerParam(); void copyFromGameDataRes(res::GameData* gdata, sead::Heap* heap); @@ -414,13 +429,23 @@ public: FlagS32* getS32FlagByHash(u32 name_hash) const; void onResetBoolFlagForRadarMgr(FlagBase* flag, s32 sub_idx = -1); + bool getBoolIfChanged(bool* value, const sead::SafeString& name, bool x, bool y) const; + bool getS32IfChanged(s32* value, const sead::SafeString& name, bool x, bool y) const; + bool getF32IfChanged(f32* value, const sead::SafeString& name, bool x, bool y) const; + + void copyChangedFlags(TriggerParam& other, bool set_all_flags, bool y, bool z); + private: enum class BitFlag : u8 { + _1 = 1, + _2 = 2, + _4 = 4, + _7 = _1 | _2 | _4, _8 = 8, EventAssociatedFlagModified = 0x10, }; - void allocCombinedFlagArrays(sead::Heap* heap); + void allocCopyRecordArrays(sead::Heap* heap); void updateBoolFlagCounts(); void initResetData(sead::Heap* heap); void initRevivalRandomBools(sead::Heap* heap); @@ -451,15 +476,15 @@ private: sead::SafeArray>, 3> mFlagChangeRecords{}; - sead::ObjArray mCombinedBoolFlags; - sead::ObjArray mCombinedS32Flags; - sead::ObjArray mCombinedF32Flags; - sead::ObjArray mCombinedStringFlags; - sead::ObjArray mCombinedString64Flags; - sead::ObjArray mCombinedString256Flags; - sead::ObjArray mCombinedVector2fFlags; - sead::ObjArray mCombinedVector3fFlags; - sead::ObjArray mCombinedVector4fFlags; + sead::ObjArray mCopiedBoolFlags; + sead::ObjArray mCopiedS32Flags; + sead::ObjArray mCopiedF32Flags; + sead::ObjArray mCopiedStringFlags; + sead::ObjArray mCopiedString64Flags; + sead::ObjArray mCopiedString256Flags; + sead::ObjArray mCopiedVector2fFlags; + sead::ObjArray mCopiedVector3fFlags; + sead::ObjArray mCopiedVector4fFlags; sead::Buffer mResetEntries; sead::PtrArray mRevivalRandomBools;