shinespark/src/fighter/state/crouch.rs

use super::{
    CollisionContext, EnterContext, FighterStateImpl, InterruptContext, UpdateContext, ground,
};
use crate::fighter::FighterSurfaceState;
use crate::fighter::animation::AnimKind;
use crate::fighter::state::air::AirborneStateCommon;
use crate::fighter::state::ground::{
    grounded_movement_common_interrupts, grounded_movement_standstill_common_interrupts,
};
use crate::fighter::state::platform_pass::PlatformPassState;
use crate::fighter::state::{FighterState, dash, ground_attack, turn, walk};
use crate::input::FighterCommands;
use crate::stage::line::StagePolyType;

#[derive(Debug, Clone, Hash)]
pub enum CrouchSubState {
    Entering { pass_queued: bool },
    Idle,
    Exiting,
}

#[derive(Debug, Clone, Hash)]
pub struct CrouchState {
    sub_state: CrouchSubState,
}

pub fn crouch_idle_interrupts(state_context: &InterruptContext) -> Option<FighterState> {
    if let Some(state) = ground_attack::check_interrupt(state_context) {
        Some(state)
    } else if let Some(state) = dash::check_input(state_context) {
        Some(state)
    } else if let Some(state) = turn::check_input(state_context) {
        Some(state)
    } else if let Some(state) = walk::check_input(state_context) {
        Some(state)
    } else {
        None
    }
}

pub fn crouch_entering_interrupts(state_context: &InterruptContext) -> Option<FighterState> {
    if let Some(state) = ground_attack::check_interrupt(state_context) {
        Some(state)
    } else {
        None
    }
}

impl FighterStateImpl for CrouchState {
    const NAME: &'static str = "Crouch";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        if let Some(state) = grounded_movement_common_interrupts(state_context) {
            return Some(state);
        }

        match self.sub_state {
            CrouchSubState::Entering { pass_queued } => {
                // pass
                if let FighterSurfaceState::Grounded { line_id } = state_context.surface {
                    if let Some(stage_poly) = state_context
                        .stage_collision
                        .stage_polys
                        .get(line_id.polygon)
                    {
                        let is_inputting_crouch = -state_context.game_settings.input_common.run_stick_threshold > state_context.input.get_last_frame().movement.y;
                        let is_on_a_soft_platform = matches!(stage_poly.poly_type, StagePolyType::Platform);
                        if pass_queued && is_inputting_crouch && is_on_a_soft_platform 
                        {
                            return Some(FighterState::PlatformPass(PlatformPassState::new(
                                AirborneStateCommon::default(),
                                line_id.polygon,
                            )));
                        }
                    }
                }

                // While entering the crouch animation we do not allow movement inputs, but we do allow attacks and jumps
                if state_context.is_current_animation_finished() {
                    return Some(FighterState::Crouch(CrouchState {
                        sub_state: CrouchSubState::Idle,
                    }));
                } else {
                    return crouch_entering_interrupts(state_context);
                }
            }
            CrouchSubState::Idle => {
                if state_context.input.get_last_frame().movement.y
                    > -state_context.game_settings.input_common.run_stick_threshold
                {
                    return Some(FighterState::Crouch(CrouchState {
                        sub_state: CrouchSubState::Exiting,
                    }));
                } else {
                    return crouch_idle_interrupts(state_context);
                }
            }
            CrouchSubState::Exiting => {
                if state_context.is_current_animation_finished() {
                    return grounded_movement_standstill_common_interrupts(state_context);
                } else {
                    return crouch_idle_interrupts(state_context);
                }
            }
        }
    }

    fn on_enter(&mut self, state_context: &mut EnterContext) {
        match self.sub_state {
            CrouchSubState::Entering { .. } => {
                state_context.play_animation(AnimKind::CrouchEnter, false);
            }
            CrouchSubState::Idle => {
                state_context.play_animation(AnimKind::CrouchIdle, true);
            }
            CrouchSubState::Exiting => {
                state_context.play_animation(AnimKind::CrouchExit, false);
            }
        }
    }

    fn update(&mut self, state_context: &mut UpdateContext) {
        if let CrouchSubState::Entering {
            ref mut pass_queued,
        } = self.sub_state
        {
            if state_context
                .input
                .has_command(FighterCommands::SmashMoveDown)
            {
                state_context
                    .input
                    .clear_command(FighterCommands::SmashMoveDown);
                *pass_queued = true;
            }
        }
        ground::update_friction_motion(state_context);
    }

    fn check_collision_interrupt(
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
        ground::collision_interrupt(state_context, false)
    }

    fn is_visually_grounded<'a>(&'a self) -> bool {
        true
    }
}

pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
    let input_frame = state_context.input.get_last_frame();

    if input_frame.movement.y <= -state_context.game_settings.input_common.run_stick_threshold {
        return Some(FighterState::Crouch(CrouchState {
            sub_state: CrouchSubState::Entering { pass_queued: false },
        }));
    }
    None
}