Initial work on ledge & improved baking of root motion. (#90)

Reviewed-on: #90
Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>

src/fighter/state/ledge_wait.rs

@@ -0,0 +1,130 @@
+use super::{CollisionContext, EnterContext, FighterStateImpl, InterruptContext, UpdateContext};
+use crate::fighter::animation::AnimKind;
+use crate::fighter::state::air::AirborneStateCommon;
+use crate::fighter::state::fall::FallState;
+use crate::fighter::state::FighterState;
+use crate::fighter::FighterFacingDirection;
+use crate::fighter::state::jump::JumpStateInitiator;
+use crate::fighter::state::ledge_action::{LedgeActionState};
+use crate::input::FighterCommands;
+use crate::math::vec::FGVec2;
+use crate::stage::line::{StageLedgeSide, StageVertexID};
+
+#[derive(Debug, Clone, Hash)]
+pub struct LedgeWaitState {
+    pub airborne_state_common: AirborneStateCommon,
+    pub ledge_id: StageVertexID,
+}
+
+impl FighterStateImpl for LedgeWaitState {
+    const NAME: &'static str = "LedgeWait";
+    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
+        if state_context.input.has_command(FighterCommands::Jump) {
+            return Some(FighterState::LedgeAction(LedgeActionState::create_jump(self.ledge_id, JumpStateInitiator::Button)));
+        } else if state_context.input.has_command(FighterCommands::TapJump) {
+            return Some(FighterState::LedgeAction(LedgeActionState::create_jump(self.ledge_id, JumpStateInitiator::Tap)));
+        }
+        if is_ledge_drop_input(state_context.input.get_last_frame().movement.x,
+            state_context.game_settings.input_common.run_stick_threshold,
+            state_context.facing_direction) {
+            state_context.ledge_grab_lockout.start(
+                state_context
+                    .game_settings
+                    .fighter_common
+                    .ledge_drop_regrab_lockout_duration_frames,
+            );
+            return Some(FighterState::Fall(FallState::new(
+                AirborneStateCommon { is_fast_falling: false },
+            )));
+        }
+        if is_ledge_drop_fastfall_input(
+            state_context.input.get_last_frame().movement.y,
+            state_context.game_settings.input_common.run_stick_threshold,
+        ) {
+            state_context.ledge_grab_lockout.start(
+                state_context
+                    .game_settings
+                    .fighter_common
+                    .ledge_drop_regrab_lockout_duration_frames,
+            );
+            return Some(FighterState::Fall(FallState::new(
+                AirborneStateCommon { is_fast_falling: true },
+            )));
+        }
+
+        None
+    }
+
+    fn on_enter(&mut self, state_context: &mut EnterContext) {
+        state_context.velocity.0 = FGVec2::ZERO;
+        state_context.knockback_velocity.0 = FGVec2::ZERO;
+        let Some(ledge) = state_context.stage_collision.find_ledge_by_vertex(self.ledge_id) else {
+            return;
+        };
+        state_context.translation.0 = ledge.position;
+        *state_context.facing_direction = match ledge.hang_side {
+            StageLedgeSide::Left => FighterFacingDirection::Right,
+            StageLedgeSide::Right => FighterFacingDirection::Left,
+        };
+        state_context.play_animation(AnimKind::LedgeWait, true);
+        if let Some(root_position) = state_context.initial_animation_root_position() {
+            state_context.translation.0 = root_position;
+        }
+        state_context.presentation_snap.0 = true;
+    }
+
+    fn update(&mut self, state_context: &mut UpdateContext) {
+        if let Some(root_position) = state_context.animation_root_position {
+            state_context.translation.0 = root_position;
+        }
+    }
+
+    fn check_collision_interrupt(
+        &mut self,
+        _state_context: &mut CollisionContext,
+    ) -> Option<FighterState> {
+        None
+    }
+
+    fn is_visually_grounded<'a>(&'a self) -> bool {
+        false
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::math::int::FGi32;
+
+    #[test]
+    fn ledge_drop_uses_the_run_stick_threshold() {
+        let threshold = FGi32::lit("0.625");
+
+        assert!(is_ledge_drop_fastfall_input(FGi32::lit("-0.625"), threshold));
+        assert!(is_ledge_drop_fastfall_input(FGi32::lit("-1.0"), threshold));
+        assert!(!is_ledge_drop_fastfall_input(FGi32::lit("-0.624"), threshold));
+    }
+}
+
+fn is_ledge_drop_fastfall_input(
+    vertical_input: crate::math::int::FGi32,
+    threshold: crate::math::int::FGi32,
+) -> bool {
+    vertical_input <= -threshold
+}
+
+fn is_ledge_drop_input(
+    horizontal_input: crate::math::int::FGi32,
+    threshold: crate::math::int::FGi32,
+    facing_dir: &FighterFacingDirection,
+) -> bool {
+    let dir = facing_dir.to_sign();
+    if horizontal_input.abs() > threshold {
+        if dir != horizontal_input.signum() {
+            return true;
+        }
+    }
+
+    false
+}
+