Implement fast falling

Reviewed-on: #43
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"

README.md

@@ -1,12 +1,15 @@
-# Game Test
+# Shinespark
 
-A Bevy game, editable in the [jackdaw](https://github.com/jbuehler23/jackdaw) editor.
+Fancy heavily advanced platform fighting game
 
-- `cargo run` plays the game standalone; no editor required.
+## Direct P2P Debugging
-- Open the folder in jackdaw to author scenes, then hit Play. The
+
-  editor builds its own artifacts into `.jackdaw/` (gitignored) and
+```text
-  never modifies your manifest or lockfile.
+# Process 1 owns player 0 and listens on 7000.
-- Gameplay lives in `src/lib.rs` (`GamePlugin`); authored scenes live
+cargo run -- --debug-match --players 2 --local-port 7000 \
-  in `assets/*.bsn`.
+  --net-player 0=local --net-player 1=127.0.0.1:7001
-- Components you derive `Reflect` on appear in the editor's inspector
+
-  automatically; no registration code is needed.
+# Process 2 owns player 1 and listens on 7001.
+cargo run -- --debug-match --players 2 --local-port 7001 \
+  --net-player 0=127.0.0.1:7000 --net-player 1=local
+```

assets/fighters/test/test.fighter.ron

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

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"

launch_localtest.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+FIRST="cargo run -- --debug-match --players 2 --local-port 7000 \
+  --net-player 0=local --net-player 1=127.0.0.1:7001"
+SECOND="cargo run -- --debug-match --players 2 --local-port 7001 \
+--net-player 0=127.0.0.1:7000 --net-player 1=local"
+
+(trap 'kill 0' SIGINT; $FIRST & $SECOND)

src/args.rs

@@ -1,5 +1,6 @@
 use bevy::prelude::*;
 use clap::Parser;
+use std::net::SocketAddr;
 use std::path::PathBuf;
 
 #[derive(Parser, Debug, Clone, Resource)]
@@ -15,6 +16,12 @@ pub struct Args {
     pub check_distance: usize,
     #[clap(long, default_value_t = 1)]
     pub players: usize,
+    /// UDP port to bind for a direct peer-to-peer session.
+    #[clap(long, default_value_t = 6969)]
+    pub local_port: u16,
+    /// Player ownership declarations in the form HANDLE=local or HANDLE=ADDRESS.
+    #[clap(long = "net-player", value_name = "HANDLE=local|ADDRESS")]
+    pub net_players: Vec<String>,
     /// Record a replay to this path.
     #[clap(long, conflicts_with = "play_replay")]
     pub record_replay: Option<PathBuf>,
@@ -25,3 +32,41 @@ pub struct Args {
     #[clap(long, value_enum, default_value_t = crate::replay::ReplayFormat::Binary)]
     pub replay_format: crate::replay::ReplayFormat,
 }
+
+pub fn parse_socket_addr(value: &str) -> Result<SocketAddr, String> {
+    let address = value
+        .parse::<SocketAddr>()
+        .map_err(|_| format!("invalid socket address: {value}"))?;
+    if address.port() == 0 {
+        return Err(format!("socket address must use a nonzero port: {value}"));
+    }
+    Ok(address)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_network_options() {
+        let args = Args::try_parse_from([
+            "game",
+            "--local-port",
+            "7000",
+            "--net-player",
+            "0=local",
+            "--net-player",
+            "1=127.0.0.1:7001",
+        ])
+        .unwrap();
+
+        assert_eq!(args.local_port, 7000);
+        assert_eq!(args.net_players, ["0=local", "1=127.0.0.1:7001"]);
+    }
+
+    #[test]
+    fn rejects_invalid_socket_addresses() {
+        assert!(parse_socket_addr("127.0.0.1:0").is_err());
+        assert!(parse_socket_addr("not-an-address").is_err());
+    }
+}

src/debug_tools/save_state.rs

@@ -1,22 +1,12 @@
 use bevy::prelude::*;
 
 use crate::{
-    camera::MatchCamera,
+    camera::MatchCamera, fighter::{
-    fighter::{
+        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterPreviousFacingDirection, FighterPreviousTranslation, FighterTranslation, FighterVelocity, Grounded, animation::FighterAnimationFrame, attack::{
-        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop,
-        FighterPreviousFacingDirection, FighterPreviousTranslation, FighterTranslation,
-        FighterVelocity, Grounded,
-        animation::FighterAnimationFrame,
-        attack::{
             FighterDamage, FighterKnockbackVelocity, FighterPendingHitReaction, FighterPendingHits,
             FighterSolvedHurtboxes, FighterStaleMoveQueue,
-        },
+        }, baked_animation::FighterBoneMatrices, state::FighterState,
-        baked_animation::FighterBoneMatrices,
+    }, input::FighterInput, player::Player, stage::line::StageCollision,
-        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,
+        Fighter, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole, FighterPendingHitReaction, FighterStaleMoveQueue, errors::FighterErrors, manifest::FighterManifest, state::FighterState,
-        FighterPendingHitReaction, FighterStaleMoveQueue, errors::FighterErrors,
+    }, game_settings::GameSettings, math::{int::FGi32}, player::Player, schedule::GameplaySet, scripting::FighterAttackScript,
-        manifest::FighterManifest,
-    },
-    game_settings::GameSettings,
-    math::{int::FGi32, vec::FGVec2},
-    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/attributes.rs

@@ -37,6 +37,7 @@ 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::{
-    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);
 
@@ -406,7 +412,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);
+            air::integrate_gravity(&mut fighter_vel, &manifest.attributes, false);
 
             let vel = knockback_vel.length();
             let new_vel = vel

src/fighter/mod.rs

@@ -33,24 +33,13 @@ pub use motion::{
 };
 
 use crate::{
-    AppState,
+    AppState, fighter::{
-    fighter::{
         attack::{
             AttackKind, FighterAttackPlugin, FighterAttackScriptAssets, FighterDamage,
             FighterKnockbackVelocity, FighterPendingHitReaction, FighterSolvedHurtboxes,
             FighterStaleMoveQueue,
-        },
+        }, baked_animation::{FighterBoneIndexMap, FighterBoneMatrices}, manifest::FighterManifest, state::{FighterState, air::AirborneStateCommon, fall::FallState}, visual::FighterAnimations,
-        baked_animation::{FighterBoneIndexMap, FighterBoneMatrices},
+    }, input::FighterInput, math::{int::FGi32, vec::FGVec2}, player::Player, schedule::GameplaySet, scripting::FighterAttackScript, stage::line::StageCollision,
-        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>()
@@ -285,7 +299,7 @@ pub fn spawn_fighter(
             visual_root,
             animations,
             attack_scripts,
-            FighterState::Fall(FallState),
+            FighterState::Fall(FallState::new(AirborneStateCommon::default())),
             animation::FighterAnimationFrame::new(animation::AnimKind::Wait, true),
             (
                 baked_animation::FighterBoneMatrices::default(),
@@ -299,8 +313,9 @@ pub fn spawn_fighter(
         .id()
 }
 
-pub fn decay_hitstop(query: Query<&mut FighterHitstop>) {
+pub fn decay_hitstop(query: Query<(&mut FighterHitstop, &mut FighterHitstopShake)>) {
-    for mut hitstop in query {
+    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.rs

@@ -2,10 +2,44 @@ 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;
 
-pub fn integrate_gravity(velocity: &mut FighterVelocity, attributes: &FighterAttributes) {
+#[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
+) {
     velocity.y -= attributes.gravity;
-    velocity.y = velocity.y.max(-attributes.terminal_velocity);
+
+    let terminal_vel = if fast_fall {
+        -attributes.fast_fall_speed
+    } else {
+        -attributes.terminal_velocity
+    };
+    velocity.y = velocity.y.max(terminal_vel);
 }
 
 pub fn apply_air_drift(
@@ -56,8 +90,12 @@ pub fn apply_air_motion(
     translation.0 += velocity.0;
 }
 
-pub fn update_standard_motion(ctx: &mut crate::fighter::state::UpdateContext) {
+pub fn update_standard_motion(
-    integrate_gravity(ctx.velocity, ctx.fighter_attributes);
+    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);
     apply_air_drift(ctx.velocity, ctx.fighter_attributes, ctx.input);
     apply_air_motion(ctx.velocity, ctx.translation, ctx.prev_translation);
 }
@@ -110,6 +148,7 @@ 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,13 +1,9 @@
 use crate::{
     fighter::{
-        animation::AnimKind,
+        animation::AnimKind, state::{
-        state::{
+            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, fall::FallState, land::LandingType,
-            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext,
-            UpdateContext, air, fall::FallState, land::LandingType,
         },
-    },
+    }, input, math::vec::FGVec2,
-    input,
-    math::vec::FGVec2,
 };
 
 #[derive(Debug, Clone, Hash)]
@@ -20,7 +16,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))
+            Some(FighterState::Fall(FallState::new(AirborneStateCommon::default())))
         } else {
             None
         }
@@ -49,6 +45,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

@@ -1,12 +1,24 @@
 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)]
+#[derive(Debug, Clone, Copy, Hash, Default)]
-pub struct FallState;
+pub struct FallState {
+    airborne_state_common: AirborneStateCommon
+}
+
+impl FallState {
+    pub fn new(airborne_state_common: AirborneStateCommon) -> Self {
+        Self {
+            airborne_state_common
+        }
+    }
+}
 
 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)
     }
@@ -16,7 +28,7 @@ impl FighterStateImpl for FallState {
     }
 
     fn update(&mut self, state_context: &mut UpdateContext) {
-        air::update_standard_motion(state_context);
+        air::update_standard_motion(state_context, &mut self.airborne_state_common);
     }
 
     fn check_collision_interrupt(
@@ -28,13 +40,11 @@ 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, dash, fall, ground_attack, turn, wait, walk,
+    CollisionContext, FighterState, InterruptContext, air, 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)),
+        GroundedMotionResult::InAir => Some(FighterState::Fall(fall::FallState::new(air::AirborneStateCommon::default()))),
     }
 }
 

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,10 +1,11 @@
 use crate::{
     fighter::{
         animation::AnimKind,
-        attack::FighterHitReaction,
+        attack::{self, FighterHitReaction},
         state::{
             CollisionContext, EnterContext, ExitContext, FighterState, FighterStateImpl,
-            InterruptContext, UpdateContext, air,
+            InterruptContext, UpdateContext,
+            air::{self, AirborneStateCommon},
             fall::FallState,
             ground::{GroundedStateCommon, collision_interrupt},
             land::LandingType,
@@ -24,6 +25,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 {
@@ -51,7 +63,9 @@ impl FighterStateImpl for HitstunState {
                         grounded_common: grounded_state_common.clone(),
                     }))
                 }
-                HitstopStateKind::Airborne => Some(FighterState::Fall(FallState)),
+                HitstopStateKind::Airborne => {
+                    Some(FighterState::Fall(FallState::new(AirborneStateCommon::default())))
+                }
             }
         } else {
             None
@@ -59,7 +73,23 @@ impl FighterStateImpl for HitstunState {
     }
 
     fn update(&mut self, ctx: &mut UpdateContext) {
-        air::integrate_gravity(ctx.velocity, ctx.fighter_attributes);
+        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);
+            }
+        }
 
         let speed = ctx.knockback_velocity.length();
         let next_speed = speed
@@ -77,7 +107,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 +124,11 @@ 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,16 +2,10 @@ use bevy::prelude::*;
 
 use crate::{
     fighter::{
-        animation::AnimKind,
+        animation::AnimKind, state::{
-        state::{
+            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, air_dodge::{self, AirDodgeState}, ground::{self, GroundedStateCommon},
-            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 {
@@ -23,6 +17,7 @@ pub enum JumpType {
 #[derive(Debug, Clone, Hash)]
 pub struct JumpState {
     jump_type: JumpType,
+    airborne_state_common: AirborneStateCommon,
 }
 
 #[derive(Debug, Clone, Hash)]
@@ -74,7 +69,7 @@ impl FighterStateImpl for JumpSquatState {
             } else {
                 JumpType::ShortHop
             };
-            Some(FighterState::Jump(JumpState { jump_type }))
+            Some(FighterState::Jump(JumpState { jump_type, airborne_state_common: AirborneStateCommon::default() }))
         } else {
             None
         }
@@ -96,6 +91,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 {
@@ -104,6 +105,7 @@ 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)
@@ -111,7 +113,7 @@ impl FighterStateImpl for JumpState {
     }
 
     fn update(&mut self, state_context: &mut UpdateContext) {
-        air::update_standard_motion(state_context);
+        air::update_standard_motion(state_context, &mut self.airborne_state_common);
     }
 
     fn on_enter(&mut self, state_context: &mut EnterContext) {
@@ -174,6 +176,12 @@ impl FighterStateImpl for JumpState {
             crate::fighter::state::land::LandingType::Normal,
         )
     }
+    
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
+        false
+    }
 }
 
 pub fn check_input(
@@ -193,6 +201,7 @@ 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,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,
+    FighterAttackScriptAssets, FighterKnockbackVelocity, FighterPendingHitReaction, FighterStaleMoveQueue, HitStop,
-    FighterStaleMoveQueue,
 };
 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,
+    Fighter, FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole, FighterPreviousTranslation, FighterTranslation, FighterVelocity,
-    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 {
@@ -141,7 +148,7 @@ pub struct ExitContext<'a> {
 pub struct UpdateContext<'a> {
     pub translation: &'a mut FighterTranslation,
     pub prev_translation: &'a mut FighterPreviousTranslation,
-    pub input: &'a FighterInput,
+    pub input: &'a mut FighterInput,
     pub hitboxes: &'a mut FighterHitboxes,
     pub velocity: &'a mut FighterVelocity,
     pub knockback_velocity: &'a mut FighterKnockbackVelocity,
@@ -282,7 +289,7 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
         UpdateContext {
             translation: &mut self.translation,
             prev_translation: &mut self.prev_translation,
-            input: &self.input,
+            input: &mut self.input,
             hitboxes: &mut self.hitboxes,
             velocity: &mut self.velocity,
             knockback_velocity: &mut self.knockback_velocity,
@@ -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/buffer.rs

@@ -20,6 +20,8 @@ pub enum FighterCommands {
     Jump,
     Shield,
     Attack,
+    SmashMoveUp,
+    SmashMoveDown,
     SmashMoveLeft,
     SmashMoveRight,
 }
@@ -60,6 +62,8 @@ 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,
@@ -72,6 +76,8 @@ 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,
@@ -84,6 +90,8 @@ 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,
@@ -221,6 +229,19 @@ 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(&c),
+            left_stick: cal.left_stick_coords(&c),
-            right_stick: cal.right_stick(&c),
+            right_stick: cal.right_stick_coords(&c),
             triggers: (c.triggers.left.raw(), c.triggers.right.raw()),
         }
     }

src/lib.rs

@@ -71,6 +71,7 @@ pub enum AppState {
     LoadingMatch,
     PreparingMatch,
     InMatch,
+    MatchDisconnected,
     MatchLoadFailed,
 }
 

src/match_loading.rs

@@ -8,25 +8,28 @@ use bevy_ggrs::prelude::Session;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    AppState,
     args::Args,
     fighter::{
-        FighterId, FighterRoster,
         animation::AnimKind,
         attack::{AttackKind, FighterAttackScriptAssets},
-        baked_animation::{BAKED_ANIMATION_FPS, BakedFighterAnimations},
+        baked_animation::{BakedFighterAnimations, BAKED_ANIMATION_FPS},
         manifest::{FighterManifest, FighterManifestRegistry},
         spawn_fighter,
         visual::FighterAnimations,
+        FighterId, FighterRoster,
     },
     input::{LocalInputAssignments, LocalInputSource},
     math::{int::FGi32, vec::FGVec2},
-    netcode::{GGRSCfg, session::create_session},
+    netcode::{
+        session::{create_session, ConnectionStatus, SessionConfig},
+        GGRSCfg,
+    },
     scripting::FighterAttackScript,
     stage::{
         self,
         manifest::{StageId, StageManifest, StageManifestRegistry},
     },
+    AppState,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@@ -140,6 +143,7 @@ pub fn initiate_match(
     next_state: &mut NextState<AppState>,
     request: PendingMatch,
 ) {
+    commands.remove_resource::<crate::netcode::session::MatchDisconnected>();
     commands.insert_resource(request);
     next_state.set(AppState::LoadingMatch);
 }
@@ -176,6 +180,14 @@ pub fn initiate_default_match(
         }
         return;
     }
+    let session_config = match SessionConfig::from_args(&args, args.players) {
+        Ok(config) => config,
+        Err(error) => {
+            error!("Invalid network configuration: {error}");
+            next_state.set(AppState::MatchLoadFailed);
+            return;
+        }
+    };
     let players = (0..args.players)
         .map(|handle| MatchPlayer {
             handle,
@@ -183,10 +195,21 @@ pub fn initiate_default_match(
         })
         .collect();
 
-    assigments.push((0, LocalInputSource::Keyboard));
+    assigments.clear();
+    let local_handles = session_config
+        .players
+        .iter()
+        .enumerate()
+        .filter_map(|(handle, player)| {
+            matches!(player, crate::netcode::session::PlayerConnection::Local).then_some(handle)
+        });
+    let mut local_handles = local_handles;
+    if let Some(handle) = local_handles.next() {
+        assigments.push((handle, LocalInputSource::Keyboard));
+    }
 
-    for (idx, entity) in gamepads.iter().take(args.players - 1).enumerate() {
+    for (entity, handle) in gamepads.iter().zip(local_handles) {
-        assigments.push((idx + 1, LocalInputSource::Gamepad(entity)));
+        assigments.push((handle, LocalInputSource::Gamepad(entity)));
     }
 
     initiate_match(
@@ -373,6 +396,16 @@ pub fn prepare_match(
         ));
     }
 
+    let session_config = match SessionConfig::from_args(&args, request.players.len()) {
+        Ok(config) => config,
+        Err(error) => {
+            fail_match(
+                &mut next_state,
+                &format!("invalid network configuration: {error}"),
+            );
+            return;
+        }
+    };
     let session = match create_session(&args, request.players.len()) {
         Ok(session) => session,
         Err(error) => {
@@ -418,6 +451,8 @@ pub fn prepare_match(
     }
 
     commands.insert_resource(FighterRoster(fighter_roster));
+    commands.insert_resource(session_config);
+    commands.insert_resource(ConnectionStatus::default());
     commands.insert_resource::<Session<GGRSCfg>>(session);
     next_state.set(AppState::InMatch);
 }
@@ -448,6 +483,8 @@ pub fn cleanup_match(
         commands.entity(fighter).despawn();
     }
     commands.remove_resource::<Session<GGRSCfg>>();
+    commands.remove_resource::<SessionConfig>();
+    commands.remove_resource::<ConnectionStatus>();
     commands.remove_resource::<stage::line::StageCollision>();
     commands.remove_resource::<MatchAssets>();
     commands.remove_resource::<PendingMatch>();

src/netcode/session.rs

@@ -1,49 +1,234 @@
-//! Bringing up the GGRS session and reporting what it does.
+//! Bringing up GGRS sessions and reporting their connection lifecycle.
+
+use std::net::SocketAddr;
 
 use bevy::prelude::*;
 use bevy_ggrs::{ggrs::UdpNonBlockingSocket, prelude::*};
+use thiserror::Error;
 
-use crate::args::Args;
+use crate::args::{parse_socket_addr, Args};
 use crate::netcode::GGRSCfg;
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum PlayerConnection {
+    Local,
+    Remote(SocketAddr),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Resource)]
+pub struct SessionConfig {
+    pub local_port: u16,
+    pub players: Vec<PlayerConnection>,
+}
+
+#[derive(Debug, Error, PartialEq, Eq)]
+pub enum SessionConfigError {
+    #[error("a session must have at least one player")]
+    NoPlayers,
+    #[error("local UDP port must be nonzero")]
+    LocalPortZero,
+    #[error("invalid network player declaration `{0}`; expected HANDLE=local or HANDLE=ADDRESS")]
+    InvalidPlayerDeclaration(String),
+    #[error("network player handle {0} is outside the session player range")]
+    PlayerHandleOutOfRange(usize),
+    #[error("network player handle {0} was declared more than once")]
+    DuplicatePlayerHandle(usize),
+    #[error("network player {0} has an invalid address: {1}")]
+    InvalidRemoteAddress(usize, String),
+    #[error("at least one player must be local")]
+    NoLocalPlayers,
+    #[error("network player declarations are not supported in sync-test or replay mode")]
+    UnsupportedOfflineNetworkConfig,
+}
+
+impl SessionConfig {
+    pub fn from_args(args: &Args, player_count: usize) -> Result<Self, SessionConfigError> {
+        if player_count == 0 {
+            return Err(SessionConfigError::NoPlayers);
+        }
+        if args.local_port == 0 {
+            return Err(SessionConfigError::LocalPortZero);
+        }
+        if (args.synctest || args.play_replay.is_some()) && !args.net_players.is_empty() {
+            return Err(SessionConfigError::UnsupportedOfflineNetworkConfig);
+        }
+
+        let mut players = vec![PlayerConnection::Local; player_count];
+        for declaration in &args.net_players {
+            let Some((handle, address)) = declaration.split_once('=') else {
+                return Err(SessionConfigError::InvalidPlayerDeclaration(
+                    declaration.clone(),
+                ));
+            };
+            let handle = handle
+                .parse::<usize>()
+                .map_err(|_| SessionConfigError::InvalidPlayerDeclaration(declaration.clone()))?;
+            if handle >= player_count {
+                return Err(SessionConfigError::PlayerHandleOutOfRange(handle));
+            }
+            if !matches!(players[handle], PlayerConnection::Local)
+                || args.net_players[..]
+                    .iter()
+                    .take_while(|item| *item != declaration)
+                    .any(|item| {
+                        item.split_once('=')
+                            .and_then(|(handle, _)| handle.parse::<usize>().ok())
+                            == Some(handle)
+                    })
+            {
+                return Err(SessionConfigError::DuplicatePlayerHandle(handle));
+            }
+            players[handle] = if address == "local" {
+                PlayerConnection::Local
+            } else {
+                PlayerConnection::Remote(
+                    parse_socket_addr(address)
+                        .map_err(|error| SessionConfigError::InvalidRemoteAddress(handle, error))?,
+                )
+            };
+        }
+
+        if !players
+            .iter()
+            .any(|player| matches!(player, PlayerConnection::Local))
+        {
+            return Err(SessionConfigError::NoLocalPlayers);
+        }
+        Ok(Self {
+            local_port: args.local_port,
+            players,
+        })
+    }
+}
+
 pub fn create_session(args: &Args, player_count: usize) -> Result<Session<GGRSCfg>> {
+    let config = SessionConfig::from_args(args, player_count)
+        .map_err(|error| bevy::ecs::error::BevyError::from(error.to_string()))?;
     let mut sess_build = SessionBuilder::<GGRSCfg>::new()
         .with_num_players(player_count)?
         .with_check_distance(args.check_distance)
-        .with_input_delay(args.input_delay); // (optional) set input delay for the local player
+        .with_input_delay(args.input_delay);
 
-    for i in 0..player_count {
+    for (handle, player) in config.players.iter().enumerate() {
-        sess_build = sess_build.add_player(PlayerType::Local, i)?;
+        let player_type = match player {
+            PlayerConnection::Local => PlayerType::Local,
+            PlayerConnection::Remote(address) => PlayerType::Remote(*address),
+        };
+        sess_build = sess_build.add_player(player_type, handle)?;
     }
 
     if args.synctest {
-        println!("Start synctest!");
+        info!("starting GGRS sync test");
-        let sess = sess_build.start_synctest_session()?;
+        Ok(Session::SyncTest(sess_build.start_synctest_session()?))
-        Ok(Session::SyncTest(sess))
     } else {
-        println!("Start p2p!");
+        info!(
-        let socket = UdpNonBlockingSocket::bind_to_port(6969)?;
+            "starting direct UDP P2P session on port {}",
-        let sess = sess_build.start_p2p_session(socket)?;
+            config.local_port
-        Ok(Session::P2P(sess))
+        );
+        let socket = UdpNonBlockingSocket::bind_to_port(config.local_port)?;
+        Ok(Session::P2P(sess_build.start_p2p_session(socket)?))
     }
 }
 
-pub fn print_events_system(session: Option<ResMut<Session<GGRSCfg>>>) {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Resource)]
-    let Some(mut session) = session else {
+pub enum ConnectionStatus {
+    #[default]
+    Connecting,
+    Running,
+    Interrupted,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Resource)]
+pub struct MatchDisconnected {
+    pub address: SocketAddr,
+}
+
+pub fn print_events_system(
+    mut commands: Commands,
+    mut next_state: ResMut<NextState<crate::AppState>>,
+    mut status: Option<ResMut<ConnectionStatus>>,
+    session: Option<ResMut<Session<GGRSCfg>>>,
+) {
+    let (Some(mut session), Some(status)) = (session, status.as_deref_mut()) else {
         return;
     };
-    match session.as_mut() {
+    let Session::P2P(session) = session.as_mut() else {
-        Session::P2P(s) => {
+        return;
-            for event in s.events() {
+    };
+    for event in session.events() {
         match event {
-                    GgrsEvent::Disconnected { .. } | GgrsEvent::NetworkInterrupted { .. } => {
+            GgrsEvent::NetworkInterrupted { addr, .. } => {
-                        warn!("GGRS event: {event:?}")
+                warn!("GGRS network interrupted: {addr}");
+                *status = ConnectionStatus::Interrupted;
             }
-                    GgrsEvent::DesyncDetected { .. } => error!("GGRS event: {event:?}"),
+            GgrsEvent::NetworkResumed { addr } => {
+                info!("GGRS network resumed: {addr}");
+                *status = ConnectionStatus::Running;
+            }
+            GgrsEvent::Disconnected { addr } => {
+                error!("GGRS peer disconnected: {addr}");
+                commands.insert_resource(MatchDisconnected { address: addr });
+                next_state.set(crate::AppState::MatchDisconnected);
+            }
+            GgrsEvent::Synchronized { .. } => {
+                info!("GGRS session synchronized");
+                *status = ConnectionStatus::Running;
+            }
+            GgrsEvent::DesyncDetected { .. } => error!("GGRS desync detected: {event:?}"),
             _ => info!("GGRS event: {event:?}"),
         }
     }
 }
-        _ => {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::Parser;
+
+    fn args(values: &[&str]) -> Args {
+        Args::try_parse_from(values).unwrap()
+    }
+
+    #[test]
+    fn defaults_to_local_players() {
+        let config = SessionConfig::from_args(&args(&["game", "--players", "2"]), 2).unwrap();
+        assert_eq!(
+            config.players,
+            [PlayerConnection::Local, PlayerConnection::Local]
+        );
+    }
+
+    #[test]
+    fn configures_remote_players_by_handle() {
+        let config = SessionConfig::from_args(
+            &args(&["game", "--players", "2", "--net-player", "1=127.0.0.1:7001"]),
+            2,
+        )
+        .unwrap();
+        assert!(matches!(config.players[0], PlayerConnection::Local));
+        assert!(matches!(config.players[1], PlayerConnection::Remote(_)));
+    }
+
+    #[test]
+    fn validates_handles_and_local_ownership() {
+        let duplicate = args(&[
+            "game",
+            "--players",
+            "2",
+            "--net-player",
+            "1=127.0.0.1:7001",
+            "--net-player",
+            "1=127.0.0.1:7002",
+        ]);
+        assert!(matches!(
+            SessionConfig::from_args(&duplicate, 2),
+            Err(SessionConfigError::DuplicatePlayerHandle(1))
+        ));
+
+        let no_local = args(&["game", "--players", "1", "--net-player", "0=127.0.0.1:7001"]);
+        assert!(matches!(
+            SessionConfig::from_args(&no_local, 1),
+            Err(SessionConfigError::NoLocalPlayers)
+        ));
     }
 }