Leahnaya/pokeplatinum
1
0
Fork 0
mirror of https://github.com/pret/pokeplatinum.git synced 2026-04-25 15:49:02 -05:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Document terrain collision manager

Browse Source 
This documents the `unk_02054D00.c` file, which is in charge of managing
height, collision and tile behavior between the terrain and the
player/map objects.

Signed-off-by: Kuruyia <github@kuruyia.net>
This commit is contained in:
Kuruyia 2025-03-21 10:15:45 +01:00
parent 5306770fd4
commit 607e8f4bf9
43 changed files with 755 additions and 879 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
include/constants/quadrant.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef POKEPLATINUM_CONSTANTS_QUADRANT_H
#define POKEPLATINUM_CONSTANTS_QUADRANT_H
#define QUADRANT_COUNT 4
#define QUADRANT_GO_TOP(quadrant) ((quadrant) - 2)
#define QUADRANT_GO_BOTTOM(quadrant) ((quadrant) + 2)
#define QUADRANT_GO_RIGHT(quadrant) ((quadrant) + 1)
#define QUADRANT_GO_LEFT(quadrant) ((quadrant) - 1)
#define QUADRANT_GO_BOTTOM_RIGHT(quadrant) ((quadrant) + 3)
#define QUADRANT_GO_TOP_LEFT(quadrant) ((quadrant) - 3)
#define QUADRANT_GO_BOTTOM_LEFT(quadrant) ((quadrant) + 1)
#define QUADRANT_GO_TOP_RIGHT(quadrant) ((quadrant) - 1)
enum Quadrant {
QUADRANT_TOP_LEFT,
QUADRANT_TOP_RIGHT,
QUADRANT_BOTTOM_LEFT,
QUADRANT_BOTTOM_RIGHT,
QUADRANT_INVALID
};
#endif // POKEPLATINUM_CONSTANTS_QUADRANT_H

2
include/field/field_system.h
View File

@ -7,7 +7,6 @@
#include "struct_decls/struct_0205E884_decl.h"
#include "struct_decls/struct_02061830_decl.h"
#include "struct_decls/struct_02095E80_decl.h"
#include "struct_decls/terrain_collision_manager_decl.h"
#include "struct_defs/map_load_mode.h"
#include "struct_defs/struct_0202610C.h"
#include "struct_defs/struct_0204AFC4.h"
@ -41,6 +40,7 @@
#include "pokedex_memory.h"
#include "pokeradar.h"
#include "savedata.h"
#include "terrain_collision_manager.h"
#define NUM_HONEY_TREES 21

14
include/struct_decls/terrain_collision_manager_decl.h
View File

@ -1,14 +0,0 @@
#ifndef POKEPLATINUM_TERRAIN_COLLISION_MANAGER_DECL_H
#define POKEPLATINUM_TERRAIN_COLLISION_MANAGER_DECL_H
#include "field/field_system_decl.h"
typedef const fx32 (*GetTerrainHeightFunc)(const FieldSystem *, const fx32, const fx32, const fx32, u8 *);
typedef BOOL (*GetTerrainAttributeFunc)(const FieldSystem *, const int, const int, u16 *);
typedef struct TerrainCollisionManager_t {
GetTerrainHeightFunc getHeightFunc;
GetTerrainAttributeFunc getAttrFunc;
} TerrainCollisionManager;
#endif // POKEPLATINUM_TERRAIN_COLLISION_MANAGER_DECL_H

2
include/struct_defs/map_load_mode.h
View File

@ -4,7 +4,7 @@
typedef struct MapLoadMode {
u32 fieldBottomScreen : 4;
u32 skipMapAttributes : 4;
u32 unk_00_8 : 4;
u32 useSimpleTerrainCollisions : 4;
u32 unk_00_12 : 4;
u32 unk_00_16 : 4;
u32 unk_00_20 : 4;

11
include/struct_defs/struct_02055130.h
View File

@ -1,11 +0,0 @@
#ifndef POKEPLATINUM_STRUCT_02055130_H
#define POKEPLATINUM_STRUCT_02055130_H
typedef struct {
fx32 unk_00;
fx32 unk_04;
fx32 unk_08;
fx32 unk_0C;
} UnkStruct_02055130;
#endif // POKEPLATINUM_STRUCT_02055130_H

47
include/terrain_collision_manager.h Normal file
View File

@ -0,0 +1,47 @@
#ifndef POKEPLATINUM_TERRAIN_COLLISION_MANAGER_H
#define POKEPLATINUM_TERRAIN_COLLISION_MANAGER_H
#include <nitro/fx/fx.h>
#include <nitro/types.h>
#include "field/field_system_decl.h"
#include "overlay005/map_prop.h"
typedef const fx32 (*GetHeightFunc)(const FieldSystem *, const fx32, const fx32, const fx32, u8 *);
typedef BOOL (*GetTileAttributesFunc)(const FieldSystem *, const int, const int, u16 *);
typedef struct TerrainCollisionManager {
GetHeightFunc getHeight;
GetTileAttributesFunc getTileAttributes;
} TerrainCollisionManager;
typedef struct TerrainCollisionHitbox {
fx32 startX;
fx32 startZ;
fx32 endX;
fx32 endZ;
} TerrainCollisionHitbox;
enum CalculatedHeightSource {
CALCULATED_HEIGHT_SOURCE_NONE = 0,
CALCULATED_HEIGHT_SOURCE_BDHC,
CALCULATED_HEIGHT_SOURCE_DYNAMIC
};
void TerrainCollisionManager_Init(const TerrainCollisionManager **terrainCollisionMan, BOOL useSimpleTerrainCollisions);
BOOL TerrainCollisionManager_CheckCollision(const FieldSystem *fieldSystem, const int tileX, const int tileY);
u8 TerrainCollisionManager_GetTileBehavior(const FieldSystem *fieldSystem, const int tileX, const int tileY);
const fx32 TerrainCollisionManager_GetHeight(const FieldSystem *fieldSystem, const fx32 objectHeight, const fx32 objectX, const fx32 objectZ, u8 *newObjectHeightSource);
BOOL TerrainCollisionManager_WillMapObjectCollide(const FieldSystem *fieldSystem, const VecFx32 *objectPosition, const int tileX, const int tileY, s8 *verticalDirection);
BOOL TerrainCollisionManager_WillPlayerCollide(FieldSystem *fieldSystem, const VecFx32 *objectPosition, const int tileX, const int tileY, s8 *verticalDirection);
void TerrainCollisionManager_GetMapAbsoluteOrigin(const int mapMatrixIndex, const int mapMatrixWidth, VecFx32 *mapAbsoluteOrigin);
void TerrainCollisionHitbox_Init(const int tileX, const int tileY, const int offsetTileX, const int offsetTileY, const u32 sizeX, const u32 sizeY, TerrainCollisionHitbox *hitbox);
BOOL TerrainCollisionHitbox_CollidesWithMapProp(const MapProp *mapProp, const TerrainCollisionHitbox *hitbox, const VecFx32 *mapAbsoluteOrigin);
BOOL FieldSystem_FindCollidingLoadedMapPropByModelID(const FieldSystem *fieldSystem, const int targetMapPropModelID, const TerrainCollisionHitbox *hitbox, MapProp **mapPropOut);
BOOL FieldSystem_FindCollidingLoadedMapPropByModelIDs(const FieldSystem *fieldSystem, const int *mapPropModelIDs, const u8 mapPropModelIDsCount, const TerrainCollisionHitbox *hitbox, MapProp **mapPropOut, int *mapPropModelIDOut);
BOOL FieldSystem_FindLoadedMapPropByModelID(const FieldSystem *fieldSystem, const int targetMapPropModelID, MapProp **mapPropOut, int *mapMatrixIndex);
BOOL FieldSystem_FindLoadedMapPropByModelIDs(const FieldSystem *fieldSystem, const int *mapPropModelIDs, const u8 mapPropModelIDsCount, MapProp **mapPropOut, int *mapPropModelIDOut);
#endif // POKEPLATINUM_TERRAIN_COLLISION_MANAGER_H

26
include/unk_02054D00.h
View File

@ -1,26 +0,0 @@
#ifndef POKEPLATINUM_UNK_02054D00_H
#define POKEPLATINUM_UNK_02054D00_H
#include <nitro/fx/fx.h>
#include "struct_decls/terrain_collision_manager_decl.h"
#include "struct_defs/struct_02055130.h"
#include "field/field_system_decl.h"
#include "overlay005/map_prop.h"
void sub_02054F44(const TerrainCollisionManager **param0, int param1);
BOOL FieldSystem_CheckCollision(const FieldSystem *fieldSystem, const int param1, const int param2);
u8 FieldSystem_GetTileBehavior(const FieldSystem *fieldSystem, const int x, const int z);
const fx32 sub_02054FBC(const FieldSystem *fieldSystem, const fx32 param1, const fx32 param2, const fx32 param3, u8 *param4);
BOOL sub_02055024(const FieldSystem *fieldSystem, const VecFx32 *param1, const int param2, const int param3, s8 *param4);
BOOL sub_0205507C(FieldSystem *fieldSystem, const VecFx32 *param1, const int param2, const int param3, s8 *param4);
void sub_020550F4(const int param0, const int param1, const int param2, const int param3, const u32 param4, const u32 param5, UnkStruct_02055130 *param6);
BOOL sub_02055130(const MapProp *param0, const UnkStruct_02055130 *param1, const VecFx32 *param2);
BOOL sub_02055178(const FieldSystem *fieldSystem, const int param1, const UnkStruct_02055130 *param2, MapProp **param3);
BOOL sub_02055208(const FieldSystem *fieldSystem, const int *param1, const u8 param2, const UnkStruct_02055130 *param3, MapProp **param4, int *param5);
BOOL sub_020552B4(const FieldSystem *fieldSystem, const int param1, MapProp **param2, int *param3);
BOOL sub_02055324(const FieldSystem *fieldSystem, const int *param1, const u8 param2, MapProp **param3, int *param4);
void sub_020553A4(const int param0, const int param1, VecFx32 *param2);
#endif // POKEPLATINUM_UNK_02054D00_H

2
platinum.us/main.lsf
View File

@ -227,7 +227,7 @@ Static main
Object main.nef.p/src_field_map_change.c.o
Object main.nef.p/src_unk_02054884.c.o
Object main.nef.p/src_unk_02054BD0.c.o
Object main.nef.p/src_unk_02054D00.c.o
Object main.nef.p/src_terrain_collision_manager.c.o
Object main.nef.p/src_unk_020553DC.c.o
Object main.nef.p/src_unk_020556C4.c.o
Object main.nef.p/src_field_transition.c.o

4
src/catching_show.c
View File

@ -22,8 +22,8 @@
#include "pokemon.h"
#include "rtc.h"
#include "species.h"
#include "terrain_collision_manager.h"
#include "unk_0202EEC0.h"
#include "unk_02054D00.h"
#define PAL_PARK_AREA_NONE 0
#define POINTS_LOST_PER_SECOND 2
@ -186,7 +186,7 @@ static BOOL IsStepCountZero(CatchingShow *catchingShow)
static int GetEncounterArea(FieldSystem *fieldSystem, int playerX, int playerY)
{
u16 tileBehavior = FieldSystem_GetTileBehavior(fieldSystem, playerX, playerY);
u16 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, playerX, playerY);
int area = (playerX < 32) ? 0 : 1;
area += (playerY < 32) ? 0 : 2;

6
src/comm_player_manager.c
View File

@ -40,10 +40,10 @@
#include "sys_task.h"
#include "sys_task_manager.h"
#include "system.h"
#include "terrain_collision_manager.h"
#include "trainer_info.h"
#include "unk_0202854C.h"
#include "unk_020366A0.h"
#include "unk_02054D00.h"
#include "unk_0205F180.h"
#include "unk_020655F4.h"
#include "unk_0206CCB0.h"
@ -667,7 +667,7 @@ static BOOL CommPlayer_CheckCollision(int x, int z, int netIdTarget)
}
}
return FieldSystem_CheckCollision(sCommPlayerManager->fieldSystem, x, z);
return TerrainCollisionManager_CheckCollision(sCommPlayerManager->fieldSystem, x, z);
}
static int sub_020581CC(int param0, int param1)
@ -847,7 +847,7 @@ void CommPlayer_RecvLocation(int netId, int unused0, void *src, void *unused1)
sCommPlayerManager->isActive[netId] = 1;
sCommPlayerManager->movementChanged[netId] = 1;
if (FieldSystem_CheckCollision(sCommPlayerManager->fieldSystem, playerLocation->x, playerLocation->z)) {
if (TerrainCollisionManager_CheckCollision(sCommPlayerManager->fieldSystem, playerLocation->x, playerLocation->z)) {
GF_ASSERT(0);
}
}

4
src/field_battle_data_transfer.c
View File

@ -47,6 +47,7 @@
#include "system_data.h"
#include "system_flags.h"
#include "system_vars.h"
#include "terrain_collision_manager.h"
#include "trainer_info.h"
#include "unk_0202602C.h"
#include "unk_02027F84.h"
@ -54,7 +55,6 @@
#include "unk_0202CC64.h"
#include "unk_0203266C.h"
#include "unk_020366A0.h"
#include "unk_02054D00.h"
#include "unk_020559DC.h"
#include "unk_0205C980.h"
#include "unk_0206CCB0.h"
@ -470,7 +470,7 @@ static const enum BattleTerrain sTerrainForBackground[] = {
static int CalcTerrain(const FieldSystem *fieldSystem, enum BattleBackground background)
{
u8 behavior = FieldSystem_GetTileBehavior(fieldSystem, fieldSystem->location->x, fieldSystem->location->z);
u8 behavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, fieldSystem->location->x, fieldSystem->location->z);
if (TileBehavior_IsIce(behavior)) {
return TERRAIN_ICE;
} else if (TileBehavior_IsTallGrass(behavior) || TileBehavior_IsVeryTallGrass(behavior)) {

14
src/field_map_change.c
View File

@ -53,6 +53,7 @@
#include "system.h"
#include "system_flags.h"
#include "system_vars.h"
#include "terrain_collision_manager.h"
#include "trainer_info.h"
#include "unk_020041CC.h"
#include "unk_02005474.h"
@ -63,7 +64,6 @@
#include "unk_0203A944.h"
#include "unk_0203D1B8.h"
#include "unk_02054BD0.h"
#include "unk_02054D00.h"
#include "unk_020553DC.h"
#include "unk_020559DC.h"
#include "unk_0205B33C.h"
@ -156,11 +156,11 @@ static void sub_02053E5C(FieldTask *task);
static BOOL sub_0205444C(FieldTask *task, int param1);
static const MapLoadMode sMapLoadMode[] = {
{ 0x1, FALSE, 0x0, 0x0, 0x0, 0x1, 0x0, 0xC4000 },
{ 0x2, TRUE, 0x1, 0x1, 0x1, 0x0, 0x10, 0xC4000 },
{ 0x3, FALSE, 0x0, 0x0, 0x0, 0x1, 0x0, 0xC4000 },
{ 0x4, TRUE, 0x1, 0x0, 0x1, 0x1, 0x1, 0xC4000 },
{ 0x1, TRUE, 0x1, 0x0, 0x1, 0x1, 0x1, 0xA0000 }
{ 0x1, FALSE, FALSE, 0x0, 0x0, 0x1, 0x0, 0xC4000 },
{ 0x2, TRUE, TRUE, 0x1, 0x1, 0x0, 0x10, 0xC4000 },
{ 0x3, FALSE, FALSE, 0x0, 0x0, 0x1, 0x0, 0xC4000 },
{ 0x4, TRUE, TRUE, 0x0, 0x1, 0x1, 0x1, 0xC4000 },
{ 0x1, TRUE, TRUE, 0x0, 0x1, 0x1, 0x1, 0xA0000 }
};
static const WindowTemplate Unk_020EC3A0 = {
@ -386,7 +386,7 @@ static void FieldMapChange_InitTerrainCollisionManager(FieldSystem *fieldSystem)
fieldSystem->skipMapAttributes = fieldSystem->mapLoadMode->skipMapAttributes;
fieldSystem->bottomScreen = fieldSystem->mapLoadMode->fieldBottomScreen;
sub_02054F44(&fieldSystem->terrainCollisionMan, fieldSystem->mapLoadMode->unk_00_8);
TerrainCollisionManager_Init(&fieldSystem->terrainCollisionMan, fieldSystem->mapLoadMode->useSimpleTerrainCollisions);
if (fieldSystem->mapLoadMode->unk_00_16) {
sub_02054BD0(fieldSystem, fieldSystem->mapLoadMode->unk_00_24);

16
src/map_object_move.c
View File

@ -22,7 +22,7 @@
#include "map_object.h"
#include "map_tile_behavior.h"
#include "unk_02054D00.h"
#include "terrain_collision_manager.h"
#include "unk_020655F4.h"
#include "unk_020673B8.h"
@ -575,7 +575,7 @@ u32 sub_02063E18(const MapObject *mapObj, const VecFx32 *pos, int x, int y, int
s8 v1;
FieldSystem *fieldSystem = MapObject_FieldSystem(mapObj);
if (sub_02055024(fieldSystem, pos, x, z, &v1) == TRUE) {
if (TerrainCollisionManager_WillMapObjectCollide(fieldSystem, pos, x, z, &v1) == TRUE) {
v0 |= (1 << 1);
if (v1 != 0) {
@ -699,7 +699,7 @@ int sub_02064004(const MapObject *mapObj, int x, int z, int dir)
if (sub_02062FDC(mapObj) == FALSE) {
FieldSystem *fieldSystem = MapObject_FieldSystem(mapObj);
u8 v1 = MapObject_GetCurrTileBehavior(mapObj);
u8 v2 = FieldSystem_GetTileBehavior(fieldSystem, x, z);
u8 v2 = TerrainCollisionManager_GetTileBehavior(fieldSystem, x, z);
if (v2 == GetNullTileBehaviorID()) {
return TRUE;
@ -860,7 +860,7 @@ u32 MapObject_GetTileBehaviorFromDir(MapObject *mapObj, int dir)
int x = MapObject_GetX(mapObj) + MapObject_GetDxFromDir(dir);
int z = MapObject_GetZ(mapObj) + MapObject_GetDzFromDir(dir);
FieldSystem *fieldSystem = MapObject_FieldSystem(mapObj);
u8 tileBehavior = FieldSystem_GetTileBehavior(fieldSystem, x, z);
u8 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, x, z);
return tileBehavior;
}
@ -941,10 +941,10 @@ int MapObject_SetTileBehaviors(MapObject *mapObj)
int z = MapObject_GetZPrev(mapObj);
FieldSystem *fieldSystem = MapObject_FieldSystem(mapObj);
prevTileBehavior = FieldSystem_GetTileBehavior(fieldSystem, x, z);
prevTileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, x, z);
x = MapObject_GetX(mapObj);
z = MapObject_GetZ(mapObj);
currTileBehavior = FieldSystem_GetTileBehavior(fieldSystem, x, z);
currTileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, x, z);
}
MapObject_SetPrevTileBehavior(mapObj, prevTileBehavior);
@ -1026,7 +1026,7 @@ int sub_020644A4(FieldSystem *fieldSystem, VecFx32 *pos)
fx32 v0;
u8 v1;
v0 = sub_02054FBC(fieldSystem, pos->y, pos->x, pos->z, &v1);
v0 = TerrainCollisionManager_GetHeight(fieldSystem, pos->y, pos->x, pos->z, &v1);
if (v1 == 0) {
return FALSE;
@ -1041,7 +1041,7 @@ int sub_020644D0(FieldSystem *fieldSystem, VecFx32 *pos, int param2)
fx32 v0;
u8 v1;
v0 = sub_02054FBC(fieldSystem, pos->y, pos->x, pos->z, &v1);
v0 = TerrainCollisionManager_GetHeight(fieldSystem, pos->y, pos->x, pos->z, &v1);
if (v1 == 0) {
return FALSE;

2
src/meson.build
View File

@ -215,7 +215,7 @@ pokeplatinum_c = files(
'field_map_change.c',
'unk_02054884.c',
'unk_02054BD0.c',
'unk_02054D00.c',
'terrain_collision_manager.c',
'unk_020553DC.c',
'unk_020556C4.c',
'field_transition.c',

14
src/overlay005/field_control.c
View File

@ -54,13 +54,13 @@
#include "system.h"
#include "system_flags.h"
#include "system_vars.h"
#include "terrain_collision_manager.h"
#include "trainer_info.h"
#include "unk_02005474.h"
#include "unk_02030EE0.h"
#include "unk_020366A0.h"
#include "unk_0203C954.h"
#include "unk_02054884.h"
#include "unk_02054D00.h"
#include "unk_02056B30.h"
#include "unk_0205A0D8.h"
#include "unk_0205B33C.h"
@ -571,7 +571,7 @@ static BOOL Field_CheckMapTransition(FieldSystem *fieldSystem, const FieldInput
int playerX, playerZ;
Field_Step(fieldSystem, &playerX, &playerZ);
if (FieldSystem_CheckCollision(fieldSystem, playerX, playerZ) == FALSE) {
if (TerrainCollisionManager_CheckCollision(fieldSystem, playerX, playerZ) == FALSE) {
return FALSE;
}
@ -579,7 +579,7 @@ static BOOL Field_CheckMapTransition(FieldSystem *fieldSystem, const FieldInput
Location nextMap;
if (Field_MapConnection(fieldSystem, playerX, playerZ, &nextMap) && input->transitionDir != DIR_NONE) {
tileBehavior = FieldSystem_GetTileBehavior(fieldSystem, playerX, playerZ);
tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, playerX, playerZ);
if (TileBehavior_IsDoor(tileBehavior)) {
int v6 = input->transitionDir;
@ -596,7 +596,7 @@ static BOOL Field_CheckMapTransition(FieldSystem *fieldSystem, const FieldInput
Field_GetPlayerPos(fieldSystem, &playerX, &playerZ);
tileBehavior = FieldSystem_GetTileBehavior(fieldSystem, playerX, playerZ);
tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, playerX, playerZ);
if (TileBehavior_IsWarpEntranceEast(tileBehavior) || TileBehavior_IsWarpEast(tileBehavior)) {
if (input->transitionDir != DIR_EAST) {
@ -715,7 +715,7 @@ static BOOL Field_ProcessStep(FieldSystem *fieldSystem)
int playerX = Player_GetXPos(fieldSystem->playerAvatar);
int playerZ = Player_GetZPos(fieldSystem->playerAvatar);
u8 tileBehavior = FieldSystem_GetTileBehavior(fieldSystem, playerX, playerZ);
u8 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, playerX, playerZ);
if (Field_CheckCoordEvent(fieldSystem) == TRUE) {
return TRUE;
@ -982,14 +982,14 @@ static u8 Field_CurrentTileBehavior(const FieldSystem *fieldSystem)
{
int playerX, playerZ;
Field_GetPlayerPos(fieldSystem, &playerX, &playerZ);
return FieldSystem_GetTileBehavior(fieldSystem, playerX, playerZ);
return TerrainCollisionManager_GetTileBehavior(fieldSystem, playerX, playerZ);
}
static u8 Field_NextTileBehavior(const FieldSystem *fieldSystem)
{
int playerX, playerZ;
Field_Step(fieldSystem, &playerX, &playerZ);
return FieldSystem_GetTileBehavior(fieldSystem, playerX, playerZ);
return TerrainCollisionManager_GetTileBehavior(fieldSystem, playerX, playerZ);
}
static BOOL Field_MapConnection(const FieldSystem *fieldSystem, int playerX, int playerZ, Location *nextMap)

10
src/overlay005/honey_tree.c
View File

@ -7,8 +7,6 @@
#include "constants/map_object.h"
#include "generated/map_headers.h"
#include "struct_defs/struct_02055130.h"
#include "field/field_system.h"
#include "overlay005/land_data.h"
#include "overlay005/map_prop.h"
@ -21,8 +19,8 @@
#include "player_avatar.h"
#include "save_player.h"
#include "special_encounter.h"
#include "terrain_collision_manager.h"
#include "trainer_info.h"
#include "unk_02054D00.h"
#define TREE_GROUP_NO_ENCOUNTER 0
#define TREE_GROUP_A 1
@ -97,7 +95,7 @@ void HoneyTree_FreeShakeData(HoneyTreeShakeList **data)
BOOL HoneyTree_TryInteract(FieldSystem *fieldSystem, int *eventId)
{
UnkStruct_02055130 v0;
TerrainCollisionHitbox v0;
int x, z;
BOOL isFacingHoneyTree;
@ -107,8 +105,8 @@ BOOL HoneyTree_TryInteract(FieldSystem *fieldSystem, int *eventId)
z = Player_GetZPos(fieldSystem->playerAvatar);
if (PlayerAvatar_GetDir(fieldSystem->playerAvatar) == DIR_NORTH) { // Honey Trees can only be interacted with from below.
sub_020550F4(x, z, 0, -1, 1, 1, &v0);
isFacingHoneyTree = sub_02055178(fieldSystem, MAP_PROP_MODEL_HONEY_TREE, &v0, NULL);
TerrainCollisionHitbox_Init(x, z, 0, -1, 1, 1, &v0);
isFacingHoneyTree = FieldSystem_FindCollidingLoadedMapPropByModelID(fieldSystem, MAP_PROP_MODEL_HONEY_TREE, &v0, NULL);
} else {
isFacingHoneyTree = FALSE;
}

20
src/overlay005/land_data.c
View File

@ -6,6 +6,7 @@
#include "constants/battle.h"
#include "constants/field/map.h"
#include "constants/heap.h"
#include "constants/quadrant.h"
#include "field/field_system.h"
#include "overlay005/area_data.h"
@ -36,17 +37,6 @@
#define MAP_LAZY_LOADER_MANAGER_COUNT 2
#define MAP_MODEL_LAZY_LOADER_DATA_CHUNK_SIZE 0xE000
#define QUADRANT_COUNT 4
#define QUADRANT_GO_TOP(quadrant) ((quadrant) - 2)
#define QUADRANT_GO_BOTTOM(quadrant) ((quadrant) + 2)
#define QUADRANT_GO_RIGHT(quadrant) ((quadrant) + 1)
#define QUADRANT_GO_LEFT(quadrant) ((quadrant) - 1)
#define QUADRANT_GO_BOTTOM_RIGHT(quadrant) ((quadrant) + 3)
#define QUADRANT_GO_TOP_LEFT(quadrant) ((quadrant) - 3)
#define QUADRANT_GO_BOTTOM_LEFT(quadrant) ((quadrant) + 1)
#define QUADRANT_GO_TOP_RIGHT(quadrant) ((quadrant) - 1)
#define LAND_DATA_LOADER_ASSERT_MAP_MATRIX_INDEX(index, matrixWidth, matrixHeight) \
if (index < 0 || index >= matrixWidth * matrixHeight) { \
return; \
@ -193,14 +183,6 @@ enum Direction {
DIRECTION_NORTH
};
enum Quadrant {
QUADRANT_TOP_LEFT,
QUADRANT_TOP_RIGHT,
QUADRANT_BOTTOM_LEFT,
QUADRANT_BOTTOM_RIGHT,
QUADRANT_INVALID
};
static SysTask *LandDataManager_LazyLoadMapModel(NARC *landDataNARC, const int mapModelDataSize, NNSG3dRenderObj *mapRenderObj, NNSG3dResFileHeader **mapModelFile, NNSG3dResTex *mapTexture, BOOL *loadedMapValid, BOOL *loadTaskRunning);
static NNSG3dResMdl *LandDataManager_LoadMapModel(NARC *landDataNARC, const int mapModelFileSize, NNSG3dRenderObj *mapRenderObj, NNSG3dResFileHeader **mapModelFile, NNSG3dResTex *mapTexture);
static void LandDataManager_KillLoadMapModel(SysTask *sysTask);

45
src/overlay005/ov5_021D431C.c
View File

@ -6,7 +6,6 @@
#include "constants/field/map_prop.h"
#include "struct_decls/struct_02061AB4_decl.h"
#include "struct_defs/struct_02055130.h"
#include "field/field_system.h"
#include "overlay005/area_data.h"
@ -19,15 +18,15 @@
#include "heap.h"
#include "map_object.h"
#include "player_avatar.h"
#include "terrain_collision_manager.h"
#include "unk_02005474.h"
#include "unk_0200F174.h"
#include "unk_02054D00.h"
#include "unk_02056B30.h"
#include "unk_020655F4.h"
typedef struct UnkStruct_ov5_021D432C_t {
int unk_00;
UnkStruct_02055130 unk_04;
TerrainCollisionHitbox unk_04;
int unk_14;
int unk_18;
u8 unk_1C;
@ -75,7 +74,7 @@ BOOL ov5_021D433C(FieldSystem *fieldSystem, UnkStruct_ov5_021D432C *param1)
case 0: {
BOOL v1;
MapProp *v2;
UnkStruct_02055130 v3;
TerrainCollisionHitbox v3;
int v4;
int v5[] = {
MAP_PROP_MODEL_DOOR01,
@ -103,11 +102,11 @@ BOOL ov5_021D433C(FieldSystem *fieldSystem, UnkStruct_ov5_021D432C *param1)
param1->unk_20 = 0;
param1->unk_1D = 0;
sub_020550F4(param1->unk_14, param1->unk_18, -1, -1, 3, 1, &v3);
TerrainCollisionHitbox_Init(param1->unk_14, param1->unk_18, -1, -1, 3, 1, &v3);
param1->unk_1C = 1;
v1 = sub_02055208(fieldSystem, v5, NELEMS(v5), &v3, &v2, &v4);
v1 = FieldSystem_FindCollidingLoadedMapPropByModelIDs(fieldSystem, v5, NELEMS(v5), &v3, &v2, &v4);
if (v1) {
u8 v6;
@ -234,7 +233,7 @@ BOOL ov5_021D453C(FieldSystem *fieldSystem, UnkStruct_ov5_021D432C *param1)
case 0: {
BOOL v1;
MapProp *v2;
UnkStruct_02055130 v3;
TerrainCollisionHitbox v3;
int v4;
int v5[] = {
MAP_PROP_MODEL_DOOR01,
@ -261,10 +260,10 @@ BOOL ov5_021D453C(FieldSystem *fieldSystem, UnkStruct_ov5_021D432C *param1)
param1->unk_20 = 0;
param1->unk_1D = 0;
sub_020550F4(param1->unk_14, param1->unk_18, -1, 0, 3, 1, &v3);
TerrainCollisionHitbox_Init(param1->unk_14, param1->unk_18, -1, 0, 3, 1, &v3);
param1->unk_1C = 1;
v1 = sub_02055208(fieldSystem, v5, NELEMS(v5), &v3, &v2, &v4);
v1 = FieldSystem_FindCollidingLoadedMapPropByModelIDs(fieldSystem, v5, NELEMS(v5), &v3, &v2, &v4);
if (v1) {
u8 v6;
@ -483,7 +482,7 @@ BOOL ov5_021D4858(FieldSystem *fieldSystem, UnkStruct_ov5_021D432C *param1, cons
case 0: {
BOOL v1;
MapProp *v2;
UnkStruct_02055130 v3;
TerrainCollisionHitbox v3;
int v4;
int v5[] = {
MAP_PROP_MODEL_POKECENTER_STAIR_UP_LEFT,
@ -493,13 +492,13 @@ BOOL ov5_021D4858(FieldSystem *fieldSystem, UnkStruct_ov5_021D432C *param1, cons
};
if (param2 == 2) {
sub_020550F4(param1->unk_14, param1->unk_18, -1, 0, 2, 1, &v3);
TerrainCollisionHitbox_Init(param1->unk_14, param1->unk_18, -1, 0, 2, 1, &v3);
} else {
sub_020550F4(param1->unk_14, param1->unk_18, 0, 0, 2, 1, &v3);
TerrainCollisionHitbox_Init(param1->unk_14, param1->unk_18, 0, 0, 2, 1, &v3);
}
param1->unk_1C = 2;
v1 = sub_02055208(fieldSystem, v5, NELEMS(v5), &v3, &v2, &v4);
v1 = FieldSystem_FindCollidingLoadedMapPropByModelIDs(fieldSystem, v5, NELEMS(v5), &v3, &v2, &v4);
if (v1) {
u8 v6;
@ -600,7 +599,7 @@ BOOL ov5_021D4A24(FieldSystem *fieldSystem, UnkStruct_ov5_021D432C *param1, cons
case 0: {
BOOL v1;
MapProp *v2;
UnkStruct_02055130 v3;
TerrainCollisionHitbox v3;
int v4;
int v5[] = {
MAP_PROP_MODEL_POKECENTER_STAIR_UP_LEFT,
@ -610,13 +609,13 @@ BOOL ov5_021D4A24(FieldSystem *fieldSystem, UnkStruct_ov5_021D432C *param1, cons
};
if (param2 == 2) {
sub_020550F4(param1->unk_14, param1->unk_18, -1, 0, 2, 1, &v3);
TerrainCollisionHitbox_Init(param1->unk_14, param1->unk_18, -1, 0, 2, 1, &v3);
} else {
sub_020550F4(param1->unk_14, param1->unk_18, 0, 0, 2, 1, &v3);
TerrainCollisionHitbox_Init(param1->unk_14, param1->unk_18, 0, 0, 2, 1, &v3);
}
param1->unk_1C = 2;
v1 = sub_02055208(fieldSystem, v5, NELEMS(v5), &v3, &v2, &v4);
v1 = FieldSystem_FindCollidingLoadedMapPropByModelIDs(fieldSystem, v5, NELEMS(v5), &v3, &v2, &v4);
if (v1) {
u8 v6;
@ -714,7 +713,7 @@ void ov5_021D4BF4(FieldSystem *fieldSystem, const int param1, const int param2,
{
BOOL v0;
MapProp *v1;
UnkStruct_02055130 v2;
TerrainCollisionHitbox v2;
int v3;
int v4[] = {
MAP_PROP_MODEL_DOOR01,
@ -739,8 +738,8 @@ void ov5_021D4BF4(FieldSystem *fieldSystem, const int param1, const int param2,
MAP_PROP_MODEL_ELEVATOR_DOOR
};
sub_020550F4(param1, param2, -1, 0, 3, 1, &v2);
v0 = sub_02055208(fieldSystem, v4, NELEMS(v4), &v2, &v1, &v3);
TerrainCollisionHitbox_Init(param1, param2, -1, 0, 3, 1, &v2);
v0 = FieldSystem_FindCollidingLoadedMapPropByModelIDs(fieldSystem, v4, NELEMS(v4), &v2, &v1, &v3);
if (v0) {
u8 v5;
@ -833,13 +832,13 @@ void ov5_021D4D78(const int param0, const int param1, const int param2, FieldSys
{
BOOL v0;
MapProp *v1;
UnkStruct_02055130 v2;
TerrainCollisionHitbox v2;
int v3;
int v4[] = { 303, 304 };
sub_020550F4(param0, param1, 0, -1, 1, 3, &v2);
TerrainCollisionHitbox_Init(param0, param1, 0, -1, 1, 3, &v2);
v0 = sub_02055208(fieldSystem, v4, NELEMS(v4), &v2, &v1, &v3);
v0 = FieldSystem_FindCollidingLoadedMapPropByModelIDs(fieldSystem, v4, NELEMS(v4), &v2, &v1, &v3);
GF_ASSERT(v0);
{

4
src/overlay005/ov5_021EE75C.c
View File

@ -12,7 +12,7 @@
#include "map_tile_behavior.h"
#include "player_avatar.h"
#include "unk_02054D00.h"
#include "terrain_collision_manager.h"
typedef struct {
int unk_00;
@ -49,7 +49,7 @@ static void ov5_021EE768(UnkStruct_ov5_021D1BEC *param0, FieldSystem *fieldSyste
v4->unk_00 = v1;
v4->unk_04 = v2;
v0 = FieldSystem_GetTileBehavior(fieldSystem, v1, v2);
v0 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v1, v2);
if (TileBehavior_IsBikeSlopeBottom(v0)) {
v3 = 0;

4
src/overlay005/ov5_021F007C.c
View File

@ -20,8 +20,8 @@
#include "palette.h"
#include "player_avatar.h"
#include "script_manager.h"
#include "terrain_collision_manager.h"
#include "unk_02005474.h"
#include "unk_02054D00.h"
typedef struct {
int unk_00;
@ -475,7 +475,7 @@ BOOL ov5_021F0488(FieldTask *param0)
v4 = Player_GetXPos(fieldSystem->playerAvatar);
v5 = Player_GetZPos(fieldSystem->playerAvatar);
v3 = (u8)FieldSystem_GetTileBehavior(fieldSystem, v4, v5);
v3 = (u8)TerrainCollisionManager_GetTileBehavior(fieldSystem, v4, v5);
if (WildEncounters_TileHasEncounterRate(fieldSystem, v3)) {
v1->unk_0C = 6;

8
src/overlay006/ov6_02246C24.c
View File

@ -13,8 +13,8 @@
#include "field_task.h"
#include "heap.h"
#include "map_matrix.h"
#include "terrain_collision_manager.h"
#include "unk_02005474.h"
#include "unk_02054D00.h"
typedef struct {
VecFx32 unk_00;
@ -43,7 +43,7 @@ void ov6_02246C24(FieldSystem *fieldSystem, const u8 param1)
int v2;
int v3 = 123;
v0 = sub_020552B4(fieldSystem, v3, &v1, &v2);
v0 = FieldSystem_FindLoadedMapPropByModelID(fieldSystem, v3, &v1, &v2);
if (v0) {
UnkStruct_ov6_02246C24 *v4 = Heap_AllocFromHeapAtEnd(4, sizeof(UnkStruct_ov6_02246C24));
@ -56,7 +56,7 @@ void ov6_02246C24(FieldSystem *fieldSystem, const u8 param1)
{
VecFx32 v5;
sub_020553A4(v2, MapMatrix_GetWidth(fieldSystem->mapMatrix), &v5);
TerrainCollisionManager_GetMapAbsoluteOrigin(v2, MapMatrix_GetWidth(fieldSystem->mapMatrix), &v5);
v4->unk_00 = MapProp_GetPosition(v1);
v4->unk_00.x += v5.x;
@ -91,7 +91,7 @@ static BOOL ov6_02246C9C(FieldTask *param0)
MapPropOneShotAnimationManager_LoadPropAnimations(fieldSystem->mapPropAnimMan, fieldSystem->mapPropOneShotAnimMan, 0x10, MAP_PROP_MODEL_POKECENTER_HEALING_MACHINE_MINI_POKEBALL, NULL, v2, AreaDataManager_GetMapPropTexture(fieldSystem->areaDataManager), 1, 1, 0);
v8 = sub_020552B4(fieldSystem, 124, &v6, NULL);
v8 = FieldSystem_FindLoadedMapPropByModelID(fieldSystem, 124, &v6, NULL);
GF_ASSERT(v8);
v7 = MapProp_GetRenderObj(v6);

6
src/overlay006/ov6_02246F00.c
View File

@ -12,8 +12,8 @@
#include "field_task.h"
#include "heap.h"
#include "terrain_collision_manager.h"
#include "unk_02005474.h"
#include "unk_02054D00.h"
typedef struct {
u8 unk_00;
@ -26,7 +26,7 @@ static BOOL ov6_02246F40(FieldTask *param0);
void ov6_02246F00(FieldSystem *fieldSystem, const u8 param1, const u8 param2)
{
BOOL v0 = sub_020552B4(fieldSystem, 498, NULL, NULL);
BOOL v0 = FieldSystem_FindLoadedMapPropByModelID(fieldSystem, 498, NULL, NULL);
if (v0) {
UnkStruct_ov6_02246F00 *v1 = Heap_AllocFromHeapAtEnd(4, sizeof(UnkStruct_ov6_02246F00));
@ -57,7 +57,7 @@ static BOOL ov6_02246F40(FieldTask *param0)
v3 = AreaDataManager_GetMapPropModelFile(MAP_PROP_MODEL_ELEVATOR_LIGHTS, fieldSystem->areaDataManager);
v2 = NNS_G3dGetMdlByIdx(NNS_G3dGetMdlSet(*v3), 0);
v6 = sub_020552B4(fieldSystem, 498, &v4, NULL);
v6 = FieldSystem_FindLoadedMapPropByModelID(fieldSystem, 498, &v4, NULL);
GF_ASSERT(v6);
v5 = MapProp_GetRenderObj(v4);

8
src/overlay006/ov6_02247078.c
View File

@ -5,20 +5,18 @@
#include "constants/field/map_prop.h"
#include "struct_defs/struct_02055130.h"
#include "field/field_system.h"
#include "overlay005/area_data.h"
#include "overlay005/map_prop.h"
#include "overlay005/map_prop_animation.h"
#include "unk_02054D00.h"
#include "terrain_collision_manager.h"
void ov6_02247078(FieldSystem *fieldSystem, const u8 param1)
{
BOOL v0;
MapProp *v1;
UnkStruct_02055130 v2;
TerrainCollisionHitbox v2;
int v3;
int v4[] = {
MAP_PROP_MODEL_POKECENTER_PC,
@ -27,7 +25,7 @@ void ov6_02247078(FieldSystem *fieldSystem, const u8 param1)
MAP_PROP_MODEL_DESK_DRAWER_LAPTOP_FACING_LEFT
};
v0 = sub_02055324(fieldSystem, v4, 4, &v1, &v3);
v0 = FieldSystem_FindLoadedMapPropByModelIDs(fieldSystem, v4, 4, &v1, &v3);
if (v0) {
NNSG3dResTex *v5;

6
src/overlay006/ov6_02247D30.c
View File

@ -13,7 +13,7 @@
#include "field_task.h"
#include "heap.h"
#include "map_matrix.h"
#include "unk_02054D00.h"
#include "terrain_collision_manager.h"
typedef struct {
VecFx32 unk_00;
@ -42,7 +42,7 @@ void ov6_02247D30(FieldSystem *fieldSystem, const u8 param1)
int v2;
int v3 = 507;
v0 = sub_020552B4(fieldSystem, v3, &v1, &v2);
v0 = FieldSystem_FindLoadedMapPropByModelID(fieldSystem, v3, &v1, &v2);
if (v0) {
UnkStruct_ov6_02247D30 *v4 = Heap_AllocFromHeapAtEnd(4, sizeof(UnkStruct_ov6_02247D30));
@ -55,7 +55,7 @@ void ov6_02247D30(FieldSystem *fieldSystem, const u8 param1)
{
VecFx32 v5;
sub_020553A4(v2, MapMatrix_GetWidth(fieldSystem->mapMatrix), &v5);
TerrainCollisionManager_GetMapAbsoluteOrigin(v2, MapMatrix_GetWidth(fieldSystem->mapMatrix), &v5);
v4->unk_00 = MapProp_GetPosition(v1);
v4->unk_00.x += v5.x;
v4->unk_00.z += v5.z;

8
src/overlay006/wild_encounters.c
View File

@ -49,10 +49,10 @@
#include "special_encounter.h"
#include "system_flags.h"
#include "system_vars.h"
#include "terrain_collision_manager.h"
#include "trainer_data.h"
#include "trainer_info.h"
#include "unk_02054884.h"
#include "unk_02054D00.h"
#include "unk_020559DC.h"
#include "vars_flags.h"
@ -244,7 +244,7 @@ BOOL WildEncounters_TryWildEncounter(FieldSystem *fieldSystem)
int playerX = Player_GetXPos(fieldSystem->playerAvatar);
int playerZ = Player_GetZPos(fieldSystem->playerAvatar);
tileBehavior = FieldSystem_GetTileBehavior(fieldSystem, playerX, playerZ);
tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, playerX, playerZ);
u8 encounterRate = GetTileEncounterRateAndType(fieldSystem, tileBehavior, &encounterType);
@ -461,7 +461,7 @@ BOOL WildEncounters_TrySweetScentEncounter(FieldSystem *fieldSystem, FieldTask *
int playerX = Player_GetXPos(fieldSystem->playerAvatar);
int playerZ = Player_GetZPos(fieldSystem->playerAvatar);
u8 tileBehavior = FieldSystem_GetTileBehavior(fieldSystem, playerX, playerZ);
u8 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, playerX, playerZ);
u8 encounterRate = GetTileEncounterRateAndType(fieldSystem, tileBehavior, &encounterType);
@ -572,7 +572,7 @@ BOOL WildEncounters_TryMudEncounter(FieldSystem *fieldSystem, FieldBattleDTO **b
int playerX = Player_GetXPos(fieldSystem->playerAvatar);
int playerZ = Player_GetZPos(fieldSystem->playerAvatar);
u8 tileBehavior = FieldSystem_GetTileBehavior(fieldSystem, playerX, playerZ);
u8 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, playerX, playerZ);
u8 encounterRate = GetTileEncounterRateAndType(fieldSystem, tileBehavior, &encounterType);

13
src/overlay008/ov8_02249960.c
View File

@ -9,7 +9,6 @@
#include "struct_decls/struct_0205E884_decl.h"
#include "struct_decls/struct_02061830_decl.h"
#include "struct_decls/struct_02061AB4_decl.h"
#include "struct_defs/struct_02055130.h"
#include "struct_defs/struct_02071B10.h"
#include "struct_defs/struct_02071B30.h"
#include "struct_defs/struct_02071B6C.h"
@ -55,10 +54,10 @@
#include "sys_task_manager.h"
#include "system.h"
#include "system_vars.h"
#include "terrain_collision_manager.h"
#include "trainer_info.h"
#include "unk_02005474.h"
#include "unk_02027F50.h"
#include "unk_02054D00.h"
#include "unk_0205F180.h"
#include "unk_020655F4.h"
#include "unk_02067A84.h"
@ -338,7 +337,7 @@ static void ov8_0224996C(const u8 param0, int *param1)
void ov8_0224997C(FieldSystem *fieldSystem)
{
UnkStruct_02055130 v0;
TerrainCollisionHitbox v0;
int v1, v2;
BOOL v3;
int v4;
@ -347,9 +346,9 @@ void ov8_0224997C(FieldSystem *fieldSystem)
v1 = Player_GetXPos(fieldSystem->playerAvatar);
v2 = Player_GetZPos(fieldSystem->playerAvatar);
sub_020550F4(v1, v2, 0, 0, 1, 1, &v0);
TerrainCollisionHitbox_Init(v1, v2, 0, 0, 1, 1, &v0);
v3 = sub_02055208(fieldSystem, v5, NELEMS(v5), &v0, NULL, &v4);
v3 = FieldSystem_FindCollidingLoadedMapPropByModelIDs(fieldSystem, v5, NELEMS(v5), &v0, NULL, &v4);
if (v3) {
UnkStruct_ov8_0224997C *v6;
@ -379,7 +378,7 @@ void ov8_0224997C(FieldSystem *fieldSystem)
BOOL ov8_02249A40(FieldSystem *fieldSystem, const int param1, const int param2, const fx32 param3, BOOL *param4)
{
u8 v0 = FieldSystem_GetTileBehavior(fieldSystem, param1, param2);
u8 v0 = TerrainCollisionManager_GetTileBehavior(fieldSystem, param1, param2);
if (TileBehavior_IsPastoriaGymHighGround(v0)) {
if (param3 != 0) {
@ -3754,7 +3753,7 @@ void ov8_0224C198(FieldSystem *fieldSystem)
GF_ASSERT(v1->unk_02 < (v8->unk_04 + v8->unk_08));
GF_ASSERT(v1->unk_04 < (v8->unk_0C + v8->unk_14));
GF_ASSERT(v1->unk_06 < (v8->unk_10 + v8->unk_18));
GF_ASSERT(FieldSystem_CheckCollision(fieldSystem, v1->unk_04, v1->unk_06) == 0);
GF_ASSERT(TerrainCollisionManager_CheckCollision(fieldSystem, v1->unk_04, v1->unk_06) == 0);
}
}

14
src/overlay023/ov23_0223E140.c
View File

@ -56,6 +56,7 @@
#include "system.h"
#include "system_flags.h"
#include "system_vars.h"
#include "terrain_collision_manager.h"
#include "text.h"
#include "trainer_info.h"
#include "unk_020041CC.h"
@ -63,7 +64,6 @@
#include "unk_0200F174.h"
#include "unk_0202854C.h"
#include "unk_020393C8.h"
#include "unk_02054D00.h"
#include "unk_0206CCB0.h"
#include "vars_flags.h"
#include "vram_transfer.h"
@ -726,20 +726,20 @@ static BOOL ov23_0223E3AC(FieldSystem *fieldSystem, int param1, int param2)
return 0;
}
if (FieldSystem_CheckCollision(fieldSystem, param1, param2)) {
if (!FieldSystem_CheckCollision(fieldSystem, param1, param2 + 1)) {
if (TerrainCollisionManager_CheckCollision(fieldSystem, param1, param2)) {
if (!TerrainCollisionManager_CheckCollision(fieldSystem, param1, param2 + 1)) {
return 1;
}
if (!FieldSystem_CheckCollision(fieldSystem, param1, param2 - 1)) {
if (!TerrainCollisionManager_CheckCollision(fieldSystem, param1, param2 - 1)) {
return 1;
}
if (!FieldSystem_CheckCollision(fieldSystem, param1 + 1, param2)) {
if (!TerrainCollisionManager_CheckCollision(fieldSystem, param1 + 1, param2)) {
return 1;
}
if (!FieldSystem_CheckCollision(fieldSystem, param1 - 1, param2)) {
if (!TerrainCollisionManager_CheckCollision(fieldSystem, param1 - 1, param2)) {
return 1;
}
}
@ -797,7 +797,7 @@ static void ov23_0223E434(MATHRandContext16 *param0, int param1)
v5 = MATH_Rand16(param0, 20) + v4 - 10;
v8 = MATH_Rand16(param0, 20) + v7 - 10;
if (!FieldSystem_CheckCollision(Unk_ov23_02257740->fieldSystem, v5, v8)) {
if (!TerrainCollisionManager_CheckCollision(Unk_ov23_02257740->fieldSystem, v5, v8)) {
int v12 = ov23_02243C3C(v5, v8, param0, Unk_ov23_02257740->unk_A30);
if (0 != v12) {

4
src/overlay023/ov23_022416A8.c
View File

@ -28,9 +28,9 @@
#include "sys_task.h"
#include "sys_task_manager.h"
#include "system_flags.h"
#include "terrain_collision_manager.h"
#include "unk_02005474.h"
#include "unk_0202854C.h"
#include "unk_02054D00.h"
#include "vars_flags.h"
typedef struct {
@ -366,7 +366,7 @@ void ov23_02241AE8(int param0, int param1, int param2, int param3)
return;
}
if (FieldSystem_CheckCollision(Unk_ov23_02257744->fieldSystem, param2, param3)) {
if (TerrainCollisionManager_CheckCollision(Unk_ov23_02257744->fieldSystem, param2, param3)) {
ov23_02253F40(ov23_0224219C(), 60, 0, NULL);
return;
}

4
src/overlay023/ov23_02241F74.c
View File

@ -45,11 +45,11 @@
#include "sys_task_manager.h"
#include "system.h"
#include "system_flags.h"
#include "terrain_collision_manager.h"
#include "trainer_info.h"
#include "unk_0202854C.h"
#include "unk_02030EE0.h"
#include "unk_020366A0.h"
#include "unk_02054D00.h"
#include "vars_flags.h"
typedef BOOL (*UnkFuncPtr_ov23_02242540)(int, int);
@ -323,7 +323,7 @@ BOOL ov23_0224240C(int param0, int param1)
v0.unk_00 = param0;
v0.unk_02 = param1;
if (FieldSystem_CheckCollision(sCommManUnderground->fieldSystem, param0, param1)) {
if (TerrainCollisionManager_CheckCollision(sCommManUnderground->fieldSystem, param0, param1)) {
return 1;
}

6
src/overlay023/ov23_0224340C.c
View File

@ -48,12 +48,12 @@
#include "sys_task_manager.h"
#include "system.h"
#include "system_vars.h"
#include "terrain_collision_manager.h"
#include "trainer_info.h"
#include "unk_020041CC.h"
#include "unk_02005474.h"
#include "unk_0202854C.h"
#include "unk_020366A0.h"
#include "unk_02054D00.h"
#include "unk_0206CCB0.h"
#include "unk_020711EC.h"
#include "vars_flags.h"
@ -956,7 +956,7 @@ static UnkStruct_ov23_02243DA8 *ov23_02243A80(int param0, int param1, UnkStruct_
int v0 = 0;
UnkStruct_ov23_02243DA8 *v1;
if (FieldSystem_CheckCollision(Unk_ov23_02257764->fieldSystem, param0, param1)) {
if (TerrainCollisionManager_CheckCollision(Unk_ov23_02257764->fieldSystem, param0, param1)) {
return NULL;
}
@ -1038,7 +1038,7 @@ void ov23_02243B0C(int param0, int param1, void *param2, void *param3)
return;
}
if (FieldSystem_CheckCollision(Unk_ov23_02257764->fieldSystem, v1, v2)) {
if (TerrainCollisionManager_CheckCollision(Unk_ov23_02257764->fieldSystem, v1, v2)) {
v4.unk_07 = 6;
CommSys_SendDataServer(34, &v4, sizeof(UnkStruct_ov23_02243ED4));
return;

8
src/overlay023/ov23_0224B05C.c
View File

@ -50,6 +50,7 @@
#include "sys_task_manager.h"
#include "system.h"
#include "system_flags.h"
#include "terrain_collision_manager.h"
#include "trainer_info.h"
#include "unk_02005474.h"
#include "unk_0200F174.h"
@ -57,7 +58,6 @@
#include "unk_02030EE0.h"
#include "unk_02033200.h"
#include "unk_020366A0.h"
#include "unk_02054D00.h"
#include "unk_020573FC.h"
#include "unk_0205F180.h"
#include "unk_020655F4.h"
@ -1913,7 +1913,7 @@ void ov23_0224CD80(int param0, int param1, void *param2, void *param3)
(void)0;
} else if (ov23_02242E58(v1, v2)) {
v8.unk_01 = 6;
} else if (FieldSystem_CheckCollision(Unk_ov23_022577AC->fieldSystem, v1, v2) && FieldSystem_CheckCollision(Unk_ov23_022577AC->fieldSystem, v3, v4) && FieldSystem_CheckCollision(Unk_ov23_022577AC->fieldSystem, v5, v6)) {
} else if (TerrainCollisionManager_CheckCollision(Unk_ov23_022577AC->fieldSystem, v1, v2) && TerrainCollisionManager_CheckCollision(Unk_ov23_022577AC->fieldSystem, v3, v4) && TerrainCollisionManager_CheckCollision(Unk_ov23_022577AC->fieldSystem, v5, v6)) {
if (v0[0] == 0) {
v8.unk_01 = 1;
} else {
@ -2677,7 +2677,7 @@ void ov23_0224DAD0(int param0)
v0 = sub_02058EA0(v3);
v1 = sub_02058EC0(v3);
if (!FieldSystem_CheckCollision(Unk_ov23_022577AC->fieldSystem, v0, v1)) {
if (!TerrainCollisionManager_CheckCollision(Unk_ov23_022577AC->fieldSystem, v0, v1)) {
if (param0 == 0) {
return;
}
@ -2689,7 +2689,7 @@ void ov23_0224DAD0(int param0)
if ((v0 == 0xffff) && (v1 == 0xffff)) {
ov23_0224B844(v3, v3, 1);
} else if (ov23_02242E58(v0, v1) || FieldSystem_CheckCollision(Unk_ov23_022577AC->fieldSystem, v0, v1)) {
} else if (ov23_02242E58(v0, v1) || TerrainCollisionManager_CheckCollision(Unk_ov23_022577AC->fieldSystem, v0, v1)) {
ov23_0224B844(v3, v3, 1);
}
}

6
src/pokeradar.c
View File

@ -24,9 +24,9 @@
#include "scrcmd.h"
#include "script_manager.h"
#include "special_encounter.h"
#include "terrain_collision_manager.h"
#include "unk_02005474.h"
#include "unk_0201CED8.h"
#include "unk_02054D00.h"
#include "unk_020553DC.h"
#include "unk_020711EC.h"
@ -306,13 +306,13 @@ static BOOL CheckTileIsGrass(FieldSystem *fieldSystem, const fx32 param1, const
int v1 = (param3 - (9 / 2)) + param5;
patch->x = v0;
patch->z = v1;
u8 v2 = FieldSystem_GetTileBehavior(fieldSystem, v0, v1);
u8 v2 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v0, v1);
if (TileBehavior_IsTallGrass(v2)) {
u8 v3;
patch->position.x = FX32_ONE * 16 * v0;
patch->position.z = FX32_ONE * 16 * v1;
patch->position.y = sub_02054FBC(fieldSystem, 0, patch->position.x, patch->position.z, &v3);
patch->position.y = TerrainCollisionManager_GetHeight(fieldSystem, 0, patch->position.x, patch->position.z, &v3);
if (param1 != patch->position.y) {
patch->active = FALSE;

536
src/terrain_collision_manager.c Normal file
View File

@ -0,0 +1,536 @@
#include "terrain_collision_manager.h"
#include <nitro.h>
#include <string.h>
#include "constants/field/map.h"
#include "constants/quadrant.h"
#include "field/field_system.h"
#include "overlay005/bdhc.h"
#include "overlay005/dynamic_terrain_height.h"
#include "overlay005/land_data.h"
#include "overlay005/land_data_manager_decl.h"
#include "overlay005/map_prop.h"
#include "map_matrix.h"
#include "map_tile_behavior.h"
#include "unk_02054BD0.h"
#include "unk_02068344.h"
#define INVALID_TERRAIN_ATTRIBUTES 0xFF
#define INVALID_TILE_BEHAVIOR 0xFF
#define TERRAIN_ATTRIBUTES_COLLISION_SHIFT 15
#define TERRAIN_ATTRIBUTES_COLLISION_MASK 0x01
#define TERRAIN_ATTRIBUTES_TILE_BEHAVIOR_MASK 0xFF
enum VerticalDirection {
VERTICAL_DIRECTION_DOWN = -1,
VERTICAL_DIRECTION_NONE,
VERTICAL_DIRECTION_UP
};
static const fx32 GetHeight(const FieldSystem *fieldSystem, const fx32 objectHeight, const fx32 objectX, const fx32 objectZ, u8 *newObjectHeightSourceOut);
static const fx32 GetSimpleHeight(const FieldSystem *fieldSystem, const fx32 objectHeight, const fx32 objectX, const fx32 objectZ, u8 *newObjectHeightSourceOut);
static BOOL GetTileAttributes(const FieldSystem *fieldSystem, const int tileX, const int tileY, u16 *attributes);
static BOOL GetSimpleTileAttributes(const FieldSystem *fieldSystem, const int tileX, const int tileY, u16 *attributes);
static int GetVerticalDirection(const FieldSystem *fieldSystem, const VecFx32 *param1, const int param2, const int param3, u8 *param4);
static const TerrainCollisionManager sTerrainCollisionManagerFuncs = {
GetHeight,
GetTileAttributes
};
static const TerrainCollisionManager sSimpleTerrainCollisionManagerFuncs = {
GetSimpleHeight,
GetSimpleTileAttributes
};
static fx32 CalculateDistance(const fx32 lhs, const fx32 rhs)
{
return lhs >= rhs
? lhs - rhs
: rhs - lhs;
}
static const fx32 GetHeight(const FieldSystem *fieldSystem, const fx32 objectHeight, const fx32 objectX, const fx32 objectZ, u8 *newObjectHeightSourceOut)
{
BOOL dynHeightPlateFound;
u32 tileX, tileY;
u32 mapMatrixX, mapMatrixY;
VecFx32 objectPosition;
fx32 fixedObjectHeight;
const LandDataManager *landDataMan = fieldSystem->landDataMan;
VecFx32 offset;
LandDataManager_GetOffset(landDataMan, &offset);
fixedObjectHeight = objectHeight - offset.y;
BOOL bdhcHeightValid;
fx32 newObjectHeight = 0;
objectPosition.x = objectX - offset.x;
objectPosition.z = objectZ - offset.z;
objectPosition.y = 0;
int mapMatrixWidth = MapMatrix_GetWidth(fieldSystem->mapMatrix);
int mapMatrixWidthTiles = mapMatrixWidth * MAP_TILES_COUNT_X;
tileX = (objectX - offset.x) / MAP_OBJECT_TILE_SIZE;
tileY = (objectZ - offset.z) / MAP_OBJECT_TILE_SIZE;
u8 dynHeightPlateIndex;
dynHeightPlateFound = DynamicTerrainHeightManager_GetPlateIndexOfTile(tileX, tileY, fieldSystem->dynamicTerrainHeightMan, &dynHeightPlateIndex);
mapMatrixX = tileX / MAP_TILES_COUNT_X;
mapMatrixY = tileY / MAP_TILES_COUNT_Y;
u32 mapMatrixIndex = mapMatrixX + mapMatrixY * mapMatrixWidth;
fx32 currentMapOriginX = (mapMatrixX * MAP_TILES_COUNT_X + MAP_TILES_COUNT_X / 2) * MAP_OBJECT_TILE_SIZE;
fx32 currentMapOriginZ = (mapMatrixY * MAP_TILES_COUNT_Y + MAP_TILES_COUNT_Y / 2) * MAP_OBJECT_TILE_SIZE;
objectPosition.x = objectX - currentMapOriginX - offset.x;
objectPosition.z = objectZ - currentMapOriginZ - offset.z;
u32 tileIndex = tileX + tileY * mapMatrixWidthTiles;
u8 tileMapQuadrant = LandDataManager_CalculateMapQuadrantOfTile(tileIndex, mapMatrixWidthTiles);
u32 loadedMapIndex = LandDataManager_GetRelativeLoadedMapsQuadrant(mapMatrixIndex, tileMapQuadrant, landDataMan);
if (loadedMapIndex > QUADRANT_COUNT - 1) {
bdhcHeightValid = FALSE;
} else {
const BDHC *bdhc = LandDataManager_GetLoadedMapBDHC(landDataMan, loadedMapIndex);
bdhcHeightValid = CalculateObjectHeight(fixedObjectHeight, objectPosition.x, objectPosition.z, bdhc, &objectPosition.y);
}
u8 newObjectHeightSource;
if (dynHeightPlateFound) {
fx32 dynamicHeight = DynamicTerrainHeightManager_GetHeight(dynHeightPlateIndex, fieldSystem->dynamicTerrainHeightMan);
if (bdhcHeightValid) {
if (dynamicHeight <= objectPosition.y) {
newObjectHeightSource = CALCULATED_HEIGHT_SOURCE_BDHC;
newObjectHeight = objectPosition.y;
} else {
fx32 bdhcHeightDiff = CalculateDistance(objectPosition.y, fixedObjectHeight);
fx32 dynamicHeightDiff = CalculateDistance(dynamicHeight, fixedObjectHeight);
if (bdhcHeightDiff <= dynamicHeightDiff) {
newObjectHeight = objectPosition.y;
newObjectHeightSource = CALCULATED_HEIGHT_SOURCE_BDHC;
} else {
newObjectHeight = dynamicHeight;
newObjectHeightSource = CALCULATED_HEIGHT_SOURCE_DYNAMIC;
}
}
} else {
newObjectHeightSource = CALCULATED_HEIGHT_SOURCE_DYNAMIC;
newObjectHeight = dynamicHeight;
}
} else {
if (bdhcHeightValid) {
newObjectHeightSource = CALCULATED_HEIGHT_SOURCE_BDHC;
newObjectHeight = objectPosition.y;
} else {
newObjectHeightSource = CALCULATED_HEIGHT_SOURCE_NONE;
}
}
if (newObjectHeightSourceOut != NULL) {
*newObjectHeightSourceOut = newObjectHeightSource;
}
newObjectHeight += offset.y;
return newObjectHeight;
}
static const fx32 GetSimpleHeight(const FieldSystem *fieldSystem, const fx32 objectHeight, const fx32 objectX, const fx32 objectZ, u8 *newObjectHeightSourceOut)
{
int tileX = objectX / MAP_OBJECT_TILE_SIZE;
int tileY = objectZ / MAP_OBJECT_TILE_SIZE;
BOOL loadedMapIndexValid = LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(fieldSystem->landDataMan, tileX, tileY, NULL);
u8 newObjectHeightSource;
if (loadedMapIndexValid) {
newObjectHeightSource = CALCULATED_HEIGHT_SOURCE_BDHC;
} else {
newObjectHeightSource = CALCULATED_HEIGHT_SOURCE_NONE;
}
if (newObjectHeightSourceOut != NULL) {
*newObjectHeightSourceOut = newObjectHeightSource;
}
return 0;
}
static BOOL GetTileAttributes(const FieldSystem *fieldSystem, const int tileX, const int tileY, u16 *attributes)
{
int fixedTileX, fixedTileY;
const LandDataManager *landDataMan = fieldSystem->landDataMan;
fixedTileX = tileX - LandDataManager_GetOffsetTileX(landDataMan);
fixedTileY = tileY - LandDataManager_GetOffsetTileY(landDataMan);
u8 loadedMapIndex;
BOOL loadedMapIndexValid = LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(landDataMan, tileX, tileY, &loadedMapIndex);
if (loadedMapIndexValid == FALSE) {
(*attributes) = INVALID_TERRAIN_ATTRIBUTES;
return FALSE;
}
u32 fixedTileIndex = (fixedTileY % MAP_TILES_COUNT_Y) * MAP_TILES_COUNT_X + (fixedTileX % MAP_TILES_COUNT_X);
u16 const *terrainAttributes = LandDataManager_GetLoadedMapTerrainAttributes(landDataMan, loadedMapIndex);
*attributes = terrainAttributes[fixedTileIndex];
return TRUE;
}
static BOOL GetSimpleTileAttributes(const FieldSystem *fieldSystem, const int tileX, const int tileY, u16 *attributes)
{
const LandDataManager *landDataMan = fieldSystem->landDataMan;
int mapMatrixWidth = MapMatrix_GetWidth(fieldSystem->mapMatrix);
int mapMatrixWidthTiles = mapMatrixWidth * MAP_TILES_COUNT_X;
u32 mapMatrixX = tileX / MAP_TILES_COUNT_X;
u32 mapMatrixY = tileY / MAP_TILES_COUNT_Y;
u32 mapMatrixIndex = mapMatrixX + mapMatrixY * mapMatrixWidth;
u32 tileIndex = (tileY % MAP_TILES_COUNT_Y) * MAP_TILES_COUNT_X + (tileX % MAP_TILES_COUNT_X);
u16 const *terrainAttributes = sub_02054C0C(mapMatrixIndex, fieldSystem->unk_58);
*attributes = terrainAttributes[tileIndex];
return TRUE;
}
void TerrainCollisionManager_Init(const TerrainCollisionManager **terrainCollisionMan, BOOL useSimpleTerrainCollisions)
{
if (useSimpleTerrainCollisions == FALSE) {
*terrainCollisionMan = &sTerrainCollisionManagerFuncs;
} else if (useSimpleTerrainCollisions == TRUE) {
*terrainCollisionMan = &sSimpleTerrainCollisionManagerFuncs;
} else {
GF_ASSERT(FALSE);
}
}
BOOL TerrainCollisionManager_CheckCollision(const FieldSystem *fieldSystem, const int tileX, const int tileY)
{
u16 attributes;
BOOL attributesValid = fieldSystem->terrainCollisionMan->getTileAttributes(fieldSystem, tileX, tileY, &attributes);
if (attributesValid) {
u8 hasCollision = attributes >> TERRAIN_ATTRIBUTES_COLLISION_SHIFT;
hasCollision &= TERRAIN_ATTRIBUTES_COLLISION_MASK;
if (hasCollision == TRUE) {
return TRUE;
}
}
return FALSE;
}
u8 TerrainCollisionManager_GetTileBehavior(const FieldSystem *fieldSystem, const int tileX, const int tileY)
{
u16 attributes;
if (fieldSystem->terrainCollisionMan->getTileAttributes(fieldSystem, tileX, tileY, &attributes)) {
u8 behavior = attributes;
behavior &= TERRAIN_ATTRIBUTES_TILE_BEHAVIOR_MASK;
return behavior;
}
return INVALID_TILE_BEHAVIOR;
}
const fx32 TerrainCollisionManager_GetHeight(const FieldSystem *fieldSystem, const fx32 objectHeight, const fx32 objectX, const fx32 objectZ, u8 *newObjectHeightSource)
{
return fieldSystem->terrainCollisionMan->getHeight(fieldSystem, objectHeight, objectX, objectZ, newObjectHeightSource);
}
static int GetVerticalDirection(const FieldSystem *fieldSystem, const VecFx32 *objectPosition, const int tileX, const int tileY, u8 *newObjectHeightSource)
{
fx32 objectX = tileX * MAP_OBJECT_TILE_SIZE + MAP_OBJECT_TILE_SIZE / 2;
fx32 objectZ = tileY * MAP_OBJECT_TILE_SIZE + MAP_OBJECT_TILE_SIZE / 2;
fx32 objectHeight = TerrainCollisionManager_GetHeight(fieldSystem, objectPosition->y, objectX, objectZ, newObjectHeightSource);
int direction;
fx32 higherHeight, lowerHeight;
if (objectHeight < objectPosition->y) {
higherHeight = objectPosition->y;
lowerHeight = objectHeight;
direction = VERTICAL_DIRECTION_DOWN;
} else if (objectHeight > objectPosition->y) {
higherHeight = objectHeight;
lowerHeight = objectPosition->y;
direction = VERTICAL_DIRECTION_UP;
} else {
direction = VERTICAL_DIRECTION_NONE;
return direction;
}
if (higherHeight - lowerHeight >= 20 * FX32_ONE) {
GF_ASSERT(direction != VERTICAL_DIRECTION_NONE);
} else {
direction = VERTICAL_DIRECTION_NONE;
}
return direction;
}
BOOL TerrainCollisionManager_WillMapObjectCollide(const FieldSystem *fieldSystem, const VecFx32 *objectPosition, const int tileX, const int tileY, s8 *verticalDirection)
{
u8 newObjectHeightSource;
int direction = GetVerticalDirection(fieldSystem, objectPosition, tileX, tileY, &newObjectHeightSource);
if (verticalDirection != NULL) {
*verticalDirection = direction;
}
if (direction == VERTICAL_DIRECTION_NONE) {
BOOL isColliding = TerrainCollisionManager_CheckCollision(fieldSystem, tileX, tileY);
if (!isColliding && newObjectHeightSource == CALCULATED_HEIGHT_SOURCE_DYNAMIC) {
u8 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, tileX, tileY);
if (TileBehavior_IsPastoriaGymWater(tileBehavior)) {
return TRUE;
}
}
return isColliding;
} else {
return TRUE;
}
}
BOOL TerrainCollisionManager_WillPlayerCollide(FieldSystem *fieldSystem, const VecFx32 *objectPosition, const int tileX, const int tileY, s8 *verticalDirection)
{
u8 newObjectHeightSource;
int direction = GetVerticalDirection(fieldSystem, objectPosition, tileX, tileY, &newObjectHeightSource);
if (verticalDirection != NULL) {
*verticalDirection = direction;
}
if (direction == VERTICAL_DIRECTION_NONE) {
BOOL isColliding;
BOOL v3 = sub_02068390(fieldSystem, tileX, tileY, objectPosition->y, &isColliding);
if (!v3) {
isColliding = TerrainCollisionManager_CheckCollision(fieldSystem, tileX, tileY);
if (!isColliding && newObjectHeightSource == CALCULATED_HEIGHT_SOURCE_DYNAMIC) {
u8 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, tileX, tileY);
if (TileBehavior_IsPastoriaGymWater(tileBehavior)) {
return TRUE;
}
}
return isColliding;
} else {
return isColliding;
}
} else {
return TRUE;
}
}
void TerrainCollisionHitbox_Init(const int tileX, const int tileY, const int offsetTileX, const int offsetTileY, const u32 sizeX, const u32 sizeY, TerrainCollisionHitbox *hitbox)
{
int startTileX = tileX + offsetTileX;
int startTileY = tileY + offsetTileY;
int endTileX = startTileX + sizeX;
int endTileY = startTileY + sizeY;
if (startTileX < 0 || startTileY < 0 || endTileX < 0 || endTileY < 0) {
GF_ASSERT(FALSE);
}
hitbox->startX = startTileX * MAP_OBJECT_TILE_SIZE;
hitbox->startZ = startTileY * MAP_OBJECT_TILE_SIZE;
hitbox->endX = endTileX * MAP_OBJECT_TILE_SIZE;
hitbox->endZ = endTileY * MAP_OBJECT_TILE_SIZE;
}
BOOL TerrainCollisionHitbox_CollidesWithMapProp(const MapProp *mapProp, const TerrainCollisionHitbox *hitbox, const VecFx32 *mapAbsoluteOrigin)
{
VecFx32 mapPropPosition;
mapPropPosition = MapProp_GetPosition(mapProp);
mapPropPosition.x += mapAbsoluteOrigin->x;
mapPropPosition.z += mapAbsoluteOrigin->z;
if (hitbox->startX <= mapPropPosition.x && mapPropPosition.x <= hitbox->endX && hitbox->startZ <= mapPropPosition.z && mapPropPosition.z <= hitbox->endZ) {
return TRUE;
}
return FALSE;
}
BOOL FieldSystem_FindCollidingLoadedMapPropByModelID(const FieldSystem *fieldSystem, const int targetMapPropModelID, const TerrainCollisionHitbox *hitbox, MapProp **mapPropOut)
{
for (u8 i = 0; i < QUADRANT_COUNT; i++) {
MapPropManager *mapPropMan;
LandDataManager_GetLoadedMapPropManager(i, fieldSystem->landDataMan, &mapPropMan);
if (mapPropMan == NULL) {
continue;
}
int mapMatrixIndex = LandDataManager_GetLoadedMapMatrixIndex(fieldSystem->landDataMan, i);
int mapMatrixWidth = MapMatrix_GetWidth(fieldSystem->mapMatrix);
VecFx32 mapAbsoluteOrigin;
TerrainCollisionManager_GetMapAbsoluteOrigin(mapMatrixIndex, mapMatrixWidth, &mapAbsoluteOrigin);
for (u8 j = 0; j < MAX_LOADED_MAP_PROPS; j++) {
MapProp *mapProp = MapPropManager_GetLoadedProp(mapPropMan, j);
BOOL collidesWithMapProp = TerrainCollisionHitbox_CollidesWithMapProp(mapProp, hitbox, &mapAbsoluteOrigin);
if (collidesWithMapProp) {
int mapPropModelID = MapProp_GetModelID(mapProp);
if (mapPropModelID == targetMapPropModelID) {
if (mapPropOut != NULL) {
*mapPropOut = mapProp;
}
return TRUE;
}
}
}
}
return FALSE;
}
BOOL FieldSystem_FindCollidingLoadedMapPropByModelIDs(const FieldSystem *fieldSystem, const int *mapPropModelIDs, const u8 mapPropModelIDsCount, const TerrainCollisionHitbox *hitbox, MapProp **mapPropOut, int *mapPropModelIDOut)
{
for (u8 i = 0; i < QUADRANT_COUNT; i++) {
MapPropManager *mapPropMan;
LandDataManager_GetLoadedMapPropManager(i, fieldSystem->landDataMan, &mapPropMan);
if (mapPropMan == NULL) {
continue;
}
int mapMatrixIndex = LandDataManager_GetLoadedMapMatrixIndex(fieldSystem->landDataMan, i);
int mapMatrixWidth = MapMatrix_GetWidth(fieldSystem->mapMatrix);
VecFx32 mapAbsoluteOrigin;
TerrainCollisionManager_GetMapAbsoluteOrigin(mapMatrixIndex, mapMatrixWidth, &mapAbsoluteOrigin);
for (u8 j = 0; j < MAX_LOADED_MAP_PROPS; j++) {
MapProp *mapProp = MapPropManager_GetLoadedProp(mapPropMan, j);
BOOL collidesWithMapProp = TerrainCollisionHitbox_CollidesWithMapProp(mapProp, hitbox, &mapAbsoluteOrigin);
if (collidesWithMapProp) {
int mapPropModelID = MapProp_GetModelID(mapProp);
for (u8 k = 0; k < mapPropModelIDsCount; k++) {
if (mapPropModelID == mapPropModelIDs[k]) {
if (mapPropOut != NULL) {
*mapPropOut = mapProp;
}
if (mapPropModelIDOut != NULL) {
*mapPropModelIDOut = mapPropModelID;
}
return TRUE;
}
}
}
}
}
return FALSE;
}
BOOL FieldSystem_FindLoadedMapPropByModelID(const FieldSystem *fieldSystem, const int targetMapPropModelID, MapProp **mapPropOut, int *mapMatrixIndex)
{
for (u8 i = 0; i < QUADRANT_COUNT; i++) {
MapPropManager *mapPropMan;
LandDataManager_GetLoadedMapPropManager(i, fieldSystem->landDataMan, &mapPropMan);
if (mapPropMan == NULL) {
continue;
}
for (u8 j = 0; j < MAX_LOADED_MAP_PROPS; j++) {
MapProp *mapProp = MapPropManager_GetLoadedProp(mapPropMan, j);
int mapPropModelID = MapProp_GetModelID(mapProp);
if (mapPropModelID == targetMapPropModelID) {
if (mapPropOut != NULL) {
*mapPropOut = mapProp;
}
if (mapMatrixIndex != NULL) {
*mapMatrixIndex = LandDataManager_GetLoadedMapMatrixIndex(fieldSystem->landDataMan, i);
}
return TRUE;
}
}
}
return FALSE;
}
BOOL FieldSystem_FindLoadedMapPropByModelIDs(const FieldSystem *fieldSystem, const int *mapPropModelIDs, const u8 mapPropModelIDsCount, MapProp **mapPropOut, int *mapPropModelIDOut)
{
for (u8 i = 0; i < QUADRANT_COUNT; i++) {
MapPropManager *mapPropMan;
LandDataManager_GetLoadedMapPropManager(i, fieldSystem->landDataMan, &mapPropMan);
if (mapPropMan == NULL) {
continue;
}
for (u8 j = 0; j < MAX_LOADED_MAP_PROPS; j++) {
MapProp *mapProp = MapPropManager_GetLoadedProp(mapPropMan, j);
int mapPropModelID = MapProp_GetModelID(mapProp);
for (u8 k = 0; k < mapPropModelIDsCount; k++) {
if (mapPropModelID == mapPropModelIDs[k]) {
if (mapPropOut != NULL) {
*mapPropOut = mapProp;
}
if (mapPropModelIDOut != NULL) {
*mapPropModelIDOut = mapPropModelID;
}
return TRUE;
}
}
}
}
return FALSE;
}
void TerrainCollisionManager_GetMapAbsoluteOrigin(const int mapMatrixIndex, const int mapMatrixWidth, VecFx32 *mapAbsoluteOrigin)
{
mapAbsoluteOrigin->x = (MAP_TILES_COUNT_X / 2) * MAP_OBJECT_TILE_SIZE;
mapAbsoluteOrigin->z = (MAP_TILES_COUNT_Y / 2) * MAP_OBJECT_TILE_SIZE;
u16 mapMatrixX = mapMatrixIndex % mapMatrixWidth;
u16 mapMatrixY = mapMatrixIndex / mapMatrixWidth;
mapAbsoluteOrigin->x += mapMatrixX * MAP_TILES_COUNT_X * MAP_OBJECT_TILE_SIZE;
mapAbsoluteOrigin->z += mapMatrixY * MAP_TILES_COUNT_Y * MAP_OBJECT_TILE_SIZE;
}

4
src/unk_0203C954.c
View File

@ -13,7 +13,7 @@
#include "map_tile_behavior.h"
#include "player_avatar.h"
#include "script_manager.h"
#include "unk_02054D00.h"
#include "terrain_collision_manager.h"
static u8 sub_0203CB18(FieldSystem *fieldSystem, const BgEvent *param1);
static u8 sub_0203CAEC(FieldSystem *fieldSystem, const BgEvent *param1);
@ -61,7 +61,7 @@ void sub_0203C9D4(FieldSystem *fieldSystem, MapObject **param1)
u8 v3;
v2 = sub_0203C954(fieldSystem, &v0, &v1);
v3 = FieldSystem_GetTileBehavior(fieldSystem, v0, v1);
v3 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v0, v1);
if (TileBehavior_IsTable(v3) == 1) {
switch (v2) {

654
src/unk_02054D00.c
View File

@ -1,654 +0,0 @@
#include "unk_02054D00.h"
#include <nitro.h>
#include <string.h>
#include "struct_defs/struct_02055130.h"
#include "field/field_system.h"
#include "overlay005/bdhc.h"
#include "overlay005/dynamic_terrain_height.h"
#include "overlay005/land_data.h"
#include "overlay005/land_data_manager_decl.h"
#include "overlay005/map_prop.h"
#include "map_matrix.h"
#include "map_tile_behavior.h"
#include "unk_02054BD0.h"
#include "unk_02068344.h"
static const fx32 sub_02054D0C(const FieldSystem *fieldSystem, const fx32 param1, const fx32 param2, const fx32 param3, u8 *param4);
static const fx32 sub_02054E50(const FieldSystem *fieldSystem, const fx32 param1, const fx32 param2, const fx32 param3, u8 *param4);
static BOOL sub_02054E84(const FieldSystem *fieldSystem, const int param1, const int param2, u16 *param3);
static BOOL sub_02054EF4(const FieldSystem *fieldSystem, const int param1, const int param2, u16 *param3);
static int sub_02054FD0(const FieldSystem *fieldSystem, const VecFx32 *param1, const int param2, const int param3, u8 *param4);
static const TerrainCollisionManager Unk_020EC3D0 = {
sub_02054D0C,
sub_02054E84
};
static const TerrainCollisionManager Unk_020EC3D8 = {
sub_02054E50,
sub_02054EF4
};
static fx32 sub_02054D00(const fx32 param0, const fx32 param1)
{
fx32 v0;
if (param0 >= param1) {
v0 = param0 - param1;
} else {
v0 = param1 - param0;
}
return v0;
}
static const fx32 sub_02054D0C(const FieldSystem *fieldSystem, const fx32 param1, const fx32 param2, const fx32 param3, u8 *param4)
{
BOOL v0, v1;
u8 v2;
u32 v3, v4;
u32 v5, v6;
u32 v7;
u32 v8;
u32 v9;
u8 v10;
VecFx32 v11;
fx32 v12, v13;
u8 v14;
fx32 v15;
fx32 v16;
VecFx32 v17;
const LandDataManager *v18 = fieldSystem->landDataMan;
LandDataManager_GetOffset(v18, &v17);
v16 = param1 - v17.y;
v0 = 0;
v1 = 0;
v15 = 0;
v11.x = param2 - v17.x;
v11.z = param3 - v17.z;
v11.y = 0;
{
int v19;
int v20;
v19 = MapMatrix_GetWidth(fieldSystem->mapMatrix);
v20 = v19 * 32;
v3 = (param2 - v17.x) / (16 * FX32_ONE);
v4 = (param3 - v17.z) / (16 * FX32_ONE);
v0 = DynamicTerrainHeightManager_GetPlateIndexOfTile(v3, v4, fieldSystem->dynamicTerrainHeightMan, &v14);
v5 = v3 / 32;
v6 = v4 / 32;
v7 = v5 + v6 * v19;
v12 = ((v5 * 32) + (32 / 2)) * 16 * FX32_ONE;
v13 = ((v6 * 32) + (32 / 2)) * 16 * FX32_ONE;
v11.x = param2 - v12 - v17.x;
v11.z = param3 - v13 - v17.z;
v9 = v3 + v4 * v20;
v10 = LandDataManager_CalculateMapQuadrantOfTile(v9, v20);
v8 = LandDataManager_GetRelativeLoadedMapsQuadrant(v7, v10, v18);
if (v8 > 3) {
v1 = 0;
} else {
{
const BDHC *v21 = LandDataManager_GetLoadedMapBDHC(v18, v8);
v1 = CalculateObjectHeight(v16, v11.x, v11.z, v21, &v11.y);
}
}
}
if (v0) {
fx32 v22;
v22 = DynamicTerrainHeightManager_GetHeight(v14, fieldSystem->dynamicTerrainHeightMan);
if (v1) {
if (v22 <= v11.y) {
v2 = 1;
v15 = v11.y;
} else {
fx32 v23, v24;
v23 = sub_02054D00(v11.y, v16);
v24 = sub_02054D00(v22, v16);
if (v23 <= v24) {
v15 = v11.y;
v2 = 1;
} else {
v15 = v22;
v2 = 2;
}
}
} else {
v2 = 2;
v15 = v22;
}
} else {
if (v1) {
v2 = 1;
v15 = v11.y;
} else {
v2 = 0;
}
}
if (param4 != NULL) {
*param4 = v2;
}
v15 += v17.y;
return v15;
}
static const fx32 sub_02054E50(const FieldSystem *fieldSystem, const fx32 param1, const fx32 param2, const fx32 param3, u8 *param4)
{
BOOL v0;
int v1, v2;
fx32 v3;
u8 v4;
v1 = param2 / (16 * FX32_ONE);
v2 = param3 / (16 * FX32_ONE);
v0 = LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(fieldSystem->landDataMan, v1, v2, NULL);
if (v0) {
v4 = 1;
} else {
v4 = 0;
}
if (param4 != NULL) {
*param4 = v4;
}
v3 = 0;
return v3;
}
static BOOL sub_02054E84(const FieldSystem *fieldSystem, const int param1, const int param2, u16 *param3)
{
BOOL v0;
u32 v1, v2;
u32 v3;
u8 v4;
int v5, v6;
const LandDataManager *v7 = fieldSystem->landDataMan;
u32 v8;
u8 v9;
v5 = param1 - LandDataManager_GetOffsetTileX(v7);
v6 = param2 - LandDataManager_GetOffsetTileY(v7);
{
BOOL v10;
v10 = LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(v7, param1, param2, &v4);
if (v10 == 0) {
(*param3) = 0xff;
return 0;
}
{
u32 v11;
u16 const *v12;
v11 = (v6 % 32) * 32 + (v5 % 32);
v12 = LandDataManager_GetLoadedMapTerrainAttributes(v7, v4);
*param3 = v12[v11];
return 1;
}
}
}
static BOOL sub_02054EF4(const FieldSystem *fieldSystem, const int param1, const int param2, u16 *param3)
{
BOOL v0;
u32 v1, v2;
u32 v3;
u32 v4;
u32 v5;
u8 v6;
{
int v7;
int v8;
const LandDataManager *v9 = fieldSystem->landDataMan;
v7 = MapMatrix_GetWidth(fieldSystem->mapMatrix);
v8 = v7 * 32;
v1 = param1 / 32;
v2 = param2 / 32;
v3 = v1 + v2 * v7;
{
u32 v10;
u16 const *v11;
v10 = (param2 % 32) * 32 + (param1 % 32);
v11 = sub_02054C0C(v3, fieldSystem->unk_58);
*param3 = v11[v10];
return 1;
}
}
}
void sub_02054F44(const TerrainCollisionManager **param0, int param1)
{
if (param1 == 0) {
*param0 = &Unk_020EC3D0;
} else if (param1 == 1) {
*param0 = &Unk_020EC3D8;
} else {
GF_ASSERT(FALSE);
}
}
BOOL FieldSystem_CheckCollision(const FieldSystem *fieldSystem, const int param1, const int param2)
{
BOOL v0;
u16 v1;
v0 = fieldSystem->terrainCollisionMan->getAttrFunc(fieldSystem, param1, param2, &v1);
if (v0) {
u8 v2;
v2 = (u8)(v1 >> 15);
v2 &= 0x1;
if (v2 == 1) {
return 1;
}
}
return 0;
}
u8 FieldSystem_GetTileBehavior(const FieldSystem *fieldSystem, const int x, const int z)
{
u16 attributes;
if (fieldSystem->terrainCollisionMan->getAttrFunc(fieldSystem, x, z, &attributes)) {
u8 behavior = attributes;
behavior &= 0xFF;
return behavior;
}
return 0xFF;
}
const fx32 sub_02054FBC(const FieldSystem *fieldSystem, const fx32 param1, const fx32 param2, const fx32 param3, u8 *param4)
{
BOOL v0;
fx32 v1;
v1 = fieldSystem->terrainCollisionMan->getHeightFunc(fieldSystem, param1, param2, param3, param4);
return v1;
}
static int sub_02054FD0(const FieldSystem *fieldSystem, const VecFx32 *param1, const int param2, const int param3, u8 *param4)
{
int v0;
fx32 v1, v2;
fx32 v3, v4;
fx32 v5;
v3 = param2 * 16 * FX32_ONE + (8 * FX32_ONE);
v4 = param3 * 16 * FX32_ONE + (8 * FX32_ONE);
v5 = 0;
v5 = sub_02054FBC(fieldSystem, param1->y, v3, v4, param4);
if (v5 < param1->y) {
v1 = param1->y;
v2 = v5;
v0 = -1;
} else if (v5 > param1->y) {
v1 = v5;
v2 = param1->y;
v0 = 1;
} else {
v0 = 0;
return v0;
}
if (v1 - v2 >= (20 * FX32_ONE)) {
GF_ASSERT(v0 != 0);
} else {
v0 = 0;
}
return v0;
}
BOOL sub_02055024(const FieldSystem *fieldSystem, const VecFx32 *pos, const int x, const int z, s8 *param4)
{
int v0;
u8 v1;
v0 = sub_02054FD0(fieldSystem, pos, x, z, &v1);
if (param4 != NULL) {
*param4 = v0;
}
if (v0 == 0) {
BOOL v2;
v2 = FieldSystem_CheckCollision(fieldSystem, x, z);
if ((!v2) && (v1 == 2)) {
u8 v3 = FieldSystem_GetTileBehavior(fieldSystem, x, z);
if (TileBehavior_IsPastoriaGymWater(v3)) {
return TRUE;
}
}
return v2;
} else {
return TRUE;
}
}
BOOL sub_0205507C(FieldSystem *fieldSystem, const VecFx32 *param1, const int param2, const int param3, s8 *param4)
{
int v0;
u8 v1;
v0 = sub_02054FD0(fieldSystem, param1, param2, param3, &v1);
if (param4 != NULL) {
*param4 = v0;
}
if (v0 == 0) {
BOOL v2;
BOOL v3;
v3 = sub_02068390(fieldSystem, param2, param3, param1->y, &v2);
if (!v3) {
v2 = FieldSystem_CheckCollision(fieldSystem, param2, param3);
if ((!v2) && (v1 == 2)) {
u8 v4 = FieldSystem_GetTileBehavior(fieldSystem, param2, param3);
if (TileBehavior_IsPastoriaGymWater(v4)) {
return 1;
}
}
return v2;
} else {
return v2;
}
} else {
return 1;
}
}
void sub_020550F4(const int param0, const int param1, const int param2, const int param3, const u32 param4, const u32 param5, UnkStruct_02055130 *param6)
{
int v0, v1, v2, v3;
v0 = param0 + param2;
v1 = param1 + param3;
v2 = v0 + param4;
v3 = v1 + param5;
if ((v0 < 0) || (v1 < 0) || (v2 < 0) || (v3 < 0)) {
GF_ASSERT(FALSE);
}
param6->unk_00 = v0 * 16 * FX32_ONE;
param6->unk_04 = v1 * 16 * FX32_ONE;
param6->unk_08 = v2 * 16 * FX32_ONE;
param6->unk_0C = v3 * 16 * FX32_ONE;
}
BOOL sub_02055130(const MapProp *param0, const UnkStruct_02055130 *param1, const VecFx32 *param2)
{
VecFx32 v0;
v0 = MapProp_GetPosition(param0);
v0.x += param2->x;
v0.z += param2->z;
if ((param1->unk_00 <= v0.x) && (v0.x <= param1->unk_08) && (param1->unk_04 <= v0.z) && (v0.z <= param1->unk_0C)) {
return 1;
}
return 0;
}
BOOL sub_02055178(const FieldSystem *fieldSystem, const int param1, const UnkStruct_02055130 *param2, MapProp **param3)
{
u8 v0;
MapPropManager *v1;
for (v0 = 0; v0 < 4; v0++) {
LandDataManager_GetLoadedMapPropManager(v0, fieldSystem->landDataMan, &v1);
if (v1 == NULL) {
continue;
}
{
u8 v2;
VecFx32 v3;
int v4;
int v5;
BOOL v6;
v4 = LandDataManager_GetLoadedMapMatrixIndex(fieldSystem->landDataMan, v0);
v5 = MapMatrix_GetWidth(fieldSystem->mapMatrix);
sub_020553A4(v4, v5, &v3);
for (v2 = 0; v2 < 32; v2++) {
MapProp *v7;
v7 = MapPropManager_GetLoadedProp(v1, v2);
v6 = sub_02055130(v7, param2, &v3);
if (v6) {
int v8;
v8 = MapProp_GetModelID(v7);
if (v8 == param1) {
if (param3 != NULL) {
*param3 = v7;
}
return 1;
}
}
}
}
}
return 0;
}
BOOL sub_02055208(const FieldSystem *fieldSystem, const int *param1, const u8 param2, const UnkStruct_02055130 *param3, MapProp **param4, int *param5)
{
u8 v0;
MapPropManager *v1;
for (v0 = 0; v0 < 4; v0++) {
LandDataManager_GetLoadedMapPropManager(v0, fieldSystem->landDataMan, &v1);
if (v1 == NULL) {
continue;
}
{
u8 v2;
VecFx32 v3;
int v4;
int v5;
BOOL v6;
v4 = LandDataManager_GetLoadedMapMatrixIndex(fieldSystem->landDataMan, v0);
v5 = MapMatrix_GetWidth(fieldSystem->mapMatrix);
sub_020553A4(v4, v5, &v3);
for (v2 = 0; v2 < 32; v2++) {
MapProp *v7;
v7 = MapPropManager_GetLoadedProp(v1, v2);
v6 = sub_02055130(v7, param3, &v3);
if (v6) {
u8 v8;
int v9;
v9 = MapProp_GetModelID(v7);
for (v8 = 0; v8 < param2; v8++) {
if (v9 == param1[v8]) {
if (param4 != NULL) {
(*param4) = v7;
}
if (param5 != NULL) {
*param5 = v9;
}
return 1;
}
}
}
}
}
}
return 0;
}
BOOL sub_020552B4(const FieldSystem *fieldSystem, const int param1, MapProp **param2, int *param3)
{
u8 v0;
MapPropManager *v1;
for (v0 = 0; v0 < 4; v0++) {
LandDataManager_GetLoadedMapPropManager(v0, fieldSystem->landDataMan, &v1);
if (v1 == NULL) {
continue;
}
{
u8 v2;
for (v2 = 0; v2 < 32; v2++) {
MapProp *v3;
v3 = MapPropManager_GetLoadedProp(v1, v2);
{
u8 v4;
int v5;
v5 = MapProp_GetModelID(v3);
if (v5 == param1) {
if (param2 != NULL) {
(*param2) = v3;
}
if (param3 != NULL) {
(*param3) = LandDataManager_GetLoadedMapMatrixIndex(fieldSystem->landDataMan, v0);
}
return 1;
}
}
}
}
}
return 0;
}
BOOL sub_02055324(const FieldSystem *fieldSystem, const int *param1, const u8 param2, MapProp **param3, int *param4)
{
u8 v0;
MapPropManager *v1;
for (v0 = 0; v0 < 4; v0++) {
LandDataManager_GetLoadedMapPropManager(v0, fieldSystem->landDataMan, &v1);
if (v1 == NULL) {
continue;
}
{
u8 v2;
for (v2 = 0; v2 < 32; v2++) {
MapProp *v3;
v3 = MapPropManager_GetLoadedProp(v1, v2);
{
u8 v4;
int v5;
v5 = MapProp_GetModelID(v3);
for (v4 = 0; v4 < param2; v4++) {
if (v5 == param1[v4]) {
if (param3 != NULL) {
(*param3) = v3;
}
if (param4 != NULL) {
*param4 = v5;
}
return 1;
}
}
}
}
}
}
return 0;
}
void sub_020553A4(const int param0, const int param1, VecFx32 *param2)
{
u16 v0;
u16 v1;
param2->x = (32 / 2) * 16 * FX32_ONE;
param2->z = (32 / 2) * 16 * FX32_ONE;
v0 = param0 % param1;
v1 = param0 / param1;
param2->x += v0 * 32 * 16 * FX32_ONE;
param2->z += v1 * 32 * 16 * FX32_ONE;
}

4
src/unk_02055C50.c
View File

@ -23,8 +23,8 @@
#include "savedata_misc.h"
#include "sys_task_manager.h"
#include "system.h"
#include "terrain_collision_manager.h"
#include "unk_0201CED8.h"
#include "unk_02054D00.h"
#include "unk_020655F4.h"
#include "unk_020677F4.h"
#include "unk_0206CCB0.h"
@ -313,7 +313,7 @@ static BOOL sub_02056010(FieldSystem *fieldSystem, UnkStruct_020562AC *param1, i
GF_ASSERT(0);
}
if (FieldSystem_CheckCollision(fieldSystem, v0, v1)) {
if (TerrainCollisionManager_CheckCollision(fieldSystem, v0, v1)) {
return 1;
}

12
src/unk_02056B30.c
View File

@ -27,9 +27,9 @@
#include "map_object.h"
#include "map_tile_behavior.h"
#include "player_avatar.h"
#include "terrain_collision_manager.h"
#include "unk_02005474.h"
#include "unk_0200F174.h"
#include "unk_02054D00.h"
#include "unk_020553DC.h"
#include "unk_020655F4.h"
@ -431,7 +431,7 @@ static BOOL sub_02057050(FieldTask *taskMan)
u8 v4;
MapObject *v5 = Player_MapObject(fieldSystem->playerAvatar);
v4 = FieldSystem_GetTileBehavior(fieldSystem, Player_GetXPos(fieldSystem->playerAvatar), Player_GetZPos(fieldSystem->playerAvatar));
v4 = TerrainCollisionManager_GetTileBehavior(fieldSystem, Player_GetXPos(fieldSystem->playerAvatar), Player_GetZPos(fieldSystem->playerAvatar));
if (TileBehavior_IsDoor(v4)) {
MapObject_SetHidden(v5, 1);
@ -482,7 +482,7 @@ static BOOL sub_0205711C(FieldTask *taskMan)
u8 v4;
MapObject *v5 = Player_MapObject(fieldSystem->playerAvatar);
v4 = FieldSystem_GetTileBehavior(fieldSystem, Player_GetXPos(fieldSystem->playerAvatar), Player_GetZPos(fieldSystem->playerAvatar));
v4 = TerrainCollisionManager_GetTileBehavior(fieldSystem, Player_GetXPos(fieldSystem->playerAvatar), Player_GetZPos(fieldSystem->playerAvatar));
if (TileBehavior_IsDoor(v4)) {
MapObject_SetHidden(v5, 1);
@ -616,7 +616,7 @@ static void sub_02057300(FieldSystem *fieldSystem)
v1.x += (FX32_ONE * 16);
}
v1.y = sub_02054FBC(fieldSystem, v1.y, v1.x, v1.z, NULL);
v1.y = TerrainCollisionManager_GetHeight(fieldSystem, v1.y, v1.x, v1.z, NULL);
sub_0205ECB8(fieldSystem->playerAvatar, &v1, v0);
Camera_SetTargetAndUpdatePosition(PlayerAvatar_PosVector(fieldSystem->playerAvatar), fieldSystem->camera);
@ -634,7 +634,7 @@ static void sub_02057368(FieldSystem *fieldSystem)
v0 = Player_GetXPos(fieldSystem->playerAvatar);
v1 = Player_GetZPos(fieldSystem->playerAvatar);
v4 = FieldSystem_GetTileBehavior(fieldSystem, v0, v1);
v4 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v0, v1);
if (TileBehavior_IsWarpStairsEast(v4)) {
v3.x += (FX32_ONE * 16);
@ -646,7 +646,7 @@ static void sub_02057368(FieldSystem *fieldSystem)
(void)0;
}
v3.y = sub_02054FBC(fieldSystem, v3.y, v3.x, v3.z, NULL);
v3.y = TerrainCollisionManager_GetHeight(fieldSystem, v3.y, v3.x, v3.z, NULL);
sub_0205ECB8(fieldSystem->playerAvatar, &v3, v2);
Camera_SetTargetAndUpdatePosition(PlayerAvatar_PosVector(fieldSystem->playerAvatar), fieldSystem->camera);

22
src/unk_0205F180.c
View File

@ -20,8 +20,8 @@
#include "map_object_move.h"
#include "map_tile_behavior.h"
#include "player_avatar.h"
#include "terrain_collision_manager.h"
#include "unk_02005474.h"
#include "unk_02054D00.h"
#include "unk_020655F4.h"
#include "unk_02068344.h"
#include "unk_02071B10.h"
@ -1734,7 +1734,7 @@ static u32 sub_02060C24(PlayerAvatar *playerAvatar, MapObject *mapObj, int param
s8 v6;
FieldSystem *fieldSystem = MapObject_FieldSystem(mapObj);
if (sub_0205507C(fieldSystem, &v0, x, z, &v6) == 1) {
if (TerrainCollisionManager_WillPlayerCollide(fieldSystem, &v0, x, z, &v6) == 1) {
v1 |= (1 << 1);
if (v6 != 0) {
@ -1766,7 +1766,7 @@ static int sub_02060CE4(PlayerAvatar *playerAvatar, MapObject *mapObj, int param
}
{
u8 v3 = FieldSystem_GetTileBehavior(fieldSystem, v1, v2);
u8 v3 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v1, v2);
switch (param2) {
case 0:
@ -1804,7 +1804,7 @@ static int sub_02060D98(PlayerAvatar *playerAvatar, MapObject *mapObj, int param
FieldSystem *fieldSystem = MapObject_FieldSystem(mapObj);
int v2 = MapObject_GetX(mapObj) + MapObject_GetDxFromDir(param2);
int v3 = MapObject_GetZ(mapObj) + MapObject_GetDzFromDir(param2);
u8 v4 = FieldSystem_GetTileBehavior(fieldSystem, v2, v3);
u8 v4 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v2, v3);
switch (param2) {
case 0:
@ -1839,7 +1839,7 @@ static int sub_02060E40(PlayerAvatar *playerAvatar, MapObject *mapObj, int param
FieldSystem *fieldSystem = MapObject_FieldSystem(mapObj);
int v1 = MapObject_GetX(mapObj);
int v2 = MapObject_GetZ(mapObj);
u8 v3 = FieldSystem_GetTileBehavior(fieldSystem, v1, v2);
u8 v3 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v1, v2);
switch (param2) {
case 0:
@ -1866,7 +1866,7 @@ static int sub_02060E40(PlayerAvatar *playerAvatar, MapObject *mapObj, int param
v1 += MapObject_GetDxFromDir(param2);
v2 += MapObject_GetDzFromDir(param2);
v3 = FieldSystem_GetTileBehavior(fieldSystem, v1, v2);
v3 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v1, v2);
if (TileBehavior_IsDoor(v3) == 1) {
return 1;
@ -1882,7 +1882,7 @@ static int sub_02060EE4(PlayerAvatar *playerAvatar, MapObject *mapObj, int param
FieldSystem *fieldSystem = MapObject_FieldSystem(mapObj);
int v1 = MapObject_GetX(mapObj) + MapObject_GetDxFromDir(param2);
int v2 = MapObject_GetZ(mapObj) + MapObject_GetDzFromDir(param2);
u8 v3 = FieldSystem_GetTileBehavior(fieldSystem, v1, v2);
u8 v3 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v1, v2);
if ((param2 == 3) && TileBehavior_IsBikeRampEastward(v3)) {
return 1;
@ -1902,7 +1902,7 @@ static int sub_02060F4C(PlayerAvatar *playerAvatar, MapObject *mapObj, int param
FieldSystem *fieldSystem = MapObject_FieldSystem(mapObj);
int v1 = MapObject_GetX(mapObj) + MapObject_GetDxFromDir(param2);
int v2 = MapObject_GetZ(mapObj) + MapObject_GetDzFromDir(param2);
u8 v3 = FieldSystem_GetTileBehavior(fieldSystem, v1, v2);
u8 v3 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v1, v2);
if (MapObject_IsOnWater(mapObj, v3)) {
return 1;
@ -1918,7 +1918,7 @@ static int sub_02060FA8(PlayerAvatar *playerAvatar, MapObject *mapObj, int param
FieldSystem *fieldSystem = MapObject_FieldSystem(mapObj);
int v1 = MapObject_GetX(mapObj) + MapObject_GetDxFromDir(param2);
int v2 = MapObject_GetZ(mapObj) + MapObject_GetDzFromDir(param2);
u8 v3 = FieldSystem_GetTileBehavior(fieldSystem, v1, v2);
u8 v3 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v1, v2);
if (PlayerAvatar_GetPlayerState(playerAvatar) == PLAYER_STATE_CYCLING) {
if (MapObject_IsOnBikeBridgeNorthSouth(mapObj, v3) == 1) {
@ -1952,7 +1952,7 @@ static int sub_02061058(PlayerAvatar *playerAvatar, MapObject *mapObj, int param
FieldSystem *fieldSystem = MapObject_FieldSystem(mapObj);
int v1 = MapObject_GetX(mapObj) + MapObject_GetDxFromDir(param2);
int v2 = MapObject_GetZ(mapObj) + MapObject_GetDzFromDir(param2);
u8 v3 = FieldSystem_GetTileBehavior(fieldSystem, v1, v2);
u8 v3 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v1, v2);
if (MapObject_IsOnWater(mapObj, v3)) {
return 1;
@ -2456,7 +2456,7 @@ u32 sub_02061760(PlayerAvatar *playerAvatar)
int z = MapObject_GetZ(mapObj);
if (PlayerAvatar_DistortionGravityChanged(playerAvatar) == FALSE) {
v0 = FieldSystem_GetTileBehavior(fieldSystem, x, z);
v0 = TerrainCollisionManager_GetTileBehavior(fieldSystem, x, z);
} else {
ov9_02251044(fieldSystem, x, y, z, &v0);
}

6
src/unk_020683F4.c
View File

@ -51,11 +51,11 @@
#include "system.h"
#include "system_flags.h"
#include "system_vars.h"
#include "terrain_collision_manager.h"
#include "unk_0200F174.h"
#include "unk_02028124.h"
#include "unk_0203C954.h"
#include "unk_0203D1B8.h"
#include "unk_02054D00.h"
#include "unk_020553DC.h"
#include "unk_02055C50.h"
#include "unk_0205F180.h"
@ -222,7 +222,7 @@ void sub_0206842C(FieldSystem *fieldSystem, UnkStruct_020684D0 *param1)
v0 = Player_GetXPos(fieldSystem->playerAvatar);
v1 = Player_GetZPos(fieldSystem->playerAvatar);
param1->unk_0E = FieldSystem_GetTileBehavior(fieldSystem, v0, v1);
param1->unk_0E = TerrainCollisionManager_GetTileBehavior(fieldSystem, v0, v1);
v2 = PlayerAvatar_GetDir(fieldSystem->playerAvatar);
@ -241,7 +241,7 @@ void sub_0206842C(FieldSystem *fieldSystem, UnkStruct_020684D0 *param1)
break;
}
param1->unk_0C = FieldSystem_GetTileBehavior(fieldSystem, v0, v1);
param1->unk_0C = TerrainCollisionManager_GetTileBehavior(fieldSystem, v0, v1);
sub_0203C9D4(fieldSystem, &v3);
param1->unk_10 = sub_02055FC8(fieldSystem, v3);

6
src/unk_02069BE0.c
View File

@ -16,7 +16,7 @@
#include "map_object_move.h"
#include "map_tile_behavior.h"
#include "player_avatar.h"
#include "unk_02054D00.h"
#include "terrain_collision_manager.h"
#include "unk_020655F4.h"
#include "unk_02067A84.h"
@ -850,7 +850,7 @@ static BOOL sub_0206A524(FieldSystem *fieldSystem, int param1, int param2, int p
param1 += Unk_020EF92C[param3][param4];
param2 += Unk_020EF94C[param3][param4];
v0 = FieldSystem_CheckCollision(fieldSystem, param1, param2);
v0 = TerrainCollisionManager_CheckCollision(fieldSystem, param1, param2);
return v0;
}
@ -861,7 +861,7 @@ static BOOL sub_0206A54C(FieldSystem *fieldSystem, int param1, int param2, int p
param1 += Unk_020EF98C[param3][param4];
param2 += Unk_020EF9AC[param3][param4];
v0 = FieldSystem_CheckCollision(fieldSystem, param1, param2);
v0 = TerrainCollisionManager_CheckCollision(fieldSystem, param1, param2);
return v0;
}

15
src/unk_0206C784.c
View File

@ -5,7 +5,6 @@
#include "constants/field/map_prop.h"
#include "struct_defs/struct_02055130.h"
#include "struct_defs/struct_0206C8D4.h"
#include "field/field_system.h"
@ -21,11 +20,11 @@
#include "field_transition.h"
#include "heap.h"
#include "player_avatar.h"
#include "terrain_collision_manager.h"
#include "unk_020041CC.h"
#include "unk_02005474.h"
#include "unk_0200F174.h"
#include "unk_0203D1B8.h"
#include "unk_02054D00.h"
#include "unk_020553DC.h"
typedef struct {
@ -62,7 +61,7 @@ void sub_0206C784(FieldSystem *fieldSystem, const u8 param1, const u8 param2, co
UnkStruct_0206CAD0 *v0;
BOOL v1;
BOOL v2;
UnkStruct_02055130 v3;
TerrainCollisionHitbox v3;
int v4;
int v5;
@ -85,19 +84,19 @@ void sub_0206C784(FieldSystem *fieldSystem, const u8 param1, const u8 param2, co
if (param1 == 3) {
v4 = 34;
sub_020550F4(Player_GetXPos(fieldSystem->playerAvatar), Player_GetZPos(fieldSystem->playerAvatar), 1, -3, 3, 6, &v3);
TerrainCollisionHitbox_Init(Player_GetXPos(fieldSystem->playerAvatar), Player_GetZPos(fieldSystem->playerAvatar), 1, -3, 3, 6, &v3);
v1 = 1;
v5 = (25 * 16 * FX32_ONE);
v0->unk_10 = (14 * 16 * FX32_ONE);
} else if (param1 == 2) {
v4 = 538;
sub_020550F4(Player_GetXPos(fieldSystem->playerAvatar), Player_GetZPos(fieldSystem->playerAvatar), -2, 2, 6, 3, &v3);
TerrainCollisionHitbox_Init(Player_GetXPos(fieldSystem->playerAvatar), Player_GetZPos(fieldSystem->playerAvatar), -2, 2, 6, 3, &v3);
v1 = 1;
v5 = (12 * 16 * FX32_ONE);
}
if (v1) {
v2 = sub_02055178(fieldSystem, v4, &v3, &v0->unk_30);
v2 = FieldSystem_FindCollidingLoadedMapPropByModelID(fieldSystem, v4, &v3, &v0->unk_30);
if (v2) {
v0->unk_0C = v5;
@ -306,7 +305,7 @@ static void sub_0206CBA0(FieldSystem *fieldSystem)
int v3[2] = { 1, 2 };
for (v0 = 0; v0 < 2; v0++) {
v1 = sub_020552B4(fieldSystem, v2[v0], NULL, NULL);
v1 = FieldSystem_FindLoadedMapPropByModelID(fieldSystem, v2[v0], NULL, NULL);
if (v1) {
NNSG3dResMdl *v4;
@ -316,7 +315,7 @@ static void sub_0206CBA0(FieldSystem *fieldSystem)
v5 = AreaDataManager_GetMapPropModelFile(v2[v0], fieldSystem->areaDataManager);
v4 = NNS_G3dGetMdlByIdx(NNS_G3dGetMdlSet(*v5), 0);
v1 = sub_020552B4(fieldSystem, v2[v0], &v6, NULL);
v1 = FieldSystem_FindLoadedMapPropByModelID(fieldSystem, v2[v0], &v6, NULL);
GF_ASSERT(v1);
v7 = MapProp_GetRenderObj(v6);

6
src/unk_0207070C.c
View File

@ -33,10 +33,10 @@
#include "script_manager.h"
#include "start_menu.h"
#include "system_flags.h"
#include "terrain_collision_manager.h"
#include "trainer_info.h"
#include "unk_0203C954.h"
#include "unk_0203D1B8.h"
#include "unk_02054D00.h"
#include "unk_0205F180.h"
#include "unk_0206B70C.h"
#include "unk_020711C8.h"
@ -199,10 +199,10 @@ void sub_02070728(FieldSystem *fieldSystem, UnkStruct_02070950 *param1)
v1 = Player_GetXPos(fieldSystem->playerAvatar);
v2 = Player_GetZPos(fieldSystem->playerAvatar);
v4 = FieldSystem_GetTileBehavior(fieldSystem, v1, v2);
v4 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v1, v2);
PlayerAvatar_GetFacingTileCoords(fieldSystem->playerAvatar, &v1, &v2);
v3 = FieldSystem_GetTileBehavior(fieldSystem, v1, v2);
v3 = TerrainCollisionManager_GetTileBehavior(fieldSystem, v1, v2);
if (ov5_021E0118(fieldSystem->playerAvatar, v4, v3)) {
param1->unk_0C |= (1 << 2);

8
src/unk_0207160C.c
View File

@ -17,9 +17,9 @@
#include "heap.h"
#include "player_avatar.h"
#include "savedata_misc.h"
#include "terrain_collision_manager.h"
#include "unk_02005474.h"
#include "unk_02027F50.h"
#include "unk_02054D00.h"
typedef struct {
fx32 unk_00[2];
@ -141,7 +141,7 @@ void sub_0207160C(FieldSystem *fieldSystem)
} else {
const int v7[2] = { 258, 502 };
v0 = sub_02055324(fieldSystem, v7, 2, &v1, NULL);
v0 = FieldSystem_FindLoadedMapPropByModelIDs(fieldSystem, v7, 2, &v1, NULL);
GF_ASSERT(v0);
}
@ -333,7 +333,7 @@ static BOOL sub_020718D8(FieldTask *taskMan)
v0 = MapPropManager_FindLoadedPropByModelID(fieldSystem->mapPropManager, MAP_PROP_MODEL_IRON_ISLAND_LIFT_PLATFORM);
} else {
const int v3[2] = { 258, 502 };
BOOL v4 = sub_02055324(fieldSystem, v3, 2, &v0, NULL);
BOOL v4 = FieldSystem_FindLoadedMapPropByModelIDs(fieldSystem, v3, 2, &v0, NULL);
GF_ASSERT(v4);
}
@ -394,7 +394,7 @@ static BOOL sub_020719D8(FieldTask *taskMan)
v0 = MapPropManager_FindLoadedPropByModelID(fieldSystem->mapPropManager, MAP_PROP_MODEL_IRON_ISLAND_LIFT_PLATFORM);
} else {
const int v3[2] = { 258, 502 };
BOOL v4 = sub_02055324(fieldSystem, v3, 2, &v0, NULL);
BOOL v4 = FieldSystem_FindLoadedMapPropByModelIDs(fieldSystem, v3, 2, &v0, NULL);
GF_ASSERT(v4);
}