actions.c File Reference

Go to the source code of this file.

Macros
#define	ACTION_FILE(name)   world_action_##name##_ROM_START, world_action_##name##_ROM_END

Functions
void	action_update_idle (void)
void	action_update_walk (void)
void	action_update_run (void)
void	action_update_land (void)
void	action_update_jump (void)
void	action_update_landing_on_switch (void)
void	action_update_falling (void)
void	action_update_step_down (void)
void	action_update_step_down_land (void)
void	action_update_spin_jump (void)
void	action_update_tornado_jump (void)
void	action_update_talk (void)
void	action_update_sliding (void)
void	action_update_hammer (void)
void	action_update_launch (void)
void	action_update_pushing_block (void)
void	action_update_hit_fire (void)
void	action_update_knockback (void)
void	action_update_hit_lava (void)
void	action_update_parasol (void)
void	action_update_spin (void)
void	action_update_step_up_peach (void)
void	action_update_ride (void)
void	action_update_step_up (void)
void	action_update_first_strike (void)
void	action_update_raise_arms (void)
void	action_update_use_spinning_flower (void)
void	action_update_use_munchlesia (void)
void	action_update_use_tweester (void)
void	action_update_state_23 (void)

Variables
Action	PlayerActionsTable []

Macro Definition Documentation

ACTION_FILE

#define ACTION_FILE

(

name

)

world_action_##name##_ROM_START, world_action_##name##_ROM_END

Definition at line 75 of file actions.c.

Function Documentation

action_update_idle()

void action_update_idle

(

void

)

Definition at line 36 of file idle.c.

                              {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerData* playerData = &gPlayerData;
    s32 firstFrame = FALSE;
    f32 angle, magnitude;
    AnimID anim;
 
    if (playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) {
        action_update_idle_peach();
        return;
    }
 
    playerStatus->curStateTime++;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~(PS_FLAG_ACTION_STATE_CHANGED | PS_FLAG_ARMS_RAISED | PS_FLAG_AIRBORNE);
        firstFrame = TRUE;
        playerStatus->actionSubstate = SUBSTATE_IDLE_DEFAULT;
        playerStatus->curStateTime = 0;
        playerStatus->timeInAir = 0;
        playerStatus->peakJumpTime = 0;
        playerStatus->curSpeed = 0.0f;
        playerStatus->pitch = 0.0f;
 
        if (playerStatus->animFlags & PA_FLAG_8BIT_MARIO) {
            anim = ANIM_MarioW3_8bit_Still;
        } else if (!(playerStatus->animFlags & PA_FLAG_USING_WATT)) {
            anim = ANIM_Mario1_Idle;
        } else if (playerStatus->prevActionState == ACTION_STATE_IDLE) {
            anim = ANIM_MarioW1_TakeItem;
        } else {
            anim = ANIM_MarioW1_CarryIdle;
        }
        suggest_player_anim_allow_backward(anim);
    }
 
    if (playerStatus->animFlags & PA_FLAG_RAISED_ARMS) {
        set_action_state(ACTION_STATE_RAISE_ARMS);
        return;
    }
 
    player_input_to_move_vector(&angle, &magnitude);
    phys_update_interact_collider();
 
    if (check_input_jump()) {
        if (magnitude != 0.0f || playerStatus->targetYaw != angle) {
            playerStatus->targetYaw = angle;
        }
        return;
    }
 
    if (!firstFrame && check_input_hammer()) {
        return;
    }
 
    if (magnitude == 0.0f) {
        playerData->idleFrameCounter++;
    } else {
        playerStatus->curStateTime = 0;
        set_action_state(ACTION_STATE_WALK);
        if (magnitude != 0.0f) {
            playerStatus->targetYaw = angle;
            playerStatus->animFlags &= ~PA_FLAG_80000000;
        }
    }
}

action_update_walk()

void action_update_walk

(

void

)

Definition at line 30 of file walk.c.

                              {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerData* playerData = &gPlayerData;
    b32 firstFrame = FALSE;
    f32 moveMag;
    f32 moveAngle;
    AnimID anim;
 
    if (playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) {
        action_update_walk_peach();
        return;
    }
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~(PS_FLAG_ACTION_STATE_CHANGED | PS_FLAG_SCRIPTED_FALL | PS_FLAG_ARMS_RAISED);
        playerStatus->unk_60 = 0;
        firstFrame = TRUE;
 
        if (!(playerStatus->flags & PS_FLAG_CUTSCENE_MOVEMENT)) {
            playerStatus->curSpeed = playerStatus->walkSpeed;
        }
 
        if (playerStatus->animFlags & PA_FLAG_8BIT_MARIO) {
            anim = ANIM_MarioW3_8bit_Run;
        } else if (!(playerStatus->animFlags & PA_FLAG_USING_WATT)) {
            anim = ANIM_Mario1_Walk;
        } else {
            anim = ANIM_MarioW1_CarryWalk;
        }
        suggest_player_anim_allow_backward(anim);
    }
 
    if (playerStatus->flags & PS_FLAG_CUTSCENE_MOVEMENT) {
        playerStatus->targetYaw = playerStatus->heading;
        try_player_footstep_sounds(8);
        return;
    }
 
    player_input_to_move_vector(&moveAngle, &moveMag);
    phys_update_interact_collider();
 
    if (check_input_jump()) {
        return;
    }
 
    if (!firstFrame && check_input_hammer()) {
        return;
    }
 
    player_input_to_move_vector(&moveAngle, &moveMag);
    if (moveMag == 0.0f) {
        set_action_state(ACTION_STATE_IDLE);
        return;
    }
 
    if (fabsf(PrevPlayerCamRelativeYaw - moveAngle) <= 90.0f && abs(moveMag - D_800F7B44) < 20) {
        if (!(playerStatus->animFlags & PA_FLAG_80000000)) {
            if (moveMag >= 20.0f) {
                playerStatus->targetYaw = moveAngle;
            }
        }
        playerStatus->animFlags &= ~PA_FLAG_80000000;
    } else {
        if (playerStatus->animFlags & PA_FLAG_80000000) {
            playerStatus->targetYaw = moveAngle;
        } else {
            playerStatus->animFlags |= PA_FLAG_80000000;
        }
    }
 
    if (!is_ability_active(ABILITY_SLOW_GO)) {
        if (SQ(playerStatus->stickAxis[0]) + SQ(playerStatus->stickAxis[1]) > SQ(55)) {
            set_action_state(ACTION_STATE_RUN);
            return;
        }
    }
 
    try_player_footstep_sounds(8);
    playerData->walkingStepsTaken++;
}

action_update_run()

void action_update_run

(

void

)

Definition at line 111 of file walk.c.

                             {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerData* playerData = &gPlayerData;
    b32 firstFrame = FALSE;
    f32 moveAngle;
    f32 moveMag;
    AnimID anim;
    f32 runSpeedModifier;
 
    if (playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) {
        action_update_run_peach();
        return;
    }
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~(PS_FLAG_ACTION_STATE_CHANGED | PS_FLAG_SCRIPTED_FALL | PS_FLAG_ARMS_RAISED);
        PlayerRunStateTime = 0;
        playerStatus->unk_60 = 0;
        firstFrame = TRUE;
 
        if (!(playerStatus->flags & PS_FLAG_CUTSCENE_MOVEMENT)) {
            playerStatus->curSpeed = playerStatus->runSpeed;
        }
 
        if (playerStatus->animFlags & PA_FLAG_8BIT_MARIO) {
            anim = ANIM_MarioW3_8bit_Run;
        } else if (!(playerStatus->animFlags & PA_FLAG_USING_WATT)) {
            anim = ANIM_Mario1_Run;
        } else {
            anim = ANIM_MarioW1_CarryRun;
        }
        suggest_player_anim_allow_backward(anim);
    }
 
    if (playerStatus->flags & PS_FLAG_CUTSCENE_MOVEMENT) {
        playerStatus->targetYaw = playerStatus->heading;
        try_player_footstep_sounds(4);
        return;
    }
 
    PlayerRunStateTime++;
    runSpeedModifier = 1.0f;
 
    if (playerStatus->animFlags & PA_FLAG_SPINNING) {
        runSpeedModifier = 1.5f;
    }
 
    playerStatus->curSpeed = playerStatus->runSpeed * runSpeedModifier;
    player_input_to_move_vector(&moveAngle, &moveMag);
    phys_update_interact_collider();
 
    if (check_input_jump()) {
        return;
    }
 
    if (!firstFrame && check_input_hammer()) {
        return;
    }
 
    player_input_to_move_vector(&moveAngle, &moveMag);
    if (moveMag == 0.0f) {
        set_action_state(ACTION_STATE_IDLE);
        return;
    }
 
    if (fabsf(PrevPlayerCamRelativeYaw - moveAngle) <= 90.0f) {
        if (!(playerStatus->animFlags & PA_FLAG_80000000)) {
            playerStatus->targetYaw = moveAngle;
        }
        playerStatus->animFlags &= ~PA_FLAG_80000000;
    } else {
        if (playerStatus->animFlags & PA_FLAG_80000000) {
            playerStatus->targetYaw = moveAngle;
        } else {
            playerStatus->animFlags |= PA_FLAG_80000000;
        }
    }
 
    if (!is_ability_active(ABILITY_SLOW_GO)) {
        if (sqrtf(SQ(playerStatus->stickAxis[0]) + SQ(playerStatus->stickAxis[1])) <= 55.0f) {
            set_action_state(ACTION_STATE_WALK);
            return;
        }
    } else {
        set_action_state(ACTION_STATE_WALK);
        return;
    }
    try_player_footstep_sounds(4);
    playerData->runningStepsTaken++;
}

action_update_land()

void action_update_land

(

void

)

Definition at line 12 of file land.c.

                              {
    CollisionStatus* collisionStatus = &gCollisionStatus;
    PlayerStatus* playerStatus = &gPlayerStatus;
    Camera* camera = &gCameras[CAM_DEFAULT];
    f32 inputMoveMagnitude;
    f32 inputMoveAngle;
    s32 jumpInputCheck;
    AnimID anim;
 
    if (playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) {
        action_update_peach_land();
        return;
    }
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~(
            PS_FLAG_ACTION_STATE_CHANGED |
            PS_FLAG_SCRIPTED_FALL |
            PS_FLAG_ARMS_RAISED |
            PS_FLAG_AIRBORNE
        );
        playerStatus->actionSubstate = SUBSTATE_INIT;
        playerStatus->timeInAir = 0;
        playerStatus->peakJumpTime = 0;
        playerStatus->landPos.x = playerStatus->pos.x;
        playerStatus->landPos.z = playerStatus->pos.z;
 
        if (playerStatus->animFlags & PA_FLAG_8BIT_MARIO) {
            anim = ANIM_MarioW3_8bit_Still;
        } else if (!(playerStatus->animFlags & PA_FLAG_USING_WATT)) {
            anim = ANIM_Mario1_Land;
        } else {
            anim = ANIM_MarioW1_LandWatt;
        }
 
        suggest_player_anim_allow_backward(anim);
        sfx_play_sound_at_player(SOUND_PLAYER_LONG_FALL | SOUND_ID_STOP, SOUND_SPACE_DEFAULT);
        sfx_play_sound_at_player(SOUND_LAND_SOFTLY, SOUND_SPACE_DEFAULT);
 
        if (!(collisionStatus->curFloor & COLLISION_WITH_ENTITY_BIT)) {
            phys_adjust_cam_on_landing();
        }
 
        collisionStatus->lastTouchedFloor = -1;
        playerStatus->animFlags &= ~PA_FLAG_INTERRUPT_SPIN;
        camera->moveFlags &= ~CAMERA_MOVE_ACCEL_INTERP_Y;
    }
    playerStatus->actionSubstate++; // SUBSTATE_DONE
    playerStatus->curSpeed *= 0.6f;
 
    player_input_to_move_vector(&inputMoveAngle, &inputMoveMagnitude);
    jumpInputCheck = check_input_jump();
 
    if (jumpInputCheck != 0 || jumpInputCheck < playerStatus->actionSubstate) {
        if (inputMoveMagnitude == 0.0f) {
            set_action_state(ACTION_STATE_IDLE);
            return;
        }
        if (inputMoveMagnitude != 0.0f) {
            playerStatus->targetYaw = inputMoveAngle;
        }
        update_locomotion_state();
    }
}

action_update_jump()

void action_update_jump

(

void

)

Definition at line 41 of file jump.c.

                              {
    PlayerStatus* playerStatus = &gPlayerStatus;
    AnimID anim;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        initialize_jump();
 
        if (playerStatus->actionState == ACTION_STATE_LAUNCH) {
            phys_adjust_cam_on_landing();
        } else {
            gCameras[CAM_DEFAULT].moveFlags |= CAMERA_MOVE_IGNORE_PLAYER_Y;
        }
 
        if (playerStatus->actionState == ACTION_STATE_JUMP) {
            if (playerStatus->animFlags & PA_FLAG_8BIT_MARIO) {
                sfx_play_sound_at_player(SOUND_JUMP_8BIT_MARIO, SOUND_SPACE_DEFAULT);
            } else {
                sfx_play_sound_at_player(SOUND_QUICK_PLAYER_JUMP, SOUND_SPACE_DEFAULT);
            }
        }
    }
 
    if (playerStatus->animFlags & PA_FLAG_8BIT_MARIO) {
        anim = ANIM_MarioW3_8bit_Jump;
    } else if (!(playerStatus->animFlags & (PA_FLAG_USING_WATT | PA_FLAG_WATT_IN_HANDS))) {
        anim = ANIM_Mario1_Jump;
    } else {
        anim = ANIM_MarioW1_JumpWatt;
    }
    suggest_player_anim_allow_backward(anim);
 
    playerStatus->timeInAir++;
}

Referenced by action_update_step_down().

action_update_landing_on_switch()

void action_update_landing_on_switch

(

void

)

Definition at line 76 of file jump.c.

                                           {
    PlayerStatus* playerStatus = &gPlayerStatus;
    CollisionStatus* collisionStatus = &gCollisionStatus;
    AnimID anim;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        Entity* entity = get_entity_by_index(collisionStatus->curFloor);
 
        JumpedOnSwitchX = entity->pos.x;
        JumpedOnSwitchZ = entity->pos.z;
        initialize_jump();
        playerStatus->flags |= (PS_FLAG_SCRIPTED_FALL | PS_FLAG_ARMS_RAISED);
        disable_player_input();
    }
 
    playerStatus->timeInAir++;
 
    if (playerStatus->actionSubstate != JUMP_SUBSTATE_1) {
        return;
    }
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~(PS_FLAG_ACTION_STATE_CHANGED | PS_FLAG_JUMPING | PS_FLAG_FLYING);
        playerStatus->flags |= PS_FLAG_FALLING;
 
        if (!(playerStatus->animFlags & (PA_FLAG_USING_WATT | PA_FLAG_WATT_IN_HANDS))) {
            anim = ANIM_Mario1_Fall;
        } else {
            anim = ANIM_MarioW1_FallWatt;
        }
 
        suggest_player_anim_allow_backward(anim);
        gCameras[CAM_DEFAULT].moveFlags |= CAMERA_MOVE_IGNORE_PLAYER_Y;
    }
 
    playerStatus->actionSubstate++;
}

action_update_falling()

void action_update_falling

(

void

)

Definition at line 114 of file jump.c.

                                 {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) {
        action_update_peach_falling();
        return;
    }
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        s32 anim;
 
        playerStatus->flags &= ~(PS_FLAG_ACTION_STATE_CHANGED | PS_FLAG_JUMPING | PS_FLAG_FLYING);
        playerStatus->flags |= PS_FLAG_FALLING;
 
        if (playerStatus->animFlags & PA_FLAG_8BIT_MARIO) {
            anim = ANIM_MarioW3_8bit_Jump;
        } else if (!(playerStatus->animFlags & (PA_FLAG_USING_WATT | PA_FLAG_WATT_IN_HANDS))) {
            anim = ANIM_Mario1_Fall;
        } else {
            anim = ANIM_MarioW1_FallWatt;
        }
        suggest_player_anim_allow_backward(anim);
        gCameras[CAM_DEFAULT].moveFlags |= CAMERA_MOVE_IGNORE_PLAYER_Y;
    }
    playerStatus->timeInAir++;
}

action_update_step_down()

void action_update_step_down

(

void

)

Definition at line 141 of file jump.c.

                                   {
    PlayerStatus* playerStatus = &gPlayerStatus;
    s32 colliderID;
    s32 surfaceType;
    f32 posX, posY, posZ;
    f32 hitRx, hitRz;
    f32 hitDirX, hitDirZ;
    f32 height;
 
    if (playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) {
        action_update_peach_step_down();
        return;
    }
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~(PS_FLAG_ACTION_STATE_CHANGED | PS_FLAG_JUMPING | PS_FLAG_FLYING);
        playerStatus->flags |= PS_FLAG_FALLING;
        gCameras[CAM_DEFAULT].moveFlags |= CAMERA_MOVE_IGNORE_PLAYER_Y;
    }
 
    playerStatus->timeInAir++;
    phys_update_interact_collider();
    posX = playerStatus->pos.x;
    posY = playerStatus->pos.y;
    posZ = playerStatus->pos.z;
    height = playerStatus->colliderHeight;
 
    colliderID = player_raycast_below_cam_relative(playerStatus, &posX, &posY, &posZ, &height, &hitRx, &hitRz, &hitDirX, &hitDirZ);
    surfaceType = get_collider_flags(colliderID) & COLLIDER_FLAGS_SURFACE_TYPE_MASK;
    if (!(surfaceType == SURFACE_TYPE_SPIKES || surfaceType == SURFACE_TYPE_LAVA) && check_input_jump()) {
        set_action_state(ACTION_STATE_JUMP);
        playerStatus->flags &= ~PS_FLAG_AIRBORNE;
        action_update_jump();
    }
}

action_update_step_down_land()

void action_update_step_down_land

(

void

)

Definition at line 77 of file land.c.

                                        {
    CollisionStatus* collisionStatus = &gCollisionStatus;
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 inputMoveMagnitude;
    f32 inputMoveAngle;
 
    if (playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) {
        action_update_peach_step_down_land();
        return;
    }
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
         playerStatus->flags &= ~(
            PS_FLAG_ACTION_STATE_CHANGED |
            PS_FLAG_SCRIPTED_FALL |
            PS_FLAG_ARMS_RAISED |
            PS_FLAG_AIRBORNE
        );
        playerStatus->actionSubstate = SUBSTATE_INIT;
        playerStatus->timeInAir = 0;
        playerStatus->peakJumpTime = 0;
        playerStatus->landPos.x = playerStatus->pos.x;
        playerStatus->landPos.z = playerStatus->pos.z;
 
        if (!(collisionStatus->curFloor & COLLISION_WITH_ENTITY_BIT)) {
            phys_adjust_cam_on_landing();
        }
 
        collisionStatus->lastTouchedFloor = -1;
    }
 
    playerStatus->actionSubstate++; // SUBSTATE_DONE
    playerStatus->curSpeed *= 0.6f;
 
    player_input_to_move_vector(&inputMoveAngle, &inputMoveMagnitude);
    check_input_jump();
 
    if (inputMoveMagnitude != 0.0f) {
        playerStatus->targetYaw = inputMoveAngle;
    }
 
    update_locomotion_state();
}

action_update_spin_jump()

void action_update_spin_jump

(

void

)

Definition at line 18 of file spin_jump.c.

                                   {
    PlayerStatus* playerStatus = &gPlayerStatus;
    CollisionStatus* collisionStatus = &gCollisionStatus;
    HiddenPanelsData* panels;
    Entity* entity;
    s32 belowColliderID;
    s32 landed;
    f32 velocity;
    u32 entityType;
    s32 surfaceType;
 
    static f32 RotationRate;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~(PS_FLAG_ACTION_STATE_CHANGED | PS_FLAG_JUMPING | PS_FLAG_FALLING);
        playerStatus->flags |= (PS_FLAG_JUMPING | PS_FLAG_FLYING);
 
        playerStatus->actionSubstate = SUBSTATE_SPIN;
        playerStatus->curSpeed = 0.0f;
        RotationRate = 0.0f;
        playerStatus->gravityIntegrator[0] = 5.2f;
        suggest_player_anim_allow_backward(ANIM_Mario1_Sit);
        disable_player_input();
        playerStatus->flags |= PS_FLAG_SPECIAL_JUMP;
        gCameras[CAM_DEFAULT].moveFlags |= CAMERA_MOVE_IGNORE_PLAYER_Y;
        sfx_play_sound_at_player(SOUND_SPIN_JUMP, SOUND_SPACE_DEFAULT);
    }
 
    landed = FALSE;
    switch (playerStatus->actionSubstate) {
        case SUBSTATE_SPIN:
            RotationRate = 40.0f;
            playerStatus->pitch += RotationRate;
            if (playerStatus->pitch >= 360.0f) {
                playerStatus->pitch = 360.0f;
            }
            if (playerStatus->gravityIntegrator[0] >= 0.0f) {
                playerStatus->gravityIntegrator[0] -= 0.54;
                if (collisionStatus->curCeiling < 0) {
                    playerStatus->pos.y += playerStatus->gravityIntegrator[0];
                } else if (collisionStatus->curCeiling & COLLISION_WITH_ENTITY_BIT) {
                    entity = get_entity_by_index(collisionStatus->curCeiling);
                    if (entity != NULL) {
                        playerStatus->pos.y = entity->pos.y - (playerStatus->colliderHeight * 0.5);
                    }
                }
            }
            if (playerStatus->pitch == 360.0f) {
                if (playerStatus->gravityIntegrator[0] <= 0.0f) {
                    playerStatus->curStateTime = 5;
                    playerStatus->actionSubstate = SUBSTATE_RISE;
                    playerStatus->gravityIntegrator[0] = 2.0f;
                }
            }
            collisionStatus->curCeiling = -1;
            break;
        case SUBSTATE_RISE:
            if (playerStatus->gravityIntegrator[0] >= 0.0f) {
                playerStatus->gravityIntegrator[0] -= 1.4;
                if (collisionStatus->curCeiling < 0) {
                    playerStatus->pos.y += playerStatus->gravityIntegrator[0];
                }
            }
            if (--playerStatus->curStateTime <= 0) {
                playerStatus->actionSubstate++;
            }
            break;
        case SUBSTATE_HOVER:
            playerStatus->pos.y = player_check_collision_below(0.0f, &belowColliderID);
            RotationRate = 45.0f;
            playerStatus->pitch += RotationRate;
            if (playerStatus->pitch >= 360.0) {
                playerStatus->pitch = 0.0f;
                playerStatus->actionSubstate++;
                playerStatus->gravityIntegrator[1] = -3.4744f;
                playerStatus->gravityIntegrator[2] = 0.4704f;
                playerStatus->gravityIntegrator[3] = -1.1904f;
                playerStatus->gravityIntegrator[0] = playerStatus->gravityIntegrator[1];
                suggest_player_anim_allow_backward(ANIM_Mario1_SpinJump);
            }
            break;
        case SUBSTATE_DESCEND:
            velocity = player_fall_distance();
            playerStatus->pos.y = player_check_collision_below(velocity, &belowColliderID);
            if (velocity < -100.0f) {
                playerStatus->gravityIntegrator[3] = 0.0f;
                playerStatus->gravityIntegrator[2] = 0.0f;
                playerStatus->gravityIntegrator[1] = 0.0f;
                playerStatus->gravityIntegrator[0] = -100.0f;
            }
            if (belowColliderID > NO_COLLIDER) {
                if (collisionStatus->curFloor & COLLISION_WITH_ENTITY_BIT && (entityType = get_entity_type(collisionStatus->curFloor),
                        entityType == ENTITY_TYPE_RED_SWITCH || entityType == ENTITY_TYPE_BLUE_SWITCH)) {
                    get_entity_by_index(collisionStatus->curFloor)->collisionFlags |= ENTITY_COLLISION_PLAYER_TOUCH_FLOOR;
                    playerStatus->actionSubstate = SUBSTATE_HIT_SWITCH;
                    playerStatus->flags &= ~PS_FLAG_FLYING;
                    break;
                } else {
                    surfaceType = get_collider_flags(belowColliderID) & COLLIDER_FLAGS_SURFACE_TYPE_MASK;
                    if (surfaceType == SURFACE_TYPE_LAVA) {
#if !VERSION_JP
                        playerStatus->hazardType = HAZARD_TYPE_LAVA;
#endif
                        set_action_state(ACTION_STATE_HIT_LAVA);
                        playerStatus->flags |= PS_FLAG_HIT_FIRE;
                        playerStatus->flags &= ~PS_FLAG_FLYING;
                        return;
                    } else if (surfaceType == SURFACE_TYPE_SPIKES) {
                        set_action_state(ACTION_STATE_HIT_LAVA);
                        playerStatus->flags &= ~PS_FLAG_FLYING;
                        return;
                    } else {
                        playerStatus->gravityIntegrator[1] = -3.4744f;
                        playerStatus->gravityIntegrator[2] = 0.4704f;
                        playerStatus->gravityIntegrator[3] = -1.1904f;
                        playerStatus->gravityIntegrator[0] = 10.0f;
                        suggest_player_anim_allow_backward(ANIM_Mario1_SpinJump);
                        playerStatus->actionState = ACTION_STATE_SPIN_POUND;
                        playerStatus->timeInAir = 0;
                        playerStatus->poundImpactDelay = 12;
                        playerStatus->pitch = 0.0f;
                        playerStatus->actionSubstate++;
                        exec_ShakeCam1(0, 0, 4);
                        sfx_play_sound_at_player(SOUND_LAND_SPIN_JUMP, SOUND_SPACE_DEFAULT);
                        start_rumble(128, 25);
                        panels = &gCurrentHiddenPanels;
                        panels->tryFlipTrigger = TRUE;
                        panels->flipTriggerPosY = playerStatus->pos.y;
                        playerStatus->flags |= PS_FLAG_SPECIAL_LAND;
                    }
                }
            }
            break;
        case SUBSTATE_IMPACT:
            velocity = integrate_gravity();
            if (velocity == 0.0f) {
                landed = TRUE;
            } else {
                if (playerStatus->gravityIntegrator[0] > 0.0f) {
                    playerStatus->pos.y += velocity;
                } else {
                    playerStatus->pos.y = player_check_collision_below(velocity, &belowColliderID);
                    if (playerStatus->gravityIntegrator[0] < 0.0f && belowColliderID >= 0) {
                        playerStatus->actionSubstate++;
                    }
                }
                playerStatus->pos.y = player_check_collision_below(0.0f, &belowColliderID);
            }
            break;
        case SUBSTATE_HOLD:
            playerStatus->pos.y = player_check_collision_below(0.0f, &belowColliderID);
            if (belowColliderID >= 0) {
                playerStatus->gravityIntegrator[0] = 0.0f;
                playerStatus->gravityIntegrator[1] = 0.0f;
                playerStatus->gravityIntegrator[2] = 0.0f;
                playerStatus->gravityIntegrator[3] = 0.0f;
            }
            // fallthrough
        case SUBSTATE_ABORT:
            if (--playerStatus->poundImpactDelay <= 0) {
                landed = TRUE;
            }
            break;
        case SUBSTATE_HIT_SWITCH:
            set_action_state(ACTION_STATE_LANDING_ON_SWITCH);
            playerStatus->actionSubstate++;
            enable_player_input();
            break;
        case SUBSTATE_DONE_SWITCH:
            break;
    }
 
    if (landed) {
        set_action_state(ACTION_STATE_LAND);
        playerStatus->flags &= ~PS_FLAG_FLYING;
    }
    if (playerStatus->gravityIntegrator[0] < 0.0f) {
        belowColliderID = get_collider_below_spin_jump();
        if (belowColliderID >= 0) {
            collisionStatus->lastTouchedFloor = -1;
            collisionStatus->curFloor = belowColliderID;
        }
    }
}

action_update_tornado_jump()

void action_update_tornado_jump

(

void

)

Definition at line 22 of file tornado_jump.c.

                                      {
    PlayerStatus* playerStatus = &gPlayerStatus;
    CollisionStatus* collisionStatus = &gCollisionStatus;
    f32 cameraRelativeYaw;
    f32 fallVelocity;
    s32 surfaceType;
    f32 spinRate;
    s32 colliderBelow;
    u32 entityType;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        playerStatus->flags |= (PS_FLAG_SPINNING | PS_FLAG_FLYING | PS_FLAG_JUMPING);
        phys_clear_spin_history();
        playerStatus->actionSubstate = SUBSTATE_ASCEND;
        playerStatus->curSpeed = 0.0f;
        playerStatus->gravityIntegrator[0] = 16.0f;
        playerStatus->gravityIntegrator[1] = -7.38624f;
        playerStatus->gravityIntegrator[2] = 3.44694f;
        playerStatus->gravityIntegrator[3] = -0.75f;
        suggest_player_anim_always_forward(ANIM_MarioW2_Carried);
        disable_player_input();
        playerStatus->flags |= PS_FLAG_SPECIAL_JUMP;
        gCameras[CAM_DEFAULT].moveFlags |= CAMERA_MOVE_IGNORE_PLAYER_Y;
        cameraRelativeYaw = clamp_angle(playerStatus->targetYaw - gCameras[gCurrentCameraID].curYaw);
        if (cameraRelativeYaw <= 180.0f) {
            spinRate = 60.0f;
        } else {
            spinRate = -60.0f;
        }
        playerStatus->spinRate = spinRate;
    }
    if (playerStatus->actionSubstate <= SUBSTATE_IMPACT) {
        if (playerStatus->spinRate >= 0.0f) {
            playerStatus->spriteFacingAngle += playerStatus->spinRate;
            if (playerStatus->spriteFacingAngle >= 360.0f) {
                playerStatus->spriteFacingAngle -= 360.0f;
            }
        } else {
            playerStatus->spriteFacingAngle += playerStatus->spinRate;
            if (playerStatus->spriteFacingAngle < 0.0f) {
                playerStatus->spriteFacingAngle += 360.0f;
            }
        }
    }
    if (playerStatus->gravityIntegrator[0] <= 0.0f) {
        gSpinHistoryPosY[gSpinHistoryBufferPos] = playerStatus->pos.y;
    }
 
    gSpinHistoryPosAngle[gSpinHistoryBufferPos++] = playerStatus->spriteFacingAngle;
 
    if (gSpinHistoryBufferPos >= 6) {
        gSpinHistoryBufferPos = 0;
    }
 
    switch (playerStatus->actionSubstate) {
        case SUBSTATE_ASCEND:
            fallVelocity = integrate_gravity();
            playerStatus->pos.y = player_check_collision_below(fallVelocity, &colliderBelow);
            if (colliderBelow >= 0 && collisionStatus->curFloor & COLLISION_WITH_ENTITY_BIT ) {
                entityType = get_entity_type(collisionStatus->curFloor);
                if (entityType == ENTITY_TYPE_BLUE_SWITCH || entityType == ENTITY_TYPE_RED_SWITCH) {
                    get_entity_by_index(collisionStatus->curFloor)->collisionFlags |= ENTITY_COLLISION_PLAYER_TOUCH_FLOOR;
                    disable_player_input();
                    playerStatus->actionSubstate = SUBSTATE_HIT_SWITCH;
                    break;
                }
            }
            if (fallVelocity <= 0.0f) {
                record_jump_apex();
                playerStatus->curStateTime = 3;
                playerStatus->flags |= PS_FLAG_FALLING;
                playerStatus->actionSubstate++;
                sfx_play_sound_at_player(SOUND_TORNADO_JUMP, SOUND_SPACE_DEFAULT);
            }
            if (colliderBelow >= 0) {
                playerStatus->flags &= ~(PS_FLAG_SPINNING | PS_FLAG_FLYING);
                set_action_state(ACTION_STATE_LAND);
            }
            break;
        case SUBSTATE_HOVER:
            if (--playerStatus->curStateTime <= 0) {
                playerStatus->actionSubstate++;
            }
            break;
        case SUBSTATE_DESCEND:
            fallVelocity = integrate_gravity();
            playerStatus->pos.y = player_check_collision_below(fallVelocity, &colliderBelow);
            if (fallVelocity < -100.0f) {
                playerStatus->gravityIntegrator[3] = 0.0f;
                playerStatus->gravityIntegrator[2] = 0.0f;
                playerStatus->gravityIntegrator[1] = 0.0f;
                playerStatus->gravityIntegrator[0] = -100.0f;
            }
            if (colliderBelow > NO_COLLIDER) {
                if (collisionStatus->curFloor & COLLISION_WITH_ENTITY_BIT) {
                    entityType = get_entity_type(collisionStatus->curFloor);
                    if (entityType == ENTITY_TYPE_SIMPLE_SPRING || entityType == ENTITY_TYPE_SCRIPT_SPRING) {
                        playerStatus->flags &= ~(PS_FLAG_SPINNING | PS_FLAG_FLYING);
                        set_action_state(ACTION_STATE_LAND);
                        return;
                    } else if (entityType == ENTITY_TYPE_BLUE_SWITCH || entityType == ENTITY_TYPE_RED_SWITCH) {
                        playerStatus->flags &= ~(PS_FLAG_SPINNING | PS_FLAG_FLYING);
                        phys_player_land();
                        exec_ShakeCam1(0, 0, 4);
                        sfx_play_sound_at_player(SOUND_LAND_TORANDO_JUMP, SOUND_SPACE_DEFAULT);
                        start_rumble(256, 50);
 
                        gCurrentHiddenPanels.tryFlipTrigger = TRUE;
                        gCurrentHiddenPanels.flipTriggerPosY = playerStatus->pos.y;
                        playerStatus->flags |= PS_FLAG_SPECIAL_LAND;
                        return;
                    }
                }
 
                surfaceType = get_collider_flags(colliderBelow) & COLLIDER_FLAGS_SURFACE_TYPE_MASK;
                if (surfaceType == SURFACE_TYPE_LAVA) {
#if !VERSION_JP
                    playerStatus->hazardType = HAZARD_TYPE_LAVA;
#endif
                    playerStatus->flags &= ~(PS_FLAG_SPINNING | PS_FLAG_FLYING);
                    set_action_state(ACTION_STATE_HIT_LAVA);
                    playerStatus->flags |= PS_FLAG_HIT_FIRE;
                    return;
                } else if (surfaceType == SURFACE_TYPE_SPIKES) {
                    set_action_state(ACTION_STATE_HIT_LAVA);
                    playerStatus->flags &= ~(PS_FLAG_SPINNING | PS_FLAG_FLYING);
                    return;
                }
                playerStatus->curStateTime = 8;
                playerStatus->timeInAir = 0;
                playerStatus->actionState = ACTION_STATE_TORNADO_POUND;
                playerStatus->actionSubstate++;
                exec_ShakeCam1(0, 0, 4);
                sfx_play_sound_at_player(SOUND_LAND_TORANDO_JUMP, SOUND_SPACE_DEFAULT);
                start_rumble(256, 50);
 
                gCurrentHiddenPanels.tryFlipTrigger = TRUE;
                gCurrentHiddenPanels.flipTriggerPosY = playerStatus->pos.y;
                playerStatus->flags |= PS_FLAG_SPECIAL_LAND;
            }
            break;
        case SUBSTATE_IMPACT:
            if (--playerStatus->curStateTime == 0) {
                playerStatus->actionSubstate++;
                playerStatus->flags &= ~(PS_FLAG_SPINNING | PS_FLAG_FLYING);
                set_action_state(ACTION_STATE_LAND);
            }
            break;
        case SUBSTATE_HIT_SWITCH:
            set_action_state(ACTION_STATE_LANDING_ON_SWITCH);
            playerStatus->actionSubstate++;
            enable_player_input();
            break;
        case SUBSTATE_DONE_SWITCH:
            break;
    }
 
    if (playerStatus->gravityIntegrator[0] < 0.0f) {
        colliderBelow = get_collider_below_tornado_jump();
        if (colliderBelow >= 0) {
            collisionStatus->lastTouchedFloor = -1;
            collisionStatus->curFloor = colliderBelow;
        }
    }
}

action_update_talk()

void action_update_talk

(

void

)

Definition at line 214 of file misc.c.

                              {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        playerStatus->curSpeed = 0.0f;
        playerStatus->unk_60 = 0;
 
        if (!(playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS)) {
            suggest_player_anim_always_forward(ANIM_MarioW2_SpeakUp);
        } else if (playerStatus->peachItemHeld == PEACH_BAKING_NONE) {
            if (!(playerStatus->animFlags & PA_FLAG_INVISIBLE)) {
                suggest_player_anim_always_forward(ANIM_Peach2_RaiseArms);
            } else {
                peach_set_disguise_anim(BasicPeachDisguiseAnims[playerStatus->peachDisguise].talk);
            }
        }
        playerStatus->curStateTime = 30;
    }
 
    if (playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) {
        if (playerStatus->curStateTime != 0) {
            playerStatus->curStateTime--;
        } else if (playerStatus->peachItemHeld == PEACH_BAKING_NONE) {
            if (!(playerStatus->animFlags & PA_FLAG_INVISIBLE)) {
                suggest_player_anim_always_forward(ANIM_Peach1_Idle);
            } else {
                peach_set_disguise_anim(BasicPeachDisguiseAnims[playerStatus->peachDisguise].idle);
            }
        }
    }
}

action_update_sliding()

void action_update_sliding

(

void

)

Definition at line 38 of file slide.c.

                                 {
    PlayerStatus* playerStatus = &gPlayerStatus;
    CollisionStatus* collisionStatus;
    s32 surfaceType;
    f32 sinA, cosA;
    f32 speed;
    f32 posX, posY, posZ, depth;
    f32 hitRx, hitRy, hitDirX, hitDirZ;
    s32 hitID;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        playerStatus->actionSubstate = SUBSTATE_SLIDING;
        playerStatus->curSpeed = 0.0f;
        playerStatus->animFlags |= PA_FLAG_INTERRUPT_USE_PARTNER;
        func_802B6000_E27510();
        SlideAcceleration = 0.0f;
        D_802B6790 = 0.0f;
        D_802B6794 = 0.0f;
        D_802B6798 = 0.0f;
        D_802B679C = 0;
        suggest_player_anim_allow_backward(ANIM_Mario1_Sit);
        sfx_play_sound_at_player(SOUND_SLIDE, SOUND_SPACE_DEFAULT);
        gCameras[CAM_DEFAULT].moveFlags |= CAMERA_MOVE_IGNORE_PLAYER_Y;
    }
    speed = playerStatus->curSpeed;
    posX = playerStatus->pos.x;
    posY = playerStatus->pos.y;
    posZ = playerStatus->pos.z;
    hitID = player_test_move_with_slipping(playerStatus, &posX, &posY, &posZ, speed, playerStatus->heading);
    playerStatus->pos.x = posX;
    playerStatus->pos.z = posZ;
    playerStatus->pos.y = posY;
 
    switch (playerStatus->actionSubstate) {
        case SUBSTATE_SLIDING:
            SlideAcceleration += 0.1;
            if (MaxSlideAccel <= SlideAcceleration) {
                SlideAcceleration = MaxSlideAccel;
            }
            playerStatus->curSpeed += SlideAcceleration;
            if (MaxSlideVelocity <= playerStatus->curSpeed) {
                playerStatus->curSpeed = MaxSlideVelocity;
            }
            posX = playerStatus->pos.x;
            depth = 100.0f;
            posZ = playerStatus->pos.z;
            D_802B6794 = D_802B6798;
            posY = playerStatus->pos.y + (playerStatus->colliderHeight * 0.5f);
            hitID = player_raycast_below_cam_relative(playerStatus, &posX, &posY, &posZ, &depth, &hitRx, &hitRy, &hitDirX, &hitDirZ);
            D_802B6798 = hitRy;
            if (hitID > NO_COLLIDER) {
                collisionStatus = &gCollisionStatus;
                surfaceType = get_collider_flags(hitID) & COLLIDER_FLAGS_SURFACE_TYPE_MASK;
                if (surfaceType == SURFACE_TYPE_SLIDE) {
                    collisionStatus->curFloor = hitID;
                    playerStatus->pos.y = posY;
                    D_802B6790 = hitRy + 180.0f;
                    break;
                }
                if (!(fabs(D_802B6794 - D_802B6798) >= 50.0)) {
                    playerStatus->actionSubstate = SUBSTATE_STOP;
                } else {
                    playerStatus->actionSubstate = SUBSTATE_LAUNCH;
                }
            } else {
                playerStatus->actionSubstate = SUBSTATE_LAUNCH;
            }
            sin_cos_rad(DEG_TO_RAD(D_802B6790), &sinA, &cosA);
            playerStatus->pos.y += fabsf((sinA / cosA) * playerStatus->curSpeed);
            snd_stop_sound(SOUND_SLIDE);
            break;
        case SUBSTATE_STOP:
            posX = playerStatus->pos.x;
            depth = 50.0f;
            posZ = playerStatus->pos.z;
            posY = playerStatus->pos.y + (playerStatus->colliderHeight * 0.5f);
            hitID = player_raycast_below_cam_relative(playerStatus, &posX, &posY, &posZ, &depth, &hitRx, &hitRy, &hitDirX, &hitDirZ);
            if (hitID > NO_COLLIDER) {
                speed = playerStatus->curSpeed / 3.0f;
                if (speed < 0.01) {
                    playerStatus->curSpeed = 0.0f;
                }
                playerStatus->curSpeed -= speed;
                if (playerStatus->curSpeed <= 0.0f) {
                    sfx_play_sound_at_player(SOUND_DUST_OFF, SOUND_SPACE_DEFAULT);
                    suggest_player_anim_always_forward(ANIM_Mario1_DustOff);
                    playerStatus->actionSubstate = SUBSTATE_DUST_OFF;
                    playerStatus->curStateTime = 15;
                    playerStatus->curSpeed = 0.0f;
                    playerStatus->pos.y = posY;
                }
                break;
            }
        case SUBSTATE_LAUNCH:
            playerStatus->curSpeed += SlideLaunchSpeed;
            if (playerStatus->curSpeed <= 0.0f) {
                playerStatus->curSpeed = 0.0f;
            }
            playerStatus->gravityIntegrator[0] += playerStatus->gravityIntegrator[1];
            playerStatus->pos.y += playerStatus->gravityIntegrator[0];
            if (playerStatus->gravityIntegrator[0] <= 0.0f) {
                playerStatus->actionSubstate = SUBSTATE_FALL;
                LOAD_INTEGRATOR_FALL(playerStatus->gravityIntegrator);
            }
            break;
        case SUBSTATE_FALL:
            playerStatus->curSpeed += SlideLaunchSpeed;
            if (playerStatus->curSpeed <= 0.0f) {
                playerStatus->curSpeed = 0.0f;
            }
            playerStatus->pos.y = player_check_collision_below(player_fall_distance(), &hitID);
            if (hitID > NO_COLLIDER) {
                SlideLaunchSpeed = -1;
                suggest_player_anim_always_forward(ANIM_MarioW2_Collapse);
                sfx_play_sound_at_player(SOUND_TRIP, SOUND_SPACE_DEFAULT);
                playerStatus->actionSubstate++; // SUBSTATE_CRASH
            }
            break;
        case SUBSTATE_CRASH:
            playerStatus->curSpeed += SlideLaunchSpeed;
            if (playerStatus->curSpeed <= 0.0f) {
                playerStatus->curSpeed = 0.0f;
            }
            if (playerStatus->animNotifyValue != 0) {
                suggest_player_anim_always_forward(ANIM_Mario1_GetUp);
                playerStatus->actionSubstate++; // SUBSTATE_GET_UP
            }
            break;
        case SUBSTATE_GET_UP:
            playerStatus->curSpeed += SlideLaunchSpeed;
            if (playerStatus->curSpeed <= 0.0f) {
                playerStatus->curSpeed = 0.0f;
            }
            if (playerStatus->animNotifyValue != 0) {
                suggest_player_anim_always_forward(ANIM_Mario1_DustOff);
                sfx_play_sound_at_player(SOUND_DUST_OFF, SOUND_SPACE_DEFAULT);
                playerStatus->curStateTime = 15;
                playerStatus->actionSubstate++; // SUBSTATE_DUST_OFF
            }
            break;
        case SUBSTATE_DUST_OFF:
            playerStatus->curSpeed += SlideLaunchSpeed;
            if (playerStatus->curSpeed <= 0.0f) {
                playerStatus->curSpeed = 0.0f;
            }
            if (--playerStatus->curStateTime == 0) {
                playerStatus->actionSubstate++; // SUBSTATE_DONE
            }
            break;
        case SUBSTATE_DONE:
            speed = playerStatus->curSpeed / 3.0f;
            if (speed < 0.01) {
                playerStatus->curSpeed = 0.0f;
            }
            playerStatus->curSpeed -= speed;
            if (playerStatus->curSpeed <= 0.0f) {
                playerStatus->curSpeed = 0.0f;
                set_action_state(ACTION_STATE_IDLE);
            }
            break;
    }
}

action_update_hammer()

void action_update_hammer

(

void

)

Definition at line 230 of file hammer.c.

                                {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    HammerHit->unk_1C = 0;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        AnimID anim;
        s32 soundID;
 
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        playerStatus->flags |= PS_FLAG_NO_FLIPPING;
        HammerHit->timer = 0;
        playerStatus->actionSubstate = SUBSTATE_HAMMER_0;
        playerStatus->curSpeed = 0.0f;
        playerStatus->animNotifyValue = 0;
        HammerHit->hitID = action_hammer_test_swing_collision();
 
        if (gPlayerData.hammerLevel == 2) {
            soundID = SOUND_HAMMER_SWING_3;
            anim = ANIM_MarioW1_Smash3_Hit;
            if (HammerHit->hitID <= NO_COLLIDER) {
                soundID = SOUND_HAMMER_SWING_3;
                anim = ANIM_MarioW1_Smash3_Miss;
            }
        } else if (gPlayerData.hammerLevel == 1) {
            soundID = SOUND_HAMMER_SWING_2;
            anim = ANIM_MarioW1_Smash2_Hit;
            if (HammerHit->hitID <= NO_COLLIDER) {
                soundID = SOUND_HAMMER_SWING_2;
                anim = ANIM_MarioW1_Smash2_Miss;
            }
        } else {
            soundID = SOUND_HAMMER_SWING_1;
            anim = ANIM_MarioW1_Smash1_Hit;
            if (HammerHit->hitID <= NO_COLLIDER) {
                soundID = SOUND_HAMMER_SWING_1;
                anim = ANIM_MarioW1_Smash1_Miss;
            }
        }
 
        suggest_player_anim_allow_backward(anim);
        sfx_play_sound_at_player(soundID, SOUND_SPACE_DEFAULT);
        HammerHit->unk_0C = 0;
        HammerHit->unk_14 = 0;
    }
 
    playerStatus->flags &= ~PS_FLAG_HAMMER_CHECK;
    if (HammerHit->timer < 3 && (playerStatus->flags & PS_FLAG_ENTERING_BATTLE)) {
        // This is probably to stop Mario from triggering multiple battles at once by hammering while one is starting.
        playerStatus->flags |= PS_FLAG_TIME_STOPPED;
    } else if (HammerHit->timer < 2) {
        HammerHit->timer++;
    } else {
        action_hammer_end_swing();
    }
}

action_update_launch()

void action_update_launch

(

void

)

Definition at line 118 of file misc.c.

                                {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~(PS_FLAG_ACTION_STATE_CHANGED | PS_FLAG_ARMS_RAISED | PS_FLAG_AIRBORNE);
        playerStatus->actionSubstate = 0;
        playerStatus->curStateTime = 0;
        playerStatus->timeInAir = 0;
        playerStatus->peakJumpTime = 0;
        playerStatus->curSpeed = 0.0f;
        playerStatus->pitch = 0.0f;
 
        if (playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) {
            return;
        }
        playerStatus->curStateTime = 5;
    }
 
    playerStatus->curStateTime--;
    if (playerStatus->curStateTime == 0) {
        set_action_state(ACTION_STATE_IDLE);
    }
}

action_update_pushing_block()

void action_update_pushing_block

(

void

)

Definition at line 182 of file misc.c.

                                       {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        f32 angle;
        f32 magnitude;
 
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        playerStatus->curSpeed = 0.0f;
        playerStatus->unk_60 = 0;
        playerStatus->curStateTime = 5;
        player_input_to_move_vector(&angle, &magnitude);
 
        if (((angle >= 45.0f) && (angle <= 135.0f)) || ((angle >= 225.0f) && (angle <= 315.0f))) {
            suggest_player_anim_always_forward(ANIM_MarioW2_PushSide);
        } else {
            suggest_player_anim_allow_backward(ANIM_MarioW1_PushToward);
        }
    }
 
    check_input_jump();
 
    if (playerStatus->animFlags & PA_FLAG_ABORT_PUSHING_BLOCK) {
        if (playerStatus->curStateTime != 0) {
            playerStatus->curStateTime--;
            if (playerStatus->curStateTime == 0) {
                set_action_state(ACTION_STATE_IDLE);
            }
        }
    }
}

action_update_hit_fire()

void action_update_hit_fire

(

void

)

Definition at line 9 of file hit_fire.c.

                                  {
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 dx, dy;
    f32 speed;
 
    static f32 ReturnAngle;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
 
        playerStatus->animFlags |= PA_FLAG_INTERRUPT_USE_PARTNER;
        playerStatus->flags |= (PS_FLAG_HIT_FIRE | PS_FLAG_FLYING);
 
        suggest_player_anim_always_forward(ANIM_Mario1_TouchedFire);
 
        playerStatus->actionSubstate = SUBSTATE_FLYING;
        playerStatus->gravityIntegrator[0] = 18.3473f;
        playerStatus->gravityIntegrator[1] = -3.738f;
        playerStatus->gravityIntegrator[2] = 0.8059f;
        playerStatus->gravityIntegrator[3] = -0.0987f;
        gCameras[CAM_DEFAULT].moveFlags |= CAMERA_MOVE_IGNORE_PLAYER_Y;
        ReturnAngle = atan2(playerStatus->pos.x, playerStatus->pos.z, playerStatus->lastGoodPos.x, playerStatus->lastGoodPos.z);
        playerStatus->curSpeed = get_xz_dist_to_player(playerStatus->lastGoodPos.x, playerStatus->lastGoodPos.z) / 18.0f;
        subtract_hp(1);
        open_status_bar_slowly();
        gOverrideFlags |= GLOBAL_OVERRIDES_40;
    }
 
    sin_cos_rad(DEG_TO_RAD(ReturnAngle), &dx, &dy);
    speed = playerStatus->curSpeed;
 
    if (playerStatus->flags & PS_FLAG_ENTERING_BATTLE) {
        speed *= 0.5;
    }
 
    playerStatus->pos.x += speed * dx;
    playerStatus->pos.z -= speed * dy;
 
    if (playerStatus->actionSubstate == SUBSTATE_FLYING) {
        integrate_gravity();
        playerStatus->pos.y += playerStatus->gravityIntegrator[0];
        if (playerStatus->gravityIntegrator[0] < 0.0f) {
            playerStatus->actionSubstate = SUBSTATE_FALLING;
            playerStatus->flags |= PS_FLAG_FALLING;
        }
    } else {
        s32 colliderID;
 
        playerStatus->pos.y = player_check_collision_below(player_fall_distance(), &colliderID);
        if (colliderID > NO_COLLIDER) {
            colliderID = get_collider_flags(colliderID); //TODO surfaceType
            set_action_state(ACTION_STATE_LAND);
            playerStatus->blinkTimer = 60;
            playerStatus->hazardType = HAZARD_TYPE_NONE;
            playerStatus->flags &= ~PS_FLAG_HIT_FIRE;
            gOverrideFlags &= ~GLOBAL_OVERRIDES_40;
        }
    }
}

action_update_knockback()

void action_update_knockback

(

void

)

Definition at line 9 of file knockback.c.

                                   {
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 dx, dy;
    f32 speed;
 
    static f32 ReturnAngle;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
 
        suggest_player_anim_always_forward(ANIM_Mario1_Hurt);
 
        playerStatus->flags |= PS_FLAG_FLYING;
 
        playerStatus->actionSubstate = SUBSTATE_FLYING;
        playerStatus->gravityIntegrator[0] = 18.3473f;
        playerStatus->gravityIntegrator[1] = -3.738f;
        playerStatus->gravityIntegrator[2] = 0.8059f;
        playerStatus->gravityIntegrator[3] = -0.0987f;
 
        gCameras[CAM_DEFAULT].moveFlags |= CAMERA_MOVE_IGNORE_PLAYER_Y;
 
        ReturnAngle = atan2(playerStatus->pos.x, playerStatus->pos.z, playerStatus->lastGoodPos.x,
                           playerStatus->lastGoodPos.z);
        playerStatus->curSpeed = get_xz_dist_to_player(playerStatus->lastGoodPos.x, playerStatus->lastGoodPos.z) / 18.0f;
    }
 
    sin_cos_rad(DEG_TO_RAD(ReturnAngle), &dx, &dy);
 
    speed = playerStatus->curSpeed;
 
    if (playerStatus->flags & PS_FLAG_ENTERING_BATTLE) {
        speed *= 0.5f;
    }
 
    playerStatus->pos.x += speed * dx;
    playerStatus->pos.z -= speed * dy;
 
    if (playerStatus->actionSubstate == SUBSTATE_FLYING) {
        integrate_gravity();
 
        playerStatus->pos.y += playerStatus->gravityIntegrator[0];
 
        if (playerStatus->gravityIntegrator[0] < 0.0f) {
            playerStatus->actionSubstate = SUBSTATE_FALLING;
            playerStatus->flags |= PS_FLAG_FALLING;
        }
    } else {
        s32 colliderID;
 
        playerStatus->pos.y = player_check_collision_below(player_fall_distance(), &colliderID);
 
        if (colliderID > NO_COLLIDER) {
            colliderID = get_collider_flags(colliderID); //TODO surfaceType
            set_action_state(ACTION_STATE_LAND);
        }
    }
}

action_update_hit_lava()

void action_update_hit_lava

(

void

)

Definition at line 19 of file hit_lava.c.

                                  {
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 resetPosX, resetPosY, resetPosZ;
    f32 returnRadians;
    f32 dx, dy;
    f32 componentSpeed;
    s32 completeAxes; // number of axes along which the 'return motion' is complete
 
    static f32 LaunchVelocity;
    static f32 LaunchInterpPhase; // used to interp launch velocity
    static f32 ReturnAngle;
    static f32 InitialPosY;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        playerStatus->flags |= (PS_FLAG_SCRIPTED_FALL | PS_FLAG_FLYING);
        playerStatus->animFlags |= PA_FLAG_INTERRUPT_USE_PARTNER;
        playerStatus->flags |= PS_FLAG_HIT_FIRE;
        if (playerStatus->hazardType == HAZARD_TYPE_LAVA) {
            playerStatus->actionSubstate = SUBSTATE_DELAY_INIT_SINK;
            playerStatus->curStateTime = 2;
        } else {
            playerStatus->actionSubstate = SUBSTATE_INIT;
        }
        InitialPosY = playerStatus->pos.y;
        playerStatus->curSpeed = 0.0f;
        LaunchVelocity = 0.0f;
 
        gCameras[CAM_DEFAULT].moveFlags |= (CAMERA_MOVE_IGNORE_PLAYER_Y | CAMERA_MOVE_NO_INTERP_Y);
        LaunchInterpPhase = 90.0f;
        subtract_hp(1);
        open_status_bar_slowly();
        gOverrideFlags |= GLOBAL_OVERRIDES_40;
        sfx_play_sound_at_player(SOUND_TOUCH_LAVA, SOUND_SPACE_DEFAULT);
    }
 
    switch (playerStatus->actionSubstate) {
        case SUBSTATE_DELAY_INIT:
            if (--playerStatus->curStateTime == -1) {
                playerStatus->actionSubstate = SUBSTATE_INIT;
            }
            break;
        case SUBSTATE_DELAY_INIT_SINK:
            if (--playerStatus->curStateTime == -1) {
                playerStatus->actionSubstate = SUBSTATE_INIT;
            }
            playerStatus->pos.y -= 4.0f;
            break;
        case SUBSTATE_INIT:
            if (playerStatus->hazardType == HAZARD_TYPE_LAVA) {
                fx_smoke_burst(0, playerStatus->pos.x, playerStatus->pos.y, playerStatus->pos.z, 1.0f, 40);
            }
            suggest_player_anim_always_forward(ANIM_MarioW2_TouchedLava);
            playerStatus->gravityIntegrator[1] = 0.0f;
            playerStatus->timeInAir = 0;
            playerStatus->peakJumpTime = 0;
            playerStatus->actionSubstate = SUBSTATE_LAUNCH;
            playerStatus->curStateTime = 1;
            playerStatus->gravityIntegrator[0] = 20.0f;
            playerStatus->gravityIntegrator[2] = 250.0f;
            playerStatus->gravityIntegrator[3] = InitialPosY;
            playerStatus->jumpFromPos.x = playerStatus->pos.x;
            playerStatus->jumpFromPos.z = playerStatus->pos.z;
            playerStatus->jumpFromHeight = playerStatus->pos.y;
            playerStatus->flags |= PS_FLAG_JUMPING;
            break;
        case SUBSTATE_DELAY_LAUNCH:
            if (--playerStatus->curStateTime <= 0) {
                playerStatus->actionSubstate++;
            }
            break;
        case SUBSTATE_LAUNCH:
            if (playerStatus->hazardType == HAZARD_TYPE_LAVA && (playerStatus->timeInAir % 2) == 0) {
                fx_smoke_burst(0, playerStatus->pos.x, playerStatus->pos.y, playerStatus->pos.z, 0.7f, 18);
            }
            if (playerStatus->pos.y < playerStatus->gravityIntegrator[3] + playerStatus->gravityIntegrator[2]) {
                sin_cos_rad(DEG_TO_RAD(LaunchInterpPhase), &dx, &dy);
                LaunchVelocity = sin_rad(DEG_TO_RAD(LaunchInterpPhase)) * 16.0f;
                if (LaunchVelocity < -1.0f) {
                    LaunchVelocity = -1.0f;
                }
                playerStatus->pos.y += LaunchVelocity;
                LaunchInterpPhase += 3.0f;
                if (LaunchInterpPhase > 180.0f) {
                    LaunchInterpPhase = 180.0f;
                    playerStatus->actionSubstate++;
                }
            } else {
                playerStatus->pos.y = playerStatus->gravityIntegrator[3] + playerStatus->gravityIntegrator[2];
                playerStatus->actionSubstate++;
            }
            break;
        case SUBSTATE_END_LAUNCH:
            if (playerStatus->hazardType == HAZARD_TYPE_LAVA && (playerStatus->timeInAir % 2) == 0) {
                fx_smoke_burst(0, playerStatus->pos.x, playerStatus->pos.y, playerStatus->pos.z, 0.7f, 18);
            }
            if (get_lava_reset_pos(&resetPosX, &resetPosY, &resetPosZ) == 0) {
                resetPosX = playerStatus->pos.x;
                resetPosZ = playerStatus->pos.z;
            }
            playerStatus->lastGoodPos.x = resetPosX;
            playerStatus->lastGoodPos.z = resetPosZ;
            playerStatus->jumpApexHeight = playerStatus->pos.y;
            LOAD_INTEGRATOR_FALL(playerStatus->gravityIntegrator);
            playerStatus->actionSubstate++;
            break;
        case SUBSTATE_RETURN_INIT:
            ReturnAngle = atan2(playerStatus->pos.x, playerStatus->pos.z, playerStatus->lastGoodPos.x, playerStatus->lastGoodPos.z);
            playerStatus->curSpeed = get_xz_dist_to_player(playerStatus->lastGoodPos.x, playerStatus->lastGoodPos.z) / 18.0f;
            playerStatus->actionSubstate++;
            break;
        case SUBSTATE_RETURN_MOTION:
            ReturnAngle = atan2(playerStatus->pos.x, playerStatus->pos.z, playerStatus->lastGoodPos.x, playerStatus->lastGoodPos.z);
            returnRadians = DEG_TO_RAD(ReturnAngle);
            // update motion along x axis
            componentSpeed = playerStatus->curSpeed * sin_rad(returnRadians);
            playerStatus->pos.x += componentSpeed;
            completeAxes = 0;
            if (componentSpeed >= 0.0f) {
                if (playerStatus->lastGoodPos.x <= playerStatus->pos.x) {
                    playerStatus->pos.x = playerStatus->lastGoodPos.x;
                    completeAxes++;
                }
            } else {
                if (playerStatus->pos.x <= playerStatus->lastGoodPos.x) {
                    playerStatus->pos.x = playerStatus->lastGoodPos.x;
                    completeAxes++;
                }
            }
            // update motion along z axis
            componentSpeed = playerStatus->curSpeed * cos_rad(returnRadians);
            playerStatus->pos.z -= componentSpeed;
            if (componentSpeed >= 0.0f) {
                if (playerStatus->pos.z <= playerStatus->lastGoodPos.z) {
                    playerStatus->pos.z = playerStatus->lastGoodPos.z;
                    completeAxes++;
                }
            } else {
                if (playerStatus->lastGoodPos.z <= playerStatus->pos.z) {
                    playerStatus->pos.z = playerStatus->lastGoodPos.z;
                    completeAxes++;
                }
            }
            // if both axes are done, continue to next substate
            if (completeAxes == 2) {
                playerStatus->actionSubstate++;
            }
            break;
        case SUBSTATE_HOVER:
            if (playerStatus->hazardType == HAZARD_TYPE_LAVA && (playerStatus->timeInAir % 2) == 0) {
                fx_smoke_burst(0, playerStatus->pos.x, playerStatus->pos.y, playerStatus->pos.z, 0.7f, 18);
            }
            playerStatus->pos.y = player_check_collision_below(player_fall_distance(), &completeAxes);
            if (completeAxes >= 0) {
                exec_ShakeCamX(CAM_DEFAULT, CAM_SHAKE_DECAYING_VERTICAL, 1, 0.8f);
                start_rumble(256, 50);
                phys_adjust_cam_on_landing();
                gCameras[CAM_DEFAULT].moveFlags &= ~CAMERA_MOVE_NO_INTERP_Y;
                sfx_play_sound_at_player(SOUND_PLAYER_COLLAPSE, SOUND_SPACE_DEFAULT);
                suggest_player_anim_always_forward(ANIM_MarioW2_Thrown);
                playerStatus->flags &= ~PS_FLAG_HIT_FIRE;
                playerStatus->flags &= ~PS_FLAG_FLYING;
                playerStatus->hazardType = HAZARD_TYPE_NONE;
                playerStatus->gravityIntegrator[0] = 6.0f;
                playerStatus->pos.y += 6.0f;
                playerStatus->actionSubstate++;
            }
            break;
        case SUBSTATE_BOUNCE:
            playerStatus->gravityIntegrator[0] -= 1.0;
            playerStatus->pos.y = player_check_collision_below(playerStatus->gravityIntegrator[0], &completeAxes);
            if (completeAxes >= 0) {
                playerStatus->curStateTime = 10;
                playerStatus->actionSubstate++;
            }
            break;
        case SUBSTATE_DELAY_DONE:
            if (--playerStatus->curStateTime <= 0) {
                set_action_state(ACTION_STATE_LAND);
                playerStatus->flags &= ~PS_FLAG_SCRIPTED_FALL;
                gOverrideFlags &= ~GLOBAL_OVERRIDES_40;
            }
            break;
    }
    if (playerStatus->actionSubstate < SUBSTATE_BOUNCE) {
        playerStatus->timeInAir++;
    }
}

action_update_parasol()

void action_update_parasol

(

void

)

Definition at line 73 of file sneaky_parasol.c.

                                 {
    PlayerStatus* playerStatus = &gPlayerStatus;
    TransformationData* transformation = &ParasolTransformation;
    Camera* cam = &gCameras[gCurrentCameraID];
    Npc* disguiseNpc;
    f32 prevFacingAngle;
    s32 reachedTangentAngle;
    f32 angle;
    f32 radius;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        mem_clear(&ParasolTransformation, sizeof(ParasolTransformation));
        disable_player_static_collisions();
 
        playerStatus->timeInAir = 0;
        playerStatus->peakJumpTime = 0;
        playerStatus->curSpeed = 0;
        playerStatus->pitch = 0;
 
        if (playerStatus->spriteFacingAngle >= 90 && playerStatus->spriteFacingAngle < 270) {
            transformation->playerRotationRate = 2;
        } else {
            transformation->playerRotationRate = -2;
        }
 
        if (!(playerStatus->animFlags & PA_FLAG_INVISIBLE)) {
            playerStatus->curStateTime = 20;
            playerStatus->actionSubstate = SUBSTATE_DISGUISE_INIT;
            transformation->disguiseTime = 15;
            transformation->npc = parasol_get_npc();
        } else {
            playerStatus->actionSubstate = SUBSTATE_REVERT_INIT;
            playerStatus->curStateTime = 40;
            transformation->reverted = 1;
            transformation->revertTime = 12;
            disguiseNpc = get_npc_by_index(PeachDisguiseNpcIndex);
            disguiseNpc->flags |= NPC_FLAG_IGNORE_CAMERA_FOR_YAW;
            playerStatus->flags |= PS_FLAG_ROTATION_LOCKED;
            sfx_play_sound_at_player(SOUND_SNEAKY_PARASOL_COPY, SOUND_SPACE_DEFAULT);
        }
    }
 
    switch (playerStatus->actionSubstate) {
        case SUBSTATE_DISGUISE_INIT:
            if (playerStatus->flipYaw[CAM_DEFAULT] == 0) {
                if (peach_disguise_check_overlaps() < 0) {
                    suggest_player_anim_allow_backward(ANIM_Peach2_UseParasol);
                    sfx_play_sound_at_player(SOUND_KKJ_USE_SNEAKY_PARASOL, SOUND_SPACE_DEFAULT);
                    playerStatus->actionSubstate++; // SUBSTATE_USE_PARASOL
                } else {
                    suggest_player_anim_allow_backward(ANIM_Peach2_CantFitParasol);
                    playerStatus->actionSubstate = SUBSTATE_BLOCKED;
                    playerStatus->curStateTime = 10;
                    transformation->disguiseTime = 0;
                }
            }
        case SUBSTATE_USE_PARASOL:
            if (--playerStatus->curStateTime == 0) {
                suggest_player_anim_allow_backward(ANIM_Peach2_PutAwayParasol);
                playerStatus->actionSubstate = SUBSTATE_PUT_AWAY;
                if (transformation->npc == NULL) {
                    playerStatus->actionSubstate = SUBSTATE_FAILED;
                } else {
                    set_time_freeze_mode(TIME_FREEZE_FULL);
                }
            }
            break;
        case SUBSTATE_PUT_AWAY:
            if (playerStatus->animNotifyValue != 0) {
                playerStatus->curStateTime = 12;
                playerStatus->flags |= PS_FLAG_ROTATION_LOCKED;
                playerStatus->actionSubstate++; // SUBSTATE_DISGUISE_BEGIN
                sfx_play_sound_at_player(SOUND_SNEAKY_PARASOL_COPY, SOUND_SPACE_DEFAULT);
            }
            break;
        case SUBSTATE_DISGUISE_BEGIN:
            if (--playerStatus->curStateTime == 0) {
                playerStatus->curStateTime = 10;
                transformation->revertTime = 10;
                playerStatus->actionSubstate++; // SUBSTATE_DISGUISE_WAIT_FOR_ANGLE
            }
            parasol_update_spin();
            break;
        case SUBSTATE_DISGUISE_WAIT_FOR_ANGLE:
            prevFacingAngle = playerStatus->spriteFacingAngle;
            parasol_update_spin();
            playerStatus->targetYaw = clamp_angle((cam->curYaw - playerStatus->spriteFacingAngle) - 90);
            if (playerStatus->curStateTime == 0) {
                // wait for the sprite to rotate into a position where it's tangent to the camera
                reachedTangentAngle = FALSE;
                if (transformation->playerRotationRate > 0) {
                    if (prevFacingAngle < 270 && playerStatus->spriteFacingAngle >= 270) {
                        reachedTangentAngle = TRUE;
                    }
                }
                if (transformation->playerRotationRate < 0) {
                    if (prevFacingAngle > 270 && playerStatus->spriteFacingAngle <= 270) {
                        reachedTangentAngle = TRUE;
                    }
                }
                if (reachedTangentAngle) {
                    playerStatus->actionSubstate = SUBSTATE_DISGUISE_SPIN_DOWN;
                    playerStatus->curStateTime = 2;
                    if (peach_make_disguise_npc(playerStatus->availableDisguiseType) != NULL) {
                        playerStatus->actionSubstate = SUBSTATE_DISGUISE_MAKE_NPC;
                        peach_sync_disguise_npc();
                    }
                }
            } else {
                playerStatus->curStateTime--;
            }
            break;
        case SUBSTATE_DISGUISE_MAKE_NPC:
            playerStatus->animFlags |= PA_FLAG_INVISIBLE;
            gGameStatus.peachFlags |= PEACH_FLAG_DISGUISED;
            playerStatus->actionSubstate++; // SUBSTATE_DISGUISE_SPIN_DOWN
        case SUBSTATE_DISGUISE_SPIN_DOWN:
            if (--playerStatus->curStateTime == 0) {
                playerStatus->actionSubstate++; // SUBSTATE_DISGUISE_FINISH_SPIN
            }
            parasol_update_spin();
            break;
        case SUBSTATE_DISGUISE_FINISH_SPIN:
            if (transformation->playerRotationRate > 0.0f) {
                transformation->playerYawOffset -= 2.35;
                if (transformation->playerYawOffset <= 0) {
                    transformation->playerYawOffset = 0;
                    playerStatus->curStateTime = 10;
                    playerStatus->actionSubstate++; // SUBSTATE_DISGUISE_DONE
                    playerStatus->spriteFacingAngle = 180;
                    disguiseNpc = get_npc_by_index(PeachDisguiseNpcIndex);
                    disguiseNpc->isFacingAway = TRUE;
                    disguiseNpc->yaw = clamp_angle((cam->curYaw - playerStatus->spriteFacingAngle) - 90);
                    disguiseNpc->yawCamOffset = disguiseNpc->yaw;
                }
            } else {
                transformation->playerYawOffset += 2.35;
                if (transformation->playerYawOffset >= 0) {
                    transformation->playerYawOffset = 0;
                    playerStatus->curStateTime = 10;
                    playerStatus->spriteFacingAngle = 0;
                    playerStatus->actionSubstate++; // SUBSTATE_DISGUISE_DONE
                    disguiseNpc = get_npc_by_index(PeachDisguiseNpcIndex);
                    disguiseNpc->isFacingAway = FALSE;
                    disguiseNpc->yaw = clamp_angle((cam->curYaw - playerStatus->spriteFacingAngle) - 90);
                    disguiseNpc->yawCamOffset = disguiseNpc->yaw;
                }
            }
            playerStatus->spriteFacingAngle = clamp_angle(playerStatus->spriteFacingAngle + transformation->playerYawOffset);
            playerStatus->targetYaw = clamp_angle((cam->curYaw - playerStatus->spriteFacingAngle) - 90);
            break;
        case SUBSTATE_DISGUISE_DONE:
            if (--playerStatus->curStateTime == 0) {
                set_time_freeze_mode(TIME_FREEZE_NONE);
                disguiseNpc = get_npc_by_index(PeachDisguiseNpcIndex);
                disguiseNpc->flags &= ~NPC_FLAG_IGNORE_CAMERA_FOR_YAW;
                playerStatus->flags &= ~PS_FLAG_ROTATION_LOCKED;
                set_action_state(ACTION_STATE_IDLE);
                enable_player_static_collisions();
            }
            break;
        case SUBSTATE_REVERT_INIT:
            if (--playerStatus->curStateTime == 0) {
                playerStatus->actionSubstate++; // SUBSTATE_REVERT_WAIT_FOR_ANGLE
            }
            parasol_update_spin();
            playerStatus->targetYaw = clamp_angle(cam->curYaw - playerStatus->spriteFacingAngle - 90);
            break;
        case SUBSTATE_REVERT_WAIT_FOR_ANGLE:
            prevFacingAngle = playerStatus->spriteFacingAngle;
            parasol_update_spin();
            playerStatus->targetYaw = clamp_angle((cam->curYaw - playerStatus->spriteFacingAngle) - 90);
            if (playerStatus->curStateTime == 0) {
                // wait for the sprite to rotate into a position where it's tangent to the camera
                reachedTangentAngle = FALSE;
                if (transformation->playerRotationRate > 0) {
                    if (prevFacingAngle < 270 && playerStatus->spriteFacingAngle >= 270) {
                        reachedTangentAngle = TRUE;
                    }
                }
                if (transformation->playerRotationRate < 0) {
                    if (prevFacingAngle > 270 && playerStatus->spriteFacingAngle <= 270) {
                        reachedTangentAngle = TRUE;
                    }
                }
                if (reachedTangentAngle) {
                    playerStatus->curStateTime = 2;
                    playerStatus->actionSubstate++; // SUBSTATE_SPIN_DOWN
                    playerStatus->animFlags &= ~PA_FLAG_INVISIBLE;
                    gGameStatus.peachFlags &= ~PEACH_FLAG_DISGUISED;
                    playerStatus->peachDisguise = 0;
                    free_npc_by_index(PeachDisguiseNpcIndex);
                    playerStatus->colliderHeight = 55;
                    playerStatus->colliderDiameter = 38;
                }
            } else {
                playerStatus->curStateTime--;
            }
            break;
        case SUBSTATE_SPIN_DOWN:
            if (--playerStatus->curStateTime == 0) {
                playerStatus->actionSubstate++; // SUBSTATE_FINISH_SPIN
            }
            parasol_update_spin();
            break;
        case SUBSTATE_FINISH_SPIN:
            if (transformation->playerRotationRate > 0) {
                transformation->playerYawOffset -= 2.35;
                if (transformation->playerYawOffset <= 0) {
                    transformation->playerYawOffset = 0;
                    playerStatus->curStateTime = 10;
                    playerStatus->actionSubstate++; // SUBSTATE_REVERT_DONE
                    playerStatus->spriteFacingAngle = 180;
                    PrevPlayerDirection = 1;
                    playerStatus->curYaw = clamp_angle((cam->curYaw - 180) - 90);
                    PrevPlayerCamRelativeYaw = playerStatus->curYaw;
                }
            } else {
                transformation->playerYawOffset += 2.35;
                if (transformation->playerYawOffset >= 0) {
                    transformation->playerYawOffset = 0;
                    playerStatus->curStateTime = 10;
                    playerStatus->spriteFacingAngle = 0;
                    playerStatus->actionSubstate++; // SUBSTATE_REVERT_DONE
                    PrevPlayerDirection = 0;
                    playerStatus->curYaw = clamp_angle((cam->curYaw - 0) - 90);
                    PrevPlayerCamRelativeYaw = playerStatus->curYaw;
                }
            }
            playerStatus->spriteFacingAngle = clamp_angle(playerStatus->spriteFacingAngle + transformation->playerYawOffset);
            playerStatus->targetYaw = clamp_angle(cam->curYaw - playerStatus->spriteFacingAngle - 90);
            break;
        case SUBSTATE_REVERT_DONE:
            if (--playerStatus->curStateTime == 0) {
                set_time_freeze_mode(TIME_FREEZE_NONE);
                playerStatus->flags &= ~PS_FLAG_ROTATION_LOCKED;
                set_action_state(ACTION_STATE_IDLE);
                enable_player_static_collisions();
            }
            break;
        case SUBSTATE_ABORT:
            peach_force_disguise_action(FALSE);
            enable_player_static_collisions();
            break;
        case SUBSTATE_FAILED:
            if (playerStatus->animNotifyValue != 0) {
                set_action_state(ACTION_STATE_IDLE);
                enable_player_static_collisions();
            }
            break;
        case SUBSTATE_BLOCKED:
            if (--playerStatus->curStateTime == 0) {
                set_action_state(ACTION_STATE_IDLE);
                enable_player_static_collisions();
            }
            break;
    }
 
    if (transformation->disguiseTime > 0) {
        if (--transformation->disguiseTime == 10) {
            if (playerStatus->spriteFacingAngle >= 90 && playerStatus->spriteFacingAngle < 270) {
                angle = DEG_TO_RAD(cam->curYaw - 270);
                radius = 46;
            } else {
                angle = DEG_TO_RAD(cam->curYaw - 90);
                radius = 30;
            }
            transformation->pos.x = playerStatus->pos.x + (radius * sin_rad(angle));
            transformation->pos.z = playerStatus->pos.z - (radius * cos_rad(angle));
            transformation->pos.y = playerStatus->pos.y - 20;
        }
        if (transformation->disguiseTime <= 10 && transformation->disguiseTime & 1) {
            fx_sparkles(FX_SPARKLES_3,
                transformation->pos.x - 8,
                transformation->pos.y + 50,
                transformation->pos.z,
                2);
 
            angle = DEG_TO_RAD((cam->curYaw + playerStatus->spriteFacingAngle) - 90);
            transformation->pos.x += (10.0 * sin_rad(angle));
            transformation->pos.z -= (10.0 * cos_rad(angle));
        }
    } else if (transformation->disguiseTime == 0) {
        transformation->disguiseTime = -1;
        if (transformation->npc != NULL) {
            fx_pink_sparkles(playerStatus->availableDisguiseType - 1,
                transformation->npc->pos.x,
                transformation->npc->pos.y,
                transformation->npc->pos.z,
                1, transformation->npc->yawCamOffset);
        }
    }
    if (transformation->revertTime != 0) {
        if (transformation->revertTime <= 10) {
            if (transformation->revertTime == 10) {
                sfx_play_sound_at_player(SOUND_SNEAKY_PARASOL_TRANSFORM, SOUND_SPACE_DEFAULT);
            }
            if ((transformation->revertTime & 3) == 0) {
                fx_stars_shimmer(4,
                    playerStatus->pos.x,
                    playerStatus->pos.y,
                    playerStatus->pos.z,
                    50, 50, 40, 30);
            }
        }
        transformation->revertTime--;
    }
}

action_update_spin()

void action_update_spin

(

void

)

Definition at line 27 of file spin.c.

                              {
    PlayerSpinState* playerSpinState = &gPlayerSpinState;
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 angle, magnitude, speedModifier;
 
    s32 spinFlags, nonDizzyFlags;
    s32 effectType;
    AnimID anim;
    s32 firstCall = FALSE;
 
    // initialization
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~(PS_FLAG_ACTION_STATE_CHANGED | PS_FLAG_ARMS_RAISED);
        playerStatus->animFlags &= ~PA_FLAG_INTERRUPT_SPIN;
        playerStatus->animFlags |= PA_FLAG_SPINNING;
        playerStatus->flags |= PS_FLAG_SPINNING;
        playerStatus->curStateTime = 0;
        playerStatus->actionSubstate = SUBSTATE_SPIN_0;
        playerSpinState->stopSoundTimer = 0;
        playerSpinState->hasBufferedSpin = FALSE;
        playerSpinState->spinDirectionMagnitude = 0.0f;
        playerSpinState->spinDirection.x = 0.0f;
        playerSpinState->spinDirection.y = 0.0f;
        playerSpinState->hitWallTime = 0;
        playerSpinState->bufferedStickAxis.x = 0;
        playerSpinState->bufferedStickAxis.y = 0;
        playerSpinState->spinSoundID = 0;
        playerStatus->specialDecorationEffect = NULL;
        playerSpinState->initialSpinTime = 25;
        playerSpinState->fullSpeedSpinTime = 15;
        playerSpinState->spinRate = 40.0f;
        playerSpinState->speedScale = 2.0f;
        playerSpinState->frictionScale = 0.5f;
        playerSpinState->spinCountdown = playerSpinState->initialSpinTime;
        spinFlags = SPIN_TYPE_DEFAULT;
        firstCall = TRUE;
 
        if (is_ability_active(ABILITY_SPIN_ATTACK)) {
            spinFlags |= SPIN_TYPE_ATTACK;
        }
 
        if (is_ability_active(ABILITY_DIZZY_ATTACK)) {
            spinFlags |= SPIN_TYPE_DIZZY;
        }
 
        if (is_ability_active(ABILITY_SPEEDY_SPIN)) {
            playerSpinState->initialSpinTime = 30;
            playerSpinState->spinRate = 40.0f;
            playerSpinState->fullSpeedSpinTime = 20;
            playerSpinState->spinCountdown = playerSpinState->initialSpinTime;
            playerSpinState->speedScale = 2.7f;
            playerSpinState->frictionScale = 0.9f;
            spinFlags |= SPIN_TYPE_SPEEDY;
        }
 
        effectType = -1;
        anim = ANIM_Mario1_Spin;
 
        if (spinFlags) {
            if (spinFlags & SPIN_TYPE_ATTACK) {
                effectType = 2;
                anim = ANIM_Mario1_SpinAttack;
            } else if (spinFlags & SPIN_TYPE_DIZZY) {
                effectType = 4;
                anim = ANIM_Mario1_Spin;
            } else if (spinFlags & SPIN_TYPE_SPEEDY) {
                effectType = 0;
                anim = ANIM_Mario1_SpeedySpin;
            }
        }
 
        playerSpinState->spinSoundID = SOUND_SPIN;
        nonDizzyFlags = spinFlags & ~SPIN_TYPE_DIZZY;
 
        if (nonDizzyFlags == SPIN_TYPE_ATTACK) {
            playerSpinState->spinSoundID = SOUND_SPIN_ATTACK;
        }
        if (nonDizzyFlags == SPIN_TYPE_SPEEDY) {
            playerSpinState->spinSoundID = SOUND_SPEEDY_SPIN;
        }
        if (nonDizzyFlags == (SPIN_TYPE_ATTACK | SPIN_TYPE_SPEEDY)) {
            playerSpinState->spinSoundID = SOUND_SPEEDY_SPIN_ATTACK;
        }
 
        sfx_play_sound_at_player(playerSpinState->spinSoundID, SOUND_SPACE_DEFAULT);
        suggest_player_anim_always_forward(anim);
 
        if ((clamp_angle(playerStatus->targetYaw - gCameras[gCurrentCameraID].curYaw) <= 180.0f)) {
            playerStatus->spinRate = playerSpinState->spinRate;
        } else {
            effectType++;
            playerStatus->spinRate = -playerSpinState->spinRate;
        }
        if (spinFlags != 0) {
            playerStatus->specialDecorationEffect = fx_effect_46(effectType, playerStatus, 1.0f, 1000);
        }
 
        phys_clear_spin_history();
        player_input_to_move_vector(&angle, &magnitude);
        playerStatus->targetYaw = angle;
        playerSpinState->inputMagnitude = magnitude;
    }
 
    // update saved position and rotation values for motion blur effect
    gSpinHistoryPosAngle[gSpinHistoryBufferPos++] = playerStatus->spriteFacingAngle;
    if (gSpinHistoryBufferPos > ARRAY_COUNT(gSpinHistoryPosX)) {
        gSpinHistoryBufferPos = 0;
    }
    gSpinHistoryPosX[gSpinHistoryBufferPos] = playerStatus->pos.x;
    gSpinHistoryPosY[gSpinHistoryBufferPos] = playerStatus->pos.y;
    gSpinHistoryPosZ[gSpinHistoryBufferPos] = playerStatus->pos.z;
    gSpinHistoryPosAngle[gSpinHistoryBufferPos] = playerStatus->spriteFacingAngle;
    gSpinHistoryBufferPos++;
    if (gSpinHistoryBufferPos > ARRAY_COUNT(gSpinHistoryPosX)) {
        gSpinHistoryBufferPos = 0;
    }
 
    // check for spin cancel
    if (!firstCall && (check_input_hammer() || check_input_jump())) {
        playerStatus->animFlags &= ~PA_FLAG_SPINNING;
        playerStatus->flags &= ~PS_FLAG_SPINNING;
        sfx_stop_sound(playerSpinState->spinSoundID);
        player_input_to_move_vector(&angle, &magnitude);
        playerStatus->targetYaw = angle;
        return;
    }
 
    // check for buffered next spin
    if (playerSpinState->spinCountdown < 11 && playerStatus->pressedButtons & BUTTON_Z) {
        playerSpinState->hasBufferedSpin = TRUE;
        playerSpinState->prevActionState = playerStatus->prevActionState;
        playerSpinState->bufferedStickAxis.x = playerStatus->stickAxis[0];
        playerSpinState->bufferedStickAxis.y = playerStatus->stickAxis[1];
    }
 
    // check for action finished
    if (playerStatus->actionSubstate >= SUBSTATE_SPIN_2) {
        playerSpinState->spinDirectionMagnitude -= 1.0f;
        if (playerSpinState->spinDirectionMagnitude < 0.0f) {
            playerSpinState->spinDirectionMagnitude = 0.0f;
        }
 
        angle = clamp_angle(playerStatus->targetYaw - gCameras[gCurrentCameraID].curYaw);
        playerSpinState->spinDirection.x = sin_rad(DEG_TO_RAD(angle)) * playerSpinState->spinDirectionMagnitude;
        playerSpinState->spinDirection.y = -cos_rad(DEG_TO_RAD(angle)) * playerSpinState->spinDirectionMagnitude;
        playerStatus->curStateTime--;
        if (playerStatus->curStateTime == 0) {
            playerSpinState->stopSoundTimer = 4;
            set_action_state(ACTION_STATE_IDLE);
            playerStatus->flags &= ~PS_FLAG_SPINNING;
            playerStatus->animFlags &= ~PA_FLAG_SPINNING;
            sfx_stop_sound(playerSpinState->spinSoundID);
        }
        playerStatus->curSpeed = 0.0f;
        return;
    }
 
    if (playerStatus->actionSubstate == SUBSTATE_SPIN_0) {
        if (playerStatus->animFlags & PA_FLAG_INTERRUPT_SPIN) {
            playerStatus->actionSubstate = SUBSTATE_SPIN_1;
        } else if (gCollisionStatus.pushingAgainstWall > NO_COLLIDER) {
            playerSpinState->hitWallTime++;
            if (playerSpinState->hitWallTime >= 10) {
                playerStatus->actionSubstate = SUBSTATE_SPIN_1;
            }
        }
    }
 
    if (!(playerStatus->curStateTime > playerSpinState->fullSpeedSpinTime)) {
        speedModifier = (playerSpinState->inputMagnitude) ? playerSpinState->speedScale : 0.0f;
        playerSpinState->spinDirectionMagnitude = playerSpinState->spinDirectionMagnitude + 0.9;
 
        if (playerSpinState->spinDirectionMagnitude > 9.0f) {
            playerSpinState->spinDirectionMagnitude = 9.0f;
        }
 
        angle = clamp_angle(playerStatus->targetYaw - gCameras[gCurrentCameraID].curYaw);
        playerSpinState->spinDirection.x = sin_rad(DEG_TO_RAD(angle)) * playerSpinState->spinDirectionMagnitude;
        playerSpinState->spinDirection.y = -cos_rad(DEG_TO_RAD(angle)) * playerSpinState->spinDirectionMagnitude;
    } else {
        speedModifier = playerSpinState->speedScale - (playerStatus->curStateTime - playerSpinState->fullSpeedSpinTime - 1) * playerSpinState->frictionScale;
        if (speedModifier < 0.1) {
            speedModifier = 0.1f;
        }
 
        if (playerSpinState->inputMagnitude == 0.0f) {
            speedModifier = 0.0f;
        }
 
        playerSpinState->spinDirectionMagnitude -= 1.0f;
        if (playerSpinState->spinDirectionMagnitude < 0.0f) {
            playerSpinState->spinDirectionMagnitude = 0.0f;
        }
    }
 
    playerStatus->curStateTime++;
 
    switch (playerStatus->prevActionState) {
        case ACTION_STATE_IDLE:
            player_input_to_move_vector(&angle, &magnitude);
            phys_update_interact_collider();
            if (check_input_jump()) {
                if (magnitude != 0.0f || playerStatus->targetYaw != angle) {
                    playerStatus->targetYaw = angle;
                }
            }
            playerStatus->curSpeed = (magnitude != 0.0f) ? playerStatus->runSpeed * speedModifier : 0.0f;
            break;
        case ACTION_STATE_WALK:
        case ACTION_STATE_RUN:
            playerStatus->curSpeed = playerStatus->runSpeed * speedModifier;
            break;
    }
    if (playerStatus->actionSubstate == SUBSTATE_SPIN_0) {
        playerSpinState->spinCountdown--;
        if (playerSpinState->spinCountdown > 0) {
            if (playerStatus->curStateTime >= 2) {
                playerStatus->spriteFacingAngle = clamp_angle(playerStatus->spriteFacingAngle + playerStatus->spinRate);
            }
            return;
        } else {
            playerStatus->actionSubstate = SUBSTATE_SPIN_1;
        }
    }
 
    if (playerStatus->actionSubstate == SUBSTATE_SPIN_1) {
        angle = playerStatus->spriteFacingAngle;
        playerStatus->spriteFacingAngle = angle + playerStatus->spinRate;
 
        if (playerSpinState->hasBufferedSpin) {
            playerStatus->curStateTime = 2;
            playerStatus->actionSubstate = SUBSTATE_SPIN_2;
            playerStatus->flags &= ~PS_FLAG_SPINNING;
            suggest_player_anim_allow_backward(ANIM_Mario1_Idle);
        } else if (angle < playerStatus->spriteFacingAngle) {
            if (playerStatus->spriteFacingAngle >= 180.0f && angle < 180.0f) {
                playerStatus->spriteFacingAngle = 180.0f;
                playerStatus->curStateTime = 2;
                playerStatus->actionSubstate = SUBSTATE_SPIN_2;
                playerStatus->flags &= ~PS_FLAG_SPINNING;
                suggest_player_anim_allow_backward(ANIM_Mario1_Idle);
            }
        } else if (playerStatus->spriteFacingAngle <= 0.0f && angle < 90.0f) {
            playerStatus->spriteFacingAngle = 0.0f;
            playerStatus->curStateTime = 2;
            playerStatus->actionSubstate = SUBSTATE_SPIN_2;
            playerStatus->flags &= ~PS_FLAG_SPINNING;
            suggest_player_anim_allow_backward(ANIM_Mario1_Idle);
        }
        playerStatus->spriteFacingAngle = clamp_angle(playerStatus->spriteFacingAngle);
    }
}

action_update_step_up_peach()

void action_update_step_up_peach

(

void

)

Definition at line 85 of file step_up.c.

                                       {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        suggest_player_anim_allow_backward(ANIM_Peach1_StepUp);
        playerStatus->curStateTime = 8;
    }
 
    if (playerStatus->curStateTime != 0) {
        playerStatus->curStateTime--;
#if !VERSION_JP
        if (playerStatus->curStateTime == 4) {
            try_player_footstep_sounds(1);
        }
#endif
    } else {
        if (!(playerStatus->flags & PS_FLAG_CUTSCENE_MOVEMENT)) {
            set_action_state(ACTION_STATE_IDLE);
        } else if (playerStatus->curSpeed >= playerStatus->runSpeed) {
            set_action_state(ACTION_STATE_RUN);
        } else {
            set_action_state(ACTION_STATE_WALK);
        }
    }
}

action_update_ride()

void action_update_ride

(

void

)

Definition at line 9 of file misc.c.

                              {
    PartnerStatus* partnerStatus = &gPartnerStatus;
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~(PS_FLAG_ACTION_STATE_CHANGED | PS_FLAG_ARMS_RAISED | PS_FLAG_AIRBORNE);
        playerStatus->actionSubstate = 0;
        playerStatus->curStateTime = 0;
        playerStatus->timeInAir = 0;
        playerStatus->peakJumpTime = 0;
        playerStatus->curSpeed = 0.0f;
        playerStatus->pitch = 0.0f;
    }
 
    if (playerStatus->animFlags & PA_FLAG_RIDING_PARTNER) {
        if (partnerStatus->actingPartner == PARTNER_LAKILESTER) {
            world_lakilester_sync_player_position();
        } else if (partnerStatus->actingPartner == PARTNER_SUSHIE) {
            world_sushie_sync_player_position();
        }
    }
}

action_update_step_up()

void action_update_step_up

(

void

)

Definition at line 29 of file step_up.c.

                                 {
    PlayerStatus* playerStatus = &gPlayerStatus;
    HitID colliderID;
    f32 cosTheta;
    f32 sinTheta;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        phys_adjust_cam_on_landing();
        if (playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) {
            action_update_step_up_set_peach_anim();
        } else if (playerStatus->animFlags & PA_FLAG_USING_WATT) {
            suggest_player_anim_allow_backward(ANIM_MarioW1_CarryWalk);
        } else {
            suggest_player_anim_allow_backward(ANIM_Mario1_Walk);
        }
        playerStatus->actionSubstate = 0;
        playerStatus->timeInAir = 0;
        playerStatus->peakJumpTime = 0;
        playerStatus->gravityIntegrator[0] = 17.7566f;
        playerStatus->gravityIntegrator[1] = -11.3862f;
        playerStatus->gravityIntegrator[2] = 3.5f;
        playerStatus->gravityIntegrator[3] = -0.75f;
    }
 
    integrate_gravity();
    sin_cos_rad(DEG_TO_RAD(playerStatus->targetYaw), &sinTheta, &cosTheta);
    colliderID = NO_COLLIDER;
    playerStatus->pos.x += sinTheta * 3.0f;
    playerStatus->pos.z -= cosTheta * 3.0f;
 
    if (playerStatus->gravityIntegrator[0] < 0.0f) {
        playerStatus->pos.y = player_check_collision_below(playerStatus->gravityIntegrator[0], &colliderID);
    } else {
        playerStatus->pos.y += playerStatus->gravityIntegrator[0];
    }
 
    if (colliderID > NO_COLLIDER) {
        if (playerStatus->prevActionState != ACTION_STATE_SPIN) {
            set_action_state(playerStatus->prevActionState);
        } else {
            update_locomotion_state();
        }
    }
}

action_update_first_strike()

void action_update_first_strike

(

void

)

Definition at line 142 of file misc.c.

                                      {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~(PS_FLAG_ACTION_STATE_CHANGED | PS_FLAG_AIRBORNE);
        playerStatus->actionSubstate = 0;
        playerStatus->timeInAir = 0;
        playerStatus->peakJumpTime = 0;
        playerStatus->curSpeed = 0.0f;
        playerStatus->pitch = 0.0f;
        suggest_player_anim_always_forward(ANIM_Mario1_Hurt);
        playerStatus->curStateTime = 30;
    }
 
    if (playerStatus->curStateTime != 0) {
        playerStatus->curStateTime--;
    } else if (gGameStatusPtr->context == CONTEXT_WORLD) {
        set_action_state(ACTION_STATE_IDLE);
    }
}

action_update_raise_arms()

void action_update_raise_arms

(

void

)

Definition at line 163 of file misc.c.

                                    {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        playerStatus->flags |= PS_FLAG_ARMS_RAISED;
        playerStatus->curStateTime = 0;
        playerStatus->actionSubstate = 0;
        playerStatus->curSpeed = 0.0f;
        playerStatus->pitch = 0.0f;
        suggest_player_anim_always_forward(ANIM_Mario1_UsePower);
    }
 
    if (!(playerStatus->animFlags & PA_FLAG_RAISED_ARMS)) {
        set_action_state(ACTION_STATE_IDLE);
        playerStatus->flags &= ~PS_FLAG_ARMS_RAISED;
    }
}

action_update_use_spinning_flower()

void action_update_use_spinning_flower

(

void

)

Definition at line 38 of file use_spinning_flower.c.

                                             {
    PlayerStatus* playerStatus = &gPlayerStatus;
    Entity* entityByIndex;
    s32* TempPointer;
    s32 entityID;
    f32 inputMagnitude;
    f32 inputAngle;
    f32 dz;
    f32 dx;
    f32 ascentVelocity;
    f32 distToCenter;
    s8 switchCondition;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        gOverrideFlags |= GLOBAL_OVERRIDES_40;
        func_800EF300();
        playerStatus->actionSubstate = SUBSTATE_ATTRACT;
        playerStatus->curStateTime = 0;
        D_802B6EE4 = 0.0f;
        D_802B6EE8 = 0.0f;
        D_802B6EF4 = playerStatus->pos.y;
        D_802B6EDC = 3.0f;
        disable_player_static_collisions();
        disable_player_input();
        playerStatus->flags |= PS_FLAG_ROTATION_LOCKED;
        entityID = gCollisionStatus.curFloor;
#if VERSION_JP
        gCollisionStatus.curFloor = -1;
#endif
 
        TempPointer = &SpinningFlower_EntityIndex;
        if (entityID >= 0){
            if (entityID & COLLISION_WITH_ENTITY_BIT) {
                SpinningFlower_EntityIndex = entityID & 0x3FF;
            } else {
                SpinningFlower_EntityIndex = -1;
            }
        } else {
            SpinningFlower_EntityIndex = -1;
        }
        if (!(playerStatus->animFlags & (PA_FLAG_USING_WATT | PA_FLAG_WATT_IN_HANDS))) {
            suggest_player_anim_allow_backward(ANIM_Mario1_Flail);
        }
    }
 
    switch (playerStatus->actionSubstate) {
        case SUBSTATE_ATTRACT:
            gOverrideFlags |= GLOBAL_OVERRIDES_40;
            D_802B6EE4 += 1.0f;
            if (D_802B6EE4 >= 20.0f) {
                D_802B6EE4 = 20.0f;
            }
            playerStatus->spriteFacingAngle = clamp_angle(playerStatus->spriteFacingAngle + D_802B6EE4);
            if (playerStatus->curStateTime < 10) {
                playerStatus->curStateTime++;
                D_802B6EF4++;
            }
            D_802B6EE8 += 8.0f;
            playerStatus->pos.y = D_802B6EF4 + sin_rad(DEG_TO_RAD(clamp_angle(D_802B6EE8))) * 4.0f;
            if (SpinningFlower_EntityIndex >= 0) {
                entityByIndex = get_entity_by_index(SpinningFlower_EntityIndex);
                distToCenter = dist2D(entityByIndex->pos.x, entityByIndex->pos.z, playerStatus->pos.x, playerStatus->pos.z);
                SpinningFlower_AngleToCenter = atan2(entityByIndex->pos.x, entityByIndex->pos.z, playerStatus->pos.x, playerStatus->pos.z);
                if (distToCenter > 4.0f) {
                    distToCenter--;
                }
                sin_cos_rad(DEG_TO_RAD(SpinningFlower_AngleToCenter), &dx, &dz);
                playerStatus->pos.x = entityByIndex->pos.x + (dx * distToCenter);
                playerStatus->pos.z = entityByIndex->pos.z - (dz * distToCenter);
                sin_cos_rad(DEG_TO_RAD(SpinningFlower_AngleToCenter - 91.0f), &dx, &dz);
                D_802B6ED4 =  dx * D_802B6EDC;
                D_802B6ED8 = -dz * D_802B6EDC;
            }
            game_input_to_move_vector(&inputAngle, &inputMagnitude);
            if (inputMagnitude != 0.0f) {
                sin_cos_rad(DEG_TO_RAD(inputAngle), &dx, &dz);
                inputMagnitude *= 0.03125f;
                if (inputMagnitude < 0.1) {
                    inputMagnitude = 0.1f;
                }
                playerStatus->pos.x += dx * inputMagnitude;
                playerStatus->pos.z -= dz * inputMagnitude;
            }
            gCameras[CAM_DEFAULT].targetPos.x = playerStatus->pos.x;
            gCameras[CAM_DEFAULT].targetPos.y = playerStatus->pos.y;
            gCameras[CAM_DEFAULT].targetPos.z = playerStatus->pos.z;
            entityID = get_entity_below_spinning_flower();
            if (entityID < 0 || !(entityID & COLLISION_WITH_ENTITY_BIT)) {
                playerStatus->curStateTime = 20;
                D_802B6EE8 = 0.0f;
                D_802B6EF4 = playerStatus->pos.y;
                playerStatus->actionSubstate++;
                D_802B6EF0 = 1.6f;
                playerStatus->flags |= PS_FLAG_SCRIPTED_FALL;
            }
            if (gGameStatusPtr->pressedButtons[0] & BUTTON_Z &&
                !(playerStatus->animFlags & (PA_FLAG_USING_WATT | PA_FLAG_WATT_IN_HANDS))) {
                suggest_player_anim_always_forward(ANIM_Mario1_Jump);
                playerStatus->actionSubstate = SUBSTATE_SPIN_UP;
                playerStatus->curStateTime = 30;
                D_802B6EE0 = 0.0f;
                gCollisionStatus.curFloor = NO_COLLIDER;
                exec_entity_commandlist(get_entity_by_index(SpinningFlower_EntityIndex));
            }
            break;
        case SUBSTATE_EJECT:
            gOverrideFlags |= GLOBAL_OVERRIDES_40;
            if (--D_802B6EE4 < 0.0f) {
                D_802B6EE4 = 0.0f;
                playerStatus->flags &= ~PS_FLAG_ROTATION_LOCKED;
            }
            playerStatus->spriteFacingAngle = clamp_angle(playerStatus->spriteFacingAngle + D_802B6EE4);
            sin_cos_rad(DEG_TO_RAD(SpinningFlower_AngleToCenter - 60.0f), &dx, &dz);
            D_802B6EDC += 0.2;
            D_802B6EF0 -= 0.72;
            D_802B6ED4 =  dx * D_802B6EDC;
            D_802B6ED8 = -dz * D_802B6EDC;
            playerStatus->pos.x += D_802B6ED4;
            playerStatus->pos.z += D_802B6ED8;
            collision_lava_reset_check_additional_overlaps();
            playerStatus->pos.y = player_check_collision_below(D_802B6EF0, &entityID);
            gCameras[CAM_DEFAULT].targetPos.x = playerStatus->pos.x;
            gCameras[CAM_DEFAULT].targetPos.y = playerStatus->pos.y;
            gCameras[CAM_DEFAULT].targetPos.z = playerStatus->pos.z;
            if (entityID >= 0) {
                playerStatus->flags &= ~PS_FLAG_ROTATION_LOCKED;
                enable_player_input();
                enable_player_static_collisions();
                set_action_state(ACTION_STATE_LAND);
                enable_partner_ai();
                gOverrideFlags &= ~GLOBAL_OVERRIDES_40;
                return;
            }
    }
 
    switch (playerStatus->actionSubstate) {
        case SUBSTATE_SPIN_UP:
            if (SpinningFlower_EntityIndex >= 0) {
                entityByIndex = get_entity_by_index(SpinningFlower_EntityIndex);
                distToCenter = dist2D(entityByIndex->pos.x, entityByIndex->pos.z, playerStatus->pos.x, playerStatus->pos.z);
                SpinningFlower_AngleToCenter = atan2(entityByIndex->pos.x, entityByIndex->pos.z, playerStatus->pos.x, playerStatus->pos.z);
                if (distToCenter > 4.0f) {
                    distToCenter -= 1.0f;
                }
                sin_cos_rad(DEG_TO_RAD(SpinningFlower_AngleToCenter), &dx, &dz);
                playerStatus->pos.x = entityByIndex->pos.x + (dx * distToCenter);
                playerStatus->pos.z = entityByIndex->pos.z - (dz * distToCenter);
                sin_cos_rad(DEG_TO_RAD(SpinningFlower_AngleToCenter - 91.0f), &dx, &dz);
                D_802B6ED4 =  dx * D_802B6EDC;
                D_802B6ED8 = -dz * D_802B6EDC;
            }
            D_802B6EE8 += 8.0f;
 
            playerStatus->pos.y = D_802B6EF4 + sin_rad(DEG_TO_RAD(clamp_angle(D_802B6EE8))) * 4.0f;
            gCameras[CAM_DEFAULT].targetPos.z = playerStatus->pos.z;
            gCameras[CAM_DEFAULT].targetPos.x = playerStatus->pos.x;
            gCameras[CAM_DEFAULT].targetPos.y = playerStatus->pos.y;
            if (playerStatus->curStateTime != 0) {
                playerStatus->curStateTime--;
                D_802B6EE4 += 2.0f;
                if (D_802B6EE4 >= 45.0f) {
                    D_802B6EE4 = 45.0f;
                }
                playerStatus->spriteFacingAngle = clamp_angle(playerStatus->spriteFacingAngle + D_802B6EE4);
                break;
            }
            playerStatus->actionSubstate++; // SUBSTATE_ASCEND_A
            playerStatus->curStateTime = 30;
            phys_adjust_cam_on_landing();
            break;
        case SUBSTATE_ASCEND_A:
            D_802B6EE4 += 2.0f;
            if (D_802B6EE4 >= 45.0f) {
                D_802B6EE4 = 45.0f;
            }
            playerStatus->spriteFacingAngle = clamp_angle(playerStatus->spriteFacingAngle + D_802B6EE4);
            D_802B6EE0 += 2.0f;
            if (D_802B6EE0 > 45.0f) {
                D_802B6EE0 = 45.0f;
            }
 
            ascentVelocity = sin_rad(DEG_TO_RAD(D_802B6EE0)) * 4.0f;
            playerStatus->pos.y += ascentVelocity;
            gCameras[CAM_DEFAULT].targetPos.x = playerStatus->pos.x;
            gCameras[CAM_DEFAULT].targetPos.y = playerStatus->pos.y;
            gCameras[CAM_DEFAULT].targetPos.z = playerStatus->pos.z;
            distToCenter = fabsf(dist2D(FlowerGoalPosition.x, FlowerGoalPosition.z, playerStatus->pos.x, playerStatus->pos.z));
            if (distToCenter > 40.0f) {
                if (FlowerGoalPosition.y + 30 < playerStatus->pos.y) {
                    playerStatus->actionSubstate++; // SUBSTATE_ASCEND_B
                    inputAngle = atan2(playerStatus->pos.x, playerStatus->pos.z, FlowerGoalPosition.x, FlowerGoalPosition.z);
                    sin_cos_rad(DEG_TO_RAD(inputAngle), &dx, &dz);
                    playerStatus->curStateTime = 64;
                    SpinningFlower_AngleToCenter = inputAngle;
                    D_802B6ED4 = (dx * distToCenter) * 0.015625;
                    D_802B6ED8 = (-dz * distToCenter) * 0.015625;
                }
                break;
            }
            if (playerStatus->curStateTime == 0) {
                playerStatus->actionSubstate = SUBSTATE_BOOST;
                playerStatus->curStateTime = 20;
            } else {
                playerStatus->curStateTime--;
            }
            break;
        case SUBSTATE_ASCEND_B:
            playerStatus->spriteFacingAngle = clamp_angle(playerStatus->spriteFacingAngle + D_802B6EE4);
            if (playerStatus->curStateTime != 0) {
                playerStatus->curStateTime--;
                if (D_802B6EE0-- < 0.0f) {
                    D_802B6EE0 = 0.0f;
                }
                ascentVelocity = 2.0f * sin_rad(DEG_TO_RAD(D_802B6EE0));
                playerStatus->pos.x += D_802B6ED4;
                playerStatus->pos.y += ascentVelocity;
                playerStatus->pos.z += D_802B6ED8;
            } else {
                playerStatus->actionSubstate = SUBSTATE_FINISH;
            }
            gCameras[CAM_DEFAULT].targetPos.x = playerStatus->pos.x;
            gCameras[CAM_DEFAULT].targetPos.y = playerStatus->pos.y;
            gCameras[CAM_DEFAULT].targetPos.z = playerStatus->pos.z;
            break;
        case SUBSTATE_BOOST:
            D_802B6EE4 += 1.0f;
            if (D_802B6EE4 >= 45.0f) {
                D_802B6EE4 = 45.0f;
            }
            playerStatus->spriteFacingAngle = clamp_angle(playerStatus->spriteFacingAngle + D_802B6EE4);
            D_802B6EE0 += 2.0f;
            if (D_802B6EE0 > 45.0f) {
                D_802B6EE0 = 45.0f;
            }
            ascentVelocity = sin_rad(DEG_TO_RAD(D_802B6EE0)) * 3.0f;
            playerStatus->pos.y += ascentVelocity;
            if (playerStatus->curStateTime != 0) {
                playerStatus->curStateTime--;
                break;
            }
        case SUBSTATE_FINISH:
            enable_player_static_collisions();
            enable_player_input();
            playerStatus->flags &= ~PS_FLAG_ROTATION_LOCKED;
            playerStatus->flags |= PS_FLAG_SCRIPTED_FALL;
            start_falling();
            enable_partner_ai();
            gOverrideFlags &= ~GLOBAL_OVERRIDES_40;
            break;
    }
}

action_update_use_munchlesia()

void action_update_use_munchlesia

(

void

)

Definition at line 18 of file use_munchlesia.c.

                                        {
    PlayerStatus* playerStatus = &gPlayerStatus;
    s32 colliderID;
    f32 hitPosY;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        playerStatus->actionSubstate = SUBSTATE_INIT;
        gOverrideFlags |= GLOBAL_OVERRIDES_40;
        disable_player_static_collisions();
        disable_player_input();
    }
 
    switch (playerStatus->actionSubstate) {
        case SUBSTATE_INIT:
            suggest_player_anim_allow_backward(ANIM_Mario1_FallBack);
            D_802B62E0 = 32;
            Munchlesia_LaunchVelocity = 16.0f;
            Munchlesia_LateralVelocity = 4.0f;
            Munchlesia_LaunchAccel = 1.0f;
            Munchlesia_LateralVelocity = 1.875f;
            playerStatus->actionSubstate++; // SUBSTATE_EJECT
            Munchlesia_LaunchYaw = playerStatus->targetYaw;
            break;
        case SUBSTATE_EJECT:
            playerStatus->pos.y += Munchlesia_LaunchVelocity;
            Munchlesia_LaunchVelocity -= Munchlesia_LaunchAccel;
            add_vec2D_polar(&playerStatus->pos.x, &playerStatus->pos.z, Munchlesia_LateralVelocity, Munchlesia_LaunchYaw);
            gCameras[CAM_DEFAULT].targetPos.x = playerStatus->pos.x;
            gCameras[CAM_DEFAULT].targetPos.y = playerStatus->pos.y;
            gCameras[CAM_DEFAULT].targetPos.z = playerStatus->pos.z;
            if (Munchlesia_LaunchVelocity <= 0.0f) {
                playerStatus->actionSubstate++; // SUBSTATE_FALL
            }
            break;
        case SUBSTATE_FALL:
            playerStatus->pos.y += Munchlesia_LaunchVelocity;
            Munchlesia_LaunchVelocity -= Munchlesia_LaunchAccel;
            add_vec2D_polar(&playerStatus->pos.x, &playerStatus->pos.z, Munchlesia_LateralVelocity, Munchlesia_LaunchYaw);
            gCameras[CAM_DEFAULT].targetPos.x = playerStatus->pos.x;
            gCameras[CAM_DEFAULT].targetPos.y = playerStatus->pos.y;
            gCameras[CAM_DEFAULT].targetPos.z = playerStatus->pos.z;
            hitPosY = player_check_collision_below(Munchlesia_LaunchVelocity, &colliderID);
            if (colliderID > NO_COLLIDER) {
                sfx_play_sound_at_player(SOUND_TRIP, SOUND_SPACE_DEFAULT);
                suggest_player_anim_always_forward(ANIM_MarioW2_Collapse);
                playerStatus->pos.y = hitPosY;
                D_802B62E0 = 10;
                playerStatus->actionSubstate++; // SUBSTATE_CRASH
            }
            break;
        case SUBSTATE_CRASH:
            if (playerStatus->animNotifyValue != 0) {
                suggest_player_anim_always_forward(ANIM_Mario1_GetUp);
                playerStatus->actionSubstate = SUBSTATE_GET_UP;
                playerStatus->curStateTime = 15;
                break;
            }
            break;
        case SUBSTATE_GET_UP:
            if (playerStatus->curStateTime != 0) {
                playerStatus->curStateTime--;
                break;
            }
            enable_player_static_collisions();
            enable_player_input();
            set_action_state(ACTION_STATE_IDLE);
            gOverrideFlags &= ~GLOBAL_OVERRIDES_40;
            break;
    }
}

action_update_use_tweester()

void action_update_use_tweester

(

void

)

Definition at line 14 of file use_tweester.c.

                                      {
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 sinAngle, cosAngle, liftoffVelocity;
    Entity* entity;
 
    entity = TweesterTouchingPlayer;
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~PS_FLAG_ACTION_STATE_CHANGED;
        disable_player_static_collisions();
        disable_player_input();
        playerStatus->flags |= (PS_FLAG_ROTATION_LOCKED | PS_FLAG_FLYING);
        suggest_player_anim_allow_backward(ANIM_MarioW2_FlailArms);
        playerStatus->actionSubstate = SUBSTATE_LAUNCH;
        mem_clear(PlayerTweesterPhysicsPtr, sizeof(*PlayerTweesterPhysicsPtr));
        PlayerTweesterPhysicsPtr->radius = fabsf(dist2D(playerStatus->pos.x, playerStatus->pos.z, entity->pos.x, entity->pos.z));
        PlayerTweesterPhysicsPtr->angle = atan2(entity->pos.x, entity->pos.z, playerStatus->pos.x, playerStatus->pos.z);
        PlayerTweesterPhysicsPtr->angularVel = 6.0f;
        PlayerTweesterPhysicsPtr->liftoffVelPhase = 50.0f;
        PlayerTweesterPhysicsPtr->countdown = 120;
        sfx_play_sound_at_player(SOUND_TWEESTER_LAUNCH, SOUND_SPACE_DEFAULT);
    }
 
    switch (playerStatus->actionSubstate) {
        case SUBSTATE_LAUNCH:
            sin_cos_rad(DEG_TO_RAD(PlayerTweesterPhysicsPtr->angle), &sinAngle, &cosAngle);
 
            playerStatus->pos.x = entity->pos.x + (sinAngle * PlayerTweesterPhysicsPtr->radius);
            playerStatus->pos.z = entity->pos.z - (cosAngle * PlayerTweesterPhysicsPtr->radius);
 
            PlayerTweesterPhysicsPtr->angle = clamp_angle(PlayerTweesterPhysicsPtr->angle - PlayerTweesterPhysicsPtr->angularVel);
 
            if (PlayerTweesterPhysicsPtr->radius > 20.0f) {
                PlayerTweesterPhysicsPtr->radius--;
            } else if (PlayerTweesterPhysicsPtr->radius < 19.0f) {
                PlayerTweesterPhysicsPtr->radius++;
            }
 
            liftoffVelocity = sin_rad(DEG_TO_RAD(PlayerTweesterPhysicsPtr->liftoffVelPhase))  * 3.0f;
            PlayerTweesterPhysicsPtr->liftoffVelPhase += 3.0f;
            if (PlayerTweesterPhysicsPtr->liftoffVelPhase > 150.0f) {
                PlayerTweesterPhysicsPtr->liftoffVelPhase = 150.0f;
            }
 
            playerStatus->pos.y += liftoffVelocity;
            playerStatus->spriteFacingAngle = clamp_angle(360.0f - PlayerTweesterPhysicsPtr->angle);
            PlayerTweesterPhysicsPtr->angularVel += 0.6;
            if (PlayerTweesterPhysicsPtr->angularVel > 40.0f) {
                PlayerTweesterPhysicsPtr->angularVel = 40.0f;
            }
            if (--PlayerTweesterPhysicsPtr->countdown == 0) {
                playerStatus->actionSubstate++; // SUBSTATE_DONE
                entity_start_script(entity);
            }
            break;
        case SUBSTATE_DONE:
            disable_player_shadow();
            disable_npc_shadow(wPartnerNpc);
            playerStatus->blinkTimer = 50;
            enable_player_static_collisions();
            enable_player_input();
            playerStatus->flags &= ~(PS_FLAG_ROTATION_LOCKED | PS_FLAG_FLYING);
            set_action_state(ACTION_STATE_IDLE);
            break;
    }
}

action_update_state_23()

void action_update_state_23

(

void

)

Definition at line 32 of file misc.c.

                                  {
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 hitDirZ;
    f32 hitDirX;
    f32 hitRz;
    f32 hitRx;
    f32 outLength;
    f32 outZ;
    f32 outY;
    f32 outX;
    f32 cosTheta;
    f32 sinTheta;
    f32 miscTempVariable;
    f32 playerXOffset;
    f32 playerZOffset;
    f32 zDelta;
    f32 playerOffsetTempVar;
 
    if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
        playerStatus->flags &= ~(PS_FLAG_ACTION_STATE_CHANGED | PS_FLAG_ARMS_RAISED | PS_FLAG_AIRBORNE);
        playerStatus->actionSubstate = 0;
        playerStatus->curStateTime = 0;
        playerStatus->timeInAir = 0;
        playerStatus->peakJumpTime = 0;
        playerStatus->curSpeed = 0.0f;
        playerStatus->pitch = 0.0f;
        D_802B6770_E27C80 = PlayerNormalYaw;
    }
 
    switch (playerStatus->actionSubstate) {
        case 0:
            playerStatus->actionSubstate++;
        case 1:
            break;
        default:
            return;
    }
 
    sin_cos_rad(DEG_TO_RAD(PlayerNormalPitch), &sinTheta, &cosTheta);
 
    miscTempVariable = 3.0f;
    miscTempVariable = sinTheta * miscTempVariable;
 
    sin_cos_rad(DEG_TO_RAD(D_802B6770_E27C80), &sinTheta, &cosTheta);
 
    playerXOffset = sinTheta * miscTempVariable;
    playerZOffset = cosTheta * miscTempVariable;
 
    if (fabs(playerXOffset) < 0.1) {
        playerOffsetTempVar = 0.1f;
        if (playerXOffset < 0.0f) {
            playerOffsetTempVar = -0.1f;
        }
        playerXOffset = playerOffsetTempVar;
    }
 
    if (fabs(playerZOffset) < 0.1) {
        playerOffsetTempVar = 0.1f;
        if (playerZOffset < 0.0f) {
            playerOffsetTempVar = -0.1f;
        }
        playerZOffset = playerOffsetTempVar;
    }
 
    playerStatus->pos.x += playerXOffset;
    playerStatus->pos.z -= playerZOffset;
    outX = playerStatus->pos.x;
    outY = playerStatus->pos.y;
    outZ = playerStatus->pos.z;
    outLength = 5.0f;
    if (player_raycast_below_cam_relative(playerStatus, &outX, &outY, &outZ, &outLength, &hitRx, &hitRz, &hitDirX, &hitDirZ) >= 0) {
        playerStatus->pos.y = outY;
    }
 
    if (gGameStatusPtr->areaID == AREA_SBK) {
        miscTempVariable = 30.0f;
    } else {
        miscTempVariable = 60.0f;
    }
 
    if (PlayerNormalPitch < miscTempVariable) {
        set_action_state(ACTION_STATE_FALLING);
        gravity_use_fall_parms();
    }
}

Variable Documentation

PlayerActionsTable

Action PlayerActionsTable[]

Definition at line 77 of file actions.c.

                              {
    [ACTION_STATE_IDLE]                 { action_update_idle, ACTION_FILE(idle), TRUE },
    [ACTION_STATE_WALK]                 { action_update_walk, ACTION_FILE(walk), TRUE },
    [ACTION_STATE_RUN]                  { action_update_run, ACTION_FILE(walk), TRUE },
    [ACTION_STATE_JUMP]                 { action_update_jump, ACTION_FILE(jump), TRUE },
    [ACTION_STATE_BOUNCE]               { action_update_jump, ACTION_FILE(jump), TRUE },
    [ACTION_STATE_HOP]                  { action_update_jump, ACTION_FILE(jump), FALSE },
    [ACTION_STATE_LAUNCH]               { action_update_jump, ACTION_FILE(jump), FALSE },
    [ACTION_STATE_LANDING_ON_SWITCH]    { action_update_landing_on_switch, ACTION_FILE(jump), FALSE },
    [ACTION_STATE_FALLING]              { action_update_falling, ACTION_FILE(jump), TRUE },
    [ACTION_STATE_STEP_DOWN]            { action_update_step_down, ACTION_FILE(jump), TRUE },
    [ACTION_STATE_LAND]                 { action_update_land, ACTION_FILE(land), TRUE },
    [ACTION_STATE_STEP_DOWN_LAND]       { action_update_step_down_land, ACTION_FILE(land), TRUE },
    [ACTION_STATE_TALK]                 { action_update_talk, ACTION_FILE(misc), TRUE },
    [ACTION_STATE_SPIN_JUMP]            { action_update_spin_jump, ACTION_FILE(spin_jump), FALSE },
    [ACTION_STATE_SPIN_POUND]           { action_update_spin_jump, ACTION_FILE(spin_jump), FALSE },
    [ACTION_STATE_TORNADO_JUMP]         { action_update_tornado_jump, ACTION_FILE(tornado_jump), FALSE },
    [ACTION_STATE_TORNADO_POUND]        { action_update_tornado_jump, ACTION_FILE(tornado_jump), FALSE },
    [ACTION_STATE_SLIDING]              { action_update_sliding, ACTION_FILE(slide), FALSE },
    [ACTION_STATE_HAMMER]               { action_update_hammer, ACTION_FILE(hammer), FALSE },
    [ACTION_STATE_13]                   { action_update_launch, ACTION_FILE(misc), TRUE },
    [ACTION_STATE_PUSHING_BLOCK]        { action_update_pushing_block, ACTION_FILE(misc), FALSE },
    [ACTION_STATE_HIT_FIRE]             { action_update_hit_fire, ACTION_FILE(hit_fire), FALSE },
    [ACTION_STATE_KNOCKBACK]            { action_update_knockback, ACTION_FILE(knockback), FALSE },
    [ACTION_STATE_HIT_LAVA]             { action_update_hit_lava, ACTION_FILE(hit_lava), FALSE },
    [ACTION_STATE_STEP_UP_PEACH]        { action_update_step_up_peach, ACTION_FILE(step_up), TRUE },
    [ACTION_STATE_USE_SNEAKY_PARASOL]   { action_update_parasol, ACTION_FILE(sneaky_parasol), TRUE },
    [ACTION_STATE_SPIN]                 { action_update_spin, ACTION_FILE(spin), FALSE },
    [ACTION_STATE_ENEMY_FIRST_STRIKE]   { action_update_first_strike, ACTION_FILE(misc), FALSE },
    [ACTION_STATE_RAISE_ARMS]           { action_update_raise_arms, ACTION_FILE(misc), FALSE },
    [ACTION_STATE_USE_SPINNING_FLOWER]  { action_update_use_spinning_flower, ACTION_FILE(use_spinning_flower), FALSE },
    [ACTION_STATE_USE_MUNCHLESIA]       { action_update_use_munchlesia, ACTION_FILE(use_munchlesia), FALSE },
    [ACTION_STATE_USE_TWEESTER]         { action_update_use_tweester, ACTION_FILE(use_tweester), FALSE },
    [ACTION_STATE_BOUNCE_OFF_SWITCH]    { action_update_launch, ACTION_FILE(misc), TRUE },
    [ACTION_STATE_RIDE]                 { action_update_ride, ACTION_FILE(misc), FALSE },
    [ACTION_STATE_STEP_UP]              { action_update_step_up, ACTION_FILE(step_up), TRUE },
    [ACTION_STATE_23]                   { action_update_state_23, ACTION_FILE(misc), FALSE },
    [ACTION_STATE_24]                   { action_update_launch, ACTION_FILE(misc), FALSE },
    //@bug function does not exist in world_action_walk, causes jump to middle of action_update_run and crashes
    [ACTION_STATE_INVALID_25]           { action_update_launch, ACTION_FILE(walk), FALSE },
    [ACTION_STATE_USE_SPRING]           { action_update_launch, ACTION_FILE(misc), TRUE },
};

Referenced by phys_peach_update(), and phys_update_action_state().