some fManager, fBase, mHeap, f - lists and tree stuff

src/d/a/d_a_base.cpp

@@ -6,49 +6,35 @@
 u32 dAcBase_c::s_Create_RoomId = -1;
 u32 dAcBase_c::s_Create_Params2 = -1;
 u16 dAcBase_c::s_Create_UnkFlags = -1;
-u8  dAcBase_c::s_Create_ViewClipIdx = -1;
+u8 dAcBase_c::s_Create_ViewClipIdx = -1;
 
 // .sbss
-mVec3_c* dAcBase_c::s_Create_Position;
-mAng3_c* dAcBase_c::s_Create_Rotation;
-mVec3_c* dAcBase_c::s_Create_Scale;
-dAcBase_c* dAcBase_c::s_Create_Parent;
-ObjInfo* dAcBase_c::s_Create_ObjInfo;
+mVec3_c *dAcBase_c::s_Create_Position;
+mAng3_c *dAcBase_c::s_Create_Rotation;
+mVec3_c *dAcBase_c::s_Create_Scale;
+dAcBase_c *dAcBase_c::s_Create_Parent;
+ObjInfo *dAcBase_c::s_Create_ObjInfo;
 u8 dAcBase_c::s_Create_Subtype;
 
-extern "C" ObjInfo* getObjByActorIdAndSubtype_unkNamespace(ProfileName, u8);
-extern "C" char* getObjectName_8006a730(ObjInfo*);
-extern "C" void* soundForActorInitRelated_803889c0(s8, fBase_c*, char*, u8);
+extern "C" ObjInfo *getObjByActorIdAndSubtype_unkNamespace(ProfileName, u8);
+extern "C" char *getObjectName_8006a730(ObjInfo *);
+extern "C" void *soundForActorInitRelated_803889c0(s8, fBase_c *, char *, u8);
 
 bool dAcBase_c::createHeap() {
     return true;
 }
 
 // Doesnt Match Yet
-dAcBase_c::dAcBase_c() :
-    heap_allocator() ,
-    obj_info(s_Create_ObjInfo),
-    sound_info_tail(&heap_allocator.mHeap),
-    sound_info_next(&heap_allocator.mHeap),
-    count(0),
-    obj_sound(nullptr),
-    obj_pos(&position),
-    params2(s_Create_Params2),
-    obj_id(s_Create_UnkFlags),
-    viewclip_index(s_Create_ViewClipIdx),
-    actor_node(),
-    roomid(s_Create_RoomId),
-    actor_subtype(s_Create_Subtype)
-{
+dAcBase_c::dAcBase_c()
+    : heap_allocator(), obj_info(s_Create_ObjInfo), sound_info_tail(&heap_allocator.mHeap),
+      sound_info_next(&heap_allocator.mHeap), count(0), obj_sound(nullptr), obj_pos(&position),
+      params2(s_Create_Params2), obj_id(s_Create_UnkFlags), viewclip_index(s_Create_ViewClipIdx), actor_node(),
+      roomid(s_Create_RoomId), actor_subtype(s_Create_Subtype) {
     JStudio_actor = 0;
     someStr[0] = 0;
     if (s_Create_Position != nullptr) {
         // void set(f32 fx, f32 fy, f32 fz) { x = fx; y = fy; z = fz; }
-        position.set(
-            s_Create_Position->x,
-            s_Create_Position->y,
-            s_Create_Position->z 
-        );
+        position.set(s_Create_Position->x, s_Create_Position->y, s_Create_Position->z);
         // position = *s_Create_Position;
     }
     if (s_Create_Rotation != 0) {
@@ -59,27 +45,23 @@ dAcBase_c::dAcBase_c() :
     } else {
         setScale(1.0, 1.0, 1.0);
     }
-    if (s_Create_Parent != 0){
+    if (s_Create_Parent != 0) {
         setActorRef(s_Create_Parent);
     }
-    fProfile::fActorProfile_c* profile = (fProfile::fActorProfile_c*)((*fProfile::sProfileList)[profile_name]);
+    fProfile::fActorProfile_c *profile = (fProfile::fActorProfile_c *)((*fProfile::sProfileList)[profile_name]);
     actor_properties = profile->mActorProperties;
     if (obj_info == nullptr) {
         obj_info = getObjByActorIdAndSubtype_unkNamespace(profile_name, actor_subtype);
     }
     someStr[0] = '\0';
-}   
+}
 
 /* 8002c530 */ dBase_c::~dBase_c() {}
 
 dAcBase_c::~dAcBase_c() {}
 
-void dAcBase_c::setTempCreateParams( \
-    mVec3_c* pos, mAng3_c* rot, mVec3_c* scale, \
-    s32 roomId, u32 params2, dAcBase_c* parent, \
-    u8 subtype, s16 unkFlag, u8 viewClipIdx,\
-    ObjInfo* objInfo ) 
-{
+void dAcBase_c::setTempCreateParams(mVec3_c *pos, mAng3_c *rot, mVec3_c *scale, s32 roomId, u32 params2,
+        dAcBase_c *parent, u8 subtype, s16 unkFlag, u8 viewClipIdx, ObjInfo *objInfo) {
     s_Create_Position = pos;
     s_Create_Rotation = rot;
     s_Create_Scale = scale;
@@ -93,25 +75,25 @@ void dAcBase_c::setTempCreateParams( \
 }
 
 // has regswap
-void* dAcBase_c::FUN_8002c690() {
+void *dAcBase_c::FUN_8002c690() {
     if (obj_info == nullptr) {
         return nullptr;
     }
     s8 unk_val = obj_info->unk_0xA;
-    if ( unk_val == -1) {
+    if (unk_val == -1) {
         return nullptr;
     }
-    char* objName = getObjectName_8006a730(obj_info);
+    char *objName = getObjectName_8006a730(obj_info);
     return soundForActorInitRelated_803889c0(unk_val, this, objName, subtype);
 }
 
-int dAcBase_c::initAllocatorWork1Heap(int size, char* name, int align) {
-    initAllocator(size, name, dHeap::work1Heap, align);
+int dAcBase_c::initAllocatorWork1Heap(int size, char *name, int align) {
+    return initAllocator(size, name, dHeap::work1Heap.heap, align);
 }
 
-extern "C" int fn_802EE510(mAllocator_c*, int size, EGG::Heap* heap, char* name, int align, int unk);
-int dAcBase_c::initAllocator(int size, char* name, EGG::Heap* heap, int align) {
-    if (fn_802EE510(&heap_allocator, size, heap, name, 0x20, 0) == 0){
+extern "C" int fn_802EE510(mAllocator_c *, int size, EGG::Heap *heap, char *name, int align, int unk);
+int dAcBase_c::initAllocator(int size, char *name, EGG::Heap *heap, int align) {
+    if (fn_802EE510(&heap_allocator, size, heap, name, 0x20, 0) == 0) {
         return 0;
     }
     obj_sound = FUN_8002c690();
@@ -121,11 +103,11 @@ int dAcBase_c::initAllocator(int size, char* name, EGG::Heap* heap, int align) {
 }
 
 bool dAcBase_c::addActorToRoom(s32 roomId) {
-    dBase_c* room = RoomManager::getRoom(roomId);
+    dBase_c *room = RoomManager::getRoom(roomId);
     if (room == nullptr) {
         return false;
     }
-    if (setConnectChild(room)){
+    if (setConnectChild(room)) {
         if (roomId == -1) {
             this->roomid = RoomManager::m_Instance->curr_room_id;
         } else {
@@ -149,7 +131,7 @@ int dAcBase_c::create() {
         return actorPostCreate();
     }
     int success = actorCreate();
-    if (success == SUCCEEDED){
+    if (success == SUCCEEDED) {
         success = NOT_READY;
         actor_properties |= 0x8000000;
     }
@@ -159,15 +141,13 @@ int dAcBase_c::create() {
 void dAcBase_c::postCreate(fBase_c::MAIN_STATE_e state) {
     if (state == SUCCESS) {
         pos_copy = position;
-        rot_copy = rotation; 
+        rot_copy = rotation;
         room_id_copy = roomid;
     }
     dBase_c::postCreate(state);
 }
 
-int dAcBase_c::preDelete() {
-
-}
+int dAcBase_c::preDelete() {}
 
 int dAcBase_c::preExecute() {
     if (dBase_c::preExecute() == NOT_READY) {
@@ -185,10 +165,14 @@ int dAcBase_c::execute() {}
 int dAcBase_c::actorExecute() {}
 int dAcBase_c::actorExecuteInEvent() {}
 void dAcBase_c::postExecute(fBase_c::MAIN_STATE_e state) {}
-void dAcBase_c::unkVirtFunc_0x5C() { return; }
-void dAcBase_c::unkVirtFunc_0x60() { return; }
+void dAcBase_c::unkVirtFunc_0x5C() {
+    return;
+}
+void dAcBase_c::unkVirtFunc_0x60() {
+    return;
+}
 bool dAcBase_c::restorePosRotFromCopy() {}
-u32 dAcBase_c::itemDroppingAndGivingRelated(Vec3f* spawnPos, int subtype) {}
+u32 dAcBase_c::itemDroppingAndGivingRelated(Vec3f *spawnPos, int subtype) {}
 void dAcBase_c::fillUpperParams2Byte() {}
 u32 dAcBase_c::getParams2_ignoreLower() {}
 void dAcBase_c::setParams2Upper_ignoreLower(u32 val) {}
@@ -196,29 +180,23 @@ u8 dAcBase_c::getParams2UpperByte() {}
 void dAcBase_c::setParams2UpperByte(u32 val) {}
 u32 dAcBase_c::buildParams2(u32 lower, u8 upper) {}
 u32 dAcBase_c::getParams2Lower() {}
-dAcBase_c* dAcBase_c::findActor(char* objName, dAcBase_c* parent) {}
+dAcBase_c *dAcBase_c::findActor(char *objName, dAcBase_c *parent) {}
 // searches for actor based on groupType
-dAcBase_c* dAcBase_c::searchActor(dAcBase_c& optionalParent) {}
+dAcBase_c *dAcBase_c::searchActor(dAcBase_c &optionalParent) {}
 
-void dAcBase_c::forEachActor(void*, dAcBase_c&) {}
+void dAcBase_c::forEachActor(void *, dAcBase_c &) {}
 mAng dAcBase_c::getXZAngleToPlayer() {}
-bool dAcBase_c::getDistanceToActor(dAcBase_c& actor, f32 distThresh, f32* outDist) {}
-bool dAcBase_c::getDistanceAndAngleToActor( \
-    dAcBase_c& actor, f32 distThresh, s16 yAngle, s16 xAngle, \
-    f32* outDist, s16* outDiffAngleY, s16* outDiffAngleX) 
-{
-
-}
+bool dAcBase_c::getDistanceToActor(dAcBase_c &actor, f32 distThresh, f32 *outDist) {}
+bool dAcBase_c::getDistanceAndAngleToActor(dAcBase_c &actor, f32 distThresh, s16 yAngle, s16 xAngle, f32 *outDist,
+        s16 *outDiffAngleY, s16 *outDiffAngleX) {}
 bool dAcBase_c::isWithinPlayerRadius(f32 radius) {}
-bool dAcBase_c::getDistanceAndAngleToPlayer( \
-    f32 distThresh, s16 yAngle, s16 xAngle, \
-    f32* outDist, s16* outDiffAngleY, s16* outDiffAngleX) 
-{
+bool dAcBase_c::getDistanceAndAngleToPlayer(f32 distThresh, s16 yAngle, s16 xAngle, f32 *outDist, s16 *outDiffAngleY,
+        s16 *outDiffAngleX) {
     // return getDistanceAndAngleToActor(PLAYER, distThresh, yAngle, xAngle, outDist, outDiffAngleY, outDiffAngleX);
 }
 
 f32 dAcBase_c::getDistToPlayer() {}
-f32 dAcBase_c::getSquareDistToPlayer() {} 
+f32 dAcBase_c::getSquareDistToPlayer() {}
 void dAcBase_c::updateRoomId(f32 yOffs) {}
 bool dAcBase_c::isRoomFlags_0x6_Set() {}
 void dAcBase_c::FUN_8002d590() {}
@@ -238,34 +216,30 @@ void dAcBase_c::FUN_8002d810() {}
 void dAcBase_c::FUN_8002d830() {}
 void dAcBase_c::FUN_8002d860() {}
 void dAcBase_c::FUN_8002d880() {}
- // first param is not dAcBase_c
+// first param is not dAcBase_c
 void dAcBase_c::FUN_8002d890() {}
- // current name is Global__setActorRef
-void dAcBase_c::setActorRef(dBase_c*) {}
- // May not be only purpose
+// current name is Global__setActorRef
+void dAcBase_c::setActorRef(dBase_c *) {}
+// May not be only purpose
 void dAcBase_c::setUnkFlag() {}
 void dAcBase_c::FUN_8002d940() {}
 void dAcBase_c::FUN_8002d960() {}
 
 // spawns GroupType2 (ACTOR)
-dAcBase_c dAcBase_c::createActor( \
-    ProfileName actorId, u32 params1, \
-    Vec3f* pos, Vec3s* rot, Vec3f* scale, \
-    u32 params2, s32 roomId, dBase_c* ref) {}
+dAcBase_c dAcBase_c::createActor(ProfileName actorId, u32 params1, Vec3f *pos, Vec3s *rot, Vec3f *scale, u32 params2,
+        s32 roomId, dBase_c *ref) {}
 
-dAcBase_c dAcBase_c::createActorUnkGroup3( \
-    ProfileName actorId, u32 params1, \
-    Vec3f* pos, Vec3s* rot, Vec3f* scale, \
-    u32 params2, s32 roomId, dBase_c* ref) {}
+dAcBase_c dAcBase_c::createActorUnkGroup3(ProfileName actorId, u32 params1, Vec3f *pos, Vec3s *rot, Vec3f *scale,
+        u32 params2, s32 roomId, dBase_c *ref) {}
 
-void* dAcBase_c::getCurrentEventActor() {}
+void *dAcBase_c::getCurrentEventActor() {}
 void dAcBase_c::unkVirtFunc_0x6C() {}
 void dAcBase_c::doInteraction(s32) {}
-void dAcBase_c::FUN_8002dc20(s16*, s16*) {}
+void dAcBase_c::FUN_8002dc20(s16 *, s16 *) {}
 void dAcBase_c::incrementKillCounter() {}
 void dAcBase_c::FUN_8002dcd0() {}
 void dAcBase_c::FUN_8002dd10() {}
 void dAcBase_c::FUN_8002dd50() {}
 void dAcBase_c::FUN_8002dd90() {}
 void dAcBase_c::FUN_8002ddd0() {}
-void dAcBase_c::FUN_8002de30() {}
+void dAcBase_c::FUN_8002de30() {}

src/d/d_heap.cpp

@@ -0,0 +1,47 @@
+#include <d/d_heap.h>
+
+dHeap dHeap::work1Heap;
+dHeap dHeap::work2Heap;
+dHeap dHeap::workExHeap;
+dHeap dHeap::layoutHeap;
+dHeap dHeap::layoutExHeap;
+dHeap dHeap::layoutEx2Heap;
+dHeap dHeap::layoutResHeap;
+dHeap dHeap::fontHeap;
+dHeap dHeap::HBMHeap;
+
+EGG::ExpHeap *dHeap::init(const char *name, size_t size, EGG::Heap *parent) {
+    heap = EGG::ExpHeap::create(size, parent, 4);
+    if (heap != nullptr) {
+        heap->setGroupID(0);
+        heap->mName = name;
+    }
+    return heap;
+}
+void dHeap::createWork1Heap(size_t size, EGG::Heap *parent) {
+    work1Heap.init("ゲーム用作業用ヒープ(dHeap::work1Heap)", size, parent);
+}
+void dHeap::createWork2Heap(size_t size, EGG::Heap *parent) {
+    work2Heap.init("ゲーム用作業用ヒープ(dHeap::work2Heap)", size, parent);
+}
+void dHeap::createWorkExHeap(size_t size, EGG::Heap *parent) {
+    workExHeap.init("ゲーム用拡張作業用ヒープ(dHeap::workExHeap)", size, parent);
+}
+void dHeap::createLayoutHeap(size_t size, EGG::Heap *parent) {
+    layoutHeap.init("レイアウト作業用ヒープ(dHeap::layoutHeap)", size, parent);
+}
+void dHeap::createLayoutExHeap(size_t size, EGG::Heap *parent) {
+    layoutExHeap.init("レイアウト拡張作業用ヒープ(dHeap::layoutExHeap)", size, parent);
+}
+void dHeap::createLayoutEx2Heap(size_t size, EGG::Heap *parent) {
+    layoutEx2Heap.init("レイアウト拡張作業用ヒープ2(dHeap::layoutEx2Heap)", size, parent);
+}
+void dHeap::createLayoutResHeap(size_t size, EGG::Heap *parent) {
+    layoutResHeap.init("レイアウトリソース用ヒープ(dHeap::layoutResHeap)", size, parent);
+}
+void dHeap::createFontHeap(size_t size, EGG::Heap *parent) {
+    fontHeap.init("フォント用ヒープ(dHeap::fontHeap)", size, parent);
+}
+void dHeap::createHBMHeap(size_t size, EGG::Heap *parent) {
+    HBMHeap.init("HBM用ヒープ(dHeap::HBMHeap)", size, parent);
+}

src/f/f_base.cpp

@@ -1,31 +1,92 @@
 #include "f/f_base.h"
+#include "MSL_C/string.h"
+#include "m/m_heap.h"
 
 /*
 .text File Range:
     [802e12f0 - 802e2680]
 */
 
-// This file will be ported from https://github.com/NSMBW-Community/NSMBW-Decomp/blob/master/source/dol/framework/f_base.cpp
+// This file will be ported from
+// https://github.com/NSMBW-Community/NSMBW-Decomp/blob/master/source/dol/framework/f_base.cpp
 
 fBaseID_e fBase_c::m_rootUniqueID = FIRST_ID;
-ProfileName fBase_c::m_tmpCtProfName;
-u32 fBase_c::m_tmpCtParam;
-u8 fBase_c::m_tmpCtGroupType;
-fTrNdBa_c *fBase_c::m_tmpCtConnectParent;
 
-//   0x80575bb0: sLoadAsyncCallback__7fBase_c
-//   0x80575bb4: sUnloadCallback__7fBase_c
+fBase_c::ConstructData fBase_c::m_tmpCtData;
+
+// 0x80575bb0: sLoadAsyncCallback__7fBase_c
+// 0x80575bb4: sUnloadCallback__7fBase_c
+fLiMgBa_c fBase_c::m_forceExecuteList;
 int (*fBase_c::sLoadAsyncCallback)();
 void (*fBase_c::sUnloadCallback)();
 
 /* 802e12f0 */
-fBase_c::fBase_c() : manager(this) {}
+fBase_c::fBase_c()
+    : unique_ID(m_rootUniqueID), params(m_tmpCtData.params), profile_name(m_tmpCtData.prof_name),
+      group_type(m_tmpCtData.group_type), manager(this) {
+    fManager_c *mgr = &manager;
+
+    m_rootUniqueID = (fBaseID_e)(m_rootUniqueID + 1);
+    if (m_rootUniqueID == INVALID) {
+        for (;;) {
+            continue;
+        }
+    }
+
+    fManager_c::m_connectManage.addTreeNode(&mgr->connect_node, m_tmpCtData.connect_parent);
+    int searchTableIdx = mgr->getSearchTableNum();
+    fManager_c::m_searchManage[searchTableIdx].prepend(&manager.search_node);
+
+    const fProfile::fBaseProfile_c *profile = (*fProfile::sProfileList)[profile_name];
+    if (profile != nullptr) {
+        manager.execute_node.setOrder(profile->m_execute_order);
+        manager.draw_node.setOrder(profile->m_draw_order);
+    }
+
+    fBase_c *parent = getConnectParent();
+    if (parent != nullptr) {
+        if (parent->isProcControlFlag(ROOT_DISABLE_EXECUTE) || parent->isProcControlFlag(DISABLE_EXECUTE)) {
+            setProcControlFlag(DISABLE_EXECUTE);
+        }
+        if (parent->isProcControlFlag(ROOT_DISABLE_DRAW) || parent->isProcControlFlag(DISABLE_DRAW)) {
+            setProcControlFlag(DISABLE_DRAW);
+        }
+    }
+}
 
 /* 802e1480 */
-fBase_c::~fBase_c() {}
+fBase_c::~fBase_c() {
+    fLiNdBa_c *node = actor_list.getFirst();
+    while (node != nullptr) {
+        node->unlink();
+        node = actor_list.getFirst();
+    }
+}
 
 /* 802e1500 */
-int fBase_c::commonPack(int (fBase_c::*doFunc)(), int (fBase_c::*preFunc)(), void (fBase_c::*postFunc)(MAIN_STATE_e)) {}
+int fBase_c::commonPack(int (fBase_c::*doFunc)(), int (fBase_c::*preFunc)(), void (fBase_c::*postFunc)(MAIN_STATE_e)) {
+    MAIN_STATE_e state;
+
+    // Pre Function to setup
+    int result = (this->*preFunc)();
+    if (result) {
+        // Do function to handle current
+        result = (this->*doFunc)();
+        if (result == NOT_READY) {
+            state = WAITING;
+        } else if (result == SUCCEEDED) {
+            state = SUCCESS;
+        } else {
+            state = ERROR;
+        }
+    } else {
+        state = CANCELED;
+    }
+
+    // Post Function to handle after effects (Allows for retry after waiting)
+    (this->*postFunc)(state);
+    return result;
+}
 
 /* 802e15c0 */
 int fBase_c::create() {
@@ -33,115 +94,533 @@ int fBase_c::create() {
 }
 
 /* 802e15d0 */
-int fBase_c::preCreate() {}
+int fBase_c::preCreate() {
+    return SUCCEEDED;
+}
 
 /* 802e15e0 */
-void fBase_c::postCreate(MAIN_STATE_e state) {}
+void fBase_c::postCreate(MAIN_STATE_e state) {
+    if (state == SUCCESS) {
+        fManager_c::m_createManage.remove(&manager.execute_node);
+        if (fManager_c::m_nowLoopProc == fManager_c::EXECUTE) {
+            update_request = true;
+        } else {
+            fManager_c::m_executeManage.addNode(&manager.execute_node);
+            fManager_c::m_drawManage.addNode(&manager.draw_node);
+            lifecycle_state = ACTIVE;
+        }
+    } else if (state == ERROR) {
+        deleteRequest();
+    }
+}
 
 /* 802e1670 */
-int fBase_c::doDelete() {}
+int fBase_c::doDelete() {
+    return 1;
+}
 
 /* 802e1680 */
-int fBase_c::createPack() {}
+int fBase_c::createPack() {
+    // Returns PACK_RESULT_e
+    return commonPack(&create, &preCreate, &postCreate);
+}
 
 /* 802e1730 */
-int fBase_c::preDelete() {}
+int fBase_c::preDelete() {
+    if (p_helper != nullptr && !p_helper->LoadOnlyOne()) {
+        return NOT_READY;
+    }
+
+    // Not ready for delete if it has children (children need deletion to process first)
+    fBase_c *child = getConnectChild();
+    if (child != nullptr) {
+        return NOT_READY;
+    }
+
+    return SUCCEEDED;
+}
 
 /* 802e17a0 */
-void fBase_c::postDelete(MAIN_STATE_e state) {}
+void fBase_c::postDelete(MAIN_STATE_e state) {
+    // If the Actor is ready for deletion, make sure that it is:
+    // - Removed from the connection tree
+    // - Removed form the search tree
+    // - Removed from the execute node from delete list (is being processed now)
+    // - Remove the Healp Allocation
+    // Helper Delete I guess
+    // - Finally Destroy the Object and ppoof it goes
+    if (state == SUCCESS) {
+        fManager_c::m_connectManage.removeTreeNode(&manager.connect_node);
+        int searchTableIdx = manager.getSearchTableNum();
+        fManager_c::m_searchManage[searchTableIdx].remove(&manager.search_node);
+        fManager_c::m_deleteManage.remove(&manager.execute_node);
+
+        if (p_heap != nullptr) {
+            p_heap->destroy();
+        }
+
+        if (p_helper != nullptr) {
+            p_helper->Delete();
+        }
+
+        delete this;
+    }
+}
 
 /* 802e15d0 */
-int fBase_c::deletePack() {}
+int fBase_c::deletePack() {
+    // Returns PACK_RESULT_e
+    return commonPack(&doDelete, &preDelete, &postDelete);
+}
 
 /* 802e1910 */
-int fBase_c::execute() {}
+int fBase_c::execute() {
+    return SUCCEEDED;
+}
 
 /* 802e1920 */
-int fBase_c::preExecute() {}
+int fBase_c::preExecute() {
+    // Do not execute if it has been flagged for deletion or marked as non-execute
+    if (delete_request || isProcControlFlag(DISABLE_EXECUTE)) {
+        return NOT_READY;
+    }
+
+    return SUCCEEDED;
+}
 
 /* 802e1950 */
-void fBase_c::postExecute(MAIN_STATE_e state) {}
+void fBase_c::postExecute(MAIN_STATE_e state) {
+    // Implemented per Actor
+    return;
+}
 
 /* 802e1960 */
-int fBase_c::executePack() {}
+int fBase_c::executePack() {
+    // Returns PACK_RESULT_e
+    int result = commonPack(&execute, &preExecute, &postExecute);
+
+    // Check force update list (bamboo cut to force a cut type of thing)
+    fLiNdBa_c *node = m_forceExecuteList.getFirst();
+    while (node != nullptr) {
+        node->p_owner->commonPack(&execute, &preExecute, &postExecute);
+        fLiNdBa_c *tempNode = node->getNext();
+        m_forceExecuteList.remove(node);
+        node = tempNode;
+    }
+
+    return result;
+}
 
 /* 802e1a90 */
-int fBase_c::draw() {}
+int fBase_c::draw() {
+    return SUCCEEDED;
+}
 
 /* 802e1aa0 */
-int fBase_c::preDraw() {}
+int fBase_c::preDraw() {
+    // Do not draw if it has been flagged for deletion or marked as non-draw
+    if (delete_request || isProcControlFlag(DISABLE_DRAW)) {
+        return NOT_READY;
+    }
+
+    return SUCCEEDED;
+}
 
 /* 802e1ad0 */
-void fBase_c::postDraw(MAIN_STATE_e state) {}
+void fBase_c::postDraw(MAIN_STATE_e state) {
+    // Per Actor imple
+    return;
+}
 
 /* 802e1ae0 */
-int fBase_c::drawPack() {}
+int fBase_c::drawPack() {
+    // Returns PACK_RESULT_e
+    return commonPack(&draw, &preDraw, &postDraw);
+}
 
 /* 802e1b90 */
 void fBase_c::deleteReady() {}
 
 /* 802e1ba0 */
-int fBase_c::connectProc() {}
+int fBase_c::connectProc() {
+    if (delete_request) {
+        delete_request = false;
+        if (lifecycle_state == ACTIVE) {
+            if (update_request != UPDATE_FORCE) {
+                fManager_c::m_executeManage.remove(&manager.execute_node);
+                update_request = UPDATING;
+            }
+            fManager_c::m_drawManage.remove(&manager.draw_node);
+        } else {
+            fManager_c::m_createManage.remove(&manager.execute_node);
+        }
+
+        // Add to Deletion list and flag as to be deleted
+        fManager_c::m_deleteManage.prepend(&manager.execute_node);
+        lifecycle_state = TO_BE_DELETED;
+
+        // Add all children to be marked as ready to delete
+        for (fTrNdBa_c *node = manager.connect_node.getChild(); node != nullptr; node = node->getBrNext()) {
+            node->p_owner->deleteRequest();
+        }
+    } else {
+        fBase_c *conn_parent = getConnectParent();
+        if (conn_parent != nullptr) {
+            if (conn_parent->isProcControlFlag(ROOT_DISABLE_EXECUTE) ||
+                    conn_parent->isProcControlFlag(DISABLE_EXECUTE)) {
+                setProcControlFlag(DISABLE_EXECUTE);
+            } else if (isProcControlFlag(DISABLE_EXECUTE)) {
+                clearProcControlFlag(DISABLE_EXECUTE);
+            }
+
+            if (conn_parent->isProcControlFlag(ROOT_DISABLE_DRAW) || conn_parent->isProcControlFlag(DISABLE_DRAW)) {
+                setProcControlFlag(DISABLE_DRAW);
+            } else if (isProcControlFlag(DISABLE_DRAW)) {
+                clearProcControlFlag(DISABLE_DRAW);
+            }
+        }
+
+        // If Actor is already Active
+        if (lifecycle_state == ACTIVE) {
+            // If flaged for update, add to the global execute list
+            if (update_request == UPDATE_FORCE) {
+                fManager_c::m_executeManage.addNode(&manager.execute_node);
+                update_request = UPDATING;
+            }
+
+            // Change the priority nodes if order has changed
+            fLiNdPrio_c *ex = &manager.execute_node;
+            if (ex->isPriorityChange()) {
+                fManager_c::m_executeManage.remove(ex);
+
+                fLiNdPrio_c *t = &manager.execute_node;
+                t->updatePriority();
+                fManager_c::m_executeManage.addNode(t);
+            }
+
+            fLiNdPrio_c *draw = &manager.draw_node;
+            if (draw->isPriorityChange()) {
+                fManager_c::m_drawManage.remove(draw);
+
+                fLiNdPrio_c *t = &manager.draw_node;
+                t->updatePriority();
+                fManager_c::m_drawManage.addNode(t);
+            }
+
+        }
+        // If Actor Is Waiting for Creation
+        else if (lifecycle_state != TO_BE_DELETED) {
+            if (create_request) {
+                create_request = false;
+                fManager_c::m_createManage.append(&manager.execute_node);
+            } else {
+                if ((u8)update_request != UPDATING) {
+                    update_request = UPDATING;
+                    fManager_c::m_executeManage.addNode(&manager.execute_node);
+                    fManager_c::m_drawManage.addNode(&manager.draw_node);
+                    lifecycle_state = ACTIVE;
+                }
+            }
+        }
+    }
+
+    return SUCCEEDED;
+}
 
 /* 802e1e00 */
-void fBase_c::deleteRequest() {}
+void fBase_c::deleteRequest() {
+    if (!delete_request && lifecycle_state != TO_BE_DELETED) {
+        delete_request = true;
+        deleteReady();
+        // Add all children to be marked as ready to delete
+        for (fTrNdBa_c *node = manager.connect_node.getChild(); node != nullptr; node = node->getBrNext()) {
+            node->p_owner->deleteRequest();
+        }
+    }
+}
 
 /* 802e1e80 */
-// addNewActorToDrawList
+void fBase_c::forceUpdate() {
+    // There is probably an inline active here
+    if (((!delete_request && lifecycle_state != TO_BE_DELETED) && lifecycle_state != ACTIVE) &&
+            (update_request == UPDATE_REQUEST && fManager_c::m_nowLoopProc == fManager_c::EXECUTE)) {
+        update_request = UPDATE_FORCE;
+        fManager_c::m_drawManage.addNode(&manager.draw_node);
+        lifecycle_state = ACTIVE;
+        m_forceExecuteList.append(&manager.execute_node);
+    }
+}
 
 /* 802e1f10 */
-// getFirstActor
+fBase_c *fBase_c::getConnectRoot() {
+    if (fManager_c::m_connectManage.getRoot() != nullptr) {
+        return fManager_c::m_connectManage.getRoot()->p_owner;
+    }
+    return nullptr;
+}
 
 /* 802e1f30 */
-// getNextActor
+fBase_c *fBase_c::getConnectTreeNext(fBase_c *actor) {
+    fBase_c *ret = nullptr;
+
+    if (actor == nullptr) {
+        ret = getConnectRoot();
+    } else {
+        fTrNdBa_c *node = actor->manager.connect_node.getTreeNext();
+        if (node != nullptr) {
+            ret = node->p_owner;
+        }
+    }
+    return ret;
+}
 
 /* 802e1f90 */
-fBase_c* fBase_c::getConnectParent() const {}
+fBase_c *fBase_c::getConnectParent() const {
+    fTrNdBa_c *node = manager.connect_node.getParent();
+    if (node != nullptr) {
+        return node->p_owner;
+    }
+    return nullptr;
+}
 
 /* 802e1fb0 */
-fBase_c* fBase_c::getConnectChild() const {}
+fBase_c *fBase_c::getConnectChild() const {
+    fTrNdBa_c *node = manager.connect_node.getChild();
+    if (node != nullptr) {
+        return node->p_owner;
+    }
+    return nullptr;
+}
 
 /* 802e1fd0 */
-fBase_c* fBase_c::getConnectBrNext() const {}
+fBase_c *fBase_c::getConnectBrNext() const {
+    fTrNdBa_c *node = manager.connect_node.getBrNext();
+    if (node != nullptr) {
+        return node->p_owner;
+    }
+    return nullptr;
+}
 
 /* 802e1ff0 */
-// FUN_802e1ff0
+void fBase_c::updateExecutePriority(u16 order) {
+    if (lifecycle_state == ACTIVE && update_request != UPDATE_FORCE) {
+        if (fManager_c::m_nowLoopProc == fManager_c::EXECUTE) {
+            manager.execute_node.m_new_order = order;
+        } else {
+            fManager_c::m_executeManage.remove(&manager.execute_node);
+            fLiNdPrio_c *node = &manager.execute_node;
+            node->setOrder(order);
+            fManager_c::m_executeManage.addNode(node);
+        }
+    } else {
+        manager.execute_node.setOrder(order);
+    }
+}
 
 /* 802e2090 */
-bool fBase_c::setConnectChild(fBase_c* child) {}
+bool fBase_c::setConnectChild(fBase_c *child) {
+    if (child == nullptr || child->lifecycle_state == TO_BE_DELETED) {
+        return false;
+    }
+
+    if (fManager_c::m_nowLoopProc == fManager_c::CONNECT) {
+        return false;
+    }
+
+    return fManager_c::m_connectManage.addTreeNode(&manager.connect_node, &child->manager.connect_node);
+}
 
 /* 802e20e0 */
-bool fBase_c::entryFrmHeap(unsigned long size, EGG::Heap *parentHeap) {}
+bool fBase_c::entryFrmHeap(size_t size, EGG::Heap *parentHeap) {
+    if (p_heap != nullptr) {
+        return true;
+    }
+
+    size_t heap_size = 0;
+    EGG::FrmHeap *new_heap = nullptr;
+
+    if (size != 0) {
+        new_heap = mHeap::makeFrmHeapAndUpdate(size, parentHeap, "各プロセスが個別で持てるヒープ(fBase_c::mHeap)", 0x20,
+                0);
+        if (new_heap != nullptr) {
+            bool create_sucess = createHeap();
+            mHeap::restoreCurrentHeap();
+            if (!create_sucess) {
+                mHeap::destroyFrmHeap(new_heap);
+                new_heap = nullptr;
+            } else {
+                heap_size = mHeap::adjustFrmHeap(new_heap);
+                if (size == heap_size) {
+                    p_heap = new_heap;
+                    return true;
+                }
+            }
+        }
+    }
+    if (new_heap == nullptr) {
+        new_heap =
+                mHeap::makeFrmHeapAndUpdate(-1, parentHeap, "各プロセスが個別で持てるヒープ(fBase_c::mHeap)", 0x20, 0);
+
+        if (new_heap != nullptr) {
+            bool create_sucess = createHeap();
+            mHeap::restoreCurrentHeap();
+            if (!create_sucess) {
+                mHeap::destroyFrmHeap(new_heap);
+                new_heap = nullptr;
+            } else {
+                heap_size = mHeap::adjustFrmHeap(new_heap);
+            }
+        }
+    }
+
+    if (new_heap != nullptr) {
+        EGG::FrmHeap *larger_heap = mHeap::makeFrmHeapAndUpdate(heap_size, parentHeap,
+                "各プロセスが個別で持てるヒープ(fBase_c::mHeap)", 0x20, 0);
+        if (larger_heap != nullptr) {
+            if (larger_heap < new_heap) {
+                mHeap::destroyFrmHeap(new_heap);
+                new_heap = nullptr;
+                bool create_sucess = createHeap();
+                mHeap::restoreCurrentHeap();
+                if (!create_sucess) {
+                    mHeap::destroyFrmHeap(larger_heap);
+                    larger_heap = nullptr;
+                } else {
+                    heap_size = mHeap::adjustFrmHeap(larger_heap);
+                    p_heap = larger_heap;
+                    return true;
+                }
+            } else {
+                mHeap::restoreCurrentHeap();
+                mHeap::destroyFrmHeap(larger_heap);
+            }
+        }
+    }
+
+    if (new_heap != nullptr) {
+        p_heap = new_heap;
+        return true;
+    }
+
+    deleteRequest();
+    return false;
+}
 
 /* 802e22e0 */
-bool fBase_c::entryFrmHeapNonAdjust(unsigned long size, EGG::Heap *parentHeap) {}
+bool fBase_c::entryFrmHeapNonAdjust(size_t size, EGG::Heap *parentHeap) {
+    if (p_heap != nullptr) {
+        return true;
+    }
+
+    EGG::FrmHeap *new_heap =
+            mHeap::makeFrmHeapAndUpdate(size, parentHeap, "各プロセスが個別で持てるヒープ(fBase_c::mHeap)", 0x20, 0);
+    if (new_heap != nullptr) {
+        bool create_sucess = createHeap();
+        mHeap::restoreCurrentHeap();
+        if (!create_sucess) {
+            mHeap::destroyFrmHeap(new_heap);
+        } else {
+            p_heap = new_heap;
+            return true;
+        }
+    }
+
+    deleteRequest();
+    return false;
+}
 
 /* 802e23a0 */
-bool fBase_c::createHeap() {}
+bool fBase_c::createHeap() {
+    return true;
+}
 
 /* 802e23b0 */
-void* fBase_c::operator new(size_t) {}
+void *fBase_c::operator new(size_t size) {
+    void *mem = EGG::Heap::alloc(size, -4, mHeap::g_gameHeaps[0]);
+    if (mem != nullptr) {
+        memset(mem, 0, size);
+    }
+    return mem;
+}
 
 /* 802e2410 */
-void fBase_c::operator delete(void*) {}
+void fBase_c::operator delete(void *block) {
+    EGG::Heap::free(block, mHeap::g_gameHeaps[0]);
+}
 
 /* 802e2420 */
-void fBase_c::runCreate() {}
+void fBase_c::runCreate() {
+    createPack();
+    if ((!delete_request && (u8)update_request == UPDATING) && lifecycle_state == WAITING_FOR_CREATE) {
+        if (fManager_c::m_nowLoopProc == fManager_c::CREATE) {
+            create_request = true;
+        } else {
+            fManager_c::m_createManage.append(&manager.execute_node);
+        }
+    }
+}
 
 /* 802e24a0 */
-fBase_c* fBase_c::getChildProcessCreateState() const {}
+fBase_c *fBase_c::getChildProcessCreateState() const {
+    const fTrNdBa_c *connect_node = &manager.connect_node;
+    fTrNdBa_c *end = connect_node->getTreeNextNotChild();
+    fTrNdBa_c *curr = connect_node->getChild();
+
+    while (curr != nullptr && curr != end) {
+        if (curr->p_owner->lifecycle_state == WAITING_FOR_CREATE) {
+            return curr->p_owner;
+        }
+        curr = curr->getTreeNext();
+    }
+    return nullptr;
+}
 
 /* 802e2510 */
-bool fBase_c::checkChildProcessCreateState() const {}
+bool fBase_c::checkChildProcessCreateState() const {
+    return getChildProcessCreateState() != nullptr;
+}
 
 /* 802e2540 */
-void fBase_c::setTmpCtData(ProfileName profName, fTrNdBa_c *connectParent, unsigned long param, u8 groupType) {}
+void fBase_c::setTmpCtData(ProfileName profile_name, fTrNdBa_c *connect_parent, unsigned long param, u8 group_type) {
+    m_tmpCtData.prof_name = profile_name;
+    m_tmpCtData.connect_parent = connect_parent;
+    m_tmpCtData.params = param;
+    m_tmpCtData.group_type = group_type;
+}
 
 /* 802e2560 */
-fBase_c* fBase_c::fBase_make(ProfileName profName, fTrNdBa_c *connectParent, unsigned long param, u8 groupType) {}
+fBase_c *fBase_c::fBase_make(ProfileName profile_name, fTrNdBa_c *connect_parent, unsigned long param, u8 group_type) {
+    if ((*fProfile::sProfileList)[profile_name] == nullptr) {
+        return nullptr;
+    }
+    if (fManager_c::m_nowLoopProc == fManager_c::DRAW) {
+        return nullptr;
+    }
+    setTmpCtData(profile_name, connect_parent, param, group_type);
+    fBase_c *actor = (fBase_c *)((*fProfile::sProfileList)[profile_name]->mpClassInit)();
+    setTmpCtData(0, nullptr, 0, 0);
+
+    if (actor != nullptr) {
+        actor->runCreate();
+    }
+
+    return actor;
+}
 
 /* 802e2600 */
-fBase_c* fBase_c::createChild(ProfileName profName, fBase_c *parent, unsigned long param, u8 groupType) {}
+fBase_c *fBase_c::createChild(ProfileName profile_name, fBase_c *parent, unsigned long param, u8 group_type) {
+    if (parent == nullptr) {
+        return nullptr;
+    }
+
+    if (parent->delete_request || parent->lifecycle_state == TO_BE_DELETED) {
+        return nullptr;
+    }
+
+    return fBase_make(profile_name, &parent->manager.connect_node, param, group_type);
+}
 
 /* 802e2640 */
-fBase_c* fBase_c::createRoot(ProfileName profName, unsigned long param, u8 groupType) {}
+fBase_c *fBase_c::createRoot(ProfileName profile_name, unsigned long param, u8 group_type) {
+    return fBase_make(profile_name, nullptr, param, group_type);
+}

src/f/f_list.cpp

@@ -0,0 +1,87 @@
+#include <f/f_base.h>
+#include <f/f_list_mg.h>
+#include <f/f_list_mg_ptmf.h>
+
+/* 802e2680 */
+void fLiMgPTMF_c::addNode(fLiNdPrio_c *add) {
+    fLiNdPrio_c *node = getFirst();
+
+    if (add == nullptr) {
+        return;
+    }
+
+    if (node == nullptr) {
+        append(add);
+        return;
+    }
+
+    if (node->getOrder() > add->getOrder()) {
+        insertAfter(add, nullptr);
+        return;
+    }
+
+    while (node->getNext() != nullptr && node->getNext()->getOrder() <= add->getOrder()) {
+        node = node->getNext();
+    }
+    insertAfter(add, node);
+}
+
+/* 802e26e0 */
+bool fLiMgPTMF_c::walkPack() {
+    if (mpProcFunc == nullptr) {
+        return true;
+    }
+
+    fLiNdBa_c *node = getFirst();
+    while (node != nullptr) {
+        fLiNdBa_c *next_node = node->getNext();
+        (node->p_owner->*mpProcFunc)();
+        node = next_node;
+    }
+
+    return true;
+}
+
+/* 802e2760 */
+const fLiNdBa_c *fLiMgBa_c::searchNodeByID(fBaseID_e id) const {
+    fLiNdBa_c *node = getFirst();
+    while (node != nullptr) {
+        if (node->p_owner->unique_ID == id) {
+            return node;
+        }
+        node = node->getNext();
+    }
+    return nullptr;
+}
+
+/* 802e2790 */
+const fLiNdBa_c *fLiMgBa_c::searchNodeByProfName(ProfileName name, fLiNdBa_c *start) const {
+    fLiNdBa_c *node = start != nullptr ? start->getNext() : getFirst();
+    while (node != nullptr) {
+        if (node->p_owner->profile_name == name) {
+            return node;
+        }
+        node = node->getNext();
+    }
+    return nullptr;
+}
+
+/* 802e27d0 */
+void fLiNdBa_c::link(fBase_c *link) {
+    if (p_owner != nullptr) {
+        unlink();
+    }
+
+    if (link != nullptr) {
+        p_owner = link;
+        link->actor_list.append(this);
+    }
+}
+
+/* 802e2830 */
+void fLiNdBa_c::unlink() {
+    if (p_owner != nullptr) {
+        reinterpret_cast<fBase_c *>(p_owner)->actor_list.remove(this);
+        p_owner = nullptr;
+    }
+}

src/f/f_manager.cpp

@@ -0,0 +1,83 @@
+#include <f/f_base.h>
+#include <f/f_manager.h>
+
+fTrMgPTMF_c fManager_c::m_connectManage(&fBase_c::connectProc);
+fLiMgPTMF_c fManager_c::m_createManage(&fBase_c::createPack);
+fLiMgPTMF_c fManager_c::m_executeManage(&fBase_c::executePack);
+fLiMgPTMF_c fManager_c::m_drawManage(&fBase_c::drawPack);
+fLiMgPTMF_c fManager_c::m_deleteManage(&fBase_c::deletePack);
+
+fLiMgBa_c fManager_c::m_searchManage[8];
+
+u32 fManager_c::m_StopProcInf;
+fManager_c::LOOP_PROC_e fManager_c::m_nowLoopProc = CONNECT;
+
+/* 802e28c0 */
+int fManager_c::getSearchTableNum() {
+    return reinterpret_cast<fBase_c *>(search_node.p_owner)->unique_ID & 7;
+}
+
+/* 802e28d0 */
+fBase_c *fManager_c::searchBaseByID(fBaseID_e id) {
+    const fLiNdBa_c *res = m_searchManage[id & 7].searchNodeByID(id);
+    if (res != nullptr) {
+        return res->p_owner;
+    }
+    return nullptr;
+}
+
+/* 802e2920 */
+fBase_c *fManager_c::searchBaseByProfName(ProfileName profID, const fBase_c *parent) {
+    const fTrNdBa_c *connect_node = parent != nullptr ? &parent->manager.connect_node : nullptr;
+
+    const fTrNdBa_c *node = m_connectManage.searchNodeByProfName(profID, connect_node);
+
+    if (node != nullptr) {
+        return node->p_owner;
+    }
+
+    return nullptr;
+}
+
+/* 802e2980 */
+fBase_c *fManager_c::searchBaseByGroupType(unsigned char groupType, const fBase_c *parent) {
+    const fTrNdBa_c *connect_node = parent != nullptr ? &parent->manager.connect_node : nullptr;
+
+    const fTrNdBa_c *node = m_connectManage.searchNodeByGroupType(groupType, connect_node);
+
+    if (node != nullptr) {
+        return node->p_owner;
+    }
+
+    return nullptr;
+}
+
+/* 802e29e0 */
+void fManager_c::mainLoop() {
+    if ((m_StopProcInf & PROC_FLAG_DELETE) == 0) {
+        m_nowLoopProc = DELETE;
+        m_deleteManage.walkPack();
+    }
+
+    if ((m_StopProcInf & PROC_FLAG_CREATE) == 0) {
+        m_nowLoopProc = CREATE;
+        m_createManage.walkPack();
+    }
+
+    if ((m_StopProcInf & PROC_FLAG_EXECUTE) == 0) {
+        m_nowLoopProc = EXECUTE;
+        m_executeManage.walkPack();
+    }
+
+    if ((m_StopProcInf & PROC_FLAG_DRAW) == 0) {
+        m_nowLoopProc = DRAW;
+        m_drawManage.walkPack();
+    }
+
+    if ((m_StopProcInf & PROC_FLAG_CONNECT) == 0) {
+        m_nowLoopProc = CONNECT;
+        m_connectManage.walkPack();
+    }
+
+    m_nowLoopProc = NOTHING;
+}

src/m/m_heap.cpp

@@ -0,0 +1,75 @@
+#include <egg/core/eggAssertHeap.h>
+#include <egg/core/eggExpHeap.h>
+#include <egg/core/eggFrmHeap.h>
+
+namespace mHeap {
+
+u8 g_DefaultGameHeapId = 1;
+static const char *s_GameHeapNames[4] = {
+        0,
+        "ゲーム用汎用ヒープ1(mHeap::gameHeaps[1])",
+        "ゲーム用汎用ヒープ2(mHeap::gameHeaps[2])",
+        0,
+};
+
+EGG::ExpHeap *g_gameHeaps[4];
+EGG::ExpHeap *s_SavedCurrentHeap;
+EGG::ExpHeap *g_archiveHeap;
+EGG::ExpHeap *g_commandHeap;
+EGG::ExpHeap *g_dylinkHeap;
+EGG::AssertHeap *g_assertHeap;
+
+u32 getHeapAttribute(u32) {}
+
+EGG::Heap *setCurrentHeap(EGG::Heap *heap) {
+    return heap->becomeCurrentHeap();
+}
+EGG::ExpHeap *createExpHeap(size_t, EGG::Heap *parent, const char *name, unsigned long, unsigned long) {}
+void adjustExpHeap(EGG::ExpHeap *) {}
+size_t expHeapCost(unsigned long, unsigned long) {}
+
+EGG::FrmHeap *createFrmHeap(unsigned long, EGG::Heap *, const char *, unsigned long, unsigned long) {}
+void destroyFrmHeap(EGG::FrmHeap *) {}
+size_t adjustFrmHeap(EGG::FrmHeap *) {}
+size_t frmHeapCost(unsigned long, unsigned long) {}
+
+EGG::ExpHeap *createHeap(unsigned long, EGG::Heap *, const char *) {}
+void saveCurrentHeap() {}
+void restoreCurrentHeap() {}
+
+int getDefaultGameHeapId() {
+    return g_DefaultGameHeapId;
+}
+
+inline bool isValidHeapId(u32 id) {
+    return id >= 1 && id <= 2;
+}
+
+EGG::ExpHeap *createGameHeap(int heapId, size_t size, EGG::Heap *parent) {
+    if (!isValidHeapId(heapId)) {
+        return nullptr;
+    }
+
+    g_gameHeaps[heapId] = createHeap(size, parent, s_GameHeapNames[heapId]);
+    if (heapId == g_DefaultGameHeapId) {
+        g_gameHeaps[0] = g_gameHeaps[heapId];
+    }
+    return g_gameHeaps[heapId];
+}
+EGG::ExpHeap *createGameHeap1(size_t size, EGG::Heap *parent) {
+    return createGameHeap(getDefaultGameHeapId(), size, parent);
+}
+EGG::ExpHeap *createArchiveHeap(size_t size, EGG::Heap *parent) {
+    g_archiveHeap = createHeap(size, parent, "");
+}
+EGG::ExpHeap *createCommandHeap(size_t size, EGG::Heap *parent) {
+    g_commandHeap = createHeap(size, parent, "DVD読み込みコマンド用ヒープ(mHeap::commandHeap)");
+}
+EGG::ExpHeap *createDylinkHeap(size_t size, EGG::Heap *parent) {
+    g_dylinkHeap = createHeap(size, parent, "ダイナミックリンク用ヒープ(mHeap::dylinkHeap)");
+}
+EGG::ExpHeap *createAssertHeap(EGG::Heap *parent) {
+    g_assertHeap = EGG::AssertHeap::create(EGG::AssertHeap::getSize(), parent);
+    g_assertHeap->mName = "アサートヒープ(mHeap::assertHeap)";
+}
+} // namespace mHeap