Leahnaya/pokeplatinum
1
0
Fork 0
mirror of https://github.com/pret/pokeplatinum.git synced 2026-03-21 17:55:13 -05:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Rename 2D Y coordinate component to Z

Browse Source 
This simply renames the `y` component in 2D coordinates to `z` in
the names of variables, constants, function parameters and struct
members.

Most common examples include:
- `tileY` -> `tileZ`
- `mapMatrixY` -> `mapMatrixZ`
- `sizeY` -> `sizeZ`

Signed-off-by: Kuruyia <github@kuruyia.net>
This commit is contained in:
Kuruyia 2025-03-30 20:54:01 +02:00
parent d37cbc9b4b
commit 7596c9c676
18 changed files with 194 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/constants/field/map.h
View File

@ -7,7 +7,7 @@
#define MAP_OBJECT_TILE_SIZE (16 * FX32_ONE)
#define MAP_TILES_COUNT_X 32
#define MAP_TILES_COUNT_Y 32
#define MAP_TILES_COUNT_Z 32
#define INVALID_LAND_DATA_ID 0xFFFF
#define INVALID_TERRAIN_ATTRIBUTES -1

4
include/dynamic_map_features.h
View File

@ -12,7 +12,7 @@ typedef BOOL (*DynamicMapFeaturesCheckCollisionFunc)(FieldSystem *, const int, c
void DynamicMapFeatures_Init(FieldSystem *fieldSystem);
void DynamicMapFeatures_Free(FieldSystem *fieldSystem);
BOOL DynamicMapFeatures_CheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding);
BOOL DynamicMapFeatures_WillPlayerJumpEternaGymClock(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 unused3, int direction);
BOOL DynamicMapFeatures_CheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding);
BOOL DynamicMapFeatures_WillPlayerJumpEternaGymClock(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 unused3, int direction);
#endif // POKEPLATINUM_DYNAMIC_MAP_FEATURES_H

8
include/overlay005/dynamic_terrain_height.h
View File

@ -6,9 +6,9 @@
typedef struct {
int startTileX;
int startTileY;
int startTileZ;
int sizeX;
int sizeY;
int sizeZ;
fx32 height;
BOOL valid;
} DynamicTerrainHeightPlate;
@ -19,9 +19,9 @@ typedef struct DynamicTerrainHeightManager {
} DynamicTerrainHeightManager;
DynamicTerrainHeightManager *DynamicTerrainHeightManager_New(const u8 platesCount, const u8 heapID);
void DynamicTerrainHeightManager_SetPlate(const u8 index, const int startTileX, const int startTileY, const int sizeX, const int sizeY, const fx32 height, DynamicTerrainHeightManager *dynamicTerrainHeightMan);
void DynamicTerrainHeightManager_SetPlate(const u8 index, const int startTileX, const int startTileZ, const int sizeX, const int sizeZ, const fx32 height, DynamicTerrainHeightManager *dynamicTerrainHeightMan);
void DynamicTerrainHeightManager_Free(DynamicTerrainHeightManager *dynamicTerrainHeightMan);
BOOL DynamicTerrainHeightManager_GetPlateIndexOfTile(const int tileX, const int tileY, const DynamicTerrainHeightManager *dynamicTerrainHeightMan, u8 *index);
BOOL DynamicTerrainHeightManager_GetPlateIndexOfTile(const int tileX, const int tileZ, const DynamicTerrainHeightManager *dynamicTerrainHeightMan, u8 *index);
fx32 DynamicTerrainHeightManager_GetHeight(const u8 index, const DynamicTerrainHeightManager *dynamicTerrainHeightMan);
void DynamicTerrainHeightManager_SetHeight(const u8 index, const fx32 height, DynamicTerrainHeightManager *dynamicTerrainHeightMan);

20
include/overlay005/land_data.h
View File

@ -19,10 +19,10 @@ typedef void (*MapLoadedCallback)(void *, const int, MapPropManager *const);
void LandDataManager_Tick(FieldSystem *fieldSystem, LandDataManager *landDataMan);
LandDataManager *LandDataManager_New(MapMatrix *mapMatrix, AreaDataManager *areaDataMan, MapPropAnimationManager *mapPropAnimMan, const BOOL skipAttributes);
void LandDataManager_InitialLoad(LandDataManager *landDataMan, const int playerTileX, const int playerTileY);
void LandDataManager_InitialLoad(LandDataManager *landDataMan, const int playerTileX, const int playerTileZ);
void LandDataManager_CheckLazyLoadNextMapPair(const u8 trackedTargetDirection, LandDataManager *landDataMan);
void LandDataManager_RenderLoadedMaps(const LandDataManager *landDataMan, ModelAttributes *const modelAttrs);
void LandData_ObjectPosToTilePos(fx32 objectPositionX, fx32 objectPositionZ, int *tileX, int *tileY);
void LandData_ObjectPosToTilePos(fx32 objectPositionX, fx32 objectPositionZ, int *tileX, int *tileZ);
void LandDataManager_End(LandDataManager *landDataMan);
void LandDataManager_FreeNARCAndLoadedMapBuffers(LandDataManager *landDataMan);
BOOL LandDataManager_HasEnded(const LandDataManager *landDataMan);
@ -33,14 +33,14 @@ u8 LandDataManager_GetTrackedTargetLoadedMapsQuadrant(const LandDataManager *lan
u8 LandDataManager_CalculateMapQuadrantOfTile(const u32 tileIndex, const int mapMatrixWidthTiles);
u8 LandDataManager_GetRelativeLoadedMapsQuadrant(const int mapMatrixIndex, const u8 unused1, const LandDataManager *landDataMan);
int LandDataManager_GetLoadedMapMatrixIndex(const LandDataManager *landDataMan, const u8 loadedMapIndex);
BOOL LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(const LandDataManager *landDataMan, const int tileX, const int tileY, u8 *result);
BOOL LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(const LandDataManager *landDataMan, const int tileX, const int tileZ, u8 *result);
const BDHC *LandDataManager_GetLoadedMapBDHC(const LandDataManager *landDataMan, const u8 loadedMapIndex);
u16 const *LandDataManager_GetLoadedMapTerrainAttributes(const LandDataManager *landDataMan, const u8 loadedMapIndex);
void LandDataManager_SetMapLoadedCallback(LandDataManager *landDataMan, MapLoadedCallback mapLoadedCb, void *cbUserData);
NARC *LandDataManager_GetLandDataNARC(LandDataManager *landDataMan);
void LandDataManager_SetInDistortionWorld(LandDataManager *landDataMan, BOOL inDistortionWorld);
int LandDataManager_GetOffsetTileX(const LandDataManager *landDataMan);
int LandDataManager_GetOffsetTileY(const LandDataManager *landDataMan);
int LandDataManager_GetOffsetTileZ(const LandDataManager *landDataMan);
void LandDataManager_GetOffset(const LandDataManager *landDataMan, VecFx32 *offset);
void LandDataManager_SetSkipMapProps(LandDataManager *landDataMan, BOOL skipMapProps);
void LandDataManager_SetMapMatrix(LandDataManager *landDataMan, MapMatrix *mapMatrix);
@ -52,18 +52,18 @@ void LandDataManager_DistortionWorldInit(LandDataManager *landDataMan, MapMatrix
void LandDataManager_DistortionWorldEnd(LandDataManager *landDataMan);
void LandDataManager_DistortionWorldInitLoadedMapPropManagers(LandDataManager *landDataMan);
void LandDataManager_DistortionWorldFreeLoadedMapBuffers(LandDataManager *landDataMan);
void LandDataManager_DistortionWorldInitialLoad(LandDataManager *landDataMan, const int playerTileX, const int playerTileY);
void LandDataManager_DistortionWorldInitLoadedMaps(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileY, int *loadedMapMatrixIndexes);
void LandDataManager_DistortionWorldInitialLoad(LandDataManager *landDataMan, const int playerTileX, const int playerTileZ);
void LandDataManager_DistortionWorldInitLoadedMaps(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileZ, int *loadedMapMatrixIndexes);
void LandDataManager_DistortionWorldLoadAndInvalidate(LandDataManager *landDataMan, int loadedMapIndex, int mapMatrixIndex);
void LandDataManager_DistortionWorldRenderNextFloorMaps(const LandDataManager *landDataMan, const ModelAttributes *modelAttrs);
void LandDataManager_DistortionWorldEndWithoutFreeing(LandDataManager *landDataMan);
void LandDataManager_DistortionWorldPrepareNextFloor(MapMatrix *mapMatrix, AreaDataManager *areaDataMan, LandDataManager *src, LandDataManager *dest, const int trackedTargetTileX, const int trackedTargetTileY);
void LandDataManager_DistortionWorldPrepareNextFloor(MapMatrix *mapMatrix, AreaDataManager *areaDataMan, LandDataManager *src, LandDataManager *dest, const int trackedTargetTileX, const int trackedTargetTileZ);
void LandDataManager_DistortionWorldPreparePreviousFloor(LandDataManager *dest, LandDataManager *src);
void LandDataManager_DistortionWorldTick(FieldSystem *fieldSystem, LandDataManager *landDataMan);
void LandDataManager_DistortionWorldInitWithoutNARC(LandDataManager *landDataMan, MapMatrix *mapMatrix, AreaDataManager *areaDataMan);
void LandDataManager_DistortionWorldInvalidateLoadedMaps(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileY, int *loadedMapMatrixIndexes);
void LandDataManager_DistortionWorldInvalidateLoadedMaps(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileZ, int *loadedMapMatrixIndexes);
void LandDataManager_DistortionWorldLoadEntire(LandDataManager *landDataMan, int loadedMapIndex, int mapMatrixIndex);
void LandDataManager_DistortionWorldSetOffsets(LandDataManager *landDataMan, int offsetTileX, int offsetAltitude, int offsetTileY);
void LandDataManager_DistortionWorldUpdateTrackedTargetValues(LandDataManager *landDataMan, int trackedTargetTileX, int trackedTargetTileY);
void LandDataManager_DistortionWorldSetOffsets(LandDataManager *landDataMan, int offsetTileX, int offsetAltitude, int offsetTileZ);
void LandDataManager_DistortionWorldUpdateTrackedTargetValues(LandDataManager *landDataMan, int trackedTargetTileX, int trackedTargetTileZ);
#endif // POKEPLATINUM_OV5_LAND_DATA_H

2
include/overlay005/ov5_021F8370.h
View File

@ -5,7 +5,7 @@
void Villa_DynamicMapFeaturesInit(FieldSystem *fieldSystem);
void Villa_DynamicMapFeaturesFree(FieldSystem *fieldSystem);
BOOL Villa_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding);
BOOL Villa_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding);
BOOL ov5_021F8410(FieldSystem *fieldSystem, const int param1, const int param2, const int param3);
#endif // POKEPLATINUM_OV5_021F8370_H

12
include/overlay008/ov8_02249960.h
View File

@ -8,25 +8,25 @@
#include "strbuf.h"
void ov8_0224997C(FieldSystem *fieldSystem);
BOOL PastoriaGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding);
BOOL PastoriaGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding);
void PastoriaGym_DynamicMapFeaturesInit(FieldSystem *fieldSystem);
void ov8_02249FB8(FieldSystem *fieldSystem);
void CanalaveGym_DynamicMapFeaturesInit(FieldSystem *fieldSystem);
BOOL ov8_0224AAA8(FieldSystem *fieldSystem);
void CanalaveGym_DynamicMapFeaturesFree(FieldSystem *fieldSystem);
BOOL CanalaveGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding);
BOOL CanalaveGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding);
void SunyshoreGym_DynamicMapFeaturesInit(FieldSystem *fieldSystem);
void SunyshoreGym_DynamicMapFeaturesFree(FieldSystem *fieldSystem);
BOOL SunyshoreGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding);
BOOL SunyshoreGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding);
void ov8_0224AD34(FieldSystem *fieldSystem, const u8 param1);
void EternaGym_DynamicMapFeaturesInit(FieldSystem *fieldSystem);
void EternaGym_DynamicMapFeaturesFree(FieldSystem *fieldSystem);
BOOL EternaGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding);
BOOL EternaGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding);
BOOL ov8_0224B67C(FieldSystem *fieldSystem, Window *param1, MessageLoader *param2, Strbuf *param3);
BOOL EternaGym_IsHourHandJumpTile(FieldSystem *fieldSystem, int tileX, int tileY, int direction);
BOOL EternaGym_IsHourHandJumpTile(FieldSystem *fieldSystem, int tileX, int tileZ, int direction);
void VeilstoneGym_DynamicMapFeaturesInit(FieldSystem *fieldSystem);
void VeilstoneGym_DynamicMapFeaturesFree(FieldSystem *fieldSystem);
BOOL VeilstoneGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding);
BOOL VeilstoneGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding);
BOOL ov8_0224BF4C(FieldSystem *fieldSystem);
void HearthomeGym_DynamicMapFeaturesInit(FieldSystem *fieldSystem);
void HearthomeGym_DynamicMapFeaturesFree(FieldSystem *fieldSystem);

2
include/overlay009/ov9_02249960.h
View File

@ -11,7 +11,7 @@
void DistortionWorld_DynamicMapFeaturesInit(FieldSystem *fieldSystem);
void DistortionWorld_DynamicMapFeaturesFree(FieldSystem *fieldSystem);
BOOL DistortionWorld_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding);
BOOL DistortionWorld_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding);
void ov9_02249F9C(FieldSystem *fieldSystem);
void ov9_02249FD0(FieldSystem *fieldSystem);
int ov9_0224A520(FieldSystem *fieldSystem, MapObject *param1);

10
include/terrain_collision_manager.h
View File

@ -29,14 +29,14 @@ enum CalculatedHeightSource {
};
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);
BOOL TerrainCollisionManager_CheckCollision(const FieldSystem *fieldSystem, const int tileX, const int tileZ);
u8 TerrainCollisionManager_GetTileBehavior(const FieldSystem *fieldSystem, const int tileX, const int tileZ);
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);
BOOL TerrainCollisionManager_WillMapObjectCollide(const FieldSystem *fieldSystem, const VecFx32 *objectPosition, const int tileX, const int tileZ, s8 *verticalDirection);
BOOL TerrainCollisionManager_WillPlayerCollide(FieldSystem *fieldSystem, const VecFx32 *objectPosition, const int tileX, const int tileZ, 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);
void TerrainCollisionHitbox_Init(const int tileX, const int tileZ, const int offsetTileX, const int offsetTileZ, const u32 sizeX, const u32 sizeZ, 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);

8
src/dynamic_map_features.c
View File

@ -85,7 +85,7 @@ void DynamicMapFeatures_Free(FieldSystem *fieldSystem)
}
}
BOOL DynamicMapFeatures_CheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding)
BOOL DynamicMapFeatures_CheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding)
{
PersistedMapFeatures *persistedMapFeatures = MiscSaveBlock_GetPersistedMapFeatures(FieldSystem_GetSaveData(fieldSystem));
int id = PersistedMapFeatures_GetID(persistedMapFeatures);
@ -95,15 +95,15 @@ BOOL DynamicMapFeatures_CheckCollision(FieldSystem *fieldSystem, const int tileX
}
if (sCheckCollisionFuncs[id] != NULL) {
BOOL hasCollision = sCheckCollisionFuncs[id](fieldSystem, tileX, tileY, height, isColliding);
BOOL hasCollision = sCheckCollisionFuncs[id](fieldSystem, tileX, tileZ, height, isColliding);
return hasCollision;
}
return FALSE;
}
BOOL DynamicMapFeatures_WillPlayerJumpEternaGymClock(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 unused3, int direction)
BOOL DynamicMapFeatures_WillPlayerJumpEternaGymClock(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 unused3, int direction)
{
return fieldSystem->location->mapId == MAP_HEADER_ETERNA_CITY_GYM
&& EternaGym_IsHourHandJumpTile(fieldSystem, tileX, tileY, direction);
&& EternaGym_IsHourHandJumpTile(fieldSystem, tileX, tileZ, direction);
}

18
src/overlay005/dynamic_terrain_height.c
View File

@ -5,19 +5,19 @@
#include "heap.h"
static BOOL DynamicTerrainHeightPlate_IsTileInPlate(const int tileX, const int tileY, const DynamicTerrainHeightPlate *plate)
static BOOL DynamicTerrainHeightPlate_IsTileInPlate(const int tileX, const int tileZ, const DynamicTerrainHeightPlate *plate)
{
if (!plate->valid) {
return FALSE;
}
int startTileX = plate->startTileX;
int startTileY = plate->startTileY;
int startTileZ = plate->startTileZ;
int endTileX = startTileX + plate->sizeX - 1;
int endTileY = startTileY + plate->sizeY - 1;
int endTileZ = startTileZ + plate->sizeZ - 1;
return startTileX <= tileX && tileX <= endTileX
&& startTileY <= tileY && tileY <= endTileY;
&& startTileZ <= tileZ && tileZ <= endTileZ;
}
DynamicTerrainHeightManager *DynamicTerrainHeightManager_New(const u8 platesCount, const u8 heapID)
@ -34,12 +34,12 @@ DynamicTerrainHeightManager *DynamicTerrainHeightManager_New(const u8 platesCoun
return dynamicTerrainHeightMan;
}
void DynamicTerrainHeightManager_SetPlate(const u8 index, const int startTileX, const int startTileY, const int sizeX, const int sizeY, const fx32 height, DynamicTerrainHeightManager *dynamicTerrainHeightMan)
void DynamicTerrainHeightManager_SetPlate(const u8 index, const int startTileX, const int startTileZ, const int sizeX, const int sizeZ, const fx32 height, DynamicTerrainHeightManager *dynamicTerrainHeightMan)
{
dynamicTerrainHeightMan->plates[index].startTileX = startTileX;
dynamicTerrainHeightMan->plates[index].startTileY = startTileY;
dynamicTerrainHeightMan->plates[index].startTileZ = startTileZ;
dynamicTerrainHeightMan->plates[index].sizeX = sizeX;
dynamicTerrainHeightMan->plates[index].sizeY = sizeY;
dynamicTerrainHeightMan->plates[index].sizeZ = sizeZ;
dynamicTerrainHeightMan->plates[index].height = height;
dynamicTerrainHeightMan->plates[index].valid = TRUE;
}
@ -50,14 +50,14 @@ void DynamicTerrainHeightManager_Free(DynamicTerrainHeightManager *dynamicTerrai
Heap_FreeToHeap(dynamicTerrainHeightMan);
}
BOOL DynamicTerrainHeightManager_GetPlateIndexOfTile(const int tileX, const int tileY, const DynamicTerrainHeightManager *dynamicTerrainHeightMan, u8 *index)
BOOL DynamicTerrainHeightManager_GetPlateIndexOfTile(const int tileX, const int tileZ, const DynamicTerrainHeightManager *dynamicTerrainHeightMan, u8 *index)
{
GF_ASSERT(index != NULL);
for (u8 i = 0; i < dynamicTerrainHeightMan->platesCount; i++) {
DynamicTerrainHeightPlate *plate = &dynamicTerrainHeightMan->plates[i];
if (DynamicTerrainHeightPlate_IsTileInPlate(tileX, tileY, plate)) {
if (DynamicTerrainHeightPlate_IsTileInPlate(tileX, tileZ, plate)) {
*index = i;
return TRUE;
}

4
src/overlay005/fieldmap.c
View File

@ -406,7 +406,7 @@ static BOOL FieldMap_ChangeZone(FieldSystem *fieldSystem)
}
x = (Player_GetXPos(fieldSystem->playerAvatar) - LandDataManager_GetOffsetTileX(fieldSystem->landDataMan)) / MAP_TILES_COUNT_X;
y = (Player_GetZPos(fieldSystem->playerAvatar) - LandDataManager_GetOffsetTileY(fieldSystem->landDataMan)) / MAP_TILES_COUNT_Y;
y = (Player_GetZPos(fieldSystem->playerAvatar) - LandDataManager_GetOffsetTileZ(fieldSystem->landDataMan)) / MAP_TILES_COUNT_Z;
v0 = MapMatrix_GetMapHeaderIDAtCoords(fieldSystem->mapMatrix, x, y);
mapId = fieldSystem->location->mapId;
@ -520,7 +520,7 @@ static void ov5_021D13B4(FieldSystem *fieldSystem)
v0 = sub_0203A76C(SaveData_GetFieldOverworldState(fieldSystem->saveData));
v1 = (Player_GetXPos(fieldSystem->playerAvatar) - LandDataManager_GetOffsetTileX(fieldSystem->landDataMan)) / MAP_TILES_COUNT_X;
v2 = (Player_GetZPos(fieldSystem->playerAvatar) - LandDataManager_GetOffsetTileY(fieldSystem->landDataMan)) / MAP_TILES_COUNT_Y;
v2 = (Player_GetZPos(fieldSystem->playerAvatar) - LandDataManager_GetOffsetTileZ(fieldSystem->landDataMan)) / MAP_TILES_COUNT_Z;
v3 = PlayerAvatar_GetDir(fieldSystem->playerAvatar);
sub_02055740(v0, v1, v2, v3);

162
src/overlay005/land_data.c
View File

@ -129,7 +129,7 @@ struct LandDataManager {
BOOL skipMapProps;
int offsetTileX;
int offsetAltitude;
int offsetTileY;
int offsetTileZ;
VecFx32 offset;
};
@ -180,8 +180,8 @@ static SysTask *LandDataManager_LazyLoadMapModel(NARC *landDataNARC, const int m
static NNSG3dResMdl *LandDataManager_LoadMapModel(NARC *landDataNARC, const int mapModelFileSize, NNSG3dRenderObj *mapRenderObj, NNSG3dResFileHeader **mapModelFile, NNSG3dResTex *mapTexture);
static void LandDataManager_KillLoadMapModel(SysTask *sysTask);
static void LandDataManager_InitMapLazyLoader(LandDataManager *landDataMan);
static void LandDataManager_InitAndLoad(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileY, const int offsetTileX, const int offsetTileY, const int mapMatrixWidthTiles);
static void LandDataManager_InitAndLoadWithoutAttributes(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileY, const int offsetTileX, const int offsetTileY, const int mapMatrixWidthTiles);
static void LandDataManager_InitAndLoad(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileZ, const int offsetTileX, const int offsetTileZ, const int mapMatrixWidthTiles);
static void LandDataManager_InitAndLoadWithoutAttributes(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileZ, const int offsetTileX, const int offsetTileZ, const int mapMatrixWidthTiles);
static void LandDataManager_NewLoadedMaps(LandDataManager *landDataMan);
static void LandDataManager_NewLoadedMapsWithoutAttributes(LandDataManager *landDataMan);
static void LandDataManager_KillLoadTasks(LandDataManager *landDataMan, const u8 index);
@ -206,11 +206,11 @@ static u32 LandData_CalculateNextTileIndex(const u8 trackedTargetDirection, cons
static u8 LandData_CalculateNextQuadrant(const u8 direction, const int quadrant);
static void LandData_CalculateNextOppositeQuadrant(const u8 direction, const int quadrant, u8 *oppositeQuadrant);
static void LandDataManager_QueueLazyLoadMapPair(const int firstMapMatrixIndex, const int secondMapMatrixIndex, const u8 firstQuadrantToLoad, const u8 secondQuadrantToLoad, const u8 trackedTargetDirection, LandDataManager *landDataMan);
static int LandData_CalculateTileIndex(const int tileX, const int tileY, const int offsetTileX, const int offsetTileY, const int mapMatrixWidthTiles);
static int LandData_CalculateTileIndex(const int tileX, const int tileZ, const int offsetTileX, const int offsetTileZ, const int mapMatrixWidthTiles);
static void LandDataManager_QueueLazyLoadPendingMaps(LandDataManager *landDataMan);
static void LandDataManager_UpdateTrackedTargetValues(const int trackedTargetTileX, const int trackedTargetTileY, const int offsetTileX, const int offsetTileY, LandDataManager *landDataMan);
static void LandDataManager_UpdateTrackedTargetValues(const int trackedTargetTileX, const int trackedTargetTileZ, const int offsetTileX, const int offsetTileZ, LandDataManager *landDataMan);
static void LandDataManager_CalculateRenderingPosition(const int mapMatrixIndex, const int mapMatrixWidth, const MapMatrix *mapMatrix, VecFx32 *position);
static void LandDataManager_DistortionWorldInitAndLoad(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileY, const int unused3, const int unused4, const int mapMatrixWidthTiles);
static void LandDataManager_DistortionWorldInitAndLoad(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileZ, const int unused3, const int unused4, const int mapMatrixWidthTiles);
static void LandDataManager_DistortionWorldLoad(const int mapMatrixIndex, const u8 loadedMapIndex, const AreaDataManager *areaDataMan, const MapMatrix *mapMatrix, const int mapMatrixWidth, const int mapMatrixHeight, const BOOL isOutdoorsLighting, LandDataManager *landDataMan);
static void LandDataManager_DistortionWorldRenderNextFloorMap(const u8 index, const LandDataManager *landDataMan, const ModelAttributes *modelAttrs);
@ -261,7 +261,7 @@ static void MapLazyLoader_KillTasks(MapLazyLoader *loader)
loader->mapLoadTasksState.bdhcTaskRunning = FALSE;
}
static void LandData_CalculateLoadedMapMatrixIndexes(const BOOL inDistortionWorld, const int trackedTargetTileX, const int trackedTargetTileY, const int offsetTileX, const int offsetTileY, const int mapMatrixWidth, const int mapMatrixHeight, const int mapMatrixWidthTiles, int *loadedMapMatrixIndexes)
static void LandData_CalculateLoadedMapMatrixIndexes(const BOOL inDistortionWorld, const int trackedTargetTileX, const int trackedTargetTileZ, const int offsetTileX, const int offsetTileZ, const int mapMatrixWidth, const int mapMatrixHeight, const int mapMatrixWidthTiles, int *loadedMapMatrixIndexes)
{
if (inDistortionWorld == TRUE) {
for (int i = 0; i < QUADRANT_COUNT; i++) {
@ -300,13 +300,13 @@ static void LandData_CalculateLoadedMapMatrixIndexes(const BOOL inDistortionWorl
}
GF_ASSERT(trackedTargetTileX >= offsetTileX);
GF_ASSERT(trackedTargetTileY >= offsetTileY);
GF_ASSERT(trackedTargetTileZ >= offsetTileZ);
int mapMatrixX = (trackedTargetTileX - offsetTileX) / MAP_TILES_COUNT_X;
int mapMatrixY = (trackedTargetTileY - offsetTileY) / MAP_TILES_COUNT_Y;
int trackedTargetTileIndex = LandData_CalculateTileIndex(trackedTargetTileX, trackedTargetTileY, offsetTileX, offsetTileY, mapMatrixWidthTiles);
int mapMatrixZ = (trackedTargetTileZ - offsetTileZ) / MAP_TILES_COUNT_Z;
int trackedTargetTileIndex = LandData_CalculateTileIndex(trackedTargetTileX, trackedTargetTileZ, offsetTileX, offsetTileZ, mapMatrixWidthTiles);
u8 trackedTargetMapQuadrant = LandDataManager_CalculateMapQuadrantOfTile(trackedTargetTileIndex, mapMatrixWidthTiles);
int mapMatrixIndex = (mapMatrixY * mapMatrixWidth) + mapMatrixX;
int mapMatrixIndex = (mapMatrixZ * mapMatrixWidth) + mapMatrixX;
switch (trackedTargetMapQuadrant) {
case QUADRANT_TOP_LEFT:
@ -320,7 +320,7 @@ static void LandData_CalculateLoadedMapMatrixIndexes(const BOOL inDistortionWorl
loadedMapMatrixIndexes[QUADRANT_BOTTOM_LEFT] = INVALID_MAP_MATRIX_INDEX;
}
if (mapMatrixY - 1 < 0) {
if (mapMatrixZ - 1 < 0) {
loadedMapMatrixIndexes[QUADRANT_TOP_RIGHT] = INVALID_MAP_MATRIX_INDEX;
}
@ -337,7 +337,7 @@ static void LandData_CalculateLoadedMapMatrixIndexes(const BOOL inDistortionWorl
loadedMapMatrixIndexes[QUADRANT_BOTTOM_RIGHT] = INVALID_MAP_MATRIX_INDEX;
}
if (mapMatrixY - 1 < 0) {
if (mapMatrixZ - 1 < 0) {
loadedMapMatrixIndexes[QUADRANT_TOP_LEFT] = INVALID_MAP_MATRIX_INDEX;
}
@ -354,7 +354,7 @@ static void LandData_CalculateLoadedMapMatrixIndexes(const BOOL inDistortionWorl
loadedMapMatrixIndexes[QUADRANT_BOTTOM_LEFT] = INVALID_MAP_MATRIX_INDEX;
}
if (mapMatrixY + 1 > mapMatrixHeight) {
if (mapMatrixZ + 1 > mapMatrixHeight) {
loadedMapMatrixIndexes[QUADRANT_BOTTOM_RIGHT] = INVALID_MAP_MATRIX_INDEX;
}
@ -371,7 +371,7 @@ static void LandData_CalculateLoadedMapMatrixIndexes(const BOOL inDistortionWorl
loadedMapMatrixIndexes[QUADRANT_BOTTOM_RIGHT] = INVALID_MAP_MATRIX_INDEX;
}
if (mapMatrixY + 1 > mapMatrixHeight) {
if (mapMatrixZ + 1 > mapMatrixHeight) {
loadedMapMatrixIndexes[QUADRANT_TOP_LEFT] = INVALID_MAP_MATRIX_INDEX;
}
@ -399,7 +399,7 @@ static void LandDataManager_NewLoadedMaps(LandDataManager *landDataMan)
}
landDataMan->loadedMaps[i]->mapMatrixIndex = INVALID_MAP_MATRIX_INDEX;
MI_CpuFillFast(landDataMan->loadedMaps[i]->terrainAttributes, INVALID_TERRAIN_ATTRIBUTES, sizeof(u16) * MAP_TILES_COUNT_X * MAP_TILES_COUNT_Y);
MI_CpuFillFast(landDataMan->loadedMaps[i]->terrainAttributes, INVALID_TERRAIN_ATTRIBUTES, sizeof(u16) * MAP_TILES_COUNT_X * MAP_TILES_COUNT_Z);
}
}
@ -674,10 +674,10 @@ void LandDataManager_Tick(FieldSystem *fieldSystem, LandDataManager *landDataMan
if (*trackedTarget->higherMovementCoord - *trackedTarget->lowerMovementCoord >= MAP_OBJECT_TILE_SIZE) {
// The tracked target has finished moving a tile.
int trackedTargetTileX, trackedTargetTileY;
int trackedTargetTileX, trackedTargetTileZ;
LandData_ObjectPosToTilePos(trackedTarget->position->x, trackedTarget->position->z, &trackedTargetTileX, &trackedTargetTileY);
LandDataManager_UpdateTrackedTargetValues(trackedTargetTileX, trackedTargetTileY, landDataMan->offsetTileX, landDataMan->offsetTileY, landDataMan);
LandData_ObjectPosToTilePos(trackedTarget->position->x, trackedTarget->position->z, &trackedTargetTileX, &trackedTargetTileZ);
LandDataManager_UpdateTrackedTargetValues(trackedTargetTileX, trackedTargetTileZ, landDataMan->offsetTileX, landDataMan->offsetTileZ, landDataMan);
trackedTarget->prevPosition = *trackedTarget->position;
@ -871,7 +871,7 @@ static void LandDataManager_ResetLoadedMap(const u8 index, LandDataManager *land
}
landDataMan->loadedMaps[index]->mapMatrixIndex = INVALID_MAP_MATRIX_INDEX;
MI_CpuFillFast(landDataMan->loadedMaps[index]->terrainAttributes, INVALID_TERRAIN_ATTRIBUTES, sizeof(u16) * MAP_TILES_COUNT_X * MAP_TILES_COUNT_Y);
MI_CpuFillFast(landDataMan->loadedMaps[index]->terrainAttributes, INVALID_TERRAIN_ATTRIBUTES, sizeof(u16) * MAP_TILES_COUNT_X * MAP_TILES_COUNT_Z);
landDataMan->mapQuadrantsToCancelLazyLoad[index] = TRUE;
}
@ -1226,26 +1226,26 @@ static void LandDataManager_RenderLoadedMap(const u8 index, const LandDataManage
static int LandData_CalculateMapMatrixIndex(const u32 tileIndex, const int mapMatrixWidth, const int mapMatrixWidthTiles)
{
u32 tileX = tileIndex % mapMatrixWidthTiles;
u32 tileY = tileIndex / mapMatrixWidthTiles;
u32 tileZ = tileIndex / mapMatrixWidthTiles;
u32 mapMatrixX = tileX / MAP_TILES_COUNT_X;
u32 mapMatrixY = tileY / MAP_TILES_COUNT_Y;
u32 mapMatrixZ = tileZ / MAP_TILES_COUNT_Z;
return mapMatrixX + mapMatrixY * mapMatrixWidth;
return mapMatrixX + mapMatrixZ * mapMatrixWidth;
}
static int LandData_CalculateTileIndex(const int tileX, const int tileY, const int offsetTileX, const int offsetTileY, const int mapMatrixWidthTiles)
static int LandData_CalculateTileIndex(const int tileX, const int tileZ, const int offsetTileX, const int offsetTileZ, const int mapMatrixWidthTiles)
{
return (tileX - offsetTileX) + ((tileY - offsetTileY) * mapMatrixWidthTiles);
return (tileX - offsetTileX) + ((tileZ - offsetTileZ) * mapMatrixWidthTiles);
}
static u32 LandData_CalculateMapMatrixIndexU32(const u32 tileIndex, const int mapMatrixWidth, const int mapMatrixWidthTiles)
{
u32 tileX = tileIndex % mapMatrixWidthTiles;
u32 tileY = tileIndex / mapMatrixWidthTiles;
u32 tileZ = tileIndex / mapMatrixWidthTiles;
u32 mapMatrixX = tileX / MAP_TILES_COUNT_X;
u32 mapMatrixY = tileY / MAP_TILES_COUNT_Y;
u32 mapMatrixZ = tileZ / MAP_TILES_COUNT_Z;
return mapMatrixX + mapMatrixY * mapMatrixWidth;
return mapMatrixX + mapMatrixZ * mapMatrixWidth;
}
static u8 LandData_GetOppositeQuadrant(const u8 quadrant)
@ -1284,7 +1284,7 @@ static u32 LandData_CalculateNextTileIndex(const u8 trackedTargetDirection, cons
case DIRECTION_SOUTH:
nextTileIndexCandidate = trackedTargetTileIndex + mapMatrixWidthTiles;
if (nextTileIndexCandidate >= mapMatrixHeight * MAP_TILES_COUNT_Y * mapMatrixWidthTiles) {
if (nextTileIndexCandidate >= mapMatrixHeight * MAP_TILES_COUNT_Z * mapMatrixWidthTiles) {
return trackedTargetTileIndex;
}
@ -1486,12 +1486,12 @@ static void LandDataManager_CancelMapQuadrantsToLazyLoad(const u8 trackedTargetD
}
}
static void LandDataManager_InitAndLoad(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileY, const int offsetTileX, const int offsetTileY, const int mapMatrixWidthTiles)
static void LandDataManager_InitAndLoad(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileZ, const int offsetTileX, const int offsetTileZ, const int mapMatrixWidthTiles)
{
int loadedMapMatrixIndexes[QUADRANT_COUNT];
LandDataManager_NewLoadedMaps(landDataMan);
LandData_CalculateLoadedMapMatrixIndexes(landDataMan->inDistortionWorld, trackedTargetTileX, trackedTargetTileY, offsetTileX, offsetTileY, landDataMan->mapMatrixWidth, landDataMan->mapMatrixHeight, mapMatrixWidthTiles, loadedMapMatrixIndexes);
LandData_CalculateLoadedMapMatrixIndexes(landDataMan->inDistortionWorld, trackedTargetTileX, trackedTargetTileZ, offsetTileX, offsetTileZ, landDataMan->mapMatrixWidth, landDataMan->mapMatrixHeight, mapMatrixWidthTiles, loadedMapMatrixIndexes);
for (u8 i = 0; i < QUADRANT_COUNT; i++) {
landDataMan->loadedMaps[i]->bdhc = BDHC_New();
@ -1501,12 +1501,12 @@ static void LandDataManager_InitAndLoad(LandDataManager *landDataMan, const int
}
}
static void LandDataManager_InitAndLoadWithoutAttributes(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileY, const int offsetTileX, const int offsetTileY, const int mapMatrixWidthTiles)
static void LandDataManager_InitAndLoadWithoutAttributes(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileZ, const int offsetTileX, const int offsetTileZ, const int mapMatrixWidthTiles)
{
int loadedMapMatrixIndexes[QUADRANT_COUNT];
LandDataManager_NewLoadedMapsWithoutAttributes(landDataMan);
LandData_CalculateLoadedMapMatrixIndexes(landDataMan->inDistortionWorld, trackedTargetTileX, trackedTargetTileY, offsetTileX, offsetTileY, landDataMan->mapMatrixWidth, landDataMan->mapMatrixHeight, mapMatrixWidthTiles, loadedMapMatrixIndexes);
LandData_CalculateLoadedMapMatrixIndexes(landDataMan->inDistortionWorld, trackedTargetTileX, trackedTargetTileZ, offsetTileX, offsetTileZ, landDataMan->mapMatrixWidth, landDataMan->mapMatrixHeight, mapMatrixWidthTiles, loadedMapMatrixIndexes);
for (u8 i = 0; i < QUADRANT_COUNT; i++) {
landDataMan->loadedMaps[i]->bdhc = NULL;
@ -1528,9 +1528,9 @@ static void LandDataManager_InitMapLazyLoader(LandDataManager *landDataMan)
LandDataManager_ResetMapQuadrantsToCancelLazyLoad(landDataMan);
}
static void LandDataManager_UpdateTrackedTargetValues(const int trackedTargetTileX, const int trackedTargetTileY, const int offsetTileX, const int offsetTileY, LandDataManager *landDataMan)
static void LandDataManager_UpdateTrackedTargetValues(const int trackedTargetTileX, const int trackedTargetTileZ, const int offsetTileX, const int offsetTileZ, LandDataManager *landDataMan)
{
int fixedTrackedTargetTileX = trackedTargetTileX, fixedTrackedTargetTileY = trackedTargetTileY;
int fixedTrackedTargetTileX = trackedTargetTileX, fixedTrackedTargetTileZ = trackedTargetTileZ;
if (landDataMan->inDistortionWorld == TRUE) {
if (landDataMan->mapMatrixWidth > 1) {
@ -1540,13 +1540,13 @@ static void LandDataManager_UpdateTrackedTargetValues(const int trackedTargetTil
}
if (landDataMan->mapMatrixHeight > 1) {
fixedTrackedTargetTileY = offsetTileY + 31;
fixedTrackedTargetTileZ = offsetTileZ + 31;
} else {
fixedTrackedTargetTileY = offsetTileY + 16;
fixedTrackedTargetTileZ = offsetTileZ + 16;
}
}
landDataMan->trackedTargetTileIndex = LandData_CalculateTileIndex(fixedTrackedTargetTileX, fixedTrackedTargetTileY, offsetTileX, offsetTileY, landDataMan->mapMatrixWidthTiles);
landDataMan->trackedTargetTileIndex = LandData_CalculateTileIndex(fixedTrackedTargetTileX, fixedTrackedTargetTileZ, offsetTileX, offsetTileZ, landDataMan->mapMatrixWidthTiles);
landDataMan->trackedTargetMapQuadrant = LandDataManager_CalculateMapQuadrantOfTile(landDataMan->trackedTargetTileIndex, landDataMan->mapMatrixWidthTiles);
landDataMan->trackedTargetLoadedMapsQuadrant = LandData_GetOppositeQuadrant(landDataMan->trackedTargetMapQuadrant);
landDataMan->trackedTargetMapMatrixIndex = LandData_CalculateMapMatrixIndexU32(landDataMan->trackedTargetTileIndex, landDataMan->mapMatrixWidth, landDataMan->mapMatrixWidthTiles);
@ -1555,22 +1555,22 @@ static void LandDataManager_UpdateTrackedTargetValues(const int trackedTargetTil
static void LandDataManager_CalculateRenderingPosition(const int mapMatrixIndex, const int mapMatrixWidth, const MapMatrix *mapMatrix, VecFx32 *position)
{
position->x = (MAP_TILES_COUNT_X / 2) * MAP_OBJECT_TILE_SIZE;
position->z = (MAP_TILES_COUNT_Y / 2) * MAP_OBJECT_TILE_SIZE;
position->z = (MAP_TILES_COUNT_Z / 2) * MAP_OBJECT_TILE_SIZE;
if (mapMatrixIndex == INVALID_MAP_MATRIX_INDEX) {
return;
}
u16 mapMatrixX = mapMatrixIndex % mapMatrixWidth;
u16 mapMatrixY = mapMatrixIndex / mapMatrixWidth;
u16 mapMatrixZ = mapMatrixIndex / mapMatrixWidth;
int mapMatrixWidth2 = MapMatrix_GetWidth(mapMatrix);
u16 mapMatrixID = MapMatrix_GetMatrixID(mapMatrix);
int altitude = MapMatrix_GetAltitudeAtCoords(mapMatrix, mapMatrixID, mapMatrixX, mapMatrixY, mapMatrixWidth2);
int altitude = MapMatrix_GetAltitudeAtCoords(mapMatrix, mapMatrixID, mapMatrixX, mapMatrixZ, mapMatrixWidth2);
position->y = altitude * (MAP_OBJECT_TILE_SIZE / 2);
position->x += mapMatrixX * MAP_TILES_COUNT_X * MAP_OBJECT_TILE_SIZE;
position->z += mapMatrixY * MAP_TILES_COUNT_Y * MAP_OBJECT_TILE_SIZE;
position->z += mapMatrixZ * MAP_TILES_COUNT_Z * MAP_OBJECT_TILE_SIZE;
}
LandDataManager *LandDataManager_New(MapMatrix *mapMatrix, AreaDataManager *areaDataMan, MapPropAnimationManager *mapPropAnimMan, const BOOL skipAttributes)
@ -1609,10 +1609,10 @@ LandDataManager *LandDataManager_New(MapMatrix *mapMatrix, AreaDataManager *area
return landDataMan;
}
void LandDataManager_InitialLoad(LandDataManager *landDataMan, const int playerTileX, const int playerTileY)
void LandDataManager_InitialLoad(LandDataManager *landDataMan, const int playerTileX, const int playerTileZ)
{
landDataMan->mapLoadFns->initialLoad(landDataMan, playerTileX, playerTileY, landDataMan->offsetTileX, landDataMan->offsetTileY, landDataMan->mapMatrixWidthTiles);
LandDataManager_UpdateTrackedTargetValues(playerTileX, playerTileY, landDataMan->offsetTileX, landDataMan->offsetTileY, landDataMan);
landDataMan->mapLoadFns->initialLoad(landDataMan, playerTileX, playerTileZ, landDataMan->offsetTileX, landDataMan->offsetTileZ, landDataMan->mapMatrixWidthTiles);
LandDataManager_UpdateTrackedTargetValues(playerTileX, playerTileZ, landDataMan->offsetTileX, landDataMan->offsetTileZ, landDataMan);
}
void LandDataManager_CheckLazyLoadNextMapPair(const u8 trackedTargetDirection, LandDataManager *landDataMan)
@ -1642,10 +1642,10 @@ void LandDataManager_RenderLoadedMaps(const LandDataManager *landDataMan, ModelA
}
}
void LandData_ObjectPosToTilePos(fx32 objectPositionX, fx32 objectPositionZ, int *tileX, int *tileY)
void LandData_ObjectPosToTilePos(fx32 objectPositionX, fx32 objectPositionZ, int *tileX, int *tileZ)
{
*tileX = objectPositionX / MAP_OBJECT_TILE_SIZE;
*tileY = objectPositionZ / MAP_OBJECT_TILE_SIZE;
*tileZ = objectPositionZ / MAP_OBJECT_TILE_SIZE;
}
void LandDataManager_End(LandDataManager *landDataMan)
@ -1715,17 +1715,17 @@ u8 LandDataManager_CalculateMapQuadrantOfTile(const u32 tileIndex, const int map
u8 mapQuadrant;
int tileX = tileIndex % MAP_TILES_COUNT_X;
int tileY = tileIndex / mapMatrixWidthTiles;
int tileYMod = tileY % MAP_TILES_COUNT_Y;
int tileZ = tileIndex / mapMatrixWidthTiles;
int tileZMod = tileZ % MAP_TILES_COUNT_Z;
if (tileX < MAP_TILES_COUNT_X / 2) {
if (tileYMod < MAP_TILES_COUNT_Y / 2) {
if (tileZMod < MAP_TILES_COUNT_Z / 2) {
mapQuadrant = QUADRANT_TOP_LEFT;
} else {
mapQuadrant = QUADRANT_BOTTOM_LEFT;
}
} else {
if (tileYMod < MAP_TILES_COUNT_Y / 2) {
if (tileZMod < MAP_TILES_COUNT_Z / 2) {
mapQuadrant = QUADRANT_TOP_RIGHT;
} else {
mapQuadrant = QUADRANT_BOTTOM_RIGHT;
@ -1811,13 +1811,13 @@ int LandDataManager_GetLoadedMapMatrixIndex(const LandDataManager *landDataMan,
return landDataMan->loadedMaps[loadedMapIndex]->mapMatrixIndex;
}
BOOL LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(const LandDataManager *landDataMan, const int tileX, const int tileY, u8 *result)
BOOL LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(const LandDataManager *landDataMan, const int tileX, const int tileZ, u8 *result)
{
int fixedTileX = tileX - landDataMan->offsetTileX;
int fixedTileY = tileY - landDataMan->offsetTileY;
int fixedTileZ = tileZ - landDataMan->offsetTileZ;
u32 mapMatrixX = fixedTileX / MAP_TILES_COUNT_X;
u32 mapMatrixY = fixedTileY / MAP_TILES_COUNT_Y;
u32 mapMatrixIndex = mapMatrixX + (mapMatrixY * landDataMan->mapMatrixWidth);
u32 mapMatrixZ = fixedTileZ / MAP_TILES_COUNT_Z;
u32 mapMatrixIndex = mapMatrixX + (mapMatrixZ * landDataMan->mapMatrixWidth);
if (mapMatrixIndex >= landDataMan->mapMatrixWidth * landDataMan->mapMatrixHeight) {
if (Link_SetErrorState(LINK_BATTLE_RESET_SAVEPOINT)) {
@ -1827,7 +1827,7 @@ BOOL LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(const LandDataManager *
GF_ASSERT(mapMatrixIndex < landDataMan->mapMatrixWidth * landDataMan->mapMatrixHeight);
u32 tileIndex = fixedTileX + (fixedTileY * landDataMan->mapMatrixWidthTiles);
u32 tileIndex = fixedTileX + (fixedTileZ * landDataMan->mapMatrixWidthTiles);
u8 tileMapQuadrant = LandDataManager_CalculateMapQuadrantOfTile(tileIndex, landDataMan->mapMatrixWidthTiles);
u32 loadedMapsQuadrant = LandDataManager_GetRelativeLoadedMapsQuadrant(mapMatrixIndex, tileMapQuadrant, landDataMan);
@ -2080,18 +2080,18 @@ void LandDataManager_DistortionWorldFreeLoadedMapBuffers(LandDataManager *landDa
Heap_FreeToHeap(&landDataMan->loadedMapBufs);
}
void LandDataManager_DistortionWorldInitialLoad(LandDataManager *landDataMan, const int playerTileX, const int playerTileY)
void LandDataManager_DistortionWorldInitialLoad(LandDataManager *landDataMan, const int playerTileX, const int playerTileZ)
{
LandDataManager_DistortionWorldInitAndLoad(landDataMan, playerTileX, playerTileY, landDataMan->offsetTileX, landDataMan->offsetTileY, landDataMan->mapMatrixWidthTiles);
LandDataManager_UpdateTrackedTargetValues(playerTileX, playerTileY, landDataMan->offsetTileX, landDataMan->offsetTileY, landDataMan);
LandDataManager_DistortionWorldInitAndLoad(landDataMan, playerTileX, playerTileZ, landDataMan->offsetTileX, landDataMan->offsetTileZ, landDataMan->mapMatrixWidthTiles);
LandDataManager_UpdateTrackedTargetValues(playerTileX, playerTileZ, landDataMan->offsetTileX, landDataMan->offsetTileZ, landDataMan);
}
static void LandDataManager_DistortionWorldInitAndLoad(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileY, const int unused3, const int unused4, const int mapMatrixWidthTiles)
static void LandDataManager_DistortionWorldInitAndLoad(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileZ, const int unused3, const int unused4, const int mapMatrixWidthTiles)
{
int loadedMapMatrixIndexes[QUADRANT_COUNT];
LandDataManager_NewLoadedMapsWithoutAttributes(landDataMan);
LandData_CalculateLoadedMapMatrixIndexes(landDataMan->inDistortionWorld, trackedTargetTileX, trackedTargetTileY, landDataMan->offsetTileX, landDataMan->offsetTileY, landDataMan->mapMatrixWidth, landDataMan->mapMatrixHeight, mapMatrixWidthTiles, loadedMapMatrixIndexes);
LandData_CalculateLoadedMapMatrixIndexes(landDataMan->inDistortionWorld, trackedTargetTileX, trackedTargetTileZ, landDataMan->offsetTileX, landDataMan->offsetTileZ, landDataMan->mapMatrixWidth, landDataMan->mapMatrixHeight, mapMatrixWidthTiles, loadedMapMatrixIndexes);
for (u8 i = 0; i < QUADRANT_COUNT; i++) {
landDataMan->loadedMaps[i]->bdhc = NULL;
@ -2099,10 +2099,10 @@ static void LandDataManager_DistortionWorldInitAndLoad(LandDataManager *landData
}
}
void LandDataManager_DistortionWorldInitLoadedMaps(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileY, int *loadedMapMatrixIndexes)
void LandDataManager_DistortionWorldInitLoadedMaps(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileZ, int *loadedMapMatrixIndexes)
{
LandDataManager_InitLoadedMapsWithoutAttributes(landDataMan);
LandData_CalculateLoadedMapMatrixIndexes(landDataMan->inDistortionWorld, trackedTargetTileX, trackedTargetTileY, landDataMan->offsetTileX, landDataMan->offsetTileY, landDataMan->mapMatrixWidth, landDataMan->mapMatrixHeight, landDataMan->mapMatrixWidthTiles, loadedMapMatrixIndexes);
LandData_CalculateLoadedMapMatrixIndexes(landDataMan->inDistortionWorld, trackedTargetTileX, trackedTargetTileZ, landDataMan->offsetTileX, landDataMan->offsetTileZ, landDataMan->mapMatrixWidth, landDataMan->mapMatrixHeight, landDataMan->mapMatrixWidthTiles, loadedMapMatrixIndexes);
for (int i = 0; i < QUADRANT_COUNT; i++) {
landDataMan->loadedMaps[i]->valid = FALSE;
@ -2182,11 +2182,11 @@ void LandDataManager_DistortionWorldEndWithoutFreeing(LandDataManager *landDataM
landDataMan->lazyLoaderTrackedTarget.tracking = FALSE;
for (i = 0; i < QUADRANT_COUNT; i++) {
MI_CpuFillFast(landDataMan->loadedMaps[i]->terrainAttributes, INVALID_TERRAIN_ATTRIBUTES, sizeof(u16) * MAP_TILES_COUNT_X * MAP_TILES_COUNT_Y);
MI_CpuFillFast(landDataMan->loadedMaps[i]->terrainAttributes, INVALID_TERRAIN_ATTRIBUTES, sizeof(u16) * MAP_TILES_COUNT_X * MAP_TILES_COUNT_Z);
}
}
void LandDataManager_DistortionWorldPrepareNextFloor(MapMatrix *mapMatrix, AreaDataManager *areaDataMan, LandDataManager *src, LandDataManager *dest, const int trackedTargetTileX, const int trackedTargetTileY)
void LandDataManager_DistortionWorldPrepareNextFloor(MapMatrix *mapMatrix, AreaDataManager *areaDataMan, LandDataManager *src, LandDataManager *dest, const int trackedTargetTileX, const int trackedTargetTileZ)
{
int i;
int mapMatrixIndexes[QUADRANT_COUNT];
@ -2225,10 +2225,10 @@ void LandDataManager_DistortionWorldPrepareNextFloor(MapMatrix *mapMatrix, AreaD
dest->inDistortionWorld = src->inDistortionWorld;
dest->offsetTileX = src->offsetTileX;
dest->offsetAltitude = src->offsetAltitude;
dest->offsetTileY = src->offsetTileY;
dest->offsetTileZ = src->offsetTileZ;
dest->offset = src->offset;
LandDataManager_UpdateTrackedTargetValues(trackedTargetTileX, trackedTargetTileY, dest->offsetTileX, dest->offsetTileY, dest);
LandDataManager_UpdateTrackedTargetValues(trackedTargetTileX, trackedTargetTileZ, dest->offsetTileX, dest->offsetTileZ, dest);
dest->ending = FALSE;
dest->lazyLoaderSubTask = src->lazyLoaderSubTask;
@ -2281,7 +2281,7 @@ void LandDataManager_DistortionWorldPreparePreviousFloor(LandDataManager *dest,
dest->inDistortionWorld = src->inDistortionWorld;
dest->offsetTileX = src->offsetTileX;
dest->offsetAltitude = src->offsetAltitude;
dest->offsetTileY = src->offsetTileY;
dest->offsetTileZ = src->offsetTileZ;
dest->offset = src->offset;
dest->ending = FALSE;
dest->lazyLoaderSubTask = src->lazyLoaderSubTask;
@ -2297,10 +2297,10 @@ void LandDataManager_DistortionWorldTick(FieldSystem *fieldSystem, LandDataManag
GF_ASSERT(*trackedTarget->lowerMovementCoord <= *trackedTarget->higherMovementCoord);
if (*trackedTarget->higherMovementCoord - *trackedTarget->lowerMovementCoord >= MAP_OBJECT_TILE_SIZE) {
int trackedTargetTileX, trackedTargetTileY;
int trackedTargetTileX, trackedTargetTileZ;
LandData_ObjectPosToTilePos(trackedTarget->position->x, trackedTarget->position->z, &trackedTargetTileX, &trackedTargetTileY);
LandDataManager_UpdateTrackedTargetValues(trackedTargetTileX, trackedTargetTileY, landDataMan->offsetTileX, landDataMan->offsetTileY, landDataMan);
LandData_ObjectPosToTilePos(trackedTarget->position->x, trackedTarget->position->z, &trackedTargetTileX, &trackedTargetTileZ);
LandDataManager_UpdateTrackedTargetValues(trackedTargetTileX, trackedTargetTileZ, landDataMan->offsetTileX, landDataMan->offsetTileZ, landDataMan);
trackedTarget->prevPosition = *trackedTarget->position;
@ -2466,9 +2466,9 @@ void LandDataManager_DistortionWorldInitWithoutNARC(LandDataManager *landDataMan
landDataMan->lazyLoaderSubTask = LAZY_LOADER_SUBTASK_IDLE;
}
void LandDataManager_DistortionWorldInvalidateLoadedMaps(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileY, int *loadedMapMatrixIndexes)
void LandDataManager_DistortionWorldInvalidateLoadedMaps(LandDataManager *landDataMan, const int trackedTargetTileX, const int trackedTargetTileZ, int *loadedMapMatrixIndexes)
{
LandData_CalculateLoadedMapMatrixIndexes(landDataMan->inDistortionWorld, trackedTargetTileX, trackedTargetTileY, landDataMan->offsetTileX, landDataMan->offsetTileY, landDataMan->mapMatrixWidth, landDataMan->mapMatrixHeight, landDataMan->mapMatrixWidthTiles, loadedMapMatrixIndexes);
LandData_CalculateLoadedMapMatrixIndexes(landDataMan->inDistortionWorld, trackedTargetTileX, trackedTargetTileZ, landDataMan->offsetTileX, landDataMan->offsetTileZ, landDataMan->mapMatrixWidth, landDataMan->mapMatrixHeight, landDataMan->mapMatrixWidthTiles, loadedMapMatrixIndexes);
for (int i = 0; i < QUADRANT_COUNT; i++) {
landDataMan->loadedMaps[i]->valid = FALSE;
@ -2482,20 +2482,20 @@ void LandDataManager_DistortionWorldLoadEntire(LandDataManager *landDataMan, int
LoadedMapBuffers_GetBDHCFileBufPtr(loadedMapIndex, landDataMan->loadedMapBufs, (void **)&landDataMan->loadedMaps[loadedMapIndex]->bdhcFile);
landDataMan->loadedMaps[loadedMapIndex]->mapMatrixIndex = INVALID_MAP_MATRIX_INDEX;
MI_CpuFillFast(landDataMan->loadedMaps[loadedMapIndex]->terrainAttributes, INVALID_TERRAIN_ATTRIBUTES, sizeof(u16) * MAP_TILES_COUNT_X * MAP_TILES_COUNT_Y);
MI_CpuFillFast(landDataMan->loadedMaps[loadedMapIndex]->terrainAttributes, INVALID_TERRAIN_ATTRIBUTES, sizeof(u16) * MAP_TILES_COUNT_X * MAP_TILES_COUNT_Z);
BDHC_MarkNotLoaded(landDataMan->loadedMaps[loadedMapIndex]->bdhc);
LandDataManager_Load(mapMatrixIndex, loadedMapIndex, landDataMan->areaDataMan, landDataMan->mapMatrix, landDataMan->mapMatrixWidth, landDataMan->mapMatrixHeight, AreaDataManager_IsOutdoorsLighting(landDataMan->areaDataMan), landDataMan);
}
void LandDataManager_DistortionWorldSetOffsets(LandDataManager *landDataMan, int offsetTileX, int offsetAltitude, int offsetTileY)
void LandDataManager_DistortionWorldSetOffsets(LandDataManager *landDataMan, int offsetTileX, int offsetAltitude, int offsetTileZ)
{
landDataMan->offsetTileX = offsetTileX;
landDataMan->offsetAltitude = offsetAltitude;
landDataMan->offsetTileY = offsetTileY;
landDataMan->offsetTileZ = offsetTileZ;
landDataMan->offset.x = offsetTileX * MAP_OBJECT_TILE_SIZE;
landDataMan->offset.y = offsetAltitude * MAP_OBJECT_TILE_SIZE;
landDataMan->offset.z = offsetTileY * MAP_OBJECT_TILE_SIZE;
landDataMan->offset.z = offsetTileZ * MAP_OBJECT_TILE_SIZE;
}
void LandDataManager_SetInDistortionWorld(LandDataManager *landDataMan, BOOL inDistortionWorld)
@ -2508,9 +2508,9 @@ int LandDataManager_GetOffsetTileX(const LandDataManager *landDataMan)
return landDataMan->offsetTileX;
}
int LandDataManager_GetOffsetTileY(const LandDataManager *landDataMan)
int LandDataManager_GetOffsetTileZ(const LandDataManager *landDataMan)
{
return landDataMan->offsetTileY;
return landDataMan->offsetTileZ;
}
void LandDataManager_GetOffset(const LandDataManager *landDataMan, VecFx32 *offset)
@ -2533,7 +2533,7 @@ void LandDataManager_SetLoadedMapValid(LandDataManager *landDataMan, int index,
landDataMan->loadedMaps[index]->valid = valid;
}
void LandDataManager_DistortionWorldUpdateTrackedTargetValues(LandDataManager *landDataMan, int trackedTargetTileX, int trackedTargetTileY)
void LandDataManager_DistortionWorldUpdateTrackedTargetValues(LandDataManager *landDataMan, int trackedTargetTileX, int trackedTargetTileZ)
{
LandDataManager_UpdateTrackedTargetValues(trackedTargetTileX, trackedTargetTileY, landDataMan->offsetTileX, landDataMan->offsetTileY, landDataMan);
LandDataManager_UpdateTrackedTargetValues(trackedTargetTileX, trackedTargetTileZ, landDataMan->offsetTileX, landDataMan->offsetTileZ, landDataMan);
}

4
src/overlay005/ov5_021F8370.c
View File

@ -97,14 +97,14 @@ void Villa_DynamicMapFeaturesFree(FieldSystem *fieldSystem)
fieldSystem->unk_04->dynamicMapFeaturesData = NULL;
}
BOOL Villa_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding)
BOOL Villa_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding)
{
int v0;
const UnkStruct_ov5_021F83D4 *v1;
const UnkStruct_ov5_0220192C *v2 = Unk_ov5_0220192C;
for (v0 = 0; v0 < 23; v0++, v2++) {
if (ov5_021F851C(tileX, tileY, v2, fieldSystem) == 1) {
if (ov5_021F851C(tileX, tileZ, v2, fieldSystem) == 1) {
*isColliding = 1;
return 1;
}

28
src/overlay008/ov8_02249960.c
View File

@ -381,9 +381,9 @@ void ov8_0224997C(FieldSystem *fieldSystem)
}
}
BOOL PastoriaGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding)
BOOL PastoriaGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding)
{
u8 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, tileX, tileY);
u8 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, tileX, tileZ);
if (TileBehavior_IsPastoriaGymHighGround(tileBehavior)) {
if (height != MAP_OBJECT_TILE_SIZE * 0) {
@ -1676,7 +1676,7 @@ void CanalaveGym_DynamicMapFeaturesFree(FieldSystem *fieldSystem)
fieldSystem->unk_04->dynamicMapFeaturesData = NULL;
}
BOOL CanalaveGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding)
BOOL CanalaveGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding)
{
u8 v0;
const u8 *v1;
@ -1686,7 +1686,7 @@ BOOL CanalaveGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, cons
GF_ASSERT(v0 <= 3);
v1 = Unk_ov8_0224D035[v0];
v2 = tileX + tileY * 32;
v2 = tileX + tileZ * 32;
GF_ASSERT(v2 < 1024);
(*isColliding) = v1[v2];
@ -2123,7 +2123,7 @@ void SunyshoreGym_DynamicMapFeaturesFree(FieldSystem *fieldSystem)
fieldSystem->unk_04->dynamicMapFeaturesData = NULL;
}
BOOL SunyshoreGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding)
BOOL SunyshoreGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding)
{
int v0, v1, v2;
u8 const *v3;
@ -2138,7 +2138,7 @@ BOOL SunyshoreGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, con
for (v0 = 0; v0 < v1; v0++) {
v4 = v3[v0];
if ((v5[v4].unk_00 <= tileX) && (tileX < v5[v4].unk_00 + v5[v4].unk_02) && (v5[v4].unk_01 <= tileY) && (tileY < v5[v4].unk_01 + v5[v4].unk_03)) {
if ((v5[v4].unk_00 <= tileX) && (tileX < v5[v4].unk_00 + v5[v4].unk_02) && (v5[v4].unk_01 <= tileZ) && (tileZ < v5[v4].unk_01 + v5[v4].unk_03)) {
(*isColliding) = 1;
return 1;
}
@ -2466,7 +2466,7 @@ void EternaGym_DynamicMapFeaturesFree(FieldSystem *fieldSystem)
fieldSystem->unk_04->dynamicMapFeaturesData = NULL;
}
BOOL EternaGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding)
BOOL EternaGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding)
{
BOOL v0;
int v1, v2, v3;
@ -2480,16 +2480,16 @@ BOOL EternaGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const
*isColliding = 0;
if (((tileY >= 7) && (tileY <= (7 + 13 - 1))) && ((tileX >= 5) && (tileX <= (5 + 13 - 1)))) {
if (((tileZ >= 7) && (tileZ <= (7 + 13 - 1))) && ((tileX >= 5) && (tileX <= (5 + 13 - 1)))) {
v2 = tileX - 5;
v3 = (tileY - 7) * 13;
v3 = (tileZ - 7) * 13;
v0 = Unk_ov8_0224CCE8[v1][v3 + v2];
*isColliding = v0;
}
if ((v0 == 0) && ((tileY >= 19) && (tileY <= (19 + 1 - 1))) && ((tileX >= 1) && (tileX <= (1 + 21 - 1)))) {
if ((v0 == 0) && ((tileZ >= 19) && (tileZ <= (19 + 1 - 1))) && ((tileX >= 1) && (tileX <= (1 + 21 - 1)))) {
v2 = tileX - 1;
v3 = (tileY - 19) * 21;
v3 = (tileZ - 19) * 21;
v0 = Unk_ov8_0224CA5C[v1][v3 + v2];
*isColliding = v0;
}
@ -2890,7 +2890,7 @@ BOOL ov8_0224B67C(FieldSystem *fieldSystem, Window *param1, MessageLoader *param
return 1;
}
BOOL EternaGym_IsHourHandJumpTile(FieldSystem *fieldSystem, int tileX, int tileY, int direction)
BOOL EternaGym_IsHourHandJumpTile(FieldSystem *fieldSystem, int tileX, int tileZ, int direction)
{
PersistedMapFeatures *v0;
UnkStruct_02071BD0 *v1;
@ -2900,7 +2900,7 @@ BOOL EternaGym_IsHourHandJumpTile(FieldSystem *fieldSystem, int tileX, int tileY
v1 = PersistedMapFeatures_GetBuffer(v0, DYNAMIC_MAP_FEATURES_ETERNA_GYM);
v2 = &Unk_ov8_0224C7F0[v1->unk_00];
if ((v2->unk_00 == tileX) && (v2->unk_02 == tileY)) {
if ((v2->unk_00 == tileX) && (v2->unk_02 == tileZ)) {
if (((v2->unk_04 == 0) && ((direction == 2) || (direction == 3))) || ((v2->unk_04 == 1) && ((direction == 0) || (direction == 1)))) {
return 1;
}
@ -2983,7 +2983,7 @@ void VeilstoneGym_DynamicMapFeaturesFree(FieldSystem *fieldSystem)
fieldSystem->unk_04->dynamicMapFeaturesData = NULL;
}
BOOL VeilstoneGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding)
BOOL VeilstoneGym_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding)
{
return FALSE;
}

6
src/overlay009/ov9_02249960.c
View File

@ -1476,18 +1476,18 @@ static u32 ov9_02249E44(UnkStruct_ov9_02249B04 *param0)
return v0->unk_00_25;
}
BOOL DistortionWorld_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileY, const fx32 height, BOOL *isColliding)
BOOL DistortionWorld_DynamicMapFeaturesCheckCollision(FieldSystem *fieldSystem, const int tileX, const int tileZ, const fx32 height, BOOL *isColliding)
{
UnkStruct_ov9_02249B04 *v0 = fieldSystem->unk_04->dynamicMapFeaturesData;
u32 v1 = ov9_022510D0(v0);
if (v1 == 582) {
if ((tileX == 15) && (tileY == 26)) {
if ((tileX == 15) && (tileZ == 26)) {
*isColliding = 1;
return 1;
}
} else if (v1 == 581) {
if ((tileX == 89) && (tileY == 56)) {
if ((tileX == 89) && (tileZ == 56)) {
*isColliding = 1;
return 1;
}

4
src/platform_lift.c
View File

@ -29,10 +29,10 @@
#define PLATFORM_LIFT_DYNAMIC_HEIGHT_PLATE_ID 0
#define PLATFORM_LIFT_IRON_ISLAND_B2F_LEFT_ROOM_POS_X (FX32_ONE * (16 * 19 + 8))
#define PLATFORM_LIFT_IRON_ISLAND_B2F_LEFT_ROOM_POS_Z (FX32_ONE * (16 * (MAP_TILES_COUNT_Y + 12) + 8))
#define PLATFORM_LIFT_IRON_ISLAND_B2F_LEFT_ROOM_POS_Z (FX32_ONE * (16 * (MAP_TILES_COUNT_Z + 12) + 8))
#define IRON_ISLAND_B1F_RIGHT_ROOM_BOTTOM_FLOOR_WARP_Z 26
#define IRON_ISLAND_B2F_LEFT_ROOM_BOTTOM_FLOOR_WARP_Z (MAP_TILES_COUNT_Y * 1 + 16)
#define IRON_ISLAND_B2F_LEFT_ROOM_BOTTOM_FLOOR_WARP_Z (MAP_TILES_COUNT_Z * 1 + 16)
#define IRON_ISLAND_B3F_BOTTOM_FLOOR_WARP_Z 15
#define POKEMON_LEAGUE_ELEVATOR_TO_ELITE_FOUR_ROOM_BOTTOM_FLOOR_WARP_Z 15
#define POKEMON_LEAGUE_ELEVATOR_TO_CHAMPION_ROOM_BOTTOM_FLOOR_WARP_Z 23

4
src/terrain_attributes.c
View File

@ -34,7 +34,7 @@ void TerrainAttributes_Free(FieldSystem *fieldSystem)
const u16 *TerrainAttributes_Get(const u32 mapMatrixIndex, const TerrainAttributes *terrainAttributes)
{
u8 blockIndex = terrainAttributes->mapMatrixIndexToBlockIndex[mapMatrixIndex];
return &terrainAttributes->terrainAttributes[MAP_TILES_COUNT_X * MAP_TILES_COUNT_Y * blockIndex];
return &terrainAttributes->terrainAttributes[MAP_TILES_COUNT_X * MAP_TILES_COUNT_Z * blockIndex];
}
static void TerrainAttributes_Load(MapMatrix *mapMatrix, TerrainAttributes *terrainAttributes, const u8 blockCount)
@ -62,7 +62,7 @@ static void TerrainAttributes_Load(MapMatrix *mapMatrix, TerrainAttributes *terr
for (i = 0; i < blockCount; i++) {
landDataID = blockIndexToLandDataID[i];
void *terrainAttributesBlock = &terrainAttributes->terrainAttributes[MAP_TILES_COUNT_X * MAP_TILES_COUNT_Y * i];
void *terrainAttributesBlock = &terrainAttributes->terrainAttributes[MAP_TILES_COUNT_X * MAP_TILES_COUNT_Z * i];
NARC_ReadFromMember(landDataNARC, landDataID, TERRAIN_ATTRIBUTES_OFFSET, TERRAIN_ATTRIBUTES_SIZE, terrainAttributesBlock);
}

90
src/terrain_collision_manager.c
View File

@ -34,8 +34,8 @@ enum VerticalDirection {
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 BOOL GetTileAttributes(const FieldSystem *fieldSystem, const int tileX, const int tileZ, u16 *attributes);
static BOOL GetSimpleTileAttributes(const FieldSystem *fieldSystem, const int tileX, const int tileZ, u16 *attributes);
static int GetVerticalDirection(const FieldSystem *fieldSystem, const VecFx32 *param1, const int param2, const int param3, u8 *param4);
static const TerrainCollisionManager sTerrainCollisionManagerFuncs = {
@ -58,8 +58,8 @@ static fx32 CalculateDistance(const fx32 lhs, const fx32 rhs)
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;
u32 tileX, tileZ;
u32 mapMatrixX, mapMatrixZ;
VecFx32 objectPosition;
fx32 fixedObjectHeight;
@ -79,22 +79,22 @@ static const fx32 GetHeight(const FieldSystem *fieldSystem, const fx32 objectHei
int mapMatrixWidthTiles = mapMatrixWidth * MAP_TILES_COUNT_X;
tileX = (objectX - offset.x) / MAP_OBJECT_TILE_SIZE;
tileY = (objectZ - offset.z) / MAP_OBJECT_TILE_SIZE;
tileZ = (objectZ - offset.z) / MAP_OBJECT_TILE_SIZE;
u8 dynHeightPlateIndex;
dynHeightPlateFound = DynamicTerrainHeightManager_GetPlateIndexOfTile(tileX, tileY, fieldSystem->dynamicTerrainHeightMan, &dynHeightPlateIndex);
dynHeightPlateFound = DynamicTerrainHeightManager_GetPlateIndexOfTile(tileX, tileZ, fieldSystem->dynamicTerrainHeightMan, &dynHeightPlateIndex);
mapMatrixX = tileX / MAP_TILES_COUNT_X;
mapMatrixY = tileY / MAP_TILES_COUNT_Y;
u32 mapMatrixIndex = mapMatrixX + mapMatrixY * mapMatrixWidth;
mapMatrixZ = tileZ / MAP_TILES_COUNT_Z;
u32 mapMatrixIndex = mapMatrixX + mapMatrixZ * 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;
fx32 currentMapOriginZ = (mapMatrixZ * MAP_TILES_COUNT_Z + MAP_TILES_COUNT_Z / 2) * MAP_OBJECT_TILE_SIZE;
objectPosition.x = objectX - currentMapOriginX - offset.x;
objectPosition.z = objectZ - currentMapOriginZ - offset.z;
u32 tileIndex = tileX + tileY * mapMatrixWidthTiles;
u32 tileIndex = tileX + tileZ * mapMatrixWidthTiles;
u8 tileMapQuadrant = LandDataManager_CalculateMapQuadrantOfTile(tileIndex, mapMatrixWidthTiles);
u32 loadedMapIndex = LandDataManager_GetRelativeLoadedMapsQuadrant(mapMatrixIndex, tileMapQuadrant, landDataMan);
@ -150,9 +150,9 @@ static const fx32 GetHeight(const FieldSystem *fieldSystem, const fx32 objectHei
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;
int tileZ = objectZ / MAP_OBJECT_TILE_SIZE;
BOOL loadedMapIndexValid = LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(fieldSystem->landDataMan, tileX, tileY, NULL);
BOOL loadedMapIndexValid = LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(fieldSystem->landDataMan, tileX, tileZ, NULL);
u8 newObjectHeightSource;
if (loadedMapIndexValid) {
@ -168,30 +168,30 @@ static const fx32 GetSimpleHeight(const FieldSystem *fieldSystem, const fx32 obj
return 0;
}
static BOOL GetTileAttributes(const FieldSystem *fieldSystem, const int tileX, const int tileY, u16 *attributes)
static BOOL GetTileAttributes(const FieldSystem *fieldSystem, const int tileX, const int tileZ, u16 *attributes)
{
int fixedTileX, fixedTileY;
int fixedTileX, fixedTileZ;
const LandDataManager *landDataMan = fieldSystem->landDataMan;
fixedTileX = tileX - LandDataManager_GetOffsetTileX(landDataMan);
fixedTileY = tileY - LandDataManager_GetOffsetTileY(landDataMan);
fixedTileZ = tileZ - LandDataManager_GetOffsetTileZ(landDataMan);
u8 loadedMapIndex;
BOOL loadedMapIndexValid = LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(landDataMan, tileX, tileY, &loadedMapIndex);
BOOL loadedMapIndexValid = LandDataManager_GetRelativeLoadedMapsQuadrantOfTile(landDataMan, tileX, tileZ, &loadedMapIndex);
if (loadedMapIndexValid == FALSE) {
(*attributes) = INVALID_TILE_ATTRIBUTES;
return FALSE;
}
u32 fixedTileIndex = (fixedTileY % MAP_TILES_COUNT_Y) * MAP_TILES_COUNT_X + (fixedTileX % MAP_TILES_COUNT_X);
u32 fixedTileIndex = (fixedTileZ % MAP_TILES_COUNT_Z) * 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)
static BOOL GetSimpleTileAttributes(const FieldSystem *fieldSystem, const int tileX, const int tileZ, u16 *attributes)
{
const LandDataManager *landDataMan = fieldSystem->landDataMan;
@ -199,10 +199,10 @@ static BOOL GetSimpleTileAttributes(const FieldSystem *fieldSystem, const int ti
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 mapMatrixZ = tileZ / MAP_TILES_COUNT_Z;
u32 mapMatrixIndex = mapMatrixX + mapMatrixZ * mapMatrixWidth;
u32 tileIndex = (tileY % MAP_TILES_COUNT_Y) * MAP_TILES_COUNT_X + (tileX % MAP_TILES_COUNT_X);
u32 tileIndex = (tileZ % MAP_TILES_COUNT_Z) * MAP_TILES_COUNT_X + (tileX % MAP_TILES_COUNT_X);
u16 const *terrainAttributes = TerrainAttributes_Get(mapMatrixIndex, fieldSystem->terrainAttributes);
*attributes = terrainAttributes[tileIndex];
@ -220,10 +220,10 @@ void TerrainCollisionManager_Init(const TerrainCollisionManager **terrainCollisi
}
}
BOOL TerrainCollisionManager_CheckCollision(const FieldSystem *fieldSystem, const int tileX, const int tileY)
BOOL TerrainCollisionManager_CheckCollision(const FieldSystem *fieldSystem, const int tileX, const int tileZ)
{
u16 attributes;
BOOL attributesValid = fieldSystem->terrainCollisionMan->getTileAttributes(fieldSystem, tileX, tileY, &attributes);
BOOL attributesValid = fieldSystem->terrainCollisionMan->getTileAttributes(fieldSystem, tileX, tileZ, &attributes);
if (attributesValid) {
u8 hasCollision = attributes >> TERRAIN_ATTRIBUTES_COLLISION_SHIFT;
@ -237,11 +237,11 @@ BOOL TerrainCollisionManager_CheckCollision(const FieldSystem *fieldSystem, cons
return FALSE;
}
u8 TerrainCollisionManager_GetTileBehavior(const FieldSystem *fieldSystem, const int tileX, const int tileY)
u8 TerrainCollisionManager_GetTileBehavior(const FieldSystem *fieldSystem, const int tileX, const int tileZ)
{
u16 attributes;
if (fieldSystem->terrainCollisionMan->getTileAttributes(fieldSystem, tileX, tileY, &attributes)) {
if (fieldSystem->terrainCollisionMan->getTileAttributes(fieldSystem, tileX, tileZ, &attributes)) {
u8 behavior = attributes;
behavior &= TERRAIN_ATTRIBUTES_TILE_BEHAVIOR_MASK;
@ -256,10 +256,10 @@ const fx32 TerrainCollisionManager_GetHeight(const FieldSystem *fieldSystem, con
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)
static int GetVerticalDirection(const FieldSystem *fieldSystem, const VecFx32 *objectPosition, const int tileX, const int tileZ, 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 objectZ = tileZ * MAP_OBJECT_TILE_SIZE + MAP_OBJECT_TILE_SIZE / 2;
fx32 objectHeight = TerrainCollisionManager_GetHeight(fieldSystem, objectPosition->y, objectX, objectZ, newObjectHeightSource);
int direction;
@ -287,20 +287,20 @@ static int GetVerticalDirection(const FieldSystem *fieldSystem, const VecFx32 *o
return direction;
}
BOOL TerrainCollisionManager_WillMapObjectCollide(const FieldSystem *fieldSystem, const VecFx32 *objectPosition, const int tileX, const int tileY, s8 *verticalDirection)
BOOL TerrainCollisionManager_WillMapObjectCollide(const FieldSystem *fieldSystem, const VecFx32 *objectPosition, const int tileX, const int tileZ, s8 *verticalDirection)
{
u8 newObjectHeightSource;
int direction = GetVerticalDirection(fieldSystem, objectPosition, tileX, tileY, &newObjectHeightSource);
int direction = GetVerticalDirection(fieldSystem, objectPosition, tileX, tileZ, &newObjectHeightSource);
if (verticalDirection != NULL) {
*verticalDirection = direction;
}
if (direction == VERTICAL_DIRECTION_NONE) {
BOOL isColliding = TerrainCollisionManager_CheckCollision(fieldSystem, tileX, tileY);
BOOL isColliding = TerrainCollisionManager_CheckCollision(fieldSystem, tileX, tileZ);
if (!isColliding && newObjectHeightSource == CALCULATED_HEIGHT_SOURCE_DYNAMIC) {
u8 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, tileX, tileY);
u8 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, tileX, tileZ);
if (TileBehavior_IsPastoriaGymWater(tileBehavior)) {
return TRUE;
@ -313,10 +313,10 @@ BOOL TerrainCollisionManager_WillMapObjectCollide(const FieldSystem *fieldSystem
}
}
BOOL TerrainCollisionManager_WillPlayerCollide(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 tileZ, s8 *verticalDirection)
{
u8 newObjectHeightSource;
int direction = GetVerticalDirection(fieldSystem, objectPosition, tileX, tileY, &newObjectHeightSource);
int direction = GetVerticalDirection(fieldSystem, objectPosition, tileX, tileZ, &newObjectHeightSource);
if (verticalDirection != NULL) {
*verticalDirection = direction;
@ -324,13 +324,13 @@ BOOL TerrainCollisionManager_WillPlayerCollide(FieldSystem *fieldSystem, const V
if (direction == VERTICAL_DIRECTION_NONE) {
BOOL isColliding;
BOOL hasDynamicCollision = DynamicMapFeatures_CheckCollision(fieldSystem, tileX, tileY, objectPosition->y, &isColliding);
BOOL hasDynamicCollision = DynamicMapFeatures_CheckCollision(fieldSystem, tileX, tileZ, objectPosition->y, &isColliding);
if (!hasDynamicCollision) {
isColliding = TerrainCollisionManager_CheckCollision(fieldSystem, tileX, tileY);
isColliding = TerrainCollisionManager_CheckCollision(fieldSystem, tileX, tileZ);
if (!isColliding && newObjectHeightSource == CALCULATED_HEIGHT_SOURCE_DYNAMIC) {
u8 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, tileX, tileY);
u8 tileBehavior = TerrainCollisionManager_GetTileBehavior(fieldSystem, tileX, tileZ);
if (TileBehavior_IsPastoriaGymWater(tileBehavior)) {
return TRUE;
@ -346,22 +346,22 @@ BOOL TerrainCollisionManager_WillPlayerCollide(FieldSystem *fieldSystem, const V
}
}
void TerrainCollisionHitbox_Init(const int tileX, const int tileY, const int offsetTileX, const int offsetTileY, const u32 sizeX, const u32 sizeY, TerrainCollisionHitbox *hitbox)
void TerrainCollisionHitbox_Init(const int tileX, const int tileZ, const int offsetTileX, const int offsetTileZ, const u32 sizeX, const u32 sizeZ, TerrainCollisionHitbox *hitbox)
{
int startTileX = tileX + offsetTileX;
int startTileY = tileY + offsetTileY;
int startTileZ = tileZ + offsetTileZ;
int endTileX = startTileX + sizeX;
int endTileY = startTileY + sizeY;
int endTileZ = startTileZ + sizeZ;
if (startTileX < 0 || startTileY < 0 || endTileX < 0 || endTileY < 0) {
if (startTileX < 0 || startTileZ < 0 || endTileX < 0 || endTileZ < 0) {
GF_ASSERT(FALSE);
}
hitbox->startX = startTileX * MAP_OBJECT_TILE_SIZE;
hitbox->startZ = startTileY * MAP_OBJECT_TILE_SIZE;
hitbox->startZ = startTileZ * MAP_OBJECT_TILE_SIZE;
hitbox->endX = endTileX * MAP_OBJECT_TILE_SIZE;
hitbox->endZ = endTileY * MAP_OBJECT_TILE_SIZE;
hitbox->endZ = endTileZ * MAP_OBJECT_TILE_SIZE;
}
BOOL TerrainCollisionHitbox_CollidesWithMapProp(const MapProp *mapProp, const TerrainCollisionHitbox *hitbox, const VecFx32 *mapAbsoluteOrigin)
@ -526,11 +526,11 @@ BOOL FieldSystem_FindLoadedMapPropByModelIDs(const FieldSystem *fieldSystem, con
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;
mapAbsoluteOrigin->z = (MAP_TILES_COUNT_Z / 2) * MAP_OBJECT_TILE_SIZE;
u16 mapMatrixX = mapMatrixIndex % mapMatrixWidth;
u16 mapMatrixY = mapMatrixIndex / mapMatrixWidth;
u16 mapMatrixZ = mapMatrixIndex / mapMatrixWidth;
mapAbsoluteOrigin->x += mapMatrixX * MAP_TILES_COUNT_X * MAP_OBJECT_TILE_SIZE;
mapAbsoluteOrigin->z += mapMatrixY * MAP_TILES_COUNT_Y * MAP_OBJECT_TILE_SIZE;
mapAbsoluteOrigin->z += mapMatrixZ * MAP_TILES_COUNT_Z * MAP_OBJECT_TILE_SIZE;
}