From 61f866af9347cd1411ba72b59ac3ce2250b2a5d2 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sat, 11 Jan 2025 18:31:37 +0100 Subject: Decompile MapManager::GetCourseMinX --- src/00_Core/Map/MapManager.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 69be3117..6ee1310b 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -62,7 +62,11 @@ unk8 MapManager::Get_MapData_Unk28() {} unk8 MapManager::Get_MapData_Unk2a() {} unk8 MapManager::func_ov00_02083374() {} unk8 MapManager::func_ov00_02083384() {} -unk8 MapManager::GetCourseMinX() {} + +ARM q20 MapManager::GetCourseMinX() { + return (this->mCourse->mBounds).min.x; +} + unk8 MapManager::GetCourseMinZ() {} unk8 MapManager::GetCourseMaxX() {} unk8 MapManager::GetCourseMaxZ() {} -- cgit v1.2.3 From 090b1ae50ee4c3c13f7b4bd0734d8be22491fe76 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sat, 11 Jan 2025 18:51:09 +0100 Subject: Decompile MapManager::GetCourseMinZ Decompile MapManager::GetCourseMaxX Decompile MapManager::GetCourseMaxZ --- src/00_Core/Map/MapManager.cpp | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 6ee1310b..161b7301 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -67,9 +67,18 @@ ARM q20 MapManager::GetCourseMinX() { return (this->mCourse->mBounds).min.x; } -unk8 MapManager::GetCourseMinZ() {} -unk8 MapManager::GetCourseMaxX() {} -unk8 MapManager::GetCourseMaxZ() {} +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; +} + unk8 MapManager::func_ov00_020833c4() {} unk8 MapManager::func_ov00_020833d0() {} unk8 MapManager::func_ov00_020833dc() {} -- cgit v1.2.3 From c09ea66d5c9c2555eb1d56650ec38a69a25a28a6 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sat, 11 Jan 2025 20:23:35 +0100 Subject: Decompile MapManager::GetMapMinX Decompile MapManager::GetMapMinZ Decompile MapManager::GetMapMaxX Decompile MapManager::GetMapMaxZ --- src/00_Core/Map/MapManager.cpp | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 161b7301..7dd4f73f 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -79,10 +79,22 @@ ARM q20 MapManager::GetCourseMaxZ() { return (this->mCourse->mBounds).max.z; } -unk8 MapManager::func_ov00_020833c4() {} -unk8 MapManager::func_ov00_020833d0() {} -unk8 MapManager::func_ov00_020833dc() {} -unk8 MapManager::func_ov00_020833e8() {} +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; +} + unk8 MapManager::Get_MapData_Unk_d0() {} unk8 MapManager::Get_MapData_Unk_d8() {} unk8 MapManager::GetMapData_Unk_dc(Vec3p *param_2) {} -- cgit v1.2.3 From ff9c4e6a6758d23767ac1d8c6148b6d44f7ef4e2 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sat, 11 Jan 2025 20:56:41 +0100 Subject: Decompile MapManager::GetMapMinBounds Decompile MapManager::GetMapMaxBounds Decompile MapManager::GetMapCenter --- src/00_Core/Map/MapManager.cpp | 37 ++++++++++++++++++++++++++++++++----- 1 file changed, 32 insertions(+), 5 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 7dd4f73f..3945e8c8 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -95,11 +95,38 @@ ARM q20 MapManager::GetMapMaxZ() { return (this->mMap->mBounds).max.z; } -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) {} +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; + return; +} + +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; + return; +} + +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; + return; +} + 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) {} -- cgit v1.2.3 From d11cc4a573b12d17206de6632178cd7e3b5ae857 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sat, 11 Jan 2025 22:08:00 +0100 Subject: Decompile MapManager::GetMapWidth Decompile MapManager::GetMapHeight Decompile MapManager::func_ov00_02083374 Decompile MapManager::func_ov00_02083384 Decompile MapManager::func_ov00_020834bc --- src/00_Core/Map/MapManager.cpp | 46 +++++++++++++++++++++++++++++++++--------- 1 file changed, 37 insertions(+), 9 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 3945e8c8..7e0e4f4b 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -58,10 +58,22 @@ 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() {} + +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; @@ -108,7 +120,6 @@ ARM void MapManager::GetMapMinBounds(Vec3p *param_2) { param_2->x = (mapBase->mBounds).min.x; param_2->y = (mapBase->mBounds).min.y; param_2->z = (mapBase->mBounds).min.z; - return; } ARM void MapManager::GetMapMaxBounds(Vec3p *param_2) { @@ -116,7 +127,6 @@ ARM void MapManager::GetMapMaxBounds(Vec3p *param_2) { param_2->x = (mapBase->mBounds).max.x; param_2->y = (mapBase->mBounds).max.y; param_2->z = (mapBase->mBounds).max.z; - return; } ARM void MapManager::GetMapCenter(Vec3p *param_2) { @@ -124,11 +134,29 @@ ARM void MapManager::GetMapCenter(Vec3p *param_2) { param_2->x = (mapBase->mCenter).x; param_2->y = (mapBase->mCenter).y; param_2->z = (mapBase->mCenter).z; - return; } -unk8 MapManager::func_ov00_0208346c(AABB *param_2) {} -unk8 MapManager::func_ov00_020834bc(Vec3p *param_2, unk32 param_3, unk32 param_4) {} +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); +} + 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) {} -- cgit v1.2.3 From 1d2124ce9d2465568ee6a51d91b22d1cd11e0e74 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sun, 12 Jan 2025 00:27:33 +0100 Subject: Decompile MapManager::GetCourseData_Unk_25c Decompile MapManager::func_ov00_02083328 Decompile MapManager::GetCourseMainGridSizeX Decompile MapManager::GetCourseMainGridSizeY Decompile MapManager::func_ov00_02083524 --- src/00_Core/Map/MapManager.cpp | 79 +++++++++++++++++++++++++++--------------- 1 file changed, 52 insertions(+), 27 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 7e0e4f4b..ed7bc6dc 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -42,7 +42,12 @@ 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() {} + +ARM u8 MapManager::UpdateMapGrid() { + Course *course = this->mCourse; + return course->mMapGrid[(u8) course->mCurrMapPos.x][(u8) course->mCurrMapPos.y]; +} + unk8 MapManager::GetCourseData_Unk_1c() {} unk8 MapManager::GetCourseData_Unk_1d() {} unk8 MapManager::func_ov00_02082d40() {} @@ -53,11 +58,25 @@ 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() {} + +ARM bool MapManager::GetCourseData_Unk_25c() { + return this->mCourse->mUnk_25c; +} + +ARM bool MapManager::func_ov00_02083318(unk32 param_2) {} + +ARM bool MapManager::func_ov00_02083328() { + u32 map = (u32) this->UpdateMapGrid(); + 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; @@ -76,64 +95,64 @@ ARM s32 MapManager::func_ov00_02083384() { } ARM q20 MapManager::GetCourseMinX() { - return (this->mCourse->mBounds).min.x; + return this->mCourse->mBounds.min.x; } ARM q20 MapManager::GetCourseMinZ() { - return (this->mCourse->mBounds).min.z; + return this->mCourse->mBounds.min.z; } ARM q20 MapManager::GetCourseMaxX() { - return (this->mCourse->mBounds).max.x; + return this->mCourse->mBounds.max.x; } ARM q20 MapManager::GetCourseMaxZ() { - return (this->mCourse->mBounds).max.z; + return this->mCourse->mBounds.max.z; } ARM q20 MapManager::GetMapMinX() { - return (this->mMap->mBounds).min.x; + return this->mMap->mBounds.min.x; } ARM q20 MapManager::GetMapMinZ() { - return (this->mMap->mBounds).min.z; + return this->mMap->mBounds.min.z; } ARM q20 MapManager::GetMapMaxX() { - return (this->mMap->mBounds).max.x; + return this->mMap->mBounds.max.x; } ARM q20 MapManager::GetMapMaxZ() { - return (this->mMap->mBounds).max.z; + return this->mMap->mBounds.max.z; } ARM q20 MapManager::GetMapCenterX() { - return (this->mMap->mCenter).x; + return this->mMap->mCenter.x; } ARM q20 MapManager::GetMapCenterZ() { - return (this->mMap->mCenter).z; + 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; + 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; + 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; + 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) { @@ -157,8 +176,14 @@ ARM void MapManager::func_ov00_020834bc(Vec3p *param_2, unk32 param_3, unk32 par param_2->z = param_2->z - (iVar2 >> 1); } -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) {} +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; +} + +void MapManager::func_ov00_02083560(Vec2b pos, 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() {} -- cgit v1.2.3 From ba1821d07b7c8420d9751ca7d7f8f2fb2bc72183 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sun, 12 Jan 2025 00:29:45 +0100 Subject: Build fix --- src/00_Core/Map/MapManager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index ed7bc6dc..879cba2d 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -183,7 +183,7 @@ ARM void MapManager::func_ov00_02083524(Vec3p *param_2, unk32 param_3, unk32 par param_2->z = mapCenter->z; } -void MapManager::func_ov00_02083560(Vec2b pos, MapManager *param_2, u32 param_3) {} +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() {} -- cgit v1.2.3 From e96f66ceb83ffaf329f6098a5b0f847d58c5e117 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sun, 12 Jan 2025 14:18:34 +0100 Subject: Decompile MapManager::func_ov00_02083570 Decompile MapManager::func_ov00_02083588 Decompile MapManager::func_ov00_020835a4 Decompile MapManager::func_ov00_020835b4 Decompile MapManager::func_ov00_020835c4 (50%) --- src/00_Core/Map/MapManager.cpp | 30 +++++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 879cba2d..35671c7d 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -43,7 +43,7 @@ unk32 *MapManager::func_ov00_02082adc() {} unk8 MapManager::func_ov00_02082af4() {} bool MapManager::func_ov00_02082b3c(s32 param_2) {} -ARM u8 MapManager::UpdateMapGrid() { +ARM u8 MapManager::func_ov00_02082d08() { Course *course = this->mCourse; return course->mMapGrid[(u8) course->mCurrMapPos.x][(u8) course->mCurrMapPos.y]; } @@ -66,7 +66,7 @@ ARM bool MapManager::GetCourseData_Unk_25c() { ARM bool MapManager::func_ov00_02083318(unk32 param_2) {} ARM bool MapManager::func_ov00_02083328() { - u32 map = (u32) this->UpdateMapGrid(); + u32 map = (u32) this->func_ov00_02082d08(); return this->mCourse->IsMapInMainGrid(map); } @@ -184,11 +184,27 @@ ARM void MapManager::func_ov00_02083524(Vec3p *param_2, unk32 param_3, unk32 par } 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) {} + +ARM u8 MapManager::func_ov00_02083570(unk32 param_2, unk32 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 s8 MapManager::func_ov00_020835c4(s32 param_2, unk32 param_3) { + return this->mCourse->func_ov00_0207d404(param_2, 0, 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) {} -- cgit v1.2.3 From acc72371ed17936435d9da11b32eef383b13f8b7 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sun, 12 Jan 2025 15:15:38 +0100 Subject: Decompile MapManager::func_ov00_020835e4 Decompile MapManager::func_ov00_020835f4 Decompile MapManager::func_ov00_02083604 Decompile MapManager::func_ov00_02083614 Decompile MapManager::GetEntrancePos (43%) Decompile MapManager::func_ov00_02083664 (68%) --- src/00_Core/Map/MapManager.cpp | 48 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 41 insertions(+), 7 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 35671c7d..81c13c35 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -201,16 +201,50 @@ ARM unk32 MapManager::func_ov00_020835b4() { return this->mCourse->Get_Unk_c8_04(); } -ARM s8 MapManager::func_ov00_020835c4(s32 param_2, unk32 param_3) { +ARM unk8 MapManager::func_ov00_020835c4(s32 param_2, unk32 param_3) { return this->mCourse->func_ov00_0207d404(param_2, 0, 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) {} +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(Vec3p *pos, unk32 entranceId) { + Vec3p *entrancePos = (Vec3p *) this->mMap->FindEntrance(entranceId); + int y = entrancePos->y; + int z = entrancePos->z; + pos->x = entrancePos->x; + pos->y = y; + pos->z = z; + //*&pos[1].x = *&entrancePos[1].x; + //*(&pos[1].x + 2) = *(&entrancePos[1].x + 2); + // pos[1].y = entrancePos[1].y; + return true; +} + +ARM bool MapManager::func_ov00_02083664(Vec3p *param_2, unk32 entranceId) { + Vec3p entrancePos; + if (this->GetEntrancePos(&entrancePos, entranceId)) { + param_2->x = entrancePos.x; + param_2->y = entrancePos.y; + param_2->z = entrancePos.z; + return true; + } + return false; +} + 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) {} -- cgit v1.2.3 From a4a9bb5dfdc9d1b3c4e024f631ced1d5d22097d1 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sun, 12 Jan 2025 19:50:41 +0100 Subject: Decompile MapManager::func_ov00_020836bc Decompile MapManager::GetTriggerBoundingBoxes Decompile MapManager::func_ov00_020836dc (60%) Decompile MapManager::IsTriggerTypeOverlapped Decompile MapManager::GetOverlappingTrigger Decompile MapManager::func_ov00_02083560 gPlayerPos type Vec3p* from Vec3p --- src/00_Core/Map/MapManager.cpp | 53 +++++++++++++++++++++++++++++++++++------- 1 file changed, 45 insertions(+), 8 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 81c13c35..656be1c8 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -1,4 +1,7 @@ #include "Map/MapManager.hpp" +#include "Actor/Actor.hpp" +#include "Actor/ActorManager.hpp" +#include "Player/PlayerBase.hpp" void MapManager::func_ov00_020820ec(unk32 *param_2) {} void MapManager::func_ov00_020820fc(s32 param_2, unk32 param_3, unk32 param_4) {} @@ -183,7 +186,9 @@ ARM void MapManager::func_ov00_02083524(Vec3p *param_2, unk32 param_3, unk32 par param_2->z = mapCenter->z; } -void MapManager::func_ov00_02083560(unk32 param_1, MapManager *param_2, u32 param_3) {} +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(unk32 param_2, unk32 param_3) { return this->mCourse->mMapGrid[param_2][param_3]; @@ -223,8 +228,8 @@ ARM unk8 MapManager::func_ov00_02083614(s32 param_2) { ARM bool MapManager::GetEntrancePos(Vec3p *pos, unk32 entranceId) { Vec3p *entrancePos = (Vec3p *) this->mMap->FindEntrance(entranceId); - int y = entrancePos->y; - int z = entrancePos->z; + s32 y = entrancePos->y; + s32 z = entrancePos->z; pos->x = entrancePos->x; pos->y = y; pos->z = z; @@ -245,11 +250,43 @@ ARM bool MapManager::func_ov00_02083664(Vec3p *param_2, unk32 entranceId) { return false; } -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) {} +ARM s32 MapManager::func_ov00_020836bc(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) { + bool state; + Actor *actor; + Vec3p playerPos; + + if (actorId < 2) { + playerPos.x = gPlayerPos->x; + playerPos.y = gPlayerPos->y; + playerPos.z = gPlayerPos->z; + } else { + actor = gActorManager->FindActorById(actorId); + if (actor == NULL) { + return false; + } + playerPos.x = *(s32 *) (actor + 0x48); + playerPos.y = *(s32 *) (actor + 0x4c); + playerPos.z = *(s32 *) (actor + 0x50); + } + 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); +} + bool MapManager::func_ov00_02083790(unk32 param_2) {} unk8 MapManager::func_ov00_02083840(unk32 param_2) {} bool MapManager::func_ov00_020838c8(s32 param_2) {} -- cgit v1.2.3 From 3cca73e1c1c0c0beba6f4864126220c478643ffc Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Mon, 13 Jan 2025 22:13:47 +0100 Subject: Decompile MapManager::IsMapInMainGrid Decompile MapManager::GetCourseDungeonProgress Decompile MapManager::func_ov00_020820fc Decompile MapManager::func_ov00_0208230c (93%) Decompile MapManager::func_ov00_020823a4 Decompile MapManager::func_ov00_020823b4 Decompile MapManager::func_ov00_020823c4 Decompile MapManager::func_ov00_020823d4 Decompile MapManager::func_ov00_020823e4 Decompile MapManager::MapData_vfunc_b4 Decompile MapManager::MapData_vfunc_9c Decompile MapManager::func_ov00_02082424 (41%) Decompile MapManager::func_ov00_02082454 (25%) Decompile MapManager::func_ov00_02082494 (28%) --- src/00_Core/Map/MapManager.cpp | 103 ++++++++++++++++++++++++++++++++++------- 1 file changed, 86 insertions(+), 17 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 656be1c8..efc01b3e 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -3,21 +3,88 @@ #include "Actor/ActorManager.hpp" #include "Player/PlayerBase.hpp" -void MapManager::func_ov00_020820ec(unk32 *param_2) {} -void MapManager::func_ov00_020820fc(s32 param_2, unk32 param_3, unk32 param_4) {} +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); +} + 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) {} + +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) { + // s32 var[4]; + // var[0] = 0x47; + // var[1] = 0; + // var[2] = 0; + // var[3] = 0xfffffffe; + // this->func_ov00_0208230c(var); + // func_ov00_02078bf0(var, param2) ??? +} + +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 = this->mMap->func_ov015_02129c14(); // Does not exist. + 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;// = this->mMap->func_ov015_02129c24(param_2, param_3); // Does not exist. + return state; + } + return false; +} + +ARM bool MapManager::func_ov00_02082494(s32 param_2) { + s32 var = this->mMap->vfunc_4c(); + if (var == 2) { + bool state;// = this->mMap->func_ov015_02129c34(param_2); // Does not exist. + return state; + } + return false; +} + unk8 MapManager::func_ov00_020824cc(unk32 param_2) {} unk8 MapManager::func_ov00_02082504() {} unk8 *MapManager::func_ov00_02082538() {} @@ -55,7 +122,7 @@ 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() {} +ARM void 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) {} @@ -66,7 +133,9 @@ ARM bool MapManager::GetCourseData_Unk_25c() { return this->mCourse->mUnk_25c; } -ARM bool MapManager::func_ov00_02083318(unk32 param_2) {} +ARM bool MapManager::IsMapInMainGrid(u32 map) { + return this->mCourse->IsMapInMainGrid(map); +} ARM bool MapManager::func_ov00_02083328() { u32 map = (u32) this->func_ov00_02082d08(); @@ -186,7 +255,7 @@ ARM void MapManager::func_ov00_02083524(Vec3p *param_2, unk32 param_3, unk32 par param_2->z = mapCenter->z; } -void MapManager::func_ov00_02083560(Vec2b *param_1, MapManager *param_2, u32 param_3) { +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); } -- cgit v1.2.3 From b7be672733b79c460d3f72bc13fd181f3652d8a8 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Tue, 14 Jan 2025 15:27:50 +0100 Subject: Decompile MapManager::func_ov00_020824cc (28%) Decompile MapManager::func_ov00_02082504 Decompile MapManager::func_ov00_02082538 (43%) Decompile MapManager::func_ov00_02082614 Decompile MapManager::MapData_vfunc_b0 Decompile MapManager::func_ov00_02082650 Decompile MapManager::func_ov00_02082660 Decompile MapManager::func_ov00_02082670 Decompile MapManager::func_ov00_02082680 Decompile MapManager:: Decompile MapManager::func_ov00_020826a0 (100% but needs verifying) Decompile MapManager::CreateMap (3%) Decompile MapManager::DestroyMap (8%) Decompile MapManager::MapData_vfunc_44 Decompile MapManager::MapData_vfunc_7c (25%) Decompile MapManager::MapData_vfunc_84 Decompile MapManager::func_ov00_020828f8 Decompile MapManager::GetNumMaps Decompile MapManager::func_ov00_02082914 (21%) Decompile MapManager::func_ov00_02082acc Decompile MapManager::func_ov00_02082af4 (55%) --- src/00_Core/Map/MapManager.cpp | 290 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 264 insertions(+), 26 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index efc01b3e..820191d9 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -85,32 +85,270 @@ ARM bool MapManager::func_ov00_02082494(s32 param_2) { return false; } -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() {} +ARM bool MapManager::func_ov00_020824cc(s32 param_2) { + s32 var = this->mMap->vfunc_4c(); + if (var == 2) { + bool state;// = this->mMap->func_ov015_02129c44(param_2); // Does not exist. + return state; + } + return false; +} + +ARM s32 MapManager::func_ov00_02082504() { + s32 var = this->mMap->vfunc_4c(); + if (var == 2) { + return (s32) this->mMap->mUnk_1ac; + } + return 0; +} + +ARM unk8 *MapManager::func_ov00_02082538() { + unk8 var0[12]; + s32 var1 = this->mMap->vfunc_4c(); + if (var1 != 2) { + return var0; + } + return this->mMap->mUnk_1a0; + // Reference to gPlayerPos in Ghidra, but not used. (See overlay_d_0::0x2082538) +} + +ARM void MapManager::func_ov00_02082594() { + // func_ov000_0208d620(DWORD_027e0f68) does not exist. + return; +} + +ARM void MapManager::func_ov00_020825ac() { + // func_ov000_0208d680(DWORD_027e0f68) does not exist. + return; +} + +ARM s32 MapManager::GetCourseFilePath(char *courseName, char *buf) { + // s32 var = sprintf(buf, "Map/%s/course.bin", courseName); // Should we manually define sprintf? + // return var; +} + +ARM void MapManager::func_ov00_020825e4(unk32 param_2, char *buf) { + // param2 unused. + // return value of GetCourseFilePath unused. + char *courseName; // = (char *) func_ov000_0209d71c(*(unk32 *) DWORD_027e0f7c) does not exist. + 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, unk32 param_4) { + this->mMap->vfunc_98(param_2, 7, param_3 /*, param_4*/); + // vfunc_98 takes either three params or four ??? This doesn't make sense + // objdiff says 100% +} + +ARM void MapManager::CreateMap(unk32 mapType, unk32 param_3, unk32 param_4) { + MapBase *mapBase; + + if (this->mMap == NULL) { + switch (mapType) { + case 0: + // mapBase = (MapBase *) SysObject::operator_new(0x1dc, (astruct_19 **)(DWORD_027e0ce0 + 4), 4); + // What is astruct_19 ** ? What is DWORD_027e0ce0 ? + if (mapBase != NULL) { + // mapBase = (MapBase *)func_ov018_0215b4a0(mapBase, param_3, param_4); // Does not exist. + } + this->mMap = mapBase; + return; + case 1: break; + case 2: + // mapBase = (MapBase *) SysObject::operator_new(0x1b0, (astruct_19 **)(DWORD_027e0ce0 + 4), 4); + if (mapBase != NULL) { + // mapBase = (MapBase *)func_ov015_02128dd8(mapBase, param_3, param_4); // Does not exist. + } + this->mMap = mapBase; + return; + case 3: break; + case 4: + // mapBase = (MapBase *) SysObject::operator_new(0x790, (astruct_19 **)(DWORD_027e0ce0 + 4), 4); + if (mapBase != NULL) { + // mapBase = (MapBase *)func_ov012_0212b358(mapBase, param_3, param_4); // Does not exist. + } + this->mMap = mapBase; + return; + } + // mapBase = (MapBase *) SysObject::operator_new(0x790, (astruct_19 **)(DWORD_027e0ce0 + 4), 4); + if (mapBase != NULL) { + // mapBase = (MapBase *)func_ov017_0215b4e8(mapBase, param_3, param_4); // Does not exist. + } + this->mMap = mapBase; + } + return; +} + +ARM void MapManager::DestroyMap() { + if (this->mMap == NULL) { + return; + } else { + // this->mMap->vfunc_04(); Doesn't exist. + } +} + +ARM void MapManager::MapData_vfunc_44() { + this->mMap->vfunc_44(); +} + +ARM void MapManager::func_ov00_02082808(s32 param_2, unk32 param_3, unk32 param_4) { + // How to define PTR_027e0d38 ? + // if (*(int*)(*(int*)PTR_027e0d38 + 0x14) == 1) { + // return; + // } + s32 var1; // = func_ov00_02084740() + s32 var2; + if (param_2 == 0) { + // var2 = thunk_FUN_0201f91c(DWORD_overlay_d_0_bss__020eec68); // What are these? + if (var1 == var2) { + return; + } + // func_ov00_020d70a4(DWORD_overlay_d_0_bss__020eec68, var1, 0, 0x7f, param_4); // And these? + } else { + // var2 = func_ov00_020a5e9c(*(s32 *) PTR_027e0d38 + 0xc); + if (var2 == 0) { + // func_ov015_021849a4(DWORD_overlay_d_15_bss__02190458); + } + // func_ov00_020a5e9c(DWORD_overlay_d_0_bss__020eec68, var1, 0, 0x7f, param_4); + } + // var1 = func_ov00_020a5e9c(*(s32 *) PTR_027e0d38 + 0xc); + if (var1 == 0) { + return; + } + // func_ov00_020d72b8(DWORD_overlay_d_0_bss__020eec68); +} + +ARM void MapManager::MapData_vfunc_7c() { + this->mMap->vfunc_7c(); +} + +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) { + int iVar1; + int iVar2; + int iVar3; + int iVar4; + int local_50; + int local_48; + Entrance local_44; + Entrance local_30; + + switch (param_2) { + case 0xfa: + // iVar1 = *(int *)(*(int *) PTR_027e0d38 + 0x28); // define PTR_027e0d38 + local_30.mPos.x = *(int *) (iVar1 + 0x5c); + local_30.mPos.y = *(int *) (iVar1 + 0x60); + local_30.mPos.z = *(int *) (iVar1 + 100); + local_30.mAngle = *(unk16 *) (iVar1 + 0x68); + local_30.mId = *(u8 *) (iVar1 + 0x6a); + local_30.mUnk_10 = *(int *) (iVar1 + 0x6c); + iVar1 = this->mMap->AddEntrance(&local_30); + return iVar1; + case 0xfb: break; + case 0xfc: break; + case 0xfd: break; + case 0xfe: break; + default: goto switchD_overlay_d_0; + } + local_44.mId = 0xff; + local_44.mUnk_10 = 0; + // iVar1 = *(int *) (*(int *) PTR_027e0d38 + 0x28); // define PTR_027e0d38 + local_50 = *(int *) (iVar1 + 0x38); + iVar2 = *(int *) (iVar1 + 0x3c); + local_48 = *(int *) (iVar1 + 0x40); + iVar1 = 0x2000; + iVar3 = 0x2000; + iVar4 = 0xfd; + if (this->mCourse->mType == 2) { + iVar1 = this->mMap->vfunc_88(); + iVar1 = iVar1 + 0xa000; + iVar3 = this->mMap->vfunc_8c(); + iVar3 = iVar3 + 0xa000; + iVar4 = 0xfe; + } + local_44.mAngle = 0; + switch (param_2) { + case 0xfb: + local_48 = this->GetMapMaxZ(); + local_48 = local_48 - iVar3; + local_44.mAngle = 0x8000; + break; + case 0xfc: + local_48 = this->GetMapMinZ(); + local_48 = iVar3 + local_48; + local_44.mAngle = 0; + break; + case 0xfd: + local_50 = this->GetMapMaxX(); + local_50 = local_50 - iVar1; + local_44.mAngle = 0xc000; + break; + case 0xfe: + local_50 = this->GetMapMinX(); + local_50 = iVar1 + local_50; + local_44.mAngle = 0x4000; + } + local_44.mId = (u8) param_2; + local_44.mPos.x = local_50; + local_44.mPos.z = local_48; + local_44.mPos.y = iVar2; + local_44.mUnk_10 = iVar4; + // this = (MapManager *) this->mMap->AddEntrance(&local_44); // huh ???? +switchD_overlay_d_0: + return (int) this; // what ??????? +} + +ARM void MapManager::func_ov00_02082acc() { + this->mCourse->func_ov00_0207d7bc(); +} + +ARM unk32 *MapManager::func_ov00_02082adc() { + // func_ov000_02096418(DWORD_027e0f70); // Does not exist. +} + +ARM void MapManager::func_ov00_02082af4() { + // func_ov00_02082af4(DWORD_027e0f68) // Does not exist. + this->mMap->vfunc_48(); + // this->func_ov00_02082808(0, ?, ?) // Only 1/3 params specified. + this->mUnk_0a = 1; + this->mUnk_0b = 0; +} + bool MapManager::func_ov00_02082b3c(s32 param_2) {} ARM u8 MapManager::func_ov00_02082d08() { -- cgit v1.2.3 From 036b2d982f9cadd46f21f8403b8cd0de64afb8e4 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Wed, 15 Jan 2025 15:05:37 +0100 Subject: Decompile MapManager::GetCurrentMapPosX Decompile MapManager::GetCurrentMapPosY Decompile MapManager::func_ov00_02082d40 (61%) Decompile MapManager::func_ov00_02082d84 (21%) Decompile MapManager::func_ov00_02082e1c (11%) Partially decompile other methods --- src/00_Core/Map/MapManager.cpp | 218 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 205 insertions(+), 13 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 820191d9..613f7cb9 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -294,7 +294,7 @@ ARM s32 MapManager::func_ov00_02082914(unk32 param_2) { iVar1 = 0x2000; iVar3 = 0x2000; iVar4 = 0xfd; - if (this->mCourse->mType == 2) { + if (this->mCourse->mType == CourseType_Sea) { iVar1 = this->mMap->vfunc_88(); iVar1 = iVar1 + 0xa000; iVar3 = this->mMap->vfunc_8c(); @@ -356,16 +356,208 @@ ARM u8 MapManager::func_ov00_02082d08() { return course->mMapGrid[(u8) course->mCurrMapPos.x][(u8) course->mCurrMapPos.y]; } -unk8 MapManager::GetCourseData_Unk_1c() {} -unk8 MapManager::GetCourseData_Unk_1d() {} -unk8 MapManager::func_ov00_02082d40() {} -u32 MapManager::func_ov00_02082d74(unk32 param_2) {} -ARM void 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) {} +ARM u8 MapManager::GetCurrentMapPosX() { + return this->mCourse->mCurrMapPos.x; +} + +ARM u8 MapManager::GetCurrentMapPosY() { + return this->mCourse->mCurrMapPos.y; +} + +ARM unk8 MapManager::func_ov00_02082d40() { + if (this->mCourse->mType == CourseType_Sea) { + return this->mCourse->mMapGrid[(u8) this->mCourse->mCurrMapPos.x][(u8) this->mCourse->mCurrMapPos.y]; + } + return this->mCourse->mUnk_0b1; +} + +ARM u32 MapManager::func_ov00_02082d74(unk32 param_2) { + // return func_ov00_02082d80(param_2); // Does not exist. +} + +ARM void MapManager::func_ov00_02082d84(unk8 *param_2, s32 *param_3, s32 *param_4) { + s32 mapWidth = this->GetMapWidth(); + u32 uVar3; // = CoDivide64By32(0x100000, mapWidth << 0xc); Not defined ? + s32 mapHeight = this->GetMapHeight(); + u32 uVar4; // = CoDivide64By32(0xc0000, mapHeight << 0xc); Not defined ? + s64 lVar1 = (s64) (s32) ((u32) *param_2 << 0xc); + *param_3 = (s32) (((u32) lVar1 >> 0xc | (s32) ((u64) lVar1 >> 0x20) * 0x100000) + ((s32) uVar4 >> 1) + 0x800) >> 0xc; + lVar1 = (s64) (s32) ((u32) param_2[1] << 0xc) * (s64) (s32) uVar4 + 0x800; + *param_4 = (s32) (((u32) lVar1 >> 0xc | (s32) ((u64) lVar1 >> 0x20) * 0x100000) + ((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 = UnkStruct_027e0d38::FUN_overlay_d_0__02078b40(*(UnkStruct_027e0d38 **) PTR_PTR_overlay_d_0__02083068); + 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; + unk8 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; + s32 iVar3; + s32 *piVar4; + s32 local_2c; // This has to be a Vec3p, but uncertain as of now. + unk32 local_28; // Unused. + unk32 local_24; // Unused. + Vec3p local_20; + + piVar4 = (s32 *) this->mCourse->mUnk_008; + piVar2 = param_2; + if (piVar4 != (s32 *) 0xfffffffd) { + piVar2 = (s32 *) 0xfffffffe; + } + if (piVar4 == (s32 *) 0xfffffffd || piVar4 == piVar2) { + // iVar3 = *(s32 *) (*(s32 *) PTR_PTR_overlay_d_0__02083240 + 0x28); + local_2c = *(s32 *) (iVar3 + 0x5c); + local_28 = *(unk32 *) (iVar3 + 0x60); + local_24 = *(unk32 *) (iVar3 + 100); + /*this->func_ov00_02083298((u32) * (u8 *) (*(s32 *) (*(s32 *) PTR_PTR_overlay_d_0__02083240 + 0x28) + 0x56), + &local_2c, param_2, param_3);*/ + return; + } + if (piVar4 != (s32 *) 0xffffffff) { + *param_2 = this->mCourse->mUnk_0bc; + *param_3 = this->mCourse->mUnk_0c0; + return; + } + local_20.x = *(s32 *) gPlayerPos->x; + local_20.y = *(s32 *) gPlayerPos->y; + local_20.z = *(s32 *) gPlayerPos->z; + uVar1 = this->func_ov00_02082d08(); + this->func_ov00_02083298(uVar1, &local_20, param_2, param_3); +} + +ARM void MapManager::func_ov00_02083244(u32 param_2, s32 *param_3, s32 *param_4, s32 *param_5) { + unk8 *puVar1; + + // puVar1 = PTR_MapManager_Unk2_overlay_d_0__020e24e8.field1_0x4_overlay_d_0__02083294; // What is this? mMap? + if (3 < param_2) { // Objdiff wants (4 < param_2), why is that? + param_2 = 0; + } + /* *param_4 = + (*param_3 - *(s32 *) (PTR_MapManager_Unk2_overlay_d_0__020e24e8_overlay_d_0__02083290 + param_2 * 8)) + 0x800 >> 0xc;*/ + *param_5 = (param_3[2] - *(s32 *) (puVar1 + param_2 * 8)) + 0x800 >> 0xc; +} + +ARM void MapManager::func_ov00_02083298(u32 param_2, Vec3p *param_3, s32 *param_4, s32 *param_5) { + if (3 < param_2) { // Objdiff wants (4 < param_2), why is that? + param_2 = 0; + } + /* *param_4 = + *(s32 *) (PTR_MapManager_Unk1_overlay_d_0__020e24c8_overlay_d_0__02083300 + param_2 * 8) + + ((*param_3 - *(s32 *) (PTR_MapManager_Unk2_overlay_d_0__020e24e8_overlay_d_0__020832fc + param_2 * 8) >> 1) + 0x800 >> + 0xc); + *param_5 = + *(s32 *) (PTR_MapManager_Unk1_overlay_d_0__020e24c8.field1_0x4_overlay_d_0__02083308 + param_2 * 8) + + ((param_3[2] - *(s32 *) (PTR_MapManager_Unk2_overlay_d_0__020e24e8.field1_0x4_overlay_d_0__02083304 + param_2 * 8) >> + 1) + + 0x800 >> + 0xc); */ + + // PTR_MapManager_Unk1_overlay_d_0__020e24c8_overlay_d_0__02083300 + // PTR_MapManager_Unk2_overlay_d_0__020e24e8_overlay_d_0__020832fc + // PTR_MapManager_Unk1_overlay_d_0__020e24c8.field1_0x4_overlay_d_0__02083308 + // PTR_MapManager_Unk2_overlay_d_0__020e24e8.field1_0x4_overlay_d_0__02083304 + // + // What are these pointers and fields? How should they be defined? +} ARM bool MapManager::GetCourseData_Unk_25c() { return this->mCourse->mUnk_25c; @@ -612,8 +804,8 @@ 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(unk32 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) {} +void MapManager::func_ov00_02083a1c(unk8 *param_1, MapManager *param_2, Vec3p *param_3) {} +unk8 MapManager::func_ov00_02083a54(u8 *param_1, MapManager *param_2, s32 *param_3, u8 param_4, u8 param_5) {} unk8 MapManager::func_ov00_02083b84() {} unk8 MapManager::func_ov00_02083bac() {} unk8 MapManager::func_ov00_02083bd4() {} -- cgit v1.2.3 From a025951d6722598082b15700c13ae96bccb38201 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Wed, 15 Jan 2025 23:31:21 +0100 Subject: Decompile MapManager::func_ov00_02083790 (13%) Decompile MapManager::func_ov00_02083840 (20%) Decompile MapManager::AddTrigger Decompile MapManager::func_ov00_020838d8 Decompile MapManager::func_ov00_020838e8 Decompile MapManager::func_ov00_020838f8 Decompile MapManager::func_ov00_02083908 Decompile MapManager::func_ov00_02083918 Decompile MapManager::func_ov00_02083928 Decompile MapManager::SetCurrentViewpointId Decompile MapManager::func_ov00_02083958 Decompile MapManager::func_ov00_02083968 Decompile MapManager::func_ov00_02083978 Decompile MapManager::func_ov00_020839b4 Decompile MapManager::func_ov00_020839c4 Decompile MapManager::func_ov00_020839d4 Decompile MapManager::func_ov00_020839f8 Decompile MapManager::func_ov00_02083a1c (14%) Decompile MapManager::GetTileStartX Decompile MapManager::GetTileStartZ Decompile MapManager::GetTileEndX Decompile MapManager::GetTileEndZ Decompile MapManager::func_ov00_02083c24 Decompile MapManager::func_ov00_02083c50 --- src/00_Core/Map/MapManager.cpp | 272 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 242 insertions(+), 30 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 613f7cb9..07d22009 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -200,7 +200,6 @@ ARM void MapManager::CreateMap(unk32 mapType, unk32 param_3, unk32 param_4) { } this->mMap = mapBase; } - return; } ARM void MapManager::DestroyMap() { @@ -484,7 +483,7 @@ ARM void MapManager::func_ov00_0208306c(s32 *param_2, s32 *param_3) { 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_02083a1c((s32 *) auStack_2c, this, &local_1c); this->func_ov00_02082d84(auStack_2c, param_2, param_3); } @@ -551,6 +550,7 @@ ARM void MapManager::func_ov00_02083298(u32 param_2, Vec3p *param_3, s32 *param_ 0x800 >> 0xc); */ + // [!] BELOW IS NOT CODE: // PTR_MapManager_Unk1_overlay_d_0__020e24c8_overlay_d_0__02083300 // PTR_MapManager_Unk2_overlay_d_0__020e24e8_overlay_d_0__020832fc // PTR_MapManager_Unk1_overlay_d_0__020e24c8.field1_0x4_overlay_d_0__02083308 @@ -786,34 +786,246 @@ ARM bool MapManager::GetOverlappingTrigger(Vec3p *param_2) { return this->mMap->GetOverlappingTrigger(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(unk8 *param_1, MapManager *param_2, Vec3p *param_3) {} -unk8 MapManager::func_ov00_02083a54(u8 *param_1, MapManager *param_2, s32 *param_3, u8 param_4, u8 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, unk32 param_3) {} -unk8 MapManager::func_ov00_02083ce8(unk8 param_1, unk8 param_2, unk8 param_3, unk8 param_4, unk32 param_5) {} +ARM bool MapManager::func_ov00_02083790(s32 param_2) { + unk8 *puVar1; + unk8 *puVar2; + bool bVar3; + s32 iVar4; + s32 iStack_18; + s32 aiStack_14[2]; + + // puVar2 = PTR_PTR_overlay_d_0__02083834; + // puVar1 = PTR_DWORD_overlay_d_0__02083830; + if (param_2 != 0) { + // *(s32 *) (*(s32 *) (*(s32 *) PTR_DWORD_overlay_d_0__02083830 + 8) + 0x1b4) = param_2; + *(s32 *) (*(s32 *) (*(s32 *) puVar1 + 4) + 0x1b4) = param_2; + // iVar4 = UnkStruct_027e0d38::FUN_overlay_d_0__02078b40(*(UnkStruct_027e0d38 **) puVar2); + if ((iVar4 != 0) && (bVar3 = this->func_ov00_02082e1c(aiStack_14, &iStack_18), !bVar3)) { + // FUN_overlay_d_0__02079898(*(undefined4 *) PTR_DWORD_overlay_d_0__02083838, param_2, 0x10); + gActorManager->func_ov00_020c3ce8(param_2, true); + } + bVar3 = this->mMap->AnyTrigger_func_0c(param_2); + return bVar3; + } + return true; +} + +ARM bool MapManager::func_ov00_02083840(s32 param_2) { + unk8 *puVar1; + unk8 *puVar2; + bool bVar3; + s32 iVar4; + + // puVar2 = PTR_DWORD_overlay_d_0__020838c0; + // puVar1 = PTR_DWORD_overlay_d_0__020838bc; + if (param_2 != 0) { + // *(unk32 *) (*(int *) (*(int *) PTR_DWORD_overlay_d_0__020838bc + 8) + 0x1b4) = 0xffffffff; + // *(unk32 *) (*(int *) (*(int *) puVar1 + 4) + 0x1b4) = 0xffffffff; + // iVar4 = FUN_overlay_d_0__02078fe8(*(unk32 *) puVar2); + if (-1 < iVar4) { + // FUN_overlay_d_0__020798bc(*(unk32 *) PTR_DWORD_overlay_d_0__020838c0, 0x10); + gActorManager->func_ov00_020c3ce8(param_2, false); + } + bVar3 = this->mMap->TriggerOfType_vfunc_10(param_2); + return bVar3; + } + return true; +} + +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(s32 *param_1, MapManager *param_2, Vec3p *param_3) { + *param_1 = param_2->func_ov00_020839f8(param_3->z); + param_1[1] = param_2->func_ov00_020839d4(param_3->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, u32 param_3) { + Vec3p local_28; // Unused. So why, ghidra? Why? Tell me why. + param_2->x = this->func_ov00_02083c24(param_3 & 0xff); + param_2->z = this->func_ov00_02083c50(param_3 >> 8 & 0xff); + param_2->y = this->MapData_vfunc_68(); +} + +ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 param_3, s32 param_4, u32 param_5) { + bool bVar1; + s32 iVar2; + u32 uVar3; + Vec3p local_2c; + + uVar3 = param_3; + iVar2 = param_1->GetCourseData_Unk_25c(); + if (iVar2 == 0) { + iVar2 = param_1->mMap->GetTileStartX(param_3 & 0xff); + *param_2 = iVar2 + 0x800; + iVar2 = param_1->mMap->GetTileStartZ(param_3 >> 8 & 0xff); + param_2[2] = iVar2 + 0x800; + } else { + if (param_4 != -1) { + uVar3 = param_5; + } + if (param_4 != -1 && uVar3 != 0xffffffff) { + uVar3 = (u32) (u8) param_1->mCourse->mMapGrid[param_4][uVar3]; + } else { + uVar3 = param_1->func_ov00_02082d08(); + } + bVar1 = param_1->IsMapInMainGrid(uVar3); + if (bVar1) { + param_1->func_ov00_02083524(&local_2c, param_4, param_5); + iVar2 = param_1->mMap->GetTileStartX(param_3 & 0xff); + *param_2 = local_2c.x + iVar2 + 0x800; + iVar2 = param_1->mMap->GetTileStartZ(param_3 >> 8 & 0xff); + param_2[2] = local_2c.z + iVar2 + 0x800; + } else { + iVar2 = param_1->mMap->GetTileStartX(param_3 & 0xff); + *param_2 = iVar2 + 0x800; + iVar2 = param_1->mMap->GetTileStartZ(param_3 >> 8 & 0xff); + param_2[2] = iVar2 + 0x800; + } + } + iVar2 = param_1->MapData_vfunc_68(); + param_2[1] = iVar2; +} + unk8 MapManager::func_ov00_02083e34(unk8 param_2, unk8 param_3, unk32 param_4) {} unk8 MapManager::MapData_vfunc_60() {} unk8 MapManager::func_ov00_02083e70() {} -- cgit v1.2.3 From 0672d06a7f3b639666bbda545ab49452e0539278 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Thu, 16 Jan 2025 13:55:44 +0100 Subject: Decompile MapManager::MapData_vfunc_60 (33%) Decompile MapManager::MapData_vfunc_60 (50%) Decompile MapManager::func_ov00_02083e70 (21%) Decompile MapManager::MapData_vfunc_68 (50%) Decompile MapManager::func_ov00_02083f44 (20%) Decompile MapManager::MapData_vfunc_6c Decompile MapManager::MapData_vfunc_70 Decompile MapManager::func_ov00_02083fb0 (24%) Decompile MapManager::func_ov00_02084024 Decompile MapManager::MapData_vfunc_54 (50%) Decompile MapManager::MapData_vfunc_78 (50%) Decompile MapManager::func_ov00_02084100 Decompile MapManager::GetMapData_Unk_48 Decompile MapManager::GetMapData_Unk_4c Decompile MapManager::func_ov00_0208412c Decompile MapManager::func_ov00_0208413c Decompile MapManager::MapData_vfunc_58 (50%) Decompile MapManager::func_ov00_02084164 (1% lol) Decompile MapManager::GetMapData_Unk_0a Decompile MapManager::GetMapData_Unk_0b Decompile MapManager::MapData_vfunc_a4 (50%) Decompile MapManager::func_ov00_0208433c (38%) Decompile MapManager::func_ov00_0208439c (90%) Decompile MapManager::func_ov00_020843ec (7%) Decompile MapManager::GetMapData_Unk_38 Decompile MapManager::func_ov00_020846a4 (61%) Decompile MapManager::func_ov00_02084700 (82%) Decompile MapManager::func_ov00_020847e0 Decompile MapManager::func_ov00_020847f0 (11%) Decompile MapManager::func_ov00_02084838 (15%) Decompile MapManager::func_ov00_020848b8 (22%) Decompile MapManager::func_ov00_02084924 Decompile MapManager::func_ov00_02084934 (18%) Decompile MapManager::GetMapData_Unk_06 Decompile MapManager::GetMapData_Unk_07 --- src/00_Core/Map/MapManager.cpp | 610 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 571 insertions(+), 39 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 07d22009..5d738880 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -1026,45 +1026,577 @@ ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 p param_2[1] = iVar2; } -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::func_ov00_02084024(unk32 param_2, AABB *param_3) {} -unk8 MapManager::MapData_vfunc_54() {} -unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) {} -unk8 MapManager::MapData_vfunc_78() {} -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() {} +ARM void MapManager::func_ov00_02083e34(unk8 param_2, unk8 param_3, unk32 param_4) { + unk8 local_8; + unk8 local_7; // Unused. + unk16 uStack_6; + + uStack_6 = (unk16) ((u32) param_4 >> 0x10); + // _local_8 = CONCAT11(param_3, param_2); What is this? + this->mMap->vfunc_60(/*&local_8*/); // Doesn't take any params, so why? +} + +ARM unk32 MapManager::MapData_vfunc_60() { + return this->mMap->vfunc_60(); +} + +ARM bool MapManager::func_ov00_02083e70() { + int iVar1; + int iVar2; + + iVar1 = this->MapData_vfunc_54(); + if (iVar1 < 0x2c) { + if ((0x2a < iVar1) || (iVar1 == 0x1b)) { + return true; + } + } else if (((iVar1 < 0x50) && (0x4d < iVar1)) && (iVar1 == 0x4e || iVar1 == 0x4f)) { + return true; + } + iVar1 = this->MapData_vfunc_60(); + iVar2 = this->GetMapData_Unk_48(); + return iVar2 <= iVar1; +} + +ARM unk8 MapManager::MapData_vfunc_68() { + return this->mMap->vfunc_68(); +} + +ARM s32 MapManager::func_ov00_02083ef8(Vec3p *param_2, Vec3p *param_3) { + int iVar1; + Vec3p local_18; + + local_18.x = param_2->x; + local_18.z = param_2->z; + local_18.y = param_2->y; + if (param_2->y < param_3->y) { + local_18.y = param_3->y; + } + iVar1 = this->mMap->vfunc_68(/*&local_18*/); // takes no args. + return iVar1; +} + +ARM void MapManager::func_ov00_02083f44(Vec3p *param_2) { + Vec3p local_18; + + local_18.z = param_2->z; + local_18.x = param_2->x; + /*local_18.y = *(int *)( + PTR_PTR_s_anc_overlay_d_0__020e24a0_overlay_d_0__020e24a4_overlay_d_0__02083f7c + + 0x20);*/ + this->func_ov00_02083ef8(param_2, &local_18); +} + +unk8 MapManager::MapData_vfunc_6c(unk32 param_2, unk32 param_3, unk32 param_4) { + this->mMap->vfunc_6c(param_2, param_3, param_4); +} + +unk8 MapManager::MapData_vfunc_70(Vec3p *param_2) { + this->mMap->vfunc_70(param_2); +} + +unk8 MapManager::func_ov00_02083fb0(u32 *param_1, MapManager *param_2, Vec3p *param_3) { + s32 iVar1; + unk32 dVar2; + + iVar1 = param_2->mMap->vfunc_74(param_3); + if (iVar1 != 0) { + *param_1 = *(unk32 *) (iVar1 + 0xc); + return; + } + dVar2 = param_2->MapData_vfunc_70(param_3); + if (dVar2 != 0xffff) { + // FUN_overlay_d_0__02093a1c(param_1, *(unk32 *) PTR_DWORD_overlay_d_0__02084020); + return; + } + *param_1 = 0; +} + +void MapManager::func_ov00_02084024(Vec2b *param_2, AABB *param_3) { + int iVar1; + Vec3p local_20; + + this->mMap->GetTileBounds(param_2, param_3); + iVar1 = this->GetMapCenterZ(); + local_20.x = this->GetMapCenterX(); + local_20.y = 0; + local_20.z = iVar1; + Vec3p_Add(¶m_3->min, &local_20, ¶m_3->min); + Vec3p_Add(¶m_3->max, &local_20, ¶m_3->max); +} + +unk8 MapManager::MapData_vfunc_54() { + this->mMap->vfunc_54(); +} + +unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) { + unk8 local_8; + unk8 local_7; + unk16 uStack_6; + + uStack_6 = (unk16) ((u32) param_4 >> 0x10); + // _local_8 = CONCAT11(param_3, param_2); + this->MapData_vfunc_54(/*&local_8*/); // Doesn't take any params. + // No calls to functions according to objdiff, why??? +} + +unk8 MapManager::MapData_vfunc_78() { + this->mMap->vfunc_78(); +} + +unk8 MapManager::func_ov00_020840dc() { + int *piVar1; + + piVar1 = (int *) this->MapData_vfunc_78(); + if (piVar1 != (int *) 0x0) { + // (**(code **) (*piVar1 + 0x1c))(); // MapBase::func_ov00_0207f934() ?? + } +} + +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() { + this->mMap->vfunc_58(); +} + +unk8 MapManager::func_ov00_02084164() { + int iVar1; + unk32 uVar2; + + iVar1 = this->mMap->vfunc_58(/*param_2, 7, pcVar3, param_4*/); // Params? + if (iVar1 == 0) { + uVar2 = this->MapData_vfunc_54(); + switch (uVar2) { + case 0: break; + case 1: return 0; + case 2: return 0; + case 3: return 0; + case 4: return 0; + case 5: return 0; + case 6: return 0; + case 7: return 0; + case 8: break; + case 9: break; + case 10: return 0; + case 0xb: break; + case 0xc: break; + case 0xd: break; + case 0xe: break; // I mean, honestly Ghidra. + case 0xf: break; // What are we going to do with you? + case 0x10: break; + case 0x11: break; + case 0x12: break; + case 0x13: break; + case 0x14: return 0; + case 0x15: break; + case 0x16: break; + case 0x17: return 0; + case 0x18: break; + case 0x19: return 0; + case 0x1a: break; + case 0x1b: return 0; + case 0x1c: return 0; + case 0x1d: return 0; + case 0x1e: return 0; + case 0x1f: return 0; + case 0x20: break; + case 0x21: break; + case 0x22: break; + case 0x23: break; + case 0x24: return 0; + case 0x25: break; + case 0x26: break; + case 0x27: break; + case 0x28: break; + case 0x29: break; + case 0x2a: break; + case 0x2b: return 0; + case 0x2c: break; + case 0x2d: break; + case 0x2e: break; + case 0x2f: break; + case 0x30: return 0; + case 0x31: break; + case 0x32: break; + case 0x33: return 0; + case 0x34: return 0; + case 0x35: break; + case 0x36: break; + case 0x37: return 0; + case 0x38: break; + case 0x39: break; + case 0x3a: break; + case 0x3b: break; + case 0x3c: break; + case 0x3d: break; + case 0x3e: break; + case 0x3f: break; + case 0x40: return 0; + case 0x41: break; + case 0x42: break; + case 0x43: break; + case 0x44: break; + case 0x45: break; + case 0x46: return 0; + case 0x47: return 0; + case 0x48: return 0; + case 0x49: return 0; + case 0x4a: return 0; + case 0x4b: return 0; + case 0x4c: return 0; + case 0x4d: break; + case 0x4e: return 0; + case 0x4f: return 0; + case 0x50: return 0; + case 0x51: break; + case 0x52: break; + case 0x53: break; + case 0x54: break; + default: return 0; + } + 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() { + this->mMap->vfunc_a4(); +} + +unk8 MapManager::func_ov00_0208433c(Vec3p *param_2, Vec3p *param_3) { + Vec2s local_28; + Vec3p VStack_24; + Vec3p local_18; + + local_18.x = param_2->x; + local_18.y = param_2->y; + local_18.z = param_2->z; + 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->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); + } + } +} + +unk32 MapManager::GetMapData_Unk_38() { + return this->mMap->mUnk_038; +} + +unk8 MapManager::func_ov00_020846a4() { + s32 iVar1 = *(s32 *) ((s32) this->mMap->mUnk_144 + 4); + if (iVar1 == 0xff) { + switch (this->mCourse->mType) { + case CourseType_Normal: return 0; + case CourseType_Dungeon: break; + case CourseType_Sea: return 2; + case CourseType_TempleOfTheOceanKing: break; + case CourseType_Battle: break; + default: return 0; + } + return 1; + } + return iVar1; +} + +unk8 MapManager::func_ov00_02084700(s32 *param_1) { + int iVar1; + + iVar1 = *(int *) (param_1[1] + 0x34); + if (iVar1 == -1) { + iVar1 = *(int *) (*param_1 + 0xc4); + } + if ((iVar1 == 0x1b) && (gActorManager->mUnk_29 != false)) { + iVar1 = 0x1c; + } + return iVar1; +} + +unk8 MapManager::func_ov00_02084740() { + bool bVar1; + int iVar2; + int iVar3; + unk32 uVar4; + unk32 uVar5; + unk32 uVar6; + unk32 uVar7; + unk32 *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 = (unk32 *) PTR_DWORD_overlay_d_0__020d88f0_overlay_d_0__020847dc; + 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); +} + +unk8 MapManager::func_ov00_020847f0() { + s32 iVar1; + unk32 in_r1; + + iVar1 = this->mMap->FindTrigger(in_r1); + if (iVar1 == 0) { + // this->func_ov00_02084700(?); + return; + } + if ((*(int *) (iVar1 + 0xc) != -1) && (*(int *) (iVar1 + 0xc) < 0x6c)) { + return; + } + // this->func_ov00_02084700(?); +} + +bool MapManager::func_ov00_02084838() { + unk32 uVar1 = this->GetMapData_Unk_38(); + switch (uVar1) { + case 0: return false; + case 1: break; + case 2: break; + case 3: break; + case 4: break; + case 5: break; + case 6: return false; + case 7: return false; + case 8: return false; + case 9: return false; + case 10: break; + case 0xb: break; + case 0xc: break; + case 0xd: return false; + case 0xe: return false; + case 0xf: return false; + case 0x10: return false; + case 0x11: break; + case 0x12: return false; + case 0x13: break; + case 0x14: break; + case 0x15: break; + case 0x16: break; + default: return false; + } + return true; +} + +bool MapManager::func_ov00_020848b8() { + unk32 uVar1 = this->func_ov00_020846a4(); + switch (uVar1) { + case 0: break; + case 1: break; + case 2: break; + case 3: break; + case 4: break; + case 5: break; + case 6: return true; + case 7: break; + case 8: break; + case 9: break; + case 10: break; + case 0xb: break; + case 0xc: return true; + case 0xd: return true; + case 0xe: break; + case 0xf: return true; + case 0x10: break; + case 0x11: return true; + } + return false; +} + +void MapManager::func_ov00_02084924(u32 param_2) { + this->mMap->func_ov00_0208008c(param_2); +} + +bool MapManager::func_ov00_02084934(s32 *param_2) { + int iVar2; + int iVar3; + int iVar4; + Vec3p local_20; + + iVar2 = this->GetMapCenterZ(); + iVar3 = param_2[2]; + iVar4 = param_2[1]; + local_20.x = this->GetMapCenterX(); + local_20.x = *param_2 - local_20.x; + local_20.y = iVar4; + local_20.z = iVar3 - iVar2; + 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; +} + unk8 MapManager::func_ov00_0208499c() {} unk8 MapManager::func_ov00_020849c0() {} unk8 MapManager::func_ov00_020849dc() {} -- cgit v1.2.3 From b375db94e8ba9c9bb76a6c39cc7e4b7e9622199c Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Thu, 16 Jan 2025 16:57:04 +0100 Subject: Decompile MapManager::func_ov00_0208499c Decompile MapManager::func_ov00_020849c0 Decompile MapManager::func_ov00_020849dc Decompile MapManager::func_ov00_020849f8 (59%) Decompile MapManager::func_ov00_02084a50 Decompile MapManager::func_ov00_02084ac4 (52%) Decompile MapManager::SetNumKeys Decompile MapManager::GetNumKeys Decompile MapManager::SetBlueWarpOpen Decompile MapManager::GetBlueWarpOpen Decompile MapManager::func_ov00_02084be0 (96%) Decompile MapManager::SetMapDataFlag1 Decompile MapManager::GetMapDataFlag1 Decompile MapManager::func_ov00_02084c7c Decompile MapManager::func_ov00_02084c94 (50%) Decompile MapManager::func_ov00_02084cb0 Decompile MapManager::func_ov00_02084cc8 (50%) Decompile MapManager::func_ov00_02084ce4 Decompile MapManager::func_ov00_02084cfc (50%) Decompile MapManager::GetMapData_Unk_09 Decompile MapManager::func_ov00_0208583c (3%) Decompile and comment out rest of functions --- src/00_Core/Map/MapManager.cpp | 1597 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 1559 insertions(+), 38 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 5d738880..683c37a3 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -11,7 +11,93 @@ ARM void MapManager::func_ov00_020820fc(s32 param_2, unk32 param_3, unk32 param_ this->mCourse->func_ov00_0207ca28(param_2, param_3, param_4); } -unk8 MapManager::func_ov00_0208210c(unk32 param_2, unk32 param_3) {} +unk8 MapManager::func_ov00_0208210c(unk32 param_2, unk32 param_3) { + /* undefined *puVar1; + undefined uVar2; + undefined4 uVar3; + int iVar4; + undefined4 local_40; + undefined4 local_3c; + undefined4 local_38; + undefined4 local_34; + undefined2 local_30; + undefined local_2e; + undefined local_2d; + undefined local_2c; + undefined local_2b; + undefined4 local_28; + undefined4 local_24; + undefined4 local_20; + undefined4 local_1c; + undefined2 local_18; + undefined local_16; + undefined local_15; + undefined local_14; + undefined local_13; + + local_28 = 0x47; + local_24 = 0; + local_20 = 0; + local_1c = 0xfffffffe; + local_18 = 0; + local_16 = 0xff; + local_15 = 0; + local_14 = 0; + local_13 = 0; + if (param_2 == 0) { + FUN_overlay_d_0__02082348(param_1, &local_28); + uVar3 = FUN_overlay_d_0__020a5e9c(&local_28); + *param_3 = uVar3; + *(undefined *) (param_3 + 1) = local_16; + uVar2 = local_15; + } else { + *param_3 = 0xb; + *(undefined *) (param_3 + 1) = 2; + uVar2 = 4; + } + *(undefined *) ((int) param_3 + 5) = uVar2; + uVar3 = FUN_overlay_d_0__020a5e9c(*(int *) (*(int *) PTR_PTR_overlay_d_0__02082300 + 0x28) + 0x1c); + puVar1 = PTR_PTR_overlay_d_0__02082300; + param_3[2] = uVar3; + *(undefined *) (param_3 + 4) = *(undefined *) (*(int *) (*(int *) puVar1 + 0x28) + 0x2e); + *(undefined2 *) (param_3 + 5) = *(undefined2 *) (*(int *) (*(int *) puVar1 + 0x28) + 0x36); + iVar4 = *(int *) (*(int *) puVar1 + 0x28); + param_3[6] = *(undefined4 *) (iVar4 + 0x38); + param_3[7] = *(undefined4 *) (iVar4 + 0x3c); + param_3[8] = *(undefined4 *) (iVar4 + 0x40); + uVar3 = FUN_overlay_d_0__020a5e9c(*(int *) (*(int *) puVar1 + 0x28) + 0x44); + param_3[3] = uVar3; + puVar1 = PTR_PTR_overlay_d_0__02082300; + *(undefined *) ((int) param_3 + 0x11) = *(undefined *) (*(int *) (*(int *) PTR_PTR_overlay_d_0__02082300 + 0x28) + 0x56); + iVar4 = *(int *) (*(int *) puVar1 + 0x28); + param_3[9] = *(undefined4 *) (iVar4 + 0x5c); + param_3[10] = *(undefined4 *) (iVar4 + 0x60); + param_3[0xb] = *(undefined4 *) (iVar4 + 100); + *(undefined2 *) ((int) param_3 + 0x16) = *(undefined2 *) (*(int *) (*(int *) puVar1 + 0x28) + 0x68); + iVar4 = *(int *) (*(int *) puVar1 + 0x28); + local_40 = *(undefined4 *) (iVar4 + 0x70); + local_3c = *(undefined4 *) (iVar4 + 0x74); + local_38 = *(undefined4 *) (iVar4 + 0x78); + local_34 = *(undefined4 *) (iVar4 + 0x7c); + local_30 = *(undefined2 *) (iVar4 + 0x80); + local_2e = *(undefined *) (iVar4 + 0x82); + local_2d = *(undefined *) (iVar4 + 0x83); + local_2c = *(undefined *) (iVar4 + 0x84); + local_2b = *(undefined *) (iVar4 + 0x85); + uVar3 = FUN_overlay_d_0__020a5e9c(&local_40); + param_3[0x70] = uVar3; + puVar1 = PTR_DWORD_overlay_d_0__02082304; + *(undefined *) ((int) param_3 + 0x1be) = local_2e; + *(undefined *) ((int) param_3 + 0x1bf) = local_2d; + FUN_overlay_d_0__02096324(*(undefined4 *) puVar1, param_3); + FUN_overlay_d_0__0209d6e8(*(undefined4 *) PTR_DWORD_overlay_d_0__02082308, param_3); + if (param_1->mCourse->mType != 3) { + *(undefined1 *) ((int) param_3 + 7) = param_1->field2_0x8; + *(undefined1 *) (param_3 + 0x6f) = param_1->field3_0x9; + return; + } + return; */ +} ARM void MapManager::func_ov00_0208230c(s32 *param_2) { *param_2 = this->mCourse->mIndex; @@ -348,7 +434,50 @@ ARM void MapManager::func_ov00_02082af4() { this->mUnk_0b = 0; } -bool MapManager::func_ov00_02082b3c(s32 param_2) {} +bool MapManager::func_ov00_02082b3c(s32 param_2) { + /* byte bVar1; + undefined *puVar2; + ushort uVar3; + uint uVar4; + undefined4 uVar5; + uint in_r3; + ActorManager *pAVar6; + undefined4 local_18; + + local_18 = in_r3; + Course::FindMapGridPos((Vec2b *) &local_18, param_1->mCourse, (uint) * (byte *) (param_2 + 0x12)); + uVar4 = GetCourseData_Unk_1c(param_1); + if (((((local_18 & 0xff) == uVar4) && (uVar4 = GetCourseData_Unk_1d(param_1), (local_18 >> 8 & 0xff) == uVar4)) && + ((*(int *) (param_2 + 8) != 1 || (*(int *) (*(int *) PTR_PTR_overlay_d_0__02082ce0 + 0x14) != 1)))) && + (*(char *) (param_2 + 0x15) == '\0')) + { + AdventureFlags::FUN_overlay_d_0__020976c8(*(AdventureFlags **) PTR_gAdventureFlags_overlay_d_0__02082ce4); + puVar2 = PTR_gPlayer_overlay_d_0__02082d00; + param_1->field6_0xc = *(undefined *) (param_2 + 0x13); + (**(code **) (**(int **) puVar2 + 0x38))(*(int **) puVar2, *(undefined *) (param_2 + 0x13), 0); + UnkStruct_027e0c68::FUN_overlay_d_4__02106db8((UnkStruct_027e0c68 *) PTR_DWORD_overlay_d_0__02082d04); + (**(code **) (param_1->mMap->vtable + 0x18))(); + } else { + AdventureFlags::FUN_overlay_d_0__020976c8(*(AdventureFlags **) PTR_gAdventureFlags_overlay_d_0__02082ce4); + FUN_overlay_d_0__0208b13c(*(undefined4 *) PTR_DWORD_overlay_d_0__02082ce8); + pAVar6 = *PTR_gActorManager_overlay_d_0__02082cec; + uVar5 = FUN_overlay_d_0__02082d08(param_1); + FUN_overlay_d_4__02105608(pAVar6, local_18 & 0xff, local_18 >> 8 & 0xff, uVar5); + (**(code **) (param_1->mMap->vtable + 0x2c))(); + FUN_overlay_d_4__02102b28(*(undefined4 *) PTR_DWORD_overlay_d_0__02082cf0); + FUN_overlay_d_4__02102770(*(undefined4 *) PTR_DWORD_overlay_d_0__02082cf4); + FUN_overlay_d_4__02102e3c(*(undefined4 *) PTR_DWORD_overlay_d_0__02082cf8); + bVar1 = *(byte *) (param_2 + 0x12); + uVar3 = Course::FindCurrentMapData_Unk_04(param_1->mCourse); + uVar4 = Course::FindMapData_Unk_04(param_1->mCourse, (uint) bVar1); + (param_1->mCourse->mCurrMapPos).x = (byte) local_18; + (param_1->mCourse->mCurrMapPos).y = local_18._1_1_; + FUN_overlay_d_4__021024c4(param_1, param_2, uVar3 != uVar4, 0); + FUN_overlay_d_4__02105578(*PTR_gActorManager_overlay_d_0__02082cec, (uint) * (byte *) (param_2 + 0x12)); + UnkStruct_027e0103c::thunk_FUN_overlay_d_0__020cf7e8(*PTR_PTR_overlay_d_0__02082cfc); + } + return true; */ +} ARM u8 MapManager::func_ov00_02082d08() { Course *course = this->mCourse; @@ -1597,41 +1726,1433 @@ u8 MapManager::GetMapData_Unk_07() { return this->mMap->mUnk_007; } -unk8 MapManager::func_ov00_0208499c() {} -unk8 MapManager::func_ov00_020849c0() {} -unk8 MapManager::func_ov00_020849dc() {} -bool MapManager::func_ov00_020849f8(unk32 param_1) {} -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(s32 *param_2) {} -unk8 MapManager::func_ov00_0208527c() {} -unk8 MapManager::func_ov00_020853fc() {} -unk8 MapManager::func_ov00_02085594() {} -void MapManager::func_ov00_0208583c(unk32 param_1, Vec3p *param_2, unk32 param_3) {} -unk8 MapManager::func_ov00_020858b0() {} -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_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; +} + +bool MapManager::func_ov00_020849f8() { + s32 iVar1; // = FUN_overlay_d_0__020a5e9c(*(s32 *) PTR_PTR_overlay_d_0__02084a4c + 0xc); + if (iVar1 == 5) { + return true; + } + iVar1 = this->GetMapData_Unk_06(); + if ((iVar1 != 0) && (iVar1 = this->func_ov00_020849c0(), iVar1 == 0)) { + return true; + } + return false; +} + +u8 MapManager::func_ov00_02084a50() { + return this->mMap->mUnk_011; +} + +void MapManager::SpawnNPC(Vec3p *param_2, unk32 param_3, unk32 param_4) { + // astruct_16 aStack_3c; + // Actor_UnkStruct_020((Actor_UnkStruct_020 *) &aStack_3c); + // aStack_3c.field24_0x1c = 0xffffffff; + // aStack_3c.field25_0x20 = 0xffffffff; + // astruct_16::astruct_16(&aStack_3c); + // aStack_3c.field26_0x24 = param_3; + // aStack_3c.field27_0x28 = param_4; + // spawnNpc(*(undefined4 *) PTR_DWORD_overlay_d_0__02084abc, s_CIVE_overlay_d_0__02084ac0, param_2, &aStack_3c, + // (ActorRef *) 0x0); +} + +bool MapManager::func_ov00_02084ac4(u32 actorId) { + Actor *iVar1; + bool bVar1; + + iVar1 = gActorManager->FindActorById(actorId); + if (iVar1 == (Actor *) 0x0) { + return false; + } + bVar1 = (char *) iVar1->mType == "CIVE"; // s_CIVE_overlay_d_0__02084b04 + if (bVar1) { + iVar1->mAlive = false; + } + return bVar1; +} + +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; +} + +unk8 MapManager::func_ov00_02084b38(unk32 param_2, unk32 param_3, unk32 param_4) { + MapBase *pMVar1; + bool value; + + if (param_2 != 0) { + // value = SUB41(param_4, 0); // What is SUB41 and where is it defined? + switch (param_3) { + case 0: goto LAB_overlay_d_0__02084b60; + case 1: this->mCourse->SetMapDataFlag0(param_2, value); return; + case 2: this->mCourse->SetFlag0(param_2, value); return; + case 3: this->mCourse->SetFlag1(param_2, value); return; + default: return; + } + } + return; +LAB_overlay_d_0__02084b60: + pMVar1 = this->mMap; + if (param_4 == 0) { + pMVar1->mUnk_180[param_2 >> 5].mUnk_0 = pMVar1->mUnk_180[param_2 >> 5].mUnk_0 & ~(1 << (param_2 & 0x1f)); + return; + } + pMVar1->mUnk_180[param_2 >> 5].mUnk_0 = pMVar1->mUnk_180[param_2 >> 5].mUnk_0 | 1 << (param_2 & 0x1f); + return; +} + +bool MapManager::func_ov00_02084be0(unk32 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 in_r2; // not defined. + + if (param_2 < 0) { + return; + } + this->mCourse->SetMapDataFlag2(param_2, in_r2); +} + +bool MapManager::func_ov00_02084c94(unk32 param_2) { + bool bVar1; + + if (-1 < param_2) { + bVar1 = this->mCourse->GetMapDataFlag2(param_2); + return bVar1; + } + return false; +} + +void MapManager::func_ov00_02084cb0(unk32 param_2) { + bool in_r2; // not defined. + + if (param_2 < 0) { + return; + } + this->mCourse->SetMapDataFlag3(param_2, in_r2); +} + +bool MapManager::func_ov00_02084cc8(unk32 param_2) { + bool bVar1; + + if (-1 < param_2) { + bVar1 = this->mCourse->GetMapDataFlag3(param_2); + return bVar1; + } + return false; +} + +void MapManager::func_ov00_02084ce4(unk32 param_2) { + unk32 in_r2; // not defined. + + if (param_2 < 0) { + return; + } + this->mCourse->SetMapDataFlag4(param_2, in_r2); +} + +bool MapManager::func_ov00_02084cfc(unk32 param_2) { + bool bVar1; + + if (-1 < param_2) { + bVar1 = this->mCourse->GetMapDataFlag4(param_2); + return bVar1; + } + return false; +} + +u8 MapManager::GetMapData_Unk_09() { + return this->mMap->mUnk_009; +} + +unk8 MapManager::func_ov00_02084d24(unk8 param_2, unk8 param_3, unk32 param_4) { + unk8 local_8; + unk8 local_7; + unk16 uStack_6; + + uStack_6 = (unk16) ((u32) param_4 >> 0x10); + // _local_8 = CONCAT11(param_3, param_2); // What is CONCAT11 ? + // this->mMap->vfunc_90(&local_8, param_4); // Missing parameter ? +} + +s32 MapManager::func_ov00_02084d4c(unk32 param_2, unk32 param_3, Vec3p *param_4) { + /* undefined *object; + undefined *dtor; + undefined *obj; + dword a; + int iVar1; + int aiStack_3c[4]; + Vec3p VStack_2c; + int iStack_20; + int iStack_1c; + int iStack_18; + Vec3p VStack_14; + + iVar1 = FUN_overlay_d_0__0208df78(*(undefined4 *) (*(int *) PTR_DWORD_overlay_d_0__02084ea0 + 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 ((*(uint *) (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; + *(undefined4 *) PTR_DWORD_overlay_d_0__020e2510_overlay_d_0__02084ea8 = 0; + *(undefined4 *) (object + 4) = 0x1000; + *(undefined4 *) (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; + *(undefined4 *) (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); + *(uint *) (PTR_DestructorChain_overlay_d_0_bss__020ec964_overlay_d_0__02084ea4 + 0x60) = + *(uint *) (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 = FUN_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 = DWORD_overlay_d_0__02084eb8; + 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; */ +} + +unk8 MapManager::func_ov00_02084ebc(unk32 param_2) { + /* int *piVar1; + int iVar2; + dword dVar3; + undefined auStack_18[4]; + uint uStack_14; + + FUN_overlay_d_0__02083a1c(auStack_18, param_1, param_2); + piVar1 = (int *) MapData_vfunc_78(param_1); + 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 = FUN_overlay_d_0__02083e70(param_1, auStack_18); + if (iVar2 != 0) { + return 0; + } + iVar2 = MapData_vfunc_54(param_1); + if (iVar2 < 0x47) { + if (0x45 < iVar2) { + return 0; + } + if (iVar2 < 0x2a) { + switch (iVar2) { + case 0: break; + case 1: return 0; + case 2: return 0; + case 3: return 0; + case 4: return 0; + case 5: return 0; + case 6: return 0; + case 7: break; + case 8: return 0; + case 9: return 0; + case 10: break; + case 0xb: break; + case 0xc: break; + case 0xd: break; + case 0xe: break; + case 0xf: break; + case 0x10: break; + case 0x11: break; + case 0x12: break; + case 0x13: break; + case 0x14: return 0; + case 0x15: break; + case 0x16: return 0; + case 0x17: return 0; + case 0x18: break; + case 0x19: return 0; + case 0x1a: break; + case 0x1b: break; + case 0x1c: break; + case 0x1d: return 0; + case 0x1e: return 0; + case 0x1f: return 0; + case 0x20: break; + case 0x21: break; + case 0x22: break; + case 0x23: break; + case 0x24: break; + case 0x25: break; + case 0x26: break; + case 0x27: return 0; + case 0x28: return 0; + case 0x29: return 0; + } + } 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 = (**(code **) (param_1->mMap->vtable + 0x58))(param_1->mMap, auStack_18, 5); + if (iVar2 != 0) { + return 0; + } + dVar3 = MapData_vfunc_70(param_1); + if (dVar3 != DWORD_overlay_d_0__02085100) { + FUN_overlay_d_0__02093a1c(&uStack_14, *(undefined4 *) PTR_DWORD_overlay_d_0__02085104); + if ((uStack_14 >> 5 & 3) != 1) { + return 0; + } + return 1; + } + return 0; */ +} + +s32 MapManager::func_ov00_02085108(s32 *param_2) { + /* undefined *puVar1; + undefined4 uVar2; + int *piVar3; + int iVar4; + uint uVar5; + int iVar6; + int iVar7; + int iVar8; + uint local_44; + byte local_3a; + byte local_39; + byte local_38; + byte local_37; + int local_34; + int local_30; + int local_2c; + undefined4 local_28; + + uVar2 = FUN_overlay_d_0__0208b180(*(undefined4 *) PTR_DWORD_overlay_d_0__02085274); + FUN_overlay_d_0__02088130(&local_38, uVar2); + local_44 = (uint) local_38; + uVar2 = FUN_overlay_d_0__0208b180(*(undefined4 *) PTR_DWORD_overlay_d_0__02085274); + FUN_overlay_d_0__02088144(&local_3a, uVar2); + if (local_44 <= local_37) { + do { + puVar1 = PTR_gMapManager_overlay_d_0__02085278; + uVar5 = (uint) local_39; + if ((uint) local_3a <= (uint) local_39) { + do { + piVar3 = (int *) MapData_vfunc_78(*(MapManager **) puVar1); + 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 = FUN_0202b8e4(&local_34, 2); + if (iVar4 != 0) { + *param_2 = piVar3[6]; + param_2[1] = piVar3[7]; + param_2[2] = piVar3[8]; + return (int) *(char *) ((int) piVar3 + 0x12); + } + } + uVar5 = uVar5 - 1; + } while ((int) (uint) local_3a <= (int) uVar5); + } + local_44 = local_44 + 1; + } while ((int) local_44 <= (int) (uint) local_37); + } + return 0; */ +} + +unk8 MapManager::func_ov00_0208527c() { + /* uint uVar1; + undefined *puVar2; + undefined4 uVar3; + int iVar4; + int iVar5; + uint uVar6; + uint uVar7; + uint local_4c; + byte local_3e; + byte local_3d; + byte local_3c; + byte local_3b; + undefined4 local_38; + undefined4 local_34; + undefined4 local_30; + undefined4 local_2c; + + uVar3 = FUN_overlay_d_0__0208b180(*(undefined4 *) PTR_DWORD_overlay_d_0__020853f4); + FUN_overlay_d_0__02088130(&local_3c, uVar3); + uVar7 = (uint) local_3c; + uVar3 = FUN_overlay_d_0__0208b180(*(undefined4 *) PTR_DWORD_overlay_d_0__020853f4); + FUN_overlay_d_0__02088144(&local_3e, uVar3); + local_4c = (uint) local_3e; + uVar6 = (uint) local_3d; + iVar4 = Get_MapData_Unk28(param_1); + iVar5 = Get_MapData_Unk2a(param_1); + puVar2 = PTR_gMapManager_overlay_d_0__020853f8; + if (uVar7 == 0) { + uVar7 = 0; + } + if (iVar4 <= (int) (uint) 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) (uint) local_3b < (int) uVar7) { + return 0; + } + for (; (int) uVar1 <= (int) uVar6; uVar1 = uVar1 + 1) { + iVar4 = MapData_vfunc_78(*(MapManager **) puVar2); + if (((iVar4 != 0) && ((*(uint *) (iVar4 + 4) & 4) != 0)) && + (iVar5 = FUN_overlay_d_0__0208b73c(iVar4, param_2), iVar5 != 0)) + { + *param_3 = *(undefined4 *) (iVar4 + 0x18); + param_3[1] = *(undefined4 *) (iVar4 + 0x1c); + param_3[2] = *(undefined4 *) (iVar4 + 0x20); + return (int) *(char *) (iVar4 + 0x12); + } + } + uVar7 = uVar7 + 1; + } while (true); */ +} + +unk8 MapManager::func_ov00_020853fc() { + /* uint uVar1; + undefined4 uVar2; + int iVar3; + int iVar4; + int iVar5; + uint uVar6; + int iVar7; + uint local_50; + uint local_48; + byte local_3e; + byte local_3d; + byte local_3c; + byte local_3b; + undefined4 local_38; + undefined4 local_34; + undefined4 local_30; + undefined4 local_2c; + + uVar2 = FUN_overlay_d_0__0208b180(*(undefined4 *) PTR_DWORD_overlay_d_0__0208558c); + FUN_overlay_d_0__02088130(&local_3c, uVar2); + local_48 = (uint) local_3c; + uVar2 = FUN_overlay_d_0__0208b180(*(undefined4 *) PTR_DWORD_overlay_d_0__0208558c); + FUN_overlay_d_0__02088144(&local_3e, uVar2); + local_50 = (uint) local_3e; + uVar6 = (uint) local_3d; + iVar3 = Get_MapData_Unk28(param_1); + iVar4 = Get_MapData_Unk2a(param_1); + iVar7 = 0; + local_2c = 0; + if (local_48 == 0) { + local_48 = 0; + } + local_38 = 0; + if (iVar3 <= (int) (uint) 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) (uint) local_3b; local_48 = local_48 + 1) { + for (; (int) uVar1 <= (int) uVar6; uVar1 = uVar1 + 1) { + iVar3 = MapData_vfunc_78(*(MapManager **) PTR_gMapManager_overlay_d_0__02085590); + if ((((iVar3 != 0) && ((*(uint *) (iVar3 + 4) & 4) != 0)) && + (iVar4 = Vec3p::Distance((Vec3p *) (iVar3 + 0x18), param_2), iVar4 < *param_3)) && + (iVar5 = FUN_overlay_d_0__0208b7d0(iVar3, param_2), iVar5 != 0)) + { + *param_3 = iVar4; + iVar7 = iVar3; + } + } + } + return iVar7; */ +} + +unk8 MapManager::func_ov00_02085594() { + /* int *piVar1; + int iVar2; + dword dVar3; + undefined4 uVar4; + bool bVar5; + undefined4 uStack_2c; + undefined local_28; + undefined local_27; + uint uStack_24; + Vec3p VStack_20; + + FUN_overlay_d_0__02083a1c(&local_28, param_1, param_2); + piVar1 = (int *) MapData_vfunc_78(param_1); + 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 = FUN_overlay_d_0__020840a0(param_1, local_28, local_27, param_4); + if (iVar2 < 0x47) { + if (0x45 < iVar2) { + return 0; + } + if (iVar2 < 0x2a) { + switch (iVar2) { + case 0: break; + case 1: return 0; + case 2: return 0; + case 3: return 0; + case 4: return 0; + case 5: return 0; + case 6: return 0; + case 7: break; + case 8: return 0; + case 9: return 0; + case 10: break; + case 0xb: break; + case 0xc: break; + case 0xd: break; + case 0xe: break; + case 0xf: break; + case 0x10: break; + case 0x11: break; + case 0x12: break; + case 0x13: break; + case 0x14: return 0; + case 0x15: break; + case 0x16: return 0; + case 0x17: return 0; + case 0x18: break; + case 0x19: return 0; + case 0x1a: break; + case 0x1b: break; + case 0x1c: break; + case 0x1d: return 0; + case 0x1e: return 0; + case 0x1f: return 0; + case 0x20: break; + case 0x21: break; + case 0x22: break; + case 0x23: break; + case 0x24: break; + case 0x25: break; + case 0x26: break; + case 0x27: return 0; + case 0x28: return 0; + case 0x29: return 0; + } + } 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 = (**(code **) (param_1->mMap->vtable + 0x58))(param_1->mMap, &local_28, 5); + if (iVar2 != 0) { + return 0; + } + uStack_2c._0_2_ = CONCAT11(local_27, local_28); + FUN_overlay_d_0__02083c7c(param_1, &VStack_20, uStack_2c); + dVar3 = MapData_vfunc_70(param_1); + if (dVar3 != DWORD_overlay_d_0__02085834) { + FUN_overlay_d_0__02093a1c(&uStack_24, *(undefined4 *) PTR_DWORD_overlay_d_0__02085838); + 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) { + s32 *piVar1; + unk8 auStack_10[4]; + + // param_1->func_ov00_02083a1c(auStack_10, param_1, param_2); // Should auStack_10 be pointer type or not ? + piVar1 = (s32 *) param_1->MapData_vfunc_78(); + if (piVar1 == (s32 *) 0x0) { + return; + } + // if (*(s32 *) PTR_UnkStruct_027e077c_overlay_d_0__020858ac == 1) { + // if (*(s32 *) (PTR_UnkStruct_027e077c_overlay_d_0__020858ac + 4) == 1) { + // (**(code **) (*piVar1 + 0x30))(piVar1, param_3); + // return; + // } + // return; + //} +} + +unk8 MapManager::func_ov00_020858b0() { + /* int iVar1; + int iVar2; + int iVar3; + int iVar4; + int *piVar5; + int iVar6; + int iVar7; + undefined4 local_38; + byte local_28; + byte local_27; + + if (param_3 == 1) { + FUN_overlay_d_0__02088000(*(undefined4 *) (*(int *) PTR_DWORD_overlay_d_0__02085a2c + 4), 7); + } else { + FUN_overlay_d_0__02088000(*(undefined4 *) (*(int *) PTR_DWORD_overlay_d_0__02085a2c + 4), 6); + } + iVar2 = Get_MapData_Unk28(param_1); + iVar3 = Get_MapData_Unk2a(param_1); + local_38 = 0xffffffff; + FUN_overlay_d_0__02083a1c(&local_28, param_1, param_2); + iVar6 = *(int *) (PTR_gPlayerPos_overlay_d_0__02085a30 + 4); + for (iVar7 = local_28 - 1; iVar7 <= (int) (local_28 + 1); iVar7 = iVar7 + 1) { + if ((-1 < iVar7) && (iVar1 = local_27 - 1, iVar7 < iVar2)) { + for (; iVar1 <= (int) (local_27 + 1); iVar1 = iVar1 + 1) { + if ((-1 < iVar1) && (iVar1 < iVar3)) { + iVar4 = MapData_vfunc_60(param_1); + iVar4 = iVar4 - iVar6; + if (iVar4 < 0) { + iVar4 = -iVar4; + } + if ((iVar4 < 0xce) && (piVar5 = (int *) MapData_vfunc_78(param_1), piVar5 != (int *) 0x0)) { + local_38 = (**(code **) (*piVar5 + 0x38))(piVar5, param_3); + } + } + } + } + } + return local_38; */ +} + +s32 MapManager::func_ov00_02085a34(unk32 param_2, unk32 param_3) { + /* int *piVar1; + int iVar2; + undefined2 *puVar3; + uint uVar4; + uint uVar5; + uint uVar6; + undefined uStack_2c; + undefined uStack_2b; + undefined auStack_2a[2]; + Vec2b aVStack_28[2]; + undefined2 auStack_24[4]; + undefined auStack_1c[4]; + undefined4 uStack_18; + undefined2 uStack_14; + undefined uStack_12; + + if (param_3 != 1) { + if (param_3 != 2 && param_3 != 3) { + return -1; + } + FUN_overlay_d_0__02083a1c(auStack_2a, param_1, param_2); + piVar1 = (int *) MapData_vfunc_78(param_1); + if (piVar1 == (int *) 0x0) { + return -1; + } + iVar2 = (**(code **) (*piVar1 + 0x1c))(); + if (iVar2 == 0x42) { + uStack_2b = *(undefined *) ((int) piVar1 + 0x15); + uStack_2c = *(undefined *) (piVar1 + 5); + MapBase::FUN_overlay_d_0__02080d08(param_1->mMap, &uStack_2c); + } + iVar2 = (**(code **) (*piVar1 + 0x3c))(piVar1, param_3); + return iVar2; + } + FUN_overlay_d_0__02083a1c(aVStack_28, param_1, param_2); + iVar2 = FUN_overlay_d_0__02084ebc(param_1, param_2); + if (iVar2 == 0) { + return -1; + } + piVar1 = (int *) MapData_vfunc_78(param_1); + 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); + 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; + FUN_overlay_d_0__020828f8(param_1, piVar1); + } + MapBase::FUN_overlay_d_0__02080b24(param_1->mMap, 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 { + *(undefined *) (puVar3 + 4) = 0; + uVar6 = uVar6 + 1; + *(undefined *) (puVar3 + 5) = 0; + puVar3 = (undefined2 *) ((int) puVar3 + 1); + } while (uVar6 < 2); + iVar2 = Map_vfunc_7c(param_1); + if (iVar2 == 0) { + return -1; + } + iVar2 = MapData_vfunc_78(param_1); + if ((iVar2 != 0) && (0 < *(short *) (iVar2 + 0xe))) { + return 1; + } + return 0; */ +} + +unk8 MapManager::func_ov00_02085c60(unk32 param_2, unk32 param_3, unk32 param_4, unk32 param_5) { + /* longlong lVar1; + undefined *puVar2; + dword dVar3; + bool bVar4; + bool bVar5; + int iVar6; + uint 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]; + undefined2 uStack_68; + undefined2 uStack_66; + undefined2 uStack_64; + undefined2 uStack_62; + undefined2 uStack_60; + undefined uStack_3e; + undefined uStack_3d; + undefined uStack_3c; + undefined uStack_3b; + undefined uStack_34; + undefined uStack_33; + undefined uStack_32; + undefined uStack_31; + undefined uStack_30; + undefined uStack_2f; + undefined4 uStack_2c; + undefined4 uStack_28; + + if (param_5 == 0) { + return 0; + } + FUN_overlay_d_0__020792a0(*(undefined4 *) PTR_DWORD_overlay_d_0__0208603c, 0, *param_3, param_3[1]); + FUN_overlay_d_0__020792a0(*(undefined4 *) PTR_DWORD_overlay_d_0__0208603c, 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 = (ulonglong) param_5 * 0xc000 + 0x800; + uVar7 = (uint) lVar1 >> 0xc | (int) ((ulonglong) 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) + (uint) (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.xyz.y = param_5 << 1; + VStack_d8.xyz.x = 0; + VStack_d8.xyz.z = 0; + VStack_d8.w = param_5; + do { + bVar4 = FUN_01ffbe78(param_1, 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 = DWORD_overlay_d_0__02086040; + param_2->x = VStack_e4.x; + param_2->y = VStack_e4.y; + param_2->z = VStack_e4.z; + uStack_68 = (undefined2) 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 = FUN_01ffbe78(param_1, 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; + } + FUN_overlay_d_0__0207920c(*(undefined4 *) PTR_DWORD_overlay_d_0__0208603c, &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 = FUN_0202b2e8(&VStack_b0, &VStack_98, uVar7); + puVar2 = PTR_DWORD_overlay_d_0__0208603c; + 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; + FUN_overlay_d_0__0207920c(*(undefined4 *) 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(unk32 param_2, unk32 param_3, unk32 param_4) { + /* undefined uVar1; + undefined uVar2; + int iVar3; + int iVar4; + int iVar5; + int iVar6; + int iVar7; + int iVar8; + int *piVar9; + Vec3p *pVVar10; + int iVar11; + undefined local_c6; + undefined local_c5; + undefined 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; + FUN_overlay_d_0__0208ed74(&local_40, &local_88); + AABB::Grow(&local_40, param_4); + iVar3 = FUN_overlay_d_0__020839d4(param_1, local_40.min.x); + iVar4 = FUN_overlay_d_0__020839f8(param_1, local_40.min.z); + iVar5 = FUN_overlay_d_0__020839d4(param_1, local_40.max.x); + iVar6 = FUN_overlay_d_0__020839f8(param_1, 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 = FUN_overlay_d_0__020839d4(param_1, param_3->x); + uVar2 = FUN_overlay_d_0__020839f8(param_1, param_3->z); + iVar7 = FUN_overlay_d_0__02083e34(param_1, uVar1, uVar2, pVVar10); + do { + if (iVar5 < iVar3) { + return 0; + } + if (iVar4 <= iVar6) { + iVar11 = iVar4; + do { + iVar8 = FUN_overlay_d_0__02083e34(param_1, (char) iVar3, (char) iVar11, pVVar10); + if (iVar7 < iVar8) { + local_c6 = (char) iVar3; + local_c5 = (char) iVar11; + FUN_overlay_d_0__02084024(*(MapManager **) PTR_gMapManager_overlay_d_0__02086280, &local_c6, &AStack_70); + Vec3p::Sub(param_2, param_3, &VStack_7c); + pVVar10 = (Vec3p *) auStack_c4; + iVar8 = FUN_overlay_d_0__0208e87c(&AStack_70, &local_b0, &VStack_7c); + if (iVar8 != 0) { + return 1; + } + } + piVar9 = (int *) MapData_vfunc_78(param_1); + 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 = FUN_overlay_d_0__0208b804(piVar9, &iStack_c0, &VStack_58); + if (iVar8 != 0) { + return 1; + } + } + iVar11 = iVar11 + 1; + } while (iVar11 <= iVar6); + } + iVar3 = iVar3 + 1; + } while (true); */ +} + 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; + int iVar2; + int iVar3; + int local_d0[2]; + int local_c8; + Vec3p local_c4; + Vec3p local_b8; + int local_ac[2]; + int local_a4; + int local_a0[2]; + int local_98; + int local_94; + int local_90; + int local_8c; + Vec3p local_88; + Vec3p local_7c; + Vec3p local_70; + int local_64; + int local_60; + int local_5c; + int local_58; + int local_54; + Vec3p local_50; + Vec3p local_44; + Vec3p local_38; + int local_2c; + int iStack_28; + int iStack_24; + int local_20; + + iVar2 = (**(code **) (*param_2 + 8))(); + if (iVar2 == 0) { + (**(code **) (*param_2 + 0x24))(param_2, &local_2c); + local_38.x = local_2c; + local_38.y = iStack_28; + local_38.z = iStack_24; + iVar2 = Vec3p::Distance(param_3, &local_38); + Vec3p::Sub(param_3, &local_38, &local_38); + bVar1 = Vec3p::Normalize(&local_38); + 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; + local_50.y = iStack_28; + local_50.z = iStack_24; + 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); + FUN_overlay_d_0__0208e6b0(local_a0, local_ac); + local_b8.y = param_3->y; + local_b8.x = local_ac[0]; + 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[0] <= 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; + } + FUN_overlay_d_0__0208e6b0(local_a0, local_d0); + iVar2 = param_3->z; + if (((iVar2 < local_8c) && (local_98 <= iVar2)) && ((param_3->x < local_94 && (local_a0[0] <= param_3->x)))) { + iVar2 = FUN_overlay_d_0__0208e6f0(local_a0); + iVar3 = FUN_overlay_d_0__0208e704(local_a0); + if (iVar2 == iVar3) { + local_c8 = local_c8 - param_3->z; + if (local_c8 < 0) { + local_c8 = -local_c8; + } + local_d0[0] = local_d0[0] - param_3->x; + if (local_d0[0] < 0) { + local_d0[0] = -local_d0[0]; + } + bVar1 = local_c8 < local_d0[0]; + } else { + iVar2 = FUN_overlay_d_0__0208e6f0(local_a0); + iVar3 = FUN_overlay_d_0__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 = FUN_overlay_d_0__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 = FUN_overlay_d_0__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 = FUN_overlay_d_0__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 = FUN_overlay_d_0__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[0] <= iVar3)) { + if (local_c4.z < 0) { + iVar2 = local_b8.z; + if (local_b8.z < 0) { + iVar2 = -local_b8.z; + } + iVar3 = FUN_overlay_d_0__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 = FUN_overlay_d_0__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 = FUN_overlay_d_0__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 = FUN_overlay_d_0__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[0] = local_d0[0] - iVar3; + if (local_d0[0] < 0) { + local_d0[0] = -local_d0[0]; + } + if (local_c8 < local_d0[0]) { + if (local_c4.x < 0) { + iVar2 = local_b8.x; + if (local_b8.x < 0) { + iVar2 = -local_b8.x; + } + iVar3 = FUN_overlay_d_0__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 = FUN_overlay_d_0__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 = FUN_overlay_d_0__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 = FUN_overlay_d_0__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; + undefined 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); + 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); + FUN_overlay_d_0__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; */ +} -- cgit v1.2.3 From 03be711e960fe91413a005c26ae0e9046b65f811 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Thu, 16 Jan 2025 23:56:10 +0100 Subject: Match MapManager::func_ov00_02082af4 --- src/00_Core/Map/MapManager.cpp | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 683c37a3..feb89ddf 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -3,6 +3,10 @@ #include "Actor/ActorManager.hpp" #include "Player/PlayerBase.hpp" +extern void func_ov000_0208cc88(s32 *param1); + +extern s32 *data_027e0f68; + ARM void MapManager::GetCourseDungeonProgress(CourseProgress *param_2) { this->mCourse->GetDungeonProgress(param_2); } @@ -300,7 +304,7 @@ ARM void MapManager::MapData_vfunc_44() { this->mMap->vfunc_44(); } -ARM void MapManager::func_ov00_02082808(s32 param_2, unk32 param_3, unk32 param_4) { +ARM void MapManager::func_ov00_02082808(s32 param_2) { // How to define PTR_027e0d38 ? // if (*(int*)(*(int*)PTR_027e0d38 + 0x14) == 1) { // return; @@ -312,13 +316,13 @@ ARM void MapManager::func_ov00_02082808(s32 param_2, unk32 param_3, unk32 param_ if (var1 == var2) { return; } - // func_ov00_020d70a4(DWORD_overlay_d_0_bss__020eec68, var1, 0, 0x7f, param_4); // And these? + // func_ov00_020d70a4(DWORD_overlay_d_0_bss__020eec68, var1, 0, 0x7f, param_3); // And these? } else { // var2 = func_ov00_020a5e9c(*(s32 *) PTR_027e0d38 + 0xc); if (var2 == 0) { // func_ov015_021849a4(DWORD_overlay_d_15_bss__02190458); } - // func_ov00_020a5e9c(DWORD_overlay_d_0_bss__020eec68, var1, 0, 0x7f, param_4); + // func_ov00_020a5e9c(DWORD_overlay_d_0_bss__020eec68, var1, 0, 0x7f, param_3); } // var1 = func_ov00_020a5e9c(*(s32 *) PTR_027e0d38 + 0xc); if (var1 == 0) { @@ -427,9 +431,9 @@ ARM unk32 *MapManager::func_ov00_02082adc() { } ARM void MapManager::func_ov00_02082af4() { - // func_ov00_02082af4(DWORD_027e0f68) // Does not exist. + func_ov000_0208cc88(data_027e0f68); this->mMap->vfunc_48(); - // this->func_ov00_02082808(0, ?, ?) // Only 1/3 params specified. + this->func_ov00_02082808(0); this->mUnk_0a = 1; this->mUnk_0b = 0; } @@ -492,7 +496,7 @@ ARM u8 MapManager::GetCurrentMapPosY() { return this->mCourse->mCurrMapPos.y; } -ARM unk8 MapManager::func_ov00_02082d40() { +ARM u8 MapManager::func_ov00_02082d40() { if (this->mCourse->mType == CourseType_Sea) { return this->mCourse->mMapGrid[(u8) this->mCourse->mCurrMapPos.x][(u8) this->mCourse->mCurrMapPos.y]; } -- cgit v1.2.3 From 93e1c583010c1d6b094fb659d8fab7dcb9dd9665 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Fri, 17 Jan 2025 20:07:13 +0100 Subject: Match MapManager::func_ov00_02082adc Match MapManager::func_ov00_02082d74 --- src/00_Core/Map/MapManager.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index feb89ddf..750476b5 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -3,9 +3,12 @@ #include "Actor/ActorManager.hpp" #include "Player/PlayerBase.hpp" +extern u32 func_ov000_02078bc4(unk32 param_1); extern void func_ov000_0208cc88(s32 *param1); +extern s32 *func_ov000_02096418(s32 *param_1); extern s32 *data_027e0f68; +extern s32 *data_027e0f70; ARM void MapManager::GetCourseDungeonProgress(CourseProgress *param_2) { this->mCourse->GetDungeonProgress(param_2); @@ -426,8 +429,8 @@ ARM void MapManager::func_ov00_02082acc() { this->mCourse->func_ov00_0207d7bc(); } -ARM unk32 *MapManager::func_ov00_02082adc() { - // func_ov000_02096418(DWORD_027e0f70); // Does not exist. +ARM s32 *MapManager::func_ov00_02082adc() { + return func_ov000_02096418(data_027e0f70); } ARM void MapManager::func_ov00_02082af4() { @@ -504,7 +507,7 @@ ARM u8 MapManager::func_ov00_02082d40() { } ARM u32 MapManager::func_ov00_02082d74(unk32 param_2) { - // return func_ov00_02082d80(param_2); // Does not exist. + return func_ov000_02078bc4(param_2); } ARM void MapManager::func_ov00_02082d84(unk8 *param_2, s32 *param_3, s32 *param_4) { -- cgit v1.2.3 From 11fcd1e4ea30212728c5646bec060c57fb0e0678 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sat, 18 Jan 2025 00:07:56 +0100 Subject: Match MapManager::func_ov00_02082594 Match MapManager::func_ov00_020825ac Refactor MapManager::func_ov00_020836bc to MapManager::GetTriggerBoundingBox --- src/00_Core/Map/MapManager.cpp | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 750476b5..1993c556 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -4,8 +4,12 @@ #include "Player/PlayerBase.hpp" extern u32 func_ov000_02078bc4(unk32 param_1); +extern void func_ov00_02078bf0(s32 *param_1, unk32 param_2); 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_02096418(s32 *param_1); +extern bool func_ov015_02129c44(s32 param_1); extern s32 *data_027e0f68; extern s32 *data_027e0f70; @@ -114,13 +118,13 @@ ARM void MapManager::func_ov00_0208230c(s32 *param_2) { } ARM void MapManager::func_ov00_02082348(unk32 param_2) { - // s32 var[4]; - // var[0] = 0x47; - // var[1] = 0; - // var[2] = 0; - // var[3] = 0xfffffffe; - // this->func_ov00_0208230c(var); - // func_ov00_02078bf0(var, param2) ??? + s32 var[4]; + var[0] = 0x47; + var[1] = 0; + var[2] = 0; + var[3] = 0xfffffffe; + this->func_ov00_0208230c(var); + func_ov00_02078bf0(var, param_2); } ARM void MapManager::func_ov00_020823a4(unk32 param_2) { @@ -181,7 +185,7 @@ ARM bool MapManager::func_ov00_02082494(s32 param_2) { ARM bool MapManager::func_ov00_020824cc(s32 param_2) { s32 var = this->mMap->vfunc_4c(); if (var == 2) { - bool state;// = this->mMap->func_ov015_02129c44(param_2); // Does not exist. + bool state = func_ov015_02129c44(param_2); return state; } return false; @@ -206,13 +210,11 @@ ARM unk8 *MapManager::func_ov00_02082538() { } ARM void MapManager::func_ov00_02082594() { - // func_ov000_0208d620(DWORD_027e0f68) does not exist. - return; + func_ov000_0208d620(data_027e0f68); } ARM void MapManager::func_ov00_020825ac() { - // func_ov000_0208d680(DWORD_027e0f68) does not exist. - return; + func_ov000_0208d680(data_027e0f68); } ARM s32 MapManager::GetCourseFilePath(char *courseName, char *buf) { @@ -885,7 +887,7 @@ ARM bool MapManager::func_ov00_02083664(Vec3p *param_2, unk32 entranceId) { return false; } -ARM s32 MapManager::func_ov00_020836bc(s32 param_2, AABB *param_3) { +ARM s32 MapManager::GetTriggerBoundingBox(s32 param_2, AABB *param_3) { return this->mMap->GetTriggerBoundingBox(param_2, param_3); } -- cgit v1.2.3 From 2450e474eae8aaf4d814b49a380c0cb8c8d2fdf1 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sun, 19 Jan 2025 00:02:20 +0100 Subject: Uncomment MapManager::func_ov00_0208210c Uncomment most of MapManager::func_ov00_02082b3c Improve MapManager::func_ov00_02083840 Improve MapManager::func_ov00_02083fb0 Uncomment most of MapManager::func_ov00_02086a84 Add Vec3p_Scale --- src/00_Core/Map/MapManager.cpp | 321 ++++++++++++++++++++++------------------- 1 file changed, 173 insertions(+), 148 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 1993c556..f934cbfe 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -2,17 +2,41 @@ #include "Actor/Actor.hpp" #include "Actor/ActorManager.hpp" #include "Player/PlayerBase.hpp" +#include "Save/AdventureFlags.hpp" extern u32 func_ov000_02078bc4(unk32 param_1); -extern void func_ov00_02078bf0(s32 *param_1, unk32 param_2); +extern void func_ov000_02078bf0(s32 *param_1, unk32 param_2); +extern s32 func_ov000_02078fe8(s32 *param_1); +extern void func_ov000_020798bc(s32 *param_1, s32 param_2); +extern void func_ov000_0208b13c(s32 *param_1); extern void func_ov000_0208cc88(s32 *param1); extern void func_ov000_0208d620(s32 *param_1); extern void func_ov000_0208d680(s32 *param_1); +extern void func_ov000_0208e6b0(s32 *param_1, Vec3p *param_2); +extern void func_ov000_02093a1c(u32 *param_1, s32 *param_2); +extern void func_ov000_02096324(s32 *param_1, s32 param_2); extern s32 *func_ov000_02096418(s32 *param_1); +extern void func_ov000_0209d6e8(s32 param_1, s32 param_2); +extern unk32 func_ov000_020a5e9c(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_02105578(ActorManager *param_1, u32 param_2); +extern void func_ov004_02105608(ActorManager *param_1, unk32 param_2, unk32 param_3, unk32 param_4); +extern s32 func_ov015_02129c14(); extern bool func_ov015_02129c44(s32 param_1); +extern s32 *data_027e0c68; +extern s32 *data_027e0d38; +extern s32 *data_027e0d3c; +extern s32 *data_027e0f64; extern s32 *data_027e0f68; +extern s32 *data_027e0f6c; extern s32 *data_027e0f70; +extern s32 *data_027e0f78; +extern s32 *data_027e0f7c; +extern s32 *data_027e103c; ARM void MapManager::GetCourseDungeonProgress(CourseProgress *param_2) { this->mCourse->GetDungeonProgress(param_2); @@ -22,29 +46,29 @@ ARM void MapManager::func_ov00_020820fc(s32 param_2, unk32 param_3, unk32 param_ this->mCourse->func_ov00_0207ca28(param_2, param_3, param_4); } -unk8 MapManager::func_ov00_0208210c(unk32 param_2, unk32 param_3) { - /* undefined *puVar1; - undefined uVar2; - undefined4 uVar3; - int iVar4; - undefined4 local_40; - undefined4 local_3c; - undefined4 local_38; - undefined4 local_34; - undefined2 local_30; - undefined local_2e; - undefined local_2d; - undefined local_2c; - undefined local_2b; - undefined4 local_28; - undefined4 local_24; - undefined4 local_20; - undefined4 local_1c; - undefined2 local_18; - undefined local_16; - undefined local_15; - undefined local_14; - undefined local_13; +unk8 MapManager::func_ov00_0208210c(unk32 param_2, unk32 *param_3) { + unk32 *puVar1; + unk8 uVar2; + unk32 uVar3; + s32 iVar4; + unk32 local_40; + unk32 local_3c; + unk32 local_38; + unk32 local_34; + unk16 local_30; + unk8 local_2e; + unk8 local_2d; + unk8 local_2c; + unk8 local_2b; + unk32 local_28; + unk32 local_24; + unk32 local_20; + unk32 local_1c; + unk16 local_18; + unk8 local_16; + unk8 local_15; + unk8 local_14; + unk8 local_13; local_28 = 0x47; local_24 = 0; @@ -56,58 +80,58 @@ unk8 MapManager::func_ov00_0208210c(unk32 param_2, unk32 param_3) { local_14 = 0; local_13 = 0; if (param_2 == 0) { - FUN_overlay_d_0__02082348(param_1, &local_28); - uVar3 = FUN_overlay_d_0__020a5e9c(&local_28); - *param_3 = uVar3; - *(undefined *) (param_3 + 1) = local_16; - uVar2 = local_15; + this->func_ov00_02082348(&local_28); + uVar3 = func_ov000_020a5e9c(&local_28); + *param_3 = uVar3; + *(unk8 *) (param_3 + 1) = local_16; + uVar2 = local_15; } else { - *param_3 = 0xb; - *(undefined *) (param_3 + 1) = 2; - uVar2 = 4; - } - *(undefined *) ((int) param_3 + 5) = uVar2; - uVar3 = FUN_overlay_d_0__020a5e9c(*(int *) (*(int *) PTR_PTR_overlay_d_0__02082300 + 0x28) + 0x1c); - puVar1 = PTR_PTR_overlay_d_0__02082300; - param_3[2] = uVar3; - *(undefined *) (param_3 + 4) = *(undefined *) (*(int *) (*(int *) puVar1 + 0x28) + 0x2e); - *(undefined2 *) (param_3 + 5) = *(undefined2 *) (*(int *) (*(int *) puVar1 + 0x28) + 0x36); - iVar4 = *(int *) (*(int *) puVar1 + 0x28); - param_3[6] = *(undefined4 *) (iVar4 + 0x38); - param_3[7] = *(undefined4 *) (iVar4 + 0x3c); - param_3[8] = *(undefined4 *) (iVar4 + 0x40); - uVar3 = FUN_overlay_d_0__020a5e9c(*(int *) (*(int *) puVar1 + 0x28) + 0x44); - param_3[3] = uVar3; - puVar1 = PTR_PTR_overlay_d_0__02082300; - *(undefined *) ((int) param_3 + 0x11) = *(undefined *) (*(int *) (*(int *) PTR_PTR_overlay_d_0__02082300 + 0x28) + 0x56); - iVar4 = *(int *) (*(int *) puVar1 + 0x28); - param_3[9] = *(undefined4 *) (iVar4 + 0x5c); - param_3[10] = *(undefined4 *) (iVar4 + 0x60); - param_3[0xb] = *(undefined4 *) (iVar4 + 100); - *(undefined2 *) ((int) param_3 + 0x16) = *(undefined2 *) (*(int *) (*(int *) puVar1 + 0x28) + 0x68); - iVar4 = *(int *) (*(int *) puVar1 + 0x28); - local_40 = *(undefined4 *) (iVar4 + 0x70); - local_3c = *(undefined4 *) (iVar4 + 0x74); - local_38 = *(undefined4 *) (iVar4 + 0x78); - local_34 = *(undefined4 *) (iVar4 + 0x7c); - local_30 = *(undefined2 *) (iVar4 + 0x80); - local_2e = *(undefined *) (iVar4 + 0x82); - local_2d = *(undefined *) (iVar4 + 0x83); - local_2c = *(undefined *) (iVar4 + 0x84); - local_2b = *(undefined *) (iVar4 + 0x85); - uVar3 = FUN_overlay_d_0__020a5e9c(&local_40); - param_3[0x70] = uVar3; - puVar1 = PTR_DWORD_overlay_d_0__02082304; - *(undefined *) ((int) param_3 + 0x1be) = local_2e; - *(undefined *) ((int) param_3 + 0x1bf) = local_2d; - FUN_overlay_d_0__02096324(*(undefined4 *) puVar1, param_3); - FUN_overlay_d_0__0209d6e8(*(undefined4 *) PTR_DWORD_overlay_d_0__02082308, param_3); - if (param_1->mCourse->mType != 3) { - *(undefined1 *) ((int) param_3 + 7) = param_1->field2_0x8; - *(undefined1 *) (param_3 + 0x6f) = param_1->field3_0x9; + *param_3 = 0xb; + *(unk8 *) (param_3 + 1) = 2; + uVar2 = 4; + } + *(unk8 *) ((int) param_3 + 5) = uVar2; + uVar3 = func_ov000_020a5e9c(data_027e0d38 + 0x28) + 0x1c; + puVar1 = data_027e0d38; + param_3[2] = uVar3; + *(unk8 *) (param_3 + 4) = *(unk8 *) (*(s32 *) (*(s32 *) puVar1 + 0x28) + 0x2e); + *(unk16 *) (param_3 + 5) = *(unk16 *) (*(s32 *) (*(s32 *) puVar1 + 0x28) + 0x36); + iVar4 = *(s32 *) (*(int *) puVar1 + 0x28); + param_3[6] = *(unk32 *) (iVar4 + 0x38); + param_3[7] = *(unk32 *) (iVar4 + 0x3c); + param_3[8] = *(unk32 *) (iVar4 + 0x40); + uVar3 = func_ov000_020a5e9c(puVar1 + 0x28) + 0x44; + param_3[3] = uVar3; + puVar1 = data_027e0d38; + *(unk8 *) ((int) param_3 + 0x11) = *(unk8 *) (*(s32 *) (*(s32 *) data_027e0d38 + 0x28) + 0x56); + iVar4 = *(s32 *) (*(s32 *) puVar1 + 0x28); + param_3[9] = *(unk32 *) (iVar4 + 0x5c); + param_3[10] = *(unk32 *) (iVar4 + 0x60); + param_3[0xb] = *(unk32 *) (iVar4 + 100); + *(unk16 *) ((int) param_3 + 0x16) = *(unk16 *) (*(s32 *) (*(s32 *) puVar1 + 0x28) + 0x68); + iVar4 = *(s32 *) (*(s32 *) puVar1 + 0x28); + local_40 = *(unk32 *) (iVar4 + 0x70); + local_3c = *(unk32 *) (iVar4 + 0x74); + local_38 = *(unk32 *) (iVar4 + 0x78); + local_34 = *(unk32 *) (iVar4 + 0x7c); + local_30 = *(unk16 *) (iVar4 + 0x80); + local_2e = *(unk8 *) (iVar4 + 0x82); + local_2d = *(unk8 *) (iVar4 + 0x83); + local_2c = *(unk8 *) (iVar4 + 0x84); + local_2b = *(unk8 *) (iVar4 + 0x85); + uVar3 = func_ov000_020a5e9c(&local_40); + param_3[0x70] = uVar3; + puVar1 = data_027e0f70; + *(unk8 *) ((int) param_3 + 0x1be) = local_2e; + *(unk8 *) ((int) param_3 + 0x1bf) = local_2d; + func_ov000_02096324(puVar1, *param_3); // unsure if (s32 *param_1, s32 param_2) or (s32 param_1, s32 *param_2) + func_ov000_0209d6e8(*data_027e0f7c, *param_3); + if (this->mCourse->mType != CourseType_TempleOfTheOceanKing) { + *(unk8 *) ((int) param_3 + 7) = this->mUnk_08; + *(unk8 *) (param_3 + 0x6f) = this->mUnk_09; return; } - return; */ + return; } ARM void MapManager::func_ov00_0208230c(s32 *param_2) { @@ -117,14 +141,14 @@ ARM void MapManager::func_ov00_0208230c(s32 *param_2) { *(unk8 *) ((u32) param_2 + 0x13) = this->mUnk_0c; } -ARM void MapManager::func_ov00_02082348(unk32 param_2) { +ARM void MapManager::func_ov00_02082348(unk32 *param_2) { s32 var[4]; var[0] = 0x47; var[1] = 0; var[2] = 0; var[3] = 0xfffffffe; this->func_ov00_0208230c(var); - func_ov00_02078bf0(var, param_2); + func_ov000_02078bf0(var, *param_2); } ARM void MapManager::func_ov00_020823a4(unk32 param_2) { @@ -158,7 +182,7 @@ ARM void MapManager::MapData_vfunc_9c() { ARM s32 MapManager::func_ov00_02082424() { s32 var = this->mMap->vfunc_4c(); if (var == 2) { - // var = this->mMap->func_ov015_02129c14(); // Does not exist. + var = func_ov015_02129c14(); // MapBase::GetUnk_19c_Unk_28 according to Ghidra return var; } return 0; @@ -444,48 +468,48 @@ ARM void MapManager::func_ov00_02082af4() { } bool MapManager::func_ov00_02082b3c(s32 param_2) { - /* byte bVar1; - undefined *puVar2; - ushort uVar3; - uint uVar4; - undefined4 uVar5; - uint in_r3; + u8 bVar1; + PlayerBase *puVar2; + u16 uVar3; + u32 uVar4; + unk32 uVar5; + u32 in_r3; ActorManager *pAVar6; - undefined4 local_18; + unk32 local_18; - local_18 = in_r3; - Course::FindMapGridPos((Vec2b *) &local_18, param_1->mCourse, (uint) * (byte *) (param_2 + 0x12)); - uVar4 = GetCourseData_Unk_1c(param_1); - if (((((local_18 & 0xff) == uVar4) && (uVar4 = GetCourseData_Unk_1d(param_1), (local_18 >> 8 & 0xff) == uVar4)) && - ((*(int *) (param_2 + 8) != 1 || (*(int *) (*(int *) PTR_PTR_overlay_d_0__02082ce0 + 0x14) != 1)))) && + local_18 = in_r3; // what's the point of that? + this->mCourse->FindMapGridPos((Vec2b *) &local_18, this->mCourse, (u32) * (u8 *) (param_2 + 0x12)); + uVar4 = this->GetCurrentMapPosX(); + if (((((local_18 & 0xff) == uVar4) && (uVar4 = this->GetCurrentMapPosY(), (local_18 >> 8 & 0xff) == uVar4)) && + ((*(s32 *) (param_2 + 8) != 1 || (*(s32 *) (*(s32 *) data_027e0d38 + 0x14) != 1)))) && (*(char *) (param_2 + 0x15) == '\0')) { - AdventureFlags::FUN_overlay_d_0__020976c8(*(AdventureFlags **) PTR_gAdventureFlags_overlay_d_0__02082ce4); - puVar2 = PTR_gPlayer_overlay_d_0__02082d00; - param_1->field6_0xc = *(undefined *) (param_2 + 0x13); - (**(code **) (**(int **) puVar2 + 0x38))(*(int **) puVar2, *(undefined *) (param_2 + 0x13), 0); - UnkStruct_027e0c68::FUN_overlay_d_4__02106db8((UnkStruct_027e0c68 *) PTR_DWORD_overlay_d_0__02082d04); - (**(code **) (param_1->mMap->vtable + 0x18))(); + gAdventureFlags->func_ov00_020976c8(); + puVar2 = gPlayer; + this->mUnk_0c = *(unk32 *) (param_2 + 0x13); + // (**(code **) (**(int **) puVar2 + 0x38))(*(int **) puVar2, *(unk32 *) (param_2 + 0x13), 0); + // UnkStruct_027e0c68::FUN_overlay_d_4__02106db8((UnkStruct_027e0c68 *) PTR_DWORD_overlay_d_0__02082d04); + this->mMap->vfunc_18(); } else { - AdventureFlags::FUN_overlay_d_0__020976c8(*(AdventureFlags **) PTR_gAdventureFlags_overlay_d_0__02082ce4); - FUN_overlay_d_0__0208b13c(*(undefined4 *) PTR_DWORD_overlay_d_0__02082ce8); - pAVar6 = *PTR_gActorManager_overlay_d_0__02082cec; - uVar5 = FUN_overlay_d_0__02082d08(param_1); - FUN_overlay_d_4__02105608(pAVar6, local_18 & 0xff, local_18 >> 8 & 0xff, uVar5); - (**(code **) (param_1->mMap->vtable + 0x2c))(); - FUN_overlay_d_4__02102b28(*(undefined4 *) PTR_DWORD_overlay_d_0__02082cf0); - FUN_overlay_d_4__02102770(*(undefined4 *) PTR_DWORD_overlay_d_0__02082cf4); - FUN_overlay_d_4__02102e3c(*(undefined4 *) PTR_DWORD_overlay_d_0__02082cf8); - bVar1 = *(byte *) (param_2 + 0x12); - uVar3 = Course::FindCurrentMapData_Unk_04(param_1->mCourse); - uVar4 = Course::FindMapData_Unk_04(param_1->mCourse, (uint) bVar1); - (param_1->mCourse->mCurrMapPos).x = (byte) local_18; - (param_1->mCourse->mCurrMapPos).y = local_18._1_1_; - FUN_overlay_d_4__021024c4(param_1, param_2, uVar3 != uVar4, 0); - FUN_overlay_d_4__02105578(*PTR_gActorManager_overlay_d_0__02082cec, (uint) * (byte *) (param_2 + 0x12)); - UnkStruct_027e0103c::thunk_FUN_overlay_d_0__020cf7e8(*PTR_PTR_overlay_d_0__02082cfc); - } - return true; */ + gAdventureFlags->func_ov00_020976c8(); + func_ov000_0208b13c(data_027e0f64); + pAVar6 = gActorManager; + uVar5 = this->func_ov00_02082d08(); + func_ov004_02105608(pAVar6, local_18 & 0xff, local_18 >> 8 & 0xff, 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) local_18; + (this->mCourse->mCurrMapPos).y = (u8) * (&local_18 + 0x4); // I assume this is what Ghidra means by "local_18._1_1_" + func_ov004_021024c4(this, param_2, uVar3 != uVar4, 0); + func_ov004_02105578(gActorManager, (u32) * (u8 *) (param_2 + 0x12)); + // UnkStruct_027e0103c::thunk_FUN_overlay_d_0__020cf7e8(*PTR_PTR_overlay_d_0__02082cfc); + } + return true; } ARM u8 MapManager::func_ov00_02082d08() { @@ -949,19 +973,19 @@ ARM bool MapManager::func_ov00_02083790(s32 param_2) { } ARM bool MapManager::func_ov00_02083840(s32 param_2) { - unk8 *puVar1; - unk8 *puVar2; + s32 *puVar1; + s32 *puVar2; bool bVar3; s32 iVar4; - // puVar2 = PTR_DWORD_overlay_d_0__020838c0; - // puVar1 = PTR_DWORD_overlay_d_0__020838bc; + puVar2 = data_027e0d3c; + puVar1 = data_027e0f64; if (param_2 != 0) { - // *(unk32 *) (*(int *) (*(int *) PTR_DWORD_overlay_d_0__020838bc + 8) + 0x1b4) = 0xffffffff; - // *(unk32 *) (*(int *) (*(int *) puVar1 + 4) + 0x1b4) = 0xffffffff; - // iVar4 = FUN_overlay_d_0__02078fe8(*(unk32 *) puVar2); + *(unk32 *) (*(int *) (*(int *) data_027e0f64 + 8) + 0x1b4) = 0xffffffff; + *(unk32 *) (*(int *) (*(int *) puVar1 + 4) + 0x1b4) = 0xffffffff; + iVar4 = func_ov000_02078fe8(puVar2); if (-1 < iVar4) { - // FUN_overlay_d_0__020798bc(*(unk32 *) PTR_DWORD_overlay_d_0__020838c0, 0x10); + func_ov000_020798bc(data_027e0d3c, 0x10); gActorManager->func_ov00_020c3ce8(param_2, false); } bVar3 = this->mMap->TriggerOfType_vfunc_10(param_2); @@ -1243,7 +1267,7 @@ unk8 MapManager::func_ov00_02083fb0(u32 *param_1, MapManager *param_2, Vec3p *pa } dVar2 = param_2->MapData_vfunc_70(param_3); if (dVar2 != 0xffff) { - // FUN_overlay_d_0__02093a1c(param_1, *(unk32 *) PTR_DWORD_overlay_d_0__02084020); + func_ov000_02093a1c(param_1, data_027e0f6c); return; } *param_1 = 0; @@ -3094,10 +3118,10 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 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) { - /* bool bVar1; + bool bVar1; int iVar2; Vec3p VStack_a0; - undefined auStack_94[24]; + unk32 auStack_94[24]; Vec3p local_7c; int local_70[5]; Vec3p local_5c; @@ -3107,33 +3131,34 @@ bool MapManager::func_ov00_02086a84(s32 *param_2, Vec3p *param_3, Vec3p *param_4 int local_2c; Vec3p VStack_28; - Vec3p::Sub(param_3, param_4, &VStack_28); - iVar2 = (**(code **) (*param_2 + 8))(); + Vec3p_Sub(param_3, param_4, &VStack_28); + // iVar2 = (**(code **) (*param_2 + 8))(); if (iVar2 == 0) { - (**(code **) (*param_2 + 0x24))(param_2, &local_38); + //(**(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); + 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); + 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); + 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); + 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; @@ -3143,25 +3168,25 @@ bool MapManager::func_ov00_02086a84(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (iVar2 != 2) { return false; } - (**(code **) (*param_2 + 0x2c))(param_2, auStack_94); - FUN_overlay_d_0__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); + //(**(code **) (*param_2 + 0x2c))(param_2, auStack_94); + func_ov000_0208e6b0(auStack_94, &VStack_a0); + Vec3p_Scale(&VStack_28, param_6); // Doesn't exist. + 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); + // (**(code **) (*param_2 + 0x28))(param_2, local_70); + // Vec3p_Scale(&VStack_28, param_6); // Doesn't exist. + 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; */ + Vec3p_Sub(param_4, &local_7c, param_9); + // Vec3p_Normalize(param_9); + return false; } -- cgit v1.2.3 From ec1bda51131ca45bc904cb5bb879a2acceea9ca0 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sun, 19 Jan 2025 22:53:58 +0100 Subject: Improve MapManager::func_ov00_02082454 Improve MapManager::func_ov00_02082494 Improve MapManager::DestroyMap Uncomment MapManager::func_ov00_02086284 --- src/00_Core/Map/MapManager.cpp | 165 +++++++++++++++++++++-------------------- 1 file changed, 84 insertions(+), 81 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index f934cbfe..a2fd77ff 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -12,7 +12,9 @@ extern void func_ov000_0208b13c(s32 *param_1); extern void func_ov000_0208cc88(s32 *param1); extern void func_ov000_0208d620(s32 *param_1); extern void func_ov000_0208d680(s32 *param_1); -extern void func_ov000_0208e6b0(s32 *param_1, Vec3p *param_2); +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 void func_ov000_02093a1c(u32 *param_1, s32 *param_2); extern void func_ov000_02096324(s32 *param_1, s32 param_2); extern s32 *func_ov000_02096418(s32 *param_1); @@ -25,6 +27,8 @@ extern void func_ov004_02102e3c(s32 *param_1); extern void func_ov004_02105578(ActorManager *param_1, u32 param_2); extern void func_ov004_02105608(ActorManager *param_1, unk32 param_2, unk32 param_3, unk32 param_4); extern s32 func_ov015_02129c14(); +extern bool func_ov015_02129c24(Vec3p *param_1, Vec3p *param_2); +extern bool func_ov015_02129c34(s32 param_1); extern bool func_ov015_02129c44(s32 param_1); extern s32 *data_027e0c68; @@ -191,7 +195,7 @@ ARM s32 MapManager::func_ov00_02082424() { ARM bool MapManager::func_ov00_02082454(Vec3p *param_2, Vec3p *param_3) { s32 var = this->mMap->vfunc_4c(); if (var == 2) { - bool state;// = this->mMap->func_ov015_02129c24(param_2, param_3); // Does not exist. + bool state = func_ov015_02129c24(param_2, param_3); return state; } return false; @@ -200,7 +204,7 @@ ARM bool MapManager::func_ov00_02082454(Vec3p *param_2, Vec3p *param_3) { ARM bool MapManager::func_ov00_02082494(s32 param_2) { s32 var = this->mMap->vfunc_4c(); if (var == 2) { - bool state;// = this->mMap->func_ov015_02129c34(param_2); // Does not exist. + bool state = func_ov015_02129c34(param_2); return state; } return false; @@ -324,9 +328,8 @@ ARM void MapManager::CreateMap(unk32 mapType, unk32 param_3, unk32 param_4) { ARM void MapManager::DestroyMap() { if (this->mMap == NULL) { return; - } else { - // this->mMap->vfunc_04(); Doesn't exist. } + this->mMap->~MapBase(); } ARM void MapManager::MapData_vfunc_44() { @@ -2822,57 +2825,57 @@ 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) { - /* bool bVar1; - int iVar2; - int iVar3; - int local_d0[2]; - int local_c8; + bool bVar1; + s32 iVar2; + s32 iVar3; + Vec3p local_d0; + s32 local_c8; Vec3p local_c4; Vec3p local_b8; - int local_ac[2]; - int local_a4; - int local_a0[2]; - int local_98; - int local_94; - int local_90; - int local_8c; + 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; - int local_64; - int local_60; - int local_5c; - int local_58; - int local_54; + s32 local_64; + s32 local_60; + s32 local_5c; + s32 local_58; + s32 local_54; Vec3p local_50; Vec3p local_44; Vec3p local_38; - int local_2c; - int iStack_28; - int iStack_24; - int local_20; + s32 local_2c; + s32 iStack_28; + s32 iStack_24; + s32 local_20; - iVar2 = (**(code **) (*param_2 + 8))(); + // iVar2 = (**(code **) (*param_2 + 8))(); // What pointer address is contained in param_2? if (iVar2 == 0) { - (**(code **) (*param_2 + 0x24))(param_2, &local_2c); + // (**(code **) (*param_2 + 0x24))(param_2, &local_2c); local_38.x = local_2c; local_38.y = iStack_28; local_38.z = iStack_24; - iVar2 = Vec3p::Distance(param_3, &local_38); - Vec3p::Sub(param_3, &local_38, &local_38); - bVar1 = Vec3p::Normalize(&local_38); + iVar2 = Vec3p_Distance(param_3, &local_38); + Vec3p_Sub(param_3, &local_38, &local_38); + // bVar1 = Vec3p_Normalize(&local_38); 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); + Vec3p_Scale(&local_38, (local_20 + param_5) - iVar2); + Vec3p_Add(param_3, &local_38, param_7); local_50.x = local_2c; local_50.y = iStack_28; local_50.z = iStack_24; - Vec3p::Sub(param_4, &local_50, &local_44); - Vec3p::Normalize(&local_44); + 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; @@ -2883,12 +2886,12 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 local_64 = 0; local_60 = 0; local_5c = 0; - (**(code **) (*param_2 + 0x28))(param_2, &local_64); + // (**(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)) && + (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; @@ -2897,22 +2900,22 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 param_8->z = 0; return true; } - iVar2 = Vec3p::Distance(param_3, &local_70); + 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); + 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); + 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); + 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; @@ -2921,23 +2924,23 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (iVar2 != 2) { return false; } - (**(code **) (*param_2 + 0x2c))(param_2, local_a0); - FUN_overlay_d_0__0208e6b0(local_a0, local_ac); + // (**(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[0]; + 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); + 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); + // 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[0] <= param_3->x && (param_3->z < local_8c)) && (local_98 <= param_3->z)))) || + (((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; @@ -2946,24 +2949,24 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 param_8->z = 0; return true; } - FUN_overlay_d_0__0208e6b0(local_a0, local_d0); + 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[0] <= param_3->x)))) { - iVar2 = FUN_overlay_d_0__0208e6f0(local_a0); - iVar3 = FUN_overlay_d_0__0208e704(local_a0); + 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[0] = local_d0[0] - param_3->x; - if (local_d0[0] < 0) { - local_d0[0] = -local_d0[0]; + 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[0]; + bVar1 = local_c8 < local_d0.x; } else { - iVar2 = FUN_overlay_d_0__0208e6f0(local_a0); - iVar3 = FUN_overlay_d_0__0208e704(local_a0); + iVar2 = func_ov000_0208e6f0(&local_a0); + iVar3 = func_ov000_0208e704(&local_a0); if (iVar2 < iVar3) { bVar1 = true; } else { @@ -2976,7 +2979,7 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (local_b8.x < 0) { iVar2 = -local_b8.x; } - iVar3 = FUN_overlay_d_0__0208e6f0(local_a0); + 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; @@ -2986,7 +2989,7 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (local_b8.x < 0) { iVar2 = -local_b8.x; } - iVar3 = FUN_overlay_d_0__0208e6f0(local_a0); + 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; @@ -2997,7 +3000,7 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (local_b8.z < 0) { iVar2 = -local_b8.z; } - iVar3 = FUN_overlay_d_0__0208e704(local_a0); + 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; @@ -3007,7 +3010,7 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (local_b8.z < 0) { iVar2 = -local_b8.z; } - iVar3 = FUN_overlay_d_0__0208e704(local_a0); + 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; @@ -3015,13 +3018,13 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 } } else { iVar3 = param_3->x; - if ((iVar3 < local_94) && (local_a0[0] <= iVar3)) { + 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 = FUN_overlay_d_0__0208e704(local_a0); + 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; @@ -3031,7 +3034,7 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (local_b8.z < 0) { iVar2 = -local_b8.z; } - iVar3 = FUN_overlay_d_0__0208e704(local_a0); + 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; @@ -3043,7 +3046,7 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (local_b8.x < 0) { iVar2 = -local_b8.x; } - iVar3 = FUN_overlay_d_0__0208e6f0(local_a0); + 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; @@ -3053,7 +3056,7 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (local_b8.x < 0) { iVar2 = -local_b8.x; } - iVar3 = FUN_overlay_d_0__0208e6f0(local_a0); + 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; @@ -3064,17 +3067,17 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (local_c8 < 0) { local_c8 = -local_c8; } - local_d0[0] = local_d0[0] - iVar3; - if (local_d0[0] < 0) { - local_d0[0] = -local_d0[0]; + 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[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 = FUN_overlay_d_0__0208e6f0(local_a0); + 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; @@ -3084,7 +3087,7 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (local_b8.x < 0) { iVar2 = -local_b8.x; } - iVar3 = FUN_overlay_d_0__0208e6f0(local_a0); + 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; @@ -3095,7 +3098,7 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (local_b8.z < 0) { iVar2 = -local_b8.z; } - iVar3 = FUN_overlay_d_0__0208e704(local_a0); + 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; @@ -3105,7 +3108,7 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 if (local_b8.z < 0) { iVar2 = -local_b8.z; } - iVar3 = FUN_overlay_d_0__0208e704(local_a0); + 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; @@ -3113,7 +3116,7 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 } } } - return false; */ + 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, @@ -3169,8 +3172,8 @@ bool MapManager::func_ov00_02086a84(s32 *param_2, Vec3p *param_3, Vec3p *param_4 return false; } //(**(code **) (*param_2 + 0x2c))(param_2, auStack_94); - func_ov000_0208e6b0(auStack_94, &VStack_a0); - Vec3p_Scale(&VStack_28, param_6); // Doesn't exist. + // 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); @@ -3181,7 +3184,7 @@ bool MapManager::func_ov00_02086a84(s32 *param_2, Vec3p *param_3, Vec3p *param_4 local_70[1] = 0; local_70[2] = 0; // (**(code **) (*param_2 + 0x28))(param_2, local_70); - // Vec3p_Scale(&VStack_28, param_6); // Doesn't exist. + 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]; -- cgit v1.2.3 From ecaa34e7e1055b22f6d0352b5710dfbea461ebad Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Mon, 20 Jan 2025 19:39:52 +0100 Subject: Decomp progress 24% --- src/00_Core/Map/MapManager.cpp | 70 ++++++++++++++++++++++-------------------- 1 file changed, 36 insertions(+), 34 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index a2fd77ff..4e4621c9 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -9,12 +9,15 @@ extern void func_ov000_02078bf0(s32 *param_1, unk32 param_2); extern s32 func_ov000_02078fe8(s32 *param_1); extern void func_ov000_020798bc(s32 *param_1, s32 param_2); extern void func_ov000_0208b13c(s32 *param_1); +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 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, s32 *param_2); extern void func_ov000_02096324(s32 *param_1, s32 param_2); extern s32 *func_ov000_02096418(s32 *param_1); @@ -26,9 +29,9 @@ extern void func_ov004_02102b28(s32 *param_1); extern void func_ov004_02102e3c(s32 *param_1); extern void func_ov004_02105578(ActorManager *param_1, u32 param_2); extern void func_ov004_02105608(ActorManager *param_1, unk32 param_2, unk32 param_3, unk32 param_4); -extern s32 func_ov015_02129c14(); -extern bool func_ov015_02129c24(Vec3p *param_1, Vec3p *param_2); -extern bool func_ov015_02129c34(s32 param_1); +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(s32 param_1); extern s32 *data_027e0c68; @@ -186,7 +189,7 @@ ARM void MapManager::MapData_vfunc_9c() { ARM s32 MapManager::func_ov00_02082424() { s32 var = this->mMap->vfunc_4c(); if (var == 2) { - var = func_ov015_02129c14(); // MapBase::GetUnk_19c_Unk_28 according to Ghidra + var = func_ov015_02129c14(this->mMap); // MapBase::GetUnk_19c_Unk_28 according to Ghidra return var; } return 0; @@ -195,7 +198,7 @@ ARM s32 MapManager::func_ov00_02082424() { 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(param_2, param_3); + bool state = func_ov015_02129c24(this->mMap, param_2, param_3); return state; } return false; @@ -204,7 +207,7 @@ ARM bool MapManager::func_ov00_02082454(Vec3p *param_2, Vec3p *param_3) { ARM bool MapManager::func_ov00_02082494(s32 param_2) { s32 var = this->mMap->vfunc_4c(); if (var == 2) { - bool state = func_ov015_02129c34(param_2); + bool state = func_ov015_02129c34(this->mMap, param_2); return state; } return false; @@ -870,8 +873,8 @@ ARM unk32 MapManager::func_ov00_020835b4() { return this->mCourse->Get_Unk_c8_04(); } -ARM unk8 MapManager::func_ov00_020835c4(s32 param_2, unk32 param_3) { - return this->mCourse->func_ov00_0207d404(param_2, 0, param_3); +ARM unk8 MapManager::func_ov00_020835c4(MapManager *param_1, s32 param_2, unk32 param_3) { + return param_1->mCourse->func_ov00_0207d404(param_2, 0, param_3); } ARM bool MapManager::func_ov00_020835e4(s32 param_2, unk32 *param_3, unk8 *param_4) { @@ -2731,9 +2734,9 @@ unk8 MapManager::func_ov00_02085c60(unk32 param_2, unk32 param_3, unk32 param_4, return 0; */ } -unk8 MapManager::func_ov00_02086044(unk32 param_2, unk32 param_3, unk32 param_4) { - /* undefined uVar1; - undefined uVar2; +unk8 MapManager::func_ov00_02086044(Vec3p *param_2, Vec3p *param_3, unk32 param_4) { + unk32 uVar1; + unk32 uVar2; int iVar3; int iVar4; int iVar5; @@ -2743,9 +2746,8 @@ unk8 MapManager::func_ov00_02086044(unk32 param_2, unk32 param_3, unk32 param_4) int *piVar9; Vec3p *pVVar10; int iVar11; - undefined local_c6; - undefined local_c5; - undefined auStack_c4[4]; + Vec2b local_c6; + unk32 auStack_c4[4]; Vec3p iStack_c0; Vec3p local_b0; Vec3p local_a0; @@ -2766,12 +2768,12 @@ unk8 MapManager::func_ov00_02086044(unk32 param_2, unk32 param_3, unk32 param_4) local_88.x = param_2->x; local_88.y = param_2->y; local_88.z = param_2->z; - FUN_overlay_d_0__0208ed74(&local_40, &local_88); - AABB::Grow(&local_40, param_4); - iVar3 = FUN_overlay_d_0__020839d4(param_1, local_40.min.x); - iVar4 = FUN_overlay_d_0__020839f8(param_1, local_40.min.z); - iVar5 = FUN_overlay_d_0__020839d4(param_1, local_40.max.x); - iVar6 = FUN_overlay_d_0__020839f8(param_1, local_40.max.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; @@ -2782,10 +2784,10 @@ unk8 MapManager::func_ov00_02086044(unk32 param_2, unk32 param_3, unk32 param_4) 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 = FUN_overlay_d_0__020839d4(param_1, param_3->x); - uVar2 = FUN_overlay_d_0__020839f8(param_1, param_3->z); - iVar7 = FUN_overlay_d_0__02083e34(param_1, uVar1, uVar2, pVVar10); + 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; @@ -2793,25 +2795,25 @@ unk8 MapManager::func_ov00_02086044(unk32 param_2, unk32 param_3, unk32 param_4) if (iVar4 <= iVar6) { iVar11 = iVar4; do { - iVar8 = FUN_overlay_d_0__02083e34(param_1, (char) iVar3, (char) iVar11, pVVar10); + // iVar8 = this->func_ov00_02083e34((char) iVar3, (char) iVar11, pVVar10); if (iVar7 < iVar8) { - local_c6 = (char) iVar3; - local_c5 = (char) iVar11; - FUN_overlay_d_0__02084024(*(MapManager **) PTR_gMapManager_overlay_d_0__02086280, &local_c6, &AStack_70); - Vec3p::Sub(param_2, param_3, &VStack_7c); + local_c6.x = (char) iVar3; + local_c6.y = (char) iVar11; + gMapManager->func_ov00_02084024(&local_c6, &AStack_70); + Vec3p_Sub(param_2, param_3, &VStack_7c); pVVar10 = (Vec3p *) auStack_c4; - iVar8 = FUN_overlay_d_0__0208e87c(&AStack_70, &local_b0, &VStack_7c); + iVar8 = func_ov000_0208e87c(&AStack_70, &local_b0, &VStack_7c); if (iVar8 != 0) { return 1; } } - piVar9 = (int *) MapData_vfunc_78(param_1); - if ((piVar9 != (int *) 0x0) && (iVar8 = (**(code **) (*piVar9 + 0x58))(), iVar8 != 0)) { + piVar9 = (int *) this->MapData_vfunc_78(); + 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 = FUN_overlay_d_0__0208b804(piVar9, &iStack_c0, &VStack_58); + iVar8 = func_ov000_0208b804(piVar9, &iStack_c0, &VStack_58); if (iVar8 != 0) { return 1; } @@ -2820,7 +2822,7 @@ unk8 MapManager::func_ov00_02086044(unk32 param_2, unk32 param_3, unk32 param_4) } while (iVar11 <= iVar6); } iVar3 = iVar3 + 1; - } while (true); */ + } while (true); } bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4, s32 param_5, u16 param_6, Vec3p *param_7, -- cgit v1.2.3 From 0060b2faac9475c744de44d38cf8ba72f83058d0 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Tue, 21 Jan 2025 13:31:12 +0100 Subject: Decomp progress 27% --- src/00_Core/Map/MapManager.cpp | 536 +++++++++++++++++++++-------------------- 1 file changed, 273 insertions(+), 263 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 4e4621c9..3d5faa7e 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -4,15 +4,26 @@ #include "Player/PlayerBase.hpp" #include "Save/AdventureFlags.hpp" +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_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); @@ -23,12 +34,14 @@ extern void func_ov000_02096324(s32 *param_1, s32 param_2); extern s32 *func_ov000_02096418(s32 *param_1); extern void func_ov000_0209d6e8(s32 param_1, s32 param_2); extern unk32 func_ov000_020a5e9c(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_02105578(ActorManager *param_1, u32 param_2); extern void func_ov004_02105608(ActorManager *param_1, unk32 param_2, unk32 param_3, unk32 param_4); + 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); @@ -651,7 +664,7 @@ ARM void MapManager::func_ov00_0208306c(s32 *param_2, s32 *param_3) { local_1c.y = gPlayerPos->y; local_1c.x = gPlayerPos->x; local_1c.z = gPlayerPos->z; - this->func_ov00_02083a1c((s32 *) auStack_2c, this, &local_1c); + // this->func_ov00_02083a1c(auStack_2c, this, &local_1c); this->func_ov00_02082d84(auStack_2c, param_2, param_3); } @@ -1071,9 +1084,9 @@ ARM s32 MapManager::func_ov00_020839f8(s32 param_2) { return this->mMap->GetClampedTileY(param_2 - this->GetMapCenterZ()); } -ARM void MapManager::func_ov00_02083a1c(s32 *param_1, MapManager *param_2, Vec3p *param_3) { - *param_1 = param_2->func_ov00_020839f8(param_3->z); - param_1[1] = param_2->func_ov00_020839d4(param_3->x); +ARM void MapManager::func_ov00_02083a1c(Vec2b *param_1, MapManager *param_2, Vec3p *param_3) { + param_1->x /*or y?*/ = param_2->func_ov00_020839f8(param_3->z); + param_1->y /*or x?*/ = param_2->func_ov00_020839d4(param_3->x); } ARM void MapManager::func_ov00_02083a54(u8 *param_1, MapManager *param_2, s32 *param_3, s32 param_4, s32 *param_5) { @@ -1960,10 +1973,10 @@ 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) { - /* undefined *object; - undefined *dtor; - undefined *obj; - dword a; + unk32 *object; // undefined type + unk32 *dtor; // undefined type + unk32 *obj; // undefined type + unk32 a; // dword int iVar1; int aiStack_3c[4]; Vec3p VStack_2c; @@ -1972,60 +1985,59 @@ s32 MapManager::func_ov00_02084d4c(unk32 param_2, unk32 param_3, Vec3p *param_4) int iStack_18; Vec3p VStack_14; - iVar1 = FUN_overlay_d_0__0208df78(*(undefined4 *) (*(int *) PTR_DWORD_overlay_d_0__02084ea0 + 4), param_2, param_3, - &VStack_14, &iStack_20); - object = PTR_DWORD_overlay_d_0__020e2510_overlay_d_0__02084ea8; + 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 ((*(uint *) (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; - *(undefined4 *) PTR_DWORD_overlay_d_0__020e2510_overlay_d_0__02084ea8 = 0; - *(undefined4 *) (object + 4) = 0x1000; - *(undefined4 *) (object + 8) = 0; + /*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; - *(undefined4 *) (PTR_PTR_s_anc_overlay_d_0__020e24a0_overlay_d_0__020e24a4_overlay_d_0__02084eac + 0x78) = 0; + *(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); - *(uint *) (PTR_DestructorChain_overlay_d_0_bss__020ec964_overlay_d_0__02084ea4 + 0x60) = - *(uint *) (PTR_DestructorChain_overlay_d_0_bss__020ec964_overlay_d_0__02084ea4 + 0x60) | 1; - } + *(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 = FUN_01ffe61c(PTR_DWORD_overlay_d_0__020e2510_overlay_d_0__02084ea8, &VStack_14, &VStack_2c, aiStack_3c); + 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 = DWORD_overlay_d_0__02084eb8; + 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); + Vec3p_Axpy(a, &VStack_2c, param_4, param_4); return 1; } return 0; } - return -1; */ + return -1; } -unk8 MapManager::func_ov00_02084ebc(unk32 param_2) { - /* int *piVar1; +unk32 MapManager::func_ov00_02084ebc(Vec3p *param_2) { + int *piVar1; int iVar2; - dword dVar3; - undefined auStack_18[4]; - uint uStack_14; + unk32 dVar3; // dword + Vec2b auStack_18[4]; // undefined type + u32 uStack_14; - FUN_overlay_d_0__02083a1c(auStack_18, param_1, param_2); - piVar1 = (int *) MapData_vfunc_78(param_1); + this->func_ov00_02083a1c(auStack_18, this, param_2); + piVar1 = (int *) this->MapData_vfunc_78(); if (piVar1 != (int *) 0x0) { - iVar2 = (**(code **) (*piVar1 + 0x1c))(); + // iVar2 = (**(code **) (*piVar1 + 0x1c))(); if (iVar2 < 0x39) { if ((iVar2 < 0x38) && (iVar2 != 1)) { return 0; @@ -2043,11 +2055,11 @@ unk8 MapManager::func_ov00_02084ebc(unk32 param_2) { } } } - iVar2 = FUN_overlay_d_0__02083e70(param_1, auStack_18); + iVar2 = this->func_ov00_02083e70(/*auStack_18*/); if (iVar2 != 0) { return 0; } - iVar2 = MapData_vfunc_54(param_1); + iVar2 = this->MapData_vfunc_54(); if (iVar2 < 0x47) { if (0x45 < iVar2) { return 0; @@ -2110,62 +2122,62 @@ unk8 MapManager::func_ov00_02084ebc(unk32 param_2) { } else if (iVar2 == 0x50) { return 0; } - iVar2 = (**(code **) (param_1->mMap->vtable + 0x58))(param_1->mMap, auStack_18, 5); + iVar2 = this->mMap->vfunc_58(/*auStack_18, 5*/); if (iVar2 != 0) { return 0; } - dVar3 = MapData_vfunc_70(param_1); - if (dVar3 != DWORD_overlay_d_0__02085100) { - FUN_overlay_d_0__02093a1c(&uStack_14, *(undefined4 *) PTR_DWORD_overlay_d_0__02085104); + // dVar3 = this->MapData_vfunc_70(); // Missing param. + if (dVar3 != 0xffff) { + func_ov000_02093a1c(&uStack_14, data_027e0f6c); if ((uStack_14 >> 5 & 3) != 1) { return 0; } return 1; } - return 0; */ + return 0; } s32 MapManager::func_ov00_02085108(s32 *param_2) { - /* undefined *puVar1; - undefined4 uVar2; + MapManager *puVar1; + unk32 uVar2; int *piVar3; int iVar4; - uint uVar5; + u32 uVar5; int iVar6; int iVar7; int iVar8; - uint local_44; - byte local_3a; - byte local_39; - byte local_38; - byte local_37; + u32 local_44; + u8 local_3a; + u8 local_39; + u8 local_38; + u8 local_37; int local_34; int local_30; int local_2c; - undefined4 local_28; + unk32 local_28; - uVar2 = FUN_overlay_d_0__0208b180(*(undefined4 *) PTR_DWORD_overlay_d_0__02085274); - FUN_overlay_d_0__02088130(&local_38, uVar2); - local_44 = (uint) local_38; - uVar2 = FUN_overlay_d_0__0208b180(*(undefined4 *) PTR_DWORD_overlay_d_0__02085274); - FUN_overlay_d_0__02088144(&local_3a, uVar2); + 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 = PTR_gMapManager_overlay_d_0__02085278; - uVar5 = (uint) local_39; - if ((uint) local_3a <= (uint) local_39) { + puVar1 = gMapManager; + uVar5 = (u32) local_39; + if ((u32) local_3a <= (u32) local_39) { do { - piVar3 = (int *) MapData_vfunc_78(*(MapManager **) puVar1); + 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))(); + 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 = FUN_0202b8e4(&local_34, 2); + // iVar4 = func_0202b8e4(&local_34, 2); if (iVar4 != 0) { *param_2 = piVar3[6]; param_2[1] = piVar3[7]; @@ -2174,46 +2186,46 @@ s32 MapManager::func_ov00_02085108(s32 *param_2) { } } uVar5 = uVar5 - 1; - } while ((int) (uint) local_3a <= (int) uVar5); + } while ((int) (u32) local_3a <= (int) uVar5); } local_44 = local_44 + 1; - } while ((int) local_44 <= (int) (uint) local_37); + } while ((int) local_44 <= (int) (u32) local_37); } - return 0; */ + return 0; } -unk8 MapManager::func_ov00_0208527c() { - /* uint uVar1; - undefined *puVar2; - undefined4 uVar3; +s32 MapManager::func_ov00_0208527c(MapManager *param_1, unk32 param_2, unk32 *param_3) { + u32 uVar1; + MapManager *puVar2; + unk32 uVar3; int iVar4; int iVar5; - uint uVar6; - uint uVar7; - uint local_4c; - byte local_3e; - byte local_3d; - byte local_3c; - byte local_3b; - undefined4 local_38; - undefined4 local_34; - undefined4 local_30; - undefined4 local_2c; - - uVar3 = FUN_overlay_d_0__0208b180(*(undefined4 *) PTR_DWORD_overlay_d_0__020853f4); - FUN_overlay_d_0__02088130(&local_3c, uVar3); - uVar7 = (uint) local_3c; - uVar3 = FUN_overlay_d_0__0208b180(*(undefined4 *) PTR_DWORD_overlay_d_0__020853f4); - FUN_overlay_d_0__02088144(&local_3e, uVar3); - local_4c = (uint) local_3e; - uVar6 = (uint) local_3d; - iVar4 = Get_MapData_Unk28(param_1); - iVar5 = Get_MapData_Unk2a(param_1); - puVar2 = PTR_gMapManager_overlay_d_0__020853f8; + 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) (uint) local_3b) { + if (iVar4 <= (int) (u32) local_3b) { uVar7 = iVar4 - 1; } if (local_4c == 0) { @@ -2228,59 +2240,59 @@ unk8 MapManager::func_ov00_0208527c() { local_30 = 0; do { uVar1 = local_4c; - if ((int) (uint) local_3b < (int) uVar7) { + if ((int) (u32) local_3b < (int) uVar7) { return 0; } for (; (int) uVar1 <= (int) uVar6; uVar1 = uVar1 + 1) { - iVar4 = MapData_vfunc_78(*(MapManager **) puVar2); - if (((iVar4 != 0) && ((*(uint *) (iVar4 + 4) & 4) != 0)) && - (iVar5 = FUN_overlay_d_0__0208b73c(iVar4, param_2), iVar5 != 0)) + iVar4 = puVar2->MapData_vfunc_78(); + if (((iVar4 != 0) && ((*(u32 *) (iVar4 + 4) & 4) != 0)) && + (iVar5 = func_ov000_0208b73c(iVar4, param_2), iVar5 != 0)) { - *param_3 = *(undefined4 *) (iVar4 + 0x18); - param_3[1] = *(undefined4 *) (iVar4 + 0x1c); - param_3[2] = *(undefined4 *) (iVar4 + 0x20); + *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); */ + } while (true); } -unk8 MapManager::func_ov00_020853fc() { - /* uint uVar1; - undefined4 uVar2; +s32 MapManager::func_ov00_020853fc(MapManager *param_1, Vec3p *param_2, s32 *param_3) { + u32 uVar1; + unk32 uVar2; int iVar3; int iVar4; int iVar5; - uint uVar6; + u32 uVar6; int iVar7; - uint local_50; - uint local_48; - byte local_3e; - byte local_3d; - byte local_3c; - byte local_3b; - undefined4 local_38; - undefined4 local_34; - undefined4 local_30; - undefined4 local_2c; - - uVar2 = FUN_overlay_d_0__0208b180(*(undefined4 *) PTR_DWORD_overlay_d_0__0208558c); - FUN_overlay_d_0__02088130(&local_3c, uVar2); - local_48 = (uint) local_3c; - uVar2 = FUN_overlay_d_0__0208b180(*(undefined4 *) PTR_DWORD_overlay_d_0__0208558c); - FUN_overlay_d_0__02088144(&local_3e, uVar2); - local_50 = (uint) local_3e; - uVar6 = (uint) local_3d; - iVar3 = Get_MapData_Unk28(param_1); - iVar4 = Get_MapData_Unk2a(param_1); + 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) (uint) local_3b) { + if (iVar3 <= (int) (u32) local_3b) { local_48 = iVar3 - 1; } local_34 = 0; @@ -2291,41 +2303,40 @@ unk8 MapManager::func_ov00_020853fc() { uVar6 = iVar4 - 1; } local_30 = 0; - for (; uVar1 = local_50, (int) local_48 <= (int) (uint) local_3b; local_48 = local_48 + 1) { + 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 = MapData_vfunc_78(*(MapManager **) PTR_gMapManager_overlay_d_0__02085590); - if ((((iVar3 != 0) && ((*(uint *) (iVar3 + 4) & 4) != 0)) && - (iVar4 = Vec3p::Distance((Vec3p *) (iVar3 + 0x18), param_2), iVar4 < *param_3)) && - (iVar5 = FUN_overlay_d_0__0208b7d0(iVar3, param_2), iVar5 != 0)) + iVar3 = gMapManager->MapData_vfunc_78(); + 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; */ + return iVar7; } -unk8 MapManager::func_ov00_02085594() { - /* int *piVar1; +unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 param_3, unk32 param_4) { + int *piVar1; int iVar2; - dword dVar3; - undefined4 uVar4; + unk32 dVar3; // dword + unk32 uVar4; bool bVar5; - undefined4 uStack_2c; - undefined local_28; - undefined local_27; - uint uStack_24; + unk32 uStack_2c; + Vec2b local_28; + u32 uStack_24; Vec3p VStack_20; - FUN_overlay_d_0__02083a1c(&local_28, param_1, param_2); - piVar1 = (int *) MapData_vfunc_78(param_1); + param_1->func_ov00_02083a1c(&local_28, param_1, param_2); + piVar1 = (int *) param_1->MapData_vfunc_78(); 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))(); + // iVar2 = (**(code **) (*piVar1 + 0x1c))(); if (iVar2 < 0x43) { if (0x41 < iVar2) { return 2; @@ -2351,7 +2362,7 @@ unk8 MapManager::func_ov00_02085594() { } } } - iVar2 = FUN_overlay_d_0__020840a0(param_1, local_28, local_27, param_4); + iVar2 = param_1->func_ov00_020840a0(local_28.x, local_28.y, param_4); if (iVar2 < 0x47) { if (0x45 < iVar2) { return 0; @@ -2414,15 +2425,15 @@ unk8 MapManager::func_ov00_02085594() { } else if (iVar2 == 0x50) { return 0; } - iVar2 = (**(code **) (param_1->mMap->vtable + 0x58))(param_1->mMap, &local_28, 5); + iVar2 = param_1->mMap->vfunc_58(/*&local_28, 5*/); // no params if (iVar2 != 0) { return 0; } - uStack_2c._0_2_ = CONCAT11(local_27, local_28); - FUN_overlay_d_0__02083c7c(param_1, &VStack_20, uStack_2c); - dVar3 = MapData_vfunc_70(param_1); - if (dVar3 != DWORD_overlay_d_0__02085834) { - FUN_overlay_d_0__02093a1c(&uStack_24, *(undefined4 *) PTR_DWORD_overlay_d_0__02085838); + // uStack_2c._0_2_ = CONCAT11(local_27, local_28); + param_1->func_ov00_02083c7c(&VStack_20, uStack_2c); + // dVar3 = param_1->MapData_vfunc_70(); + if (dVar3 != 0xffff) { + func_ov000_02093a1c(&uStack_24, data_027e0f6c); if ((uStack_24 >> 5 & 3) != 1) { return 0; } @@ -2433,7 +2444,7 @@ unk8 MapManager::func_ov00_02085594() { } return uVar4; } - return 0; */ + return 0; } void MapManager::func_ov00_0208583c(MapManager *param_1, Vec3p *param_2, unk32 param_3) { @@ -2454,95 +2465,94 @@ void MapManager::func_ov00_0208583c(MapManager *param_1, Vec3p *param_2, unk32 p //} } -unk8 MapManager::func_ov00_020858b0() { - /* int iVar1; +unk8 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; - undefined4 local_38; - byte local_28; - byte local_27; + unk32 local_38; + Vec2b local_28; // x = originally 'local_28' ; y = originally 'local_27' if (param_3 == 1) { - FUN_overlay_d_0__02088000(*(undefined4 *) (*(int *) PTR_DWORD_overlay_d_0__02085a2c + 4), 7); + func_ov000_02088000(*(unk32 *) (*(int *) data_027e0f64 + 4), 7); } else { - FUN_overlay_d_0__02088000(*(undefined4 *) (*(int *) PTR_DWORD_overlay_d_0__02085a2c + 4), 6); + func_ov000_02088000(*(unk32 *) (*(int *) data_027e0f64 + 4), 6); } - iVar2 = Get_MapData_Unk28(param_1); - iVar3 = Get_MapData_Unk2a(param_1); + iVar2 = param_1->GetMapWidth(); + iVar3 = param_1->GetMapHeight(); local_38 = 0xffffffff; - FUN_overlay_d_0__02083a1c(&local_28, param_1, param_2); - iVar6 = *(int *) (PTR_gPlayerPos_overlay_d_0__02085a30 + 4); - for (iVar7 = local_28 - 1; iVar7 <= (int) (local_28 + 1); iVar7 = iVar7 + 1) { - if ((-1 < iVar7) && (iVar1 = local_27 - 1, iVar7 < iVar2)) { - for (; iVar1 <= (int) (local_27 + 1); iVar1 = iVar1 + 1) { + 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 = MapData_vfunc_60(param_1); + iVar4 = param_1->MapData_vfunc_60(); iVar4 = iVar4 - iVar6; if (iVar4 < 0) { iVar4 = -iVar4; } - if ((iVar4 < 0xce) && (piVar5 = (int *) MapData_vfunc_78(param_1), piVar5 != (int *) 0x0)) { - local_38 = (**(code **) (*piVar5 + 0x38))(piVar5, param_3); + if ((iVar4 < 0xce) && (piVar5 = (int *) param_1->MapData_vfunc_78(), piVar5 != (int *) 0x0)) { + // local_38 = (**(code **) (*piVar5 + 0x38))(piVar5, param_3); } } } } } - return local_38; */ + return local_38; } -s32 MapManager::func_ov00_02085a34(unk32 param_2, unk32 param_3) { - /* int *piVar1; +s32 MapManager::func_ov00_02085a34(Vec3p *param_2, s32 param_3) { + int *piVar1; int iVar2; - undefined2 *puVar3; - uint uVar4; - uint uVar5; - uint uVar6; - undefined uStack_2c; - undefined uStack_2b; - undefined auStack_2a[2]; + unk16 *puVar3; + u32 uVar4; + u32 uVar5; + u32 uVar6; + unk32 uStack_2c; + unk32 uStack_2b; + Vec2b auStack_2a[2]; Vec2b aVStack_28[2]; - undefined2 auStack_24[4]; - undefined auStack_1c[4]; - undefined4 uStack_18; - undefined2 uStack_14; - undefined uStack_12; + 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; } - FUN_overlay_d_0__02083a1c(auStack_2a, param_1, param_2); - piVar1 = (int *) MapData_vfunc_78(param_1); + this->func_ov00_02083a1c(auStack_2a, this, param_2); + piVar1 = (int *) this->MapData_vfunc_78(); if (piVar1 == (int *) 0x0) { return -1; } - iVar2 = (**(code **) (*piVar1 + 0x1c))(); + // iVar2 = (**(code **) (*piVar1 + 0x1c))(); if (iVar2 == 0x42) { - uStack_2b = *(undefined *) ((int) piVar1 + 0x15); - uStack_2c = *(undefined *) (piVar1 + 5); - MapBase::FUN_overlay_d_0__02080d08(param_1->mMap, &uStack_2c); + // 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); + // iVar2 = (**(code **) (*piVar1 + 0x3c))(piVar1, param_3); return iVar2; } - FUN_overlay_d_0__02083a1c(aVStack_28, param_1, param_2); - iVar2 = FUN_overlay_d_0__02084ebc(param_1, param_2); + this->func_ov00_02083a1c(aVStack_28, this, param_2); + iVar2 = this->func_ov00_02084ebc(param_2); if (iVar2 == 0) { return -1; } - piVar1 = (int *) MapData_vfunc_78(param_1); + piVar1 = (int *) this->MapData_vfunc_78(); if (piVar1 != (int *) 0x0) { - iVar2 = (**(code **) (*piVar1 + 0x1c))(); + // iVar2 = (**(code **) (*piVar1 + 0x1c))(); if (0x38 < iVar2) { if (iVar2 < 0x5a) { if (iVar2 == 0x59) { LAB_overlay_d_0__02085afc: - iVar2 = (**(code **) (*piVar1 + 0x3c))(piVar1, 1); + // iVar2 = (**(code **) (*piVar1 + 0x3c))(piVar1, 1); // What is this? return iVar2; } } else if (iVar2 == 0x61) @@ -2553,9 +2563,9 @@ s32 MapManager::func_ov00_02085a34(unk32 param_2, unk32 param_3) { return -1; } piVar1[1] = piVar1[1] & 0xfffffffe; - FUN_overlay_d_0__020828f8(param_1, piVar1); + this->func_ov00_020828f8(piVar1); } - MapBase::FUN_overlay_d_0__02080b24(param_1->mMap, aVStack_28); + this->mMap->func_ov00_02080b24(aVStack_28); uStack_14 = 0xffff; uStack_18 = 0; uStack_12 = 1; @@ -2568,30 +2578,30 @@ s32 MapManager::func_ov00_02085a34(unk32 param_2, unk32 param_3) { uVar4 = uVar5; } while (uVar5 < 4); do { - *(undefined *) (puVar3 + 4) = 0; - uVar6 = uVar6 + 1; - *(undefined *) (puVar3 + 5) = 0; - puVar3 = (undefined2 *) ((int) puVar3 + 1); + *(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 = Map_vfunc_7c(param_1); + // iVar2 = this->MapData_vfunc_7c(); <- This needs to return some value (not void). if (iVar2 == 0) { return -1; } - iVar2 = MapData_vfunc_78(param_1); - if ((iVar2 != 0) && (0 < *(short *) (iVar2 + 0xe))) { + iVar2 = MapData_vfunc_78(); // Same here. + if ((iVar2 != 0) && (0 < *(s16 *) (iVar2 + 0xe))) { return 1; } - return 0; */ + return 0; } -unk8 MapManager::func_ov00_02085c60(unk32 param_2, unk32 param_3, unk32 param_4, unk32 param_5) { - /* longlong lVar1; - undefined *puVar2; - dword dVar3; +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; - uint uVar7; + u32 uVar7; int iStack_10c; int iStack_108; int iStack_104; @@ -2605,29 +2615,29 @@ unk8 MapManager::func_ov00_02085c60(unk32 param_2, unk32 param_3, unk32 param_4, Vec3p VStack_a4; Vec3p VStack_98; Vec3p aVStack_8c[3]; - undefined2 uStack_68; - undefined2 uStack_66; - undefined2 uStack_64; - undefined2 uStack_62; - undefined2 uStack_60; - undefined uStack_3e; - undefined uStack_3d; - undefined uStack_3c; - undefined uStack_3b; - undefined uStack_34; - undefined uStack_33; - undefined uStack_32; - undefined uStack_31; - undefined uStack_30; - undefined uStack_2f; - undefined4 uStack_2c; - undefined4 uStack_28; + 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; } - FUN_overlay_d_0__020792a0(*(undefined4 *) PTR_DWORD_overlay_d_0__0208603c, 0, *param_3, param_3[1]); - FUN_overlay_d_0__020792a0(*(undefined4 *) PTR_DWORD_overlay_d_0__0208603c, 0, *param_4, param_4[1]); + 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; @@ -2637,17 +2647,17 @@ unk8 MapManager::func_ov00_02085c60(unk32 param_2, unk32 param_3, unk32 param_4, 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 = (ulonglong) param_5 * 0xc000 + 0x800; - uVar7 = (uint) lVar1 >> 0xc | (int) ((ulonglong) lVar1 >> 0x20) * 0x100000; - iVar6 = Vec3p::Length(&VStack_c8); + 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); + 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); + 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; @@ -2655,25 +2665,25 @@ unk8 MapManager::func_ov00_02085c60(unk32 param_2, unk32 param_3, unk32 param_4, 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); + Vec3p_Sub(&VStack_c8, &VStack_a4, &VStack_c8); uVar7 = param_5 * 0x800 + 0x800 >> 0xc | - ((((int) param_5 >> 0x1f) << 0xb | param_5 >> 0x15) + (uint) (0xfffff7ff < param_5 * 0x800)) * 0x100000; - iVar6 = Vec3p::Length(&VStack_c8); + ((((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); + 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); + Vec3p_Add(&VStack_b0, &VStack_c8, &VStack_b0); } - bVar5 = false; - VStack_d8.xyz.y = param_5 << 1; - VStack_d8.xyz.x = 0; - VStack_d8.xyz.z = 0; - VStack_d8.w = param_5; + bVar5 = false; + VStack_d8.y = param_5 << 1; + VStack_d8.x = 0; + VStack_d8.z = 0; + VStack_d8.w = param_5; do { - bVar4 = FUN_01ffbe78(param_1, param_2, &VStack_b0, &VStack_bc, &VStack_d8); + 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; @@ -2681,14 +2691,14 @@ unk8 MapManager::func_ov00_02085c60(unk32 param_2, unk32 param_3, unk32 param_4, 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 = DWORD_overlay_d_0__02086040; + 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 = (undefined2) dVar3; + uStack_68 = (u16) dVar3; uStack_60 = 0; uStack_3e = 0; uStack_3d = 0; @@ -2705,13 +2715,13 @@ unk8 MapManager::func_ov00_02085c60(unk32 param_2, unk32 param_3, unk32 param_4, uStack_66 = uStack_68; uStack_64 = uStack_68; uStack_62 = uStack_68; - bVar5 = FUN_01ffbe78(param_1, aVStack_8c, &VStack_e4, &VStack_e4, &VStack_d8); + 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; } - FUN_overlay_d_0__0207920c(*(undefined4 *) PTR_DWORD_overlay_d_0__0208603c, &VStack_e4, &iStack_104, 0); + func_ov000_0207920c(data_027e0d3c, &VStack_e4, &iStack_104, 0); param_2[8].x = iStack_104; param_2[8].y = iStack_100; return 1; @@ -2719,8 +2729,8 @@ unk8 MapManager::func_ov00_02085c60(unk32 param_2, unk32 param_3, unk32 param_4, VStack_bc.x = VStack_b0.x; VStack_bc.y = VStack_b0.y; VStack_bc.z = VStack_b0.z; - iVar6 = FUN_0202b2e8(&VStack_b0, &VStack_98, uVar7); - puVar2 = PTR_DWORD_overlay_d_0__0208603c; + // iVar6 = func_0202b2e8(&VStack_b0, &VStack_98, uVar7); + puVar2 = data_027e0d3c; if (iVar6 != 0) { bVar5 = true; } @@ -2728,10 +2738,10 @@ unk8 MapManager::func_ov00_02085c60(unk32 param_2, unk32 param_3, unk32 param_4, param_2->x = VStack_98.x; param_2->y = VStack_98.y; param_2->z = VStack_98.z; - FUN_overlay_d_0__0207920c(*(undefined4 *) puVar2, &VStack_98, &iStack_10c, 0); + func_ov000_0207920c(puVar2, &VStack_98, &iStack_10c, 0); param_2[8].x = iStack_10c; param_2[8].y = iStack_108; - return 0; */ + return 0; } unk8 MapManager::func_ov00_02086044(Vec3p *param_2, Vec3p *param_3, unk32 param_4) { -- cgit v1.2.3 From a4d82cfa6fe4ef394123bd96331f353b7fc6f9c4 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Thu, 23 Jan 2025 21:09:13 +0100 Subject: Decomp progress 28% --- src/00_Core/Map/MapManager.cpp | 90 +++++++++++++++++++++--------------------- 1 file changed, 45 insertions(+), 45 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 3d5faa7e..6dff6ace 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -1161,10 +1161,10 @@ ARM s32 MapManager::func_ov00_02083c50(unk32 z) { } ARM void MapManager::func_ov00_02083c7c(Vec3p *param_2, u32 param_3) { - Vec3p local_28; // Unused. So why, ghidra? Why? Tell me why. + Vec3p local_28; param_2->x = this->func_ov00_02083c24(param_3 & 0xff); param_2->z = this->func_ov00_02083c50(param_3 >> 8 & 0xff); - param_2->y = this->MapData_vfunc_68(); + param_2->y = this->MapData_vfunc_68(&local_28, 0); // please tell me this is correct } ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 param_3, s32 param_4, u32 param_5) { @@ -1203,29 +1203,29 @@ ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 p param_2[2] = iVar2 + 0x800; } } - iVar2 = param_1->MapData_vfunc_68(); + iVar2 = param_1->MapData_vfunc_68(&local_2c, 0); // I really do hope this is right param_2[1] = iVar2; } ARM void MapManager::func_ov00_02083e34(unk8 param_2, unk8 param_3, unk32 param_4) { - unk8 local_8; + unk8 local_8; // Should this be a bool or a Vec2p or a Vec3p? unk8 local_7; // Unused. unk16 uStack_6; uStack_6 = (unk16) ((u32) param_4 >> 0x10); // _local_8 = CONCAT11(param_3, param_2); What is this? - this->mMap->vfunc_60(/*&local_8*/); // Doesn't take any params, so why? + this->mMap->vfunc_60(&local_8); } -ARM unk32 MapManager::MapData_vfunc_60() { - return this->mMap->vfunc_60(); +ARM unk32 MapManager::MapData_vfunc_60(unk8 *param_1) { // should the param be bool*? + return this->mMap->vfunc_60(param_1); } ARM bool MapManager::func_ov00_02083e70() { int iVar1; int iVar2; - iVar1 = this->MapData_vfunc_54(); + iVar1 = this->MapData_vfunc_54(0); if (iVar1 < 0x2c) { if ((0x2a < iVar1) || (iVar1 == 0x1b)) { return true; @@ -1233,13 +1233,13 @@ ARM bool MapManager::func_ov00_02083e70() { } else if (((iVar1 < 0x50) && (0x4d < iVar1)) && (iVar1 == 0x4e || iVar1 == 0x4f)) { return true; } - iVar1 = this->MapData_vfunc_60(); + iVar1 = this->MapData_vfunc_60(0); iVar2 = this->GetMapData_Unk_48(); return iVar2 <= iVar1; } -ARM unk8 MapManager::MapData_vfunc_68() { - return this->mMap->vfunc_68(); +ARM unk32 MapManager::MapData_vfunc_68(Vec3p *param_1, bool *param_2) { // not sure about the bool* here. + return this->mMap->vfunc_68(param_1, param_2); } ARM s32 MapManager::func_ov00_02083ef8(Vec3p *param_2, Vec3p *param_3) { @@ -1252,7 +1252,7 @@ ARM s32 MapManager::func_ov00_02083ef8(Vec3p *param_2, Vec3p *param_3) { if (param_2->y < param_3->y) { local_18.y = param_3->y; } - iVar1 = this->mMap->vfunc_68(/*&local_18*/); // takes no args. + iVar1 = this->mMap->vfunc_68(&local_18, 0); // takes no args. return iVar1; } @@ -1305,8 +1305,8 @@ void MapManager::func_ov00_02084024(Vec2b *param_2, AABB *param_3) { Vec3p_Add(¶m_3->max, &local_20, ¶m_3->max); } -unk8 MapManager::MapData_vfunc_54() { - this->mMap->vfunc_54(); +unk32 MapManager::MapData_vfunc_54(unk8 *param_1) { // what type is this param? + return this->mMap->vfunc_54(param_1); } unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) { @@ -1316,18 +1316,18 @@ unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) { uStack_6 = (unk16) ((u32) param_4 >> 0x10); // _local_8 = CONCAT11(param_3, param_2); - this->MapData_vfunc_54(/*&local_8*/); // Doesn't take any params. + this->MapData_vfunc_54(&local_8); // Doesn't take any params. // No calls to functions according to objdiff, why??? } -unk8 MapManager::MapData_vfunc_78() { - this->mMap->vfunc_78(); +unk32 MapManager::MapData_vfunc_78(bool *param_1) { // bool* param placeholder for now, no way of knowing what the type is. + return this->mMap->vfunc_78(param_1); } unk8 MapManager::func_ov00_020840dc() { int *piVar1; - piVar1 = (int *) this->MapData_vfunc_78(); + piVar1 = (int *) this->MapData_vfunc_78(0); if (piVar1 != (int *) 0x0) { // (**(code **) (*piVar1 + 0x1c))(); // MapBase::func_ov00_0207f934() ?? } @@ -1355,17 +1355,17 @@ void MapManager::func_ov00_0208413c(unk32 param_2) { this->mMap->func_ov00_0207f948(param_2); } -unk8 MapManager::MapData_vfunc_58() { - this->mMap->vfunc_58(); +unk8 MapManager::MapData_vfunc_58(Vec2b *param_1, int param_2) { + this->mMap->vfunc_58(param_1, param_2); } -unk8 MapManager::func_ov00_02084164() { +unk8 MapManager::func_ov00_02084164(Vec2b *param_2) { int iVar1; unk32 uVar2; - iVar1 = this->mMap->vfunc_58(/*param_2, 7, pcVar3, param_4*/); // Params? + iVar1 = this->mMap->vfunc_58(param_2, 7 /*, pcVar3, param_4*/); // Params? if (iVar1 == 0) { - uVar2 = this->MapData_vfunc_54(); + uVar2 = this->MapData_vfunc_54(0); switch (uVar2) { case 0: break; case 1: return 0; @@ -1467,8 +1467,8 @@ u8 MapManager::GetMapData_Unk_0b() { return this->mMap->mUnk_00b; } -unk8 MapManager::MapData_vfunc_a4() { - this->mMap->vfunc_a4(); +unk8 MapManager::MapData_vfunc_a4(unk8 *param_1) { + this->mMap->vfunc_a4(param_1); } unk8 MapManager::func_ov00_0208433c(Vec3p *param_2, Vec3p *param_3) { @@ -1493,7 +1493,7 @@ unk8 MapManager::func_ov00_0208439c(Vec2s *param_2, Vec3p *param_3) { 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(); + iVar1 = this->MapData_vfunc_68(param_3, 0); // is this correct? param_3->y = iVar1; } @@ -1617,7 +1617,7 @@ unk8 MapManager::func_ov00_020846a4() { return iVar1; } -unk8 MapManager::func_ov00_02084700(s32 *param_1) { +unk8 MapManager::func_ov00_02084700(s32 *param_1) { // param_1 perhaps Vec2b ? int iVar1; iVar1 = *(int *) (param_1[1] + 0x34); @@ -1827,10 +1827,10 @@ bool MapManager::func_ov00_02084ac4(u32 actorId) { bool bVar1; iVar1 = gActorManager->FindActorById(actorId); - if (iVar1 == (Actor *) 0x0) { + if (iVar1 == NULL) { return false; } - bVar1 = (char *) iVar1->mType == "CIVE"; // s_CIVE_overlay_d_0__02084b04 + bVar1 = iVar1->mType == ActorTypeId_EVIC; if (bVar1) { iVar1->mAlive = false; } @@ -1878,7 +1878,7 @@ LAB_overlay_d_0__02084b60: return; } -bool MapManager::func_ov00_02084be0(unk32 param_2, unk32 param_3) { +bool MapManager::func_ov00_02084be0(u32 param_2, unk32 param_3) { bool bVar1; if (param_2 == 0) { @@ -2035,7 +2035,7 @@ unk32 MapManager::func_ov00_02084ebc(Vec3p *param_2) { u32 uStack_14; this->func_ov00_02083a1c(auStack_18, this, param_2); - piVar1 = (int *) this->MapData_vfunc_78(); + piVar1 = (int *) this->MapData_vfunc_78(0); if (piVar1 != (int *) 0x0) { // iVar2 = (**(code **) (*piVar1 + 0x1c))(); if (iVar2 < 0x39) { @@ -2059,7 +2059,7 @@ unk32 MapManager::func_ov00_02084ebc(Vec3p *param_2) { if (iVar2 != 0) { return 0; } - iVar2 = this->MapData_vfunc_54(); + iVar2 = this->MapData_vfunc_54(0); if (iVar2 < 0x47) { if (0x45 < iVar2) { return 0; @@ -2122,7 +2122,7 @@ unk32 MapManager::func_ov00_02084ebc(Vec3p *param_2) { } else if (iVar2 == 0x50) { return 0; } - iVar2 = this->mMap->vfunc_58(/*auStack_18, 5*/); + iVar2 = this->mMap->vfunc_58(auStack_18, 5); if (iVar2 != 0) { return 0; } @@ -2167,7 +2167,7 @@ s32 MapManager::func_ov00_02085108(s32 *param_2) { uVar5 = (u32) local_39; if ((u32) local_3a <= (u32) local_39) { do { - piVar3 = (int *) puVar1->MapData_vfunc_78(); + piVar3 = (int *) puVar1->MapData_vfunc_78(0); if ((piVar3 != (int *) 0x0) && ((piVar3[1] & 4U) != 0)) { iVar7 = piVar3[7]; iVar6 = piVar3[6]; @@ -2244,7 +2244,7 @@ s32 MapManager::func_ov00_0208527c(MapManager *param_1, unk32 param_2, unk32 *pa return 0; } for (; (int) uVar1 <= (int) uVar6; uVar1 = uVar1 + 1) { - iVar4 = puVar2->MapData_vfunc_78(); + iVar4 = puVar2->MapData_vfunc_78(0); if (((iVar4 != 0) && ((*(u32 *) (iVar4 + 4) & 4) != 0)) && (iVar5 = func_ov000_0208b73c(iVar4, param_2), iVar5 != 0)) { @@ -2305,7 +2305,7 @@ s32 MapManager::func_ov00_020853fc(MapManager *param_1, Vec3p *param_2, s32 *par 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(); + 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)) @@ -2330,7 +2330,7 @@ unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 Vec3p VStack_20; param_1->func_ov00_02083a1c(&local_28, param_1, param_2); - piVar1 = (int *) param_1->MapData_vfunc_78(); + piVar1 = (int *) param_1->MapData_vfunc_78(0); bVar5 = true; if (piVar1 != (int *) 0x0) { param_2->x = piVar1[6]; @@ -2425,7 +2425,7 @@ unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 } else if (iVar2 == 0x50) { return 0; } - iVar2 = param_1->mMap->vfunc_58(/*&local_28, 5*/); // no params + iVar2 = param_1->mMap->vfunc_58(&local_28, 5); // no params if (iVar2 != 0) { return 0; } @@ -2452,7 +2452,7 @@ void MapManager::func_ov00_0208583c(MapManager *param_1, Vec3p *param_2, unk32 p unk8 auStack_10[4]; // param_1->func_ov00_02083a1c(auStack_10, param_1, param_2); // Should auStack_10 be pointer type or not ? - piVar1 = (s32 *) param_1->MapData_vfunc_78(); + piVar1 = (s32 *) param_1->MapData_vfunc_78(0); if (piVar1 == (s32 *) 0x0) { return; } @@ -2490,12 +2490,12 @@ unk8 MapManager::func_ov00_020858b0(MapManager *param_1, Vec3p *param_2, s32 par 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(); + 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(), piVar5 != (int *) 0x0)) { + if ((iVar4 < 0xce) && (piVar5 = (int *) param_1->MapData_vfunc_78(0), piVar5 != (int *) 0x0)) { // local_38 = (**(code **) (*piVar5 + 0x38))(piVar5, param_3); } } @@ -2527,7 +2527,7 @@ s32 MapManager::func_ov00_02085a34(Vec3p *param_2, s32 param_3) { return -1; } this->func_ov00_02083a1c(auStack_2a, this, param_2); - piVar1 = (int *) this->MapData_vfunc_78(); + piVar1 = (int *) this->MapData_vfunc_78(0); if (piVar1 == (int *) 0x0) { return -1; } @@ -2545,7 +2545,7 @@ s32 MapManager::func_ov00_02085a34(Vec3p *param_2, s32 param_3) { if (iVar2 == 0) { return -1; } - piVar1 = (int *) this->MapData_vfunc_78(); + piVar1 = (int *) this->MapData_vfunc_78(0); if (piVar1 != (int *) 0x0) { // iVar2 = (**(code **) (*piVar1 + 0x1c))(); if (0x38 < iVar2) { @@ -2587,7 +2587,7 @@ s32 MapManager::func_ov00_02085a34(Vec3p *param_2, s32 param_3) { if (iVar2 == 0) { return -1; } - iVar2 = MapData_vfunc_78(); // Same here. + iVar2 = MapData_vfunc_78(0); // Same here. if ((iVar2 != 0) && (0 < *(s16 *) (iVar2 + 0xe))) { return 1; } @@ -2817,7 +2817,7 @@ unk8 MapManager::func_ov00_02086044(Vec3p *param_2, Vec3p *param_3, unk32 param_ return 1; } } - piVar9 = (int *) this->MapData_vfunc_78(); + piVar9 = (int *) this->MapData_vfunc_78(0); if ((piVar9 != (int *) 0x0) /*&& (iVar8 = (**(code **) (*piVar9 + 0x58))(), iVar8 != 0)*/) { iStack_c0.x = param_3->x; iStack_c0.y = param_3->y; -- cgit v1.2.3 From 5b3bc3313eb9d424657e6eb888ad741494484d03 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Tue, 4 Feb 2025 16:06:04 +0100 Subject: Decomp update --- src/00_Core/Map/MapManager.cpp | 68 ++++++++++++++++++++++-------------------- 1 file changed, 35 insertions(+), 33 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 6dff6ace..c1f70e90 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -45,7 +45,7 @@ extern void func_ov004_02105608(ActorManager *param_1, unk32 param_2, unk32 para 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(s32 param_1); +extern bool func_ov015_02129c44(MapBase *param_1, s32 param_2); extern s32 *data_027e0c68; extern s32 *data_027e0d38; @@ -229,7 +229,7 @@ ARM bool MapManager::func_ov00_02082494(s32 param_2) { ARM bool MapManager::func_ov00_020824cc(s32 param_2) { s32 var = this->mMap->vfunc_4c(); if (var == 2) { - bool state = func_ov015_02129c44(param_2); + bool state = func_ov015_02129c44(this->mMap, param_2); return state; } return false; @@ -545,10 +545,11 @@ ARM u8 MapManager::GetCurrentMapPosY() { } ARM u8 MapManager::func_ov00_02082d40() { - if (this->mCourse->mType == CourseType_Sea) { - return this->mCourse->mMapGrid[(u8) this->mCourse->mCurrMapPos.x][(u8) this->mCourse->mCurrMapPos.y]; + 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; } - return this->mCourse->mUnk_0b1; } ARM u32 MapManager::func_ov00_02082d74(unk32 param_2) { @@ -906,25 +907,27 @@ ARM unk8 MapManager::func_ov00_02083614(s32 param_2) { return this->mCourse->func_ov00_0207cc24(param_2); } -ARM bool MapManager::GetEntrancePos(Vec3p *pos, unk32 entranceId) { - Vec3p *entrancePos = (Vec3p *) this->mMap->FindEntrance(entranceId); - s32 y = entrancePos->y; - s32 z = entrancePos->z; - pos->x = entrancePos->x; - pos->y = y; - pos->z = z; - //*&pos[1].x = *&entrancePos[1].x; - //*(&pos[1].x + 2) = *(&entrancePos[1].x + 2); - // pos[1].y = entrancePos[1].y; +ARM bool MapManager::GetEntrancePos(Entrance *param_1, unk32 entranceId) { + Entrance *entrance = this->mMap->FindEntrance(entranceId); + q20 y = entrance->mPos.y; + q20 z = entrance->mPos.z; + param_1->mPos.x = entrance->mPos.x; + param_1->mPos.y = y; + param_1->mPos.z = z; + param_1->mAngle = entrance->mAngle; + param_1->mId = entrance->mId; // mId needs to be u8 according to objdiff + param_1->mUnk_10 = entrance->mUnk_10; return true; } -ARM bool MapManager::func_ov00_02083664(Vec3p *param_2, unk32 entranceId) { - Vec3p entrancePos; - if (this->GetEntrancePos(&entrancePos, entranceId)) { - param_2->x = entrancePos.x; - param_2->y = entrancePos.y; - param_2->z = entrancePos.z; +ARM bool MapManager::func_ov00_02083664(Entrance *param_2, unk32 entranceId) { + Entrance entrance; + entrance.mId = (u8) 0xff; // mId needs to be u8 + 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; @@ -939,11 +942,10 @@ ARM s32 MapManager::GetTriggerBoundingBoxes(s32 param_2, AABB *param_3, s32 para } ARM bool MapManager::func_ov00_020836dc(u32 type, u32 actorId) { - bool state; Actor *actor; Vec3p playerPos; - if (actorId < 2) { + if (!(actorId != 0 && actorId != 1)) { // what an awkward statement (as opposed to actorId < 2) playerPos.x = gPlayerPos->x; playerPos.y = gPlayerPos->y; playerPos.z = gPlayerPos->z; @@ -952,9 +954,9 @@ ARM bool MapManager::func_ov00_020836dc(u32 type, u32 actorId) { if (actor == NULL) { return false; } - playerPos.x = *(s32 *) (actor + 0x48); - playerPos.y = *(s32 *) (actor + 0x4c); - playerPos.z = *(s32 *) (actor + 0x50); + playerPos.x = actor->mPos.x; + playerPos.y = actor->mPos.y; + playerPos.z = actor->mPos.z; } return this->IsTriggerTypeOverlapped(type, &playerPos); } @@ -1164,7 +1166,7 @@ ARM void MapManager::func_ov00_02083c7c(Vec3p *param_2, u32 param_3) { Vec3p local_28; param_2->x = this->func_ov00_02083c24(param_3 & 0xff); param_2->z = this->func_ov00_02083c50(param_3 >> 8 & 0xff); - param_2->y = this->MapData_vfunc_68(&local_28, 0); // please tell me this is correct + param_2->y = this->MapData_vfunc_68(&local_28, true); // please tell me this is correct } ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 param_3, s32 param_4, u32 param_5) { @@ -1203,7 +1205,7 @@ ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 p param_2[2] = iVar2 + 0x800; } } - iVar2 = param_1->MapData_vfunc_68(&local_2c, 0); // I really do hope this is right + iVar2 = param_1->MapData_vfunc_68(&local_2c, true); // I really do hope this is right param_2[1] = iVar2; } @@ -1238,7 +1240,7 @@ ARM bool MapManager::func_ov00_02083e70() { return iVar2 <= iVar1; } -ARM unk32 MapManager::MapData_vfunc_68(Vec3p *param_1, bool *param_2) { // not sure about the bool* here. +ARM unk32 MapManager::MapData_vfunc_68(Vec3p *param_1, bool param_2) { return this->mMap->vfunc_68(param_1, param_2); } @@ -1493,7 +1495,7 @@ unk8 MapManager::func_ov00_0208439c(Vec2s *param_2, Vec3p *param_3) { 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, 0); // is this correct? + iVar1 = this->MapData_vfunc_68(param_3, true); // is this correct? param_3->y = iVar1; } @@ -1913,7 +1915,7 @@ void MapManager::func_ov00_02084c7c(unk32 param_2) { bool MapManager::func_ov00_02084c94(unk32 param_2) { bool bVar1; - if (-1 < param_2) { + if (0 <= param_2) { bVar1 = this->mCourse->GetMapDataFlag2(param_2); return bVar1; } @@ -1932,7 +1934,7 @@ void MapManager::func_ov00_02084cb0(unk32 param_2) { bool MapManager::func_ov00_02084cc8(unk32 param_2) { bool bVar1; - if (-1 < param_2) { + if (0 <= param_2) { bVar1 = this->mCourse->GetMapDataFlag3(param_2); return bVar1; } @@ -1951,7 +1953,7 @@ void MapManager::func_ov00_02084ce4(unk32 param_2) { bool MapManager::func_ov00_02084cfc(unk32 param_2) { bool bVar1; - if (-1 < param_2) { + if (0 <= param_2) { bVar1 = this->mCourse->GetMapDataFlag4(param_2); return bVar1; } -- cgit v1.2.3 From e922eb92ed5152d9aeeb3d6921bd27af62c2b2e7 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Tue, 4 Feb 2025 17:00:51 +0100 Subject: Update MapManager --- src/00_Core/Map/MapManager.cpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 19df9b36..22ec6050 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -524,7 +524,7 @@ bool MapManager::func_ov00_02082b3c(s32 param_2) { uVar4 = this->mCourse->FindMapData_Unk_04((u32) bVar1); (this->mCourse->mCurrMapPos).x = (u8) local_18; (this->mCourse->mCurrMapPos).y = (u8) * (&local_18 + 0x4); // I assume this is what Ghidra means by "local_18._1_1_" - func_ov004_021024c4(this, param_2, uVar3 != uVar4, 0); + func_ov004_021024c4(param_2, uVar3 != uVar4, 0); func_ov004_02105578(gActorManager, (u32) * (u8 *) (param_2 + 0x12)); // UnkStruct_027e0103c::thunk_FUN_overlay_d_0__020cf7e8(*PTR_PTR_overlay_d_0__02082cfc); } @@ -1227,7 +1227,7 @@ ARM bool MapManager::func_ov00_02083e70() { int iVar1; int iVar2; - iVar1 = this->MapData_vfunc_54(0); + iVar1 = this->MapData_vfunc_54(); if (iVar1 < 0x2c) { if ((0x2a < iVar1) || (iVar1 == 0x1b)) { return true; @@ -1307,8 +1307,8 @@ void MapManager::GetTileWorldBounds(Vec2b *tile, AABB *tileBounds) { Vec3p_Add(&tileBounds->max, &local_20, &tileBounds->max); } -unk32 MapManager::MapData_vfunc_54(unk8 *param_1) { // what type is this param? - return this->mMap->vfunc_54(param_1); +unk32 MapManager::MapData_vfunc_54() { + return this->mMap->vfunc_54(0); // what to use for this param? } unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) { @@ -1318,7 +1318,7 @@ unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) { uStack_6 = (unk16) ((u32) param_4 >> 0x10); // _local_8 = CONCAT11(param_3, param_2); - this->MapData_vfunc_54(&local_8); // Doesn't take any params. + this->MapData_vfunc_54(/*&local_8*/); // Doesn't take any params. // No calls to functions according to objdiff, why??? } @@ -1367,7 +1367,7 @@ unk8 MapManager::func_ov00_02084164(Vec2b *param_2) { iVar1 = this->mMap->vfunc_58(param_2, 7 /*, pcVar3, param_4*/); // Params? if (iVar1 == 0) { - uVar2 = this->MapData_vfunc_54(0); + uVar2 = this->MapData_vfunc_54(); switch (uVar2) { case 0: break; case 1: return 0; @@ -2061,7 +2061,7 @@ unk32 MapManager::func_ov00_02084ebc(Vec3p *param_2) { if (iVar2 != 0) { return 0; } - iVar2 = this->MapData_vfunc_54(0); + iVar2 = this->MapData_vfunc_54(); if (iVar2 < 0x47) { if (0x45 < iVar2) { return 0; @@ -2811,7 +2811,7 @@ unk8 MapManager::func_ov00_02086044(Vec3p *param_2, Vec3p *param_3, unk32 param_ if (iVar7 < iVar8) { local_c6.x = (char) iVar3; local_c6.y = (char) iVar11; - gMapManager->func_ov00_02084024(&local_c6, &AStack_70); + 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); -- cgit v1.2.3 From 4c799ec3f32e5bd06463f88fa036d8208d6bcb02 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Thu, 6 Feb 2025 14:00:27 +0100 Subject: Decomp progress 29% --- src/00_Core/Map/MapManager.cpp | 57 +++++++++++++++++++++++------------------- 1 file changed, 31 insertions(+), 26 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 22ec6050..708652b6 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -945,10 +945,15 @@ ARM bool MapManager::func_ov00_020836dc(u32 type, u32 actorId) { Actor *actor; Vec3p playerPos; - if (!(actorId != 0 && actorId != 1)) { // what an awkward statement (as opposed to actorId < 2) - playerPos.x = gPlayerPos->x; - playerPos.y = gPlayerPos->y; - playerPos.z = gPlayerPos->z; + if (!(actorId != 0 && actorId != 1)) { // what an awkward statement (as opposed to if (actorId < 2)) + // below doesn't match in objdiff + q20 x = gPlayerPos->x; + q20 y = gPlayerPos->y; + playerPos.x = x; + playerPos.y = y; + q20 z = gPlayerPos->z; + playerPos.z = z; + } else { actor = gActorManager->FindActorById(actorId); if (actor == NULL) { @@ -1210,12 +1215,14 @@ ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 p } ARM void MapManager::func_ov00_02083e34(unk8 param_2, unk8 param_3, unk32 param_4) { - unk8 local_8; // Should this be a bool or a Vec2p or a Vec3p? + // Missing opcode in objdiff + unk8 local_8; // What type is this? unk8 local_7; // Unused. - unk16 uStack_6; + unk16 uStack_6; // Unused. uStack_6 = (unk16) ((u32) param_4 >> 0x10); - // _local_8 = CONCAT11(param_3, param_2); What is this? + local_8 = param_2; + local_7 = param_3; this->mMap->vfunc_60(&local_8); } @@ -1227,7 +1234,7 @@ ARM bool MapManager::func_ov00_02083e70() { int iVar1; int iVar2; - iVar1 = this->MapData_vfunc_54(); + iVar1 = this->MapData_vfunc_54(0); if (iVar1 < 0x2c) { if ((0x2a < iVar1) || (iVar1 == 0x1b)) { return true; @@ -1277,7 +1284,7 @@ unk8 MapManager::MapData_vfunc_70(Vec3p *param_2) { this->mMap->vfunc_70(param_2); } -unk8 MapManager::func_ov00_02083fb0(u32 *param_1, MapManager *param_2, Vec3p *param_3) { +ARM void MapManager::func_ov00_02083fb0(u32 *param_1, MapManager *param_2, Vec3p *param_3) { s32 iVar1; unk32 dVar2; @@ -1307,8 +1314,8 @@ void MapManager::GetTileWorldBounds(Vec2b *tile, AABB *tileBounds) { Vec3p_Add(&tileBounds->max, &local_20, &tileBounds->max); } -unk32 MapManager::MapData_vfunc_54() { - return this->mMap->vfunc_54(0); // what to use for this param? +unk32 MapManager::MapData_vfunc_54(unk8 *a) { + return this->mMap->vfunc_54(a); // what to use for this param? } unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) { @@ -1318,7 +1325,7 @@ unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) { uStack_6 = (unk16) ((u32) param_4 >> 0x10); // _local_8 = CONCAT11(param_3, param_2); - this->MapData_vfunc_54(/*&local_8*/); // Doesn't take any params. + this->MapData_vfunc_54(&local_8); // Doesn't take any params. // No calls to functions according to objdiff, why??? } @@ -1367,7 +1374,7 @@ unk8 MapManager::func_ov00_02084164(Vec2b *param_2) { iVar1 = this->mMap->vfunc_58(param_2, 7 /*, pcVar3, param_4*/); // Params? if (iVar1 == 0) { - uVar2 = this->MapData_vfunc_54(); + uVar2 = this->MapData_vfunc_54(0); switch (uVar2) { case 0: break; case 1: return 0; @@ -1599,32 +1606,30 @@ void MapManager::func_ov00_020843ec(s32 *param_2) { } } -unk32 MapManager::GetMapData_Unk_38() { +ARM unk32 MapManager::GetMapData_Unk_38() { return this->mMap->mUnk_038; } -unk8 MapManager::func_ov00_020846a4() { +ARM s32 MapManager::func_ov00_020846a4() { s32 iVar1 = *(s32 *) ((s32) this->mMap->mUnk_144 + 4); if (iVar1 == 0xff) { switch (this->mCourse->mType) { - case CourseType_Normal: return 0; - case CourseType_Dungeon: break; + case CourseType_Dungeon: + case CourseType_TempleOfTheOceanKing: + case CourseType_Battle: return 1; case CourseType_Sea: return 2; - case CourseType_TempleOfTheOceanKing: break; - case CourseType_Battle: break; + case CourseType_Normal: default: return 0; } - return 1; } return iVar1; } -unk8 MapManager::func_ov00_02084700(s32 *param_1) { // param_1 perhaps Vec2b ? - int iVar1; - - iVar1 = *(int *) (param_1[1] + 0x34); +ARM s32 MapManager::func_ov00_02084700(MapManager *pMapManager) { + s32 iVar1; + iVar1 = pMapManager->mMap->mUnk_034; if (iVar1 == -1) { - iVar1 = *(int *) (*param_1 + 0xc4); + iVar1 = pMapManager->mCourse->mUnk_0c4; } if ((iVar1 == 0x1b) && (gActorManager->mUnk_29 != false)) { iVar1 = 0x1c; @@ -2061,7 +2066,7 @@ unk32 MapManager::func_ov00_02084ebc(Vec3p *param_2) { if (iVar2 != 0) { return 0; } - iVar2 = this->MapData_vfunc_54(); + iVar2 = this->MapData_vfunc_54(0); if (iVar2 < 0x47) { if (0x45 < iVar2) { return 0; -- cgit v1.2.3 From 6b9df2f4701f6790739bba8b07badcf002c7f72e Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Tue, 1 Apr 2025 21:22:24 +0200 Subject: Function fixes (still 29%) --- src/00_Core/Map/MapManager.cpp | 137 ++++++++++++++++++++++------------------- 1 file changed, 75 insertions(+), 62 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 708652b6..15de64f6 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -47,8 +47,15 @@ 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); +struct UnkStruct_027e0d38 { + /* 00 */ unk8 mUnk_00[0xc]; + /* 0c */ unk32 mUnk_0c; + /* 10 */ unk8 mUnk_10[0x18]; + /* 28 */ unk32 mUnk_28; +}; + extern s32 *data_027e0c68; -extern s32 *data_027e0d38; +extern UnkStruct_027e0d38 *data_027e0d38; extern s32 *data_027e0d3c; extern s32 *data_027e0f64; extern s32 *data_027e0f68; @@ -111,8 +118,8 @@ unk8 MapManager::func_ov00_0208210c(unk32 param_2, unk32 *param_3) { uVar2 = 4; } *(unk8 *) ((int) param_3 + 5) = uVar2; - uVar3 = func_ov000_020a5e9c(data_027e0d38 + 0x28) + 0x1c; - puVar1 = data_027e0d38; + uVar3 = func_ov000_020a5e9c(&data_027e0d38->mUnk_28) + 0x1c; + puVar1 = (s32 *) data_027e0d38; param_3[2] = uVar3; *(unk8 *) (param_3 + 4) = *(unk8 *) (*(s32 *) (*(s32 *) puVar1 + 0x28) + 0x2e); *(unk16 *) (param_3 + 5) = *(unk16 *) (*(s32 *) (*(s32 *) puVar1 + 0x28) + 0x36); @@ -122,7 +129,7 @@ unk8 MapManager::func_ov00_0208210c(unk32 param_2, unk32 *param_3) { param_3[8] = *(unk32 *) (iVar4 + 0x40); uVar3 = func_ov000_020a5e9c(puVar1 + 0x28) + 0x44; param_3[3] = uVar3; - puVar1 = data_027e0d38; + puVar1 = (s32 *) data_027e0d38; *(unk8 *) ((int) param_3 + 0x11) = *(unk8 *) (*(s32 *) (*(s32 *) data_027e0d38 + 0x28) + 0x56); iVar4 = *(s32 *) (*(s32 *) puVar1 + 0x28); param_3[9] = *(unk32 *) (iVar4 + 0x5c); @@ -141,7 +148,7 @@ unk8 MapManager::func_ov00_0208210c(unk32 param_2, unk32 *param_3) { local_2b = *(unk8 *) (iVar4 + 0x85); uVar3 = func_ov000_020a5e9c(&local_40); param_3[0x70] = uVar3; - puVar1 = data_027e0f70; + puVar1 = (s32 *) data_027e0f70; *(unk8 *) ((int) param_3 + 0x1be) = local_2e; *(unk8 *) ((int) param_3 + 0x1bf) = local_2d; func_ov000_02096324(puVar1, *param_3); // unsure if (s32 *param_1, s32 param_2) or (s32 param_1, s32 *param_2) @@ -243,14 +250,19 @@ ARM s32 MapManager::func_ov00_02082504() { return 0; } -ARM unk8 *MapManager::func_ov00_02082538() { - unk8 var0[12]; +ARM Vec3p *MapManager::func_ov00_02082538() { s32 var1 = this->mMap->vfunc_4c(); + Vec3p var0; if (var1 != 2) { - return var0; + q20 x = gPlayerPos->x; + q20 y = gPlayerPos->y; + var0.x = x; + var0.y = y; + q20 z = gPlayerPos->z; + var0.z = z; + return &var0; } - return this->mMap->mUnk_1a0; - // Reference to gPlayerPos in Ghidra, but not used. (See overlay_d_0::0x2082538) + return &this->mMap->mUnk_1a0; } ARM void MapManager::func_ov00_02082594() { @@ -379,8 +391,8 @@ ARM void MapManager::func_ov00_02082808(s32 param_2) { // func_ov00_020d72b8(DWORD_overlay_d_0_bss__020eec68); } -ARM void MapManager::MapData_vfunc_7c() { - this->mMap->vfunc_7c(); +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) { @@ -915,14 +927,14 @@ ARM bool MapManager::GetEntrancePos(Entrance *param_1, unk32 entranceId) { param_1->mPos.y = y; param_1->mPos.z = z; param_1->mAngle = entrance->mAngle; - param_1->mId = entrance->mId; // mId needs to be u8 according to objdiff + param_1->mId = entrance->mId; param_1->mUnk_10 = entrance->mUnk_10; return true; } ARM bool MapManager::func_ov00_02083664(Entrance *param_2, unk32 entranceId) { Entrance entrance; - entrance.mId = (u8) 0xff; // mId needs to be u8 + entrance.mId = (u8) 0xff; entrance.mUnk_10 = 0; if (this->GetEntrancePos(&entrance, entranceId)) { param_2->mPos.x = entrance.mPos.x; @@ -945,23 +957,23 @@ ARM bool MapManager::func_ov00_020836dc(u32 type, u32 actorId) { Actor *actor; Vec3p playerPos; - if (!(actorId != 0 && actorId != 1)) { // what an awkward statement (as opposed to if (actorId < 2)) - // below doesn't match in objdiff - q20 x = gPlayerPos->x; - q20 y = gPlayerPos->y; - playerPos.x = x; - playerPos.y = y; - q20 z = gPlayerPos->z; - playerPos.z = z; - - } else { - actor = gActorManager->FindActorById(actorId); - if (actor == NULL) { - return false; - } - playerPos.x = actor->mPos.x; - playerPos.y = actor->mPos.y; - playerPos.z = actor->mPos.z; + 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); } @@ -1169,9 +1181,12 @@ ARM s32 MapManager::func_ov00_02083c50(unk32 z) { ARM void MapManager::func_ov00_02083c7c(Vec3p *param_2, u32 param_3) { Vec3p local_28; - param_2->x = this->func_ov00_02083c24(param_3 & 0xff); - param_2->z = this->func_ov00_02083c50(param_3 >> 8 & 0xff); - param_2->y = this->MapData_vfunc_68(&local_28, true); // please tell me this is correct + q20 x = this->func_ov00_02083c24(param_3 & 0xff); + // param_2->x = x; + q20 z = this->func_ov00_02083c50(param_3 >> 8 & 0xff); + // param_2->z = z; + q20 y = this->MapData_vfunc_68(&local_28, true); + // param_2->y = y; } ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 param_3, s32 param_4, u32 param_5) { @@ -1214,19 +1229,18 @@ ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 p param_2[1] = iVar2; } -ARM void MapManager::func_ov00_02083e34(unk8 param_2, unk8 param_3, unk32 param_4) { - // Missing opcode in objdiff - unk8 local_8; // What type is this? - unk8 local_7; // Unused. - unk16 uStack_6; // Unused. +ARM s32 MapManager::func_ov00_02083e34(unk8 param_2, unk8 param_3, unk32 param_4) { + u8 local_8; + u8 local_7; + // unk16 uStack_6; // Unused. - uStack_6 = (unk16) ((u32) param_4 >> 0x10); - local_8 = param_2; - local_7 = param_3; - this->mMap->vfunc_60(&local_8); + // uStack_6 = (unk16) ((u32) param_4 >> 0x10); + local_8 = param_2; // Likely a struct + *(&local_8 + 1) = param_3; + return this->mMap->vfunc_60(&local_8); } -ARM unk32 MapManager::MapData_vfunc_60(unk8 *param_1) { // should the param be bool*? +ARM unk32 MapManager::MapData_vfunc_60(u8 *param_1) { // should the param be bool*? return this->mMap->vfunc_60(param_1); } @@ -1280,13 +1294,13 @@ unk8 MapManager::MapData_vfunc_6c(unk32 param_2, unk32 param_3, unk32 param_4) { this->mMap->vfunc_6c(param_2, param_3, param_4); } -unk8 MapManager::MapData_vfunc_70(Vec3p *param_2) { - this->mMap->vfunc_70(param_2); +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) { s32 iVar1; - unk32 dVar2; + s32 dVar2; iVar1 = param_2->mMap->vfunc_74(param_3); if (iVar1 != 0) { @@ -1294,7 +1308,7 @@ ARM void MapManager::func_ov00_02083fb0(u32 *param_1, MapManager *param_2, Vec3p return; } dVar2 = param_2->MapData_vfunc_70(param_3); - if (dVar2 != 0xffff) { + if (iVar1 != 0xffff) { func_ov000_02093a1c(param_1, data_027e0f6c); return; } @@ -1801,14 +1815,14 @@ bool MapManager::func_ov00_020849dc() { return this->mCourse->mUnk_008 == -3; } -bool MapManager::func_ov00_020849f8() { - s32 iVar1; // = FUN_overlay_d_0__020a5e9c(*(s32 *) PTR_PTR_overlay_d_0__02084a4c + 0xc); - if (iVar1 == 5) { - return true; - } - iVar1 = this->GetMapData_Unk_06(); - if ((iVar1 != 0) && (iVar1 = this->func_ov00_020849c0(), iVar1 == 0)) { - return true; +ARM bool MapManager::func_ov00_020849f8() { + switch (func_ov000_020a5e9c(&data_027e0d38->mUnk_0c)) { + case 5: return true; + default: + if (this->GetMapData_Unk_06() != 0 && !this->func_ov00_020849c0()) { + return true; + } + break; } return false; } @@ -1829,7 +1843,7 @@ void MapManager::SpawnNPC(Vec3p *param_2, unk32 param_3, unk32 param_4) { // (ActorRef *) 0x0); } -bool MapManager::func_ov00_02084ac4(u32 actorId) { +ARM bool MapManager::func_ov00_02084ac4(u32 actorId) { Actor *iVar1; bool bVar1; @@ -1837,11 +1851,10 @@ bool MapManager::func_ov00_02084ac4(u32 actorId) { if (iVar1 == NULL) { return false; } - bVar1 = iVar1->mType == ActorTypeId_EVIC; - if (bVar1) { - iVar1->mAlive = false; - } - return bVar1; + + if (iVar1->mType != ActorTypeId_EVIC) return false; + iVar1->mAlive = false; + return true; } void MapManager::SetNumKeys(unk32 keys) { -- cgit v1.2.3 From d5a2e0f57e469d780eb0e2ab1183aa40f93cf23c Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sun, 6 Apr 2025 22:32:49 +0200 Subject: Decomp progress 30% Change gPlayerPos from Vec3p* to Vec3p (thx lago) --- src/00_Core/Map/MapManager.cpp | 48 +++++++++++++++++++----------------------- 1 file changed, 22 insertions(+), 26 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 15de64f6..e7e826f6 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -244,25 +244,21 @@ ARM bool MapManager::func_ov00_020824cc(s32 param_2) { ARM s32 MapManager::func_ov00_02082504() { s32 var = this->mMap->vfunc_4c(); - if (var == 2) { - return (s32) this->mMap->mUnk_1ac; - } + 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) { - q20 x = gPlayerPos->x; - q20 y = gPlayerPos->y; - var0.x = x; - var0.y = y; - q20 z = gPlayerPos->z; - var0.z = z; - return &var0; - } - return &this->mMap->mUnk_1a0; + if (var1 == 2) return &this->mMap->mUnk_1a0; + q20 x = gPlayerPos.x; + q20 y = gPlayerPos.y; + var0.x = x; + var0.y = y; + q20 z = gPlayerPos.z; + var0.z = z; + return &var0; } ARM void MapManager::func_ov00_02082594() { @@ -674,9 +670,9 @@ ARM void MapManager::func_ov00_0208306c(s32 *param_2, s32 *param_3) { *param_3 = this->mCourse->mUnk_0b8; return; } - local_1c.y = gPlayerPos->y; - local_1c.x = gPlayerPos->x; - local_1c.z = gPlayerPos->z; + 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); } @@ -710,9 +706,9 @@ ARM void MapManager::func_ov00_0208315c(s32 *param_2, s32 *param_3) { *param_3 = this->mCourse->mUnk_0c0; return; } - local_20.x = *(s32 *) gPlayerPos->x; - local_20.y = *(s32 *) gPlayerPos->y; - local_20.z = *(s32 *) gPlayerPos->z; + local_20.x = *(s32 *) gPlayerPos.x; + local_20.y = *(s32 *) gPlayerPos.y; + local_20.z = *(s32 *) gPlayerPos.z; uVar1 = this->func_ov00_02082d08(); this->func_ov00_02083298(uVar1, &local_20, param_2, param_3); } @@ -960,10 +956,10 @@ ARM bool MapManager::func_ov00_020836dc(u32 type, u32 actorId) { switch (actorId) { case 0: case 1: - q20 y = gPlayerPos->y; - playerPos.x = gPlayerPos->x; + q20 y = gPlayerPos.y; + playerPos.x = gPlayerPos.x; playerPos.y = y; - playerPos.z = gPlayerPos->z; + playerPos.z = gPlayerPos.z; break; default: actor = gActorManager->FindActorById(actorId); @@ -1669,9 +1665,9 @@ unk8 MapManager::func_ov00_02084740() { // 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; + 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(); @@ -2505,7 +2501,7 @@ unk8 MapManager::func_ov00_020858b0(MapManager *param_1, Vec3p *param_2, s32 par 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); + 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) { -- cgit v1.2.3 From 96e2380df560dd3d9898f41f6caaa08e5eeaa56e Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Mon, 7 Apr 2025 21:06:29 +0200 Subject: Decomp progress 33% --- src/00_Core/Map/MapManager.cpp | 226 +++++++++++++++-------------------------- 1 file changed, 84 insertions(+), 142 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index e7e826f6..c5903854 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -252,12 +252,7 @@ ARM Vec3p *MapManager::func_ov00_02082538() { s32 var1 = this->mMap->vfunc_4c(); Vec3p var0; if (var1 == 2) return &this->mMap->mUnk_1a0; - q20 x = gPlayerPos.x; - q20 y = gPlayerPos.y; - var0.x = x; - var0.y = y; - q20 z = gPlayerPos.z; - var0.z = z; + var0 = gPlayerPos; return &var0; } @@ -353,7 +348,11 @@ ARM void MapManager::DestroyMap() { if (this->mMap == NULL) { return; } - this->mMap->~MapBase(); + if (this->mMap != NULL) { + this->mMap->~MapBase(); // 0x0 offset instead of the expected 0x4. + } + this->mMap = NULL; + return; } ARM void MapManager::MapData_vfunc_44() { @@ -1300,7 +1299,8 @@ ARM void MapManager::func_ov00_02083fb0(u32 *param_1, MapManager *param_2, Vec3p iVar1 = param_2->mMap->vfunc_74(param_3); if (iVar1 != 0) { - *param_1 = *(unk32 *) (iVar1 + 0xc); + // iVar1 += 0xc; + *param_1 = iVar1; return; } dVar2 = param_2->MapData_vfunc_70(param_3); @@ -1324,12 +1324,12 @@ void MapManager::GetTileWorldBounds(Vec2b *tile, AABB *tileBounds) { Vec3p_Add(&tileBounds->max, &local_20, &tileBounds->max); } -unk32 MapManager::MapData_vfunc_54(unk8 *a) { +unk32 MapManager::MapData_vfunc_54(Vec2b *a) { return this->mMap->vfunc_54(a); // what to use for this param? } unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) { - unk8 local_8; + Vec2b local_8; unk8 local_7; unk16 uStack_6; @@ -1383,97 +1383,63 @@ unk8 MapManager::func_ov00_02084164(Vec2b *param_2) { unk32 uVar2; iVar1 = this->mMap->vfunc_58(param_2, 7 /*, pcVar3, param_4*/); // Params? - if (iVar1 == 0) { - uVar2 = this->MapData_vfunc_54(0); - switch (uVar2) { - case 0: break; - case 1: return 0; - case 2: return 0; - case 3: return 0; - case 4: return 0; - case 5: return 0; - case 6: return 0; - case 7: return 0; - case 8: break; - case 9: break; - case 10: return 0; - case 0xb: break; - case 0xc: break; - case 0xd: break; - case 0xe: break; // I mean, honestly Ghidra. - case 0xf: break; // What are we going to do with you? - case 0x10: break; - case 0x11: break; - case 0x12: break; - case 0x13: break; - case 0x14: return 0; - case 0x15: break; - case 0x16: break; - case 0x17: return 0; - case 0x18: break; - case 0x19: return 0; - case 0x1a: break; - case 0x1b: return 0; - case 0x1c: return 0; - case 0x1d: return 0; - case 0x1e: return 0; - case 0x1f: return 0; - case 0x20: break; - case 0x21: break; - case 0x22: break; - case 0x23: break; - case 0x24: return 0; - case 0x25: break; - case 0x26: break; - case 0x27: break; - case 0x28: break; - case 0x29: break; - case 0x2a: break; - case 0x2b: return 0; - case 0x2c: break; - case 0x2d: break; - case 0x2e: break; - case 0x2f: break; - case 0x30: return 0; - case 0x31: break; - case 0x32: break; - case 0x33: return 0; - case 0x34: return 0; - case 0x35: break; - case 0x36: break; - case 0x37: return 0; - case 0x38: break; - case 0x39: break; - case 0x3a: break; - case 0x3b: break; - case 0x3c: break; - case 0x3d: break; - case 0x3e: break; - case 0x3f: break; - case 0x40: return 0; - case 0x41: break; - case 0x42: break; - case 0x43: break; - case 0x44: break; - case 0x45: break; - case 0x46: return 0; - case 0x47: return 0; - case 0x48: return 0; - case 0x49: return 0; - case 0x4a: return 0; - case 0x4b: return 0; - case 0x4c: return 0; - case 0x4d: break; - case 0x4e: return 0; - case 0x4f: return 0; - case 0x50: return 0; - case 0x51: break; - case 0x52: break; - case 0x53: break; - case 0x54: break; - default: return 0; - } - return 1; + 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; } @@ -1714,54 +1680,30 @@ unk8 MapManager::func_ov00_020847f0() { bool MapManager::func_ov00_02084838() { unk32 uVar1 = this->GetMapData_Unk_38(); switch (uVar1) { - case 0: return false; - case 1: break; - case 2: break; - case 3: break; - case 4: break; - case 5: break; - case 6: return false; - case 7: return false; - case 8: return false; - case 9: return false; - case 10: break; - case 0xb: break; - case 0xc: break; - case 0xd: return false; - case 0xe: return false; - case 0xf: return false; - case 0x10: return false; - case 0x11: break; - case 0x12: return false; - case 0x13: break; - case 0x14: break; - case 0x15: break; - case 0x16: break; + 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; } - return true; } bool MapManager::func_ov00_020848b8() { unk32 uVar1 = this->func_ov00_020846a4(); switch (uVar1) { - case 0: break; - case 1: break; - case 2: break; - case 3: break; - case 4: break; - case 5: break; - case 6: return true; - case 7: break; - case 8: break; - case 9: break; - case 10: break; - case 0xb: break; - case 0xc: return true; - case 0xd: return true; - case 0xe: break; - case 0xf: return true; - case 0x10: break; + case 6: + case 0xc: + case 0xd: + case 0xf: case 0x11: return true; } return false; -- cgit v1.2.3 From 1c3cf95937e1cd56c2fb3bcdbe89afaf4bb83626 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Mon, 7 Apr 2025 21:09:10 +0200 Subject: Clean up comments --- src/00_Core/Map/MapManager.cpp | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index c5903854..e7f0397a 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -1324,8 +1324,8 @@ void MapManager::GetTileWorldBounds(Vec2b *tile, AABB *tileBounds) { Vec3p_Add(&tileBounds->max, &local_20, &tileBounds->max); } -unk32 MapManager::MapData_vfunc_54(Vec2b *a) { - return this->mMap->vfunc_54(a); // what to use for this param? +unk32 MapManager::MapData_vfunc_54(Vec2b *param_1) { + return this->mMap->vfunc_54(param_1); } unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) { @@ -1335,8 +1335,7 @@ unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) { uStack_6 = (unk16) ((u32) param_4 >> 0x10); // _local_8 = CONCAT11(param_3, param_2); - this->MapData_vfunc_54(&local_8); // Doesn't take any params. - // No calls to functions according to objdiff, why??? + this->MapData_vfunc_54(&local_8); } unk32 MapManager::MapData_vfunc_78(bool *param_1) { // bool* param placeholder for now, no way of knowing what the type is. @@ -1378,11 +1377,11 @@ unk8 MapManager::MapData_vfunc_58(Vec2b *param_1, int param_2) { this->mMap->vfunc_58(param_1, param_2); } -unk8 MapManager::func_ov00_02084164(Vec2b *param_2) { +ARM s32 MapManager::func_ov00_02084164(Vec2b *param_2) { int iVar1; unk32 uVar2; - iVar1 = this->mMap->vfunc_58(param_2, 7 /*, pcVar3, param_4*/); // Params? + iVar1 = this->mMap->vfunc_58(param_2, 7); if (iVar1 != 0) { return 0; } -- cgit v1.2.3 From 2c6ffc5abc822a1333438ea4e22e0b640bd421c1 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Mon, 7 Apr 2025 23:01:16 +0200 Subject: Add rodata --- src/00_Core/Map/MapManager.cpp | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index e7f0397a..64225e48 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -1460,9 +1460,7 @@ unk8 MapManager::func_ov00_0208433c(Vec3p *param_2, Vec3p *param_3) { Vec3p VStack_24; Vec3p local_18; - local_18.x = param_2->x; - local_18.y = param_2->y; - local_18.z = param_2->z; + local_18 = *param_2; this->GetMapMinBounds(&VStack_24); Vec3p_Sub(&local_18, &VStack_24, &local_18); this->mMap->func_ov00_0207f53c(&local_28, this->mMap, &local_18); @@ -1613,6 +1611,13 @@ ARM s32 MapManager::func_ov00_02084700(MapManager *pMapManager) { } unk8 MapManager::func_ov00_02084740() { + static const s32 data_ov000_020d88f0[] = { + 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; -- cgit v1.2.3 From a76a91ad1374913127446307f48028be1fcd4deb Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sat, 12 Apr 2025 17:36:12 +0200 Subject: Decomp progress 35% --- src/00_Core/Map/MapManager.cpp | 251 ++++++++++++++++++++--------------------- 1 file changed, 122 insertions(+), 129 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 64225e48..7e3e8399 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -1,6 +1,11 @@ +// 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 "DTCM/UnkStruct_027e0d38.hpp" #include "Player/PlayerBase.hpp" #include "Save/AdventureFlags.hpp" @@ -33,6 +38,7 @@ extern void func_ov000_02093a1c(u32 *param_1, s32 *param_2); extern void func_ov000_02096324(s32 *param_1, s32 param_2); extern s32 *func_ov000_02096418(s32 *param_1); extern void func_ov000_0209d6e8(s32 param_1, s32 param_2); +extern s32 func_ov000_0209d71c(s32 *param_1, s32 param_2); extern unk32 func_ov000_020a5e9c(unk32 *param_1); extern void func_ov004_021024c4(MapManager *param_1, s32 param_2, bool param_3, s32 param_4); @@ -42,20 +48,32 @@ extern void func_ov004_02102e3c(s32 *param_1); extern void func_ov004_02105578(ActorManager *param_1, u32 param_2); extern void func_ov004_02105608(ActorManager *param_1, unk32 param_2, unk32 param_3, unk32 param_4); +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); -struct UnkStruct_027e0d38 { - /* 00 */ unk8 mUnk_00[0xc]; +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); + +// Should this be defined? +extern int sprintf(char *__restrict s, const char *__restrict format, ...); + +struct UnkStruct_02082348 { + /* 00 */ unk32 mUnk_00; + /* 04 */ unk32 mUnk_04; + /* 08 */ unk32 mUnk_08; /* 0c */ unk32 mUnk_0c; - /* 10 */ unk8 mUnk_10[0x18]; - /* 28 */ unk32 mUnk_28; + /* 10 */ unk16 mUnk_10; + /* 12 */ unk8 mUnk_12[0x4]; }; extern s32 *data_027e0c68; -extern UnkStruct_027e0d38 *data_027e0d38; +extern u32 *data_027e0ce4; extern s32 *data_027e0d3c; extern s32 *data_027e0f64; extern s32 *data_027e0f68; @@ -117,8 +135,8 @@ unk8 MapManager::func_ov00_0208210c(unk32 param_2, unk32 *param_3) { *(unk8 *) (param_3 + 1) = 2; uVar2 = 4; } - *(unk8 *) ((int) param_3 + 5) = uVar2; - uVar3 = func_ov000_020a5e9c(&data_027e0d38->mUnk_28) + 0x1c; + *(unk8 *) ((int) param_3 + 5) = uVar2; + // uVar3 = func_ov000_020a5e9c(data_027e0d38->mUnk_28) + 0x1c; puVar1 = (s32 *) data_027e0d38; param_3[2] = uVar3; *(unk8 *) (param_3 + 4) = *(unk8 *) (*(s32 *) (*(s32 *) puVar1 + 0x28) + 0x2e); @@ -169,13 +187,18 @@ ARM void MapManager::func_ov00_0208230c(s32 *param_2) { } ARM void MapManager::func_ov00_02082348(unk32 *param_2) { - s32 var[4]; - var[0] = 0x47; - var[1] = 0; - var[2] = 0; - var[3] = 0xfffffffe; - this->func_ov00_0208230c(var); - func_ov000_02078bf0(var, *param_2); + UnkStruct_02082348 unkStruct; + unkStruct.mUnk_00 = 0x47; + unkStruct.mUnk_04 = 0; + unkStruct.mUnk_08 = 0; + unkStruct.mUnk_0c = 0; + unkStruct.mUnk_10 = 0; + unkStruct.mUnk_12[0] = 0xff; + unkStruct.mUnk_12[1] = 0; + unkStruct.mUnk_12[2] = 0; + unkStruct.mUnk_12[3] = 0; + this->func_ov00_0208230c((s32 *) &unkStruct); + func_ov000_02078bf0((s32 *) &unkStruct, *param_2); } ARM void MapManager::func_ov00_020823a4(unk32 param_2) { @@ -265,14 +288,13 @@ ARM void MapManager::func_ov00_020825ac() { } ARM s32 MapManager::GetCourseFilePath(char *courseName, char *buf) { - // s32 var = sprintf(buf, "Map/%s/course.bin", courseName); // Should we manually define sprintf? - // return var; + s32 var = sprintf(buf, "Map/%s/course.bin", courseName); // Should we manually define sprintf? + return var; + // reference to func_ov000_020e2528 (changed to @1495 in symbols) } ARM void MapManager::func_ov00_020825e4(unk32 param_2, char *buf) { - // param2 unused. - // return value of GetCourseFilePath unused. - char *courseName; // = (char *) func_ov000_0209d71c(*(unk32 *) DWORD_027e0f7c) does not exist. + char *courseName = (char *) func_ov000_0209d71c(data_027e0f7c, param_2); this->GetCourseFilePath(courseName, buf); } @@ -300,10 +322,8 @@ 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, unk32 param_4) { - this->mMap->vfunc_98(param_2, 7, param_3 /*, param_4*/); - // vfunc_98 takes either three params or four ??? This doesn't make sense - // objdiff says 100% +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) { @@ -312,33 +332,33 @@ ARM void MapManager::CreateMap(unk32 mapType, unk32 param_3, unk32 param_4) { if (this->mMap == NULL) { switch (mapType) { case 0: - // mapBase = (MapBase *) SysObject::operator_new(0x1dc, (astruct_19 **)(DWORD_027e0ce0 + 4), 4); - // What is astruct_19 ** ? What is DWORD_027e0ce0 ? + // data_027e0ce4 (data_027e0ce0) of type UnkStruct_0202e894 + SysObject::operator new(0x1dc, data_027e0ce4, 4); if (mapBase != NULL) { - // mapBase = (MapBase *)func_ov018_0215b4a0(mapBase, param_3, param_4); // Does not exist. + mapBase = (MapBase *) func_ov018_0215b4a0(mapBase, param_3, param_4); // Does not exist. } this->mMap = mapBase; return; case 1: break; case 2: - // mapBase = (MapBase *) SysObject::operator_new(0x1b0, (astruct_19 **)(DWORD_027e0ce0 + 4), 4); + mapBase = (MapBase *) SysObject::operator new(0x1b0, data_027e0ce4, 4); if (mapBase != NULL) { - // mapBase = (MapBase *)func_ov015_02128dd8(mapBase, param_3, param_4); // Does not exist. + mapBase = (MapBase *) func_ov015_02128dd8(mapBase, param_3, param_4); // Does not exist. } this->mMap = mapBase; return; case 3: break; case 4: - // mapBase = (MapBase *) SysObject::operator_new(0x790, (astruct_19 **)(DWORD_027e0ce0 + 4), 4); + mapBase = (MapBase *) SysObject::operator new(0x790, data_027e0ce4, 4); if (mapBase != NULL) { - // mapBase = (MapBase *)func_ov012_0212b358(mapBase, param_3, param_4); // Does not exist. + mapBase = (MapBase *) func_ov012_0212b358(mapBase, param_3, param_4); // Does not exist. } this->mMap = mapBase; return; } - // mapBase = (MapBase *) SysObject::operator_new(0x790, (astruct_19 **)(DWORD_027e0ce0 + 4), 4); + mapBase = (MapBase *) SysObject::operator new(0x790, data_027e0ce4, 4); if (mapBase != NULL) { - // mapBase = (MapBase *)func_ov017_0215b4e8(mapBase, param_3, param_4); // Does not exist. + mapBase = (MapBase *) func_ov017_0215b4e8(mapBase, param_3, param_4); // Does not exist. } this->mMap = mapBase; } @@ -360,26 +380,25 @@ ARM void MapManager::MapData_vfunc_44() { } ARM void MapManager::func_ov00_02082808(s32 param_2) { - // How to define PTR_027e0d38 ? - // if (*(int*)(*(int*)PTR_027e0d38 + 0x14) == 1) { - // return; - // } - s32 var1; // = func_ov00_02084740() + if (*(int *) (*(int *) data_027e0d38 + 0x14) == 1) { + return; + } + s32 var1 = this->func_ov00_02084740(); s32 var2; if (param_2 == 0) { // var2 = thunk_FUN_0201f91c(DWORD_overlay_d_0_bss__020eec68); // What are these? if (var1 == var2) { return; } - // func_ov00_020d70a4(DWORD_overlay_d_0_bss__020eec68, var1, 0, 0x7f, param_3); // And these? + // func_ov000_020d70a4(DWORD_overlay_d_0_bss__020eec68, var1, 0, 0x7f, param_3); // And these? } else { - // var2 = func_ov00_020a5e9c(*(s32 *) PTR_027e0d38 + 0xc); + var2 = func_ov000_020a5e9c((unk32 *) data_027e0d38 + 0xc); if (var2 == 0) { // func_ov015_021849a4(DWORD_overlay_d_15_bss__02190458); } // func_ov00_020a5e9c(DWORD_overlay_d_0_bss__020eec68, var1, 0, 0x7f, param_3); } - // var1 = func_ov00_020a5e9c(*(s32 *) PTR_027e0d38 + 0xc); + var1 = func_ov000_020a5e9c((unk32 *) data_027e0d38 + 0xc); if (var1 == 0) { return; } @@ -564,14 +583,14 @@ ARM u32 MapManager::func_ov00_02082d74(unk32 param_2) { } ARM void MapManager::func_ov00_02082d84(unk8 *param_2, s32 *param_3, s32 *param_4) { - s32 mapWidth = this->GetMapWidth(); - u32 uVar3; // = CoDivide64By32(0x100000, mapWidth << 0xc); Not defined ? + s32 mapWidth = this->GetMapWidth(); + u32 uVar3 = CoDivide64By32(0x100000, mapWidth << 0xc); s32 mapHeight = this->GetMapHeight(); - u32 uVar4; // = CoDivide64By32(0xc0000, mapHeight << 0xc); Not defined ? - s64 lVar1 = (s64) (s32) ((u32) *param_2 << 0xc); - *param_3 = (s32) (((u32) lVar1 >> 0xc | (s32) ((u64) lVar1 >> 0x20) * 0x100000) + ((s32) uVar4 >> 1) + 0x800) >> 0xc; - lVar1 = (s64) (s32) ((u32) param_2[1] << 0xc) * (s64) (s32) uVar4 + 0x800; - *param_4 = (s32) (((u32) lVar1 >> 0xc | (s32) ((u64) lVar1 >> 0x20) * 0x100000) + ((s32) uVar4 >> 1) + 0x800) >> 0xc; + u32 uVar4 = CoDivide64By32(0xc0000, mapHeight << 0xc); + s64 lVar1 = (s64) (s32) ((u32) *param_2 << 0xc); + *param_3 = (s32) (((u32) lVar1 >> 0xc | (s32) ((u64) lVar1 >> 0x20) * 0x100000) + ((s32) uVar4 >> 1) + 0x800) >> 0xc; + lVar1 = (s64) (s32) ((u32) param_2[1] << 0xc) * (s64) (s32) uVar4 + 0x800; + *param_4 = (s32) (((u32) lVar1 >> 0xc | (s32) ((u64) lVar1 >> 0x20) * 0x100000) + ((s32) uVar4 >> 1) + 0x800) >> 0xc; } ARM bool MapManager::func_ov00_02082e1c(s32 *param_2, s32 *param_3) { @@ -597,7 +616,7 @@ ARM bool MapManager::func_ov00_02082e1c(s32 *param_2, s32 *param_3) { local_44[0] = -0x100; local_48 = -0x100; bVar1 = this->mMap->mUnk_01a; - // iVar5 = UnkStruct_027e0d38::FUN_overlay_d_0__02078b40(*(UnkStruct_027e0d38 **) PTR_PTR_overlay_d_0__02083068); + iVar5 = data_027e0d38->func_ov000_02078b40(); if (iVar5 == 0) { // bVar2 = *(u8 *) (*(s32 *) (*(s32 *) PTR_PTR_overlay_d_0__02083068 + 0x28) + 0x9a); } else { @@ -894,8 +913,8 @@ ARM unk32 MapManager::func_ov00_020835b4() { return this->mCourse->Get_Unk_c8_04(); } -ARM unk8 MapManager::func_ov00_020835c4(MapManager *param_1, s32 param_2, unk32 param_3) { - return param_1->mCourse->func_ov00_0207d404(param_2, 0, param_3); +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) { @@ -916,14 +935,7 @@ ARM unk8 MapManager::func_ov00_02083614(s32 param_2) { ARM bool MapManager::GetEntrancePos(Entrance *param_1, unk32 entranceId) { Entrance *entrance = this->mMap->FindEntrance(entranceId); - q20 y = entrance->mPos.y; - q20 z = entrance->mPos.z; - param_1->mPos.x = entrance->mPos.x; - param_1->mPos.y = y; - param_1->mPos.z = z; - param_1->mAngle = entrance->mAngle; - param_1->mId = entrance->mId; - param_1->mUnk_10 = entrance->mUnk_10; + *param_1 = *entrance; return true; } @@ -1099,8 +1111,10 @@ ARM s32 MapManager::func_ov00_020839f8(s32 param_2) { } ARM void MapManager::func_ov00_02083a1c(Vec2b *param_1, MapManager *param_2, Vec3p *param_3) { - param_1->x /*or y?*/ = param_2->func_ov00_020839f8(param_3->z); - param_1->y /*or x?*/ = param_2->func_ov00_020839d4(param_3->x); + 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) { @@ -1175,13 +1189,16 @@ ARM s32 MapManager::func_ov00_02083c50(unk32 z) { } ARM void MapManager::func_ov00_02083c7c(Vec3p *param_2, u32 param_3) { + q20 x; + q20 z; + q20 y; Vec3p local_28; - q20 x = this->func_ov00_02083c24(param_3 & 0xff); - // param_2->x = x; - q20 z = this->func_ov00_02083c50(param_3 >> 8 & 0xff); - // param_2->z = z; - q20 y = this->MapData_vfunc_68(&local_28, true); - // param_2->y = y; + x = this->func_ov00_02083c24(param_3 & 0xff); + param_2->x = x; + z = this->func_ov00_02083c50(param_3 >> 8 & 0xff); + param_2->z = z; + y = this->MapData_vfunc_68(&local_28, true); + param_2->y = y; } ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 param_3, s32 param_4, u32 param_5) { @@ -1612,6 +1629,7 @@ ARM s32 MapManager::func_ov00_02084700(MapManager *pMapManager) { unk8 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, @@ -1625,7 +1643,7 @@ unk8 MapManager::func_ov00_02084740() { unk32 uVar5; unk32 uVar6; unk32 uVar7; - unk32 *puVar8; + s32 *puVar8; unk32 *puVar9; unk32 local_1c8; unk32 local_1c4; @@ -1645,7 +1663,7 @@ unk8 MapManager::func_ov00_02084740() { } puVar9 = local_1bc; iVar3 = 0x1b; - // puVar8 = (unk32 *) PTR_DWORD_overlay_d_0__020d88f0_overlay_d_0__020847dc; + puVar8 = (s32 *) data_ov000_020d88f0; do { uVar4 = *puVar8; uVar5 = puVar8[1]; @@ -1717,17 +1735,17 @@ void MapManager::func_ov00_02084924(u32 param_2) { this->mMap->func_ov00_0208008c(param_2); } -bool MapManager::func_ov00_02084934(s32 *param_2) { - int iVar2; - int iVar3; - int iVar4; +bool MapManager::func_ov00_02084934(Vec3p *param_2) { + q20 iVar2; + q20 iVar3; + q20 iVar4; Vec3p local_20; iVar2 = this->GetMapCenterZ(); - iVar3 = param_2[2]; - iVar4 = param_2[1]; + iVar3 = param_2->z; + iVar4 = param_2->y; local_20.x = this->GetMapCenterX(); - local_20.x = *param_2 - local_20.x; + local_20.x = param_2->x - local_20.x; local_20.y = iVar4; local_20.z = iVar3 - iVar2; return this->mMap->IsInBounds(&local_20); @@ -1822,22 +1840,20 @@ unk8 MapManager::func_ov00_02084b38(unk32 param_2, unk32 param_3, unk32 param_4) if (param_2 != 0) { // value = SUB41(param_4, 0); // What is SUB41 and where is it defined? switch (param_3) { - case 0: goto LAB_overlay_d_0__02084b60; + case 0: + pMVar1 = this->mMap; + if (param_4 == 0) { + pMVar1->mUnk_180[param_2 >> 5].mUnk_0 = pMVar1->mUnk_180[param_2 >> 5].mUnk_0 & ~(1 << (param_2 & 0x1f)); + return; + } + pMVar1->mUnk_180[param_2 >> 5].mUnk_0 = pMVar1->mUnk_180[param_2 >> 5].mUnk_0 | 1 << (param_2 & 0x1f); + return; case 1: this->mCourse->SetMapDataFlag0(param_2, value); return; case 2: this->mCourse->SetFlag0(param_2, value); return; case 3: this->mCourse->SetFlag1(param_2, value); return; default: return; } } - return; -LAB_overlay_d_0__02084b60: - pMVar1 = this->mMap; - if (param_4 == 0) { - pMVar1->mUnk_180[param_2 >> 5].mUnk_0 = pMVar1->mUnk_180[param_2 >> 5].mUnk_0 & ~(1 << (param_2 & 0x1f)); - return; - } - pMVar1->mUnk_180[param_2 >> 5].mUnk_0 = pMVar1->mUnk_180[param_2 >> 5].mUnk_0 | 1 << (param_2 & 0x1f); - return; } bool MapManager::func_ov00_02084be0(u32 param_2, unk32 param_3) { @@ -1924,14 +1940,14 @@ u8 MapManager::GetMapData_Unk_09() { return this->mMap->mUnk_009; } -unk8 MapManager::func_ov00_02084d24(unk8 param_2, unk8 param_3, unk32 param_4) { +ARM void MapManager::func_ov00_02084d24(unk32 param_2, unk32 param_3, unk32 param_4) { unk8 local_8; unk8 local_7; unk16 uStack_6; uStack_6 = (unk16) ((u32) param_4 >> 0x10); - // _local_8 = CONCAT11(param_3, param_2); // What is CONCAT11 ? - // this->mMap->vfunc_90(&local_8, param_4); // Missing parameter ? + // _local_8 = CONCAT11(param_3, param_2); // What is CONCAT11 ? + this->mMap->vfunc_90(param_2, param_3, param_4); // Missing parameter ? } s32 MapManager::func_ov00_02084d4c(unk32 param_2, unk32 param_3, Vec3p *param_4) { @@ -2028,48 +2044,25 @@ unk32 MapManager::func_ov00_02084ebc(Vec3p *param_2) { } if (iVar2 < 0x2a) { switch (iVar2) { - case 0: break; - case 1: return 0; - case 2: return 0; - case 3: return 0; - case 4: return 0; - case 5: return 0; - case 6: return 0; - case 7: break; - case 8: return 0; - case 9: return 0; - case 10: break; - case 0xb: break; - case 0xc: break; - case 0xd: break; - case 0xe: break; - case 0xf: break; - case 0x10: break; - case 0x11: break; - case 0x12: break; - case 0x13: break; - case 0x14: return 0; - case 0x15: break; - case 0x16: return 0; - case 0x17: return 0; - case 0x18: break; - case 0x19: return 0; - case 0x1a: break; - case 0x1b: break; - case 0x1c: break; - case 0x1d: return 0; - case 0x1e: return 0; - case 0x1f: return 0; - case 0x20: break; - case 0x21: break; - case 0x22: break; - case 0x23: break; - case 0x24: break; - case 0x25: break; - case 0x26: break; - case 0x27: return 0; - case 0x28: return 0; + 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; -- cgit v1.2.3 From e93fedad570cf09fa0baaaed6789a35b074cbbfa Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sat, 12 Apr 2025 17:53:52 +0200 Subject: Add stdio.h lib --- src/00_Core/Map/MapManager.cpp | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 7e3e8399..d54c7b3b 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -8,6 +8,7 @@ #include "DTCM/UnkStruct_027e0d38.hpp" #include "Player/PlayerBase.hpp" #include "Save/AdventureFlags.hpp" +#include "stdio.h" extern bool func_01ffbe78(Vec3p *param1, Vec3p *param2, Vec3p *param3, Vec4p *param4); @@ -60,9 +61,6 @@ extern MapBase *func_ov017_0215b4e8(MapBase *param_1, unk32 param_2, unk32 param extern MapBase *func_ov018_0215b4a0(MapBase *param_1, unk32 param_2, unk32 param_3); -// Should this be defined? -extern int sprintf(char *__restrict s, const char *__restrict format, ...); - struct UnkStruct_02082348 { /* 00 */ unk32 mUnk_00; /* 04 */ unk32 mUnk_04; @@ -288,9 +286,8 @@ ARM void MapManager::func_ov00_020825ac() { } ARM s32 MapManager::GetCourseFilePath(char *courseName, char *buf) { - s32 var = sprintf(buf, "Map/%s/course.bin", courseName); // Should we manually define sprintf? + s32 var = sprintf(buf, "Map/%s/course.bin", courseName); return var; - // reference to func_ov000_020e2528 (changed to @1495 in symbols) } ARM void MapManager::func_ov00_020825e4(unk32 param_2, char *buf) { -- cgit v1.2.3 From 60e6b907127bbd84bd65cd569249cca42edb306c Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sun, 20 Apr 2025 12:12:51 +0200 Subject: Update --- src/00_Core/Map/MapManager.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index d54c7b3b..762bfd99 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -1938,13 +1938,13 @@ u8 MapManager::GetMapData_Unk_09() { } ARM void MapManager::func_ov00_02084d24(unk32 param_2, unk32 param_3, unk32 param_4) { - unk8 local_8; - unk8 local_7; + unk8 local_8 = param_2; + unk8 local_7 = param_3; unk16 uStack_6; uStack_6 = (unk16) ((u32) param_4 >> 0x10); - // _local_8 = CONCAT11(param_3, param_2); // What is CONCAT11 ? - this->mMap->vfunc_90(param_2, param_3, param_4); // Missing parameter ? + // _local_8 = CONCAT11(param_3, param_2); + this->mMap->vfunc_90(param_2, param_3, param_4); } s32 MapManager::func_ov00_02084d4c(unk32 param_2, unk32 param_3, Vec3p *param_4) { -- cgit v1.2.3 From 71ef8b58aad0315d839c3b2a4e996028d90952e6 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Mon, 21 Apr 2025 23:07:04 +0200 Subject: Decomp progress 36% --- src/00_Core/Map/MapManager.cpp | 80 ++++++++++++++++++++---------------------- 1 file changed, 39 insertions(+), 41 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 762bfd99..8164011e 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -6,6 +6,7 @@ #include "Actor/Actor.hpp" #include "Actor/ActorManager.hpp" #include "DTCM/UnkStruct_027e0d38.hpp" +#include "DTCM/UnkStruct_027e0fd4.hpp" #include "Player/PlayerBase.hpp" #include "Save/AdventureFlags.hpp" #include "stdio.h" @@ -1308,17 +1309,16 @@ ARM unk32 MapManager::MapData_vfunc_70(Vec3p *param_2) { } ARM void MapManager::func_ov00_02083fb0(u32 *param_1, MapManager *param_2, Vec3p *param_3) { - s32 iVar1; + Vec4p *iVar1; s32 dVar2; - iVar1 = param_2->mMap->vfunc_74(param_3); - if (iVar1 != 0) { - // iVar1 += 0xc; - *param_1 = iVar1; + iVar1 = (Vec4p *) param_2->mMap->vfunc_74(param_3); + if (iVar1 != NULL) { + *param_1 = iVar1->w; return; } dVar2 = param_2->MapData_vfunc_70(param_3); - if (iVar1 != 0xffff) { + if (dVar2 != 0xffff) { func_ov000_02093a1c(param_1, data_027e0f6c); return; } @@ -1342,26 +1342,24 @@ unk32 MapManager::MapData_vfunc_54(Vec2b *param_1) { return this->mMap->vfunc_54(param_1); } -unk8 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk32 param_4) { - Vec2b local_8; - unk8 local_7; - unk16 uStack_6; - - uStack_6 = (unk16) ((u32) param_4 >> 0x10); - // _local_8 = CONCAT11(param_3, param_2); - this->MapData_vfunc_54(&local_8); +ARM unk32 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3, unk16 param_4) { + // Correct param types? + Vec2b vec; + vec.x = param_2; + vec.y = param_3; + return this->mMap->vfunc_54(&vec); } -unk32 MapManager::MapData_vfunc_78(bool *param_1) { // bool* param placeholder for now, no way of knowing what the type is. +unk32 *MapManager::MapData_vfunc_78(Vec2b *param_1) { return this->mMap->vfunc_78(param_1); } -unk8 MapManager::func_ov00_020840dc() { - int *piVar1; +unk8 MapManager::func_ov00_020840dc(Vec2b *param_1) { + UnkStruct_027e0fd4 *piVar1; - piVar1 = (int *) this->MapData_vfunc_78(0); - if (piVar1 != (int *) 0x0) { - // (**(code **) (*piVar1 + 0x1c))(); // MapBase::func_ov00_0207f934() ?? + piVar1 = (UnkStruct_027e0fd4 *) this->MapData_vfunc_78(param_1); + if (piVar1 != NULL) { + piVar1->vfunc_1c(); } } @@ -1937,14 +1935,14 @@ u8 MapManager::GetMapData_Unk_09() { return this->mMap->mUnk_009; } -ARM void MapManager::func_ov00_02084d24(unk32 param_2, unk32 param_3, unk32 param_4) { - unk8 local_8 = param_2; - unk8 local_7 = param_3; - unk16 uStack_6; - - uStack_6 = (unk16) ((u32) param_4 >> 0x10); - // _local_8 = CONCAT11(param_3, param_2); - this->mMap->vfunc_90(param_2, param_3, param_4); +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_3 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) { @@ -2010,7 +2008,7 @@ unk32 MapManager::func_ov00_02084ebc(Vec3p *param_2) { u32 uStack_14; this->func_ov00_02083a1c(auStack_18, this, param_2); - piVar1 = (int *) this->MapData_vfunc_78(0); + piVar1 = (int *) this->MapData_vfunc_78(auStack_18); if (piVar1 != (int *) 0x0) { // iVar2 = (**(code **) (*piVar1 + 0x1c))(); if (iVar2 < 0x39) { @@ -2119,7 +2117,7 @@ s32 MapManager::func_ov00_02085108(s32 *param_2) { uVar5 = (u32) local_39; if ((u32) local_3a <= (u32) local_39) { do { - piVar3 = (int *) puVar1->MapData_vfunc_78(0); + // piVar3 = (int *) puVar1->MapData_vfunc_78(); if ((piVar3 != (int *) 0x0) && ((piVar3[1] & 4U) != 0)) { iVar7 = piVar3[7]; iVar6 = piVar3[6]; @@ -2196,7 +2194,7 @@ s32 MapManager::func_ov00_0208527c(MapManager *param_1, unk32 param_2, unk32 *pa return 0; } for (; (int) uVar1 <= (int) uVar6; uVar1 = uVar1 + 1) { - iVar4 = puVar2->MapData_vfunc_78(0); + // iVar4 = puVar2->MapData_vfunc_78(0); if (((iVar4 != 0) && ((*(u32 *) (iVar4 + 4) & 4) != 0)) && (iVar5 = func_ov000_0208b73c(iVar4, param_2), iVar5 != 0)) { @@ -2257,7 +2255,7 @@ s32 MapManager::func_ov00_020853fc(MapManager *param_1, Vec3p *param_2, s32 *par 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); + // 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)) @@ -2282,7 +2280,7 @@ unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 Vec3p VStack_20; param_1->func_ov00_02083a1c(&local_28, param_1, param_2); - piVar1 = (int *) param_1->MapData_vfunc_78(0); + piVar1 = (int *) param_1->MapData_vfunc_78(&local_28); bVar5 = true; if (piVar1 != (int *) 0x0) { param_2->x = piVar1[6]; @@ -2401,11 +2399,11 @@ unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 void MapManager::func_ov00_0208583c(MapManager *param_1, Vec3p *param_2, unk32 param_3) { s32 *piVar1; - unk8 auStack_10[4]; + Vec2b auStack_10[2]; // param_1->func_ov00_02083a1c(auStack_10, param_1, param_2); // Should auStack_10 be pointer type or not ? - piVar1 = (s32 *) param_1->MapData_vfunc_78(0); - if (piVar1 == (s32 *) 0x0) { + piVar1 = (unk32 *) param_1->MapData_vfunc_78(auStack_10); + if (piVar1 == (unk32 *) 0x0) { return; } // if (*(s32 *) PTR_UnkStruct_027e077c_overlay_d_0__020858ac == 1) { @@ -2447,7 +2445,7 @@ unk8 MapManager::func_ov00_020858b0(MapManager *param_1, Vec3p *param_2, s32 par if (iVar4 < 0) { iVar4 = -iVar4; } - if ((iVar4 < 0xce) && (piVar5 = (int *) param_1->MapData_vfunc_78(0), piVar5 != (int *) 0x0)) { + if ((iVar4 < 0xce) && (piVar5 = (int *) param_1->MapData_vfunc_78(&local_28), piVar5 != (int *) 0x0)) { // local_38 = (**(code **) (*piVar5 + 0x38))(piVar5, param_3); } } @@ -2479,7 +2477,7 @@ s32 MapManager::func_ov00_02085a34(Vec3p *param_2, s32 param_3) { return -1; } this->func_ov00_02083a1c(auStack_2a, this, param_2); - piVar1 = (int *) this->MapData_vfunc_78(0); + piVar1 = (int *) this->MapData_vfunc_78(auStack_2a); if (piVar1 == (int *) 0x0) { return -1; } @@ -2497,7 +2495,7 @@ s32 MapManager::func_ov00_02085a34(Vec3p *param_2, s32 param_3) { if (iVar2 == 0) { return -1; } - piVar1 = (int *) this->MapData_vfunc_78(0); + piVar1 = (int *) this->MapData_vfunc_78(aVStack_28); if (piVar1 != (int *) 0x0) { // iVar2 = (**(code **) (*piVar1 + 0x1c))(); if (0x38 < iVar2) { @@ -2539,7 +2537,7 @@ s32 MapManager::func_ov00_02085a34(Vec3p *param_2, s32 param_3) { if (iVar2 == 0) { return -1; } - iVar2 = MapData_vfunc_78(0); // Same here. + // iVar2 = MapData_vfunc_78(0); // Same here. if ((iVar2 != 0) && (0 < *(s16 *) (iVar2 + 0xe))) { return 1; } @@ -2769,7 +2767,7 @@ unk8 MapManager::func_ov00_02086044(Vec3p *param_2, Vec3p *param_3, unk32 param_ return 1; } } - piVar9 = (int *) this->MapData_vfunc_78(0); + 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; -- cgit v1.2.3 From 2025fdf4604ba6db6391ab8354352b707c5a9359 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Mon, 21 Apr 2025 23:26:30 +0200 Subject: Restore usa overlay symbols --- src/00_Core/Map/MapManager.cpp | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 8164011e..7a96bf04 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -71,16 +71,18 @@ struct UnkStruct_02082348 { /* 12 */ unk8 mUnk_12[0x4]; }; -extern s32 *data_027e0c68; +extern unk32 *data_027e0c68; extern u32 *data_027e0ce4; -extern s32 *data_027e0d3c; -extern s32 *data_027e0f64; -extern s32 *data_027e0f68; -extern s32 *data_027e0f6c; -extern s32 *data_027e0f70; -extern s32 *data_027e0f78; -extern s32 *data_027e0f7c; -extern s32 *data_027e103c; +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 unk32 *data_027e103c; + +extern unk32 *data_ov000_020e24a4; ARM void MapManager::GetCourseDungeonProgress(CourseProgress *param_2) { this->mCourse->GetDungeonProgress(param_2); @@ -1294,9 +1296,7 @@ ARM void MapManager::func_ov00_02083f44(Vec3p *param_2) { local_18.z = param_2->z; local_18.x = param_2->x; - /*local_18.y = *(int *)( - PTR_PTR_s_anc_overlay_d_0__020e24a0_overlay_d_0__020e24a4_overlay_d_0__02083f7c - + 0x20);*/ + local_18.y = *(data_ov000_020e24a4 + 0x10); this->func_ov00_02083ef8(param_2, &local_18); } @@ -1467,7 +1467,7 @@ unk8 MapManager::MapData_vfunc_a4(unk8 *param_1) { this->mMap->vfunc_a4(param_1); } -unk8 MapManager::func_ov00_0208433c(Vec3p *param_2, Vec3p *param_3) { +unk8 MapManager::func_ov00_0208433c(Vec3p *param_2, Vec2s *param_3) { Vec2s local_28; Vec3p VStack_24; Vec3p local_18; -- cgit v1.2.3 From a9af655856b791d5a6d4bf1b75c123a855e646bb Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Tue, 29 Apr 2025 22:12:35 +0200 Subject: Decomp progress 38% --- src/00_Core/Map/MapManager.cpp | 281 ++++++++++++++++++----------------------- 1 file changed, 126 insertions(+), 155 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 7a96bf04..8fb7c9d4 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -5,16 +5,18 @@ #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 "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 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); @@ -36,12 +38,13 @@ 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, s32 *param_2); +extern void func_ov000_02093a1c(u32 *param_1, unk32 *param_2, unk32 param_3); extern void func_ov000_02096324(s32 *param_1, s32 param_2); extern s32 *func_ov000_02096418(s32 *param_1); extern void func_ov000_0209d6e8(s32 param_1, s32 param_2); extern s32 func_ov000_0209d71c(s32 *param_1, s32 param_2); extern unk32 func_ov000_020a5e9c(unk32 *param_1); +extern void func_ov000_020c3348(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); @@ -58,9 +61,12 @@ 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 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); +// extern MapBase *func_ov018_0215b4a0(MapBase *param_1, unk32 param_2, unk32 param_3); + +struct astruct_16 {}; // What is this struct? struct UnkStruct_02082348 { /* 00 */ unk32 mUnk_00; @@ -68,13 +74,35 @@ struct UnkStruct_02082348 { /* 08 */ unk32 mUnk_08; /* 0c */ unk32 mUnk_0c; /* 10 */ unk16 mUnk_10; - /* 12 */ unk8 mUnk_12[0x4]; + /* 12 */ u8 mUnk_12[0x4]; + /* 16 */ +}; + +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 unk32 *data_027e0c68; -extern u32 *data_027e0ce4; +extern u32 *data_027e0ce0[]; extern unk32 *data_027e0d3c; -extern unk32 *data_027e0f64; +extern unk32 data_027e0f64[]; extern unk32 *data_027e0f68; extern unk32 *data_027e0f6c; extern unk32 *data_027e0f70; @@ -84,6 +112,10 @@ extern unk32 *data_027e103c; extern unk32 *data_ov000_020e24a4; +MapManager::MapManager() {} + +MapManager::~MapManager() {} + ARM void MapManager::GetCourseDungeonProgress(CourseProgress *param_2) { this->mCourse->GetDungeonProgress(param_2); } @@ -192,14 +224,14 @@ ARM void MapManager::func_ov00_02082348(unk32 *param_2) { unkStruct.mUnk_00 = 0x47; unkStruct.mUnk_04 = 0; unkStruct.mUnk_08 = 0; - unkStruct.mUnk_0c = 0; + unkStruct.mUnk_0c = -2; unkStruct.mUnk_10 = 0; - unkStruct.mUnk_12[0] = 0xff; + unkStruct.mUnk_12[0] = -1; unkStruct.mUnk_12[1] = 0; unkStruct.mUnk_12[2] = 0; unkStruct.mUnk_12[3] = 0; this->func_ov00_0208230c((s32 *) &unkStruct); - func_ov000_02078bf0((s32 *) &unkStruct, *param_2); + func_ov000_02078bf0((s32 *) &unkStruct, param_2); } ARM void MapManager::func_ov00_020823a4(unk32 param_2) { @@ -289,7 +321,7 @@ ARM void MapManager::func_ov00_020825ac() { } ARM s32 MapManager::GetCourseFilePath(char *courseName, char *buf) { - s32 var = sprintf(buf, "Map/%s/course.bin", courseName); + s32 var = sprintf(buf, "Map/%s/course.bin\0\0", courseName); return var; } @@ -328,39 +360,15 @@ ARM void MapManager::func_ov00_020826a0(unk32 param_2, unk32 param_3) { ARM void MapManager::CreateMap(unk32 mapType, unk32 param_3, unk32 param_4) { MapBase *mapBase; - if (this->mMap == NULL) { switch (mapType) { - case 0: - // data_027e0ce4 (data_027e0ce0) of type UnkStruct_0202e894 - SysObject::operator new(0x1dc, data_027e0ce4, 4); - if (mapBase != NULL) { - mapBase = (MapBase *) func_ov018_0215b4a0(mapBase, param_3, param_4); // Does not exist. - } - this->mMap = mapBase; - return; - case 1: break; - case 2: - mapBase = (MapBase *) SysObject::operator new(0x1b0, data_027e0ce4, 4); - if (mapBase != NULL) { - mapBase = (MapBase *) func_ov015_02128dd8(mapBase, param_3, param_4); // Does not exist. - } - this->mMap = mapBase; - return; - case 3: break; - case 4: - mapBase = (MapBase *) SysObject::operator new(0x790, data_027e0ce4, 4); - if (mapBase != NULL) { - mapBase = (MapBase *) func_ov012_0212b358(mapBase, param_3, param_4); // Does not exist. - } - this->mMap = mapBase; - return; + 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; } - mapBase = (MapBase *) SysObject::operator new(0x790, data_027e0ce4, 4); - if (mapBase != NULL) { - mapBase = (MapBase *) func_ov017_0215b4e8(mapBase, param_3, param_4); // Does not exist. - } - this->mMap = mapBase; } } @@ -582,15 +590,17 @@ ARM u32 MapManager::func_ov00_02082d74(unk32 param_2) { return func_ov000_02078bc4(param_2); } -ARM void MapManager::func_ov00_02082d84(unk8 *param_2, s32 *param_3, s32 *param_4) { +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); - s64 lVar1 = (s64) (s32) ((u32) *param_2 << 0xc); - *param_3 = (s32) (((u32) lVar1 >> 0xc | (s32) ((u64) lVar1 >> 0x20) * 0x100000) + ((s32) uVar4 >> 1) + 0x800) >> 0xc; - lVar1 = (s64) (s32) ((u32) param_2[1] << 0xc) * (s64) (s32) uVar4 + 0x800; - *param_4 = (s32) (((u32) lVar1 >> 0xc | (s32) ((u64) lVar1 >> 0x20) * 0x100000) + ((s32) uVar4 >> 1) + 0x800) >> 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) { @@ -663,7 +673,7 @@ ARM void MapManager::func_ov00_0208306c(s32 *param_2, s32 *param_3) { MapManager *pMVar1; s32 iVar2; MapManager *pMVar3; - unk8 auStack_2c[18]; + 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. @@ -1018,25 +1028,21 @@ ARM bool MapManager::func_ov00_02083790(s32 param_2) { } ARM bool MapManager::func_ov00_02083840(s32 param_2) { - s32 *puVar1; - s32 *puVar2; bool bVar3; s32 iVar4; - puVar2 = data_027e0d3c; - puVar1 = data_027e0f64; - if (param_2 != 0) { - *(unk32 *) (*(int *) (*(int *) data_027e0f64 + 8) + 0x1b4) = 0xffffffff; - *(unk32 *) (*(int *) (*(int *) puVar1 + 4) + 0x1b4) = 0xffffffff; - iVar4 = func_ov000_02078fe8(puVar2); - if (-1 < iVar4) { - func_ov000_020798bc(data_027e0d3c, 0x10); - gActorManager->func_ov00_020c3ce8(param_2, false); - } - bVar3 = this->mMap->TriggerOfType_vfunc_10(param_2); - return bVar3; + if (param_2 == 0) { + return true; } - 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) { @@ -1188,14 +1194,14 @@ 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, u32 param_3) { +ARM void MapManager::func_ov00_02083c7c(Vec3p *param_2, Vec2b *param_3) { q20 x; q20 z; q20 y; Vec3p local_28; - x = this->func_ov00_02083c24(param_3 & 0xff); + x = this->func_ov00_02083c24(param_3->x); param_2->x = x; - z = this->func_ov00_02083c50(param_3 >> 8 & 0xff); + z = this->func_ov00_02083c50(param_3->y); param_2->z = z; y = this->MapData_vfunc_68(&local_28, true); param_2->y = y; @@ -1291,13 +1297,12 @@ ARM s32 MapManager::func_ov00_02083ef8(Vec3p *param_2, Vec3p *param_3) { return iVar1; } -ARM void MapManager::func_ov00_02083f44(Vec3p *param_2) { +ARM unk32 MapManager::func_ov00_02083f44(Vec3p *param_2) { Vec3p local_18; - local_18.z = param_2->z; - local_18.x = param_2->x; - local_18.y = *(data_ov000_020e24a4 + 0x10); - this->func_ov00_02083ef8(param_2, &local_18); + local_18 = *param_2; + local_18.y = *(data_ov000_020e24a4 + 0x8); + return this->func_ov00_02083ef8(param_2, &local_18); } unk8 MapManager::MapData_vfunc_6c(unk32 param_2, unk32 param_3, unk32 param_4) { @@ -1309,17 +1314,17 @@ ARM unk32 MapManager::MapData_vfunc_70(Vec3p *param_2) { } ARM void MapManager::func_ov00_02083fb0(u32 *param_1, MapManager *param_2, Vec3p *param_3) { - Vec4p *iVar1; + Vec4p *iVar1; // Unsure s32 dVar2; iVar1 = (Vec4p *) param_2->mMap->vfunc_74(param_3); if (iVar1 != NULL) { - *param_1 = iVar1->w; + *param_1 = iVar1->w; // offset 0xc return; } dVar2 = param_2->MapData_vfunc_70(param_3); if (dVar2 != 0xffff) { - func_ov000_02093a1c(param_1, data_027e0f6c); + func_ov000_02093a1c(param_1, data_027e0f6c, dVar2); return; } *param_1 = 0; @@ -1354,13 +1359,14 @@ unk32 *MapManager::MapData_vfunc_78(Vec2b *param_1) { return this->mMap->vfunc_78(param_1); } -unk8 MapManager::func_ov00_020840dc(Vec2b *param_1) { - UnkStruct_027e0fd4 *piVar1; +unk32 MapManager::func_ov00_020840dc(Vec2b *param_1) { + UnkStruct_02037750 *piVar1; // placeholder struct until I can find the real struct - piVar1 = (UnkStruct_027e0fd4 *) this->MapData_vfunc_78(param_1); + piVar1 = (UnkStruct_02037750 *) this->MapData_vfunc_78(param_1); if (piVar1 != NULL) { - piVar1->vfunc_1c(); + return piVar1->vfunc_1c(); } + return -1; } unk8 MapManager::func_ov00_02084100(unk32 *param_1, MapManager *param_2) { @@ -1467,12 +1473,11 @@ unk8 MapManager::MapData_vfunc_a4(unk8 *param_1) { this->mMap->vfunc_a4(param_1); } -unk8 MapManager::func_ov00_0208433c(Vec3p *param_2, Vec2s *param_3) { - Vec2s local_28; +ARM void MapManager::func_ov00_0208433c(Vec3p *param_2, Vec2s *param_3) { + Vec3p local_18 = *param_2; Vec3p VStack_24; - Vec3p local_18; + Vec2s local_28; - local_18 = *param_2; this->GetMapMinBounds(&VStack_24); Vec3p_Sub(&local_18, &VStack_24, &local_18); this->mMap->func_ov00_0207f53c(&local_28, this->mMap, &local_18); @@ -1787,15 +1792,13 @@ u8 MapManager::func_ov00_02084a50() { } void MapManager::SpawnNPC(Vec3p *param_2, unk32 param_3, unk32 param_4) { - // astruct_16 aStack_3c; - // Actor_UnkStruct_020((Actor_UnkStruct_020 *) &aStack_3c); - // aStack_3c.field24_0x1c = 0xffffffff; - // aStack_3c.field25_0x20 = 0xffffffff; - // astruct_16::astruct_16(&aStack_3c); - // aStack_3c.field26_0x24 = param_3; - // aStack_3c.field27_0x28 = param_4; - // spawnNpc(*(undefined4 *) PTR_DWORD_overlay_d_0__02084abc, s_CIVE_overlay_d_0__02084ac0, param_2, &aStack_3c, - // (ActorRef *) 0x0); + astruct_16 aStack_3c; // = Actor_UnkStruct_020(); + // aStack_3c. = 0xffffffff; + // aStack_3c.field25_0x20 = 0xffffffff; + func_ov000_020c3348((unk32 *) &aStack_3c); + // aStack_3c.field26_0x24 = param_3; + // aStack_3c.field27_0x28 = param_4; + gActorSpawner->Spawn(ActorTypeId_EVIC, param_2, &aStack_3c, NULL); } ARM bool MapManager::func_ov00_02084ac4(u32 actorId) { @@ -1874,13 +1877,11 @@ bool MapManager::GetMapDataFlag1(unk32 param_2) { return this->mCourse->GetMapDataFlag1(param_2); } -void MapManager::func_ov00_02084c7c(unk32 param_2) { - bool in_r2; // not defined. - +void MapManager::func_ov00_02084c7c(unk32 param_2, bool param_3) { if (param_2 < 0) { return; } - this->mCourse->SetMapDataFlag2(param_2, in_r2); + this->mCourse->SetMapDataFlag2(param_2, param_3); } bool MapManager::func_ov00_02084c94(unk32 param_2) { @@ -1893,13 +1894,11 @@ bool MapManager::func_ov00_02084c94(unk32 param_2) { return false; } -void MapManager::func_ov00_02084cb0(unk32 param_2) { - bool in_r2; // not defined. - +void MapManager::func_ov00_02084cb0(unk32 param_2, bool param_3) { if (param_2 < 0) { return; } - this->mCourse->SetMapDataFlag3(param_2, in_r2); + this->mCourse->SetMapDataFlag3(param_2, param_3); } bool MapManager::func_ov00_02084cc8(unk32 param_2) { @@ -1912,13 +1911,11 @@ bool MapManager::func_ov00_02084cc8(unk32 param_2) { return false; } -void MapManager::func_ov00_02084ce4(unk32 param_2) { - unk32 in_r2; // not defined. - +void MapManager::func_ov00_02084ce4(unk32 param_2, bool param_3) { if (param_2 < 0) { return; } - this->mCourse->SetMapDataFlag4(param_2, in_r2); + this->mCourse->SetMapDataFlag4(param_2, param_3); } bool MapManager::func_ov00_02084cfc(unk32 param_2) { @@ -1938,7 +1935,7 @@ u8 MapManager::GetMapData_Unk_09() { 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_3 short or int? + // param_4 short or int? Vec2b vec; vec.x = param_2; vec.y = param_3; @@ -2078,7 +2075,7 @@ unk32 MapManager::func_ov00_02084ebc(Vec3p *param_2) { } // dVar3 = this->MapData_vfunc_70(); // Missing param. if (dVar3 != 0xffff) { - func_ov000_02093a1c(&uStack_14, data_027e0f6c); + func_ov000_02093a1c(&uStack_14, data_027e0f6c, dVar3); if ((uStack_14 >> 5 & 3) != 1) { return 0; } @@ -2274,7 +2271,7 @@ unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 unk32 dVar3; // dword unk32 uVar4; bool bVar5; - unk32 uStack_2c; + Vec2b uStack_2c[2]; Vec2b local_28; u32 uStack_24; Vec3p VStack_20; @@ -2313,59 +2310,32 @@ unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 } } iVar2 = param_1->func_ov00_020840a0(local_28.x, local_28.y, param_4); - if (iVar2 < 0x47) { - if (0x45 < iVar2) { - return 0; - } + if (iVar2 < 0x46) { if (iVar2 < 0x2a) { switch (iVar2) { - case 0: break; - case 1: return 0; - case 2: return 0; - case 3: return 0; - case 4: return 0; - case 5: return 0; - case 6: return 0; - case 7: break; - case 8: return 0; - case 9: return 0; - case 10: break; - case 0xb: break; - case 0xc: break; - case 0xd: break; - case 0xe: break; - case 0xf: break; - case 0x10: break; - case 0x11: break; - case 0x12: break; - case 0x13: break; - case 0x14: return 0; - case 0x15: break; - case 0x16: return 0; - case 0x17: return 0; - case 0x18: break; - case 0x19: return 0; - case 0x1a: break; - case 0x1b: break; - case 0x1c: break; - case 0x1d: return 0; - case 0x1e: return 0; - case 0x1f: return 0; - case 0x20: break; - case 0x21: break; - case 0x22: break; - case 0x23: break; - case 0x24: break; - case 0x25: break; - case 0x26: break; - case 0x27: return 0; - case 0x28: return 0; + 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 < 0x49) { + } else if (iVar2 < 0x48) { if (0x47 < iVar2) { return 0; } @@ -2375,15 +2345,16 @@ unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 } else if (iVar2 == 0x50) { return 0; } - iVar2 = param_1->mMap->vfunc_58(&local_28, 5); // no params + iVar2 = param_1->mMap->vfunc_58(&local_28, 5); if (iVar2 != 0) { return 0; } - // uStack_2c._0_2_ = CONCAT11(local_27, local_28); + uStack_2c[0].y = local_28.y; + uStack_2c[0].x = local_28.x; param_1->func_ov00_02083c7c(&VStack_20, uStack_2c); - // dVar3 = param_1->MapData_vfunc_70(); + dVar3 = param_1->MapData_vfunc_70(&VStack_20); if (dVar3 != 0xffff) { - func_ov000_02093a1c(&uStack_24, data_027e0f6c); + func_ov000_02093a1c(&uStack_24, data_027e0f6c, dVar3); if ((uStack_24 >> 5 & 3) != 1) { return 0; } @@ -2401,7 +2372,7 @@ void MapManager::func_ov00_0208583c(MapManager *param_1, Vec3p *param_2, unk32 p s32 *piVar1; Vec2b auStack_10[2]; - // param_1->func_ov00_02083a1c(auStack_10, param_1, param_2); // Should auStack_10 be pointer type or not ? + param_1->func_ov00_02083a1c(auStack_10, param_1, param_2); piVar1 = (unk32 *) param_1->MapData_vfunc_78(auStack_10); if (piVar1 == (unk32 *) 0x0) { return; -- cgit v1.2.3 From 780ed17043d22941ce1a8142ffc8683d3a35159b Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sun, 4 May 2025 17:05:56 +0200 Subject: Decomp progress 42% --- src/00_Core/Map/MapManager.cpp | 328 ++++++++++++++++++----------------------- 1 file changed, 145 insertions(+), 183 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 8fb7c9d4..81f11a9f 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -20,6 +20,7 @@ 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); @@ -39,12 +40,15 @@ 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(s32 *param_1, s32 param_2); +extern void func_ov000_02096324(unk32 *param_1, unk32 *param_2); extern s32 *func_ov000_02096418(s32 *param_1); -extern void func_ov000_0209d6e8(s32 param_1, s32 param_2); +extern void func_ov000_0209d6e8(unk32 *param_1, unk32 *param_2); extern s32 func_ov000_0209d71c(s32 *param_1, s32 param_2); extern unk32 func_ov000_020a5e9c(unk32 *param_1); extern void func_ov000_020c3348(unk32 *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); @@ -60,6 +64,7 @@ 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); @@ -111,6 +116,8 @@ extern unk32 *data_027e0f7c; extern unk32 *data_027e103c; extern unk32 *data_ov000_020e24a4; +extern unk32 data_ov000_020eec68; +extern unk32 data_ov015_02190458; MapManager::MapManager() {} @@ -124,92 +131,62 @@ ARM void MapManager::func_ov00_020820fc(s32 param_2, unk32 param_3, unk32 param_ this->mCourse->func_ov00_0207ca28(param_2, param_3, param_4); } -unk8 MapManager::func_ov00_0208210c(unk32 param_2, unk32 *param_3) { - unk32 *puVar1; - unk8 uVar2; - unk32 uVar3; - s32 iVar4; - unk32 local_40; - unk32 local_3c; - unk32 local_38; - unk32 local_34; - unk16 local_30; - unk8 local_2e; - unk8 local_2d; - unk8 local_2c; - unk8 local_2b; - unk32 local_28; - unk32 local_24; - unk32 local_20; - unk32 local_1c; - unk16 local_18; - unk8 local_16; - unk8 local_15; - unk8 local_14; - unk8 local_13; - - local_28 = 0x47; - local_24 = 0; - local_20 = 0; - local_1c = 0xfffffffe; - local_18 = 0; - local_16 = 0xff; - local_15 = 0; - local_14 = 0; - local_13 = 0; - if (param_2 == 0) { - this->func_ov00_02082348(&local_28); - uVar3 = func_ov000_020a5e9c(&local_28); - *param_3 = uVar3; - *(unk8 *) (param_3 + 1) = local_16; - uVar2 = local_15; +ARM void MapManager::func_ov00_0208210c(unk32 param_2, unk32 *param_3) { + void *pvVar3; + 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[0] = -1; + local_40[1].mUnk_12[1] = 0; + local_40[1].mUnk_12[2] = 0; + local_40[1].mUnk_12[3] = 0; + if (param_2 != 0) { + *param_3 = 0xb; + *(unk8 *) (param_3 + 1) = 2; + *(u8 *) ((int) param_3 + 5) = 4; } else { - *param_3 = 0xb; - *(unk8 *) (param_3 + 1) = 2; - uVar2 = 4; - } - *(unk8 *) ((int) param_3 + 5) = uVar2; - // uVar3 = func_ov000_020a5e9c(data_027e0d38->mUnk_28) + 0x1c; - puVar1 = (s32 *) data_027e0d38; - param_3[2] = uVar3; - *(unk8 *) (param_3 + 4) = *(unk8 *) (*(s32 *) (*(s32 *) puVar1 + 0x28) + 0x2e); - *(unk16 *) (param_3 + 5) = *(unk16 *) (*(s32 *) (*(s32 *) puVar1 + 0x28) + 0x36); - iVar4 = *(s32 *) (*(int *) puVar1 + 0x28); - param_3[6] = *(unk32 *) (iVar4 + 0x38); - param_3[7] = *(unk32 *) (iVar4 + 0x3c); - param_3[8] = *(unk32 *) (iVar4 + 0x40); - uVar3 = func_ov000_020a5e9c(puVar1 + 0x28) + 0x44; - param_3[3] = uVar3; - puVar1 = (s32 *) data_027e0d38; - *(unk8 *) ((int) param_3 + 0x11) = *(unk8 *) (*(s32 *) (*(s32 *) data_027e0d38 + 0x28) + 0x56); - iVar4 = *(s32 *) (*(s32 *) puVar1 + 0x28); - param_3[9] = *(unk32 *) (iVar4 + 0x5c); - param_3[10] = *(unk32 *) (iVar4 + 0x60); - param_3[0xb] = *(unk32 *) (iVar4 + 100); - *(unk16 *) ((int) param_3 + 0x16) = *(unk16 *) (*(s32 *) (*(s32 *) puVar1 + 0x28) + 0x68); - iVar4 = *(s32 *) (*(s32 *) puVar1 + 0x28); - local_40 = *(unk32 *) (iVar4 + 0x70); - local_3c = *(unk32 *) (iVar4 + 0x74); - local_38 = *(unk32 *) (iVar4 + 0x78); - local_34 = *(unk32 *) (iVar4 + 0x7c); - local_30 = *(unk16 *) (iVar4 + 0x80); - local_2e = *(unk8 *) (iVar4 + 0x82); - local_2d = *(unk8 *) (iVar4 + 0x83); - local_2c = *(unk8 *) (iVar4 + 0x84); - local_2b = *(unk8 *) (iVar4 + 0x85); - uVar3 = func_ov000_020a5e9c(&local_40); - param_3[0x70] = uVar3; - puVar1 = (s32 *) data_027e0f70; - *(unk8 *) ((int) param_3 + 0x1be) = local_2e; - *(unk8 *) ((int) param_3 + 0x1bf) = local_2d; - func_ov000_02096324(puVar1, *param_3); // unsure if (s32 *param_1, s32 param_2) or (s32 param_1, s32 *param_2) - func_ov000_0209d6e8(*data_027e0f7c, *param_3); + this->func_ov00_02082348((unk32 *) &local_40[1]); + *param_3 = func_ov000_020a5e9c((unk32 *) &local_40[1]); + *(unk8 *) (param_3 + 1) = local_40[1].mUnk_12[0]; + *(u8 *) ((int) param_3 + 5) = local_40[1].mUnk_12[1]; + } + param_3[2] = func_ov000_020a5e9c((unk32 *) ((unk32) (data_027e0d38->mUnk_28) + 0x1c)); + *(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] = func_ov000_020a5e9c((unk32 *) ((unk32) data_027e0d38->mUnk_28 + 0x44)); + *(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[0] = *(u8 *) ((int) pvVar3 + 0x82); + local_40[0].mUnk_12[1] = *(u8 *) ((int) pvVar3 + 0x83); + local_40[0].mUnk_12[2] = *(u8 *) ((int) pvVar3 + 0x84); + local_40[0].mUnk_12[3] = *(u8 *) ((int) pvVar3 + 0x85); + param_3[0x70] = func_ov000_020a5e9c((unk32 *) &local_40[0]); + *(u8 *) ((int) param_3 + 0x1be) = local_40[0].mUnk_12[0]; + *(u8 *) ((int) param_3 + 0x1bf) = local_40[0].mUnk_12[1]; + func_ov000_02096324(data_027e0f70, param_3); + func_ov000_0209d6e8(data_027e0f7c, param_3); if (this->mCourse->mType != CourseType_TempleOfTheOceanKing) { - *(unk8 *) ((int) param_3 + 7) = this->mUnk_08; + *(unk8 *) ((int) param_3 + 7) = (u8) this->mUnk_08; *(unk8 *) (param_3 + 0x6f) = this->mUnk_09; - return; } - return; } ARM void MapManager::func_ov00_0208230c(s32 *param_2) { @@ -388,29 +365,31 @@ ARM void MapManager::MapData_vfunc_44() { } ARM void MapManager::func_ov00_02082808(s32 param_2) { - if (*(int *) (*(int *) data_027e0d38 + 0x14) == 1) { + int iVar1; + int iVar2; + + if (data_027e0d38->mUnk_14 == 1) { return; } - s32 var1 = this->func_ov00_02084740(); - s32 var2; - if (param_2 == 0) { - // var2 = thunk_FUN_0201f91c(DWORD_overlay_d_0_bss__020eec68); // What are these? - if (var1 == var2) { - return; + iVar1 = this->func_ov00_02084740(); + if (param_2 != 0) { + iVar2 = func_ov000_020a5e9c(&data_027e0d38->mUnk_0c); + if (iVar2 == 0) { + func_ov015_021849a4(&data_ov015_02190458); } - // func_ov000_020d70a4(DWORD_overlay_d_0_bss__020eec68, var1, 0, 0x7f, param_3); // And these? + func_ov000_020d70a4(&data_ov000_020eec68, iVar1, 0, 0x7f); } else { - var2 = func_ov000_020a5e9c((unk32 *) data_027e0d38 + 0xc); - if (var2 == 0) { - // func_ov015_021849a4(DWORD_overlay_d_15_bss__02190458); + iVar2 = func_ov000_020d7424(&data_ov000_020eec68); + if (iVar1 == iVar2) { + return; } - // func_ov00_020a5e9c(DWORD_overlay_d_0_bss__020eec68, var1, 0, 0x7f, param_3); + func_ov000_020d70a4(&data_ov000_020eec68, iVar1, 0, 0x7f); } - var1 = func_ov000_020a5e9c((unk32 *) data_027e0d38 + 0xc); - if (var1 == 0) { + iVar1 = func_ov000_020a5e9c(&data_027e0d38->mUnk_0c); + if (iVar1 == 0) { return; } - // func_ov00_020d72b8(DWORD_overlay_d_0_bss__020eec68); + 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]) { @@ -430,78 +409,73 @@ ARM u8 MapManager::GetNumMaps() { } ARM s32 MapManager::func_ov00_02082914(unk32 param_2) { - int iVar1; - int iVar2; + void *pvVar1; int iVar3; int iVar4; - int local_50; - int local_48; + int iVar5; + Vec3p pVar1; Entrance local_44; Entrance local_30; switch (param_2) { case 0xfa: - // iVar1 = *(int *)(*(int *) PTR_027e0d38 + 0x28); // define PTR_027e0d38 - local_30.mPos.x = *(int *) (iVar1 + 0x5c); - local_30.mPos.y = *(int *) (iVar1 + 0x60); - local_30.mPos.z = *(int *) (iVar1 + 100); - local_30.mAngle = *(unk16 *) (iVar1 + 0x68); - local_30.mId = *(u8 *) (iVar1 + 0x6a); - local_30.mUnk_10 = *(int *) (iVar1 + 0x6c); - iVar1 = this->mMap->AddEntrance(&local_30); - return iVar1; - case 0xfb: break; - case 0xfc: break; - case 0xfd: break; + 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: goto switchD_overlay_d_0; + default: return (int) this; } - local_44.mId = 0xff; + local_44.mId = -1; local_44.mUnk_10 = 0; - // iVar1 = *(int *) (*(int *) PTR_027e0d38 + 0x28); // define PTR_027e0d38 - local_50 = *(int *) (iVar1 + 0x38); - iVar2 = *(int *) (iVar1 + 0x3c); - local_48 = *(int *) (iVar1 + 0x40); - iVar1 = 0x2000; - iVar3 = 0x2000; - iVar4 = 0xfd; + pvVar1 = data_027e0d38->mUnk_28; + pVar1 = *(Vec3p *) ((int) pvVar1 + 0x38); + iVar3 = 0x2000; + iVar4 = 0x2000; + iVar5 = 0xfd; if (this->mCourse->mType == CourseType_Sea) { - iVar1 = this->mMap->vfunc_88(); - iVar1 = iVar1 + 0xa000; - iVar3 = this->mMap->vfunc_8c(); + iVar3 = this->mMap->vfunc_88(); iVar3 = iVar3 + 0xa000; - iVar4 = 0xfe; + iVar4 = this->mMap->vfunc_8c(); + iVar4 = iVar4 + 0xa000; + iVar5 = 0xfe; } local_44.mAngle = 0; switch (param_2) { case 0xfb: - local_48 = this->GetMapMaxZ(); - local_48 = local_48 - iVar3; + pVar1.z = this->GetMapMaxZ(); + pVar1.z = pVar1.z - iVar4; local_44.mAngle = 0x8000; break; case 0xfc: - local_48 = this->GetMapMinZ(); - local_48 = iVar3 + local_48; + pVar1.z = this->GetMapMinZ(); + pVar1.z = iVar4 + pVar1.z; local_44.mAngle = 0; break; case 0xfd: - local_50 = this->GetMapMaxX(); - local_50 = local_50 - iVar1; + pVar1.x = GetMapMaxX(); + pVar1.x = pVar1.x - iVar3; local_44.mAngle = 0xc000; break; case 0xfe: - local_50 = this->GetMapMinX(); - local_50 = iVar1 + local_50; + pVar1.x = GetMapMinX(); + pVar1.x = iVar3 + pVar1.x; local_44.mAngle = 0x4000; } - local_44.mId = (u8) param_2; - local_44.mPos.x = local_50; - local_44.mPos.z = local_48; - local_44.mPos.y = iVar2; - local_44.mUnk_10 = iVar4; - // this = (MapManager *) this->mMap->AddEntrance(&local_44); // huh ???? -switchD_overlay_d_0: - return (int) this; // what ??????? + 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() { @@ -1004,27 +978,23 @@ ARM bool MapManager::GetOverlappingTrigger(Vec3p *param_2) { } ARM bool MapManager::func_ov00_02083790(s32 param_2) { - unk8 *puVar1; - unk8 *puVar2; - bool bVar3; - s32 iVar4; - s32 iStack_18; - s32 aiStack_14[2]; + bool bVar1; + int iVar2; + int aiStack_14; + int iStack_18; - // puVar2 = PTR_PTR_overlay_d_0__02083834; - // puVar1 = PTR_DWORD_overlay_d_0__02083830; - if (param_2 != 0) { - // *(s32 *) (*(s32 *) (*(s32 *) PTR_DWORD_overlay_d_0__02083830 + 8) + 0x1b4) = param_2; - *(s32 *) (*(s32 *) (*(s32 *) puVar1 + 4) + 0x1b4) = param_2; - // iVar4 = UnkStruct_027e0d38::FUN_overlay_d_0__02078b40(*(UnkStruct_027e0d38 **) puVar2); - if ((iVar4 != 0) && (bVar3 = this->func_ov00_02082e1c(aiStack_14, &iStack_18), !bVar3)) { - // FUN_overlay_d_0__02079898(*(undefined4 *) PTR_DWORD_overlay_d_0__02083838, param_2, 0x10); - gActorManager->func_ov00_020c3ce8(param_2, true); - } - bVar3 = this->mMap->AnyTrigger_func_0c(param_2); - return bVar3; + if (param_2 == 0) { + return true; } - 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) { @@ -1195,16 +1165,11 @@ ARM s32 MapManager::func_ov00_02083c50(unk32 z) { } ARM void MapManager::func_ov00_02083c7c(Vec3p *param_2, Vec2b *param_3) { - q20 x; - q20 z; - q20 y; Vec3p local_28; - x = this->func_ov00_02083c24(param_3->x); - param_2->x = x; - z = this->func_ov00_02083c50(param_3->y); - param_2->z = z; - y = this->MapData_vfunc_68(&local_28, true); - param_2->y = y; + 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(MapManager *param_1, s32 *param_2, u32 param_3, s32 param_4, u32 param_5) { @@ -1627,7 +1592,7 @@ ARM s32 MapManager::func_ov00_02084700(MapManager *pMapManager) { return iVar1; } -unk8 MapManager::func_ov00_02084740() { +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, @@ -1831,25 +1796,22 @@ bool MapManager::GetBlueWarpOpen() { return this->mCourse->mBlueWarpOpen; } -unk8 MapManager::func_ov00_02084b38(unk32 param_2, unk32 param_3, unk32 param_4) { +unk8 MapManager::func_ov00_02084b38(unk32 param_2, unk32 param_3, bool param_4) { MapBase *pMVar1; - bool value; - if (param_2 != 0) { - // value = SUB41(param_4, 0); // What is SUB41 and where is it defined? switch (param_3) { case 0: pMVar1 = this->mMap; - if (param_4 == 0) { + if (!param_4) { pMVar1->mUnk_180[param_2 >> 5].mUnk_0 = pMVar1->mUnk_180[param_2 >> 5].mUnk_0 & ~(1 << (param_2 & 0x1f)); return; } pMVar1->mUnk_180[param_2 >> 5].mUnk_0 = pMVar1->mUnk_180[param_2 >> 5].mUnk_0 | 1 << (param_2 & 0x1f); - return; - case 1: this->mCourse->SetMapDataFlag0(param_2, value); return; - case 2: this->mCourse->SetFlag0(param_2, value); return; - case 3: this->mCourse->SetFlag1(param_2, value); return; - default: return; + 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; } } } -- cgit v1.2.3 From 0d060f1d81066b141bba92578c7f839130dc1b2b Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Thu, 8 May 2025 14:10:16 +0200 Subject: Decomp progress 43% --- src/00_Core/Map/MapManager.cpp | 173 +++++++++++++++++++---------------------- 1 file changed, 79 insertions(+), 94 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 81f11a9f..1ec099d4 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -56,6 +56,7 @@ extern void func_ov004_02102b28(s32 *param_1); extern void func_ov004_02102e3c(s32 *param_1); extern void func_ov004_02105578(ActorManager *param_1, u32 param_2); extern void func_ov004_02105608(ActorManager *param_1, unk32 param_2, unk32 param_3, unk32 param_4); +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); @@ -73,13 +74,17 @@ extern MapBase *func_ov017_0215b4e8(MapBase *param_1, unk32 param_2, unk32 param struct astruct_16 {}; // 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[0x4]; + /* 12 */ u8 mUnk_12; + /* 13 */ u8 mUnk_13; + /* 14 */ u8 mUnk_14; + /* 15 */ u8 mUnk_15; /* 16 */ }; @@ -135,15 +140,15 @@ ARM void MapManager::func_ov00_0208210c(unk32 param_2, unk32 *param_3) { void *pvVar3; 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[0] = -1; - local_40[1].mUnk_12[1] = 0; - local_40[1].mUnk_12[2] = 0; - local_40[1].mUnk_12[3] = 0; + 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; @@ -151,8 +156,8 @@ ARM void MapManager::func_ov00_0208210c(unk32 param_2, unk32 *param_3) { } else { this->func_ov00_02082348((unk32 *) &local_40[1]); *param_3 = func_ov000_020a5e9c((unk32 *) &local_40[1]); - *(unk8 *) (param_3 + 1) = local_40[1].mUnk_12[0]; - *(u8 *) ((int) param_3 + 5) = local_40[1].mUnk_12[1]; + *(unk8 *) (param_3 + 1) = local_40[1].mUnk_12; + *(u8 *) ((int) param_3 + 5) = local_40[1].mUnk_13; } param_3[2] = func_ov000_020a5e9c((unk32 *) ((unk32) (data_027e0d38->mUnk_28) + 0x1c)); *(u8 *) (param_3 + 4) = *(u8 *) ((int) data_027e0d38->mUnk_28 + 0x2e); @@ -174,13 +179,13 @@ ARM void MapManager::func_ov00_0208210c(unk32 param_2, unk32 *param_3) { 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[0] = *(u8 *) ((int) pvVar3 + 0x82); - local_40[0].mUnk_12[1] = *(u8 *) ((int) pvVar3 + 0x83); - local_40[0].mUnk_12[2] = *(u8 *) ((int) pvVar3 + 0x84); - local_40[0].mUnk_12[3] = *(u8 *) ((int) pvVar3 + 0x85); + 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); param_3[0x70] = func_ov000_020a5e9c((unk32 *) &local_40[0]); - *(u8 *) ((int) param_3 + 0x1be) = local_40[0].mUnk_12[0]; - *(u8 *) ((int) param_3 + 0x1bf) = local_40[0].mUnk_12[1]; + *(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) { @@ -198,15 +203,15 @@ ARM void MapManager::func_ov00_0208230c(s32 *param_2) { 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[0] = -1; - unkStruct.mUnk_12[1] = 0; - unkStruct.mUnk_12[2] = 0; - unkStruct.mUnk_12[3] = 0; + 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); } @@ -364,7 +369,7 @@ ARM void MapManager::MapData_vfunc_44() { this->mMap->vfunc_44(); } -ARM void MapManager::func_ov00_02082808(s32 param_2) { +ARM void MapManager::func_ov00_02082808(bool param_2) { int iVar1; int iVar2; @@ -372,7 +377,7 @@ ARM void MapManager::func_ov00_02082808(s32 param_2) { return; } iVar1 = this->func_ov00_02084740(); - if (param_2 != 0) { + if (!param_2) { iVar2 = func_ov000_020a5e9c(&data_027e0d38->mUnk_0c); if (iVar2 == 0) { func_ov015_021849a4(&data_ov015_02190458); @@ -489,12 +494,12 @@ ARM s32 *MapManager::func_ov00_02082adc() { ARM void MapManager::func_ov00_02082af4() { func_ov000_0208cc88(data_027e0f68); this->mMap->vfunc_48(); - this->func_ov00_02082808(0); - this->mUnk_0a = 1; - this->mUnk_0b = 0; + this->func_ov00_02082808(false); + this->mUnk_0a = true; + this->mUnk_0b = false; } -bool MapManager::func_ov00_02082b3c(s32 param_2) { +bool MapManager::func_ov00_02082b3c(unk32 *param_2) { u8 bVar1; PlayerBase *puVar2; u16 uVar3; @@ -514,15 +519,15 @@ bool MapManager::func_ov00_02082b3c(s32 param_2) { gAdventureFlags->func_ov00_020976c8(); puVar2 = gPlayer; this->mUnk_0c = *(unk32 *) (param_2 + 0x13); - // (**(code **) (**(int **) puVar2 + 0x38))(*(int **) puVar2, *(unk32 *) (param_2 + 0x13), 0); - // UnkStruct_027e0c68::FUN_overlay_d_4__02106db8((UnkStruct_027e0c68 *) PTR_DWORD_overlay_d_0__02082d04); + // puVar2->TeleportToEntrance(*(unk32 *) (param_2 + 0x13), false); + // (**(code **) (**(int **) puVar2 + 0x38))(*(int **) puVar2, *(unk32 *) (param_2 + 0x13), 0); + // func_ov004_02106db8(data_027e0c68); this->mMap->vfunc_18(); } else { gAdventureFlags->func_ov00_020976c8(); func_ov000_0208b13c(data_027e0f64); - pAVar6 = gActorManager; - uVar5 = this->func_ov00_02082d08(); - func_ov004_02105608(pAVar6, local_18 & 0xff, local_18 >> 8 & 0xff, uVar5); + uVar5 = this->func_ov00_02082d08(); + gActorManager->func_ov004_02105608(local_18 & 0xff, local_18 >> 8 & 0xff, uVar5); this->mMap->vfunc_2c(); func_ov004_02102b28(data_027e0f68); func_ov004_02102770(data_027e0f6c); @@ -532,8 +537,9 @@ bool MapManager::func_ov00_02082b3c(s32 param_2) { uVar4 = this->mCourse->FindMapData_Unk_04((u32) bVar1); (this->mCourse->mCurrMapPos).x = (u8) local_18; (this->mCourse->mCurrMapPos).y = (u8) * (&local_18 + 0x4); // I assume this is what Ghidra means by "local_18._1_1_" - func_ov004_021024c4(param_2, uVar3 != uVar4, 0); + this->func_ov004_021024c4(param_2, uVar3 != uVar4, 0); func_ov004_02105578(gActorManager, (u32) * (u8 *) (param_2 + 0x12)); + // data_027e0d3c-> // UnkStruct_027e0103c::thunk_FUN_overlay_d_0__020cf7e8(*PTR_PTR_overlay_d_0__02082cfc); } return true; @@ -715,40 +721,24 @@ ARM void MapManager::func_ov00_0208315c(s32 *param_2, s32 *param_3) { this->func_ov00_02083298(uVar1, &local_20, param_2, param_3); } -ARM void MapManager::func_ov00_02083244(u32 param_2, s32 *param_3, s32 *param_4, s32 *param_5) { - unk8 *puVar1; - - // puVar1 = PTR_MapManager_Unk2_overlay_d_0__020e24e8.field1_0x4_overlay_d_0__02083294; // What is this? mMap? - if (3 < param_2) { // Objdiff wants (4 < param_2), why is that? +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 - *(s32 *) (PTR_MapManager_Unk2_overlay_d_0__020e24e8_overlay_d_0__02083290 + param_2 * 8)) + 0x800 >> 0xc;*/ - *param_5 = (param_3[2] - *(s32 *) (puVar1 + param_2 * 8)) + 0x800 >> 0xc; + // *param_4 = (param_3->x - (&data_ov000_020e24e8)[param_2].mUnk_00) + 0x800 >> 0xc; + // *param_5 = (param_3->z - (&data_ov000_020e24ec)[param_2].mUnk_04) + 0x800 >> 0xc; } ARM void MapManager::func_ov00_02083298(u32 param_2, Vec3p *param_3, s32 *param_4, s32 *param_5) { - if (3 < param_2) { // Objdiff wants (4 < param_2), why is that? + if (3 < param_2) { param_2 = 0; } - /* *param_4 = - *(s32 *) (PTR_MapManager_Unk1_overlay_d_0__020e24c8_overlay_d_0__02083300 + param_2 * 8) + - ((*param_3 - *(s32 *) (PTR_MapManager_Unk2_overlay_d_0__020e24e8_overlay_d_0__020832fc + param_2 * 8) >> 1) + 0x800 >> - 0xc); + /* + *param_4 = + (&data_ov000_020e24c8)[param_2].mUnk_00 + ((param_3->x - (&data_ov000_020e24e8)[param_2].mUnk_00 >> 1) + 0x800 >> 0xc); *param_5 = - *(s32 *) (PTR_MapManager_Unk1_overlay_d_0__020e24c8.field1_0x4_overlay_d_0__02083308 + param_2 * 8) + - ((param_3[2] - *(s32 *) (PTR_MapManager_Unk2_overlay_d_0__020e24e8.field1_0x4_overlay_d_0__02083304 + param_2 * 8) >> - 1) + - 0x800 >> - 0xc); */ - - // [!] BELOW IS NOT CODE: - // PTR_MapManager_Unk1_overlay_d_0__020e24c8_overlay_d_0__02083300 - // PTR_MapManager_Unk2_overlay_d_0__020e24e8_overlay_d_0__020832fc - // PTR_MapManager_Unk1_overlay_d_0__020e24c8.field1_0x4_overlay_d_0__02083308 - // PTR_MapManager_Unk2_overlay_d_0__020e24e8.field1_0x4_overlay_d_0__02083304 - // - // What are these pointers and fields? How should they be defined? + (&data_ov000_020e24c8)[param_2].mUnk_04 + ((param_3->z - (&data_ov000_020e24e8)[param_2].mUnk_04 >> 1) + 0x800 >> 0xc); + */ } ARM bool MapManager::GetCourseData_Unk_25c() { @@ -881,7 +871,7 @@ ARM void MapManager::func_ov00_02083560(Vec2b *param_1, MapManager *param_2, u32 param_2->mCourse->FindMapGridPos(param_1, param_2->mCourse, param_3); } -ARM u8 MapManager::func_ov00_02083570(unk32 param_2, unk32 param_3) { +ARM u8 MapManager::func_ov00_02083570(u8 param_2, u8 param_3) { return this->mCourse->mMapGrid[param_2][param_3]; } @@ -1213,61 +1203,56 @@ ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 p } ARM s32 MapManager::func_ov00_02083e34(unk8 param_2, unk8 param_3, unk32 param_4) { - u8 local_8; - u8 local_7; + Vec2b local_8; // unk16 uStack_6; // Unused. // uStack_6 = (unk16) ((u32) param_4 >> 0x10); - local_8 = param_2; // Likely a struct - *(&local_8 + 1) = param_3; + local_8.x = param_2; // Likely a struct + local_8.y = param_3; return this->mMap->vfunc_60(&local_8); } -ARM unk32 MapManager::MapData_vfunc_60(u8 *param_1) { // should the param be bool*? +ARM unk32 MapManager::MapData_vfunc_60(Vec2b *param_1) { // should the param be bool*? return this->mMap->vfunc_60(param_1); } -ARM bool MapManager::func_ov00_02083e70() { +ARM bool MapManager::func_ov00_02083e70(Vec2b *param_2) { int iVar1; int iVar2; - iVar1 = this->MapData_vfunc_54(0); - if (iVar1 < 0x2c) { - if ((0x2a < iVar1) || (iVar1 == 0x1b)) { - return true; - } - } else if (((iVar1 < 0x50) && (0x4d < iVar1)) && (iVar1 == 0x4e || iVar1 == 0x4f)) { - return true; + iVar1 = this->MapData_vfunc_54(param_2); + + switch (iVar1) { + case 0x1b: + case 0x2b: + case 0x4e: + case 0x4f: return true; } - iVar1 = this->MapData_vfunc_60(0); + + iVar1 = this->MapData_vfunc_60(param_2); iVar2 = this->GetMapData_Unk_48(); - return iVar2 <= iVar1; + 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) { - int iVar1; - Vec3p local_18; +ARM s32 MapManager::func_ov00_02083ef8(Vec3p *param_2, Vec3p *param_3, bool param_4) { + Vec3p local_18 = *param_2; - local_18.x = param_2->x; - local_18.z = param_2->z; - local_18.y = param_2->y; - if (param_2->y < param_3->y) { + if (param_3->y > local_18.y) { local_18.y = param_3->y; } - iVar1 = this->mMap->vfunc_68(&local_18, 0); // takes no args. - return iVar1; + return this->mMap->vfunc_68(&local_18, param_4); } -ARM unk32 MapManager::func_ov00_02083f44(Vec3p *param_2) { +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); + 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) { @@ -1457,7 +1442,7 @@ unk8 MapManager::func_ov00_0208439c(Vec2s *param_2, Vec3p *param_3) { 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); // is this correct? + iVar1 = this->MapData_vfunc_68(param_3, true); param_3->y = iVar1; } @@ -1987,7 +1972,7 @@ unk32 MapManager::func_ov00_02084ebc(Vec3p *param_2) { } } } - iVar2 = this->func_ov00_02083e70(/*auStack_18*/); + iVar2 = this->func_ov00_02083e70(auStack_18); if (iVar2 != 0) { return 0; } -- cgit v1.2.3 From ef6c7422a9e33b2870aaec64c45b00c243452b85 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sun, 11 May 2025 12:09:39 +0200 Subject: Update --- src/00_Core/Map/MapManager.cpp | 165 +++++++++++++++++++++++++++-------------- 1 file changed, 108 insertions(+), 57 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 1ec099d4..b9a05f49 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -88,6 +88,13 @@ struct UnkStruct_02082348 { /* 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]; @@ -109,8 +116,10 @@ public: 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; @@ -124,7 +133,50 @@ extern unk32 *data_ov000_020e24a4; extern unk32 data_ov000_020eec68; extern unk32 data_ov015_02190458; -MapManager::MapManager() {} +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() {} @@ -138,6 +190,7 @@ ARM void MapManager::func_ov00_020820fc(s32 param_2, unk32 param_3, unk32 param_ 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; @@ -183,14 +236,15 @@ ARM void MapManager::func_ov00_0208210c(unk32 param_2, unk32 *param_3) { 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); - param_3[0x70] = func_ov000_020a5e9c((unk32 *) &local_40[0]); + uVar2 = func_ov000_020a5e9c((unk32 *) &local_40[0]); + 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) { - *(unk8 *) ((int) param_3 + 7) = (u8) this->mUnk_08; - *(unk8 *) (param_3 + 0x6f) = this->mUnk_09; + *(bool *) ((int) param_3 + 7) = this->mUnk_08; + *(bool *) (param_3 + 0x6f) = this->mUnk_09; } } @@ -1154,8 +1208,9 @@ 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) { +ARM void MapManager::func_ov00_02083c7c(Vec3p *param_2, Vec2s *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; @@ -1204,15 +1259,12 @@ ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 p ARM s32 MapManager::func_ov00_02083e34(unk8 param_2, unk8 param_3, unk32 param_4) { Vec2b local_8; - // unk16 uStack_6; // Unused. - - // uStack_6 = (unk16) ((u32) param_4 >> 0x10); - local_8.x = param_2; // Likely a struct + 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) { // should the param be bool*? +ARM unk32 MapManager::MapData_vfunc_60(Vec2b *param_1) { return this->mMap->vfunc_60(param_1); } @@ -1264,7 +1316,7 @@ ARM unk32 MapManager::MapData_vfunc_70(Vec3p *param_2) { } ARM void MapManager::func_ov00_02083fb0(u32 *param_1, MapManager *param_2, Vec3p *param_3) { - Vec4p *iVar1; // Unsure + Vec4p *iVar1; // Vec4p * unsure, need type with field at offset 0xc s32 dVar2; iVar1 = (Vec4p *) param_2->mMap->vfunc_74(param_3); @@ -1742,13 +1794,13 @@ u8 MapManager::func_ov00_02084a50() { } void MapManager::SpawnNPC(Vec3p *param_2, unk32 param_3, unk32 param_4) { - astruct_16 aStack_3c; // = Actor_UnkStruct_020(); - // aStack_3c. = 0xffffffff; - // aStack_3c.field25_0x20 = 0xffffffff; - func_ov000_020c3348((unk32 *) &aStack_3c); + void *aStack_3c; // = Actor_UnkStruct_020(); + // aStack_3c.field24_0x1c = 0xffffffff; + // aStack_3c.field25_0x20 = 0xffffffff; + func_ov000_020c3348((unk32 *) aStack_3c); // aStack_3c.field26_0x24 = param_3; // aStack_3c.field27_0x28 = param_4; - gActorSpawner->Spawn(ActorTypeId_EVIC, param_2, &aStack_3c, NULL); + gActorSpawner->Spawn(ActorTypeId_EVIC, param_2, aStack_3c, NULL); } ARM bool MapManager::func_ov00_02084ac4(u32 actorId) { @@ -1783,21 +1835,22 @@ bool MapManager::GetBlueWarpOpen() { unk8 MapManager::func_ov00_02084b38(unk32 param_2, unk32 param_3, bool param_4) { MapBase *pMVar1; - if (param_2 != 0) { - switch (param_3) { - case 0: - pMVar1 = this->mMap; - if (!param_4) { - pMVar1->mUnk_180[param_2 >> 5].mUnk_0 = pMVar1->mUnk_180[param_2 >> 5].mUnk_0 & ~(1 << (param_2 & 0x1f)); - return; - } - pMVar1->mUnk_180[param_2 >> 5].mUnk_0 = pMVar1->mUnk_180[param_2 >> 5].mUnk_0 | 1 << (param_2 & 0x1f); + 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; - 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; - } + } + 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; } } @@ -2218,7 +2271,7 @@ unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 unk32 dVar3; // dword unk32 uVar4; bool bVar5; - Vec2b uStack_2c[2]; + Vec2s uStack_2c; Vec2b local_28; u32 uStack_24; Vec3p VStack_20; @@ -2296,9 +2349,9 @@ unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 if (iVar2 != 0) { return 0; } - uStack_2c[0].y = local_28.y; - uStack_2c[0].x = local_28.x; - param_1->func_ov00_02083c7c(&VStack_20, uStack_2c); + uStack_2c.y = local_28.y; + uStack_2c.x = local_28.x; + param_1->func_ov00_02083c7c(&VStack_20, &uStack_2c); dVar3 = param_1->MapData_vfunc_70(&VStack_20); if (dVar3 != 0xffff) { func_ov000_02093a1c(&uStack_24, data_027e0f6c, dVar3); @@ -2316,24 +2369,24 @@ unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 } void MapManager::func_ov00_0208583c(MapManager *param_1, Vec3p *param_2, unk32 param_3) { - s32 *piVar1; - Vec2b auStack_10[2]; + 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 == (unk32 *) 0x0) { + 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; } - // if (*(s32 *) PTR_UnkStruct_027e077c_overlay_d_0__020858ac == 1) { - // if (*(s32 *) (PTR_UnkStruct_027e077c_overlay_d_0__020858ac + 4) == 1) { - // (**(code **) (*piVar1 + 0x30))(piVar1, param_3); - // return; - // } - // return; - //} } -unk8 MapManager::func_ov00_020858b0(MapManager *param_1, Vec3p *param_2, s32 param_3) { +unk32 MapManager::func_ov00_020858b0(MapManager *param_1, Vec3p *param_2, s32 param_3) { int iVar1; int iVar2; int iVar3; @@ -2730,20 +2783,18 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 Vec3p local_50; Vec3p local_44; Vec3p local_38; - s32 local_2c; - s32 iStack_28; - s32 iStack_24; + 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; - local_38.y = iStack_28; - local_38.z = iStack_24; + 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); - // bVar1 = Vec3p_Normalize(&local_38); + Vec3p_Normalize(&local_38, &local_2c); if (!bVar1) { local_38.x = 0; local_38.y = 0; @@ -2751,9 +2802,9 @@ bool MapManager::func_ov00_02086284(s32 *param_2, Vec3p *param_3, Vec3p *param_4 } Vec3p_Scale(&local_38, (local_20 + param_5) - iVar2); Vec3p_Add(param_3, &local_38, param_7); - local_50.x = local_2c; - local_50.y = iStack_28; - local_50.z = iStack_24; + 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; -- cgit v1.2.3 From bed4fb43a7796a232731c8226a6eac3cb2c49ba1 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Wed, 4 Jun 2025 00:07:45 +0200 Subject: Post-conflict update --- src/00_Core/Map/MapManager.cpp | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index b9a05f49..efd359bb 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -1208,11 +1208,11 @@ 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, Vec2s *param_3) { +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); + 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); } @@ -1349,7 +1349,7 @@ 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, unk16 param_4) { +ARM unk32 MapManager::func_ov00_020840a0(unk8 param_2, unk8 param_3) { // Correct param types? Vec2b vec; vec.x = param_2; @@ -2084,7 +2084,7 @@ unk32 MapManager::func_ov00_02084ebc(Vec3p *param_2) { return 0; } -s32 MapManager::func_ov00_02085108(s32 *param_2) { +s32 MapManager::func_ov00_02085108(Vec3p *param_2) { MapManager *puVar1; unk32 uVar2; int *piVar3; @@ -2126,9 +2126,9 @@ s32 MapManager::func_ov00_02085108(s32 *param_2) { local_2c = iVar8; // iVar4 = func_0202b8e4(&local_34, 2); if (iVar4 != 0) { - *param_2 = piVar3[6]; - param_2[1] = piVar3[7]; - param_2[2] = piVar3[8]; + param_2->x = piVar3[6]; + param_2->y = piVar3[7]; + param_2->z = piVar3[8]; return (int) *(char *) ((int) piVar3 + 0x12); } } @@ -2265,19 +2265,19 @@ s32 MapManager::func_ov00_020853fc(MapManager *param_1, Vec3p *param_2, s32 *par return iVar7; } -unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 param_3, unk32 param_4) { +unk32 MapManager::func_ov00_02085594(Vec3p *param_2) { int *piVar1; int iVar2; unk32 dVar3; // dword unk32 uVar4; bool bVar5; - Vec2s uStack_2c; + Vec2b uStack_2c; Vec2b local_28; u32 uStack_24; Vec3p VStack_20; - param_1->func_ov00_02083a1c(&local_28, param_1, param_2); - piVar1 = (int *) param_1->MapData_vfunc_78(&local_28); + 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]; @@ -2309,7 +2309,7 @@ unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 } } } - iVar2 = param_1->func_ov00_020840a0(local_28.x, local_28.y, param_4); + iVar2 = this->func_ov00_020840a0(local_28.x, local_28.y); if (iVar2 < 0x46) { if (iVar2 < 0x2a) { switch (iVar2) { @@ -2345,14 +2345,14 @@ unk32 MapManager::func_ov00_02085594(MapManager *param_1, Vec3p *param_2, unk32 } else if (iVar2 == 0x50) { return 0; } - iVar2 = param_1->mMap->vfunc_58(&local_28, 5); + 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; - param_1->func_ov00_02083c7c(&VStack_20, &uStack_2c); - dVar3 = param_1->MapData_vfunc_70(&VStack_20); + 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) { -- cgit v1.2.3 From c763d7e281a93fbf5c8d87d53f1ba9edd5ee2b2c Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sat, 28 Jun 2025 12:01:17 +0200 Subject: Update --- src/00_Core/Map/MapManager.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index efd359bb..21a31b33 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -431,7 +431,7 @@ ARM void MapManager::func_ov00_02082808(bool param_2) { return; } iVar1 = this->func_ov00_02084740(); - if (!param_2) { + if (param_2) { iVar2 = func_ov000_020a5e9c(&data_027e0d38->mUnk_0c); if (iVar2 == 0) { func_ov015_021849a4(&data_ov015_02190458); @@ -1833,7 +1833,7 @@ bool MapManager::GetBlueWarpOpen() { return this->mCourse->mBlueWarpOpen; } -unk8 MapManager::func_ov00_02084b38(unk32 param_2, unk32 param_3, bool param_4) { +ARM void MapManager::func_ov00_02084b38(u32 param_2, unk32 param_3, bool param_4) { MapBase *pMVar1; if (param_2 == 0) { return; -- cgit v1.2.3 From d733ef8b005cc5d8e865c58543d9bb473d08b7e8 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sat, 28 Jun 2025 14:37:36 +0200 Subject: Decomp progress 44% --- src/00_Core/Map/MapManager.cpp | 50 +++++++++++++++++++----------------------- 1 file changed, 22 insertions(+), 28 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 21a31b33..a6c509ca 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -1217,44 +1217,38 @@ ARM void MapManager::func_ov00_02083c7c(Vec3p *param_2, Vec2b param_3) { param_2->y = this->MapData_vfunc_68(&local_28, true); } -ARM void MapManager::func_ov00_02083ce8(MapManager *param_1, s32 *param_2, u32 param_3, s32 param_4, u32 param_5) { +ARM void MapManager::func_ov00_02083ce8(Vec3p *param_2, u32 param_3, s32 param_4, u32 param_5) { bool bVar1; - s32 iVar2; - u32 uVar3; + u32 uVar2; + Vec3p local_38; Vec3p local_2c; - uVar3 = param_3; - iVar2 = param_1->GetCourseData_Unk_25c(); - if (iVar2 == 0) { - iVar2 = param_1->mMap->GetTileStartX(param_3 & 0xff); - *param_2 = iVar2 + 0x800; - iVar2 = param_1->mMap->GetTileStartZ(param_3 >> 8 & 0xff); - param_2[2] = iVar2 + 0x800; - } else { + uVar2 = param_3; + bVar1 = GetCourseData_Unk_25c(); + if (bVar1) { if (param_4 != -1) { - uVar3 = param_5; - } - if (param_4 != -1 && uVar3 != 0xffffffff) { - uVar3 = (u32) (u8) param_1->mCourse->mMapGrid[param_4][uVar3]; + uVar2 = param_5; + } else if (param_4 != -1 && uVar2 != -1) { + uVar2 = this->mCourse->mMapGrid[param_4][uVar2]; } else { - uVar3 = param_1->func_ov00_02082d08(); + uVar2 = this->func_ov00_02082d08(); } - bVar1 = param_1->IsMapInMainGrid(uVar3); + bVar1 = this->IsMapInMainGrid(uVar2); if (bVar1) { - param_1->func_ov00_02083524(&local_2c, param_4, param_5); - iVar2 = param_1->mMap->GetTileStartX(param_3 & 0xff); - *param_2 = local_2c.x + iVar2 + 0x800; - iVar2 = param_1->mMap->GetTileStartZ(param_3 >> 8 & 0xff); - param_2[2] = local_2c.z + iVar2 + 0x800; + 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 { - iVar2 = param_1->mMap->GetTileStartX(param_3 & 0xff); - *param_2 = iVar2 + 0x800; - iVar2 = param_1->mMap->GetTileStartZ(param_3 >> 8 & 0xff); - param_2[2] = iVar2 + 0x800; + 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; } - iVar2 = param_1->MapData_vfunc_68(&local_2c, true); // I really do hope this is right - param_2[1] = iVar2; + 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) { -- cgit v1.2.3 From f446227797e5bc5e338d51e2e23a026360f484a5 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sat, 28 Jun 2025 23:19:29 +0200 Subject: Decomp progress 46% --- src/00_Core/Map/MapManager.cpp | 108 ++++++++++++++++++----------------------- 1 file changed, 48 insertions(+), 60 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index a6c509ca..1af83dab 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -130,6 +130,8 @@ extern unk32 *data_027e0f7c; extern unk32 *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; @@ -742,57 +744,50 @@ ARM void MapManager::func_ov00_0208306c(s32 *param_2, s32 *param_3) { ARM void MapManager::func_ov00_0208315c(s32 *param_2, s32 *param_3) { u32 uVar1; s32 *piVar2; - s32 iVar3; + UnkStruct_027e0d38_Unk28 *pvVar3; s32 *piVar4; - s32 local_2c; // This has to be a Vec3p, but uncertain as of now. - unk32 local_28; // Unused. - unk32 local_24; // Unused. Vec3p local_20; + Vec3p local_2c; - piVar4 = (s32 *) this->mCourse->mUnk_008; - piVar2 = param_2; - if (piVar4 != (s32 *) 0xfffffffd) { - piVar2 = (s32 *) 0xfffffffe; - } - if (piVar4 == (s32 *) 0xfffffffd || piVar4 == piVar2) { - // iVar3 = *(s32 *) (*(s32 *) PTR_PTR_overlay_d_0__02083240 + 0x28); - local_2c = *(s32 *) (iVar3 + 0x5c); - local_28 = *(unk32 *) (iVar3 + 0x60); - local_24 = *(unk32 *) (iVar3 + 100); - /*this->func_ov00_02083298((u32) * (u8 *) (*(s32 *) (*(s32 *) PTR_PTR_overlay_d_0__02083240 + 0x28) + 0x56), - &local_2c, param_2, param_3);*/ + *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 = pvVar3->mUnk_5c; + this->func_ov00_02083298((u32) * (u8 *) (*(s32 *) data_027e0d38->mUnk_28 + 0x56), &local_2c, param_2, param_3); return; } - if (piVar4 != (s32 *) 0xffffffff) { + if (*piVar4 != -1) { *param_2 = this->mCourse->mUnk_0bc; *param_3 = this->mCourse->mUnk_0c0; - return; } - local_20.x = *(s32 *) gPlayerPos.x; - local_20.y = *(s32 *) gPlayerPos.y; - local_20.z = *(s32 *) gPlayerPos.z; - uVar1 = this->func_ov00_02082d08(); - this->func_ov00_02083298(uVar1, &local_20, param_2, param_3); } 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_00) + 0x800 >> 0xc; - // *param_5 = (param_3->z - (&data_ov000_020e24ec)[param_2].mUnk_04) + 0x800 >> 0xc; + *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 (3 < param_2) { + if (4 <= param_2) { param_2 = 0; } - /* - *param_4 = - (&data_ov000_020e24c8)[param_2].mUnk_00 + ((param_3->x - (&data_ov000_020e24e8)[param_2].mUnk_00 >> 1) + 0x800 >> 0xc); - *param_5 = - (&data_ov000_020e24c8)[param_2].mUnk_04 + ((param_3->z - (&data_ov000_020e24e8)[param_2].mUnk_04 >> 1) + 0x800 >> 0xc); - */ + + *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() { @@ -1310,12 +1305,12 @@ ARM unk32 MapManager::MapData_vfunc_70(Vec3p *param_2) { } ARM void MapManager::func_ov00_02083fb0(u32 *param_1, MapManager *param_2, Vec3p *param_3) { - Vec4p *iVar1; // Vec4p * unsure, need type with field at offset 0xc + unk32 *iVar1; // find type with field that exists at offset 0xc s32 dVar2; - iVar1 = (Vec4p *) param_2->mMap->vfunc_74(param_3); + iVar1 = (unk32 *) param_2->mMap->vfunc_74(param_3); if (iVar1 != NULL) { - *param_1 = iVar1->w; // offset 0xc + *param_1 = *(u32 *) ((unk32 *) iVar1 + 0x3); // offset 0xc return; } dVar2 = param_2->MapData_vfunc_70(param_3); @@ -1611,11 +1606,11 @@ ARM s32 MapManager::func_ov00_020846a4() { return iVar1; } -ARM s32 MapManager::func_ov00_02084700(MapManager *pMapManager) { +ARM s32 MapManager::func_ov00_02084700() { s32 iVar1; - iVar1 = pMapManager->mMap->mUnk_034; + iVar1 = this->mMap->mUnk_034; if (iVar1 == -1) { - iVar1 = pMapManager->mCourse->mUnk_0c4; + iVar1 = this->mCourse->mUnk_0c4; } if ((iVar1 == 0x1b) && (gActorManager->mUnk_29 != false)) { iVar1 = 0x1c; @@ -1654,7 +1649,7 @@ unk32 MapManager::func_ov00_02084740() { local_1c0 = *(unk32 *) gPlayerPos.z; // bVar1 = FUN_overlay_d_0__02083780(&local_1c8); // MapManager method? if (bVar1) { - iVar2 = this->func_ov00_020847f0(); + // iVar2 = this->func_ov00_020847f0(); } } puVar9 = local_1bc; @@ -1680,19 +1675,16 @@ unk32 MapManager::func_ov00_020847e0() { return *(s32 *) ((s32) this->mMap->mUnk_144 + 0xc); } -unk8 MapManager::func_ov00_020847f0() { - s32 iVar1; - unk32 in_r1; +ARM unk32 MapManager::func_ov00_020847f0(unk32 type) { + TriggerBase *triggerBase = this->mMap->FindTrigger(type); - iVar1 = this->mMap->FindTrigger(in_r1); - if (iVar1 == 0) { - // this->func_ov00_02084700(?); - return; + if (triggerBase == NULL) { + return this->func_ov00_02084700(); } - if ((*(int *) (iVar1 + 0xc) != -1) && (*(int *) (iVar1 + 0xc) < 0x6c)) { - return; + if ((triggerBase->mUnk_0c != -1) && ((int) triggerBase->mUnk_0c < 0x6c)) { + return triggerBase->mUnk_0c; } - // this->func_ov00_02084700(?); + return this->func_ov00_02084700(); } bool MapManager::func_ov00_02084838() { @@ -1731,19 +1723,15 @@ void MapManager::func_ov00_02084924(u32 param_2) { this->mMap->func_ov00_0208008c(param_2); } -bool MapManager::func_ov00_02084934(Vec3p *param_2) { - q20 iVar2; - q20 iVar3; - q20 iVar4; +ARM bool MapManager::func_ov00_02084934(Vec3p *param_2) { Vec3p local_20; - iVar2 = this->GetMapCenterZ(); - iVar3 = param_2->z; - iVar4 = param_2->y; - local_20.x = this->GetMapCenterX(); - local_20.x = param_2->x - local_20.x; - local_20.y = iVar4; - local_20.z = iVar3 - iVar2; + 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); } -- cgit v1.2.3 From a02e12a0d9880d66eefbbbc88823ccff98be36d0 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sat, 28 Jun 2025 23:41:07 +0200 Subject: Fix type non-recognition --- src/00_Core/Map/MapManager.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 1af83dab..e97985b0 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -762,8 +762,10 @@ ARM void MapManager::func_ov00_0208315c(s32 *param_2, s32 *param_3) { this->func_ov00_02083298(uVar1, &local_20, param_2, param_3); if (*piVar4 == -2 || piVar4 == piVar2) { - pvVar3 = data_027e0d38->mUnk_28; - local_2c = pvVar3->mUnk_5c; + 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; } -- cgit v1.2.3 From 91ec8dbe164971d257152dd6c1a9dc2f47f5181e Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Sun, 29 Jun 2025 21:13:04 +0200 Subject: Update for ActorSpawnOptions --- src/00_Core/Map/MapManager.cpp | 33 +++++++++++++++++++++++---------- 1 file changed, 23 insertions(+), 10 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index e97985b0..1ef0336b 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -45,7 +45,7 @@ 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 unk32 func_ov000_020a5e9c(unk32 *param_1); -extern void func_ov000_020c3348(unk32 *param_1); +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); @@ -72,7 +72,19 @@ extern MapBase *func_ov017_0215b4e8(MapBase *param_1, unk32 param_2, unk32 param // extern MapBase *func_ov018_0215b4a0(MapBase *param_1, unk32 param_2, unk32 param_3); -struct astruct_16 {}; // What is this struct? +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 { @@ -1777,14 +1789,15 @@ u8 MapManager::func_ov00_02084a50() { return this->mMap->mUnk_011; } -void MapManager::SpawnNPC(Vec3p *param_2, unk32 param_3, unk32 param_4) { - void *aStack_3c; // = Actor_UnkStruct_020(); - // aStack_3c.field24_0x1c = 0xffffffff; - // aStack_3c.field25_0x20 = 0xffffffff; - func_ov000_020c3348((unk32 *) aStack_3c); - // aStack_3c.field26_0x24 = param_3; - // aStack_3c.field27_0x28 = param_4; - gActorSpawner->Spawn(ActorTypeId_EVIC, param_2, aStack_3c, NULL); +void MapManager::SpawnNPC(Vec3p *pos, unk32 param_3, unk32 param_4) { + ActorSpawnOptions actorSpawnOptions; + actorSpawnOptions.mUnk_00 = Actor_UnkStruct_020(); + 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) { -- cgit v1.2.3 From 52867bf54f57fdbb405b2940c38f13160414a289 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Mon, 30 Jun 2025 22:08:37 +0200 Subject: Fix SpawnNPC --- src/00_Core/Map/MapManager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 1ef0336b..6df41ea7 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -1791,7 +1791,7 @@ u8 MapManager::func_ov00_02084a50() { void MapManager::SpawnNPC(Vec3p *pos, unk32 param_3, unk32 param_4) { ActorSpawnOptions actorSpawnOptions; - actorSpawnOptions.mUnk_00 = Actor_UnkStruct_020(); + // actorSpawnOptions.mUnk_00 = Actor_UnkStruct_020(); actorSpawnOptions.mUnk_1c.id = -1; actorSpawnOptions.mUnk_1c.index = -1; func_ov000_020c3348(&actorSpawnOptions); -- cgit v1.2.3 From 18f940fde40ed6263b82c2b7e7f9e3cd348ba750 Mon Sep 17 00:00:00 2001 From: SammygoodTunes Date: Mon, 30 Jun 2025 23:29:42 +0200 Subject: Update --- src/00_Core/Map/MapManager.cpp | 36 +++++++++++++----------------------- 1 file changed, 13 insertions(+), 23 deletions(-) (limited to 'src/00_Core/Map/MapManager.cpp') diff --git a/src/00_Core/Map/MapManager.cpp b/src/00_Core/Map/MapManager.cpp index 6df41ea7..e26cc57e 100644 --- a/src/00_Core/Map/MapManager.cpp +++ b/src/00_Core/Map/MapManager.cpp @@ -8,6 +8,7 @@ #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" @@ -54,8 +55,6 @@ extern void func_ov004_021024c4(MapManager *param_1, s32 param_2, bool param_3, 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_02105578(ActorManager *param_1, u32 param_2); -extern void func_ov004_02105608(ActorManager *param_1, unk32 param_2, unk32 param_3, unk32 param_4); 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); @@ -139,7 +138,7 @@ extern unk32 *data_027e0f6c; extern unk32 *data_027e0f70; extern unk32 *data_027e0f78; extern unk32 *data_027e0f7c; -extern unk32 *data_027e103c; +extern UnkStruct_027e103c *data_027e103c; extern unk32 *data_ov000_020e24a4; extern MapManager_Unk2 data_ov000_020e24c8[]; @@ -567,35 +566,30 @@ ARM void MapManager::func_ov00_02082af4() { this->mUnk_0b = false; } -bool MapManager::func_ov00_02082b3c(unk32 *param_2) { +void MapManager::func_ov00_02082b3c(unk32 *param_2, Vec2b *param_3) { u8 bVar1; - PlayerBase *puVar2; u16 uVar3; u32 uVar4; unk32 uVar5; - u32 in_r3; ActorManager *pAVar6; - unk32 local_18; + PlayerBase *puVar2; - local_18 = in_r3; // what's the point of that? - this->mCourse->FindMapGridPos((Vec2b *) &local_18, this->mCourse, (u32) * (u8 *) (param_2 + 0x12)); + this->mCourse->FindMapGridPos(param_3, this->mCourse, *(u32 *) ((unk32) param_2 + 0x12)); uVar4 = this->GetCurrentMapPosX(); - if (((((local_18 & 0xff) == uVar4) && (uVar4 = this->GetCurrentMapPosY(), (local_18 >> 8 & 0xff) == uVar4)) && + 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(); - puVar2 = gPlayer; this->mUnk_0c = *(unk32 *) (param_2 + 0x13); - // puVar2->TeleportToEntrance(*(unk32 *) (param_2 + 0x13), false); - // (**(code **) (**(int **) puVar2 + 0x38))(*(int **) puVar2, *(unk32 *) (param_2 + 0x13), 0); - // func_ov004_02106db8(data_027e0c68); + 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(local_18 & 0xff, local_18 >> 8 & 0xff, uVar5); + 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); @@ -603,14 +597,12 @@ bool MapManager::func_ov00_02082b3c(unk32 *param_2) { bVar1 = *(u8 *) (param_2 + 0x12); uVar3 = this->mCourse->FindCurrentMapData_Unk_04(); uVar4 = this->mCourse->FindMapData_Unk_04((u32) bVar1); - (this->mCourse->mCurrMapPos).x = (u8) local_18; - (this->mCourse->mCurrMapPos).y = (u8) * (&local_18 + 0x4); // I assume this is what Ghidra means by "local_18._1_1_" + (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); - func_ov004_02105578(gActorManager, (u32) * (u8 *) (param_2 + 0x12)); - // data_027e0d3c-> - // UnkStruct_027e0103c::thunk_FUN_overlay_d_0__020cf7e8(*PTR_PTR_overlay_d_0__02082cfc); + gActorManager->func_ov004_02105578(*(unk32 *) ((unk32) param_2 + 0x12)); + data_027e103c->func_ov000_020cfcec(); } - return true; } ARM u8 MapManager::func_ov00_02082d08() { @@ -1257,7 +1249,6 @@ ARM void MapManager::func_ov00_02083ce8(Vec3p *param_2, u32 param_3, s32 param_4 } 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) { @@ -1791,7 +1782,6 @@ u8 MapManager::func_ov00_02084a50() { void MapManager::SpawnNPC(Vec3p *pos, unk32 param_3, unk32 param_4) { ActorSpawnOptions actorSpawnOptions; - // actorSpawnOptions.mUnk_00 = Actor_UnkStruct_020(); actorSpawnOptions.mUnk_1c.id = -1; actorSpawnOptions.mUnk_1c.index = -1; func_ov000_020c3348(&actorSpawnOptions); -- cgit v1.2.3