Enumerations
enum	BattleSubStates { BTL_SUBSTATE_INIT = 0 , BTL_SUBSTATE_END_BATTLE_EXEC_STAGE_SCRIPT = 2 , BTL_SUBSTATE_PLAYER_CONTINUE_DIP = 70 }

Functions
void	btl_state_update_normal_start (void)

void	btl_state_draw_normal_start (void)

void	btl_state_update_begin_turn (void)

void	btl_state_draw_begin_turn (void)

void	btl_state_update_begin_player_turn (void)

void	btl_state_draw_begin_player_turn (void)

void	btl_state_update_switch_to_player (void)

void	btl_state_draw_switch_to_player (void)

void	btl_state_update_begin_partner_turn (void)

void	btl_state_draw_begin_partner_turn (void)

void	btl_state_update_switch_to_partner (void)

void	btl_state_draw_switch_to_partner (void)

void	btl_state_update_transfer_turn (void)

void	btl_state_draw_transfer_turn (void)

void	btl_state_update_prepare_menu (void)

void	btl_state_draw_prepare_menu (void)

void	btl_state_update_end_turn (void)

void	btl_state_draw_end_turn (void)

void	btl_state_update_victory (void)

void	btl_state_draw_victory (void)

void	btl_state_update_end_training_battle (void)

void	btl_state_draw_end_training_battle (void)

void	btl_state_update_end_battle (void)

void	btl_state_draw_end_battle (void)

void	btl_state_update_defend (void)

void	btl_state_draw_defend (void)

void	btl_state_update_run_away (void)

void	btl_state_draw_run_away (void)

void	btl_state_update_defeat (void)

void	btl_state_draw_defeat (void)

void	btl_state_update_change_partner (void)

void	btl_state_draw_change_partner (void)

void	btl_state_update_player_move (void)

void	btl_state_draw_player_move (void)

void	btl_state_update_end_player_turn (void)

void	btl_state_update_partner_move (void)

void	btl_state_draw_end_player_turn (void)

void	btl_state_draw_partner_move (void)

void	btl_state_update_end_partner_turn (void)

void	btl_state_draw_end_partner_turn (void)

void	btl_state_update_next_enemy (void)

void	btl_state_draw_next_enemy (void)

void	btl_state_update_enemy_move (void)

void	btl_state_draw_enemy_move (void)

void	btl_state_update_first_strike (void)

void	btl_state_draw_first_stike (void)

void	btl_state_update_partner_striking_first (void)

void	btl_state_draw_partner_striking_first (void)

void	btl_state_update_enemy_striking_first (void)

void	btl_state_draw_enemy_striking_first (void)

void	btl_state_update_end_demo_battle (void)

void	btl_state_draw_end_demo_battle (void)

void	btl_state_update_player_menu (void)

void	btl_state_draw_player_menu (void)

void	btl_state_update_partner_menu (void)

void	btl_state_draw_partner_menu (void)

void	btl_state_update_peach_menu (void)

void	btl_state_draw_peach_menu (void)

void	btl_state_update_twink_menu (void)

void	btl_state_draw_twink_menu (void)

void	btl_state_update_select_target (void)

void	btl_state_draw_select_target (void)

void	btl_state_update_celebration (void)

void	btl_state_draw_celebration (void)

Variables
s16	EndDemoWhiteOut

b32	BattleSkipActorTurn

b32	BattleCanShowFirstStrike

s32	BattleStatusUpdateDelay

s32	BattleSubstateDelay

s32	BattleScreenFadeAmt

Enumeration Type Documentation

◆ BattleSubStates

enum BattleSubStates

Enumerator
BTL_SUBSTATE_INIT
BTL_SUBSTATE_END_BATTLE_EXEC_STAGE_SCRIPT
BTL_SUBSTATE_PLAYER_CONTINUE_DIP

Definition at line 6 of file states.h.

                     {
    // shared
    BTL_SUBSTATE_INIT                                       = 0,
 
    // accessed across states
    BTL_SUBSTATE_END_BATTLE_EXEC_STAGE_SCRIPT               = 2,
    BTL_SUBSTATE_PLAYER_CONTINUE_DIP                        = 70,
};

Function Documentation

◆ btl_state_update_normal_start()

void btl_state_update_normal_start ( void )

Definition at line 50 of file start_battle.c.

                                         {
    BattleStatus* battleStatus = &gBattleStatus;
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    Battle* battle;
    Stage* stage;
    Actor* actor;
    Evt* script;
    s32 enemyNotDone;
    s32 type;
    s32 i;
    s32 j;
 
    s32* types;
 
    battle = gCurrentBattlePtr;
    if (gOverrideBattlePtr != NULL) {
        battle = gOverrideBattlePtr;
    }
 
    if (gCurrentStagePtr == NULL) {
        stage = battle->stage;
    } else {
        stage = gCurrentStagePtr->stage;
    }
 
    battleStatus->curStage = stage;
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            #if DX_DEBUG_MENU
            dx_debug_set_battle_info(gCurrentBattleID << 16 | (gCurrentStageID & 0xFFFF), stage->shape);
            #endif
 
            BattleEnemiesCreated = battle->formationSize;
            set_screen_overlay_params_back(OVERLAY_NONE, -1.0f);
 
            load_stage_assets(stage);
 
            if (gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED) {
                set_curtain_scale_goal(1.0f);
            }
 
            battleStatus->controlScript = NULL;
            battleStatus->camMovementScript = NULL;
            battleStatus->unk_90 = 0;
            battleStatus->preUpdateCallback = NULL;
            battleStatus->initBattleCallback = NULL;
            battleStatus->curSubmenu = 0;
            battleStatus->lastSelectedAbility = 0;
            battleStatus->curPartnerSubmenu = 0;
            battleStatus->lastPartnerPowerSelection = 0;
            battleStatus->totalStarPoints = 0;
            battleStatus->pendingStarPoints = 0;
            battleStatus->incrementStarPointDelay = 0;
            battleStatus->damageTaken = 0;
            battleStatus->nextMerleeSpellType = MERLEE_SPELL_NONE;
            battleStatus->actionCommandMode = AC_MODE_NOT_LEARNED;
            gCameras[CAM_DEFAULT].flags |= CAMERA_FLAG_DISABLED;
            gCameras[CAM_BATTLE].flags |= CAMERA_FLAG_DISABLED;
            gCameras[CAM_TATTLE].flags |= CAMERA_FLAG_DISABLED;
            if (gPlayerData.hasActionCommands) {
                battleStatus->actionCommandMode = AC_MODE_LEARNED;
            }
            battleStatus->actionQuality = 0;
            battleStatus->maxActionQuality = 0;
            battleStatus->enabledMenusFlags = -1;
            battleStatus->enabledStarPowersFlags = -1;
            battleStatus->itemUsesLeft = 0;
            battleStatus->hammerCharge = 0;
            battleStatus->jumpCharge = 0;
            battleStatus->unk_98 = 0;
            battleStatus->hpDrainCount = 0;
            gBattleStatus.flags2 |= BS_FLAGS2_CAN_FLEE;
            if (currentEncounter->forbidFleeing) {
                gBattleStatus.flags2 &= ~BS_FLAGS2_CAN_FLEE;
            }
            battleStatus->endBattleFadeOutRate = 10;
            battleStatus->waitForState = BATTLE_STATE_NONE;
            battleStatus->hammerLossTurns = -1;
            battleStatus->jumpLossTurns = -1;
            battleStatus->itemLossTurns = -1;
            battleStatus->outtaSightActive = 0;
            battleStatus->waterBlockTurnsLeft = 0;
            battleStatus->waterBlockAmount = 0;
            battleStatus->waterBlockEffect = NULL;
            battleStatus->cloudNineTurnsLeft = 0;
            battleStatus->cloudNineDodgeChance = 0;
            battleStatus->cloudNineEffect = NULL;
            battleStatus->reflectFlags = 0;
            battleStatus->turboChargeTurnsLeft = 0;
            battleStatus->turboChargeAmount = 0;
            battleStatus->stateFreezeCount = 0;
            battleStatus->merleeAttackBoost = 0;
            battleStatus->merleeDefenseBoost = 0;
            battleStatus->darknessMode = BTL_DARKNESS_STATE_NONE;
            battleStatus->unk_433 = -1;
            battleStatus->hustleTurns = 0;
            battleStatus->nextActorOrdinal = 0;
            battleStatus->cancelTurnMode = 0;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_STORED_TURBO_CHARGE_TURN;
            gBattleStatus.flags2 &= ~BS_FLAGS2_DOING_JUMP_TUTORIAL;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->varTable); i++) {
                battleStatus->varTable[i] = 0;
            }
 
            BattleScreenFadeAmt = 255;
            battleStatus->inputBitmask = 0xFFFFF & ~(BUTTON_START | 0xC0);
            battleStatus->buffEffect = fx_partner_buff(0, 0.0f, 0.0f, 0.0f, 0.0f, 0);
            setup_status_bar_for_battle();
            gCurrentCameraID = CAM_BATTLE;
            script = start_script(&EVS_OnBattleInit, EVT_PRIORITY_A, 0);
            battleStatus->camMovementScript = script;
            battleStatus->camMovementScriptID = script->id;
            gBattleSubState = BTL_SUBSTATE_CREATE_ENEMIES;
            break;
        case BTL_SUBSTATE_CREATE_ENEMIES:
            // wait for camera initialization to finish
            if (does_script_exist(battleStatus->camMovementScriptID)) {
                break;
            }
 
            if (stage->preBattle != NULL) {
                script = start_script(stage->preBattle, EVT_PRIORITY_A, 0);
                battleStatus->controlScript = script;
                battleStatus->controlScriptID = script->id;
            }
 
            gStatusBar.hidden = FALSE;
            gBattleStatus.flags1 |= BS_FLAGS1_ACTORS_VISIBLE;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                battleStatus->enemyActors[i] = NULL;
            }
            battleStatus->initialEnemyCount = 0;
 
            for (i = 0; i < BattleEnemiesCreated; i++) {
                create_actor(&(*battle->formation)[i]);
                types = bActorsIgnoreDuringCount;
                actor = battleStatus->enemyActors[i];
 
                while (TRUE) {
                    type = *types;
                    if (type == -1) {
                        battleStatus->initialEnemyCount++;
                        break;
                    } else if (actor->actorType == type) {
                        break;
                    }
                    types++;
                }
 
                actor->instigatorValue = 0;
                if (i == 0) {
                    actor->instigatorValue = currentEncounter->instigatorValue;
                    if (currentEncounter->dizzyAttack.status == STATUS_KEY_DIZZY) {
                        inflict_status_set_duration(actor, STATUS_KEY_DIZZY, STATUS_TURN_MOD_DIZZY, currentEncounter->dizzyAttack.duration);
                    }
                }
            }
 
            if (stage->stageEnemyCount != 0) {
                if (stage->stageEnemyChance == 0 || (stage->stageEnemyChance > 0 && (rand_int(stage->stageEnemyChance) == 0))) {
                    BattleEnemiesCreated += stage->stageEnemyCount;
                    for (j = 0; i < BattleEnemiesCreated; i++, j++) {
                        create_actor(&(*stage->stageFormation)[j]);
                        actor = battleStatus->enemyActors[i];
                        actor->instigatorValue = 0;
                        if (i == 0) {
                            actor->instigatorValue = 0;
                            if (currentEncounter->dizzyAttack.status == STATUS_KEY_DIZZY) {
                                inflict_status_set_duration(actor, STATUS_KEY_DIZZY, STATUS_TURN_MOD_DIZZY, currentEncounter->dizzyAttack.duration);
                            }
                        }
 
                    }
                }
            }
 
            load_player_actor();
            actor = battleStatus->playerActor;
            if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                script = start_script(&EVS_Peach_OnActorCreate, EVT_PRIORITY_A, 0);
            } else {
                script = start_script(&EVS_Mario_OnActorCreate, EVT_PRIORITY_A, 0);
            }
            actor->takeTurnScript = script;
            actor->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
            load_partner_actor();
            gBattleSubState = BTL_SUBSTATE_CHECK_FIRST_STRIKE;
            break;
        case BTL_SUBSTATE_CHECK_FIRST_STRIKE:
            enemyNotDone = FALSE;
            for (i = 0; i < BattleEnemiesCreated; i++) {
                actor = battleStatus->enemyActors[i];
                if (does_script_exist(actor->takeTurnScriptID)) {
                    enemyNotDone = TRUE;
                    break;
                } else {
                    actor->takeTurnScript = NULL;
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            actor = battleStatus->playerActor;
            if (does_script_exist(actor->takeTurnScriptID)) {
                break;
            }
            actor->takeTurnScript = NULL;
 
            actor = battleStatus->partnerActor;
            if (actor != NULL) {
                if (does_script_exist(actor->takeTurnScriptID)) {
                    break;
                }
                actor->takeTurnScript = NULL;
            }
 
            if (battle->onBattleStart != NULL) {
                script = start_script(battle->onBattleStart, EVT_PRIORITY_A, 0);
                battleStatus->controlScript = script;
                battleStatus->controlScriptID = script->id;
            }
            if (battleStatus->darknessMode > BTL_DARKNESS_STATE_NONE) {
                set_screen_overlay_color(SCREEN_LAYER_BACK, 0, 0, 0);
                set_screen_overlay_params_back(OVERLAY_SCREEN_COLOR, 215.0f);
            }
            if (is_ability_active(ABILITY_CHILL_OUT) && currentEncounter->firstStrikeType == FIRST_STRIKE_ENEMY) {
                currentEncounter->firstStrikeType = FIRST_STRIKE_NONE;
            }
 
            switch (currentEncounter->firstStrikeType) {
                case FIRST_STRIKE_PLAYER:
                    btl_set_state(BATTLE_STATE_FIRST_STRIKE);
                    break;
                case FIRST_STRIKE_ENEMY:
                    btl_set_state(BATTLE_STATE_ENEMY_FIRST_STRIKE);
                    break;
                default:
                    if (!(gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED)) {
                        actor = battleStatus->playerActor;
                        if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                            script = start_script(&EVS_PeachEnterStage, EVT_PRIORITY_A, 0);
                        } else {
                            script = start_script(&EVS_MarioEnterStage, EVT_PRIORITY_A, 0);
                        }
                        actor->takeTurnScript = script;
                        actor->takeTurnScriptID = script->id;
                        script->owner1.actorID = ACTOR_PLAYER;
                    }
 
                    if (currentEncounter->curEnemy != NULL
                        && currentEncounter->curEnemy->encountered == ENCOUNTER_TRIGGER_SPIN
                        && is_ability_active(ABILITY_DIZZY_ATTACK)
                    ) {
                        actor = battleStatus->enemyActors[0];
                        script = start_script(&EVS_ApplyDizzyAttack, EVT_PRIORITY_A, 0);
                        actor->takeTurnScript = script;
                        actor->takeTurnScriptID = script->id;
                        script->owner1.enemyID = ACTOR_ENEMY0;
                    }
 
                    BattleScreenFadeAmt = 305;
                    BattleSubstateDelay = 0;
                    gBattleSubState = BTL_SUBSTATE_FADE_IN;
                    break;
            }
            break;
        case BTL_SUBSTATE_FADE_IN:
            if (BattleScreenFadeAmt == 0) {
                gBattleSubState = BTL_SUBSTATE_DONE;
                break;
            }
 
            BattleSubstateDelay++;
            if (BattleSubstateDelay == 15) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
            }
 
            if (!(gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED)) {
                BattleScreenFadeAmt -= 10;
            } else {
                BattleScreenFadeAmt -= 50;
            }
 
            if (BattleScreenFadeAmt < 0) {
                BattleScreenFadeAmt = 0;
            }
            break;
        case BTL_SUBSTATE_DONE:
            if (battleStatus->stateFreezeCount == 0) {
                set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
                btl_set_state(BATTLE_STATE_BEGIN_TURN);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_normal_start()

void btl_state_draw_normal_start ( void )

Definition at line 354 of file start_battle.c.

                                       {
    set_screen_overlay_color(SCREEN_LAYER_FRONT, 0, 0, 0);
 
    if (BattleScreenFadeAmt > 255) {
        set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, 255.0f);
    } else {
        set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, BattleScreenFadeAmt);
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_begin_turn()

void btl_state_update_begin_turn ( void )

Definition at line 12 of file turn_begin.c.

                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* partner = battleStatus->partnerActor;
    Actor* player = battleStatus->playerActor;
    Actor* enemy;
    Actor* enemy1;
    Actor* enemy2;
    Evt* script;
    b32 awaiting;
    u16 id1;
    u16 id2;
    s32 numEnemyActors;
    s32 i;
    s32 j;
    s16* enemyIDs;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        battleStatus->flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
        battleStatus->flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
        battleStatus->flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
        battleStatus->flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
        battleStatus->merleeAttackBoost = 0;
        battleStatus->merleeDefenseBoost = 0;
        battleStatus->flags2 &= ~BS_FLAGS2_IS_FIRST_STRIKE;
 
        player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
        player->disableDismissTimer = 0;
        if (partner != NULL) {
            player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
            partner->disableDismissTimer = 0;
        }
 
        if (battleStatus->hustleTurns != 0) {
            gBattleStatus.flags1 |= BS_FLAGS1_HUSTLED;
        }
 
        numEnemyActors = 0;
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            enemy = battleStatus->enemyActors[i];
            if (enemy != NULL) {
                battleStatus->enemyIDs[numEnemyActors] = i | ACTOR_ENEMY0;
                numEnemyActors++;
            }
        }
        battleStatus->numEnemyActors = numEnemyActors;
 
        // sort enemies by x-position or turn priority
        enemyIDs = battleStatus->enemyIDs;
        for (i = 0; i < numEnemyActors - 1; i++) {
            for (j = i + 1; j < numEnemyActors; j++) {
                id1 = enemyIDs[i];
                id2 = enemyIDs[j];
                enemy1 = battleStatus->enemyActors[id1 & 0xFF];
                enemy2 = battleStatus->enemyActors[id2 & 0xFF];
                if (gBattleStatus.flags1 & BS_FLAGS1_SORT_ENEMIES_BY_POSX) {
                    if (enemy1->homePos.x > enemy2->homePos.x) {
                        enemyIDs[i] = id2;
                        enemyIDs[j] = id1;
                    }
                } else if (enemy1->turnPriority < enemy2->turnPriority) {
                    enemyIDs[i] = id2;
                    enemyIDs[j] = id1;
                }
            }
        }
        battleStatus->nextEnemyIndex = 0;
 
        btl_merlee_on_start_turn();
 
        // clear rush flags to initialize
        battleStatus->rushFlags = RUSH_FLAG_NONE;
        gBattleStatus.flags2 &= ~BS_FLAGS2_HAS_RUSH;
 
        // set rush flags based on danger/peril status
        if (!(gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE)) {
            if (gPlayerData.curHP <= PERIL_THRESHOLD && is_ability_active(ABILITY_MEGA_RUSH)) {
                gBattleStatus.flags2 |= BS_FLAGS2_HAS_RUSH;
                battleStatus->rushFlags |= RUSH_FLAG_MEGA;
            }
            if (gPlayerData.curHP <= DANGER_THRESHOLD && is_ability_active(ABILITY_POWER_RUSH)) {
                if (!(battleStatus->rushFlags & RUSH_FLAG_MEGA)) {
                    gBattleStatus.flags2 |= BS_FLAGS2_HAS_RUSH;
                    battleStatus->rushFlags |= RUSH_FLAG_POWER;
                }
            }
        }
 
        if (!(gBattleStatus.flags1 & BS_FLAGS1_JUMP_CHARGED)) {
            battleStatus->jumpCharge = 0;
        }
 
        if (!(gBattleStatus.flags1 & BS_FLAGS1_HAMMER_CHARGED)) {
            battleStatus->hammerCharge = 0;
        }
 
        if (gGameStatusPtr->debugEnemyContact == DEBUG_CONTACT_AUTO_FLEE) {
            btl_set_state(BATTLE_STATE_RUN_AWAY);
            return;
        }
 
        if (gGameStatusPtr->debugEnemyContact == DEBUG_CONTACT_DIE_IN_BATTLE) {
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->handleEventSource != NULL) {
                    Evt* script = start_script(enemy->handleEventSource, EVT_PRIORITY_A, 0);
 
                    enemy->handleEventScript = script;
                    script->owner1.actorID = i | ACTOR_ENEMY0;
                    enemy->handleEventScriptID = script->id;
                    enemy->lastEventType = EVENT_DEATH;
                }
            }
            gBattleSubState = BTL_SUBSTATE_AWAIT_ENEMY_DEATH;
        } else {
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->handlePhaseSource != NULL) {
                    battleStatus->battlePhase = PHASE_PLAYER_BEGIN;
                    script = start_script(enemy->handlePhaseSource, EVT_PRIORITY_A, 0);
                    enemy->handlePhaseScript = script;
                    enemy->handlePhaseScriptID = script->id;
                    script->owner1.actorID = i | ACTOR_ENEMY0;
                }
            }
 
            partner = battleStatus->partnerActor;
            if (partner != NULL && partner->handlePhaseSource != NULL) {
                battleStatus->battlePhase = PHASE_PLAYER_BEGIN;
                script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
                partner->handlePhaseScript = script;
                partner->handlePhaseScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
            }
            gBattleSubState = BTL_SUBSTATE_AWAIT_ENEMY_SCRIPTS;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_AWAIT_ENEMY_SCRIPTS) {
        awaiting = FALSE;
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            enemy = battleStatus->enemyActors[i];
            if (enemy != NULL && enemy->handlePhaseSource != NULL && does_script_exist(enemy->handlePhaseScriptID)) {
                awaiting = TRUE;
            }
        }
        if (partner != NULL && partner->handlePhaseSource != NULL && does_script_exist(partner->handlePhaseScriptID)) {
            awaiting = TRUE;
        }
 
        if (!awaiting) {
            if (!btl_check_enemies_defeated()) {
                btl_set_state(BATTLE_STATE_BEGIN_PLAYER_TURN);
            }
            return;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_AWAIT_ENEMY_DEATH) {
        awaiting = FALSE;
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            enemy = battleStatus->enemyActors[i];
            if (enemy != NULL && enemy->handleEventSource != NULL && does_script_exist(enemy->handleEventScriptID)) {
                awaiting = TRUE;
            }
        }
 
        if (!awaiting) {
            if (!btl_check_enemies_defeated()) {
                btl_set_state(BATTLE_STATE_BEGIN_PLAYER_TURN);
            }
        }
    }
}

Referenced by btl_update().

◆ btl_state_draw_begin_turn()

void btl_state_draw_begin_turn ( void )

Definition at line 186 of file turn_begin.c.

186 {

187}

Referenced by btl_draw_ui().

◆ btl_state_update_begin_player_turn()

void btl_state_update_begin_player_turn ( void )

Definition at line 346 of file player_turn_begin.c.

                                              {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Evt* script;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        btl_cam_use_preset(BTL_CAM_DEFAULT);
        btl_cam_move(5);
        gBattleSubState = BTL_SUBSTATE_RESET_STATE;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_RESET_STATE:
            if (btl_cam_is_moving_done()) {
                gBattleStatus.flags1 &= ~BS_FLAGS1_PARTNER_ACTING;
                reset_actor_turn_info();
                battleStatus->actionResult = ACTION_RESULT_NONE;
                battleStatus->blockResult = BLOCK_RESULT_NONE;
                battleStatus->selectedMoveID = 0;
                gBattleStatus.flags1 |= BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
                gBattleStatus.flags2 &= ~BS_FLAGS2_IS_FIRST_STRIKE;
                player->disableDismissTimer = 0;
                player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
 
                if (partner != NULL) {
                    player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                    partner->disableDismissTimer = 0;
                }
 
                battleStatus->stateFreezeCount = 0;
                BattleSkipActorTurn = FALSE;
                BattleStatusUpdateDelay = 0;
 
                if (battleStatus->outtaSightActive != 0) {
                    battleStatus->battlePhase = PHASE_ENEMY_BEGIN;
                    script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
                    partner->handlePhaseScript = script;
                    gBattleSubState = BTL_SUBSTATE_AWAIT_OUTTA_SIGHT;
                    partner->handlePhaseScriptID = script->id;
                    script->owner1.actorID = ACTOR_PARTNER;
                } else {
                    gBattleSubState = BTL_SUBSTATE_CHECK_WATER_BLOCK;
                }
            }
            break;
        case BTL_SUBSTATE_AWAIT_OUTTA_SIGHT:
            if (!does_script_exist(partner->handlePhaseScriptID)) {
                battleStatus->outtaSightActive = 0;
                gBattleSubState = BTL_SUBSTATE_CHECK_WATER_BLOCK;
                gBattleStatus.flags2 |= BS_FLAGS2_PARTNER_TURN_USED;
            }
            break;
    }
 
    update_water_block();
    update_cloud_nine();
    update_turbo_charge();
 
    update_status_damage();
    update_command_loss();
 
    if (gBattleSubState == BTL_SUBSTATE_END_DELAY) {
        if (player->handleEventScript == NULL || !does_script_exist(player->handleEventScriptID)) {
            player->handleEventScript = NULL;
 
            if (btl_check_player_defeated() || btl_check_enemies_defeated()) {
                return;
            }
 
            if (BattleStatusUpdateDelay != 0) {
                BattleStatusUpdateDelay--;
                return;
            }
 
            if (BattleSkipActorTurn) {
                btl_set_state(BATTLE_STATE_BEGIN_PARTNER_TURN);
                gBattleStatus.flags2 |= BS_FLAGS2_PLAYER_TURN_USED;
            } else{
                btl_set_state(BATTLE_STATE_SWITCH_TO_PLAYER);
            }
        }
    }
}

Referenced by btl_update().

◆ btl_state_draw_begin_player_turn()

void btl_state_draw_begin_player_turn ( void )

Definition at line 431 of file player_turn_begin.c.

431 {

432}

Referenced by btl_draw_ui().

◆ btl_state_update_switch_to_player()

void btl_state_update_switch_to_player ( void )

Definition at line 3 of file switch_to_player.c.

                                             {
    Actor* player = gBattleStatus.playerActor;
    Actor* partner = gBattleStatus.partnerActor;
    s32 i;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        gBattleStatus.flags1 &= ~BS_FLAGS1_PARTNER_ACTING;
        reset_actor_turn_info();
        gBattleStatus.selectedMoveID = MOVE_NONE;
        gBattleStatus.actionResult = ACTION_RESULT_NONE;
        gBattleStatus.blockResult = BLOCK_RESULT_NONE;
        gBattleStatus.flags1 |= BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
        player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
        if (partner != NULL) {
            partner->flags |= (ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
        }
 
        for (i = 0; i < ARRAY_COUNT(gBattleStatus.enemyActors); i++) {
            Actor* enemy = gBattleStatus.enemyActors[i];
 
            if (enemy != NULL) {
                enemy->flags |= ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                enemy->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
        }
 
        btl_set_state(BATTLE_STATE_PREPARE_MENU);
    }
}

Referenced by btl_update().

◆ btl_state_draw_switch_to_player()

void btl_state_draw_switch_to_player ( void )

Definition at line 33 of file switch_to_player.c.

33 {

34}

Referenced by btl_draw_ui().

◆ btl_state_update_begin_partner_turn()

void btl_state_update_begin_partner_turn ( void )

Definition at line 13 of file partner_turn_begin.c.

                                               {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* partner = battleStatus->partnerActor;
    Actor* enemy;
    Evt* script;
    s32 i;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        if (partner == NULL) {
            BattleSkipActorTurn = TRUE;
            gBattleSubState = BTL_SUBSTATE_END_DELAY;
        } else if ((battleStatus->flags2 & (BS_FLAGS2_PARTNER_TURN_USED | BS_FLAGS2_PLAYER_TURN_USED)) == (BS_FLAGS2_PARTNER_TURN_USED | BS_FLAGS2_PLAYER_TURN_USED)) {
            btl_set_state(BATTLE_STATE_TRANSFER_TURN);
            return;
        } else if (partner->flags & ACTOR_FLAG_NO_ATTACK) {
            btl_set_state(BATTLE_STATE_TRANSFER_TURN);
            return;
        } else {
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            btl_cam_move(5);
            gBattleSubState = BTL_SUBSTATE_RESET_STATE;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_RESET_STATE) {
        if (btl_cam_is_moving_done()) {
            BattleStatusUpdateDelay = 0;
            reset_actor_turn_info();
            partner = battleStatus->partnerActor;
            battleStatus->actionResult = ACTION_RESULT_NONE;
            battleStatus->blockResult = BLOCK_RESULT_NONE;
            BattleSkipActorTurn = FALSE;
            gBattleStatus.flags1 |= BS_FLAGS1_PARTNER_ACTING;
            gBattleStatus.flags2 |= BS_FLAGS1_PLAYER_IN_BACK;
            partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
 
            if (partner->koStatus != 0) {
                partner->koDuration--;
                BattleSkipActorTurn = TRUE;
                BattleStatusUpdateDelay = 20;
                if (partner->koDuration > 0) {
                    partner->disableEffect->data.disableX->koDuration = partner->koDuration;
                } else {
                    partner->koStatus = 0;
                    dispatch_event_partner(EVENT_RECOVER_FROM_KO);
                    partner->disableEffect->data.disableX->koDuration = 0;
                    gBattleStatus.flags2 |= BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
                }
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL) {
                    enemy->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                }
            }
            gBattleSubState = BTL_SUBSTATE_AWAIT_RECOVER_DONE;
        }
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_AWAIT_RECOVER_DONE:
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
 
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            if (btl_check_player_defeated() || btl_check_enemies_defeated()) {
                return;
            }
            gBattleSubState = BTL_SUBSTATE_EXEC_TURN_SCRIPT;
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_EXEC_TURN_SCRIPT) {
        if (partner->handlePhaseSource != NULL) {
            battleStatus->battlePhase = PHASE_ENEMY_BEGIN;
            script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
            partner->handlePhaseScript = script;
            partner->handlePhaseScriptID = script->id;
            script->owner1.actorID = ACTOR_PARTNER;
        }
        gBattleSubState = BTL_SUBSTATE_AWAIT_TURN_SCRIPT;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_AWAIT_TURN_SCRIPT) {
        if (partner->handlePhaseSource == NULL || !does_script_exist(partner->handlePhaseScriptID)) {
            gBattleSubState = BTL_SUBSTATE_END_DELAY;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_END_DELAY) {
        if (BattleStatusUpdateDelay != 0) {
            BattleStatusUpdateDelay--;
            return;
        }
        gBattleStatus.flags2 &= ~BS_FLAGS2_NO_PLAYER_PAL_ADJUST;
        if (BattleSkipActorTurn) {
            gBattleStatus.flags2 |= BS_FLAGS2_PARTNER_TURN_USED;
            btl_set_state(BATTLE_STATE_TRANSFER_TURN);
        } else {
            btl_set_state(BATTLE_STATE_SWITCH_TO_PARTNER);
        }
    }
}

Referenced by btl_update().

◆ btl_state_draw_begin_partner_turn()

void btl_state_draw_begin_partner_turn ( void )

Definition at line 122 of file partner_turn_begin.c.

122 {

123}

Referenced by btl_draw_ui().

◆ btl_state_update_switch_to_partner()

void btl_state_update_switch_to_partner ( void )

Definition at line 3 of file switch_to_partner.c.

                                              {
    Actor* player = gBattleStatus.playerActor;
    Actor* partner = gBattleStatus.partnerActor;
    s32 i;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        reset_actor_turn_info();
        gBattleStatus.flags1 |= BS_FLAGS1_PARTNER_ACTING;
        gBattleStatus.selectedMoveID = MOVE_NONE;
        gBattleStatus.actionResult = ACTION_RESULT_NONE;
        gBattleStatus.blockResult = BLOCK_RESULT_NONE;
        gBattleStatus.flags1 |= BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
        player->flags |= (ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
        partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
 
        for (i = 0; i < ARRAY_COUNT(gBattleStatus.enemyActors); i++) {
            Actor* enemy = gBattleStatus.enemyActors[i];
            if (enemy != NULL) {
                enemy->flags |= ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                enemy->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
        }
 
        btl_set_state(BATTLE_STATE_PREPARE_MENU);
    }
}

Referenced by btl_update().

◆ btl_state_draw_switch_to_partner()

void btl_state_draw_switch_to_partner ( void )

Definition at line 30 of file switch_to_partner.c.

30 {

31}

Referenced by btl_draw_ui().

◆ btl_state_update_transfer_turn()

void btl_state_update_transfer_turn ( void )

Definition at line 16 of file turn_transfer.c.

                                          {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Actor* actor;
    ActorState* state;
    Evt* script;
    s32 waitingForScript;
    s32 i;
 
    s32 oldKoDuration;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        if (!(gBattleStatus.flags2 & BS_FLAGS2_PLAYER_TURN_USED)) {
            btl_set_state(BATTLE_STATE_SWITCH_TO_PLAYER);
            return;
        }
 
        if (partner != NULL) {
            if (!(gBattleStatus.flags2 & BS_FLAGS2_PARTNER_TURN_USED) && !(partner->flags & ACTOR_FLAG_NO_ATTACK)) {
                btl_set_state(BATTLE_STATE_SWITCH_TO_PARTNER);
                return;
            }
        }
 
        player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
        player->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
        if (partner != NULL) {
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
        }
 
        gBattleSubState = BTL_SUBSTATE_RESET_ENEMIES;
        BattleStatusUpdateDelay = 0;
        gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
        gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
        gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
        gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_RESET_ENEMIES) {
        // await all enemy event scripts
        waitingForScript = FALSE;
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL && actor->handleEventScript != NULL) {
                if (does_script_exist(actor->handleEventScriptID)) {
                    waitingForScript = TRUE;
                } else {
                    actor->handleEventScript = NULL;
                }
            }
        }
        if (waitingForScript) {
            return;
        }
 
        reset_actor_turn_info();
 
        // prepare each enemy actor for the coming turn
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
 
            if (actor == NULL) {
                continue;
            }
 
            actor->flags |= ACTOR_FLAG_USING_IDLE_ANIM | ACTOR_FLAG_SHOW_STATUS_ICONS;
            actor->flags &= ~ACTOR_FLAG_SKIP_TURN;
 
            if (actor->debuff != 0) {
                if (actor->debuff == STATUS_KEY_UNUSED
                    || actor->debuff == STATUS_KEY_DIZZY
                    || actor->debuff == STATUS_KEY_PARALYZE
                    || actor->debuff == STATUS_KEY_SLEEP
                    || actor->debuff == STATUS_KEY_FROZEN
                    || actor->debuff == STATUS_KEY_STOP
                ) {
                    actor->flags |= ACTOR_FLAG_SKIP_TURN;
                }
                actor->debuffDuration--;
                if (actor->debuffDuration <= 0) {
                    actor->debuff = 0;
                    remove_status_debuff(actor->hudElementDataIndex);
                    dispatch_event_actor(actor, EVENT_RECOVER_STATUS);
                    BattleStatusUpdateDelay = 20;
                }
            }
 
            if (actor->staticStatus != 0) {
                actor->staticDuration--;
                if (actor->staticDuration <= 0) {
                    actor->staticStatus = 0;
                    remove_status_static(actor->hudElementDataIndex);
                    BattleStatusUpdateDelay = 20;
                }
            }
 
            if (actor->transparentStatus != 0) {
                actor->transparentDuration--;
                if (actor->transparentDuration <= 0) {
                    actor->transparentStatus = 0;
                    remove_status_transparent(actor->hudElementDataIndex);
                    BattleStatusUpdateDelay = 20;
                }
            }
 
            if (actor->stoneStatus != 0) {
                actor->stoneDuration--;
                if (actor->stoneDuration <= 0) {
                    actor->stoneStatus = 0;
                    BattleStatusUpdateDelay = 20;
                }
            }
 
            oldKoDuration = actor->koDuration;
            actor->koDuration = actor->debuffDuration;
            if (actor->koDuration > 0) {
                actor->koStatus = STATUS_KEY_KO;
                actor->disableEffect->data.disableX->koDuration = actor->koDuration;
            } else if (oldKoDuration != actor->koDuration) {
                actor->koStatus = 0;
                actor->disableEffect->data.disableX->koDuration = 0;
            }
            if (actor->debuff == STATUS_KEY_POISON) {
                gBattleStatus.flags1 |= BS_FLAGS1_TRIGGER_EVENTS;
                dispatch_damage_event_actor_0(actor, 1, EVENT_HIT);
                BattleStatusUpdateDelay = 20;
            }
        }
        gBattleSubState = BTL_SUBSTATE_AWAIT_ALL;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_AWAIT_ALL) {
        // wait for player HandleEvent script to finish
        if(player->handleEventScript != NULL) {
            if (does_script_exist(player->handleEventScriptID)) {
                return;
            } else {
                player->handleEventScript = NULL;
            }
        }
 
        // wait for partner HandleEvent script to finish
        if (partner != NULL) {
            if (partner->handleEventScript != NULL) {
                if (does_script_exist(partner->handleEventScriptID)) {
                    return;
                } else {
                    partner->handleEventScript = NULL;
                }
            }
        }
 
        // wait for all enemy HandleEvent scripts to finish
        waitingForScript = FALSE;
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL && actor->handleEventScript != NULL) {
                if (does_script_exist(actor->handleEventScriptID)) {
                    waitingForScript = TRUE;
                } else {
                    actor->handleEventScript = NULL;
                }
            }
        }
        if (waitingForScript) {
            return;
        }
 
        if (btl_check_player_defeated() || btl_check_enemies_defeated()) {
            return;
        }
 
        btl_cam_use_preset(BTL_CAM_DEFAULT);
 
        if (partner == NULL || !(gBattleStatus.flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
            gBattleSubState = BTL_SUBSTATE_TRY_MERLEE_DEF;
        } else if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
            gBattleSubState = BTL_SUBSTATE_TRY_MERLEE_DEF;
        } else {
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            player->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            state = &partner->state;
            if (!battleStatus->outtaSightActive) {
                partner->state.curPos.x = partner->homePos.x;
                partner->state.curPos.z = partner->homePos.z;
                partner->state.goalPos.x = player->homePos.x;
                partner->state.goalPos.z = player->homePos.z;
            } else {
                partner->state.curPos.x = partner->homePos.x;
                partner->state.curPos.z = partner->homePos.z;
                partner->state.goalPos.x = partner->homePos.x;
                partner->state.goalPos.z = partner->homePos.z + 5.0f;
                partner->homePos.x = player->homePos.x;
                partner->homePos.z = player->homePos.z;
            }
            state->moveTime = 4;
            state->angle = 0.0f;
            gBattleSubState = BTL_SUBSTATE_RESET_POSITIONS;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_RESET_POSITIONS) {
        if (partner->state.moveTime != 0) {
            partner->curPos.x += (partner->state.goalPos.x - partner->curPos.x) / partner->state.moveTime;
            partner->curPos.z += (partner->state.goalPos.z - partner->curPos.z) / partner->state.moveTime;
            player->curPos.x += (partner->state.curPos.x - player->curPos.x) / partner->state.moveTime;
            player->curPos.z += (partner->state.curPos.z - player->curPos.z) / partner->state.moveTime;
        }
        partner->curPos.z -= sin_rad(DEG_TO_RAD(partner->state.angle)) * 16.0f;
        partner->yaw = clamp_angle(partner->state.angle);
        player->curPos.z += sin_rad(DEG_TO_RAD(partner->state.angle)) * 16.0f;
        player->yaw = clamp_angle(partner->state.angle);
        partner->state.angle += 90.0f;
 
        if (partner->state.moveTime != 0) {
            partner->state.moveTime--;
        } else {
            partner->curPos.x = partner->state.goalPos.x;
            partner->curPos.z = partner->state.goalPos.z;
            player->curPos.x = partner->state.curPos.x;
            player->curPos.z = partner->state.curPos.z;
            if (!battleStatus->outtaSightActive) {
                partner->homePos.x = partner->curPos.x;
                partner->homePos.z = partner->curPos.z;
                player->homePos.x = player->curPos.x;
                player->homePos.z = player->curPos.z;
            } else {
                player->homePos.x = player->curPos.x;
                player->homePos.z = player->curPos.z;
            }
            gBattleSubState = BTL_SUBSTATE_TRY_MERLEE_DEF;
            gBattleStatus.flags1 &= ~BS_FLAGS1_PLAYER_IN_BACK;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_TRY_MERLEE_DEF) {
        if (BattleStatusUpdateDelay != 0) {
            BattleStatusUpdateDelay--;
            return;
        }
 
        if (battleStatus->nextMerleeSpellType == MERLEE_SPELL_DEF_BOOST) {
            battleStatus->merleeDefenseBoost = 3;
            battleStatus->nextMerleeSpellType = MERLEE_SPELL_NONE;
            battleStatus->battlePhase = PHASE_MERLEE_DEFENSE_BONUS;
            script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            player->takeTurnScript = script;
            player->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
        }
        gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
        player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
        player->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
        if (partner != NULL) {
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
        }
        gBattleSubState = BTL_SUBSTATE_NOTIFY_ENEMY_PHASE;
        gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
        gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
        gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
        gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_NOTIFY_ENEMY_PHASE) {
        // potentially wait for the merlee script to end
        if (player->takeTurnScript != NULL) {
            if (does_script_exist(player->takeTurnScriptID)) {
                return;
            } else {
                player->takeTurnScript = NULL;
            }
        }
 
        // initiate all enemy PHASE_PLAYER_END scripts
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL && actor->handlePhaseSource != NULL) {
                battleStatus->battlePhase = PHASE_PLAYER_END;
                script = start_script(actor->handlePhaseSource, EVT_PRIORITY_A, 0);
                actor->handlePhaseScript = script;
                actor->handlePhaseScriptID = script->id;
                script->owner1.enemyID = i | ACTOR_CLASS_ENEMY;
            }
        }
 
        gBattleSubState = BTL_SUBSTATE_AWAIT_ENEMY_PHASE;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_AWAIT_ENEMY_PHASE) {
        // await all the enemy PHASE_PLAYER_END scripts
        waitingForScript = FALSE;
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            // interesting: this condition checks for handlePhaseSource instead of handlePhaseScript,
            // which is the expected pattern. result: handlePhaseScript is never NULL'd. minor bug?
            if (actor != NULL && actor->handlePhaseSource != NULL) {
                if (does_script_exist(actor->handlePhaseScriptID)) {
                    waitingForScript = TRUE;
                }
            }
        }
        if (waitingForScript) {
            return;
        }
 
        gBattleSubState = BTL_SUBSTATE_DONE;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_DONE) {
        btl_set_state(BATTLE_STATE_NEXT_ENEMY);
    }
}

Referenced by btl_update().

◆ btl_state_draw_transfer_turn()

void btl_state_draw_transfer_turn ( void )

Definition at line 334 of file turn_transfer.c.

334 {

335}

Referenced by btl_draw_ui().

◆ btl_state_update_prepare_menu()

void btl_state_update_prepare_menu ( void )

Definition at line 4 of file prepare_menu.c.

                                         {
    BattleStatus* battleStatus = &gBattleStatus;
 
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_JUMP] = -1;
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_SMASH] = -1;
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_ITEMS] = -1;
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = -1;
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_PARTNER] = -1;
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STAR_POWER] = -1;
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STRATEGY] = -1;
    battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_ABILITY] = -1;
    battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STAR_POWER] = -1;
    battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STRATEGY] = -1;
 
    DMA_COPY_SEGMENT(btl_states_menus);
 
    if (battleStatus->flags1 & BS_FLAGS1_PARTNER_ACTING) {
        btl_set_state(BATTLE_STATE_PARTNER_MENU);
    } else if (gBattleSubState == BTL_SUBSTATE_PLAYER_CONTINUE_DIP) {
        btl_set_state(BATTLE_STATE_PLAYER_MENU);
        gBattleSubState = BTL_SUBSTATE_PLAYER_CONTINUE_DIP; // maintain substate
    } else {
        btl_set_state(BATTLE_STATE_PLAYER_MENU);
    }
}

Referenced by btl_update().

◆ btl_state_draw_prepare_menu()

void btl_state_draw_prepare_menu ( void )

Definition at line 30 of file prepare_menu.c.

30 {

31}

Referenced by btl_draw_ui().

◆ btl_state_update_end_turn()

void btl_state_update_end_turn ( void )

Definition at line 13 of file turn_end.c.

                                     {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Actor* actor;
    Evt* script;
    s32 i;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        s32 cond = FALSE;
 
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL && actor->handleEventScript != NULL) {
                if (does_script_exist(actor->handleEventScriptID)) {
                    cond = TRUE;
                } else {
                    actor->handleEventScript = NULL;
                }
            }
        }
 
        if (!cond) {
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->takeTurnScript != NULL) {
                    if (does_script_exist(actor->takeTurnScriptID)) {
                        cond = TRUE;
                    } else {
                        actor->takeTurnScript = NULL;
                    }
                }
            }
 
            if (!cond) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                gBattleSubState = BTL_SUBSTATE_CHECK_FOR_SWAP;
            }
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_CHECK_FOR_SWAP) {
        if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
            gBattleSubState = BTL_SUBSTATE_START_SCRIPTS;
        } else if (!(gBattleStatus.flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
            gBattleSubState = BTL_SUBSTATE_START_SCRIPTS;
        } else {
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            player->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            partner->state.curPos.x = partner->homePos.x;
            partner->state.curPos.z = partner->homePos.z;
            partner->state.goalPos.x = player->homePos.x;
            partner->state.goalPos.z = player->homePos.z;
            partner->state.moveTime = 4;
            partner->state.angle = 0.0f;
            gBattleSubState = BTL_SUBSTATE_PERFORM_SWAP;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_PERFORM_SWAP) {
        if (partner->state.moveTime != 0) {
            partner->curPos.x += (partner->state.goalPos.x - partner->curPos.x) / partner->state.moveTime;
            partner->curPos.z += (partner->state.goalPos.z - partner->curPos.z) / partner->state.moveTime;
            player->curPos.x += (partner->state.curPos.x - player->curPos.x) / partner->state.moveTime;
            player->curPos.z += (partner->state.curPos.z - player->curPos.z) / partner->state.moveTime;
        }
        partner->curPos.z -= sin_rad(DEG_TO_RAD(partner->state.angle)) * 16.0f;
        partner->yaw = clamp_angle(partner->state.angle);
        player->curPos.z += sin_rad(DEG_TO_RAD(partner->state.angle)) * 16.0f;
        player->yaw = clamp_angle(partner->state.angle);
        partner->state.angle += 90.0f;
        if (partner->state.moveTime != 0) {
            partner->state.moveTime--;
        } else {
            partner->curPos.x = partner->state.goalPos.x;
            partner->curPos.z = partner->state.goalPos.z;
            player->curPos.x = partner->state.curPos.x;
            player->curPos.z = partner->state.curPos.z;
            partner->homePos.x = partner->curPos.x;
            partner->homePos.z = partner->curPos.z;
            player->homePos.x = player->curPos.x;
            player->homePos.z = player->curPos.z;
            player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                gBattleStatus.flags1 |= BS_FLAGS1_PLAYER_IN_BACK;
            } else {
                gBattleStatus.flags1 &= ~BS_FLAGS1_PLAYER_IN_BACK;
            }
            gBattleSubState = BTL_SUBSTATE_START_SCRIPTS;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_START_SCRIPTS) {
        gBattleStatus.flags2 &= ~BS_FLAGS2_HIDE_BUFF_COUNTERS;
        player->disableDismissTimer = 0;
        player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
        if (partner != NULL) {
            player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
            partner->disableDismissTimer = 0;
        }
 
        btl_set_player_idle_anims();
        gBattleStatus.flags1 &= ~BS_FLAGS1_PLAYER_DEFENDING;
        playerData->starPower += SP_PER_SEG;
        if (playerData->starPower > playerData->maxStarPower * SP_PER_BAR) {
            playerData->starPower = playerData->maxStarPower * SP_PER_BAR;
        }
 
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL && actor->handlePhaseSource != NULL) {
                battleStatus->battlePhase = PHASE_ENEMY_END;
                script = start_script(actor->handlePhaseSource, EVT_PRIORITY_A, 0);
                actor->handlePhaseScript = script;
                actor->handlePhaseScriptID = script->id;
                script->owner1.enemyID = i | ACTOR_ENEMY0;
            }
        }
 
        if (partner != NULL && partner->handlePhaseSource != NULL) {
            battleStatus->battlePhase = PHASE_ENEMY_END;
            script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
            partner->handlePhaseScript = script;
            partner->handlePhaseScriptID = script->id;
            script->owner1.actorID = ACTOR_PARTNER;
        }
        gBattleSubState = BTL_SUBSTATE_AWAIT_SCRIPTS;
    }
 
    // wait for all end turn scripts to finish executing
    if (gBattleSubState == BTL_SUBSTATE_AWAIT_SCRIPTS) {
        s32 waitingForScript = FALSE;
 
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL && actor->handlePhaseSource != NULL && does_script_exist(actor->handlePhaseScriptID)) {
                waitingForScript = TRUE;
            }
        }
 
        if (partner != NULL && partner->handlePhaseSource != NULL && does_script_exist(partner->handlePhaseScriptID)) {
            waitingForScript = TRUE;
        }
 
        if (!waitingForScript) {
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            gBattleSubState = BTL_SUBSTATE_BEGIN_NEXT;
        }
    }
 
    // proceed to next turn
    switch (gBattleSubState) {
        case BTL_SUBSTATE_BEGIN_NEXT:
        case BTL_SUBSTATE_UNUSED_4:
            btl_set_state(BATTLE_STATE_BEGIN_TURN);
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_end_turn()

void btl_state_draw_end_turn ( void )

Definition at line 176 of file turn_end.c.

176 {

177}

Referenced by btl_draw_ui().

◆ btl_state_update_victory()

void btl_state_update_victory ( void )

Definition at line 16 of file victory.c.

                                    {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Evt* script;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CHECK_OUTTA_SIGHT:
            player->flags &= ~(ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
            if (partner != NULL) {
                partner->flags &= ~(ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
            }
 
            battleStatus->stateFreezeCount = 0;
            if (battleStatus->outtaSightActive == 0) {
                gBattleSubState = BTL_SUBSTATE_RECOVER_STATUS;
            } else {
                battleStatus->battlePhase = PHASE_ENEMY_BEGIN;
                script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
                partner->handlePhaseScript = script;
                partner->handlePhaseScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
                gBattleSubState = BTL_SUBSTATE_AWAIT_OUTTA_SIGHT;
            }
 
            break;
        case BTL_SUBSTATE_AWAIT_OUTTA_SIGHT:
            if (!does_script_exist(partner->handlePhaseScriptID)) {
                battleStatus->outtaSightActive = 0;
                gBattleSubState = BTL_SUBSTATE_RECOVER_STATUS;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_RECOVER_STATUS:
            player->flags &= ~(ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
            if (partner != NULL) {
                partner->flags &= ~(ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
            }
            gBattleSubState = BTL_SUBSTATE_CHECK_SWAP;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
 
            gBattleStatus.flags1 &= ~BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
            if (player->koStatus == STATUS_KEY_KO) {
                dispatch_event_player(EVENT_RECOVER_FROM_KO);
                gBattleSubState = BTL_SUBSTATE_AWAIT_RECOVER_KO;
            }
            player->debuff = 0;
            player->staticStatus = 0;
            player->stoneStatus = 0;
            player->transparentStatus = 0;
            player->koStatus = 0;
            player->koDuration = 0;
            player->disableEffect->data.disableX->koDuration = 0;
 
            if (partner != NULL) {
                if (partner->koStatus == STATUS_KEY_KO) {
                    dispatch_event_partner(EVENT_RECOVER_FROM_KO);
                    gBattleSubState = BTL_SUBSTATE_AWAIT_RECOVER_KO;
                }
                partner->debuff = 0;
                partner->staticStatus = 0;
                partner->stoneStatus = 0;
                partner->transparentStatus = 0;
                partner->koStatus = 0;
                partner->koDuration = 0;
                partner->disableEffect->data.disableX->koDuration = 0;
            }
            break;
        case BTL_SUBSTATE_AWAIT_RECOVER_KO:
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
            gBattleSubState = BTL_SUBSTATE_CHECK_SWAP;
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_CHECK_SWAP) {
        if (partner == NULL || !(gBattleStatus.flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
            gBattleSubState = BTL_SUBSTATE_CHECK_MERLEE;
        } else {
            partner->state.curPos.x = partner->curPos.x;
            partner->state.curPos.z = partner->curPos.z;
            partner->state.goalPos.x = player->curPos.x;
            partner->state.goalPos.z = player->curPos.z;
            partner->state.moveTime = 4;
            partner->state.angle = 0.0f;
            gBattleSubState = BTL_SUBSTATE_AWAIT_SWAP;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_AWAIT_SWAP) {
        if (partner->state.moveTime != 0) {
            partner->curPos.x += (partner->state.goalPos.x - partner->curPos.x) / partner->state.moveTime;
            partner->curPos.z += (partner->state.goalPos.z - partner->curPos.z) / partner->state.moveTime;
            player->curPos.x += (partner->state.curPos.x - player->curPos.x) / partner->state.moveTime;
            player->curPos.z += (partner->state.curPos.z - player->curPos.z) / partner->state.moveTime;
        }
        partner->curPos.z += sin_rad(DEG_TO_RAD(partner->state.angle)) * 16.0f;
        partner->yaw = clamp_angle(-partner->state.angle);
        player->curPos.z -= sin_rad(DEG_TO_RAD(partner->state.angle)) * 16.0f;
        player->yaw = clamp_angle(-partner->state.angle);
        partner->state.angle += 90.0f;
 
        if (partner->state.moveTime != 0) {
            partner->state.moveTime--;
        } else {
            partner->curPos.x = partner->state.goalPos.x;
            partner->curPos.z = partner->state.goalPos.z;
            player->curPos.x = partner->state.curPos.x;
            player->curPos.z = partner->state.curPos.z;
            partner->homePos.x = partner->curPos.x;
            partner->homePos.z = partner->curPos.z;
            player->homePos.x = player->curPos.x;
            player->homePos.z = player->curPos.z;
            gBattleSubState = BTL_SUBSTATE_CHECK_MERLEE;
            gBattleStatus.flags1 &= ~BS_FLAGS1_PLAYER_IN_BACK;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_CHECK_MERLEE) {
        btl_cam_use_preset(BTL_CAM_DEFAULT);
        if (battleStatus->nextMerleeSpellType == MERLEE_SPELL_EXP_BOOST) {
            if (battleStatus->totalStarPoints == 0) {
                battleStatus->nextMerleeSpellType = MERLEE_SPELL_NONE;
                gPlayerData.merleeTurnCount = 0;
                gPlayerData.merleeCastsLeft++;
            } else {
                battleStatus->battlePhase = PHASE_MERLEE_EXP_BONUS;
                script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
                player->takeTurnScript = script;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
            }
        }
        gBattleSubState = BTL_SUBSTATE_AWAIT_MERLEE;
        BattleSubstateDelay = 0;
        gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_AWAIT_MERLEE) {
        if (BattleSubstateDelay != 0) {
            BattleSubstateDelay--;
        } else {
            if (player->takeTurnScript == NULL || !does_script_exist(player->takeTurnScriptID)) {
                player->takeTurnScript = NULL;
                if (battleStatus->nextMerleeSpellType != MERLEE_SPELL_EXP_BOOST) {
                    gBattleSubState = BTL_SUBSTATE_DONE;
                } else {
                    battleStatus->incrementStarPointDelay = 20;
                    battleStatus->nextMerleeSpellType = MERLEE_SPELL_NONE;
                    gBattleSubState = BTL_SUBSTATE_DONE;
                    battleStatus->pendingStarPoints = battleStatus->totalStarPoints
                                            + battleStatus->pendingStarPoints + battleStatus->pendingStarPoints;
                }
            }
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_DONE) {
        if (battleStatus->pendingStarPoints <= 0) {
            if (gBattleStatus.flags1 & BS_FLAGS1_STAR_POINTS_DROPPED) {
                gBattleStatus.flags1 &= ~BS_FLAGS1_BATTLE_FLED;
            }
            if (gPlayerData.battlesWon < 9999) {
                gPlayerData.battlesWon++;
            }
            if (gBattleStatus.flags1 & BS_FLAGS1_BATTLE_FLED) {
                gCurrentEncounter.battleOutcome = OUTCOME_ENEMY_FLED;
            } else {
                gCurrentEncounter.battleOutcome = OUTCOME_PLAYER_WON;
            }
            if (gBattleStatus.flags1 & BS_FLAGS1_DISABLE_CELEBRATION) {
                if (!(gBattleStatus.flags2 & BS_FLAGS2_DONT_STOP_MUSIC)) {
                    bgm_set_song(0, -1, 0, 1500, 8);
                }
                btl_set_state(BATTLE_STATE_END_BATTLE);
            } else {
                btl_set_state(BATTLE_STATE_CELEBRATION);
            }
        }
    }
}

Referenced by btl_update().

◆ btl_state_draw_victory()

void btl_state_draw_victory ( void )

Definition at line 212 of file victory.c.

212 {

213}

Referenced by btl_draw_ui().

◆ btl_state_update_end_training_battle()

void btl_state_update_end_training_battle ( void )

Definition at line 13 of file end_training.c.

                                                {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    EncounterStatus* encounterStatus = &gCurrentEncounter;
    Actor* player = gBattleStatus.playerActor;
    Actor* partner = gBattleStatus.partnerActor;
    Evt* script;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            player->flags &= ~(ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
            if (partner != NULL) {
                partner->flags &= ~(ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
            }
            gBattleSubState = BTL_SUBSTATE_CHECK_OUTTA_SIGHT;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
 
            if (player->koStatus == STATUS_KEY_KO) {
                dispatch_event_player(EVENT_RECOVER_FROM_KO);
                gBattleSubState = BTL_SUBSTATE_AWAIT_RECOVERING;
            }
            player->debuff = 0;
            player->staticStatus = 0;
            player->stoneStatus = 0;
            player->transparentStatus = 0;
            player->koStatus = 0;
            player->koDuration = 0;
            player->disableEffect->data.disableX->koDuration = 0;
            if (partner != NULL) {
                if (partner->koStatus == STATUS_KEY_KO) {
                    dispatch_event_partner(EVENT_RECOVER_FROM_KO);
                    gBattleSubState = BTL_SUBSTATE_AWAIT_RECOVERING;
                }
                partner->debuff = 0;
                partner->staticStatus = 0;
                partner->stoneStatus = 0;
                partner->transparentStatus = 0;
                partner->koStatus = 0;
                partner->koDuration = 0;
                partner->disableEffect->data.disableX->koDuration = 0;
            }
            break;
        case BTL_SUBSTATE_AWAIT_RECOVERING:
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
 
            gBattleSubState = BTL_SUBSTATE_CHECK_OUTTA_SIGHT;
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CHECK_OUTTA_SIGHT:
            battleStatus->stateFreezeCount = 0;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
 
            if (!battleStatus->outtaSightActive) {
                gBattleSubState = BTL_SUBSTATE_RESET_CAM;
            } else {
                battleStatus->battlePhase = PHASE_ENEMY_BEGIN;
                script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
                partner->handlePhaseScript = script;
                partner->handlePhaseScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
                gBattleSubState = BTL_SUBSTATE_AWAIT_OUTTA_SIGHT;
            }
            break;
        case BTL_SUBSTATE_AWAIT_OUTTA_SIGHT:
            if (!does_script_exist(partner->handlePhaseScriptID)) {
                battleStatus->outtaSightActive = FALSE;
                gBattleSubState = BTL_SUBSTATE_RESET_CAM;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_RESET_CAM:
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            BattleSubstateDelay = 30;
            gBattleSubState = BTL_SUBSTATE_DONE;
            break;
        case BTL_SUBSTATE_DONE:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
                return;
            }
            if (playerData->trainingsDone < 9999) {
                playerData->trainingsDone++;
            }
            encounterStatus->battleOutcome = OUTCOME_ENEMY_FLED;
            if (!(gBattleStatus.flags2 & BS_FLAGS2_DONT_STOP_MUSIC)) {
                bgm_set_song(0, -1, 0, 1500, 8);
            }
            btl_set_state(BATTLE_STATE_END_BATTLE);
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_end_training_battle()

void btl_state_draw_end_training_battle ( void )

Definition at line 125 of file end_training.c.

125 {

126}

Referenced by btl_draw_ui().

◆ btl_state_update_end_battle()

void btl_state_update_end_battle ( void )

Definition at line 15 of file end_battle.c.

                                       {
    EncounterStatus* encounterStatus = &gCurrentEncounter;
    BattleStatus* battleStatus = &gBattleStatus;
    Battle* battle = gCurrentBattlePtr;
    Stage* stage;
    Evt* script;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            BattleScreenFadeAmt = 0;
            if (gGameStatusPtr->debugEnemyContact == DEBUG_CONTACT_DIE_ON_TOUCH) {
                BattleScreenFadeAmt = 255;
            }
            if (encounterStatus->battleOutcome == OUTCOME_PLAYER_LOST && !(gBattleStatus.flags1 & BS_FLAGS1_NO_GAME_OVER)) {
                btl_cam_unfreeze();
                btl_cam_use_preset(BTL_CAM_INTERRUPT);
                set_screen_overlay_color(SCREEN_LAYER_FRONT, 0, 0, 0);
                set_screen_overlay_center(SCREEN_LAYER_FRONT, 0, 160, 120);
            }
            gBattleSubState = BTL_SUBSTATE_FADE_OUT;
            break;
        case BTL_SUBSTATE_FADE_OUT:
            if (BattleScreenFadeAmt == 255) {
                gBattleSubState = BTL_SUBSTATE_EXEC_STAGE_SCRIPT;
                break;
            }
            BattleScreenFadeAmt += battleStatus->endBattleFadeOutRate;
            if (BattleScreenFadeAmt > 255) {
                BattleScreenFadeAmt = 255;
            }
            break;
        case BTL_SUBSTATE_EXEC_STAGE_SCRIPT:
            BattleScreenFadeAmt = 255;
            gBattleStatus.flags1 &= ~BS_FLAGS1_ACTORS_VISIBLE;
            if (gCurrentStagePtr == NULL) {
                stage = battle->stage;
            } else {
                stage = gCurrentStagePtr->stage;
            }
            if (stage->postBattle == NULL) {
                gBattleSubState = BTL_SUBSTATE_CLEANUP;
                return;
            }
            script = start_script(stage->postBattle, EVT_PRIORITY_A, 0);
            battleStatus->controlScript = script;
            battleStatus->controlScriptID = script->id;
            gBattleSubState = BTL_SUBSTATE_AWAIT_STAGE_SCRIPT;
            break;
        case BTL_SUBSTATE_AWAIT_STAGE_SCRIPT:
            if (does_script_exist(battleStatus->controlScriptID)) {
                break;
            }
            gBattleSubState = BTL_SUBSTATE_CLEANUP;
            // fallthrough
        case BTL_SUBSTATE_CLEANUP:
            kill_all_scripts();
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                if (battleStatus->enemyActors[i] != NULL) {
                    btl_delete_actor(battleStatus->enemyActors[i]);
                }
            }
            if (battleStatus->partnerActor != NULL) {
                btl_delete_actor(battleStatus->partnerActor);
            }
 
            btl_delete_player_actor(battleStatus->playerActor);
 
            if (battleStatus->nextMerleeSpellType == MERLEE_SPELL_COIN_BOOST) {
                encounterStatus->hasMerleeCoinBonus = TRUE;
                battleStatus->nextMerleeSpellType = MERLEE_SPELL_NONE;
            }
 
            encounterStatus->damageTaken = battleStatus->damageTaken;
 
            if (gBattleStatus.flags2 & BS_FLAGS2_DROP_WHACKA_BUMP) {
                encounterStatus->dropWhackaBump = TRUE;
            }
 
            remove_all_effects();
            set_windows_visible(0);
 
            if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                decrement_status_bar_disabled();
            }
 
            if (encounterStatus->battleOutcome == OUTCOME_PLAYER_LOST &&
                !(gBattleStatus.flags1 & BS_FLAGS1_NO_GAME_OVER))
            {
                s16 areaID;
                s16 mapID;
 
                btl_set_state(BATTLE_STATE_NONE);
                gLastDrawBattleState = gBattleState;
                get_map_IDs_by_name_checked("gv_01", &areaID, &mapID);
                gGameStatusPtr->areaID = areaID;
                gGameStatusPtr->mapID = mapID;
                gGameStatusPtr->entryID = gv_01_ENTRY_0;
                set_game_mode(GAME_MODE_GAME_OVER);
            } else {
                btl_set_state(BATTLE_STATE_NONE);
                gLastDrawBattleState = gBattleState;
                func_8003E514(1);
                set_game_mode(GAME_MODE_END_BATTLE);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_end_battle()

void btl_state_draw_end_battle ( void )

Definition at line 124 of file end_battle.c.

                                     {
    Camera* camera = &gCameras[gCurrentCameraID];
 
    if (gCurrentEncounter.battleOutcome == OUTCOME_PLAYER_LOST && !(gBattleStatus.flags1 & BS_FLAGS1_NO_GAME_OVER)) {
        camera->params.basic.offsetY += 256;
        set_screen_overlay_params_front(OVERLAY_SCREEN_MARIO, BattleScreenFadeAmt);
    } else {
        set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, BattleScreenFadeAmt);
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_defend()

void btl_state_update_defend ( void )

Definition at line 9 of file defend.c.

                                   {
    Actor* player = gBattleStatus.playerActor;
    Evt* script;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            gBattleStatus.stateFreezeCount = 0;
 
            // prompt player to handle PHASE_USE_DEFEND
            gBattleStatus.battlePhase = PHASE_USE_DEFEND;
            player->takeTurnScript = script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            player->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
            gBattleSubState = BTL_SUBSTATE_AWAIT;
            break;
        case BTL_SUBSTATE_AWAIT:
            // wait for PHASE_USE_DEFEND event to complete
            if (does_script_exist(player->takeTurnScriptID) || gBattleStatus.stateFreezeCount != 0) {
                break;
            }
 
            // done waiting for the script
            btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_defend()

void btl_state_draw_defend ( void )

Definition at line 36 of file defend.c.

36 {

37}

Referenced by btl_draw_ui().

◆ btl_state_update_run_away()

void btl_state_update_run_away ( void )

Definition at line 17 of file run_away.c.

                                     {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Actor* enemy;
    s32 enemyCount;
    f32 totalEscapeChance;
    Evt* script;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_EXEC_SCRIPT:
            battleStatus->stateFreezeCount = 0;
            gBattleStatus.flags1 &= ~BS_FLAGS1_BATTLE_FLED;
            gBattleStatus.flags2 |= BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
            gBattleStatus.flags2 |= BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 |= BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 |= BS_FLAGS2_PLAYER_TURN_USED;
 
            playerData->fleeAttempts++;
            btl_cam_use_preset(BTL_CAM_PLAYER_FLEE);
            btl_cam_target_actor(ACTOR_PLAYER);
 
            // calculate average escape chance
            enemyCount = 0;
            totalEscapeChance = 0.0f;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL) {
                    if (!(enemy->flags & ACTOR_FLAG_TARGET_ONLY)) {
                        if (!(enemy->flags & ACTOR_FLAG_NO_DMG_APPLY)) {
                            f32 escapeChance = enemy->actorBlueprint->escapeChance;
 
                            if (enemy->debuff == STATUS_KEY_UNUSED ||
                                enemy->debuff == STATUS_KEY_DIZZY ||
                                enemy->debuff == STATUS_KEY_PARALYZE ||
                                enemy->debuff == STATUS_KEY_SLEEP ||
                                enemy->debuff == STATUS_KEY_FROZEN ||
                                enemy->debuff == STATUS_KEY_STOP)
                            {
                                escapeChance = 100.0f;
                            }
                            totalEscapeChance += escapeChance;
                            enemyCount++;
                        }
                    }
                }
            }
            player->state.varTable[0] = totalEscapeChance / enemyCount;
 
            if (gGameStatusPtr->debugEnemyContact == DEBUG_CONTACT_AUTO_FLEE) {
                player->state.varTable[0] = 100;
            }
 
            battleStatus->battlePhase = PHASE_RUN_AWAY_START;
            script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            player->takeTurnScript = script;
            player->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
            if (partner != NULL && partner->koStatus == 0) {
                script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
                partner->takeTurnScript = script;
                partner->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
            }
            gBattleSubState = BTL_SUBSTATE_AWAIT_SCRIPT;
            break;
        case BTL_SUBSTATE_AWAIT_SCRIPT:
            if (does_script_exist(player->takeTurnScriptID) || battleStatus->stateFreezeCount != 0) {
                break;
            }
            if (!(gBattleStatus.flags1 & BS_FLAGS1_BATTLE_FLED)) {
                gBattleSubState = BTL_SUBSTATE_EXEC_POST_FAILURE;
            } else {
                currentEncounter->battleOutcome = OUTCOME_PLAYER_FLED;
                if (!is_ability_active(ABILITY_RUNAWAY_PAY)) {
                    gBattleSubState = BTL_SUBSTATE_DONE;
                } else {
                    status_bar_start_blinking_starpoints();
                    btl_start_blinking_starpoints();
                    BattleScreenFadeAmt = 0;
                    // divide reward into 20 increments
                    RunAwayRewardTotal = battleStatus->totalStarPoints * 100;
                    RunAwayRewardStep = 20;
                    RunAwayRewardIncrement = RunAwayRewardTotal / RunAwayRewardStep;
                    gBattleSubState = BTL_SUBSTATE_GIVE_STAR_POINTS;
                }
            }
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_GIVE_STAR_POINTS) {
        if (battleStatus->totalStarPoints != 0) {
            s32 deltaSP;
            s32 prevSP;
 
            RunAwayRewardTotal -= RunAwayRewardIncrement;
            prevSP = battleStatus->totalStarPoints;
            battleStatus->totalStarPoints = RunAwayRewardTotal / 100;
            deltaSP = prevSP - battleStatus->totalStarPoints;
 
            if (deltaSP > 0) {
                sfx_play_sound(SOUND_COIN_PICKUP);
            }
            playerData->starPoints += deltaSP;
            BattleScreenFadeAmt++;
            if (RunAwayRewardStep == 0 && battleStatus->totalStarPoints != 0) {
                playerData->starPoints++;
            }
        }
        if (playerData->starPoints >= 99) {
            playerData->starPoints = 99;
        }
        if (battleStatus->totalStarPoints == 0) {
            if (RunAwayRewardStep != 0) {
                RunAwayRewardStep--;
            } else {
                status_bar_stop_blinking_starpoints();
                btl_stop_blinking_starpoints();
                gBattleSubState = BTL_SUBSTATE_DONE;
            }
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_DONE) {
        playerData->battlesFled++;
        if (!(gBattleStatus.flags2 & BS_FLAGS2_DONT_STOP_MUSIC)) {
            bgm_set_song(0, -1, 0, 1500, 8);
        }
        btl_set_state(BATTLE_STATE_END_BATTLE);
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_EXEC_POST_FAILURE:
            battleStatus->battlePhase = PHASE_RUN_AWAY_FAIL;
            script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            player->takeTurnScript = script;
            player->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
            if (partner != NULL && partner->koStatus == 0) {
                script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
                partner->takeTurnScript = script;
                partner->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
            }
            gBattleSubState = BTL_SUBSTATE_AWAIT_POST_FAILURE;
            break;
        case BTL_SUBSTATE_AWAIT_POST_FAILURE:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
                return;
            }
            if (!does_script_exist(player->takeTurnScriptID)
                && (partner == NULL || !does_script_exist(partner->takeTurnScriptID))
                && battleStatus->stateFreezeCount == 0
            ) {
                btl_set_state(BATTLE_STATE_TRANSFER_TURN);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_run_away()

void btl_state_draw_run_away ( void )

Definition at line 182 of file run_away.c.

182 {

183}

Referenced by btl_draw_ui().

◆ btl_state_update_defeat()

void btl_state_update_defeat ( void )

Definition at line 11 of file defeat.c.

                                   {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Evt* script;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            battleStatus->flags1 &= ~BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
            battleStatus->stateFreezeCount = 0;
 
            // clear player debuffs
            if (player->debuff != 0) {
                if (player->debuff == STATUS_KEY_FROZEN) {
                    sfx_play_sound(SOUND_FROZEN_SHATTER);
                    player->icePillarEffect->flags |= FX_INSTANCE_FLAG_DISMISS;
                    player->icePillarEffect = NULL;
                }
                player->debuff = 0;
                player->debuffDuration = 0;
                remove_status_debuff(player->hudElementDataIndex);
                player->koStatus = 0;
                player->koDuration = 0;
                player->disableEffect->data.disableX->koDuration = 0;
            }
 
            btl_cam_use_preset(BTL_CAM_PLAYER_FLEE);
            btl_cam_target_actor(ACTOR_PLAYER);
 
            // prompt player to handle PHASE_DEATH
            battleStatus->battlePhase = PHASE_DEATH;
            script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            player->takeTurnScript = script;
            player->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
 
            // prompt partner to handle PHASE_DEATH
            if (partner != NULL) {
                script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
                partner->takeTurnScript = script;
                partner->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
            }
            gBattleSubState = BTL_SUBSTATE_CHECK_LIFE_SHROOM;
            break;
        case BTL_SUBSTATE_CHECK_LIFE_SHROOM:
            // wait for player PHASE_DEATH event to complete (ignore partner script)
            if (does_script_exist(player->takeTurnScriptID) || battleStatus->stateFreezeCount != 0) {
                break;
            }
            if (find_item(ITEM_LIFE_SHROOM) >= 0) {
                // prompt player to handle PHASE_USE_LIFE_SHROOM
                battleStatus->battlePhase = PHASE_USE_LIFE_SHROOM;
                script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
                player->takeTurnScript = script;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
                gBattleSubState = BTL_SUBSTATE_AWAIT_LIFE_SHROOM;
            } else {
                gBattleSubState = BTL_SUBSTATE_DONE;
            }
            break;
        case BTL_SUBSTATE_AWAIT_LIFE_SHROOM:
            // wait for player PHASE_USE_LIFE_SHROOM event to complete
            if (does_script_exist(player->takeTurnScriptID) || battleStatus->stateFreezeCount != 0) {
                break;
            }
            // never reached if life shroom is successful. its item script calls RestorePreDefeatState,
            // resetting the state to BATTLE_STATE_ENEMY_MOVE (based on the value of gDefeatedBattleState)
            gBattleSubState = BTL_SUBSTATE_DONE;
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_DONE) {
        gCurrentEncounter.battleOutcome = OUTCOME_PLAYER_LOST;
        if (!(gBattleStatus.flags2 & BS_FLAGS2_DONT_STOP_MUSIC)) {
            bgm_set_song(0, -1, 0, 1500, 8);
        }
        btl_set_state(BATTLE_STATE_END_BATTLE);
    }
}

Referenced by btl_update().

◆ btl_state_draw_defeat()

void btl_state_draw_defeat ( void )

Definition at line 97 of file defeat.c.

97 {

98}

Referenced by btl_draw_ui().

◆ btl_state_update_change_partner()

void btl_state_update_change_partner ( void )

Definition at line 66 of file change_partner.c.

                                           {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Actor* enemyActor;
    Evt* script;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            battleStatus->stateFreezeCount = 0;
            gBattleStatus.flags2 |= BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
            btl_cam_use_preset(BTL_CAM_REPOSITION);
            btl_cam_set_target_pos(-89.0, 40.0, -99.0);
            btl_cam_set_zoom(372);
            btl_cam_set_zoffset(0);
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    enemyActor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                    enemyActor->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
                }
            }
 
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] = -1;
            BattleSubstateDelay = 10;
            gBattleSubState = BTL_SUBSTATE_EXEC_PUT_AWAY;
 
            // fallthrough
        case BTL_SUBSTATE_EXEC_PUT_AWAY:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
                break;
            }
            deduct_current_move_fp();
            script = start_script(&EVS_BtlPutPartnerAway, EVT_PRIORITY_A, 0);
            battleStatus->controlScript = script;
            battleStatus->controlScriptID = script->id;
            script->owner1.actorID = ACTOR_PARTNER;
            player->state.unk_18.x = partner->curPos.x;
            player->state.unk_18.y = 0.0f;
            player->state.unk_18.z = partner->curPos.z;
            gBattleSubState = BTL_SUBSTATE_LOAD_NEW_PARTNER;
            break;
        case BTL_SUBSTATE_LOAD_NEW_PARTNER:
            if (does_script_exist(battleStatus->controlScriptID)) {
                break;
            }
            btl_delete_actor(partner);
            gPlayerData.curPartner = battleStatus->lastSelectedPartner;
            load_partner_actor();
            partner = battleStatus->partnerActor;
            partner->scale.x = 0.1f;
            partner->scale.y = 0.1f;
            partner->scale.z = 0.1f;
            partner->state.goalPos.x = player->state.unk_18.x;
            partner->state.goalPos.y = partner->curPos.y;
            partner->state.goalPos.z = player->state.unk_18.z;
            partner->curPos.x = player->curPos.x;
            partner->curPos.y = player->curPos.y + 25.0f;
            partner->curPos.z = player->curPos.z;
            gBattleSubState = BTL_SUBSTATE_EXEC_BRING_OUT;
            break;
        case BTL_SUBSTATE_EXEC_BRING_OUT:
            partner = battleStatus->partnerActor;
            if (partner != NULL) {
                if (does_script_exist(partner->takeTurnScriptID)) {
                    break;
                }
                partner->takeTurnScript = NULL;
            }
 
            script = start_script(&EVS_BtlBringPartnerOut, EVT_PRIORITY_A, 0);
            battleStatus->controlScript = script;
            battleStatus->controlScriptID = script->id;
            script->owner1.actorID = ACTOR_PARTNER;
            gBattleSubState = BTL_SUBSTATE_EXEC_PHASE;
            break;
        case BTL_SUBSTATE_EXEC_PHASE:
            if (does_script_exist(battleStatus->controlScriptID)) {
                break;
            }
            partner = battleStatus->partnerActor;
            if (partner != NULL) {
                if (partner->handlePhaseSource != NULL) {
                    battleStatus->battlePhase = PHASE_PLAYER_BEGIN;
                    script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
                    partner->handlePhaseScript = script;
                    partner->handlePhaseScriptID = script->id;
                    script->owner1.actorID = ACTOR_PARTNER;
                }
            }
            gBattleSubState = BTL_SUBSTATE_AWAIT_PHASE;
            break;
        case BTL_SUBSTATE_AWAIT_PHASE:
            partner = battleStatus->partnerActor;
            if (partner != NULL) {
                if (partner->handlePhaseSource != NULL && does_script_exist(partner->handlePhaseScriptID)) {
                    break;
                }
            }
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            gBattleSubState = BTL_SUBSTATE_DONE;
            break;
        case BTL_SUBSTATE_DONE:
            if (battleStatus->stateFreezeCount != 0) {
                break;
            }
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
            if (gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING) {
                if (player_team_is_ability_active(player, ABILITY_QUICK_CHANGE)) {
                    btl_set_state(BATTLE_STATE_PREPARE_MENU);
                } else {
                    btl_set_state(BATTLE_STATE_END_PARTNER_TURN);
                }
            } else {
                if (player_team_is_ability_active(player, ABILITY_QUICK_CHANGE)) {
                    btl_set_state(BATTLE_STATE_PREPARE_MENU);
                } else {
                    btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
                }
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_change_partner()

void btl_state_draw_change_partner ( void )

Definition at line 196 of file change_partner.c.

196 {

197}

Referenced by btl_draw_ui().

◆ btl_state_update_player_move()

void btl_state_update_player_move ( void )

Definition at line 19 of file player_move.c.

                                        {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    s32 messageIndex;
    Actor* actor;
    Evt* script;
    s32 enemyNotDone;
    s8 tipIndex;
    s32 i;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        battleStatus->stateFreezeCount = 0;
        battleStatus->actionResult = ACTION_RESULT_NONE;
        battleStatus->blockResult = BLOCK_RESULT_NONE;
        battleStatus->lastAttackDamage = 0;
        battleStatus->curDamageSource = DMG_SRC_DEFAULT;
        gBattleStatus.flags1 &= ~BS_FLAGS1_AUTO_SUCCEED_ACTION;
        gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
        reset_actor_turn_info();
        player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
        if (partner != NULL) {
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
        }
        btl_cam_target_actor(ACTOR_PLAYER);
        gBattleStatus.flags1 &= ~BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
        player->statusAfflicted = 0;
        gBattleStatus.flags2 |= BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
        gBattleStatus.flags1 &= ~BS_FLAGS1_YIELD_TURN;
 
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL) {
                actor->statusAfflicted = 0;
            }
        }
 
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL) {
                actor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                actor->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
        }
 
        if (battleStatus->moveCategory == BTL_MENU_TYPE_JUMP || battleStatus->moveCategory == BTL_MENU_TYPE_SMASH) {
            if (battleStatus->nextMerleeSpellType == MERLEE_SPELL_ATK_BOOST) {
                battleStatus->merleeAttackBoost = 3;
                battleStatus->nextMerleeSpellType = MERLEE_SPELL_NONE;
                battleStatus->battlePhase = PHASE_MERLEE_ATTACK_BONUS;
                script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
                player->takeTurnScript = script;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
                gBattleStatus.flags1 |= BS_FLAGS1_10000;
                close_action_command_instruction_popup();
                gBattleSubState = BTL_SUBSTATE_BEGIN_SHOW_TIP;
            } else {
                gBattleSubState = BTL_SUBSTATE_EXECUTE_MOVE;
                gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            }
        } else {
            gBattleSubState = BTL_SUBSTATE_EXECUTE_MOVE;
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
        }
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_BEGIN_SHOW_TIP:
            if (player->takeTurnScript != NULL && does_script_exist(player->takeTurnScriptID)) {
                break;
            }
            player->takeTurnScript = NULL;
            if (!is_ability_active(ABILITY_BERSERKER)) {
                if (battleStatus->selectedMoveID != MOVE_NONE) {
                    tipIndex = gMoveTable[battleStatus->selectedMoveID].actionTip;
                    if (tipIndex >= 0) {
                        btl_show_battle_message(BTL_MSG_FIRST_ACTION_TIP + tipIndex, 60);
                    }
                }
            }
            BattleSubstateDelay = 2;
            gBattleSubState = BTL_SUBSTATE_SHOW_TIP_DELAY;
            break;
        case BTL_SUBSTATE_SHOW_TIP_DELAY:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_EXECUTE_MOVE;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_EXECUTE_MOVE:
            gBattleStatus.flags1 &= ~BS_FLAGS1_4000;
            gBattleStatus.flags1 &= ~BS_FLAGS1_10000;
            increment_status_bar_disabled();
            gBattleStatus.flags1 |= BS_FLAGS1_EXECUTING_MOVE;
            reset_all_actor_sounds(player);
            battleStatus->battlePhase = PHASE_EXECUTE_ACTION;
            if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                script = start_script(&EVS_Peach_HandlePhase, EVT_PRIORITY_A, 0);
            } else {
                script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            }
            player->takeTurnScript = script;
            gBattleSubState = BTL_SUBSTATE_HANDLE_RESULTS;
            player->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
            break;
        case BTL_SUBSTATE_HANDLE_RESULTS:
            // wait for player battle phase script to finish
            if (!(gBattleStatus.flags1 & BS_FLAGS1_YIELD_TURN)) {
                if (player->takeTurnScript != NULL && does_script_exist(player->takeTurnScriptID)) {
                    break;
                }
                player->takeTurnScript = NULL;
            }
 
            gBattleStatus.flags1 &= ~BS_FLAGS1_EXECUTING_MOVE;
 
             // wait for player battle event script to finish
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            // wait for partner battle event script to finish
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
 
            // wait for all enemy battle phase scripts to finish
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->takeTurnScript != NULL) {
                    if (does_script_exist(actor->takeTurnScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        actor->takeTurnScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            // wait for all enemy battle event scripts to finish
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->handleEventScript != NULL) {
                    if (does_script_exist(actor->handleEventScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        actor->handleEventScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL) {
                    actor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
 
            if (battleStatus->stateFreezeCount != 0) {
                break;
            }
 
            if (gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED) {
                btl_set_state(BATTLE_STATE_END_DEMO_BATTLE);
                break;
            }
 
            decrement_status_bar_disabled();
            gBattleStatus.flags1 |= BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            if (btl_check_player_defeated()) {
                return;
            }
 
            if ((battleStatus->moveCategory == BTL_MENU_TYPE_SMASH)
                && (battleStatus->selectedMoveID != MOVE_SMASH_CHARGE0)
                && (battleStatus->selectedMoveID != MOVE_SMASH_CHARGE)
                && (battleStatus->selectedMoveID != MOVE_SUPER_SMASH_CHARGE)
            ) {
                gBattleStatus.flags1 &= ~BS_FLAGS1_HAMMER_CHARGED;
            }
 
            if ((battleStatus->moveCategory == BTL_MENU_TYPE_JUMP)
                && (battleStatus->selectedMoveID != MOVE_JUMP_CHARGE0)
                && (battleStatus->selectedMoveID != MOVE_JUMP_CHARGE)
                && (battleStatus->selectedMoveID != MOVE_SUPER_JUMP_CHARGE)
            ) {
                gBattleStatus.flags1 &= ~BS_FLAGS1_JUMP_CHARGED;
            }
 
            if (!(gBattleStatus.flags1 & BS_FLAGS1_JUMP_CHARGED)) {
                battleStatus->jumpCharge = 0;
            }
            if (!(gBattleStatus.flags1 & BS_FLAGS1_HAMMER_CHARGED)) {
                battleStatus->hammerCharge = 0;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && !(actor->flags & ACTOR_FLAG_NO_DMG_APPLY)) {
                    actor->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                }
            }
 
            btl_update_ko_status();
 
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL) {
                    if (actor->statusAfflicted != 0) {
                        enemyNotDone = TRUE;
                        break;
                    }
                }
            }
 
            if (!enemyNotDone) {
                gBattleSubState = BTL_SUBSTATE_CHECK_PLAYER_STATUS;
            } else {
                btl_cam_use_preset(BTL_CAM_VIEW_ENEMIES);
                switch (actor->statusAfflicted) {
                    case STATUS_KEY_DIZZY:
                        messageIndex = BTL_MSG_ENEMY_DAZED;
                        break;
                    case STATUS_KEY_SLEEP:
                        messageIndex = BTL_MSG_ENEMY_ASLEEP;
                        break;
                    case STATUS_KEY_FROZEN:
                        messageIndex = BTL_MSG_ENEMY_FROZEN;
                        break;
                    case STATUS_KEY_POISON:
                        messageIndex = BTL_MSG_ENEMY_POISONED;
                        break;
                    case STATUS_KEY_SHRINK:
                        messageIndex = BTL_MSG_ENEMY_SHRUNK;
                        break;
                    case STATUS_KEY_PARALYZE:
                        messageIndex = BTL_MSG_ENEMY_PARALYZED;
                        break;
                    case STATUS_KEY_STATIC:
                        messageIndex = BTL_MSG_ENEMY_ELECTRIFIED;
                        break;
                    case STATUS_KEY_STOP:
                        messageIndex = BTL_MSG_ENEMY_CANT_MOVE;
                        break;
                    default:
                        messageIndex = 0;
                        gBattleSubState = BTL_SUBSTATE_CHECK_PLAYER_STATUS;
                        break;
                }
                sfx_play_sound(SOUND_INFLICT_KO);
                btl_show_battle_message(messageIndex, 60);
                for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                    actor = battleStatus->enemyActors[i];
                    if (actor != NULL) {
                        actor->statusAfflicted = 0;
                    }
                }
                gBattleSubState = BTL_SUBSTATE_AWAIT_ENEMY_STATUS_POPUP;
            }
            break;
        case BTL_SUBSTATE_AWAIT_ENEMY_STATUS_POPUP:
            if (!btl_is_popup_displayed()) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(15);
                BattleSubstateDelay = 10;
                gBattleSubState = BTL_SUBSTATE_POST_ENEMY_STATUS_POPUP;
            }
            break;
        case BTL_SUBSTATE_POST_ENEMY_STATUS_POPUP:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_CHECK_PLAYER_STATUS;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CHECK_PLAYER_STATUS:
            if (player->statusAfflicted != 0) {
                btl_cam_use_preset(BTL_CAM_PLAYER_STATUS_AFFLICTED);
                switch (player->statusAfflicted) {
                    case STATUS_KEY_DIZZY:
                        messageIndex = BTL_MSG_PLAYER_DAZED;
                        break;
                    case STATUS_KEY_SLEEP:
                        messageIndex = BTL_MSG_PLAYER_ASLEEP;
                        break;
                    case STATUS_KEY_FROZEN:
                        messageIndex = BTL_MSG_PLAYER_FROZEN;
                        break;
                    case STATUS_KEY_POISON:
                        messageIndex = BTL_MSG_PLAYER_POISONED;
                        break;
                    case STATUS_KEY_SHRINK:
                        messageIndex = BTL_MSG_PLAYER_SHRUNK;
                        break;
                    case STATUS_KEY_PARALYZE:
                        messageIndex = BTL_MSG_PLAYER_PARALYZED;
                        break;
                    case STATUS_KEY_STATIC:
                        messageIndex = BTL_MSG_PLAYER_CHARGED;
                        break;
                    default:
                        messageIndex = 0;
                        gBattleSubState = BTL_SUBSTATE_AWAIT_DONE;
                        break;
                }
                btl_show_battle_message(messageIndex, 60);
                player->statusAfflicted = 0;
                player->disableDismissTimer = 0;
                player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
                gBattleSubState = BTL_SUBSTATE_AWAIT_PLAYER_STATUS_POPUP;
 
            } else {
                gBattleSubState = BTL_SUBSTATE_AWAIT_DONE;
            }
            break;
        case BTL_SUBSTATE_AWAIT_PLAYER_STATUS_POPUP:
            if (!btl_is_popup_displayed()) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(15);
                BattleSubstateDelay = 10;
                gBattleSubState = BTL_SUBSTATE_POST_PLAYER_STATUS_POPUP;
            }
            break;
        case BTL_SUBSTATE_POST_PLAYER_STATUS_POPUP:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_AWAIT_DONE;
            }
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_AWAIT_DONE) {
        if (player->takeTurnScript == NULL || !does_script_exist(player->takeTurnScriptID)) {
            player->takeTurnScript = NULL;
            btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
        }
    }
}

Referenced by btl_update().

◆ btl_state_draw_player_move()

void btl_state_draw_player_move ( void )

Definition at line 381 of file player_move.c.

381 {

382}

Referenced by btl_draw_ui().

◆ btl_state_update_end_player_turn()

void btl_state_update_end_player_turn ( void )

Definition at line 68 of file player_turn_end.c.

                                            {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Evt* script;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        btl_substate_try_hpfp_recovery();
        gBattleSubState = BTL_SUBSTATE_AWAIT_RECOVER;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_AWAIT_RECOVER) {
        // if a script is running from 'Happy!', wait for it to complete
        if (player->takeTurnScript != NULL && does_script_exist(player->takeTurnScriptID)) {
            return;
        }
        player->takeTurnScript = NULL;
 
        // force peach to back position after turn end
        if ((gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) && !(gBattleStatus.flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
            player->state.curPos.x = player->homePos.x;
            player->state.curPos.z = player->homePos.z;
            player->state.goalPos.x = partner->homePos.x;
            player->state.goalPos.z = partner->homePos.z;
            player->state.moveTime = 4;
            player->state.angle = 0.0f;
            gBattleSubState = BTL_SUBSTATE_AWAIT_SWAP;
        } else {
            gBattleSubState = BTL_SUBSTATE_DONE;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_AWAIT_SWAP) {
        if (player->state.moveTime != 0) {
            player->curPos.x += (player->state.goalPos.x - player->curPos.x) / player->state.moveTime;
            player->curPos.z += (player->state.goalPos.z - player->curPos.z) / player->state.moveTime;
            partner->curPos.x += (player->state.curPos.x - partner->curPos.x) / player->state.moveTime;
            partner->curPos.z += (player->state.curPos.z - partner->curPos.z) / player->state.moveTime;
        }
        player->curPos.z += sin_rad(DEG_TO_RAD(player->state.angle)) * 16.0f;
        player->yaw = clamp_angle(-player->state.angle);
        partner->curPos.z -= sin_rad(DEG_TO_RAD(player->state.angle)) * 16.0f;
        partner->yaw = clamp_angle(-player->state.angle);
        player->state.angle += 90.0f;
 
        if (player->state.moveTime != 0) {
            player->state.moveTime--;
        } else {
            player->curPos.x = player->state.goalPos.x;
            player->curPos.z = player->state.goalPos.z;
            partner->curPos.x = player->state.curPos.x;
            partner->curPos.z = player->state.curPos.z;
            player->homePos.x = player->curPos.x;
            player->homePos.z = player->curPos.z;
            partner->homePos.x = partner->curPos.x;
            partner->homePos.z = partner->curPos.z;
            gBattleStatus.flags1 |= BS_FLAGS1_PLAYER_IN_BACK;
            gBattleSubState = BTL_SUBSTATE_DONE;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_DONE) {
        // dont bother with command loss if all enemies are defeated
        if(btl_check_enemies_defeated()) {
            return;
        }
 
        if (battleStatus->moveCategory == BTL_MENU_TYPE_ITEMS && battleStatus->itemUsesLeft >= 2) {
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            btl_cam_move(10);
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
        } else {
            gBattleStatus.flags2 |= BS_FLAGS2_PLAYER_TURN_USED;
        }
 
        // if the rest of the turn was canceled, proceed immediately to END_TURN
        if (battleStatus->cancelTurnMode < 0) {
            battleStatus->cancelTurnMode = 0;
            battleStatus->itemUsesLeft = 0;
            btl_set_state(BATTLE_STATE_END_TURN);
            return;
        }
 
        if (battleStatus->itemUsesLeft != 0) {
            battleStatus->itemUsesLeft--;
            if (battleStatus->itemUsesLeft != 0) {
                // double or triple dip has not run out yet, let the player choose another item
                btl_set_state(BATTLE_STATE_PREPARE_MENU);
                gBattleSubState = BTL_SUBSTATE_PLAYER_CONTINUE_DIP;
                return;
            }
 
            if (gBattleStatus.flags1 & BS_FLAGS1_HUSTLED) {
                if (battleStatus->hustleTurns != 0) {
                    battleStatus->hustleTurns--;
                }
            }
 
            if (battleStatus->hustleTurns != 0 && (gBattleStatus.flags1 & BS_FLAGS1_HUSTLED)) {
                gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
                btl_set_state(BATTLE_STATE_PREPARE_MENU);
                return;
            } else {
                gBattleStatus.flags1 &= ~BS_FLAGS1_HUSTLED;
                btl_set_state(BATTLE_STATE_BEGIN_PARTNER_TURN);
                return;
            }
        }
 
        if (gBattleStatus.flags1 & BS_FLAGS1_HUSTLED) {
            if (battleStatus->hustleTurns != 0) {
                battleStatus->hustleTurns--;
            }
        }
 
        if (battleStatus->hustleTurns != 0 && (gBattleStatus.flags1 & BS_FLAGS1_HUSTLED)) {
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            btl_set_state(BATTLE_STATE_PREPARE_MENU);
        } else {
            gBattleStatus.flags1 &= ~BS_FLAGS2_HAS_DRAINED_HP;
            if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                btl_set_state(BATTLE_STATE_TRANSFER_TURN);
            } else {
                btl_set_state(BATTLE_STATE_BEGIN_PARTNER_TURN);
            }
        }
    }
}

Referenced by btl_update().

◆ btl_state_update_partner_move()

void btl_state_update_partner_move ( void )

Definition at line 15 of file partner_move.c.

                                         {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Actor* enemyActor;
    Evt* script;
    s32 enemyFound;
    s32 messageIndex;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            if (partner == NULL) {
                btl_set_state(BATTLE_STATE_TRANSFER_TURN);
                break;
            }
            battleStatus->stateFreezeCount = 0;
            battleStatus->actionResult = ACTION_RESULT_NONE;
            battleStatus->blockResult = BLOCK_RESULT_NONE;
            battleStatus->curDamageSource = DMG_SRC_DEFAULT;
            gBattleStatus.flags1 &= ~BS_FLAGS1_AUTO_SUCCEED_ACTION;
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            reset_actor_turn_info();
            partner->statusAfflicted = 0;
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            deduct_current_move_fp();
            btl_cam_target_actor(ACTOR_PARTNER);
            gBattleStatus.flags2 |= BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
            gBattleStatus.flags1 &= ~BS_FLAGS1_YIELD_TURN;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    enemyActor->statusAfflicted = 0;
                }
            }
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            gBattleSubState = BTL_SUBSTATE_EXECUTE_MOVE;
            break;
        case BTL_SUBSTATE_EXECUTE_MOVE:
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    enemyActor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                    enemyActor->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
                }
            }
 
            increment_status_bar_disabled();
            gBattleStatus.flags1 |= BS_FLAGS1_EXECUTING_MOVE;
            reset_actor_turn_info();
            reset_all_actor_sounds(partner);
            battleStatus->battlePhase = PHASE_EXECUTE_ACTION;
            script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
            partner->takeTurnScript = script;
            partner->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PARTNER;
            gBattleSubState = BTL_SUBSTATE_HANDLE_RESULTS;
            break;
        case BTL_SUBSTATE_HANDLE_RESULTS:
            if (!(gBattleStatus.flags1 & BS_FLAGS1_YIELD_TURN)) {
                if (partner->takeTurnScript != NULL && does_script_exist(partner->takeTurnScriptID)) {
                    break;
                }
                partner->takeTurnScript = NULL;
            }
            gBattleStatus.flags1 &= ~BS_FLAGS1_EXECUTING_MOVE;
 
            if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                break;
            }
            partner->handleEventScript = NULL;
 
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            enemyFound = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL && enemyActor->takeTurnScript != NULL) {
                    if (does_script_exist(enemyActor->takeTurnScriptID)) {
                        enemyFound = TRUE;
                    } else {
                        enemyActor->takeTurnScript = NULL;
                    }
                }
            }
            if (enemyFound) {
                break;
            }
 
            enemyFound = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL && enemyActor->handleEventScript != NULL) {
                    if (does_script_exist(enemyActor->handleEventScriptID)) {
                        enemyFound = TRUE;
                    } else {
                        enemyActor->handleEventScript = NULL;
                    }
                }
            }
            if (enemyFound) {
                break;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    enemyActor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
 
            if (battleStatus->stateFreezeCount != 0) {
                break;
            }
 
            if (gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED) {
                btl_set_state(BATTLE_STATE_END_DEMO_BATTLE);
                break;
            }
            decrement_status_bar_disabled();
            if (playerData->curPartner == PARTNER_GOOMBARIO
                    && battleStatus->moveCategory == BTL_MENU_TYPE_CHANGE_PARTNER
                    && battleStatus->selectedMoveID != MOVE_CHARGE) {
                partner->isGlowing = FALSE;
                gBattleStatus.flags1 &= ~BS_FLAGS1_GOOMBARIO_CHARGED;
            }
            if (btl_check_player_defeated()) {
                return;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    if (!(enemyActor->flags & ACTOR_FLAG_NO_DMG_APPLY)) {
                        enemyActor->flags |= (ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
                    }
                }
            }
 
            btl_update_ko_status();
 
            if (partner->statusAfflicted == STATUS_KEY_KO && !btl_are_all_enemies_defeated()) {
                btl_cam_use_preset(BTL_CAM_PARTNER_INJURED);
                btl_show_battle_message(BTL_MSG_PARTNER_INJURED, 60);
                partner->statusAfflicted = 0;
                partner->disableDismissTimer = 0;
                gBattleSubState = BTL_SUBSTATE_AWAIT_PARTNER_STATUS_POPUP;
                partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            } else {
                gBattleSubState = BTL_SUBSTATE_CHECK_ENEMY_STATUS;
            }
            break;
        case BTL_SUBSTATE_AWAIT_PARTNER_STATUS_POPUP:
            if (btl_is_popup_displayed()) {
                break;
            }
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            btl_cam_move(15);
            BattleSubstateDelay = 10;
            gBattleSubState = BTL_SUBSTATE_POST_PARTNER_STATUS_POPUP;
            break;
        case BTL_SUBSTATE_POST_PARTNER_STATUS_POPUP:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_CHECK_ENEMY_STATUS;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CHECK_ENEMY_STATUS:
            enemyFound = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    if (enemyActor->statusAfflicted != 0) {
                        enemyFound = TRUE;
                        break;
                    }
                }
            }
            if (!enemyFound) {
                gBattleSubState = BTL_SUBSTATE_DONE;
                break;
            }
 
            btl_cam_use_preset(BTL_CAM_VIEW_ENEMIES);
            switch (enemyActor->statusAfflicted) {
                case STATUS_KEY_DIZZY:
                    messageIndex = BTL_MSG_ENEMY_DAZED;
                    break;
                case STATUS_KEY_SLEEP:
                    messageIndex = BTL_MSG_ENEMY_ASLEEP;
                    break;
                case STATUS_KEY_FROZEN:
                    messageIndex = BTL_MSG_ENEMY_FROZEN;
                    break;
                case STATUS_KEY_POISON:
                    messageIndex = BTL_MSG_ENEMY_POISONED;
                    break;
                case STATUS_KEY_SHRINK:
                    messageIndex = BTL_MSG_ENEMY_SHRUNK;
                    break;
                case STATUS_KEY_PARALYZE:
                    messageIndex = BTL_MSG_ENEMY_PARALYZED;
                    break;
                case STATUS_KEY_STATIC:
                    messageIndex = BTL_MSG_ENEMY_ELECTRIFIED;
                    break;
                case STATUS_KEY_STOP:
                    messageIndex = BTL_MSG_ENEMY_CANT_MOVE;
                    break;
                default:
                    messageIndex = 0;
                    gBattleSubState = BTL_SUBSTATE_CHECK_ENEMY_STATUS;
                    break;
            }
 
            sfx_play_sound(SOUND_INFLICT_KO);
            btl_show_battle_message(messageIndex, 60);
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    enemyActor->statusAfflicted = 0;
                }
            }
            gBattleSubState = BTL_SUBSTATE_AWAIT_ENEMY_STATUS_POPUP;
            break;
        case BTL_SUBSTATE_AWAIT_ENEMY_STATUS_POPUP:
            if (btl_is_popup_displayed() == FALSE) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(15);
                BattleSubstateDelay = 10;
                gBattleSubState = BTL_SUBSTATE_POST_ENEMY_STATUS_POPUP;
            }
            break;
        case BTL_SUBSTATE_POST_ENEMY_STATUS_POPUP:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_DONE;
            }
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_DONE) {
        if (partner->takeTurnScript != NULL && does_script_exist(partner->takeTurnScriptID)) {
            return;
        }
        partner->takeTurnScript = NULL;
        btl_set_state(BATTLE_STATE_END_PARTNER_TURN);
    }
}

Referenced by btl_update().

◆ btl_state_draw_end_player_turn()

void btl_state_draw_end_player_turn ( void )

Definition at line 197 of file player_turn_end.c.

197 {

198}

Referenced by btl_draw_ui().

◆ btl_state_draw_partner_move()

void btl_state_draw_partner_move ( void )

Definition at line 277 of file partner_move.c.

277 {

278}

Referenced by btl_draw_ui().

◆ btl_state_update_end_partner_turn()

void btl_state_update_end_partner_turn ( void )

Definition at line 3 of file partner_turn_end.c.

                                             {
    BattleStatus* battleStatus = &gBattleStatus;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        battleStatus->flags2 |= BS_FLAGS2_PARTNER_TURN_USED;
        if (btl_check_enemies_defeated()) {
            return;
        }
        battleStatus->flags1 &= ~BS_FLAGS1_PARTNER_ACTING;
        battleStatus->flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
 
        if (battleStatus->cancelTurnMode < 0) {
            battleStatus->cancelTurnMode = 0;
            btl_set_state(BATTLE_STATE_END_TURN);
        } else {
            btl_set_state(BATTLE_STATE_TRANSFER_TURN);
        }
    }
}

Referenced by btl_update().

◆ btl_state_draw_end_partner_turn()

void btl_state_draw_end_partner_turn ( void )

Definition at line 23 of file partner_turn_end.c.

23 {

24}

Referenced by btl_draw_ui().

◆ btl_state_update_next_enemy()

void btl_state_update_next_enemy ( void )

Definition at line 11 of file enemy_next.c.

                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = gBattleStatus.playerActor;
    Actor* partner = gBattleStatus.partnerActor;
    Actor* enemy;
    s32 skipEnemy;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
        case BTL_SUBSTATE_UNUSED_1:
            i = battleStatus->nextEnemyIndex;
            if (i >= battleStatus->numEnemyActors) {
                // all enemies have been exhausted
                battleStatus->nextEnemyIndex = 0;
                btl_set_state(BATTLE_STATE_END_TURN);
                return;
            }
 
            // find the next eligible enemy
            while (TRUE) {
                if (battleStatus->enemyIDs[i] >= 0) {
                    u16 enemyID = battleStatus->enemyIDs[i];
 
                    enemy = battleStatus->enemyActors[enemyID & 0xFF];
                    if (enemy != NULL) {
                        if (!(enemy->flags & (ACTOR_FLAG_NO_ATTACK | ACTOR_FLAG_TARGET_ONLY))) {
                            break;
                        }
                    }
                }
                i++;
                if (i >= battleStatus->numEnemyActors) {
                    i = 0;
                }
                if (i == 0) {
                    battleStatus->nextEnemyIndex = 0;
                    btl_set_state(BATTLE_STATE_END_TURN);
                    return;
                }
            }
 
            battleStatus->activeEnemyActorID = battleStatus->enemyIDs[i++];
            battleStatus->curTurnEnemy = enemy;
            battleStatus->nextEnemyIndex = i;
 
            skipEnemy = FALSE;
 
            if (enemy->debuff == STATUS_KEY_SLEEP) {
                skipEnemy = TRUE;
            }
            if (enemy->debuff == STATUS_KEY_UNUSED) {
                skipEnemy = TRUE;
            }
            if (enemy->debuff == STATUS_KEY_DIZZY) {
                skipEnemy = TRUE;
            }
            if (enemy->debuff == STATUS_KEY_PARALYZE) {
                skipEnemy = TRUE;
            }
            if (enemy->debuff == STATUS_KEY_FROZEN) {
                skipEnemy = TRUE;
            }
            if (enemy->debuff == STATUS_KEY_STOP) {
                skipEnemy = TRUE;
            }
            if (enemy->stoneStatus == STATUS_KEY_STONE) {
                skipEnemy = TRUE;
            }
            if (enemy->flags & ACTOR_FLAG_SKIP_TURN) {
                skipEnemy = TRUE;
            }
 
            if (skipEnemy) {
                // reset state to fetch next enemy
                gBattleSubState = BTL_SUBSTATE_INIT;
                return;
            }
 
            battleStatus->stateFreezeCount = 0;
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            gBattleStatus.flags1 &= ~BS_FLAGS1_BATTLE_FLED;
            gBattleStatus.flags1 &= ~BS_FLAGS1_AUTO_SUCCEED_ACTION;
            gBattleStatus.flags1 &= ~BS_FLAGS1_PARTNER_ACTING;
 
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            player->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
 
            if (partner != NULL) {
                partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
                partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            }
 
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 |= BS_FLAGS2_HIDE_BUFF_COUNTERS;
 
            NextEnemyWaitingOrdinal = enemy->ordinal;
            if (enemy->handlePhaseSource != NULL) {
                Evt* onTurnChanceScript;
 
                battleStatus->battlePhase = PHASE_ENEMY_BEGIN;
                onTurnChanceScript = start_script(enemy->handlePhaseSource, EVT_PRIORITY_A, 0);
                enemy->handlePhaseScript = onTurnChanceScript;
                enemy->handlePhaseScriptID = onTurnChanceScript->id;
                onTurnChanceScript->owner1.actorID = battleStatus->activeEnemyActorID;
            }
            gBattleSubState = BTL_SUBSTATE_DONE;
            break;
        case BTL_SUBSTATE_DONE:
            if (battleStatus->stateFreezeCount == 0) {
                enemy = get_actor(battleStatus->activeEnemyActorID);
 
                if (enemy == NULL || enemy->ordinal != NextEnemyWaitingOrdinal) {
                    btl_set_state(BATTLE_STATE_NEXT_ENEMY);
                } else {
                    if (enemy->handlePhaseSource == NULL || !does_script_exist(enemy->handlePhaseScriptID)) {
                        if (battleStatus->cancelTurnMode < 0) {
                            battleStatus->cancelTurnMode = 0;
                            btl_set_state(BATTLE_STATE_END_TURN);
                        } else {
                            btl_set_state(BATTLE_STATE_ENEMY_MOVE);
                        }
                    }
                }
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_next_enemy()

void btl_state_draw_next_enemy ( void )

Definition at line 141 of file enemy_next.c.

141 {

142}

Referenced by btl_draw_ui().

◆ btl_state_update_enemy_move()

void btl_state_update_enemy_move ( void )

Definition at line 15 of file enemy_move.c.

                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = gBattleStatus.playerActor;
    Actor* partner = gBattleStatus.partnerActor;
    Actor* enemy;
    s32 i;
 
    Evt* script;
    s32 messageIndex;
    s32 waitingForEnemyScript;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_EXECUTE:
        case BTL_SUBSTATE_UNUSED_1:
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            gBattleStatus.flags1 &= ~BS_FLAGS1_YIELD_TURN;
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            if (partner != NULL) {
                partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
            battleStatus->stateFreezeCount = 0;
            battleStatus->lastAttackDamage = 0;
            battleStatus->actionQuality = 0;
            battleStatus->actionResult = ACTION_RESULT_NONE;
            battleStatus->blockResult = BLOCK_RESULT_NONE;
            battleStatus->curDamageSource = DMG_SRC_DEFAULT;
            reset_actor_turn_info();
            gBattleStatus.flags1 |= BS_FLAGS1_EXECUTING_MOVE;
            player->statusAfflicted = 0;
            if (partner != NULL) {
                partner->statusAfflicted = 0;
            }
 
            gBattleStatus.flags2 |= BS_FLAGS2_IGNORE_DARKNESS;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL) {
                    enemy->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL) {
                    if (!(enemy->flags & ACTOR_FLAG_NO_DMG_APPLY)) {
                        enemy->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
                    }
                }
            }
 
            enemy = battleStatus->curTurnEnemy;
            if (!(enemy->flags & ACTOR_FLAG_NO_ATTACK)) {
                reset_all_actor_sounds(enemy);
                battleStatus->battlePhase = PHASE_EXECUTE_ACTION;
                script = start_script(enemy->takeTurnSource, EVT_PRIORITY_A, 0);
                enemy->takeTurnScript = script;
                enemy->takeTurnScriptID = script->id;
                script->owner1.actorID = battleStatus->activeEnemyActorID;
            }
            gBattleSubState = BTL_SUBSTATE_AWAIT_SCRIPTS;
            break;
        case BTL_SUBSTATE_AWAIT_SCRIPTS:
            if (player->takeTurnScript != NULL && does_script_exist(player->takeTurnScriptID)) {
                break;
            }
            player->takeTurnScript = NULL;
 
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
 
            waitingForEnemyScript = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->handleEventScript != NULL) {
                    if (does_script_exist(enemy->handleEventScriptID)) {
                        waitingForEnemyScript = TRUE;
                    } else {
                        enemy->handleEventScript = NULL;
                    }
                }
            }
 
            if (waitingForEnemyScript) {
                break;
            }
 
            if (btl_check_player_defeated()) {
                return;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->takeTurnScript != NULL) {
                    if (does_script_exist(enemy->takeTurnScriptID)) {
                        waitingForEnemyScript = TRUE;
                    } else {
                        enemy->takeTurnScript = NULL;
                    }
                }
            }
 
            if (waitingForEnemyScript && !(gBattleStatus.flags1 & BS_FLAGS1_YIELD_TURN)) {
                break;
            }
 
            gBattleStatus.flags1 &= ~BS_FLAGS1_EXECUTING_MOVE;
            gBattleStatus.flags2 &= ~BS_FLAGS2_IGNORE_DARKNESS;
            if (btl_check_enemies_defeated()) {
                return;
            }
 
            if (battleStatus->stateFreezeCount != 0) {
                break;
            }
 
            if (gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED) {
                btl_set_state(BATTLE_STATE_END_DEMO_BATTLE);
            } else {
                btl_update_ko_status();
                if (player->statusAfflicted != 0) {
                    player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                    if (partner != NULL) {
                        partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                    }
                    btl_cam_use_preset(BTL_CAM_PLAYER_STATUS_AFFLICTED);
 
                    switch (player->statusAfflicted) {
                        case STATUS_KEY_DIZZY:
                            messageIndex = BTL_MSG_PLAYER_DAZED;
                            break;
                        case STATUS_KEY_SLEEP:
                            messageIndex = BTL_MSG_PLAYER_ASLEEP;
                            break;
                        case STATUS_KEY_FROZEN:
                            messageIndex = BTL_MSG_PLAYER_FROZEN;
                            break;
                        case STATUS_KEY_POISON:
                            messageIndex = BTL_MSG_PLAYER_POISONED;
                            break;
                        case STATUS_KEY_SHRINK:
                            messageIndex = BTL_MSG_PLAYER_SHRUNK;
                            break;
                        case STATUS_KEY_PARALYZE:
                            messageIndex = BTL_MSG_PLAYER_PARALYZED;
                            break;
                        default:
                            messageIndex = 0;
                            gBattleSubState = BTL_SUBSTATE_CHECK_PARTNER;
                            break;
                    }
                    btl_show_battle_message(messageIndex, 60);
                    player->statusAfflicted = 0;
                    gBattleSubState = BTL_SUBSTATE_AWAIT_PLAYER_POPUP_DONE;
                    break;
                } else {
                    gBattleSubState = BTL_SUBSTATE_CHECK_PARTNER;
                    break;
                }
            }
            break;
        case BTL_SUBSTATE_AWAIT_PLAYER_POPUP_DONE:
            if (!btl_is_popup_displayed()) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(15);
                BattleSubstateDelay = 10;
                gBattleSubState = BTL_SUBSTATE_POST_PLAYER_POPUP_DELAY;
            }
            break;
        case BTL_SUBSTATE_POST_PLAYER_POPUP_DELAY:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_CHECK_PARTNER;
                break;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CHECK_PARTNER:
            if (partner != NULL) {
                if (partner->statusAfflicted == STATUS_KEY_KO) {
                    player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                    partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                    btl_cam_use_preset(BTL_CAM_PARTNER_INJURED);
                    btl_show_battle_message(BTL_MSG_PARTNER_INJURED, 60);
                    partner->statusAfflicted = 0;
                    gBattleSubState = BTL_SUBSTATE_AWAIT_PARTNER_POPUP_DONE;
                } else {
                    gBattleSubState = BTL_SUBSTATE_DONE;
                }
            } else {
                gBattleSubState = BTL_SUBSTATE_DONE;
            }
            break;
        case BTL_SUBSTATE_AWAIT_PARTNER_POPUP_DONE:
            if (!btl_is_popup_displayed()) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(15);
                BattleSubstateDelay = 10;
                gBattleSubState = BTL_SUBSTATE_POST_PARTNER_POPUP_DELAY;
            }
            break;
        case BTL_SUBSTATE_POST_PARTNER_POPUP_DELAY:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_DONE;
            }
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_DONE) {
        btl_set_state(BATTLE_STATE_NEXT_ENEMY);
    }
}

Referenced by btl_update().

◆ btl_state_draw_enemy_move()

void btl_state_draw_enemy_move ( void )

Definition at line 241 of file enemy_move.c.

241 {

242}

Referenced by btl_draw_ui().

◆ btl_state_update_first_strike()

void btl_state_update_first_strike ( void )

Definition at line 13 of file player_first_strike.c.

                                         {
    PlayerData* playerData = &gPlayerData;
    BattleStatus* battleStatus = &gBattleStatus;
    EncounterStatus* encounterStatus = &gCurrentEncounter;
    Actor* player = gBattleStatus.playerActor;
    Actor* partner = gBattleStatus.partnerActor;
    Evt* script;
    Actor* enemy;
    s32 enemyNotDone;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            BattleCanShowFirstStrike = FALSE;
            btl_merlee_on_first_strike();
            if (playerData->playerFirstStrikes < 9999) {
                playerData->playerFirstStrikes++;
            }
 
            // clear rush flags to initialize
            battleStatus->rushFlags = RUSH_FLAG_NONE;
            gBattleStatus.flags2 &= ~BS_FLAGS2_HAS_RUSH;
 
            // set rush flags based on danger/peril status
            if (!(gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE)) {
                if (playerData->curHP <= PERIL_THRESHOLD && is_ability_active(ABILITY_MEGA_RUSH)) {
                    gBattleStatus.flags2 |= BS_FLAGS2_HAS_RUSH;
                    battleStatus->rushFlags |= RUSH_FLAG_MEGA;
                }
                if (playerData->curHP <= DANGER_THRESHOLD && is_ability_active(ABILITY_POWER_RUSH)) {
                    if (!(battleStatus->rushFlags & RUSH_FLAG_MEGA)) {
                        gBattleStatus.flags2 |= BS_FLAGS2_HAS_RUSH;
                        battleStatus->rushFlags |= RUSH_FLAG_POWER;
                    }
                }
            }
 
            // setup dummy 'menu selection' for player move
            switch (encounterStatus->hitType) {
                case ENCOUNTER_TRIGGER_JUMP:
                    battleStatus->moveCategory = BTL_MENU_TYPE_JUMP;
                    battleStatus->selectedMoveID = MOVE_FIRST_STRIKE_JUMP;
                    battleStatus->moveArgument = encounterStatus->hitTier;
                    battleStatus->curTargetListFlags = gMoveTable[MOVE_FIRST_STRIKE_JUMP].flags;
                    break;
                case ENCOUNTER_TRIGGER_HAMMER:
                    battleStatus->moveCategory = BTL_MENU_TYPE_SMASH;
                    battleStatus->selectedMoveID = MOVE_FIRST_STRIKE_HAMMER;
                    battleStatus->moveArgument = encounterStatus->hitTier;
                    battleStatus->curTargetListFlags = gMoveTable[MOVE_FIRST_STRIKE_HAMMER].flags;
                    break;
                case ENCOUNTER_TRIGGER_PARTNER:
                    btl_set_state(BATTLE_STATE_PARTNER_FIRST_STRIKE);
                    return;
            }
            // let the enemy know a first strike is coming
            enemy = get_actor(ACTOR_ENEMY0);
            if (enemy->handleEventSource != NULL) {
                enemy->lastEventType = EVENT_BEGIN_FIRST_STRIKE;
                script = start_script(enemy->handleEventSource, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
                enemy->handleEventScript = script;
                enemy->handleEventScriptID = script->id;
                script->owner1.actorID = enemy->actorID;
            }
            gBattleSubState = BTL_SUBSTATE_AWAIT_ENEMY_READY;
            break;
        case BTL_SUBSTATE_AWAIT_ENEMY_READY:
            enemy = get_actor(ACTOR_ENEMY0);
            if (enemy->handleEventSource != NULL) {
                if (does_script_exist(enemy->handleEventScriptID)) {
                    break;
                } else {
                    enemy->handleEventScript = NULL;
                }
            }
 
            func_80263230(player, enemy);
            battleStatus->stateFreezeCount = 0;
            battleStatus->lastAttackDamage = 0;
            battleStatus->curDamageSource = DMG_SRC_DEFAULT;
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            gBattleStatus.flags2 |= BS_FLAGS2_IS_FIRST_STRIKE;
            gBattleStatus.flags1 &= ~BS_FLAGS1_PARTNER_ACTING;
            increment_status_bar_disabled();
            btl_cam_use_preset(BTL_CAM_MIDPOINT_CLOSE);
            btl_cam_target_actor(ACTOR_PLAYER);
            reset_actor_turn_info();
            // begin the player turn script
            battleStatus->battlePhase = PHASE_FIRST_STRIKE;
            script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            player->takeTurnScript = script;
            player->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
            BattleSubstateDelay = 3;
            gBattleSubState = BTL_SUBSTATE_AWAIT_SCRIPTS;
            break;
        case BTL_SUBSTATE_AWAIT_SCRIPTS:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
            } else {
                BattleCanShowFirstStrike = TRUE;
            }
 
            // wait for player move script
            if (!(gBattleStatus.flags1 & BS_FLAGS1_YIELD_TURN)) {
                if (player->takeTurnScript != NULL && does_script_exist(player->takeTurnScriptID)) {
                    break;
                }
                player->takeTurnScript = NULL;
            }
 
            gBattleStatus.flags1 &= ~BS_FLAGS1_EXECUTING_MOVE;
 
            // wait for player handle event script
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            // wait for partner handle event script
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
 
            // wait for all enemy turn scripts
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->takeTurnScript != NULL) {
                    if (does_script_exist(enemy->takeTurnScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        enemy->takeTurnScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            // wait for all enemy handle event scripts
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->handleEventScript != NULL) {
                    if (does_script_exist(enemy->handleEventScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        enemy->handleEventScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL) {
                    enemy->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
 
            if (battleStatus->stateFreezeCount == 0) {
                decrement_status_bar_disabled();
                if (!(gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED)) {
                    Actor* target;
 
                    if (btl_check_player_defeated() || btl_check_enemies_defeated()) {
                        return;
                    }
 
                    target = get_actor(player->targetActorID);
                    if (target != NULL) {
                        if (target->handleEventSource != NULL) {
                            target->lastEventType = EVENT_END_FIRST_STRIKE;
                            script = start_script(target->handleEventSource, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
                            target->handleEventScript = script;
                            target->handleEventScriptID = script->id;
                            script->owner1.actorID = target->actorID;
                        }
                    }
                    gBattleSubState = BTL_SUBSTATE_AWAIT_ENEMY_DONE;
                } else {
                    btl_set_state(BATTLE_STATE_END_DEMO_BATTLE);
                }
            }
            break;
        case BTL_SUBSTATE_AWAIT_ENEMY_DONE:
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->handleEventScript != NULL) {
                    if (does_script_exist(enemy->handleEventScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        enemy->handleEventScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
            if (player->takeTurnScript == NULL || !does_script_exist(player->takeTurnScriptID)) {
                player->takeTurnScript = NULL;
                btl_set_state(BATTLE_STATE_BEGIN_TURN);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_first_stike()

void btl_state_draw_first_stike ( void )

Definition at line 227 of file player_first_strike.c.

                                      {
    if (EndDemoWhiteOut == -1 && BattleCanShowFirstStrike) {
        if (BattleScreenFadeAmt == 0) {
            set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
        } else {
            if (!(gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED)) {
                BattleScreenFadeAmt -= 20;
            } else {
                BattleScreenFadeAmt -= 50;
            }
 
            if (BattleScreenFadeAmt < 0) {
                BattleScreenFadeAmt = 0;
            }
            set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, BattleScreenFadeAmt);
        }
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_partner_striking_first()

void btl_state_update_partner_striking_first ( void )

Definition at line 11 of file partner_first_strike.c.

                                                   {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Actor* actor;
    s32 enemyNotDone;
    SelectableTarget* target;
    Evt* script;
    s32 level;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            BattleCanShowFirstStrike = FALSE;
            // setup dummy 'menu selection' for partner move
            level = partner->actorBlueprint->level;
            switch (gPlayerData.curPartner) {
                case PARTNER_KOOPER:
                    battleStatus->moveCategory = BTL_MENU_TYPE_CHANGE_PARTNER;
                    battleStatus->moveArgument = 0;
                    battleStatus->selectedMoveID = level + MOVE_SHELL_TOSS1;
                    battleStatus->curTargetListFlags = gMoveTable[battleStatus->selectedMoveID].flags;
                    break;
                case PARTNER_BOMBETTE:
                    battleStatus->moveCategory = BTL_MENU_TYPE_CHANGE_PARTNER;
                    battleStatus->moveArgument = 0;
                    battleStatus->selectedMoveID = level + MOVE_BODY_SLAM1;
                    battleStatus->curTargetListFlags = gMoveTable[battleStatus->selectedMoveID].flags;
                    break;
            }
            // let the enemy know a first strike is coming
            actor = get_actor(ACTOR_ENEMY0);
            if (actor->handleEventSource != NULL) {
                actor->lastEventType = EVENT_BEGIN_FIRST_STRIKE;
                script = start_script(actor->handleEventSource, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
                actor->handleEventScript = script;
                actor->handleEventScriptID = script->id;
                script->owner1.actorID = actor->actorID;
            }
            gBattleSubState = BTL_SUBSTATE_AWAIT_ENEMY_READY;
            break;
        case BTL_SUBSTATE_AWAIT_ENEMY_READY:
            create_current_pos_target_list(partner);
            target = &partner->targetData[partner->targetIndexList[0]];
            partner->targetActorID = target->actorID;
            partner->targetPartID = target->partID;
            battleStatus->stateFreezeCount = 0;
            battleStatus->lastAttackDamage = 0;
            battleStatus->curDamageSource = DMG_SRC_DEFAULT;
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            gBattleStatus.flags2 |= BS_FLAGS2_IS_FIRST_STRIKE;
            gBattleStatus.flags1 |= BS_FLAGS1_PARTNER_ACTING;
            increment_status_bar_disabled();
            btl_cam_use_preset(BTL_CAM_MIDPOINT_CLOSE);
            btl_cam_target_actor(ACTOR_PARTNER);
            reset_actor_turn_info();
            // begin the partner turn script
            battleStatus->battlePhase = PHASE_FIRST_STRIKE;
            script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
            partner->takeTurnScript = script;
            partner->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PARTNER;
            BattleSubstateDelay = 3;
            gBattleSubState = BTL_SUBSTATE_AWAIT_SCRIPTS;
            break;
        case BTL_SUBSTATE_AWAIT_SCRIPTS:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
            } else {
                BattleCanShowFirstStrike = TRUE;
            }
            // wait for partner move script
            if (partner->takeTurnScript != NULL && does_script_exist(partner->takeTurnScriptID)) {
                break;
            }
            partner->takeTurnScript = NULL;
            // wait for partner handle event script
            if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                break;
            }
            partner->handleEventScript = NULL;
            // wait for player handle event script
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            // wait for all enemy turn scripts
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->takeTurnScript != NULL) {
                    if (does_script_exist(actor->takeTurnScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        actor->takeTurnScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            // wait for all enemy handle event scripts
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->handleEventScript != NULL) {
                    if (does_script_exist(actor->handleEventScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        actor->handleEventScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL) {
                    actor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
 
            if (battleStatus->stateFreezeCount == 0) {
                decrement_status_bar_disabled();
                if (btl_check_player_defeated() || btl_check_enemies_defeated()) {
                    return;
                }
 
                actor = get_actor(partner->targetActorID);
                if (actor != NULL) {
                    if (actor->handleEventSource != NULL) {
                        actor->lastEventType = EVENT_END_FIRST_STRIKE;
                        script = start_script(actor->handleEventSource, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
                        actor->handleEventScript = script;
                        actor->handleEventScriptID = script->id;
                        script->owner1.actorID = actor->actorID;
                    }
                }
                gBattleSubState = BTL_SUBSTATE_AWAIT_ENEMY_DONE;
            }
            break;
        case BTL_SUBSTATE_AWAIT_ENEMY_DONE:
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->handleEventScript != NULL) {
                    if (does_script_exist(actor->handleEventScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        actor->handleEventScript = NULL;
                    }
                }
            }
            if (!enemyNotDone) {
                btl_set_state(BATTLE_STATE_BEGIN_TURN);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_partner_striking_first()

void btl_state_draw_partner_striking_first ( void )

Definition at line 175 of file partner_first_strike.c.

                                                 {
    if (BattleCanShowFirstStrike) {
        if (BattleScreenFadeAmt == 0) {
            set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
        } else {
            BattleScreenFadeAmt -= 20;
            if (BattleScreenFadeAmt < 0) {
                BattleScreenFadeAmt = 0;
            }
 
            set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, BattleScreenFadeAmt);
        }
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_enemy_striking_first()

void btl_state_update_enemy_striking_first ( void )

Definition at line 8 of file enemy_first_strike.c.

                                                 {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Evt* script;
    Actor* actor;
    u16* enemyIDs;
    s16 activeEnemyActorID;
    s32 nextEnemyIdx;
    s32 count;
    s32 flags;
    s32 waitingForScript;
    s32 i;
    s32 j;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            gPlayerData.enemyFirstStrikes++;
            battleStatus->stateFreezeCount = 0;
            battleStatus->lastAttackDamage = 0;
            battleStatus->curDamageSource = DMG_SRC_DEFAULT;
            battleStatus->flags1 &= ~BS_FLAGS1_MENU_OPEN;
            BattleCanShowFirstStrike = FALSE;
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            if (partner != NULL) {
                partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
            battleStatus->flags2 |= BS_FLAGS2_IS_FIRST_STRIKE;
            battleStatus->flags2 |= BS_FLAGS2_IGNORE_DARKNESS;
            count = 0;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL) {
                    battleStatus->enemyIDs[count] = i | ACTOR_ENEMY0;
                    count++;
                }
            }
 
            battleStatus->numEnemyActors = count;
 
            enemyIDs = battleStatus->enemyIDs;
            for (i = 0; i < count - 1; i++) {
                for (j = i + 1; j < count; j++) {
                    s32 iVal = enemyIDs[i];
                    s32 jVal = enemyIDs[j];
 
                    if (battleStatus->enemyActors[iVal & 0xFF]->turnPriority <
                        battleStatus->enemyActors[jVal & 0xFF]->turnPriority)
                    {
                        enemyIDs[i] = jVal;
                        enemyIDs[j] = iVal;
                    }
                }
            }
 
            battleStatus->nextEnemyIndex = 0;
            nextEnemyIdx = 0;
            flags = ACTOR_FLAG_NO_ATTACK | ACTOR_FLAG_TARGET_ONLY;
 
            while (TRUE) {
                actor = battleStatus->enemyActors[battleStatus->enemyIDs[nextEnemyIdx] & 0xFF];
                if (actor == NULL || (actor->flags & flags)) {
                    nextEnemyIdx++;
                    if (nextEnemyIdx >= battleStatus->numEnemyActors) {
                        nextEnemyIdx = 0;
                    }
                } else {
                    break;
                }
            }
 
            activeEnemyActorID = battleStatus->enemyIDs[nextEnemyIdx];
            nextEnemyIdx++;
            battleStatus->curTurnEnemy = actor;
            battleStatus->activeEnemyActorID = activeEnemyActorID;
            if (nextEnemyIdx >= battleStatus->numEnemyActors) {
                nextEnemyIdx = 0;
            }
            battleStatus->nextEnemyIndex = nextEnemyIdx;
            btl_cam_target_actor(battleStatus->activeEnemyActorID);
            actor = battleStatus->curTurnEnemy;
            reset_actor_turn_info();
            battleStatus->battlePhase = PHASE_FIRST_STRIKE;
            script = start_script(actor->takeTurnSource, EVT_PRIORITY_A, 0);
            script->owner1.actorID = battleStatus->activeEnemyActorID;
            actor->takeTurnScript = script;
            actor->takeTurnScriptID = script->id;
            gBattleSubState = BTL_SUBSTATE_AWAIT;
            BattleSubstateDelay = 3;
            break;
        case BTL_SUBSTATE_AWAIT:
            if (BattleSubstateDelay != 0) {
                BattleSubstateDelay--;
            } else {
                BattleCanShowFirstStrike = TRUE;
            }
 
            // wait for current enemy TakeTurn script to finish
            actor = battleStatus->curTurnEnemy;
            if (actor->takeTurnScript != NULL && does_script_exist(actor->takeTurnScriptID)) {
                break;
            }
            actor->takeTurnScript = NULL;
 
            // wait for player HandleEvent script to finish (may have been triggered by enemy Take Turn)
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            // wait for partner HandleEvent script to finish (may have been triggered by enemy Take Turn)
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
 
            // wait for all enemy TakeTurn scripts to finish
            waitingForScript = FALSE;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->takeTurnScript != NULL) {
                    if (does_script_exist(actor->takeTurnScriptID)) {
                        waitingForScript = TRUE;
                    } else {
                        actor->takeTurnScript = NULL;
                    }
                }
            }
 
            if (waitingForScript) {
                break;
            }
 
            // wait for all enemy HandleEvent scripts to finish
            waitingForScript = FALSE;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->handleEventScript != NULL) {
                    if (does_script_exist(actor->handleEventScriptID)) {
                        waitingForScript = TRUE;
                    } else {
                        actor->handleEventScript = NULL;
                    }
                }
            }
 
            if (waitingForScript) {
                break;
            }
 
            // reset state
            gBattleStatus.flags2 &= ~BS_FLAGS2_IGNORE_DARKNESS;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL) {
                    actor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
 
            if (battleStatus->stateFreezeCount == 0) {
                if (btl_check_player_defeated() || btl_check_enemies_defeated()) {
                    return;
                }
                btl_set_state(BATTLE_STATE_BEGIN_TURN);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_enemy_striking_first()

void btl_state_draw_enemy_striking_first ( void )

Definition at line 182 of file enemy_first_strike.c.

                                               {
    if (BattleCanShowFirstStrike) {
        if (BattleScreenFadeAmt == 0) {
            set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
        } else {
            BattleScreenFadeAmt -= 20;
            if (BattleScreenFadeAmt < 0) {
                BattleScreenFadeAmt = 0;
            }
 
            set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, BattleScreenFadeAmt);
        }
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_end_demo_battle()

void btl_state_update_end_demo_battle ( void )

Definition at line 16 of file end_demo.c.

                                            {
    BattleStatus* battleStatus = &gBattleStatus;
    Battle* battle = gCurrentBattlePtr;
    Stage* stage;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            BattleScreenFadeAmt = 0;
            if (EndDemoWhiteOut == -1) {
                if (DemoBattleBeginDelay != 0) {
                    DemoBattleBeginDelay--;
                    break;
                }
            }
            gBattleSubState = BTL_SUBSTATE_FADE_OUT;
            break;
        case BTL_SUBSTATE_FADE_OUT:
            switch (EndDemoWhiteOut) {
                case 255:
                    gBattleSubState = BTL_SUBSTATE_EXEC_STAGE_SCRIPT;
                    return;
                case -1:
                    if (BattleScreenFadeAmt == 255) {
                        gBattleSubState = BTL_SUBSTATE_EXEC_STAGE_SCRIPT;
                        return;
                    }
                    BattleScreenFadeAmt += 50;
                    if (BattleScreenFadeAmt > 255) {
                        BattleScreenFadeAmt = 255;
                    }
                    return;
            }
            break;
        case BTL_SUBSTATE_EXEC_STAGE_SCRIPT:
            BattleScreenFadeAmt = 255;
            gBattleStatus.flags1 &= ~BS_FLAGS1_ACTORS_VISIBLE;
            if (gCurrentStagePtr == NULL) {
                stage = battle->stage;
            } else {
                stage = gCurrentStagePtr->stage;
            }
 
            if (stage->postBattle == NULL) {
                gBattleSubState = BTL_SUBSTATE_CLEANUP;
            } else {
                battleStatus->controlScript = start_script(stage->postBattle, EVT_PRIORITY_A, 0);
                battleStatus->controlScriptID = battleStatus->controlScript->id;
                gBattleSubState = BTL_SUBSTATE_AWAIT_STAGE_SCRIPT;
            }
            break;
        case BTL_SUBSTATE_AWAIT_STAGE_SCRIPT:
            if (does_script_exist(battleStatus->controlScriptID)) {
                break;
            }
            gBattleSubState = BTL_SUBSTATE_CLEANUP;
            //fallthrough
        case BTL_SUBSTATE_CLEANUP:
            kill_all_scripts();
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                Actor* enemy = battleStatus->enemyActors[i];
 
                if (enemy != NULL) {
                    btl_delete_actor(enemy);
                }
            }
 
            if (battleStatus->partnerActor != NULL) {
                btl_delete_actor(battleStatus->partnerActor);
            }
 
            btl_delete_player_actor(battleStatus->playerActor);
            remove_all_effects();
            set_windows_visible(WINDOW_GROUP_ALL);
 
            if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                decrement_status_bar_disabled();
            }
 
            if (EndDemoWhiteOut != -1) {
                gGameStatusPtr->nextDemoScene = LAST_DEMO_SCENE_IDX;
            }
 
            btl_set_state(BATTLE_STATE_NONE);
            gLastDrawBattleState = gBattleState;
            set_game_mode(GAME_MODE_END_BATTLE);
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_end_demo_battle()

void btl_state_draw_end_demo_battle ( void )

Definition at line 107 of file end_demo.c.

                                          {
    if (EndDemoWhiteOut == -1) {
        set_screen_overlay_color(SCREEN_LAYER_FRONT, 0, 0, 0);
        set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, BattleScreenFadeAmt);
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_player_menu()

void btl_state_update_player_menu ( void )

Definition at line 298 of file menu_player.c.

                                        {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* playerActor = battleStatus->playerActor;
    Actor* partnerActor = battleStatus->partnerActor;
    PopupMenu* popup = &BattlePopupMenu;
    MoveData* moveData;
    s32 entryIdx, initialPos;
    s32 i;
    s32 submenuResult;
    s32 jumpTargetCount, hammerTargetCount, jumpChance;
    ItemData* itemData;
    s32 starBeamLevel;
    s32 currentSubmenu;
    s32 currentSubmenu2;
    IconHudScriptPair* hudScriptPair;
    PartnerPopupProperties* prop;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            battleStatus->moveCategory = BTL_MENU_TYPE_INVALID;
            battleStatus->selectedMoveID = 0;
            battleStatus->curAttackElement = 0;
            if (!btl_player_can_act()) {
                btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
                return;
            }
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            btl_cam_move(10);
            if (!(battleStatus->flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
                gBattleSubState = BTL_SUBSTATE_CREATE_MAIN_MENU;
            } else {
                gBattleSubState = BTL_SUBSTATE_PERFORM_SWAP;
                partnerActor->state.curPos.x = partnerActor->homePos.x;
                partnerActor->state.curPos.z = partnerActor->homePos.z;
                partnerActor->state.goalPos.x = playerActor->homePos.x;
                partnerActor->state.goalPos.z = playerActor->homePos.z;
                partnerActor->state.moveTime = 4;
                partnerActor->state.angle = 0.0f;
            }
            break;
        case BTL_SUBSTATE_PERFORM_SWAP:
            if (partnerActor->state.moveTime != 0) {
                partnerActor->curPos.x += (partnerActor->state.goalPos.x - partnerActor->curPos.x) / partnerActor->state.moveTime;
                partnerActor->curPos.z += (partnerActor->state.goalPos.z - partnerActor->curPos.z) / partnerActor->state.moveTime;
                playerActor->curPos.x += (partnerActor->state.curPos.x - playerActor->curPos.x) / partnerActor->state.moveTime;
                playerActor->curPos.z += (partnerActor->state.curPos.z - playerActor->curPos.z) / partnerActor->state.moveTime;
            }
            partnerActor->curPos.z -= sin_rad(DEG_TO_RAD(partnerActor->state.angle)) * 16.0f;
            partnerActor->yaw = clamp_angle(-partnerActor->state.angle);
            playerActor->curPos.z += sin_rad(DEG_TO_RAD(partnerActor->state.angle)) * 16.0f;
            playerActor->yaw = clamp_angle(-partnerActor->state.angle);
            partnerActor->state.angle += 90.0f;
            if (partnerActor->state.moveTime != 0) {
                partnerActor->state.moveTime--;
            } else {
                partnerActor->curPos.x = partnerActor->state.goalPos.x;
                partnerActor->curPos.z = partnerActor->state.goalPos.z;
                playerActor->curPos.x = partnerActor->state.curPos.x;
                playerActor->curPos.z = partnerActor->state.curPos.z;
                partnerActor->homePos.x = partnerActor->curPos.x;
                partnerActor->homePos.z = partnerActor->curPos.z;
                playerActor->homePos.x = playerActor->curPos.x;
                playerActor->homePos.z = playerActor->curPos.z;
                gBattleSubState = BTL_SUBSTATE_CREATE_MAIN_MENU;
                battleStatus->flags1 &= ~BS_FLAGS1_PLAYER_IN_BACK;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CREATE_MAIN_MENU:
            gBattleStatus.flags1 |= BS_FLAGS1_MENU_OPEN;
            playerActor->flags &= ~ACTOR_FLAG_USING_IDLE_ANIM;
            playerActor->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            if (partnerActor != NULL) {
                partnerActor->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
                partnerActor->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
            btl_check_can_change_partner();
            btl_init_menu_items();
            btl_init_menu_boots();
            btl_init_menu_hammer();
            if (player_team_is_ability_active(playerActor, ABILITY_BERSERKER)) {
                gBattleSubState = BTL_SUBSTATE_BERSERKER_CHOOSE;
                break;
            }
 
            entryIdx = 0;
            initialPos = 2;
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] < 0) {
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] = 0;
            }
 
            // strategies menu category
            WheelOptionSubmenu[entryIdx] = BTL_MENU_TYPE_STRATEGIES;
            WheelOptionEnabled[entryIdx] = TRUE;
            WheelOptionHudScript[entryIdx] = StrategiesHudScripts.enabled;
            WheelOptionName[entryIdx] = CenteredBattleMessages[BTL_MENU_TYPE_STRATEGIES];
            if (battleStatus->actionCommandMode == AC_MODE_TUTORIAL || gBattleStatus.flags1 & BS_FLAGS1_TUTORIAL_BATTLE) {
                WheelOptionName[entryIdx] = MSG_Menus_EndTraining_Centered;
            }
            WheelOptionError[entryIdx] = 0;
            if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_STRATEGIES)) {
                WheelOptionHudScript[entryIdx] = StrategiesHudScripts.disabled;
                WheelOptionEnabled[entryIdx] = FALSE;
                WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
            }
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_STRATEGIES) {
                initialPos = entryIdx;
            }
            entryIdx++;
 
            // items menu category
            if (battleStatus->menuStatus[0] >= 0) {
                WheelOptionHudScript[entryIdx] = ItemsHudScripts.enabled;
                WheelOptionSubmenu[entryIdx] = BTL_MENU_TYPE_ITEMS;
                WheelOptionEnabled[entryIdx] = TRUE;
                WheelOptionName[entryIdx] = CenteredBattleMessages[BTL_MENU_TYPE_ITEMS];
 
                if(battleStatus->menuStatus[0] == 0) {
                    WheelOptionHudScript[entryIdx] = ItemsHudScripts.disabled;
                    WheelOptionEnabled[entryIdx] = FALSE;
                    WheelOptionError[entryIdx] = BTL_MSG_NO_ITEM_TARGET;
                }
 
                if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_ITEMS)) {
                    WheelOptionHudScript[entryIdx] = ItemsHudScripts.disabled;
                    WheelOptionEnabled[entryIdx] = FALSE;
                    WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                }
 
                if (battleStatus->itemLossTurns >= 0) {
                    WheelOptionHudScript[entryIdx] = ItemsHudScripts.disabled;
                    WheelOptionEnabled[entryIdx] = FALSE;
                    WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                }
 
                if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_ITEMS) {
                    initialPos = entryIdx;
                }
 
                entryIdx++;
            }
 
            // jump menu category
            WheelOptionHudScript[entryIdx] = BootsHudScripts[playerData->bootsLevel + 1].enabled;
            WheelOptionSubmenu[entryIdx] = BTL_MENU_TYPE_JUMP;
            WheelOptionEnabled[entryIdx] = TRUE;
            WheelOptionName[entryIdx] = CenteredBattleMessages[BTL_MENU_TYPE_JUMP];
 
            if (battleStatus->menuStatus[1] <= 0) {
                WheelOptionHudScript[entryIdx] = BootsHudScripts[0].enabled;
                WheelOptionEnabled[entryIdx] = FALSE;
                WheelOptionError[entryIdx] = BTL_MSG_NO_JUMP_TARGET;
            }
            if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_JUMP)) {
                WheelOptionHudScript[entryIdx] = BootsHudScripts[0].disabled;
                WheelOptionEnabled[entryIdx] = FALSE;
                WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
            }
            if (battleStatus->jumpLossTurns >= 0) {
                WheelOptionHudScript[entryIdx] = BootsHudScripts[0].disabled;
                WheelOptionEnabled[entryIdx] = FALSE;
                WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
            }
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_JUMP) {
                initialPos = entryIdx;
            }
            entryIdx++;
 
            // hammer menu category
            if (playerData->hammerLevel >= 0) {
                WheelOptionHudScript[entryIdx] = HammerHudScripts[playerData->hammerLevel + 1].enabled;
                WheelOptionSubmenu[entryIdx] = BTL_MENU_TYPE_SMASH;
                WheelOptionEnabled[entryIdx] = TRUE;
                WheelOptionName[entryIdx] = CenteredBattleMessages[BTL_MENU_TYPE_SMASH];
                if (battleStatus->menuStatus[2] <= 0) {
                    WheelOptionHudScript[entryIdx] = HammerHudScripts[0].enabled;
                    WheelOptionEnabled[entryIdx] = FALSE;
                    WheelOptionError[entryIdx] = BTL_MSG_NO_HAMMER_TARGET;
                }
                if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_SMASH)) {
                    WheelOptionHudScript[entryIdx] = HammerHudScripts[0].disabled;
                    WheelOptionEnabled[entryIdx] = FALSE;
                    WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                }
                if (battleStatus->hammerLossTurns >= 0) {
                    WheelOptionHudScript[entryIdx] = HammerHudScripts[0].disabled;
                    WheelOptionEnabled[entryIdx] = FALSE;
                    WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                }
                if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_SMASH) {
                    initialPos = entryIdx;
                }
                entryIdx++;
            }
 
            // star powers menu category
            if (playerData->maxStarPower != 0) {
                WheelOptionHudScript[entryIdx] = StarPowersHudScripts.enabled;
                WheelOptionSubmenu[entryIdx] = BTL_MENU_TYPE_STAR_POWERS;
                WheelOptionEnabled[entryIdx] = TRUE;
                WheelOptionName[entryIdx] = CenteredBattleMessages[BTL_MENU_TYPE_STAR_POWERS];
                WheelOptionError[entryIdx] = 0;
                if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_STAR_POWERS)) {
                    WheelOptionHudScript[entryIdx] = StarPowersHudScripts.disabled;
                    WheelOptionEnabled[entryIdx] = FALSE;
                    WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                }
                if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_STAR_POWERS) {
                    initialPos = entryIdx;
                }
                entryIdx++;
            }
 
            WheelOptionCount = entryIdx;
            BattleMenu_PrevSelected = initialPos;
            BattleMenu_WheelBase = 2 - initialPos;
            if (btl_partner_can_act()) {
                BattleMenu_ShowSwapIcons = TRUE;
            } else {
                BattleMenu_ShowSwapIcons = FALSE;
            }
            btl_main_menu_init();
            BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
            BattleMenu_SwapDelay = 0;
            gBattleSubState = BTL_SUBSTATE_MAIN_CHOOSING;
            break;
        case BTL_SUBSTATE_MAIN_CHOOSING:
            if (battleStatus->hustleTurns != 0) {
                set_actor_anim(ACTOR_PLAYER, 0, ANIM_Mario1_ThinkingRun);
            } else {
                set_actor_anim(ACTOR_PLAYER, 0, get_player_anim_for_status(STATUS_KEY_THINKING));
            }
            submenuResult = btl_main_menu_update();
            if (BattleMenu_SwapDelay != 0) {
                BattleMenu_SwapDelay--;
            } else if (!(gBattleStatus.flags1 & BS_FLAGS1_TUTORIAL_BATTLE) && (gGameStatusPtr->pressedButtons[0] & BUTTON_Z)) {
                if (btl_partner_can_act() && battleStatus->hustleTurns != 1) {
                    sfx_play_sound(SOUND_PARTNER_SWAP_BATTLE_POS);
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] = WheelOptionSubmenu[BattleMenu_CurPos + BattleMenu_HomePos];
                    btl_main_menu_destroy();
                    btl_set_state(BATTLE_STATE_SWITCH_TO_PARTNER);
                } else if (partnerActor != NULL && !(partnerActor->flags & BS_FLAGS1_YIELD_TURN) && battleStatus->hustleTurns != 1) {
                    sfx_play_sound(SOUND_MENU_ERROR);
                    gBattleSubState = BTL_SUBSTATE_MAIN_SHOW_CANT_SWAP;
                }
                break;
            }
 
            if (BattleMenu_ChooseDelay != 0) {
                BattleMenu_ChooseDelay--;
                break;
            }
 
            if (submenuResult == 0) {
                break;
            }
 
            set_actor_anim(ACTOR_PLAYER, 0, ANIM_Mario1_Walk);
            battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] = battleStatus->curSubmenu = WheelOptionSubmenu[submenuResult - 1];
            for (i = 0; i < ARRAY_COUNT(battleStatus->submenuMoves); i++) {
                battleStatus->submenuMoves[i] = MOVE_NONE;
                battleStatus->submenuIcons[i] = ITEM_NONE;
                battleStatus->submenuStatus[i] = 0;
            }
 
            switch (battleStatus->curSubmenu) {
                case BTL_MENU_TYPE_ITEMS:
                    battleStatus->submenuMoves[0] = MOVE_ITEMS;
                    battleStatus->submenuIcons[0] = ITEM_PARTNER_ATTACK;
                    battleStatus->submenuStatus[0] = 1;
                    for (i = 0; i < ARRAY_COUNT(playerData->invItems); i++) {
                        if (playerData->invItems[i] == ITEM_NONE) {
                            continue;
                        }
                        itemData = &gItemTable[playerData->invItems[i]];
 
                        battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                        battleStatus->moveArgument = playerData->invItems[i];
                        battleStatus->curTargetListFlags = itemData->targetFlags;
                        create_current_pos_target_list(playerActor);
                    }
                    entryIdx = 1;
                    for (i = 0; i < ARRAY_COUNT(playerData->equippedBadges); i++) {
                        if (playerData->equippedBadges[i] != 0) {
                            s32 moveID = gItemTable[playerData->equippedBadges[i]].moveID;
                            moveData = &gMoveTable[moveID];
                            if (moveData->category == BattleMenu_CategoryForSubmenu[battleStatus->curSubmenu]) {
                                s32 cost = moveData->costFP;
                                battleStatus->submenuMoves[entryIdx] = moveID;
                                battleStatus->submenuIcons[entryIdx] = playerData->equippedBadges[i];
                                battleStatus->submenuStatus[entryIdx] = 1;
 
                                cost -= player_team_is_ability_active(playerActor, ABILITY_FLOWER_SAVER);
                                cost -= 2 * player_team_is_ability_active(playerActor, ABILITY_FLOWER_FANATIC);
 
                                if (playerData->curFP < cost) {
                                    battleStatus->submenuStatus[entryIdx] = 0;
                                }
                                entryIdx++;
                            }
                        }
                    }
                    battleStatus->submenuMoveCount = entryIdx;
                    if (entryIdx == 1) {
                        battleStatus->submenuMoveCount = 0;
                    }
                    break;
                case BTL_MENU_TYPE_SMASH:
                    btl_init_menu_hammer();
                    if (battleStatus->submenuMoveCount == 1) {
                        battleStatus->submenuMoveCount = 0;
                    }
                    if (battleStatus->actionCommandMode == AC_MODE_TUTORIAL) {
                        battleStatus->submenuMoveCount = 0;
                    }
                    break;
                case BTL_MENU_TYPE_JUMP:
                    btl_init_menu_boots();
                    if (battleStatus->submenuMoveCount == 1) {
                        battleStatus->submenuMoveCount = 0;
                    }
                    if (battleStatus->actionCommandMode == AC_MODE_TUTORIAL) {
                        battleStatus->submenuMoveCount = 0;
                    }
                    break;
                case BTL_MENU_TYPE_STAR_POWERS:
                    battleStatus->submenuMoves[0] = MOVE_FOCUS;
                    battleStatus->submenuIcons[0] = ITEM_PARTNER_ATTACK;
                    battleStatus->submenuStatus[0] = 1;
                    entryIdx = 1;
                    initialPos = 8;
                    for (i = 0; i < playerData->maxStarPower; i++) {
                        moveData = &gMoveTable[MOVE_REFRESH + i];
                        battleStatus->submenuMoves[entryIdx] = MOVE_REFRESH + i;
                        battleStatus->submenuIcons[entryIdx] = ITEM_NONE;
                        battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
                        battleStatus->moveArgument = MOVE_REFRESH + i;
                        battleStatus->curTargetListFlags = moveData->flags;
                        create_current_pos_target_list(playerActor);
                        battleStatus->submenuStatus[entryIdx] = 1;
                        if (playerActor->targetListLength == 0) {
                            battleStatus->submenuStatus[entryIdx] = -2;
                        }
                        if (playerData->starPower / SP_PER_BAR < moveData->costFP) {
                            battleStatus->submenuStatus[entryIdx] = 0;
                        }
                        if (gBattleStatus.flags2 & BS_FLAGS2_NO_TARGET_AVAILABLE) {
                            battleStatus->submenuStatus[entryIdx] = -1;
                        }
                        entryIdx++;
                    }
                    starBeamLevel = playerData->starBeamLevel;
                    if (starBeamLevel == 1) {
                        moveData = &gMoveTable[MOVE_STAR_BEAM];
                        battleStatus->submenuMoves[entryIdx] = MOVE_STAR_BEAM;
                        battleStatus->submenuIcons[entryIdx] = 0;
                        battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
                        battleStatus->moveArgument = MOVE_REFRESH + i;
                        battleStatus->curTargetListFlags = moveData->flags;
                        create_current_pos_target_list(playerActor);
                        battleStatus->submenuStatus[entryIdx] = starBeamLevel;
                        if (playerActor->targetListLength == 0) {
                            battleStatus->submenuStatus[entryIdx] = -2;
                        }
                        if (playerData->starPower / SP_PER_BAR < moveData->costFP) {
                            battleStatus->submenuStatus[entryIdx] = 0;
                        }
                        if (gBattleStatus.flags2 & BS_FLAGS2_NO_TARGET_AVAILABLE) {
                            battleStatus->submenuStatus[entryIdx] = -1;
                        }
                        entryIdx++;
                    }
                    if (playerData->starBeamLevel == 2) {
                        moveData = &gMoveTable[MOVE_PEACH_BEAM];
                        battleStatus->submenuMoves[entryIdx] = MOVE_PEACH_BEAM;
                        battleStatus->submenuIcons[entryIdx] = ITEM_NONE;
                        battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
                        battleStatus->moveArgument = MOVE_REFRESH + i;
                        battleStatus->curTargetListFlags = moveData->flags;
                        create_current_pos_target_list(playerActor);
                        battleStatus->submenuStatus[entryIdx] = 1;
                        if (playerActor->targetListLength == 0) {
                            battleStatus->submenuStatus[entryIdx] = -2;
                        }
                        if (playerData->starPower / SP_PER_BAR < moveData->costFP) {
                            battleStatus->submenuStatus[entryIdx] = 0;
                        }
                        if (gBattleStatus.flags2 & BS_FLAGS2_NO_TARGET_AVAILABLE) {
                            battleStatus->submenuStatus[entryIdx] = -1;
                        }
                        entryIdx++;
                    }
                    battleStatus->submenuMoveCount = entryIdx;
                    break;
            }
 
            currentSubmenu = battleStatus->curSubmenu;
 
            if (currentSubmenu == BTL_MENU_TYPE_STAR_POWERS) {
                gBattleSubState = BTL_SUBSTATE_STAR_SPIRITS_BUILD_MENU;
                btl_state_update_player_menu();
                btl_state_update_player_menu();
                break;
            }
 
            if (currentSubmenu == BTL_MENU_TYPE_STRATEGIES) {
                if (battleStatus->actionCommandMode != AC_MODE_TUTORIAL && !(gBattleStatus.flags1 & BS_FLAGS1_TUTORIAL_BATTLE)) {
                    gBattleSubState = BTL_SUBSTATE_STRATEGIES_BUILD_MENU;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                } else {
                    btl_main_menu_destroy();
                    battleStatus->moveCategory = currentSubmenu;
                    battleStatus->moveArgument = 0;
                    battleStatus->selectedMoveID = 0;
                    btl_set_state(BATTLE_STATE_PLAYER_MOVE);
                }
                break;
            }
 
            // handle menus without multiple options (skipping submenu)
            if (battleStatus->submenuMoveCount == 0) {
                if (currentSubmenu != BTL_MENU_TYPE_ITEMS) {
                    gBattleSubState = BTL_SUBSTATE_NOSUBMENU_SHOW;
                } else {
                    gBattleSubState = BTL_SUBSTATE_ITEMS_BUILD_MENU;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                }
                break;
            }
 
            initialPos = 0;
            if (currentSubmenu == BTL_MENU_TYPE_JUMP) {
                if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_JUMP] < 0) {
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_JUMP] = 0;
                }
                initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_JUMP];
            }
            if (battleStatus->curSubmenu == BTL_MENU_TYPE_SMASH) {
                if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_SMASH] < 0) {
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_SMASH] = 0;
                }
                initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_SMASH];
            }
            if (battleStatus->curSubmenu == BTL_MENU_TYPE_ITEMS) {
                if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_ITEMS] < 0) {
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_ITEMS] = 0;
                }
                initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_ITEMS];
            }
 
            for (i = 0; i < battleStatus->submenuMoveCount; i++) {
                moveData = &gMoveTable[battleStatus->submenuMoves[i]];
                itemData = &gItemTable[battleStatus->submenuIcons[i]];
                hudScriptPair = &gItemHudScripts[itemData->hudElemID];
 
                MovesOptionError[i] = 0;
                if (battleStatus->submenuStatus[i] == 0) {
                    MovesOptionError[i] = 0;
                }
                if (battleStatus->submenuStatus[i] == -1) {
                    battleStatus->submenuStatus[i] = 0;
                    MovesOptionError[i] = BTL_MSG_CANT_SELECT_NOW;
                }
                if (battleStatus->submenuStatus[i] == -2) {
                    battleStatus->submenuStatus[i] = 0;
                    MovesOptionError[i] = BTL_MSG_CANT_SELECT_NOW;
                }
                if (battleStatus->submenuStatus[i] == -3) {
                    battleStatus->submenuStatus[i] = 0;
                    MovesOptionError[i] = BTL_MSG_CANT_SELECT_NOW_ALT;
                }
                MovesOptionHudScripts[i] = hudScriptPair->enabled;
                if (battleStatus->submenuStatus[i] == 0) {
                    MovesOptionHudScripts[i] = hudScriptPair->disabled;
                }
 
                MovesOptionDisplayCosts[i] = moveData->costFP;
                MovesOptionBPCosts[i] = moveData->costBP;
                MovesOptionSortPriority[i] = 0;
                MovesOptionDiscounts[i] = 0;
                MovesOptionDiscountColors[i] = 0;
 
                if (player_team_is_ability_active(playerActor, ABILITY_FLOWER_SAVER)) {
                    MovesOptionDiscounts[i] += player_team_is_ability_active(playerActor, ABILITY_FLOWER_SAVER);
                    MovesOptionDiscountColors[i] = 1;
                }
                if (player_team_is_ability_active(playerActor, ABILITY_FLOWER_FANATIC)) {
                    MovesOptionDiscounts[i] += 2 * player_team_is_ability_active(playerActor, ABILITY_FLOWER_FANATIC);
                    MovesOptionDiscountColors[i] = 2;
                }
 
                MovesOptionIndices[i] = i;
                MovesOptionEnabled[i] = battleStatus->submenuStatus[i];
                MovesOptionNames[i] = moveData->nameMsg;
                MovesOptionDesc[i] = moveData->shortDescMsg;
 
            }
            UsingSpiritsSubmenu = FALSE;
            MovesOptionCount = battleStatus->submenuMoveCount;
            MovesPrevSelected = initialPos;
            btl_submenu_moves_init();
            gBattleSubState = BTL_SUBSTATE_ABILITIES_CHOOSING;
            break;
        case BTL_SUBSTATE_ABILITIES_CHOOSING:
            submenuResult = btl_submenu_moves_update();
            switch (submenuResult) {
                case POPUP_RESULT_CHOOSING:
                    // do nothing while player is choosing from menu
                    break;
                case POPUP_RESULT_INVALID:
                    gBattleSubState = BTL_SUBSTATE_ABILITIES_SHOW_ERROR;
                    break;
                case POPUP_RESULT_CANCEL:
                    btl_main_menu_resume_choose();
                    BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                    BattleMenu_SwapDelay = 4;
                    gBattleSubState = BTL_SUBSTATE_MAIN_CHOOSING;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                    break;
                default: // something has been selected
                    battleStatus->lastSelectedAbility = MovesOptionIndices[submenuResult - 1];
                    battleStatus->selectedMoveID = battleStatus->submenuMoves[battleStatus->lastSelectedAbility];
                    if (battleStatus->curSubmenu == BTL_MENU_TYPE_JUMP) {
                        battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_JUMP] = SelectedMovesIndex;
                    }
                    if (battleStatus->curSubmenu == BTL_MENU_TYPE_SMASH) {
                        battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_SMASH] = SelectedMovesIndex;
                    }
                    currentSubmenu2 = battleStatus->curSubmenu;
                    if (battleStatus->curSubmenu == BTL_MENU_TYPE_ITEMS) {
                        battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_ITEMS] = SelectedMovesIndex;
                        if (battleStatus->curSubmenu == currentSubmenu2) {
                            gBattleSubState = BTL_SUBSTATE_DIPPING_BUILD_MENU;
                            btl_state_update_player_menu();
                            btl_state_update_player_menu();
                            break;
                        }
                    }
                    btl_submenu_moves_hide();
                    btl_main_menu_hide();
                    gBattleSubState = BTL_SUBSTATE_ABILITIES_HANDOVER;
                    break;
            }
            break;
        case BTL_SUBSTATE_ABILITIES_HANDOVER:
            submenuResult = btl_submenu_moves_update();
            if ((battleStatus->curButtonsPressed & BUTTON_B) && submenuResult == 0) {
                btl_submenu_moves_restore_choose();
                btl_main_menu_restore_submenu();
                gBattleSubState = BTL_SUBSTATE_ABILITIES_REOPEN_MENU;
                break;
            }
            if (btl_main_menu_update() == 0) {
                break;
            }
            battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_ABILITIES_TARGET_CANCEL;
            battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_ABILITIES_TARGET_CHOSEN;
            battleStatus->selectedMoveID = battleStatus->submenuMoves[battleStatus->lastSelectedAbility];
            battleStatus->curTargetListFlags = gMoveTable[battleStatus->submenuMoves[battleStatus->lastSelectedAbility]].flags;
            currentSubmenu = battleStatus->curSubmenu;
            switch (currentSubmenu) {
                case BTL_MENU_TYPE_JUMP:
                    battleStatus->moveCategory = BTL_MENU_TYPE_JUMP;
                    battleStatus->moveArgument = playerData->bootsLevel;
                    btl_set_state(BATTLE_STATE_SELECT_TARGET);
                    break;
                case BTL_MENU_TYPE_SMASH:
                    battleStatus->moveCategory = BTL_MENU_TYPE_SMASH;
                    battleStatus->moveArgument = playerData->hammerLevel;
                    btl_set_state(BATTLE_STATE_SELECT_TARGET);
                    break;
                case BTL_MENU_TYPE_DEFEND:
                    gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                    btl_state_update_player_menu();
                    battleStatus->moveCategory = BTL_MENU_TYPE_DEFEND;
                    btl_set_state(BATTLE_STATE_DEFEND);
                    break;
            }
            break;
        case BTL_SUBSTATE_ABILITIES_REOPEN_MENU:
            btl_submenu_moves_update();
            if (btl_main_menu_update() == 0) {
                break;
            }
            gBattleSubState = BTL_SUBSTATE_ABILITIES_CHOOSING;
            break;
        case BTL_SUBSTATE_ABILITIES_TARGET_CANCEL:
            btl_submenu_moves_restore_choose();
            btl_main_menu_restore_submenu();
            gBattleSubState = BTL_SUBSTATE_ABILITIES_REOPEN_MENU;
            break;
        case BTL_SUBSTATE_ABILITIES_TARGET_CHOSEN:
            btl_submenu_moves_destroy();
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_ABILITIES_SHOW_ERROR:
            if (btl_submenu_moves_update() != -1) {
                gBattleSubState = BTL_SUBSTATE_ABILITIES_CHOOSING;
            }
            break;
        case BTL_SUBSTATE_MAIN_SHOW_CANT_SWAP:
            if (gBattleStatus.flags2 & BS_FLAGS2_PARTNER_TURN_USED) {
                btl_show_variable_battle_message(BTL_MSG_CANT_SWITCH, 60, 0);
            } else {
                btl_show_variable_battle_message(BTL_MSG_CANT_MOVE, 60, playerData->curPartner);
            }
            ShowingErrorMessage = TRUE;
            gBattleSubState = BTL_SUBSTATE_MAIN_AWAIT_CANT_SWAP;
            break;
        case BTL_SUBSTATE_MAIN_AWAIT_CANT_SWAP:
            if (btl_is_popup_displayed()) {
                break;
            }
            ShowingErrorMessage = FALSE;
            BattleMenu_ChooseDelay = 0;
            BattleMenu_SwapDelay = 4;
            gBattleSubState = BTL_SUBSTATE_MAIN_CHOOSING;
            break;
        case BTL_SUBSTATE_NOSUBMENU_SHOW:
            btl_main_menu_hide();
            gBattleSubState = BTL_SUBSTATE_NOSUBMENU_HANDOVER;
            break;
        case BTL_SUBSTATE_NOSUBMENU_HANDOVER:
            submenuResult = btl_main_menu_update();
 
            if (submenuResult == 0) {
                if (battleStatus->curButtonsPressed & BUTTON_B) {
                    btl_main_menu_restore_choose();
                    gBattleSubState = BTL_SUBSTATE_NOSUBMENU_RETURN_MAIN;
                }
                break;
            }
 
            battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_NOSUBMENU_TARGET_CANCEL;
            battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_NOSUBMENU_TARGET_CHOSEN;
            switch (battleStatus->curSubmenu) {
                case BTL_MENU_TYPE_JUMP:
                    battleStatus->moveCategory = BTL_MENU_TYPE_JUMP;
                    battleStatus->moveArgument = playerData->bootsLevel;
                    battleStatus->selectedMoveID = playerData->bootsLevel + MOVE_JUMP1;
                    battleStatus->curTargetListFlags = gMoveTable[battleStatus->selectedMoveID].flags;
                    btl_set_state(BATTLE_STATE_SELECT_TARGET);
                    break;
                case BTL_MENU_TYPE_SMASH:
                    battleStatus->moveCategory = BTL_MENU_TYPE_SMASH;
                    battleStatus->moveArgument = playerData->hammerLevel;
                    battleStatus->selectedMoveID = playerData->hammerLevel + MOVE_HAMMER1;
                    battleStatus->curTargetListFlags = gMoveTable[battleStatus->selectedMoveID].flags;
                    btl_set_state(BATTLE_STATE_SELECT_TARGET);
                    break;
                default:
                    ; // fallthrough
            }
        case BTL_SUBSTATE_NOSUBMENU_RETURN_MAIN:
            if (btl_main_menu_update() == 0) {
                break;
            }
            BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
            BattleMenu_SwapDelay = 4;
            gBattleSubState = BTL_SUBSTATE_MAIN_CHOOSING;
            break;
        case BTL_SUBSTATE_NOSUBMENU_TARGET_CANCEL:
            btl_main_menu_restore_choose();
            gBattleSubState = BTL_SUBSTATE_NOSUBMENU_RETURN_MAIN;
            break;
        case BTL_SUBSTATE_NOSUBMENU_TARGET_CHOSEN:
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_DIPPING_BUILD_MENU:
            if (battleStatus->selectedMoveID == MOVE_DOUBLE_DIP) {
                battleStatus->itemUsesLeft = 2;
            }
            if (battleStatus->selectedMoveID == MOVE_TRIPLE_DIP) {
                battleStatus->itemUsesLeft = 3;
            }
            entryIdx = 0;
            for (i = 0; i < ARRAY_COUNT(playerData->invItems); i++) {
                if (playerData->invItems[i] == ITEM_NONE) {
                    continue;
                }
                itemData = &gItemTable[playerData->invItems[i]];
                hudScriptPair = &gItemHudScripts[itemData->hudElemID];
                if (!(itemData->typeFlags & ITEM_TYPE_FLAG_BATTLE_USABLE)) {
                    continue;
                }
                battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                battleStatus->moveArgument = playerData->invItems[i];
                battleStatus->curTargetListFlags = itemData->targetFlags;
                create_current_pos_target_list(playerActor);
                popup->ptrIcon[entryIdx] = hudScriptPair->enabled;
                popup->userIndex[entryIdx] = playerData->invItems[i];
                popup->enabled[entryIdx] = TRUE;
                popup->nameMsg[entryIdx] = itemData->nameMsg;
                popup->descMsg[entryIdx] = itemData->shortDescMsg;
                if (playerActor->targetListLength == 0) {
                    popup->ptrIcon[entryIdx] = hudScriptPair->disabled;
                    popup->enabled[entryIdx] = 0;
                }
                entryIdx++;
            }
            popup->dipMode = 0;
            popup->titleNumber = 0;
            if (battleStatus->selectedMoveID == MOVE_DOUBLE_DIP) {
                popup->dipMode = 1;
                popup->titleNumber = battleStatus->itemUsesLeft;
            }
            if (battleStatus->selectedMoveID == MOVE_TRIPLE_DIP) {
                popup->dipMode = 2;
                popup->titleNumber = battleStatus->itemUsesLeft;
            }
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] < 0) {
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = 0;
            }
            popup->popupType = POPUP_MENU_USE_ITEM;
            popup->numEntries = entryIdx;
            initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP];
            popup->initialPos = initialPos;
            create_battle_popup_menu(popup);
            flush_popup_menu();
            gBattleSubState = BTL_SUBSTATE_DIPPING_CHOOSING;
            break;
        case BTL_SUBSTATE_DIPPING_CHOOSING:
            switch (popup->result) {
                case POPUP_RESULT_CHOOSING:
                    // do nothing while player is choosing from popup menu
                    break;
                case POPUP_RESULT_CANCEL:
                    btl_submenu_moves_resume_choose();
                    battleStatus->selectedMoveID = 0;
                    battleStatus->itemUsesLeft = 0;
                    gBattleSubState = BTL_SUBSTATE_ABILITIES_CHOOSING;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                    break;
                default:
                    battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_DIPPING_TARGET_CANCEL;
                    battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_DIPPING_TARGET_CHOSEN;
                    battleStatus->lastSelectedItem = popup->userIndex[popup->result - 1];
                    battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                    battleStatus->moveArgument = battleStatus->lastSelectedItem;
                    battleStatus->curTargetListFlags = gItemTable[battleStatus->moveArgument].targetFlags | TARGET_FLAG_PRIMARY_ONLY;
                    battleStatus->curAttackElement = 0;
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = popup->result - 1;
                    hide_popup_menu();
                    btl_submenu_moves_hide();
                    btl_main_menu_hide();
                    gBattleSubState = BTL_SUBSTATE_DIPPING_HANDOVER;
                    break;
            }
            break;
        case BTL_SUBSTATE_DIPPING_HANDOVER:
            if ((battleStatus->curButtonsPressed & BUTTON_B) && popup->result == POPUP_RESULT_CHOOSING) {
                show_popup_menu();
                btl_submenu_moves_restore_locked();
                btl_main_menu_restore_submenu();
                battleStatus->selectedMoveID = 0;
                gBattleSubState = BTL_SUBSTATE_DIPPING_REOPEN_MENU;
            } else {
                btl_submenu_moves_update();
                if (btl_main_menu_update()) {
                    btl_set_state(BATTLE_STATE_SELECT_TARGET);
                }
            }
            break;
        case BTL_SUBSTATE_DIPPING_REOPEN_MENU:
            btl_submenu_moves_update();
            if (btl_main_menu_update() != 0) {
                gBattleSubState = BTL_SUBSTATE_DIPPING_CHOOSING;
            }
            break;
        case BTL_SUBSTATE_DIPPING_TARGET_CANCEL:
            show_popup_menu();
            btl_submenu_moves_restore_locked();
            btl_main_menu_restore_submenu();
            btl_submenu_moves_update();
            gBattleSubState = BTL_SUBSTATE_DIPPING_REOPEN_MENU;
            break;
        case BTL_SUBSTATE_DIPPING_TARGET_CHOSEN:
            destroy_popup_menu();
            btl_submenu_moves_destroy();
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_ITEMS_BUILD_MENU:
            entryIdx = 0;
            for (i = 0; i < ARRAY_COUNT(playerData->invItems); i++) {
                if (playerData->invItems[i] == ITEM_NONE) {
                    continue;
                }
                itemData = &gItemTable[playerData->invItems[i]];
                hudScriptPair = &gItemHudScripts[itemData->hudElemID];
                if (!(itemData->typeFlags & ITEM_TYPE_FLAG_BATTLE_USABLE)) {
                    continue;
                }
                battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                battleStatus->moveArgument = playerData->invItems[i];
                battleStatus->curTargetListFlags = itemData->targetFlags;
                create_current_pos_target_list(playerActor);
                popup->ptrIcon[entryIdx] = hudScriptPair->enabled;
 
                popup->userIndex[entryIdx] = playerData->invItems[i];
                popup->enabled[entryIdx] = TRUE;
                popup->nameMsg[entryIdx] = itemData->nameMsg;
                popup->descMsg[entryIdx] = itemData->shortDescMsg;
                if (playerActor->targetListLength == 0) {
                    popup->ptrIcon[entryIdx] = hudScriptPair->disabled;
                    popup->enabled[entryIdx] = 0;
                }
                entryIdx++;
            }
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] < 0) {
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = 0;
            }
            initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP];
            popup->popupType = POPUP_MENU_USE_ITEM;
            popup->numEntries = entryIdx;
            popup->dipMode = 0;
            popup->titleNumber = 0;
            popup->initialPos = initialPos;
            create_battle_popup_menu(popup);
            flush_popup_menu();
            gBattleSubState = BTL_SUBSTATE_ITEMS_CHOOSING;
            break;
        case BTL_SUBSTATE_ITEMS_CHOOSING:
            switch(popup->result) {
                case POPUP_RESULT_CHOOSING:
                    // do nothing while player is choosing from popup menu
                    break;
                case POPUP_RESULT_CANCEL:
                    btl_main_menu_resume_choose();
                    BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                    BattleMenu_SwapDelay = 4;
                    gBattleSubState = BTL_SUBSTATE_MAIN_CHOOSING;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                    break;
                default:
                    battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_ITEMS_TARGET_CANCEL;
                    battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_ITEMS_TARGET_CHOSEN;
                    battleStatus->lastSelectedItem = popup->userIndex[popup->result - 1];
                    battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                    battleStatus->moveArgument = battleStatus->lastSelectedItem;
                    battleStatus->selectedMoveID = MOVE_ITEMS;
                    battleStatus->curTargetListFlags = gItemTable[battleStatus->moveArgument].targetFlags | TARGET_FLAG_PRIMARY_ONLY;
                    battleStatus->curAttackElement = 0;
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = popup->result - 1;
                    hide_popup_menu();
                    btl_main_menu_hide();
                    gBattleSubState = BTL_SUBSTATE_ITEMS_HANDOVER;
                    break;
            }
            break;
        case BTL_SUBSTATE_ITEMS_HANDOVER:
            if ((battleStatus->curButtonsPressed & BUTTON_B) && popup->result == POPUP_RESULT_CHOOSING) {
                show_popup_menu();
                btl_main_menu_restore_submenu();
                gBattleSubState = BTL_SUBSTATE_ITEMS_REOPEN_MENU;
            } else {
                if (btl_main_menu_update() != 0) {
                    btl_set_state(BATTLE_STATE_SELECT_TARGET);
                }
            }
            break;
        case BTL_SUBSTATE_ITEMS_REOPEN_MENU:
            if (btl_main_menu_update() != 0) {
                gBattleSubState = BTL_SUBSTATE_ITEMS_CHOOSING;
            }
            break;
        case BTL_SUBSTATE_ITEMS_TARGET_CANCEL:
            show_popup_menu();
            btl_main_menu_restore_submenu();
            gBattleSubState = BTL_SUBSTATE_ITEMS_REOPEN_MENU;
            break;
        case BTL_SUBSTATE_ITEMS_TARGET_CHOSEN:
            destroy_popup_menu();
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_STAR_SPIRITS_BUILD_MENU:
            for (i = 0; i < battleStatus->submenuMoveCount; i++) {
                moveData = &gMoveTable[battleStatus->submenuMoves[i]];
                MovesOptionError[i] = 0;
 
                if (battleStatus->submenuStatus[i] == 0) {
                    MovesOptionError[i] = 0;
                }
 
                if (battleStatus->submenuStatus[i] == -1) {
                    battleStatus->submenuStatus[i] = 0;
                    MovesOptionError[i] = BTL_MSG_CANT_SELECT_NOW;
                }
                if (battleStatus->submenuStatus[i] == -2) {
                    battleStatus->submenuStatus[i] = 0;
                    MovesOptionError[i] = BTL_MSG_CANT_SELECT_NOW;
                }
                if (!(battleStatus->enabledStarPowersFlags & (1 << i))) {
                    battleStatus->submenuStatus[i] = 0;
                    MovesOptionError[i] = BTL_MSG_CANT_SELECT_NOW;
                }
 
                MovesOptionHudScripts[i] = StarPowerMovesHudScripts[STAR_POWER_INDEX(battleStatus->submenuMoves[i])].enabled;
                if (battleStatus->submenuStatus[i] == 0) {
                    MovesOptionHudScripts[i] = StarPowerMovesHudScripts[STAR_POWER_INDEX(battleStatus->submenuMoves[i])].disabled;
                }
                MovesOptionDisplayCosts[i] = moveData->costFP;
                MovesOptionBPCosts[i] = moveData->costBP;
                MovesOptionSortPriority[i] = 0;
                MovesOptionIndices[i] = i;
                MovesOptionEnabled[i] = battleStatus->submenuStatus[i];
                MovesOptionNames[i] = moveData->nameMsg;
                MovesOptionDesc[i] = moveData->shortDescMsg;
                MovesOptionDiscounts[i] = 0;
                MovesOptionDiscountColors[i] = 0;
            }
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STAR_POWER] < 0) {
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STAR_POWER] = 0;
            }
            UsingSpiritsSubmenu = TRUE;
            MovesOptionCount = battleStatus->submenuMoveCount;
            initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STAR_POWER];
            MovesPrevSelected = initialPos;
            btl_submenu_moves_init();
            gBattleSubState = BTL_SUBSTATE_STAR_SPIRITS_CHOOSING;
            break;
        case BTL_SUBSTATE_STAR_SPIRITS_CHOOSING:
            submenuResult = btl_submenu_moves_update();
            switch(submenuResult) {
                case POPUP_RESULT_CHOOSING:
                    // do nothing while player is choosing from menu
                    break;
                case POPUP_RESULT_INVALID:
                    gBattleSubState = BTL_SUBSTATE_STAR_SPIRITS_SHOW_ERROR;
                    break;
                case POPUP_RESULT_CANCEL:
                    btl_main_menu_resume_choose();
                    BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                    BattleMenu_SwapDelay = 4;
                    gBattleSubState = BTL_SUBSTATE_MAIN_CHOOSING;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                    break;
                default:
                    battleStatus->lastSelectedAbility = MovesOptionIndices[submenuResult - 1];
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STAR_POWER] = SelectedMovesIndex;
                    btl_submenu_moves_hide();
                    btl_main_menu_hide();
                    gBattleSubState = BTL_SUBSTATE_STAR_SPIRITS_HANDOVER;
                    break;
            }
            break;
        case BTL_SUBSTATE_STAR_SPIRITS_HANDOVER:
            submenuResult = btl_submenu_moves_update();
            if ((battleStatus->curButtonsPressed & BUTTON_B) && submenuResult == 0) {
                btl_submenu_moves_restore_choose();
                btl_main_menu_restore_submenu();
                gBattleSubState = BTL_SUBSTATE_STAR_SPIRITS_REOPEN_MENU;
            } else if (btl_main_menu_update() != 0) {
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_STAR_SPIRITS_TARGET_CANCEL;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_STAR_SPIRITS_TARGET_CHOSEN;
                battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
                battleStatus->selectedMoveID = battleStatus->submenuMoves[battleStatus->lastSelectedAbility];
                battleStatus->curTargetListFlags = gMoveTable[battleStatus->submenuMoves[battleStatus->lastSelectedAbility]].flags;
                battleStatus->moveArgument = battleStatus->lastSelectedAbility;
                if (playerData->starBeamLevel == 2 && battleStatus->moveArgument == 8) {
                    battleStatus->moveArgument++;
                }
                btl_set_state(BATTLE_STATE_SELECT_TARGET);
            }
            break;
        case BTL_SUBSTATE_STAR_SPIRITS_REOPEN_MENU:
            btl_submenu_moves_update();
            if (btl_main_menu_update() != 0) {
                gBattleSubState = BTL_SUBSTATE_STAR_SPIRITS_CHOOSING;
            }
            break;
        case BTL_SUBSTATE_STAR_SPIRITS_TARGET_CANCEL:
            btl_submenu_moves_restore_choose();
            btl_main_menu_restore_submenu();
            gBattleSubState = BTL_SUBSTATE_STAR_SPIRITS_REOPEN_MENU;
            break;
        case BTL_SUBSTATE_STAR_SPIRITS_TARGET_CHOSEN:
            btl_submenu_moves_destroy();
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_STAR_SPIRITS_SHOW_ERROR:
            if (btl_submenu_moves_update() != POPUP_RESULT_INVALID) {
                gBattleSubState = BTL_SUBSTATE_STAR_SPIRITS_CHOOSING;
            }
            break;
        case BTL_SUBSTATE_NEXT_DIP_BUILD_MENU:
            if (!btl_player_can_act()) {
                battleStatus->itemUsesLeft = 1;
                btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
            } else {
                entryIdx = 0;
                for (i = 0; i < ARRAY_COUNT(playerData->invItems); i++) {
                    if (playerData->invItems[i] == ITEM_NONE) {
                        continue;
                    }
                    itemData = &gItemTable[playerData->invItems[i]];
                    hudScriptPair = &gItemHudScripts[itemData->hudElemID];
                    if (!(itemData->typeFlags & ITEM_TYPE_FLAG_BATTLE_USABLE)) {
                        continue;
                    }
 
                    battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                    battleStatus->moveArgument = playerData->invItems[i];
                    battleStatus->curTargetListFlags = itemData->targetFlags;
                    create_current_pos_target_list(playerActor);
                    popup->ptrIcon[entryIdx] = hudScriptPair->enabled;
                    popup->userIndex[entryIdx] = playerData->invItems[i];
                    popup->enabled[entryIdx] = TRUE;
                    popup->nameMsg[entryIdx] = itemData->nameMsg;
                    popup->descMsg[entryIdx] = itemData->shortDescMsg;
                    if (playerActor->targetListLength == 0) {
                        popup->ptrIcon[entryIdx] = hudScriptPair->disabled;
                        popup->enabled[entryIdx] = FALSE;
                    }
                    entryIdx++;
                }
                if (entryIdx == 0) {
                    battleStatus->itemUsesLeft = 1;
                    btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
                } else {
                    popup->popupType = POPUP_MENU_USE_ITEM;
                    if (battleStatus->selectedMoveID == MOVE_DOUBLE_DIP) {
                        popup->popupType += POPUP_MENU_DOUBLE_DIP;
                        popup->dipMode = 1;
                        popup->titleNumber = battleStatus->itemUsesLeft;
                    }
                    if (battleStatus->selectedMoveID == MOVE_TRIPLE_DIP) {
                        popup->popupType += POPUP_MENU_TRIPLE_DIP;
                        popup->dipMode = 2;
                        popup->titleNumber = battleStatus->itemUsesLeft;
                    }
                    if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] < 0) {
                        battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = 0;
                    }
                    popup->numEntries = entryIdx;
                    initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP];
                    popup->initialPos = initialPos;
                    create_battle_popup_menu(popup);
                    flush_popup_menu();
                    gBattleSubState = BTL_SUBSTATE_NEXT_DIP_CHOOSING;
                }
            }
            break;
        case BTL_SUBSTATE_NEXT_DIP_CHOOSING:
            switch(popup->result) {
                case POPUP_RESULT_CHOOSING:
                    // do nothing while player is choosing from menu
                    break;
                case POPUP_RESULT_CANCEL:
                    battleStatus->itemUsesLeft = 1;
                    btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
                    break;
                default:
                    battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_NEXT_DIP_TARGET_CANCEL;
                    battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_NEXT_DIP_TARGET_CHOSEN;
                    battleStatus->lastSelectedItem = popup->userIndex[popup->result - 1];
                    battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                    battleStatus->moveArgument = battleStatus->lastSelectedItem;
                    battleStatus->curTargetListFlags = gItemTable[battleStatus->moveArgument].targetFlags | TARGET_FLAG_PRIMARY_ONLY;
                    battleStatus->curAttackElement = 0;
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = popup->result - 1;
                    hide_popup_menu();
                    BattleMenu_ChooseDelay = MENU_DIPPING_DELAY;
                    gBattleSubState = BTL_SUBSTATE_NEXT_DIP_HANDOVER;
                    break;
            }
            break;
        case BTL_SUBSTATE_NEXT_DIP_HANDOVER:
            if (BattleMenu_ChooseDelay != 0) {
                BattleMenu_ChooseDelay--;
            } else {
                btl_set_state(BATTLE_STATE_SELECT_TARGET);
            }
            break;
        case BTL_SUBSTATE_NEXT_DIP_REOPEN_MENU:
            if (BattleMenu_ChooseDelay != 0) {
                BattleMenu_ChooseDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_NEXT_DIP_CHOOSING;
            }
            break;
        case BTL_SUBSTATE_NEXT_DIP_TARGET_CANCEL:
            show_popup_menu();
            BattleMenu_ChooseDelay = MENU_DIPPING_DELAY;
            gBattleSubState = BTL_SUBSTATE_NEXT_DIP_REOPEN_MENU;
            break;
        case BTL_SUBSTATE_NEXT_DIP_TARGET_CHOSEN:
            destroy_popup_menu();
            break;
        case BTL_SUBSTATE_BERSERKER_CHOOSE:
            if (playerData->bootsLevel > GEAR_RANK_NONE) {
                battleStatus->curTargetListFlags = gMoveTable[MOVE_BERSERKER_JUMP].flags;
                create_current_pos_target_list(playerActor);
                jumpTargetCount = playerActor->targetListLength;
            } else {
                jumpTargetCount = 0;
            }
 
            if (playerData->hammerLevel > GEAR_RANK_NONE) {
                battleStatus->curTargetListFlags = gMoveTable[MOVE_BERSERKER_HAMMER].flags;
                create_current_pos_target_list(playerActor);
                hammerTargetCount = playerActor->targetListLength;
            } else {
                hammerTargetCount = 0;
            }
 
            if (jumpTargetCount <= 0 && hammerTargetCount <= 0) {
                battleStatus->moveCategory = BTL_MENU_TYPE_DO_NOTHING;
                battleStatus->waitForState = BATTLE_STATE_NONE;
                btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
            } else {
                jumpChance = 50;
                if (jumpTargetCount <= 0) {
                    jumpChance = 0;
                }
                if (hammerTargetCount <= 0) {
                    jumpChance = 101;
                }
                if (rand_int(100) < jumpChance) {
                    battleStatus->selectedMoveID = MOVE_BERSERKER_JUMP;
                    battleStatus->moveCategory = BTL_MENU_TYPE_JUMP;
                    battleStatus->curTargetListFlags = gMoveTable[MOVE_BERSERKER_JUMP].flags;
                    battleStatus->moveArgument = playerData->bootsLevel;
                    create_current_pos_target_list(playerActor);
                } else {
                    battleStatus->selectedMoveID = MOVE_BERSERKER_HAMMER;
                    battleStatus->moveCategory = BTL_MENU_TYPE_SMASH;
                    battleStatus->curTargetListFlags = gMoveTable[MOVE_BERSERKER_HAMMER].flags;
                    battleStatus->moveArgument = playerData->hammerLevel;
                    create_current_pos_target_list(playerActor);
                }
                btl_set_state(BATTLE_STATE_PLAYER_MOVE);
            }
            break;
        case BTL_SUBSTATE_STRATEGIES_BUILD_MENU:
            entryIdx = 0;
            btl_check_can_change_partner();
 
            // add 'Change Member' command
            if (battleStatus->changePartnerAllowed >= 0) {
                StratsOptionMenuTypes[entryIdx] = BTL_MENU_TYPE_CHANGE_PARTNER;
                StratsOptionNames[entryIdx] = LeftJustMenuMessages[BTL_MENU_TYPE_CHANGE_PARTNER];
                StratsOptionHudScripts[entryIdx] = PartnerHudScripts[playerData->curPartner].enabled;
                StratsOptionEnabled[entryIdx] = TRUE;
                StratsOptionMessage[entryIdx] = MSG_Menus_Action_ChangePartner;
                if (battleStatus->changePartnerAllowed <= 0) {
                    StratsOptionHudScripts[entryIdx] = PartnerHudScripts[playerData->curPartner].disabled;
                    StratsOptionEnabled[entryIdx] = FALSE;
                    StratsOptionError[entryIdx] = 0;
                }
                entryIdx++;
            }
 
            // add 'Do Nothing' command
            StratsOptionHudScripts[entryIdx] = DoNothingHudScripts.enabled;
            StratsOptionMenuTypes[entryIdx] = BTL_MENU_TYPE_DO_NOTHING;
            StratsOptionEnabled[entryIdx] = TRUE;
            StratsOptionNames[entryIdx] = LeftJustMenuMessages[BTL_MENU_TYPE_DO_NOTHING];
            StratsOptionMessage[entryIdx] = MSG_Menus_Action_DoNothing;
            entryIdx++;
 
            // add 'Run Away' command
            StratsOptionHudScripts[entryIdx] = FleeHudScripts.enabled;
            StratsOptionMenuTypes[entryIdx] = BTL_MENU_TYPE_RUN_AWAY;
            StratsOptionEnabled[entryIdx] = TRUE;
            StratsOptionNames[entryIdx] = LeftJustMenuMessages[BTL_MENU_TYPE_RUN_AWAY];
            StratsOptionMessage[entryIdx] = MSG_Menus_Action_RunAway;
            if (!(gBattleStatus.flags2 & BS_FLAGS2_CAN_FLEE)) {
                StratsOptionHudScripts[entryIdx] = FleeHudScripts.disabled;
                StratsOptionEnabled[entryIdx] = FALSE;
                StratsOptionError[entryIdx] = 1;
            }
            entryIdx++;
 
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STRATEGY] < 0) {
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STRATEGY] = 0;
            }
            initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STRATEGY];
            StratsOptionCount = entryIdx;
            StratsPrevSelected = initialPos;
            btl_menu_strats_init();
            gBattleSubState = BTL_SUBSTATE_STRATEGIES_CHOOSING;
            break;
        case BTL_SUBSTATE_STRATEGIES_CHOOSING:
            submenuResult = btl_submenu_strats_update();
            switch(submenuResult) {
                case POPUP_RESULT_CHOOSING:
                    // do nothing while player is choosing from menu
                    break;
                case POPUP_RESULT_INVALID:
                    gBattleSubState = BTL_SUBSTATE_STRATEGIES_SHOW_ERROR;
                    break;
                case POPUP_RESULT_CANCEL:
                    btl_main_menu_resume_choose();
                    BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                    BattleMenu_SwapDelay = 4;
                    gBattleSubState = BTL_SUBSTATE_MAIN_CHOOSING;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                    break;
                default:
                    battleStatus->curSubmenu = StratsOptionMenuTypes[submenuResult - 1];
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STRATEGY] = submenuResult - 1;
                    if (battleStatus->curSubmenu == BTL_MENU_TYPE_CHANGE_PARTNER) {
                        gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_BUILD_MENU;
                        btl_state_update_player_menu();
                        btl_state_update_player_menu();
                    } else {
                        btl_submenu_strats_hide();
                        btl_main_menu_hide();
                        gBattleSubState = BTL_SUBSTATE_STRATEGIES_HANDOVER;
                    }
                    break;
                }
            break;
        case BTL_SUBSTATE_STRATEGIES_HANDOVER:
            submenuResult = btl_submenu_strats_update();
            if ((battleStatus->curButtonsPressed & BUTTON_B) && submenuResult == 0) {
                btl_submenu_strats_restore_choose();
                btl_main_menu_restore_submenu();
                gBattleSubState = BTL_SUBSTATE_STRATEGIES_REOPEN_MENU;
            } else if (btl_main_menu_update() != 0) {
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_STRATEGIES_TARGET_CANCEL;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_STRATEGIES_TARGET_CHOSEN;
                switch (battleStatus->curSubmenu) {
                    case BTL_MENU_TYPE_RUN_AWAY:
                        gBattleSubState = BTL_SUBSTATE_STRATEGIES_TARGET_CHOSEN;
                        btl_state_update_player_menu();
                        battleStatus->moveCategory = BTL_MENU_TYPE_RUN_AWAY;
                        battleStatus->selectedMoveID = MOVE_RUN_AWAY;
                        btl_set_state(BATTLE_STATE_RUN_AWAY);
                        break;
                    case BTL_MENU_TYPE_DO_NOTHING:
                        battleStatus->hustleTurns = 0;
                        gBattleStatus.flags1 &= ~BS_FLAGS1_HUSTLED;
                        gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                        btl_state_update_player_menu();
                        btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
                        break;
                    case BTL_MENU_TYPE_DEFEND:
                        gBattleSubState = BTL_SUBSTATE_STRATEGIES_TARGET_CHOSEN;
                        btl_state_update_player_menu();
                        battleStatus->moveCategory = BTL_MENU_TYPE_DEFEND;
                        battleStatus->selectedMoveID = MOVE_DEFEND;
                        btl_set_state(BATTLE_STATE_DEFEND);
                        break;
                    case BTL_MENU_TYPE_ACT_LATER:
                        gBattleSubState = BTL_SUBSTATE_STRATEGIES_TARGET_CHOSEN;
                        btl_state_update_player_menu();
                        btl_set_state(BATTLE_STATE_SWITCH_TO_PARTNER);
                        break;
                }
            }
            break;
        case BTL_SUBSTATE_STRATEGIES_REOPEN_MENU:
            btl_submenu_strats_update();
            if (btl_main_menu_update() != 0) {
                BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_MAIN_CHOOSING;
            }
            break;
        case BTL_SUBSTATE_STRATEGIES_TARGET_CANCEL:
            btl_submenu_strats_restore_choose();
            btl_main_menu_restore_submenu();
            gBattleSubState = BTL_SUBSTATE_STRATEGIES_REOPEN_MENU;
            break;
        case BTL_SUBSTATE_STRATEGIES_TARGET_CHOSEN:
            btl_submenu_strats_destroy();
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_STRATEGIES_SHOW_ERROR:
            if (btl_submenu_strats_update() != -1) {
                gBattleSubState = BTL_SUBSTATE_STRATEGIES_CHOOSING;
            }
            break;
        case BTL_SUBSTATE_CHANGE_PARTNER_BUILD_MENU:
            entryIdx = 0;
            for (i = 1; i < ARRAY_COUNT(playerData->partners); i++) {
                s32 partnerId = PartnerIDFromMenuIndex[i];
                if (playerData->partners[partnerId].enabled) {
                    prop = &gPartnerPopupProperties[partnerId];
                    popup->ptrIcon[entryIdx] = PartnerHudScripts[partnerId].enabled;
                    popup->enabled[entryIdx] = TRUE;
                    popup->userIndex[entryIdx] = partnerId;
                    popup->nameMsg[entryIdx] = prop->nameMsg;
                    popup->descMsg[entryIdx] = prop->battleDescMsg;
                    popup->value[entryIdx] = playerData->partners[partnerId].level;
                    if (playerData->curPartner == partnerId) {
                        popup->ptrIcon[entryIdx] = PartnerHudScripts[partnerId].disabled;
                        popup->enabled[entryIdx] = FALSE;
                    }
                    entryIdx++;
                }
            }
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_PARTNER] < 0) {
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_PARTNER] = 0;
            }
            popup->popupType = POPUP_MENU_SWITCH_PARTNER;
            popup->numEntries = entryIdx;
            popup->initialPos = MenuIndexFromPartnerID[playerData->curPartner] - 1;
            popup->dipMode = 0;
            popup->titleNumber = 0;
            create_battle_popup_menu(popup);
            flush_popup_menu();
            gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_CHOOSING;
            break;
        case BTL_SUBSTATE_CHANGE_PARTNER_CHOOSING:
            switch(popup->result) {
                case POPUP_RESULT_CHOOSING:
                    // do nothing while player is choosing from menu
                    break;
                case POPUP_RESULT_INVALID:
                    gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_ERROR;
                    break;
                case POPUP_RESULT_CANCEL:
                    btl_submenu_strats_resume_choose();
                    gBattleSubState = BTL_SUBSTATE_STRATEGIES_CHOOSING;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                    break;
                default:
                    battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_CHANGE_PARTNER_TARGET_CANCEL;
                    battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_CHANGE_PARTNER_TARGET_CHOSEN;
                    battleStatus->lastSelectedPartner = popup->userIndex[popup->result - 1];
                    battleStatus->moveCategory = BTL_MENU_TYPE_CHANGE_PARTNER;
                    battleStatus->selectedMoveID = MOVE_CHANGE_PARTNER;
                    battleStatus->curTargetListFlags = TARGET_FLAG_2;
                    battleStatus->moveArgument = battleStatus->lastSelectedPartner;
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_PARTNER] = popup->result - 1;
                    hide_popup_menu();
                    btl_submenu_strats_hide();
                    btl_main_menu_hide();
                    gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_HANDOVER;
                    break;
            }
            break;
        case BTL_SUBSTATE_CHANGE_PARTNER_HANDOVER:
            if ((battleStatus->curButtonsPressed & BUTTON_B) && popup->result == POPUP_RESULT_CHOOSING) {
                show_popup_menu();
                btl_submenu_strats_restore_locked();
                btl_main_menu_restore_submenu();
                gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_REOPEN_MENU;
            } else {
                btl_submenu_strats_update();
                if (btl_main_menu_update() != 0) {
                    gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                    btl_state_update_player_menu();
                    btl_set_state(BATTLE_STATE_CHANGE_PARTNER);
                }
            }
            break;
        case BTL_SUBSTATE_CHANGE_PARTNER_REOPEN_MENU:
            btl_submenu_strats_update();
            if (btl_main_menu_update() != 0) {
                gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_CHOOSING;
            }
            break;
        case BTL_SUBSTATE_CHANGE_PARTNER_TARGET_CANCEL:
            show_popup_menu();
            btl_submenu_strats_restore_locked();
            btl_main_menu_restore_submenu();
            gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_REOPEN_MENU;
            break;
        case BTL_SUBSTATE_CHANGE_PARTNER_TARGET_CHOSEN:
            destroy_popup_menu();
            btl_submenu_strats_destroy();
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_CHANGE_PARTNER_ERROR:
            set_window_update(WIN_BTL_STRATS_MENU, WINDOW_UPDATE_HIDE);
            set_window_update(WIN_BTL_STRATS_TITLE, WINDOW_UPDATE_HIDE);
            if (popup->result != POPUP_RESULT_INVALID) {
                set_window_update(WIN_BTL_STRATS_MENU, WINDOW_UPDATE_9);
                set_window_update(WIN_BTL_STRATS_TITLE, WINDOW_UPDATE_9);
                gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_CHOOSING;
            }
            break;
    }
}

Referenced by btl_state_update_player_menu(), btl_state_update_select_target(), and btl_update().

◆ btl_state_draw_player_menu()

void btl_state_draw_player_menu ( void )

Definition at line 1687 of file menu_player.c.

                                      {
    switch (gBattleSubState) {
        case BTL_SUBSTATE_MAIN_CHOOSING:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_ABILITIES_CHOOSING:
        case BTL_SUBSTATE_ABILITIES_HANDOVER:
        case BTL_SUBSTATE_ABILITIES_REOPEN_MENU:
        case BTL_SUBSTATE_ABILITIES_TARGET_CANCEL:
        case BTL_SUBSTATE_NOSUBMENU_SHOW:
        case BTL_SUBSTATE_NOSUBMENU_HANDOVER:
        case BTL_SUBSTATE_NOSUBMENU_RETURN_MAIN:
        case BTL_SUBSTATE_NOSUBMENU_TARGET_CANCEL:
        case BTL_SUBSTATE_DIPPING_BUILD_MENU:
        case BTL_SUBSTATE_DIPPING_CHOOSING:
        case BTL_SUBSTATE_DIPPING_HANDOVER:
        case BTL_SUBSTATE_DIPPING_REOPEN_MENU:
        case BTL_SUBSTATE_DIPPING_TARGET_CANCEL:
        case BTL_SUBSTATE_CHANGE_PARTNER_BUILD_MENU:
        case BTL_SUBSTATE_CHANGE_PARTNER_CHOOSING:
        case BTL_SUBSTATE_CHANGE_PARTNER_HANDOVER:
        case BTL_SUBSTATE_CHANGE_PARTNER_REOPEN_MENU:
        case BTL_SUBSTATE_CHANGE_PARTNER_TARGET_CANCEL:
        case BTL_SUBSTATE_ITEMS_BUILD_MENU:
        case BTL_SUBSTATE_ITEMS_CHOOSING:
        case BTL_SUBSTATE_ITEMS_HANDOVER:
        case BTL_SUBSTATE_ITEMS_REOPEN_MENU:
        case BTL_SUBSTATE_ITEMS_TARGET_CANCEL:
        case BTL_SUBSTATE_STAR_SPIRITS_CHOOSING:
        case BTL_SUBSTATE_STAR_SPIRITS_HANDOVER:
        case BTL_SUBSTATE_STAR_SPIRITS_REOPEN_MENU:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_STAR_SPIRITS_TARGET_CANCEL:
        case BTL_SUBSTATE_STAR_SPIRITS_TARGET_CHOSEN:
        case BTL_SUBSTATE_STRATEGIES_BUILD_MENU:
        case BTL_SUBSTATE_STRATEGIES_CHOOSING:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_STRATEGIES_HANDOVER:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_STRATEGIES_REOPEN_MENU:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_STRATEGIES_TARGET_CANCEL:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_STRATEGIES_TARGET_CHOSEN:
            btl_main_menu_draw();
            break;
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_partner_menu()

void btl_state_update_partner_menu ( void )

Definition at line 281 of file menu_partner.c.

                                         {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* playerActor = battleStatus->playerActor;
    Actor* partnerActor = battleStatus->partnerActor;
    PopupMenu* popupMenu = &BattlePopupMenu;
    s32 entryIdx;
    s32 i;
    s32 popupIndex;
    s32 initialPos;
    MoveData* moveData;
    PartnerPopupProperties* popupProps;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        battleStatus->moveCategory = BTL_MENU_TYPE_INVALID;
        battleStatus->selectedMoveID = MOVE_NONE;
        battleStatus->curAttackElement = 0;
        if (!btl_partner_can_act()) {
            btl_set_state(BATTLE_STATE_TRANSFER_TURN);
        } else {
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            battleStatus->flags1 |= BS_FLAGS1_MENU_OPEN;
            playerActor->flags &= ~(ACTOR_FLAG_USING_IDLE_ANIM | ACTOR_FLAG_SHOW_STATUS_ICONS);
            partnerActor->flags &= ~(ACTOR_FLAG_USING_IDLE_ANIM | ACTOR_FLAG_SHOW_STATUS_ICONS);
            if (battleStatus->flags1 & BS_FLAGS1_PLAYER_IN_BACK) {
                gBattleSubState = BTL_SUBSTATE_CREATE_MAIN_MENU;
            } else {
                gBattleSubState = BTL_SUBSTATE_PERFORM_SWAP;
                partnerActor->state.curPos.x = partnerActor->homePos.x;
                partnerActor->state.curPos.z = partnerActor->homePos.z;
                partnerActor->state.goalPos.x = playerActor->homePos.x;
                partnerActor->state.goalPos.z = playerActor->homePos.z;
                partnerActor->state.moveTime = 4;
                partnerActor->state.angle = 0.0f;
            }
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_PERFORM_SWAP) {
        if (partnerActor->state.moveTime != 0) {
            partnerActor->curPos.x += (partnerActor->state.goalPos.x - partnerActor->curPos.x) / partnerActor->state.moveTime;
            partnerActor->curPos.z += (partnerActor->state.goalPos.z - partnerActor->curPos.z) / partnerActor->state.moveTime;
            playerActor->curPos.x += (partnerActor->state.curPos.x - playerActor->curPos.x) / partnerActor->state.moveTime;
            playerActor->curPos.z += (partnerActor->state.curPos.z - playerActor->curPos.z) / partnerActor->state.moveTime;
        }
        partnerActor->curPos.z += sin_rad(DEG_TO_RAD(partnerActor->state.angle)) * 16.0f;
        partnerActor->yaw = clamp_angle(-partnerActor->state.angle);
        playerActor->curPos.z -= sin_rad(DEG_TO_RAD(partnerActor->state.angle)) * 16.0f;
        playerActor->yaw = clamp_angle(-partnerActor->state.angle);
        partnerActor->state.angle += 90.0f;
        if (partnerActor->state.moveTime != 0) {
            partnerActor->state.moveTime--;
        } else {
            gBattleSubState = BTL_SUBSTATE_CREATE_MAIN_MENU;
            partnerActor->curPos.x = partnerActor->state.goalPos.x;
            partnerActor->curPos.z = partnerActor->state.goalPos.z;
            playerActor->curPos.x = partnerActor->state.curPos.x;
            playerActor->curPos.z = partnerActor->state.curPos.z;
            partnerActor->homePos.x = partnerActor->curPos.x;
            partnerActor->homePos.z = partnerActor->curPos.z;
            playerActor->homePos.x = playerActor->curPos.x;
            playerActor->homePos.z = playerActor->curPos.z;
            gBattleStatus.flags1 |= BS_FLAGS1_PLAYER_IN_BACK;
        }
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CREATE_MAIN_MENU:
            partnerActor->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            partnerActor->flags &= ~ACTOR_FLAG_USING_IDLE_ANIM;
            playerActor->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            playerActor->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            btl_init_menu_items();
            btl_check_can_change_partner();
 
            // default menu position is section option: abilities
            // will be overridden by most recently selected option, if one exists
            initialPos = 1;
            entryIdx = 0;
 
            if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] < 0) {
                battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] = BTL_MENU_TYPE_ABILITY;
            }
            btl_init_menu_partner();
            btl_check_can_change_partner();
 
            // strategies menu category
            WheelOptionSubmenu[entryIdx] = BTL_MENU_TYPE_STRATEGIES;
            WheelOptionEnabled[entryIdx] = TRUE;
            WheelOptionError[entryIdx] = 0;
            WheelOptionHudScript[entryIdx] = StrategiesHudScripts.enabled;
            WheelOptionName[entryIdx] = CenteredBattleMessages[BTL_MENU_TYPE_STRATEGIES];
            if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_STRATEGIES)) {
                WheelOptionEnabled[entryIdx] = FALSE;
                WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                WheelOptionHudScript[entryIdx] = StrategiesHudScripts.disabled;
            }
            if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_STRATEGIES) {
                initialPos = entryIdx;
            }
            entryIdx++;
 
            // abilities menu category
            WheelOptionHudScript[entryIdx] = PartnerMoveHudScripts[playerData->curPartner][0].enabled;
            WheelOptionSubmenu[entryIdx] = BTL_MENU_TYPE_ABILITY;
            WheelOptionEnabled[entryIdx] = TRUE;
            WheelOptionName[entryIdx] = CenteredBattleMessages[BTL_MENU_TYPE_ABILITY];
            if (battleStatus->menuStatus[3] <= 0) {
                WheelOptionHudScript[entryIdx] = PartnerMoveHudScripts[playerData->curPartner][0].disabled;
                WheelOptionEnabled[entryIdx] = FALSE;
                WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
            }
            if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_ABILITIES)) {
                WheelOptionHudScript[entryIdx] = PartnerMoveHudScripts[playerData->curPartner][0].disabled;
                WheelOptionEnabled[entryIdx] = FALSE;
                WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
            }
            if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_ABILITY) {
                initialPos = entryIdx;
            }
            entryIdx++;
 
            // focus menu category
            if (playerData->maxStarPower != 0 && is_ability_active(ABILITY_GROUP_FOCUS)) {
                WheelOptionSubmenu[entryIdx] = BTL_MENU_TYPE_PARTNER_FOCUS;
                WheelOptionEnabled[entryIdx] = TRUE;
                WheelOptionError[entryIdx] = 0;
                WheelOptionHudScript[entryIdx] = StarPowersHudScripts.enabled;
                WheelOptionName[entryIdx] = CenteredBattleMessages[BTL_MENU_TYPE_PARTNER_FOCUS];
                if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_PARTNER_FOCUS)) {
                    WheelOptionEnabled[entryIdx] = FALSE;
                    WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                    WheelOptionHudScript[entryIdx] = StarPowersHudScripts.disabled;
                }
                if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_PARTNER_FOCUS) {
                    initialPos = entryIdx;
                }
                entryIdx++;
            }
 
            WheelOptionCount = entryIdx;
            BattleMenu_PrevSelected = initialPos;
            BattleMenu_WheelBase = 2 - initialPos;
            if (btl_player_can_act()) {
                BattleMenu_ShowSwapIcons = TRUE;
            } else {
                BattleMenu_ShowSwapIcons = FALSE;
            }
            btl_main_menu_init();
            BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
            BattleMenu_SwapDelay = 0;
            gBattleSubState = BTL_SUBSTATE_MAIN_BEGIN;
            return;
        case BTL_SUBSTATE_MAIN_BEGIN:
            set_actor_anim(ACTOR_PARTNER, 0, PartnerThinkAnims[playerData->curPartner]);
            gBattleSubState = BTL_SUBSTATE_MAIN_CHOOSING;
            // fall through
        case BTL_SUBSTATE_MAIN_CHOOSING:
            entryIdx = btl_main_menu_update();
 
            if (BattleMenu_SwapDelay != 0) {
                BattleMenu_SwapDelay--;
            } else if (!(gBattleStatus.flags1 & BS_FLAGS1_TUTORIAL_BATTLE) && (gGameStatusPtr->pressedButtons[0] & BUTTON_Z)) {
                if (btl_player_can_act()) {
                    sfx_play_sound(SOUND_PARTNER_SWAP_BATTLE_POS);
                    battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] = WheelOptionSubmenu[BattleMenu_CurPos + BattleMenu_HomePos];
                    btl_main_menu_destroy();
                    btl_set_state(BATTLE_STATE_SWITCH_TO_PLAYER);
                } else {
                    sfx_play_sound(SOUND_MENU_ERROR);
                    gBattleSubState = BTL_SUBSTATE_MAIN_SHOW_CANT_SWAP;
                }
                break;
            }
 
            if (BattleMenu_ChooseDelay != 0) {
                BattleMenu_ChooseDelay--;
                break;
            }
 
            if (entryIdx != 0) {
                set_actor_anim(ACTOR_PARTNER, 0, PartnerIdleAnims[playerData->curPartner]);
                battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] = battleStatus->curPartnerSubmenu = WheelOptionSubmenu[entryIdx - 1];
                switch (battleStatus->curPartnerSubmenu) {
                    case BTL_MENU_TYPE_STRATEGIES:
                        gBattleSubState = BTL_SUBSTATE_STRATEGIES_BUILD_MENU;
                        btl_state_update_partner_menu();
                        btl_state_update_partner_menu();
                        break;
                    case BTL_MENU_TYPE_ABILITY:
                        gBattleSubState = BTL_SUBSTATE_ABILITIES_BUILD_MENU;
                        btl_state_update_partner_menu();
                        btl_state_update_partner_menu();
                        break;
                    case BTL_MENU_TYPE_STAR_POWERS:
                        gBattleSubState = BTL_SUBSTATE_FOCUS_BUILD_MENU;
                        btl_state_update_partner_menu();
                        btl_state_update_partner_menu();
                        break;
                    case BTL_MENU_TYPE_ITEMS:
                        gBattleSubState = BTL_SUBSTATE_ITEMS_BUILD_MENU;
                        btl_state_update_partner_menu();
                        btl_state_update_partner_menu();
                        break;
                    case BTL_MENU_TYPE_CHANGE_PARTNER:
                        gBattleSubState = BTL_SUBSTATE_UNUSED_CHANGE_BUILD_MENU;
                        btl_state_update_partner_menu();
                        btl_state_update_partner_menu();
                        break;
                    default:
                        battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_MAIN_TARGET_CANCEL;
                        battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_MAIN_TARGET_CHOSEN;
                        btl_main_menu_hide();
                        gBattleSubState = BTL_SUBSTATE_MAIN_HANDOVER;
                        break;
                }
            }
            break;
    case BTL_SUBSTATE_MAIN_HANDOVER:
        entryIdx = btl_main_menu_update();
        if ((battleStatus->curButtonsPressed & BUTTON_B) && entryIdx == 0) {
            btl_main_menu_restore_choose();
            gBattleSubState = BTL_SUBSTATE_MAIN_REOPEN_MENU;
            return;
        }
        if (entryIdx != 0) {
            battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
            battleStatus->selectedMoveID = MOVE_FOCUS;
            battleStatus->moveArgument = 0;
            battleStatus->curTargetListFlags = gMoveTable[MOVE_FOCUS].flags;
            btl_set_state(BATTLE_STATE_SELECT_TARGET);
            return;
        }
        break;
    case BTL_SUBSTATE_MAIN_REOPEN_MENU:
        if (btl_main_menu_update() != 0) {
            BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
            BattleMenu_SwapDelay = 4;
            gBattleSubState = BTL_SUBSTATE_MAIN_BEGIN;
        }
        break;
    case BTL_SUBSTATE_MAIN_TARGET_CANCEL:
        btl_main_menu_restore_choose();
        gBattleSubState = BTL_SUBSTATE_MAIN_REOPEN_MENU;
        break;
    case BTL_SUBSTATE_MAIN_TARGET_CHOSEN:
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_MAIN_SHOW_CANT_SWAP:
        if (!btl_player_can_act()) {
            btl_show_variable_battle_message(BTL_MSG_CANT_MOVE, 60, 0);
        } else {
            btl_show_variable_battle_message(BTL_MSG_CANT_SWITCH, 60, 0);
        }
        ShowingErrorMessage = TRUE;
        gBattleSubState = BTL_SUBSTATE_MAIN_AWAIT_CANT_SWAP;
        break;
    case BTL_SUBSTATE_MAIN_AWAIT_CANT_SWAP:
        if (btl_is_popup_displayed()) {
            break;
        }
        ShowingErrorMessage = FALSE;
        BattleMenu_ChooseDelay = 0;
        BattleMenu_SwapDelay = 4;
        gBattleSubState = BTL_SUBSTATE_MAIN_BEGIN;
        break;
    case BTL_SUBSTATE_ABILITIES_BUILD_MENU:
        for (i = 0; i < battleStatus->submenuMoveCount; i++) {
            moveData = &gMoveTable[battleStatus->submenuMoves[i]];
 
            MovesOptionError[i] = 0;
            if (battleStatus->submenuStatus[i] == 0) {
                MovesOptionError[i] = 0;
            }
            if (battleStatus->submenuStatus[i] == -1) {
                battleStatus->submenuStatus[i] = 0;
                MovesOptionError[i] = BTL_MSG_CANT_SELECT_NOW;
            }
            if (battleStatus->submenuStatus[i] == -2) {
                battleStatus->submenuStatus[i] = 0;
                MovesOptionError[i] = BTL_MSG_CANT_SELECT_NOW;
            }
            MovesOptionHudScripts[i] = PartnerMoveHudScripts[playerData->curPartner][i + 1].enabled;
            if (battleStatus->submenuStatus[i] == 0) {
                MovesOptionHudScripts[i] = PartnerMoveHudScripts[playerData->curPartner][i + 1].disabled;
            }
            MovesOptionIndices[i] = battleStatus->submenuMoves[i];
            MovesOptionEnabled[i] = battleStatus->submenuStatus[i];
            MovesOptionNames[i] = moveData->nameMsg;
            MovesOptionDesc[i] = moveData->shortDescMsg;
            MovesOptionDisplayCosts[i] = moveData->costFP;
            MovesOptionBPCosts[i] = moveData->costBP;
            MovesOptionSortPriority[i] = i;
 
            MovesOptionDiscounts[i] = 0;
            MovesOptionDiscountColors[i] = 0;
            if (player_team_is_ability_active(playerActor, ABILITY_FLOWER_SAVER)) {
                MovesOptionDiscounts[i] += player_team_is_ability_active(playerActor, ABILITY_FLOWER_SAVER);
                MovesOptionDiscountColors[i] = 1;
            }
            if (player_team_is_ability_active(playerActor, ABILITY_FLOWER_FANATIC)) {
                MovesOptionDiscounts[i] += player_team_is_ability_active(playerActor, ABILITY_FLOWER_FANATIC) * 2;
                MovesOptionDiscountColors[i] = 2;
            }
        }
        if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_ABILITY] < 0) {
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_ABILITY] = 0;
        }
        UsingSpiritsSubmenu = FALSE;
        MovesOptionCount = battleStatus->submenuMoveCount;
        initialPos = battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_ABILITY];
        MovesPrevSelected = initialPos;
        btl_submenu_moves_init();
        gBattleSubState = BTL_SUBSTATE_ABILITIES_CHOOSING;
        break;
    case BTL_SUBSTATE_ABILITIES_CHOOSING:
        entryIdx = btl_submenu_moves_update();
        switch (entryIdx) {
            case POPUP_RESULT_CHOOSING:
                // do nothing while player is choosing from popup menu
                break;
            case POPUP_RESULT_INVALID:
                gBattleSubState = BTL_SUBSTATE_ABILITIES_SHOW_ERROR;
                break;
            case POPUP_RESULT_CANCEL:
                btl_main_menu_resume_choose();
                BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_MAIN_BEGIN;
                btl_state_update_partner_menu();
                btl_state_update_partner_menu();
                break;
            default:
                battleStatus->lastPartnerPowerSelection = entryIdx - 1;
                btl_submenu_moves_hide();
                btl_main_menu_hide();
                gBattleSubState = BTL_SUBSTATE_ABILITIES_HANDOVER;
                break;
        }
        break;
    case BTL_SUBSTATE_ABILITIES_HANDOVER:
        entryIdx = btl_submenu_moves_update();
        if ((battleStatus->curButtonsPressed & BUTTON_B) && entryIdx == 0) {
            btl_submenu_moves_restore_choose();
            btl_main_menu_restore_submenu();
            gBattleSubState = BTL_SUBSTATE_ABILITIES_REOPEN_MENU;
        } else if (btl_main_menu_update() != 0) {
            battleStatus->moveCategory = BTL_MENU_TYPE_ABILITY;
            battleStatus->selectedMoveID = MovesOptionIndices[battleStatus->lastPartnerPowerSelection];
            battleStatus->curTargetListFlags = gMoveTable[battleStatus->selectedMoveID].flags;
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_ABILITY] = SelectedMovesIndex;
            battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_ABILITIES_TARGET_CANCEL;
            battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_ABILITIES_TARGET_CHOSEN;
            btl_set_state(BATTLE_STATE_SELECT_TARGET);
        }
        break;
    case BTL_SUBSTATE_ABILITIES_REOPEN_MENU:
        btl_submenu_moves_update();
        if (btl_main_menu_update() != 0) {
            gBattleSubState = BTL_SUBSTATE_ABILITIES_CHOOSING;
        }
        break;
    case BTL_SUBSTATE_ABILITIES_TARGET_CANCEL:
        btl_submenu_moves_restore_choose();
        btl_main_menu_restore_submenu();
        gBattleSubState = BTL_SUBSTATE_ABILITIES_REOPEN_MENU;
        break;
    case BTL_SUBSTATE_ABILITIES_TARGET_CHOSEN:
        btl_submenu_moves_destroy();
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_ABILITIES_SHOW_ERROR:
        if (btl_submenu_moves_update() != -1) {
            gBattleSubState = BTL_SUBSTATE_ABILITIES_CHOOSING;
        }
        break;
    case BTL_SUBSTATE_ITEMS_BUILD_MENU:
        popupIndex = 0;
        for (i = 0; i < ARRAY_COUNT(playerData->invItems); i++) {
            ItemData* item;
            HudScript** hudScript;
            if (playerData->invItems[i] == ITEM_NONE) {
                continue;
            }
            item = &gItemTable[playerData->invItems[i]];
            hudScript = &gItemHudScripts[item->hudElemID].enabled;
 
            if (!(item->typeFlags & ITEM_TYPE_FLAG_BATTLE_USABLE)) {
                continue;
            }
            popupMenu->ptrIcon[popupIndex] = hudScript[0];
            popupMenu->userIndex[popupIndex] = playerData->invItems[i];
            popupMenu->enabled[popupIndex] = TRUE;
            popupMenu->nameMsg[popupIndex] = item->nameMsg;
            popupMenu->descMsg[popupIndex] = item->shortDescMsg;
            popupIndex++;
        }
        if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER_ITEM] < 0) {
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER_ITEM] = 0;
        }
        popupMenu->popupType = POPUP_MENU_USE_ITEM;
        popupMenu->numEntries = popupIndex;
        popupMenu->dipMode = 0;
        popupMenu->titleNumber = 0;
        initialPos = battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER_ITEM];
        popupMenu->initialPos = initialPos;
        create_battle_popup_menu(popupMenu);
        flush_popup_menu();
        gBattleSubState = BTL_SUBSTATE_ITEMS_CHOOSING;
        break;
    case BTL_SUBSTATE_ITEMS_CHOOSING:
        switch (popupMenu->result) {
            case POPUP_RESULT_CHOOSING:
                // do nothing while player is choosing from menu
                break;
            case POPUP_RESULT_CANCEL:
                btl_main_menu_resume_choose();
                BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_MAIN_BEGIN;
                btl_state_update_partner_menu();
                btl_state_update_partner_menu();
                break;
            default: // something has been selected
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_ITEMS_TARGET_CANCEL;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_ITEMS_TARGET_CHOSEN;
                battleStatus->lastSelectedItem = popupMenu->userIndex[popupMenu->result - 1];
                battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                battleStatus->moveArgument = battleStatus->lastSelectedItem;
                battleStatus->curTargetListFlags = gItemTable[battleStatus->moveArgument].targetFlags | TARGET_FLAG_PRIMARY_ONLY;
                battleStatus->curAttackElement = 0;
                battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER_ITEM] = popupMenu->result - 1;
                hide_popup_menu();
                btl_main_menu_hide();
                gBattleSubState = BTL_SUBSTATE_ITEMS_HANDOVER;
                break;
        }
        break;
    case BTL_SUBSTATE_ITEMS_REOPEN_MENU:
        if (btl_main_menu_update() != 0) {
            gBattleSubState = BTL_SUBSTATE_ITEMS_CHOOSING;
        }
        break;
    case BTL_SUBSTATE_ITEMS_HANDOVER:
        if ((battleStatus->curButtonsPressed & BUTTON_B) && popupMenu->result == POPUP_RESULT_CHOOSING) {
            show_popup_menu();
            btl_main_menu_restore_submenu();
            gBattleSubState = BTL_SUBSTATE_ITEMS_REOPEN_MENU;
        } else if (btl_main_menu_update() != 0) {
            btl_set_state(BATTLE_STATE_SELECT_TARGET);
        }
        break;
    case BTL_SUBSTATE_ITEMS_TARGET_CANCEL:
        show_popup_menu();
        btl_main_menu_restore_submenu();
        gBattleSubState = BTL_SUBSTATE_ITEMS_REOPEN_MENU;
        break;
    case BTL_SUBSTATE_ITEMS_TARGET_CHOSEN:
        destroy_popup_menu();
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_UNUSED_CHANGE_BUILD_MENU:
        popupIndex = 0;
        for (i = 1; i < ARRAY_COUNT(PartnerIDFromMenuIndex); i++) {
            s32 partnerId = PartnerIDFromMenuIndex[i];
            if (playerData->partners[partnerId].enabled) {
                popupProps = &gPartnerPopupProperties[partnerId];
                popupMenu->ptrIcon[popupIndex] = PartnerHudScripts[partnerId].enabled;
                popupMenu->enabled[popupIndex] = TRUE;
                popupMenu->userIndex[popupIndex] = partnerId;
                popupMenu->nameMsg[popupIndex] = popupProps->nameMsg;
                popupMenu->descMsg[popupIndex] = popupProps->battleDescMsg;
                popupMenu->value[popupIndex] = playerData->partners[partnerId].level;
                if (playerData->curPartner == partnerId) {
                    popupMenu->ptrIcon[popupIndex] = PartnerHudScripts[partnerId].disabled;
                    popupMenu->enabled[popupIndex] = FALSE;
                }
                popupIndex++;
            }
        }
        if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER] < 0) {
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER] = 0;
        }
        popupMenu->popupType = POPUP_MENU_SWITCH_PARTNER;
        popupMenu->numEntries = popupIndex;
        popupMenu->initialPos = MenuIndexFromPartnerID[playerData->curPartner] - 1;
        popupMenu->dipMode = 0;
        popupMenu->titleNumber = 0;
        create_battle_popup_menu(popupMenu);
        flush_popup_menu();
        gBattleSubState = BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_CHOOSING;
        break;
    case BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_CHOOSING:
        switch (popupMenu->result) {
            case POPUP_RESULT_CHOOSING:
                // do nothing while player is choosing from popup menu
                break;
            case POPUP_RESULT_INVALID:
                gBattleSubState = BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_SHOW_ERROR;
                break;
            case POPUP_RESULT_CANCEL:
                btl_main_menu_resume_choose();
                BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_MAIN_BEGIN;
                btl_state_update_partner_menu();
                btl_state_update_partner_menu();
                break;
            default:
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_TARGET_CANCEL;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_TARGET_CHOSEN;
                battleStatus->lastSelectedPartner = popupMenu->userIndex[popupMenu->result - 1];
                battleStatus->moveCategory = BTL_MENU_TYPE_CHANGE_PARTNER;
                battleStatus->selectedMoveID = MOVE_CHANGE_PARTNER;
                battleStatus->curTargetListFlags = TARGET_FLAG_2;
                battleStatus->moveArgument = battleStatus->lastSelectedPartner;
                battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER] = popupMenu->result - 1;
                hide_popup_menu();
                btl_main_menu_hide();
                gBattleSubState = BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_HANDOVER;
                break;
        }
        break;
    case BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_HANDOVER:
        if ((battleStatus->curButtonsPressed & BUTTON_B) && (popupMenu->result == POPUP_RESULT_CHOOSING)) {
            show_popup_menu();
            btl_main_menu_restore_submenu();
            gBattleSubState = BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_REOPEN_MENU;
        } else if (btl_main_menu_update() != 0) {
            gBattleSubState = battleStatus->acceptTargetMenuSubstate;
            btl_state_update_partner_menu();
            btl_set_state(BATTLE_STATE_CHANGE_PARTNER);
        }
        break;
    case BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_REOPEN_MENU:
        if (btl_main_menu_update() != 0) {
            gBattleSubState = BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_CHOOSING;
        }
        break;
    case BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_TARGET_CANCEL:
        show_popup_menu();
        btl_main_menu_restore_submenu();
        gBattleSubState = BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_REOPEN_MENU;
        break;
    case BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_TARGET_CHOSEN:
        destroy_popup_menu();
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_SHOW_ERROR:
        if (popupMenu->result != POPUP_RESULT_INVALID) {
            gBattleSubState = BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_CHOOSING;
        }
        break;
    case BTL_SUBSTATE_FOCUS_BUILD_MENU:
        entryIdx = 1;
        battleStatus->submenuMoveCount = entryIdx;
        battleStatus->submenuMoves[0] = MOVE_FOCUS;
        battleStatus->submenuIcons[0] = ITEM_PARTNER_ATTACK;
        battleStatus->submenuStatus[0] = 1;
        for (i = 0; i < battleStatus->submenuMoveCount; i++) {
            moveData = &gMoveTable[battleStatus->submenuMoves[i]];
            MovesOptionHudScripts[i] = StarPowerMovesHudScripts[STAR_POWER_INDEX(battleStatus->submenuMoves[i])].enabled;
            if (battleStatus->submenuStatus[i] == 0) {
                MovesOptionHudScripts[i] = StarPowerMovesHudScripts[STAR_POWER_INDEX(battleStatus->submenuMoves[i])].disabled;
            }
            MovesOptionDisplayCosts[i] = moveData->costFP;
            MovesOptionBPCosts[i] = moveData->costBP;
            MovesOptionIndices[i] = i;
            MovesOptionSortPriority[i] = i;
            MovesOptionEnabled[i] = battleStatus->submenuStatus[i];
            MovesOptionNames[i] = moveData->nameMsg;
            MovesOptionDesc[i] = moveData->shortDescMsg;
            MovesOptionDiscounts[i] = 0;
            MovesOptionDiscountColors[i] = 0;
        }
        if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STAR_POWER] < 0) {
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STAR_POWER] = 0;
        }
        UsingSpiritsSubmenu = TRUE;
        MovesOptionCount = battleStatus->submenuMoveCount;
        initialPos = battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STAR_POWER];
        MovesPrevSelected = initialPos;
        btl_submenu_moves_init();
        gBattleSubState = BTL_SUBSTATE_FOCUS_CHOOSING;
        break;
    case BTL_SUBSTATE_FOCUS_CHOOSING:
        entryIdx = btl_submenu_moves_update();
        switch (entryIdx) {
            case POPUP_RESULT_CHOOSING:
                // do nothing while player is choosing from popup menu
                break;
            case POPUP_RESULT_CANCEL:
                btl_main_menu_resume_choose();
                BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_MAIN_BEGIN;
                btl_state_update_partner_menu();
                btl_state_update_partner_menu();
                break;
            default:
                battleStatus->lastPartnerPowerSelection = MovesOptionIndices[entryIdx - 1];
                btl_submenu_moves_hide();
                btl_main_menu_hide();
                gBattleSubState = BTL_SUBSTATE_FOCUS_HANDOVER;
                break;
        }
        break;
    case BTL_SUBSTATE_FOCUS_HANDOVER:
        entryIdx = btl_submenu_moves_update();
        if ((battleStatus->curButtonsPressed & BUTTON_B) && (entryIdx == 0)) {
            btl_submenu_moves_restore_choose();
            btl_main_menu_restore_submenu();
            gBattleSubState = BTL_SUBSTATE_FOCUS_REOPEN_MENU;
        } else if (btl_main_menu_update() != 0) {
            battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_FOCUS_CANCELED;
            battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_FOCUS_SELECTED;
            battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
            battleStatus->selectedMoveID = battleStatus->submenuMoves[battleStatus->lastPartnerPowerSelection];
            battleStatus->curTargetListFlags = gMoveTable[battleStatus->submenuMoves[battleStatus->lastPartnerPowerSelection]].flags;
            battleStatus->moveArgument = battleStatus->lastPartnerPowerSelection;
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STAR_POWER] = SelectedMovesIndex;
            btl_set_state(BATTLE_STATE_SELECT_TARGET);
        }
        break;
    case BTL_SUBSTATE_FOCUS_REOPEN_MENU:
        btl_submenu_moves_update();
        if (btl_main_menu_update() != 0) {
            gBattleSubState = BTL_SUBSTATE_FOCUS_CHOOSING;
        }
        break;
    case BTL_SUBSTATE_FOCUS_CANCELED:
        btl_submenu_moves_restore_choose();
        btl_main_menu_restore_submenu();
        gBattleSubState = BTL_SUBSTATE_FOCUS_REOPEN_MENU;
        break;
    case BTL_SUBSTATE_FOCUS_SELECTED:
        btl_submenu_moves_destroy();
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_STRATEGIES_BUILD_MENU:
        popupIndex = 0;
        btl_check_can_change_partner();
 
        // add 'Change Member' command
        if (battleStatus->changePartnerAllowed >= 0) {
            StratsOptionMenuTypes[popupIndex] = BTL_MENU_TYPE_CHANGE_PARTNER;
            StratsOptionNames[popupIndex] = LeftJustMenuMessages[BTL_MENU_TYPE_CHANGE_PARTNER];
            StratsOptionHudScripts[popupIndex] = PartnerHudScripts[playerData->curPartner].enabled;
            StratsOptionMessage[popupIndex] = MSG_Menus_Action_ChangePartner;
            StratsOptionEnabled[popupIndex] = TRUE;
            if (battleStatus->changePartnerAllowed <= 0) {
                StratsOptionHudScripts[popupIndex] = PartnerHudScripts[playerData->curPartner].disabled;
                StratsOptionEnabled[popupIndex] = FALSE;
                StratsOptionError[popupIndex] = 0;
            }
            popupIndex++;
        }
 
        // add 'Do Nothing' command
        StratsOptionMenuTypes[popupIndex] = BTL_MENU_TYPE_DO_NOTHING;
        StratsOptionNames[popupIndex] = LeftJustMenuMessages[BTL_MENU_TYPE_DO_NOTHING];
        StratsOptionHudScripts[popupIndex] = DoNothingHudScripts.enabled;
        StratsOptionMessage[popupIndex] = MSG_Menus_Action_DoNothing;
        StratsOptionEnabled[popupIndex] = TRUE;
        popupIndex++;
 
        if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STRATEGY] < 0) {
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STRATEGY] = 0;
        }
        StratsOptionCount = popupIndex;
        initialPos = battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STRATEGY];
        StratsPrevSelected = initialPos;
        btl_menu_strats_init();
        gBattleSubState = BTL_SUBSTATE_STRATEGIES_CHOOSING;
        break;
    case BTL_SUBSTATE_STRATEGIES_CHOOSING:
        entryIdx = btl_submenu_strats_update();
        switch (entryIdx) {
            case POPUP_RESULT_CHOOSING:
                // do nothing while player is selecting an entry
                break;
            case POPUP_RESULT_CANCEL:
                btl_main_menu_resume_choose();
                BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_MAIN_BEGIN;
                btl_state_update_partner_menu();
                btl_state_update_partner_menu();
                break;
            default:
                battleStatus->curPartnerSubmenu = StratsOptionMenuTypes[entryIdx - 1];
                battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STRATEGY] = entryIdx - 1;
                if (battleStatus->curPartnerSubmenu == BTL_MENU_TYPE_CHANGE_PARTNER) {
                    gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_BUILD_MENU;
                    btl_state_update_partner_menu();
                    btl_state_update_partner_menu();
                } else {
                    btl_submenu_strats_hide();
                    btl_main_menu_hide();
                    gBattleSubState = BTL_SUBSTATE_STRATEGIES_HANDOVER;
                }
                break;
        }
        break;
    case BTL_SUBSTATE_STRATEGIES_HANDOVER:
        entryIdx = btl_submenu_strats_update();
        if ((battleStatus->curButtonsPressed & BUTTON_B) && entryIdx == POPUP_RESULT_CHOOSING) {
            btl_submenu_strats_restore_choose();
            btl_main_menu_restore_submenu();
            gBattleSubState = BTL_SUBSTATE_STRATEGIES_REOPEN_MENU;
        } else if (btl_main_menu_update() != 0) {
            battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_STRATEGIES_TARGET_CANCEL;
            battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_STRATEGIES_TARGET_CHOSEN;
            switch (battleStatus->curPartnerSubmenu) {
                case BTL_MENU_TYPE_DO_NOTHING:
                    gBattleSubState = BTL_SUBSTATE_STRATEGIES_TARGET_CHOSEN;
                    btl_state_update_partner_menu();
                    btl_set_state(BATTLE_STATE_END_PARTNER_TURN);
                    break;
                case BTL_MENU_TYPE_RUN_AWAY:
                    gBattleSubState = BTL_SUBSTATE_STRATEGIES_TARGET_CHOSEN;
                    btl_state_update_partner_menu();
                    battleStatus->moveCategory = BTL_MENU_TYPE_RUN_AWAY;
                    battleStatus->selectedMoveID = MOVE_RUN_AWAY;
                    btl_set_state(BATTLE_STATE_RUN_AWAY);
                    break;
                case BTL_MENU_TYPE_ACT_LATER:
                    gBattleSubState = BTL_SUBSTATE_STRATEGIES_TARGET_CHOSEN;
                    btl_state_update_partner_menu();
                    btl_set_state(BATTLE_STATE_SWITCH_TO_PLAYER);
                    break;
            }
        }
        break;
    case BTL_SUBSTATE_STRATEGIES_REOPEN_MENU:
        btl_submenu_strats_update();
        if (btl_main_menu_update() != 0) {
            BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
            BattleMenu_SwapDelay = 4;
            gBattleSubState = BTL_SUBSTATE_MAIN_BEGIN;
        }
        break;
    case BTL_SUBSTATE_STRATEGIES_TARGET_CANCEL:
        btl_submenu_strats_restore_choose();
        btl_main_menu_restore_submenu();
        gBattleSubState = BTL_SUBSTATE_STRATEGIES_REOPEN_MENU;
        break;
    case BTL_SUBSTATE_STRATEGIES_TARGET_CHOSEN:
        btl_submenu_strats_destroy();
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_CHANGE_PARTNER_BUILD_MENU:
        popupIndex = 0;
        for (i = 1; i < ARRAY_COUNT(PartnerIDFromMenuIndex); i++) {
            s32 partnerId = PartnerIDFromMenuIndex[i];
            if (playerData->partners[partnerId].enabled) {
                popupProps = &gPartnerPopupProperties[partnerId];
                popupMenu->ptrIcon[popupIndex] = PartnerHudScripts[partnerId].enabled;
                popupMenu->enabled[popupIndex] = TRUE;
                popupMenu->userIndex[popupIndex] = partnerId;
                popupMenu->nameMsg[popupIndex] = popupProps->nameMsg;
                popupMenu->descMsg[popupIndex] = popupProps->battleDescMsg;
                popupMenu->value[popupIndex] = playerData->partners[partnerId].level;
                if (playerData->curPartner == partnerId) {
                    popupMenu->ptrIcon[popupIndex] = PartnerHudScripts[partnerId].disabled;
                    popupMenu->enabled[popupIndex] = FALSE;
                }
                popupIndex++;
            }
        }
        if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER] < 0) {
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER] = 0;
        }
        popupMenu->popupType = POPUP_MENU_SWITCH_PARTNER;
        popupMenu->numEntries = popupIndex;
        popupMenu->initialPos = MenuIndexFromPartnerID[playerData->curPartner] - 1;
        popupMenu->dipMode = 0;
        popupMenu->titleNumber = 0;
        create_battle_popup_menu(popupMenu);
        flush_popup_menu();
        gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_CHOOSING;
        break;
    case BTL_SUBSTATE_CHANGE_PARTNER_CHOOSING:
        switch (popupMenu->result) {
            case POPUP_RESULT_CHOOSING:
                // do nothing while player is choosing from popup menu
                break;
            case POPUP_RESULT_INVALID:
                gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_ERROR;
                break;
            case POPUP_RESULT_CANCEL:
                btl_submenu_strats_resume_choose();
                gBattleSubState = BTL_SUBSTATE_STRATEGIES_CHOOSING;
                btl_state_update_partner_menu();
                btl_state_update_partner_menu();
                break;
            default:
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_CHANGE_PARTNER_TARGET_CANCEL;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_CHANGE_PARTNER_TARGET_CHOSEN;
                battleStatus->lastSelectedPartner = popupMenu->userIndex[popupMenu->result - 1];
                battleStatus->moveCategory = BTL_MENU_TYPE_CHANGE_PARTNER;
                battleStatus->selectedMoveID = MOVE_CHANGE_PARTNER;
                battleStatus->curTargetListFlags = TARGET_FLAG_2;
                battleStatus->moveArgument = battleStatus->lastSelectedPartner;
                battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER] = popupMenu->result - 1;
                hide_popup_menu();
                btl_submenu_strats_hide();
                btl_main_menu_hide();
                gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_HANDOVER;
                break;
        }
        break;
    case BTL_SUBSTATE_CHANGE_PARTNER_HANDOVER:
        if ((battleStatus->curButtonsPressed & BUTTON_B) && popupMenu->result == POPUP_RESULT_CHOOSING) {
            show_popup_menu();
            btl_submenu_strats_restore_locked();
            btl_main_menu_restore_submenu();
            gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_REOPEN_MENU;
        } else {
            btl_submenu_strats_update();
            if (btl_main_menu_update() != 0) {
                gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                btl_state_update_partner_menu();
                btl_set_state(BATTLE_STATE_CHANGE_PARTNER);
            }
        }
        break;
    case BTL_SUBSTATE_CHANGE_PARTNER_REOPEN_MENU:
        btl_submenu_strats_update();
        if (btl_main_menu_update() != 0) {
            gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_CHOOSING;
        }
        break;
    case BTL_SUBSTATE_CHANGE_PARTNER_TARGET_CANCEL:
        show_popup_menu();
        btl_submenu_strats_restore_locked();
        btl_main_menu_restore_submenu();
        gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_REOPEN_MENU;
        break;
    case BTL_SUBSTATE_CHANGE_PARTNER_TARGET_CHOSEN:
        destroy_popup_menu();
        btl_submenu_strats_destroy();
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_CHANGE_PARTNER_ERROR:
        set_window_update(WIN_BTL_STRATS_MENU, WINDOW_UPDATE_HIDE);
        set_window_update(WIN_BTL_STRATS_TITLE, WINDOW_UPDATE_HIDE);
        if (popupMenu->result != POPUP_RESULT_INVALID) {
            set_window_update(WIN_BTL_STRATS_MENU, WINDOW_UPDATE_9);
            set_window_update(WIN_BTL_STRATS_TITLE, WINDOW_UPDATE_9);
            gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_CHOOSING;
        }
        break;
    }
}

Referenced by btl_state_update_partner_menu(), btl_state_update_select_target(), and btl_update().

◆ btl_state_draw_partner_menu()

void btl_state_draw_partner_menu ( void )

Definition at line 1137 of file menu_partner.c.

                                       {
    switch (gBattleSubState) {
        case BTL_SUBSTATE_MAIN_BEGIN:
        case BTL_SUBSTATE_MAIN_CHOOSING:
        case BTL_SUBSTATE_MAIN_HANDOVER:
        case BTL_SUBSTATE_MAIN_REOPEN_MENU:
        case BTL_SUBSTATE_MAIN_TARGET_CANCEL:
        case BTL_SUBSTATE_ABILITIES_BUILD_MENU:
        case BTL_SUBSTATE_ABILITIES_CHOOSING:
        case BTL_SUBSTATE_ABILITIES_HANDOVER:
        case BTL_SUBSTATE_ABILITIES_REOPEN_MENU:
        case BTL_SUBSTATE_ABILITIES_TARGET_CANCEL:
        case BTL_SUBSTATE_UNKNOWN_1:
        case BTL_SUBSTATE_UNKNOWN_2:
        case BTL_SUBSTATE_UNKNOWN_3:
        case BTL_SUBSTATE_UNKNOWN_4:
        case BTL_SUBSTATE_UNKNOWN_5:
        case BTL_SUBSTATE_CHANGE_PARTNER_BUILD_MENU:
        case BTL_SUBSTATE_CHANGE_PARTNER_CHOOSING:
        case BTL_SUBSTATE_CHANGE_PARTNER_HANDOVER:
        case BTL_SUBSTATE_CHANGE_PARTNER_REOPEN_MENU:
        case BTL_SUBSTATE_CHANGE_PARTNER_TARGET_CANCEL:
        case BTL_SUBSTATE_ITEMS_BUILD_MENU:
        case BTL_SUBSTATE_ITEMS_CHOOSING:
        case BTL_SUBSTATE_ITEMS_HANDOVER:
        case BTL_SUBSTATE_ITEMS_REOPEN_MENU:
        case BTL_SUBSTATE_ITEMS_TARGET_CANCEL:
        case BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_CHOOSING:
        case BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_HANDOVER:
        case BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_REOPEN_MENU:
        case BTL_SUBSTATE_UNUSED_CHANGE_PARTNER_TARGET_CANCEL:
        case BTL_SUBSTATE_FOCUS_CHOOSING:
        case BTL_SUBSTATE_FOCUS_HANDOVER:
        case BTL_SUBSTATE_FOCUS_REOPEN_MENU:
        case BTL_SUBSTATE_FOCUS_CANCELED:
        case BTL_SUBSTATE_FOCUS_SELECTED:
        case BTL_SUBSTATE_STRATEGIES_BUILD_MENU:
        case BTL_SUBSTATE_STRATEGIES_CHOOSING:
        case BTL_SUBSTATE_STRATEGIES_HANDOVER:
        case BTL_SUBSTATE_STRATEGIES_REOPEN_MENU:
        case BTL_SUBSTATE_STRATEGIES_TARGET_CANCEL:
        case BTL_SUBSTATE_STRATEGIES_TARGET_CHOSEN:
            btl_main_menu_draw();
            break;
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_peach_menu()

void btl_state_update_peach_menu ( void )

Definition at line 24 of file menu_peach.c.

                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    s32 selectedOption;
    s32 initialPos;
    s32 entryIdx;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            btl_cam_move(10);
            if (gBattleStatus.flags1 & BS_FLAGS1_PLAYER_IN_BACK) {
                // if the player (Peach) is in back, we need to swap her to the front before opening the menu
                player->state.curPos.x = player->homePos.x;
                player->state.curPos.z = player->homePos.z;
                player->state.goalPos.x = partner->homePos.x;
                player->state.goalPos.z = partner->homePos.z;
                player->state.moveTime = 4;
                player->state.angle = 0.0f;
                gBattleSubState = BTL_SUBSTATE_SWAP_PEACH_FRONT;
            } else {
                gBattleSubState = BTL_SUBSTATE_CREATE_MAIN_MENU;
            }
            break;
        case BTL_SUBSTATE_SWAP_PEACH_FRONT:
            if (player->state.moveTime != 0) {
                player->curPos.x += (player->state.goalPos.x - player->curPos.x) / player->state.moveTime;
                player->curPos.z += (player->state.goalPos.z - player->curPos.z) / player->state.moveTime;
                partner->curPos.x += (player->state.curPos.x - partner->curPos.x) / player->state.moveTime;
                partner->curPos.z += (player->state.curPos.z - partner->curPos.z) / player->state.moveTime;
            }
 
            player->curPos.z -= sin_rad(DEG_TO_RAD(player->state.angle)) * 16.0f;
            player->yaw = clamp_angle(-player->state.angle);
            partner->curPos.z += sin_rad(DEG_TO_RAD(player->state.angle)) * 16.0f;
            partner->yaw = clamp_angle(-player->state.angle);
            player->state.angle += 90.0f;
 
            if (player->state.moveTime != 0) {
                player->state.moveTime--;
                break;
            }
 
            player->curPos.x = player->state.goalPos.x;
            player->curPos.z = player->state.goalPos.z;
            partner->curPos.x = player->state.curPos.x;
            partner->curPos.z = player->state.curPos.z;
            player->homePos.x = player->curPos.x;
            player->homePos.z = player->curPos.z;
            partner->homePos.x = partner->curPos.x;
            partner->homePos.z = partner->curPos.z;
            gBattleStatus.flags1 &= ~BS_FLAGS1_PLAYER_IN_BACK;
            // fallthrough
        case BTL_SUBSTATE_CREATE_MAIN_MENU:
            gBattleStatus.flags1 |= BS_FLAGS1_MENU_OPEN;
            player->flags &= ~ACTOR_FLAG_USING_IDLE_ANIM;
            player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            if (partner != NULL) {
                partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
                partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
 
            // add main menu entry for star powers
            entryIdx = 0;
            battleStatus->selectedMoveID = MOVE_NONE;
            WheelOptionSubmenu[entryIdx] = BTL_MENU_TYPE_STAR_POWERS;
            WheelOptionEnabled[entryIdx] = TRUE;
            WheelOptionError[entryIdx] = 0;
            WheelOptionHudScript[entryIdx] = PeachStarPowerHudScripts.enabled;
            WheelOptionName[entryIdx] = PeachMenuMessages[entryIdx];
            if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_STAR_POWERS)) {
                WheelOptionEnabled[entryIdx] = FALSE;
                WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                WheelOptionHudScript[entryIdx] = PeachStarPowerHudScripts.disabled;
            }
            entryIdx++;
 
            initialPos = 0;
            WheelOptionCount = entryIdx;
            BattleMenu_PrevSelected = initialPos;
            BattleMenu_WheelBase = 2 - initialPos;
 
            if (gBattleStatus.flags2 & BS_FLAGS2_PARTNER_TURN_USED) {
                BattleMenu_ShowSwapIcons = FALSE;
            } else {
                BattleMenu_ShowSwapIcons = TRUE;
            }
 
            btl_main_menu_init();
            BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
            gBattleSubState = BTL_SUBSTATE_CHOOSE_CATEGORY;
            break;
        case BTL_SUBSTATE_CHOOSE_CATEGORY:
            set_actor_anim(ACTOR_PLAYER, 0, ANIM_Peach2_Delighted);
            selectedOption = btl_main_menu_update();
            if (BattleMenu_ChooseDelay != 0) {
                BattleMenu_ChooseDelay--;
                break;
            }
            if (selectedOption != 0) {
                set_actor_anim(ACTOR_PLAYER, 0, ANIM_Peach1_Walk);
                battleStatus->curSubmenu = WheelOptionSubmenu[selectedOption - 1];
                btl_main_menu_hide();
                BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_CHOOSE_TARGET;
            }
            break;
        case BTL_SUBSTATE_CHOOSE_TARGET:
            if (btl_main_menu_update() != 0) {
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_TARGET_CANCEL;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_TARGET_CHOSEN;
                battleStatus->curTargetListFlags = gMoveTable[MOVE_PEACH_FOCUS].flags;
                battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
                battleStatus->selectedMoveID = MOVE_PEACH_FOCUS;
                battleStatus->moveArgument = STAR_POWER_INDEX(MOVE_PEACH_FOCUS);
                btl_set_state(BATTLE_STATE_SELECT_TARGET);
            }
            break;
        case BTL_SUBSTATE_TARGET_CANCEL:
            btl_main_menu_resume_choose();
            gBattleSubState = BTL_SUBSTATE_CHOOSE_CATEGORY;
            btl_state_update_peach_menu();
            btl_state_update_peach_menu();
            break;
        case BTL_SUBSTATE_TARGET_CHOSEN:
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_SHOW_CANT_SWITCH:
            btl_show_variable_battle_message(BTL_MSG_CANT_SWITCH, 60, 0);
            ShowingErrorMessage = TRUE;
            gBattleSubState = BTL_SUBSTATE_AWAIT_CANT_SWITCH_POPUP;
            break;
        case BTL_SUBSTATE_AWAIT_CANT_SWITCH_POPUP:
            if (btl_is_popup_displayed()) {
                break;
            }
            ShowingErrorMessage = FALSE;
            BattleMenu_ChooseDelay = 0;
            gBattleSubState = BTL_SUBSTATE_CHOOSE_CATEGORY;
            break;
    }
}

Referenced by btl_state_update_peach_menu(), btl_state_update_select_target(), and btl_update().

◆ btl_state_draw_peach_menu()

void btl_state_draw_peach_menu ( void )

Definition at line 169 of file menu_peach.c.

                                     {
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CHOOSE_CATEGORY:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_CHOOSE_TARGET:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_TARGET_CANCEL:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_TARGET_CHOSEN:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_SHOW_CANT_SWITCH:
        case BTL_SUBSTATE_AWAIT_CANT_SWITCH_POPUP:
            break;
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_twink_menu()

void btl_state_update_twink_menu ( void )

Definition at line 27 of file menu_twink.c.

                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    s32 selection;
    s32 shouldSkipTurn;
    s32 initialPos;
    s32 entryIdx;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            shouldSkipTurn = FALSE;
 
            switch (player->debuff) {
                case STATUS_KEY_SLEEP:
                case STATUS_KEY_UNUSED:
                case STATUS_KEY_DIZZY:
                case STATUS_KEY_PARALYZE:
                case STATUS_KEY_FROZEN:
                case STATUS_KEY_STOP:
                    shouldSkipTurn = TRUE;
                    break;
                default:
                    break;
            }
 
            if (player->stoneStatus == STATUS_KEY_STONE) {
                shouldSkipTurn = TRUE;
            }
 
            if (player->koStatus == STATUS_KEY_KO) {
                shouldSkipTurn = TRUE;
            }
 
            if (shouldSkipTurn) {
                btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
                break;
            }
 
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            btl_cam_move(10);
            if (!(gBattleStatus.flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
                // if the player (Peach) is in front, we need to swap her to the back before opening the menu
                player->state.curPos.x = player->homePos.x;
                player->state.curPos.z = player->homePos.z;
                player->state.goalPos.x = partner->homePos.x;
                player->state.goalPos.z = partner->homePos.z;
                player->state.moveTime = 4;
                player->state.angle = 0.0f;
                gBattleSubState = BTL_SUBSTATE_SWAP_PEACH_BACK;
            } else {
                gBattleSubState = BTL_SUBSTATE_CREATE_MAIN_MENU;
            }
            break;
        case BTL_SUBSTATE_SWAP_PEACH_BACK:
            if (player->state.moveTime != 0) {
                player->curPos.x += (player->state.goalPos.x - player->curPos.x) / player->state.moveTime;
                player->curPos.z += (player->state.goalPos.z - player->curPos.z) / player->state.moveTime;
                partner->curPos.x += (player->state.curPos.x - partner->curPos.x) / player->state.moveTime;
                partner->curPos.z += (player->state.curPos.z - partner->curPos.z) / player->state.moveTime;
            }
            player->curPos.z += sin_rad(DEG_TO_RAD(player->state.angle)) * 16.0f;
            player->yaw = clamp_angle(-player->state.angle);
            partner->curPos.z -= sin_rad(DEG_TO_RAD(player->state.angle)) * 16.0f;
            partner->yaw = clamp_angle(-player->state.angle);
            player->state.angle += 90.0f;
            if (player->state.moveTime != 0) {
                player->state.moveTime--;
                break;
            }
            player->curPos.x = player->state.goalPos.x;
            player->curPos.z = player->state.goalPos.z;
            partner->curPos.x = player->state.curPos.x;
            partner->curPos.z = player->state.curPos.z;
            player->homePos.x = player->curPos.x;
            player->homePos.z = player->curPos.z;
            partner->homePos.x = partner->curPos.x;
            partner->homePos.z = partner->curPos.z;
            gBattleStatus.flags1 |= BS_FLAGS1_PLAYER_IN_BACK;
            // fallthrough
        case BTL_SUBSTATE_CREATE_MAIN_MENU:
            gBattleStatus.flags1 |= BS_FLAGS1_MENU_OPEN;
            player->flags &= ~ACTOR_FLAG_USING_IDLE_ANIM;
            player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            if (partner != NULL) {
                partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
                partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
 
            // add main menu entry for star powers
            entryIdx = 0;
            battleStatus->selectedMoveID = MOVE_NONE;
            WheelOptionSubmenu[entryIdx] = BTL_MENU_TYPE_STAR_POWERS;
            WheelOptionEnabled[entryIdx] = TRUE;
            WheelOptionError[entryIdx] = 0;
            WheelOptionHudScript[entryIdx] = TwinkStarPowerHudScripts.enabled;
            WheelOptionName[entryIdx] = TwinkMenuMessages[entryIdx];
            if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_STAR_POWERS)) {
                WheelOptionEnabled[entryIdx] = FALSE;
                WheelOptionError[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                WheelOptionHudScript[entryIdx] = TwinkStarPowerHudScripts.disabled;
            }
            entryIdx++;
 
            initialPos = 0;
            WheelOptionCount = entryIdx;
            BattleMenu_PrevSelected = initialPos;
            BattleMenu_WheelBase = 2 - initialPos;
 
            if (gBattleStatus.flags2 & BS_FLAGS2_PLAYER_TURN_USED) {
                BattleMenu_ShowSwapIcons = FALSE;
            } else {
                BattleMenu_ShowSwapIcons = TRUE;
            }
 
            btl_main_menu_init();
            BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
            gBattleSubState = BTL_SUBSTATE_CHOOSE_CATEGORY;
            break;
        case BTL_SUBSTATE_CHOOSE_CATEGORY:
            set_actor_anim(ACTOR_PARTNER, 0, ANIM_Twink_Idle);
            selection = btl_main_menu_update();
            if (BattleMenu_ChooseDelay != 0) {
                BattleMenu_ChooseDelay--;
                break;
            }
            if (selection != 0) {
                set_actor_anim(ACTOR_PARTNER, 0, ANIM_Twink_Angry);
                battleStatus->curSubmenu = WheelOptionSubmenu[selection - 1];
                btl_main_menu_hide();
                BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_CHOOSE_TARGET;
            }
            break;
        case BTL_SUBSTATE_CHOOSE_TARGET:
            if (btl_main_menu_update() != 0) {
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_TARGET_CANCEL;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_TARGET_CHOSEN;
                battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
                battleStatus->selectedMoveID = MOVE_TWINK_DASH;
                battleStatus->moveArgument = 0;
                battleStatus->curTargetListFlags = gMoveTable[MOVE_TWINK_DASH].flags;
                btl_set_state(BATTLE_STATE_SELECT_TARGET);
            }
            break;
        case BTL_SUBSTATE_TARGET_CANCEL:
            btl_main_menu_resume_choose();
            gBattleSubState = BTL_SUBSTATE_CHOOSE_CATEGORY;
            btl_state_update_twink_menu();
            btl_state_update_twink_menu();
            break;
        case BTL_SUBSTATE_TARGET_CHOSEN:
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_SHOW_CANT_SWITCH:
            btl_show_variable_battle_message(BTL_MSG_CANT_SWITCH, 60, 0);
            ShowingErrorMessage = TRUE;
            gBattleSubState = BTL_SUBSTATE_AWAIT_CANT_SWITCH_POPUP;
            break;
        case BTL_SUBSTATE_AWAIT_CANT_SWITCH_POPUP:
            if (btl_is_popup_displayed()) {
                break;
            }
            ShowingErrorMessage = FALSE;
            BattleMenu_ChooseDelay = 0;
            gBattleSubState = BTL_SUBSTATE_CHOOSE_CATEGORY;
            break;
    }
}

Referenced by btl_state_update_select_target(), btl_state_update_twink_menu(), and btl_update().

◆ btl_state_draw_twink_menu()

void btl_state_draw_twink_menu ( void )

Definition at line 198 of file menu_twink.c.

                                     {
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CHOOSE_CATEGORY:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_CHOOSE_TARGET:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_UNUSED_3:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_TARGET_CANCEL:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_TARGET_CHOSEN:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_UNUSED_6:
        case BTL_SUBSTATE_UNUSED_7:
        case BTL_SUBSTATE_SHOW_CANT_SWITCH:
        case BTL_SUBSTATE_AWAIT_CANT_SWITCH_POPUP:
            break;
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_select_target()

void btl_state_update_select_target ( void )

Definition at line 13 of file select_target.c.

                                          {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* actor;
    s32 targetListLength;
    s32 selectedTargetIndex;
    HudElemID hid;
    s8* targetIndexList;
    SelectableTarget* target;
    s32 i;
 
    if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
        actor = battleStatus->playerActor;
    } else {
        actor = battleStatus->partnerActor;
    }
    targetListLength = actor->targetListLength;
    selectedTargetIndex = actor->selectedTargetIndex;
 
    actor->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
    targetIndexList = actor->targetIndexList;
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            BattleMenu_TargetPointerAlpha = 255;
            BattleMenu_TargetNameOffsetX = -100;
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
 
            // prepare the action command tip for the selected move
            if (!is_ability_active(ABILITY_BERSERKER) || (gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
                if (battleStatus->selectedMoveID != MOVE_NONE) {
                    s8 actionTip = gMoveTable[battleStatus->selectedMoveID].actionTip;
 
                    if (actionTip >= 0) {
                        btl_show_battle_message(BTL_MSG_ACTION_TIP_PRESS_BEFORE_LANDING + actionTip, 60);
                    }
                }
            }
 
            // create the target list
            create_current_pos_target_list(actor);
            targetListLength = actor->targetListLength;
            if (battleStatus->curTargetListFlags & TARGET_FLAG_SELECT_ONE) {
                targetIndexList = actor->targetIndexList;
                for (i = 0; i < targetListLength; i++) {
                    target = &actor->targetData[targetIndexList[i]];
                    if (get_actor_part(get_actor(target->actorID), target->partID)->flags & ACTOR_PART_FLAG_DEFAULT_TARGET) {
                        actor->selectedTargetIndex = i;
                        break;
                    }
                }
            }
 
            // when TARGET_FLAG_OVERRIDE is set, skip selecting a target and begin executing the move
            if (battleStatus->curTargetListFlags & TARGET_FLAG_OVERRIDE) {
                if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
                    gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                        btl_state_update_player_menu();
                    } else {
                        btl_state_update_player_menu();
                    }
                    btl_set_state(BATTLE_STATE_PLAYER_MOVE);
                } else {
                    gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                        btl_state_update_twink_menu();
                    } else {
                        btl_state_update_partner_menu();
                    }
                    btl_set_state(BATTLE_STATE_PARTNER_MOVE);
                }
                break;
            }
 
            // if the target list is empty, skip selecting a target and begin executing the move
            if (targetListLength == 0) {
                if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
                    gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                        btl_state_update_player_menu();
                    } else {
                        btl_state_update_player_menu();
                    }
                    btl_set_state(BATTLE_STATE_PLAYER_MOVE);
                } else {
                    gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                        btl_state_update_twink_menu();
                    } else {
                        btl_state_update_partner_menu();
                    }
                    btl_set_state(BATTLE_STATE_PARTNER_MOVE);
                }
                break;
            }
 
            // create the HUD elements for the target pointers
            for (i = 0; i < targetListLength; i++) {
                hid = hud_element_create(&HES_HandPointDownLoop);
                BattleMenu_TargetHudElems[i] = hid;
                hud_element_set_render_depth(hid, 0);
                hud_element_set_render_pos(hid, 0, -100);
            }
            gBattleSubState = BTL_SUBSTATE_CHOOSE;
            break;
        case BTL_SUBSTATE_CHOOSE:
            // animate the target name sliding into view
            if (BattleMenu_TargetNameOffsetX < 0) {
                BattleMenu_TargetNameOffsetX += 20;
                if (BattleMenu_TargetNameOffsetX > 0) {
                    BattleMenu_TargetNameOffsetX = 0;
                }
            }
 
            if (battleStatus->curButtonsPressed & BUTTON_B) {
                sfx_play_sound(SOUND_MENU_BACK);
                gBattleSubState = BTL_SUBSTATE_CANCEL;
                break;
            }
 
            if (battleStatus->curButtonsPressed & BUTTON_A) {
                sfx_play_sound(SOUND_MENU_NEXT);
                BattleMenu_ChooseDelay = MENU_CHANGE_DELAY;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_DONE;
                break;
            }
 
            gBattleStatus.flags1 |= BS_FLAGS1_MENU_OPEN;
            if (battleStatus->curButtonsDown & (BUTTON_Z | BUTTON_R)) {
                gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
                break;
            }
 
            if (battleStatus->curTargetListFlags & TARGET_FLAG_SELECT_ONE) {
                s32 oldSelectedTargetIndex = selectedTargetIndex;
 
                if (battleStatus->curButtonsHeld & BUTTON_STICK_LEFT) {
                    selectedTargetIndex--;
                }
                if (battleStatus->curButtonsHeld & BUTTON_STICK_RIGHT) {
                    selectedTargetIndex++;
                }
                if (selectedTargetIndex < 0) {
                    selectedTargetIndex = targetListLength - 1;
                }
                if (selectedTargetIndex >= targetListLength) {
                    selectedTargetIndex = 0;
                }
                if (selectedTargetIndex != oldSelectedTargetIndex) {
                    s32 actorFlags;
 
                    target = &actor->targetData[targetIndexList[selectedTargetIndex]];
                    actorFlags = get_actor(target->actorID)->flags;
                    hid = BattleMenu_TargetHudElems[0];
 
                    if (actorFlags & ACTOR_FLAG_UPSIDE_DOWN) {
                        hud_element_set_script(hid, &HES_HandPointLeftLoop);
                    } else {
                        hud_element_set_script(hid, &HES_HandPointDownLoop);
                    }
                    sfx_play_sound(SOUND_MENU_CHANGE_SELECTION);
                }
                actor->selectedTargetIndex = selectedTargetIndex;
            }
            break;
        case BTL_SUBSTATE_DONE:
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            target = &actor->targetData[targetIndexList[actor->selectedTargetIndex]];
            actor->targetActorID = target->actorID;
            actor->targetPartID = target->partID;
 
            // free the HUD elements for the target pointers
            for (i = 0; i < targetListLength; i++) {
                hud_element_free(BattleMenu_TargetHudElems[i]);
            }
 
            // begin executing the move
            if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
                gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                    btl_state_update_peach_menu();
                } else {
                    btl_state_update_player_menu();
                }
                btl_set_state(BATTLE_STATE_PLAYER_MOVE);
            } else {
                gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                    btl_state_update_twink_menu();
                } else {
                    btl_state_update_partner_menu();
                }
                btl_set_state(BATTLE_STATE_PARTNER_MOVE);
            }
            break;
        case BTL_SUBSTATE_CANCEL:
            // free the HUD elements for the target pointers
            for (i = 0; i < targetListLength; i++) {
                hud_element_free(BattleMenu_TargetHudElems[i]);
            }
 
            gBattleStatus.flags1 |= BS_FLAGS1_10000 | BS_FLAGS1_MENU_OPEN;
            actor->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
 
            if (battleStatus->itemUsesLeft != 0) {
                btl_set_state(BATTLE_STATE_PLAYER_MENU);
                gBattleSubState = battleStatus->cancelTargetMenuSubstate;
                if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                    btl_state_update_peach_menu();
                } else {
                    btl_state_update_player_menu();
                }
            } else if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
                btl_set_state(BATTLE_STATE_PLAYER_MENU);
                gBattleSubState = battleStatus->cancelTargetMenuSubstate;
                if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                    btl_state_update_peach_menu();
                } else {
                    btl_state_update_player_menu();
                }
            } else {
                btl_set_state(BATTLE_STATE_PARTNER_MENU);
                gBattleSubState = battleStatus->cancelTargetMenuSubstate;
                if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                    btl_state_update_twink_menu();
                } else {
                    btl_state_update_partner_menu();
                }
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_select_target()

void btl_state_draw_select_target ( void )

Definition at line 246 of file select_target.c.

                                        {
    BattleStatus* battleStatus = &gBattleStatus;
    s32 msgID;
    s32 msgX;
    s32 msgY;
    s32 targetListLength;
    s32 currentPartner;
    s32 actorID;
    SelectableTarget* target;
    Actor* choosingActor;
    Actor* enemyActor;
    s32 id;
    s32 i;
    s32 nameWidth;
    s32 xOffset, yOffset;
    f32 targetX, targetY, targetZ;
    s32 screenX, screenY, screenZ;
    s32 selectedTargetIndex;
    s8* targetIndexList;
 
    if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
        choosingActor = battleStatus->playerActor;
    } else {
        choosingActor = battleStatus->partnerActor;
    }
 
    targetListLength = choosingActor->targetListLength;
    target = choosingActor->targetData;
    selectedTargetIndex = choosingActor->selectedTargetIndex;
    targetIndexList = choosingActor->targetIndexList;
 
    if (targetListLength == 0) {
        return;
    }
 
    // draw target pointers
    if (battleStatus->curTargetListFlags & TARGET_FLAG_SELECT_ONE) {
        target = &choosingActor->targetData[targetIndexList[selectedTargetIndex]];
        enemyActor = get_actor(target->actorID);
        id = BattleMenu_TargetHudElems[0];
        targetX = target->truePos.x;
        targetY = target->truePos.y;
        targetZ = target->truePos.z;
 
        // select target pointer style based on target actor orientation
        if (enemyActor->flags & ACTOR_FLAG_UPSIDE_DOWN) {
            xOffset = 16;
            yOffset = 2;
            if (hud_element_get_script(id) != &HES_HandPointLeftLoop) {
                hud_element_set_script(id, &HES_HandPointLeftLoop);
            }
        } else {
            xOffset = 5;
            yOffset = -11;
            if (hud_element_get_script(id) != &HES_HandPointDownLoop) {
                hud_element_set_script(id, &HES_HandPointDownLoop);
            }
        }
 
        get_screen_coords(CAM_BATTLE, targetX, targetY, targetZ, &screenX, &screenY, &screenZ);
        hud_element_set_render_pos(id, screenX + xOffset, screenY + yOffset);
        hud_element_set_alpha(id, BattleMenu_TargetPointerAlpha);
    } else {
        for (i = 0; i < targetListLength; i++) {
            target = &choosingActor->targetData[targetIndexList[i]];
            enemyActor = get_actor(target->actorID);
            id = BattleMenu_TargetHudElems[i];
            targetX = target->truePos.x;
            targetY = target->truePos.y;
            targetZ = target->truePos.z;
 
            // select target pointer style based on target actor orientation
            if (enemyActor->flags & ACTOR_FLAG_UPSIDE_DOWN) {
                xOffset = 16;
                yOffset = 2;
                if (hud_element_get_script(id) != &HES_HandPointLeftLoop) {
                    hud_element_set_script(id, &HES_HandPointLeftLoop);
                }
            } else {
                xOffset = 5;
                yOffset = -11;
                if (hud_element_get_script(id) != &HES_HandPointDownLoop) {
                    hud_element_set_script(id, &HES_HandPointDownLoop);
                }
            }
 
            get_screen_coords(CAM_BATTLE, targetX, targetY, targetZ, &screenX, &screenY, &screenZ);
            hud_element_set_render_pos(id, screenX + xOffset, screenY + yOffset);
            hud_element_set_alpha(id, BattleMenu_TargetPointerAlpha);
        }
    }
 
    currentPartner = gPlayerData.curPartner;
    screenX = 52;
    screenY = 64;
    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
        currentPartner = PARTNER_TWINK;
    }
 
    // get target name width
    if ((battleStatus->curTargetListFlags & TARGET_FLAG_SELECT_ONE) || targetListLength == 1) {
        actorID = target->actorID;
        if (actorID == ACTOR_PLAYER) {
            nameWidth = get_msg_width(MSG_Menus_Battle_TargetMario, 0) + 10;
        } else if (actorID == ACTOR_PARTNER) {
            nameWidth = get_msg_width(PartnerNameMessages[currentPartner], 0) + 10;
        } else {
            target = &choosingActor->targetData[targetIndexList[selectedTargetIndex]];
            enemyActor = get_actor(target->actorID);
            msgID = get_actor_part(enemyActor, target->partID)->staticData->overrideNameMsg;
            if (msgID == MSG_NONE) {
                msgID = bActorNames[enemyActor->actorType];
            }
            nameWidth = get_msg_width(msgID, 0) + 10;
        }
    } else {
        target = &choosingActor->targetData[targetIndexList[selectedTargetIndex]];
        actorID = target->actorID;
        if (actorID == ACTOR_PLAYER) {
            nameWidth = get_msg_width(MSG_Menus_Battle_TargetMario, 0) + 10;
        } else if (actorID == ACTOR_PARTNER) {
            nameWidth = get_msg_width(PartnerNameMessages[currentPartner], 0) + 10;
        } else {
            nameWidth = get_msg_width(MSG_Menus_Battle_TargetAllEnemies, 0) + 10;
        }
    }
 
    // draw target name box
    draw_box(0, WINDOW_STYLE_4, screenX + BattleMenu_TargetNameOffsetX, screenY, 0, nameWidth, 20, 255, 0,
                0.0f, 0.0f, 0.0f, 0.0f, 0.0f, NULL, NULL, NULL, SCREEN_WIDTH, SCREEN_HEIGHT, NULL);
 
    // draw target name text
    screenX += 4;
    screenY += 2;
    if ((battleStatus->curTargetListFlags & TARGET_FLAG_SELECT_ONE) || targetListLength == 1) {
        actorID = target->actorID;
        if (actorID == ACTOR_PLAYER) {
            draw_msg(MSG_Menus_Battle_TargetMario, screenX + BattleMenu_TargetNameOffsetX, screenY, 255, MSG_PAL_36, 0);
        } else if (actorID == ACTOR_PARTNER) {
            draw_msg(PartnerNameMessages[currentPartner], screenX + BattleMenu_TargetNameOffsetX, screenY, 255, MSG_PAL_36, 0);
        } else {
            target = &choosingActor->targetData[targetIndexList[selectedTargetIndex]];
            enemyActor = get_actor(target->actorID);
            msgID = get_actor_part(enemyActor, target->partID)->staticData->overrideNameMsg;
            if (msgID == MSG_NONE) {
                msgID = bActorNames[enemyActor->actorType];
            }
            draw_msg(msgID, screenX + BattleMenu_TargetNameOffsetX, screenY, 255, MSG_PAL_36, 0);
        }
    } else {
        target = &choosingActor->targetData[targetIndexList[selectedTargetIndex]];
        actorID = target->actorID;
        if (actorID == ACTOR_PLAYER) {
            draw_msg(MSG_Menus_Battle_TargetMario, screenX + BattleMenu_TargetNameOffsetX, screenY, 255, MSG_PAL_36, 0);
        } else if (actorID == ACTOR_PARTNER) {
            draw_msg(PartnerNameMessages[currentPartner], screenX + BattleMenu_TargetNameOffsetX, screenY, 255, MSG_PAL_36, 0);
        } else {
            draw_msg(MSG_Menus_Battle_TargetAllEnemies, screenX + BattleMenu_TargetNameOffsetX, screenY, 255, MSG_PAL_36, 0);
        }
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_celebration()

void btl_state_update_celebration ( void )

Definition at line 508 of file level_up.c.

                                        {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    s8 currentSubmenu;
    s32 newSubmenu;
    HudElemID hid;
    s32 x, y, z;
    s32 width;
    s32 itemHudElemID;
 
    Evt* takeTurnScript;
    Evt* script;
 
    s32 tensDigit;
    s32 onesDigit;
 
    s32 deltaSP;
    s32 prevSP;
 
    s32 i;
    s32 j;
 
    HudScript* new_var;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_INIT:
            if (battleStatus->pendingStarPoints <= 0) {
                player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
                EndBattleRewardTotal = battleStatus->totalStarPoints * 100;
                pendingLevelUps = 0;
                D_8029FB50 = 0;
                bFadeToBlackAmt = 0;
                LevelUpSelectTextOffsetX = 0;
                LevelUpSelectTextVelX = 0;
                sfx_play_sound(SOUND_JINGLE_WON_BATTLE);
 
                prevSP = playerData->starPoints + battleStatus->totalStarPoints;
                if (prevSP > 99) {
                    bgm_set_song(0, SONG_LEVEL_UP, 0, 250, 8);
                } else {
                    bgm_set_song(0, SONG_BATTLE_END, 0, 250, 8);
                }
 
                CelebrateStateTime = 0;
                btl_cam_use_preset(BTL_CAM_VICTORY);
                EndBattleRewardStep = 0;
                CelebrateSubstateTime = 1;
                gBattleSubState = BTL_SUBSTATE_LOAD_STAR_POINTS;
                gBattleStatus.flags2 |= BS_FLAGS2_AWARDING_STAR_POINTS;
            }
            break;
        case BTL_SUBSTATE_LOAD_STAR_POINTS:
            if (CelebrateSubstateTime != 0) {
                CelebrateSubstateTime--;
            } else if (btl_cam_is_moving_done()) {
                DMA_COPY_SEGMENT(starpoint);
                script = start_script(&EVS_ShowStarpoints, EVT_PRIORITY_A, 0);
                EndBattleRewardsDone = FALSE;
                // divide reward into 20 increments
                EndBattleRewardStep = 20;
                EndBattleRewardIncrement = EndBattleRewardTotal / EndBattleRewardStep;
                player->takeTurnScript = script;
                CelebrateSubstateTime = 1;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
                gBattleSubState = BTL_SUBSTATE_TALLY_STAR_POINTS;
            }
            break;
        case BTL_SUBSTATE_TALLY_STAR_POINTS:
            if (CelebrateSubstateTime == 0) {
                if (battleStatus->totalStarPoints != 0) {
                    // determine the remaining star point reward after this step and give the difference to the player
                    EndBattleRewardTotal -= EndBattleRewardIncrement;
                    prevSP = battleStatus->totalStarPoints;
                    battleStatus->totalStarPoints = EndBattleRewardTotal / 100;
                    deltaSP = prevSP - battleStatus->totalStarPoints;
                    if (deltaSP > 0) {
                        sfx_play_sound(SOUND_STAR_POINT_PICKUP);
                    }
 
                    playerData->starPoints += deltaSP;
                    bFadeToBlackAmt++; // ??
                    if (EndBattleRewardStep == 0 && battleStatus->totalStarPoints != 0) {
                        playerData->starPoints++;
                    }
                }
                if (playerData->level >= 27) {
                    playerData->starPoints = 0;
                }
                if (playerData->starPoints >= 100) {
                    pendingLevelUps = 1;
                    playerData->starPoints -= 100;
                }
                if (playerData->level + pendingLevelUps == 27) {
                    playerData->starPoints = 0;
                }
                if (battleStatus->totalStarPoints == 0) {
                    if (EndBattleRewardStep == 0) {
                        EndBattleRewardsDone = TRUE;
                        player->flags &= ~(ACTOR_FLAG_USING_IDLE_ANIM | ACTOR_FLAG_SHOW_STATUS_ICONS);
                        if (partner != NULL) {
                            partner->flags &= ~(ACTOR_FLAG_USING_IDLE_ANIM | ACTOR_FLAG_SHOW_STATUS_ICONS);
                        }
                        battleStatus->battlePhase = PHASE_CELEBRATE;
                        script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
                        player->takeTurnScript = script;
                        player->takeTurnScriptID = script->id;
                        script->owner1.actorID = ACTOR_PLAYER;
                        if (partner != NULL) {
                            script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
                            partner->takeTurnScript = script;
                            partner->takeTurnScriptID = script->id;
                            script->owner1.actorID = ACTOR_PARTNER;
                        }
                        CelebrateSubstateTime = 40;
                        gBattleSubState = BTL_SUBSTATE_POST_STAR_POINTS;
                    } else {
                        EndBattleRewardStep--;
                    }
                }
            } else {
                CelebrateSubstateTime--;
            }
            break;
        case BTL_SUBSTATE_POST_STAR_POINTS:
            if (CelebrateSubstateTime == 0) {
                if (pendingLevelUps == 0) {
                    gBattleSubState = BTL_SUBSTATE_SKIPPABLE_END_DELAY;
                } else {
                    gBattleSubState = BTL_SUBSTATE_LEVEL_UP_LOAD;
                }
                break;
            }
            CelebrateSubstateTime--;
            break;
        case BTL_SUBSTATE_LEVEL_UP_LOAD:
            if (CelebrateStateTime >= 99) {
                playerData->level++;
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(5);
                DMA_COPY_SEGMENT(level_up);
                sfx_play_sound(SOUND_LOOP_CHEERING);
                CelebrateStateTime = 0;
                gBattleSubState = BTL_SUBSTATE_LEVEL_UP_BEGIN;
            }
            break;
        case BTL_SUBSTATE_LEVEL_UP_BEGIN:
            LevelUpScriptPtr = start_script(&EVS_ShowLevelUp, EVT_PRIORITY_A, 0);
            LevelUpScriptID = LevelUpScriptPtr->id;
            CelebrateSubstateTime = 25;
            gBattleSubState = BTL_SUBSTATE_LEVEL_UP_CREATE_HUD;
            mdl_set_all_tint_type(ENV_TINT_SHROUD);
            *gBackgroundTintModePtr = ENV_TINT_SHROUD;
            mdl_set_shroud_tint_params(0, 0, 0, 0);
            break;
        case BTL_SUBSTATE_LEVEL_UP_CREATE_HUD:
            if (CelebrateSubstateTime == 18) {
                playerData->curHP = playerData->curMaxHP;
                playerData->curFP = playerData->curMaxFP;
                x = player->curPos.x + 0.0f;
                y = player->curPos.y + 35.0f;
                z = player->curPos.z;
                fx_recover(0, x, y, z, playerData->curHP);
                x = player->curPos.x + 20.0f;
                y = player->curPos.y + 25.0f;
                z = player->curPos.z;
                fx_recover(1, x, y, z, playerData->curFP);
                playerData->starPower = playerData->maxStarPower * SP_PER_BAR;
            }
 
            if (CelebrateSubstateTime != 0) {
                CelebrateSubstateTime--;
                if (CelebrateSubstateTime < 10) {
                    mdl_set_shroud_tint_params(0, 0, 0, ((10 - CelebrateSubstateTime) * 16) & 0xF0);
                }
            } else {
                hid = hud_element_create(&HES_level_up_heart);
                LevelUpStatEmblemIDs[0] = hid;
                hud_element_set_render_pos(hid, 310, 140);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_MANUAL_RENDER);
 
                hid = hud_element_create(&HES_level_up_flower);
                LevelUpStatEmblemIDs[1] = hid;
                hud_element_set_render_pos(hid, 158, 340);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_MANUAL_RENDER);
 
                hid = hud_element_create(&HES_level_up_leaves);
                LevelUpStatEmblemIDs[3] = hid;
                hud_element_set_render_pos(hid, 158, 340);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_MANUAL_RENDER);
 
                hid = hud_element_create(&HES_level_up_badge);
                LevelUpStatEmblemIDs[2] = hid;
                hud_element_set_render_pos(hid, 6, 140);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_MANUAL_RENDER);
 
                hid = hud_element_create(levelup_stat_scripts[0]);
                LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_TITLE] = hid;
                hud_element_set_render_pos(hid, 160, 317);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_MANUAL_RENDER);
 
                for (i = 1; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                    hid = hud_element_create(HES_LevelUpDigits[LVL_UP_FP][0]);
                    LevelUpStatTextIDs[LVL_UP_FP][i] = hid;
                    hud_element_set_render_pos(hid, 160, 317);
                    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_MANUAL_RENDER | HUD_ELEMENT_FLAG_DISABLED);
                }
 
                hid = hud_element_create(levelup_stat_scripts[1]);
                LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_TITLE] = hid;
                hud_element_set_render_pos(hid, 312, 117);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_MANUAL_RENDER);
 
                for (i = 1; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_HP]); i++) {
                    hid = hud_element_create(HES_LevelUpDigits[LVL_UP_HP][0]);
                    LevelUpStatTextIDs[LVL_UP_HP][i] = hid;
                    hud_element_set_render_pos(hid, 312, 117);
                    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_MANUAL_RENDER | HUD_ELEMENT_FLAG_DISABLED);
                }
 
                hid = hud_element_create(levelup_stat_scripts[2]);
                LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_TITLE] = hid;
                hud_element_set_render_pos(hid, 8, 117);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_MANUAL_RENDER);
 
                for (i = 1; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_BP]); i++) {
                    hid = hud_element_create(HES_LevelUpDigits[LVL_UP_BP][0]);
                    LevelUpStatTextIDs[LVL_UP_BP][i] = hid;
                    hud_element_set_render_pos(hid, 8, 117);
                    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_MANUAL_RENDER | HUD_ELEMENT_FLAG_DISABLED);
                }
 
                CantLevelUpStat[MENU_HP] = FALSE;
                CantLevelUpStat[MENU_FP] = FALSE;
                CantLevelUpStat[MENU_BP] = FALSE;
 
                if (playerData->hardMaxFP != 50) {
                    // current FP
                    tensDigit = playerData->curMaxFP / 10;
                    onesDigit = playerData->curMaxFP % 10;
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_CUR_TENS];
                    hud_element_set_script(hid, level_up_small_digit_scripts[LVL_UP_FP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 14, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_CUR_ONES];
                    hud_element_set_script(hid, level_up_small_digit_scripts[LVL_UP_FP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 8, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_ARROW];
                    hud_element_set_script(hid, &HES_level_up_small_green_arrow);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 3, y + 46);
 
                    // upgraded FP
                    tensDigit = (playerData->curMaxFP + 5) / 10;
                    onesDigit = (playerData->curMaxFP + 5) % 10;
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_NEXT_TENS];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_FP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 3, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_NEXT_ONES];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_FP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 10, y + 46);
                } else {
                    // upgraded FP only
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_NEXT_TENS];
                    tensDigit = playerData->curMaxFP / 10;
                    onesDigit = playerData->curMaxFP % 10;
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_FP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 6, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_NEXT_ONES];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_FP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 2, y + 46);
                    CantLevelUpStat[MENU_FP] = TRUE;
                }
 
                if (is_ability_active(ABILITY_FP_PLUS)) {
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_BONUS];
                    itemHudElemID = gItemTable[ITEM_FP_PLUS_A].hudElemID;
                    hud_element_set_script(hid, gItemHudScripts[itemHudElemID].enabled);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_set_scale(hid, 0.5f);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 17, y + 46);
                }
 
                if (playerData->hardMaxHP != 50) {
                    // current HP
                    tensDigit = playerData->curMaxHP / 10;
                    onesDigit = playerData->curMaxHP % 10;
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_CUR_TENS];
                    hud_element_set_script(hid, level_up_small_digit_scripts[LVL_UP_HP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 14, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_CUR_ONES];
                    hud_element_set_script(hid, level_up_small_digit_scripts[LVL_UP_HP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 8, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_ARROW];
                    hud_element_set_script(hid, &HES_level_up_small_red_arrow);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 3, y + 46);
 
                    tensDigit = (playerData->curMaxHP + 5) / 10;
                    onesDigit = (playerData->curMaxHP + 5) % 10;
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_NEXT_TENS];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_HP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 3, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_NEXT_ONES];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_HP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 10, y + 46);
                } else {
                    tensDigit = playerData->curMaxHP / 10;
                    onesDigit = playerData->curMaxHP % 10;
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_NEXT_TENS];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_HP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 6, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_NEXT_ONES];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_HP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 2, y + 46);
                    CantLevelUpStat[MENU_HP] = TRUE;
                }
 
                if (is_ability_active(ABILITY_HP_PLUS)) {
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_BONUS];
                    itemHudElemID = gItemTable[ITEM_HP_PLUS_A].hudElemID;
                    hud_element_set_script(hid, gItemHudScripts[itemHudElemID].enabled);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_set_scale(hid, 0.5f);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 17, y + 46);
                }
 
                if (playerData->maxBP != 30) {
                    tensDigit = playerData->maxBP / 10;
                    onesDigit = playerData->maxBP % 10;
 
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_CUR_TENS];
                    hud_element_set_script(hid, level_up_small_digit_scripts[LVL_UP_BP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 14, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_CUR_ONES];
                    hud_element_set_script(hid, level_up_small_digit_scripts[LVL_UP_BP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 8, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_ARROW];
                    hud_element_set_script(hid, &HES_level_up_small_blue_arrow);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 3, y + 46);
 
                    tensDigit = (playerData->maxBP + 3) / 10;
                    onesDigit = (playerData->maxBP + 3) % 10;
 
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_NEXT_TENS];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_BP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 3, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_NEXT_ONES];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_BP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 10, y + 46);
                } else {
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_NEXT_TENS];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_BP][3]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 6, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_NEXT_ONES];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_BP][0]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 2, y + 46);
                    CantLevelUpStat[MENU_BP] = TRUE;
                }
 
                LevelUpSpotlightID = hid = hud_element_create(&HES_ProjectorBeam);
                hud_element_create_transform_B(hid);
                hud_element_set_render_pos(hid, 156, 13);
                hud_element_set_tint(hid, 255, 255, 255);
                hud_element_set_transform_rotation_pivot(hid, 0, -35);
                hud_element_set_transform_rotation(hid, 0.0f, 0.0f, 180.0f);
                hud_element_set_transform_scale(hid, 1.0f, 1.5f, 1.0f);
                hud_element_set_alpha(hid, 200);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX | HUD_ELEMENT_FLAG_MANUAL_RENDER);
 
                LevelUpSelectTextID = hid = hud_element_create(&HES_level_up_select_one_to_upgrade);
                hud_element_set_render_pos(hid, 0, 0);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_MANUAL_RENDER);
                battleStatus->curSubmenu = MENU_FP;
 
                CelebrateSubstateTime = 10;
                gBattleSubState = BTL_SUBSTATE_LEVEL_UP_SHOW_HUD;
            }
            break;
        case BTL_SUBSTATE_LEVEL_UP_SHOW_HUD:
            hid = LevelUpStatEmblemIDs[0];
            hud_element_get_render_pos(hid, &x, &y);
            x -= 20;
            hud_element_set_render_pos(hid, x, y);
 
            for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_HP]); i++) {
                hid = LevelUpStatTextIDs[LVL_UP_HP][i];
                hud_element_get_render_pos(hid, &x, &y);
                x -= 20;
                hud_element_set_render_pos(hid, x, y);
            }
 
            hid = LevelUpStatEmblemIDs[1];
            hud_element_get_render_pos(hid, &x, &y);
            y -= 20;
            hud_element_set_render_pos(hid, x, y);
 
            hid = LevelUpStatEmblemIDs[3];
            hud_element_get_render_pos(hid, &x, &y);
            y -= 20;
            hud_element_set_render_pos(hid, x, y);
 
            for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                hid = LevelUpStatTextIDs[LVL_UP_FP][i];
                hud_element_get_render_pos(hid, &x, &y);
                y -= 20;
                hud_element_set_render_pos(hid, x, y);
            }
 
            hid = LevelUpStatEmblemIDs[2];
            hud_element_get_render_pos(hid, &x, &y);
            x += 20;
            hud_element_set_render_pos(hid, x, y);
 
            for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_BP]); i++) {
                hid = LevelUpStatTextIDs[LVL_UP_BP][i];
                hud_element_get_render_pos(hid, &x, &y);
                x += 20;
                hud_element_set_render_pos(hid, x, y);
            }
 
            CelebrateSubstateTime--;
            if (CelebrateSubstateTime == 0) {
                hud_element_set_tint(hid, 128, 128, 128);
#if VERSION_JP
                x = 32;
                y = 186;
                set_window_properties(WIN_BTL_DESC_BOX, 32, 186, 242, 32, WINDOW_PRIORITY_20, draw_content_level_up_textbox, NULL, -1);
#else
                x = 20;
                y = 186;
                set_window_properties(WIN_BTL_DESC_BOX, 20, 186, 280, 32, WINDOW_PRIORITY_20, draw_content_level_up_textbox, NULL, -1);
#endif
                set_window_update(WIN_BTL_DESC_BOX, WINDOW_UPDATE_SHOW);
                gBattleSubState = BTL_SUBSTATE_LEVEL_UP_CHOOSE;
            }
            break;
        case BTL_SUBSTATE_LEVEL_UP_CHOOSE:
            if (battleStatus->curButtonsPressed & BUTTON_A) {
                if (!CantLevelUpStat[battleStatus->curSubmenu]) {
                    sfx_play_sound(SOUND_MENU_NEXT);
                    sfx_play_sound(SOUND_LRAW_CHEERING | SOUND_ID_TRIGGER_CHANGE_SOUND);
                    gBattleSubState = BTL_SUBSTATE_LEVEL_UP_UPGRADE;
                } else {
                    sfx_play_sound(SOUND_MENU_ERROR);
                    gBattleSubState = BTL_SUBSTATE_LEVEL_UP_INVALID;
                }
                break;
            }
 
            newSubmenu = currentSubmenu = battleStatus->curSubmenu;
            if (battleStatus->curButtonsHeld & BUTTON_STICK_LEFT) {
                newSubmenu--;
            }
            if (battleStatus->curButtonsHeld & BUTTON_STICK_RIGHT) {
                newSubmenu++;
            }
            if (newSubmenu < 0) {
                newSubmenu = 0;
            }
            if (newSubmenu > 2) {
                newSubmenu = 2;
            }
            if (newSubmenu != currentSubmenu) {
                sfx_play_sound(SOUND_MENU_CHANGE_SELECTION);
                battleStatus->curSubmenu = newSubmenu;
            }
 
            CelebrateStateTime++;
            if (CelebrateStateTime > 100) {
                fx_confetti(3, 0.0f, 100.0f, 0.0f, 1.0f, 120);
                CelebrateStateTime = 0;
            }
            break;
        case BTL_SUBSTATE_LEVEL_UP_UPGRADE:
            hud_element_free(LevelUpSpotlightID);
            set_window_update(WIN_BTL_DESC_BOX, WINDOW_UPDATE_HIDE);
 
            switch (battleStatus->curSubmenu) {
                case 0:
                    playerData->hardMaxHP += 5;
                    playerData->curMaxHP += 5;
                    playerData->curHP += 5;
                    if (playerData->curMaxHP > 75) {
                        playerData->curMaxHP = 75;
                    }
                    if (playerData->curHP > playerData->curMaxHP) {
                        playerData->curHP = playerData->curMaxHP;
                    }
                    player->maxHP = playerData->curMaxHP;
                    player->curHP = playerData->curHP;
                    break;
                case 1:
                    playerData->hardMaxFP += 5;
                    playerData->curMaxFP += 5;
                    playerData->curFP += 5;
                    if (playerData->curMaxFP > 75) {
                        playerData->curMaxFP = 75;
                    }
                    if (playerData->curFP > playerData->curMaxFP) {
                        playerData->curFP = playerData->curMaxFP;
                    }
                    break;
                case 2:
                    playerData->maxBP += 3;
                    if (playerData->maxBP > 30) {
                        playerData->maxBP = 30;
                    }
                    break;
            }
 
            set_actor_anim(0, 0, ANIM_MarioB1_AdjustCap);
 
            if (partner != NULL) {
                script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
                partner->takeTurnScript = script;
                partner->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
            }
            if (!(gBattleStatus.flags2 & BS_FLAGS2_DONT_STOP_MUSIC)) {
                bgm_set_song(0, -1, 0, 2000, 8);
            }
            bFadeToBlackAmt = 0;
            gBattleSubState = BTL_SUBSTATE_LEVEL_UP_FADE_OUT;
            break;
        case BTL_SUBSTATE_LEVEL_UP_FADE_OUT:
            if ((gGameStatusPtr->frameCounter % 2) != 0) {
                switch (battleStatus->curSubmenu) {
                    case MENU_HP:
                        hud_element_set_flags(LevelUpStatEmblemIDs[0], HUD_ELEMENT_FLAG_DISABLED);
                        break;
                    case MENU_FP:
                        hud_element_set_flags(LevelUpStatEmblemIDs[1], HUD_ELEMENT_FLAG_DISABLED);
                        hud_element_set_flags(LevelUpStatEmblemIDs[3], HUD_ELEMENT_FLAG_DISABLED);
                        break;
                    case MENU_BP:
                        hud_element_set_flags(LevelUpStatEmblemIDs[2], HUD_ELEMENT_FLAG_DISABLED);
                        break;
                }
            } else {
                switch (battleStatus->curSubmenu) {
                    case MENU_HP:
                        hud_element_clear_flags(LevelUpStatEmblemIDs[0], HUD_ELEMENT_FLAG_DISABLED);
                        break;
                    case MENU_FP:
                        hud_element_clear_flags(LevelUpStatEmblemIDs[1], HUD_ELEMENT_FLAG_DISABLED);
                        hud_element_clear_flags(LevelUpStatEmblemIDs[3], HUD_ELEMENT_FLAG_DISABLED);
                        break;
                    case MENU_BP:
                        hud_element_clear_flags(LevelUpStatEmblemIDs[2], HUD_ELEMENT_FLAG_DISABLED);
                        break;
                }
            }
            if (bFadeToBlackAmt == 255) {
                gBattleSubState = BTL_SUBSTATE_LEVEL_UP_DESTROY_HUD;
                break;
            }
            bFadeToBlackAmt += 10;
            if (bFadeToBlackAmt > 255) {
                bFadeToBlackAmt = 255;
            }
            break;
        case BTL_SUBSTATE_LEVEL_UP_DESTROY_HUD:
            hud_element_free(LevelUpStatEmblemIDs[0]);
            hud_element_free(LevelUpStatEmblemIDs[1]);
            hud_element_free(LevelUpStatEmblemIDs[3]);
            hud_element_free(LevelUpStatEmblemIDs[2]);
 
            for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs); i++) {
                for (j = 0; j < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); j++) {
                    hud_element_free(LevelUpStatTextIDs[i][j]);
                }
            }
 
            hud_element_free(LevelUpSelectTextID);
            mdl_set_shroud_tint_params(0, 0, 0, 0);
            btl_set_state(BATTLE_STATE_END_BATTLE);
            gBattleSubState = BTL_SUBSTATE_END_BATTLE_EXEC_STAGE_SCRIPT;
            break;
        case BTL_SUBSTATE_LEVEL_UP_INVALID:
            width = get_msg_width(MSG_Menus_CantIncrease, 0) + 31;
            x = 160 - (width / 2);
            y = 80;
            set_window_properties(WIN_BTL_POPUP, x, y, width, 28, WINDOW_PRIORITY_10, draw_content_cant_increase_popup, NULL, -1);
            set_window_update(WIN_BTL_POPUP, WINDOW_UPDATE_SHOW);
            CelebrateSubstateTime = 60;
            gBattleSubState = BTL_SUBSTATE_LEVEL_UP_INVALID_DELAY;
            break;
        case BTL_SUBSTATE_LEVEL_UP_INVALID_DELAY:
            if (gGameStatusPtr->pressedButtons[0] & (BUTTON_A | BUTTON_B)) {
                CelebrateSubstateTime = 0;
            }
            if (CelebrateSubstateTime != 0) {
                CelebrateSubstateTime--;
                break;
            }
            set_window_update(WIN_BTL_POPUP, WINDOW_UPDATE_HIDE);
            gBattleSubState = BTL_SUBSTATE_LEVEL_UP_CHOOSE;
            break;
        case BTL_SUBSTATE_SKIPPABLE_END_DELAY:
            if (battleStatus->curButtonsPressed & (BUTTON_A | BUTTON_B)) {
                CelebrateStateTime = 99;
#if VERSION_JP
                sfx_play_sound(SOUND_MENU_NEXT);
#endif
            }
            if (CelebrateStateTime >= 99) {
                if (!(gBattleStatus.flags2 & BS_FLAGS2_DONT_STOP_MUSIC)) {
                    bgm_set_song(0, -1, 0, 1500, 8);
                }
                bFadeToBlackAmt = 0;
                btl_cam_set_params(TRUE, 270, 100, 8, 0, 0x2400, 100);
                set_actor_anim(0, 0, ANIM_MarioB1_AdjustCap);
                if (partner != NULL) {
                    set_actor_anim(ACTOR_PARTNER, 0, D_80284154[playerData->curPartner]);
                }
                CelebrateSubstateTime = 6;
                gBattleSubState = BTL_SUBSTATE_WALK_AWAY;
                break;
            }
            break;
        case BTL_SUBSTATE_WALK_AWAY:
            if (CelebrateSubstateTime != 0) {
                CelebrateSubstateTime--;
                if (CelebrateSubstateTime == 0) {
                    set_actor_anim(0, 0, ANIM_Mario1_Walk);
                }
            } else {
                player->yaw = 0.0f;
                if (partner != NULL) {
                    partner->yaw = 0.0f;
                }
 
                player->curPos.x += 4.0f;
                if (partner != NULL) {
                    partner->curPos.x += 4.0f;
                }
            }
            if (bFadeToBlackAmt == 255) {
                gBattleSubState = BTL_SUBSTATE_DONE;
                break;
            }
            bFadeToBlackAmt += 20;
            if (bFadeToBlackAmt > 255) {
                bFadeToBlackAmt = 255;
            }
            break;
        case BTL_SUBSTATE_DONE:
            if (does_script_exist(player->takeTurnScriptID)) {
                kill_script_by_ID(player->takeTurnScriptID);
            }
            if (partner != NULL && does_script_exist(partner->takeTurnScriptID)) {
                kill_script_by_ID(partner->takeTurnScriptID);
            }
            btl_set_state(BATTLE_STATE_END_BATTLE);
            gBattleSubState = BTL_SUBSTATE_END_BATTLE_EXEC_STAGE_SCRIPT;
            break;
    }
    CelebrateStateTime++;
}

Referenced by btl_update().

◆ btl_state_draw_celebration()

void btl_state_draw_celebration ( void )

Definition at line 1294 of file level_up.c.

                                      {
    BattleStatus* battleStatus = &gBattleStatus;
    s32 rotZ;
    s32 id;
    s32 i;
    s32 j;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_LEVEL_UP_SHOW_HUD:
            btl_draw_upgrade_windows(0);
            id = LevelUpStatEmblemIDs[0];
            hud_element_set_tint(id, 128, 128, 128);
            hud_element_draw_clipped(id);
            id = LevelUpStatEmblemIDs[3];
            hud_element_set_tint(id, 128, 128, 128);
            hud_element_draw_clipped(id);
            id = LevelUpStatEmblemIDs[1];
            hud_element_set_tint(id, 128, 128, 128);
            hud_element_draw_clipped(id);
            id = LevelUpStatEmblemIDs[2];
            hud_element_set_tint(id, 128, 128, 128);
            hud_element_draw_clipped(id);
 
            for (j = 0; j < ARRAY_COUNT(LevelUpStatTextIDs); j++) {
                for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                    id = LevelUpStatTextIDs[j][i];
 
                    hud_element_set_tint(id, 128, 128, 128);
                    hud_element_draw_clipped(id);
                }
            }
            break;
        case BTL_SUBSTATE_LEVEL_UP_CHOOSE:
        case BTL_SUBSTATE_LEVEL_UP_INVALID:
        case BTL_SUBSTATE_LEVEL_UP_INVALID_DELAY:
            switch (battleStatus->curSubmenu) {
                case MENU_HP:
                    rotZ = 152;
                    hud_element_set_tint(LevelUpStatEmblemIDs[0], 255, 255, 255);
                    hud_element_set_tint(LevelUpStatEmblemIDs[3], 128, 128, 128);
                    hud_element_set_tint(LevelUpStatEmblemIDs[1], 128, 128, 128);
                    hud_element_set_tint(LevelUpStatEmblemIDs[2], 128, 128, 128);
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_FP][i];
 
                        hud_element_set_tint(id, 128, 128, 128);
                    }
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_HP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_HP][i];
 
                        hud_element_set_tint(id, 255, 255, 255);
                    }
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_BP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_BP][i];
 
                        hud_element_set_tint(id, 128, 128, 128);
                    }
 
                    id = LevelUpStatEmblemIDs[0];
                    if (hud_element_get_script(id) != &HES_level_up_heart_copy) {
                        hud_element_set_script(id, &HES_level_up_heart_copy);
                    }
                    id = LevelUpStatEmblemIDs[3];
                    if (hud_element_get_script(id) != &HES_level_up_leaves) {
                        hud_element_set_script(id, &HES_level_up_leaves);
                    }
                    id = LevelUpStatEmblemIDs[1];
                    if (hud_element_get_script(id) != &HES_level_up_flower) {
                        hud_element_set_script(id, &HES_level_up_flower);
                    }
                    id = LevelUpStatEmblemIDs[2];
                    if (hud_element_get_script(id) != &HES_level_up_badge) {
                        hud_element_set_script(id, &HES_level_up_badge);
                    }
                    break;
                case MENU_FP:
                    rotZ = 180;
                    hud_element_set_tint(LevelUpStatEmblemIDs[0], 128, 128, 128);
                    hud_element_set_tint(LevelUpStatEmblemIDs[3], 255, 255, 255);
                    hud_element_set_tint(LevelUpStatEmblemIDs[1], 255, 255, 255);
                    hud_element_set_tint(LevelUpStatEmblemIDs[2], 128, 128, 128);
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_FP][i];
 
                        hud_element_set_tint(id, 255, 255, 255);
                    }
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_HP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_HP][i];
 
                        hud_element_set_tint(id, 128, 128, 128);
                    }
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_BP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_BP][i];
 
                        hud_element_set_tint(id, 128, 128, 128);
                    }
                    break;
                case MENU_BP:
                default:
                    rotZ = 208;
                    hud_element_set_tint(LevelUpStatEmblemIDs[0], 128, 128, 128);
                    hud_element_set_tint(LevelUpStatEmblemIDs[3], 128, 128, 128);
                    hud_element_set_tint(LevelUpStatEmblemIDs[1], 128, 128, 128);
                    hud_element_set_tint(LevelUpStatEmblemIDs[2], 255, 255, 255);
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_FP][i];
 
                        hud_element_set_tint(id, 128, 128, 128);
                    }
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_HP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_HP][i];
 
                        hud_element_set_tint(id, 128, 128, 128);
                    }
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_BP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_BP][i];
 
                        hud_element_set_tint(id, 255, 255, 255);
                    }
                    break;
            }
 
            btl_draw_upgrade_windows(1);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[0]);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[3]);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[1]);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[2]);
 
            for (j = 0; j < ARRAY_COUNT(LevelUpStatTextIDs); j++) {
                for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                    hud_element_draw_clipped(LevelUpStatTextIDs[j][i]);
                }
            }
 
            hud_element_draw_complex_hud_first(-1);
            id = LevelUpSpotlightID;
            hud_element_set_transform_rotation(id, 0.0f, 0.0f, rotZ);
            hud_element_draw_complex_hud_next(id);
            break;
        case BTL_SUBSTATE_LEVEL_UP_UPGRADE:
        case BTL_SUBSTATE_LEVEL_UP_FADE_OUT:
            btl_draw_upgrade_windows(1);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[0]);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[3]);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[1]);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[2]);
 
            for (j = 0; j < ARRAY_COUNT(LevelUpStatTextIDs); j++) {
                for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                    hud_element_draw_clipped(LevelUpStatTextIDs[j][i]);
                }
            }
 
            set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, bFadeToBlackAmt);
            break;
        case BTL_SUBSTATE_LEVEL_UP_DESTROY_HUD:
            set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, bFadeToBlackAmt);
            break;
        case BTL_SUBSTATE_WALK_AWAY:
            if (bFadeToBlackAmt != 0) {
                set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, bFadeToBlackAmt);
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_LEVEL_UP_SHOW_HUD:
        case BTL_SUBSTATE_LEVEL_UP_CHOOSE:
        case BTL_SUBSTATE_LEVEL_UP_UPGRADE:
            LevelUpSelectTextVelX += 2;
            LevelUpSelectTextOffsetX += LevelUpSelectTextVelX;
            if (LevelUpSelectTextOffsetX > 200) {
                LevelUpSelectTextOffsetX = 200;
                LevelUpSelectTextVelX = -LevelUpSelectTextVelX / 3; // rebounding
            }
            id = LevelUpSelectTextID;
            hud_element_set_render_pos(id, LevelUpSelectTextOffsetX - 43, 176);
            hud_element_draw_clipped(id);
            break;
        case BTL_SUBSTATE_LEVEL_UP_FADE_OUT:
            LevelUpSelectTextVelX += 4;
            LevelUpSelectTextOffsetX += LevelUpSelectTextVelX;
            if (LevelUpSelectTextOffsetX > 500) {
                LevelUpSelectTextOffsetX = 500;
            }
            id = LevelUpSelectTextID;
            hud_element_set_render_pos(id, LevelUpSelectTextOffsetX - 43, 176);
            hud_element_draw_clipped(id);
            break;
    }
}

Referenced by btl_draw_ui().

Variable Documentation

◆ EndDemoWhiteOut

s16 EndDemoWhiteOut

extern

Definition at line 13 of file 16C8E0.c.

Referenced by btl_state_draw_end_demo_battle(), btl_state_draw_first_stike(), btl_state_update_end_demo_battle(), and btl_update().

◆ BattleSkipActorTurn

b32 BattleSkipActorTurn

extern

Definition at line 5 of file btl_states_actions.c.

Referenced by btl_state_update_begin_partner_turn(), btl_state_update_begin_player_turn(), and update_status_damage().

◆ BattleCanShowFirstStrike

b32 BattleCanShowFirstStrike

extern

Definition at line 6 of file btl_states_actions.c.

Referenced by btl_state_draw_enemy_striking_first(), btl_state_draw_first_stike(), btl_state_draw_partner_striking_first(), btl_state_update_enemy_striking_first(), btl_state_update_first_strike(), and btl_state_update_partner_striking_first().

◆ BattleStatusUpdateDelay

s32 BattleStatusUpdateDelay

extern

Definition at line 7 of file btl_states_actions.c.

Referenced by btl_state_update_begin_partner_turn(), btl_state_update_begin_player_turn(), btl_state_update_transfer_turn(), and update_status_damage().

◆ BattleSubstateDelay

s32 BattleSubstateDelay

extern

Definition at line 4 of file btl_states_actions.c.

Referenced by btl_state_update_change_partner(), btl_state_update_end_training_battle(), btl_state_update_enemy_move(), btl_state_update_enemy_striking_first(), btl_state_update_first_strike(), btl_state_update_normal_start(), btl_state_update_partner_move(), btl_state_update_partner_striking_first(), btl_state_update_player_move(), btl_state_update_run_away(), and btl_state_update_victory().

◆ BattleScreenFadeAmt

s32 BattleScreenFadeAmt

extern

Definition at line 50 of file 16C8E0.c.

Referenced by btl_state_draw_end_battle(), btl_state_draw_end_demo_battle(), btl_state_draw_enemy_striking_first(), btl_state_draw_first_stike(), btl_state_draw_normal_start(), btl_state_draw_partner_striking_first(), btl_state_update_end_battle(), btl_state_update_end_demo_battle(), btl_state_update_normal_start(), and btl_state_update_run_away().

Enumerations

Functions

Variables

Enumeration Type Documentation

◆ BattleSubStates

Function Documentation

◆ btl_state_update_normal_start()

◆ btl_state_draw_normal_start()

◆ btl_state_update_begin_turn()

◆ btl_state_draw_begin_turn()

◆ btl_state_update_begin_player_turn()

◆ btl_state_draw_begin_player_turn()

◆ btl_state_update_switch_to_player()

◆ btl_state_draw_switch_to_player()

◆ btl_state_update_begin_partner_turn()

◆ btl_state_draw_begin_partner_turn()

◆ btl_state_update_switch_to_partner()

◆ btl_state_draw_switch_to_partner()

◆ btl_state_update_transfer_turn()

◆ btl_state_draw_transfer_turn()

◆ btl_state_update_prepare_menu()

◆ btl_state_draw_prepare_menu()

◆ btl_state_update_end_turn()

◆ btl_state_draw_end_turn()

◆ btl_state_update_victory()

◆ btl_state_draw_victory()

◆ btl_state_update_end_training_battle()

◆ btl_state_draw_end_training_battle()

◆ btl_state_update_end_battle()

◆ btl_state_draw_end_battle()

◆ btl_state_update_defend()

◆ btl_state_draw_defend()

◆ btl_state_update_run_away()

◆ btl_state_draw_run_away()

◆ btl_state_update_defeat()

◆ btl_state_draw_defeat()

◆ btl_state_update_change_partner()

◆ btl_state_draw_change_partner()

◆ btl_state_update_player_move()

◆ btl_state_draw_player_move()

◆ btl_state_update_end_player_turn()

◆ btl_state_update_partner_move()

◆ btl_state_draw_end_player_turn()

◆ btl_state_draw_partner_move()

◆ btl_state_update_end_partner_turn()

◆ btl_state_draw_end_partner_turn()

◆ btl_state_update_next_enemy()

◆ btl_state_draw_next_enemy()

◆ btl_state_update_enemy_move()

◆ btl_state_draw_enemy_move()

◆ btl_state_update_first_strike()

◆ btl_state_draw_first_stike()

◆ btl_state_update_partner_striking_first()

◆ btl_state_draw_partner_striking_first()

◆ btl_state_update_enemy_striking_first()

◆ btl_state_draw_enemy_striking_first()

◆ btl_state_update_end_demo_battle()

◆ btl_state_draw_end_demo_battle()

◆ btl_state_update_player_menu()

◆ btl_state_draw_player_menu()

◆ btl_state_update_partner_menu()

◆ btl_state_draw_partner_menu()

◆ btl_state_update_peach_menu()

◆ btl_state_draw_peach_menu()

◆ btl_state_update_twink_menu()

◆ btl_state_draw_twink_menu()

◆ btl_state_update_select_target()

◆ btl_state_draw_select_target()

◆ btl_state_update_celebration()

◆ btl_state_draw_celebration()

Variable Documentation

◆ EndDemoWhiteOut

◆ BattleSkipActorTurn

◆ BattleCanShowFirstStrike

◆ BattleStatusUpdateDelay

◆ BattleSubstateDelay

◆ BattleScreenFadeAmt