ksys/evt: Add OrderParam "add param" and assign functions

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

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<s32*>(other_ptr), *other_name))
+                        return false;
+                    break;
+                case OrderParamType::INT_2:
+                    if (!addParamInt2(*static_cast<s32*>(other_ptr), *other_name))
+                        return false;
+                    break;
+                case OrderParamType::STRING:
+                    if (!addParamString(*static_cast<sead::SafeString*>(other_ptr), *other_name))
+                        return false;
+                    break;
+                case OrderParamType::BYTE:
+                    if (!addParamByte(*static_cast<char*>(other_ptr), *other_name))
+                        return false;
+                    break;
+                case OrderParamType::ACTOR:
+                    link_ptr = static_cast<ksys::act::BaseProcLink*>(other_ptr);
+                    actor_ptr =
+                        sead::DynamicCast<ksys::act::BaseProc>(link_ptr->getProc(nullptr, nullptr));
+                    if (!addParamActor(actor_ptr, *other_name))
+                        return false;
+                    break;
+                case OrderParamType::ARRAY:
+                    if (!addParamArray(static_cast<char*>(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<s32>(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<s32>(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<sead::BufferedSafeString>(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<char>(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<ksys::act::BaseProcLink>(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<ksys::act::BaseProcLink>(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) {

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 <typename T>
-    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<T*>(ptr);
         return true;
     }
 
+    template <typename T>
+    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<T*>(entry->mPointer);
+    }
+
     inline void clearEntry(OrderParamEntry* e) {
         e->mHash = 0;
         e->mSize = 0;