Register loaders during asset preprocessing

## Summary
- package the production Linux binary and Bevy assets under `build/linux`
- generate Steam TOTP credentials in CI
- deploy app 3409670 to the Steam `master` branch using the latest commit hash as the build description
- restrict packaging and deployment to pushes on `master`, excluding pull requests and manual runs

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

.gitea/workflows/ci.yml

@@ -50,3 +50,78 @@ jobs:
 
       - name: Run unit tests
         run: cargo test --locked --lib -j 4
+
+  production-build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - name: Check out source
+        uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        run: |
+          curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
+            sh -s -- -y --profile minimal
+          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
+          "$HOME/.cargo/bin/rustup" toolchain install nightly-2026-09-14 --profile minimal
+
+      - name: Cache production Rust dependencies and build artifacts
+        uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        with:
+          prefix-key: v2-rust
+          shared-key: linux-nightly-production
+          cache-bin: false
+
+      - name: Install Linux dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install --no-install-recommends -y \
+            clang \
+            libasound2-dev \
+            libudev-dev \
+            libusb-1.0-0-dev \
+            libwayland-dev \
+            libx11-dev \
+            libxkbcommon-dev \
+            libxkbcommon-x11-0 \
+            mesa-vulkan-drivers \
+            mold \
+            pkg-config
+
+      - name: Preprocess assets
+        run: cargo run --locked --bin process-assets --no-default-features --features debug_features -j 4
+
+      - name: Build production binary
+        run: cargo build --locked --profile production --no-default-features --features debug_features -j 4
+
+      - name: Verify production binary is not Bevy/Rust dynamically linked
+        run: |
+          ! readelf -d target/production/shinespark | grep -E 'libbevy_dylib|libstd-.*\.so'
+
+      - name: Package Linux Steam depot
+        if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+        run: |
+          mkdir -p build/linux
+          cp target/production/shinespark build/linux/shinespark
+          cp -R assets build/linux/assets
+          cp -R imported_assets build/linux/imported_assets
+
+      - if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+        uses: CyberAndrii/steam-totp@v1
+        name: Generate Steam TOTP
+        id: steam-totp
+        with:
+          shared_secret: ${{ secrets.STEAM_SHARED_SECRET }}
+
+      - name: Deploy Linux build to Steam
+        if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+        uses: game-ci/steam-deploy@v3
+        with:
+          username: ${{ secrets.STEAM_USERNAME }}
+          password: ${{ secrets.STEAM_PASSWORD }}
+          totp: ${{ steps.steam-totp.outputs.code }}
+          appId: 3409670
+          buildDescription: ${{ github.sha }}
+          rootPath: build
+          depot1Path: linux
+          releaseBranch: master

Cargo.lock

@@ -2096,14 +2096,6 @@ dependencies = [
  "thread_local",
 ]
 
-[[package]]
-name = "bevy_wind_waker_shader"
-version = "0.6.0"
-source = "git+https://github.com/lavaeater/bevy_wind_waker_shader.git#1b017c3ef6a4fbdaff115df9ec5ae4954b2fb6ba"
-dependencies = [
- "bevy",
-]
-
 [[package]]
 name = "bevy_window"
 version = "0.19.0"
@@ -2232,32 +2224,6 @@ dependencies = [
  "varinteger",
 ]
 
-[[package]]
-name = "bitfields"
-version = "3.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca5a55e8cbc3b75d1f002a3b62261ab67954755f7e7866f079b8aa63a409b549"
-dependencies = [
- "bitfields-impl",
-]
-
-[[package]]
-name = "bitfields-impl"
-version = "3.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "797cb6b6e8d5e8c2ecbb5ef52b7c273596d58ce1ab79ef2a6c38fa8dca0817c5"
-dependencies = [
- "derive_more",
- "getset",
- "proc-macro2",
- "quote",
- "rustversion",
- "strum",
- "strum_macros",
- "syn 2.0.119",
- "thiserror 2.0.19",
-]
-
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -3468,9 +3434,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",
@@ -3523,17 +3489,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "getset"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6cf442baaabe4213ce7d1239afc26c039180b6456da2cededa316ae2c8a77a77"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "ggrs"
 version = "0.13.0"
@@ -6170,9 +6125,7 @@ dependencies = [
  "bevy_asset_loader",
  "bevy_egui",
  "bevy_ggrs",
- "bevy_wind_waker_shader",
  "bincode",
- "bitfields",
  "clap",
  "enum_cycling",
  "enum_cycling_derive",

Cargo.toml

@@ -6,8 +6,13 @@ authors = [""]
 
 [workspace]
 
+[features]
+default = ["development", "debug_features"]
+development = ["bevy/dynamic_linking", "bevy/file_watcher"]
+debug_features = ["bevy/free_camera"]
+
 [dependencies]
-bevy = { version = "0.19", features = ["asset_processor", "basis-universal", "dynamic_linking", "free_camera", "file_watcher", "bevy_settings"] }
+bevy = { version = "0.19", features = ["asset_processor", "basis-universal", "bevy_settings"] }
 # Loads the scenes you author in the editor (assets/*.bsn) and builds
 # physics colliders from them. An ordinary dependency; remove it if you
 # stop using authored scenes.
@@ -22,15 +27,13 @@ serde_json = "1.0.145"
 bincode = "1.3.3"
 gltf = "1.4.1"
 ron = "0.12.0"
-bitfields = "3.0.0"
 clap = { version = "4.6.6", features = ["derive"] }
-bevy_wind_waker_shader = { git = "https://github.com/lavaeater/bevy_wind_waker_shader.git" }
 fixed = { version = "1.31.0", features = ["serde", "serde-str"] }
 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"
@@ -39,3 +42,9 @@ fixed_math = "0.4.1"
 # Enable a large amount of optimization in the dev profile for dependencies.
 [profile.dev.package."*"]
 opt-level = 3
+
+[profile.production]
+inherits = "release"
+lto = "thin"
+codegen-units = 1
+strip = "symbols"

README.md

@@ -1,12 +1,33 @@
-# 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
+```
+
+## Production Build
+
+Production builds use the `production` Cargo profile and do not dynamically
+link Bevy or Rust. Development builds retain Bevy dynamic linking for faster
+iteration. Cargo stores the production profile under `target/production`,
+separate from development artifacts under `target/debug`.
+
+```sh
+cargo run --locked \
+  --bin process-assets --no-default-features --features debug_features
+cargo build --locked \
+  --profile production --no-default-features --features debug_features
+```
+
+The asset preprocessing command must be run from the repository root. It
+populates `imported_assets/Default`, which is then consumed by the production
+game without running the asset processor at startup.

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/bin/process-assets.rs

@@ -0,0 +1,35 @@
+use bevy::{
+    app::ScheduleRunnerPlugin,
+    asset::{AssetMode, AssetPlugin, processor::AssetProcessor, processor::ProcessorState},
+    gltf::GltfPlugin,
+    image::ImagePlugin,
+    prelude::*,
+    tasks::block_on,
+    text::TextPlugin,
+};
+use shinespark::AssetProcessingPlugin;
+use std::{process::ExitCode, time::Duration};
+
+fn main() -> ExitCode {
+    let mut app = App::new();
+    app.add_plugins(MinimalPlugins.set(ScheduleRunnerPlugin::run_loop(Duration::from_millis(50))))
+        .add_plugins(AssetPlugin {
+            mode: AssetMode::Processed,
+            use_asset_processor_override: Some(true),
+            ..default()
+        })
+        .add_plugins((ImagePlugin::default(), TextPlugin, GltfPlugin::default()))
+        .add_plugins(AssetProcessingPlugin)
+        .add_systems(Update, finish_when_processed);
+
+    app.run();
+    ExitCode::SUCCESS
+}
+
+fn finish_when_processed(processor: Option<Res<AssetProcessor>>, mut exit: MessageWriter<AppExit>) {
+    if processor
+        .is_some_and(|processor| block_on(processor.get_state()) == ProcessorState::Finished)
+    {
+        exit.write(AppExit::Success);
+    }
+}

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::*;
@@ -31,9 +32,15 @@ use crate::{
 #[derive(Deref, Component, Default, Hash, Debug, Copy, Clone)]
 pub struct FighterKnockbackVelocity(pub FGVec2);
 
-#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Component, Hash)]
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Component, Hash, PartialEq)]
 pub struct FighterDamage(FGi32);
 
+impl std::fmt::Display for FighterDamage {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:.2}", self.0)
+    }
+}
+
 #[derive(Debug, Hash, Clone)]
 pub enum HitReactionKind {
     Flinch,
@@ -42,10 +49,12 @@ 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,
+    pub damage: FighterDamage,
 }
 
 #[derive(Component, DerefMut, Deref, Debug, Default, Hash, Clone)]
@@ -62,10 +71,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 +90,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,31 +1,24 @@
 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(
     mut pending_hits: ResMut<FighterPendingHits>,
     mut attacker: Query<(
-        &FighterStaleMoveQueue,
+        &mut FighterStaleMoveQueue,
         &FighterFacingDirection,
-        &FighterHitboxes,
+        &mut 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, _, player, _, _)) =
                     attacker.get(hit.attacker)
                 else {
                     return None;
@@ -59,7 +52,6 @@ pub fn resolve_fighter_hits(
                 let damage_received = stale_move_queue
                     .get_attack_damage_multiplier(hit.attack_kind)
                     * hitbox.damage.0;
-
                 Some((
                     hit.attacker,
                     damage_received,
@@ -96,17 +88,19 @@ pub fn resolve_fighter_hits(
             } else {
                 angle
             };
-            let (sin, cos) = launch_angle.sin_cos();
+
-            let launch_direction = FGVec2::new(cos, sin);
+            // Attacker hitstop and data
             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,
+                    damage: FighterDamage(attack_damage)
                 },
             ));
         }
@@ -114,10 +108,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
@@ -128,6 +135,19 @@ pub fn resolve_fighter_hits(
         hit_offset = next_defender;
     }
 
+    for hit in hits {
+        let Ok((mut stale_move_queue, _facing_direction, mut hitboxes, ..)) = attacker.get_mut(hit.attacker) else {
+            continue;
+        };
+
+        if let Some(ref mut hitbox) = hitboxes.0 {
+            if !hitbox.stalled {
+                hitbox.stalled = true;
+                stale_move_queue.push(hitbox.kind);
+            }
+        }
+    }
+
     Ok(())
 }
 

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/baked_animation/asset_baking.rs

@@ -151,7 +151,10 @@ type FighterBakeProcessor = LoadTransformAndSave<
 >;
 
 pub struct BakedAnimationPlugin;
-impl Plugin for BakedAnimationPlugin {
+
+pub struct BakedAnimationAssetProcessingPlugin;
+
+impl Plugin for BakedAnimationAssetProcessingPlugin {
     fn build(&self, app: &mut App) {
         app.init_asset::<BakedFighterAnimations>()
             .register_asset_loader(FighterBakeSourceLoader)
@@ -160,7 +163,13 @@ impl Plugin for BakedAnimationPlugin {
                 FighterBakeTransformer,
                 BakedFighterAnimationsSaver,
             ))
-            .set_default_asset_processor::<FighterBakeProcessor>("fighterbake")
+            .set_default_asset_processor::<FighterBakeProcessor>("fighterbake");
+    }
+}
+
+impl Plugin for BakedAnimationPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(BakedAnimationAssetProcessingPlugin)
             .add_systems(
                 bevy_ggrs::prelude::GgrsSchedule,
                 super::runtime::update_fighter_bone_matrices

src/fighter/baked_animation/mod.rs

@@ -4,7 +4,7 @@ mod asset_baking;
 mod runtime;
 mod visual_binding;
 
-pub use asset_baking::BakedAnimationPlugin;
+pub use asset_baking::{BakedAnimationAssetProcessingPlugin, BakedAnimationPlugin};
 pub use crate::math::fixed_transform::FixedMat4;
 pub use runtime::{
     BakedAnimationClip, BakedFighterAnimations, FighterBoneIndexMap, FighterBoneMatrices,

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>()
@@ -245,6 +259,7 @@ pub struct FighterActiveAttack {
     pub active_hitboxes: Vec<usize>,
     pub solved_hitboxes: Vec<attack::FighterSolvedHitbox>,
     pub hit_fighters: Vec<Entity>,
+    pub stalled: bool
 }
 
 #[derive(Component, Clone, Debug, Default, Hash)]
@@ -285,7 +300,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 +314,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,
         )
     }
-}
     
-pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
+    fn is_visually_grounded<'a>(
-    let input_frame = state_context.input.get_last_frame();
+        &'a self,
-
+    ) -> bool {
-    if input_frame.movement.x.abs() < state_context.game_settings.input_common.stick_deadzone {
+        false
-        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

@@ -47,13 +47,13 @@ impl FighterStateImpl for GroundAttackState {
     fn on_enter(&mut self, state_context: &mut EnterContext) {
         state_context.play_animation(self.attack_kind.get_animation(), false);
         let script = state_context.attack_script_assets.scripts[&self.attack_kind].clone();
-        state_context.stale_move_queue.push(self.attack_kind);
         state_context.hitboxes.0 = Some(crate::fighter::FighterActiveAttack {
             kind: self.attack_kind,
             script,
             active_hitboxes: Vec::new(),
             solved_hitboxes: Vec::new(),
             hit_fighters: Vec::new(),
+            stalled: false
         });
     }
 
@@ -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

@@ -28,13 +28,17 @@ use bevy::{
     tasks::block_on,
 };
 use bevy_asset_loader::prelude::*;
-use bevy_wind_waker_shader::prelude::*;
 use clap::Parser;
 use ron_asset_manager::RonAssetPlugin;
 
 use crate::{
-    camera::MatchCameraPlugin, fighter::manifest::FighterManifest, game_settings::GameSettings,
+    camera::MatchCameraPlugin,
-    schedule::GameplaySchedulePlugin, stage::manifest::StageManifest,
+    fighter::manifest::FighterManifest,
+    game_settings::GameSettings,
+    menus::style::FGUiStyle,
+    schedule::GameplaySchedulePlugin,
+    stage::manifest::StageManifest,
+    ui::InGameUIPlugin,
 };
 
 mod args;
@@ -53,6 +57,7 @@ pub mod schedule;
 pub mod scripting;
 pub mod stage;
 pub mod texture_reference;
+pub mod ui;
 
 #[derive(States, Debug, Clone, Copy, Eq, PartialEq, Hash, Default)]
 pub enum AppState {
@@ -71,6 +76,7 @@ pub enum AppState {
     LoadingMatch,
     PreparingMatch,
     InMatch,
+    MatchDisconnected,
     MatchLoadFailed,
 }
 
@@ -80,6 +86,20 @@ pub enum AppState {
 #[derive(Default)]
 pub struct GamePlugin;
 
+/// Registers every custom asset loader used by the game and asset processor.
+pub struct GameAssetPlugin;
+
+impl Plugin for GameAssetPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins((
+            RonAssetPlugin::<FighterManifest>::create("fighter.ron"),
+            RonAssetPlugin::<StageManifest>::create("stage.ron"),
+            RonAssetPlugin::<GameSettings>::create("ron"),
+            RonAssetPlugin::<FGUiStyle>::create("stylesheet.ron"),
+        ));
+    }
+}
+
 impl Plugin for GamePlugin {
     fn build(&self, app: &mut App) {
         // Each module owns its own systems, rollback registrations and
@@ -88,7 +108,6 @@ impl Plugin for GamePlugin {
         app.init_state::<AppState>()
             .add_plugins((
                 SettingsPlugin::new("moe.eirteam.shinespark.debug_settings"),
-                WindWakerShaderPlugin::default(),
                 // Brings up GGRS (and with it `GgrsSchedule`), so it goes first.
                 netcode::FighterNetcodePlugin::default(),
                 GameplaySchedulePlugin,
@@ -100,9 +119,8 @@ impl Plugin for GamePlugin {
                 scripting::importer::FighterScriptImportPlugin,
                 stage::StagePlugin,
                 MatchCameraPlugin,
-                RonAssetPlugin::<FighterManifest>::create("fighter.ron"),
+                GameAssetPlugin,
-                RonAssetPlugin::<StageManifest>::create("stage.ron"),
+                InGameUIPlugin,
-                RonAssetPlugin::<GameSettings>::create("ron"),
             ))
             .add_plugins(menus::MenuPlugin)
             .add_loading_state(
@@ -155,11 +173,27 @@ impl Plugin for GamePlugin {
     }
 }
 
+/// Registers the custom asset loaders and processors used by CI and release
+/// builds. The processing binary adds this plugin without starting the game.
+pub struct AssetProcessingPlugin;
+
+impl Plugin for AssetProcessingPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins((
+            GameAssetPlugin,
+            scripting::importer::FighterScriptImportPlugin,
+            fighter::baked_animation::BakedAnimationAssetProcessingPlugin,
+        ));
+    }
+}
+
 fn wait_for_asset_processor(
     processor: Option<Res<AssetProcessor>>,
     mut next_state: ResMut<NextState<AppState>>,
 ) {
-    if processor.is_none_or(|processor| block_on(processor.get_state()) == ProcessorState::Finished)
+    if !cfg!(feature = "development")
+        || processor
+            .is_none_or(|processor| block_on(processor.get_state()) == ProcessorState::Finished)
     {
         next_state.set(AppState::LoadCommonAssets);
     }

src/main.rs

@@ -1,8 +1,11 @@
 use bevy::asset::AssetMode::Processed;
+#[cfg(feature = "debug_features")]
 use bevy::camera_controller::free_camera::FreeCameraPlugin;
 use bevy::image::{ImageAddressMode, ImagePlugin, ImageSamplerDescriptor};
 use bevy::prelude::*;
+#[cfg(feature = "debug_features")]
 use bevy_egui::EguiPlugin;
+#[cfg(feature = "debug_features")]
 use bevy_inspector_egui::quick::WorldInspectorPlugin;
 
 fn main() -> AppExit {
@@ -20,16 +23,22 @@ fn main() -> AppExit {
         })
         .set(AssetPlugin {
             mode: Processed,
+            use_asset_processor_override: Some(cfg!(feature = "development")),
             ..default()
         });
 
-    App::new()
+    let mut app = App::new();
-        .add_plugins(default_plugins)
+    app.add_plugins(default_plugins)
         .add_plugins(avian3d::prelude::PhysicsPlugins::default())
         .add_plugins(shinespark::GamePlugin)
-        .add_plugins(FreeCameraPlugin)
+        .insert_resource(Time::<Fixed>::from_hz(60.0));
-        .add_plugins(EguiPlugin::default())
+
-        .add_plugins(WorldInspectorPlugin::default()) // adds default options and `InspectorEguiImpl`s
+    #[cfg(feature = "debug_features")]
-        .insert_resource(Time::<Fixed>::from_hz(60.0))
+    app.add_plugins((
-        .run()
+        FreeCameraPlugin,
+        EguiPlugin::default(),
+        WorldInspectorPlugin::default(),
+    ));
+
+    app.run()
 }

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/menus/mod.rs

@@ -6,12 +6,10 @@ use bevy::{
     prelude::*,
 };
 
-use ron_asset_manager::RonAssetPlugin;
-
 use crate::{
     AppState,
     game_settings::CommonAssets,
-    menus::{character_select::CharacterSelectScreen, main_menu::MainMenu, style::FGUiStyle},
+    menus::{character_select::CharacterSelectScreen, main_menu::MainMenu},
 };
 pub mod button;
 pub mod character_select;
@@ -222,7 +220,6 @@ impl Plugin for MenuPlugin {
         //---------
         // STAGE SELECT END
         //---------
-        .add_plugins(RonAssetPlugin::<FGUiStyle>::create("stylesheet.ron"))
         .add_systems(
             Update,
             (

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)
+        ));
     }
 }

src/ui/battle_ui.rs

@@ -0,0 +1,57 @@
+use bevy::prelude::*;
+
+use crate::{
+    fighter::manifest::{FighterManifest, FighterManifestRegistry}, match_loading::{PendingMatch}, ui::{errors::UIErrors, fighter_info::FighterInfoUI},
+};
+
+#[derive(Component, FromTemplate)]
+pub struct BattleUI {
+}
+
+pub fn spawn_battle_ui(mut commands: Commands, request: Res<PendingMatch>, fighter_registry: Res<FighterManifestRegistry>, manifests: Res<Assets<FighterManifest>>) -> Result {
+
+    let mut fighter_uis = vec![];
+
+    for player in &request.players {
+        let manifest = fighter_registry.get(player.fighter).ok_or_else(|| UIErrors::FighterManifestHandleNotFound(player.fighter))?;
+        let manifest = manifests.get(manifest).ok_or_else(|| UIErrors::FighterManifestNotFound(player.fighter))?;
+
+        fighter_uis.push(FighterInfoUI::build(manifest, player));
+    }
+
+    let scene = bsn! {
+        BattleUI {
+        }
+        Node {
+            width: percent(100),
+            height: percent(100),
+            flex_direction: FlexDirection::Column,
+            align_items: AlignItems::Center,
+            justify_content: JustifyContent::End,
+        }
+        Children [
+            (
+                #FighterInfos
+                Node {
+                    width: percent(100),
+                    flex_direction: FlexDirection::Row,
+                    align_items: AlignItems::End,
+                    justify_content: JustifyContent::SpaceEvenly,
+                }
+                Children [
+                    {fighter_uis}
+                ]
+            )
+        ]
+    };
+
+    commands.spawn_scene(scene);
+
+    Ok(())
+}
+
+pub fn cleanup_battle_ui(mut commands: Commands, battle_ui: Query<Entity, With<BattleUI>>) {
+    for entity in battle_ui {
+        commands.entity(entity).despawn();
+    }
+}

src/ui/errors.rs

@@ -0,0 +1,14 @@
+use bevy::{scene::SpawnSceneError};
+
+use crate::{fighter::FighterId};
+
+#[derive(thiserror::Error, Debug)]
+pub enum UIErrors {
+    #[error("Scene spawn failed: {0:?}")]
+    SceneSpawnFailed(#[from] SpawnSceneError),
+    #[error("Fighter manifest handle not found for fighter id {0:?}")]
+    FighterManifestHandleNotFound(FighterId),
+
+    #[error("Fighter manifest not found for fighter id {0:?}")]
+    FighterManifestNotFound(FighterId),
+}

src/ui/fighter_info.rs

@@ -0,0 +1,57 @@
+use bevy::prelude::*;
+
+use crate::{fighter::{attack::FighterDamage, manifest::{FighterManifest}}, match_loading::MatchPlayer, player::Player};
+
+#[derive(Component, FromTemplate)]
+pub struct FighterInfoUI {
+    percentage_text: Entity,
+    _name_text: Entity,
+    player_handle: usize,
+    visible_damage: FighterDamage,
+}
+
+impl FighterInfoUI {
+    pub fn build(_manifest: &FighterManifest, match_player: &MatchPlayer) -> impl Scene {
+        let fighter_name = "El grande padre";
+        bsn! {
+            FighterInfoUI {
+                percentage_text: #PercentageText,
+                _name_text: #NameText,
+                player_handle: {match_player.handle}
+            }
+            Node {
+                flex_direction: FlexDirection::Column,
+                align_items: AlignItems::Center,
+                justify_content: JustifyContent::Center,
+            }
+            Children [
+                (
+                    #PercentageText
+                    Text("0.00%")
+                    TextFont {
+                        font_size: px(crate::menus::style::H2_SIZE),
+                    }
+                ),
+                (
+                    #NameText
+                    Text({fighter_name})
+                )
+            ]
+        }
+    }
+}
+
+pub fn update_fighter_info_damage(fighters: Query<(&Player, &FighterDamage)>, ui_elements: Query<&mut FighterInfoUI>, mut commands: Commands) {
+    for mut ui_element in ui_elements {
+        let Some((_, damage)) = fighters.iter().find(|(player, _)| {
+            player.handle == ui_element.player_handle
+        }) else {
+            continue;
+        };
+
+        if *damage != ui_element.visible_damage {
+            commands.entity(ui_element.percentage_text).insert(Text(format!("{}%", damage)));
+            ui_element.visible_damage = damage.clone();
+        }
+    }
+}

src/ui/mod.rs

@@ -0,0 +1,18 @@
+use bevy::prelude::*;
+
+use crate::AppState;
+
+pub mod battle_ui;
+pub mod errors;
+pub mod fighter_info;
+
+#[derive(Default)]
+pub struct InGameUIPlugin;
+
+impl Plugin for InGameUIPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(OnEnter(AppState::InMatch), battle_ui::spawn_battle_ui)
+            .add_systems(OnExit(AppState::InMatch), battle_ui::cleanup_battle_ui)
+            .add_systems(PostUpdate, fighter_info::update_fighter_info_damage);
+    }
+}