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

ksys/gdt: Start adding TriggerParam's copy record functions

This commit is contained in:
Léo Lam 2020-10-31 14:58:32 +01:00
parent 2cd8eb111f
commit 1ccd65836d
No known key found for this signature in database
GPG Key ID: 0DF30F9081000741
4 changed files with 134 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
data/uking_functions.csv
View File

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

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

2
lib/sead

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

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

@ -430,6 +430,36 @@ void makeFlagProxies(sead::PtrArray<FlagBase>& dest, const sead::PtrArray<FlagBa
}
}
}
// TODO: remove noinline
template <typename T>
[[gnu::noinline]] void addFlagCopyRecord(sead::ObjArray<TriggerParam::FlagCopyRecord>& records,
Flag<T>* 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<FlagBool*>(mBoolFlags[record.index]);
const bool find_existing = mBitFlags.ref().isOn(BitFlag::_7);
flag->setValue(
static_cast<FlagBool*>(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<FlagBool*>((*mBoolArrayFlags[record.index])[record.sub_index]);
const bool find_existing = mBitFlags.ref().isOn(BitFlag::_7);
flag->setValue(static_cast<FlagBool*>(
(*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);
}

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

@ -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<BitFlag> 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<sead::StorageFor<sead::Buffer<FlagChangeRecord>>, 3> mFlagChangeRecords{};
sead::ObjArray<FlagBase> mCombinedBoolFlags;
sead::ObjArray<FlagBase> mCombinedS32Flags;
sead::ObjArray<FlagBase> mCombinedF32Flags;
sead::ObjArray<FlagBase> mCombinedStringFlags;
sead::ObjArray<FlagBase> mCombinedString64Flags;
sead::ObjArray<FlagBase> mCombinedString256Flags;
sead::ObjArray<FlagBase> mCombinedVector2fFlags;
sead::ObjArray<FlagBase> mCombinedVector3fFlags;
sead::ObjArray<FlagBase> mCombinedVector4fFlags;
sead::ObjArray<FlagCopyRecord> mCopiedBoolFlags;
sead::ObjArray<FlagCopyRecord> mCopiedS32Flags;
sead::ObjArray<FlagCopyRecord> mCopiedF32Flags;
sead::ObjArray<FlagCopyRecord> mCopiedStringFlags;
sead::ObjArray<FlagCopyRecord> mCopiedString64Flags;
sead::ObjArray<FlagCopyRecord> mCopiedString256Flags;
sead::ObjArray<FlagCopyRecord> mCopiedVector2fFlags;
sead::ObjArray<FlagCopyRecord> mCopiedVector3fFlags;
sead::ObjArray<FlagCopyRecord> mCopiedVector4fFlags;
sead::Buffer<ResetEntry> mResetEntries;
sead::PtrArray<FlagBool> mRevivalRandomBools;