pause_main.c File Reference

Go to the source code of this file.

Functions
void	pause_tutorial_draw_contents (MenuPanel *menu, s32 baseX, s32 baseY, s32 width, s32 height, s32 opacity, s32 darkening)
void	pause_main_draw_contents (MenuPanel *menu, s32 baseX, s32 baseY, s32 width, s32 height, s32 opacity, s32 darkening)
void	pause_textbox_draw_contents (MenuPanel *menu, s32 baseX, s32 baseY, s32 width, s32 height, s32 opacity, s32 darkening)
void	pause_draw_cursor (MenuPanel *menu, s32 baseX, s32 baseY, s32 width, s32 height, s32 opacity, s32 darkening)
void	pause_set_cursor_opacity (s32 val)
void	pause_set_cursor_pos_immediate (s32 windowID, s32 posX, s32 posY)
void	pause_set_cursor_pos (s32 windowID, s32 posX, s32 posY)
void	pause_interp_cursor (void)
void	pause_update_tab_default (s32 windowIndex, s32 *flags, s32 *posX, s32 *posY, s32 *posZ, f32 *scaleX, f32 *scaleY, f32 *rotX, f32 *rotY, f32 *rotZ, s32 *darkening, s32 *opacity)
void	func_80242FBC (s32 windowIndex, s32 *flags, s32 *posX, s32 *posY, s32 *posZ, f32 *scaleX, f32 *scaleY, f32 *rotX, f32 *rotY, f32 *rotZ, s32 *darkening, s32 *opacity)
void	pause_update_tab_inactive (s32 windowIndex, s32 *flags, s32 *posX, s32 *posY, s32 *posZ, f32 *scaleX, f32 *scaleY, f32 *rotX, f32 *rotY, f32 *rotZ, s32 *darkening, s32 *opacity)
void	pause_update_tab_active (s32 windowIndex, s32 *flags, s32 *posX, s32 *posY, s32 *posZ, f32 *scaleX, f32 *scaleY, f32 *rotX, f32 *rotY, f32 *rotZ, s32 *darkening, s32 *opacity)
void	func_802430E4 (s32 windowIndex, s32 *flags, s32 *posX, s32 *posY, s32 *posZ, f32 *scaleX, f32 *scaleY, f32 *rotX, f32 *rotY, f32 *rotZ, s32 *darkening, s32 *opacity)
void	func_8024313C (s32 windowIndex, s32 *flags, s32 *posX, s32 *posY, s32 *posZ, f32 *scaleX, f32 *scaleY, f32 *rotX, f32 *rotY, f32 *rotZ, s32 *darkening, s32 *opacity)
void	pause_update_page_active_2 (s32 windowIndex, s32 *flags, s32 *posX, s32 *posY, s32 *posZ, f32 *scaleX, f32 *scaleY, f32 *rotX, f32 *rotY, f32 *rotZ, s32 *darkening, s32 *opacity)
void	pause_update_page_active_1 (s32 windowIndex, s32 *flags, s32 *posX, s32 *posY, s32 *posZ, f32 *scaleX, f32 *scaleY, f32 *rotX, f32 *rotY, f32 *rotZ, s32 *darkening, s32 *opacity)
void	pause_update_page_inactive_1 (s32 windowIndex, s32 *flags, s32 *posX, s32 *posY, s32 *posZ, f32 *scaleX, f32 *scaleY, f32 *rotX, f32 *rotY, f32 *rotZ, s32 *darkening, s32 *opacity)
void	pause_update_page_inactive_2 (s32 windowIndex, s32 *flags, s32 *posX, s32 *posY, s32 *posZ, f32 *scaleX, f32 *scaleY, f32 *rotX, f32 *rotY, f32 *rotZ, s32 *darkening, s32 *opacity)
s32	pause_interp_text_scroll (s32 deltaBefore)
s32	pause_interp_vertical_scroll (s32 deltaBefore)
void	pause_init (void)
void	pause_tutorial_input (s32 *pressed, s32 *held)
void	pause_handle_input (s32 pressed, s32 held)
void	pause_cleanup (void)
s32	pause_get_total_equipped_bp_cost (void)
void	pause_draw_rect (s32 ulx, s32 uly, s32 lrx, s32 lry, s32 tileIdx, s32 uls, s32 ult, s32 dsdx, s32 dtdy)
void	pause_sort_item_list (s16 *arr, s32 len, s32(*compare)(s16 *, s16 *))

Variables
MenuPanel	gPausePanelTabs
MenuPanel	gPausePanelStats
MenuPanel	gPausePanelBadges
MenuPanel	gPausePanelItems
MenuPanel	gPausePanelPartners
MenuPanel	gPausePanelSpirits
MenuPanel	gPausePanelMap
BSS s32	gPauseHeldButtons
BSS s32	gPausePressedButtons
BSS s32	gPauseCurrentDescMsg
BSS HudScript *	gPauseCurrentDescIconScript
BSS HudElemID	gPauseCursorHID
BSS s8	gPauseMenuCurrentTab
BSS s8	D_802700D [7]
MenuPanel *	gPausePanels []
s32	gPauseCursorPosX = 160
s32	gPauseCursorPosY = -120
s32	gPauseCursorOpacity = 0
s32	gPauseCursorTargetPosX = 160
s32	gPauseCursorTargetPosY = -120
s32	gPauseCursorTargetOpacity = 0
u32	D_8024EFB4 = 1
s16	D_8024EFB8 [] = { -10, -25, -42, -60, -80 }
u8	gPauseWindowFlipUpFlags [] = { DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, 0, 0}
s16	gPauseWindowFlipUpAngles [] = { -80, -65, -38, -30, -10, 0 }
s16	gPauseWindowFlipUpAngles_2 [] = { 80, 65, 38, 30, 10, 0 }
u8	gPauseWindowFlipDownFlags [] = { DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, 0, 0 }
u8	D_8024EFEC []
s16	gPauseWindowFlipDownAngles [] = { -10, -25, -42, -60, -80}
s16	gPauseWindowFlipDownAngles_2 [] = { 10, 25, 42, 60, 80 }
s32	gPauseTutorialState = -1
s32	gPauseTutorialInputState = 3
s32	gPauseTutorialButtons [] = { BUTTON_A, BUTTON_STICK_RIGHT, BUTTON_A, BUTTON_A, BUTTON_A, BUTTON_A, BUTTON_START }
s32	gPauseTutorialDescMessages []
s32	gPauseTutorialCmdMessages []
s32	D_8024F074 []
s32	gPauseTutorialIconIDs [] = { 5, 4, 5, 5, 5, 5, 6 }
u8	gPauseMenuTextScrollInterpEasingLUT [] = { 0, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8}
u8	gPauseMenuPageScrollInterpEasingLUT [] = { 0, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8}
s32	gPauseTutorialSpriteAnims [][4]
Vp	gPauseTutorialViewport
s32	gPauseTutorialScrollPos = 0
MenuWindowBP	gPauseCommonWindowsBPs []

Function Documentation

pause_tutorial_draw_contents()

void pause_tutorial_draw_contents	(	MenuPanel *	menu,
		s32	baseX,
		s32	baseY,
		s32	width,
		s32	height,
		s32	opacity,
		s32	darkening )

Definition at line 513 of file pause_main.c.

                                                                                                                            {
    Matrix4f matrix1;
    Matrix4f matrix2;
    f32 (*matrix2ptr)[4];
    s32 msgHeight;
    s32 msgWidth;
    s32 msgMaxLineChars;
    s32 msgNumLines;
    s32 msgMaxLinesPerPage;
    s32 msgHeight2;
    u32 msgWidth2;
    s32 msgMaxLineChars2;
    s32 msgNumLines2;
    s32 msgMaxLinesPerPage2;
    s32 i;
    s32 margin, margin2;
    s32 state;
 
    if (evt_get_variable(nullptr, GF_Tutorial_Badges) == false) {
        return;
    }
 
    gDPSetCycleType(gMainGfxPos++, G_CYC_1CYCLE);
    gDPSetRenderMode(gMainGfxPos++, G_RM_CLD_SURF, G_RM_CLD_SURF2);
    gDPSetCombineMode(gMainGfxPos++, G_CC_PRIMITIVE, G_CC_PRIMITIVE);
    gDPSetPrimColor(gMainGfxPos++, 0, 0, 55, 55, 55, 255);
    pause_draw_rect(baseX * 4, baseY * 4, (baseX + width) * 4, (baseY + 12) * 4, 0, 0, 0, 0, 0);
    gDPPipeSync(gMainGfxPos++);
    gDPSetPrimColor(gMainGfxPos++, 0, 0, 185, 185, 185, 255);
    pause_draw_rect(baseX * 4, (baseY + 12) * 4, (baseX + width) * 4, (baseY + height) * 4, 0, 0, 0, 0, 0);
    gDPPipeSync(gMainGfxPos++);
    gSPViewport(gMainGfxPos++, &gPauseTutorialViewport);
    guOrthoF(matrix1, 0.0f, 320.0f, 240.0f, 0.0f, -100.0f, 100.0f, 1.0f);
    guMtxF2L(matrix1, &gDisplayContext->matrixStack[gMatrixListPos]);
    gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
 
    for (i = 0; i < 3; i++) {
        //needed to match
        matrix2ptr = matrix2;
        switch (i) {
            case 0:
                guTranslateF(matrix1, 40.0f, 223.0f, 0);
                guScaleF(matrix2ptr, -0.8f, 0.8f, 1.0f);
                break;
            case 1:
                guTranslateF(matrix1, 60.0f, 223.0f, 0);
                guScaleF(matrix2ptr, -0.8f, 0.8f, 1.0f);
                break;
            default:
                guTranslateF(matrix1, 280.0f, 223.0f, 0);
                guScaleF(matrix2ptr, 0.8f, 0.8f, 1.0f);
                break;
        }
 
        guMtxCatF(matrix2ptr, matrix1, matrix1);
        guRotateF(matrix2ptr, 180.0f, 0.0f, 0.0f, 1.0f);
        guMtxCatF(matrix2ptr, matrix1, matrix1);
        guRotateF(matrix2ptr, 180.0f, 0.0f, 1.0f, 0.0f);
        guMtxCatF(matrix2ptr, matrix1, matrix1);
        guMtxF2L(matrix1, &gDisplayContext->matrixStack[gMatrixListPos]);
        gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
        set_npc_imgfx_all(gPauseTutorialSprites[i], IMGFX_SET_COLOR, 255, 255, 255, 255, 64);
        spr_draw_npc_sprite(gPauseTutorialSprites[i], 0, 0, 0, matrix1);
        gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
    }
 
    get_msg_properties(pause_get_menu_msg(PAUSE_MSG_TUT_NAME_BADGES), &msgHeight, &msgWidth, &msgMaxLineChars, &msgNumLines, &msgMaxLinesPerPage, nullptr, 1);
    margin = (s32)(width - msgWidth) >> 1;
    draw_msg(pause_get_menu_msg(PAUSE_MSG_TUT_NAME_BADGES), baseX + margin, baseY, 255, MSG_PAL_WHITE, DRAW_MSG_STYLE_MENU);
    gPauseTutorialScrollPos += pause_interp_text_scroll(gPauseTutorialState * 140 - gPauseTutorialScrollPos);
    gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE, baseX + 1, baseY + 1, baseX + width - 1, baseY + height - 1);
    state = gPauseTutorialState;
    get_msg_properties(pause_get_menu_msg(gPauseTutorialDescMessages[state]), &msgHeight2, &msgWidth2, &msgMaxLineChars2, &msgNumLines2, &msgMaxLinesPerPage2, nullptr, 1);
    margin2 = (s32)(width - msgWidth2) >> 1;
    draw_msg(pause_get_menu_msg(gPauseTutorialDescMessages[state]), baseX + margin2, baseY + 13 + state * 140 - gPauseTutorialScrollPos, 255, MSG_PAL_STANDARD, DRAW_MSG_STYLE_MENU);
    hud_element_set_render_pos(gPauseCommonHIDs[gPauseTutorialIconIDs[gPauseTutorialState]], baseX + width / 2 - 2, baseY + 52);
    hud_element_set_flags(gPauseCommonHIDs[gPauseTutorialIconIDs[gPauseTutorialState]], HUD_ELEMENT_FLAG_FILTER_TEX);
    hud_element_set_scale(gPauseCommonHIDs[gPauseTutorialIconIDs[gPauseTutorialState]], 0.5f);
    hud_element_draw_without_clipping(gPauseCommonHIDs[gPauseTutorialIconIDs[gPauseTutorialState]]);
 
    if (gPauseTutorialIconIDs[gPauseTutorialState] == 6) {
        hud_element_set_render_pos(gPauseCommonHIDs[7], baseX + width / 2 + 1, baseY + 50);
        hud_element_draw_without_clipping(gPauseCommonHIDs[7]);
    }
 
    draw_msg(pause_get_menu_msg(gPauseTutorialCmdMessages[gPauseTutorialState]), baseX + width / 2 + 10, baseY + 44, 255, MSG_PAL_STANDARD, 0);
}

pause_main_draw_contents()

void pause_main_draw_contents	(	MenuPanel *	menu,
		s32	baseX,
		s32	baseY,
		s32	width,
		s32	height,
		s32	opacity,
		s32	darkening )

Definition at line 479 of file pause_main.c.

                                                                                                                        {
}

pause_textbox_draw_contents()

void pause_textbox_draw_contents	(	MenuPanel *	menu,
		s32	baseX,
		s32	baseY,
		s32	width,
		s32	height,
		s32	opacity,
		s32	darkening )

Definition at line 482 of file pause_main.c.

                                                                                                                           {
    s32 msgID = gPauseShownDescMsg;
 
    if (msgID == MSG_NONE) {
        return;
    }
 
    if (gPauseDescTextPos != 0) {
        hud_element_set_render_pos(gPauseCommonHIDs[1], baseX + width - 4, baseY + 4);
        hud_element_draw_without_clipping(gPauseCommonHIDs[1]);
    }
 
    if (gPauseDescTextPos < gPauseDescTextMaxPos) {
        hud_element_set_render_pos(gPauseCommonHIDs[2], baseX + width - 4, baseY + height - 4);
        hud_element_draw_without_clipping(gPauseCommonHIDs[2]);
    }
 
    gDPPipeSync(gMainGfxPos++);
    gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE, baseX + 1, baseY + 1, baseX + width - 1, baseY + height - 1);
    draw_msg(msgID, baseX + 10, baseY - gPauseDescTextOffset, 255, MSG_PAL_STANDARD, 0);
    if (gPauseShownDescIconScript != 0) {
        gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
        hud_element_set_render_pos(gPauseCommonHIDs[3], baseX - 4, baseY + 16);
        hud_element_set_script(gPauseCommonHIDs[3], gPauseShownDescIconScript);
        hud_element_set_flags(gPauseCommonHIDs[3], HUD_ELEMENT_FLAG_DROP_SHADOW);
        hud_element_clear_flags(gPauseCommonHIDs[3], HUD_ELEMENT_FLAG_FILTER_TEX);
        hud_element_set_scale(gPauseCommonHIDs[3], 1.0f);
        hud_element_draw_without_clipping(gPauseCommonHIDs[3]);
    }
}

pause_draw_cursor()

void pause_draw_cursor	(	MenuPanel *	menu,
		s32	baseX,
		s32	baseY,
		s32	width,
		s32	height,
		s32	opacity,
		s32	darkening )

Definition at line 464 of file pause_main.c.

                                                                                                                 {
    s32 currentOpacity;
 
    pause_interp_cursor();
    currentOpacity = gPauseCursorOpacity;
    if (currentOpacity > 0) {
        if (currentOpacity > 255) {
            currentOpacity = 255;
        }
        hud_element_set_alpha(gPauseCommonHIDs[0], currentOpacity);
        hud_element_set_render_pos(gPauseCommonHIDs[0], baseX + gPauseCursorPosX, baseY + gPauseCursorPosY);
        hud_element_draw_without_clipping(gPauseCommonHIDs[0]);
    }
}

pause_set_cursor_opacity()

void pause_set_cursor_opacity

(

s32

val

)

Definition at line 189 of file pause_main.c.

                                       {
    gPauseCursorTargetOpacity = val;
}

Referenced by pause_badges_draw_contents().

pause_set_cursor_pos_immediate()

void pause_set_cursor_pos_immediate	(	s32	windowID,
		s32	posX,
		s32	posY )

Definition at line 193 of file pause_main.c.

                                                                      {
    Window* window = &gWindows[windowID];
 
    if (D_8024EFB4 != 0 || get_game_mode() == GAME_MODE_END_FILE_SELECT) {
        if (D_8024EFB4 != 0) {
            s32 i;
 
            for (i = WIN_PAUSE_MAIN; i < WIN_PAUSE_CURSOR; i++) {
                Window* window = &gWindows[i];
                s8 parent = window->parent;
 
                if ((parent == WIN_NONE || parent == WIN_PAUSE_MAIN) && (window->flags & WINDOW_FLAG_INITIAL_ANIMATION)) {
                    break;
                }
            }
            if (i >= WIN_PAUSE_CURSOR) {
                D_8024EFB4 = 0;
            }
        }
        gPauseCursorTargetPosX = posX;
        gPauseCursorPosX = posX;
        gPauseCursorTargetPosY = posY;
        gPauseCursorPosY = posY;
 
    } else if ((window->flags & WINDOW_FLAG_INITIAL_ANIMATION) == 0 && (window->parent == WIN_NONE || !(gWindows[window->parent].flags & WINDOW_FLAG_INITIAL_ANIMATION))) {
        gPauseCursorTargetPosX = posX;
        gPauseCursorPosX = posX;
        gPauseCursorTargetPosY = posY;
        gPauseCursorPosY = posY;
    }
}

Referenced by pause_badges_draw_contents(), and pause_items_draw_contents().

pause_set_cursor_pos()

void pause_set_cursor_pos	(	s32	windowID,
		s32	posX,
		s32	posY )

Definition at line 225 of file pause_main.c.

                                                            {
    Window* window = &gWindows[windowID];
 
    if (D_8024EFB4 != 0 || get_game_mode() == GAME_MODE_END_FILE_SELECT) {
        if (D_8024EFB4 != 0) {
            s32 i;
 
            for (i = WIN_PAUSE_MAIN; i < WIN_PAUSE_CURSOR; i++) {
                Window* window = &gWindows[i];
                s8 parent = window->parent;
 
                if ((parent == WIN_NONE || parent == WIN_PAUSE_MAIN) && (window->flags & WINDOW_FLAG_INITIAL_ANIMATION)) {
                    break;
                }
            }
            if (i >= 44) {
                D_8024EFB4 = 0;
            }
        }
        gPauseCursorTargetPosX = posX;
        gPauseCursorPosX = posX;
        gPauseCursorTargetPosY = posY;
        gPauseCursorPosY = posY;
    } else if ((window->flags & WINDOW_FLAG_INITIAL_ANIMATION) == 0 && (window->parent == WIN_NONE || !(gWindows[window->parent].flags & WINDOW_FLAG_INITIAL_ANIMATION))) {
        gPauseCursorTargetPosX = posX;
        gPauseCursorTargetPosY = posY;
    }
}

Referenced by pause_badges_draw_contents(), pause_items_draw_contents(), pause_map_draw_contents(), pause_partners_draw_contents(), pause_partners_draw_movelist(), pause_spirits_draw_contents(), pause_stats_draw_contents(), pause_tabs_draw_badges(), pause_tabs_draw_items(), pause_tabs_draw_map(), pause_tabs_draw_party(), pause_tabs_draw_spirits(), and pause_tabs_draw_stats().

pause_interp_cursor()

void pause_interp_cursor

(

void

)

Definition at line 254 of file pause_main.c.

                               {
    s32 xDelta;
    s32 yDelta;
 
    xDelta = (gPauseCursorTargetPosX - gPauseCursorPosX) * 0.5;
    yDelta = (gPauseCursorTargetPosY - gPauseCursorPosY) * 0.5;
 
    if ((gPauseCursorTargetPosX != gPauseCursorPosX) || (gPauseCursorTargetPosY != gPauseCursorPosY)) {
        if ((xDelta == 0) && (yDelta == 0)) {
            gPauseCursorPosX = gPauseCursorTargetPosX;
            gPauseCursorPosY = gPauseCursorTargetPosY;
        }
    }
 
    gPauseCursorPosX += xDelta;
    gPauseCursorPosY += yDelta;
 
    if (gPauseCursorTargetOpacity == 0) {
        gPauseCursorOpacity -= 128;
        if (gPauseCursorOpacity < 0) {
            gPauseCursorOpacity = 0;
        }
    } else {
        gPauseCursorOpacity += 32;
        if (gPauseCursorOpacity> 255) {
            gPauseCursorOpacity = 255;
        }
    }
    gPauseCursorTargetOpacity = 255;
}

Referenced by pause_draw_cursor().

pause_update_tab_default()

void pause_update_tab_default	(	s32	windowIndex,
		s32 *	flags,
		s32 *	posX,
		s32 *	posY,
		s32 *	posZ,
		f32 *	scaleX,
		f32 *	scaleY,
		f32 *	rotX,
		f32 *	rotY,
		f32 *	rotZ,
		s32 *	darkening,
		s32 *	opacity )

Definition at line 285 of file pause_main.c.

                                                                                  {
    Window* window = &gWindows[windowIndex];
 
    *darkening = 160;
    window->flags &= ~(WINDOW_FLAG_HIDDEN | WINDOW_FLAG_INITIAL_ANIMATION);
}

func_80242FBC()

void func_80242FBC	(	s32	windowIndex,
		s32 *	flags,
		s32 *	posX,
		s32 *	posY,
		s32 *	posZ,
		f32 *	scaleX,
		f32 *	scaleY,
		f32 *	rotX,
		f32 *	rotY,
		f32 *	rotZ,
		s32 *	darkening,
		s32 *	opacity )

Definition at line 293 of file pause_main.c.

                                                                                  {
    Window* window = &gWindows[windowIndex];
 
    *darkening = 160;
    *opacity = 80;
    window->flags &= ~(WINDOW_FLAG_HIDDEN | WINDOW_FLAG_INITIAL_ANIMATION);
}

pause_update_tab_inactive()

void pause_update_tab_inactive	(	s32	windowIndex,
		s32 *	flags,
		s32 *	posX,
		s32 *	posY,
		s32 *	posZ,
		f32 *	scaleX,
		f32 *	scaleY,
		f32 *	rotX,
		f32 *	rotY,
		f32 *	rotZ,
		s32 *	darkening,
		s32 *	opacity )

Definition at line 302 of file pause_main.c.

                                                                                  {
    Window* window = &gWindows[windowIndex];
    s32 updateCounter = window->updateCounter;
 
    if (updateCounter == 0) {
        window->flags &= ~WINDOW_FLAG_HIDDEN;
    }
 
    if (updateCounter == 5) {
        update_window_hierarchy(windowIndex, window->originalPriority);
    }
 
    if (updateCounter < 10) {
        *darkening = (updateCounter + 1) * 16;
    } else {
        *darkening = 160;
        window->flags &= ~WINDOW_FLAG_INITIAL_ANIMATION;
    }
}

Referenced by pause_tabs_handle_input().

pause_update_tab_active()

void pause_update_tab_active	(	s32	windowIndex,
		s32 *	flags,
		s32 *	posX,
		s32 *	posY,
		s32 *	posZ,
		f32 *	scaleX,
		f32 *	scaleY,
		f32 *	rotX,
		f32 *	rotY,
		f32 *	rotZ,
		s32 *	darkening,
		s32 *	opacity )

Definition at line 323 of file pause_main.c.

                                                                                  {
    Window* window = &gWindows[windowIndex];
 
    if (window->updateCounter == 0) {
        update_window_hierarchy(windowIndex, window->originalPriority);
        *darkening = 0;
        window->flags &= ~WINDOW_FLAG_INITIAL_ANIMATION;
    }
}

Referenced by pause_tabs_handle_input().

func_802430E4()

void func_802430E4	(	s32	windowIndex,
		s32 *	flags,
		s32 *	posX,
		s32 *	posY,
		s32 *	posZ,
		f32 *	scaleX,
		f32 *	scaleY,
		f32 *	rotX,
		f32 *	rotY,
		f32 *	rotZ,
		s32 *	darkening,
		s32 *	opacity )

Definition at line 334 of file pause_main.c.

                                                                                  {
    Window* window = &gWindows[windowIndex];
    s32 updateCounter = window->updateCounter;
 
    if (updateCounter == 0) {
        window->flags &= ~WINDOW_FLAG_HIDDEN;
    }
 
    if (updateCounter < 16) {
        *opacity = updateCounter * 16;
    } else {
        *opacity = 255;
        window->flags &= ~WINDOW_FLAG_INITIAL_ANIMATION;
    }
}

func_8024313C()

void func_8024313C	(	s32	windowIndex,
		s32 *	flags,
		s32 *	posX,
		s32 *	posY,
		s32 *	posZ,
		f32 *	scaleX,
		f32 *	scaleY,
		f32 *	rotX,
		f32 *	rotY,
		f32 *	rotZ,
		s32 *	darkening,
		s32 *	opacity )

Definition at line 351 of file pause_main.c.

                                                                                  {
    Window* window = &gWindows[windowIndex];
    s32 updateCounter = window->updateCounter;
 
    if (updateCounter < 16) {
        *opacity = 255 - (updateCounter * 16);
    } else {
        *opacity = 0;
        window->flags &= ~WINDOW_FLAG_INITIAL_ANIMATION;
        window->flags |= WINDOW_FLAG_HIDDEN;
    }
}

pause_update_page_active_2()

void pause_update_page_active_2	(	s32	windowIndex,
		s32 *	flags,
		s32 *	posX,
		s32 *	posY,
		s32 *	posZ,
		f32 *	scaleX,
		f32 *	scaleY,
		f32 *	rotX,
		f32 *	rotY,
		f32 *	rotZ,
		s32 *	darkening,
		s32 *	opacity )

Definition at line 365 of file pause_main.c.

                                                                                  {
    Window* window = &gWindows[windowIndex];
    s32 updateCounter = window->updateCounter;
 
    if (updateCounter == 0) {
        window->flags &= ~WINDOW_FLAG_HIDDEN;
    }
    if (updateCounter < 7) {
        *flags = gPauseWindowFlipUpFlags[updateCounter];
        *rotX += gPauseWindowFlipUpAngles[updateCounter];
    } else {
        *flags = gPauseWindowFlipUpFlags[5];
        *rotX += gPauseWindowFlipUpAngles[6];
        window->flags &= ~WINDOW_FLAG_INITIAL_ANIMATION;
    }
}

Referenced by pause_tabs_update().

pause_update_page_active_1()

void pause_update_page_active_1	(	s32	windowIndex,
		s32 *	flags,
		s32 *	posX,
		s32 *	posY,
		s32 *	posZ,
		f32 *	scaleX,
		f32 *	scaleY,
		f32 *	rotX,
		f32 *	rotY,
		f32 *	rotZ,
		s32 *	darkening,
		s32 *	opacity )

Definition at line 383 of file pause_main.c.

                                                                                  {
    Window* window = &gWindows[windowIndex];
    s32 updateCounter = window->updateCounter;
 
    if (updateCounter == 0) {
        window->flags &= ~WINDOW_FLAG_HIDDEN;
    }
    if (updateCounter < 7) {
        *flags = gPauseWindowFlipUpFlags[updateCounter];
        *rotX += gPauseWindowFlipUpAngles_2[updateCounter];
    } else {
        *flags = gPauseWindowFlipUpFlags[5];
        *rotX += gPauseWindowFlipUpAngles_2[6];
        window->flags &= ~WINDOW_FLAG_INITIAL_ANIMATION;
    }
}

Referenced by pause_tabs_update().

pause_update_page_inactive_1()

void pause_update_page_inactive_1	(	s32	windowIndex,
		s32 *	flags,
		s32 *	posX,
		s32 *	posY,
		s32 *	posZ,
		f32 *	scaleX,
		f32 *	scaleY,
		f32 *	rotX,
		f32 *	rotY,
		f32 *	rotZ,
		s32 *	darkening,
		s32 *	opacity )

Definition at line 401 of file pause_main.c.

                                                                                  {
    Window* window = &gWindows[windowIndex];
    s32 updateCounter = window->updateCounter;
 
    if (updateCounter < 5) {
        *flags = gPauseWindowFlipDownFlags[updateCounter];
        *rotX += gPauseWindowFlipDownAngles[updateCounter];
    } else {
        *flags = gPauseWindowFlipDownFlags[4];
        *rotX += gPauseWindowFlipDownAngles[4];
        window->flags &= ~WINDOW_FLAG_INITIAL_ANIMATION;
        window->flags |= WINDOW_FLAG_HIDDEN;
    }
}

Referenced by pause_tabs_update().

pause_update_page_inactive_2()

void pause_update_page_inactive_2	(	s32	windowIndex,
		s32 *	flags,
		s32 *	posX,
		s32 *	posY,
		s32 *	posZ,
		f32 *	scaleX,
		f32 *	scaleY,
		f32 *	rotX,
		f32 *	rotY,
		f32 *	rotZ,
		s32 *	darkening,
		s32 *	opacity )

Definition at line 417 of file pause_main.c.

                                                                                  {
    Window* window = &gWindows[windowIndex];
    s32 updateCounter = window->updateCounter;
 
    if (updateCounter < 5) {
        *flags = gPauseWindowFlipDownFlags[updateCounter];
        *rotX = gPauseWindowFlipDownAngles_2[updateCounter];
    } else {
        *flags = gPauseWindowFlipDownFlags[4];
        *rotX = gPauseWindowFlipDownAngles_2[4];
        window->flags &= ~WINDOW_FLAG_INITIAL_ANIMATION;
        window->flags |= WINDOW_FLAG_HIDDEN;
    }
}

Referenced by pause_tabs_update().

pause_interp_text_scroll()

s32 pause_interp_text_scroll

(

s32

deltaBefore

)

Definition at line 433 of file pause_main.c.

                                              {
    s32 val;
    s32 db = abs(deltaBefore);
    s32 s = sign(deltaBefore);
 
    if (db >= 16) {
        val = 8;
    } else {
        val = gPauseMenuTextScrollInterpEasingLUT[db];
    }
 
    return val * s;
}

Referenced by pause_handle_input(), and pause_tutorial_draw_contents().

pause_interp_vertical_scroll()

s32 pause_interp_vertical_scroll

(

s32

deltaBefore

)

Definition at line 447 of file pause_main.c.

                                                  {
    s32 val;
    s32 db = abs(deltaBefore);
    s32 s = sign(deltaBefore);
 
    if (db >= 16) {
        val = db / 2;
        if (val > 20) {
            val = 20;
        }
    } else {
        val = gPauseMenuPageScrollInterpEasingLUT[db];
    }
 
    return val * s;
}

Referenced by pause_badges_update(), and pause_items_update().

pause_init()

void pause_init

(

void

)

Definition at line 601 of file pause_main.c.

                      {
    s32 posX;
    s32 x;
    Window* pauseWindows;
    MenuPanel** menuPanels;
    s32 i;
 
    DMA_COPY_SEGMENT(ui_images_filemenu_pause);
 
    for (i = 0; i < ARRAY_COUNT(gPauseHudScripts); i++) {
        gPauseCommonHIDs[i] = hud_element_create(gPauseHudScripts[i]);
        if (gPauseHudScripts[i] == &HES_AnimatedCursorHand) {
            hud_element_set_flags(gPauseCommonHIDs[i], HUD_ELEMENT_FLAG_DROP_SHADOW | HUD_ELEMENT_FLAG_MANUAL_RENDER);
        } else {
            hud_element_set_flags(gPauseCommonHIDs[i], HUD_ELEMENT_FLAG_MANUAL_RENDER);
        }
    }
 
    gPauseCursorHID = gPauseCommonHIDs[0];
    setup_pause_menu_tab(gPauseCommonWindowsBPs, ARRAY_COUNT(gPauseCommonWindowsBPs));
    gPauseShownDescMsg = 0;
    gPauseDescTextPos = 0;
    gPauseDescTextOffset = 0;
    gPauseDescTextMaxPos = 0;
    gPauseShownDescIconScript = 0;
    gPauseCurrentDescMsg = MSG_NONE;
    gPauseCurrentDescIconScript = 0;
    gPauseMenuCurrentTab = 0;
 
    menuPanels = gPausePanels;
    for (i = 0; i < ARRAY_COUNT(gPausePanels); menuPanels++, i++) {
        if ((*menuPanels)->fpInit) {
            (*menuPanels)->fpInit(*menuPanels);
        }
    }
 
    posX = 225;
    for (i = 6; i > 0; i--) {
        if (!gPausePanels[i]->initialized) {
            set_window_update(WIN_PAUSE_TUTORIAL + i, WINDOW_UPDATE_HIDE);
        } else {
            gWindows[WIN_PAUSE_TUTORIAL + i].pos.x = posX + 14;
            posX -= 45;
        }
    }
    pauseWindows = &gWindows[WIN_PAUSE_TAB_STATS];
    x = pauseWindows[gPausePanels[0]->col].pos.x;
    gWindows[WIN_PAUSE_TAB_INVIS].pos.x = x + 6;
 
    if (evt_get_variable(nullptr, GF_Tutorial_Badges)) {
        for (i = 0; i < ARRAY_COUNT(gPauseTutorialSpriteAnims); i++) {
            gPauseTutorialSprites[i] = spr_load_npc_sprite(gPauseTutorialSpriteAnims[i][0], gPauseTutorialSpriteAnims[i]);
        }
 
        set_window_update(WIN_PAUSE_TUTORIAL, WINDOW_UPDATE_SHOW);
        sfx_play_sound(SOUND_MENU_SHOW_CHOICE);
    }
 
    update_window_hierarchy(WIN_PAUSE_CURSOR, 64);
}

Referenced by state_step_pause().

pause_tutorial_input()

void pause_tutorial_input	(	s32 *	pressed,
		s32 *	held )

Definition at line 662 of file pause_main.c.

                                                   {
    s32 pressedOld = *pressed;
    s32 pressedNew = *pressed;
    s32 heldNew = *held;
 
    switch (gPauseTutorialInputState) {
        case 0:
            heldNew = pressedNew = pressedNew & gPauseTutorialButtons[gPauseTutorialState];
            if (pressedNew) {
                gPauseTutorialInputState = 1;
            }
            if (pressedOld && pressedNew == 0) {
                sfx_play_sound(SOUND_MENU_ERROR);
            }
            if (gPauseTutorialState == 0) {
                pressedNew = 0;
                heldNew = 0;
            }
            break;
        case 1:
            gPauseTutorialFrameCounter = 0;
            gPauseTutorialInputState = 2;
            pressedNew = 0;
            heldNew = 0;
            break;
        case 2:
            if (--gPauseTutorialFrameCounter <= 0) {
                gPauseTutorialInputState = 3;
            }
            pressedNew = 0;
            heldNew = 0;
            break;
        case 3:
            gPauseTutorialFrameCounter = 16;
            gPauseTutorialInputState = 4;
            gPauseTutorialState++;
            pressedNew = 0;
            heldNew = 0;
            break;
        case 4:
            if (--gPauseTutorialFrameCounter <= 0) {
                gPauseTutorialInputState = 0;
            }
            pressedNew = 0;
            heldNew = 0;
            break;
    }
 
    *pressed = pressedNew;
    *held = heldNew;
}

Referenced by pause_handle_input().

pause_handle_input()

void pause_handle_input	(	s32	pressed,
		s32	held )

Definition at line 714 of file pause_main.c.

                                               {
    s32 height;
    s32 width;
    s32 maxLineChars;
    s32 numLines;
    s32 i;
    MenuPanel** menuPanels;
    s32 currentDescMsg = gPauseCurrentDescMsg;
    MenuPanel* currentPanel = gPausePanels[gPauseMenuCurrentTab];
 
    if (evt_get_variable(nullptr, GF_Tutorial_Badges)) {
        for (i = 0; i < ARRAY_COUNT(gPauseTutorialSprites); i++) {
            spr_update_sprite(gPauseTutorialSprites[i], gPauseTutorialSpriteAnims[i][1], 1.0f);
        }
    }
 
    gPausePressedButtons = pressed;
    gPauseHeldButtons = held;
    if (evt_get_variable(nullptr, GF_Tutorial_Badges)) {
        pause_tutorial_input(&gPausePressedButtons, &gPauseHeldButtons);
    }
 
    if ((gPausePressedButtons & BUTTON_START) || ((gPauseMenuCurrentTab == 0) && (gPausePressedButtons & BUTTON_B))) {
        enforce_hpfp_limits();
        sfx_play_sound(SOUND_MENU_CLOSE);
        set_game_mode(GAME_MODE_UNPAUSE);
        return;
    }
 
    if (gPauseCurrentDescIconScript != gPauseShownDescIconScript) {
        gPauseShownDescIconScript = gPauseCurrentDescIconScript;
    }
 
    if (currentDescMsg != gPauseShownDescMsg) {
        gPauseShownDescMsg = currentDescMsg;
        gPauseDescTextPos = 0;
        gPauseDescTextOffset = 0;
        if (currentDescMsg != 0) {
            get_msg_properties(currentDescMsg, &height, &width, &maxLineChars, &numLines, nullptr, nullptr, 0);
            if (numLines % 2) {
                numLines++;
            }
            gPauseDescTextMaxPos = numLines - 2;
            if (gPauseDescTextMaxPos < 0) {
                gPauseDescTextMaxPos = 0;
            }
        } else {
            gPauseDescTextMaxPos = 0;
        }
    }
    if (gPauseHeldButtons & BUTTON_C_UP) {
        gPauseDescTextPos -= 2;
        if (gPauseDescTextPos < 0) {
            gPauseDescTextPos = 0;
        }
    }
    if (gPauseHeldButtons & BUTTON_C_DOWN) {
        gPauseDescTextPos += 2;
        if (gPauseDescTextPos > gPauseDescTextMaxPos) {
            gPauseDescTextPos = gPauseDescTextMaxPos;
        }
    }
    gPauseDescTextOffset += pause_interp_text_scroll(gPauseDescTextPos * 16 - gPauseDescTextOffset);
    if (currentPanel->initialized) {
        if (currentPanel->fpHandleInput) {
            currentPanel->fpHandleInput(currentPanel);
        }
    }
    menuPanels = gPausePanels;
    for (i = 0; i < ARRAY_COUNT(gPausePanels); menuPanels++, i++) {
        if ((*menuPanels)->initialized) {
            if ((*menuPanels)->fpUpdate) {
                (*menuPanels)->fpUpdate(*menuPanels);
            }
        }
    }
}

Referenced by state_step_pause().

pause_cleanup()

void pause_cleanup

(

void

)

Definition at line 792 of file pause_main.c.

                         {
    s32 i;
    MenuPanel** menuPanels;
 
    for (i = 0; i < ARRAY_COUNT(gPauseCommonHIDs); i++) {
        hud_element_free(gPauseCommonHIDs[i]);
    }
 
    if (evt_get_variable(nullptr, GF_Tutorial_Badges)) {
        for (i = 0; i < ARRAY_COUNT(gPauseTutorialSprites); i++) {
            spr_free_sprite(gPauseTutorialSprites[i]);
        }
    }
 
    menuPanels = gPausePanels;
    for (i = 0; i < ARRAY_COUNT(gPausePanels); menuPanels++, i++) {
        if ((*menuPanels)->initialized) {
            if ((*menuPanels)->fpCleanup) {
                (*menuPanels)->fpCleanup(*menuPanels);
            }
        }
    }
 
    for (i = WIN_PAUSE_MAIN; i < WIN_PAUSE_CURSOR; i++)
        set_window_update(i, WINDOW_UPDATE_HIDE);
 
    set_window_update(WIN_PAUSE_CURSOR, WINDOW_UPDATE_HIDE);
}

Referenced by state_step_unpause().

pause_get_total_equipped_bp_cost()

s32 pause_get_total_equipped_bp_cost

(

void

)

Definition at line 821 of file pause_main.c.

                                           {
    s32 totalCost = 0;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gPlayerData.equippedBadges); i++) {
        s16 itemID = gPlayerData.equippedBadges[i];
 
        if (itemID != ITEM_NONE) {
            s32 moveID = gItemTable[itemID].moveID;
 
            totalCost += gMoveTable[moveID].costBP;
        }
    }
    return totalCost;
}

Referenced by pause_badges_draw_contents(), pause_badges_try_equip(), and pause_badges_try_remove().

pause_draw_rect()

void pause_draw_rect	(	s32	ulx,
		s32	uly,
		s32	lrx,
		s32	lry,
		s32	tileIdx,
		s32	uls,
		s32	ult,
		s32	dsdx,
		s32	dtdy )

Definition at line 837 of file pause_main.c.

                                                                                                            {
    if (ulx <= -2688 || uly <= -2688 || lrx <= 0 || lry <= 0) {
        return;
    }
    if (ulx >= 1280 || uly >= 960 || lrx >= 2688 || lry >= 2688) {
        return;
    }
    gSPScisTextureRectangle(gMainGfxPos++, ulx, uly, lrx, lry, tileIdx, uls, ult, dsdx, dtdy);
}

Referenced by pause_badges_draw_bp_orbs(), pause_draw_menu_label(), pause_map_draw_border_arrows(), pause_map_draw_contents(), pause_partners_draw_contents(), pause_spirits_draw_contents(), and pause_tutorial_draw_contents().

pause_sort_item_list()

void pause_sort_item_list	(	s16 *	arr,
		s32	len,
		s32(*)(s16 *, s16 *)	compare )

Definition at line 847 of file pause_main.c.

                                                                          {
    if (len < 2) {
        // Trivially sorted
        return;
    } else if (len == 2) {
        // Trivial 2-element sort
        if (compare(&arr[0], &arr[1]) > 0) {
            s16 temp = arr[0];
            arr[0] = arr[1];
            arr[1] = temp;
        }
    } else {
        // Nontrivial sort required, use shell sort
        u32 gap = 1;
        s16* end;
 
        while (gap < len) {
            gap = gap * 2 + 1;
        }
 
        end = &arr[len];
        while ((gap /= 2) != 0) {
            s16* window_end;
 
            for (window_end = &arr[gap]; window_end < end; window_end++) {
                s16* cur_elem = window_end - gap;
 
                // This could be written simpler as a while loop, but the compiler figures out that it only needs to do
                // the "cur_elem < end" check on the first iteration in that case
                if (cur_elem >= arr && cur_elem < end) {
                    do {
                        s16* elem_a = cur_elem;
                        s16* elem_b = cur_elem + gap;
 
                        if (compare(elem_a, elem_b) > 0) {
                            s16 temp = *elem_a;
                            *elem_a = *elem_b;
                            *elem_b = temp;
                            cur_elem -= gap;
                        } else {
                            break;
                        }
                    } while (cur_elem >= arr && cur_elem < end);
                }
            }
        }
    }
}

Referenced by pause_badges_count_all(), pause_badges_count_equipped(), and pause_items_load_items().

Variable Documentation

gPausePanelTabs

MenuPanel gPausePanelTabs

extern

Definition at line 185 of file pause_tabs.c.

                            {
    .initialized = false,
    .col = 0,
    .row = 0,
    .selected = 0,
    .state = 0,
    .numCols = 6,
    .numRows = 1,
    .numPages = 0,
    .gridData = gPauseTabsGridData,
    .fpInit = pause_tabs_init,
    .fpHandleInput = pause_tabs_handle_input,
    .fpUpdate = pause_tabs_update,
    .fpCleanup = pause_tabs_cleanup
};

gPausePanelStats

MenuPanel gPausePanelStats

extern

Definition at line 149 of file pause_stats.c.

                             {
    .initialized = false,
    .col = 0,
    .row = 0,
    .selected = 0,
    .state = 0,
    .numCols = 2,
    .numRows = 7,
    .numPages = 0,
    .gridData = gPauseStatsGridData,
    .fpInit = &pause_stats_init,
    .fpHandleInput = &pause_stats_handle_input,
    .fpUpdate = nullptr,
    .fpCleanup = &pause_stats_cleanup
};

gPausePanelBadges

MenuPanel gPausePanelBadges

extern

Definition at line 111 of file pause_badges.c.

                              {
    .initialized = false,
    .col = 0,
    .row = 0,
    .selected = 0,
    .state = 0,
    .numCols = 0,
    .numRows = 0,
    .numPages = 0,
    .gridData = nullptr,
    .fpInit = &pause_badges_init,
    .fpHandleInput = &pause_badges_handle_input,
    .fpUpdate = &pause_badges_update,
    .fpCleanup = &pause_badges_cleanup
};

gPausePanelItems

MenuPanel gPausePanelItems

extern

Definition at line 51 of file pause_items.c.

                             {
    .initialized = false,
    .col = 0,
    .row = 0,
    .selected = 0,
    .state = 0,
    .numCols = 0,
    .numRows = 0,
    .numPages = 0,
    .gridData = nullptr,
    .fpInit = &pause_items_init,
    .fpHandleInput = &pause_items_handle_input,
    .fpUpdate = &pause_items_update,
    .fpCleanup = &pause_items_cleanup
};

gPausePanelPartners

MenuPanel gPausePanelPartners

extern

Definition at line 271 of file pause_partners.c.

                                {
    .initialized = false,
    .col = 0,
    .row = 1,
    .selected = 0,
    .state = 0,
    .numCols = 4,
    .numRows = 2,
    .numPages = 0,
    .gridData = gPausePartnersGridData,
    .fpInit = &pause_partners_init,
    .fpHandleInput = &pause_partners_handle_input,
    .fpUpdate = &pause_partners_update,
    .fpCleanup = &pause_partners_cleanup
};

gPausePanelSpirits

MenuPanel gPausePanelSpirits

extern

Definition at line 129 of file pause_spirits.c.

                               {
    .initialized = false,
    .col = 2,
    .row = 0,
    .selected = 0,
    .state = 0,
    .numCols = 5,
    .numRows = 2,
    .numPages = 0,
    .gridData = gPauseSpiritsGridData,
    .fpInit = &pause_spirits_init,
    .fpHandleInput = &pause_spirits_handle_input,
    .fpUpdate = &pause_spirits_update,
    .fpCleanup = &pause_spirits_cleanup
};

gPausePanelMap

MenuPanel gPausePanelMap

extern

Definition at line 76 of file pause_map.c.

                           {
    .initialized = false,
    .col = 0,
    .row = 0,
    .selected = 0,
    .state = 0,
    .numCols = 0,
    .numRows = 0,
    .numPages = 0,
    .gridData = nullptr,
    .fpInit = &pause_map_init,
    .fpHandleInput = &pause_map_handle_input,
    .fpUpdate = &pause_map_update,
    .fpCleanup = &pause_map_cleanup
};

gPauseHeldButtons

BSS s32 gPauseHeldButtons

Definition at line 23 of file pause_main.c.

Referenced by pause_badges_handle_input(), pause_handle_input(), pause_items_handle_input(), pause_partners_handle_input(), pause_spirits_handle_input(), pause_stats_handle_input(), and pause_tabs_handle_input().

gPausePressedButtons

BSS s32 gPausePressedButtons

Definition at line 24 of file pause_main.c.

Referenced by pause_badges_handle_input(), pause_handle_input(), pause_items_handle_input(), pause_map_handle_input(), pause_partners_handle_input(), pause_spirits_handle_input(), pause_stats_handle_input(), and pause_tabs_handle_input().

gPauseCurrentDescMsg

BSS s32 gPauseCurrentDescMsg

Definition at line 25 of file pause_main.c.

Referenced by pause_badges_handle_input(), pause_handle_input(), pause_init(), pause_items_handle_input(), pause_map_handle_input(), pause_partners_handle_input(), pause_spirits_handle_input(), pause_stats_handle_input(), and pause_tabs_handle_input().

gPauseCurrentDescIconScript

BSS HudScript* gPauseCurrentDescIconScript

Definition at line 26 of file pause_main.c.

Referenced by pause_badges_draw_contents(), pause_badges_handle_input(), pause_handle_input(), pause_init(), pause_items_draw_contents(), pause_items_handle_input(), pause_map_handle_input(), pause_partners_handle_input(), pause_spirits_handle_input(), pause_stats_handle_input(), and pause_tabs_handle_input().

gPauseCursorHID

BSS HudElemID gPauseCursorHID

Definition at line 27 of file pause_main.c.

Referenced by pause_init().

gPauseMenuCurrentTab

BSS s8 gPauseMenuCurrentTab

Definition at line 28 of file pause_main.c.

Referenced by pause_badges_draw_contents(), pause_badges_handle_input(), pause_handle_input(), pause_init(), pause_items_draw_contents(), pause_items_handle_input(), pause_map_draw_contents(), pause_map_draw_title(), pause_map_handle_input(), pause_partners_draw_contents(), pause_partners_draw_movelist(), pause_partners_handle_input(), pause_spirits_draw_contents(), pause_spirits_draw_title(), pause_spirits_handle_input(), pause_stats_draw_contents(), pause_stats_handle_input(), pause_tabs_draw_badges(), pause_tabs_draw_items(), pause_tabs_draw_map(), pause_tabs_draw_party(), pause_tabs_draw_spirits(), pause_tabs_draw_stats(), and pause_tabs_handle_input().

D_802700D

BSS s8 D_802700D[7]

Definition at line 29 of file pause_main.c.

gPausePanels

MenuPanel* gPausePanels[]

Initial value:

= {
    &gPausePanelTabs, &gPausePanelStats, &gPausePanelBadges, &gPausePanelItems, &gPausePanelPartners,
    &gPausePanelSpirits, &gPausePanelMap
}

Definition at line 44 of file pause_main.c.

                            {
    &gPausePanelTabs, &gPausePanelStats, &gPausePanelBadges, &gPausePanelItems, &gPausePanelPartners,
    &gPausePanelSpirits, &gPausePanelMap
};

Referenced by pause_cleanup(), pause_handle_input(), pause_init(), pause_tabs_handle_input(), and pause_tabs_update().

gPauseCursorPosX

s32 gPauseCursorPosX = 160

Definition at line 48 of file pause_main.c.

Referenced by pause_draw_cursor(), pause_interp_cursor(), pause_set_cursor_pos(), and pause_set_cursor_pos_immediate().

gPauseCursorPosY

s32 gPauseCursorPosY = -120

Definition at line 49 of file pause_main.c.

Referenced by pause_draw_cursor(), pause_interp_cursor(), pause_set_cursor_pos(), and pause_set_cursor_pos_immediate().

gPauseCursorOpacity

s32 gPauseCursorOpacity = 0

Definition at line 50 of file pause_main.c.

Referenced by pause_draw_cursor(), and pause_interp_cursor().

gPauseCursorTargetPosX

s32 gPauseCursorTargetPosX = 160

Definition at line 51 of file pause_main.c.

Referenced by pause_interp_cursor(), pause_set_cursor_pos(), and pause_set_cursor_pos_immediate().

gPauseCursorTargetPosY

s32 gPauseCursorTargetPosY = -120

Definition at line 52 of file pause_main.c.

Referenced by pause_interp_cursor(), pause_set_cursor_pos(), and pause_set_cursor_pos_immediate().

gPauseCursorTargetOpacity

s32 gPauseCursorTargetOpacity = 0

Definition at line 53 of file pause_main.c.

Referenced by pause_interp_cursor(), and pause_set_cursor_opacity().

D_8024EFB4

u32 D_8024EFB4 = 1

Definition at line 54 of file pause_main.c.

Referenced by pause_set_cursor_pos(), and pause_set_cursor_pos_immediate().

D_8024EFB8

s16 D_8024EFB8[] = { -10, -25, -42, -60, -80 }

Definition at line 55 of file pause_main.c.

{ -10, -25, -42, -60, -80 }; //unused

gPauseWindowFlipUpFlags

u8 gPauseWindowFlipUpFlags[] = { DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, 0, 0}

Definition at line 56 of file pause_main.c.

{ DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, 0, 0};

Referenced by pause_update_page_active_1(), and pause_update_page_active_2().

gPauseWindowFlipUpAngles

s16 gPauseWindowFlipUpAngles[] = { -80, -65, -38, -30, -10, 0 }

Definition at line 57 of file pause_main.c.

{ -80, -65, -38, -30, -10, 0 };

Referenced by pause_update_page_active_2().

gPauseWindowFlipUpAngles_2

s16 gPauseWindowFlipUpAngles_2[] = { 80, 65, 38, 30, 10, 0 }

Definition at line 58 of file pause_main.c.

{  80,  65,  38,  30,  10, 0 };

Referenced by pause_update_page_active_1().

gPauseWindowFlipDownFlags

u8 gPauseWindowFlipDownFlags[] = { DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, 0, 0 }

Definition at line 59 of file pause_main.c.

{ DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, DRAW_FLAG_ROTSCALE, 0, 0 };

Referenced by pause_update_page_inactive_1(), and pause_update_page_inactive_2().

D_8024EFEC

u8 D_8024EFEC[]

Initial value:

= { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x11, 0x00, 0x25, 0x00, 0x3C,
                    0x00, 0x55, 0x00, 0x6E }

Definition at line 60 of file pause_main.c.

                  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x11, 0x00, 0x25, 0x00, 0x3C,
                    0x00, 0x55, 0x00, 0x6E }; //unused

gPauseWindowFlipDownAngles

s16 gPauseWindowFlipDownAngles[] = { -10, -25, -42, -60, -80}

Definition at line 62 of file pause_main.c.

{ -10, -25, -42, -60, -80};

Referenced by pause_update_page_inactive_1().

gPauseWindowFlipDownAngles_2

s16 gPauseWindowFlipDownAngles_2[] = { 10, 25, 42, 60, 80 }

Definition at line 63 of file pause_main.c.

{  10,  25,  42,  60,  80 };

Referenced by pause_update_page_inactive_2().

gPauseTutorialState

s32 gPauseTutorialState = -1

Definition at line 64 of file pause_main.c.

Referenced by pause_tutorial_draw_contents(), and pause_tutorial_input().

gPauseTutorialInputState

s32 gPauseTutorialInputState = 3

Definition at line 65 of file pause_main.c.

Referenced by pause_tutorial_input().

gPauseTutorialButtons

s32 gPauseTutorialButtons[] = { BUTTON_A, BUTTON_STICK_RIGHT, BUTTON_A, BUTTON_A, BUTTON_A, BUTTON_A, BUTTON_START }

Definition at line 66 of file pause_main.c.

{ BUTTON_A, BUTTON_STICK_RIGHT, BUTTON_A, BUTTON_A, BUTTON_A, BUTTON_A, BUTTON_START };

Referenced by pause_tutorial_input().

gPauseTutorialDescMessages

s32 gPauseTutorialDescMessages[]

Initial value:

= {
    PAUSE_MSG_TUT_DESC_1,
    PAUSE_MSG_TUT_DESC_2,
    PAUSE_MSG_TUT_DESC_3,
    PAUSE_MSG_TUT_DESC_4,
    PAUSE_MSG_TUT_DESC_5,
    PAUSE_MSG_TUT_DESC_6,
    PAUSE_MSG_TUT_DESC_7,
}

Definition at line 68 of file pause_main.c.

                                   {
    PAUSE_MSG_TUT_DESC_1,
    PAUSE_MSG_TUT_DESC_2,
    PAUSE_MSG_TUT_DESC_3,
    PAUSE_MSG_TUT_DESC_4,
    PAUSE_MSG_TUT_DESC_5,
    PAUSE_MSG_TUT_DESC_6,
    PAUSE_MSG_TUT_DESC_7,
};

Referenced by pause_tutorial_draw_contents().

gPauseTutorialCmdMessages

s32 gPauseTutorialCmdMessages[]

Initial value:

= {
    PAUSE_MSG_TUT_CMD_1,
    PAUSE_MSG_TUT_CMD_2,
    PAUSE_MSG_TUT_CMD_3,
    PAUSE_MSG_TUT_CMD_4,
    PAUSE_MSG_TUT_CMD_5,
    PAUSE_MSG_TUT_CMD_6,
    PAUSE_MSG_TUT_CMD_7,
}

Definition at line 78 of file pause_main.c.

                                  {
    PAUSE_MSG_TUT_CMD_1,
    PAUSE_MSG_TUT_CMD_2,
    PAUSE_MSG_TUT_CMD_3,
    PAUSE_MSG_TUT_CMD_4,
    PAUSE_MSG_TUT_CMD_5,
    PAUSE_MSG_TUT_CMD_6,
    PAUSE_MSG_TUT_CMD_7,
};

Referenced by pause_tutorial_draw_contents().

D_8024F074

s32 D_8024F074[]

Initial value:

= {
    PAUSE_MSG_TUT_UNUSED_1,
    PAUSE_MSG_TUT_UNUSED_2,
    PAUSE_MSG_TUT_UNUSED_3,
    PAUSE_MSG_TUT_UNUSED_4,
    PAUSE_MSG_TUT_UNUSED_5,
    PAUSE_MSG_TUT_UNUSED_6,
    PAUSE_MSG_TUT_UNUSED_7,
}

Definition at line 89 of file pause_main.c.

                   {
    PAUSE_MSG_TUT_UNUSED_1,
    PAUSE_MSG_TUT_UNUSED_2,
    PAUSE_MSG_TUT_UNUSED_3,
    PAUSE_MSG_TUT_UNUSED_4,
    PAUSE_MSG_TUT_UNUSED_5,
    PAUSE_MSG_TUT_UNUSED_6,
    PAUSE_MSG_TUT_UNUSED_7,
};

gPauseTutorialIconIDs

s32 gPauseTutorialIconIDs[] = { 5, 4, 5, 5, 5, 5, 6 }

Definition at line 99 of file pause_main.c.

{ 5, 4, 5, 5, 5, 5, 6 };

Referenced by pause_tutorial_draw_contents().

gPauseMenuTextScrollInterpEasingLUT

u8 gPauseMenuTextScrollInterpEasingLUT[] = { 0, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8}

Definition at line 100 of file pause_main.c.

{ 0, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8};

Referenced by pause_interp_text_scroll().

gPauseMenuPageScrollInterpEasingLUT

u8 gPauseMenuPageScrollInterpEasingLUT[] = { 0, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8}

Definition at line 101 of file pause_main.c.

{ 0, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8};

Referenced by pause_interp_vertical_scroll().

gPauseTutorialSpriteAnims

s32 gPauseTutorialSpriteAnims[][4]

Initial value:

= {
    {
        ANIM_Goombaria_Still,
        ANIM_Goombaria_Idle,
        ANIM_Goombaria_Talk,
        ANIM_LIST_END
    },
    {
        ANIM_WorldGoombario_Still,
        ANIM_WorldGoombario_Idle,
        ANIM_WorldGoombario_Talk,
        ANIM_LIST_END
    },
    {
        ANIM_Goompa_Still,
        ANIM_Goompa_Idle,
        ANIM_Goompa_Talk,
        ANIM_LIST_END
    }
}

Definition at line 103 of file pause_main.c.

                                     {
    {
        ANIM_Goombaria_Still,
        ANIM_Goombaria_Idle,
        ANIM_Goombaria_Talk,
        ANIM_LIST_END
    },
    {
        ANIM_WorldGoombario_Still,
        ANIM_WorldGoombario_Idle,
        ANIM_WorldGoombario_Talk,
        ANIM_LIST_END
    },
    {
        ANIM_Goompa_Still,
        ANIM_Goompa_Idle,
        ANIM_Goompa_Talk,
        ANIM_LIST_END
    }
};

Referenced by pause_handle_input(), and pause_init().

gPauseTutorialViewport

Vp gPauseTutorialViewport

Initial value:

= {
    .vp = {
        .vscale = { 640, 480, 511, 0 },
        .vtrans = { 640, 480, 511, 0 },
    }
}

Definition at line 123 of file pause_main.c.

                            {
    .vp = {
        .vscale = { 640, 480, 511, 0 },
        .vtrans = { 640, 480, 511, 0 },
    }
};

Referenced by pause_tutorial_draw_contents().

gPauseTutorialScrollPos

s32 gPauseTutorialScrollPos = 0

Definition at line 129 of file pause_main.c.

Referenced by pause_tutorial_draw_contents().

gPauseCommonWindowsBPs

MenuWindowBP gPauseCommonWindowsBPs[]

Definition at line 130 of file pause_main.c.

                                        {
    {
        .windowID = WIN_PAUSE_MAIN,
        .unk_01 = 0,
        .pos = { .x = 12, .y = 20 },
        .width = 296,
        .height = 200,
        .priority = 0,
        .fpDrawContents = &pause_main_draw_contents,
        .tab = nullptr,
        .parentID = WIN_NONE,
        .fpUpdate = { WINDOW_UPDATE_SHOW },
        .extraFlags = WINDOW_FLAG_40,
        .style = { .customStyle = &gPauseWS_0 }
    },
    {
        .windowID = WIN_PAUSE_TUTORIAL,
        .unk_01 = 0,
        .pos = { .x = 0, .y = 138 },
        .width = 296,
        .height = 63,
        .priority = 0,
        .fpDrawContents = &pause_tutorial_draw_contents,
        .tab = nullptr,
        .parentID = WIN_PAUSE_MAIN,
        .fpUpdate = { WINDOW_UPDATE_HIDE },
        .extraFlags = 0,
        .style = { .customStyle = &gPauseWS_2 }
    },
    {
        .windowID = WIN_PAUSE_DECRIPTION,
        .unk_01 = 0,
        .pos = { .x = 20, .y = 164 },
        .width = 256,
        .height = 32,
        .priority = 0,
        .fpDrawContents = &pause_textbox_draw_contents,
        .tab = nullptr,
        .parentID = WIN_PAUSE_MAIN,
        .fpUpdate = { .func = &basic_window_update },
        .extraFlags = 0,
        .style = { .customStyle = &gPauseWS_1 }
    },
    {
        .windowID = WIN_PAUSE_CURSOR,
        .unk_01 = 0,
        .pos = { .x = 0, .y = 0 },
        .width = SCREEN_WIDTH,
        .height = SCREEN_HEIGHT,
        .priority = 0,
        .fpDrawContents = &pause_draw_cursor,
        .tab = nullptr,
        .parentID = WIN_NONE,
        .fpUpdate = { WINDOW_UPDATE_SHOW },
        .extraFlags = 0,
        .style = { .customStyle = &gPauseWS_0 }
    }
};

Referenced by pause_init().