Implement being able to drop through soft platforms

src/fighter/state/crouch.rs

@@ -1,25 +1,30 @@
 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::fighter::state::ground::{grounded_movement_common_interrupts, grounded_movement_standstill_common_interrupts};
+use crate::input::FighterCommands;
+use crate::stage::line::StagePolyType;
 
 #[derive(Debug, Clone, Hash)]
 pub enum CrouchSubState {
-    Entering,
+    Entering { pass_queued: bool },
     Idle,
-    Exiting
+    Exiting,
 }
 
 #[derive(Debug, Clone, Hash)]
 pub struct CrouchState {
-    sub_state: CrouchSubState
+    sub_state: CrouchSubState,
 }
 
-pub fn crouch_idle_interrupts(
-    state_context: &InterruptContext,
-) -> Option<FighterState> {
+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) {
@@ -33,9 +38,7 @@ pub fn crouch_idle_interrupts(
     }
 }
 
-pub fn crouch_entering_interrupts(
-    state_context: &InterruptContext,
-) -> Option<FighterState> {
+pub fn crouch_entering_interrupts(state_context: &InterruptContext) -> Option<FighterState> {
     if let Some(state) = ground_attack::check_interrupt(state_context) {
         Some(state)
     } else {
@@ -51,54 +54,85 @@ impl FighterStateImpl for CrouchState {
         }
 
         match self.sub_state {
-            CrouchSubState::Entering => {
+            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,
-                        }
-                    ));
+                    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,
-                        }
-                    ));
+                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 => {
+            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);
     }
 
@@ -119,7 +153,7 @@ pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
 
     if input_frame.movement.y <= -state_context.game_settings.input_common.run_stick_threshold {
         return Some(FighterState::Crouch(CrouchState {
-            sub_state: CrouchSubState::Entering
+            sub_state: CrouchSubState::Entering { pass_queued: false },
         }));
     }
     None