Fix build and clamp DI angle change

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

Cargo.lock

@@ -3468,9 +3468,9 @@ dependencies = [
 
 [[package]]
 name = "gc-adapter-neo"
-version = "1.0.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd350c081bf33e501e9a5a11732294dfe266683d6b58a366b097146f3e633cb5"
+checksum = "120a5b3858ae854c4674ae41a38173e8ea04b814fb3212fd3bdd1b04d414a9d7"
 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.0.0", features = ["libusb"] }
+gc-adapter-neo = { version = "1.1.0", features = ["libusb"] }
 rhai = "1.26.0"
 enum_cycling = "0.2.1"
 enum_cycling_derive = "0.2.1"

assets/game_settings.ron

@@ -17,7 +17,15 @@
         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,22 +1,12 @@
 use bevy::prelude::*;
 
 use crate::{
-    camera::MatchCamera,
-    fighter::{
-        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop,
-        FighterPreviousFacingDirection, FighterPreviousTranslation, FighterTranslation,
-        FighterVelocity, Grounded,
-        animation::FighterAnimationFrame,
-        attack::{
+    camera::MatchCamera, fighter::{
+        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, 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)]
@@ -48,6 +38,7 @@ struct FighterCheckpoint {
     damage: FighterDamage,
     pending_hit_reaction: FighterPendingHitReaction,
     hitstop: FighterHitstop,
+    hitstop_shake: FighterHitstopShake,
     knockback_velocity: FighterKnockbackVelocity,
     stale_moves: FighterStaleMoveQueue,
     hitboxes: FighterHitboxes,
@@ -146,6 +137,7 @@ 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());
@@ -183,6 +175,7 @@ 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

@@ -0,0 +1,69 @@
+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,6 +1,7 @@
 use std::collections::{HashMap, VecDeque};
 
 mod reaction;
+pub mod directional_influence;
 
 use bevy::ecs::entity::{EntityMapper, MapEntities};
 use bevy::prelude::*;
@@ -42,7 +43,8 @@ pub enum HitReactionKind {
 
 #[derive(Debug, Hash, Clone)]
 pub struct FighterHitReaction {
-    pub launch_velocity: FGVec2,
+    pub launch_velocity: FGi32,
+    pub launch_angle: FGi32,
     pub hitstop_frames: HitStop,
     pub hitstun_frames: u32,
     pub kind: HitReactionKind,
@@ -62,10 +64,13 @@ pub struct FighterLastAttackDebug {
     pub trajectory_points: Vec<Vec3>,
 }
 
-#[derive(Debug, Default, Clone, Deref, DerefMut, Hash)]
+#[derive(Debug, Default, Clone, Deref, DerefMut, Hash, PartialEq, PartialOrd)]
 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 {
@@ -78,6 +83,10 @@ 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,19 +1,11 @@
 use bevy::prelude::*;
 use bevy_ggrs::prelude::GgrsSchedule;
-use fixed_math::SinCos;
 
 use super::*;
 use crate::{
     fighter::{
-        Fighter, FighterFacingDirection, FighterHitboxes, FighterHitstop,
-        FighterPendingHitReaction, FighterStaleMoveQueue, errors::FighterErrors,
-        manifest::FighterManifest,
-    },
-    game_settings::GameSettings,
-    math::{int::FGi32, vec::FGVec2},
-    player::Player,
-    schedule::GameplaySet,
-    scripting::FighterAttackScript,
+        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,
 };
 
 pub fn resolve_fighter_hits(
@@ -24,8 +16,9 @@ pub fn resolve_fighter_hits(
         &FighterHitboxes,
         &Player,
         &mut FighterHitstop,
+        &mut FighterHitstopShake,
     )>,
-    mut receiver: Query<(&mut FighterDamage, &Fighter, &mut FighterPendingHitReaction)>,
+    mut receiver: Query<(&mut FighterDamage, &Fighter, &mut FighterPendingHitReaction, &FighterState)>,
     attack_scripts: Res<Assets<FighterAttackScript>>,
     game_settings: Res<GameSettings>,
     fighter_manifests: Res<Assets<FighterManifest>>,
@@ -40,7 +33,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.get_mut(defender)
+        let Ok((mut receiver_damage, fighter, mut pending_reaction, receiver_state)) = receiver.get_mut(defender)
         else {
             hit_offset = next_defender;
             continue;
@@ -49,7 +42,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;
@@ -96,14 +89,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: launch_direction * knockback.get_launch_speed(&game_settings),
+                    launch_velocity: knockback.get_launch_speed(&game_settings),
+                    launch_angle,
                     hitstun_frames: knockback.get_hitstun_frames(&game_settings),
                     hitstop_frames: hitstop,
                     kind: HitReactionKind::Flinch,
@@ -114,10 +107,23 @@ pub fn resolve_fighter_hits(
         receiver_damage.0 += total_damage_received_this_frame;
 
         for (attacker_entity, _, reaction) in &reactions {
-            let Ok((.., mut hitstop)) = attacker.get_mut(*attacker_entity) else {
+            let Ok((.., mut hitstop, mut hitstop_shake)) = attacker.get_mut(*attacker_entity) else {
                 continue;
             };
-            hitstop.remaining_frames = reaction.hitstop_frames.max(hitstop.remaining_frames);
+
+            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;
+            }
         }
 
         pending_reaction.0 = reactions

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::{
-    FighterKnockbackVelocity, FighterLastAttackDebug, FighterPendingHitReaction,
+    self, 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) in query {
+    for (entity, reaction, translation, fighter, input) in query {
         let Some(ref hit) = reaction.0 else {
-            commands.entity(entity).remove::<FighterLastAttackDebug>();
             continue;
         };
 
@@ -397,7 +397,13 @@ pub fn attack_debug_gather(
             .get(&fighter.manifest)
             .ok_or(FighterErrors::FighterManifestNotFound)?;
 
-        let mut knockback_vel = FighterKnockbackVelocity(hit.launch_velocity);
+        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 fighter_vel = FighterVelocity(FGVec2::ZERO);
         let mut translation = Vec3::new(translation.x.to_num(), translation.y.to_num(), 0.0);
 

src/fighter/mod.rs

@@ -33,24 +33,13 @@ 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, 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;
 
@@ -65,7 +54,30 @@ 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,
 }
@@ -120,7 +132,8 @@ pub struct FighterVisual;
     FighterDamage,
     FighterPendingHitReaction,
     FighterHitstop,
-    FighterKnockbackVelocity
+    FighterKnockbackVelocity,
+    FighterTranslation,
 )]
 pub struct Fighter {
     pub manifest: Handle<FighterManifest>,
@@ -230,6 +243,7 @@ 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,8 +313,9 @@ pub fn spawn_fighter(
         .id()
 }
 
-pub fn decay_hitstop(query: Query<&mut FighterHitstop>) {
-    for mut hitstop in query {
+pub fn decay_hitstop(query: Query<(&mut FighterHitstop, &mut FighterHitstopShake)>) {
+    for (mut hitstop, mut hitstop_shake) 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,6 +5,8 @@ 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},
@@ -58,13 +60,15 @@ 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, mut transform) in query {
+    for (translation, previous_translation, ecb, hitstop_shake, mut transform) in query {
         let translation = sample_presentation_translation(
             *previous_translation,
             *translation,
@@ -77,6 +81,28 @@ 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;
+        }
     }
 }
 
@@ -85,22 +111,15 @@ pub fn apply_air_motion(
         &FighterVelocity,
         &mut FighterTranslation,
         &mut FighterPreviousTranslation,
-        &mut Transform,
     )>,
     _time: Res<Time<Fixed>>,
 ) {
-    for (velocity, mut translation, mut prev_translation, _transform) in fighters {
+    for (velocity, mut translation, mut prev_translation) 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_dodge.rs

@@ -49,6 +49,12 @@ 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,6 +108,12 @@ 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

@@ -28,6 +28,12 @@ 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> {

src/fighter/state/ground_attack.rs

@@ -67,6 +67,12 @@ 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,8 +1,6 @@
 use crate::{
     fighter::{
-        animation::AnimKind,
-        attack::FighterHitReaction,
-        state::{
+        animation::AnimKind, attack::{self, FighterHitReaction}, state::{
             CollisionContext, EnterContext, ExitContext, FighterState, FighterStateImpl,
             InterruptContext, UpdateContext, air,
             fall::FallState,
@@ -10,8 +8,7 @@ use crate::{
             land::LandingType,
             wait::WaitState,
         },
-    },
-    math::int::FGi32,
+    }, math::int::FGi32,
 };
 
 #[derive(Clone, Debug, Hash)]
@@ -24,6 +21,17 @@ 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 {
@@ -59,6 +67,17 @@ 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;
+        }
+
         air::integrate_gravity(ctx.velocity, ctx.fighter_attributes);
 
         let speed = ctx.knockback_velocity.length();
@@ -77,7 +96,6 @@ 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) {}
@@ -95,4 +113,13 @@ 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

@@ -96,6 +96,12 @@ 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 {
@@ -174,6 +180,12 @@ impl FighterStateImpl for JumpState {
             crate::fighter::state::land::LandingType::Normal,
         )
     }
+    
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
+        false
+    }
 }
 
 pub fn check_input(

src/fighter/state/land.rs

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

src/fighter/state/mod.rs

@@ -7,8 +7,7 @@ use bevy::prelude::*;
 
 use crate::fighter::animation::{AnimKind, FighterAnimationFrame};
 use crate::fighter::attack::{
-    FighterAttackScriptAssets, FighterKnockbackVelocity, FighterPendingHitReaction,
-    FighterStaleMoveQueue,
+    FighterAttackScriptAssets, FighterKnockbackVelocity, FighterPendingHitReaction, FighterStaleMoveQueue, HitStop,
 };
 use crate::fighter::attributes::FighterAttributes;
 use crate::fighter::baked_animation::BakedFighterAnimations;
@@ -17,11 +16,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,
-    FighterPreviousTranslation, FighterTranslation, FighterVelocity,
+    Fighter, FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole, 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;
 
@@ -66,6 +65,10 @@ 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 {
@@ -91,6 +94,10 @@ pub trait FighterStateImpl: Sized {
     ) -> Option<FighterState> {
         None
     }
+
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool;
 }
 
 pub struct AnimationStatus {
@@ -320,6 +327,7 @@ 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(
@@ -384,6 +392,7 @@ 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)
@@ -391,7 +400,17 @@ pub fn state_interrupt_system(
 
         let new_state = if let Some(reaction) = pending_hit_reaction.take() {
             hitstop.remaining_frames = *reaction.hitstop_frames;
-            let hitstop_kind = match &*state {
+            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 {
                 FighterState::Wait(value) => {
                     hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
                 }
@@ -412,10 +431,30 @@ pub fn state_interrupt_system(
                 }
                 _ => hitstun::HitstopStateKind::Airborne,
             };
-            Some(FighterState::Hitstun(HitstunState {
-                hit_reaction: reaction,
+
+            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,
                 hitstop_kind,
-            }))
+            )))
         } else if hitstop.remaining_frames > 0 {
             None
         } else {

src/fighter/state/run.rs

@@ -64,6 +64,12 @@ 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,6 +56,12 @@ 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,6 +46,12 @@ 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,6 +56,12 @@ 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,12 +9,36 @@ 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/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(&c),
-            right_stick: cal.right_stick(&c),
+            left_stick: cal.left_stick_coords(&c),
+            right_stick: cal.right_stick_coords(&c),
             triggers: (c.triggers.left.raw(), c.triggers.right.raw()),
         }
     }