Decompile MapObjectProfile (#52)

* delink mapobj profile

* match base mapobjectprofile classes

* match other sections (+ accidental mapobject ctor match)

src/000_Second/Actor/Actor.cpp

@@ -21,7 +21,7 @@ ARM Actor::Actor() {
     this->mUnk_5c.func_ov000_020975f8();
     this->mRef.Reset();
     this->mType = NULL;
-    _MI_CpuCopy(&data_ov000_020b539c.mUnk_00, &this->mUnk_5c, sizeof(data_ov000_020b539c.mUnk_00));
+    _MI_CpuCopy(&data_ov000_020b539c_eur.mUnk_00, &this->mUnk_5c, sizeof(data_ov000_020b539c_eur.mUnk_00));
     this->mPos     = this->mUnk_5c.mUnk_00;
     this->mPrevPos = this->mUnk_5c.mUnk_00;
     this->mAngle   = this->mUnk_5c.mUnk_0c;
@@ -29,7 +29,7 @@ ARM Actor::Actor() {
     this->mUnk_44 = 0xFF;
     this->mUnk_46 = 0;
     this->func_ov000_0209862c(0);
-    this->func_ov000_0209848c(data_ov000_020b539c.mUnk_30);
+    this->func_ov000_0209848c(data_ov000_020b539c_eur.mUnk_30);
 }
 
 ARM Actor::~Actor() {}

src/000_Second/MapObject/MapObject.cpp

@@ -10,7 +10,6 @@
 #include "Unknown/UnkStruct_027e0ce0.hpp"
 #include "Unknown/UnkStruct_ov000_020b5d34.hpp"
 
-extern "C" void func_ov000_0209c7c8(void *);
 extern "C" void func_01ffb714(Vec3p *, Vec3p *, void *);
 extern "C" void func_01ffb9cc(Vec3p *, Vec3p *);
 extern "C" u16 func_01ffbbe0(q20 x, q20 z);
@@ -19,24 +18,17 @@ extern "C" bool func_01ffd768(unk32, void *, void *, unk8);
 
 extern "C" void func_ov000_020973f4(void *, void *, u32, void *, int); //! TODO: solve oddity
 
-struct UnkStruct {
-    u32 *mUnk_00;
-    MapObject_20 *mUnk_04;
-    Vec3p *mUnk_08;
-};
-
-// https://decomp.me/scratch/4do9S
 ARM MapObject::MapObject() {
     this->mUnk_10   = NULL;
     this->mUnk_16   = -1;
     this->mFlags[0] = 0;
-    func_ov000_0209c7c8(&this->mUnk_20);
+    this->mUnk_20.func_ov000_0209c7c8();
     *(u32 *) &this->mUnk_38 = 0;
 
     UnkStruct_ov000_020b5d34 *ptr1 = &data_ov000_020b5d34;
     this->mpProfile                = ptr1->mpProfile;
 
-    UnkStruct *ptr2 = (UnkStruct *) ptr1->mUnk_00;
+    UnkStruct_ov000_020b5d34_00 *ptr2 = ptr1->mUnk_00;
 
     *(u32 *) &this->mUnk_38 = *ptr2->mUnk_00;
 
@@ -45,7 +37,7 @@ ARM MapObject::MapObject() {
     this->mPos.y = ptr->y;
     this->mPos.z = ptr->z;
 
-    this->mUnk_14 = ptr1->mUnk_0C->mUnk_00;
+    this->mUnk_14 = *ptr2->mUnk_0C;
     _MI_CpuCopy(ptr2->mUnk_04, &this->mUnk_20, sizeof(MapObject_20));
 
     for (int i = 0; i < ARRAY_LEN(this->mUnk_18); i++) {
@@ -257,7 +249,7 @@ ARM void MapObject::func_ov000_0209d54c(unk32 param1, u16 param2, Vec3p *param3,
     local_4c.param_r2  = param2;
     local_4c.extra_s16 = param4;
     local_4c.extra_u16 = param5;
-    func_ov000_020973f4(this, &data_ov000_020b539c, ActorId_EventIcon, &local_4c, 0);
+    func_ov000_020973f4(this, &data_ov000_020b539c_eur, ActorId_EventIcon, &local_4c, 0);
 }
 
 ARM void MapObject::func_ov000_0209d5c8(ActorRef ref) {

src/000_Second/MapObject/MapObjectMiniBlocks.cpp

@@ -38,11 +38,11 @@ ARM MapObjectMiniBlocks::MapObjectMiniBlocks() :
 
 ARM bool MapObjectMiniBlocks::vfunc_00(void) {
     GET_PROFILE(MapObjectProfileMiniBlocks)
-        ->func_ov000_0209ccd8(this->mUnk_20.mUnk_02, data_ov000_020af574[this->mUnk_20.mUnk_02]);
+        ->func_ov000_0209ccd8(this->mUnk_20.mUnk_00[1], data_ov000_020af574[this->mUnk_20.mUnk_00[1]]);
     UnkStruct_027e0cd8_0c *pUnkStruct_027e0cd8_0c = data_027e0cd8->mUnk_0c;
     u8 uVar6;
 
-    if (this->mUnk_20.mUnk_02 != MiniBlocksVariant_BLKF) {
+    if (this->mUnk_20.mUnk_00[1] != MiniBlocksVariant_BLKF) {
         Vec2b vec(this->mUnk_3A.x, this->mUnk_3A.y);
         this->mPos.y = pUnkStruct_027e0cd8_0c->func_01ffedf4(&vec);
     }
@@ -50,7 +50,7 @@ ARM bool MapObjectMiniBlocks::vfunc_00(void) {
     Vec3p vec(FLOAT_TO_Q20(0.0f), FLOAT_TO_Q20(0.0f), FLOAT_TO_Q20(0.0f));
     uVar6 = 0;
 
-    switch (this->mUnk_20.mUnk_00) {
+    switch (this->mUnk_20.mUnk_00[0]) {
         case 4:
         case 5:
         case 6:
@@ -64,7 +64,7 @@ ARM bool MapObjectMiniBlocks::vfunc_00(void) {
             uVar6 = 2;
             break;
         default:
-            if (this->mUnk_20.mUnk_02 == MiniBlocksVariant_BLKF) {
+            if (this->mUnk_20.mUnk_00[1] == MiniBlocksVariant_BLKF) {
                 vec.x = FLOAT_TO_Q20(0.0f);
                 vec.y = FLOAT_TO_Q20(0.0f);
                 vec.z = -FLOAT_TO_Q20(0.375f);
@@ -77,7 +77,7 @@ ARM bool MapObjectMiniBlocks::vfunc_00(void) {
     }
 
     MapObjectProfile_Derived2_20_Base_50 *ptr =
-        GET_PROFILE(MapObjectProfileMiniBlocks)->vfunc_1C(this->mUnk_20.mUnk_02)->mUnk_50;
+        GET_PROFILE(MapObjectProfileMiniBlocks)->vfunc_1C(this->mUnk_20.mUnk_00[1])->mUnk_50;
     void *var_r1;
     if (ptr != NULL) {
         u16 *temp_r1 = (u16 *) ((u8 *) ptr + 8);
@@ -104,7 +104,7 @@ next:
 
     unk32 var_r0_2;
     unk32 var_r0;
-    switch (this->mUnk_20.mUnk_00) {
+    switch (this->mUnk_20.mUnk_00[0]) {
         case 1:
         case 6:
         case 8:

src/000_Second/MapObject/MapObjectProfile.cpp

@@ -0,0 +1,218 @@
+#include "MapObject/MapObjectProfile.hpp"
+
+#include "Actor/Actor.hpp"
+#include "MapObject/MapObject.hpp"
+#include "Unknown/UnkMemFuncs.h"
+#include "Unknown/UnkStruct_ov000_020b5d34.hpp"
+
+extern unk8 data_ov000_020af4d4[];
+
+MapObjectProfile *data_ov000_020b5d3c[MapObjectIndex_Max];
+UnkStruct_ov000_020b5d34 data_ov000_020b5d34;
+
+ARM void MapObject_20::func_ov000_0209c790(MapObjectId mapObjId, MapObjectProfile *pProfile) {
+    data_ov000_020b5d3c[UnkStruct_ov000_020b5d34::func_ov000_0209c718(mapObjId)] = pProfile;
+}
+
+ARM void MapObject_20::func_ov000_0209c7ac(MapObjectId mapObjId) {
+    data_ov000_020b5d3c[UnkStruct_ov000_020b5d34::func_ov000_0209c718(mapObjId)] = NULL;
+}
+
+ARM void MapObject_20::func_ov000_0209c7c8() {
+    this->mUnk_16 = 0;
+    this->mUnk_10 = 0;
+    MI_CpuFill32(0, this->mUnk_00, sizeof(this->mUnk_00));
+    MI_CpuFill16(0, this->mUnk_08, sizeof(this->mUnk_08));
+    MI_CpuFill16(0, this->mUnk_0A, sizeof(this->mUnk_0A));
+    this->mUnk_14 = -1;
+    this->mUnk_17 = 0;
+}
+
+ARM unk32 MapObjectProfile::func_ov000_0209c820() {
+    return MapObjectIndex_Max;
+}
+
+ARM MapObjectProfile::MapObjectProfile(MapObjectId mapObjId) {
+    this->mUnk_06   = 1;
+    this->mUnk_08   = 0x800;
+    this->mUnk_0C   = 0x1333;
+    this->mUnk_0E   = -1;
+    this->mUnk_0F   = 0;
+    this->mMapObjId = mapObjId;
+    this->mUnk_14   = 0;
+    this->mUnk_18   = 0;
+    this->mUnk_1C   = 0;
+    this->mUnk_1D   = 0;
+    this->mUnk_1E   = 1;
+
+    for (int i = 0; i < ARRAY_LEN(this->mUnk_04); i++) {
+        this->mUnk_04[i] = data_ov000_020af4d4[i];
+    }
+
+    MapObject_20::func_ov000_0209c790(this->mMapObjId, this);
+}
+
+ARM MapObjectProfile::~MapObjectProfile() {
+    this->func_ov000_0209c970();
+    MapObject_20::func_ov000_0209c7ac(this->mMapObjId);
+}
+
+ARM MapObjectProfile_Derived2_20 *MapObjectProfile::vfunc_04() {
+    return NULL;
+}
+
+ARM unk32 MapObjectProfile::func_ov000_0209c8e4(MapObject_20 *param1) {
+    return this->mUnk_0E;
+}
+
+ARM void MapObjectProfile::func_ov000_0209c8ec(MapObjectProfile *thisx) {
+    if (thisx->mUnk_0F == 0) {
+        if (thisx->mUnk_14 != 0) {
+            thisx->func_ov000_0209c8ec(data_ov000_020b5d34.func_ov000_0209c6b8(thisx->mUnk_14));
+        }
+
+        if (thisx->mUnk_18 != 0) {
+            data_ov000_020b539c_eur.func_ov000_020974dc(thisx->mUnk_18)->vfunc_08();
+        }
+
+        thisx->vfunc_08();
+        thisx->mUnk_0F = 2;
+    }
+}
+
+ARM void MapObjectProfile::func_ov000_0209c95c() {
+    this->vfunc_0C();
+}
+
+ARM void MapObjectProfile::func_ov000_0209c970() {
+    if (this->mUnk_0F == 2) {
+        this->vfunc_10();
+        this->mUnk_0F = 0;
+    }
+}
+
+ARM void MapObjectProfile::vfunc_08() {}
+
+ARM void MapObjectProfile::vfunc_0C() {}
+
+ARM void MapObjectProfile::vfunc_10() {}
+
+ARM MapObjectProfile_Derived2::MapObjectProfile_Derived2(MapObjectId mapObjId1, MapObjectId mapObjId2) :
+    MapObjectProfile(mapObjId1),
+    mUnk_20(mapObjId2) {}
+
+ARM MapObjectProfile_Derived2::~MapObjectProfile_Derived2() {
+    this->vfunc_10();
+}
+
+ARM MapObjectProfile_Derived2_20 *MapObjectProfile_Derived2::vfunc_04() {
+    return &this->mUnk_20;
+}
+
+ARM void MapObjectProfile_Derived2::vfunc_08() {
+    this->mUnk_20.func_ov000_0209cfdc(0, 0);
+    this->mUnk_20.func_ov000_020586b4(0, 0, 0, 0);
+    this->mUnk_20.func_ov000_02058ab0();
+}
+
+ARM void MapObjectProfile_Derived2::vfunc_0C() {
+    if (this->mUnk_20.mUnk_20.mUnk_04 != 0) {
+        this->mUnk_20.func_ov000_02058914(0);
+    }
+}
+
+ARM void MapObjectProfile_Derived2::vfunc_10() {
+    this->mUnk_20.func_ov000_020589e4();
+}
+
+ARM MapObjectProfile_Derived3::MapObjectProfile_Derived3(MapObjectId mapObjId1, MapObjectId mapObjId2) :
+    MapObjectProfile(mapObjId1) {
+    this->mUnk_20 = NULL;
+    this->mUnk_14 = mapObjId2;
+}
+
+ARM MapObjectProfile_Derived2_20 *MapObjectProfile_Derived3::vfunc_04() {
+    return this->mUnk_20;
+}
+
+ARM void MapObjectProfile_Derived3::vfunc_08() {
+    this->mUnk_20 = data_ov000_020b5d34.func_ov000_0209c6b8(this->mUnk_14)->vfunc_04();
+}
+
+ARM MapObjectProfile_Derived4::MapObjectProfile_Derived4(MapObjectId mapObjId1, MapObjectId mapObjId2) :
+    MapObjectProfile_Derived2(mapObjId1, mapObjId2) {}
+
+ARM MapObjectProfile_Derived4::~MapObjectProfile_Derived4() {
+    if (this->mUnk_20.mUnk_20.mUnk_04 != 0) {
+        this->mUnk_20.func_ov000_020589e4();
+    }
+}
+
+ARM void MapObjectProfile_Derived4::vfunc_08() {}
+
+ARM void MapObjectProfile_Derived4::vfunc_0C() {}
+
+ARM MapObjectProfile_Derived1::MapObjectProfile_Derived1(MapObjectId mapObjId, unk32 param2, unk32 param3) :
+    MapObjectProfile(mapObjId),
+    mUnk_60(param3),
+    mUnk_64(param2) {
+    for (MapObjectProfile_Derived2_20 **ptr = this->mUnk_20; ptr != &this->mUnk_20[ARRAY_LEN(this->mUnk_20)]; ptr++) {
+        *ptr = NULL;
+    }
+}
+
+ARM MapObjectProfile_Derived2_20 *MapObjectProfile_Derived1::vfunc_04() {
+    if (this->mUnk_64 >= 0) {
+        return this->mUnk_20[this->mUnk_64];
+    }
+
+    return NULL;
+}
+
+ARM MapObjectProfile_Derived2_20 *MapObjectProfile_Derived1::vfunc_1C(unk32 param1) {
+    if (param1 >= 0) {
+        return this->mUnk_20[param1];
+    }
+
+    return NULL;
+}
+
+ARM MapObjectProfile_Derived1::~MapObjectProfile_Derived1() {
+    for (MapObjectProfile_Derived2_20 **ptr = this->mUnk_20; ptr != &this->mUnk_20[ARRAY_LEN(this->mUnk_20)]; ptr++) {
+        delete *ptr;
+    }
+}
+
+ARM void MapObjectProfile_Derived1::func_ov000_0209ccd8(unk32 param1, u32 param2) {
+    if (this->mUnk_20[param1] == NULL) {
+        MapObjectProfile_Derived2_20 *ptr       = new(HeapIndex_1) MapObjectProfile_Derived2_20(param2);
+        MapObjectProfile_Derived2_20 **ppUnk_20 = this->mUnk_20;
+        ppUnk_20[param1]                        = ptr;
+        ppUnk_20[param1]->func_ov000_0209cfdc(0, 0);
+        ppUnk_20[param1]->func_ov000_020586b4(0, 0, 0, 0);
+        ppUnk_20[param1]->func_ov000_02058ab0();
+    }
+}
+
+ARM void MapObjectProfile_Derived1::vfunc_08() {
+    if (this->mUnk_64 >= 0) {
+        this->func_ov000_0209ccd8(this->mUnk_64, this->mUnk_60);
+    }
+}
+
+ARM void MapObjectProfile_Derived1::vfunc_0C() {
+    for (MapObjectProfile_Derived2_20 **ptr = this->mUnk_20; ptr != &this->mUnk_20[ARRAY_LEN(this->mUnk_20)]; ptr++) {
+        if (*ptr != NULL && (*ptr)->mUnk_20.mUnk_04 != NULL) {
+            (*ptr)->func_ov000_02058914(0);
+        }
+    }
+}
+
+ARM void MapObjectProfile_Derived1::vfunc_10() {
+    for (MapObjectProfile_Derived2_20 **ptr = this->mUnk_20; ptr != &this->mUnk_20[ARRAY_LEN(this->mUnk_20)]; ptr++) {
+        if (*ptr != NULL) {
+            delete *ptr;
+            *ptr = NULL;
+        }
+    }
+}

src/000_Second/MapObject/MapObjectProfile_Derived2_20.cpp

@@ -0,0 +1,58 @@
+#include "MapObject/MapObjectProfile_Derived2_20.hpp"
+
+#include <string.h>
+
+extern "C" {
+void func_02015ea8(u32 resourceId, void *);
+unk32 func_02012fa8(const char *);
+}
+
+ARM MapObjectProfile_Derived2_20::MapObjectProfile_Derived2_20(MapObjectId mapObjId2) :
+    MapObjectProfile_Derived2_20_Base("MapObj", &mUnk_94, &mUnk_94, &mUnk_94, 0, 0),
+    mUnk_94(0),
+    mUnk_98(0),
+    mUnk_B0(false),
+    mUnk_B1(0) {
+    func_02015ea8(mapObjId2, &this->mUnk_94);
+}
+
+ARM MapObjectProfile_Derived2_20::~MapObjectProfile_Derived2_20() {
+    this->func_ov000_020589e4();
+    this->func_ov000_0209cfac();
+}
+
+ARM void MapObjectProfile_Derived2_20::func_ov000_0209cef0() {
+    char path[32 + 1];
+    size_t curLength;
+
+    ((wchar_t *) &path)[(sizeof(path) - 1) / 2] = L'\0';
+
+    // path = "MapObj/RESID/filename.zcb"
+    strncpy(&path[0], "MapObj/", sizeof(path) - 1);
+
+    curLength = strlen(path);
+    strncpy(&path[curLength], this->mUnk_08, sizeof(path) - 1 - curLength);
+
+    const char *ext = ".zcb";
+    curLength       = strlen(path);
+    strncpy(&path[curLength], ext, sizeof(path) - 1 - curLength);
+
+    this->mUnk_9C.vfunc_0C();
+    this->mUnk_9C.mUnk_04 = path;
+
+    if (func_02012fa8(path) != 0) {
+        this->mUnk_9C.vfunc_08(0x10);
+        this->mUnk_B0 = true;
+    } else {
+        this->mUnk_B0 = false;
+    }
+}
+
+ARM void MapObjectProfile_Derived2_20::func_ov000_0209cfac() {
+    if (this->mUnk_B0) {
+        this->mUnk_9C.vfunc_0C();
+        this->mUnk_B0 = false;
+    }
+}
+
+ARM void MapObjectProfile_Derived2_20::func_ov000_0209cfdc(unk32 param1, unk32 param2) {}

src/000_Second/MapObject/MapObjectSwitchStep.cpp

@@ -121,7 +121,7 @@ end:
 }
 
 ARM MapObjectSwitchStep::~MapObjectSwitchStep() {
-    if (this->mUnk_20.mUnk_00 == 2) {
+    if (this->mUnk_20.mUnk_00[0] == 2) {
         this->func_ov000_0209e11c(0, 1);
         this->func_ov000_0209d2c4(0, 0);
     }
@@ -182,8 +182,8 @@ ARM void MapObjectSwitchStep::func_ov000_0209e11c(unk32 param1, unk32 param2) {
                 this->mUnk_EA = 1;
             }
 
-            if (this->mUnk_20.mUnk_00 == 2) {
-                this->mUnk_E6 = this->mUnk_20.mUnk_02;
+            if (this->mUnk_20.mUnk_00[0] == 2) {
+                this->mUnk_E6 = this->mUnk_20.mUnk_00[1];
                 this->mUnk_E4 = 0;
             }
 

src/001_SceneInit/Actor/ActorManager_001.cpp

@@ -279,8 +279,8 @@ THUMB void ActorManager::func_ov001_020bb548() {
 }
 
 THUMB void ActorManager::func_ov001_020bb630() {
-    ActorProfile **piVar2 = data_ov000_020b539c.func_ov000_02073dc();
-    ActorProfile **piVar3 = data_ov000_020b539c.func_ov000_02073e8();
+    ActorProfile **piVar2 = data_ov000_020b539c_eur.func_ov000_02073dc();
+    ActorProfile **piVar3 = data_ov000_020b539c_eur.func_ov000_02073e8();
 
     while (piVar2 != piVar3) {
         ActorProfile *iVar4 = *piVar2;
@@ -302,7 +302,7 @@ THUMB void ActorManager::func_ov001_020bb630() {
         }
 
         piVar2++;
-        piVar3 = data_ov000_020b539c.func_ov000_02073e8();
+        piVar3 = data_ov000_020b539c_eur.func_ov000_02073e8();
     }
 
     if (data_027e09a4->mUnk_60 == 1) {
@@ -311,8 +311,8 @@ THUMB void ActorManager::func_ov001_020bb630() {
 }
 
 THUMB void ActorManager::func_ov001_020bb6b0(s32 *param1) {
-    ActorProfile **piVar1 = data_ov000_020b539c.func_ov000_02073dc();
-    ActorProfile **piVar2 = data_ov000_020b539c.func_ov000_02073e8();
+    ActorProfile **piVar1 = data_ov000_020b539c_eur.func_ov000_02073dc();
+    ActorProfile **piVar2 = data_ov000_020b539c_eur.func_ov000_02073e8();
 
     while (piVar1 != piVar2) {
         ActorProfile *iVar5 = *piVar1;
@@ -330,7 +330,7 @@ THUMB void ActorManager::func_ov001_020bb6b0(s32 *param1) {
         }
 
         piVar1++;
-        piVar2 = data_ov000_020b539c.func_ov000_02073e8();
+        piVar2 = data_ov000_020b539c_eur.func_ov000_02073e8();
     }
 }
 
@@ -368,7 +368,7 @@ THUMB bool ActorManager::func_ov001_020bb728(s32 param1) {
 THUMB void ActorManager::func_ov001_020bb7b0(ZeldaObjectList *pObjList) {
     for (s32 i = 0; i < pObjList->nEntries; i++) {
         u32 id                      = pObjList->aIdList[i];
-        ActorProfile *pActorProfile = data_ov000_020b539c.func_ov000_020974dc(id);
+        ActorProfile *pActorProfile = data_ov000_020b539c_eur.func_ov000_020974dc(id);
 
         if (!this->func_ov001_020bb728(id) && pActorProfile != NULL) {
             pActorProfile->vfunc_08();
@@ -377,8 +377,8 @@ THUMB void ActorManager::func_ov001_020bb7b0(ZeldaObjectList *pObjList) {
 }
 
 THUMB void ActorManager::func_ov001_020bb7f0() {
-    ActorProfile **ptr1 = data_ov000_020b539c.func_ov000_02073dc();
-    ActorProfile **ptr2 = data_ov000_020b539c.func_ov000_02073e8();
+    ActorProfile **ptr1 = data_ov000_020b539c_eur.func_ov000_02073dc();
+    ActorProfile **ptr2 = data_ov000_020b539c_eur.func_ov000_02073e8();
 
     while (ptr1 != ptr2) {
         if (*ptr1 != NULL) {
@@ -386,7 +386,7 @@ THUMB void ActorManager::func_ov001_020bb7f0() {
         }
 
         ptr1++;
-        ptr2 = data_ov000_020b539c.func_ov000_02073e8();
+        ptr2 = data_ov000_020b539c_eur.func_ov000_02073e8();
     }
 }
 

src/031_Land/Actor/ActorRupee.cpp

@@ -55,7 +55,7 @@ ARM void ActorRupee::func_ov031_020e8d2c(Vec3p *param1, u8 param2, unk32 param3,
     stack.sp4.z = param1->z;
     stack.sp2C  = param4;
     stack.sp30  = param3;
-    this->func_ov000_020973f4(&data_ov000_020b539c, ActorId_Rupee, (Actor_5c *) &stack, 0);
+    this->func_ov000_020973f4(&data_ov000_020b539c_eur, ActorId_Rupee, (Actor_5c *) &stack, 0);
 }
 
 ARM ActorRupee::ActorRupee() :

src/Main/UnkFileSystem.cpp

@@ -2,9 +2,9 @@
 #include "Unknown/UnkStruct_ov000_020b4f84.hpp"
 
 extern "C" size_t func_020010e0(UnkStruct_02011e10_Sub1 *heapID, void *pFile, unk32 param3);
-extern "C" void *func_02012ec8(unk32, unk16, void *, size_t *, unk32, u8);
-extern "C" void *func_02012ee4(void *, unk32, unk32, size_t *, u8);
-extern "C" void *func_02012f6c(void *, size_t *);
+extern "C" void *func_02012ec8(unk32, unk16, const char *, size_t *, unk32, u8);
+extern "C" void *func_02012ee4(const char *, unk32, unk32, size_t *, u8);
+extern "C" void *func_02012f6c(const char *, size_t *);
 extern "C" HeapIndex16 func_02015338();
 
 THUMB UnkFileSystem1::~UnkFileSystem1() {}
@@ -27,7 +27,7 @@ THUMB UnkFileSystem5::UnkFileSystem5() :
     this->mUnk_12    = 0;
 }
 
-THUMB UnkFileSystem5::UnkFileSystem5(void *param1, unk32 param2, unk32 param3, u8 param4) :
+THUMB UnkFileSystem5::UnkFileSystem5(const char *param1, unk32 param2, unk32 param3, u8 param4) :
     UnkFileSystem1(param1) {
     this->mHeapIndex = param3;
     this->mUnk_12    = param4;
@@ -64,7 +64,7 @@ THUMB size_t UnkFileSystem5::vfunc_10(unk32 param1) {
     return prevFileSize;
 }
 
-THUMB UnkFileSystem4::UnkFileSystem4(void *param1, unk32 param2, unk32 param3, unk32 param4) :
+THUMB UnkFileSystem4::UnkFileSystem4(const char *param1, unk32 param2, unk32 param3, unk32 param4) :
     UnkFileSystem1(param1) {
     this->mUnk_18 = param2;
     this->mUnk_10 = param3;
@@ -92,7 +92,7 @@ THUMB void *UnkFileSystem3::vfunc_08(unk32 param1) {
 }
 
 // https://decomp.me/scratch/Y2SB8
-THUMB UnkFileSystem2::UnkFileSystem2(void *param1, unk32 param2) :
+THUMB UnkFileSystem2::UnkFileSystem2(const char *param1, unk32 param2) :
     UnkFileSystem1(param1) {
     this->mUnk_14 = param2;
 }