From d4b49662e160330c8baf01e1bb6d387a5db2b543 Mon Sep 17 00:00:00 2001 From: iTNTPiston Date: Sat, 6 Feb 2021 01:58:06 -0500 Subject: [PATCH] ksys/evt: Add OrderParam "add param" and assign functions --- data/uking_functions.csv | 12 +- src/KingSystem/Event/evtOrderParam.cpp | 153 +++++++++++++++++++++---- src/KingSystem/Event/evtOrderParam.h | 36 ++++-- 3 files changed, 167 insertions(+), 34 deletions(-) diff --git a/data/uking_functions.csv b/data/uking_functions.csv index 98e61f37..31dfc19f 100644 --- a/data/uking_functions.csv +++ b/data/uking_functions.csv @@ -75589,13 +75589,13 @@ 0x0000007100db4808,ksys::evt::OrderParam::dtor,20, 0x0000007100db481c,ksys::evt::OrderParam::uninitialize,284,_ZN4ksys3evt10OrderParam12uninitializeEv 0x0000007100db4938,ksys::evt::OrderParam::dtorDelete,52, -0x0000007100db496c,ksys::evt::OrderParam::doAssign,1160, -0x0000007100db4df4,ksys::evt::OrderParam::assign,48, +0x0000007100db496c,ksys::evt::OrderParam::doAssign,1160,_ZN4ksys3evt10OrderParam8doAssignEPS1_ +0x0000007100db4df4,ksys::evt::OrderParam::assign,48,_ZN4ksys3evt10OrderParam6assignEPS1_ 0x0000007100db4e24,ksys::evt::OrderParam::initialize,332,_ZN4ksys3evt10OrderParam10initializeEi? -0x0000007100db4f70,ksys::evt::OrderParam::addParamInt,220, -0x0000007100db504c,ksys::evt::OrderParam::addParamStr,412, -0x0000007100db51e8,ksys::evt::OrderParam::tryAlloc_,944,_ZN4ksys3evt10OrderParam8tryAllocENS0_14OrderParamTypeEjRN4sead14SafeStringBaseIcEE? -0x0000007100db5598,ksys::evt::OrderParam::addParamActor,240,_ZN4ksys3evt10OrderParam13addParamActorERNS_3act8BaseProcERN4sead14SafeStringBaseIcEE? +0x0000007100db4f70,ksys::evt::OrderParam::addParamInt,220,_ZN4ksys3evt10OrderParam11addParamIntEiRKN4sead14SafeStringBaseIcEE +0x0000007100db504c,ksys::evt::OrderParam::addParamString,412,_ZN4ksys3evt10OrderParam14addParamStringERKN4sead14SafeStringBaseIcEES6_ +0x0000007100db51e8,ksys::evt::OrderParam::tryAlloc_,944,_ZN4ksys3evt10OrderParam8tryAllocENS0_14OrderParamTypeEjRKN4sead14SafeStringBaseIcEE? +0x0000007100db5598,ksys::evt::OrderParam::addParamActor,240,_ZN4ksys3evt10OrderParam13addParamActorEPNS_3act8BaseProcERN4sead14SafeStringBaseIcEE 0x0000007100db5688,ksys::evt::OrderParam::getIntByName,176,_ZN4ksys3evt10OrderParam12getIntByNameERKN4sead14SafeStringBaseIcEEPPj 0x0000007100db5738,ksys::evt::OrderParam::getStringByName,176,_ZN4ksys3evt10OrderParam15getStringByNameERKN4sead14SafeStringBaseIcEEPPS4_ 0x0000007100db57e8,ksys::evt::OrderParam::getArrayByName,208,_ZN4ksys3evt10OrderParam14getArrayByNameERKN4sead14SafeStringBaseIcEEPPvPj diff --git a/src/KingSystem/Event/evtOrderParam.cpp b/src/KingSystem/Event/evtOrderParam.cpp index 918fca06..0d4d0b64 100644 --- a/src/KingSystem/Event/evtOrderParam.cpp +++ b/src/KingSystem/Event/evtOrderParam.cpp @@ -71,41 +71,142 @@ void OrderParam::uninitialize() { mInitialized = false; } -// half done -void OrderParam::addParamActor(ksys::act::BaseProc& actor, sead::SafeString& name) { - u32 hash = sead::HashCRC32::calcStringHash(name.cstr()); - s32 i; - for (i = 0; i < mEntries.size(); i++) { - if (mEntries[i].mHash == hash && mEntries[i].mType == OrderParamType::ACTOR) { - if (!mEntries[i].mPointer) { - break; +const OrderParamEntry* OrderParam::getParam(const s32 index) const { + sead::FixedSafeString<0x100> error_message; + + error_message.format("[%s] getParam(%d) is failed.", "ksys::evt::OrderParam", index); + if ((u32)std::max(0, mEntries.size()) > (u32)index) { + return &mEntries[index]; + } else { + return nullptr; + } +} +OrderParam* OrderParam::assign(OrderParam* other) { + if (this != other) { + doAssign(other); + } + return this; +} + +bool OrderParam::doAssign(OrderParam* other) { + if (this == other) + return true; + if (!initialize(std::max(0, other->mEntries.size()))) + return false; + for (s32 i = 0; i < mEntries.size(); i++) { + auto* other_entry = other->getParam(i); + if (other_entry) { + auto* other_ptr = other_entry->mPointer; + auto* other_name = other_entry->mName; + ksys::act::BaseProcLink* link_ptr; + ksys::act::BaseProc* actor_ptr; + if (other_ptr && other_name) { + switch (other_entry->mType) { + case OrderParamType::INT: + if (!addParamInt(*static_cast(other_ptr), *other_name)) + return false; + break; + case OrderParamType::INT_2: + if (!addParamInt2(*static_cast(other_ptr), *other_name)) + return false; + break; + case OrderParamType::STRING: + if (!addParamString(*static_cast(other_ptr), *other_name)) + return false; + break; + case OrderParamType::BYTE: + if (!addParamByte(*static_cast(other_ptr), *other_name)) + return false; + break; + case OrderParamType::ACTOR: + link_ptr = static_cast(other_ptr); + actor_ptr = + sead::DynamicCast(link_ptr->getProc(nullptr, nullptr)); + if (!addParamActor(actor_ptr, *other_name)) + return false; + break; + case OrderParamType::ARRAY: + if (!addParamArray(static_cast(other_ptr), other_entry->mSize, + *other_name)) + return false; + break; + default: + break; + } } } } + return true; +} - auto* entry = tryAlloc(OrderParamType::ACTOR, 0, name); - if (entry) { - auto* actor_ptr = (ksys::act::BaseProcLink*)entry->mPointer; - if (actor_ptr->acquire(&actor, false)) { - ++this->mEntryCount; - } - } +bool OrderParam::addParamInt(s32 val, const sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::INT); + if (!entry_ptr) + return false; + *entry_ptr = val; + ++mEntryCount; + return true; +} + +bool OrderParam::addParamInt2(s32 val, const sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::INT_2); + if (!entry_ptr) + return false; + *entry_ptr = val; + ++mEntryCount; + return true; +} +bool OrderParam::addParamString(const sead::SafeString& val, const sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::STRING); + if (!entry_ptr) + return false; + entry_ptr->copy(val); + ++mEntryCount; + return true; +} + +bool OrderParam::addParamByte(char val, const sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::BYTE); + if (!entry_ptr) + return false; + *entry_ptr = val; + ++mEntryCount; + return true; +} + +bool OrderParam::addParamActor(ksys::act::BaseProc* actor, sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::ACTOR); + if (!entry_ptr) + return false; + if (!entry_ptr->acquire(actor, false)) + return false; + ++mEntryCount; + return true; +} + +bool OrderParam::addParamArray(char* array, u32 size, sead::SafeString& name) { + auto* entry_ptr = tryAllocParam(name, OrderParamType::ARRAY, size); + if (!entry_ptr) + return false; + std::memcpy(entry_ptr, array, size); + ++mEntryCount; + return true; } bool OrderParam::getIntByName(const sead::SafeString& name, u32** out_ptr) { - return getPointerByName(name, out_ptr, nullptr, OrderParamType::INT); + return getPointerByName(name, out_ptr, OrderParamType::INT); } bool OrderParam::getStringByName(const sead::SafeString& name, sead::SafeString** out_ptr) { - return getPointerByName(name, out_ptr, nullptr, OrderParamType::STRING); + return getPointerByName(name, out_ptr, OrderParamType::STRING); } bool OrderParam::getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size) { - return getPointerByName(name, out_ptr, out_size, OrderParamType::ARRAY); + return getPointerByName(name, out_ptr, OrderParamType::ARRAY, out_size); } // This one also does not match -OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, sead::SafeString& name) { +OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, const sead::SafeString& name) { sead::FixedSafeString<0x100> error_message; error_message.format("[%s] tryAlloc_(%d, %d, %s) is failed.", "ksys::evt::OrderParam", type, @@ -169,8 +270,18 @@ OrderParamEntry* OrderParam::tryAlloc(OrderParamType type, u32 size, sead::SafeS return nullptr; } -void* OrderParam::getPointerByName(const sead::SafeString& name, u32* out_size, - OrderParamType type) const { +// OrderParamEntry* OrderParam::getEntryByName(const sead::SafeString& name, OrderParamType type) { +// const u32 hash = sead::HashCRC32::calcStringHash(name); +// for (s32 i = 0; i < mEntries.size(); i++) { +// if (mEntries[i].mHash == hash && mEntries[i].mType == type) { +// return &mEntries[i]; +// } +// } +// return nullptr; +// } + +void* OrderParam::getPointerByName(const sead::SafeString& name, OrderParamType type, + u32* out_size) const { const u32 hash = sead::HashCRC32::calcStringHash(name); for (s32 i = 0; i < mEntries.size(); i++) { if (mEntries[i].mHash == hash && mEntries[i].mType == type) { diff --git a/src/KingSystem/Event/evtOrderParam.h b/src/KingSystem/Event/evtOrderParam.h index 11352a33..5eff171c 100644 --- a/src/KingSystem/Event/evtOrderParam.h +++ b/src/KingSystem/Event/evtOrderParam.h @@ -36,27 +36,49 @@ class OrderParam { public: bool initialize(s32 entry_count); void uninitialize(); + OrderParam* assign(OrderParam* other); - bool addParamInt(s32 val, const sead::SafeString& key); - void addParamActor(ksys::act::BaseProc& actor, sead::SafeString& name); - OrderParamEntry* tryAlloc(OrderParamType type, u32 size, sead::SafeString& name); + inline const OrderParamEntry* getParam(const s32 index) const; + bool addParamInt(s32 val, const sead::SafeString& name); + bool addParamInt2(s32 val, const sead::SafeString& name); + bool addParamString(const sead::SafeString& val, const sead::SafeString& name); + bool addParamByte(char val, const sead::SafeString& name); + bool addParamActor(ksys::act::BaseProc* actor, sead::SafeString& name); + bool addParamArray(char* array, u32 size, sead::SafeString& name); + + OrderParamEntry* tryAlloc(OrderParamType type, u32 size, const sead::SafeString& name); bool getIntByName(const sead::SafeString& name, u32** out_ptr); bool getStringByName(const sead::SafeString& name, sead::SafeString** out_ptr); bool getArrayByName(const sead::SafeString& name, void** out_ptr, u32* out_size); private: - void* getPointerByName(const sead::SafeString& name, u32* out_size, OrderParamType type) const; + bool doAssign(OrderParam* other); + // OrderParamEntry* getEntryByName(const sead::SafeString& name, OrderParamType type); + void* getPointerByName(const sead::SafeString& name, OrderParamType type, + u32* out_size = nullptr) const; template - bool getPointerByName(const sead::SafeString& name, T** out_ptr, u32* out_size, - OrderParamType type) const { - auto* ptr = getPointerByName(name, out_size, type); + bool getPointerByName(const sead::SafeString& name, T** out_ptr, OrderParamType type, + u32* out_size = nullptr) const { + auto* ptr = getPointerByName(name, type, out_size); if (!ptr) return false; *out_ptr = static_cast(ptr); return true; } + template + T* tryAllocParam(const sead::SafeString& name, OrderParamType type, u32 size = 0) { + auto* ptr = getPointerByName(name, type); + if (ptr) + return nullptr; + + auto* entry = tryAlloc(type, size, name); + if (!entry || !(entry->mPointer)) + return nullptr; + return static_cast(entry->mPointer); + } + inline void clearEntry(OrderParamEntry* e) { e->mHash = 0; e->mSize = 0;