Refresh documentation and add test script

Cargo.lock

@@ -3468,9 +3468,9 @@ dependencies = [
 
 [[package]]
 name = "gc-adapter-neo"
-version = "1.1.0"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "120a5b3858ae854c4674ae41a38173e8ea04b814fb3212fd3bdd1b04d414a9d7"
+checksum = "bd350c081bf33e501e9a5a11732294dfe266683d6b58a366b097146f3e633cb5"
 dependencies = [
  "binread",
  "modular-bitfield",

Cargo.toml

@@ -30,7 +30,7 @@ strum = "0.28.0"
 strum_macros = "0.28.0"
 bevy_asset_loader = "0.27.0"
 ron_asset_manager = "0.9.0"
-gc-adapter-neo = { version = "1.1.0", features = ["libusb"] }
+gc-adapter-neo = { version = "1.0.0", features = ["libusb"] }
 rhai = "1.26.0"
 enum_cycling = "0.2.1"
 enum_cycling_derive = "0.2.1"

assets/fighters/test/test.fighter.ron

@@ -22,8 +22,7 @@
         air_jump_horizontal_velocity: "0.96",
         air_jump_multiplier: "1.0",
         dash_initial_velocity: "1.4",
-        terminal_velocity: "3.0",
-        fast_fall_speed: "3.5",
+        terminal_velocity: "1.6",
         gravity: "0.084",
         weight: "100.0",
         jumpsquat_duration: 5,

assets/game_settings.ron

@@ -17,15 +17,7 @@
         knockback_decay_per_frame: "0.051",
         knockback_launch_velocity_multiplier: "0.03",
         hitstun_frames_per_unit_knockback: "0.4",
-        tumble_bounce_hitstop_threshold: 32,
-        attack_ground_to_airborne_transition_vertical_angle_threshold: "90.0",
-        meteor_angle_threshold: "10.0",
-        visual_shake_frames_per_hitstop_frame: "1.2",
-        visual_shake_table: [
-            -3.0, -1.5, 1.5, 3.0
-        ],
-        attacker_visual_shake_multiplier: 0.4,
-        di_max_angle: "18.0"
+
     ),
     stage_manifest_paths: [
         "stages/battlefield/test.stage.ron"

src/debug_tools/save_state.rs

@@ -1,12 +1,22 @@
 use bevy::prelude::*;
 
 use crate::{
-    camera::MatchCamera, fighter::{
-        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterPreviousFacingDirection, FighterPreviousTranslation, FighterTranslation, FighterVelocity, Grounded, animation::FighterAnimationFrame, attack::{
+    camera::MatchCamera,
+    fighter::{
+        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop,
+        FighterPreviousFacingDirection, FighterPreviousTranslation, FighterTranslation,
+        FighterVelocity, Grounded,
+        animation::FighterAnimationFrame,
+        attack::{
             FighterDamage, FighterKnockbackVelocity, FighterPendingHitReaction, FighterPendingHits,
             FighterSolvedHurtboxes, FighterStaleMoveQueue,
-        }, baked_animation::FighterBoneMatrices, state::FighterState,
-    }, input::FighterInput, player::Player, stage::line::StageCollision,
+        },
+        baked_animation::FighterBoneMatrices,
+        state::FighterState,
+    },
+    input::FighterInput,
+    player::Player,
+    stage::line::StageCollision,
 };
 
 #[derive(Resource, Default)]
@@ -38,7 +48,6 @@ struct FighterCheckpoint {
     damage: FighterDamage,
     pending_hit_reaction: FighterPendingHitReaction,
     hitstop: FighterHitstop,
-    hitstop_shake: FighterHitstopShake,
     knockback_velocity: FighterKnockbackVelocity,
     stale_moves: FighterStaleMoveQueue,
     hitboxes: FighterHitboxes,
@@ -137,7 +146,6 @@ pub(super) fn save_or_restore(world: &mut World) {
         entity.insert(saved.damage);
         entity.insert(saved.pending_hit_reaction.clone());
         entity.insert(saved.hitstop);
-        entity.insert(saved.hitstop_shake);
         entity.insert(saved.knockback_velocity);
         entity.insert(saved.stale_moves.clone());
         entity.insert(saved.hitboxes.clone());
@@ -175,7 +183,6 @@ fn capture_fighter(world: &World, entity: Entity) -> Option<FighterCheckpoint> {
         damage: *fighter.get::<FighterDamage>()?,
         pending_hit_reaction: fighter.get::<FighterPendingHitReaction>()?.clone(),
         hitstop: *fighter.get::<FighterHitstop>()?,
-        hitstop_shake: *fighter.get::<FighterHitstopShake>()?,
         knockback_velocity: *fighter.get::<FighterKnockbackVelocity>()?,
         stale_moves: fighter.get::<FighterStaleMoveQueue>()?.clone(),
         hitboxes: fighter.get::<FighterHitboxes>()?.clone(),

src/fighter/attack/directional_influence.rs

@@ -1,69 +0,0 @@
-use fixed::traits::ToFixed;
-use fixed_math::SinCos;
-
-use crate::math::{
-    int::{FGWide, FGi32},
-    vec::FGVec2,
-};
-
-/// Applies DI to a given attack direction
-pub fn apply_directional_influence(
-    receiver_stick: FGVec2,
-    attack_angle: FGi32,
-    di_max_angle: FGi32,
-) -> FGVec2 {
-    let (sin, cos) = attack_angle.sin_cos();
-    let base_launch_direction = FGVec2::new(cos, sin);
-
-    let Some(base_launch_direction) = base_launch_direction.normalize() else {
-        return FGVec2::ZERO;
-    };
-
-    if receiver_stick.length_squared().is_zero() {
-        return base_launch_direction;
-    }
-
-    let normal = FGVec2::new(-base_launch_direction.y, base_launch_direction.x);
-    let di_amount = receiver_stick.dot(normal);
-    let angle_change = di_amount * di_max_angle.to_fixed::<FGWide>();
-    let angle_change = angle_change.clamp(
-        -di_max_angle.to_fixed::<FGWide>(),
-        di_max_angle.to_fixed::<FGWide>(),
-    );
-    let (sin, cos) = (attack_angle + angle_change.to_fixed::<FGi32>()).sin_cos();
-    FGVec2::new(cos, sin).normalize_or_zero()
-}
-
-#[cfg(test)]
-mod test {
-    use crate::{
-        fighter::attack::directional_influence::apply_directional_influence,
-        math::{int::FGi32, vec::FGVec2},
-    };
-
-    #[test]
-    fn di_zero_passes_unmodified() {
-        let di = apply_directional_influence(FGVec2::ZERO, FGi32::lit("0.0"), FGi32::lit("18.0"));
-        const EPSILON: FGi32 = FGi32::from_bits(4);
-        assert!(di.x.abs_diff(FGi32::ONE) < EPSILON);
-        assert!(di.y.abs_diff(FGi32::ZERO) < EPSILON);
-    }
-
-    #[test]
-    fn di_applies_on_the_correct_side() {
-        let di = apply_directional_influence(
-            FGVec2::lit("0.0", "1.0"),
-            FGi32::lit("0.0"),
-            FGi32::lit("18.0"),
-        );
-        assert!(di.x > FGi32::ZERO);
-        assert!(di.y > FGi32::ZERO);
-        let di = apply_directional_influence(
-            FGVec2::lit("0.0", "-1.0"),
-            FGi32::lit("0.0"),
-            FGi32::lit("18.0"),
-        );
-        assert!(di.x > FGi32::ZERO);
-        assert!(di.y < FGi32::ZERO);
-    }
-}

src/fighter/attack/mod.rs

@@ -1,7 +1,6 @@
 use std::collections::{HashMap, VecDeque};
 
 mod reaction;
-pub mod directional_influence;
 
 use bevy::ecs::entity::{EntityMapper, MapEntities};
 use bevy::prelude::*;
@@ -43,8 +42,7 @@ pub enum HitReactionKind {
 
 #[derive(Debug, Hash, Clone)]
 pub struct FighterHitReaction {
-    pub launch_velocity: FGi32,
-    pub launch_angle: FGi32,
+    pub launch_velocity: FGVec2,
     pub hitstop_frames: HitStop,
     pub hitstun_frames: u32,
     pub kind: HitReactionKind,
@@ -64,13 +62,10 @@ pub struct FighterLastAttackDebug {
     pub trajectory_points: Vec<Vec3>,
 }
 
-#[derive(Debug, Default, Clone, Deref, DerefMut, Hash, PartialEq, PartialOrd)]
+#[derive(Debug, Default, Clone, Deref, DerefMut, Hash)]
 pub struct HitStop(u32);
 
 impl HitStop {
-    pub fn new(hitstop: u32) -> Self {
-        HitStop(hitstop)
-    }
     pub fn calculate(attack_damage_stalled: FighterDamage, crouch_cancelling: bool) -> Self {
         let a = (attack_damage_stalled.0 / FGi32::lit("3.0") + FGi32::lit("4.0")).round_to_zero();
         let crouch_cancelling_factor = if crouch_cancelling {
@@ -83,10 +78,6 @@ impl HitStop {
 
         Self(frames)
     }
-
-    pub fn calculate_shake_frames(&self, game_settings: &GameSettings) -> u32 {
-        (FGi32::from_num(self.0) * game_settings.fighter_common.visual_shake_frames_per_hitstop_frame).floor().to_num()
-    }
 }
 
 #[derive(Clone, Copy, Debug, Serialize, Deserialize)]

src/fighter/attack/reaction.rs

@@ -1,11 +1,19 @@
 use bevy::prelude::*;
 use bevy_ggrs::prelude::GgrsSchedule;
+use fixed_math::SinCos;
 
 use super::*;
 use crate::{
     fighter::{
-        Fighter, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole, FighterPendingHitReaction, FighterStaleMoveQueue, errors::FighterErrors, manifest::FighterManifest, state::FighterState,
-    }, game_settings::GameSettings, math::{int::FGi32}, player::Player, schedule::GameplaySet, scripting::FighterAttackScript,
+        Fighter, FighterFacingDirection, FighterHitboxes, FighterHitstop,
+        FighterPendingHitReaction, FighterStaleMoveQueue, errors::FighterErrors,
+        manifest::FighterManifest,
+    },
+    game_settings::GameSettings,
+    math::{int::FGi32, vec::FGVec2},
+    player::Player,
+    schedule::GameplaySet,
+    scripting::FighterAttackScript,
 };
 
 pub fn resolve_fighter_hits(
@@ -16,9 +24,8 @@ pub fn resolve_fighter_hits(
         &FighterHitboxes,
         &Player,
         &mut FighterHitstop,
-        &mut FighterHitstopShake,
     )>,
-    mut receiver: Query<(&mut FighterDamage, &Fighter, &mut FighterPendingHitReaction, &FighterState)>,
+    mut receiver: Query<(&mut FighterDamage, &Fighter, &mut FighterPendingHitReaction)>,
     attack_scripts: Res<Assets<FighterAttackScript>>,
     game_settings: Res<GameSettings>,
     fighter_manifests: Res<Assets<FighterManifest>>,
@@ -33,7 +40,7 @@ pub fn resolve_fighter_hits(
             .position(|hit| hit.defender != defender)
             .map_or(hits.len(), |offset| hit_offset + offset);
 
-        let Ok((mut receiver_damage, fighter, mut pending_reaction, receiver_state)) = receiver.get_mut(defender)
+        let Ok((mut receiver_damage, fighter, mut pending_reaction)) = receiver.get_mut(defender)
         else {
             hit_offset = next_defender;
             continue;
@@ -42,7 +49,7 @@ pub fn resolve_fighter_hits(
         let damage_data = hits[hit_offset..next_defender]
             .iter()
             .filter_map(|hit| {
-                let Ok((stale_move_queue, facing_dir, _hitboxes, player, _, _)) =
+                let Ok((stale_move_queue, facing_dir, _hitboxes, player, _)) =
                     attacker.get(hit.attacker)
                 else {
                     return None;
@@ -89,14 +96,14 @@ pub fn resolve_fighter_hits(
             } else {
                 angle
             };
-
+            let (sin, cos) = launch_angle.sin_cos();
+            let launch_direction = FGVec2::new(cos, sin);
             let hitstop = HitStop::calculate(FighterDamage(attack_damage), false);
             reactions.push((
                 attacker_entity,
                 attacker_slot,
                 FighterHitReaction {
-                    launch_velocity: knockback.get_launch_speed(&game_settings),
-                    launch_angle,
+                    launch_velocity: launch_direction * knockback.get_launch_speed(&game_settings),
                     hitstun_frames: knockback.get_hitstun_frames(&game_settings),
                     hitstop_frames: hitstop,
                     kind: HitReactionKind::Flinch,
@@ -107,23 +114,10 @@ pub fn resolve_fighter_hits(
         receiver_damage.0 += total_damage_received_this_frame;
 
         for (attacker_entity, _, reaction) in &reactions {
-            let Ok((.., mut hitstop, mut hitstop_shake)) = attacker.get_mut(*attacker_entity) else {
+            let Ok((.., mut hitstop)) = attacker.get_mut(*attacker_entity) else {
                 continue;
             };
-
-            if hitstop.remaining_frames < reaction.hitstop_frames.0 {
-                let shake_kind = if receiver_state.is_visually_grounded() {
-                    FighterHitstopShakeKind::Horizontal
-                } else {
-                    FighterHitstopShakeKind::Vertical
-                };
-                hitstop.remaining_frames = reaction.hitstop_frames.0;
-                let shake_frames = reaction.hitstop_frames.calculate_shake_frames(&game_settings);
-                hitstop_shake.total_frames = shake_frames;
-                hitstop_shake.remaining_frames = shake_frames;
-                hitstop_shake.kind = shake_kind;
-                hitstop_shake.role = FighterHitstopShakeRole::Attacker;
-            }
+            hitstop.remaining_frames = reaction.hitstop_frames.max(hitstop.remaining_frames);
         }
 
         pending_reaction.0 = reactions

src/fighter/attributes.rs

@@ -37,7 +37,6 @@ pub struct FighterAttributes {
     pub ground_friction: FGi32,
     pub terminal_velocity: FGi32,
     pub gravity: FGi32,
-    pub fast_fall_speed: FGi32,
     pub weight: FGi32,
     pub air_friction: FGi32,
 

src/fighter/debug.rs

@@ -9,7 +9,7 @@ use bevy_egui::{EguiContexts, egui};
 use crate::debug_tools::{DebugSettings, FighterDebugRowKind};
 use crate::fighter::animation::FighterAnimationFrame;
 use crate::fighter::attack::{
-    self, FighterKnockbackVelocity, FighterLastAttackDebug, FighterPendingHitReaction,
+    FighterKnockbackVelocity, FighterLastAttackDebug, FighterPendingHitReaction,
     FighterSolvedHurtboxes,
 };
 use crate::fighter::baked_animation::{BakedFighterAnimations, FighterBoneMatrices};
@@ -382,14 +382,14 @@ pub fn attack_debug_gather(
         &FighterPendingHitReaction,
         &FighterTranslation,
         &Fighter,
-        &FighterInput,
     )>,
     mut commands: Commands,
     manifests: Res<Assets<FighterManifest>>,
     game_settings: Res<GameSettings>,
 ) -> Result {
-    for (entity, reaction, translation, fighter, input) in query {
+    for (entity, reaction, translation, fighter) in query {
         let Some(ref hit) = reaction.0 else {
+            commands.entity(entity).remove::<FighterLastAttackDebug>();
             continue;
         };
 
@@ -397,13 +397,7 @@ pub fn attack_debug_gather(
             .get(&fighter.manifest)
             .ok_or(FighterErrors::FighterManifestNotFound)?;
 
-        let launch_dir = attack::directional_influence::apply_directional_influence(
-            input.get_last_frame().movement,
-            hit.launch_angle,
-            game_settings.fighter_common.di_max_angle,
-        );
-
-        let mut knockback_vel = FighterKnockbackVelocity(launch_dir * hit.launch_velocity);
+        let mut knockback_vel = FighterKnockbackVelocity(hit.launch_velocity);
         let mut fighter_vel = FighterVelocity(FGVec2::ZERO);
         let mut translation = Vec3::new(translation.x.to_num(), translation.y.to_num(), 0.0);
 
@@ -412,7 +406,7 @@ pub fn attack_debug_gather(
         points.reserve(hit.hitstun_frames as usize);
 
         for _ in 1..hit.hitstun_frames {
-            air::integrate_gravity(&mut fighter_vel, &manifest.attributes, false);
+            air::integrate_gravity(&mut fighter_vel, &manifest.attributes);
 
             let vel = knockback_vel.length();
             let new_vel = vel

src/fighter/mod.rs

@@ -33,13 +33,24 @@ pub use motion::{
 };
 
 use crate::{
-    AppState, fighter::{
+    AppState,
+    fighter::{
         attack::{
             AttackKind, FighterAttackPlugin, FighterAttackScriptAssets, FighterDamage,
             FighterKnockbackVelocity, FighterPendingHitReaction, FighterSolvedHurtboxes,
             FighterStaleMoveQueue,
-        }, baked_animation::{FighterBoneIndexMap, FighterBoneMatrices}, manifest::FighterManifest, state::{FighterState, air::AirborneStateCommon, fall::FallState}, visual::FighterAnimations,
-    }, input::FighterInput, math::{int::FGi32, vec::FGVec2}, player::Player, schedule::GameplaySet, scripting::FighterAttackScript, stage::line::StageCollision,
+        },
+        baked_animation::{FighterBoneIndexMap, FighterBoneMatrices},
+        manifest::FighterManifest,
+        state::{FighterState, fall::FallState},
+        visual::FighterAnimations,
+    },
+    input::FighterInput,
+    math::{int::FGi32, vec::FGVec2},
+    player::Player,
+    schedule::GameplaySet,
+    scripting::FighterAttackScript,
+    stage::line::StageCollision,
 };
 use state::state_interrupt_system;
 
@@ -54,30 +65,7 @@ pub enum FighterFacingDirection {
     Right,
 }
 
-#[derive(Component, Copy, Clone, Hash, Debug, PartialEq, Reflect, Default)]
-pub enum FighterHitstopShakeKind {
-    #[default]
-    Horizontal,
-    Vertical
-}
-
-#[derive(Component, Copy, Clone, Hash, Debug, PartialEq, Reflect, Default)]
-pub enum FighterHitstopShakeRole {
-    #[default]
-    Attacker,
-    Receiver
-}
-
 #[derive(Component, Default, Copy, Clone, Hash)]
-pub struct FighterHitstopShake {
-    pub remaining_frames: u32,
-    pub total_frames: u32,
-    pub kind: FighterHitstopShakeKind,
-    pub role: FighterHitstopShakeRole
-}
-
-#[derive(Component, Default, Copy, Clone, Hash)]
-#[require(FighterHitstopShake)]
 pub struct FighterHitstop {
     pub remaining_frames: u32,
 }
@@ -132,8 +120,7 @@ pub struct FighterVisual;
     FighterDamage,
     FighterPendingHitReaction,
     FighterHitstop,
-    FighterKnockbackVelocity,
-    FighterTranslation,
+    FighterKnockbackVelocity
 )]
 pub struct Fighter {
     pub manifest: Handle<FighterManifest>,
@@ -243,7 +230,6 @@ impl Plugin for FighterPlugin {
             .rollback_component_with_clone::<FighterState>()
             .rollback_component_with_clone::<FighterHitboxes>()
             .rollback_component_with_clone::<FighterBoneMatrices>()
-            .rollback_component_with_clone::<FighterHitstopShake>()
             .checksum_component_with_hash::<FighterHitboxes>()
             .rollback_component_with_clone::<FighterSolvedHurtboxes>()
             .checksum_component_with_hash::<FighterSolvedHurtboxes>()
@@ -299,7 +285,7 @@ pub fn spawn_fighter(
             visual_root,
             animations,
             attack_scripts,
-            FighterState::Fall(FallState::new(AirborneStateCommon::default())),
+            FighterState::Fall(FallState),
             animation::FighterAnimationFrame::new(animation::AnimKind::Wait, true),
             (
                 baked_animation::FighterBoneMatrices::default(),
@@ -313,9 +299,8 @@ pub fn spawn_fighter(
         .id()
 }
 
-pub fn decay_hitstop(query: Query<(&mut FighterHitstop, &mut FighterHitstopShake)>) {
-    for (mut hitstop, mut hitstop_shake) in query {
+pub fn decay_hitstop(query: Query<&mut FighterHitstop>) {
+    for mut hitstop in query {
         hitstop.remaining_frames = hitstop.remaining_frames.saturating_sub(1);
-        hitstop_shake.remaining_frames = hitstop_shake.remaining_frames.saturating_sub(1);
     }
 }

src/fighter/motion.rs

@@ -5,8 +5,6 @@ use bevy::prelude::*;
 use bevy_ggrs::GgrsFrameTiming;
 
 use crate::debug_tools::PresentationMotionMode;
-use crate::fighter::{FighterHitstopShake};
-use crate::game_settings::GameSettings;
 use crate::{
     fighter::{FighterECB, FighterFacingDirection, baked_animation::FixedMat4},
     math::{int::FGi32, vec::FGVec2, vec3::FGVec3},
@@ -60,15 +58,13 @@ pub fn apply_fighter_translation_to_visuals(
         &FighterTranslation,
         &FighterPreviousTranslation,
         &FighterECB,
-        &FighterHitstopShake,
         &mut Transform,
     )>,
     timing: Res<GgrsFrameTiming>,
     debug_settings: Res<crate::debug_tools::DebugSettings>,
-    game_settings: Res<GameSettings>,
 ) {
     let overstep_fraction = timing.overstep_fraction();
-    for (translation, previous_translation, ecb, hitstop_shake, mut transform) in query {
+    for (translation, previous_translation, ecb, mut transform) in query {
         let translation = sample_presentation_translation(
             *previous_translation,
             *translation,
@@ -81,28 +77,6 @@ pub fn apply_fighter_translation_to_visuals(
             translation.y + bottom.y.to_num::<f32>(),
             0.0,
         );
-
-        if hitstop_shake.remaining_frames > 0 && hitstop_shake.total_frames > 0 && !game_settings.fighter_common.visual_shake_table.is_empty() {
-            let total = hitstop_shake.total_frames as f32;
-            let curr = hitstop_shake.remaining_frames as f32;
-            let elapsed = 1.0 - curr / total;
-
-            
-            let access_index = (hitstop_shake.remaining_frames as usize) % game_settings.fighter_common.visual_shake_table.len();
-            let shake_multiplier = match hitstop_shake.role {
-                super::FighterHitstopShakeRole::Attacker => game_settings.fighter_common.attacker_visual_shake_multiplier,
-                super::FighterHitstopShakeRole::Receiver => 1.0,
-            };
-            let shake_amount: f32 = 1.0 - EaseFunction::QuinticIn.sample(elapsed).unwrap_or_default();
-            let shake_amount = game_settings.fighter_common.visual_shake_table[access_index] * shake_amount * shake_multiplier;
-
-            let shake_offset = match hitstop_shake.kind {
-                super::FighterHitstopShakeKind::Horizontal => Vec3::new(shake_amount, 0.0, 0.0),
-                super::FighterHitstopShakeKind::Vertical => Vec3::new(0.0, shake_amount, 0.0),
-            };
-
-            transform.translation += shake_offset;
-        }
     }
 }
 
@@ -111,15 +85,22 @@ pub fn apply_air_motion(
         &FighterVelocity,
         &mut FighterTranslation,
         &mut FighterPreviousTranslation,
+        &mut Transform,
     )>,
     _time: Res<Time<Fixed>>,
 ) {
-    for (velocity, mut translation, mut prev_translation) in fighters {
+    for (velocity, mut translation, mut prev_translation, _transform) in fighters {
         prev_translation.0 = translation.0;
         translation.0 += velocity.0;
     }
 }
 
+pub fn copy_fighter_transform_to_visuals(fighters: Query<(&FighterTranslation, &mut Transform)>) {
+    for (translation, mut transform) in fighters {
+        transform.translation = Vec3::new(translation.x.to_num(), translation.y.to_num(), 0.0);
+    }
+}
+
 pub fn fighter_movement() {}
 
 pub fn snapshot_fighter_motion(

src/fighter/state/air.rs

@@ -2,44 +2,10 @@ use crate::fighter::state::ground::GroundedStateCommon;
 use crate::fighter::state::land::{LandingState, LandingType};
 use crate::fighter::state::{CollisionContext, FighterState};
 use crate::fighter::*;
-use crate::input::FighterCommands;
 
-#[derive(Default, Debug, Clone, Copy, Hash)]
-pub struct AirborneStateCommon {
-    pub is_fast_falling: bool,
-}
-
-pub fn process_fast_fall(
-    airborne_state_common: &mut AirborneStateCommon,
-    input: &mut FighterInput,
-    velocity: &mut FighterVelocity,
-    attributes: &FighterAttributes,
-) {
-    if velocity.y.is_negative() {
-        if input.has_command(FighterCommands::SmashMoveDown) {
-            airborne_state_common.is_fast_falling = true;
-        }
-        input.clear_command(FighterCommands::SmashMoveDown);
-    }
-
-    if airborne_state_common.is_fast_falling {
-        velocity.y = -attributes.fast_fall_speed;
-    }
-}
-
-pub fn integrate_gravity(
-    velocity: &mut FighterVelocity,
-    attributes: &FighterAttributes,
-    fast_fall: bool
-) {
+pub fn integrate_gravity(velocity: &mut FighterVelocity, attributes: &FighterAttributes) {
     velocity.y -= attributes.gravity;
-
-    let terminal_vel = if fast_fall {
-        -attributes.fast_fall_speed
-    } else {
-        -attributes.terminal_velocity
-    };
-    velocity.y = velocity.y.max(terminal_vel);
+    velocity.y = velocity.y.max(-attributes.terminal_velocity);
 }
 
 pub fn apply_air_drift(
@@ -90,12 +56,8 @@ pub fn apply_air_motion(
     translation.0 += velocity.0;
 }
 
-pub fn update_standard_motion(
-    ctx: &mut crate::fighter::state::UpdateContext,
-    airborne_common: &mut AirborneStateCommon,
-) {
-    process_fast_fall(airborne_common, ctx.input, &mut ctx.velocity, ctx.fighter_attributes);
-    integrate_gravity(ctx.velocity, ctx.fighter_attributes, airborne_common.is_fast_falling);
+pub fn update_standard_motion(ctx: &mut crate::fighter::state::UpdateContext) {
+    integrate_gravity(ctx.velocity, ctx.fighter_attributes);
     apply_air_drift(ctx.velocity, ctx.fighter_attributes, ctx.input);
     apply_air_motion(ctx.velocity, ctx.translation, ctx.prev_translation);
 }
@@ -148,7 +110,6 @@ mod tests {
             air_drift_max: FGi32::lit("1.2"),
             ground_friction: FGi32::ZERO,
             terminal_velocity: FGi32::ZERO,
-            fast_fall_speed: FGi32::ZERO,
             gravity: FGi32::ZERO,
             weight: FGi32::lit("1"),
             air_friction: FGi32::lit("0.001"),

src/fighter/state/air_dodge.rs

@@ -1,9 +1,13 @@
 use crate::{
     fighter::{
-        animation::AnimKind, state::{
-            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, fall::FallState, land::LandingType,
+        animation::AnimKind,
+        state::{
+            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext,
+            UpdateContext, air, fall::FallState, land::LandingType,
         },
-    }, input, math::vec::FGVec2,
+    },
+    input,
+    math::vec::FGVec2,
 };
 
 #[derive(Debug, Clone, Hash)]
@@ -16,7 +20,7 @@ impl FighterStateImpl for AirDodgeState {
 
     fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
         if state_context.is_current_animation_finished() {
-            Some(FighterState::Fall(FallState::new(AirborneStateCommon::default())))
+            Some(FighterState::Fall(FallState))
         } else {
             None
         }
@@ -45,12 +49,6 @@ impl FighterStateImpl for AirDodgeState {
         state_context.velocity.0 =
             self.direction * state_context.fighter_attributes.air_dodge_velocity;
     }
-    
-    fn is_visually_grounded<'a>(
-        &'a self,
-    ) -> bool {
-        false
-    }
 }
 
 pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {

src/fighter/state/dash.rs

@@ -108,12 +108,6 @@ impl FighterStateImpl for DashState {
     ) -> Option<FighterState> {
         ground::collision_interrupt(state_context, &mut self.ground_common, true)
     }
-    
-    fn is_visually_grounded<'a>(
-        &'a self,
-    ) -> bool {
-        true
-    }
 }
 
 fn check_smash_input_with_dir(state_context: &InterruptContext) -> Option<FighterFacingDirection> {

src/fighter/state/fall.rs

@@ -1,24 +1,12 @@
 use super::{CollisionContext, EnterContext, FighterStateImpl, InterruptContext, UpdateContext};
 use crate::fighter::animation::AnimKind;
-use crate::fighter::state::air::AirborneStateCommon;
 use crate::fighter::state::{FighterState, air, jump};
 
-#[derive(Debug, Clone, Copy, Hash, Default)]
-pub struct FallState {
-    airborne_state_common: AirborneStateCommon
-}
-
-impl FallState {
-    pub fn new(airborne_state_common: AirborneStateCommon) -> Self {
-        Self {
-            airborne_state_common
-        }
-    }
-}
+#[derive(Debug, Clone, Copy, Hash)]
+pub struct FallState;
 
 impl FighterStateImpl for FallState {
     const NAME: &'static str = "Fall";
-    
     fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
         jump::check_input_double_jump(state_context)
     }
@@ -28,7 +16,7 @@ impl FighterStateImpl for FallState {
     }
 
     fn update(&mut self, state_context: &mut UpdateContext) {
-        air::update_standard_motion(state_context, &mut self.airborne_state_common);
+        air::update_standard_motion(state_context);
     }
 
     fn check_collision_interrupt(
@@ -40,11 +28,13 @@ impl FighterStateImpl for FallState {
             crate::fighter::state::land::LandingType::Normal,
         )
     }
-    
-    fn is_visually_grounded<'a>(
-        &'a self,
-    ) -> bool {
-        false
-    }
 }
 
+pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
+    let input_frame = state_context.input.get_last_frame();
+
+    if input_frame.movement.x.abs() < state_context.game_settings.input_common.stick_deadzone {
+        return Some(FighterState::Fall(FallState));
+    }
+    None
+}

src/fighter/state/ground.rs

@@ -3,7 +3,7 @@
 //! bit-for-bit deterministic for rollback.
 
 use crate::fighter::state::{
-    CollisionContext, FighterState, InterruptContext, air, dash, fall, ground_attack, turn, wait, walk,
+    CollisionContext, FighterState, InterruptContext, dash, fall, ground_attack, turn, wait, walk,
 };
 use crate::fighter::{
     FighterAttributes, FighterPreviousTranslation, FighterTranslation, FighterVelocity,
@@ -233,7 +233,7 @@ pub fn collision_interrupt(
 ) -> Option<FighterState> {
     match collide_with_stage_grounded(ctx, common, can_walk_off) {
         GroundedMotionResult::InGround => None,
-        GroundedMotionResult::InAir => Some(FighterState::Fall(fall::FallState::new(air::AirborneStateCommon::default()))),
+        GroundedMotionResult::InAir => Some(FighterState::Fall(fall::FallState)),
     }
 }
 

src/fighter/state/ground_attack.rs

@@ -67,12 +67,6 @@ impl FighterStateImpl for GroundAttackState {
     ) -> Option<FighterState> {
         None
     }
-    
-    fn is_visually_grounded<'a>(
-        &'a self,
-    ) -> bool {
-        true
-    }
 }
 
 pub fn check_interrupt(

src/fighter/state/hitstun.rs

@@ -1,11 +1,10 @@
 use crate::{
     fighter::{
         animation::AnimKind,
-        attack::{self, FighterHitReaction},
+        attack::FighterHitReaction,
         state::{
             CollisionContext, EnterContext, ExitContext, FighterState, FighterStateImpl,
-            InterruptContext, UpdateContext,
-            air::{self, AirborneStateCommon},
+            InterruptContext, UpdateContext, air,
             fall::FallState,
             ground::{GroundedStateCommon, collision_interrupt},
             land::LandingType,
@@ -25,17 +24,6 @@ pub enum HitstopStateKind {
 pub struct HitstunState {
     pub hit_reaction: FighterHitReaction,
     pub hitstop_kind: HitstopStateKind,
-    knockback_applied: bool,
-}
-
-impl HitstunState {
-    pub fn new(hit_reaction: FighterHitReaction, hitstop_kind: HitstopStateKind) -> Self {
-        Self {
-            hit_reaction,
-            hitstop_kind,
-            knockback_applied: false,
-        }
-    }
 }
 
 impl FighterStateImpl for HitstunState {
@@ -63,9 +51,7 @@ impl FighterStateImpl for HitstunState {
                         grounded_common: grounded_state_common.clone(),
                     }))
                 }
-                HitstopStateKind::Airborne => {
-                    Some(FighterState::Fall(FallState::new(AirborneStateCommon::default())))
-                }
+                HitstopStateKind::Airborne => Some(FighterState::Fall(FallState)),
             }
         } else {
             None
@@ -73,23 +59,7 @@ impl FighterStateImpl for HitstunState {
     }
 
     fn update(&mut self, ctx: &mut UpdateContext) {
-        if !self.knockback_applied {
-            let launch_direction = attack::directional_influence::apply_directional_influence(
-                ctx.input.get_last_frame().movement,
-                self.hit_reaction.launch_angle,
-                ctx.game_settings.fighter_common.di_max_angle,
-            );
-
-            ctx.knockback_velocity.0 = launch_direction * self.hit_reaction.launch_velocity;
-            self.knockback_applied = true;
-        }
-
-        match self.hitstop_kind {
-            HitstopStateKind::Grounded(_) => {}
-            HitstopStateKind::Airborne => {
-                air::integrate_gravity(ctx.velocity, ctx.fighter_attributes, false);
-            }
-        }
+        air::integrate_gravity(ctx.velocity, ctx.fighter_attributes);
 
         let speed = ctx.knockback_velocity.length();
         let next_speed = speed
@@ -107,6 +77,7 @@ impl FighterStateImpl for HitstunState {
             HitstopStateKind::Airborne => AnimKind::FlinchAir,
         };
         state_context.play_animation(animation, false);
+        state_context.knockback_velocity.0 = self.hit_reaction.launch_velocity;
     }
 
     fn on_exit(&mut self, _state_context: &mut ExitContext) {}
@@ -124,11 +95,4 @@ impl FighterStateImpl for HitstunState {
             }
         }
     }
-
-    fn is_visually_grounded<'a>(&'a self) -> bool {
-        match self.hitstop_kind {
-            HitstopStateKind::Grounded(_) => true,
-            HitstopStateKind::Airborne => false,
-        }
-    }
 }

src/fighter/state/jump.rs

@@ -2,10 +2,16 @@ use bevy::prelude::*;
 
 use crate::{
     fighter::{
-        animation::AnimKind, state::{
-            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, air_dodge::{self, AirDodgeState}, ground::{self, GroundedStateCommon},
+        animation::AnimKind,
+        state::{
+            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext,
+            UpdateContext, air,
+            air_dodge::{self, AirDodgeState},
+            ground::{self, GroundedStateCommon},
         },
-    }, input::FighterCommands, math::{int::FGi32, vec::FGVec2},
+    },
+    input::FighterCommands,
+    math::{int::FGi32, vec::FGVec2},
 };
 #[derive(Debug, Hash, Clone, Copy)]
 pub enum JumpType {
@@ -17,7 +23,6 @@ pub enum JumpType {
 #[derive(Debug, Clone, Hash)]
 pub struct JumpState {
     jump_type: JumpType,
-    airborne_state_common: AirborneStateCommon,
 }
 
 #[derive(Debug, Clone, Hash)]
@@ -69,7 +74,7 @@ impl FighterStateImpl for JumpSquatState {
             } else {
                 JumpType::ShortHop
             };
-            Some(FighterState::Jump(JumpState { jump_type, airborne_state_common: AirborneStateCommon::default() }))
+            Some(FighterState::Jump(JumpState { jump_type }))
         } else {
             None
         }
@@ -91,12 +96,6 @@ impl FighterStateImpl for JumpSquatState {
         state_context.play_animation(AnimKind::JumpSquat, false);
         state_context.input.clear_command(FighterCommands::Jump);
     }
-    
-    fn is_visually_grounded<'a>(
-        &'a self,
-    ) -> bool {
-        true
-    }
 }
 
 impl FighterStateImpl for JumpState {
@@ -105,7 +104,6 @@ impl FighterStateImpl for JumpState {
         if state_context.input.has_command(FighterCommands::Jump) {
             Some(FighterState::Jump(JumpState {
                 jump_type: JumpType::DoubleJump,
-                airborne_state_common: AirborneStateCommon::default()
             }))
         } else {
             air_dodge::check_input(state_context)
@@ -113,7 +111,7 @@ impl FighterStateImpl for JumpState {
     }
 
     fn update(&mut self, state_context: &mut UpdateContext) {
-        air::update_standard_motion(state_context, &mut self.airborne_state_common);
+        air::update_standard_motion(state_context);
     }
 
     fn on_enter(&mut self, state_context: &mut EnterContext) {
@@ -176,12 +174,6 @@ impl FighterStateImpl for JumpState {
             crate::fighter::state::land::LandingType::Normal,
         )
     }
-    
-    fn is_visually_grounded<'a>(
-        &'a self,
-    ) -> bool {
-        false
-    }
 }
 
 pub fn check_input(
@@ -201,7 +193,6 @@ pub fn check_input_double_jump(state_context: &InterruptContext) -> Option<Fight
         .then(|| {
             FighterState::Jump(JumpState {
                 jump_type: JumpType::DoubleJump,
-                airborne_state_common: AirborneStateCommon::default()
             })
         })
 }

src/fighter/state/land.rs

@@ -69,10 +69,4 @@ impl FighterStateImpl for LandingState {
             }
         };
     }
-    
-    fn is_visually_grounded<'a>(
-        &'a self,
-    ) -> bool {
-        true
-    }
 }

src/fighter/state/mod.rs

@@ -7,7 +7,8 @@ use bevy::prelude::*;
 
 use crate::fighter::animation::{AnimKind, FighterAnimationFrame};
 use crate::fighter::attack::{
-    FighterAttackScriptAssets, FighterKnockbackVelocity, FighterPendingHitReaction, FighterStaleMoveQueue, HitStop,
+    FighterAttackScriptAssets, FighterKnockbackVelocity, FighterPendingHitReaction,
+    FighterStaleMoveQueue,
 };
 use crate::fighter::attributes::FighterAttributes;
 use crate::fighter::baked_animation::BakedFighterAnimations;
@@ -16,11 +17,11 @@ use crate::fighter::manifest::FighterManifest;
 use crate::fighter::state::hitstun::HitstunState;
 use crate::fighter::visual::FighterAnimations;
 use crate::fighter::{
-    Fighter, FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole, FighterPreviousTranslation, FighterTranslation, FighterVelocity,
+    Fighter, FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop,
+    FighterPreviousTranslation, FighterTranslation, FighterVelocity,
 };
 use crate::game_settings::GameSettings;
 use crate::input::FighterInput;
-use crate::math::int::FGi32;
 use crate::scripting::FighterAttackScript;
 use crate::stage::line::StageCollision;
 
@@ -65,10 +66,6 @@ macro_rules! fighter_states {
             pub fn check_collision_interrupt(&mut self, ctx: &mut CollisionContext) -> Option<FighterState> {
                 match self { $(Self::$variant(s) => s.check_collision_interrupt(ctx)),* }
             }
-
-            pub fn is_visually_grounded(&self) -> bool {
-                match self { $(Self::$variant(s) => s.is_visually_grounded()),* }
-            }
         }
 
         $(impl From<$ty> for FighterState {
@@ -94,10 +91,6 @@ pub trait FighterStateImpl: Sized {
     ) -> Option<FighterState> {
         None
     }
-
-    fn is_visually_grounded<'a>(
-        &'a self,
-    ) -> bool;
 }
 
 pub struct AnimationStatus {
@@ -148,7 +141,7 @@ pub struct ExitContext<'a> {
 pub struct UpdateContext<'a> {
     pub translation: &'a mut FighterTranslation,
     pub prev_translation: &'a mut FighterPreviousTranslation,
-    pub input: &'a mut FighterInput,
+    pub input: &'a FighterInput,
     pub hitboxes: &'a mut FighterHitboxes,
     pub velocity: &'a mut FighterVelocity,
     pub knockback_velocity: &'a mut FighterKnockbackVelocity,
@@ -289,7 +282,7 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
         UpdateContext {
             translation: &mut self.translation,
             prev_translation: &mut self.prev_translation,
-            input: &mut self.input,
+            input: &self.input,
             hitboxes: &mut self.hitboxes,
             velocity: &mut self.velocity,
             knockback_velocity: &mut self.knockback_velocity,
@@ -327,7 +320,6 @@ pub struct StatefulFighterQuery {
     pub attack_script_assets: &'static FighterAttackScriptAssets,
     pub pending_hit_reaction: &'static mut FighterPendingHitReaction,
     pub hitstop: &'static mut FighterHitstop,
-    pub hitstop_shake: &'static mut FighterHitstopShake,
 }
 
 pub fn state_update_system(
@@ -392,7 +384,6 @@ pub fn state_interrupt_system(
             attack_script_assets,
             mut pending_hit_reaction,
             mut hitstop,
-            mut hitstop_shake,
         } = fighter;
         let manifest = fighter_manifests
             .get(&fighter.manifest)
@@ -400,17 +391,7 @@ pub fn state_interrupt_system(
 
         let new_state = if let Some(reaction) = pending_hit_reaction.take() {
             hitstop.remaining_frames = *reaction.hitstop_frames;
-            let shake_frames = reaction.hitstop_frames.calculate_shake_frames(&game_settings);
-            hitstop_shake.role = FighterHitstopShakeRole::Receiver;
-            hitstop_shake.total_frames = shake_frames;
-            hitstop_shake.remaining_frames = shake_frames;
-            hitstop_shake.kind = if state.is_visually_grounded() {
-                FighterHitstopShakeKind::Horizontal
-            } else {
-                FighterHitstopShakeKind::Vertical
-            };
-            
-            let mut hitstop_kind = match &*state {
+            let hitstop_kind = match &*state {
                 FighterState::Wait(value) => {
                     hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
                 }
@@ -431,30 +412,10 @@ pub fn state_interrupt_system(
                 }
                 _ => hitstun::HitstopStateKind::Airborne,
             };
-
-            if let hitstun::HitstopStateKind::Grounded(_) = hitstop_kind {
-                let straight_up_angle = FGi32::lit("90.0");
-                if reaction.hitstop_frames >= HitStop::new(game_settings.fighter_common.tumble_bounce_hitstop_threshold) {
-                    hitstop_kind = hitstun::HitstopStateKind::Airborne;
-                // TODO: Use floor normal here
-                } else if reaction.launch_angle.abs_diff(straight_up_angle) < game_settings.fighter_common.attack_ground_to_airborne_transition_vertical_angle_threshold {
-                        hitstop_kind = hitstun::HitstopStateKind::Airborne;
-                } else {
-                    // straight down is 270
-                    let straight_down_angle = FGi32::lit("270.0");
-                    let meteor_threshold = game_settings.fighter_common.meteor_angle_threshold;
-                    if (reaction.launch_angle - straight_down_angle).abs() <= meteor_threshold {
-                        // TODO: Floor bounce
-                        hitstop_kind = hitstun::HitstopStateKind::Airborne;
-                    }
-                }
-            }
-
-            info!("Entering hitstop kind: {:?}", hitstop_kind);
-            Some(FighterState::Hitstun(HitstunState::new(
-                reaction,
+            Some(FighterState::Hitstun(HitstunState {
+                hit_reaction: reaction,
                 hitstop_kind,
-            )))
+            }))
         } else if hitstop.remaining_frames > 0 {
             None
         } else {

src/fighter/state/run.rs

@@ -64,12 +64,6 @@ impl FighterStateImpl for RunState {
     ) -> Option<FighterState> {
         ground::collision_interrupt(state_context, &mut self.grounded_common, true)
     }
-    
-    fn is_visually_grounded<'a>(
-        &'a self,
-    ) -> bool {
-        true
-    }
 }
 
 pub fn check_input(

src/fighter/state/turn.rs

@@ -56,12 +56,6 @@ impl FighterStateImpl for TurnState {
     ) -> Option<FighterState> {
         ground::collision_interrupt(state_context, &mut self.grounded_common, false)
     }
-    
-    fn is_visually_grounded<'a>(
-        &'a self,
-    ) -> bool {
-        true
-    }
 }
 
 pub fn check_input(

src/fighter/state/wait.rs

@@ -46,12 +46,6 @@ impl FighterStateImpl for WaitState {
     ) -> Option<FighterState> {
         ground::collision_interrupt(state_context, &mut self.grounded_common, false)
     }
-    
-    fn is_visually_grounded<'a>(
-        &'a self,
-    ) -> bool {
-        true
-    }
 }
 
 pub fn check_input(

src/fighter/state/walk.rs

@@ -56,12 +56,6 @@ impl FighterStateImpl for WalkState {
     ) -> Option<FighterState> {
         ground::collision_interrupt(state_context, &mut self.grounded_common, false)
     }
-    
-    fn is_visually_grounded<'a>(
-        &'a self,
-    ) -> bool {
-        true
-    }
 }
 
 pub fn check_input(

src/game_settings.rs

@@ -9,36 +9,12 @@ use crate::{math::int::FGi32, menus::style::FGUiStyle};
 #[reflect(opaque)]
 pub struct FighterSettingsCommon {
     pub walk_speed_ease: FGi32,
-
-    /// Maximum allowed horizontal velocity
     pub ground_max_horizontal_velocity: FGi32,
-
-    /// Ground friction applied when the fighter is above the walk speed
     pub ground_friction_over_walk_speed_multiplier: FGi32,
     pub knockback_stacking_window: u32,
     pub knockback_decay_per_frame: FGi32,
-
-    /// Multiplier that translates knockback -> game unit velocity
     pub knockback_launch_velocity_multiplier: FGi32,
     pub hitstun_frames_per_unit_knockback: FGi32,
-
-    /// If an attack's hitstop > this value it will cause a grounded fighter to either bounce (if a meteor/spike)
-    /// or to become airborne
-    pub tumble_bounce_hitstop_threshold: u32,
-
-    /// Angle diff from straight down under which the attack will count as a meteor
-    pub meteor_angle_threshold: FGi32,
-
-    /// Angle diff from straight up under which the attack will force an airborne state 
-    pub attack_ground_to_airborne_transition_vertical_angle_threshold: FGi32,
-    pub visual_shake_frames_per_hitstop_frame: FGi32,
-    // offsets applied when the fighter is in hitstop
-    pub visual_shake_table: Vec<f32>,
-    /// The attacker will always get less hitstop
-    pub attacker_visual_shake_multiplier: f32,
-    
-    /// Maximum angle changed caused by directional influence
-    pub di_max_angle: FGi32,
 }
 #[derive(Reflect, Serialize, Deserialize, Clone)]
 #[reflect(opaque)]

src/input/buffer.rs

@@ -20,8 +20,6 @@ pub enum FighterCommands {
     Jump,
     Shield,
     Attack,
-    SmashMoveUp,
-    SmashMoveDown,
     SmashMoveLeft,
     SmashMoveRight,
 }
@@ -62,8 +60,6 @@ impl FighterAttackCommandType {
 pub struct FighterCommandLifetimes {
     smash_move_left: u8,
     smash_move_right: u8,
-    smash_move_down: u8,
-    smash_move_up: u8,
     jump: u8,
     shield: u8,
     attack: u8,
@@ -76,8 +72,6 @@ impl Index<FighterCommands> for FighterCommandLifetimes {
         match command {
             FighterCommands::SmashMoveLeft => &self.smash_move_left,
             FighterCommands::SmashMoveRight => &self.smash_move_right,
-            FighterCommands::SmashMoveDown => &self.smash_move_down,
-            FighterCommands::SmashMoveUp => &self.smash_move_up,
             FighterCommands::Jump => &self.jump,
             FighterCommands::Shield => &self.shield,
             FighterCommands::Attack => &self.attack,
@@ -90,8 +84,6 @@ impl IndexMut<FighterCommands> for FighterCommandLifetimes {
         match command {
             FighterCommands::SmashMoveLeft => &mut self.smash_move_left,
             FighterCommands::SmashMoveRight => &mut self.smash_move_right,
-            FighterCommands::SmashMoveDown => &mut self.smash_move_down,
-            FighterCommands::SmashMoveUp => &mut self.smash_move_up,
             FighterCommands::Jump => &mut self.jump,
             FighterCommands::Shield => &mut self.shield,
             FighterCommands::Attack => &mut self.attack,
@@ -229,19 +221,6 @@ pub fn postprocess_input(
         let mut x_flick_detected =
             x_abs >= axis_threshold && input.frames_in_x_flick_deadzone <= frame_threshold;
 
-        if y_flick_detected {
-            input.clear_command(FighterCommands::SmashMoveUp);
-            input.clear_command(FighterCommands::SmashMoveDown);
-
-            let command_to_set = if input.current_frame.movement.y > 0.0 {
-                FighterCommands::SmashMoveUp
-            } else {
-                FighterCommands::SmashMoveDown
-            };
-
-            input.set_lifetime(command_to_set, game_settings.input_common.input_buffer_size);
-        }
-
         // if both flicks are detected, only one wins
 
         if x_flick_detected && y_flick_detected {

src/input/gamecube/poll.rs

@@ -45,8 +45,8 @@ impl GcPortState {
             dpad_right: b.dpad_right(),
             left_trigger_digital: b.left_trigger(),
             right_trigger_digital: b.right_trigger(),
-            left_stick: cal.left_stick_coords(&c),
-            right_stick: cal.right_stick_coords(&c),
+            left_stick: cal.left_stick(&c),
+            right_stick: cal.right_stick(&c),
             triggers: (c.triggers.left.raw(), c.triggers.right.raw()),
         }
     }