NSMBW-Decomp
A decompilation of New Super Mario Bros. Wii
Loading...
Searching...
No Matches
d_CourseSelectGuide.cpp
1#include <game/bases/d_CourseSelectGuide.hpp>
2#include <game/bases/d_a_player_com.hpp>
3#include <game/bases/d_a_player_manager.hpp>
4#include <game/bases/d_game_display.hpp>
5#include <game/bases/d_game_com.hpp>
6#include <game/bases/d_game_key.hpp>
7#include <game/bases/d_save_mng.hpp>
8#include <game/mLib/m_video.hpp>
10
12
13template <>
16};
17
19
34
35STATE_DEFINE(dCourseSelectGuide_c, WorldCourseOnStageWait);
36STATE_DEFINE(dCourseSelectGuide_c, WorldCourseOnStageAnimeEndCheck);
37STATE_DEFINE(dCourseSelectGuide_c, WorldCourseDisp);
38STATE_DEFINE(dCourseSelectGuide_c, WorldCourseExitAnimeEndCheck);
39STATE_DEFINE(dCourseSelectGuide_c, GuideOnStageWait);
40STATE_DEFINE(dCourseSelectGuide_c, GuideOnStageAnimeEndCheck);
42STATE_DEFINE(dCourseSelectGuide_c, GuideExitAnimeEndCheck);
44STATE_DEFINE(dCourseSelectGuide_c, UpOnStageAnimeEndCheck);
46STATE_DEFINE(dCourseSelectGuide_c, UpExitAnimeEndCheck);
47STATE_DEFINE(dCourseSelectGuide_c, DownOnStageWait);
48STATE_DEFINE(dCourseSelectGuide_c, DownOnStageAnimeEndCheck);
50STATE_DEFINE(dCourseSelectGuide_c, DownExitAnimeEndCheck);
51STATE_DEFINE(dCourseSelectGuide_c, LeftOnStageWait);
52STATE_DEFINE(dCourseSelectGuide_c, LeftOnStageAnimeEndCheck);
54STATE_DEFINE(dCourseSelectGuide_c, LeftExitAnimeEndCheck);
55STATE_DEFINE(dCourseSelectGuide_c, RightOnStageWait);
56STATE_DEFINE(dCourseSelectGuide_c, RightOnStageAnimeEndCheck);
58STATE_DEFINE(dCourseSelectGuide_c, RightExitAnimeEndCheck);
59STATE_DEFINE(dCourseSelectGuide_c, ShadowOnStageWait);
60STATE_DEFINE(dCourseSelectGuide_c, ShadowOnStageAnimeEndCheck);
62STATE_DEFINE(dCourseSelectGuide_c, ShadowExitAnimeEndCheck);
63STATE_DEFINE(dCourseSelectGuide_c, ScrollGuideOnStageWait);
64STATE_DEFINE(dCourseSelectGuide_c, ScrollGuideOnStageAnimeEndCheck);
65STATE_DEFINE(dCourseSelectGuide_c, ScrollGuideDisp);
66STATE_DEFINE(dCourseSelectGuide_c, ScrollGuideExitAnimeEndCheck);
67
71
73 static const char *AnmNameTbl[ANIM_NAME_COUNT] = {
74 "corseSelectUIGuide_37_inInfo.brlan",
75 "corseSelectUIGuide_37_loopInfo.brlan",
76 "corseSelectUIGuide_37_outInfo.brlan",
77 "corseSelectUIGuide_37_inMapArrow.brlan",
78 "corseSelectUIGuide_37_loopArrow.brlan",
79 "corseSelectUIGuide_37_outMapArrow.brlan",
80 "corseSelectUIGuide_37_inShadow.brlan",
81 "corseSelectUIGuide_37_outShadow.brlan"
82 };
83
84 static const char *GROUP_NAME_DT[ANIM_COUNT] = {
85 "A00_underGuide", "A01_zanki", "A02_courseInfo",
86 "A00_underGuide", "A01_zanki", "A02_courseInfo",
87 "A00_underGuide", "A01_zanki", "A02_courseInfo",
88 "B00_ArrowRight", "B01_ArrowLeft", "B02_ArrowUp", "B03_ArrowUnder",
89 "B00_ArrowRight", "B01_ArrowLeft", "B02_ArrowUp", "B03_ArrowUnder",
90 "B00_ArrowRight", "B01_ArrowLeft", "B02_ArrowUp", "B03_ArrowUnder",
91 "C00_shadow",
92 "C00_shadow"
93 };
94
95 static const int ANIME_INDEX_TBL[ANIM_COUNT] = {
96 inInfo, inInfo, inInfo,
97 loopInfo, loopInfo, loopInfo,
98 outInfo, outInfo, outInfo,
99 inMapArrow, inMapArrow, inMapArrow, inMapArrow,
100 loopArrow, loopArrow, loopArrow, loopArrow,
101 outMapArrow, outMapArrow, outMapArrow, outMapArrow,
102 inShadow,
103 outShadow
104 };
105
106 static const char *NPANE_NAME_DT[N_COUNT] = {
107 "N_IconPos1P_00", "N_IconPos2P_00", "N_IconPos3P_00", "N_IconPos4P_00",
108 "N_mapArrow_00",
109 "N_proportionL_00", "N_proportionR_00", "N_proportionC_00",
110 "N_guideViewC_00", "N_guideViewR_01",
111 "N_left_00"
112 };
113
114 static const char *T_PANE_NAME_TBL[T_COUNT] = {
115 "T_worldNum_00",
116 "T_cSelect_00", "T_cSelect_pic",
117 "T_lifeNumber_00", "T_lifeNumber_01", "T_lifeNumber_02", "T_lifeNumber_03",
118 "T_guideViewLS_00", "T_guideViewL_01"
119 };
120
121 static const int MESSAGE_DATA_TBL[T_FIXED_COUNT] = {
122 MSG_CS_SELECT_WORLD,
123 MSG_CS_MENU,
124 MSG_CS_WORLD
125 };
126 static const char *T_PANE_FIXED_NAME_TBL[T_FIXED_COUNT] = {
127 "T_guideViewC_00",
128 "T_guideViewR_00",
129 "T_world_00"
130 };
131
132 static const char *P_PANE_NAME_TBL[P_COUNT] = {
133 "P_cC_1_00",
134 "P_cC_2_00",
135 "P_cC_3_00",
136 "P_cC_1s_00",
137 "P_cC_2s_00",
138 "P_cC_3s_00",
139 "P_flagSkull_00",
140 "P_marioFace_00",
141 "P_luigiFace_00",
142 "P_BkinoFace_00",
143 "P_YkinoFace_00",
144 "P_bgShadow_00"
145 };
146
147 if (mInitialized) {
148 return true;
149 }
150 if (!mLayout.ReadResource("corseSelectUIGuide/corseSelectUIGuide.arc", false)) {
151 return false;
152 }
153 mLayout.build("corseSelectUIGuide_37.brlyt", 0);
154 mLayout.AnimeResRegister(AnmNameTbl, ANIM_NAME_COUNT);
155 mLayout.GroupRegister(GROUP_NAME_DT, ANIME_INDEX_TBL, ANIM_COUNT);
156 mpRootPane = mLayout.getRootPane();
157 mLayout.NPaneRegister(NPANE_NAME_DT, &mpNullPanes[N_IconPos1P_00], N_COUNT);
158 mLayout.TPaneRegister(T_PANE_NAME_TBL, &mpTextBoxes[T_worldNum_00], T_COUNT);
159 mLayout.TPaneNameRegister(T_PANE_FIXED_NAME_TBL, MESSAGE_DATA_TBL, BMG_CATEGORY_COURSE_SELECT_GUIDE, T_FIXED_COUNT);
160 mLayout.PPaneRegister(P_PANE_NAME_TBL, &mpPicturePanes[P_cC_1_00], P_COUNT);
161
162 mLayout.mDrawOrder = 2;
163 mpRootPane->setVisible(true);
164 mpNullPanes[N_mapArrow_00]->setVisible(true);
165 mpPicturePanes[P_flagSkull_00]->setVisible(false);
166
167 for (int i = 0; i < ARRAY_SIZE(mRest); i++) {
168 mRest[i] = -1;
169 }
170
172
174 mInitialized = true;
175
176 mWorldNo = dScWMap_c::getWorldNo();
177 mCourseNo = -10;
178 mCourseType = 11;
179
180 mLayout.AllAnimeEndSetup();
181
182 mEnabled = true;
183
184 mShowCourseInfo = false;
185 mHideCourseInfo = true;
186
187 mIsCourseInfoOutAnime = false;
188 mNoAnimCourseInfoIn = false;
189
190 mBeginGuide = false;
191 mEndGuide = true;
192 mGuideRelated = false;
193 mNoHUDAppearAnim = false;
194
195 mMapView = false;
196 mDisableArrows = false;
197 mHideHUD = false;
198
199 mShowShadow = false;
200 mHideShadow = false;
201
202 mShowScrollGuide = false;
203 mEndScrollGuide = false;
204
205 mScrollGuideRelated = false;
206 mCourseInfoAnim = false;
207 mUpAnim = false;
208 mDownAnim = false;
209 mLeftAnim = false;
210 mRightAnim = false;
211
212 mShowRestNumber = false;
213
216
217 mRestAlpha = 255;
218 mRestAlphaTarget = 255;
219
220 mLayout.ReverseAnimeStartSetup(ANIM_OUT_UNDER, false);
221 mLayout.ReverseAnimeStartSetup(ANIM_OUT_ZANKI, false);
222 mLayout.ReverseAnimeStartSetup(ANIM_OUT_COURSE_INFO, false);
223 mLayout.AnimePlay();
224 mLayout.calc();
226 mLayout.ReverseAnimeStartSetup(ANIM_IN_SHADOW, false);
227 mLayout.ReverseAnimeStartSetup(ANIM_IN_UNDER, false);
228 mLayout.ReverseAnimeStartSetup(ANIM_IN_ZANKI, false);
229 mLayout.ReverseAnimeStartSetup(ANIM_IN_COURSE_INFO, false);
230 mLayout.AnimePlay();
231 mLayout.calc();
232
233 mVec2_c scale;
234 dGameCom::DispSizeScale(scale);
235 mpNullPanes[N_proportionL_00]->setScale(scale);
236 mpNullPanes[N_proportionR_00]->setScale(scale);
237 mpNullPanes[N_proportionC_00]->setScale(scale);
238
240
241 return true;
242}
243
245 d2d::ClipSettings clipSettings;
246 if (dGameCom::GetAspectRatio() == 0) {
247 clipSettings.mPos.y = mVideo::getSmth(330.0f);
248 clipSettings.mSize.x = 640.0f;
249 clipSettings.mSize.y = 330.0f;
250 clipSettings.mEnabled = true;
251 }
252 mLayout.mClipSettings = clipSettings;
253}
254
256 static const int picPaneNums[PLAYER_COUNT] = { P_marioFace_00, P_luigiFace_00, P_BkinoFace_00, P_YkinoFace_00 };
257
258 for (int i = 0; i < PLAYER_COUNT; i++) {
259 mpPicturePanes[P_marioFace_00 + i]->setVisible(false);
260 }
261
262 int currPane = N_IconPos1P_00;
263 int playerCount = -1;
264 for (int i = 0; i < PLAYER_COUNT; i++) {
266 int playerIndex = daPyMng_c::getPlayerIndex(playerType);
267 if (dGameCom::PlayerEnterCheck(playerIndex)) {
268 mVec3_c pos = mpNullPanes[currPane]->mPos;
269 mpPicturePanes[picPaneNums[playerType]]->mPos = pos;
270 mpPicturePanes[picPaneNums[playerType]]->setVisible(true);
271 currPane++;
272 playerCount++;
273 }
274 }
275
276 for (int i = 0; i < PLAYER_COUNT; i++) {
277 mpNullPanes[N_IconPos1P_00 + i]->setVisible(false);
278 }
279 mpNullPanes[N_IconPos1P_00 + playerCount]->setVisible(true);
280}
281
283 static const int textBoxIdxs[PLAYER_COUNT] = { T_lifeNumber_00, T_lifeNumber_01, T_lifeNumber_03, T_lifeNumber_02 };
284
285 for (int i = 0; i < PLAYER_COUNT; i++) {
287 int playerIndex = daPyMng_c::getPlayerIndex(playerType);
288 int rest = daPyMng_c::getRest(playerType);
289 if (mRest[i] != rest) {
290 mRest[i] = rest;
291 int textIdx = textBoxIdxs[i];
292 LytTextBox_c *textBox = mpTextBoxes[textIdx];
293 dGameCom::LayoutDispNumber(rest, dGameDisplay_c::c_PLAYNUM_DIGIT, textBox, true);
294 }
295 }
296 mShowRestNumber = false;
297}
298
301 return;
302 }
303 if (mRestAlphaTarget != 0) {
305 if (mRestAlpha >= 255) {
306 mRestAlpha = 255;
307 }
308 } else {
310 if (mRestAlpha < 0) {
311 mRestAlpha = 0;
312 }
313 }
314
315 u8 alpha = mRestAlpha;
316 for (int i = 0; i < PLAYER_COUNT; i++) {
317 mpNullPanes[N_IconPos1P_00 + i]->setAlpha(alpha);
318 mpPicturePanes[P_marioFace_00 + i]->setAlpha(alpha);
319 }
320}
321
323 if (mInitialized && mEnabled) {
324 if (mShowRestNumber) {
326 }
327
328 mStateMgrWorldCourse.executeState();
329 mStateMgrGuide.executeState();
330
331 if (mMapView) {
332 mStateMgrUp.executeState();
333 mStateMgrDown.executeState();
334 mStateMgrLeft.executeState();
335 mStateMgrRight.executeState();
336
337 mMoveDirection = 0;
338 if (mEnableAllArrows) {
339 mEnableAllArrows = false;
340 }
341 if (mDisableArrows) {
342 if (
343 !mLayout.isAnime(ANIM_OUT_ARROW_U) || !mLayout.isAnime(ANIM_OUT_ARROW_D) ||
344 !mLayout.isAnime(ANIM_OUT_ARROW_L) || !mLayout.isAnime(ANIM_OUT_ARROW_R)
345 ) {
346 mDisableArrows = false;
347 mMapView = false;
348 }
349 }
350 }
351
352 mStateMgrScrollGuide.executeState();
353 mStateMgrShadow.executeState();
354 mLayout.AnimePlay();
357 mLayout.calc();
358 }
359}
360
362 if (mInitialized && mEnabled) {
363 mLayout.entry();
364 }
365}
366
368 mLayout.doDelete();
369}
370
371void dCourseSelectGuide_c::CourseSelectSet(dWmLib::PointType_e type) {
372 static const int sc_startPointIcons[WORLD_USED_COUNT] = {
373 MSG_CS_ICON_START_RIGHT, // W1
374 MSG_CS_ICON_START_UP, // W2
375 MSG_CS_ICON_START_RIGHT, // W3
376 MSG_CS_ICON_START_UP, // W4
377 MSG_CS_ICON_START_RIGHT, // W5
378 MSG_CS_ICON_START_UP, // W6
379 MSG_CS_ICON_START_RIGHT, // W7
380 MSG_CS_ICON_START_UP, // W8
381 MSG_CS_ICON_START_UP, // W9
382 };
383 dInfo_c *info = dInfo_c::m_instance;
384 MsgRes_c *msgRes = dMessage_c::getMesRes();
385 int actualWNo = mWorldNo + 1;
386 int actualLevelNo;
387 if (type == dWmLib::POINT_TYPE_PATH) {
388 mCourseNo = -2;
389 return;
390 } else if (type == dWmLib::POINT_TYPE_REGULAR_COURSE || type == dWmLib::POINT_TYPE_OTHER) {
391 actualLevelNo = mCourseNo + 1;
392 } else if (type == dWmLib::POINT_TYPE_START_NODE) {
393 mCourseType = dWmLib::COURSE_TYPE_INVALID; /// [Why not use COURSE_TYPE_KINOKO_START here?]
394 } else {
395 mCourseType = dWmLib::COURSE_TYPE_JUNCTION;
396 }
397 info->field_3b4 = actualWNo;
398 mpTextBoxes[T_worldNum_00]->setMessage(msgRes, BMG_CATEGORY_COURSE_SELECT_GUIDE, MSG_CS_CURR_WORLD, 0);
399 mRestAlphaTarget = 255;
400 int messageID;
401 switch (mCourseType) {
402 default:
403 info->field_3b8 = actualLevelNo;
404 mpTextBoxes[T_cSelect_00]->setMessage(msgRes, BMG_CATEGORY_COURSE_SELECT_GUIDE, MSG_CS_COURSE_NUM, 0);
405 mpTextBoxes[T_cSelect_00]->setVisible(true);
406 mpTextBoxes[T_cSelect_pic]->setVisible(false);
407 return;
408 case dWmLib::COURSE_TYPE_GHOST: messageID = MSG_CS_ICON_GHOST_HOUSE; break;
409 case dWmLib::COURSE_TYPE_TOWER: messageID = MSG_CS_ICON_TOWER; break;
410 case dWmLib::COURSE_TYPE_CASTLE:
411 if (mWorldNo != WORLD_8) {
412 messageID = MSG_CS_ICON_CASTLE;
413 } else {
414 messageID = MSG_CS_ICON_W8_CASTLE;
415 }
416 break;
417 case dWmLib::COURSE_TYPE_KINOKO:
418 if (dScWMap_c::IsCourseType(mWorldNo, mCourseNo, dScWMap_c::COURSE_TYPE_KINOKO_HOUSE_1UP)) {
419 messageID = MSG_CS_ICON_KINOKO_HOUSE_1UP;
420 } else if (dScWMap_c::IsCourseType(mWorldNo, mCourseNo, dScWMap_c::COURSE_TYPE_KINOKO_HOUSE_STAR)) {
421 messageID = MSG_CS_ICON_KINOKO_HOUSE_STAR;
422 } else {
423 messageID = MSG_CS_ICON_KINOKO_HOUSE_RED;
424 }
425 break;
426 case dWmLib::COURSE_TYPE_JUNCTION: messageID = MSG_CS_ICON_JUNCTION; break;
427 case dWmLib::COURSE_TYPE_CANNON: messageID = MSG_CS_ICON_CANNON; break;
428 case dWmLib::COURSE_TYPE_KOOPA_SHIP:
429 if (dWmLib::isKoopaShipAnchor()) {
430 messageID = MSG_CS_ICON_ANCHOR;
431 } else {
432 messageID = MSG_CS_ICON_AIRSHIP;
433 }
434 break;
435 case dWmLib::COURSE_TYPE_PEACH_CASTLE:
437 messageID = MSG_CS_ICON_PEACH_CASTLE;
438 break;
439 case dWmLib::COURSE_TYPE_INVALID:
440 if (dWmLib::getStartPointKinokoHouseKindNum() == 0 || dWmLib::IsCourseClear(mWorldNo, STAGE_START_KINOKO_HOUSE)) {
441 messageID = sc_startPointIcons[mWorldNo];
442 break;
443 }
444 if (dWmLib::isStartPointKinokoHouseStar()) {
445 messageID = MSG_CS_ICON_KINOKO_HOUSE_STAR;
446 } else if (dWmLib::isStartPointKinokoHouseRed()) {
447 messageID = MSG_CS_ICON_KINOKO_HOUSE_RED;
448 } else {
449 messageID = MSG_CS_ICON_KINOKO_HOUSE_1UP;
450 }
451 break;
452 }
453 mpTextBoxes[T_cSelect_pic]->setMessage(msgRes, BMG_CATEGORY_COURSE_SELECT_GUIDE, messageID, 0);
454 mpTextBoxes[T_cSelect_00]->setVisible(false);
455 mpTextBoxes[T_cSelect_pic]->setVisible(true);
456}
457
459 dMj2dGame_c *saveGame = dSaveMng_c::m_instance->getSaveGame(-1);
460 dCyuukan_c *checkpoint = dInfo_c::m_instance->getCyuukan();
461 for (unsigned int i = 0; i < STAR_COIN_COUNT; i++) {
462 mpPicturePanes[P_cC_1s_00 + i]->setVisible(true);
463 mpPicturePanes[P_cC_1s_00 + i]->setAlpha(255);
464 mpPicturePanes[P_cC_1_00 + i]->setAlpha(255);
465 if (mCourseNo < 0 || !dScWMap_c::IsCourseType(mWorldNo, mCourseNo, dScWMap_c::COURSE_TYPE_NO_STAR_COINS)) {
466 mpPicturePanes[P_cC_1s_00 + i]->setVisible(false);
467 } else {
468 u8 collectCoin = saveGame->isCollectCoin(mWorldNo, mCourseNo, i);
469 if (collectCoin != 0) {
470 mpPicturePanes[P_cC_1_00 + i]->setVisible(true);
471 } else if (
472 mWorldNo == checkpoint->mWorldNo
473 && mCourseNo == checkpoint->mCourseNo
474 && checkpoint->mCoinCollection[i] != 4
475 ) {
476 mpPicturePanes[P_cC_1s_00 + i]->setAlpha(0);
477 mpPicturePanes[P_cC_1_00 + i]->setVisible(true);
478 mpPicturePanes[P_cC_1_00 + i]->setAlpha(70);
479 } else {
480 mpPicturePanes[P_cC_1_00 + i]->setVisible(false);
481 }
482 }
483 }
484}
485
487 static const u8 flags[] = {
488 BIT_FLAG(DIR_UP),
489 BIT_FLAG(DIR_DOWN),
490 BIT_FLAG(DIR_LEFT),
491 BIT_FLAG(DIR_RIGHT)
492 };
493 return (mMoveDirection & flags[dir]) != 0;
494}
495
513
515 mCourseInfoAnim = true;
516 mShowCourseInfo = false;
517 mLayout.AnimeStartSetup(ANIM_IN_COURSE_INFO, mNoAnimCourseInfoIn);
518}
520 if (mHideCourseInfo) {
521 mLayout.AnimeEndSetup(ANIM_IN_COURSE_INFO);
523 } else if (!mLayout.isAnime(ANIM_IN_COURSE_INFO)) {
525 }
526}
530
532 mLayout.LoopAnimeStartSetup(ANIM_LOOP_COURSE_INFO);
533}
544
546 mCourseInfoAnim = true;
547 mHideCourseInfo = false;
548 mLayout.AnimeEndSetup(ANIM_LOOP_COURSE_INFO);
549 mLayout.AnimeStartSetup(ANIM_OUT_COURSE_INFO, false);
550}
552 if (mShowCourseInfo) {
553 mLayout.AnimeEndSetup(ANIM_OUT_COURSE_INFO);
555 } else if (!mLayout.isAnime(ANIM_OUT_COURSE_INFO)) {
556 mIsCourseInfoOutAnime = false;
558 }
559}
563
567 return;
568 }
569
570 if (mGuideOnStageTimer > 0) {
572 return;
573 }
575
576 if (mBeginGuide) {
578 }
579}
583
585 mBeginGuide = false;
586 mLayout.AnimeStartSetup(ANIM_IN_UNDER, mNoHUDAppearAnim);
587 mLayout.AnimeStartSetup(ANIM_IN_ZANKI, mNoHUDAppearAnim);
588}
590 if (mEndGuide) {
591 mLayout.AnimeEndSetup(ANIM_IN_UNDER);
592 mLayout.AnimeEndSetup(ANIM_IN_ZANKI);
594 } else {
595 if (mLayout.isAnime(ANIM_IN_UNDER) || mLayout.isAnime(ANIM_IN_ZANKI)) {
596 return;
597 }
599 }
600}
602
604 mLayout.LoopAnimeStartSetup(ANIM_LOOP_UNDER);
605 mLayout.LoopAnimeStartSetup(ANIM_LOOP_ZANKI);
606}
608 if (!mHideHUD) {
609 mBeginGuide = false;
610 if (mEndGuide) {
612 }
613 }
614}
616
618 mEndGuide = false;
619 mLayout.AnimeEndSetup(ANIM_LOOP_UNDER);
620 mLayout.AnimeEndSetup(ANIM_LOOP_ZANKI);
621 mLayout.AnimeStartSetup(ANIM_OUT_UNDER, false);
622 mLayout.AnimeStartSetup(ANIM_OUT_ZANKI, false);
623}
625 if (mBeginGuide) {
626 mLayout.AnimeEndSetup(ANIM_OUT_UNDER);
627 mLayout.AnimeEndSetup(ANIM_OUT_ZANKI);
629 } else {
630 if (mLayout.isAnime(ANIM_OUT_UNDER) || mLayout.isAnime(ANIM_OUT_ZANKI)) {
631 return;
632 }
633 mGuideRelated = false;
635 }
636}
638
646
648 mUpAnim = true;
649 mLayout.AnimeStartSetup(ANIM_IN_ARROW_U, false);
650}
652 if (!IsDirectionAllowed(DIR_UP) || mDisableArrows) {
653 mLayout.AnimeEndSetup(ANIM_IN_ARROW_U);
655 } else {
656 if (mLayout.isAnime(ANIM_IN_ARROW_U) || mLayout.isAnime(ANIM_IN_UNDER)) {
657 return;
658 }
659 mStateMgrUp.changeState(StateID_UpDisp);
660 }
661}
665
667 mLayout.LoopAnimeStartSetup(ANIM_LOOP_ARROW_U);
668}
675
677 mUpAnim = true;
678 mLayout.AnimeEndSetup(ANIM_LOOP_ARROW_U);
679 mLayout.AnimeStartSetup(ANIM_OUT_ARROW_U, false);
680}
682 if (IsDirectionAllowed(DIR_UP)) {
684 } else if (!mLayout.isAnime(ANIM_OUT_ARROW_U)) {
686 }
687}
691
699
701 mDownAnim = true;
702 mLayout.AnimeStartSetup(ANIM_IN_ARROW_D, false);
703}
705 if (!IsDirectionAllowed(DIR_DOWN) || mDisableArrows) {
706 mLayout.AnimeEndSetup(ANIM_IN_ARROW_D);
708 } else if (!mLayout.isAnime(ANIM_IN_ARROW_D)) {
709 mStateMgrDown.changeState(StateID_DownDisp);
710 }
711}
715
717 mLayout.LoopAnimeStartSetup(ANIM_LOOP_ARROW_D);
718}
725
727 mDownAnim = true;
728 mLayout.AnimeEndSetup(ANIM_LOOP_ARROW_D);
729 mLayout.AnimeStartSetup(ANIM_OUT_ARROW_D, false);
730}
732 if (IsDirectionAllowed(DIR_DOWN)) {
734 } else if (!mLayout.isAnime(ANIM_OUT_ARROW_D)) {
736 }
737}
741
749
751 mLeftAnim = true;
752 mLayout.AnimeStartSetup(ANIM_IN_ARROW_L, false);
753}
755 if (!IsDirectionAllowed(DIR_LEFT) || mDisableArrows) {
756 mLayout.AnimeEndSetup(ANIM_IN_ARROW_L);
758 } else if (!mLayout.isAnime(ANIM_IN_ARROW_L)) {
759 mStateMgrLeft.changeState(StateID_LeftDisp);
760 }
761}
765
767 mLayout.LoopAnimeStartSetup(ANIM_LOOP_ARROW_L);
768}
775
777 mLeftAnim = true;
778 mLayout.AnimeEndSetup(ANIM_LOOP_ARROW_L);
779 mLayout.AnimeStartSetup(ANIM_OUT_ARROW_L, false);
780}
782 if (IsDirectionAllowed(DIR_LEFT)) {
784 } else if (!mLayout.isAnime(ANIM_OUT_ARROW_L)) {
786 }
787}
791
799
801 mRightAnim = true;
802 mLayout.AnimeStartSetup(ANIM_IN_ARROW_R, false);
803}
805 if (!IsDirectionAllowed(DIR_RIGHT) || mDisableArrows) {
806 mLayout.AnimeEndSetup(ANIM_IN_ARROW_R);
808 } else if (!mLayout.isAnime(ANIM_IN_ARROW_R)) {
810 }
811}
815
817 mLayout.LoopAnimeStartSetup(ANIM_LOOP_ARROW_R);
818}
825
827 mRightAnim = true;
828 mLayout.AnimeEndSetup(ANIM_LOOP_ARROW_R);
829 mLayout.AnimeStartSetup(ANIM_OUT_ARROW_R, false);
830}
832 if (IsDirectionAllowed(DIR_RIGHT)) {
834 } else if (!mLayout.isAnime(ANIM_OUT_ARROW_R)) {
836 }
837}
841
851
853 mLayout.AnimeStartSetup(ANIM_IN_SHADOW, false);
854}
861
871
873 mLayout.AnimeStartSetup(ANIM_OUT_SHADOW, false);
874}
881
887 mEndScrollGuide = false;
888 mScrollGuideRelated = false;
889 mGuideRelated = false;
890 mInMapView = false;
891#if (defined(VERSION_K) || defined(VERSION_W))
892 // Don't transition to the next state until the animation is finished.
893 // Otherwise, the "View Map" text would change to "Back to Mario" too early.
894 } else if (mShowScrollGuide && !mLayout.isAnime(ANIM_OUT_UNDER)) {
895#else
896 } else if (mShowScrollGuide) {
897#endif
899 }
900}
904
907 mInMapView = true;
908 mpNullPanes[N_guideViewC_00]->setVisible(false);
909 mpNullPanes[N_guideViewR_01]->setVisible(false);
910 mpNullPanes[N_left_00]->setVisible(false);
911 mLayout.AnimeStartSetup(ANIM_IN_UNDER, false);
912 mScrollGuideRelated = true;
913}
915 if (mEndScrollGuide) {
916 mLayout.AnimeEndSetup(ANIM_IN_UNDER);
918 } else if (!mLayout.isAnime(-1)) {
919 // [Bug: The above should probably be !mLayout.isAnime(ANIM_IN_UNDER).
920 // But since ScrollGuideDisp doesn't really do anything, no difference is visible.]
922 }
923}
925
927 mLayout.LoopAnimeStartSetup(ANIM_LOOP_UNDER);
928}
935
937 mEndScrollGuide = false;
938 mLayout.AnimeEndSetup(ANIM_LOOP_UNDER);
939 mLayout.AnimeStartSetup(ANIM_OUT_UNDER, false);
940}
948 mScrollGuideRelated = false;
949 mpNullPanes[N_guideViewC_00]->setVisible(true);
950 mpNullPanes[N_guideViewR_01]->setVisible(true);
951 mpNullPanes[N_left_00]->setVisible(true);
952 mInMapView = false;
953}
954
955void dCourseSelectGuide_c::UpdateGuide(short courseNo, dWmLib::PointType_e type) {
956 if (mCourseNo == courseNo) {
957 return;
958 }
959 mCourseType = dWmLib::GetCourseTypeFromCourseNo(courseNo);
960 mCourseNo = courseNo;
961 CourseSelectSet(type);
962 if (type != dWmLib::POINT_TYPE_PATH) {
964 }
965 dInfo_c *info = dInfo_c::m_instance;
966 dCyuukan_c *checkpoint = &info->mCyuukan;
967 u8 wNo = mWorldNo;
968 u8 cNo = courseNo;
969 mpPicturePanes[P_flagSkull_00]->setVisible(false);
970 for (int i = 0; i < CHECKPOINT_COUNT; i++) {
971 if (checkpoint->isCyuukanStart(i, wNo, cNo)) {
972 mpPicturePanes[P_flagSkull_00]->setVisible(true);
973 break;
974 }
975 }
976}
977
979 Remocon::EXTENSION_TYPE_e attachedExtension = dGameKey_c::m_instance->mRemocon[0]->mAttachedExtension;
980 if (attachedExtension != mExtension) {
981 mExtension = attachedExtension;
982
983 MsgRes_c *msgRes = dMessage_c::getMesRes();
984 bool attached = true;
985 if (attachedExtension == Remocon::EXTENSION_NONE) {
986 attached = false;
987 }
988 dInfo_c::m_instance->mExtensionAttached = attached;
989 if (mInMapView) {
990 mpTextBoxes[T_guideViewLS_00]->setMessage(msgRes, BMG_CATEGORY_COURSE_SELECT_GUIDE, MSG_CS_BACK_TO_MARIO, 0);
991 } else {
992 mpTextBoxes[T_guideViewLS_00]->setMessage(msgRes, BMG_CATEGORY_COURSE_SELECT_GUIDE, MSG_CS_VIEW_MAP, 0);
993 }
994 mpTextBoxes[T_guideViewL_01]->setMessage(msgRes, BMG_CATEGORY_COURSE_SELECT_GUIDE, MSG_CS_ITEMS, 0);
995 }
996}
@ EXTENSION_NONE
No Wii remote extension is connected.
Definition d_game_key.hpp:8
@ EXTENSION_UNKNOWN
It has not been checked yet whether an extension is connected.
bool mLeftAnim
Whether the left arrow is in an animation.
sFStateMgr_c< dCourseSelectGuide_c, sStateMethodUsr_FI_c > mStateMgrUp
The state manager for the up arrow for the map view.
sFStateMgr_c< dCourseSelectGuide_c, sStateMethodUsr_FI_c > mStateMgrGuide
The state manager for the button legends and remaining lives display.
bool mHideCourseInfo
Set this to true to hide the course info.
static sFStateID_c< dCourseSelectGuide_c > StateID_LeftOnStageAnimeEndCheck
The state ID for the LeftOnStageAnimeEndCheck state.
void executeState_DownDisp()
Execution function for the DownDisp state.
bool mShowScrollGuide
Set this to true to show the button legends for the map view mode.
bool mShowRestNumber
Whether to update the remaining lives count.
void executeState_GuideExitAnimeEndCheck()
Execution function for the GuideExitAnimeEndCheck state.
bool mHideShadow
Set this to true to remove the darkening of the world map view.
bool mInMapView
Whether the HUD is in the map view mode.
void initializeState_GuideOnStageAnimeEndCheck()
Initialization function for the GuideOnStageAnimeEndCheck state.
static sFStateID_c< dCourseSelectGuide_c > StateID_DownExitAnimeEndCheck
The state ID for the DownExitAnimeEndCheck state.
void executeState_GuideOnStageAnimeEndCheck()
Execution function for the GuideOnStageAnimeEndCheck state.
void CollectionCoinSet()
Updates the star coin icons.
void initializeState_ShadowExitAnimeEndCheck()
Initialization function for the ShadowExitAnimeEndCheck state.
void finalizeState_ScrollGuideOnStageWait()
Finalization function for the ScrollGuideOnStageWait state.
static sFStateID_c< dCourseSelectGuide_c > StateID_UpOnStageAnimeEndCheck
The state ID for the UpOnStageAnimeEndCheck state.
void initializeState_ScrollGuideOnStageWait()
Initialization function for the ScrollGuideOnStageWait state.
void executeState_LeftOnStageWait()
Execution function for the LeftOnStageWait state.
bool mEndScrollGuide
Set this to true to hide the button legends for the map view mode.
void finalizeState_DownOnStageAnimeEndCheck()
Finalization function for the DownOnStageAnimeEndCheck state.
int mRestAlphaTarget
The target transparency for mRestAlpha.
void ScissorMaskSet()
Clips the layout to the maximum allowed size.
void executeState_ShadowOnStageAnimeEndCheck()
Execution function for the ShadowOnStageAnimeEndCheck state.
bool mNoAnimCourseInfoIn
Whether the course info should simply appear instead of sliding in.
static sFStateID_c< dCourseSelectGuide_c > StateID_GuideDisp
The state ID for the GuideDisp state.
sFStateMgr_c< dCourseSelectGuide_c, sStateMethodUsr_FI_c > mStateMgrDown
The state manager for the down arrow for the map view.
void finalizeState_WorldCourseOnStageWait()
Finalization function for the WorldCourseOnStageWait state.
void finalizeState_RightDisp()
Finalization function for the RightDisp state.
bool mHideHUD
Set this to true to hide the entire HUD.
void initializeState_UpOnStageAnimeEndCheck()
Initialization function for the UpOnStageAnimeEndCheck state.
bool mShowCourseInfo
Set this to true to show the course info.
static sFStateID_c< dCourseSelectGuide_c > StateID_ScrollGuideDisp
The state ID for the ScrollGuideDisp state.
bool mUpAnim
Whether the up arrow is in an animation.
void executeState_DownOnStageAnimeEndCheck()
Execution function for the DownOnStageAnimeEndCheck state.
void initializeState_ShadowDisp()
Initialization function for the ShadowDisp state.
void finalizeState_LeftOnStageAnimeEndCheck()
Finalization function for the LeftOnStageAnimeEndCheck state.
void finalizeState_DownExitAnimeEndCheck()
Finalization function for the DownExitAnimeEndCheck state.
int mCourseNo
The current course number. Set to a negative value if it's a course with an icon.
static sFStateID_c< dCourseSelectGuide_c > StateID_ScrollGuideExitAnimeEndCheck
The state ID for the ScrollGuideExitAnimeEndCheck state.
static sFStateID_c< dCourseSelectGuide_c > StateID_RightOnStageWait
The state ID for the RightOnStageWait state.
void finalizeState_GuideExitAnimeEndCheck()
Finalization function for the GuideExitAnimeEndCheck state.
static sFStateID_c< dCourseSelectGuide_c > StateID_UpOnStageWait
The state ID for the UpOnStageWait state.
void initializeState_ScrollGuideDisp()
Initialization function for the ScrollGuideDisp state.
static sFStateID_c< dCourseSelectGuide_c > StateID_GuideOnStageAnimeEndCheck
The state ID for the GuideOnStageAnimeEndCheck state.
void finalizeState_WorldCourseDisp()
Finalization function for the WorldCourseDisp state.
void executeState_DownOnStageWait()
Execution function for the DownOnStageWait state.
Remocon::EXTENSION_TYPE_e mExtension
The currently attached Wii remote extension.
void executeState_RightOnStageAnimeEndCheck()
Execution function for the RightOnStageAnimeEndCheck state.
bool mEnableAllArrows
Whether to show all map view arrows. Gets reset after 1 frame.
void initializeState_LeftDisp()
Initialization function for the LeftDisp state.
bool mEndGuide
Set this to true to hide the remaining guide.
int mWorldNo
The current world number.
LytBase_c mLayout
The layout for the window.
void initializeState_GuideDisp()
Initialization function for the GuideDisp state.
void initializeState_LeftOnStageAnimeEndCheck()
Initialization function for the LeftOnStageAnimeEndCheck state.
sFStateMgr_c< dCourseSelectGuide_c, sStateMethodUsr_FI_c > mStateMgrLeft
The state manager for the left arrow for the map view.
int mWorldCourseOnStageTimer
Cooldown for showing the course info.
void finalizeState_GuideOnStageWait()
Finalization function for the GuideOnStageWait state.
void finalizeState_UpExitAnimeEndCheck()
Finalization function for the UpExitAnimeEndCheck state.
void initializeState_ShadowOnStageWait()
Initialization function for the ShadowOnStageWait state.
void executeState_DownExitAnimeEndCheck()
Execution function for the DownExitAnimeEndCheck state.
void executeState_LeftExitAnimeEndCheck()
Execution function for the LeftExitAnimeEndCheck state.
int mRest[PLAYER_COUNT]
The remaining lives for each player.
sFStateMgr_c< dCourseSelectGuide_c, sStateMethodUsr_FI_c > mStateMgrWorldCourse
The state manager for the course info (world / course name).
void finalizeState_ShadowExitAnimeEndCheck()
Finalization function for the ShadowExitAnimeEndCheck state.
void executeState_RightExitAnimeEndCheck()
Execution function for the RightExitAnimeEndCheck state.
void initializeState_LeftExitAnimeEndCheck()
Initialization function for the LeftExitAnimeEndCheck state.
bool mDownAnim
Whether the down arrow is in an animation.
sFStateMgr_c< dCourseSelectGuide_c, sStateMethodUsr_FI_c > mStateMgrShadow
The state manager for darkening the course view. [Unused?].
static sFStateID_c< dCourseSelectGuide_c > StateID_WorldCourseOnStageWait
The state ID for the WorldCourseOnStageWait state.
void initializeState_WorldCourseDisp()
Initialization function for the WorldCourseDisp state.
bool mShowShadow
Set this to true to darken the world map view.
bool mDisableArrows
Whether to stop updating the map view arrows.
void executeState_UpExitAnimeEndCheck()
Execution function for the UpExitAnimeEndCheck state.
void UpdateGuide(short courseNo, dWmLib::PointType_e type)
Updates the course-related parts of the course info guide.
static sFStateID_c< dCourseSelectGuide_c > StateID_ScrollGuideOnStageWait
The state ID for the ScrollGuideOnStageWait state.
void executeState_ShadowExitAnimeEndCheck()
Execution function for the ShadowExitAnimeEndCheck state.
void executeState_ShadowOnStageWait()
Execution function for the ShadowOnStageWait state.
void RestAlphaDisp()
Sets the opacity of the remaining lives count.
void initializeState_LeftOnStageWait()
Initialization function for the LeftOnStageWait state.
void initializeState_UpDisp()
Initialization function for the UpDisp state.
void finalizeState_ShadowDisp()
Finalization function for the ShadowDisp state.
void finalizeState_UpDisp()
Finalization function for the UpDisp state.
void executeState_UpDisp()
Execution function for the UpDisp state.
void finalizeState_LeftDisp()
Finalization function for the LeftDisp state.
static sFStateID_c< dCourseSelectGuide_c > StateID_RightExitAnimeEndCheck
The state ID for the RightExitAnimeEndCheck state.
void initializeState_WorldCourseExitAnimeEndCheck()
Initialization function for the WorldCourseExitAnimeEndCheck state.
void initializeState_DownExitAnimeEndCheck()
Initialization function for the DownExitAnimeEndCheck state.
void doDelete()
Prepares the view for deletion.
nw4r::lyt::Pane * mpNullPanes[N_COUNT]
The null panes of the view.
void finalizeState_ScrollGuideDisp()
Finalization function for the ScrollGuideDisp state.
void executeState_ScrollGuideDisp()
Execution function for the ScrollGuideDisp state.
void initializeState_WorldCourseOnStageAnimeEndCheck()
Initialization function for the WorldCourseOnStageAnimeEndCheck state.
static sFStateID_c< dCourseSelectGuide_c > StateID_WorldCourseOnStageAnimeEndCheck
The state ID for the WorldCourseOnStageAnimeEndCheck state.
static sFStateID_c< dCourseSelectGuide_c > StateID_GuideExitAnimeEndCheck
The state ID for the GuideExitAnimeEndCheck state.
static sFStateID_c< dCourseSelectGuide_c > StateID_ShadowDisp
The state ID for the ShadowDisp state.
void finalizeState_DownOnStageWait()
Finalization function for the DownOnStageWait state.
void ControllerConnectCheck()
Checks for attached controller extensions and updates the button hints with the correct icon.
static const int c_DISP_WAIT_TIMER
The speed at which the opacity of the remaining lives counter is changed.
nw4r::lyt::Picture * mpPicturePanes[P_COUNT]
The picture panes of the view.
static dCourseSelectGuide_c * m_instance
The instance of the view.
void finalizeState_UpOnStageAnimeEndCheck()
Finalization function for the UpOnStageAnimeEndCheck state.
void initializeState_ScrollGuideOnStageAnimeEndCheck()
Initialization function for the ScrollGuideOnStageAnimeEndCheck state.
static sFStateID_c< dCourseSelectGuide_c > StateID_DownOnStageWait
The state ID for the DownOnStageWait state.
void initializeState_RightOnStageAnimeEndCheck()
Initialization function for the RightOnStageAnimeEndCheck state.
void executeState_ScrollGuideExitAnimeEndCheck()
Execution function for the ScrollGuideExitAnimeEndCheck state.
void executeState_ShadowDisp()
Execution function for the ShadowDisp state.
void finalizeState_UpOnStageWait()
Finalization function for the UpOnStageWait state.
int mCourseType
The current course type.
static sFStateID_c< dCourseSelectGuide_c > StateID_DownDisp
The state ID for the DownDisp state.
bool mEnabled
Controls whether the HUD is updated every frame.
void initializeState_GuideOnStageWait()
Initialization function for the GuideOnStageWait state.
bool IsDirectionAllowed(int dir)
Returns whether the arrow for direction dir should be shown.
bool mIsCourseInfoOutAnime
Automatically set to false after the course info has been hidden.
void finalizeState_RightOnStageAnimeEndCheck()
Finalization function for the RightOnStageAnimeEndCheck state.
static sFStateID_c< dCourseSelectGuide_c > StateID_GuideOnStageWait
The state ID for the GuideOnStageWait state.
static sFStateID_c< dCourseSelectGuide_c > StateID_LeftDisp
The state ID for the LeftDisp state.
void finalizeState_ScrollGuideOnStageAnimeEndCheck()
Finalization function for the ScrollGuideOnStageAnimeEndCheck state.
static sFStateID_c< dCourseSelectGuide_c > StateID_LeftOnStageWait
The state ID for the LeftOnStageWait state.
bool mMapView
Whether the HUD should process the map view elements.
void initializeState_RightDisp()
Initialization function for the RightDisp state.
void initializeState_UpExitAnimeEndCheck()
Initialization function for the UpExitAnimeEndCheck state.
void finalizeState_ShadowOnStageAnimeEndCheck()
Finalization function for the ShadowOnStageAnimeEndCheck state.
static sFStateID_c< dCourseSelectGuide_c > StateID_WorldCourseExitAnimeEndCheck
The state ID for the WorldCourseExitAnimeEndCheck state.
static sFStateID_c< dCourseSelectGuide_c > StateID_LeftExitAnimeEndCheck
The state ID for the LeftExitAnimeEndCheck state.
void initializeState_RightOnStageWait()
Initialization function for the RightOnStageWait state.
static sFStateID_c< dCourseSelectGuide_c > StateID_ShadowOnStageAnimeEndCheck
The state ID for the ShadowOnStageAnimeEndCheck state.
void finalizeState_GuideOnStageAnimeEndCheck()
Finalization function for the GuideOnStageAnimeEndCheck state.
void executeState_WorldCourseOnStageAnimeEndCheck()
Execution function for the WorldCourseOnStageAnimeEndCheck state.
void executeState_WorldCourseOnStageWait()
Execution function for the WorldCourseOnStageWait state.
static sFStateID_c< dCourseSelectGuide_c > StateID_UpDisp
The state ID for the UpDisp state.
LytTextBox_c * mpTextBoxes[T_COUNT]
The textboxes of the view.
static sFStateID_c< dCourseSelectGuide_c > StateID_ScrollGuideOnStageAnimeEndCheck
The state ID for the ScrollGuideOnStageAnimeEndCheck state.
void initializeState_ScrollGuideExitAnimeEndCheck()
Initialization function for the ScrollGuideExitAnimeEndCheck state.
bool createLayout()
Creates the layout and initializes the class state.
void finalizeState_WorldCourseOnStageAnimeEndCheck()
Finalization function for the WorldCourseOnStageAnimeEndCheck state.
void initializeState_RightExitAnimeEndCheck()
Initialization function for the RightExitAnimeEndCheck state.
void initializeState_DownOnStageWait()
Initialization function for the DownOnStageWait state.
static sFStateID_c< dCourseSelectGuide_c > StateID_DownOnStageAnimeEndCheck
The state ID for the DownOnStageAnimeEndCheck state.
static sFStateID_c< dCourseSelectGuide_c > StateID_UpExitAnimeEndCheck
The state ID for the UpExitAnimeEndCheck state.
void executeState_ScrollGuideOnStageAnimeEndCheck()
Execution function for the ScrollGuideOnStageAnimeEndCheck state.
void CourseSelectSet(dWmLib::PointType_e type)
Updates the textbox that displays the current course.
void finalizeState_LeftExitAnimeEndCheck()
Finalization function for the LeftExitAnimeEndCheck state.
void finalizeState_GuideDisp()
Finalization function for the GuideDisp state.
void executeState_WorldCourseDisp()
Execution function for the WorldCourseDisp state.
void initializeState_ShadowOnStageAnimeEndCheck()
Initialization function for the ShadowOnStageAnimeEndCheck state.
void executeState_GuideOnStageWait()
Execution function for the GuideOnStageWait state.
void executeState_ScrollGuideOnStageWait()
Execution function for the ScrollGuideOnStageWait state.
void initializeState_DownOnStageAnimeEndCheck()
Initialization function for the DownOnStageAnimeEndCheck state.
void finalizeState_ScrollGuideExitAnimeEndCheck()
Finalization function for the ScrollGuideExitAnimeEndCheck state.
void finalizeState_WorldCourseExitAnimeEndCheck()
Finalization function for the WorldCourseExitAnimeEndCheck state.
void draw()
Draws the view.
bool mInitialized
Whether the layout has been fully initialized.
void RestNumberDisp()
Fills in the text boxes showing the remaining lives count.
sFStateMgr_c< dCourseSelectGuide_c, sStateMethodUsr_FI_c > mStateMgrRight
The state manager for the right arrow for the map view.
dCourseSelectGuide_c()
Constructs a new course select guide instance.
void initializeState_DownDisp()
Initialization function for the DownDisp state.
void finalizeState_ShadowOnStageWait()
Finalization function for the ShadowOnStageWait state.
void finalizeState_DownDisp()
Finalization function for the DownDisp state.
void executeState_RightDisp()
Execution function for the RightDisp state.
static sFStateID_c< dCourseSelectGuide_c > StateID_RightOnStageAnimeEndCheck
The state ID for the RightOnStageAnimeEndCheck state.
void executeState_UpOnStageWait()
Execution function for the UpOnStageWait state.
void initializeState_UpOnStageWait()
Initialization function for the UpOnStageWait state.
bool mRightAnim
Whether the right arrow is in an animation.
void finalizeState_LeftOnStageWait()
Finalization function for the LeftOnStageWait state.
virtual ~dCourseSelectGuide_c()
Destroys the instance.
static sFStateID_c< dCourseSelectGuide_c > StateID_ShadowExitAnimeEndCheck
The state ID for the ShadowExitAnimeEndCheck state.
sFStateMgr_c< dCourseSelectGuide_c, sStateMethodUsr_FI_c > mStateMgrScrollGuide
The state manager for the button legends during the map view.
bool mCourseInfoAnim
Whether the course information is in an animation.
void initializeState_GuideExitAnimeEndCheck()
Initialization function for the GuideExitAnimeEndCheck state.
void finalizeState_RightExitAnimeEndCheck()
Finalization function for the RightExitAnimeEndCheck state.
void initializeState_WorldCourseOnStageWait()
Initialization function for the WorldCourseOnStageWait state.
bool mBeginGuide
Set this to true to show the remaining guide.
static sFStateID_c< dCourseSelectGuide_c > StateID_WorldCourseDisp
The state ID for the WorldCourseDisp state.
static sFStateID_c< dCourseSelectGuide_c > StateID_ShadowOnStageWait
The state ID for the ShadowOnStageWait state.
void executeState_LeftDisp()
Execution function for the LeftDisp state.
void finalizeState_RightOnStageWait()
Finalization function for the RightOnStageWait state.
static sFStateID_c< dCourseSelectGuide_c > StateID_RightDisp
The state ID for the RightDisp state.
void executeState_GuideDisp()
Execution function for the GuideDisp state.
void executeState_WorldCourseExitAnimeEndCheck()
Execution function for the WorldCourseExitAnimeEndCheck state.
bool mNoHUDAppearAnim
Whether the HUD should be shown without an animation.
void executeState_RightOnStageWait()
Execution function for the RightOnStageWait state.
void executeState_LeftOnStageAnimeEndCheck()
Execution function for the LeftOnStageAnimeEndCheck state.
void executeState_UpOnStageAnimeEndCheck()
Execution function for the UpOnStageAnimeEndCheck state.
int mGuideOnStageTimer
Cooldown for showing the remaining guide HUD.
nw4r::lyt::Pane * mpRootPane
The root pane of the view.
void PlayerIconSet()
Updates the player icons in the remaining lives info to the active player.
u8 mMoveDirection
A bitmask describing which arrows should be shown in the free move view.
void execute()
The main loop of the view.
Represents the slot-specific save data for the game.
u8 isCollectCoin(int world, int level, int coin) const
Checks if the given Star Coin has been obtained in the given world/level.
static int getPlayerIndex(PLAYER_CHARACTER_e)
A two-dimensional floating point vector.
Definition m_vec.hpp:9
A three-dimensional floating point vector.
Definition m_vec.hpp:100
static T::GlobalData_t mData
PLAYER_CHARACTER_e
The identifiers for each character.
#define STAR_COIN_COUNT
The amount of Star Coins per level.
#define CHECKPOINT_COUNT
The maximum number of checkpoints supported.
@ STAGE_START_KINOKO_HOUSE
The toad house on the starting node of each world.
static const PLAYER_CHARACTER_e sc_PLAYER_ORDER[]
#define STATE_DEFINE(class, name)
Defines a state.
Definition s_State.hpp:32