ksys/evt: Implement Metadata

data/uking_functions.csv

@@ -75576,15 +75576,15 @@
 0x0000007100db37c0,EventMgr::setActorBeingDeletedOnContexts,128,
 0x0000007100db3840,j__ZdlPv_885,4,
 0x0000007100db3844,sinitEvent,408,
-0x0000007100db39dc,evt::Event::ctor,408,
+0x0000007100db39dc,evt::Event::ctor,408,_ZN4ksys3evt8MetadataC1Ev
-0x0000007100db3b74,evt::Event::reset,72,
+0x0000007100db3b74,evt::Event::reset,72,_ZN4ksys3evt8Metadata5resetEv
-0x0000007100db3bbc,evt::Event::ctorWithNames,456,
+0x0000007100db3bbc,evt::Event::ctorWithNames,456,_ZN4ksys3evt8MetadataC1EPKcS3_S3_
-0x0000007100db3d84,evt::Event::init,496,
+0x0000007100db3d84,evt::Event::init,496,_ZN4ksys3evt8Metadata4initEPKcS3_S3_
-0x0000007100db3f74,evt::Event::dtor,68,
+0x0000007100db3f74,evt::Event::dtor,68,_ZN4ksys3evt8MetadataD1Ev
-0x0000007100db3fb8,sub_7100DB3FB8,68,
+0x0000007100db3fb8,sub_7100DB3FB8,68,_ZN4ksys3evt8MetadataD0Ev
-0x0000007100db3ffc,evt::Event::doAssign,296,
+0x0000007100db3ffc,evt::Event::doAssign,296,_ZN4ksys3evt8Metadata9doAssign_ERKS1_
-0x0000007100db4124,evt::Event::assign,48,
+0x0000007100db4124,evt::Event::assign,48,_ZN4ksys3evt8MetadataaSERKS1_
-0x0000007100db4154,sub_7100DB4154,1680,
+0x0000007100db4154,sub_7100DB4154,1680,_ZN4ksys3evt8Metadata10initFlags_Ev
 0x0000007100db47e4,ksys::evt::OrderParam::ctor,36,_ZN4ksys3evt10OrderParamC1EPN4sead4HeapE
 0x0000007100db4808,ksys::evt::OrderParam::dtor,20,_ZN4ksys3evt10OrderParamD1Ev
 0x0000007100db481c,ksys::evt::OrderParam::uninitialize,284,_ZN4ksys3evt10OrderParam12uninitializeEv

src/KingSystem/Event/evtManager.h

@@ -23,9 +23,13 @@ public:
     Event* getActiveEvent() const;
     bool hasActiveEvent() const;
 
+    sead::Heap* getEventHeap() const { return mEventHeap; }
+
     bool callEvent(const Metadata& metadata, act::Actor* actor = nullptr, void* x = nullptr);
 
-    sead::Heap* mEventHeap;  // 0x1d180
+private:
+    u8 pad_20[0x1d178 - 0x20];
+    sead::Heap* mEventHeap;
 };
 
 }  // namespace ksys::evt

src/KingSystem/Event/evtMetadata.cpp

@@ -1 +1,115 @@
 #include "KingSystem/Event/evtMetadata.h"
+#include "KingSystem/Event/evtManager.h"
+#include "KingSystem/Event/evtOrderParam.h"
+
+namespace ksys::evt {
+
+Metadata::Metadata() {
+    reset();
+    initOrderParam_();
+}
+
+Metadata::Metadata(const char* event, const char* entry_point, const char* type) {
+    reset();
+    initOrderParam_();
+    init(event, entry_point, type);
+}
+
+Metadata::~Metadata() {
+    if (mOrderParam) {
+        delete mOrderParam;
+        mOrderParam = nullptr;
+    }
+}
+
+void Metadata::doAssign_(const Metadata& other) {
+    reset();
+    init(other.mEventName.cstr(), other.mEntryPointName.cstr(), other.mType.cstr());
+
+    mCurrentActor = other.mCurrentActor;
+    if (other.mSetNoDeleteCurrentActor)
+        mSetNoDeleteCurrentActor = true;
+    _18 = other._18;
+    _20 = other._20;
+    mIsAsync = other.mIsAsync;
+    mSkipIsStartableAirCheck = other.mSkipIsStartableAirCheck;
+    mForceNoChild = other.mForceNoChild;
+    _13 = other._13;
+    mEventStartWaitFrame = other.mEventStartWaitFrame;
+    if (mOrderParam && other.mOrderParam)
+        *mOrderParam = *other.mOrderParam;
+}
+
+Metadata& Metadata::operator=(const Metadata& other) {
+    if (this != &other)
+        doAssign_(other);
+    return *this;
+}
+
+void Metadata::init(const char* event, const char* entry_point, const char* type) {
+    mEventName = event;
+    mEntryPointName = entry_point;
+    mType = type;
+    initFlags_();
+}
+
+void Metadata::reset() {
+    mEventName.clear();
+    mEntryPointName.clear();
+    mType.clear();
+    mFlags = Flag::DefaultFlags;
+    _18 = {};
+    mIsAsync = false;
+    mSetNoDeleteCurrentActor = false;
+    mSkipIsStartableAirCheck = false;
+    mForceNoChild = false;
+    _13 = false;
+    mCurrentActor = nullptr;
+    _20 = 0;
+    mEventStartWaitFrame = -1;
+}
+
+void Metadata::initOrderParam_() {
+    if (mOrderParam)
+        return;
+
+    if (!Manager::instance())
+        return;
+
+    sead::Heap* heap = Manager::instance()->getEventHeap();
+    if (!heap)
+        return;
+
+    mOrderParam = new (heap, std::nothrow_t()) OrderParam(heap);
+    if (mOrderParam)
+        mOrderParam->initialize(8);
+}
+
+void Metadata::initFlags_() {
+    if (mEventName == "Demo006_0") {
+        mFlags = Flag::_4;
+    } else if (mEventName == "Demo017_0") {
+        mFlags = Flag::_4 | Flag::_1;
+    } else if (mEventName == "ClearRemains" || mEventName.comparen("Demo", 4) == 0) {
+        mFlags = Flag::_8 | Flag::_4 | Flag::_2 | Flag::_1;
+    } else if (mEventName.comparen("OpenDoor", 8) == 0) {
+        mFlags = Flag::_8 | Flag::_4 | Flag::_2 | Flag::_1;
+    } else if (mType == "Timeline") {
+        mFlags = Flag::_4;
+    } else if (mType == "Talk") {
+        mFlags = Flag::_100 | Flag::_80 | Flag::_10;
+    } else if (mType == "EachFrame") {
+        mFlags = Flag::_100 | Flag::_80 | Flag::_40 | Flag::_20 | Flag::_10 | Flag::_4;
+    } else if (mType == "Near" || mType == "NearActors") {
+        mFlags = Flag::_100 | Flag::_80 | Flag::_10 | Flag::_8 | Flag::_2;
+    } else if (mType == "StepStart") {
+        mFlags = Flag::_8 | Flag::_2;
+    } else if (mType == "Background") {
+        mFlags = Flag::_100 | Flag::_80 | Flag::_40 | Flag::_20 | Flag::_10 | Flag::_8 | Flag::_4 |
+                 Flag::_2;
+    } else {
+        mFlags = Flag::_40 | Flag::_20 | Flag::_4;
+    }
+}
+
+}  // namespace ksys::evt

src/KingSystem/Event/evtMetadata.h

@@ -1,11 +1,18 @@
 #pragma once
 
 #include <basis/seadTypes.h>
+#include <prim/seadSafeString.h>
+#include <prim/seadTypedBitFlag.h>
 #include "KingSystem/Utils/Types.h"
 
+namespace ksys::act {
+class Actor;
+}
+
 namespace ksys::evt {
 
-// FIXME: incomplete
+class OrderParam;
+
 class Metadata {
 public:
     Metadata();
@@ -13,8 +20,46 @@ public:
     explicit Metadata(const char* event) : Metadata(event, event) {}
     virtual ~Metadata();
 
+    Metadata(const Metadata& other) { *this = other; }
+    Metadata& operator=(const Metadata& other);
+
+    void init(const char* event, const char* entry_point, const char* type = "");
+    void reset();
+
 private:
-    u8 pad_0x8[0x158 - 0x8];
+    enum class Flag {
+        _1 = 1,
+        _2 = 2,
+        _4 = 4,
+        _8 = 8,
+        _10 = 0x10,
+        _20 = 0x20,
+        _40 = 0x40,
+        _80 = 0x80,
+        _100 = 0x100,
+
+        DefaultFlags = _4 | _20 | _40,
+    };
+    friend constexpr Flag operator|(Flag a, Flag b) { return Flag(u32(a) | u32(b)); }
+
+    void initOrderParam_();
+    void initFlags_();
+    void doAssign_(const Metadata& other);
+
+    act::Actor* mCurrentActor;
+    bool mSetNoDeleteCurrentActor;
+    bool mSkipIsStartableAirCheck;
+    bool mForceNoChild;
+    bool _13;
+    void* _18;
+    u32 _20;
+    int mEventStartWaitFrame;
+    sead::FixedSafeString<64> mEventName;
+    sead::FixedSafeString<128> mEntryPointName;
+    sead::FixedSafeString<16> mType;
+    sead::TypedBitFlag<Flag> mFlags = Flag::DefaultFlags;
+    OrderParam* mOrderParam{};
+    bool mIsAsync;
 };
 KSYS_CHECK_SIZE_NX150(Metadata, 0x158);