mirror of https://github.com/zeldaret/tp.git
2997 lines
108 KiB
C++
2997 lines
108 KiB
C++
#include "d/dolzel.h" // IWYU pragma: keep
|
|
|
|
#include "d/d_menu_fmap2D.h"
|
|
#include "JSystem/J2DGraph/J2DAnmLoader.h"
|
|
#include "JSystem/J2DGraph/J2DOrthoGraph.h"
|
|
#include "JSystem/J2DGraph/J2DScreen.h"
|
|
#include "JSystem/JKernel/JKRExpHeap.h"
|
|
#include "JSystem/JUtility/JUTTexture.h"
|
|
#include "SSystem/SComponent/c_math.h"
|
|
#include "d/actor/d_a_player.h"
|
|
#include "d/d_com_inf_game.h"
|
|
#include "d/d_lib.h"
|
|
#include "d/d_menu_fmap.h"
|
|
#include "d/d_meter2_info.h"
|
|
#include "d/d_meter_HIO.h"
|
|
#include "d/d_msg_class.h"
|
|
#include "d/d_msg_scrn_explain.h"
|
|
#include "m_Do/m_Do_graphic.h"
|
|
#include "d/actor/d_a_midna.h"
|
|
|
|
dMenu_Fmap2DBack_c::dMenu_Fmap2DBack_c() {
|
|
dMeter2Info_setMapDrugFlag(0);
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
mpAreaTex[i] = NULL;
|
|
mRegionMinMapX[i] = 0.0;
|
|
mRegionMinMapY[i] = 0.0;
|
|
mRegionMapSizeX[i] = 0.0;
|
|
mRegionMapSizeY[i] = 0.0;
|
|
field_0xf0c[i] = 0.0;
|
|
field_0xf2c[i] = 0.0;
|
|
field_0xf4c[i] = 0.0;
|
|
field_0xf6c[i] = 0.0;
|
|
mRegionOriginX[i] = 0.0;
|
|
mRegionOriginZ[i] = 0.0;
|
|
mRegionTexData[i].mMinX = 0.0;
|
|
mRegionTexData[i].mMinZ = 0.0;
|
|
mRegionTexData[i].mMaxX = 0.0;
|
|
mRegionTexData[i].mMaxZ = 0.0;
|
|
mRegionTexData[i].mScale = 0.0;
|
|
mRegionTextureReadNum[i] = 0xff;
|
|
field_0x1230[i] = 0xff;
|
|
mRegionScrollMinX[i] = 0.0;
|
|
mRegionScrollMinZ[i] = 0.0;
|
|
mRegionScrollMaxX[i] = 0.0;
|
|
mRegionScrollMaxZ[i] = 0.0;
|
|
mRegionScrollMapMinX[i] = 0.0;
|
|
mRegionScrollMapMinY[i] = 0.0;
|
|
mRegionScrollMapMaxX[i] = 0.0;
|
|
mRegionScrollMapMaxY[i] = 0.0;
|
|
}
|
|
|
|
for (int i = 0; i < 20; i++) {
|
|
mStageOriginX[i] = 0.0;
|
|
mStageOriginZ[i] = 0.0;
|
|
mStageOriginPathX[i] = 0.0;
|
|
mStageOriginPathZ[i] = 0.0;
|
|
}
|
|
|
|
mpStages = NULL;
|
|
mTexMinX = 0.0;
|
|
mTexMinZ = 0.0;
|
|
mTexMaxX = 0.0;
|
|
mTexMaxZ = 0.0;
|
|
mAllMapScaleRate = 0.0;
|
|
mWorldMinX = 0.0;
|
|
mWorldMinZ = 0.0;
|
|
mWorldMaxX = 0.0;
|
|
mWorldMaxZ = 0.0;
|
|
field_0x1184 = 0.0;
|
|
field_0x1188 = 0.0;
|
|
mRenderingPosX = 0.0;
|
|
mRenderingPosZ = 0.0;
|
|
mRenderingScale = 1.0;
|
|
field_0xf98 = 1.0;
|
|
mMapZoomRate = 0.0;
|
|
mZoom = getAllMapZoomRate();
|
|
field_0xfa4 = 1.0;
|
|
field_0xfa8 = 0.0;
|
|
mpBackTex = NULL;
|
|
mpSpotTexture = NULL;
|
|
mTransX = 0.0;
|
|
mTransZ = 0.0;
|
|
mAlphaRate = 0.0;
|
|
mpMenuFmapMap = NULL;
|
|
mpMeterHaihai = NULL;
|
|
field_0x122d = 0;
|
|
field_0x122e = false;
|
|
mSpotNum = 0;
|
|
mStageDataNum = 0;
|
|
mStageTransX = 0.0;
|
|
mStageTransZ = 0.0;
|
|
field_0xfd0 = 0.0;
|
|
field_0xfd4 = 0.0;
|
|
field_0xfd8 = 0.0;
|
|
field_0xfdc = 0.0;
|
|
control_xpos = 0.0;
|
|
control_ypos = 0.0;
|
|
field_0x11b4 = 0.0;
|
|
field_0x11b8 = 0.0;
|
|
field_0x11bc = 0.0;
|
|
field_0x11c0 = 0.0;
|
|
field_0x11c4 = 0.0;
|
|
field_0x11c8 = 0.0;
|
|
field_0x11cc = 0.0;
|
|
field_0x11d0 = 0.0;
|
|
mRegionFlag = 0;
|
|
mMapDrawFlag = false;
|
|
field_0x1238 = 0;
|
|
field_0x1218 = 0;
|
|
field_0x121a = 0;
|
|
mSelectRegion = 0xff;
|
|
mRegionCursor = 0;
|
|
field_0x1228 = 0;
|
|
mSpotCursor = 0;
|
|
field_0x122a = 0;
|
|
field_0x122b = 1;
|
|
field_0xfb0 = 0.0;
|
|
field_0xfb4 = 0.0;
|
|
field_0xfb8 = 1.0;
|
|
mArrowPos3DX = mArrowPos3DZ = mArrowAlpha = 0.0;
|
|
field_0x11a4 = field_0x11a8 = 0.0;
|
|
field_0x11ac = field_0x11b0 = 0.0;
|
|
mArrowPos2DX = mArrowPos2DY = 0.0;
|
|
mSpotTextureFadeAlpha = 0.0;
|
|
field_0x11dc = 0.0;
|
|
field_0x11e0 = 360.0;
|
|
mBackAlpha = 0.0;
|
|
field_0x11e8 = 0.0;
|
|
field_0x11ec = 0.0;
|
|
|
|
mSelectedRegionBlack.set(0, 0, 0, 0);
|
|
mSelectedRegionWhite.set(255, 255, 255, 255);
|
|
mUnselectedRegionBlack.set(0, 0, 0, 0);
|
|
mUnselectedRegionWhite.set(255, 255, 255, 255);
|
|
mUnreachedRegionBlack.set(0, 0, 0, 0);
|
|
mUnreachedRegionWhite.set(0, 0, 0, 255);
|
|
field_0x1208.set(0, 0, 0, 0);
|
|
field_0x120c.set(0, 0, 0, 255);
|
|
|
|
field_0x1210 = 1.0;
|
|
field_0x1214 = 1.0;
|
|
mArrowDrawFlag = true;
|
|
|
|
#if DEBUG
|
|
mAllPathShowFlag = g_fmapHIO.mDisplayAllPaths;
|
|
#else
|
|
mAllPathShowFlag = false;
|
|
#endif
|
|
|
|
initiate(dComIfGp_getFmapResArchive());
|
|
|
|
mpBackScreen = new J2DScreen();
|
|
JUT_ASSERT(238, mpBackScreen != NULL);
|
|
|
|
bool fg = mpBackScreen->setPriority("zelda_map_screen_stone_base.blo", 0x20000,
|
|
dComIfGp_getFmapResArchive());
|
|
JUT_ASSERT(242, fg != false);
|
|
|
|
dPaneClass_showNullPane(mpBackScreen);
|
|
|
|
mpBaseScreen = new J2DScreen();
|
|
JUT_ASSERT(248, mpBaseScreen != NULL)
|
|
|
|
fg = mpBaseScreen->setPriority("zelda_map_screen_base.blo", 0x20000,
|
|
dComIfGp_getFmapResArchive());
|
|
JUT_ASSERT(252, fg != false);
|
|
|
|
dPaneClass_showNullPane(mpBaseScreen);
|
|
|
|
void* r = JKRGetNameResource("zelda_map_screen_base.btk", dComIfGp_getFmapResArchive());
|
|
mpBaseAnm = (J2DAnmTextureSRTKey*)J2DAnmLoaderDataBase::load(r);
|
|
mpBaseAnm->searchUpdateMaterialID(mpBaseScreen);
|
|
|
|
mAnmFrame = 0.0;
|
|
|
|
mpBaseRoot = new CPaneMgrAlphaMorf(mpBaseScreen, 'ROOT', 2, NULL);
|
|
JUT_ASSERT(264, mpBaseRoot != NULL);
|
|
|
|
mpMapArea = new CPaneMgr(mpBaseScreen, 'center_n', 0, NULL);
|
|
JUT_ASSERT(269, mpMapArea != NULL);
|
|
|
|
mpMapBlack = new CPaneMgr(mpBaseScreen, 'map_blak', 0, NULL);
|
|
JUT_ASSERT(273, mpMapBlack != NULL);
|
|
|
|
mpMeterHaihai = new dMeterHaihai_c(1);
|
|
JUT_ASSERT(277, mpMeterHaihai != NULL);
|
|
|
|
ResTIMG* backTexResource =
|
|
(ResTIMG*)dComIfGp_getMain2DArchive()->getResource('TIMG', "tt_block8x8.bti");
|
|
mpBackTex = new J2DPicture(backTexResource);
|
|
JUT_ASSERT(282, mpBackTex != NULL);
|
|
|
|
mpBackTex->setBlackWhite(JUtility::TColor(0, 0, 0, 0), JUtility::TColor(0, 0, 0, 255));
|
|
mpBackTex->setAlpha(0);
|
|
|
|
mpPointScreen = new J2DScreen();
|
|
JUT_ASSERT(293, mpPointScreen != NULL);
|
|
|
|
mpPointScreen->setPriority("zelda_field_map_point_cursor.blo", 0x20000,
|
|
dComIfGp_getFmapResArchive());
|
|
JUT_ASSERT(297, fg != false);
|
|
|
|
dPaneClass_showNullPane(mpPointScreen);
|
|
|
|
mpPointParent = new CPaneMgr(mpPointScreen, 'f_po_n', 2, NULL);
|
|
JUT_ASSERT(301, mpPointParent != NULL);
|
|
|
|
mpPointParent->scale(g_fmapHIO.mCursorScale, g_fmapHIO.mCursorScale);
|
|
|
|
static const u64 cur_tag[4] = {'f_po_ru', 'f_po_rd', 'f_po_ld', 'f_po_lu'};
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
J2DPicture* picture = static_cast<J2DPicture*>(mpPointScreen->search(cur_tag[i]));
|
|
picture->setBlackWhite(g_fmapHIO.mCursorBlack, g_fmapHIO.mCursorWhite);
|
|
}
|
|
|
|
dMeter2Info_set2DWidth(getMapScissorAreaSizeX());
|
|
dMeter2Info_set2DHeight(getMapScissorAreaSizeY());
|
|
dMeter2Info_set2DPosH(getMapScissorAreaLX());
|
|
dMeter2Info_set2DPosV(getMapScissorAreaLY());
|
|
setDebugData(NULL, NULL, 0);
|
|
}
|
|
|
|
dMenu_Fmap2DBack_c::~dMenu_Fmap2DBack_c() {
|
|
delete mpBackScreen;
|
|
mpBackScreen = NULL;
|
|
|
|
delete mpBaseScreen;
|
|
mpBaseScreen = NULL;
|
|
|
|
delete mpBaseAnm;
|
|
mpBaseAnm = NULL;
|
|
|
|
delete mpBaseRoot;
|
|
mpBaseRoot = NULL;
|
|
|
|
delete mpMapArea;
|
|
mpMapArea = NULL;
|
|
|
|
delete mpMapBlack;
|
|
mpMapBlack = NULL;
|
|
|
|
delete mpMeterHaihai;
|
|
mpMeterHaihai = NULL;
|
|
|
|
delete mpBackTex;
|
|
mpBackTex = NULL;
|
|
|
|
delete mpPointScreen;
|
|
mpPointScreen = NULL;
|
|
|
|
delete mpPointParent;
|
|
mpPointParent = NULL;
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
if (mpAreaTex[i] != NULL) {
|
|
delete mpAreaTex[i];
|
|
mpAreaTex[i] = NULL;
|
|
}
|
|
}
|
|
|
|
deleteSpotPane();
|
|
dMeter2Info_setMapDrugFlag(0);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::draw() {
|
|
calcBlink();
|
|
|
|
J2DGrafContext* grafPort = dComIfGp_getCurrentGrafPort();
|
|
|
|
grafPort->setup2D();
|
|
|
|
u32 scissorLeft, scissorTop, scissorWidth, scissorHeight;
|
|
GXGetScissor(&scissorLeft, &scissorTop, &scissorWidth, &scissorHeight);
|
|
|
|
grafPort->scissor(mTransX, 0.0f, FB_WIDTH, FB_HEIGHT);
|
|
grafPort->setScissor();
|
|
|
|
mpBackTex->setBlackWhite(field_0x1208, field_0x120c);
|
|
mpBackTex->setAlpha(mAlphaRate * 255.0f * g_fmapHIO.mBackgroundAlpha);
|
|
mpBackTex->draw(mTransX + mDoGph_gInf_c::getMinXF(),
|
|
mTransZ + mDoGph_gInf_c::getMinYF(), mDoGph_gInf_c::getWidthF(),
|
|
mDoGph_gInf_c::getHeightF(), false, false, false);
|
|
|
|
mpBackScreen->draw(mTransX, mTransZ, grafPort);
|
|
mpBaseScreen->draw(mTransX, mTransZ, grafPort);
|
|
|
|
Mtx mtx;
|
|
Vec vec1 = mpMapArea->getGlobalVtx(&mtx, 0, false, 0);
|
|
|
|
Vec vec2 = mpMapArea->getGlobalVtx(&mtx, 3, false, 0);
|
|
|
|
f32 width = mDoGph_gInf_c::getWidthF() / FB_WIDTH;
|
|
f32 height = mDoGph_gInf_c::getHeightF() / FB_HEIGHT;
|
|
|
|
grafPort->scissor(mTransX + ((vec1.x - mDoGph_gInf_c::getMinXF()) / width),
|
|
mTransZ + (vec1.y / height), (vec2.x - vec1.x) / width,
|
|
(vec2.y - vec1.y) / height);
|
|
|
|
grafPort->setScissor();
|
|
|
|
field_0x11dc = (mTransX + getMapScissorAreaLX()) + (getMapScissorAreaSizeRealX() * 0.5f);
|
|
|
|
if (g_fmapHIO.mRangeCheck && g_fmapHIO.mRangeCheckDrawPriority) {
|
|
drawDebugRegionArea();
|
|
}
|
|
|
|
regionTextureDraw();
|
|
|
|
if (g_fmapHIO.mRangeCheck && g_fmapHIO.mRangeCheckDrawPriority) {
|
|
drawDebugStageArea();
|
|
}
|
|
|
|
if (mMapDrawFlag && mpSpotTexture) {
|
|
if (g_fmapHIO.mDisplayRegionGrid && g_fmapHIO.mRegionGridWidth > 0.0f) {
|
|
regionGridDraw();
|
|
}
|
|
|
|
stageTextureDraw();
|
|
|
|
if (g_fmapHIO.mDisplayStageOrigin) {
|
|
stageOriginDraw();
|
|
}
|
|
}
|
|
|
|
if (g_fmapHIO.mDisplayRegionOrigin) {
|
|
regionOriginDraw();
|
|
}
|
|
|
|
if (g_fmapHIO.mDisplayWorldGrid && g_fmapHIO.mWorldGridWidth > 0.0f) {
|
|
worldGridDraw();
|
|
}
|
|
|
|
if (g_fmapHIO.mDisplayWorldOrigin) {
|
|
worldOriginDraw();
|
|
}
|
|
|
|
if (g_fmapHIO.mScrollRangeDisplay) {
|
|
scrollAreaDraw();
|
|
}
|
|
|
|
blinkMove(30);
|
|
moveLightDropAnime();
|
|
setCenterPosX(field_0x11dc, 1);
|
|
drawIcon(mTransX, mTransZ, mAlphaRate, field_0xfa8 * mSpotTextureFadeAlpha);
|
|
|
|
if (g_fmapHIO.mRangeCheck && !g_fmapHIO.mRangeCheckDrawPriority) {
|
|
drawDebugRegionArea();
|
|
}
|
|
|
|
grafPort->scissor(scissorLeft, scissorTop, scissorWidth, scissorHeight);
|
|
grafPort->setScissor();
|
|
|
|
if (isArrowDrawFlag()) {
|
|
f32 fVar2 = 0.0f;
|
|
f32 fVar3 = 0.0f;
|
|
f32 fVar4, fVar5;
|
|
|
|
if (mMapZoomRate > 1.0f && mMapZoomRate < 2.0f) {
|
|
f32 tmp = 2.0f - mMapZoomRate;
|
|
if (field_0x11a4 != 0.0f) {
|
|
fVar2 = field_0x11a4 * tmp;
|
|
}
|
|
if (field_0x11a8 != 0.0f) {
|
|
fVar3 = field_0x11a8 * tmp;
|
|
}
|
|
fVar4 = field_0x11ac;
|
|
fVar5 = field_0x11b0;
|
|
} else {
|
|
fVar4 = mStageTransX;
|
|
fVar5 = mStageTransZ;
|
|
}
|
|
|
|
calcAllMapPos2D((mArrowPos3DX + control_xpos + fVar2) - fVar4,
|
|
(mArrowPos3DZ + control_ypos + fVar3) - fVar5, &mArrowPos2DX,
|
|
&mArrowPos2DY);
|
|
|
|
field_0x11e0 -= g_fmapHIO.mCursorSpeed;
|
|
|
|
if (field_0x11e0 < 0.0f) {
|
|
field_0x11e0 += 360.0f;
|
|
}
|
|
|
|
mpPointParent->getPanePtr()->rotate(mpPointParent->getSizeX() / 2.0f,
|
|
mpPointParent->getSizeY() / 2.0f, ROTATE_Z,
|
|
field_0x11e0);
|
|
|
|
if (g_fmapHIO.mCursorDebugON) {
|
|
mpPointParent->scale(g_fmapHIO.mCursorScale, g_fmapHIO.mCursorScale);
|
|
|
|
static const u64 cur_tag[4] = {'f_po_ru', 'f_po_rd', 'f_po_ld', 'f_po_lu'};
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
J2DPicture* picture = static_cast<J2DPicture*>(mpPointScreen->search(cur_tag[i]));
|
|
picture->setBlackWhite(g_fmapHIO.mCursorBlack, g_fmapHIO.mCursorWhite);
|
|
}
|
|
}
|
|
|
|
mpPointParent->setAlphaRate(mArrowAlpha * mSpotTextureFadeAlpha);
|
|
mpPointParent->translate(mArrowPos2DX + mTransX, mArrowPos2DY + mTransZ);
|
|
mpPointScreen->draw(0.0f, 0.0f, grafPort);
|
|
}
|
|
|
|
if (g_fmapHIO.mDisplayReferenceArea) {
|
|
J2DDrawFrame(mTransX + getMapAreaGlobalPosX(), mTransZ + getMapAreaGlobalPosY(),
|
|
getMapAreaSizeX(), getMapAreaSizeY(), JUtility::TColor(255, 255, 255, 255), 6);
|
|
J2DFillBox(getMapAreaGlobalCenterPosX() - 3.0f, getMapAreaGlobalCenterPosY() - 3.0f, 6.0f,
|
|
6.0f, JUtility::TColor(255, 255, 255, 255));
|
|
}
|
|
|
|
if (field_0x122d) {
|
|
mpMeterHaihai->drawHaihai(field_0x122d);
|
|
field_0x122d = 0;
|
|
}
|
|
|
|
if (g_fmapHIO.mRangeCheck && !g_fmapHIO.mRangeCheckDrawPriority) {
|
|
drawDebugStageArea();
|
|
}
|
|
|
|
mpBackTex->setBlackWhite(field_0x1208, field_0x120c);
|
|
mpBackTex->setAlpha((mAlphaRate * 255.0f) * g_fmapHIO.mBackgroundFrontAlpha * mBackAlpha);
|
|
mpBackTex->draw(mTransX + mDoGph_gInf_c::getMinXF(),
|
|
mTransZ + mDoGph_gInf_c::getMinYF(), mDoGph_gInf_c::getWidthF(),
|
|
mDoGph_gInf_c::getHeightF(), false, false, false);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::setRegionTexData(u8 i_areaType, ResTIMG* i_timg, f32 i_originX,
|
|
f32 i_originZ, f32 i_posX, f32 i_posZ, f32 i_scale,
|
|
f32 i_scrollMinX, f32 i_scrollMinZ, f32 i_scrollMaxX,
|
|
f32 i_scrollMaxZ) {
|
|
if (i_scale == 0.0f) {
|
|
i_scale = 100.0f;
|
|
}
|
|
|
|
mpAreaTex[i_areaType] = new J2DPicture(i_timg);
|
|
JUT_ASSERT(763, mpAreaTex[i_areaType] != NULL);
|
|
|
|
mRegionOriginX[i_areaType] = i_originX;
|
|
mRegionOriginZ[i_areaType] = i_originZ;
|
|
mRegionTexData[i_areaType].mScale = i_scale * 100.0f;
|
|
|
|
f32 width = i_timg->width;
|
|
f32 height = i_timg->height;
|
|
|
|
f32 min_x = (mRegionOriginX[i_areaType] + i_posX) -
|
|
((width * 0.5f) * mRegionTexData[i_areaType].mScale);
|
|
f32 min_z = (mRegionOriginZ[i_areaType] + i_posZ) -
|
|
((height * 0.5f) * mRegionTexData[i_areaType].mScale);
|
|
f32 max_x = (mRegionOriginX[i_areaType] + i_posX) +
|
|
((width * 0.5f) * mRegionTexData[i_areaType].mScale);
|
|
f32 max_z = (mRegionOriginZ[i_areaType] + i_posZ) +
|
|
((height * 0.5f) * mRegionTexData[i_areaType].mScale);
|
|
|
|
mRegionTexData[i_areaType].mMinX = min_x;
|
|
mRegionTexData[i_areaType].mMinZ = min_z;
|
|
mRegionTexData[i_areaType].mMaxX = max_x;
|
|
mRegionTexData[i_areaType].mMaxZ = max_z;
|
|
|
|
mRegionScrollMinX[i_areaType] = i_scrollMinX;
|
|
mRegionScrollMinZ[i_areaType] = i_scrollMinZ;
|
|
mRegionScrollMaxX[i_areaType] = i_scrollMaxX;
|
|
mRegionScrollMaxZ[i_areaType] = i_scrollMaxZ;
|
|
|
|
bool first = false;
|
|
|
|
mTexMinX = 0.0f;
|
|
mTexMinZ = 0.0f;
|
|
mTexMaxX = 0.0f;
|
|
mTexMaxZ = 0.0f;
|
|
|
|
bool bVar14 = false;
|
|
for (int i = 0; i < 8; i++) {
|
|
if (mpAreaTex[i] != NULL) {
|
|
if (!first) {
|
|
mTexMinX = mRegionTexData[i].mMinX;
|
|
mTexMinZ = mRegionTexData[i].mMinZ;
|
|
mTexMaxX = mRegionTexData[i].mMaxX;
|
|
mTexMaxZ = mRegionTexData[i].mMaxZ;
|
|
first = true;
|
|
} else {
|
|
if (mTexMinX > mRegionTexData[i].mMinX) {
|
|
mTexMinX = mRegionTexData[i].mMinX;
|
|
}
|
|
if (mTexMinZ > mRegionTexData[i].mMinZ) {
|
|
mTexMinZ = mRegionTexData[i].mMinZ;
|
|
}
|
|
if (mTexMaxX < mRegionTexData[i].mMaxX) {
|
|
mTexMaxX = mRegionTexData[i].mMaxX;
|
|
}
|
|
if (mTexMaxZ < mRegionTexData[i].mMaxZ) {
|
|
mTexMaxZ = mRegionTexData[i].mMaxZ;
|
|
}
|
|
}
|
|
}
|
|
if ((!bVar14) && (field_0x1230[i] == 0xff)) {
|
|
field_0x1230[i] = i_areaType;
|
|
bVar14 = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::setRegionTexData(u8 i_areaType, f32 i_originX, f32 i_originZ, f32 i_posX,
|
|
f32 i_posZ, f32 i_scale, f32 i_scrollMinX,
|
|
f32 i_scrollMinZ, f32 i_scrollMaxX, f32 i_scrollMaxZ) {
|
|
if (i_scale == 0.0f) {
|
|
i_scale = 100.0f;
|
|
}
|
|
|
|
mRegionOriginX[i_areaType] = i_originX;
|
|
mRegionOriginZ[i_areaType] = i_originZ;
|
|
mRegionTexData[i_areaType].mScale = i_scale * 100.0f;
|
|
|
|
f32 width = mpAreaTex[i_areaType]->getTexture(0)->getTexInfo()->width;
|
|
f32 height = mpAreaTex[i_areaType]->getTexture(0)->getTexInfo()->height;
|
|
|
|
f32 min_x = (mRegionOriginX[i_areaType] + i_posX) -
|
|
((width * 0.5f) * mRegionTexData[i_areaType].mScale);
|
|
f32 min_z = (mRegionOriginZ[i_areaType] + i_posZ) -
|
|
((height * 0.5f) * mRegionTexData[i_areaType].mScale);
|
|
f32 max_x = (mRegionOriginX[i_areaType] + i_posX) +
|
|
((width * 0.5f) * mRegionTexData[i_areaType].mScale);
|
|
f32 max_z = (mRegionOriginZ[i_areaType] + i_posZ) +
|
|
((height * 0.5f) * mRegionTexData[i_areaType].mScale);
|
|
|
|
mRegionTexData[i_areaType].mMinX = min_x;
|
|
mRegionTexData[i_areaType].mMinZ = min_z;
|
|
mRegionTexData[i_areaType].mMaxX = max_x;
|
|
mRegionTexData[i_areaType].mMaxZ = max_z;
|
|
|
|
mRegionScrollMinX[i_areaType] = i_scrollMinX;
|
|
mRegionScrollMinZ[i_areaType] = i_scrollMinZ;
|
|
mRegionScrollMaxX[i_areaType] = i_scrollMaxX;
|
|
mRegionScrollMaxZ[i_areaType] = i_scrollMaxZ;
|
|
|
|
bool first = false;
|
|
|
|
mTexMinX = 0.0f;
|
|
mTexMinZ = 0.0f;
|
|
mTexMaxX = 0.0f;
|
|
mTexMaxZ = 0.0f;
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
if (mpAreaTex[i] != NULL) {
|
|
if (!first) {
|
|
mTexMinX = mRegionTexData[i].mMinX;
|
|
mTexMinZ = mRegionTexData[i].mMinZ;
|
|
mTexMaxX = mRegionTexData[i].mMaxX;
|
|
mTexMaxZ = mRegionTexData[i].mMaxZ;
|
|
first = true;
|
|
} else {
|
|
if (mTexMinX > mRegionTexData[i].mMinX) {
|
|
mTexMinX = mRegionTexData[i].mMinX;
|
|
}
|
|
if (mTexMinZ > mRegionTexData[i].mMinZ) {
|
|
mTexMinZ = mRegionTexData[i].mMinZ;
|
|
}
|
|
if (mTexMaxX < mRegionTexData[i].mMaxX) {
|
|
mTexMaxX = mRegionTexData[i].mMaxX;
|
|
}
|
|
if (mTexMaxZ < mRegionTexData[i].mMaxZ) {
|
|
mTexMaxZ = mRegionTexData[i].mMaxZ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::calcAllMapPos() {
|
|
bool set = false;
|
|
calcAllMapScaleRate();
|
|
for (int i = 0; i < 8; i++) {
|
|
if (mpAreaTex[i] != NULL) {
|
|
f32 min_x, min_y, max_x, max_y;
|
|
|
|
calcAllMapPos2DFirst(mRegionTexData[i].mMinX, mRegionTexData[i].mMinZ, &min_x, &min_y);
|
|
calcAllMapPos2DFirst(mRegionTexData[i].mMaxX, mRegionTexData[i].mMaxZ, &max_x, &max_y);
|
|
mRegionMinMapX[i] = min_x;
|
|
mRegionMinMapY[i] = min_y;
|
|
mRegionMapSizeX[i] = max_x - min_x;
|
|
mRegionMapSizeY[i] = max_y - min_y;
|
|
|
|
calcAllMapPos2DFirst(mRegionScrollMinX[i], mRegionScrollMinZ[i],
|
|
&mRegionScrollMapMinX[i], &mRegionScrollMapMinY[i]);
|
|
calcAllMapPos2DFirst(mRegionScrollMaxX[i], mRegionScrollMaxZ[i],
|
|
&mRegionScrollMapMaxX[i], &mRegionScrollMapMaxY[i]);
|
|
|
|
onShowRegionFlag(i);
|
|
|
|
if (!set) {
|
|
set = true;
|
|
calcRenderingScale();
|
|
calcRenderingPos();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::calcAllMapScaleRate() {
|
|
f32 width = mTexMaxX - mTexMinX;
|
|
f32 height = mTexMaxZ - mTexMinZ;
|
|
f32 size = width;
|
|
if (size < height) {
|
|
size = height;
|
|
}
|
|
f32 v = getMapAreaSizeX();
|
|
mAllMapScaleRate = v / size;
|
|
|
|
return mAllMapScaleRate;
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::calcAllMapPos2DFirst(f32 i_texPosX, f32 i_texPosZ, f32* o_posX,
|
|
f32* o_posY) {
|
|
f32 midTexX = (mTexMaxX + mTexMinX) * 0.5f;
|
|
f32 midTexZ = (mTexMaxZ + mTexMinZ) * 0.5f;
|
|
f32 relativePosX = i_texPosX - midTexX;
|
|
f32 relativePosZ = i_texPosZ - midTexZ;
|
|
f32 pos_x = (mAllMapScaleRate * relativePosX);
|
|
f32 pos_y = (mAllMapScaleRate * relativePosZ);
|
|
|
|
*o_posX = pos_x + getMapAreaGlobalCenterPosX();
|
|
*o_posY = pos_y + getMapAreaGlobalCenterPosY();
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::calcAllMapPos2D(f32 param_0, f32 param_1, f32* o_posX, f32* o_posY) {
|
|
calcAllMapPos2D(param_0, param_1, o_posX, o_posY, field_0xf0c[mRegionCursor],
|
|
field_0xf2c[mRegionCursor], mZoom);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::calcAllMapPos2D(char const* param_0, f32 param_1, f32 param_2,
|
|
f32* o_posX, f32* o_posY) {
|
|
f32 tmp1, tmp2;
|
|
calcOffset(mRegionCursor, param_0, &tmp1, &tmp2);
|
|
calcAllMapPos2D(param_1 + tmp1, param_2 + tmp2, o_posX, o_posY, field_0xf0c[mRegionCursor],
|
|
field_0xf2c[mRegionCursor], mZoom);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::calcAllMapPos2D(f32 param_0, f32 param_1, f32* outX, f32* outZ,
|
|
f32 param_4, f32 param_5, f32 i_zoom) {
|
|
f32 unusedX = (mTexMaxX - mTexMinX) / getMapAreaSizeX();
|
|
f32 unusedY = (mTexMaxZ - mTexMinZ) / getMapAreaSizeY();
|
|
f32 unusedMax = unusedX;
|
|
if (unusedX < unusedY) {
|
|
unusedMax = unusedY;
|
|
}
|
|
f32 regionMidX = (mRegionTexData[mRegionCursor].mMinX + mRegionTexData[mRegionCursor].mMaxX) * 0.5f;
|
|
f32 regionMidY = (mRegionTexData[mRegionCursor].mMinZ + mRegionTexData[mRegionCursor].mMaxZ) * 0.5f;
|
|
f32 f25 = mRegionMinMapX[mRegionCursor] + param_4 + (mRegionMapSizeX[mRegionCursor] * i_zoom) * 0.5f;
|
|
f32 f24 = mRegionMinMapY[mRegionCursor] + param_5 + (mRegionMapSizeY[mRegionCursor] * i_zoom) * 0.5f;
|
|
|
|
f32 scale = getPathScale(i_zoom) / getMapScissorAreaSizeRealY();
|
|
f32 offsX = (param_0 - regionMidX) / scale;
|
|
f32 offsY = (param_1 - regionMidY) / scale;
|
|
*outX = offsX + f25;
|
|
*outZ = offsY + f24;
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::calcAllMapPosWorld(f32 param_0, f32 param_1, f32* outX, f32* outZ) {
|
|
f32 midX = (mRegionTexData[mRegionCursor].mMinX + mRegionTexData[mRegionCursor].mMaxX) * 0.5f;
|
|
f32 midY = (mRegionTexData[mRegionCursor].mMinZ + mRegionTexData[mRegionCursor].mMaxZ) * 0.5f;
|
|
f32 tmp3 = (mRegionMinMapX[mRegionCursor] + field_0xf0c[mRegionCursor]) +
|
|
mRegionMapSizeX[mRegionCursor] * mZoom * 0.5f;
|
|
f32 tmp4 = (mRegionMinMapY[mRegionCursor] + field_0xf2c[mRegionCursor]) +
|
|
mRegionMapSizeY[mRegionCursor] * mZoom * 0.5f;
|
|
f32 tmp3_ = param_0 - tmp3;
|
|
f32 tmp4_ = param_1 - tmp4;
|
|
f32 tmp5 = field_0xf98 / getMapScissorAreaSizeRealY();
|
|
|
|
*outX = midX + (tmp3_ * tmp5);
|
|
*outZ = midY + (tmp4_ * tmp5);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::setSpotPane(ResTIMG* i_timg) {
|
|
if (mpSpotTexture == NULL) {
|
|
mpSpotTexture = new J2DPicture(i_timg);
|
|
JUT_ASSERT(1169, mpSpotTexture != NULL);
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::deleteSpotPane() {
|
|
if (mpSpotTexture != NULL) {
|
|
delete mpSpotTexture;
|
|
mpSpotTexture = NULL;
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::zoomMapCalc(f32 i_zoom) {
|
|
mMapZoomRate = i_zoom;
|
|
field_0xfa8 = i_zoom;
|
|
mZoom = getAllMapZoomRate() +
|
|
(i_zoom * (getRegionMapZoomRate(mRegionCursor) - getAllMapZoomRate()));
|
|
calcRenderingScale();
|
|
|
|
f32 centerX = getMapAreaGlobalCenterPosX();
|
|
f32 centerY = getMapAreaGlobalCenterPosY();
|
|
if (g_fmapHIO.field_0x308 == false) {
|
|
f32 region_centerX = mRegionMinMapX[mRegionCursor] + (mRegionMapSizeX[mRegionCursor] * 0.5f);
|
|
f32 region_centerY = mRegionMinMapY[mRegionCursor] + (mRegionMapSizeY[mRegionCursor] * 0.5f);
|
|
f32 v = region_centerX + (i_zoom * (centerX - region_centerX));
|
|
f32 v2 = region_centerY + (i_zoom * (centerY - region_centerY));
|
|
field_0xf0c[mRegionCursor] =
|
|
v - (mRegionMapSizeX[mRegionCursor] * mZoom * 0.5f) - mRegionMinMapX[mRegionCursor];
|
|
field_0xf2c[mRegionCursor] =
|
|
v2 - (mRegionMapSizeY[mRegionCursor] * mZoom * 0.5f) - mRegionMinMapY[mRegionCursor];
|
|
} else {
|
|
f32 dVar12 = (mRegionScrollMapMinX[mRegionCursor] + mRegionScrollMapMaxX[mRegionCursor]) * 0.5f;
|
|
f32 dVar11 = (mRegionScrollMapMinY[mRegionCursor] + mRegionScrollMapMaxY[mRegionCursor]) * 0.5f;
|
|
|
|
f32 tmp3 = (mRegionMinMapX[mRegionCursor] + mRegionMapSizeX[mRegionCursor] * 0.5f) - dVar12;
|
|
f32 tmp = (mRegionMinMapY[mRegionCursor] + mRegionMapSizeY[mRegionCursor] * 0.5f) - dVar11;
|
|
|
|
f32 tmp2 = (dVar12 + (i_zoom * (centerX - dVar12)));
|
|
f32 tmp2_ = (dVar11 + (i_zoom * (centerY - dVar11)));
|
|
|
|
field_0xf0c[mRegionCursor] =
|
|
((tmp2 + (tmp3 * mZoom)) - mRegionMapSizeX[mRegionCursor] * mZoom * 0.5f) -
|
|
mRegionMinMapX[mRegionCursor];
|
|
|
|
field_0xf2c[mRegionCursor] =
|
|
((tmp2_ + tmp * mZoom) - mRegionMapSizeY[mRegionCursor] * mZoom * 0.5f) -
|
|
mRegionMinMapY[mRegionCursor];
|
|
}
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
if (i != mRegionCursor) {
|
|
field_0xf0c[i] =
|
|
field_0xf0c[mRegionCursor] +
|
|
(mRegionMinMapX[i] - mRegionMinMapX[mRegionCursor]) * (mZoom - getAllMapZoomRate());
|
|
field_0xf2c[i] =
|
|
field_0xf2c[mRegionCursor] +
|
|
(mRegionMinMapY[i] - mRegionMinMapY[mRegionCursor]) * (mZoom - getAllMapZoomRate());
|
|
}
|
|
}
|
|
|
|
if (i_zoom == 1.0f) {
|
|
for (int i = 0; i < 8; i++) {
|
|
field_0xf4c[i] = field_0xf0c[i];
|
|
field_0xf6c[i] = field_0xf2c[i];
|
|
}
|
|
}
|
|
|
|
calcRenderingPos();
|
|
setSpotCursor(mSpotCursor);
|
|
|
|
field_0xfb8 =
|
|
((mRegionMapSizeX[mRegionCursor] + (i_zoom * (getMapAreaSizeX() - mRegionMapSizeX[mRegionCursor]))) /
|
|
getMapAreaSizeX());
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::zoomMapCalc2(f32 param_0) {
|
|
f32 spotZoomRate = getSpotMapZoomRate();
|
|
f32 regionZoomRate = getRegionMapZoomRate(mRegionCursor);
|
|
mZoom = regionZoomRate + (param_0 * (spotZoomRate - regionZoomRate));
|
|
|
|
if (mArrowPos3DX + control_xpos < mRegionScrollMinX[mRegionCursor]) {
|
|
if (field_0x11a4 == 0.0f) {
|
|
field_0x11a4 = (mArrowPos3DX + control_xpos) - mRegionScrollMinX[mRegionCursor];
|
|
}
|
|
control_xpos = mRegionScrollMinX[mRegionCursor] - mArrowPos3DX;
|
|
} else {
|
|
if (mArrowPos3DX + control_xpos > mRegionScrollMaxX[mRegionCursor]) {
|
|
if (field_0x11a4 == 0.0f) {
|
|
field_0x11a4 = (mArrowPos3DX + control_xpos) - mRegionScrollMaxX[mRegionCursor];
|
|
}
|
|
control_xpos = mRegionScrollMaxX[mRegionCursor] - mArrowPos3DX;
|
|
}
|
|
}
|
|
|
|
if (mArrowPos3DZ + control_ypos < mRegionScrollMinZ[mRegionCursor]) {
|
|
if (field_0x11a8 == 0.0f) {
|
|
field_0x11a8 = (mArrowPos3DZ + control_ypos) - mRegionScrollMinZ[mRegionCursor];
|
|
}
|
|
control_ypos = mRegionScrollMinZ[mRegionCursor] - this->mArrowPos3DZ;
|
|
} else {
|
|
if (mArrowPos3DZ + control_ypos > mRegionScrollMaxZ[mRegionCursor]) {
|
|
if (field_0x11a8 == 0.0f) {
|
|
field_0x11a8 = (mArrowPos3DZ + control_ypos) - mRegionScrollMaxZ[mRegionCursor];
|
|
}
|
|
control_ypos = mRegionScrollMaxZ[mRegionCursor] - mArrowPos3DZ;
|
|
}
|
|
}
|
|
|
|
calcRenderingScale();
|
|
|
|
mMapZoomRate = param_0 + 1.0f;
|
|
f32 centerX = getMapAreaGlobalCenterPosX();
|
|
f32 centerY = getMapAreaGlobalCenterPosY();
|
|
if (g_fmapHIO.field_0x308 == false) {
|
|
field_0xf0c[mRegionCursor] = (centerX - (mRegionMapSizeX[mRegionCursor] * mZoom * 0.5f)) -
|
|
mRegionMinMapX[mRegionCursor];
|
|
field_0xf2c[mRegionCursor] = (centerY - (mRegionMapSizeY[mRegionCursor] * mZoom * 0.5f)) -
|
|
mRegionMinMapY[mRegionCursor];
|
|
} else {
|
|
f32 x = (mRegionScrollMapMinX[mRegionCursor] + mRegionScrollMapMaxX[mRegionCursor]) * 0.5f;
|
|
f32 y = (mRegionScrollMapMinY[mRegionCursor] + mRegionScrollMapMaxY[mRegionCursor]) * 0.5f;
|
|
|
|
f32 tmp2 = (mRegionMinMapX[mRegionCursor] + (mRegionMapSizeX[mRegionCursor] * 0.5f)) - x;
|
|
f32 tmp1 = (mRegionMinMapY[mRegionCursor] + (mRegionMapSizeY[mRegionCursor] * 0.5f)) - y;
|
|
|
|
field_0xf0c[mRegionCursor] =
|
|
((centerX + (tmp2 * mZoom)) - mRegionMapSizeX[mRegionCursor] * mZoom * 0.5f) -
|
|
mRegionMinMapX[mRegionCursor];
|
|
field_0xf2c[mRegionCursor] =
|
|
((centerY + (tmp1 * mZoom)) - mRegionMapSizeY[mRegionCursor] * mZoom * 0.5f) -
|
|
mRegionMinMapY[mRegionCursor];
|
|
}
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
if (i != mRegionCursor) {
|
|
field_0xf0c[i] =
|
|
field_0xf0c[mRegionCursor] +
|
|
(mRegionMinMapX[i] - mRegionMinMapX[mRegionCursor]) * (mZoom - getAllMapZoomRate());
|
|
field_0xf2c[i] =
|
|
field_0xf2c[mRegionCursor] +
|
|
(mRegionMinMapY[i] - mRegionMinMapY[mRegionCursor]) * (mZoom - getAllMapZoomRate());
|
|
}
|
|
}
|
|
|
|
scrollCalc(param_0);
|
|
|
|
if (param_0 == 1.0f) {
|
|
field_0x11b4 = (mArrowPos3DX + control_xpos) - mStageTransX;
|
|
field_0x11b8 = (mArrowPos3DZ + control_ypos) - mStageTransZ;
|
|
field_0x11a4 = 0.0f;
|
|
field_0x11a8 = 0.0f;
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::zoomMapCalcHIO() {
|
|
if (mZoom != getSpotMapZoomRate()) {
|
|
f32 spotZoomRate = getSpotMapZoomRate();
|
|
f32 regionZoomRate = getRegionMapZoomRate(mRegionCursor);
|
|
mZoom = getSpotMapZoomRate();
|
|
calcRenderingScale();
|
|
|
|
f32 centerX = getMapAreaGlobalCenterPosX();
|
|
f32 centerY = getMapAreaGlobalCenterPosY();
|
|
if (g_fmapHIO.field_0x308 == false) {
|
|
field_0xf0c[mRegionCursor] =
|
|
(centerX - (mRegionMapSizeX[mRegionCursor] * mZoom * 0.5f)) -
|
|
mRegionMinMapX[mRegionCursor];
|
|
field_0xf2c[mRegionCursor] =
|
|
(centerY - (mRegionMapSizeY[mRegionCursor] * mZoom * 0.5f)) -
|
|
mRegionMinMapY[mRegionCursor];
|
|
} else {
|
|
f32 x =
|
|
(mRegionScrollMapMinX[mRegionCursor] + mRegionScrollMapMaxX[mRegionCursor]) * 0.5f;
|
|
f32 y =
|
|
(mRegionScrollMapMinY[mRegionCursor] + mRegionScrollMapMaxY[mRegionCursor]) * 0.5f;
|
|
|
|
f32 tmp2 =
|
|
((mRegionMinMapX[mRegionCursor] + mRegionMapSizeX[mRegionCursor] * 0.5f) - x);
|
|
f32 tmp1 =
|
|
((mRegionMinMapY[mRegionCursor] + mRegionMapSizeY[mRegionCursor] * 0.5f) - y);
|
|
|
|
field_0xf0c[mRegionCursor] = ((centerX + (tmp2 * mZoom)) -
|
|
mRegionMapSizeX[mRegionCursor] * mZoom * 0.5f) -
|
|
mRegionMinMapX[mRegionCursor];
|
|
field_0xf2c[mRegionCursor] = ((centerY + (tmp1 * mZoom)) -
|
|
mRegionMapSizeY[mRegionCursor] * mZoom * 0.5f) -
|
|
mRegionMinMapY[mRegionCursor];
|
|
}
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
if (i != mRegionCursor) {
|
|
field_0xf0c[i] =
|
|
field_0xf0c[mRegionCursor] + (mRegionMinMapX[i] - mRegionMinMapX[mRegionCursor]) *
|
|
(mZoom - getAllMapZoomRate());
|
|
field_0xf2c[i] =
|
|
field_0xf2c[mRegionCursor] + (mRegionMinMapY[i] - mRegionMinMapY[mRegionCursor]) *
|
|
(mZoom - getAllMapZoomRate());
|
|
}
|
|
}
|
|
|
|
scrollCalc(1.0f);
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::scrollCalc(f32 param_0) {
|
|
f32 sp40, sp3C;
|
|
calcAllMapPos2D(mArrowPos3DX + control_xpos, mArrowPos3DZ + control_ypos, &sp40, &sp3C,
|
|
field_0xf4c[mRegionCursor], field_0xf6c[mRegionCursor],
|
|
getRegionMapZoomRate(mRegionCursor));
|
|
|
|
f32 sp38 = getMapAreaGlobalCenterPosX();
|
|
f32 sp34 = getMapAreaGlobalCenterPosY();
|
|
|
|
f32 sp30 = sp40 + (param_0 * (sp38 - sp40));
|
|
f32 sp2C = sp3C + (param_0 * (sp34 - sp3C));
|
|
f32 sp28, sp24;
|
|
calcAllMapPosWorld(sp30, sp2C, &sp28, &sp24);
|
|
|
|
mStageTransX = (mArrowPos3DX + control_xpos) - sp28;
|
|
mStageTransZ = (mArrowPos3DZ + control_ypos) - sp24;
|
|
|
|
field_0x11ac = mStageTransX;
|
|
field_0x11b0 = mStageTransZ;
|
|
|
|
if ((((field_0x11a4 != 0.0f) || (field_0x11a8 != 0.0f)) && (mMapZoomRate > 1.0f)) &&
|
|
(mMapZoomRate < 2.0f))
|
|
{
|
|
f32 local_40 = 2.0f - mMapZoomRate;
|
|
|
|
//!@bug local_44 or local_48 can be uninitialized if field_0x11a4 or field_0x11a8 is not 0
|
|
f32 local_44, local_48;
|
|
|
|
if (field_0x11a4 != 0.0f) {
|
|
local_44 = field_0x11a4 * local_40;
|
|
}
|
|
|
|
if (field_0x11a8 != 0.0f) {
|
|
local_48 = field_0x11a8 * local_40;
|
|
}
|
|
|
|
calcAllMapPos2D(mArrowPos3DX + control_xpos + local_44,
|
|
mArrowPos3DZ + control_ypos + local_48, &sp40, &sp3C,
|
|
field_0xf4c[mRegionCursor], field_0xf6c[mRegionCursor],
|
|
getRegionMapZoomRate(mRegionCursor));
|
|
|
|
f32 sp14 = sp40 + (param_0 * (sp38 - sp40));
|
|
f32 sp10 = sp3C + (param_0 * (sp34 - sp3C));
|
|
f32 spC, sp8;
|
|
calcAllMapPosWorld(sp14, sp10, &spC, &sp8);
|
|
|
|
field_0x11ac = (mArrowPos3DX + control_xpos + local_44) - spC;
|
|
field_0x11b0 = (mArrowPos3DZ + control_ypos + local_48) - sp8;
|
|
}
|
|
|
|
if (param_0 == 0.0f) {
|
|
field_0xfd0 = field_0xfd4 = 0.0f;
|
|
field_0xfd8 = field_0xfdc = 0.0f;
|
|
} else if (param_0 == 1.0f) {
|
|
field_0xfd0 = mStageTransX;
|
|
field_0xfd4 = mStageTransZ;
|
|
}
|
|
|
|
calcRenderingPos();
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::mapBlink(s16* param_0) {
|
|
*param_0 += (s16)1;
|
|
if (*param_0 >= 30) {
|
|
*param_0 -= (s16)30;
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::setSpotCursor(u8 param_0) {
|
|
this->mSpotCursor = param_0;
|
|
|
|
f32 tmp1, tmp2;
|
|
getStageOriginPath(param_0, &tmp1, &tmp2);
|
|
calcAllMapPos2D(tmp1, tmp2, &field_0x1184, &field_0x1188);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::allmap_move2(STControl* param_0) {
|
|
f32 sp48, sp44;
|
|
calcAllMapPosWorld(getMapScissorAreaLX(), getMapScissorAreaLY(), &sp48, &sp44);
|
|
|
|
f32 sp40, sp3C;
|
|
calcAllMapPosWorld(getMapScissorAreaLX() + getMapScissorAreaSizeRealX(),
|
|
getMapScissorAreaLY() + getMapScissorAreaSizeRealY(), &sp40, &sp3C);
|
|
int r26 = 0;
|
|
if (r26 == 0) {
|
|
f32 spC = g_fmapHIO.mScrollSpeedSlowBound < g_fmapHIO.mScrollSpeedFastBound ?
|
|
g_fmapHIO.mScrollSpeedSlowBound :
|
|
g_fmapHIO.mScrollSpeedFastBound;
|
|
f32 sp8 = g_fmapHIO.mScrollSpeedSlowBound > g_fmapHIO.mScrollSpeedFastBound ?
|
|
g_fmapHIO.mScrollSpeedSlowBound :
|
|
g_fmapHIO.mScrollSpeedFastBound;
|
|
|
|
f32 stickValue = param_0->getValueStick();
|
|
if (stickValue >= spC) {
|
|
s16 angle = param_0->getAngleStick();
|
|
f32 local_68 = (mTexMaxX - mTexMinX);
|
|
f32 zoomRate = local_68 / getAllMapZoomRate();
|
|
f32 sp24;
|
|
if (stickValue < sp8) {
|
|
sp24 = g_fmapHIO.mScrollSpeedWorldSlow;
|
|
} else {
|
|
sp24 = g_fmapHIO.mScrollSpeedWorldFast;
|
|
}
|
|
|
|
f32 speed = (sp24 / 100.0f) * zoomRate;
|
|
f32 delta_y = speed * cM_ssin(angle);
|
|
f32 delta_x = speed * cM_scos(angle);
|
|
|
|
control_xpos = control_xpos + delta_y;
|
|
control_ypos = control_ypos + delta_x;
|
|
}
|
|
}
|
|
if (mArrowPos3DX + control_xpos < sp48) {
|
|
control_xpos = sp48 - mArrowPos3DX;
|
|
}
|
|
|
|
if (mArrowPos3DX + control_xpos > sp40) {
|
|
control_xpos = sp40 - mArrowPos3DX;
|
|
}
|
|
|
|
if (mArrowPos3DZ + control_ypos < sp44) {
|
|
control_ypos = sp44 - mArrowPos3DZ;
|
|
}
|
|
|
|
if (mArrowPos3DZ + control_ypos > sp3C) {
|
|
control_ypos = sp3C - mArrowPos3DZ;
|
|
}
|
|
|
|
calcRenderingScale();
|
|
calcRenderingPos();
|
|
calcAllMapPos();
|
|
|
|
f32 sp14, sp10;
|
|
calcAllMapPos2D((mArrowPos3DX + control_xpos) - mStageTransX,
|
|
(mArrowPos3DZ + control_ypos) - mStageTransZ, &sp14, &sp10);
|
|
|
|
mSelectRegion = 0xff;
|
|
for (int i = 7; i >= 0; i--) {
|
|
int val = field_0x1230[i];
|
|
if (val != 0xff && val != 7) {
|
|
u8 pixel = dMeter2Info_getPixel(
|
|
sp14, sp10, (mRegionMinMapX[val] + field_0xf0c[val] + mTransX),
|
|
(mRegionMinMapY[val] + field_0xf2c[val] + mTransZ), (mRegionMapSizeX[val] * mZoom),
|
|
(mRegionMapSizeY[val] * mZoom), mpAreaTex[val]->getTexture(0)->getTexInfo());
|
|
if (pixel) {
|
|
mSelectRegion = val;
|
|
}
|
|
}
|
|
if (mSelectRegion != 0xff)
|
|
break;
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::setIcon2DPos(u8 param_0, f32 param_1, f32 param_2, f32 param_3, u8 param_4,
|
|
bool param_5) {
|
|
f32 local_68, local_6c;
|
|
|
|
f32 sp30 = mMapZoomRate;
|
|
u8 uVar9 = 1;
|
|
if (param_0 == 17) {
|
|
uVar9 = 2;
|
|
|
|
f32 dVar11 = 0.0f;
|
|
f32 dVar10 = 0.0f;
|
|
f32 sp2C, sp28;
|
|
calcAllMapPosWorld(getMapScissorAreaCenterPosX(), getMapScissorAreaCenterPosY(), &sp2C,
|
|
&sp28);
|
|
|
|
f32 sp24, sp20;
|
|
calcAllMapPos2D(sp2C + mStageTransX, sp28 + mStageTransZ, &sp24, &sp20);
|
|
|
|
dVar11 = getMapScissorAreaCenterPosX() - sp24;
|
|
dVar10 = getMapScissorAreaCenterPosY() - sp20;
|
|
|
|
if (mRegionCursor + 1 == dComIfGp_getNowLevel()) {
|
|
calcAllMapPos2D(param_1 - mStageTransX, param_2 - mStageTransZ, &local_68, &local_6c);
|
|
f32 tmp2 = (dVar11 + (mRegionMinMapX[mRegionCursor] + field_0xf0c[mRegionCursor])) +
|
|
((mRegionMapSizeX[mRegionCursor] * mZoom) / 2.0f);
|
|
f32 tmp1 = (dVar10 + (mRegionMinMapY[mRegionCursor] + field_0xf2c[mRegionCursor])) +
|
|
((mRegionMapSizeY[mRegionCursor] * mZoom) / 2.0f);
|
|
|
|
field_0x11e8 = local_68 - tmp2;
|
|
field_0x11ec = local_6c - tmp1;
|
|
} else {
|
|
f32 tmp2 = (dVar11 + (mRegionMinMapX[dComIfGp_getNowLevel() - 1] +
|
|
field_0xf0c[dComIfGp_getNowLevel() - 1])) +
|
|
((mRegionMapSizeX[dComIfGp_getNowLevel() - 1] * mZoom) / 2.0f);
|
|
f32 tmp1 = (dVar10 + (mRegionMinMapY[dComIfGp_getNowLevel() - 1] +
|
|
field_0xf2c[dComIfGp_getNowLevel() - 1])) +
|
|
((mRegionMapSizeY[dComIfGp_getNowLevel() - 1] * mZoom) / 2.0f);
|
|
local_68 = tmp2 + (field_0x11e8 * mZoom);
|
|
local_6c = tmp1 + (field_0x11ec * mZoom);
|
|
}
|
|
} else {
|
|
calcAllMapPos2D(param_1 - mStageTransX, param_2 - mStageTransZ, &local_68, &local_6c);
|
|
}
|
|
|
|
if (!param_5) {
|
|
if (param_0 == 1) {
|
|
sp30 = (mMapZoomRate * 0.5f) + 0.5f;
|
|
uVar9 = 2;
|
|
}
|
|
|
|
if (param_4 != 0) {
|
|
uVar9 = 3;
|
|
}
|
|
setIconInfo(param_0, local_68, local_6c, 1.0f, param_3, sp30, uVar9);
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::setIcon2DPos(u8 param_0, char const* param_1, f32 param_2, f32 param_3,
|
|
f32 param_4, u8 param_5, bool param_6) {
|
|
setIcon2DPos(param_0, mRegionCursor, param_1, param_2, param_3, param_4, param_5, param_6);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::setIcon2DPos(u8 param_0, u8 param_1, char const* param_2, f32 param_3,
|
|
f32 param_4, f32 param_5, u8 param_6, bool param_7) {
|
|
f32 tmp1, tmp2;
|
|
calcOffset(param_1, param_2, &tmp1, &tmp2);
|
|
|
|
setIcon2DPos(param_0, param_3 + tmp1, param_4 + tmp2, param_5, param_6, param_7);
|
|
}
|
|
|
|
int dMenu_Fmap2DBack_c::isShowRegion(int param_0) {
|
|
if (param_0 == 7) {
|
|
return 1;
|
|
}
|
|
|
|
if (g_fmapHIO.mAllRegionsUnlocked) {
|
|
if (isShowRegionFlag(param_0)) {
|
|
return 1;
|
|
}
|
|
} else {
|
|
if (g_fmapHIO.mDebugRegionBits[param_0] && isShowRegionFlag(param_0)) {
|
|
return 1;
|
|
}
|
|
if (param_0 == 6) {
|
|
if (isShowRegionFlag(3) && dComIfGs_isRegionBit(4)) {
|
|
return 1;
|
|
}
|
|
if (dComIfGp_getNowLevel() == 4) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
if (isShowRegionFlag(param_0) && dComIfGs_isRegionBit(param_0 + 1)) {
|
|
return 1;
|
|
}
|
|
if (param_0 + 1 == dComIfGp_getNowLevel()) {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapAreaGlobalPosX() {
|
|
return g_fmapHIO.mMapTopLeftPosX;
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapAreaGlobalPosY() {
|
|
return g_fmapHIO.mMapTopLeftPosY;
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapAreaGlobalCenterPosX() {
|
|
return getMapAreaGlobalPosX() + (getMapAreaSizeX() / 2.0f);
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapAreaGlobalCenterPosY() {
|
|
return getMapAreaGlobalPosY() + (getMapAreaSizeY() / 2.0f);
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapAreaSizeX() {
|
|
return g_fmapHIO.mMapScale;
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapAreaSizeY() {
|
|
return g_fmapHIO.mMapScale;
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapScissorAreaLX() {
|
|
Mtx mtx;
|
|
Vec vec = mpMapArea->getGlobalVtx(mpMapArea->getPanePtr(), &mtx, 0, false, 0);
|
|
return vec.x;
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapScissorAreaLY() {
|
|
Mtx mtx;
|
|
Vec vec = mpMapArea->getGlobalVtx(mpMapArea->getPanePtr(), &mtx, 0, false, 0);
|
|
return vec.y;
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapScissorAreaSizeX() {
|
|
f32 scale = mpMapArea->getScaleX();
|
|
J2DPane* pane;
|
|
for (pane = mpMapArea->getPanePtr()->getParentPane(); pane != NULL;
|
|
pane = pane->getParentPane())
|
|
{
|
|
scale *= pane->getScaleX();
|
|
}
|
|
|
|
return scale * mpMapArea->getSizeX();
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapScissorAreaSizeRealX() {
|
|
#if PLATFORM_GCN
|
|
return getMapScissorAreaSizeX();
|
|
#else
|
|
return getMapScissorAreaSizeX() * mDoGph_gInf_c::getScale();
|
|
#endif
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapScissorAreaCenterPosX() {
|
|
return getMapScissorAreaLX() + (getMapScissorAreaSizeRealX() / 2.0f);
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapScissorAreaCenterPosY() {
|
|
return getMapScissorAreaLY() + (getMapScissorAreaSizeRealY() / 2.0f);
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapScissorAreaSizeY() {
|
|
f32 scale = mpMapArea->getScaleY();
|
|
J2DPane* pane;
|
|
for (pane = mpMapArea->getPanePtr()->getParentPane(); pane != NULL;
|
|
pane = pane->getParentPane())
|
|
{
|
|
scale *= pane->getScaleY();
|
|
}
|
|
|
|
return scale * mpMapArea->getSizeY();
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getMapScissorAreaSizeRealY() {
|
|
return getMapScissorAreaSizeY();
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::calcRenderingPos() {
|
|
calcAllMapPosWorld(getMapScissorAreaCenterPosX(), getMapScissorAreaCenterPosY(), &mRenderingPosX,
|
|
&mRenderingPosZ);
|
|
|
|
mRenderingPosX += mStageTransX;
|
|
mRenderingPosZ += mStageTransZ;
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::calcRenderingScale() {
|
|
f32 xScale = (mTexMaxX - mTexMinX) / getMapAreaSizeX();
|
|
f32 yScale = (mTexMaxZ - mTexMinZ) / getMapAreaSizeY();
|
|
|
|
f32 scale = xScale;
|
|
if (xScale < yScale) {
|
|
scale = yScale;
|
|
}
|
|
|
|
mRenderingScale = scale / mZoom;
|
|
field_0xf98 = mRenderingScale * getMapScissorAreaSizeRealY();
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getPathScale(f32 i_zoom) {
|
|
JUT_ASSERT(2204, i_zoom != 0.0f);
|
|
|
|
f32 xScale = (mTexMaxX - mTexMinX) / getMapAreaSizeX();
|
|
f32 yScale = (mTexMaxZ - mTexMinZ) / getMapAreaSizeY();
|
|
|
|
f32 scale = xScale;
|
|
if (xScale < yScale) {
|
|
scale = yScale;
|
|
}
|
|
|
|
return (scale * getMapScissorAreaSizeRealY()) / i_zoom;
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getAllMapZoomRate() {
|
|
return 1.0f;
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getRegionMapZoomRate(int i_regionNo) {
|
|
f32 tmp1, tmp2;
|
|
|
|
if (g_fmapHIO.field_0x308 == false) {
|
|
tmp1 = getMapAreaSizeX() / mRegionMapSizeX[i_regionNo];
|
|
tmp2 = getMapAreaSizeY() / mRegionMapSizeY[i_regionNo];
|
|
} else {
|
|
tmp1 = getMapAreaSizeX() /
|
|
(mRegionScrollMapMaxX[mRegionCursor] - mRegionScrollMapMinX[mRegionCursor]);
|
|
tmp2 = getMapAreaSizeY() /
|
|
(mRegionScrollMapMaxY[mRegionCursor] - mRegionScrollMapMinY[mRegionCursor]);
|
|
}
|
|
|
|
if (tmp1 < tmp2) {
|
|
field_0x122e = false;
|
|
return tmp1;
|
|
} else {
|
|
field_0x122e = true;
|
|
return tmp2;
|
|
}
|
|
}
|
|
|
|
f32 dMenu_Fmap2DBack_c::getSpotMapZoomRate() {
|
|
f32 tmp4;
|
|
f32 tmp1 = mTexMaxX - mTexMinX;
|
|
f32 tmp2 = mTexMaxZ - mTexMinZ;
|
|
|
|
f32 tmp3 = tmp1;
|
|
if (tmp3 < tmp2) {
|
|
tmp3 = tmp2;
|
|
}
|
|
tmp4 = tmp3 / g_fmapHIO.mRegionZoomRange;
|
|
return tmp4;
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::getStageOriginPath(u8 param_0, f32* param_1, f32* param_2) {
|
|
for (int i = 0; i < 20; i++) {
|
|
if (i == param_0) {
|
|
*param_1 = mStageOriginPathX[i];
|
|
*param_2 = mStageOriginPathZ[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::calcOffset(u8 i_regionNo, char const* i_stageName,
|
|
f32* o_offsetX, f32* o_offsetZ) {
|
|
if (mpStages != NULL) {
|
|
Stage_c::data* data = mpStages->mData;
|
|
for (int j = 0, i = 0; i < mStageDataNum; i++) {
|
|
if (i_regionNo + 1 == data[i].mRegionNo) {
|
|
if (strcmp(i_stageName, data[i].mName) == 0) {
|
|
*o_offsetX = mRegionOriginX[i_regionNo] + data[i].mOffsetX;
|
|
*o_offsetZ = mRegionOriginZ[i_regionNo] + data[i].mOffsetZ;
|
|
return;
|
|
} else {
|
|
j++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
*o_offsetX = mRegionOriginX[i_regionNo];
|
|
*o_offsetZ = mRegionOriginZ[i_regionNo];
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::regionTextureDraw() {
|
|
f32 local_84, local_88;
|
|
f32 dVar14 = 0.0f;
|
|
f32 dVar13 = 0.0f;
|
|
calcAllMapPosWorld(getMapScissorAreaCenterPosX(), getMapScissorAreaCenterPosY(), &local_84,
|
|
&local_88);
|
|
|
|
f32 local_8c, local_90;
|
|
calcAllMapPos2D(local_84 + mStageTransX, local_88 + mStageTransZ, &local_8c, &local_90);
|
|
|
|
dVar14 = getMapScissorAreaCenterPosX() - local_8c;
|
|
dVar13 = getMapScissorAreaCenterPosY() - local_90;
|
|
|
|
s32 uVar9 = mRegionCursor;
|
|
|
|
s32 local_94;
|
|
if (mMapZoomRate == 0.0f) {
|
|
local_94 = mSelectRegion;
|
|
} else {
|
|
local_94 = mRegionCursor;
|
|
}
|
|
|
|
if (g_fmapHIO.mDrawBackground == false) {
|
|
return;
|
|
}
|
|
|
|
for (int iVar8 = 0; iVar8 < 8; iVar8++) {
|
|
s32 uVar10 = field_0x1230[iVar8];
|
|
if (uVar10 != 0xff && mpAreaTex[uVar10] != NULL) {
|
|
f32 fVar3;
|
|
if (isShowRegion(uVar10)) {
|
|
if (uVar10 != local_94) {
|
|
mpAreaTex[uVar10]->setBlackWhite(mUnselectedRegionBlack, mUnselectedRegionWhite);
|
|
fVar3 = field_0x1214;
|
|
|
|
} else {
|
|
mpAreaTex[uVar10]->setBlackWhite(mSelectedRegionBlack, mSelectedRegionWhite);
|
|
fVar3 = field_0x1210;
|
|
}
|
|
} else {
|
|
mpAreaTex[uVar10]->setBlackWhite(mUnreachedRegionBlack, mUnreachedRegionWhite);
|
|
fVar3 = 0.5f;
|
|
}
|
|
|
|
mpAreaTex[uVar10]->setAlpha(mAlphaRate * 255.0f * fVar3 * field_0xfa4);
|
|
|
|
if (uVar10 != uVar9) {
|
|
bool b = 0;
|
|
f32 v = mTransX + (dVar14 + (mRegionMinMapX[uVar10] + field_0xf0c[uVar10]));
|
|
mpAreaTex[uVar10]->draw(
|
|
v, mTransZ + (dVar13 + (mRegionMinMapY[uVar10] + field_0xf2c[uVar10])),
|
|
mRegionMapSizeX[uVar10] * mZoom, mRegionMapSizeY[uVar10] * mZoom, b, false,
|
|
false);
|
|
} else {
|
|
bool b = 0;
|
|
f32 v = mTransX + (dVar14 + (mRegionMinMapX[uVar9] + field_0xf0c[uVar9]));
|
|
mpAreaTex[uVar9]->draw(
|
|
v, mTransZ + (dVar13 + (mRegionMinMapY[uVar9] + field_0xf2c[uVar9])),
|
|
mRegionMapSizeX[uVar9] * mZoom, mRegionMapSizeY[uVar9] * mZoom, b, false,
|
|
false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::stageTextureDraw() {
|
|
if (mAllPathShowFlag) {
|
|
mpSpotTexture->setAlpha(mAlphaRate * 255.0f * mSpotTextureFadeAlpha);
|
|
} else {
|
|
mpSpotTexture->setAlpha(mAlphaRate * 255.0f * field_0xfa8 * mSpotTextureFadeAlpha);
|
|
}
|
|
|
|
mpSpotTexture->draw(mTransX + getMapScissorAreaLX(), mTransZ + getMapScissorAreaLY(),
|
|
getMapScissorAreaSizeRealX(), getMapScissorAreaSizeRealY(), false, false,
|
|
false);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::worldGridDraw() {
|
|
f32 local_74, local_78;
|
|
|
|
f32 xPos, yPos;
|
|
f32 dVar9 = -mStageTransX;
|
|
f32 dVar8 = -mStageTransZ;
|
|
calcAllMapPos2D(dVar9, dVar8, &local_74, &local_78);
|
|
|
|
J2DDrawLine(local_74, mDoGph_gInf_c::getMinYF(), local_74,
|
|
mDoGph_gInf_c::getMinYF() + mDoGph_gInf_c::getHeightF(),
|
|
JUtility::TColor(255, 255, 255, 255), 6);
|
|
|
|
xPos = dVar9 - g_fmapHIO.mWorldGridWidth;
|
|
while (true) {
|
|
calcAllMapPos2D(xPos, dVar8, &local_74, &local_78);
|
|
if (local_74 >= getMapScissorAreaLX()) {
|
|
J2DDrawLine(local_74, mDoGph_gInf_c::getMinYF(), local_74,
|
|
mDoGph_gInf_c::getMinYF() + mDoGph_gInf_c::getHeightF(),
|
|
JUtility::TColor(255, 255, 255, 255), 6);
|
|
xPos -= g_fmapHIO.mWorldGridWidth;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
xPos = dVar9 + g_fmapHIO.mWorldGridWidth;
|
|
while (true) {
|
|
calcAllMapPos2D(xPos, dVar8, &local_74, &local_78);
|
|
if (local_74 <= getMapScissorAreaLX() + getMapScissorAreaSizeRealX()) {
|
|
J2DDrawLine(local_74, mDoGph_gInf_c::getMinYF(), local_74,
|
|
mDoGph_gInf_c::getMinYF() + mDoGph_gInf_c::getHeightF(),
|
|
JUtility::TColor(255, 255, 255, 255), 6);
|
|
xPos += g_fmapHIO.mWorldGridWidth;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
J2DDrawLine(mDoGph_gInf_c::getMinXF(), local_78,
|
|
mDoGph_gInf_c::getMinXF() + mDoGph_gInf_c::getWidthF(), local_78,
|
|
JUtility::TColor(255, 255, 255, 255), 6);
|
|
|
|
yPos = dVar8 - g_fmapHIO.mWorldGridWidth;
|
|
while (true) {
|
|
calcAllMapPos2D(dVar9, yPos, &local_74, &local_78);
|
|
if (local_78 >= getMapScissorAreaLY()) {
|
|
J2DDrawLine(mDoGph_gInf_c::getMinXF(), local_78,
|
|
mDoGph_gInf_c::getMinXF() + mDoGph_gInf_c::getWidthF(), local_78,
|
|
JUtility::TColor(255, 255, 255, 255), 6);
|
|
yPos -= g_fmapHIO.mWorldGridWidth;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
yPos = dVar8 + g_fmapHIO.mWorldGridWidth;
|
|
while (true) {
|
|
calcAllMapPos2D(dVar9, yPos, &local_74, &local_78);
|
|
if (local_78 <= getMapScissorAreaLY() + getMapScissorAreaSizeRealY()) {
|
|
J2DDrawLine(mDoGph_gInf_c::getMinXF(), local_78,
|
|
mDoGph_gInf_c::getMinXF() + mDoGph_gInf_c::getWidthF(), local_78,
|
|
JUtility::TColor(255, 255, 255, 255), 6);
|
|
yPos += g_fmapHIO.mWorldGridWidth;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::regionGridDraw() {
|
|
f32 local_74, local_78;
|
|
|
|
f32 xPos, yPos;
|
|
f32 dVar9 = mRegionOriginX[mRegionCursor] - mStageTransX;
|
|
f32 dVar8 = mRegionOriginZ[mRegionCursor] - mStageTransZ;
|
|
calcAllMapPos2D(dVar9, dVar8, &local_74, &local_78);
|
|
|
|
J2DDrawLine(local_74, mDoGph_gInf_c::getMinYF(), local_74,
|
|
mDoGph_gInf_c::getMinYF() + mDoGph_gInf_c::getHeightF(),
|
|
JUtility::TColor(180, 0, 0, 255), 6);
|
|
|
|
xPos = dVar9 - g_fmapHIO.mRegionGridWidth;
|
|
while (true) {
|
|
calcAllMapPos2D(xPos, dVar8, &local_74, &local_78);
|
|
if (local_74 >= getMapScissorAreaLX()) {
|
|
J2DDrawLine(local_74, mDoGph_gInf_c::getMinYF(), local_74,
|
|
mDoGph_gInf_c::getMinYF() + mDoGph_gInf_c::getHeightF(),
|
|
JUtility::TColor(180, 0, 0, 255), 6);
|
|
xPos -= g_fmapHIO.mRegionGridWidth;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
xPos = dVar9 + g_fmapHIO.mRegionGridWidth;
|
|
while (true) {
|
|
calcAllMapPos2D(xPos, dVar8, &local_74, &local_78);
|
|
if (local_74 <= getMapScissorAreaLX() + getMapScissorAreaSizeRealX()) {
|
|
J2DDrawLine(local_74, mDoGph_gInf_c::getMinYF(), local_74,
|
|
mDoGph_gInf_c::getMinYF() + mDoGph_gInf_c::getHeightF(),
|
|
JUtility::TColor(180, 0, 0, 255), 6);
|
|
xPos += g_fmapHIO.mRegionGridWidth;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
J2DDrawLine(mDoGph_gInf_c::getMinXF(), local_78,
|
|
mDoGph_gInf_c::getMinXF() + mDoGph_gInf_c::getWidthF(), local_78,
|
|
JUtility::TColor(180, 0, 0, 255), 6);
|
|
|
|
yPos = dVar8 - g_fmapHIO.mRegionGridWidth;
|
|
while (true) {
|
|
calcAllMapPos2D(dVar9, yPos, &local_74, &local_78);
|
|
if (local_78 >= getMapScissorAreaLY()) {
|
|
J2DDrawLine(mDoGph_gInf_c::getMinXF(), local_78,
|
|
mDoGph_gInf_c::getMinXF() + mDoGph_gInf_c::getWidthF(), local_78,
|
|
JUtility::TColor(180, 0, 0, 255), 6);
|
|
yPos -= g_fmapHIO.mRegionGridWidth;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
yPos = dVar8 + g_fmapHIO.mRegionGridWidth;
|
|
while (true) {
|
|
calcAllMapPos2D(dVar9, yPos, &local_74, &local_78);
|
|
if (local_78 <= getMapScissorAreaLY() + getMapScissorAreaSizeRealY()) {
|
|
J2DDrawLine(mDoGph_gInf_c::getMinXF(), local_78,
|
|
mDoGph_gInf_c::getMinXF() + mDoGph_gInf_c::getWidthF(), local_78,
|
|
JUtility::TColor(180, 0, 0, 255), 6);
|
|
yPos += g_fmapHIO.mRegionGridWidth;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// needed to make sdata2 match
|
|
static f32 dummy(int param_0) {
|
|
return param_0;
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::worldOriginDraw() {
|
|
f32 local_44, local_48;
|
|
calcAllMapPos2D(-mStageTransX, -mStageTransZ, &local_44, &local_48);
|
|
|
|
J2DDrawLine(mDoGph_gInf_c::getMinXF(), local_48 - local_44 + mDoGph_gInf_c::getMinXF(),
|
|
mDoGph_gInf_c::getMinXF() + mDoGph_gInf_c::getWidthF(),
|
|
local_48 - local_44 + (mDoGph_gInf_c::getMinXF() + mDoGph_gInf_c::getWidthF()),
|
|
JUtility::TColor(0, 255, 0, 255), 6);
|
|
|
|
J2DDrawLine(mDoGph_gInf_c::getMinXF(), local_48 + local_44 + -mDoGph_gInf_c::getMinXF(),
|
|
mDoGph_gInf_c::getMinXF() + mDoGph_gInf_c::getWidthF(),
|
|
local_48 + local_44 + -(mDoGph_gInf_c::getMinXF() + mDoGph_gInf_c::getWidthF()),
|
|
JUtility::TColor(0, 255, 0, 255), 6);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::scrollAreaDraw() {
|
|
for (int i = 0; i < 8; i++) {
|
|
if (mMapZoomRate != 0.0f && i != mRegionCursor) {
|
|
continue;
|
|
}
|
|
|
|
f32 x_min, z_min, x_max, z_max;
|
|
if (g_fmapHIO.mScrollRangeDebugON) {
|
|
x_min = g_fmapHIO.mRegionScrollRangeMinX[i];
|
|
z_min = g_fmapHIO.mRegionScrollRangeMinZ[i];
|
|
x_max = g_fmapHIO.mRegionScrollRangeMaxX[i];
|
|
z_max = g_fmapHIO.mRegionScrollRangeMaxZ[i];
|
|
} else {
|
|
x_min = mRegionScrollMinX[i];
|
|
z_min = mRegionScrollMinZ[i];
|
|
x_max = mRegionScrollMaxX[i];
|
|
z_max = mRegionScrollMaxZ[i];
|
|
}
|
|
|
|
f32 local_4c, local_50, local_54, local_58;
|
|
calcAllMapPos2D(x_min - mStageTransX, z_min - mStageTransZ, &local_4c, &local_50);
|
|
calcAllMapPos2D(x_max - mStageTransX, z_max - mStageTransZ, &local_54, &local_58);
|
|
|
|
J2DDrawLine(local_4c, local_50, local_4c, local_58,
|
|
JUtility::TColor(255, 255, 255, 255), 6);
|
|
J2DDrawLine(local_54, local_50, local_54, local_58,
|
|
JUtility::TColor(255, 255, 255, 255), 6);
|
|
J2DDrawLine(local_4c, local_50, local_54, local_50,
|
|
JUtility::TColor(255, 255, 255, 255), 6);
|
|
J2DDrawLine(local_4c, local_58, local_54, local_58,
|
|
JUtility::TColor(255, 255, 255, 255), 6);
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::regionOriginDraw() {
|
|
for (int i = 0; i < 8; i++) {
|
|
if (!mpAreaTex[i]) {
|
|
continue;
|
|
}
|
|
|
|
f32 center_x, center_y;
|
|
calcAllMapPos2D(mRegionOriginX[i] - mStageTransX, mRegionOriginZ[i] - mStageTransZ,
|
|
¢er_x, ¢er_y);
|
|
J2DFillBox(center_x - 3.0f, center_y - 3.0f, 6.0f, 6.0f, JUtility::TColor(255, 0, 0, 255));
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::stageOriginDraw() {
|
|
if (!mpStages) {
|
|
return;
|
|
}
|
|
|
|
dMenuMapCommon_c::Stage_c::data* stage_data = mpStages->mData;
|
|
|
|
for (int i = 0; i < mStageDataNum; i++) {
|
|
if (mRegionCursor + 1 == stage_data[i].mRegionNo) {
|
|
f32 center_x, center_y;
|
|
f32 v1 = mRegionOriginX[mRegionCursor] + stage_data[i].mOffsetX - mStageTransX;
|
|
f32 v2 = mRegionOriginZ[mRegionCursor] + stage_data[i].mOffsetZ - mStageTransZ;
|
|
calcAllMapPos2D(v1, v2, ¢er_x, ¢er_y);
|
|
J2DFillBox(center_x - 3.0f, center_y - 3.0f, 6.0f, 6.0f,
|
|
JUtility::TColor(0, 0, 255, 255));
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::calcBlink() {
|
|
f32 t;
|
|
int i;
|
|
if (mMapZoomRate <= 1.0f) {
|
|
t = mMapZoomRate;
|
|
i = 0;
|
|
} else {
|
|
t = mMapZoomRate - 1.0f;
|
|
i = 1;
|
|
}
|
|
|
|
mSelectedRegionBlack.r = g_fmapHIO.mMapBlink[i].mSelectedRegion.mBlack.r
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mSelectedRegion.mBlack.r
|
|
- g_fmapHIO.mMapBlink[i].mSelectedRegion.mBlack.r);
|
|
mSelectedRegionBlack.g = g_fmapHIO.mMapBlink[i].mSelectedRegion.mBlack.g
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mSelectedRegion.mBlack.g
|
|
- g_fmapHIO.mMapBlink[i].mSelectedRegion.mBlack.g);
|
|
mSelectedRegionBlack.b = g_fmapHIO.mMapBlink[i].mSelectedRegion.mBlack.b
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mSelectedRegion.mBlack.b
|
|
- g_fmapHIO.mMapBlink[i].mSelectedRegion.mBlack.b);
|
|
mSelectedRegionBlack.a = g_fmapHIO.mMapBlink[i].mSelectedRegion.mBlack.a
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mSelectedRegion.mBlack.a
|
|
- g_fmapHIO.mMapBlink[i].mSelectedRegion.mBlack.a);
|
|
mSelectedRegionWhite.r = g_fmapHIO.mMapBlink[i].mSelectedRegion.mWhite.r
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mSelectedRegion.mWhite.r
|
|
- g_fmapHIO.mMapBlink[i].mSelectedRegion.mWhite.r);
|
|
mSelectedRegionWhite.g = g_fmapHIO.mMapBlink[i].mSelectedRegion.mWhite.g
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mSelectedRegion.mWhite.g
|
|
- g_fmapHIO.mMapBlink[i].mSelectedRegion.mWhite.g);
|
|
mSelectedRegionWhite.b = g_fmapHIO.mMapBlink[i].mSelectedRegion.mWhite.b
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mSelectedRegion.mWhite.b
|
|
- g_fmapHIO.mMapBlink[i].mSelectedRegion.mWhite.b);
|
|
mSelectedRegionWhite.a = g_fmapHIO.mMapBlink[i].mSelectedRegion.mWhite.a
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mSelectedRegion.mWhite.a
|
|
- g_fmapHIO.mMapBlink[i].mSelectedRegion.mWhite.a);
|
|
mUnselectedRegionBlack.r = g_fmapHIO.mMapBlink[i].mUnselectedRegion.mBlack.r
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnselectedRegion.mBlack.r
|
|
- g_fmapHIO.mMapBlink[i].mUnselectedRegion.mBlack.r);
|
|
mUnselectedRegionBlack.g = g_fmapHIO.mMapBlink[i].mUnselectedRegion.mBlack.g
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnselectedRegion.mBlack.g
|
|
- g_fmapHIO.mMapBlink[i].mUnselectedRegion.mBlack.g);
|
|
mUnselectedRegionBlack.b = g_fmapHIO.mMapBlink[i].mUnselectedRegion.mBlack.b
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnselectedRegion.mBlack.b
|
|
- g_fmapHIO.mMapBlink[i].mUnselectedRegion.mBlack.b);
|
|
mUnselectedRegionBlack.a = g_fmapHIO.mMapBlink[i].mUnselectedRegion.mBlack.a
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnselectedRegion.mBlack.a
|
|
- g_fmapHIO.mMapBlink[i].mUnselectedRegion.mBlack.a);
|
|
mUnselectedRegionWhite.r = g_fmapHIO.mMapBlink[i].mUnselectedRegion.mWhite.r
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnselectedRegion.mWhite.r
|
|
- g_fmapHIO.mMapBlink[i].mUnselectedRegion.mWhite.r);
|
|
mUnselectedRegionWhite.g = g_fmapHIO.mMapBlink[i].mUnselectedRegion.mWhite.g
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnselectedRegion.mWhite.g
|
|
- g_fmapHIO.mMapBlink[i].mUnselectedRegion.mWhite.g);
|
|
mUnselectedRegionWhite.b = g_fmapHIO.mMapBlink[i].mUnselectedRegion.mWhite.b
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnselectedRegion.mWhite.b
|
|
- g_fmapHIO.mMapBlink[i].mUnselectedRegion.mWhite.b);
|
|
mUnselectedRegionWhite.a = g_fmapHIO.mMapBlink[i].mUnselectedRegion.mWhite.a
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnselectedRegion.mWhite.a
|
|
- g_fmapHIO.mMapBlink[i].mUnselectedRegion.mWhite.a);
|
|
mUnreachedRegionBlack.r = g_fmapHIO.mMapBlink[i].mUnreachedRegionBlack.r
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnreachedRegionBlack.r
|
|
- g_fmapHIO.mMapBlink[i].mUnreachedRegionBlack.r);
|
|
mUnreachedRegionBlack.g = g_fmapHIO.mMapBlink[i].mUnreachedRegionBlack.g
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnreachedRegionBlack.g
|
|
- g_fmapHIO.mMapBlink[i].mUnreachedRegionBlack.g);
|
|
mUnreachedRegionBlack.b = g_fmapHIO.mMapBlink[i].mUnreachedRegionBlack.b
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnreachedRegionBlack.b
|
|
- g_fmapHIO.mMapBlink[i].mUnreachedRegionBlack.b);
|
|
mUnreachedRegionBlack.a = g_fmapHIO.mMapBlink[i].mUnreachedRegionBlack.a
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnreachedRegionBlack.a
|
|
- g_fmapHIO.mMapBlink[i].mUnreachedRegionBlack.a);
|
|
mUnreachedRegionWhite.r = g_fmapHIO.mMapBlink[i].mUnreachedRegionWhite.r
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnreachedRegionWhite.r
|
|
- g_fmapHIO.mMapBlink[i].mUnreachedRegionWhite.r);
|
|
mUnreachedRegionWhite.g = g_fmapHIO.mMapBlink[i].mUnreachedRegionWhite.g
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnreachedRegionWhite.g
|
|
- g_fmapHIO.mMapBlink[i].mUnreachedRegionWhite.g);
|
|
mUnreachedRegionWhite.b = g_fmapHIO.mMapBlink[i].mUnreachedRegionWhite.b
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnreachedRegionWhite.b
|
|
- g_fmapHIO.mMapBlink[i].mUnreachedRegionWhite.b);
|
|
mUnreachedRegionWhite.a = g_fmapHIO.mMapBlink[i].mUnreachedRegionWhite.a
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].mUnreachedRegionWhite.a
|
|
- g_fmapHIO.mMapBlink[i].mUnreachedRegionWhite.a);
|
|
field_0x1208.r = g_fmapHIO.mMapBlink[i].field_0x20.r
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].field_0x20.r
|
|
- g_fmapHIO.mMapBlink[i].field_0x20.r);
|
|
field_0x1208.g = g_fmapHIO.mMapBlink[i].field_0x20.g
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].field_0x20.g
|
|
- g_fmapHIO.mMapBlink[i].field_0x20.g);
|
|
field_0x1208.b = g_fmapHIO.mMapBlink[i].field_0x20.b
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].field_0x20.b
|
|
- g_fmapHIO.mMapBlink[i].field_0x20.b);
|
|
field_0x1208.a = g_fmapHIO.mMapBlink[i].field_0x20.a
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].field_0x20.a
|
|
- g_fmapHIO.mMapBlink[i].field_0x20.a);
|
|
field_0x120c.r = g_fmapHIO.mMapBlink[i].field_0x24.r
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].field_0x24.r
|
|
- g_fmapHIO.mMapBlink[i].field_0x24.r);
|
|
field_0x120c.g = g_fmapHIO.mMapBlink[i].field_0x24.g
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].field_0x24.g
|
|
- g_fmapHIO.mMapBlink[i].field_0x24.g);
|
|
field_0x120c.b = g_fmapHIO.mMapBlink[i].field_0x24.b
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].field_0x24.b
|
|
- g_fmapHIO.mMapBlink[i].field_0x24.b);
|
|
field_0x120c.a = g_fmapHIO.mMapBlink[i].field_0x24.a
|
|
+ t * (g_fmapHIO.mMapBlink[i + 1].field_0x24.a
|
|
- g_fmapHIO.mMapBlink[i].field_0x24.a);
|
|
|
|
f32 selected_max, selected_min, unselected_max, unselected_min;
|
|
f32 tmp_selected_min = g_fmapHIO.mMapBlink[i].mSelectedRegion.mMin / 255.0f;
|
|
f32 tmp_selected_max = g_fmapHIO.mMapBlink[i].mSelectedRegion.mMax / 255.0f;
|
|
f32 tmp_unselected_min = g_fmapHIO.mMapBlink[i].mUnselectedRegion.mMin / 255.0f;
|
|
f32 tmp_unselected_max = g_fmapHIO.mMapBlink[i].mUnselectedRegion.mMax / 255.0f;
|
|
|
|
f32 sp20 = g_fmapHIO.mMapBlink[i + 1].mSelectedRegion.mMin / 255.0f;
|
|
f32 sp1C = g_fmapHIO.mMapBlink[i + 1].mSelectedRegion.mMax / 255.0f;
|
|
f32 sp18 = g_fmapHIO.mMapBlink[i + 1].mUnselectedRegion.mMin / 255.0f;
|
|
f32 sp14 = g_fmapHIO.mMapBlink[i + 1].mUnselectedRegion.mMax / 255.0f;
|
|
|
|
selected_max = tmp_selected_max + t * (sp1C - tmp_selected_max);
|
|
selected_min = tmp_selected_min + t * (sp20 - tmp_selected_min);
|
|
|
|
s16 selected_blink_speed = g_fmapHIO.mMapBlink[i].mSelectedRegion.mBlinkSpeed +
|
|
t * (g_fmapHIO.mMapBlink[i + 1].mSelectedRegion.mBlinkSpeed -
|
|
g_fmapHIO.mMapBlink[i].mSelectedRegion.mBlinkSpeed);
|
|
|
|
unselected_max = tmp_unselected_max + t * (sp14 - tmp_unselected_max);
|
|
unselected_min = tmp_unselected_min + t * (sp18 - tmp_unselected_min);
|
|
|
|
s16 unselected_blink_speed = g_fmapHIO.mMapBlink[i].mUnselectedRegion.mBlinkSpeed +
|
|
t * (g_fmapHIO.mMapBlink[i + 1].mUnselectedRegion.mBlinkSpeed -
|
|
g_fmapHIO.mMapBlink[i].mUnselectedRegion.mBlinkSpeed);
|
|
|
|
field_0x1218++;
|
|
if (field_0x1218 >= selected_blink_speed) {
|
|
field_0x1218 = 0;
|
|
}
|
|
|
|
field_0x121a++;
|
|
if (field_0x121a >= unselected_blink_speed) {
|
|
field_0x121a = 0;
|
|
}
|
|
|
|
f32 t_selected = 0.0f;
|
|
f32 t_unselected = 0.0f;
|
|
|
|
if (selected_blink_speed > 0.0f) {
|
|
if (field_0x1218 < selected_blink_speed * 0.5f) {
|
|
t_selected = field_0x1218 / (selected_blink_speed * 0.5f);
|
|
} else {
|
|
t_selected = (selected_blink_speed - field_0x1218) / (selected_blink_speed * 0.5f);
|
|
}
|
|
}
|
|
|
|
if (unselected_blink_speed > 0.0f) {
|
|
if (field_0x121a < unselected_blink_speed * 0.5f) {
|
|
t_unselected = field_0x121a / (unselected_blink_speed * 0.5f);
|
|
} else {
|
|
t_unselected = (unselected_blink_speed - field_0x121a) / (unselected_blink_speed * 0.5f);
|
|
}
|
|
}
|
|
|
|
field_0x1210 = selected_min + t_selected * (selected_max - selected_min);
|
|
field_0x1214 = unselected_min + t_unselected * (unselected_max - unselected_min);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::calcBackAlpha(bool param_0) {
|
|
if (param_0) {
|
|
if (mBackAlpha != 1.0f) {
|
|
cLib_addCalc2(&mBackAlpha, 1.0f, 0.4f, 0.5f);
|
|
if (std::fabs(mBackAlpha - 1.0f) < 0.1f) {
|
|
mBackAlpha = 1.0f;
|
|
}
|
|
}
|
|
} else {
|
|
if (mBackAlpha != 0.0f) {
|
|
cLib_addCalc2(&mBackAlpha, 0.0f, 0.4f, 0.5f);
|
|
if (std::fabs(mBackAlpha) < 0.1f) {
|
|
mBackAlpha = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::btkAnimeLoop(f32 i_step) {
|
|
if (mpBaseAnm) {
|
|
mAnmFrame += i_step;
|
|
if (mAnmFrame >= mpBaseAnm->getFrameMax()) {
|
|
mAnmFrame -= mpBaseAnm->getFrameMax();
|
|
}
|
|
mpBaseAnm->setFrame(mAnmFrame);
|
|
} else {
|
|
mAnmFrame = 0.0f;
|
|
}
|
|
|
|
mpBaseScreen->search('gold00_0')->setAnimation(mpBaseAnm);
|
|
mpBaseScreen->search('gold00_1')->setAnimation(mpBaseAnm);
|
|
mpBaseScreen->animation();
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::setBaseBackAlpha(u8 param_0) {
|
|
mpMapBlack->setAlpha(param_0);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::regionMapMove(STControl* i_stick) {
|
|
f32 min_x, min_y, max_x, max_y;
|
|
calcAllMapPosWorld(getMapScissorAreaLX(), getMapScissorAreaLY(), &min_x, &min_y);
|
|
calcAllMapPosWorld(getMapScissorAreaLX() + getMapScissorAreaSizeRealX(),
|
|
getMapScissorAreaLY() + getMapScissorAreaSizeRealY(), &max_x, &max_y);
|
|
int r27 = 0;
|
|
if (r27 == 0) {
|
|
f32 slow_bound = g_fmapHIO.mScrollSpeedSlowBound < g_fmapHIO.mScrollSpeedFastBound ?
|
|
g_fmapHIO.mScrollSpeedSlowBound :
|
|
g_fmapHIO.mScrollSpeedFastBound;
|
|
f32 fast_bound = g_fmapHIO.mScrollSpeedSlowBound > g_fmapHIO.mScrollSpeedFastBound ?
|
|
g_fmapHIO.mScrollSpeedSlowBound :
|
|
g_fmapHIO.mScrollSpeedFastBound;
|
|
|
|
f32 stick_value = i_stick->getValueStick();
|
|
if (stick_value >= slow_bound) {
|
|
s16 angle = i_stick->getAngleStick();
|
|
f32 local_68 = mTexMaxX - mTexMinX;
|
|
f32 spot_zoom = getSpotMapZoomRate();
|
|
f32 region_zoom = getRegionMapZoomRate(mRegionCursor);
|
|
f32 zoom = region_zoom + (mMapZoomRate - 1.0f) * (spot_zoom - region_zoom);
|
|
f32 local_78 = local_68 / zoom;
|
|
f32 base_speed;
|
|
if (stick_value < fast_bound) {
|
|
base_speed = g_fmapHIO.mScrollSpeedRegionSlow;
|
|
} else {
|
|
base_speed = g_fmapHIO.mScrollSpeedRegionFast;
|
|
}
|
|
f32 speed = base_speed / 100.0f * local_78;
|
|
f32 speed_y = speed * cM_ssin(angle);
|
|
f32 speed_x = speed * cM_scos(angle);
|
|
control_xpos += speed_y;
|
|
control_ypos += speed_x;
|
|
}
|
|
}
|
|
|
|
if (mArrowPos3DX + control_xpos < min_x) {
|
|
control_xpos = min_x - mArrowPos3DX;
|
|
}
|
|
if (mArrowPos3DX + control_xpos > max_x) {
|
|
control_xpos = max_x - mArrowPos3DX;
|
|
}
|
|
if (mArrowPos3DZ + control_ypos < min_y) {
|
|
control_ypos = min_y - mArrowPos3DZ;
|
|
}
|
|
if (mArrowPos3DZ + control_ypos > max_y) {
|
|
control_ypos = max_y - mArrowPos3DZ;
|
|
}
|
|
|
|
calcRenderingScale();
|
|
calcRenderingPos();
|
|
|
|
f32 pos_x, pos_y;
|
|
calcAllMapPos2D(mArrowPos3DX + control_xpos - mStageTransX,
|
|
mArrowPos3DZ + control_ypos - mStageTransZ, &pos_x, &pos_y);
|
|
|
|
mSelectRegion = 0xff;
|
|
int region = mRegionCursor;
|
|
if (region != 0xff && region != 7) {
|
|
u8 pix = dMeter2Info_getPixel(
|
|
pos_x, pos_y, mRegionMinMapX[region] + field_0xf0c[region] + mTransX,
|
|
mRegionMinMapY[region] + field_0xf2c[region] + mTransZ, mRegionMapSizeX[region] * mZoom,
|
|
mRegionMapSizeY[region] * mZoom, mpAreaTex[region]->getTexture(0)->getTexInfo());
|
|
if (pix) {
|
|
mSelectRegion = region;
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::stageMapMove(STControl* i_stick, u8 param_1, bool param_2) {
|
|
(void)param_1;
|
|
|
|
f32 slow_bound = g_fmapHIO.mScrollSpeedSlowBound < g_fmapHIO.mScrollSpeedFastBound ?
|
|
g_fmapHIO.mScrollSpeedSlowBound : g_fmapHIO.mScrollSpeedFastBound;
|
|
f32 fast_bound = g_fmapHIO.mScrollSpeedSlowBound > g_fmapHIO.mScrollSpeedFastBound ?
|
|
g_fmapHIO.mScrollSpeedSlowBound : g_fmapHIO.mScrollSpeedFastBound;
|
|
|
|
f32 min_x, min_y, max_x, max_y;
|
|
f32 stick_value = i_stick->getValueStick();
|
|
bool bVar6 = false;
|
|
f32 trans_x = mStageTransX;
|
|
f32 trans_z = mStageTransZ;
|
|
|
|
if (stick_value >= slow_bound && param_2 && field_0x1238 != 2) {
|
|
bVar6 = true;
|
|
s16 angle = i_stick->getAngleStick();
|
|
f32 local_68 = mTexMaxX - mTexMinX;
|
|
f32 spot_zoom = getSpotMapZoomRate();
|
|
f32 region_zoom = getRegionMapZoomRate(mRegionCursor);
|
|
f32 zoom = region_zoom + (mMapZoomRate - 1.0f) * (spot_zoom - region_zoom);
|
|
f32 local_78 = local_68 / zoom;
|
|
f32 base_speed;
|
|
if (stick_value < fast_bound) {
|
|
base_speed = g_fmapHIO.mScrollSpeedRegionZoomSlow;
|
|
} else {
|
|
base_speed = g_fmapHIO.mScrollSpeedRegionZoomFast;
|
|
}
|
|
f32 speed = base_speed / 100.0f * local_78;
|
|
f32 speed_x = speed * cM_ssin(angle);
|
|
f32 speed_z = speed * cM_scos(angle);
|
|
mStageTransX += speed_x;
|
|
mStageTransZ += speed_z;
|
|
} else if (!param_2) {
|
|
return;
|
|
}
|
|
f32 center_x, center_y;
|
|
calcAllMapPosWorld(getMapAreaGlobalCenterPosX(), getMapAreaGlobalCenterPosY(),
|
|
¢er_x, ¢er_y);
|
|
calcAllMapPosWorld(getMapScissorAreaLX(), getMapScissorAreaLY(), &min_x, &min_y);
|
|
|
|
if (g_fmapHIO.mScrollRangeDebugON) {
|
|
min_x = g_fmapHIO.mRegionScrollRangeMinX[mRegionCursor];
|
|
min_y = g_fmapHIO.mRegionScrollRangeMinZ[mRegionCursor];
|
|
max_x = g_fmapHIO.mRegionScrollRangeMaxX[mRegionCursor];
|
|
max_y = g_fmapHIO.mRegionScrollRangeMaxZ[mRegionCursor];
|
|
} else {
|
|
min_x = mRegionScrollMinX[mRegionCursor];
|
|
min_y = mRegionScrollMinZ[mRegionCursor];
|
|
max_x = mRegionScrollMaxX[mRegionCursor];
|
|
max_y = mRegionScrollMaxZ[mRegionCursor];
|
|
}
|
|
|
|
if (center_x < min_x - mStageTransX) {
|
|
mStageTransX = -(center_x - min_x);
|
|
}
|
|
if (center_x > max_x - mStageTransX) {
|
|
mStageTransX = -(center_x - max_x);
|
|
}
|
|
if (center_y < min_y - mStageTransZ) {
|
|
mStageTransZ = -(center_y - min_y);
|
|
}
|
|
if (center_y > max_y - mStageTransZ) {
|
|
mStageTransZ = -(center_y - max_y);
|
|
}
|
|
|
|
if (bVar6 && (trans_x != mStageTransX || trans_z != mStageTransZ)) {
|
|
Z2GetAudioMgr()->seStartLevel(Z2SE_SY_MAP_SCROLL, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
|
|
}
|
|
|
|
field_0xfd8 = mStageTransX - field_0xfd0;
|
|
field_0xfdc = mStageTransZ - field_0xfd4;
|
|
control_xpos = mStageTransX + (field_0x11b4 - mArrowPos3DX);
|
|
control_ypos = mStageTransZ + (field_0x11b8 - mArrowPos3DZ);
|
|
|
|
calcRenderingScale();
|
|
calcRenderingPos();
|
|
|
|
field_0x122d = 0;
|
|
if (mStageTransX > -(center_x - min_x)) {
|
|
field_0x122d |= (u8)1;
|
|
}
|
|
if (mStageTransX < -(center_x - max_x)) {
|
|
field_0x122d |= (u8)4;
|
|
}
|
|
if (mStageTransZ > -(center_y - min_y)) {
|
|
field_0x122d |= (u8)8;
|
|
}
|
|
if (mStageTransZ < -(center_y - max_y)) {
|
|
field_0x122d |= (u8)2;
|
|
}
|
|
|
|
mpMeterHaihai->_execute(0);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::setAllAlphaRate(f32 i_rate, bool i_init) {
|
|
mAlphaRate = i_rate;
|
|
if (i_init) {
|
|
mpBaseRoot->setBackupAlpha();
|
|
}
|
|
mpBaseRoot->setAlphaMorfRate(i_rate);
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::drawDebugStageArea() {
|
|
JUtility::TColor colors[6] = {
|
|
JUtility::TColor(255, 255, 0, 50),
|
|
JUtility::TColor(255, 0, 255, 50),
|
|
JUtility::TColor(0, 255, 255, 50),
|
|
JUtility::TColor(255, 0, 0, 50),
|
|
JUtility::TColor(0, 255, 0, 50),
|
|
JUtility::TColor(0, 0, 255, 50),
|
|
};
|
|
|
|
if (mpFmapMap && mpRegionData) {
|
|
for (int i = 0; i < mDoGph_gInf_c::getWidthF(); i += g_fmapHIO.mRangeCheckInterval + 1) {
|
|
for (int j = 0; j < mDoGph_gInf_c::getHeightF(); j += g_fmapHIO.mRangeCheckInterval + 1)
|
|
{
|
|
int stage_no;
|
|
mpFmapMap->getPointStagePathInnerNo(mpRegionData,
|
|
i - mDoGph_gInf_c::getWidthF() / 2.0f,
|
|
j - mDoGph_gInf_c::getHeightF() / 2.0f,
|
|
field_0x1244, &stage_no, NULL);
|
|
if (stage_no >= 0) {
|
|
f32 v = i + mDoGph_gInf_c::getMinXF();
|
|
f32 v2 = j;
|
|
J2DFillBox(v - 3.0f, v2 - 3.0f, 6.0f, 6.0f, colors[stage_no % 6]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::drawDebugRegionArea() {
|
|
if (mZoom != getAllMapZoomRate()) {
|
|
}
|
|
|
|
JUtility::TColor colors[7] = {
|
|
JUtility::TColor(255, 255, 0, 50),
|
|
JUtility::TColor(255, 0, 255, 50),
|
|
JUtility::TColor(0, 255, 255, 50),
|
|
JUtility::TColor(255, 0, 0, 50),
|
|
JUtility::TColor(0, 255, 0, 50),
|
|
JUtility::TColor(0, 0, 255, 50),
|
|
JUtility::TColor(255, 255, 255, 50),
|
|
};
|
|
|
|
for (int i = 0; i < getMapScissorAreaSizeRealX(); i += g_fmapHIO.mRangeCheckInterval + 1) {
|
|
for (int j = 0; j < getMapScissorAreaSizeRealY(); j += g_fmapHIO.mRangeCheckInterval + 1) {
|
|
u8 u = 0;
|
|
for (int k = 7; k >= 0; k--) {
|
|
int region = field_0x1230[k];
|
|
if (region == 0xff || region == 7) continue;
|
|
f32 pos_x = i + getMapScissorAreaLX();
|
|
f32 pos_y = j + getMapScissorAreaLY();
|
|
u = dMeter2Info_getPixel(
|
|
pos_x, pos_y, mRegionMinMapX[region] + field_0xf0c[region] + mTransX,
|
|
mRegionMinMapY[region] + field_0xf2c[region] + mTransZ,
|
|
mRegionMapSizeX[region] * mZoom, mRegionMapSizeY[region] * mZoom,
|
|
mpAreaTex[region]->getTexture(0)->getTexInfo());
|
|
if (u) {
|
|
J2DFillBox(pos_x - 3.0f, pos_y - 3.0f, 6.0f, 6.0f, colors[region]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::setArrowPos3D(u8 i_regionNo, char const* i_stageName, f32 i_posX,
|
|
f32 i_posZ) {
|
|
f32 offset_x = 0.0f;
|
|
f32 offset_z = 0.0f;
|
|
|
|
if (i_stageName) {
|
|
calcOffset(i_regionNo, i_stageName, &offset_x, &offset_z);
|
|
} else {
|
|
i_posX = 0.5f * (mRegionTexData[i_regionNo].mMinX + mRegionTexData[i_regionNo].mMaxX);
|
|
i_posZ = 0.5f * (mRegionTexData[i_regionNo].mMinZ + mRegionTexData[i_regionNo].mMaxZ);
|
|
}
|
|
|
|
mArrowPos3DX = i_posX + offset_x;
|
|
mArrowPos3DZ = i_posZ + offset_z;
|
|
control_xpos = 0.0f;
|
|
control_ypos = 0.0f;
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::setArrowPos3DOffset(u8 i_regionNo, char const* i_stageName, f32 i_posX,
|
|
f32 i_posZ, f32 param_4) {
|
|
f32 offset_x, offset_z, pos2d_x, pos2d_y;
|
|
|
|
if (param_4 != 0.0f) {
|
|
calcOffset(i_regionNo, i_stageName, &offset_x, &offset_z);
|
|
f32 v = i_posX + offset_x - getRegionOriginX(i_regionNo);
|
|
f32 v2 = i_posZ + offset_z - getRegionOriginZ(i_regionNo);
|
|
calcAllMapPos2D(v, v2, &pos2d_x, &pos2d_y);
|
|
pos2d_y -= param_4;
|
|
calcAllMapPosWorld(pos2d_x, pos2d_y, &i_posX, &i_posZ);
|
|
i_posX += getRegionOriginX(i_regionNo);
|
|
i_posZ += getRegionOriginZ(i_regionNo);
|
|
}
|
|
|
|
mArrowPos3DX = i_posX;
|
|
mArrowPos3DZ = i_posZ;
|
|
control_xpos = 0.0f;
|
|
control_ypos = 0.0f;
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::calcDrawPriority() {
|
|
u8 region;
|
|
u8 dVar2 = mRegionCursor;
|
|
u8 dVar3 = 6;
|
|
|
|
for (int i = 7; i >= 0; i--) {
|
|
if (field_0x1230[i] != 0xff) {
|
|
if (field_0x1230[i] == mRegionCursor) {
|
|
field_0x1230[i] = dVar2;
|
|
break;
|
|
} else {
|
|
u8 tmp = field_0x1230[i];
|
|
field_0x1230[i] = dVar2;
|
|
dVar2 = tmp;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mRegionCursor != 6) {
|
|
for (int i = 7; i >= 0; i--) {
|
|
if (field_0x1230[i] != 0xff) {
|
|
if (field_0x1230[i] == 6) {
|
|
field_0x1230[i] = dVar3;
|
|
break;
|
|
} else {
|
|
u8 tmp = field_0x1230[i];
|
|
field_0x1230[i] = dVar3;
|
|
dVar3 = tmp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (field_0x1230[0] != 7) {
|
|
u8 dVar4 = field_0x1230[0];
|
|
field_0x1230[0] = 7;
|
|
for (int i = 1; i < 8; i++) {
|
|
if (field_0x1230[i] != 0xff) {
|
|
if (field_0x1230[i] == 7) {
|
|
field_0x1230[i] = dVar4;
|
|
break;
|
|
} else {
|
|
u8 tmp = field_0x1230[i];
|
|
field_0x1230[i] = dVar4;
|
|
dVar4 = tmp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DBack_c::setArrowPosAxis(f32 i_posX, f32 i_posZ) {
|
|
mArrowPos3DX = i_posX;
|
|
mArrowPos3DZ = i_posZ;
|
|
control_xpos = 0.0f;
|
|
control_ypos = 0.0f;
|
|
}
|
|
|
|
dMenu_Fmap2DTop_c::dMenu_Fmap2DTop_c(JKRExpHeap* i_heap, STControl* i_stick) {
|
|
mpHeap = i_heap;
|
|
mTransX = 0.0f;
|
|
mTransY = 0.0f;
|
|
mpPortalBin = NULL;
|
|
mpScrnExplain = NULL;
|
|
|
|
mpTitleScreen = new J2DScreen();
|
|
JUT_ASSERT(3872, mpTitleScreen != NULL);
|
|
#if PLATFORM_GCN
|
|
bool fg = mpTitleScreen->setPriority("zelda_map_screen_title.blo", 0x1020000,
|
|
dComIfGp_getFmapResArchive());
|
|
#else
|
|
bool fg = mpTitleScreen->setPriority("zelda_map_screen_title_revo.blo", 0x1020000,
|
|
dComIfGp_getFmapResArchive());
|
|
#endif
|
|
JUT_ASSERT(3877, fg != false);
|
|
|
|
dPaneClass_showNullPane(mpTitleScreen);
|
|
mpTitleRoot = new CPaneMgrAlphaMorf(mpTitleScreen, 'ROOT', 2, NULL);
|
|
JUT_ASSERT(3881, mpTitleRoot != NULL);
|
|
#if PLATFORM_SHIELD
|
|
for (int i = 0; i < 2; i++) {
|
|
mpArrowLAlpha[i] = NULL;
|
|
mpArrowRAlpha[i] = NULL;
|
|
}
|
|
mpDpadAlpha = NULL;
|
|
mpAnalogStickAlpha = NULL;
|
|
mpAnalogStick = NULL;
|
|
mpDpad = NULL;
|
|
mpTitleScreen->search('tri_Null')->hide();
|
|
#endif
|
|
#if PLATFORM_GCN
|
|
mpArrowLAlpha[0] = new CPaneMgrAlpha(mpTitleScreen, 'yaji_04', 0, NULL);
|
|
mpArrowLAlpha[1] = new CPaneMgrAlpha(mpTitleScreen, 'yaji_05', 0, NULL);
|
|
mpArrowRAlpha[0] = new CPaneMgrAlpha(mpTitleScreen, 'yaji_06', 0, NULL);
|
|
mpArrowRAlpha[1] = new CPaneMgrAlpha(mpTitleScreen, 'yaji_07', 0, NULL);
|
|
|
|
mpDpadAlpha = new CPaneMgrAlpha(mpTitleScreen, 'juji_c_n', 2, NULL);
|
|
mpDpadAlpha->setAlphaRate(0.0f);
|
|
mpAnalogStickAlpha = new CPaneMgrAlpha(mpTitleScreen, 'as_n', 2, NULL);
|
|
mpAnalogStickAlpha->setAlphaRate(0.0f);
|
|
mpAnalogStick = new CPaneMgr(mpTitleScreen, 'as_n', 0, NULL);
|
|
mpDpad = new CPaneMgr(mpTitleScreen, 'juji_c_n', 0, NULL);
|
|
#endif
|
|
#if PLATFORM_SHIELD
|
|
mpButtonA = new CPaneMgr(mpTitleScreen, 'abtn_n', 2, NULL);
|
|
JUT_ASSERT(3935, mpButtonA != NULL);
|
|
mpButtonB = new CPaneMgr(mpTitleScreen, 'bbtn_n', 2, NULL);
|
|
JUT_ASSERT(3938, mpButtonB != NULL);
|
|
mpButtonZ = new CPaneMgr(mpTitleScreen, 'j_scal_n', 2, NULL);
|
|
JUT_ASSERT(3941, mpButtonZ != NULL);
|
|
mpButtonTextA = new CPaneMgr(mpTitleScreen, 'a_text_n', 2, NULL);
|
|
JUT_ASSERT(3953, mpButtonTextA != NULL);
|
|
mpButtonTextB = new CPaneMgr(mpTitleScreen, 'b_text_n', 2, NULL);
|
|
JUT_ASSERT(3956, mpButtonTextB != NULL);
|
|
mpButtonTextZ = new CPaneMgr(mpTitleScreen, 'z_text_n', 2, NULL);
|
|
JUT_ASSERT(3959, mpButtonTextZ != NULL);
|
|
#else
|
|
mpButtonA = new CPaneMgr(mpTitleScreen, 'abtn_n1', 2, NULL);
|
|
JUT_ASSERT(3935, mpButtonA != NULL);
|
|
mpButtonB = new CPaneMgr(mpTitleScreen, 'bbtn_n1', 2, NULL);
|
|
JUT_ASSERT(3938, mpButtonB != NULL);
|
|
mpButtonZ = new CPaneMgr(mpTitleScreen, 'zbtn_n1', 2, NULL);
|
|
JUT_ASSERT(3941, mpButtonZ != NULL);
|
|
mpButtonTextA = new CPaneMgr(mpTitleScreen, 'a_text_n', 2, NULL);
|
|
JUT_ASSERT(3953, mpButtonTextA != NULL);
|
|
mpButtonTextB = new CPaneMgr(mpTitleScreen, 'b_text_n', 2, NULL);
|
|
JUT_ASSERT(3956, mpButtonTextB != NULL);
|
|
mpButtonTextZ = new CPaneMgr(mpTitleScreen, 'z_text_n', 2, NULL);
|
|
JUT_ASSERT(3959, mpButtonTextZ != NULL);
|
|
#endif
|
|
mpButtonA->setAlphaRate(0.0f);
|
|
mpButtonB->setAlphaRate(0.0f);
|
|
mpButtonZ->setAlphaRate(0.0f);
|
|
mpButtonTextA->setAlphaRate(0.0f);
|
|
mpButtonTextB->setAlphaRate(0.0f);
|
|
mpButtonTextZ->setAlphaRate(0.0f);
|
|
|
|
mpNamePane = new CPaneMgr(mpTitleScreen, 'name_n', 0, NULL);
|
|
JUT_ASSERT(3970, mpNamePane != NULL);
|
|
mpSubPane = new CPaneMgr(mpTitleScreen, 'sub_n_n', 0, NULL);
|
|
JUT_ASSERT(3974, mpSubPane != NULL);
|
|
|
|
if (dMeter2Info_getMapStatus() == 9) {
|
|
mpNamePane->hide();
|
|
mpSubPane->hide();
|
|
}
|
|
mpContPane = new CPaneMgr(mpTitleScreen, 'cont_n', 0, NULL);
|
|
JUT_ASSERT(3984, mpContPane != NULL);
|
|
|
|
mTitlePosX = mTitlePosY = 0.0f;
|
|
mTitleScale = 1.0f;
|
|
mSubTitlePosX = mSubTitlePosY = 0.0f;
|
|
mSubTitleScale = 1.0f;
|
|
mAreaMovementPosX = mAreaMovementPosY = 0.0f;
|
|
mAreaMovementScale = 1.0f;
|
|
mClosingPosX = mClosingPosY = 0.0f;
|
|
mClosingScale = 1.0f;
|
|
mDoIconPosX = mDoIconPosY = 0.0f;
|
|
mDoIconScale = 1.0f;
|
|
|
|
OSInitFastCast();
|
|
#if PLATFORM_GCN
|
|
mpAnm = static_cast<J2DAnmTextureSRTKey*>(J2DAnmLoaderDataBase::load(
|
|
JKRFileLoader::getGlbResource("zelda_map_screen_title.btk", dComIfGp_getFmapResArchive())));
|
|
#else
|
|
void* v = JKRGetNameResource("zelda_map_screen_title_revo.btk", dComIfGp_getFmapResArchive());
|
|
mpAnm = static_cast<J2DAnmTextureSRTKey*>(J2DAnmLoaderDataBase::load(v));
|
|
#endif
|
|
mpAnm->searchUpdateMaterialID(mpTitleScreen);
|
|
|
|
mAnmFrame = 0.0f;
|
|
|
|
static const u64 area_name[3] = {'i_name_s', 'i_name' ,'i_name1'};
|
|
static const u64 farea_name[3] = {'f_name_1', 'f_name3', 'f_name2'};
|
|
for (int i = 0; i < 3; i++) {
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(area_name[i]))
|
|
->setFont(mDoExt_getRubyFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(area_name[i]))->setString(0x40, "");
|
|
mpTitleScreen->search(farea_name[i])->hide();
|
|
#else
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(farea_name[i]))
|
|
->setFont(mDoExt_getRubyFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(farea_name[i]))->setString(0x40, "");
|
|
mpTitleScreen->search(area_name[i])->hide();
|
|
#endif
|
|
}
|
|
#if PLATFORM_GCN
|
|
static const u64 sfont_name[7] = {
|
|
'sfont00', 'sfontl0', 'sfontl1', 'sfontl2', 'sfontb0', 'sfontb1', 'sfontb2'
|
|
};
|
|
static const u64 ffont_name[7] = {
|
|
'ffont00', 'ffontl0', 'ffontl1', 'ffontl2', 'ffontb0', 'ffontb3', 'ffontb4'
|
|
};
|
|
#else
|
|
static const u64 sfont_name[7] = {
|
|
'sfont00', 'sfontl0', 'sfontl1', 'sfontl2', 'sfontb0', 'sfontb1', 'sfontb2'
|
|
};
|
|
static const u64 ffont_name[7] = {
|
|
'ffont01', 'ffontl3', 'ffontl4', 'ffontl5', 'ffontb3', 'ffontb4', 'ffontb5'
|
|
};
|
|
#endif
|
|
for (int i = 0; i < 7; i++) {
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(sfont_name[i]))
|
|
->setFont(mDoExt_getRubyFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(sfont_name[i]))->setString(0x40, "");
|
|
mpTitleScreen->search(ffont_name[i])->hide();
|
|
#else
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(ffont_name[i]))
|
|
->setFont(mDoExt_getRubyFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(ffont_name[i]))->setString(0x40, "");
|
|
mpTitleScreen->search(sfont_name[i])->hide();
|
|
#endif
|
|
}
|
|
setTitleNameString(0x3e0);
|
|
|
|
static const u64 cont_zt[5] = {'cont_zt', 'cont_zt1', 'cont_zt2', 'cont_zt3', 'cont_zt4'};
|
|
static const u64 font_zt[5] = {'font_zt1', 'font_zt2', 'font_zt3', 'font_zt4', 'font_zt5'};
|
|
for (int i = 0; i < 5; i++) {
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(cont_zt[i]))
|
|
->setFont(mDoExt_getMesgFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(cont_zt[i]))->setString(0x20, "");
|
|
mpTitleScreen->search(font_zt[i])->hide();
|
|
#else
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(font_zt[i]))
|
|
->setFont(mDoExt_getMesgFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(font_zt[i]))->setString(0x20, "");
|
|
mpTitleScreen->search(cont_zt[i])->hide();
|
|
#endif
|
|
}
|
|
setZButtonString(0x529, 0xff);
|
|
#if PLATFORM_GCN
|
|
static const u64 cont_bt[5] = {'cont_bt1', 'cont_bt2', 'cont_bt3', 'cont_bt4', 'cont_bt'};
|
|
static const u64 font_bt[5] = {'font_bt1', 'font_bt2', 'font_bt3', 'font_bt4', 'font_bt5'};
|
|
#else
|
|
static const u64 cont_bt[5] = {'cont_bt1', 'cont_bt2', 'cont_bt3', 'cont_bt4', 'cont_bt8'};
|
|
static const u64 font_bt[5] = {'font_bt1', 'font_bt2', 'font_bt3', 'font_bt4', 'font_bt5'};
|
|
#endif
|
|
for (int i = 0; i < 5; i++) {
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(cont_bt[i]))
|
|
->setFont(mDoExt_getMesgFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(cont_bt[i]))->setString(0x20, "");
|
|
mpTitleScreen->search(font_bt[i])->hide();
|
|
#else
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(font_bt[i]))
|
|
->setFont(mDoExt_getMesgFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(font_bt[i]))->setString(0x20, "");
|
|
mpTitleScreen->search(cont_bt[i])->hide();
|
|
#endif
|
|
}
|
|
setBButtonString(0x522, 0xff);
|
|
|
|
static const u64 cont_at[5] = {'cont_at', 'cont_at1', 'cont_at2', 'cont_at3', 'cont_at4'};
|
|
static const u64 font_at[5] = {'font_at1', 'font_at2', 'font_at3', 'font_at4', 'font_at5'};
|
|
for (int i = 0; i < 5; i++) {
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(cont_at[i]))
|
|
->setFont(mDoExt_getMesgFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(cont_at[i]))->setString(0x20, "");
|
|
mpTitleScreen->search(font_at[i])->hide();
|
|
#else
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(font_at[i]))
|
|
->setFont(mDoExt_getMesgFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(font_at[i]))->setString(0x20, "");
|
|
mpTitleScreen->search(cont_at[i])->hide();
|
|
#endif
|
|
}
|
|
setAButtonString(0x527, 0xff);
|
|
|
|
#if PLATFORM_GCN
|
|
static const u64 juji_c[5] = {'juji_c00', 'juji_c01', 'juji_c02', 'juji_c03', 'juji_c04'};
|
|
static const u64 fuji_c[5] = {'fuji_c00', 'fuji_c01', 'fuji_c02', 'fuji_c03', 'fuji_c04'};
|
|
for (int i = 0; i < 5; i++) {
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(juji_c[i]))
|
|
->setFont(mDoExt_getMesgFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(juji_c[i]))->setString(0x20, "");
|
|
mpTitleScreen->search(fuji_c[i])->hide();
|
|
#else
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(fuji_c[i]))
|
|
->setFont(mDoExt_getMesgFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(fuji_c[i]))->setString(0x20, "");
|
|
mpTitleScreen->search(juji_c[i])->hide();
|
|
#endif
|
|
}
|
|
setCrossLRString(0x3f9);
|
|
|
|
static const u64 ast_c[5] = {'ast_00', 'ast_01', 'ast_02', 'ast_03', 'ast_04'};
|
|
static const u64 fst_c[5] = {'fst_00', 'fst_01', 'fst_02', 'fst_03', 'fst_04'};
|
|
for (int i = 0; i < 5; i++) {
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(ast_c[i]))
|
|
->setFont(mDoExt_getMesgFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(ast_c[i]))->setString(0x20, "");
|
|
mpTitleScreen->search(fst_c[i])->hide();
|
|
#else
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(fst_c[i]))
|
|
->setFont(mDoExt_getMesgFont());
|
|
static_cast<J2DTextBox*>(mpTitleScreen->search(fst_c[i]))->setString(0x20, "");
|
|
mpTitleScreen->search(ast_c[i])->hide();
|
|
#endif
|
|
}
|
|
set3DStickString(0x524);
|
|
#endif
|
|
|
|
setHIO(true);
|
|
}
|
|
|
|
dMenu_Fmap2DTop_c::~dMenu_Fmap2DTop_c() {
|
|
deleteExplain();
|
|
delete mpTitleScreen;
|
|
mpTitleScreen = NULL;
|
|
delete mpTitleRoot;
|
|
if (mpTitleRoot != NULL) {
|
|
}
|
|
delete mpButtonA;
|
|
mpButtonA = NULL;
|
|
delete mpButtonB;
|
|
mpButtonB = NULL;
|
|
delete mpButtonZ;
|
|
mpButtonZ = NULL;
|
|
delete mpButtonTextA;
|
|
mpButtonTextA = NULL;
|
|
delete mpButtonTextB;
|
|
mpButtonTextB = NULL;
|
|
delete mpButtonTextZ;
|
|
mpButtonTextZ = NULL;
|
|
if (mpDpadAlpha != NULL) {
|
|
delete mpDpadAlpha;
|
|
mpDpadAlpha = NULL;
|
|
}
|
|
if (mpAnalogStickAlpha != NULL) {
|
|
delete mpAnalogStickAlpha;
|
|
mpAnalogStickAlpha = NULL;
|
|
}
|
|
delete mpNamePane;
|
|
mpNamePane = NULL;
|
|
delete mpSubPane;
|
|
mpSubPane = NULL;
|
|
if (mpAnalogStick != NULL) {
|
|
delete mpAnalogStick;
|
|
mpAnalogStick = NULL;
|
|
}
|
|
if (mpDpad != NULL) {
|
|
delete mpDpad;
|
|
mpDpad = NULL;
|
|
}
|
|
delete mpContPane;
|
|
mpContPane = NULL;
|
|
for (int i = 0; i < 2; i++) {
|
|
if (mpArrowLAlpha[i] != NULL) {
|
|
delete mpArrowLAlpha[i];
|
|
if (mpArrowLAlpha[i] != NULL) {
|
|
}
|
|
}
|
|
if (mpArrowRAlpha[i] != NULL) {
|
|
delete mpArrowRAlpha[i];
|
|
if (mpArrowRAlpha[i] != NULL) {
|
|
}
|
|
}
|
|
}
|
|
delete mpAnm;
|
|
mpAnm = NULL;
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::_execute() {
|
|
switch (mAlphaButtonA) {
|
|
case ALPHA_MIN:
|
|
setAlphaAnimeMax(mpButtonA);
|
|
setAlphaAnimeMin(mpButtonTextA);
|
|
break;
|
|
case ALPHA_MID:
|
|
setAlphaAnimeMid(mpButtonA);
|
|
setAlphaAnimeMid(mpButtonTextA);
|
|
break;
|
|
default:
|
|
setAlphaAnimeMax(mpButtonA);
|
|
setAlphaAnimeMax(mpButtonTextA);
|
|
}
|
|
|
|
switch (mAlphaButtonB) {
|
|
case ALPHA_MIN:
|
|
setAlphaAnimeMax(mpButtonB);
|
|
setAlphaAnimeMin(mpButtonTextB);
|
|
break;
|
|
case ALPHA_MID:
|
|
setAlphaAnimeMid(mpButtonB);
|
|
setAlphaAnimeMid(mpButtonTextB);
|
|
break;
|
|
default:
|
|
setAlphaAnimeMax(mpButtonB);
|
|
setAlphaAnimeMax(mpButtonTextB);
|
|
}
|
|
|
|
switch (mAlphaButtonZ) {
|
|
case ALPHA_MIN:
|
|
setAlphaAnimeMax(mpButtonZ);
|
|
setAlphaAnimeMin(mpButtonTextZ);
|
|
break;
|
|
case ALPHA_MID:
|
|
setAlphaAnimeMid(mpButtonZ);
|
|
setAlphaAnimeMid(mpButtonTextZ);
|
|
break;
|
|
default:
|
|
setAlphaAnimeMax(mpButtonZ);
|
|
setAlphaAnimeMax(mpButtonTextZ);
|
|
}
|
|
|
|
if (mpDpadAlpha) {
|
|
switch (mAlphaDpad) {
|
|
case ALPHA_MIN:
|
|
setAlphaAnimeMin(mpDpadAlpha);
|
|
break;
|
|
case ALPHA_MID:
|
|
setAlphaAnimeMid(mpDpadAlpha);
|
|
break;
|
|
default:
|
|
setAlphaAnimeMax(mpDpadAlpha);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (mpAnalogStickAlpha) {
|
|
switch (mAlphaAnalogStick) {
|
|
case ALPHA_MIN:
|
|
setAlphaAnimeMin(mpAnalogStickAlpha);
|
|
break;
|
|
case ALPHA_MID:
|
|
setAlphaAnimeMid(mpAnalogStickAlpha);
|
|
break;
|
|
default:
|
|
setAlphaAnimeMax(mpAnalogStickAlpha);
|
|
break;
|
|
}
|
|
}
|
|
|
|
setHIO(false);
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setAllAlphaRate(f32 i_rate, bool i_init) {
|
|
mAlphaRate = i_rate;
|
|
if (i_init) {
|
|
mpTitleRoot->setBackupAlpha();
|
|
}
|
|
mpTitleRoot->setAlphaMorfRate(i_rate);
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::draw() {
|
|
u32 scissor_left, scissor_top, scissor_width, scissor_height;
|
|
J2DOrthoGraph* ctx = static_cast<J2DOrthoGraph*>(dComIfGp_getCurrentGrafPort());
|
|
ctx->setup2D();
|
|
GXGetScissor(&scissor_left, &scissor_top, &scissor_width, &scissor_height);
|
|
ctx->scissor(mTransX, 0.0f, FB_WIDTH, FB_HEIGHT);
|
|
ctx->setScissor();
|
|
mpTitleScreen->draw(mTransX, mTransY, ctx);
|
|
ctx->scissor(scissor_left, scissor_top, scissor_width, scissor_height);
|
|
ctx->setScissor();
|
|
if (mpScrnExplain) {
|
|
mpScrnExplain->draw(ctx);
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::btkAnimeLoop(J2DAnmTextureSRTKey* i_anm, f32 i_delta) {
|
|
if (i_anm) {
|
|
mAnmFrame += i_delta;
|
|
if (mAnmFrame >= i_anm->getFrameMax()) {
|
|
mAnmFrame -= i_anm->getFrameMax();
|
|
}
|
|
i_anm->setFrame(mAnmFrame);
|
|
} else {
|
|
mAnmFrame = 0.0f;
|
|
}
|
|
|
|
mpTitleScreen->search('spot_0')->setAnimation(i_anm);
|
|
mpTitleScreen->animation();
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setMoyaAlpha(u8 i_alpha) {
|
|
mpTitleScreen->search('spot_0')->setAlpha(i_alpha);
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setTitleNameString(u32 param_0) {
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static const u64 sfont_name[7] = {
|
|
'sfont00', 'sfontl0', 'sfontl1', 'sfontl2', 'sfontb0', 'sfontb1', 'sfontb2'
|
|
};
|
|
#define setTitleNameString_font_name sfont_name
|
|
#elif PLATFORM_GCN
|
|
static const u64 ffont_name[7] = {
|
|
'ffont00', 'ffontl0', 'ffontl1', 'ffontl2', 'ffontb0', 'ffontb3', 'ffontb4'
|
|
};
|
|
#define setTitleNameString_font_name ffont_name
|
|
#else
|
|
static const u64 ffont_name[7] = {
|
|
'ffont01', 'ffontl3', 'ffontl4', 'ffontl5', 'ffontb3', 'ffontb4', 'ffontb5'
|
|
};
|
|
#define setTitleNameString_font_name ffont_name
|
|
#endif
|
|
for (int i = 0; i < 7; i++) {
|
|
if (param_0 == 0) {
|
|
strcpy(((J2DTextBox*)(mpTitleScreen->search(setTitleNameString_font_name[i])))
|
|
->getStringPtr(),
|
|
"");
|
|
} else {
|
|
dMeter2Info_getStringKanji(
|
|
param_0,
|
|
((J2DTextBox*)(mpTitleScreen->search(setTitleNameString_font_name[i])))
|
|
->getStringPtr(),
|
|
NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setAreaNameString(u32 param_0) {
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static const u64 iarea_name[3] = {'i_name_s', 'i_name', 'i_name1'};
|
|
#define setAreaNameString_area_name iarea_name
|
|
#else
|
|
static const u64 farea_name[3] = {'f_name_1', 'f_name3', 'f_name2'};
|
|
#define setAreaNameString_area_name farea_name
|
|
#endif
|
|
for (int i = 0; i < 3; i++) {
|
|
if (param_0 == 0) {
|
|
strcpy(((J2DTextBox*)(mpTitleScreen->search(setAreaNameString_area_name[i])))
|
|
->getStringPtr(),
|
|
"");
|
|
} else {
|
|
dMeter2Info_getStringKanji(
|
|
param_0,
|
|
((J2DTextBox*)(mpTitleScreen->search(setAreaNameString_area_name[i])))
|
|
->getStringPtr(),
|
|
NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setZButtonString(u32 param_0, u8 i_alpha) {
|
|
if (param_0 == 0x529 && ((daMidna_c*)daPy_py_c::getMidnaActor())->checkPortalObjRide()) {
|
|
param_0 = 0x533;
|
|
}
|
|
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static const u64 cont_zt[5] = {'cont_zt', 'cont_zt1', 'cont_zt2', 'cont_zt3', 'cont_zt4'};
|
|
#define setZButtonString_font_zt cont_zt
|
|
#else
|
|
static const u64 font_zt[5] = {'font_zt1', 'font_zt2', 'font_zt3', 'font_zt4', 'font_zt5'};
|
|
#define setZButtonString_font_zt font_zt
|
|
#endif
|
|
if (param_0 == 0 || !isWarpAccept()) {
|
|
#if PLATFORM_GCN
|
|
mAlphaButtonZ = ALPHA_MID;
|
|
#else
|
|
mAlphaButtonZ = ALPHA_MIN;
|
|
#endif
|
|
} else {
|
|
for (int i = 0; i < 5; i++) {
|
|
dMeter2Info_getStringKanji(
|
|
param_0,
|
|
((J2DTextBox*)(mpTitleScreen->search(setZButtonString_font_zt[i])))->getStringPtr(),
|
|
NULL);
|
|
}
|
|
|
|
if (i_alpha == ALPHA_DEFAULT) {
|
|
if (checkPlayerWarpAccept()) {
|
|
mAlphaButtonZ = ALPHA_MAX;
|
|
} else {
|
|
mAlphaButtonZ = ALPHA_MID;
|
|
}
|
|
} else {
|
|
mAlphaButtonZ = i_alpha;
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setBButtonString(u32 param_0, u8 i_alpha) {
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static const u64 cont_bt[5] = {'cont_bt1', 'cont_bt2', 'cont_bt3', 'cont_bt4', 'cont_bt'};
|
|
#define setBButtonString_font_bt cont_bt
|
|
#else
|
|
static const u64 font_bt[5] = {'font_bt1', 'font_bt2', 'font_bt3', 'font_bt4', 'font_bt5'};
|
|
#define setBButtonString_font_bt font_bt
|
|
#endif
|
|
if (param_0 == 0) {
|
|
mAlphaButtonB = ALPHA_MIN;
|
|
} else {
|
|
for (int i = 0; i < 5; i++) {
|
|
dMeter2Info_getStringKanji(
|
|
param_0,
|
|
((J2DTextBox*)(mpTitleScreen->search(setBButtonString_font_bt[i])))->getStringPtr(),
|
|
NULL);
|
|
}
|
|
|
|
if (i_alpha == ALPHA_DEFAULT) {
|
|
mAlphaButtonB = ALPHA_MAX;
|
|
} else {
|
|
mAlphaButtonB = i_alpha;
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setAButtonString(u32 param_0, u8 i_alpha) {
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static const u64 cont_at[5] = {'cont_at', 'cont_at1', 'cont_at2', 'cont_at3', 'cont_at4'};
|
|
#define setAButtonString_font_at cont_at
|
|
#else
|
|
static const u64 font_at[5] = {'font_at1', 'font_at2', 'font_at3', 'font_at4', 'font_at5'};
|
|
#define setAButtonString_font_at font_at
|
|
#endif
|
|
if (param_0 == 0) {
|
|
mAlphaButtonA = ALPHA_MIN;
|
|
} else {
|
|
for (int i = 0; i < 5; i++) {
|
|
dMeter2Info_getStringKanji(
|
|
param_0,
|
|
((J2DTextBox*)(mpTitleScreen->search(setAButtonString_font_at[i])))->getStringPtr(),
|
|
NULL);
|
|
}
|
|
|
|
if (i_alpha == ALPHA_DEFAULT) {
|
|
mAlphaButtonA = ALPHA_MAX;
|
|
} else {
|
|
mAlphaButtonA = i_alpha;
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setCrossLRString(u32 param_0) {
|
|
#if PLATFORM_GCN || (VERSION == VERSION_SHIELD)
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static const u64 juji_c[5] = {'juji_c00', 'juji_c01', 'juji_c02', 'juji_c03', 'juji_c04'};
|
|
#else
|
|
static const u64 juji_c[5] = {'fuji_c00', 'fuji_c01', 'fuji_c02', 'fuji_c03', 'fuji_c04'};
|
|
#endif
|
|
if (param_0 == 0) {
|
|
for (int i = 0; i < 5; i++) {
|
|
J2DTextBox* text_box = static_cast<J2DTextBox*>(mpTitleScreen->search(juji_c[i]));
|
|
strcpy(text_box->getStringPtr(), "");
|
|
}
|
|
mpTitleScreen->search('juy_sha0')->show();
|
|
mAlphaDpad = 1;
|
|
} else {
|
|
for (int i = 0; i < 5; i++) {
|
|
J2DTextBox* text_box = static_cast<J2DTextBox*>(mpTitleScreen->search(juji_c[i]));
|
|
dMeter2Info_getStringKanji(param_0, text_box->getStringPtr(), NULL);
|
|
}
|
|
mpTitleScreen->search('juy_sha0')->show();
|
|
mAlphaDpad = 2;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::set3DStickString(u32 param_0) {
|
|
#if PLATFORM_GCN || (VERSION == VERSION_SHIELD)
|
|
#if VERSION == VERSION_GCN_JPN
|
|
static const u64 ast_c[5] = {'ast_00', 'ast_01', 'ast_02', 'ast_03', 'ast_04'};
|
|
#else
|
|
static const u64 ast_c[5] = {'fst_00', 'fst_01', 'fst_02', 'fst_03', 'fst_04'};
|
|
#endif
|
|
if (param_0 == 0) {
|
|
for (int i = 0; i < 5; i++) {
|
|
J2DTextBox* text_box = static_cast<J2DTextBox*>(mpTitleScreen->search(ast_c[i]));
|
|
strcpy(text_box->getStringPtr(), "");
|
|
}
|
|
mpTitleScreen->search('as_sha0')->show();
|
|
mAlphaAnalogStick = 1;
|
|
} else {
|
|
for (int i = 0; i < 5; i++) {
|
|
J2DTextBox* text_box = static_cast<J2DTextBox*>(mpTitleScreen->search(ast_c[i]));
|
|
dMeter2Info_getStringKanji(param_0, text_box->getStringPtr(), NULL);
|
|
}
|
|
mpTitleScreen->search('as_sha0')->show();
|
|
mAlphaAnalogStick = 2;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::createExplain(JKRExpHeap* i_heap, STControl* i_stick) {
|
|
if (!mpScrnExplain) {
|
|
JKRHeap* heap = mDoExt_setCurrentHeap(i_heap);
|
|
mpScrnExplain = new dMsgScrnExplain_c(i_stick, 0, false, 1);
|
|
JUT_ASSERT(4743, mpScrnExplain != NULL);
|
|
mDoExt_setCurrentHeap(heap);
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::deleteExplain() {
|
|
if (mpScrnExplain) {
|
|
delete mpScrnExplain;
|
|
mpScrnExplain = NULL;
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setArrowAlphaRatio(u8 i_mask, f32 i_rate) {
|
|
if (i_mask & ARROW_LEFT) {
|
|
for (int i = 0; i < 2; i++) {
|
|
if (mpArrowLAlpha[i]) {
|
|
mpArrowLAlpha[i]->setAlphaRate(i_rate);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (i_mask & ARROW_RIGHT) {
|
|
for (int i = 0; i < 2; i++) {
|
|
if (mpArrowRAlpha[i]) {
|
|
mpArrowRAlpha[i]->setAlphaRate(i_rate);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setAlphaAnimeMin(CPaneMgrAlpha* i_pane) {
|
|
s16 timer = i_pane->getAlphaTimer();
|
|
if (timer > 0 || i_pane->getAlphaRate() != 0.0f) {
|
|
timer--;
|
|
if (timer < 0) {
|
|
timer = 0;
|
|
}
|
|
i_pane->alphaAnimeStart(timer);
|
|
i_pane->setAlphaRate(timer / 5.0f);
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setAlphaAnimeMid(CPaneMgrAlpha* i_pane) {
|
|
s16 timer = i_pane->getAlphaTimer();
|
|
if (timer != 3 || i_pane->getAlphaRate() != 0.25f) {
|
|
if (timer > 3) {
|
|
timer--;
|
|
} else if (timer < 3) {
|
|
timer++;
|
|
}
|
|
i_pane->alphaAnimeStart(timer);
|
|
i_pane->setAlphaRate(timer / 6.0f * 0.5f);
|
|
}
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setAlphaAnimeMax(CPaneMgrAlpha* i_pane) {
|
|
s16 timer = i_pane->getAlphaTimer();
|
|
if (timer < 5 || i_pane->getAlphaRate() != 1.0f) {
|
|
timer++;
|
|
if (timer > 5) {
|
|
timer = 5;
|
|
}
|
|
i_pane->alphaAnimeStart(timer);
|
|
i_pane->setAlphaRate(timer / 5.0f);
|
|
}
|
|
}
|
|
|
|
bool dMenu_Fmap2DTop_c::checkPlayerWarpAccept() {
|
|
if (checkWarpAcceptCannon() == FALSE) {
|
|
return FALSE;
|
|
} else if (checkWarpAcceptRegion4() == FALSE) {
|
|
return FALSE;
|
|
} else {
|
|
return daPy_getLinkPlayerActorClass()->checkAcceptDungeonWarpAlink(0);
|
|
}
|
|
}
|
|
|
|
bool dMenu_Fmap2DTop_c::checkWarpAcceptRegion(int i_region) {
|
|
if (g_fmapHIO.mAllRegionsUnlocked) {
|
|
return true;
|
|
}
|
|
|
|
if (mpPortalBin) {
|
|
dMenu_Fmap_portal_data_c* portal_data = (dMenu_Fmap_portal_data_c*)mpPortalBin;
|
|
dMenu_Fmap_portal_data_c::data* portals = portal_data->mData;
|
|
for (int i = 0; i < portal_data->mCount; i++) {
|
|
if (i_region + 1 == portals[i].mRegionNo
|
|
&& dComIfGs_isStageSwitch(portals[i].mStageNo, portals[i].mSwitchNo))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool dMenu_Fmap2DTop_c::checkWarpAcceptRegion4() {
|
|
if (dComIfGp_getNowLevel() == 4 && !checkWarpAcceptRegion(3)) {
|
|
return false;
|
|
}
|
|
|
|
/* dSv_event_flag_c::M_071 - Cutscene - [cutscene: 20] Zant appears (during Midna's desperate hour) */
|
|
if (dComIfGs_isEventBit(dSv_event_flag_c::saveBitLabels[104])
|
|
/* dSv_event_flag_c::F_0250 - Cutscene - [cutscene: 21] reunion with Zelda / Midna revived (Hyrule Castle barrier appears) */
|
|
&& !dComIfGs_isEventBit(dSv_event_flag_c::saveBitLabels[250]))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool dMenu_Fmap2DTop_c::checkWarpAcceptCannon() {
|
|
/* dSv_event_flag_c::F_0786 - Kakariko Village - Forced conversation with Shad when he sees the sky cannon */
|
|
if (dComIfGs_isEventBit(dSv_event_flag_c::saveBitLabels[786])
|
|
/* dSv_event_flag_c::F_0785 - Kakariko Village - Shad leaves after attempting to warp sky cannon */
|
|
&& !dComIfGs_isEventBit(dSv_event_flag_c::saveBitLabels[785]))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void dMenu_Fmap2DTop_c::setHIO(bool param_0) {
|
|
if (mTitlePosX != g_fmapHIO.mTitlePosX || mTitlePosY != g_fmapHIO.mTitlePosY) {
|
|
mTitlePosX = g_fmapHIO.mTitlePosX;
|
|
mTitlePosY = g_fmapHIO.mTitlePosY;
|
|
mpNamePane->paneTrans(mTitlePosX, mTitlePosY);
|
|
}
|
|
|
|
if (mTitleScale != g_fmapHIO.mTitleScale) {
|
|
mTitleScale = g_fmapHIO.mTitleScale;
|
|
mpNamePane->scale(mTitleScale, mTitleScale);
|
|
}
|
|
|
|
if (mSubTitlePosX != g_fmapHIO.mSubTitlePosX || mSubTitlePosY != g_fmapHIO.mSubTitlePosY) {
|
|
mSubTitlePosX = g_fmapHIO.mSubTitlePosX;
|
|
mSubTitlePosY = g_fmapHIO.mSubTitlePosY;
|
|
mpSubPane->paneTrans(mSubTitlePosX, mSubTitlePosY);
|
|
}
|
|
|
|
if (mSubTitleScale != g_fmapHIO.mSubTitleScale) {
|
|
mSubTitleScale = g_fmapHIO.mSubTitleScale;
|
|
mpSubPane->scale(mSubTitleScale, mSubTitleScale);
|
|
}
|
|
|
|
if (mpAnalogStick) {
|
|
if (mAreaMovementPosX != g_fmapHIO.mAreaMovementPosX
|
|
|| mAreaMovementPosY != g_fmapHIO.mAreaMovementPosY)
|
|
{
|
|
mAreaMovementPosX = g_fmapHIO.mAreaMovementPosX;
|
|
mAreaMovementPosY = g_fmapHIO.mAreaMovementPosY;
|
|
mpAnalogStick->paneTrans(mAreaMovementPosX, mAreaMovementPosY);
|
|
}
|
|
|
|
if (mAreaMovementScale != g_fmapHIO.mAreaMovementScale) {
|
|
mAreaMovementScale = g_fmapHIO.mAreaMovementScale;
|
|
mpAnalogStick->scale(mAreaMovementScale, mAreaMovementScale);
|
|
}
|
|
}
|
|
|
|
if (mpDpad) {
|
|
if (mClosingPosX != g_fmapHIO.mClosingPosX || mClosingPosY != g_fmapHIO.mClosingPosY) {
|
|
mClosingPosX = g_fmapHIO.mClosingPosX;
|
|
mClosingPosY = g_fmapHIO.mClosingPosY;
|
|
mpDpad->paneTrans(mClosingPosX, mClosingPosY);
|
|
}
|
|
|
|
if (mClosingScale != g_fmapHIO.mClosingScale) {
|
|
mClosingScale = g_fmapHIO.mClosingScale;
|
|
mpDpad->scale(mClosingScale, mClosingScale);
|
|
}
|
|
}
|
|
|
|
if (mDoIconPosX != g_fmapHIO.mDoIconPosX || mDoIconPosY != g_fmapHIO.mDoIconPosY) {
|
|
mDoIconPosX = g_fmapHIO.mDoIconPosX;
|
|
mDoIconPosY = g_fmapHIO.mDoIconPosY;
|
|
mpContPane->paneTrans(mDoIconPosX, mDoIconPosY);
|
|
}
|
|
|
|
if (mDoIconScale != g_fmapHIO.mDoIconScale) {
|
|
mDoIconScale = g_fmapHIO.mDoIconScale;
|
|
mpContPane->scale(mDoIconScale, mDoIconScale);
|
|
}
|
|
|
|
if (g_fmapHIO.mButtonDebugON || param_0) {
|
|
mpButtonZ->paneTrans(g_fmapHIO.mButtonZPosX, g_fmapHIO.mButtonZPosY);
|
|
mpButtonZ->scale(g_fmapHIO.mButtonZScale, g_fmapHIO.mButtonZScale);
|
|
mpButtonA->paneTrans(g_fmapHIO.mButtonAPosX, g_fmapHIO.mButtonAPosY);
|
|
mpButtonA->scale(g_fmapHIO.mButtonAScale, g_fmapHIO.mButtonAScale);
|
|
mpButtonB->paneTrans(g_fmapHIO.mButtonBPosX, g_fmapHIO.mButtonBPosY);
|
|
mpButtonB->scale(g_fmapHIO.mButtonBScale, g_fmapHIO.mButtonBScale);
|
|
mpButtonTextZ->paneTrans(g_fmapHIO.mButtonZTextPosX, g_fmapHIO.mButtonZTextPosY);
|
|
mpButtonTextZ->scale(g_fmapHIO.mButtonZTextScale, g_fmapHIO.mButtonZTextScale);
|
|
mpButtonTextA->paneTrans(g_fmapHIO.mButtonATextPosX, g_fmapHIO.mButtonATextPosY);
|
|
mpButtonTextA->scale(g_fmapHIO.mButtonATextScale, g_fmapHIO.mButtonATextScale);
|
|
mpButtonTextB->paneTrans(g_fmapHIO.mButtonBTextPosX, g_fmapHIO.mButtonBTextPosY);
|
|
mpButtonTextB->scale(g_fmapHIO.mButtonBTextScale, g_fmapHIO.mButtonBTextScale);
|
|
}
|
|
}
|
|
|
|
bool dMenu_Fmap2DTop_c::isWarpAccept() {
|
|
/* dSv_event_flag_c::M_021 - Main Event - First portal warp */
|
|
if ((dComIfGs_isEventBit(dSv_event_flag_c::saveBitLabels[54])
|
|
&& dMeter2Info_getMapStatus() != 9 && dMeter2Info_getMapStatus() != 7
|
|
&& dMeter2Info_getMapStatus() != 8) || g_fmapHIO.mPortalWarpON)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|