falso
/
mm
mirror of https://github.com/zeldaret/mm.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
mm/src/code/z_map_disp.c

1827 lines
69 KiB
C
Raw Blame History

#include "global.h"
#include "gfx.h"
#include "sys_cmpdma.h"
#include "assets/interface/icon_item_dungeon_static/icon_item_dungeon_static.h"
#include "assets/interface/parameter_static/parameter_static.h"
#include "assets/objects/gameplay_keep/gameplay_keep.h"
#include "overlays/actors/ovl_Door_Shutter/z_door_shutter.h"
#include "overlays/kaleido_scope/ovl_kaleido_scope/z_kaleido_scope.h"
void MapDisp_DestroyMapI(PlayState* play);
void MapDisp_InitMapI(PlayState* play);
#include "gDPLoadTextureBlock_Runtime.inc.c"
static UNK_TYPE4 D_801BEB30[2] = { 0, 0 };
static u64 sWhiteSquareTex[] = {
#include "assets/code/z_map_disp/white_square.i4.inc.c"
};
static MapDisp sMapDisp = {
NULL, -1, 210, 140, 0, 0, NULL, -1, NULL, 0, 0, 0, 0, NULL, NULL, 0,
0, 0, 0, 0, 0, NULL, 0, 0, 0, NULL, 0, 0, NULL, 0, 0,
};
MapDataRoom sMapDataRooms[ROOM_MAX];
MapDataChest sMapDataChests[32];
static MapDataScene sMapDataScene = {
sMapDataRooms,
80,
};
static s32 sSceneNumRooms = 0; // current scene's no. of rooms
static s32 sNumChests = 0; // MinimapChest count
static TransitionActorList sTransitionActorList = { 0, NULL };
static Color_RGBA8 sMinimapActorCategoryColors[12] = {
{ 255, 255, 255, 255 }, { 255, 255, 255, 255 }, { 0, 255, 0, 255 }, { 255, 255, 255, 255 },
{ 255, 255, 255, 255 }, { 255, 0, 0, 255 }, { 255, 255, 255, 255 }, { 255, 255, 255, 255 },
{ 255, 255, 255, 255 }, { 255, 0, 0, 255 }, { 255, 255, 255, 255 }, { 255, 255, 255, 255 },
};
TransitionActorEntry sTransitionActors[ROOM_TRANSITION_MAX];
PauseDungeonMap sPauseDungeonMap;
void MapDisp_GetMapITexture(void* dst, s32 mapCompactId) {
if (MapDisp_GetSizeOfMapITex(mapCompactId) != 0) {
CmpDma_LoadFile(SEGMENT_ROM_START(map_i_static), mapCompactId, dst, MapDisp_GetSizeOfMapITex(mapCompactId));
}
}
void MapDisp_InitRoomStoreyRecord(PlayState* play, s16* roomStorey) {
*roomStorey = -1;
}
void MapDisp_DestroyRoomStoreyRecord(PlayState* play, s16* roomStory) {
}
void func_80102EB4(u32 flag) {
sMapDisp.unk20 |= flag;
}
void func_80102ED0(u32 flag) {
sMapDisp.unk20 &= ~flag;
}
s32 MapDisp_CurRoomHasMapI(PlayState* play) {
MapDataRoom* mapDataRoom;
s8 curRoom;
if (Map_IsInBossScene(play) == true) {
return true;
}
curRoom = play->roomCtx.curRoom.num;
if (curRoom == -1) {
return false;
}
mapDataRoom = &sMapDisp.mapDataScene->rooms[curRoom];
if (mapDataRoom->mapId == MAP_DATA_NO_MAP) {
return false;
}
if (MapData_GetMapIId(mapDataRoom->mapId) == MAPDATA_MAP_I_MAX) {
return false;
}
return true;
}
/**
* Computes the storey containing checkY and returns the floor Y value.
* @note Only used to check if a chest is on the same storey as the player.
*/
f32 MapDisp_GetStoreyY(f32 checkY) {
s32 i;
if ((sMapDisp.storeyYList[sMapDisp.numStoreys - 1] - 80.0f) < checkY) {
return sMapDisp.storeyYList[sMapDisp.numStoreys - 1];
}
for (i = sMapDisp.numStoreys - 2; i >= 0; i--) {
if (((sMapDisp.storeyYList[i] - 80.0f) < checkY) && (checkY < (sMapDisp.storeyYList[i + 1] + 80.0f))) {
return sMapDisp.storeyYList[i];
}
}
if (checkY < (sMapDisp.storeyYList[0] + 80.0f)) {
return sMapDisp.storeyYList[0];
}
return 0.0f;
}
void MapDisp_GetMapTexDim(MapDataRoom* mapDataRoom, s32* width, s32* height) {
MapData_GetMapTexDim(mapDataRoom->mapId, width, height);
}
void MapDisp_GetMapScale(MapDataRoom* mapDataRoom, s32* scale) {
MapData_GetMapScale(mapDataRoom->mapId, scale);
if (*scale == 0) {
*scale = 20;
}
}
void MapDisp_GetMapOffset(MapDataRoom* mapDataRoom, s32* offsetX, s32* offsetY) {
s32 width;
s32 height;
if (mapDataRoom->mapId == MAP_DATA_NO_MAP) {
*offsetX = 0;
*offsetY = 0;
return;
}
MapDisp_GetMapTexDim(mapDataRoom, &width, &height);
MapData_GetMapTexOffset(mapDataRoom->mapId, offsetX, offsetY);
if (mapDataRoom->flags & MAP_DATA_ROOM_FLIP_X) {
s32 temp = (width / 2);
*offsetX = ((width / 2) - *offsetX) + (width / 2);
}
if (mapDataRoom->flags & MAP_DATA_ROOM_FLIP_Y) {
s32 temp = (height / 2);
*offsetY = (temp - *offsetY) + temp;
}
}
void MapDisp_DrawMinimapRoom(PlayState* play, TexturePtr texture, s32 x, s32 y, s32 room, f32 intensity) {
MapDataRoom* mapDataRoom = &sMapDisp.mapDataScene->rooms[room];
s32 texWidth;
s32 texHeight;
s32 dtdy;
s32 dsdx;
s32 t;
s32 s;
s16 dsdx_temp;
s16 dtdy_temp;
Color_RGBA8 color;
s32 drawType;
if ((mapDataRoom->mapId == MAP_DATA_NO_MAP) || (texture == NULL)) {
return;
}
MapDisp_GetMapTexDim(mapDataRoom, &texWidth, &texHeight);
OPEN_DISPS(play->state.gfxCtx);
Gfx_SetupDL39_Overlay(play->state.gfxCtx);
MapData_GetMapColor(MapData_GetMapColorIndex(mapDataRoom->mapId), &color);
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, color.r, color.g, color.b,
(s32)(play->interfaceCtx.minimapAlpha * intensity * color.a / 255.0f));
MapData_GetDrawType(mapDataRoom->mapId, &drawType);
switch (drawType) {
case MAPDATA_DRAW_1:
gDPSetCombineMode(OVERLAY_DISP++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
gDPLoadTextureBlock_4b(OVERLAY_DISP++, texture, G_IM_FMT_IA, texWidth, texHeight, 0,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
G_TX_NOLOD, G_TX_NOLOD);
break;
case MAPDATA_DRAW_3:
gDPSetCombineLERP(OVERLAY_DISP++, 0, 0, 0, PRIMITIVE, 0, 0, 0, TEXEL0, 0, 0, 0, PRIMITIVE, 0, 0, 0, TEXEL0);
gDPLoadTextureBlock_4b(OVERLAY_DISP++, texture, G_IM_FMT_I, texWidth, texHeight, 0,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
G_TX_NOLOD, G_TX_NOLOD);
break;
default:
case MAPDATA_DRAW_0:
gDPSetCombineMode(OVERLAY_DISP++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
gDPLoadTextureBlock_4b(OVERLAY_DISP++, texture, G_IM_FMT_I, texWidth, texHeight, 0,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
G_TX_NOLOD, G_TX_NOLOD);
break;
}
s = (mapDataRoom->flags & MAP_DATA_ROOM_FLIP_X) ? (texWidth - 1) << 5 : 0;
t = (mapDataRoom->flags & MAP_DATA_ROOM_FLIP_Y) ? 0 : (texHeight - 1) << 5;
dsdx_temp = ((mapDataRoom->flags & MAP_DATA_ROOM_FLIP_X) ? -1 : 1) * (1 << 10);
dtdy_temp = ((mapDataRoom->flags & MAP_DATA_ROOM_FLIP_Y) ? 1 : -1) * (1 << 10);
dsdx = (mapDataRoom->flags & MAP_DATA_ROOM_FLIP_X) ? dsdx_temp & 0xFFFF : dsdx_temp;
dtdy = (mapDataRoom->flags & MAP_DATA_ROOM_FLIP_Y) ? dtdy_temp : dtdy_temp & 0xFFFF;
gSPTextureRectangle(OVERLAY_DISP++, x << 2, y << 2, (texWidth + x) << 2, (y + texHeight) << 2, G_TX_RENDERTILE, s,
t, dsdx, dtdy);
CLOSE_DISPS(play->state.gfxCtx);
}
// Tests if the map data should be rotated 180 degrees
// SCENE_35TAKI is the only scene with data flipped in this manner.
s32 MapDisp_IsDataRotated(PlayState* play) {
if (play->sceneId == SCENE_35TAKI) {
return true;
}
return false;
}
s32 MapDisp_CanDrawDoors(PlayState* play) {
if ((gSaveContext.save.entrance == ENTRANCE(ROMANI_RANCH, 0)) && (Cutscene_GetSceneLayer(play) != 0)) {
return false;
}
return true;
}
void MapDisp_Minimap_DrawActorIcon(PlayState* play, Actor* actor) {
MapDataRoom* mapDataRoom;
s32 posX;
s32 posY;
s32 texOffsetX;
s32 texOffsetY;
s32 texWidth;
s32 texHeight;
f32 scaleFrac;
f32 unused1;
f32 unused2;
Player* player = GET_PLAYER(play);
s32 scale;
// inferred from `MapDisp_Minimap_DrawDoorActor`
unused1 = fabsf(player->actor.world.pos.y - actor->world.pos.y);
unused2 = 1.0f - (1 / 350.0f) * unused1;
if (unused2 < 0.0f) {
unused2 = 0.0f;
}
mapDataRoom = &sMapDisp.mapDataScene->rooms[sMapDisp.curRoom];
if (mapDataRoom->mapId == MAP_DATA_NO_MAP) {
return;
}
MapDisp_GetMapOffset(mapDataRoom, &texOffsetX, &texOffsetY);
MapDisp_GetMapTexDim(mapDataRoom, &texWidth, &texHeight);
scale = sMapDisp.mapDataScene->scale;
if (sMapDisp.mapDataScene->scale == 0) {
scale = 20;
} else if (sMapDisp.mapDataScene->scale == -1) {
s32 scaleTemp;
MapDisp_GetMapScale(mapDataRoom, &scaleTemp);
scale = scaleTemp;
}
scaleFrac = 1.0f / scale;
if (!MapDisp_IsDataRotated(play)) {
posX = (s32)((actor->world.pos.x - mapDataRoom->centerX) * scaleFrac) + sMapDisp.minimapBaseX +
sMapDisp.minimapCurX - sMapDisp.minimapBaseX + texOffsetX;
posY = (s32)((actor->world.pos.z - mapDataRoom->centerZ) * scaleFrac) + sMapDisp.minimapBaseY +
sMapDisp.minimapCurY - sMapDisp.minimapBaseY + texOffsetY;
} else {
posX = -(s32)((actor->world.pos.x - mapDataRoom->centerX) * scaleFrac) + sMapDisp.minimapBaseX +
sMapDisp.minimapCurX - sMapDisp.minimapBaseX + texOffsetX;
posY = -(s32)((actor->world.pos.z - mapDataRoom->centerZ) * scaleFrac) + sMapDisp.minimapBaseY +
sMapDisp.minimapCurY - sMapDisp.minimapBaseY + texOffsetY;
}
if ((posX > 0) && (posX < 0x3FF) && (posY > 0) && (posY < 0x3FF)) {
OPEN_DISPS(play->state.gfxCtx);
if ((actor->category == ACTORCAT_PLAYER) && (actor->flags & ACTOR_FLAG_MINIMAP_ICON_ENABLED)) {
s16 compassRot;
Gfx_SetupDL42_Overlay(play->state.gfxCtx);
gSPMatrix(OVERLAY_DISP++, &gIdentityMtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gDPSetCombineLERP(OVERLAY_DISP++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
gDPSetEnvColor(OVERLAY_DISP++, 0, 0, 0, play->interfaceCtx.minimapAlpha);
gDPSetCombineMode(OVERLAY_DISP++, G_CC_PRIMITIVE, G_CC_PRIMITIVE);
gDPSetRenderMode(OVERLAY_DISP++, G_RM_AA_DEC_LINE, G_RM_NOOP2);
Matrix_Translate(posX - 160.0f, 120.0f - posY, 0.0f, MTXMODE_NEW);
Matrix_RotateXFApply(-1.6f);
compassRot = (s32)(0x7FFF - actor->focus.rot.y) / 1024;
if (MapDisp_IsDataRotated(play)) {
compassRot += 0x7FFF;
}
Matrix_RotateYF(compassRot / 10.0f, MTXMODE_APPLY);
Matrix_Scale(0.4f, 0.4f, 0.4f, MTXMODE_APPLY);
MATRIX_FINALIZE_AND_LOAD(OVERLAY_DISP++, play->state.gfxCtx);
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 200, 255, 0, play->interfaceCtx.minimapAlpha);
gSPDisplayList(OVERLAY_DISP++, gCompassArrowDL);
} else if ((actor->id == ACTOR_EN_BOX) && !Flags_GetTreasure(play, actor->params & 0x1F) &&
(MapDisp_GetStoreyY(player->actor.world.pos.y) == MapDisp_GetStoreyY(actor->world.pos.y))) {
Gfx_SetupDL39_Overlay(play->state.gfxCtx);
gDPPipeSync(OVERLAY_DISP++);
gDPSetTextureLUT(OVERLAY_DISP++, G_TT_NONE);
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 255, play->interfaceCtx.minimapAlpha);
gDPSetEnvColor(OVERLAY_DISP++, 0, 0, 0, play->interfaceCtx.minimapAlpha);
gDPPipeSync(OVERLAY_DISP++);
gDPLoadTextureBlock_Runtime(OVERLAY_DISP++, gMapChestIconTex, G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 8, 0,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
G_TX_NOLOD, G_TX_NOLOD);
gSPTextureRectangle(OVERLAY_DISP++, (posX - 4) << 2, (posY - 4) << 2, (posX + 4) << 2, (posY + 4) << 2,
G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
} else {
Gfx_SetupDL39_Overlay(play->state.gfxCtx);
gDPSetCombineMode(OVERLAY_DISP++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
if (actor->flags & ACTOR_FLAG_MINIMAP_ICON_ENABLED) {
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, sMinimapActorCategoryColors[actor->category].r,
sMinimapActorCategoryColors[actor->category].g,
sMinimapActorCategoryColors[actor->category].b, play->interfaceCtx.minimapAlpha);
gSPTextureRectangle(OVERLAY_DISP++, (posX - 1) << 2, (posY - 1) << 2, (posX + 1) << 2, (posY + 1) << 2,
G_TX_RENDERTILE, 0, 0, 0x0001, 0x0001);
}
}
CLOSE_DISPS(play->state.gfxCtx);
}
}
void MapDisp_Minimap_DrawActors(PlayState* play) {
ActorContext* actorCtx;
s32 i;
if (play->roomCtx.curRoom.num != -1) {
OPEN_DISPS(play->state.gfxCtx);
gDPLoadTextureBlock_4b(OVERLAY_DISP++, &sWhiteSquareTex, G_IM_FMT_I, 16, 16, 0, G_TX_NOMIRROR | G_TX_WRAP,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
actorCtx = &play->actorCtx;
for (i = 0; i < ACTORCAT_MAX; i++) {
Actor* actor = actorCtx->actorLists[i].first;
while (actor != NULL) {
if ((actor->update != NULL) && (actor->init == NULL) &&
Object_IsLoaded(&play->objectCtx, actor->objectSlot) &&
((actor->id == ACTOR_EN_BOX) || (i == ACTORCAT_PLAYER) ||
(actor->flags & ACTOR_FLAG_MINIMAP_ICON_ENABLED)) &&
((sMapDisp.curRoom == actor->room) || (actor->room == -1))) {
MapDisp_Minimap_DrawActorIcon(play, actor);
}
actor = actor->next;
}
}
CLOSE_DISPS(play->state.gfxCtx);
}
}
void MapDisp_Minimap_DrawDoorActor(PlayState* play, Actor* actor) {
MapDataRoom* mapDataRoom;
s32 posX;
s32 posY;
s32 texOffsetX;
s32 texOffsetY;
s32 texWidth;
s32 texHeight;
Player* player = GET_PLAYER(play);
f32 scaleFrac;
f32 yDistFromPlayer = fabsf(player->actor.world.pos.y - actor->world.pos.y);
s32 scale;
f32 yDistAlpha = 1.0f - (1.0f / 350.0f) * yDistFromPlayer;
if (yDistAlpha < 0.0f) {
yDistAlpha = 0.0f;
}
mapDataRoom = &sMapDisp.mapDataScene->rooms[sMapDisp.curRoom];
if (mapDataRoom->mapId != MAP_DATA_NO_MAP) {
MapDisp_GetMapOffset(mapDataRoom, &texOffsetX, &texOffsetY);
MapDisp_GetMapTexDim(mapDataRoom, &texWidth, &texHeight);
scale = sMapDisp.mapDataScene->scale;
if (sMapDisp.mapDataScene->scale == 0) {
scale = 20;
} else if (sMapDisp.mapDataScene->scale == -1) {
s32 scaleTemp;
MapDisp_GetMapScale(mapDataRoom, &scaleTemp);
scale = scaleTemp;
}
scaleFrac = 1.0f / scale;
if (!MapDisp_IsDataRotated(play)) {
posX = (((s32)((actor->world.pos.x - mapDataRoom->centerX) * scaleFrac) + sMapDisp.minimapBaseX +
sMapDisp.minimapCurX) -
sMapDisp.minimapBaseX) +
texOffsetX;
posY = (((s32)((actor->world.pos.z - mapDataRoom->centerZ) * scaleFrac) + sMapDisp.minimapBaseY +
sMapDisp.minimapCurY) -
sMapDisp.minimapBaseY) +
texOffsetY;
} else {
posX = (((sMapDisp.minimapBaseX - (s32)((actor->world.pos.x - mapDataRoom->centerX) * scaleFrac)) +
sMapDisp.minimapCurX) -
sMapDisp.minimapBaseX) +
texOffsetX;
posY = (((sMapDisp.minimapBaseY - (s32)((actor->world.pos.z - mapDataRoom->centerZ) * scaleFrac)) +
sMapDisp.minimapCurY) -
sMapDisp.minimapBaseY) +
texOffsetY;
}
if ((posX > 0) && (posX < 0x3FF) && (posY > 0) && (posY < 0x3FF)) {
OPEN_DISPS(play->state.gfxCtx);
Gfx_SetupDL39_Overlay(play->state.gfxCtx);
gDPSetCombineMode(OVERLAY_DISP++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
if ((actor->category == ACTORCAT_DOOR) && MapDisp_CanDrawDoors(play)) {
s32 pad;
gDPSetPrimColor(
OVERLAY_DISP++, 0, 0, sMinimapActorCategoryColors[actor->category].r,
sMinimapActorCategoryColors[actor->category].g, sMinimapActorCategoryColors[actor->category].b,
(s32)((sMinimapActorCategoryColors[actor->category].a * (1.0f - sMapDisp.swapAnimTimer * 0.05f) *
yDistAlpha * play->interfaceCtx.minimapAlpha) /
255.0f));
scale = sMapDisp.mapDataScene->scale;
if (sMapDisp.mapDataScene->scale == 0) {
scale = 20;
} else if (sMapDisp.mapDataScene->scale == -1) {
s32 scaleTemp;
MapDisp_GetMapScale(mapDataRoom, &scaleTemp);
scale = scaleTemp;
}
if (scale <= 50) {
gSPTextureRectangle(OVERLAY_DISP++, (posX - 2) << 2, (posY - 2) << 2, (posX + 2) << 2,
(posY + 2) << 2, G_TX_RENDERTILE, 0, 0, 0x0001, 0x0001);
} else {
gSPTextureRectangle(OVERLAY_DISP++, (posX - 1) << 2, (posY - 1) << 2, (posX + 1) << 2,
(posY + 1) << 2, G_TX_RENDERTILE, 0, 0, 0x0001, 0x0001);
}
}
CLOSE_DISPS(play->state.gfxCtx);
}
}
}
void MapDisp_Minimap_DrawDoorActors(PlayState* play) {
s32 i;
Actor* actor;
if (play->roomCtx.curRoom.num != -1) {
OPEN_DISPS(play->state.gfxCtx);
gDPLoadTextureBlock_4b(OVERLAY_DISP++, &sWhiteSquareTex, G_IM_FMT_I, 16, 16, 0, G_TX_NOMIRROR | G_TX_WRAP,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
actor = play->actorCtx.actorLists[ACTORCAT_DOOR].first;
while (actor != NULL) {
if ((actor->update != NULL) && (actor->init == NULL) &&
Object_IsLoaded(&play->objectCtx, actor->objectSlot) &&
((sMapDisp.curRoom == actor->room) || (actor->room == -1))) {
MapDisp_Minimap_DrawDoorActor(play, actor);
}
actor = actor->next;
}
CLOSE_DISPS(play->state.gfxCtx);
}
}
/**
* @brief Waits for GAMEPLAY_DANGEON_KEEP to load, if it is a current object depenency
*
* @param play
*/
void MapDisp_AwaitGameplayDangeonKeep(PlayState* play) {
s32 objectSlot = Object_GetSlot(&play->objectCtx, GAMEPLAY_DANGEON_KEEP);
if (objectSlot <= OBJECT_SLOT_NONE) {
sMapDisp.unk20 |= 1;
return;
}
while (true) {
if (Object_IsLoaded(&play->objectCtx, objectSlot)) {
break;
}
}
}
void MapDisp_Init(PlayState* play) {
s32 i;
sMapDisp.mapDataScene = NULL;
sMapDisp.curRoom = -1;
sMapDisp.minimapBaseX = 210;
sMapDisp.minimapBaseY = 140;
sMapDisp.minimapCurX = 210;
sMapDisp.minimapCurY = 140;
sMapDisp.minimapCurTex = NULL;
sMapDisp.prevRoom = -1;
sMapDisp.minimapPrevTex = NULL;
sMapDisp.minimapPrevX = 0;
sMapDisp.minimapPrevY = 0;
sMapDisp.unk20 = 0;
sMapDisp.swapAnimTimer = 0;
if (!Map_IsInBossScene(play)) {
sSceneNumRooms = play->roomList.count;
}
sMapDisp.texBuff0 = THA_AllocTailAlign16(&play->state.tha, 0x4000);
sMapDisp.texBuff1 = THA_AllocTailAlign16(&play->state.tha, 0x4000);
MapDisp_AwaitGameplayDangeonKeep(play);
if (!Map_IsInBossScene(play)) {
sMapDisp.sceneMinX = 0;
sMapDisp.sceneMinZ = 0;
sMapDisp.sceneWidth = 100;
sMapDisp.sceneHeight = 100;
sMapDisp.sceneMidX = TRUNCF_BINANG((f32)sMapDisp.sceneMinX + ((f32)sMapDisp.sceneWidth * 0.5f));
sMapDisp.sceneMidZ = TRUNCF_BINANG((f32)sMapDisp.sceneMinZ + ((f32)sMapDisp.sceneHeight * 0.5f));
}
sMapDisp.roomStoreyList = THA_AllocTailAlign16(&play->state.tha, sSceneNumRooms * sizeof(s16));
for (i = 0; i < sSceneNumRooms; i++) {
MapDisp_InitRoomStoreyRecord(play, &sMapDisp.roomStoreyList[i]);
}
sMapDisp.storeyYList = THA_AllocTailAlign16(&play->state.tha, ROOM_MAX * sizeof(s16));
for (i = 0; i < ROOM_MAX; i++) {
sMapDisp.storeyYList[i] = FLOOR_MIN_Y;
}
MapDisp_InitMapI(play);
sMapDisp.bossRoomStorey = 0;
sMapDisp.unk5A = 0;
if (Map_IsInBossScene(play)) {
MapDisp_InitMapData(play, NULL);
MapDisp_InitChestData(play, 0, NULL);
}
}
typedef struct {
/* 0x0 */ s16 sceneId;
/* 0x2 */ s16 bottomStorey;
} MapCustomBottomStorey; // size = 0x4
void MapDisp_InitSceneFloorData(PlayState* play) {
static MapCustomBottomStorey sCustomBottomStorey[] = {
{ SCENE_HAKUGIN, -1 }, { SCENE_HAKUGIN_BS, -1 }, { SCENE_SEA, -2 },
{ SCENE_SEA_BS, -2 }, { SCENE_INISIE_N, -1 },
};
s32 i1;
s32 i2;
s32 i3;
s32 storey;
// init table
for (i1 = 0; i1 < ROOM_MAX; i1++) {
sMapDisp.storeyYList[i1] = FLOOR_MIN_Y;
}
// for all rooms in scene
for (i2 = 0; i2 < sSceneNumRooms; i2++) {
MapDataRoom* mapDataRoom = &sMapDisp.mapDataScene->rooms[i2];
if (mapDataRoom->mapId == MAP_DATA_NO_MAP) {
continue;
}
// add item to the table if it is a newish value
for (i1 = 0; i1 < ROOM_MAX; i1++) {
if (sMapDisp.storeyYList[i1] == FLOOR_MIN_Y) {
sMapDisp.storeyYList[i1] = mapDataRoom->floorY;
break;
} else if (fabsf((f32)sMapDisp.storeyYList[i1] - (f32)mapDataRoom->floorY) < 5.0f) {
break;
}
}
}
// sort the table in ascending order
for (i2 = 0; i2 < sSceneNumRooms; i2++) {
if (sMapDisp.storeyYList[i2] == FLOOR_MIN_Y) {
break;
}
for (i3 = i2 + 1; i3 < sSceneNumRooms; i3++) {
if (sMapDisp.storeyYList[i3] == FLOOR_MIN_Y) {
break;
}
if (sMapDisp.storeyYList[i3] < sMapDisp.storeyYList[i2]) {
s16 swap = sMapDisp.storeyYList[i2];
sMapDisp.storeyYList[i2] = sMapDisp.storeyYList[i3];
sMapDisp.storeyYList[i3] = swap;
}
}
}
for (i2 = 0; i2 < sSceneNumRooms; i2++) {
MapDataRoom* mapDataRoom = &sMapDisp.mapDataScene->rooms[i2];
sMapDisp.roomStoreyList[i2] = -1;
for (storey = 0; storey < sSceneNumRooms; storey++) {
if (sMapDisp.storeyYList[storey] != FLOOR_MIN_Y) {
if (fabsf((f32)sMapDisp.storeyYList[storey] - (f32)mapDataRoom->floorY) < 5.0f) {
sMapDisp.roomStoreyList[i2] = storey;
break;
}
}
}
}
sMapDisp.numStoreys = 0;
for (i2 = 0; i2 < sSceneNumRooms; i2++) {
if (sMapDisp.storeyYList[i2] != FLOOR_MIN_Y) {
sMapDisp.numStoreys++;
}
}
sMapDisp.bottomStorey = 0;
for (i2 = 0; i2 < ARRAY_COUNT(sCustomBottomStorey); i2++) {
if (play->sceneId == sCustomBottomStorey[i2].sceneId) {
sMapDisp.bottomStorey = sCustomBottomStorey[i2].bottomStorey;
}
}
}
/**
* Unused result
* @returns the y position to place the boss room skull icon on the pause map.
* The result position is the inverse of what it should be, stacking lower rooms above higher ones
*/
s32 MapDisp_GetBossIconY(void) {
s32 dungeonMapFloorIconPosY[5] = { 67, 81, 95, 109, 123 };
if ((sMapDisp.mapDataScene == NULL) || (sMapDisp.bossRoomStorey < 0) || (sMapDisp.bossRoomStorey >= 5) ||
(sSceneNumRooms == 0)) {
return 123;
}
return dungeonMapFloorIconPosY[sMapDisp.bossRoomStorey];
}
s16 MapDisp_GetBossRoomStorey(void) {
return sMapDisp.bossRoomStorey;
}
// TransitionActor params test
s32 MapDisp_IsBossDoor(s32 params) {
if (DOORSHUTTER_PARAMS_GET_TYPE((u16)params) == DOORSHUTTER_TYPE_BOSS_DOOR) {
return true;
}
return false;
}
void MapDisp_InitBossRoomStorey(PlayState* play) {
TransitionActorList* transitionActors = &sTransitionActorList;
s32 storey;
s32 i;
for (i = 0; i < transitionActors->count; i++) {
TransitionActorEntry* entry = &sTransitionActors[i];
if (MapDisp_IsBossDoor(entry->params)) {
if (ABS_ALT(entry->id) != ACTOR_EN_HOLL) {
for (storey = 0; storey < sMapDisp.numStoreys; storey++) {
if (((storey == sMapDisp.numStoreys - 1) && (entry->pos.y >= (sMapDisp.storeyYList[storey] - 5))) ||
((storey != sMapDisp.numStoreys - 1) && (entry->pos.y >= (sMapDisp.storeyYList[storey] - 5)) &&
(entry->pos.y < (sMapDisp.storeyYList[storey + 1] - 5)))) {
sMapDisp.bossRoomStorey = storey;
return;
}
}
}
}
}
sMapDisp.bossRoomStorey = 0;
}
/**
* @brief Initializes the MapData for the current scene
*
* @param play
* @param segmentAddress
*/
void MapDisp_InitMapData(PlayState* play, void* segmentAddress) {
MapDataScene* mapDataScene;
MapDataRoom* mapDataRooms;
s32 i;
if (!Map_IsInBossScene(play)) {
sSceneNumRooms = play->roomList.count;
mapDataScene = Lib_SegmentedToVirtual(segmentAddress);
sMapDataScene = *mapDataScene;
mapDataRooms = Lib_SegmentedToVirtual(mapDataScene->rooms);
for (i = 0; i < sSceneNumRooms; i++) {
sMapDataRooms[i] = *mapDataRooms++;
}
sMapDataScene.rooms = sMapDataRooms;
if (play->colCtx.colHeader != NULL) {
sMapDisp.sceneMinX = play->colCtx.colHeader->minBounds.x;
sMapDisp.sceneMinZ = play->colCtx.colHeader->minBounds.z;
sMapDisp.sceneWidth = play->colCtx.colHeader->maxBounds.x - play->colCtx.colHeader->minBounds.x;
sMapDisp.sceneHeight = play->colCtx.colHeader->maxBounds.z - play->colCtx.colHeader->minBounds.z;
sMapDisp.sceneMidX = sMapDisp.sceneMinX + (sMapDisp.sceneWidth * 0.5f);
sMapDisp.sceneMidZ = sMapDisp.sceneMinZ + (sMapDisp.sceneHeight * 0.5f);
}
}
sMapDisp.mapDataScene = &sMapDataScene;
MapDisp_InitSceneFloorData(play);
MapDisp_InitBossRoomStorey(play);
}
/**
* @brief Creates a deep copy of chest data from the scene data.
*
* @param play
* @param num
* @param segmentAddress
* @note If a boss scene is loaded, no data is copied. This allows the scene to borrow the main dungeon scene data
* instead.
*/
void MapDisp_InitChestData(PlayState* play, s32 num, void* segmentAddress) {
MapDataChest* mapDataChests;
s32 i;
if (!Map_IsInBossScene(play)) {
mapDataChests = Lib_SegmentedToVirtual(segmentAddress);
for (i = 0; i < num; mapDataChests++, i++) {
sMapDataChests[i] = *mapDataChests;
}
sNumChests = num;
}
sMapDisp.mapDataChests = sMapDataChests;
sMapDisp.numChests = sNumChests;
}
/**
* @brief Creates a deep copy of transition actors from the scene data.
*
* @param play
* @param num number of transition actors within the list
* @param transitionActorList pointer to the list of transition actors
* @note If a boss scene is loaded, no data is copied. This allows the scene to borrow the main dungeon scene data
* instead.
*/
void MapDisp_InitTransitionActorData(PlayState* play, s32 num, TransitionActorEntry* transitionActorList) {
s32 i;
if (!Map_IsInBossScene(play)) {
sTransitionActorList.count = num;
for (i = 0; i < num; i++) {
sTransitionActors[i] = transitionActorList[i];
}
sTransitionActorList.list = sTransitionActors;
}
}
void MapDisp_Destroy(PlayState* play) {
s32 i;
sMapDisp.mapDataScene = NULL;
sMapDisp.curRoom = -1;
sMapDisp.minimapCurX = 210;
sMapDisp.minimapCurY = 140;
sMapDisp.minimapCurTex = NULL;
sMapDisp.prevRoom = -1;
sMapDisp.minimapPrevTex = NULL;
sMapDisp.minimapPrevX = 0;
sMapDisp.minimapPrevY = 0;
sMapDisp.unk20 = 0;
sMapDisp.swapAnimTimer = 0;
sMapDisp.texBuff0 = NULL;
sMapDisp.texBuff1 = NULL;
for (i = 0; i < sSceneNumRooms; i++) {
MapDisp_DestroyRoomStoreyRecord(play, &sMapDisp.roomStoreyList[i]);
}
sMapDisp.roomStoreyList = NULL;
sMapDisp.numStoreys = 0;
sMapDisp.pauseMapCurStorey = 0;
sMapDisp.bottomStorey = 0;
sMapDisp.timer = 0;
sMapDisp.storeyYList = NULL;
sMapDisp.numChests = 0;
sMapDisp.mapDataChests = NULL;
MapDisp_DestroyMapI(play);
sMapDisp.unk5A = 0;
}
void MapDisp_Update(PlayState* play) {
PauseContext* pauseCtx = &play->pauseCtx;
s16 currentX;
s16 currentY;
s16 targetX;
s16 targetY;
if ((sMapDisp.mapDataScene != NULL) && (sSceneNumRooms != 0)) {
sMapDisp.pauseMapCurStorey = DUNGEON_FLOOR_INDEX_0 - pauseCtx->cursorMapDungeonItem;
if (sMapDisp.prevRoom != -1) {
if (sMapDisp.swapAnimTimer > 0) {
targetX = sMapDisp.minimapBaseX;
currentX = sMapDisp.minimapCurX;
if (targetX != currentX) {
sMapDisp.minimapCurX =
TRUNCF_BINANG(((f32)(targetX - currentX) / (f32)sMapDisp.swapAnimTimer) + (f32)currentX);
}
targetY = sMapDisp.minimapBaseY;
currentY = sMapDisp.minimapCurY;
if (targetY != currentY) {
sMapDisp.minimapCurY =
TRUNCF_BINANG(((f32)(targetY - currentY) / (f32)sMapDisp.swapAnimTimer) + (f32)currentY);
}
sMapDisp.swapAnimTimer--;
} else {
sMapDisp.prevRoom = -1;
sMapDisp.swapAnimTimer = 0;
sMapDisp.minimapCurX = sMapDisp.minimapBaseX;
sMapDisp.minimapCurY = sMapDisp.minimapBaseY;
}
} else {
sMapDisp.swapAnimTimer = 0;
}
}
}
void MapDisp_SwapRooms(s16 nextRoom) {
MapDataRoom* nextMapDataRoom;
MapDataRoom* prevMapDataRoom;
s32 minimapBaseX;
s32 minimapBaseY;
s32 width;
s32 height;
s32 offsetX;
s32 offsetY;
if ((sMapDisp.mapDataScene != NULL) && (sSceneNumRooms != 0) && (nextRoom != -1)) {
nextMapDataRoom = &sMapDisp.mapDataScene->rooms[nextRoom];
if ((nextMapDataRoom->mapId < MAPDATA_GAMEPLAY_DANGEON_KEEP_MAX) ||
((nextMapDataRoom->mapId >= MAPDATA_MAP_GRAND) && (nextMapDataRoom->mapId < MAPDATA_MAP_GRAND_MAX)) ||
nextMapDataRoom->mapId == MAP_DATA_NO_MAP) {
sMapDisp.prevRoom = sMapDisp.curRoom;
sMapDisp.curRoom = nextRoom;
sMapDisp.swapAnimTimer = 20;
sMapDisp.minimapPrevTex = sMapDisp.minimapCurTex;
minimapBaseX = sMapDisp.minimapBaseX;
minimapBaseY = sMapDisp.minimapBaseY;
nextMapDataRoom = &sMapDisp.mapDataScene->rooms[sMapDisp.curRoom];
if (nextMapDataRoom->mapId == MAP_DATA_NO_MAP) {
sMapDisp.minimapPrevY = 0;
sMapDisp.minimapBaseX = 210;
sMapDisp.minimapBaseY = 140;
sMapDisp.minimapCurX = 210;
sMapDisp.minimapCurY = 140;
sMapDisp.minimapCurTex = NULL;
sMapDisp.minimapPrevX = sMapDisp.minimapPrevY;
return;
}
MapDisp_GetMapOffset(nextMapDataRoom, &offsetX, &offsetY);
MapDisp_GetMapTexDim(nextMapDataRoom, &width, &height);
sMapDisp.minimapBaseX = 295 - width;
sMapDisp.minimapBaseY = 220 - height;
if (sMapDisp.prevRoom != -1) {
prevMapDataRoom = &sMapDisp.mapDataScene->rooms[sMapDisp.prevRoom];
if (prevMapDataRoom->mapId == MAP_DATA_NO_MAP) {
sMapDisp.minimapCurTex = NULL;
sMapDisp.minimapPrevX = sMapDisp.minimapPrevY = 0;
sMapDisp.minimapCurX = sMapDisp.minimapBaseX;
sMapDisp.minimapCurY = sMapDisp.minimapBaseY;
return;
} else {
s32 prevOffsetX;
s32 prevOffsetY;
s32 scale;
s32 pad;
MapDisp_GetMapOffset(prevMapDataRoom, &prevOffsetX, &prevOffsetY);
scale = sMapDisp.mapDataScene->scale;
if (sMapDisp.mapDataScene->scale == 0) {
scale = 20;
} else if (sMapDisp.mapDataScene->scale == -1) {
s32 scaleTemp;
MapDisp_GetMapScale(nextMapDataRoom, &scaleTemp);
scale = scaleTemp;
}
sMapDisp.minimapPrevX =
TRUNCF_BINANG(((f32)offsetX + (((f32)prevMapDataRoom->centerX - (f32)nextMapDataRoom->centerX) *
(1.0f / scale))) -
(f32)prevOffsetX);
sMapDisp.minimapPrevY =
TRUNCF_BINANG(((f32)offsetY + (((f32)prevMapDataRoom->centerZ - (f32)nextMapDataRoom->centerZ) *
(1.0f / scale))) -
(f32)prevOffsetY);
sMapDisp.minimapCurX = minimapBaseX - sMapDisp.minimapPrevX;
sMapDisp.minimapCurY = minimapBaseY - sMapDisp.minimapPrevY;
}
} else {
sMapDisp.minimapPrevX = sMapDisp.minimapPrevY = 0;
sMapDisp.minimapCurX = sMapDisp.minimapBaseX;
sMapDisp.minimapCurY = sMapDisp.minimapBaseY;
}
sMapDisp.minimapCurTex = NULL;
switch (MapData_MID_GetType(nextMapDataRoom->mapId)) {
case MAPDATA_MID_GAMEPLAY_DANGEON_KEEP:
sMapDisp.minimapCurTex = MapData_GetMapTexGameplayDangeonKeep(nextMapDataRoom->mapId);
return;
case MAPDATA_MID_MAP_GRAND_STATIC:
if (sMapDisp.minimapPrevTex == sMapDisp.texBuff0) {
sMapDisp.minimapCurTex = sMapDisp.texBuff1;
} else {
sMapDisp.minimapCurTex = sMapDisp.texBuff0;
}
if (MapData_GetSizeOfMapGrandTex(nextMapDataRoom->mapId) != 0) {
CmpDma_LoadFile(SEGMENT_ROM_START(map_grand_static),
MAPDATA_GET_MAP_GRAND_ID_FROM_MAP_ID(nextMapDataRoom->mapId),
sMapDisp.minimapCurTex, MapData_GetSizeOfMapGrandTex(nextMapDataRoom->mapId));
}
break;
default:
break;
}
}
}
}
void MapDisp_Minimap_DrawRedCompassIcon(PlayState* play, s32 x, s32 z, s32 rot) {
MapDataRoom* mapDataRoom;
s32 posX;
s32 posY;
s32 texOffsetX;
s32 texOffsetY;
s32 texWidth;
s32 texHeight;
s32 scale;
f32 scaleFrac;
mapDataRoom = &sMapDisp.mapDataScene->rooms[sMapDisp.curRoom];
if (mapDataRoom->mapId == MAP_DATA_NO_MAP) {
return;
}
MapDisp_GetMapOffset(mapDataRoom, &texOffsetX, &texOffsetY);
MapDisp_GetMapTexDim(mapDataRoom, &texWidth, &texHeight);
scale = sMapDisp.mapDataScene->scale;
if (sMapDisp.mapDataScene->scale == 0) {
scale = 20;
} else if (sMapDisp.mapDataScene->scale == -1) {
s32 scaleTemp;
MapDisp_GetMapScale(mapDataRoom, &scaleTemp);
scale = scaleTemp;
}
scaleFrac = 1.0f / scale;
if (!MapDisp_IsDataRotated(play)) {
posX = (s32)((x - (f32)mapDataRoom->centerX) * scaleFrac) + sMapDisp.minimapBaseX +
(sMapDisp.minimapCurX - sMapDisp.minimapBaseX) + texOffsetX;
posY = (s32)((z - (f32)mapDataRoom->centerZ) * scaleFrac) + sMapDisp.minimapBaseY +
(sMapDisp.minimapCurY - sMapDisp.minimapBaseY) + texOffsetY;
} else {
posX = -(s32)((x - (f32)mapDataRoom->centerX) * scaleFrac) + sMapDisp.minimapBaseX +
(sMapDisp.minimapCurX - sMapDisp.minimapBaseX) + texOffsetX;
posY = -(s32)((z - (f32)mapDataRoom->centerZ) * scaleFrac) + sMapDisp.minimapBaseY +
(sMapDisp.minimapCurY - sMapDisp.minimapBaseY) + texOffsetY;
}
if ((posX > 0) && (posX < 0x3FF) && (posY > 0) && (posY < 0x3FF)) {
OPEN_DISPS(play->state.gfxCtx);
Gfx_SetupDL42_Overlay(play->state.gfxCtx);
gSPMatrix(OVERLAY_DISP++, &gIdentityMtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gDPSetCombineLERP(OVERLAY_DISP++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
gDPSetEnvColor(OVERLAY_DISP++, 0, 0, 0, 255);
gDPSetCombineMode(OVERLAY_DISP++, G_CC_PRIMITIVE, G_CC_PRIMITIVE);
gDPSetRenderMode(OVERLAY_DISP++, G_RM_AA_DEC_LINE, G_RM_NOOP2);
Matrix_Translate(posX - 160.0f, 120.0f - posY, 0.0f, MTXMODE_NEW);
Matrix_RotateXFApply(-1.6f);
if (MapDisp_IsDataRotated(play)) {
rot += 0x7FFF;
}
Matrix_RotateYF(rot / 10.0f, MTXMODE_APPLY);
Matrix_Scale(0.4f, 0.4f, 0.4f, MTXMODE_APPLY);
MATRIX_FINALIZE_AND_LOAD(OVERLAY_DISP++, play->state.gfxCtx);
gDPSetPrimColor(OVERLAY_DISP++, 0, 255, 200, 0, 0, play->interfaceCtx.minimapAlpha);
gSPDisplayList(OVERLAY_DISP++, gCompassArrowDL);
CLOSE_DISPS(play->state.gfxCtx);
}
}
s32 MapDisp_IsLocationRomaniRanchAltScene(PlayState* play) {
if ((gSaveContext.save.entrance == ENTRANCE(ROMANI_RANCH, 0)) && (Cutscene_GetSceneLayer(play) != 0)) {
return true;
}
return false;
}
s32 MapDisp_CanDisplayMinimap(PlayState* play) {
if ((!Map_CurRoomHasMapI(play) && Inventory_IsMapVisible(play->sceneId)) ||
(Map_CurRoomHasMapI(play) && CHECK_DUNGEON_ITEM(DUNGEON_MAP, gSaveContext.mapIndex))) {
return true;
}
return false;
}
s32 MapDisp_IsLocationMinimapBlocked(PlayState* play) {
if (((play->csCtx.state != CS_STATE_IDLE) && !MapDisp_IsLocationRomaniRanchAltScene(play)) ||
(sMapDisp.unk20 & 2) || Map_IsInBossScene(play)) {
return true;
}
return false;
}
s32 MapDisp_IsMinimapToggleBlocked(PlayState* play) {
if ((MapDisp_IsLocationMinimapBlocked(play) == true) || !MapDisp_CanDisplayMinimap(play)) {
return true;
}
return false;
}
s32 MapDisp_AreRoomsSameStorey(s32 curRoom, s32 prevRoom) {
MapDataRoom* mapDataRoom;
s16* roomStoreyList;
if ((curRoom == -1) || (prevRoom == -1)) {
return false;
}
mapDataRoom = &sMapDisp.mapDataScene->rooms[curRoom];
roomStoreyList = sMapDisp.roomStoreyList;
if ((roomStoreyList[curRoom] <= roomStoreyList[prevRoom]) &&
(roomStoreyList[prevRoom] <= (roomStoreyList[curRoom] + MAP_DATA_ROOM_GET_EXTRA_STOREYS(mapDataRoom)))) {
return true;
}
mapDataRoom = &sMapDisp.mapDataScene->rooms[prevRoom];
if ((roomStoreyList[prevRoom] <= roomStoreyList[curRoom]) &&
(roomStoreyList[curRoom] <= (roomStoreyList[prevRoom] + MAP_DATA_ROOM_GET_EXTRA_STOREYS(mapDataRoom)))) {
return true;
}
return false;
}
void MapDisp_DrawMinimap(PlayState* play, s32 playerInitX, s32 playerInitZ, s32 playerInitDir) {
PauseContext* pauseCtx = &play->pauseCtx;
if ((sMapDisp.mapDataScene != NULL) && ((s32)pauseCtx->state <= PAUSE_STATE_OPENING_2) && !R_MINIMAP_DISABLED &&
(play->interfaceCtx.minimapAlpha != 0)) {
if (!MapDisp_IsLocationMinimapBlocked(play) && (sSceneNumRooms != 0)) {
if (MapDisp_CanDisplayMinimap(play)) {
MapDisp_DrawMinimapRoom(play, sMapDisp.minimapCurTex, sMapDisp.minimapCurX, sMapDisp.minimapCurY,
sMapDisp.curRoom, 1.0f - (sMapDisp.swapAnimTimer * 0.05f));
if ((sMapDisp.curRoom != sMapDisp.prevRoom) &&
MapDisp_AreRoomsSameStorey(sMapDisp.curRoom, sMapDisp.prevRoom)) {
MapDisp_DrawMinimapRoom(play, sMapDisp.minimapPrevTex, sMapDisp.minimapCurX + sMapDisp.minimapPrevX,
sMapDisp.minimapCurY + sMapDisp.minimapPrevY, sMapDisp.prevRoom,
sMapDisp.swapAnimTimer * 0.05f);
}
MapDisp_Minimap_DrawDoorActors(play);
}
if ((!Map_CurRoomHasMapI(play) || CHECK_DUNGEON_ITEM(DUNGEON_COMPASS, gSaveContext.mapIndex)) &&
(Map_CurRoomHasMapI(play) || Inventory_IsMapVisible(play->sceneId))) {
if (play->interfaceCtx.minigameState == MINIGAME_STATE_NONE) {
MapDisp_Minimap_DrawRedCompassIcon(play, playerInitX, playerInitZ, playerInitDir);
}
MapDisp_Minimap_DrawActors(play);
}
}
}
}
void MapDisp_ResetMapI(void) {
s32 i;
sPauseDungeonMap.textureCount = 0;
for (i = 0; i < ROOM_MAX; i++) {
sPauseDungeonMap.mapI_mapCompactId[i] = 0;
sPauseDungeonMap.mapI_roomTextures[i] = NULL;
sPauseDungeonMap.roomSprite[i] = NULL;
}
sPauseDungeonMap.animTimer = 0;
sMapDisp.unk20 &= ~1;
}
void MapDisp_InitMapI(PlayState* play) {
MapDisp_ResetMapI();
}
void MapDisp_DestroyMapI(PlayState* play) {
MapDisp_ResetMapI();
}
// alloc pause screen dungeon map
void* MapDisp_AllocDungeonMap(PlayState* play, void* heap) {
void* heapNext;
s32 dungeonMapRoomIter;
s32 sceneRoomIter;
heapNext = heap;
if ((sMapDisp.mapDataScene == NULL) || (sSceneNumRooms == 0)) {
return heapNext;
}
sPauseDungeonMap.textureCount = 0;
// loop for number of rooms
for (sceneRoomIter = 0; sceneRoomIter < sSceneNumRooms; sceneRoomIter++) {
s32 mapCompactId;
MapDataRoom* mapDataRoom = &sMapDisp.mapDataScene->rooms[sceneRoomIter];
s32 isDuplicateTexture = false;
if (mapDataRoom->mapId == MAP_DATA_NO_MAP) {
continue;
}
mapCompactId = MapData_GetMapCompactId(mapDataRoom->mapId);
if (mapCompactId == -1) {
continue;
}
// test if the texture reference already exists
for (dungeonMapRoomIter = 0; dungeonMapRoomIter < sPauseDungeonMap.textureCount; dungeonMapRoomIter++) {
if (mapCompactId == sPauseDungeonMap.mapI_mapCompactId[dungeonMapRoomIter]) {
isDuplicateTexture = true;
break;
}
}
if (isDuplicateTexture == false) {
sPauseDungeonMap.mapI_mapCompactId[sPauseDungeonMap.textureCount] = mapCompactId;
sPauseDungeonMap.textureCount++;
}
}
// fetch all textures from rom
sPauseDungeonMap.mapI_roomTextures[0] = heap;
for (dungeonMapRoomIter = 0; dungeonMapRoomIter < sPauseDungeonMap.textureCount; dungeonMapRoomIter++) {
s32 mapCompactId = sPauseDungeonMap.mapI_mapCompactId[dungeonMapRoomIter];
MapDisp_GetMapITexture(sPauseDungeonMap.mapI_roomTextures[dungeonMapRoomIter], mapCompactId);
if (dungeonMapRoomIter + 1 < sPauseDungeonMap.textureCount) {
sPauseDungeonMap.mapI_roomTextures[dungeonMapRoomIter + 1] =
(void*)ALIGN16((uintptr_t)sPauseDungeonMap.mapI_roomTextures[dungeonMapRoomIter] +
MapData_CPID_GetSizeOfMapTex(mapCompactId));
} else {
heapNext = (void*)((uintptr_t)sPauseDungeonMap.mapI_roomTextures[dungeonMapRoomIter] +
MapData_CPID_GetSizeOfMapTex(mapCompactId));
}
}
for (sceneRoomIter = 0; sceneRoomIter < sSceneNumRooms; sceneRoomIter++) {
MapDataRoom* mapDataRoom = &sMapDisp.mapDataScene->rooms[sceneRoomIter];
s32 foundTexture = false;
s32 mapCompactId;
if (mapDataRoom->mapId == MAP_DATA_NO_MAP) {
sPauseDungeonMap.roomSprite[sceneRoomIter] = NULL;
} else {
mapCompactId = MapData_GetMapCompactId(mapDataRoom->mapId);
for (dungeonMapRoomIter = 0; dungeonMapRoomIter < sPauseDungeonMap.textureCount; dungeonMapRoomIter++) {
if (mapCompactId == sPauseDungeonMap.mapI_mapCompactId[dungeonMapRoomIter]) {
foundTexture = true;
break;
}
}
if (!foundTexture) {
sPauseDungeonMap.roomSprite[sceneRoomIter] = NULL;
} else {
s32 requiredScopeTemp;
sPauseDungeonMap.roomSprite[sceneRoomIter] = sPauseDungeonMap.mapI_roomTextures[dungeonMapRoomIter];
}
}
}
return heapNext;
}
s32 MapDisp_IsOnStorey(s32 storey, f32 checkY) {
if (storey == 0) {
if ((sMapDisp.storeyYList[0] <= checkY) && ((sMapDisp.numStoreys == 1) || (checkY < sMapDisp.storeyYList[1]))) {
return true;
}
} else if (storey >= (sMapDisp.numStoreys - 1)) {
if (sMapDisp.storeyYList[sMapDisp.numStoreys - 1] <= checkY) {
return true;
}
} else if ((sMapDisp.storeyYList[storey] <= checkY) && (checkY < sMapDisp.storeyYList[storey + 1])) {
return true;
}
return false;
}
s32 MapDisp_ConvertBossSceneToDungeonScene(s32 sceneId) {
switch (sceneId) {
case SCENE_MITURIN_BS:
return SCENE_MITURIN;
case SCENE_HAKUGIN_BS:
return SCENE_HAKUGIN;
case SCENE_SEA_BS:
return SCENE_SEA;
case SCENE_INISIE_BS:
return SCENE_INISIE_N;
default:
return sceneId;
}
}
/**
* @brief Draws the dungeon room sprites for the pause menu dungeon map
*
* @param play
* @param viewX top left x position of the dungeon map view window
* @param viewY top left y posiiton of the dungeon map view window
* @param viewWidth width in pixels of the dungeon map view window
* @param viewHeight height in pixels of the dungeon map view window
* @param scaleFrac ratio to convert world space coordinates to map coordinates
* @param dungeonSceneSharedIndex enum DungeonSceneIndex for retrieving map/compass data
*/
void MapDisp_DrawRooms(PlayState* play, s32 viewX, s32 viewY, s32 viewWidth, s32 viewHeight, f32 scaleFrac,
s32 dungeonSceneSharedIndex) {
static u16 sUnvisitedRoomPal[16] = {
0x0000, 0x0000, 0xFFC1, 0x07C1, 0x07FF, 0x003F, 0xFB3F, 0xF305,
0x0453, 0x0577, 0x0095, 0x82E5, 0xFD27, 0x7A49, 0x94A5, 0x0001,
}; // palette 0
static u16 sVisitedRoomPal[16] = {
0x0000, 0x027F, 0xFFC1, 0x07C1, 0x07FF, 0x003F, 0xFB3F, 0xF305,
0x0453, 0x0577, 0x0095, 0x82E5, 0xFD27, 0x7A49, 0x94A5, 0x0001,
}; // palette 1
static u16 sCurrentRoomPal[16] = {
0x0000, 0x0623, 0xFFC1, 0x07C1, 0x07FF, 0x003F, 0xFB3F, 0xF305,
0x0453, 0x0577, 0x0095, 0x82E5, 0xFD27, 0x7A49, 0x94A5, 0x0001,
}; // palette 2
PauseContext* pauseCtx = &play->pauseCtx;
s32 pad[4];
s32 i;
s32 green = ((sPauseDungeonMap.animTimer * -120.0f / 40.0f) + 200.0f) * 31.0f / 255.0f;
s32 blue = ((sPauseDungeonMap.animTimer * 115.0f / 40.0f) + 140.0f) * 31.0f / 255.0f;
sCurrentRoomPal[1] = (green << 6) | (blue << 1) | 1;
if (CHECK_DUNGEON_ITEM(DUNGEON_MAP, dungeonSceneSharedIndex)) {
s32 requiredScopeTemp;
sUnvisitedRoomPal[15] = 0xAD5F;
sVisitedRoomPal[15] = 0xAD5F;
sCurrentRoomPal[15] = 0xAD5F;
} else {
sCurrentRoomPal[15] = sVisitedRoomPal[15] = sUnvisitedRoomPal[15] = 0;
}
OPEN_DISPS(play->state.gfxCtx);
Gfx_SetupDL39_Opa(play->state.gfxCtx);
gDPSetPrimColor(POLY_OPA_DISP++, 0, 0, 255, 255, 255, pauseCtx->alpha);
gDPLoadTLUT_pal16(POLY_OPA_DISP++, 0, sUnvisitedRoomPal);
gDPLoadTLUT_pal16(POLY_OPA_DISP++, 1, sVisitedRoomPal);
gDPLoadTLUT_pal16(POLY_OPA_DISP++, 2, sCurrentRoomPal);
gDPSetTextureLUT(POLY_OPA_DISP++, G_TT_RGBA16);
for (i = 0; i < sSceneNumRooms; i++) {
s32 texWidth;
s32 texHeight;
s32 offsetX;
s32 offsetY;
MapDataRoom* mapDataRoom;
TexturePtr roomTexture;
s32 s;
s32 t;
s32 dsdx;
s32 dtdy;
s32 texPosX;
s32 texPosY;
s32 spE8;
s32 two = 2;
mapDataRoom = &sMapDisp.mapDataScene->rooms[i];
if ((mapDataRoom->mapId == MAP_DATA_NO_MAP) || (mapDataRoom->mapId >= MAPDATA_MAP_GRAND_MAX)) {
continue;
}
if ((sMapDisp.pauseMapCurStorey < sMapDisp.roomStoreyList[i]) ||
((sMapDisp.roomStoreyList[i] + MAP_DATA_ROOM_GET_EXTRA_STOREYS(mapDataRoom)) <
sMapDisp.pauseMapCurStorey)) {
continue;
}
roomTexture = sPauseDungeonMap.roomSprite[i];
if (roomTexture == NULL) {
continue;
}
spE8 = MapData_GetMapCompactId(mapDataRoom->mapId);
if (spE8 == -1) {
continue;
}
MapData_CPID_GetTexDim(spE8, &texWidth, &texHeight);
MapData_CPID_GetTexOffset(spE8, &offsetX, &offsetY);
if (mapDataRoom->flags & MAP_DATA_ROOM_FLIP_X) {
offsetX = ((texWidth / 2) - offsetX) + (texWidth / 2);
s = (texWidth - 1) << 5;
dsdx = 0xFC00;
} else {
s = 0;
dsdx = 0x400;
}
if (mapDataRoom->flags & MAP_DATA_ROOM_FLIP_Y) {
s32 requiredScopeTemp;
offsetY = ((texHeight / 2) - offsetY) + (texHeight / 2);
t = (texHeight - 1) << 5;
dtdy = 0xFC00;
} else {
t = 0;
dtdy = 0x400;
}
texPosX =
((mapDataRoom->centerX - (f32)sMapDisp.sceneMidX) * scaleFrac - offsetX) + ((viewWidth / two) + viewX);
texPosY =
((mapDataRoom->centerZ - (f32)sMapDisp.sceneMidZ) * scaleFrac - offsetY) + ((viewHeight / two) + viewY);
if (i == play->roomCtx.curRoom.num) {
if (Map_IsInBossScene(play)) {
gDPLoadTextureBlock_4b(POLY_OPA_DISP++, roomTexture, G_IM_FMT_CI, texWidth, texHeight, 1,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
G_TX_NOLOD, G_TX_NOLOD);
} else {
gDPLoadTextureBlock_4b(POLY_OPA_DISP++, roomTexture, G_IM_FMT_CI, texWidth, texHeight, 2,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
G_TX_NOLOD, G_TX_NOLOD);
}
} else if (GET_ROOM_VISITED(Play_GetOriginalSceneId(MapDisp_ConvertBossSceneToDungeonScene(play->sceneId)),
i)) {
gDPLoadTextureBlock_4b(POLY_OPA_DISP++, roomTexture, G_IM_FMT_CI, texWidth, texHeight, 1,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
G_TX_NOLOD, G_TX_NOLOD);
} else if (CHECK_DUNGEON_ITEM(DUNGEON_MAP, dungeonSceneSharedIndex)) {
gDPLoadTextureBlock_4b(POLY_OPA_DISP++, roomTexture, G_IM_FMT_CI, texWidth, texHeight, 0,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
G_TX_NOLOD, G_TX_NOLOD);
} else {
continue;
}
gSPTextureRectangle(POLY_OPA_DISP++, (texPosX << 2), (texPosY << 2), (texPosX + texWidth) << 2,
(texPosY + texHeight) << 2, 0, s, t, dsdx, dtdy);
gDPPipeSync(POLY_OPA_DISP++);
}
gDPSetTextureLUT(POLY_OPA_DISP++, G_TT_NONE);
CLOSE_DISPS(play->state.gfxCtx);
}
/**
* @brief Draws the chests for the pause menu dungeon map
*
* @param play
* @param viewX top left x position of the dungeon map view window
* @param viewY top left y posiiton of the dungeon map view window
* @param viewWidth width in pixels of the dungeon map view window
* @param viewHeight height in pixels of the dungeon map view window
* @param scaleFrac ratio to convert world space coordinates to map coordinates
* @param dungeonSceneSharedIndex enum DungeonSceneIndex for retrieving map/compass data
*/
void MapDisp_DrawChests(PlayState* play, s32 viewX, s32 viewY, s32 viewWidth, s32 viewHeight, f32 scaleFrac) {
s32 pad[23];
MapDataChest* mapDataChests = sMapDisp.mapDataChests;
s32 room;
MapDataRoom* mapDataRoom;
s32 texPosX;
s32 texPosY;
s32 i;
s32 isChestOpen;
s32 offsetX = 4;
s32 offsetZ = 4;
if (mapDataChests == NULL) {
return;
}
OPEN_DISPS(play->state.gfxCtx);
gDPPipeSync(POLY_OPA_DISP++);
gDPSetTextureLUT(POLY_OPA_DISP++, G_TT_NONE);
gDPSetPrimColor(POLY_OPA_DISP++, 0, 0, 255, 255, 255, play->pauseCtx.alpha);
gDPSetEnvColor(POLY_OPA_DISP++, 0, 0, 0, 255);
gDPPipeSync(POLY_OPA_DISP++);
gDPLoadTextureBlock_Runtime(POLY_OPA_DISP++, gMapChestIconTex, G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 8, 0,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
G_TX_NOLOD, G_TX_NOLOD);
for (i = 0; i < sMapDisp.numChests; i++) {
room = mapDataChests[i].room;
mapDataRoom = &sMapDisp.mapDataScene->rooms[room];
switch (play->sceneId) {
case SCENE_MITURIN_BS:
isChestOpen = GET_CYCLE_CHEST_OPENED(SCENE_MITURIN, mapDataChests[i].chestFlagId);
break;
case SCENE_HAKUGIN_BS:
isChestOpen = GET_CYCLE_CHEST_OPENED(SCENE_HAKUGIN, mapDataChests[i].chestFlagId);
break;
case SCENE_SEA_BS:
isChestOpen = GET_CYCLE_CHEST_OPENED(SCENE_SEA, mapDataChests[i].chestFlagId);
break;
case SCENE_INISIE_BS:
isChestOpen = GET_CYCLE_CHEST_OPENED(SCENE_INISIE_N, mapDataChests[i].chestFlagId);
break;
default:
isChestOpen = Flags_GetTreasure(play, mapDataChests[i].chestFlagId);
break;
}
if ((sMapDisp.pauseMapCurStorey < sMapDisp.roomStoreyList[room]) ||
((sMapDisp.roomStoreyList[room] + MAP_DATA_ROOM_GET_EXTRA_STOREYS(mapDataRoom)) <
sMapDisp.pauseMapCurStorey) ||
(isChestOpen != 0)) {
continue;
}
if (!MapDisp_IsOnStorey((s32)sMapDisp.pauseMapCurStorey, (f32)mapDataChests[i].y)) {
continue;
}
texPosX =
(s32)((((mapDataChests[i].x - (f32)sMapDisp.sceneMidX) * scaleFrac) - offsetX) + ((viewWidth / 2) + viewX));
texPosY = (s32)((((mapDataChests[i].z - (f32)sMapDisp.sceneMidZ) * scaleFrac) - offsetZ) +
((viewHeight / 2) + viewY));
gSPTextureRectangle(POLY_OPA_DISP++, texPosX << 2, texPosY << 2, (texPosX + 8) << 2, (texPosY + 8) << 2,
G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
}
CLOSE_DISPS(play->state.gfxCtx);
}
/**
* @brief Draws the room exit points for the pause menu dungeon map
*
* @param play
* @param viewX top left x position of the dungeon map view window
* @param viewY top left y posiiton of the dungeon map view window
* @param viewWidth width in pixels of the dungeon map view window
* @param viewHeight height in pixels of the dungeon map view window
* @param scaleFrac ratio to convert world space coordinates to map coordinates
* @param dungeonSceneSharedIndex enum DungeonSceneIndex for retrieving map/compass data
*/
void MapDisp_DrawRoomExits(PlayState* play, s32 viewX, s32 viewY, s32 viewWidth, s32 viewHeight, f32 scaleFrac,
s32 dungeonSceneSharedIndex) {
PauseContext* pauseCtx = &play->pauseCtx;
TransitionActorList* transitionActors = &sTransitionActorList;
s32 texPosX;
s32 texPosY;
s32 i;
s8 roomA;
s8 roomB;
if (transitionActors->count != 0) {
OPEN_DISPS(play->state.gfxCtx);
gDPSetCombineMode(POLY_OPA_DISP++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
gDPLoadTextureBlock_4b(POLY_OPA_DISP++, &sWhiteSquareTex, G_IM_FMT_I, 16, 16, 0, G_TX_NOMIRROR | G_TX_WRAP,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
for (i = 0; i < transitionActors->count; i++) {
if (MapDisp_IsOnStorey(sMapDisp.pauseMapCurStorey, sTransitionActors[i].pos.y)) {
if ((ABS_ALT(sTransitionActors[i].id) != ACTOR_EN_HOLL) &&
!MapDisp_IsBossDoor(sTransitionActors[i].params)) {
roomA = sTransitionActors[i].sides[0].room;
roomB = sTransitionActors[i].sides[1].room;
if (CHECK_DUNGEON_ITEM(DUNGEON_MAP, gSaveContext.mapIndex) || (roomA < 0) ||
GET_ROOM_VISITED(Play_GetOriginalSceneId(MapDisp_ConvertBossSceneToDungeonScene(play->sceneId)),
roomA) ||
(roomB < 0) ||
GET_ROOM_VISITED(Play_GetOriginalSceneId(MapDisp_ConvertBossSceneToDungeonScene(play->sceneId)),
roomB)) {
gDPSetPrimColor(POLY_OPA_DISP++, 0, 0, 255, 255, 255, pauseCtx->alpha);
texPosX = ((f32)sTransitionActors[i].pos.x - sMapDisp.sceneMidX) * scaleFrac +
((viewWidth / 2) + viewX);
texPosY = ((f32)sTransitionActors[i].pos.z - sMapDisp.sceneMidZ) * scaleFrac +
((viewHeight / 2) + viewY);
gSPTextureRectangle(POLY_OPA_DISP++, ((texPosX - 1) << 2), ((texPosY - 1) << 2),
((texPosX + 1) << 2), ((texPosY + 1) << 2), G_TX_RENDERTILE, 0, 0, 1 << 10,
1 << 10);
}
}
}
}
CLOSE_DISPS(play->state.gfxCtx);
}
}
/**
* @brief Draws the boss room icon for the pause menu dungeon map.
*
* @param play
* @param viewX top left x position of the dungeon map view window
* @param viewY top left y posiiton of the dungeon map view window
* @param viewWidth width in pixels of the dungeon map view window
* @param viewHeight height in pixels of the dungeon map view window
* @param scaleFrac ratio to convert world space coordinates to map coordinates
* @param dungeonSceneSharedIndex enum DungeonSceneIndex for retrieving map/compass data
*/
void MapDisp_DrawBossIcon(PlayState* play, s32 viewX, s32 viewY, s32 viewWidth, s32 viewHeight, f32 scaleFrac,
s32 dungeonSceneSharedIndex) {
s32 i;
TransitionActorList* transitionActorList = &sTransitionActorList;
s32 offsetX = 4;
s32 offsetZ = 4;
s32 texPosX;
s32 texPosY;
OPEN_DISPS(play->state.gfxCtx);
gDPPipeSync(POLY_OPA_DISP++);
gDPSetTextureLUT(POLY_OPA_DISP++, G_TT_NONE);
gDPSetRenderMode(POLY_OPA_DISP++, G_RM_AA_DEC_LINE, G_RM_NOOP2);
gDPSetPrimColor(POLY_OPA_DISP++, 0, 0, 255, 255, 255, play->pauseCtx.alpha);
gDPSetEnvColor(POLY_OPA_DISP++, 0, 0, 0, 255);
gDPPipeSync(POLY_OPA_DISP++);
if (CHECK_DUNGEON_ITEM(DUNGEON_COMPASS, dungeonSceneSharedIndex)) {
gDPLoadTextureBlock_Runtime(POLY_OPA_DISP++, gMapBossIconTex, G_IM_FMT_IA, G_IM_SIZ_8b, 8, 8, 0,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
G_TX_NOLOD, G_TX_NOLOD);
for (i = 0; i < transitionActorList->count; i++) {
if (!MapDisp_IsBossDoor(sTransitionActors[i].params)) {
continue;
}
if (!MapDisp_IsOnStorey(sMapDisp.pauseMapCurStorey, sTransitionActors[i].pos.y)) {
continue;
}
if (ABS_ALT(sTransitionActors[i].id) == ACTOR_EN_HOLL) {
continue;
}
texPosX = ((((f32)sTransitionActors[i].pos.x - sMapDisp.sceneMidX) * scaleFrac) - offsetX) +
((viewWidth / 2) + viewX);
texPosY = ((((f32)sTransitionActors[i].pos.z - sMapDisp.sceneMidZ) * scaleFrac) - offsetZ) +
((viewHeight / 2) + viewY);
gSPTextureRectangle(POLY_OPA_DISP++, texPosX << 2, texPosY << 2, (texPosX + 8) << 2, (texPosY + 8) << 2,
G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
}
}
CLOSE_DISPS(play->state.gfxCtx);
}
TexturePtr MapDisp_GetDungeonMapFloorTexture(s32 floorNumber) {
static TexturePtr sDungeonMapFloorTextures[] = {
gDungeonMap1FButtonTex, gDungeonMap2FButtonTex, gDungeonMap3FButtonTex, gDungeonMap4FButtonTex,
gDungeonMap5FButtonTex, gDungeonMap6FButtonTex, gDungeonMap7FButtonTex, gDungeonMap8FButtonTex,
gDungeonMapB1ButtonTex, gDungeonMapB2ButtonTex, gDungeonMapB3ButtonTex, gDungeonMapB4ButtonTex,
gDungeonMapB5ButtonTex, gDungeonMapB6ButtonTex, gDungeonMapB7ButtonTex, gDungeonMapB8ButtonTex,
};
if ((floorNumber >= 0) && (floorNumber < 8)) {
return sDungeonMapFloorTextures[floorNumber];
}
if ((floorNumber >= -8) && (floorNumber < 0)) {
return sDungeonMapFloorTextures[7 + -floorNumber];
}
return gDungeonMapBlankFloorButtonTex;
}
/**
* @brief Tests if the dungeon map on the Map screen should be drawn.
*
* @param play
* @return true if the map should be drawn, else false.
*/
s32 MapDisp_SkipDrawDungeonMap(PlayState* play) {
PauseContext* pauseCtx = &play->pauseCtx;
if (pauseCtx->pageIndex != PAUSE_MAP) {
return true;
}
if ((pauseCtx->state == PAUSE_STATE_SAVEPROMPT) || IS_PAUSE_STATE_GAMEOVER(pauseCtx)) {
return true;
}
if ((pauseCtx->state != PAUSE_STATE_MAIN) || (pauseCtx->mainState != PAUSE_MAIN_STATE_IDLE)) {
return true;
}
if (pauseCtx->alpha == 0) {
return true;
}
return false;
}
void MapDisp_DrawDungeonFloorSelect(PlayState* play) {
PauseContext* pauseCtx = &play->pauseCtx;
s32 texULY;
s32 texLRY;
s16 texULX;
s16 texLRX;
s32 pad;
s32 storey;
s32 dungeonSceneSharedIndex = 0;
if ((sMapDisp.mapDataScene != NULL) && (sSceneNumRooms != 0) && !MapDisp_SkipDrawDungeonMap(play)) {
if (Map_IsInBossScene(play)) {
switch (play->sceneId) {
case SCENE_MITURIN_BS:
dungeonSceneSharedIndex = DUNGEON_SCENE_INDEX_WOODFALL_TEMPLE;
break;
case SCENE_HAKUGIN_BS:
dungeonSceneSharedIndex = DUNGEON_SCENE_INDEX_SNOWHEAD_TEMPLE;
break;
case SCENE_SEA_BS:
dungeonSceneSharedIndex = DUNGEON_SCENE_INDEX_GREAT_BAY_TEMPLE;
break;
case SCENE_INISIE_BS:
dungeonSceneSharedIndex = DUNGEON_SCENE_INDEX_STONE_TOWER_TEMPLE;
break;
default:
break;
}
} else {
dungeonSceneSharedIndex = gSaveContext.mapIndex;
}
OPEN_DISPS(play->state.gfxCtx);
Gfx_SetupDL39_Opa(play->state.gfxCtx);
gDPSetCombineMode(POLY_OPA_DISP++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
gDPSetPrimColor(POLY_OPA_DISP++, 0, 0, 255, 255, 200, pauseCtx->alpha);
// Draw unlocked storeys
for (storey = 0; storey < sMapDisp.numStoreys; storey++) {
if (GET_DUNGEON_FLOOR_VISITED(
Play_GetOriginalSceneId(MapDisp_ConvertBossSceneToDungeonScene(play->sceneId)), 4 - storey) ||
CHECK_DUNGEON_ITEM_ALT(DUNGEON_MAP, dungeonSceneSharedIndex)) {
gDPLoadTextureBlock(POLY_OPA_DISP++, MapDisp_GetDungeonMapFloorTexture(sMapDisp.bottomStorey + storey),
G_IM_FMT_IA, G_IM_SIZ_8b, 24, 16, 0, G_TX_NOMIRROR | G_TX_WRAP,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
gSPTextureRectangle(POLY_OPA_DISP++, 81 << 2, (125 - storey * 15) << 2, 105 << 2,
((125 - storey * 15) + 16) << 2, G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
}
}
gDPPipeSync(POLY_OPA_DISP++);
// Draw currently selected storey
gDPSetPrimColor(POLY_OPA_DISP++, 0, 0, 150, 150, 255, pauseCtx->alpha);
gDPLoadTextureBlock(
POLY_OPA_DISP++,
MapDisp_GetDungeonMapFloorTexture((sMapDisp.bottomStorey - pauseCtx->cursorMapDungeonItem) + 8),
G_IM_FMT_IA, G_IM_SIZ_8b, 24, 16, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
texULX = 80;
texLRX = 106;
texULY = (5 + (pauseCtx->cursorMapDungeonItem * 0xF));
texLRY = texULY + 16;
if ((pauseCtx->cursorSpecialPos == 0) && (pauseCtx->cursorXIndex[1] == 0)) {
texLRX++;
texULX--;
texLRY += 4;
texULY -= 4;
gSPTextureRectangle(POLY_OPA_DISP++, texULX << 2, texULY << 2, texLRX << 2, (texLRY) << 2, G_TX_RENDERTILE,
0, 0, 0x036E, 0x02AA);
} else {
gSPTextureRectangle(POLY_OPA_DISP++, (texULX + 1) << 2, texULY << 2, (texLRX - 1) << 2, texLRY << 2,
G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
}
Gfx_SetupDL42_Opa(play->state.gfxCtx);
CLOSE_DISPS(play->state.gfxCtx);
}
}
s32 MapDisp_IsValidStorey(s32 storey) {
if ((sMapDisp.mapDataScene == NULL) || (sSceneNumRooms == 0)) {
return false;
}
if ((storey < 0) || (storey > 5)) {
return false;
}
if (sMapDisp.storeyYList[storey] != FLOOR_MIN_Y) {
return true;
}
return false;
}
s32 MapDisp_GetPlayerStorey(s16 checkY) {
s32 i;
if ((sMapDisp.mapDataScene == NULL) || (sSceneNumRooms == 0)) {
return -1;
}
if (sMapDisp.numStoreys <= 1) {
return 0;
}
if ((sMapDisp.storeyYList[1] - 5) >= checkY) {
return 0;
}
for (i = 1; i < sMapDisp.numStoreys; i++) {
if (((sMapDisp.storeyYList[i] - 5) < checkY) && ((sMapDisp.storeyYList[i + 1] - 5) >= checkY)) {
return i;
}
}
return sMapDisp.numStoreys - 1;
}
typedef struct {
/* 0x0 */ s16 sceneId;
/* 0x4 */ s32 offsetX;
/* 0x8 */ s32 offsetY;
} MapCustomPosOffset; // size = 0xC
/**
* Draws the dungeon map within the pause menu's Map screen.
*
* @param play
*/
void MapDisp_DrawDungeonMap(PlayState* play) {
static MapCustomPosOffset sCustomMapOffset[] = {
{ SCENE_MITURIN, 0, -10 },
{ SCENE_MITURIN_BS, 0, -10 },
};
MapDataRoom* mapDataRoom;
f32 scaleFrac;
s32 scale;
s32 var_v0;
s32 dungeonSceneSharedIndex = 0;
s32 offsetX = 0;
s32 offsetY = 0;
if (MapDisp_SkipDrawDungeonMap(play)) {
return;
}
if (Map_IsInBossScene(play)) {
switch (play->sceneId) {
case SCENE_MITURIN_BS:
dungeonSceneSharedIndex = DUNGEON_SCENE_INDEX_WOODFALL_TEMPLE;
break;
case SCENE_HAKUGIN_BS:
dungeonSceneSharedIndex = DUNGEON_SCENE_INDEX_SNOWHEAD_TEMPLE;
break;
case SCENE_SEA_BS:
dungeonSceneSharedIndex = DUNGEON_SCENE_INDEX_GREAT_BAY_TEMPLE;
break;
case SCENE_INISIE_BS:
dungeonSceneSharedIndex = DUNGEON_SCENE_INDEX_STONE_TOWER_TEMPLE;
break;
default:
break;
}
} else {
dungeonSceneSharedIndex = gSaveContext.mapIndex;
}
mapDataRoom = sMapDisp.mapDataScene->rooms;
if ((mapDataRoom->mapId == MAP_DATA_NO_MAP) || (mapDataRoom->mapId >= MAPDATA_MAP_GRAND_MAX)) {
return;
}
var_v0 = MapData_GetMapCompactId(mapDataRoom->mapId);
if (var_v0 == -1) {
return;
}
scale = MapData_CPID_GetMapScale(var_v0);
if (scale == 0) {
scale = 80;
}
for (var_v0 = 0; var_v0 < ARRAY_COUNT(sCustomMapOffset); var_v0++) {
if (play->sceneId == sCustomMapOffset[var_v0].sceneId) {
offsetX = sCustomMapOffset[var_v0].offsetX;
offsetY = sCustomMapOffset[var_v0].offsetY;
}
}
scaleFrac = 1.0f / scale;
MapDisp_DrawRooms(play, offsetX + 144, offsetY + 85, 120, 100, scaleFrac, dungeonSceneSharedIndex);
MapDisp_DrawRoomExits(play, offsetX + 144, offsetY + 85, 120, 100, scaleFrac, dungeonSceneSharedIndex);
MapDisp_DrawBossIcon(play, offsetX + 144, offsetY + 85, 120, 100, scaleFrac, dungeonSceneSharedIndex);
if (CHECK_DUNGEON_ITEM(DUNGEON_COMPASS, dungeonSceneSharedIndex)) {
MapDisp_DrawChests(play, offsetX + 144, offsetY + 85, 120, 100, scaleFrac);
}
}
void MapDisp_UpdateDungeonMap(PlayState* play) {
sMapDisp.timer++;
if (!(sMapDisp.unk20 & 1)) {
sPauseDungeonMap.animTimer++;
if (sPauseDungeonMap.animTimer > 40) {
sMapDisp.unk20 |= 1;
}
} else {
sPauseDungeonMap.animTimer--;
if (sPauseDungeonMap.animTimer < 0) {
sMapDisp.unk20 &= ~1;
}
}
}
Reference in New Issue View Git Blame Copy Permalink