summaryrefslogtreecommitdiff
path: root/src/00_Core/Map/MapManager.cpp
diff options
context:
space:
mode:
authorAetias <aetias@outlook.com>2025-07-01 22:36:29 +0200
committerAetias <aetias@outlook.com>2025-07-01 22:36:29 +0200
commit67c7707657bc509e7a534ad74eaf0d513feb861f (patch)
tree5506b6a43e75e45bcb3df60057dfddbb36e4e272 /src/00_Core/Map/MapManager.cpp
parentfc678172685705dfbbd6ce264331a14bd0b4ba9c (diff)
parentd90d96dca48177a841e7f76101343125debb594a (diff)
Merge remote-tracking branch 'zeldaret/main' into hammer
Diffstat (limited to 'src/00_Core/Map/MapManager.cpp')
-rw-r--r--src/00_Core/Map/MapManager.cpp3306
1 files changed, 3108 insertions, 198 deletions
diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp
index 46da8997..0351a7a6 100644
--- a/src/00_Core/Map/MapManager.cpp
+++ b/src/00_Core/Map/MapManager.cpp
@@ -1,202 +1,3112 @@
+// TODO: Make sure every function has either ARM or THUMB
+// TODO: Optimise functions' bodies as much as possible (without affecting asm)
+// Clear these comments when done
+
#include "Map/MapManager.hpp"
+#include "Actor/Actor.hpp"
+#include "Actor/ActorManager.hpp"
+#include "Actor/ActorSpawner.hpp"
+#include "DTCM/UnkStruct_027e0d38.hpp"
+#include "DTCM/UnkStruct_027e0fd4.hpp"
+#include "DTCM/UnkStruct_027e103c.hpp"
+#include "Player/PlayerBase.hpp"
+#include "Save/AdventureFlags.hpp"
+#include "Unknown/UnkStruct_02037750.hpp"
+#include "stdio.h"
+
+extern bool func_01ffbe78(Vec3p *param1, Vec3p *param2, Vec3p *param3, Vec4p *param4);
+
+extern u32 func_ov000_02078bc4(unk32 param_1);
+extern void func_ov000_02078bf0(s32 *param_1, unk32 *param_2);
+extern s32 func_ov000_02078fe8(s32 *param_1);
+extern void func_ov000_0207920c(s32 *param_1, Vec3p *param_2, s32 *param_3, s32 *param_4);
+extern void func_ov000_020792a0(s32 *param_1, s32 param_2, unk32 param_3, unk32 param_4);
+extern void func_ov000_02079898(unk32 *param_1, unk32 param_2, unk32 param_3);
+extern void func_ov000_020798bc(s32 *param_1, s32 param_2);
+extern void func_ov000_02088000(unk32 param_1, s32 param_2);
+extern void func_ov000_02088130(u8 *param_1, unk32 param_2);
+extern void func_ov000_02088144(u8 *param_1, unk32 param_2);
+extern void func_ov000_0208b13c(s32 *param_1);
+extern unk32 func_ov000_0208b180(s32 *param_1);
+extern s32 func_ov000_0208b73c(s32 param_1, unk32 param_2);
+extern s32 func_ov000_0208b7d0(s32 param_1, Vec3p *param_2);
+extern s32 func_ov000_0208b804(s32 *param_1, Vec3p *param_2, Vec3p *param_3);
+extern void func_ov000_0208cc88(s32 *param1);
+extern void func_ov000_0208d620(s32 *param_1);
+extern void func_ov000_0208d680(s32 *param_1);
+extern s32 func_ov000_0208df78(s32 *param_1, unk32 param_, unk32 param_3, Vec3p *param_4, s32 *param_5);
+extern void func_ov000_0208e6b0(Vec3p *param_1, Vec3p *param_2);
+extern s32 func_ov000_0208e6f0(Vec3p *param_1);
+extern s32 func_ov000_0208e704(Vec3p *param_1);
+extern s32 func_ov000_0208e87c(AABB *param_1, Vec3p *param_2, Vec3p *param_3);
+extern void func_ov000_0208ed74(AABB *param_1, Vec3p *param_2);
+extern void func_ov000_02093a1c(u32 *param_1, unk32 *param_2, unk32 param_3);
+extern void func_ov000_02096324(unk32 *param_1, unk32 *param_2);
+extern s32 *func_ov000_02096418(s32 *param_1);
+extern void func_ov000_0209d6e8(unk32 *param_1, unk32 *param_2);
+extern s32 func_ov000_0209d71c(s32 *param_1, s32 param_2);
+extern void func_ov000_020c3348(ActorSpawnOptions *param_1);
+extern void func_ov000_020d70a4(unk32 *param_1, unk32 param_2, unk32 param_3, unk32 param_4);
+extern void func_ov000_020d72b8(unk32 *param_1);
+extern unk32 func_ov000_020d7424(unk32 *param_1);
+
+extern void func_ov004_021024c4(MapManager *param_1, s32 param_2, bool param_3, s32 param_4);
+extern void func_ov004_02102770(s32 *param_1);
+extern void func_ov004_02102b28(s32 *param_1);
+extern void func_ov004_02102e3c(s32 *param_1);
+extern void func_ov004_02106db8(unk32 *param_1); // UnkStruct_027e0c68 doesn't exist, so using unk32
+
+extern MapBase *func_ov012_0212b358(MapBase *param_1, unk32 param_2, unk32 param_3);
+
+extern MapBase *func_ov015_02128dd8(MapBase *param_1, unk32 param_2, unk32 param_3);
+extern s32 func_ov015_02129c14(MapBase *param_1);
+extern bool func_ov015_02129c24(MapBase *param_1, Vec3p *param_2, Vec3p *param_3);
+extern bool func_ov015_02129c34(MapBase *param_1, s32 param_2);
+extern bool func_ov015_02129c44(MapBase *param_1, s32 param_2);
+extern void func_ov015_021849a4(unk32 *param_1);
+
+extern MapBase *func_ov017_0215b4a0(MapBase *param_1, unk32 param_2, unk32 param_3);
+extern MapBase *func_ov017_0215b4e8(MapBase *param_1, unk32 param_2, unk32 param_3);
+
+// extern MapBase *func_ov018_0215b4a0(MapBase *param_1, unk32 param_2, unk32 param_3);
+
+struct astruct_16 {
+ /* 00 */ Actor_UnkStruct_020 *mUnk_00;
+ /* 04 */ unk8 mUnk_08[0x10];
+ /* 14 */ unk16 mAngle;
+ /* 16 */ unk8 mUnk_16;
+ /* 17 */ unk8 mUnk_17;
+ /* 18 */ unk32 mUnk_18;
+ /* 1c */ unk32 mUnk_1c;
+ /* 20 */ unk32 mUnk_20;
+ /* 24 */ unk32 mUnk_24;
+ /* 28 */ unk32 mUnk_28;
+ /* 2c */
+}; // What is this struct?
+
+// This might be FlagsUnk2
+struct UnkStruct_02082348 {
+ /* 00 */ unk32 mUnk_00;
+ /* 04 */ unk32 mUnk_04;
+ /* 08 */ unk32 mUnk_08;
+ /* 0c */ unk32 mUnk_0c;
+ /* 10 */ unk16 mUnk_10;
+ /* 12 */ u8 mUnk_12;
+ /* 13 */ u8 mUnk_13;
+ /* 14 */ u8 mUnk_14;
+ /* 15 */ u8 mUnk_15;
+ /* 16 */
+};
+
+struct UnkStruct_027e077c {
+ /* 00 */ unk32 mUnk_00;
+ /* 04 */ unk32 mUnk_04;
+ /* 08 */ unk16 mUnk_08;
+ /* 0a */ unk8 mUnk_0a;
+};
+
+class Case_0 : public MapBase {
+public:
+ char pad[0x790 - 0x1B0];
+ Case_0(u32 param1, u32 param2);
+ virtual ~Case_0() override;
+};
+
+class Case_4 : public MapBase {
+public:
+ char pad[0x1DC - 0x1B0];
+ Case_4(u32 param1, u32 param2);
+ virtual ~Case_4() override;
+};
+
+class Case_Default : public MapBase {
+public:
+ char pad[0x790 - 0x1B0];
+ Case_Default(u32 param1, u32 param2);
+ virtual ~Case_Default() override;
+};
+
+extern UnkStruct_027e077c *data_027e077c;
+extern unk32 *data_027e0c68;
+extern u32 *data_027e0ce0[];
+extern UnkStruct_0202e894 *data_027e0ce4;
+extern unk32 *data_027e0d3c;
+extern unk32 data_027e0f64[];
+extern unk32 *data_027e0f68;
+extern unk32 *data_027e0f6c;
+extern unk32 *data_027e0f70;
+extern unk32 *data_027e0f78;
+extern unk32 *data_027e0f7c;
+extern UnkStruct_027e103c *data_027e103c;
+
+extern unk32 *data_ov000_020e24a4;
+extern MapManager_Unk2 data_ov000_020e24c8[];
+extern MapManager_Unk2 data_ov000_020e24e8[];
+extern unk32 data_ov000_020eec68;
+extern unk32 data_ov015_02190458;
+
+MapManager::MapManager() {
+ /*MapManager_Unk1 *object;
+ undefined *destructor;
+ undefined *chain;
+
+ DWORD_arm9_ov000__020e24c4 = 0x5fff;
+ data_ov000_020e24c8.field0_0x0 = 0;
+ data_ov000_020e24c8.field1_0x4 = 0x60;
+ __register_global_object
+ (&data_ov000_020e24c8,func_ov000_02086cd0,(DestructorChain *)(undefined *)0x20ec964);
+ data_ov000_020e24d0.field0_0x0 = 0;
+ data_ov000_020e24d0.field1_0x4 = 0;
+ __register_global_object
+ (&data_ov000_020e24d0,func_ov000_02086cd0,(DestructorChain *)(undefined *)0x20ec970);
+ data_ov000_020e24d8.field0_0x0 = 0x80;
+ data_ov000_020e24d8.field1_0x4 = 0x60;
+ __register_global_object
+ (&data_ov000_020e24d8,func_ov000_02086cd0,(DestructorChain *)(undefined *)0x20ec97c);
+ data_ov000_020e24e0.field0_0x0 = 0x80;
+ data_ov000_020e24e0.field1_0x4 = 0;
+ __register_global_object
+ (&data_ov000_020e24e0,func_ov000_02086cd0,(DestructorChain *)(undefined *)0x20ec988);
+ data_ov000_020e24e8.field0_0x0 = 0xfff80000;
+ data_ov000_020e24e8.field1_0x4 = 0xfffa0000;
+ __register_global_object
+ (&data_ov000_020e24e8,MapManager_Unk2::~MapManager_Unk2,
+ (DestructorChain *)(undefined *)0x20ec994);
+ data_ov000_020e24f0.field0_0x0 = 0xfff80000;
+ data_ov000_020e24f0.field1_0x4 = 0xfffa0000;
+ __register_global_object
+ (&data_ov000_020e24f0,MapManager_Unk2::~MapManager_Unk2,
+ (DestructorChain *)(undefined *)0x20ec9a0);
+ data_ov000_020e24f8.field0_0x0 = 0xfff80000;
+ data_ov000_020e24f8.field1_0x4 = 0xfffa0000;
+ __register_global_object
+ (&data_ov000_020e24f8,MapManager_Unk2::~MapManager_Unk2,
+ (DestructorChain *)(undefined *)0x20ec9ac);
+ data_ov000_020e2500.field0_0x0 = 0xfff80000;
+ data_ov000_020e2500.field1_0x4 = 0xfffa0000;
+ __register_global_object
+ (&data_ov000_020e2500,MapManager_Unk2::~MapManager_Unk2,
+ (DestructorChain *)(undefined *)0x20ec9b8);
+ return;*/
+}
+
+MapManager::~MapManager() {}
+
+ARM void MapManager::GetCourseDungeonProgress(CourseProgress *param_2) {
+ this->mCourse->GetDungeonProgress(param_2);
+}
+
+ARM void MapManager::func_ov00_020820fc(s32 param_2, unk32 param_3, unk32 param_4) {
+ this->mCourse->func_ov00_0207ca28(param_2, param_3, param_4);
+}
+
+ARM void MapManager::func_ov00_0208210c(unk32 param_2, unk32 *param_3) {
+ void *pvVar3;
+ unk32 uVar2;
+ UnkStruct_02082348 local_40[2];
+
+ local_40[1].mUnk_00 = 0x47;
+ local_40[1].mUnk_04 = 0;
+ local_40[1].mUnk_08 = 0;
+ local_40[1].mUnk_0c = -2;
+ local_40[1].mUnk_10 = 0;
+ local_40[1].mUnk_12 = -1;
+ local_40[1].mUnk_13 = 0;
+ local_40[1].mUnk_14 = 0;
+ local_40[1].mUnk_15 = 0;
+ if (param_2 != 0) {
+ *param_3 = 0xb;
+ *(unk8 *) (param_3 + 1) = 2;
+ *(u8 *) ((int) param_3 + 5) = 4;
+ } else {
+ this->func_ov00_02082348((unk32 *) &local_40[1]);
+ *param_3 = ((UnkStruct_027e0d38_UnkC *) &local_40[1])->func_ov000_020a5e9c();
+ *(unk8 *) (param_3 + 1) = local_40[1].mUnk_12;
+ *(u8 *) ((int) param_3 + 5) = local_40[1].mUnk_13;
+ }
+ param_3[2] = ((UnkStruct_027e0d38_UnkC *) ((unk32) (data_027e0d38->mUnk_28) + 0x1c))->func_ov000_020a5e9c();
+ *(u8 *) (param_3 + 4) = *(u8 *) ((int) data_027e0d38->mUnk_28 + 0x2e);
+ *(unk16 *) (param_3 + 5) = *(unk16 *) ((int) data_027e0d38->mUnk_28 + 0x36);
+ pvVar3 = data_027e0d38->mUnk_28;
+ param_3[6] = *(unk32 *) ((int) pvVar3 + 0x38); // Likely Vec3p
+ param_3[7] = *(unk32 *) ((int) pvVar3 + 0x3c);
+ param_3[8] = *(unk32 *) ((int) pvVar3 + 0x40);
+ param_3[3] = ((UnkStruct_027e0d38_UnkC *) ((unk32) data_027e0d38->mUnk_28 + 0x44))->func_ov000_020a5e9c();
+ *(u8 *) ((int) param_3 + 0x11) = *(u8 *) ((int) data_027e0d38->mUnk_28 + 0x56);
+ pvVar3 = data_027e0d38->mUnk_28;
+ param_3[9] = *(unk32 *) ((int) pvVar3 + 0x5c); // Likely Vec3p
+ param_3[10] = *(unk32 *) ((int) pvVar3 + 0x60);
+ param_3[0xb] = *(unk32 *) ((int) pvVar3 + 0x64);
+ *(unk16 *) ((int) param_3 + 0x16) = *(unk16 *) ((int) data_027e0d38->mUnk_28 + 0x68);
+ pvVar3 = data_027e0d38->mUnk_28;
+ local_40[0].mUnk_00 = *(unk32 *) ((int) pvVar3 + 0x70);
+ local_40[0].mUnk_04 = *(unk32 *) ((int) pvVar3 + 0x74);
+ local_40[0].mUnk_08 = *(unk32 *) ((int) pvVar3 + 0x78);
+ local_40[0].mUnk_0c = *(unk32 *) ((int) pvVar3 + 0x7c);
+ local_40[0].mUnk_10 = *(unk16 *) ((int) pvVar3 + 0x80);
+ local_40[0].mUnk_12 = *(u8 *) ((int) pvVar3 + 0x82);
+ local_40[0].mUnk_13 = *(u8 *) ((int) pvVar3 + 0x83);
+ local_40[0].mUnk_14 = *(u8 *) ((int) pvVar3 + 0x84);
+ local_40[0].mUnk_15 = *(u8 *) ((int) pvVar3 + 0x85);
+ uVar2 = ((UnkStruct_027e0d38_UnkC *) &local_40[0])->func_ov000_020a5e9c();
+ param_3[0x70] = uVar2;
+ *(u8 *) ((int) param_3 + 0x1be) = local_40[0].mUnk_12;
+ *(u8 *) ((int) param_3 + 0x1bf) = local_40[0].mUnk_13;
+ func_ov000_02096324(data_027e0f70, param_3);
+ func_ov000_0209d6e8(data_027e0f7c, param_3);
+ if (this->mCourse->mType != CourseType_TempleOfTheOceanKing) {
+ *(bool *) ((int) param_3 + 7) = this->mUnk_08;
+ *(bool *) (param_3 + 0x6f) = this->mUnk_09;
+ }
+}
+
+ARM void MapManager::func_ov00_0208230c(s32 *param_2) {
+ *param_2 = this->mCourse->mIndex;
+ Course *course = this->mCourse;
+ *(unk8 *) ((u32) param_2 + 0x12) = course->mMapGrid[(u8) course->mCurrMapPos.x][(u8) course->mCurrMapPos.y];
+ *(unk8 *) ((u32) param_2 + 0x13) = this->mUnk_0c;
+}
+
+ARM void MapManager::func_ov00_02082348(unk32 *param_2) {
+ UnkStruct_02082348 unkStruct;
+ unkStruct.mUnk_00 = 0x47;
+ unkStruct.mUnk_04 = 0;
+ unkStruct.mUnk_08 = 0;
+ unkStruct.mUnk_0c = -2;
+ unkStruct.mUnk_10 = 0;
+ unkStruct.mUnk_12 = -1;
+ unkStruct.mUnk_13 = 0;
+ unkStruct.mUnk_14 = 0;
+ unkStruct.mUnk_15 = 0;
+ this->func_ov00_0208230c((s32 *) &unkStruct);
+ func_ov000_02078bf0((s32 *) &unkStruct, param_2);
+}
+
+ARM void MapManager::func_ov00_020823a4(unk32 param_2) {
+ this->mMap->func_ov00_0207de68(param_2);
+}
+
+ARM void MapManager::func_ov00_020823b4() {
+ this->mMap->func_ov00_0207de88();
+}
+
+ARM bool MapManager::func_ov00_020823c4(s32 *param_2, s32 param_3) {
+ return this->mMap->func_ov00_0207e08c(param_2, param_3);
+}
+
+ARM s32 MapManager::func_ov00_020823d4(s32 param_2) {
+ return this->mMap->func_ov00_0207e0f0(param_2);
+}
+
+ARM s32 MapManager::func_ov00_020823e4(s32 param_2) {
+ return this->mMap->func_ov00_0207e28c(param_2);
+}
+
+ARM void MapManager::MapData_vfunc_b4() {
+ this->mMap->vfunc_b4();
+}
+
+ARM void MapManager::MapData_vfunc_9c() {
+ this->mMap->vfunc_9c();
+}
+
+ARM s32 MapManager::func_ov00_02082424() {
+ s32 var = this->mMap->vfunc_4c();
+ if (var == 2) {
+ var = func_ov015_02129c14(this->mMap); // MapBase::GetUnk_19c_Unk_28 according to Ghidra
+ return var;
+ }
+ return 0;
+}
+
+ARM bool MapManager::func_ov00_02082454(Vec3p *param_2, Vec3p *param_3) {
+ s32 var = this->mMap->vfunc_4c();
+ if (var == 2) {
+ bool state = func_ov015_02129c24(this->mMap, param_2, param_3);
+ return state;
+ }
+ return false;
+}
+
+ARM bool MapManager::func_ov00_02082494(s32 param_2) {
+ s32 var = this->mMap->vfunc_4c();
+ if (var == 2) {
+ bool state = func_ov015_02129c34(this->mMap, param_2);
+ return state;
+ }
+ return false;
+}
+
+ARM bool MapManager::func_ov00_020824cc(s32 param_2) {
+ s32 var = this->mMap->vfunc_4c();
+ if (var == 2) {
+ bool state = func_ov015_02129c44(this->mMap, param_2);
+ return state;
+ }
+ return false;
+}
+
+ARM s32 MapManager::func_ov00_02082504() {
+ s32 var = this->mMap->vfunc_4c();
+ if (var == 2) return this->mMap->mUnk_1ac;
+ return 0;
+}
+
+ARM Vec3p *MapManager::func_ov00_02082538() {
+ s32 var1 = this->mMap->vfunc_4c();
+ Vec3p var0;
+ if (var1 == 2) return &this->mMap->mUnk_1a0;
+ var0 = gPlayerPos;
+ return &var0;
+}
+
+ARM void MapManager::func_ov00_02082594() {
+ func_ov000_0208d620(data_027e0f68);
+}
+
+ARM void MapManager::func_ov00_020825ac() {
+ func_ov000_0208d680(data_027e0f68);
+}
+
+ARM s32 MapManager::GetCourseFilePath(char *courseName, char *buf) {
+ s32 var = sprintf(buf, "Map/%s/course.bin\0\0", courseName);
+ return var;
+}
+
+ARM void MapManager::func_ov00_020825e4(unk32 param_2, char *buf) {
+ char *courseName = (char *) func_ov000_0209d71c(data_027e0f7c, param_2);
+ this->GetCourseFilePath(courseName, buf);
+}
+
+ARM void MapManager::func_ov00_02082614(char *param_2, unk32 param_3) {
+ this->mCourse->func_ov00_0207ce20(param_3, 0, param_2, 4);
+}
+
+ARM void MapManager::MapData_vfunc_b0(unk32 param_2, unk32 param_3) {
+ this->mMap->vfunc_b0(param_2, param_3);
+}
+
+ARM void MapManager::func_ov00_02082650(s32 param_2, s32 param_3, unk32 param_4) {
+ this->mMap->func_ov00_0208005c(param_2, param_3, param_4);
+}
+
+ARM void MapManager::func_ov00_02082660(s32 param_2, s32 param_3) {
+ this->mMap->func_ov00_0208007c(param_2, param_3);
+}
+
+ARM void MapManager::func_ov00_02082670(unk32 param_2, s32 param_3) {
+ this->mMap->func_ov00_0208006c(param_2, param_3);
+}
+
+ARM void MapManager::func_ov00_02082680(unk32 param_2, unk32 param_3) {
+ this->mMap->vfunc_98(param_2, 5, param_3);
+}
+
+ARM void MapManager::func_ov00_020826a0(unk32 param_2, unk32 param_3) {
+ this->mMap->vfunc_98(param_2, 7, param_3);
+}
+
+ARM void MapManager::CreateMap(unk32 mapType, unk32 param_3, unk32 param_4) {
+ MapBase *mapBase;
+ if (this->mMap == NULL) {
+ switch (mapType) {
+ case 4: this->mMap = new(data_027e0ce0[1], 4) Case_0(param_3, param_4); break;
+ case 2: this->mMap = new(data_027e0ce0[1], 4) MapBase(param_3, param_4); break;
+ case 0: this->mMap = new(data_027e0ce0[1], 4) Case_4(param_3, param_4); break;
+ case 1:
+ case 3:
+ default: this->mMap = new(data_027e0ce0[1], 4) Case_Default(param_3, param_4); break;
+ }
+ }
+}
+
+ARM void MapManager::DestroyMap() {
+ if (this->mMap == NULL) {
+ return;
+ }
+ if (this->mMap != NULL) {
+ this->mMap->~MapBase(); // 0x0 offset instead of the expected 0x4.
+ }
+ this->mMap = NULL;
+ return;
+}
+
+ARM void MapManager::MapData_vfunc_44() {
+ this->mMap->vfunc_44();
+}
+
+ARM void MapManager::func_ov00_02082808(bool param_2) {
+ int iVar1;
+ int iVar2;
+
+ if (data_027e0d38->mUnk_14 == 1) {
+ return;
+ }
+ iVar1 = this->func_ov00_02084740();
+ if (param_2) {
+ iVar2 = data_027e0d38->mUnk_0c.func_ov000_020a5e9c();
+ if (iVar2 == 0) {
+ func_ov015_021849a4(&data_ov015_02190458);
+ }
+ func_ov000_020d70a4(&data_ov000_020eec68, iVar1, 0, 0x7f);
+ } else {
+ iVar2 = func_ov000_020d7424(&data_ov000_020eec68);
+ if (iVar1 == iVar2) {
+ return;
+ }
+ func_ov000_020d70a4(&data_ov000_020eec68, iVar1, 0, 0x7f);
+ }
+ iVar1 = data_027e0d38->mUnk_0c.func_ov000_020a5e9c();
+ if (iVar1 == 0) {
+ return;
+ }
+ func_ov000_020d72b8(&data_ov000_020eec68);
+}
+
+ARM s32 MapManager::MapData_vfunc_7c(s32 param_1, unk32 *param_2, s32 param_3, short param_4[4]) {
+ return this->mMap->vfunc_7c(param_1, param_2, param_3, param_4);
+}
+
+ARM void MapManager::MapData_vfunc_84(unk32 param_2) {
+ this->mMap->vfunc_84(param_2);
+}
+
+ARM bool MapManager::func_ov00_020828f8(s32 *param_2) {
+ return this->mMap->func_ov00_0207f38c(param_2);
+}
+
+ARM u8 MapManager::GetNumMaps() {
+ return this->mCourse->mNumMaps;
+}
+
+ARM s32 MapManager::func_ov00_02082914(unk32 param_2) {
+ void *pvVar1;
+ int iVar3;
+ int iVar4;
+ int iVar5;
+ Vec3p pVar1;
+ Entrance local_44;
+ Entrance local_30;
+
+ switch (param_2) {
+ case 0xfa:
+ pvVar1 = data_027e0d38->mUnk_28;
+ local_30.mPos.x = *(int *) ((int) pvVar1 + 0x5c);
+ local_30.mPos.y = *(int *) ((int) pvVar1 + 0x60);
+ local_30.mPos.z = *(int *) ((int) pvVar1 + 100);
+ local_30.mAngle = *(unk16 *) ((int) pvVar1 + 0x68);
+ local_30.mId = *(unk8 *) ((int) pvVar1 + 0x6a);
+ local_30.mUnk_10 = *(int *) ((int) pvVar1 + 0x6c);
+ iVar3 = this->mMap->AddEntrance(&local_30);
+ return iVar3;
+ case 0xfb:
+ case 0xfc:
+ case 0xfd:
+ case 0xfe: break;
+ default: return (int) this;
+ }
+ local_44.mId = -1;
+ local_44.mUnk_10 = 0;
+ pvVar1 = data_027e0d38->mUnk_28;
+ pVar1 = *(Vec3p *) ((int) pvVar1 + 0x38);
+ iVar3 = 0x2000;
+ iVar4 = 0x2000;
+ iVar5 = 0xfd;
+ if (this->mCourse->mType == CourseType_Sea) {
+ iVar3 = this->mMap->vfunc_88();
+ iVar3 = iVar3 + 0xa000;
+ iVar4 = this->mMap->vfunc_8c();
+ iVar4 = iVar4 + 0xa000;
+ iVar5 = 0xfe;
+ }
+ local_44.mAngle = 0;
+ switch (param_2) {
+ case 0xfb:
+ pVar1.z = this->GetMapMaxZ();
+ pVar1.z = pVar1.z - iVar4;
+ local_44.mAngle = 0x8000;
+ break;
+ case 0xfc:
+ pVar1.z = this->GetMapMinZ();
+ pVar1.z = iVar4 + pVar1.z;
+ local_44.mAngle = 0;
+ break;
+ case 0xfd:
+ pVar1.x = GetMapMaxX();
+ pVar1.x = pVar1.x - iVar3;
+ local_44.mAngle = 0xc000;
+ break;
+ case 0xfe:
+ pVar1.x = GetMapMinX();
+ pVar1.x = iVar3 + pVar1.x;
+ local_44.mAngle = 0x4000;
+ }
+ local_44.mId = (unk8) param_2;
+ local_44.mPos.x = pVar1.x;
+ local_44.mPos.z = pVar1.z;
+ local_44.mPos.y = pVar1.y;
+ local_44.mUnk_10 = iVar5;
+ return this->mMap->AddEntrance(&local_44);
+}
+
+ARM void MapManager::func_ov00_02082acc() {
+ this->mCourse->func_ov00_0207d7bc();
+}
+
+ARM s32 *MapManager::func_ov00_02082adc() {
+ return func_ov000_02096418(data_027e0f70);
+}
+
+ARM void MapManager::func_ov00_02082af4() {
+ func_ov000_0208cc88(data_027e0f68);
+ this->mMap->vfunc_48();
+ this->func_ov00_02082808(false);
+ this->mUnk_0a = true;
+ this->mUnk_0b = false;
+}
+
+void MapManager::func_ov00_02082b3c(unk32 *param_2, Vec2b *param_3) {
+ u8 bVar1;
+ u16 uVar3;
+ u32 uVar4;
+ unk32 uVar5;
+ ActorManager *pAVar6;
+ PlayerBase *puVar2;
+
+ this->mCourse->FindMapGridPos(param_3, this->mCourse, *(u32 *) ((unk32) param_2 + 0x12));
+ uVar4 = this->GetCurrentMapPosX();
+ if (((((param_3->x) == uVar4) && (uVar4 = this->GetCurrentMapPosY(), (param_3->y) == uVar4)) &&
+ ((*(s32 *) (param_2 + 8) != 1 || (*(s32 *) (*(s32 *) data_027e0d38 + 0x14) != 1)))) &&
+ (*(char *) (param_2 + 0x15) == '\0'))
+ {
+ gAdventureFlags->func_ov00_020976c8();
+ this->mUnk_0c = *(unk32 *) (param_2 + 0x13);
+ gPlayer->TeleportToEntrance(*(unk32 *) (param_2 + 0x13), false);
+ func_ov004_02106db8(data_027e0c68);
+ this->mMap->vfunc_18();
+ } else {
+ gAdventureFlags->func_ov00_020976c8();
+ func_ov000_0208b13c(data_027e0f64);
+ uVar5 = this->func_ov00_02082d08();
+ gActorManager->func_ov004_02105608(param_3->x, param_3->y, uVar5);
+ this->mMap->vfunc_2c();
+ func_ov004_02102b28(data_027e0f68);
+ func_ov004_02102770(data_027e0f6c);
+ func_ov004_02102e3c(data_027e0f78);
+ bVar1 = *(u8 *) (param_2 + 0x12);
+ uVar3 = this->mCourse->FindCurrentMapData_Unk_04();
+ uVar4 = this->mCourse->FindMapData_Unk_04((u32) bVar1);
+ (this->mCourse->mCurrMapPos).x = (u8) param_3->x;
+ (this->mCourse->mCurrMapPos).y = (u8) param_3->y;
+ this->func_ov004_021024c4(param_2, uVar3 != uVar4, 0);
+ gActorManager->func_ov004_02105578(*(unk32 *) ((unk32) param_2 + 0x12));
+ data_027e103c->func_ov000_020cfcec();
+ }
+}
+
+ARM u8 MapManager::func_ov00_02082d08() {
+ Course *course = this->mCourse;
+ return course->mMapGrid[(u8) course->mCurrMapPos.x][(u8) course->mCurrMapPos.y];
+}
+
+ARM u8 MapManager::GetCurrentMapPosX() {
+ return this->mCourse->mCurrMapPos.x;
+}
+
+ARM u8 MapManager::GetCurrentMapPosY() {
+ return this->mCourse->mCurrMapPos.y;
+}
+
+ARM u8 MapManager::func_ov00_02082d40() {
+ switch (this->mCourse->mType) {
+ case CourseType_Sea:
+ return this->mCourse->mMapGrid[(u8) this->mCourse->mCurrMapPos.x][(u8) this->mCourse->mCurrMapPos.y];
+ default: return this->mCourse->mUnk_0b1;
+ }
+}
+
+ARM u32 MapManager::func_ov00_02082d74(unk32 param_2) {
+ return func_ov000_02078bc4(param_2);
+}
+
+ARM void MapManager::func_ov00_02082d84(Vec2b *param_2, s32 *param_3, s32 *param_4) {
+ s32 mapWidth = this->GetMapWidth();
+ u32 uVar3 = CoDivide64By32(0x100000, mapWidth << 0xc);
+ s32 mapHeight = this->GetMapHeight();
+ u32 uVar4 = CoDivide64By32(0xc0000, mapHeight << 0xc);
+ // something related to x or width
+ s64 lVar1 = (s64) ((u8) param_2->x << 0xc) * (s32) uVar3 + 0x800;
+ *param_3 = (s32) (((s32) (lVar1 >> 0xc)) + ((s32) uVar3 >> 1) + 0x800) >> 0xc;
+ // something related to y or height
+ lVar1 = (s64) ((u8) param_2->y << 0xc) * (s32) uVar4 + 0x800;
+ *param_4 = (s32) (((s32) (lVar1 >> 0xc)) + ((s32) uVar4 >> 1) + 0x800) >> 0xc;
+}
+
+ARM bool MapManager::func_ov00_02082e1c(s32 *param_2, s32 *param_3) {
+ unk32 local_20; // Unused. What could this be for?
+ unk32 local_24; // Unused. What could this be for?
+ unk32 local_28; // Vec3p instead ???
+ s32 local_44[11]; // not [6] apparently
+ s32 local_48;
+ Vec2b local_4a;
+ u8 local_4b;
+ u8 local_4c;
+ u8 bVar1;
+ u8 bVar2;
+ s64 lVar3;
+ s32 iVar5;
+ u32 uVar7;
+ if (!this->mCourse->mUnk_25c) {
+ *param_2 = 0xc0;
+ *param_3 = 0xc0;
+ return false;
+ }
+ if (!this->mCourse->IsCurrentMapInMainGrid()) {
+ local_44[0] = -0x100;
+ local_48 = -0x100;
+ bVar1 = this->mMap->mUnk_01a;
+ iVar5 = data_027e0d38->func_ov000_02078b40();
+ if (iVar5 == 0) {
+ // bVar2 = *(u8 *) (*(s32 *) (*(s32 *) PTR_PTR_overlay_d_0__02083068 + 0x28) + 0x9a);
+ } else {
+ // bVar2 = *(u8 *) (*(s32 *) (*(s32 *) PTR_PTR_overlay_d_0__02083068 + 0x28) + 0x2e);
+ }
+ uVar7 = (u32) bVar2;
+ if (uVar7 == 0xff) {
+ uVar7 = (u32) (u8) this->mCourse->mMapGrid[(u8) this->mCourse->mUnk_01e][(u8) this->mCourse->mUnk_01f];
+ }
+ // iVar5 = UnkStruct_027e0d38::FUN_overlay_d_0__02078b40(*(UnkStruct_027e0d38 **) PTR_PTR_overlay_d_0__02083068);
+ if (iVar5 == 0) {
+ // iVar5 = *(s32 *) (*(s32 *) PTR_PTR_overlay_d_0__02083068 + 0x28);
+ local_24 = *(unk32 *) (iVar5 + 0xa4);
+ local_20 = *(unk32 *) (iVar5 + 0xa8);
+ local_28 = *(unk32 *) (iVar5 + 0xa0);
+ } else {
+ // iVar5 = *(int *) (*(int *) PTR_PTR_overlay_d_0__02083068 + 0x28);
+ local_24 = *(unk32 *) (iVar5 + 0x3c);
+ local_20 = *(unk32 *) (iVar5 + 0x40);
+ local_28 = *(unk32 *) (iVar5 + 0x38);
+ }
+ if (this->mCourse->GetMapScreenPos((u32) bVar1, local_44, &local_48)) {
+ uVar7 = this->mCourse->GetScreenMapCellSizeX();
+ lVar3 = (s64) (s32) ((u32) (u8) this->mMap->mUnk_01b << 0xc) * (s64) (s32) uVar7 + 0x800;
+ *param_2 = local_44[0] + ((s32) (((u32) lVar3 >> 0xc | (s32) ((u64) lVar3 >> 0x20) * 0x100000) + 0x800) >> 0xc);
+ uVar7 = this->mCourse->GetScreenMapCellSizeY();
+ local_4b = this->mMap->mUnk_01c;
+ } else {
+ this->mCourse->GetMapScreenPos(uVar7, local_44, &local_48);
+ this->mCourse->FindMapGridPos(&local_4a, this->mCourse, uVar7);
+ // this->func_ov00_02083a54(&local_4c, this, &local_28, (u32) local_4a.x, (u32) local_4a.y);
+ uVar7 = this->mCourse->GetScreenMapCellSizeX();
+ lVar3 = (s64) (s32) ((u32) local_4c << 0xc) * (s64) (s32) uVar7 + 0x800;
+ *param_2 = local_44[0] + ((s32) (((u32) lVar3 >> 0xc | (s32) ((u64) lVar3 >> 0x20) * 0x100000) + 0x800) >> 0xc);
+ uVar7 = this->mCourse->GetScreenMapCellSizeY();
+ }
+ lVar3 = (s64) (s32) ((u32) local_4b << 0xc) * (s64) (s32) uVar7 + 0x800;
+ *param_3 = local_48 + ((s32) (((u32) lVar3 >> 0xc | (s32) ((u64) lVar3 >> 0x20) * 0x100000) + 0x800) >> 0xc);
+ return true;
+ }
+}
+
+ARM void MapManager::func_ov00_0208306c(s32 *param_2, s32 *param_3) {
+ MapManager *pMVar1;
+ s32 iVar2;
+ MapManager *pMVar3;
+ Vec2b auStack_2c[18];
+ s32 local_28; // This has to be a Vec3p, but uncertain as of now.
+ unk32 local_24; // Unused.
+ unk32 local_20; // Unused.
+ Vec3p local_1c;
+
+ pMVar3 = (MapManager *) this->mCourse->mUnk_008;
+ pMVar1 = this; // why
+ if (pMVar3 != (MapManager *) 0xfffffffd) {
+ pMVar1 = (MapManager *) 0xfffffffe; // I really don't get this
+ }
+ if (pMVar3 == (MapManager *) 0xfffffffd || pMVar3 == pMVar1) {
+ // iVar2 = *(s32 *) (*(s32 *) PTR_PTR_overlay_d_0__02083158 + 0x28);
+ local_28 = *(int *) (iVar2 + 0x5c);
+ local_24 = *(unk32 *) (iVar2 + 0x60);
+ local_20 = *(unk32 *) (iVar2 + 100);
+ /*this->func_ov00_02083244((u32) * (u8 *) (*(s32 *) (*(s32 *) PTR_PTR_overlay_d_0__02083158 + 0x28) + 0x56), &local_28,
+ param_2, param_3);*/
+ return;
+ }
+ if (pMVar3 != (MapManager *) 0xffffffff) {
+ *param_2 = this->mCourse->mUnk_0b4;
+ *param_3 = this->mCourse->mUnk_0b8;
+ return;
+ }
+ local_1c.y = gPlayerPos.y;
+ local_1c.x = gPlayerPos.x;
+ local_1c.z = gPlayerPos.z;
+ // this->func_ov00_02083a1c(auStack_2c, this, &local_1c);
+ this->func_ov00_02082d84(auStack_2c, param_2, param_3);
+}
+
+ARM void MapManager::func_ov00_0208315c(s32 *param_2, s32 *param_3) {
+ u32 uVar1;
+ s32 *piVar2;
+ UnkStruct_027e0d38_Unk28 *pvVar3;
+ s32 *piVar4;
+ Vec3p local_20;
+ Vec3p local_2c;
+
+ *piVar4 = this->mCourse->mUnk_008;
+ *piVar2 = *param_2;
+
+ if (*piVar4 != -3) {
+ *piVar2 = -2;
+ }
+ local_20.x = gPlayerPos.x;
+ local_20.y = gPlayerPos.y;
+ local_20.z = gPlayerPos.z;
+ uVar1 = this->func_ov00_02082d08();
+ this->func_ov00_02083298(uVar1, &local_20, param_2, param_3);
+
+ if (*piVar4 == -2 || piVar4 == piVar2) {
+ pvVar3 = data_027e0d38->mUnk_28;
+ local_2c.x = pvVar3->mUnk_5c[0];
+ local_2c.y = pvVar3->mUnk_5c[1];
+ local_2c.z = pvVar3->mUnk_5c[2];
+ this->func_ov00_02083298((u32) * (u8 *) (*(s32 *) data_027e0d38->mUnk_28 + 0x56), &local_2c, param_2, param_3);
+ return;
+ }
+ if (*piVar4 != -1) {
+ *param_2 = this->mCourse->mUnk_0bc;
+ *param_3 = this->mCourse->mUnk_0c0;
+ }
+}
+
+ARM void MapManager::func_ov00_02083244(u32 param_2, Vec3p *param_3, s32 *param_4, s32 *param_5) {
+ if (4 <= param_2) {
+ param_2 = 0;
+ }
+ *param_4 = (param_3->x - data_ov000_020e24e8[param_2].mUnk_0) + 0x800 >> 0xc;
+ *param_5 = (param_3->z - data_ov000_020e24e8[param_2].mUnk_4) + 0x800 >> 0xc;
+}
+
+ARM void MapManager::func_ov00_02083298(u32 param_2, Vec3p *param_3, s32 *param_4, s32 *param_5) {
+ if (4 <= param_2) {
+ param_2 = 0;
+ }
+
+ *param_4 = data_ov000_020e24c8[param_2].mUnk_0 + ((param_3->x - data_ov000_020e24e8[param_2].mUnk_0 >> 1) + 0x800 >> 0xc);
+ *param_5 = data_ov000_020e24c8[param_2].mUnk_4 + ((param_3->z - data_ov000_020e24e8[param_2].mUnk_4 >> 1) + 0x800 >> 0xc);
+}
+
+ARM bool MapManager::GetCourseData_Unk_25c() {
+ return this->mCourse->mUnk_25c;
+}
+
+ARM bool MapManager::IsMapInMainGrid(u32 map) {
+ return this->mCourse->IsMapInMainGrid(map);
+}
+
+ARM bool MapManager::func_ov00_02083328() {
+ u32 map = (u32) this->func_ov00_02082d08();
+ return this->mCourse->IsMapInMainGrid(map);
+}
+
+ARM u8 MapManager::GetCourseMainGridSizeX() {
+ return (u8) this->mCourse->mMainGridSize.x;
+}
+
+ARM u8 MapManager::GetCourseMainGridSizeY() {
+ return (u8) this->mCourse->mMainGridSize.y;
+}
+
+ARM u16 MapManager::GetMapWidth() {
+ return this->mMap->mWidth;
+}
+
+ARM u16 MapManager::GetMapHeight() {
+ return this->mMap->mHeight;
+}
+
+ARM s32 MapManager::func_ov00_02083374() {
+ return this->GetMapWidth() << 0xc;
+}
+
+ARM s32 MapManager::func_ov00_02083384() {
+ return this->GetMapHeight() << 0xc;
+}
+
+ARM q20 MapManager::GetCourseMinX() {
+ return this->mCourse->mBounds.min.x;
+}
+
+ARM q20 MapManager::GetCourseMinZ() {
+ return this->mCourse->mBounds.min.z;
+}
+
+ARM q20 MapManager::GetCourseMaxX() {
+ return this->mCourse->mBounds.max.x;
+}
+
+ARM q20 MapManager::GetCourseMaxZ() {
+ return this->mCourse->mBounds.max.z;
+}
+
+ARM q20 MapManager::GetMapMinX() {
+ return this->mMap->mBounds.min.x;
+}
+
+ARM q20 MapManager::GetMapMinZ() {
+ return this->mMap->mBounds.min.z;
+}
+
+ARM q20 MapManager::GetMapMaxX() {
+ return this->mMap->mBounds.max.x;
+}
+
+ARM q20 MapManager::GetMapMaxZ() {
+ return this->mMap->mBounds.max.z;
+}
+
+ARM q20 MapManager::GetMapCenterX() {
+ return this->mMap->mCenter.x;
+}
+
+ARM q20 MapManager::GetMapCenterZ() {
+ return this->mMap->mCenter.z;
+}
+
+ARM void MapManager::GetMapMinBounds(Vec3p *param_2) {
+ MapBase *mapBase = this->mMap;
+ param_2->x = mapBase->mBounds.min.x;
+ param_2->y = mapBase->mBounds.min.y;
+ param_2->z = mapBase->mBounds.min.z;
+}
+
+ARM void MapManager::GetMapMaxBounds(Vec3p *param_2) {
+ MapBase *mapBase = this->mMap;
+ param_2->x = mapBase->mBounds.max.x;
+ param_2->y = mapBase->mBounds.max.y;
+ param_2->z = mapBase->mBounds.max.z;
+}
+
+ARM void MapManager::GetMapCenter(Vec3p *param_2) {
+ MapBase *mapBase = this->mMap;
+ param_2->x = mapBase->mCenter.x;
+ param_2->y = mapBase->mCenter.y;
+ param_2->z = mapBase->mCenter.z;
+}
+
+ARM void MapManager::func_ov00_0208346c(AABB *param_2) {
+ (param_2->min).x = this->GetMapMinX();
+ (param_2->min).z = this->GetMapMinZ();
+ (param_2->max).x = this->GetMapMaxX();
+ (param_2->max).z = this->GetMapMaxZ();
+ (param_2->max).y = 0x1333;
+ (param_2->min).y = 0;
+}
+
+ARM void MapManager::func_ov00_020834bc(Vec3p *param_2, unk32 param_3, unk32 param_4) {
+ Vec3p *mapCenter = this->mCourse->FindMapCenter((u32) (u8) this->mCourse->mMapGrid[param_3][param_4]);
+ s32 iVar2;
+ param_2->x = mapCenter->x;
+ param_2->y = mapCenter->y;
+ param_2->z = mapCenter->z;
+ iVar2 = this->func_ov00_02083374();
+ param_2->x = param_2->x - (iVar2 >> 1);
+ iVar2 = this->func_ov00_02083384();
+ param_2->z = param_2->z - (iVar2 >> 1);
+}
+
+ARM void MapManager::func_ov00_02083524(Vec3p *param_2, unk32 param_3, unk32 param_4) {
+ Vec3p *mapCenter = this->mCourse->FindMapCenter((u32) (u8) this->mCourse->mMapGrid[param_3][param_4]);
+ param_2->x = mapCenter->x;
+ param_2->y = mapCenter->y;
+ param_2->z = mapCenter->z;
+}
+
+ARM void MapManager::func_ov00_02083560(Vec2b *param_1, MapManager *param_2, u32 param_3) {
+ param_2->mCourse->FindMapGridPos(param_1, param_2->mCourse, param_3);
+}
+
+ARM u8 MapManager::func_ov00_02083570(u8 param_2, u8 param_3) {
+ return this->mCourse->mMapGrid[param_2][param_3];
+}
+
+ARM unk32 MapManager::func_ov00_02083588() {
+ return this->mCourse->FindMapData_Unk_08(this->func_ov00_02082d08());
+}
+
+ARM unk32 MapManager::func_ov00_020835a4() {
+ return this->mCourse->Get_Unk_c8_00();
+}
+
+ARM unk32 MapManager::func_ov00_020835b4() {
+ return this->mCourse->Get_Unk_c8_04();
+}
+
+ARM bool MapManager::func_ov00_020835c4(s32 param_1, unk32 param_2) {
+ return this->mCourse->func_ov00_0207d404(param_1, 0, param_2, 3);
+}
+
+ARM bool MapManager::func_ov00_020835e4(s32 param_2, unk32 *param_3, unk8 *param_4) {
+ return this->mCourse->func_ov00_0207caa8(param_2, param_3, param_4);
+}
+
+ARM unk32 MapManager::func_ov00_020835f4(s32 param_2) {
+ return this->mCourse->func_ov00_0207cb30(param_2);
+}
+
+ARM void MapManager::func_ov00_02083604(s32 param_2) {
+ this->mCourse->func_ov00_0207cbe8(param_2);
+}
+
+ARM unk8 MapManager::func_ov00_02083614(s32 param_2) {
+ return this->mCourse->func_ov00_0207cc24(param_2);
+}
+
+ARM bool MapManager::GetEntrancePos(Entrance *param_1, unk32 entranceId) {
+ Entrance *entrance = this->mMap->FindEntrance(entranceId);
+ *param_1 = *entrance;
+ return true;
+}
+
+ARM bool MapManager::func_ov00_02083664(Entrance *param_2, unk32 entranceId) {
+ Entrance entrance;
+ entrance.mId = (u8) 0xff;
+ entrance.mUnk_10 = 0;
+ if (this->GetEntrancePos(&entrance, entranceId)) {
+ param_2->mPos.x = entrance.mPos.x;
+ param_2->mPos.y = entrance.mPos.y;
+ param_2->mPos.z = entrance.mPos.z;
+ return true;
+ }
+ return false;
+}
+
+ARM s32 MapManager::GetTriggerBoundingBox(s32 param_2, AABB *param_3) {
+ return this->mMap->GetTriggerBoundingBox(param_2, param_3);
+}
+
+ARM s32 MapManager::GetTriggerBoundingBoxes(s32 param_2, AABB *param_3, s32 param_4) {
+ return this->mMap->GetTriggerBoundingBoxes(param_2, param_3, param_4);
+}
+
+ARM bool MapManager::func_ov00_020836dc(u32 type, u32 actorId) {
+ Actor *actor;
+ Vec3p playerPos;
+
+ switch (actorId) {
+ case 0:
+ case 1:
+ q20 y = gPlayerPos.y;
+ playerPos.x = gPlayerPos.x;
+ playerPos.y = y;
+ playerPos.z = gPlayerPos.z;
+ break;
+ default:
+ actor = gActorManager->FindActorById(actorId);
+ if (actor == NULL) {
+ return false;
+ }
+ playerPos.x = actor->mPos.x;
+ playerPos.y = actor->mPos.y;
+ playerPos.z = actor->mPos.z;
+ break;
+ }
+ return this->IsTriggerTypeOverlapped(type, &playerPos);
+}
+
+ARM bool MapManager::IsTriggerTypeOverlapped(u32 type, Vec3p *pos) {
+ return this->mMap->IsTriggerTypeOverlapped(type, pos);
+}
+
+ARM bool MapManager::GetOverlappingTrigger(Vec3p *param_2) {
+ return this->mMap->GetOverlappingTrigger(param_2);
+}
+
+ARM bool MapManager::func_ov00_02083790(s32 param_2) {
+ bool bVar1;
+ int iVar2;
+ int aiStack_14;
+ int iStack_18;
+
+ if (param_2 == 0) {
+ return true;
+ }
+ *(int *) (*(int *) (*(unk32 *) data_027e0f64 + 8) + 0x1b4) = param_2;
+ *(int *) (*(int *) (*(unk32 *) data_027e0f64 + 4) + 0x1b4) = param_2;
+ iVar2 = data_027e0d38->func_ov000_02078b40();
+ if ((iVar2 != 0) && (bVar1 = this->func_ov00_02082e1c(&aiStack_14, &iStack_18), !bVar1)) {
+ func_ov000_02079898(data_027e0d3c, param_2, 0x10);
+ gActorManager->func_ov00_020c3ce8(param_2, true);
+ }
+ bVar1 = this->mMap->AnyTrigger_func_0c(param_2);
+ return bVar1;
+}
+
+ARM bool MapManager::func_ov00_02083840(s32 param_2) {
+ bool bVar3;
+ s32 iVar4;
+
+ if (param_2 == 0) {
+ return true;
+ }
+ *(unk32 *) (*(unk32 *) (*(unk32 *) data_027e0f64 + 8) + 0x1b4) = -1;
+ *(unk32 *) (*(unk32 *) (*(unk32 *) data_027e0f64 + 4) + 0x1b4) = -1;
+ iVar4 = func_ov000_02078fe8(data_027e0d3c);
+ if (0 <= iVar4) {
+ func_ov000_020798bc(data_027e0d3c, 0x10);
+ gActorManager->func_ov00_020c3ce8(param_2, false);
+ }
+ bVar3 = this->mMap->TriggerOfType_vfunc_10(param_2);
+ return bVar3;
+}
+
+ARM bool MapManager::AddTrigger(s32 param_2) {
+ return this->mMap->AddTrigger(param_2);
+}
+
+ARM bool MapManager::func_ov00_020838d8(s32 param_2) {
+ return this->mMap->func_ov00_0207ff88(param_2);
+}
+
+ARM bool MapManager::FindExit(u32 param_2, Exit *param_3) {
+ return this->mMap->FindExit(param_2, param_3);
+}
+
+ARM char MapManager::func_ov00_020838f8(Exit *param_2) {
+ return this->mMap->func_ov00_02080140(param_2);
+}
+
+ARM bool MapManager::func_ov00_02083908(char id, CameraViewpoint *param_3) {
+ return this->mMap->FindViewpoint_Unk_4(id, param_3);
+}
+
+ARM void MapManager::func_ov00_02083918(s32 param_2, CameraViewpoint *param_3) {
+ this->mMap->FindViewpoint_Unk_0(param_2, param_3);
+}
+
+ARM void MapManager::GetCurrentViewpoint(CameraViewpoint *param_2, s32 param_3) {
+ this->mMap->GetCurrentViewpoint(param_2, param_3);
+}
+
+ARM unk32 MapManager::func_ov00_02083938(s32 param_2) {
+ return this->mMap->GetCurrentViewpoint_Unk_00(param_2);
+}
+
+ARM void MapManager::SetCurrentViewpointId(unk8 value, s32 index) {
+ this->mMap->mCurrViewpointId[index] = value;
+}
+
+ARM void MapManager::func_ov00_02083958(s32 param_2) {
+ this->mMap->func_ov00_0207f924(param_2);
+}
+
+ARM void MapManager::func_ov00_02083968(u32 param_2, unk8 *param_3) {
+ this->mMap->func_ov00_02080824(param_2, param_3);
+}
+
+ARM bool MapManager::func_ov00_02083978(Vec3p *param_2, Vec3p *param_3) {
+ s32 iVar1 = this->mMap->func_ov00_02080a78(param_2);
+ if (iVar1 != 0) {
+ param_3->x = *(s32 *) (iVar1 + 0x8);
+ param_3->y = *(s32 *) (iVar1 + 0xc);
+ param_3->z = *(s32 *) (iVar1 + 0x10);
+ return true;
+ }
+ return false;
+}
+
+ARM bool MapManager::func_ov00_020839b4(s32 param_2) {
+ return this->mMap->AddUnk_130(param_2);
+}
+
+ARM bool MapManager::func_ov00_020839c4(s32 param_2) {
+ return this->mMap->func_ov00_020809b8(param_2);
+}
+
+ARM s32 MapManager::func_ov00_020839d4(s32 param_2) {
+ return this->mMap->GetClampedTileX(param_2 - this->GetMapCenterX());
+}
+
+ARM s32 MapManager::func_ov00_020839f8(s32 param_2) {
+ return this->mMap->GetClampedTileY(param_2 - this->GetMapCenterZ());
+}
+
+ARM void MapManager::func_ov00_02083a1c(Vec2b *param_1, MapManager *param_2, Vec3p *param_3) {
+ s8 x = param_2->func_ov00_020839f8(param_3->z);
+ s8 y = param_2->func_ov00_020839d4(param_3->x);
+ param_1->x = y;
+ param_1->y = x;
+}
+
+ARM void MapManager::func_ov00_02083a54(u8 *param_1, MapManager *param_2, s32 *param_3, s32 param_4, s32 *param_5) {
+ bool bVar1;
+ unk8 uVar2;
+ unk8 uVar3;
+ s32 iVar4;
+ u32 uVar5;
+ s32 *piVar6;
+ Vec3p local_38;
+ Vec3p local_2c;
+ Vec3p VStack_20;
+
+ piVar6 = param_3;
+ iVar4 = param_2->GetCourseData_Unk_25c();
+ if (iVar4 == 0) {
+ uVar2 = param_2->func_ov00_020839f8(param_3[2]);
+ uVar3 = param_2->func_ov00_020839d4(*param_3);
+ *param_1 = uVar3;
+ param_1[1] = uVar2;
+ return;
+ }
+ if (param_4 != -1) {
+ piVar6 = param_5;
+ }
+ if (param_4 != -1 && piVar6 != (int *) 0xffffffff) {
+ uVar5 = (u32) * (u8 *) ((s32) piVar6 + (s32) (param_2->mCourse->mMapGrid + param_4));
+ } else {
+ uVar5 = param_2->func_ov00_02082d08();
+ }
+ bVar1 = param_2->IsMapInMainGrid(uVar5);
+ if (!bVar1) {
+ uVar2 = param_2->func_ov00_020839f8(param_3[2]);
+ uVar3 = param_2->func_ov00_020839d4(*param_3);
+ *param_1 = uVar3;
+ param_1[1] = uVar2;
+ return;
+ }
+ param_2->func_ov00_02083524(&VStack_20, param_4, *param_5);
+ local_38.x = *param_3;
+ local_38.y = param_3[1];
+ local_38.z = param_3[2];
+ Vec3p_Sub(&local_38, &VStack_20, &local_2c);
+ uVar2 = param_2->mMap->GetClampedTileY(local_2c.z);
+ uVar3 = param_2->mMap->GetClampedTileX(local_2c.x);
+ *param_1 = uVar3;
+ param_1[1] = uVar2;
+}
+
+ARM s32 MapManager::GetTileStartX(unk32 x) {
+ return this->GetMapCenterX() + this->mMap->GetTileStartX(x);
+}
+
+ARM s32 MapManager::GetTileStartZ(unk32 z) {
+ return this->GetMapCenterZ() + this->mMap->GetTileStartZ(z);
+}
+
+ARM s32 MapManager::GetTileEndX(unk32 x) {
+ return this->GetMapCenterX() + this->mMap->GetTileEndX(x);
+}
+
+ARM s32 MapManager::GetTileEndZ(unk32 z) {
+ return this->GetMapCenterZ() + this->mMap->GetTileEndZ(z);
+}
+
+ARM s32 MapManager::func_ov00_02083c24(unk32 x) {
+ return this->GetMapCenterX() + this->mMap->GetTileStartX(x) + 0x800;
+}
+
+ARM s32 MapManager::func_ov00_02083c50(unk32 z) {
+ return this->GetMapCenterZ() + this->mMap->GetTileStartZ(z) + 0x800;
+}
+
+ARM void MapManager::func_ov00_02083c7c(Vec3p *param_2, Vec2b param_3) {
+ Vec3p local_28;
+
+ param_2->x = this->func_ov00_02083c24(param_3.x);
+ param_2->z = this->func_ov00_02083c50(param_3.y);
+ local_28 = *param_2;
+ param_2->y = this->MapData_vfunc_68(&local_28, true);
+}
+
+ARM void MapManager::func_ov00_02083ce8(Vec3p *param_2, u32 param_3, s32 param_4, u32 param_5) {
+ bool bVar1;
+ u32 uVar2;
+ Vec3p local_38;
+ Vec3p local_2c;
+
+ uVar2 = param_3;
+ bVar1 = GetCourseData_Unk_25c();
+ if (bVar1) {
+ if (param_4 != -1) {
+ uVar2 = param_5;
+ } else if (param_4 != -1 && uVar2 != -1) {
+ uVar2 = this->mCourse->mMapGrid[param_4][uVar2];
+ } else {
+ uVar2 = this->func_ov00_02082d08();
+ }
+ bVar1 = this->IsMapInMainGrid(uVar2);
+ if (bVar1) {
+ func_ov00_02083524(&local_2c, param_4, param_5);
+ param_2->x = local_2c.x + this->mMap->GetTileStartX(param_3 & 0xff) + 0x800;
+ param_2->z = local_2c.z + this->mMap->GetTileStartZ(param_3 >> 8 & 0xff) + 0x800;
+ } else {
+ param_2->x = this->mMap->GetTileStartX(param_3 & 0xff) + 0x800;
+ param_2->z = this->mMap->GetTileStartZ(param_3 >> 8 & 0xff) + 0x800;
+ }
+ } else {
+ param_2->x = this->mMap->GetTileStartX(param_3 & 0xff) + 0x800;
+ param_2->z = this->mMap->GetTileStartZ(param_3 >> 8 & 0xff) + 0x800;
+ }
+ local_38 = *param_2;
+ param_2->y = MapData_vfunc_68(&local_38, true);
+}
+
+ARM s32 MapManager::func_ov00_02083e34(unk8 param_2, unk8 param_3, unk32 param_4) {
+ Vec2b local_8;
+ local_8.x = param_2;
+ local_8.y = param_3;
+ return this->mMap->vfunc_60(&local_8);
+}
+
+ARM unk32 MapManager::MapData_vfunc_60(Vec2b *param_1) {
+ return this->mMap->vfunc_60(param_1);
+}
+
+ARM bool MapManager::func_ov00_02083e70(Vec2b *param_2) {
+ int iVar1;
+ int iVar2;
+
+ iVar1 = this->MapData_vfunc_54(param_2);
+
+ switch (iVar1) {
+ case 0x1b:
+ case 0x2b:
+ case 0x4e:
+ case 0x4f: return true;
+ }
+
+ iVar1 = this->MapData_vfunc_60(param_2);
+ iVar2 = this->GetMapData_Unk_48();
+ return iVar1 >= iVar2;
+}
+
+ARM unk32 MapManager::MapData_vfunc_68(Vec3p *param_1, bool param_2) {
+ return this->mMap->vfunc_68(param_1, param_2);
+}
+
+ARM s32 MapManager::func_ov00_02083ef8(Vec3p *param_2, Vec3p *param_3, bool param_4) {
+ Vec3p local_18 = *param_2;
+
+ if (param_3->y > local_18.y) {
+ local_18.y = param_3->y;
+ }
+ return this->mMap->vfunc_68(&local_18, param_4);
+}
+
+ARM unk32 MapManager::func_ov00_02083f44(Vec3p *param_2, bool param_3) {
+ Vec3p local_18;
+
+ local_18 = *param_2;
+ local_18.y = *(data_ov000_020e24a4 + 0x8);
+ return this->func_ov00_02083ef8(param_2, &local_18, param_3);
+}
+
+unk8 MapManager::MapData_vfunc_6c(unk32 param_2, unk32 param_3, unk32 param_4) {
+ this->mMap->vfunc_6c(param_2, param_3, param_4);
+}
+
+ARM unk32 MapManager::MapData_vfunc_70(Vec3p *param_2) {
+ return this->mMap->vfunc_70(param_2);
+}
+
+ARM void MapManager::func_ov00_02083fb0(u32 *param_1, MapManager *param_2, Vec3p *param_3) {
+ unk32 *iVar1; // find type with field that exists at offset 0xc
+ s32 dVar2;
+
+ iVar1 = (unk32 *) param_2->mMap->vfunc_74(param_3);
+ if (iVar1 != NULL) {
+ *param_1 = *(u32 *) ((unk32 *) iVar1 + 0x3); // offset 0xc
+ return;
+ }
+ dVar2 = param_2->MapData_vfunc_70(param_3);
+ if (dVar2 != 0xffff) {
+ func_ov000_02093a1c(param_1, data_027e0f6c, dVar2);
+ return;
+ }
+ *param_1 = 0;
+}
+
+void MapManager::GetTileWorldBounds(Vec2b *tile, AABB *tileBounds) {
+ int iVar1;
+ Vec3p local_20;
+
+ this->mMap->GetTileBounds(tile, tileBounds);
+ iVar1 = this->GetMapCenterZ();
+ local_20.x = this->GetMapCenterX();
+ local_20.y = 0;
+ local_20.z = iVar1;
+ Vec3p_Add(&tileBounds->min, &local_20, &tileBounds->min);
+ Vec3p_Add(&tileBounds->max, &local_20, &tileBounds->max);
+}
+
+unk32 MapManager::MapData_vfunc_54(Vec2b *param_1) {
+ return this->mMap->vfunc_54(param_1);
+}
+
+ARM unk32 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3) {
+ // Correct param types?
+ Vec2b vec;
+ vec.x = param_2;
+ vec.y = param_3;
+ return this->mMap->vfunc_54(&vec);
+}
+
+unk32 *MapManager::MapData_vfunc_78(Vec2b *param_1) {
+ return this->mMap->vfunc_78(param_1);
+}
+
+unk32 MapManager::func_ov00_020840dc(Vec2b *param_1) {
+ UnkStruct_02037750 *piVar1; // placeholder struct until I can find the real struct
+
+ piVar1 = (UnkStruct_02037750 *) this->MapData_vfunc_78(param_1);
+ if (piVar1 != NULL) {
+ return piVar1->vfunc_1c();
+ }
+ return -1;
+}
+
+unk8 MapManager::func_ov00_02084100(unk32 *param_1, MapManager *param_2) {
+ unk32 uVar1 = param_2->mMap->mUnk_040;
+ *param_1 = param_2->mMap->mUnk_044;
+ param_1[1] = uVar1;
+}
+
+u32 MapManager::GetMapData_Unk_48() {
+ return this->mMap->mUnk_048;
+}
+
+unk32 MapManager::GetMapData_Unk_4c() {
+ return this->mMap->mUnk_04c;
+}
+
+unk32 MapManager::func_ov00_0208412c() {
+ return this->mMap->func_ov00_0207f934();
+}
+
+void MapManager::func_ov00_0208413c(unk32 param_2) {
+ this->mMap->func_ov00_0207f948(param_2);
+}
+
+unk8 MapManager::MapData_vfunc_58(Vec2b *param_1, int param_2) {
+ this->mMap->vfunc_58(param_1, param_2);
+}
+
+ARM s32 MapManager::func_ov00_02084164(Vec2b *param_2) {
+ int iVar1;
+ unk32 uVar2;
+
+ iVar1 = this->mMap->vfunc_58(param_2, 7);
+ if (iVar1 != 0) {
+ return 0;
+ }
+ uVar2 = this->MapData_vfunc_54(param_2);
+ switch (uVar2) {
+ case 0:
+ case 8:
+ case 9:
+ case 0xb:
+ case 0xc:
+ case 0xd:
+ case 0xe:
+ case 0xf:
+ case 0x10:
+ case 0x11:
+ case 0x12:
+ case 0x13:
+ case 0x15:
+ case 0x16:
+ case 0x18:
+ case 0x1a:
+ case 0x20:
+ case 0x21:
+ case 0x22:
+ case 0x23:
+ case 0x25:
+ case 0x26:
+ case 0x27:
+ case 0x28:
+ case 0x29:
+ case 0x2a:
+ case 0x2c:
+ case 0x2d:
+ case 0x2e:
+ case 0x2f:
+ case 0x31:
+ case 0x32:
+ case 0x35:
+ case 0x36:
+ case 0x38:
+ case 0x39:
+ case 0x3a:
+ case 0x3b:
+ case 0x3c:
+ case 0x3d:
+ case 0x3e:
+ case 0x3f:
+ case 0x41:
+ case 0x42:
+ case 0x43:
+ case 0x44:
+ case 0x45:
+ case 0x4d:
+ case 0x51:
+ case 0x52:
+ case 0x53:
+ case 0x54: return 1;
+ }
+ return 0;
+}
+
+u8 MapManager::GetMapData_Unk_0a() {
+ return this->mMap->mUnk_00a;
+}
+
+u8 MapManager::GetMapData_Unk_0b() {
+ return this->mMap->mUnk_00b;
+}
+
+unk8 MapManager::MapData_vfunc_a4(unk8 *param_1) {
+ this->mMap->vfunc_a4(param_1);
+}
+
+ARM void MapManager::func_ov00_0208433c(Vec3p *param_2, Vec2s *param_3) {
+ Vec3p local_18 = *param_2;
+ Vec3p VStack_24;
+ Vec2s local_28;
+
+ this->GetMapMinBounds(&VStack_24);
+ Vec3p_Sub(&local_18, &VStack_24, &local_18);
+ this->mMap->func_ov00_0207f53c(&local_28, this->mMap, &local_18);
+ param_3->x = local_28.x;
+ param_3->y = local_28.y;
+}
+
+unk8 MapManager::func_ov00_0208439c(Vec2s *param_2, Vec3p *param_3) {
+ s32 iVar1;
+ Vec3p VStack_18;
+
+ this->mMap->func_ov00_0207f630(param_2, param_3);
+ this->GetMapMinBounds(&VStack_18);
+ Vec3p_Add(param_3, &VStack_18, param_3);
+ iVar1 = this->MapData_vfunc_68(param_3, true);
+ param_3->y = iVar1;
+}
+
+void MapManager::func_ov00_020843ec(s32 *param_2) {
+ u32 uVar1;
+ s32 iVar2;
+ s32 iVar3;
+ unk16 uStack_88;
+ unk16 uStack_86;
+ unk16 uStack_84;
+ unk16 uStack_82;
+ Vec2s local_80;
+ Vec2s local_7c;
+ Vec2s local_78;
+ Vec2s local_74;
+ Vec3p local_70;
+ Vec3p local_64;
+ s32 local_58;
+ s32 iStack_54;
+ s32 iStack_50;
+ s32 local_4c;
+ s32 iStack_48;
+ s32 iStack_44;
+ Vec3p local_40;
+ Vec3p local_34;
+ s32 local_28;
+ s32 local_24;
+ s32 local_20;
+
+ // uVar1 = (**(code **) (*param_2 + 8))(); // Which function is this?
+ if (uVar1 < 2) {
+ // (**(code **) (*param_2 + 0x3c))(param_2, &local_28); // And this?
+ // local_40.z = (**(code **) (*param_2 + 0x40))(); // What about this?
+ local_34.x = local_28 - local_40.z;
+ local_34.z = local_20 - local_40.z;
+ local_40.x = local_28 + local_40.z;
+ local_40.z = local_20 + local_40.z;
+ local_34.y = local_24;
+ local_40.y = local_24;
+ iVar2 = this->GetMapMinX();
+ local_34.x = local_34.x - iVar2;
+ iVar2 = this->GetMapMinZ();
+ local_34.z = local_34.z - iVar2;
+ iVar2 = this->GetMapMinX();
+ local_40.x = local_40.x - iVar2;
+ iVar2 = this->GetMapMinZ();
+ local_40.z = local_40.z - iVar2;
+ this->mMap->func_ov00_0207f53c(&local_74, this->mMap, &local_34);
+ this->mMap->func_ov00_0207f53c(&local_78, this->mMap, &local_40);
+ iVar2 = (int) local_74.x;
+ if (iVar2 <= local_78.x) {
+ do {
+ iVar3 = (int) local_74.y;
+ if (iVar3 <= local_78.y) {
+ do {
+ uStack_84 = (unk16) iVar2;
+ uStack_82 = (unk16) iVar3;
+ this->mMap->vfunc_ac(/*&uStack_84*/); // No args?
+ iVar3 = (iVar3 + 1) * 0x10000 >> 0x10;
+ } while (iVar3 <= local_78.y);
+ }
+ iVar2 = (iVar2 + 1) * 0x10000 >> 0x10;
+ } while (iVar2 <= local_78.x);
+ return;
+ }
+ return;
+ }
+ if (uVar1 == 2) {
+ this->mMap->vfunc_2c(/*&local_58*/); // No args?
+ local_64.x = local_58;
+ local_64.y = iStack_54;
+ local_64.z = iStack_50;
+ local_70.x = local_4c;
+ local_70.y = iStack_48;
+ local_70.z = iStack_44;
+ iVar2 = this->GetMapMinX();
+ local_64.x = local_64.x - iVar2;
+ iVar2 = this->GetMapMinZ();
+ local_64.z = local_64.z - iVar2;
+ iVar2 = this->GetMapMinX();
+ local_70.x = local_70.x - iVar2;
+ iVar2 = this->GetMapMinZ();
+ local_70.z = local_70.z - iVar2;
+ this->mMap->func_ov00_0207f53c(&local_7c, this->mMap, &local_64);
+ this->mMap->func_ov00_0207f53c(&local_80, this->mMap, &local_70);
+ iVar2 = (int) local_7c.x;
+ if (iVar2 <= local_80.x) {
+ do {
+ iVar3 = (int) local_7c.y;
+ if (iVar3 <= local_80.y) {
+ do {
+ uStack_88 = (unk16) iVar2;
+ uStack_86 = (unk16) iVar3;
+ this->mMap->vfunc_ac(/*&uStack_88*/); // No args?
+ iVar3 = (iVar3 + 1) * 0x10000 >> 0x10;
+ } while (iVar3 <= local_80.y);
+ }
+ iVar2 = (iVar2 + 1) * 0x10000 >> 0x10;
+ } while (iVar2 <= local_80.x);
+ }
+ }
+}
+
+ARM unk32 MapManager::GetMapData_Unk_38() {
+ return this->mMap->mUnk_038;
+}
+
+ARM s32 MapManager::func_ov00_020846a4() {
+ s32 iVar1 = *(s32 *) ((s32) this->mMap->mUnk_144 + 4);
+ if (iVar1 == 0xff) {
+ switch (this->mCourse->mType) {
+ case CourseType_Dungeon:
+ case CourseType_TempleOfTheOceanKing:
+ case CourseType_Battle: return 1;
+ case CourseType_Sea: return 2;
+ case CourseType_Normal:
+ default: return 0;
+ }
+ }
+ return iVar1;
+}
+
+ARM s32 MapManager::func_ov00_02084700() {
+ s32 iVar1;
+ iVar1 = this->mMap->mUnk_034;
+ if (iVar1 == -1) {
+ iVar1 = this->mCourse->mUnk_0c4;
+ }
+ if ((iVar1 == 0x1b) && (gActorManager->mUnk_29 != false)) {
+ iVar1 = 0x1c;
+ }
+ return iVar1;
+}
+
+unk32 MapManager::func_ov00_02084740() {
+ static const s32 data_ov000_020d88f0[] = {
+ // Map IDs?
+ 0x51, 0x6e, 0x65, 0x50, 0x30, 0x74, 0x49, 0x50, 0x51, 0x54, 0x52, 0x53, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5f,
+ 0x60, 0x61, 0x5c, 0x5b, 0x5e, 0x62, 0x63, 0x64, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x5d, 0x31, 0x39,
+ 0x3a, 0x3b, 0x3c, 0x32, 0x33, 0x34, 0x35, 0x38, 0x3d, 0xd9, 0xdc, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0x6f, 0x72,
+ 0x75, 0x78, 0x79, 0x7a, 0x7b, 0x7f, 0x83, 0x87, 0x7c, 0x80, 0x84, 0x0, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e,
+ 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9d, 0x9e, 0x9f, 0xa0, 0x70, 0x71,
+ 0x73, 0x76, 0x77, 0x7d, 0x7e, 0x81, 0x82, 0x86, 0x9c, 0x36, 0x37, 0xd0, 0xd1, 0xcd, 0x19a};
+ bool bVar1;
+ int iVar2;
+ int iVar3;
+ unk32 uVar4;
+ unk32 uVar5;
+ unk32 uVar6;
+ unk32 uVar7;
+ s32 *puVar8;
+ unk32 *puVar9;
+ unk32 local_1c8;
+ unk32 local_1c4;
+ unk32 local_1c0;
+ unk32 local_1bc[108];
+
+ // iVar2 = this->func_ov00_02084700(?); // what param?
+ // iVar3 = UnkStruct_027e0d38::FUN_overlay_d_0__02078b40(*(UnkStruct_027e0d38 **) PTR_PTR_overlay_d_0__020847d4);
+ if (iVar3 != 2) {
+ local_1c8 = *(unk32 *) gPlayerPos.x;
+ local_1c4 = *(unk32 *) gPlayerPos.y;
+ local_1c0 = *(unk32 *) gPlayerPos.z;
+ // bVar1 = FUN_overlay_d_0__02083780(&local_1c8); // MapManager method?
+ if (bVar1) {
+ // iVar2 = this->func_ov00_020847f0();
+ }
+ }
+ puVar9 = local_1bc;
+ iVar3 = 0x1b;
+ puVar8 = (s32 *) data_ov000_020d88f0;
+ do {
+ uVar4 = *puVar8;
+ uVar5 = puVar8[1];
+ uVar6 = puVar8[2];
+ uVar7 = puVar8[3];
+ puVar8 = puVar8 + 4;
+ *puVar9 = uVar4;
+ puVar9[1] = uVar5;
+ puVar9[2] = uVar6;
+ puVar9[3] = uVar7;
+ puVar9 = puVar9 + 4;
+ iVar3 = iVar3 + -1;
+ } while (iVar3 != 0);
+ return local_1bc[iVar2];
+}
+
+unk32 MapManager::func_ov00_020847e0() {
+ return *(s32 *) ((s32) this->mMap->mUnk_144 + 0xc);
+}
+
+ARM unk32 MapManager::func_ov00_020847f0(unk32 type) {
+ TriggerBase *triggerBase = this->mMap->FindTrigger(type);
+
+ if (triggerBase == NULL) {
+ return this->func_ov00_02084700();
+ }
+ if ((triggerBase->mUnk_0c != -1) && ((int) triggerBase->mUnk_0c < 0x6c)) {
+ return triggerBase->mUnk_0c;
+ }
+ return this->func_ov00_02084700();
+}
+
+bool MapManager::func_ov00_02084838() {
+ unk32 uVar1 = this->GetMapData_Unk_38();
+ switch (uVar1) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 10:
+ case 0xb:
+ case 0xc:
+ case 0x11:
+ case 0x13:
+ case 0x14:
+ case 0x15:
+ case 0x16: return true;
+ default: return false;
+ }
+}
+
+bool MapManager::func_ov00_020848b8() {
+ unk32 uVar1 = this->func_ov00_020846a4();
+ switch (uVar1) {
+ case 6:
+ case 0xc:
+ case 0xd:
+ case 0xf:
+ case 0x11: return true;
+ }
+ return false;
+}
+
+void MapManager::func_ov00_02084924(u32 param_2) {
+ this->mMap->func_ov00_0208008c(param_2);
+}
+
+ARM bool MapManager::func_ov00_02084934(Vec3p *param_2) {
+ Vec3p local_20;
+
+ q20 mapCenterZ = this->GetMapCenterZ();
+ q20 y = param_2->y;
+ q20 zDiff = param_2->z - mapCenterZ;
+ local_20.x = param_2->x - this->GetMapCenterX();
+ local_20.y = y;
+ local_20.z = zDiff;
+ return this->mMap->IsInBounds(&local_20);
+}
+
+u8 MapManager::GetMapData_Unk_06() {
+ return this->mMap->mUnk_006;
+}
+
+u8 MapManager::GetMapData_Unk_07() {
+ return this->mMap->mUnk_007;
+}
+
+bool MapManager::func_ov00_0208499c() {
+ s32 iVar2 = this->func_ov00_020849c0();
+ if (iVar2 == 0) {
+ return this->mCourse->IsCurrentMapInMainGrid();
+ }
+ return false;
+}
+
+bool MapManager::func_ov00_020849c0() {
+ return this->mCourse->mUnk_008 == -2;
+}
+
+bool MapManager::func_ov00_020849dc() {
+ return this->mCourse->mUnk_008 == -3;
+}
+
+ARM bool MapManager::func_ov00_020849f8() {
+ switch (data_027e0d38->mUnk_0c.func_ov000_020a5e9c()) {
+ case 5: return true;
+ default:
+ if (this->GetMapData_Unk_06() != 0 && !this->func_ov00_020849c0()) {
+ return true;
+ }
+ break;
+ }
+ return false;
+}
+
+u8 MapManager::func_ov00_02084a50() {
+ return this->mMap->mUnk_011;
+}
+
+void MapManager::SpawnNPC(Vec3p *pos, unk32 param_3, unk32 param_4) {
+ ActorSpawnOptions actorSpawnOptions;
+ actorSpawnOptions.mUnk_1c.id = -1;
+ actorSpawnOptions.mUnk_1c.index = -1;
+ func_ov000_020c3348(&actorSpawnOptions);
+ actorSpawnOptions.mUnk_24 = param_3;
+ actorSpawnOptions.mUnk_28 = param_4;
+ gActorSpawner->Spawn(ActorTypeId_EVIC, pos, &actorSpawnOptions, NULL);
+}
+
+ARM bool MapManager::func_ov00_02084ac4(u32 actorId) {
+ Actor *iVar1;
+ bool bVar1;
+
+ iVar1 = gActorManager->FindActorById(actorId);
+ if (iVar1 == NULL) {
+ return false;
+ }
+
+ if (iVar1->mType != ActorTypeId_EVIC) return false;
+ iVar1->mAlive = false;
+ return true;
+}
+
+void MapManager::SetNumKeys(unk32 keys) {
+ this->mCourse->mNumKeys = keys;
+}
+
+unk32 MapManager::GetNumKeys() {
+ return this->mCourse->mNumKeys;
+}
+
+void MapManager::SetBlueWarpOpen(bool state) {
+ this->mCourse->mBlueWarpOpen = state;
+}
+
+bool MapManager::GetBlueWarpOpen() {
+ return this->mCourse->mBlueWarpOpen;
+}
+
+ARM void MapManager::func_ov00_02084b38(u32 param_2, unk32 param_3, bool param_4) {
+ MapBase *pMVar1;
+ if (param_2 == 0) {
+ return;
+ }
+ switch (param_3) {
+ case 0:
+ pMVar1 = this->mMap;
+ if (param_4) {
+ pMVar1->mUnk_180[param_2 >> 5].mUnk_0 |= 1 << (param_2 & 0x1f);
+ break;
+ }
+ pMVar1->mUnk_180[param_2 >> 5].mUnk_0 &= ~(1 << (param_2 & 0x1f));
+ break;
+ case 1: this->mCourse->SetMapDataFlag0(param_2, param_4); break;
+ case 2: this->mCourse->SetFlag0(param_2, param_4); break;
+ case 3: this->mCourse->SetFlag1(param_2, param_4); break;
+ default: break;
+ }
+}
+
+bool MapManager::func_ov00_02084be0(u32 param_2, unk32 param_3) {
+ bool bVar1;
+
+ if (param_2 == 0) {
+ return false;
+ }
+ switch (param_3) {
+ case 0: return (this->mMap->mUnk_180[param_2 >> 5].mUnk_0 & 1 << (param_2 & 0x1f)) != 0;
+ case 1: bVar1 = this->mCourse->GetMapDataFlag0(param_2); return bVar1;
+ case 2: bVar1 = this->mCourse->GetFlag0(param_2); return bVar1;
+ case 3: bVar1 = this->mCourse->SetFlag1(param_2); return bVar1;
+ default: return false;
+ }
+}
+
+void MapManager::SetMapDataFlag1(unk32 param_2, bool param_3) {
+ this->mCourse->SetMapDataFlag1(param_2, param_3);
+}
+
+bool MapManager::GetMapDataFlag1(unk32 param_2) {
+ return this->mCourse->GetMapDataFlag1(param_2);
+}
+
+void MapManager::func_ov00_02084c7c(unk32 param_2, bool param_3) {
+ if (param_2 < 0) {
+ return;
+ }
+ this->mCourse->SetMapDataFlag2(param_2, param_3);
+}
+
+bool MapManager::func_ov00_02084c94(unk32 param_2) {
+ bool bVar1;
+
+ if (0 <= param_2) {
+ bVar1 = this->mCourse->GetMapDataFlag2(param_2);
+ return bVar1;
+ }
+ return false;
+}
+
+void MapManager::func_ov00_02084cb0(unk32 param_2, bool param_3) {
+ if (param_2 < 0) {
+ return;
+ }
+ this->mCourse->SetMapDataFlag3(param_2, param_3);
+}
+
+bool MapManager::func_ov00_02084cc8(unk32 param_2) {
+ bool bVar1;
+
+ if (0 <= param_2) {
+ bVar1 = this->mCourse->GetMapDataFlag3(param_2);
+ return bVar1;
+ }
+ return false;
+}
+
+void MapManager::func_ov00_02084ce4(unk32 param_2, bool param_3) {
+ if (param_2 < 0) {
+ return;
+ }
+ this->mCourse->SetMapDataFlag4(param_2, param_3);
+}
+
+bool MapManager::func_ov00_02084cfc(unk32 param_2) {
+ bool bVar1;
+
+ if (0 <= param_2) {
+ bVar1 = this->mCourse->GetMapDataFlag4(param_2);
+ return bVar1;
+ }
+ return false;
+}
+
+u8 MapManager::GetMapData_Unk_09() {
+ return this->mMap->mUnk_009;
+}
+
+ARM void MapManager::func_ov00_02084d24(unk8 param_2, unk8 param_3, unk16 param_4) {
+ // Matches, but param types unsure.
+ // param_2 and param_3 aren't both part of a Vec2b *
+ // param_4 short or int?
+ Vec2b vec;
+ vec.x = param_2;
+ vec.y = param_3;
+ this->mMap->vfunc_90(&vec, param_4);
+}
+
+s32 MapManager::func_ov00_02084d4c(unk32 param_2, unk32 param_3, Vec3p *param_4) {
+ unk32 *object; // undefined type
+ unk32 *dtor; // undefined type
+ unk32 *obj; // undefined type
+ unk32 a; // dword
+ int iVar1;
+ int aiStack_3c[4];
+ Vec3p VStack_2c;
+ int iStack_20;
+ int iStack_1c;
+ int iStack_18;
+ Vec3p VStack_14;
+
+ iVar1 = func_ov000_0208df78(data_027e0f64 + 4, param_2, param_3, &VStack_14, &iStack_20);
+ // object = PTR_DWORD_overlay_d_0__020e2510_overlay_d_0__02084ea8;
+ if (iVar1 == -1) {
+ return -1;
+ }
+ /*if ((*(u32 *) (PTR_DestructorChain_overlay_d_0_bss__020ec964_overlay_d_0__02084ea4 + 0x60) & 1) == 0) {
+ aiStack_3c[1] = 0;
+ aiStack_3c[3] = 0;
+ aiStack_3c[2] = 0x1000;
+ *(unk32 *) PTR_DWORD_overlay_d_0__020e2510_overlay_d_0__02084ea8 = 0;
+ *(unk32 *) (object + 4) = 0x1000;
+ *(unk32 *) (object + 8) = 0;
+ obj = PTR_DestructorChain_overlay_d_0_bss__020ec9c8_overlay_d_0__02084eb4;
+ dtor = PTR_FUN_overlay_d_0__0207e968_overlay_d_0__02084eb0;
+ *(unk32 *) (PTR_PTR_s_anc_overlay_d_0__020e24a0_overlay_d_0__020e24a4_overlay_d_0__02084eac + 0x78) = 0;
+ __register_global_object(object, dtor, (DestructorChain *) obj);
+ *(u32 *) (PTR_DestructorChain_overlay_d_0_bss__020ec964_overlay_d_0__02084ea4 + 0x60) =
+ *(u32 *) (PTR_DestructorChain_overlay_d_0_bss__020ec964_overlay_d_0__02084ea4 + 0x60) | 1;
+ }*/
+ VStack_2c.x = iStack_20;
+ VStack_2c.y = iStack_1c;
+ VStack_2c.z = iStack_18;
+ Vec3p_Sub(&VStack_2c, &VStack_14, &VStack_2c);
+ // iVar1 = func_01ffe61c(PTR_DWORD_overlay_d_0__020e2510_overlay_d_0__02084ea8, &VStack_14, &VStack_2c, aiStack_3c);
+ if (iVar1 != 0) {
+ param_4->x = VStack_14.x;
+ param_4->y = VStack_14.y;
+ param_4->z = VStack_14.z;
+ Vec3p_Axpy(aiStack_3c[0], &VStack_2c, param_4, param_4);
+ a = 0x19a;
+ if (aiStack_3c[0] < 0) {
+ param_4->x = VStack_14.x;
+ param_4->y = VStack_14.y;
+ param_4->z = VStack_14.z;
+ Vec3p_Axpy(a, &VStack_2c, param_4, param_4);
+ return 1;
+ }
+ return 0;
+ }
+ return -1;
+}
+
+unk32 MapManager::func_ov00_02084ebc(Vec3p *param_2) {
+ int *piVar1;
+ int iVar2;
+ unk32 dVar3; // dword
+ Vec2b auStack_18[4]; // undefined type
+ u32 uStack_14;
+
+ this->func_ov00_02083a1c(auStack_18, this, param_2);
+ piVar1 = (int *) this->MapData_vfunc_78(auStack_18);
+ if (piVar1 != (int *) 0x0) {
+ // iVar2 = (**(code **) (*piVar1 + 0x1c))();
+ if (iVar2 < 0x39) {
+ if ((iVar2 < 0x38) && (iVar2 != 1)) {
+ return 0;
+ }
+ } else if (iVar2 < 0x5a) {
+ if (iVar2 != 0x59) {
+ return 0;
+ }
+ } else {
+ if (iVar2 != 0x61) {
+ return 0;
+ }
+ if (piVar1[2] == 2) {
+ return 0;
+ }
+ }
+ }
+ iVar2 = this->func_ov00_02083e70(auStack_18);
+ if (iVar2 != 0) {
+ return 0;
+ }
+ iVar2 = this->MapData_vfunc_54(0);
+ if (iVar2 < 0x47) {
+ if (0x45 < iVar2) {
+ return 0;
+ }
+ if (iVar2 < 0x2a) {
+ switch (iVar2) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ case 8:
+ case 9:
+ case 0x14:
+ case 0x16:
+ case 0x17:
+ case 0x19:
+ case 0x1d:
+ case 0x1e:
+ case 0x1f:
+ case 0x27:
+ case 0x28:
+ case 0x29: return 0;
+ default: break;
+ }
+ } else if (iVar2 == 0x37) {
+ return 0;
+ }
+ } else if (iVar2 < 0x49) {
+ if (0x47 < iVar2) {
+ return 0;
+ }
+ if (iVar2 == 0x47) {
+ return 0;
+ }
+ } else if (iVar2 == 0x50) {
+ return 0;
+ }
+ iVar2 = this->mMap->vfunc_58(auStack_18, 5);
+ if (iVar2 != 0) {
+ return 0;
+ }
+ // dVar3 = this->MapData_vfunc_70(); // Missing param.
+ if (dVar3 != 0xffff) {
+ func_ov000_02093a1c(&uStack_14, data_027e0f6c, dVar3);
+ if ((uStack_14 >> 5 & 3) != 1) {
+ return 0;
+ }
+ return 1;
+ }
+ return 0;
+}
+
+s32 MapManager::func_ov00_02085108(Vec3p *param_2) {
+ MapManager *puVar1;
+ unk32 uVar2;
+ int *piVar3;
+ int iVar4;
+ u32 uVar5;
+ int iVar6;
+ int iVar7;
+ int iVar8;
+ u32 local_44;
+ u8 local_3a;
+ u8 local_39;
+ u8 local_38;
+ u8 local_37;
+ int local_34;
+ int local_30;
+ int local_2c;
+ unk32 local_28;
+
+ uVar2 = func_ov000_0208b180(data_027e0f64);
+ func_ov000_02088130(&local_38, uVar2);
+ local_44 = (u32) local_38;
+ uVar2 = func_ov000_0208b180(data_027e0f64);
+ func_ov000_02088144(&local_3a, uVar2);
+ if (local_44 <= local_37) {
+ do {
+ puVar1 = gMapManager;
+ uVar5 = (u32) local_39;
+ if ((u32) local_3a <= (u32) local_39) {
+ do {
+ // piVar3 = (int *) puVar1->MapData_vfunc_78();
+ if ((piVar3 != (int *) 0x0) && ((piVar3[1] & 4U) != 0)) {
+ iVar7 = piVar3[7];
+ iVar6 = piVar3[6];
+ iVar8 = piVar3[8];
+ // iVar4 = (**(code **) (*piVar3 + 0x60))();
+ // local_28 = (**(code **) (*piVar3 + 0x5c))();
+ local_34 = iVar6;
+ local_30 = iVar7 + iVar4;
+ local_2c = iVar8;
+ // iVar4 = func_0202b8e4(&local_34, 2);
+ if (iVar4 != 0) {
+ param_2->x = piVar3[6];
+ param_2->y = piVar3[7];
+ param_2->z = piVar3[8];
+ return (int) *(char *) ((int) piVar3 + 0x12);
+ }
+ }
+ uVar5 = uVar5 - 1;
+ } while ((int) (u32) local_3a <= (int) uVar5);
+ }
+ local_44 = local_44 + 1;
+ } while ((int) local_44 <= (int) (u32) local_37);
+ }
+ return 0;
+}
+
+s32 MapManager::func_ov00_0208527c(MapManager *param_1, unk32 param_2, unk32 *param_3) {
+ u32 uVar1;
+ MapManager *puVar2;
+ unk32 uVar3;
+ int iVar4;
+ int iVar5;
+ u32 uVar6;
+ u32 uVar7;
+ u32 local_4c;
+ u8 local_3e;
+ u8 local_3d;
+ u8 local_3c;
+ u8 local_3b;
+ unk32 local_38;
+ unk32 local_34;
+ unk32 local_30;
+ unk32 local_2c;
+
+ uVar3 = func_ov000_0208b180(data_027e0f64);
+ func_ov000_02088130(&local_3c, uVar3);
+ uVar7 = (u32) local_3c;
+ uVar3 = func_ov000_0208b180(data_027e0f64);
+ func_ov000_02088144(&local_3e, uVar3);
+ local_4c = (u32) local_3e;
+ uVar6 = (u32) local_3d;
+ iVar4 = param_1->GetMapWidth();
+ iVar5 = param_1->GetMapHeight();
+ puVar2 = gMapManager;
+ if (uVar7 == 0) {
+ uVar7 = 0;
+ }
+ if (iVar4 <= (int) (u32) local_3b) {
+ uVar7 = iVar4 - 1;
+ }
+ if (local_4c == 0) {
+ local_4c = 0;
+ }
+ if (iVar5 <= (int) uVar6) {
+ uVar6 = iVar5 - 1;
+ }
+ local_2c = 0;
+ local_38 = 0;
+ local_34 = 0;
+ local_30 = 0;
+ do {
+ uVar1 = local_4c;
+ if ((int) (u32) local_3b < (int) uVar7) {
+ return 0;
+ }
+ for (; (int) uVar1 <= (int) uVar6; uVar1 = uVar1 + 1) {
+ // iVar4 = puVar2->MapData_vfunc_78(0);
+ if (((iVar4 != 0) && ((*(u32 *) (iVar4 + 4) & 4) != 0)) &&
+ (iVar5 = func_ov000_0208b73c(iVar4, param_2), iVar5 != 0))
+ {
+ *param_3 = *(unk32 *) (iVar4 + 0x18);
+ param_3[1] = *(unk32 *) (iVar4 + 0x1c);
+ param_3[2] = *(unk32 *) (iVar4 + 0x20);
+ return (int) *(char *) (iVar4 + 0x12);
+ }
+ }
+ uVar7 = uVar7 + 1;
+ } while (true);
+}
+
+s32 MapManager::func_ov00_020853fc(MapManager *param_1, Vec3p *param_2, s32 *param_3) {
+ u32 uVar1;
+ unk32 uVar2;
+ int iVar3;
+ int iVar4;
+ int iVar5;
+ u32 uVar6;
+ int iVar7;
+ u32 local_50;
+ u32 local_48;
+ u8 local_3e;
+ u8 local_3d;
+ u8 local_3c;
+ u8 local_3b;
+ unk32 local_38;
+ unk32 local_34;
+ unk32 local_30;
+ unk32 local_2c;
+
+ uVar2 = func_ov000_0208b180(data_027e0f64);
+ func_ov000_02088130(&local_3c, uVar2);
+ local_48 = (u32) local_3c;
+ uVar2 = func_ov000_0208b180(data_027e0f64);
+ func_ov000_02088144(&local_3e, uVar2);
+ local_50 = local_3e;
+ uVar6 = local_3d;
+ iVar3 = param_1->GetMapWidth();
+ iVar4 = param_1->GetMapHeight();
+ iVar7 = 0;
+ local_2c = 0;
+ if (local_48 == 0) {
+ local_48 = 0;
+ }
+ local_38 = 0;
+ if (iVar3 <= (int) (u32) local_3b) {
+ local_48 = iVar3 - 1;
+ }
+ local_34 = 0;
+ if (local_50 == 0) {
+ local_50 = 0;
+ }
+ if (iVar4 <= (int) uVar6) {
+ uVar6 = iVar4 - 1;
+ }
+ local_30 = 0;
+ for (; uVar1 = local_50, (int) local_48 <= (int) (u32) local_3b; local_48 = local_48 + 1) {
+ for (; (int) uVar1 <= (int) uVar6; uVar1 = uVar1 + 1) {
+ // iVar3 = gMapManager->MapData_vfunc_78(0);
+ if ((((iVar3 != 0) && ((*(u32 *) (iVar3 + 4) & 4) != 0)) &&
+ (iVar4 = Vec3p_Distance((Vec3p *) (iVar3 + 0x18), param_2), iVar4 < *param_3)) &&
+ (iVar5 = func_ov000_0208b7d0(iVar3, param_2), iVar5 != 0))
+ {
+ *param_3 = iVar4;
+ iVar7 = iVar3;
+ }
+ }
+ }
+ return iVar7;
+}
+
+unk32 MapManager::func_ov00_02085594(Vec3p *param_2) {
+ int *piVar1;
+ int iVar2;
+ unk32 dVar3; // dword
+ unk32 uVar4;
+ bool bVar5;
+ Vec2b uStack_2c;
+ Vec2b local_28;
+ u32 uStack_24;
+ Vec3p VStack_20;
+
+ this->func_ov00_02083a1c(&local_28, this, param_2);
+ piVar1 = (int *) this->MapData_vfunc_78(&local_28);
+ bVar5 = true;
+ if (piVar1 != (int *) 0x0) {
+ param_2->x = piVar1[6];
+ param_2->y = piVar1[7];
+ param_2->z = piVar1[8];
+ // iVar2 = (**(code **) (*piVar1 + 0x1c))();
+ if (iVar2 < 0x43) {
+ if (0x41 < iVar2) {
+ return 2;
+ }
+ if (iVar2 < 2) {
+ if (iVar2 != 1) {
+ return 0;
+ }
+ } else if (iVar2 != 0x38) {
+ return 0;
+ }
+ } else if (iVar2 < 0x5a) {
+ if (iVar2 != 0x59) {
+ return 0;
+ }
+ bVar5 = piVar1[2] == 4;
+ } else {
+ if (iVar2 != 0x61) {
+ return 0;
+ }
+ if (piVar1[2] == 2) {
+ return 0;
+ }
+ }
+ }
+ iVar2 = this->func_ov00_020840a0(local_28.x, local_28.y);
+ if (iVar2 < 0x46) {
+ if (iVar2 < 0x2a) {
+ switch (iVar2) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ case 8:
+ case 9:
+ case 0x14:
+ case 0x16:
+ case 0x17:
+ case 0x19:
+ case 0x1d:
+ case 0x1e:
+ case 0x1f:
+ case 0x27:
+ case 0x28:
+ case 0x29: return 0;
+ }
+ } else if (iVar2 == 0x37) {
+ return 0;
+ }
+ } else if (iVar2 < 0x48) {
+ if (0x47 < iVar2) {
+ return 0;
+ }
+ if (iVar2 == 0x47) {
+ return 0;
+ }
+ } else if (iVar2 == 0x50) {
+ return 0;
+ }
+ iVar2 = this->mMap->vfunc_58(&local_28, 5);
+ if (iVar2 != 0) {
+ return 0;
+ }
+ uStack_2c.y = local_28.y;
+ uStack_2c.x = local_28.x;
+ this->func_ov00_02083c7c(&VStack_20, uStack_2c);
+ dVar3 = this->MapData_vfunc_70(&VStack_20);
+ if (dVar3 != 0xffff) {
+ func_ov000_02093a1c(&uStack_24, data_027e0f6c, dVar3);
+ if ((uStack_24 >> 5 & 3) != 1) {
+ return 0;
+ }
+ if (bVar5) {
+ uVar4 = 1;
+ } else {
+ uVar4 = 2;
+ }
+ return uVar4;
+ }
+ return 0;
+}
+
+void MapManager::func_ov00_0208583c(MapManager *param_1, Vec3p *param_2, unk32 param_3) {
+ void *piVar1;
+ Vec2b auStack_10;
+
+ param_1->func_ov00_02083a1c(&auStack_10, param_1, param_2);
+ piVar1 = (unk32 *) param_1->MapData_vfunc_78(&auStack_10);
+ if (piVar1 == NULL) {
+ return;
+ }
+ if (data_027e077c->mUnk_00 == 1) {
+ if (data_027e077c->mUnk_04 == 1) {
+ //(**(code **) (*piVar1 + 0x30))(piVar1, param_3);
+ return;
+ }
+ return;
+ }
+}
+
+unk32 MapManager::func_ov00_020858b0(MapManager *param_1, Vec3p *param_2, s32 param_3) {
+ int iVar1;
+ int iVar2;
+ int iVar3;
+ int iVar4;
+ int *piVar5;
+ int iVar6;
+ int iVar7;
+ unk32 local_38;
+ Vec2b local_28; // x = originally 'local_28' ; y = originally 'local_27'
+
+ if (param_3 == 1) {
+ func_ov000_02088000(*(unk32 *) (*(int *) data_027e0f64 + 4), 7);
+ } else {
+ func_ov000_02088000(*(unk32 *) (*(int *) data_027e0f64 + 4), 6);
+ }
+ iVar2 = param_1->GetMapWidth();
+ iVar3 = param_1->GetMapHeight();
+ local_38 = 0xffffffff;
+ param_1->func_ov00_02083a1c(&local_28, param_1, param_2);
+ iVar6 = gPlayerPos.y; // *(int *) (PTR_gPlayerPos_overlay_d_0__02085a30 + 4);
+ for (iVar7 = local_28.x - 1; iVar7 <= (int) (local_28.x + 1); iVar7 = iVar7 + 1) {
+ if ((-1 < iVar7) && (iVar1 = local_28.y - 1, iVar7 < iVar2)) {
+ for (; iVar1 <= (int) (local_28.y + 1); iVar1 = iVar1 + 1) {
+ if ((-1 < iVar1) && (iVar1 < iVar3)) {
+ iVar4 = param_1->MapData_vfunc_60(0);
+ iVar4 = iVar4 - iVar6;
+ if (iVar4 < 0) {
+ iVar4 = -iVar4;
+ }
+ if ((iVar4 < 0xce) && (piVar5 = (int *) param_1->MapData_vfunc_78(&local_28), piVar5 != (int *) 0x0)) {
+ // local_38 = (**(code **) (*piVar5 + 0x38))(piVar5, param_3);
+ }
+ }
+ }
+ }
+ }
+ return local_38;
+}
+
+s32 MapManager::func_ov00_02085a34(Vec3p *param_2, s32 param_3) {
+ int *piVar1;
+ int iVar2;
+ unk16 *puVar3;
+ u32 uVar4;
+ u32 uVar5;
+ u32 uVar6;
+ unk32 uStack_2c;
+ unk32 uStack_2b;
+ Vec2b auStack_2a[2];
+ Vec2b aVStack_28[2];
+ unk16 auStack_24[4];
+ unk32 auStack_1c[4];
+ unk32 uStack_18;
+ unk16 uStack_14;
+ unk32 uStack_12;
+
+ if (param_3 != 1) {
+ if (param_3 != 2 && param_3 != 3) {
+ return -1;
+ }
+ this->func_ov00_02083a1c(auStack_2a, this, param_2);
+ piVar1 = (int *) this->MapData_vfunc_78(auStack_2a);
+ if (piVar1 == (int *) 0x0) {
+ return -1;
+ }
+ // iVar2 = (**(code **) (*piVar1 + 0x1c))();
+ if (iVar2 == 0x42) {
+ // uStack_2b = *(undefined *) ((int) piVar1 + 0x15);
+ // uStack_2c = *(undefined *) (piVar1 + 5);
+ // this->mMap->func_ov00_02080d08(&uStack_2c);
+ }
+ // iVar2 = (**(code **) (*piVar1 + 0x3c))(piVar1, param_3);
+ return iVar2;
+ }
+ this->func_ov00_02083a1c(aVStack_28, this, param_2);
+ iVar2 = this->func_ov00_02084ebc(param_2);
+ if (iVar2 == 0) {
+ return -1;
+ }
+ piVar1 = (int *) this->MapData_vfunc_78(aVStack_28);
+ if (piVar1 != (int *) 0x0) {
+ // iVar2 = (**(code **) (*piVar1 + 0x1c))();
+ if (0x38 < iVar2) {
+ if (iVar2 < 0x5a) {
+ if (iVar2 == 0x59) {
+ LAB_overlay_d_0__02085afc:
+ // iVar2 = (**(code **) (*piVar1 + 0x3c))(piVar1, 1); // What is this?
+ return iVar2;
+ }
+ } else if (iVar2 == 0x61)
+ goto LAB_overlay_d_0__02085afc;
+ return -1;
+ }
+ if ((iVar2 < 0x38) && (iVar2 != 1)) {
+ return -1;
+ }
+ piVar1[1] = piVar1[1] & 0xfffffffe;
+ this->func_ov00_020828f8(piVar1);
+ }
+ this->mMap->func_ov00_02080b24(aVStack_28);
+ uStack_14 = 0xffff;
+ uStack_18 = 0;
+ uStack_12 = 1;
+ uVar6 = 0;
+ puVar3 = auStack_24;
+ uVar4 = 0;
+ do {
+ uVar5 = uVar4 + 1;
+ puVar3[uVar4] = 0;
+ uVar4 = uVar5;
+ } while (uVar5 < 4);
+ do {
+ *(unk32 *) (puVar3 + 4) = 0; // This is undefined, using unk32 as placeholder.
+ uVar6 = uVar6 + 1;
+ *(unk32 *) (puVar3 + 5) = 0; // Same here.
+ puVar3 = (unk16 *) ((int) puVar3 + 1);
+ } while (uVar6 < 2);
+ // iVar2 = this->MapData_vfunc_7c(); <- This needs to return some value (not void).
+ if (iVar2 == 0) {
+ return -1;
+ }
+ // iVar2 = MapData_vfunc_78(0); // Same here.
+ if ((iVar2 != 0) && (0 < *(s16 *) (iVar2 + 0xe))) {
+ return 1;
+ }
+ return 0;
+}
+
+unk8 MapManager::func_ov00_02085c60(Vec3p *param_2, unk32 *param_3, unk32 *param_4, u32 param_5) {
+ s64 lVar1;
+ s32 *puVar2;
+ unk32 dVar3; // dword
+ bool bVar4;
+ bool bVar5;
+ int iVar6;
+ u32 uVar7;
+ int iStack_10c;
+ int iStack_108;
+ int iStack_104;
+ int iStack_100;
+ Vec3p VStack_f0;
+ Vec3p VStack_e4;
+ Vec4p VStack_d8;
+ Vec3p VStack_c8;
+ Vec3p VStack_bc;
+ Vec3p VStack_b0;
+ Vec3p VStack_a4;
+ Vec3p VStack_98;
+ Vec3p aVStack_8c[3];
+ unk16 uStack_68;
+ unk16 uStack_66;
+ unk16 uStack_64;
+ unk16 uStack_62;
+ unk16 uStack_60;
+ unk32 uStack_3e;
+ unk32 uStack_3d;
+ unk32 uStack_3c;
+ unk32 uStack_3b;
+ unk32 uStack_34;
+ unk32 uStack_33;
+ unk32 uStack_32;
+ unk32 uStack_31;
+ unk32 uStack_30;
+ unk32 uStack_2f;
+ unk32 uStack_2c;
+ unk32 uStack_28;
+
+ if (param_5 == 0) {
+ return 0;
+ }
+ func_ov000_020792a0(data_027e0d3c, 0, *param_3, param_3[1]);
+ func_ov000_020792a0(data_027e0d3c, 0, *param_4, param_4[1]);
+ VStack_b0.x = VStack_98.x;
+ VStack_b0.y = VStack_98.y;
+ VStack_b0.z = VStack_98.z;
+ VStack_bc.x = VStack_a4.x;
+ VStack_bc.y = VStack_a4.y;
+ VStack_bc.z = VStack_a4.z;
+ VStack_c8.x = VStack_98.x;
+ VStack_c8.y = VStack_98.y;
+ VStack_c8.z = VStack_98.z;
+ Vec3p_Sub(&VStack_c8, &VStack_bc, &VStack_c8);
+ lVar1 = (u64) param_5 * 0xc000 + 0x800;
+ uVar7 = (u32) lVar1 >> 0xc | (int) ((u64) lVar1 >> 0x20) * 0x100000;
+ iVar6 = Vec3p_Length(&VStack_c8);
+ if ((int) uVar7 < iVar6) {
+ Vec3p_Normalize(&VStack_c8, &VStack_c8);
+ Vec3p_Scale(&VStack_c8, uVar7);
+ VStack_98.x = VStack_a4.x;
+ VStack_98.y = VStack_a4.y;
+ VStack_98.z = VStack_a4.z;
+ Vec3p_Add(&VStack_98, &VStack_c8, &VStack_98);
+ VStack_b0.y = VStack_98.y;
+ VStack_b0.x = VStack_98.x;
+ VStack_b0.z = VStack_98.z;
+ }
+ VStack_c8.x = VStack_98.x;
+ VStack_c8.y = VStack_98.y;
+ VStack_c8.z = VStack_98.z;
+ Vec3p_Sub(&VStack_c8, &VStack_a4, &VStack_c8);
+ uVar7 = param_5 * 0x800 + 0x800 >> 0xc |
+ ((((int) param_5 >> 0x1f) << 0xb | param_5 >> 0x15) + (u32) (0xfffff7ff < param_5 * 0x800)) * 0x100000;
+ iVar6 = Vec3p_Length(&VStack_c8);
+ if ((int) param_5 <= iVar6) {
+ Vec3p_Normalize(&VStack_c8, &VStack_c8);
+ Vec3p_Scale(&VStack_c8, uVar7);
+ VStack_b0.x = VStack_bc.x;
+ VStack_b0.y = VStack_bc.y;
+ VStack_b0.z = VStack_bc.z;
+ Vec3p_Add(&VStack_b0, &VStack_c8, &VStack_b0);
+ }
+ bVar5 = false;
+ VStack_d8.y = param_5 << 1;
+ VStack_d8.x = 0;
+ VStack_d8.z = 0;
+ VStack_d8.w = param_5;
+ do {
+ bVar4 = func_01ffbe78(param_2, &VStack_b0, &VStack_bc, &VStack_d8);
+ if (bVar4) {
+ VStack_e4.x = param_2->x;
+ VStack_e4.y = param_2->y;
+ VStack_e4.z = param_2->z;
+ VStack_f0.x = param_2[1].x;
+ VStack_f0.y = param_2[1].y;
+ VStack_f0.z = param_2[1].z;
+ Vec3p_Normalize(&VStack_f0, &VStack_f0);
+ Vec3p_Scale(&VStack_f0, param_5);
+ Vec3p_Add(&VStack_e4, &VStack_f0, &VStack_e4);
+ dVar3 = 0xffff;
+ param_2->x = VStack_e4.x;
+ param_2->y = VStack_e4.y;
+ param_2->z = VStack_e4.z;
+ uStack_68 = (u16) dVar3;
+ uStack_60 = 0;
+ uStack_3e = 0;
+ uStack_3d = 0;
+ uStack_3c = 0;
+ uStack_3b = 0;
+ uStack_34 = 0;
+ uStack_33 = 0;
+ uStack_32 = 0;
+ uStack_31 = 0;
+ uStack_30 = 0;
+ uStack_2f = 0;
+ uStack_2c = 0xffffffff;
+ uStack_28 = 0xffffffff;
+ uStack_66 = uStack_68;
+ uStack_64 = uStack_68;
+ uStack_62 = uStack_68;
+ bVar5 = func_01ffbe78(aVStack_8c, &VStack_e4, &VStack_e4, &VStack_d8);
+ if (bVar5) {
+ VStack_e4.x = aVStack_8c[0].x;
+ VStack_e4.y = aVStack_8c[0].y;
+ VStack_e4.z = aVStack_8c[0].z;
+ }
+ func_ov000_0207920c(data_027e0d3c, &VStack_e4, &iStack_104, 0);
+ param_2[8].x = iStack_104;
+ param_2[8].y = iStack_100;
+ return 1;
+ }
+ VStack_bc.x = VStack_b0.x;
+ VStack_bc.y = VStack_b0.y;
+ VStack_bc.z = VStack_b0.z;
+ // iVar6 = func_0202b2e8(&VStack_b0, &VStack_98, uVar7);
+ puVar2 = data_027e0d3c;
+ if (iVar6 != 0) {
+ bVar5 = true;
+ }
+ } while (!bVar5);
+ param_2->x = VStack_98.x;
+ param_2->y = VStack_98.y;
+ param_2->z = VStack_98.z;
+ func_ov000_0207920c(puVar2, &VStack_98, &iStack_10c, 0);
+ param_2[8].x = iStack_10c;
+ param_2[8].y = iStack_108;
+ return 0;
+}
+
+unk8 MapManager::func_ov00_02086044(Vec3p *param_2, Vec3p *param_3, unk32 param_4) {
+ unk32 uVar1;
+ unk32 uVar2;
+ int iVar3;
+ int iVar4;
+ int iVar5;
+ int iVar6;
+ int iVar7;
+ int iVar8;
+ int *piVar9;
+ Vec3p *pVVar10;
+ int iVar11;
+ Vec2b local_c6;
+ unk32 auStack_c4[4];
+ Vec3p iStack_c0;
+ Vec3p local_b0;
+ Vec3p local_a0;
+ Vec3p local_94;
+ Vec3p local_88;
+ Vec3p VStack_7c;
+ AABB AStack_70;
+ Vec3p VStack_58;
+ Vec3p local_4c;
+ AABB local_40;
+
+ local_40.min.x = param_3->x;
+ local_40.min.y = param_3->y;
+ local_40.min.z = param_3->z;
+ local_40.max.x = param_3->x;
+ local_40.max.y = param_3->y;
+ local_40.max.z = param_3->z;
+ local_88.x = param_2->x;
+ local_88.y = param_2->y;
+ local_88.z = param_2->z;
+ func_ov000_0208ed74(&local_40, &local_88);
+ // AABB_Grow(&local_40, param_4);
+ iVar3 = this->func_ov00_020839d4(local_40.min.x);
+ iVar4 = this->func_ov00_020839f8(local_40.min.z);
+ iVar5 = this->func_ov00_020839d4(local_40.max.x);
+ iVar6 = this->func_ov00_020839f8(local_40.max.z);
+ local_4c.x = param_3->x;
+ local_4c.y = param_3->y;
+ local_4c.z = param_3->z;
+ local_94.x = param_2->x;
+ local_94.y = param_2->y;
+ local_94.z = param_2->z;
+ pVVar10 = &local_a0;
+ local_a0.x = param_3->x;
+ local_a0.y = param_3->y;
+ local_a0.z = param_3->z;
+ Vec3p_Sub(&local_94, pVVar10, &VStack_58);
+ uVar1 = this->func_ov00_020839d4(param_3->x);
+ uVar2 = this->func_ov00_020839f8(param_3->z);
+ // iVar7 = this->func_ov00_02083e34(uVar1, uVar2, pVVar10);
+ do {
+ if (iVar5 < iVar3) {
+ return 0;
+ }
+ if (iVar4 <= iVar6) {
+ iVar11 = iVar4;
+ do {
+ // iVar8 = this->func_ov00_02083e34((char) iVar3, (char) iVar11, pVVar10);
+ if (iVar7 < iVar8) {
+ local_c6.x = (char) iVar3;
+ local_c6.y = (char) iVar11;
+ gMapManager->GetTileWorldBounds(&local_c6, &AStack_70);
+ Vec3p_Sub(param_2, param_3, &VStack_7c);
+ pVVar10 = (Vec3p *) auStack_c4;
+ iVar8 = func_ov000_0208e87c(&AStack_70, &local_b0, &VStack_7c);
+ if (iVar8 != 0) {
+ return 1;
+ }
+ }
+ piVar9 = (int *) this->MapData_vfunc_78(&local_c6);
+ if ((piVar9 != (int *) 0x0) /*&& (iVar8 = (**(code **) (*piVar9 + 0x58))(), iVar8 != 0)*/) {
+ iStack_c0.x = param_3->x;
+ iStack_c0.y = param_3->y;
+ pVVar10 = (Vec3p *) param_3->z;
+ iStack_c0.z = (int) pVVar10;
+ iVar8 = func_ov000_0208b804(piVar9, &iStack_c0, &VStack_58);
+ if (iVar8 != 0) {
+ return 1;
+ }
+ }
+ iVar11 = iVar11 + 1;
+ } while (iVar11 <= iVar6);
+ }
+ iVar3 = iVar3 + 1;
+ } while (true);
+}
-void MapManager::func_ov00_020820ec(unk32 *param_2) {}
-void MapManager::func_ov00_020820fc(s32 param_2, unk32 param_3, unk32 param_4) {}
-unk8 MapManager::func_ov00_0208210c(unk32 param_2, unk32 param_3) {}
-unk8 MapManager::func_ov00_0208230c(unk32 param_2) {}
-unk8 MapManager::func_ov00_02082348(unk32 param_2) {}
-void MapManager::func_ov00_020823a4(unk32 param_2) {}
-unk8 MapManager::func_ov00_020823b4() {}
-bool MapManager::func_ov00_020823c4(unk32 *param_2, s32 param_3) {}
-s32 MapManager::func_ov00_020823d4(s32 param_2) {}
-s32 MapManager::func_ov00_020823e4(s32 param_2) {}
-unk8 MapManager::MapData_vfunc_b4() {}
-unk8 MapManager::MapData_vfunc_9c() {}
-s32 MapManager::func_ov00_02082424() {}
-unk8 MapManager::func_ov00_02082454(unk32 param_2, unk32 param_3) {}
-unk8 MapManager::func_ov00_02082494(unk32 param_2) {}
-unk8 MapManager::func_ov00_020824cc(unk32 param_2) {}
-unk8 MapManager::func_ov00_02082504() {}
-unk8 *MapManager::func_ov00_02082538() {}
-void MapManager::func_ov00_02082594() {}
-void MapManager::func_ov00_020825ac() {}
-s32 MapManager::GetCourseFilePath(char *courseName, char *buf) {}
-unk8 MapManager::func_ov00_020825e4(unk32 param_2, unk32 param_3) {}
-unk8 MapManager::func_ov00_02082614(unk32 param_2, unk32 param_3) {}
-unk8 MapManager::MapData_vfunc_b0() {}
-void MapManager::func_ov00_02082650(s32 param_2, s32 param_3, unk32 param_4) {}
-void MapManager::func_ov00_02082660(s32 param_2, s32 param_3) {}
-void MapManager::func_ov00_02082670(unk32 param_2, s32 param_3) {}
-void MapManager::func_ov00_02082680(unk32 param_2, unk32 param_3) {}
-unk8 MapManager::func_ov00_020826a0(unk32 param_2, unk32 param_3, unk32 param_4) {}
-unk8 MapManager::CreateMap(unk32 mapType, unk32 param_3, unk32 param_4) {}
-unk8 MapManager::DestroyMap() {}
-unk8 MapManager::MapData_vfunc_44() {}
-unk8 MapManager::func_ov00_02082808() {}
-unk8 MapManager::MapData_vfunc_7c() {}
-unk8 MapManager::MapData_vfunc_84() {}
-bool MapManager::func_ov00_020828f8(s32 *param_2) {}
-unk8 MapManager::GetCourseData_Unk_b0() {}
-s32 MapManager::func_ov00_02082914(unk32 param_2) {}
-unk8 MapManager::func_ov00_02082acc() {}
-unk32 *MapManager::func_ov00_02082adc() {}
-unk8 MapManager::func_ov00_02082af4() {}
-bool MapManager::func_ov00_02082b3c(s32 param_2) {}
-unk8 MapManager::func_ov00_02082d08() {}
-unk8 MapManager::GetCourseData_Unk_1c() {}
-unk8 MapManager::GetCourseData_Unk_1d() {}
-unk8 MapManager::func_ov00_02082d40() {}
-u32 MapManager::func_ov00_02082d74(unk32 param_2) {}
-unk8 MapManager::func_ov00_02082d84() {}
-bool MapManager::func_ov00_02082e1c(s32 *param_2, s32 *param_3) {}
-unk8 MapManager::func_ov00_0208306c() {}
-void MapManager::func_ov00_0208315c(s32 *param_2, s32 *param_3) {}
-void MapManager::func_ov00_02083244(u32 param_2, s32 *param_3, s32 *param_4, s32 *param_5) {}
-void MapManager::func_ov00_02083298(u32 param_2, s32 *param_3, s32 *param_4, s32 *param_5) {}
-unk8 MapManager::GetCourseData_Unk_25c() {}
-bool MapManager::func_ov00_02083318(unk32 param_2) {}
-unk8 MapManager::func_ov00_02083328() {}
-unk8 MapManager::GetCourseData_Unk_86() {}
-unk8 MapManager::GetCourseData_Unk_87() {}
-unk8 MapManager::Get_MapData_Unk28() {}
-unk8 MapManager::Get_MapData_Unk2a() {}
-unk8 MapManager::func_ov00_02083374() {}
-unk8 MapManager::func_ov00_02083384() {}
-unk8 MapManager::GetCourseMinX() {}
-unk8 MapManager::GetCourseMinZ() {}
-unk8 MapManager::GetCourseMaxX() {}
-unk8 MapManager::GetCourseMaxZ() {}
-unk8 MapManager::func_ov00_020833c4() {}
-unk8 MapManager::func_ov00_020833d0() {}
-unk8 MapManager::func_ov00_020833dc() {}
-unk8 MapManager::func_ov00_020833e8() {}
-unk8 MapManager::Get_MapData_Unk_d0() {}
-unk8 MapManager::Get_MapData_Unk_d8() {}
-unk8 MapManager::GetMapData_Unk_dc(Vec3p *param_2) {}
-unk8 MapManager::GetMapData_Unk_e8(Vec3p *param_2) {}
-unk8 MapManager::GetMapData_Unk_d0(Vec3p *param_2) {}
-unk8 MapManager::func_ov00_0208346c(AABB *param_2) {}
-unk8 MapManager::func_ov00_020834bc(Vec3p *param_2, unk32 param_3, unk32 param_4) {}
-unk8 MapManager::func_ov00_02083524(Vec3p *param_2, unk32 param_3, unk32 param_4) {}
-void MapManager::func_ov00_02083560(unk32 param_1, MapManager *param_2, u32 param_3) {}
-unk8 MapManager::func_ov00_02083570(unk32 param_2, unk32 param_3) {}
-unk32 MapManager::func_ov00_02083588() {}
-unk32 MapManager::func_ov00_020835a4() {}
-unk32 MapManager::func_ov00_020835b4() {}
-unk8 MapManager::func_ov00_020835c4(unk32 param_2, unk32 param_3) {}
-bool MapManager::func_ov00_020835e4(s32 param_2, unk32 *param_3, unk32 *param_4) {}
-unk32 MapManager::func_ov00_020835f4(s32 param_2) {}
-void MapManager::func_ov00_02083604(s32 param_2) {}
-unk8 MapManager::func_ov00_02083614(s32 param_2) {}
-bool MapManager::GetEntrancePos(Vec3p *param_2, unk32 entranceId) {}
-bool MapManager::func_ov00_02083664(Vec3p *param_2, unk32 entranceId) {}
-s32 MapManager::func_ov00_020836bc(u32 param_2, unk32 *param_3) {}
-s32 MapManager::GetTriggerBoundingBoxes(u32 param_2, AABB *param_3, u32 param_4) {}
-unk8 MapManager::func_ov00_020836dc(unk32 param_2, unk32 param_3) {}
-bool MapManager::func_ov00_02083770(u32 param_2, unk32 param_3) {}
-bool MapManager::func_ov00_02083780(unk32 param_2) {}
-bool MapManager::func_ov00_02083790(unk32 param_2) {}
-unk8 MapManager::func_ov00_02083840(unk32 param_2) {}
-bool MapManager::func_ov00_020838c8(s32 param_2) {}
-bool MapManager::func_ov00_020838d8(s32 param_2) {}
-bool MapManager::func_ov00_020838e8(u32 param_2, unk32 *param_3) {}
-char MapManager::func_ov00_020838f8(unk32 *param_2) {}
-bool MapManager::func_ov00_02083908(char param_2, unk32 *param_3) {}
-void MapManager::func_ov00_02083918(s32 param_2, s32 *param_3) {}
-void MapManager::func_ov00_02083928(unk8 *param_2, s32 param_3) {}
-unk32 MapManager::func_ov00_02083938(s32 param_2) {}
-unk8 MapManager::Set_MapData_Unk_16(unk8 value, unk32 index) {}
-void MapManager::func_ov00_02083958(s32 param_2) {}
-void MapManager::func_ov00_02083968(u32 param_2, unk8 *param_3) {}
-bool MapManager::func_ov00_02083978(unk32 param_2, Vec3p *param_3) {}
-bool MapManager::func_ov00_020839b4(s32 param_2) {}
-bool MapManager::func_ov00_020839c4(s32 param_2) {}
-unk8 MapManager::func_ov00_020839d4() {}
-unk8 MapManager::func_ov00_020839f8() {}
-void MapManager::func_ov00_02083a1c(Vec2b *param_1, MapManager *param_2, Vec3p *param_3) {}
-unk8 MapManager::func_ov00_02083a54(unk32 param_1, MapManager *param_2, unk32 param_3, unk32 param_4, unk32 param_5) {}
-unk8 MapManager::func_ov00_02083b84() {}
-unk8 MapManager::func_ov00_02083bac() {}
-unk8 MapManager::func_ov00_02083bd4() {}
-unk8 MapManager::func_ov00_02083bfc() {}
-unk8 MapManager::func_ov00_02083c24(unk32 param_2) {}
-unk8 MapManager::func_ov00_02083c50(unk32 param_2) {}
-unk8 MapManager::func_ov00_02083c7c(Vec3p *param_2, Vec2b param_3) {}
-unk8 MapManager::func_ov00_02083ce8(unk8 param_1, unk8 param_2, unk8 param_3, unk8 param_4, unk32 param_5) {}
-unk8 MapManager::func_ov00_02083e34(unk8 param_2, unk8 param_3, unk32 param_4) {}
-unk8 MapManager::MapData_vfunc_60() {}
-unk8 MapManager::func_ov00_02083e70() {}
-unk8 MapManager::MapData_vfunc_68() {}
-s32 MapManager::func_ov00_02083ef8(Vec3p *param_2, Vec3p *param_3, unk32 param_4) {}
-void MapManager::func_ov00_02083f44(Vec3p *param_2) {}
-unk8 MapManager::MapData_vfunc_6c() {}
-unk8 MapManager::MapData_vfunc_70() {}
-unk8 MapManager::func_ov00_02083fb0(u32 *param_1, MapManager *param_2, Vec3p *param_3) {}
-void MapManager::GetTileWorldBounds(Vec2b *tile, AABB *tileBounds) {}
-unk8 MapManager::MapData_vfunc_54() {}
-unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) {}
-unk32 MapManager::MapData_vfunc_78(Vec2b *param1) {}
-unk8 MapManager::func_ov00_020840dc() {}
-unk8 MapManager::func_ov00_02084100(unk32 param_1, MapManager *param_2) {}
-unk8 MapManager::GetMapData_Unk_48() {}
-unk8 MapManager::GetMapData_Unk_4c() {}
-unk32 MapManager::func_ov00_0208412c() {}
-void MapManager::func_ov00_0208413c(unk32 param_2) {}
-unk8 MapManager::MapData_vfunc_58() {}
-unk8 MapManager::func_ov00_02084164() {}
-unk8 MapManager::GetMapData_Unk_0a() {}
-unk8 MapManager::GetMapData_Unk_0b() {}
-unk8 MapManager::MapData_vfunc_a4() {}
-unk8 MapManager::func_ov00_0208433c(Vec3p *param_2, unk32 param_3) {}
-unk8 MapManager::func_ov00_0208439c() {}
-void MapManager::func_ov00_020843ec(s32 *param_2) {}
-unk8 MapManager::GetMapData_Unk_38() {}
-unk8 MapManager::func_ov00_020846a4() {}
-unk8 MapManager::func_ov00_02084700() {}
-unk8 MapManager::func_ov00_02084740() {}
-unk8 MapManager::func_ov00_020847e0() {}
-unk8 MapManager::func_ov00_020847f0() {}
-bool MapManager::func_ov00_02084838() {}
-bool MapManager::func_ov00_020848b8() {}
-void MapManager::func_ov00_02084924(u32 param_2) {}
-unk8 MapManager::func_ov00_02084934() {}
-unk8 MapManager::GetMapData_Unk_06() {}
-unk8 MapManager::GetMapData_Unk_07() {}
-unk8 MapManager::func_ov00_0208499c() {}
-unk8 MapManager::func_ov00_020849c0() {}
-unk8 MapManager::func_ov00_020849dc() {}
-bool MapManager::func_ov00_020849f8() {}
-unk8 MapManager::func_ov00_02084a50() {}
-void MapManager::SpawnNPC(Vec3p *param_2, unk32 param_3, unk32 param_4) {}
-bool MapManager::func_ov00_02084ac4(u32 actorId) {}
-unk8 MapManager::SetNumKeys(unk32 keys) {}
-unk8 MapManager::GetNumKeys() {}
-unk8 MapManager::SetCourseData_Unk_25c(unk8 param_2) {}
-unk8 MapManager::GetCourseData_Unk_25d() {}
-unk8 MapManager::func_ov00_02084b38(unk32 param_2, unk32 param_3, unk32 param_4) {}
-bool MapManager::func_ov00_02084be0(unk32 param_2, unk32 param_3) {}
-void MapManager::func_ov00_02084c5c(unk32 param_2, unk32 param_3) {}
-bool MapManager::func_ov00_02084c6c(unk32 param_2) {}
-unk8 MapManager::func_ov00_02084c7c(unk32 param_2) {}
-unk8 MapManager::func_ov00_02084c94(unk32 param_2) {}
-unk8 MapManager::func_ov00_02084cb0(unk32 param_2) {}
-unk8 MapManager::func_ov00_02084cc8(unk32 param_2) {}
-unk8 MapManager::func_ov00_02084ce4(unk32 param_2) {}
-unk8 MapManager::func_ov00_02084cfc(unk32 param_2) {}
-unk8 MapManager::GetMapData_Unk_09() {}
-unk8 MapManager::func_ov00_02084d24(unk8 param_2, unk8 param_3, unk32 param_4) {}
-s32 MapManager::func_ov00_02084d4c(unk32 param_2, unk32 param_3, Vec3p *param_4) {}
-unk8 MapManager::func_ov00_02084ebc(unk32 param_2) {}
-s32 MapManager::func_ov00_02085108(Vec3p *param_2) {}
-unk8 MapManager::func_ov00_0208527c() {}
-unk8 MapManager::func_ov00_020853fc() {}
-unk8 MapManager::func_ov00_02085594(Vec3p *param_1) {}
-void MapManager::func_ov00_0208583c(unk32 param_1, Vec3p *param_2, unk32 param_3) {}
-unk8 MapManager::func_ov00_020858b0(MapManager *param_1, Vec3p *param_2, s32 param_3) {}
-s32 MapManager::func_ov00_02085a34(unk32 param_2, unk32 param_3) {}
-unk8 MapManager::func_ov00_02085c60(unk32 param_2, unk32 param_3, unk32 param_4, unk32 param_5) {}
-unk8 MapManager::func_ov00_02086044(unk32 param_2, unk32 param_3, unk32 param_4) {}
bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4, s32 param_5, u16 param_6, Vec3p *param_7,
- Vec3p *param_8) {}
+ Vec3p *param_8) {
+ bool bVar1;
+ s32 iVar2;
+ s32 iVar3;
+ Vec3p local_d0;
+ s32 local_c8;
+ Vec3p local_c4;
+ Vec3p local_b8;
+ Vec3p local_ac;
+ s32 local_a4;
+ Vec3p local_a0;
+ s32 local_98;
+ s32 local_94;
+ s32 local_90;
+ s32 local_8c;
+ Vec3p local_88;
+ Vec3p local_7c;
+ Vec3p local_70;
+ s32 local_64;
+ s32 local_60;
+ s32 local_5c;
+ s32 local_58;
+ s32 local_54;
+ Vec3p local_50;
+ Vec3p local_44;
+ Vec3p local_38;
+ Vec3p local_2c;
+ s32 local_20;
+
+ // iVar2 = (**(code **) (*param_2 + 8))(); // What pointer address is contained in param_2?
+ if (iVar2 == 0) {
+ // (**(code **) (*param_2 + 0x24))(param_2, &local_2c);
+ local_38.x = local_2c.x;
+ local_38.y = local_2c.y;
+ local_38.z = local_2c.z;
+ iVar2 = Vec3p_Distance(param_3, &local_38);
+ Vec3p_Sub(param_3, &local_38, &local_38);
+ Vec3p_Normalize(&local_38, &local_2c);
+ if (!bVar1) {
+ local_38.x = 0;
+ local_38.y = 0;
+ local_38.z = 0x1000;
+ }
+ Vec3p_Scale(&local_38, (local_20 + param_5) - iVar2);
+ Vec3p_Add(param_3, &local_38, param_7);
+ local_50.x = local_2c.x;
+ local_50.y = local_2c.y;
+ local_50.z = local_2c.z;
+ Vec3p_Sub(param_4, &local_50, &local_44);
+ // Vec3p_Normalize(&local_44);
+ param_8->x = local_44.x;
+ param_8->y = local_44.y;
+ param_8->z = local_44.z;
+ return false;
+ }
+ if (iVar2 == 1) {
+ local_58 = 0;
+ local_64 = 0;
+ local_60 = 0;
+ local_5c = 0;
+ // (**(code **) (*param_2 + 0x28))(param_2, &local_64);
+ local_70.y = param_3->y;
+ local_70.x = local_64;
+ local_70.z = local_5c;
+ if ((((*(char *) ((int) param_2 + 5) != '\0') && ((param_6 & 0x80) != 0)) &&
+ (iVar2 = Vec3p_Distance(&local_70, param_3), iVar2 <= local_58)) &&
+ ((local_60 + local_54 <= param_4->y && (iVar2 = param_5 + local_60 + local_54, param_3->y <= iVar2))))
+ {
+ param_7->y = iVar2;
+ param_8->x = 0;
+ param_8->y = 0x1000;
+ param_8->z = 0;
+ return true;
+ }
+ iVar2 = Vec3p_Distance(param_3, &local_70);
+ iVar3 = local_58 + param_5;
+ Vec3p_Sub(param_3, &local_70, &local_70);
+ // bVar1 = Vec3p_Normalize(&local_70);
+ if (!bVar1) {
+ local_70.x = 0;
+ local_70.y = 0;
+ local_70.z = 0x1000;
+ }
+ Vec3p_Scale(&local_70, iVar3 - iVar2);
+ Vec3p_Add(param_3, &local_70, param_7);
+ local_88.x = local_64;
+ local_88.z = local_5c;
+ local_88.y = param_4->y;
+ Vec3p_Sub(param_4, &local_88, &local_7c);
+ // Vec3p_Normalize(&local_7c);
+ param_8->x = local_7c.x;
+ param_8->y = local_7c.y;
+ param_8->z = local_7c.z;
+ return false;
+ }
+ if (iVar2 != 2) {
+ return false;
+ }
+ // (**(code **) (*param_2 + 0x2c))(param_2, local_a0);
+ func_ov000_0208e6b0(&local_a0, &local_ac);
+ local_b8.y = param_3->y;
+ local_b8.x = local_ac.x; // previously = local_ac[0] (of type s32)
+ local_b8.z = local_a4;
+ Vec3p_Sub(param_3, &local_b8, &local_b8);
+ local_c4.x = local_b8.x;
+ local_c4.y = local_b8.y;
+ local_c4.z = local_b8.z;
+ // bVar1 = Vec3p_Normalize(&local_c4);
+ if (!bVar1) {
+ local_c4.x = 0;
+ local_c4.y = 0;
+ local_c4.z = 0x1000;
+ }
+ if (((*(char *) ((int) param_2 + 5) != '\0') && ((param_6 & 0x80) != 0)) &&
+ (((param_3->x < local_94 && (((local_a0.x <= param_3->x && (param_3->z < local_8c)) && (local_98 <= param_3->z)))) ||
+ (local_90 + param_5 <= param_4->y))))
+ {
+ param_7->y = local_90 + param_5;
+ param_8->x = 0;
+ param_8->y = 0x1000;
+ param_8->z = 0;
+ return true;
+ }
+ func_ov000_0208e6b0(&local_a0, &local_d0);
+ iVar2 = param_3->z;
+ if (((iVar2 < local_8c) && (local_98 <= iVar2)) && ((param_3->x < local_94 && (local_a0.x <= param_3->x)))) {
+ iVar2 = func_ov000_0208e6f0(&local_a0);
+ iVar3 = func_ov000_0208e704(&local_a0);
+ if (iVar2 == iVar3) {
+ local_c8 = local_c8 - param_3->z;
+ if (local_c8 < 0) {
+ local_c8 = -local_c8;
+ }
+ local_d0.x = local_d0.x - param_3->x;
+ if (local_d0.x < 0) {
+ local_d0.x = -local_d0.x;
+ }
+ bVar1 = local_c8 < local_d0.x;
+ } else {
+ iVar2 = func_ov000_0208e6f0(&local_a0);
+ iVar3 = func_ov000_0208e704(&local_a0);
+ if (iVar2 < iVar3) {
+ bVar1 = true;
+ } else {
+ bVar1 = false;
+ }
+ }
+ if (bVar1) {
+ if (local_c4.x < 0) {
+ iVar2 = local_b8.x;
+ if (local_b8.x < 0) {
+ iVar2 = -local_b8.x;
+ }
+ iVar3 = func_ov000_0208e6f0(&local_a0);
+ param_7->x = param_7->x - ((param_5 + (iVar3 >> 1)) - iVar2);
+ param_8->x = -0x1000;
+ param_8->y = 0;
+ param_8->z = 0;
+ } else {
+ iVar2 = local_b8.x;
+ if (local_b8.x < 0) {
+ iVar2 = -local_b8.x;
+ }
+ iVar3 = func_ov000_0208e6f0(&local_a0);
+ param_7->x = param_7->x + ((param_5 + (iVar3 >> 1)) - iVar2);
+ param_8->x = 0x1000;
+ param_8->y = 0;
+ param_8->z = 0;
+ }
+ } else if (local_c4.z < 0) {
+ iVar2 = local_b8.z;
+ if (local_b8.z < 0) {
+ iVar2 = -local_b8.z;
+ }
+ iVar3 = func_ov000_0208e704(&local_a0);
+ param_7->z = param_7->z - ((param_5 + (iVar3 >> 1)) - iVar2);
+ param_8->x = 0;
+ param_8->y = 0;
+ param_8->z = -0x1000;
+ } else {
+ iVar2 = local_b8.z;
+ if (local_b8.z < 0) {
+ iVar2 = -local_b8.z;
+ }
+ iVar3 = func_ov000_0208e704(&local_a0);
+ param_7->z = param_7->z + ((param_5 + (iVar3 >> 1)) - iVar2);
+ param_8->x = 0;
+ param_8->y = 0;
+ param_8->z = 0x1000;
+ }
+ } else {
+ iVar3 = param_3->x;
+ if ((iVar3 < local_94) && (local_a0.x <= iVar3)) {
+ if (local_c4.z < 0) {
+ iVar2 = local_b8.z;
+ if (local_b8.z < 0) {
+ iVar2 = -local_b8.z;
+ }
+ iVar3 = func_ov000_0208e704(&local_a0);
+ param_7->z = param_7->z - ((param_5 + (iVar3 >> 1)) - iVar2);
+ param_8->x = 0;
+ param_8->y = 0;
+ param_8->z = -0x1000;
+ } else {
+ iVar2 = local_b8.z;
+ if (local_b8.z < 0) {
+ iVar2 = -local_b8.z;
+ }
+ iVar3 = func_ov000_0208e704(&local_a0);
+ param_7->z = param_7->z + ((param_5 + (iVar3 >> 1)) - iVar2);
+ param_8->x = 0;
+ param_8->y = 0;
+ param_8->z = 0x1000;
+ }
+ } else if ((iVar2 < local_8c) && (local_98 <= iVar2)) {
+ if (local_c4.x < 0) {
+ iVar2 = local_b8.x;
+ if (local_b8.x < 0) {
+ iVar2 = -local_b8.x;
+ }
+ iVar3 = func_ov000_0208e6f0(&local_a0);
+ param_7->x = param_7->x - ((param_5 + (iVar3 >> 1)) - iVar2);
+ param_8->x = -0x1000;
+ param_8->y = 0;
+ param_8->z = 0;
+ } else {
+ iVar2 = local_b8.x;
+ if (local_b8.x < 0) {
+ iVar2 = -local_b8.x;
+ }
+ iVar3 = func_ov000_0208e6f0(&local_a0);
+ param_7->x = param_7->x + ((param_5 + (iVar3 >> 1)) - iVar2);
+ param_8->x = 0x1000;
+ param_8->y = 0;
+ param_8->z = 0;
+ }
+ } else {
+ local_c8 = local_c8 - iVar2;
+ if (local_c8 < 0) {
+ local_c8 = -local_c8;
+ }
+ local_d0.x = local_d0.x - iVar3;
+ if (local_d0.x < 0) {
+ local_d0.x = -local_d0.x; // local_d0.x previously local_d0[0]
+ }
+ if (local_c8 < local_d0.x) {
+ if (local_c4.x < 0) {
+ iVar2 = local_b8.x;
+ if (local_b8.x < 0) {
+ iVar2 = -local_b8.x;
+ }
+ iVar3 = func_ov000_0208e6f0(&local_a0);
+ param_7->x = param_7->x - ((param_5 + (iVar3 >> 1)) - iVar2);
+ param_8->x = -0x1000;
+ param_8->y = 0;
+ param_8->z = 0;
+ } else {
+ iVar2 = local_b8.x;
+ if (local_b8.x < 0) {
+ iVar2 = -local_b8.x;
+ }
+ iVar3 = func_ov000_0208e6f0(&local_a0);
+ param_7->x = param_7->x + ((param_5 + (iVar3 >> 1)) - iVar2);
+ param_8->x = 0x1000;
+ param_8->y = 0;
+ param_8->z = 0;
+ }
+ } else if (local_c4.z < 0) {
+ iVar2 = local_b8.z;
+ if (local_b8.z < 0) {
+ iVar2 = -local_b8.z;
+ }
+ iVar3 = func_ov000_0208e704(&local_a0);
+ param_7->z = param_7->z - ((param_5 + (iVar3 >> 1)) - iVar2);
+ param_8->x = 0;
+ param_8->y = 0;
+ param_8->z = -0x1000;
+ } else {
+ iVar2 = local_b8.z;
+ if (local_b8.z < 0) {
+ iVar2 = -local_b8.z;
+ }
+ iVar3 = func_ov000_0208e704(&local_a0);
+ param_7->z = param_7->z + ((param_5 + (iVar3 >> 1)) - iVar2);
+ param_8->x = 0;
+ param_8->y = 0;
+ param_8->z = 0x1000;
+ }
+ }
+ }
+ return false;
+}
+
bool MapManager::func_ov00_02086a84(s32 *param_2, Vec3p *param_3, Vec3p *param_4, s32 param_5, s32 param_6, unk32 param_7,
- Vec3p *param_8, Vec3p *param_9) {}
+ Vec3p *param_8, Vec3p *param_9) {
+ bool bVar1;
+ int iVar2;
+ Vec3p VStack_a0;
+ unk32 auStack_94[24];
+ Vec3p local_7c;
+ int local_70[5];
+ Vec3p local_5c;
+ Vec3p local_50;
+ Vec3p local_44;
+ Vec3p local_38;
+ int local_2c;
+ Vec3p VStack_28;
+
+ Vec3p_Sub(param_3, param_4, &VStack_28);
+ // iVar2 = (**(code **) (*param_2 + 8))();
+ if (iVar2 == 0) {
+ //(**(code **) (*param_2 + 0x24))(param_2, &local_38);
+ if (param_6 == 0) {
+ local_44.x = local_38.x;
+ local_44.y = local_38.y;
+ local_44.z = local_38.z;
+ iVar2 = Vec3p_Distance(param_3, &local_44);
+ Vec3p_Sub(param_3, &local_38, &local_44);
+ // bVar1 = Vec3p_Normalize(&local_44); // This function needs to be declared and defined separately to the other
+ // Vec3p_Normalize with the return type as bool.
+ if (!bVar1) {
+ local_44.x = 0;
+ local_44.y = 0;
+ local_44.z = 0x1000;
+ }
+ Vec3p_Scale(&local_44, (local_2c + param_5) - iVar2);
+ Vec3p_Add(param_3, &local_44, param_8);
+ } else {
+ Vec3p_Scale(&VStack_28, param_6);
+ Vec3p_Add(param_4, &VStack_28, param_8);
+ }
+ local_5c.x = local_38.x;
+ local_5c.y = local_38.y;
+ local_5c.z = local_38.z;
+ Vec3p_Sub(param_4, &local_5c, &local_50);
+ // Vec3p_Normalize(&local_50);
+ param_9->x = local_50.x;
+ param_9->y = local_50.y;
+ param_9->z = local_50.z;
+ return false;
+ }
+ if (iVar2 != 1) {
+ if (iVar2 != 2) {
+ return false;
+ }
+ //(**(code **) (*param_2 + 0x2c))(param_2, auStack_94);
+ // func_ov000_0208e6b0(auStack_94, &VStack_a0);
+ Vec3p_Scale(&VStack_28, param_6);
+ Vec3p_Add(param_4, &VStack_28, param_8);
+ Vec3p_Sub(param_4, &VStack_a0, param_9);
+ // Vec3p_Normalize(param_9);
+ return false;
+ }
+ local_70[3] = 0;
+ local_70[0] = 0;
+ local_70[1] = 0;
+ local_70[2] = 0;
+ // (**(code **) (*param_2 + 0x28))(param_2, local_70);
+ Vec3p_Scale(&VStack_28, param_6);
+ Vec3p_Add(param_4, &VStack_28, param_8);
+ local_7c.x = local_70[0];
+ local_7c.z = local_70[2];
+ local_7c.y = param_4->y;
+ Vec3p_Sub(param_4, &local_7c, param_9);
+ // Vec3p_Normalize(param_9);
+ return false;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-08-04 19:23:37 +0000