Expose LLVM tools to Windows build

Use Clang 19 for Windows cross-builds
Fix blake build
2026-09-19 23:14:03 +02:00 · 2026-09-19 22:53:19 +02:00 · 2026-09-19 22:28:04 +02:00 · 2026-09-19 22:15:16 +02:00 · 2026-09-19 22:12:35 +02:00 · 2026-09-19 22:01:52 +02:00
41 changed files with 832 additions and 264 deletions
@@ -50,3 +50,94 @@ 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: Install Windows build tooling
+        run: |
+          "$HOME/.cargo/bin/rustup" target add x86_64-pc-windows-msvc --toolchain nightly-2026-09-14
+          "$HOME/.cargo/bin/cargo" install cargo-xwin --locked
+
+      - 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-19 \
+            libasound2-dev \
+            libudev-dev \
+            libusb-1.0-0-dev \
+            libwayland-dev \
+            libx11-dev \
+            libxkbcommon-dev \
+            libxkbcommon-x11-0 \
+            lld-19 \
+            llvm-19 \
+            mesa-vulkan-drivers \
+            mold \
+            pkg-config
+          sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-19 100
+          sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-19 100
+          echo "/usr/lib/llvm-19/bin" >> "$GITHUB_PATH"
+          rm -f "$HOME/.cache/cargo-xwin/clang-cl"
+
+      - 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: Build Windows production binary
+        run: |
+          clang --version
+          cargo xwin build --locked --target x86_64-pc-windows-msvc --profile production --no-default-features --features debug_features -j 4 --bin shinespark
+
+      - 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/game
+          cp target/production/shinespark build/game/shinespark
+          cp target/x86_64-pc-windows-msvc/production/shinespark.exe build/game/shinespark.exe
+          cp -R imported_assets build/game/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: game
+          releaseBranch: master
@@ -94,12 +94,6 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"

-[[package]]
-name = "adler32"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
-
 [[package]]
 name = "ahash"
 version = "0.8.12"
@@ -2096,14 +2090,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 +2218,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"
@@ -3242,16 +3202,6 @@ dependencies = [
 "windows-sys 0.60.2",
 ]

-[[package]]
-name = "filetime"
-version = "0.2.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"
-dependencies = [
- "cfg-if",
- "libc",
-]
-
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.9"
@@ -3468,9 +3418,9 @@ dependencies = [

 [[package]]
 name = "gc-adapter-neo"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "120a5b3858ae854c4674ae41a38173e8ea04b814fb3212fd3bdd1b04d414a9d7"
+checksum = "a8d3e10c6c4b928cb559f641765ebaa40f5f099bf51bc0227af7431859f8bd84"
 dependencies = [
 "binread",
 "modular-bitfield",
@@ -3523,17 +3473,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"
@@ -4311,26 +4250,6 @@ version = "0.2.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"

-[[package]]
-name = "libflate"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ff4ae71b685bbad2f2f391fe74f6b7659a34871c08b210fdc039e43bee07d18"
-dependencies = [
- "adler32",
- "crc32fast",
- "libflate_lz77",
-]
-
-[[package]]
-name = "libflate_lz77"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a52d3a8bfc85f250440e4424db7d857e241a3aebbbe301f3eb606ab15c39acbf"
-dependencies = [
- "rle-decode-fast",
-]
-
 [[package]]
 name = "libloading"
 version = "0.8.9"
@@ -4371,15 +4290,13 @@ dependencies = [

 [[package]]
 name = "libusb1-sys"
-version = "0.4.4"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be241693102a24766d0b8526c8988771edac2842630d7e730f8e9fbc014f3703"
+checksum = "da050ade7ac4ff1ba5379af847a10a10a8e284181e060105bf8d86960ce9ce0f"
 dependencies = [
 "cc",
 "libc",
- "libflate",
 "pkg-config",
- "tar",
 "vcpkg",
 ]

@@ -5885,12 +5802,6 @@ dependencies = [
 "syn 2.0.119",
 ]

-[[package]]
-name = "rle-decode-fast"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3582f63211428f83597b51b2ddb88e2a91a9d52d12831f9d08f5e624e8977422"
-
 [[package]]
 name = "robust"
 version = "1.2.0"
@@ -5961,9 +5872,9 @@ dependencies = [

 [[package]]
 name = "rusb"
-version = "0.6.5"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f32cd45962594f9f8cd4547b5757132715600e2c8840aa9ccd3d1a9ed6fdc6"
+checksum = "ab9f9ff05b63a786553a4c02943b74b34a988448671001e9a27e2f0565cc05a4"
 dependencies = [
 "libc",
 "libusb1-sys",
@@ -6170,9 +6081,8 @@ dependencies = [
 "bevy_asset_loader",
 "bevy_egui",
 "bevy_ggrs",
- "bevy_wind_waker_shader",
 "bincode",
- "bitfields",
+ "blake3",
 "clap",
 "enum_cycling",
 "enum_cycling_derive",
@@ -6542,17 +6452,6 @@ dependencies = [
 "slotmap",
 ]

-[[package]]
-name = "tar"
-version = "0.4.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840"
-dependencies = [
- "filetime",
- "libc",
- "xattr",
-]
-
 [[package]]
 name = "termcolor"
 version = "1.4.1"
@@ -7958,16 +7857,6 @@ version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"

-[[package]]
-name = "xattr"
-version = "1.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
-dependencies = [
- "libc",
- "rustix 1.1.4",
-]
-
 [[package]]
 name = "xcursor"
 version = "0.3.11"
@@ -6,11 +6,17 @@ 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.
+blake3 = { version = "1.8.5", features = [ "pure" ] }
 thiserror = "2"
 avian3d = "0.7"
 arrayvec = "0.7.8"
@@ -22,15 +28,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.1.0", features = ["libusb"] }
+gc-adapter-neo = { version = "1.1.1", features = ["libusb"] }
 rhai = "1.26.0"
 enum_cycling = "0.2.1"
 enum_cycling_derive = "0.2.1"
@@ -39,3 +43,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"
@@ -13,3 +13,21 @@ cargo run -- --debug-match --players 2 --local-port 7000 \
 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.
@@ -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,
@@ -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"
@@ -0,0 +1,36 @@
+use bevy::{
+    app::ScheduleRunnerPlugin,
+    asset::{AssetMode, AssetPlugin, processor::AssetProcessor, processor::ProcessorState},
+    gltf::GltfPlugin,
+    image::{CompressedImageFormats, ImageLoader, 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()))
+        .register_asset_loader(ImageLoader::new(CompressedImageFormats::NONE))
+        .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);
+    }
+}
@@ -1,22 +1,12 @@
 use bevy::prelude::*;

 use crate::{
-    camera::MatchCamera,
-    fighter::{
-        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop,
-        FighterPreviousFacingDirection, FighterPreviousTranslation, FighterTranslation,
-        FighterVelocity, Grounded,
-        animation::FighterAnimationFrame,
-        attack::{
+    camera::MatchCamera, fighter::{
+        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterPreviousFacingDirection, FighterPreviousTranslation, FighterTranslation, FighterVelocity, Grounded, animation::FighterAnimationFrame, attack::{
            FighterDamage, FighterKnockbackVelocity, FighterPendingHitReaction, FighterPendingHits,
            FighterSolvedHurtboxes, FighterStaleMoveQueue,
-        },
-        baked_animation::FighterBoneMatrices,
-        state::FighterState,
-    },
-    input::FighterInput,
-    player::Player,
-    stage::line::StageCollision,
+        }, baked_animation::FighterBoneMatrices, state::FighterState,
+    }, input::FighterInput, player::Player, stage::line::StageCollision,
 };

 #[derive(Resource, Default)]
@@ -48,6 +38,7 @@ struct FighterCheckpoint {
    damage: FighterDamage,
    pending_hit_reaction: FighterPendingHitReaction,
    hitstop: FighterHitstop,
+    hitstop_shake: FighterHitstopShake,
    knockback_velocity: FighterKnockbackVelocity,
    stale_moves: FighterStaleMoveQueue,
    hitboxes: FighterHitboxes,
@@ -146,6 +137,7 @@ pub(super) fn save_or_restore(world: &mut World) {
        entity.insert(saved.damage);
        entity.insert(saved.pending_hit_reaction.clone());
        entity.insert(saved.hitstop);
+        entity.insert(saved.hitstop_shake);
        entity.insert(saved.knockback_velocity);
        entity.insert(saved.stale_moves.clone());
        entity.insert(saved.hitboxes.clone());
@@ -183,6 +175,7 @@ fn capture_fighter(world: &World, entity: Entity) -> Option<FighterCheckpoint> {
        damage: *fighter.get::<FighterDamage>()?,
        pending_hit_reaction: fighter.get::<FighterPendingHitReaction>()?.clone(),
        hitstop: *fighter.get::<FighterHitstop>()?,
+        hitstop_shake: *fighter.get::<FighterHitstopShake>()?,
        knockback_velocity: *fighter.get::<FighterKnockbackVelocity>()?,
        stale_moves: fighter.get::<FighterStaleMoveQueue>()?.clone(),
        hitboxes: fighter.get::<FighterHitboxes>()?.clone(),
@@ -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);
+    }
+}
@@ -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,11 +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)]
@@ -82,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)]
@@ -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,
-        FighterPendingHitReaction, FighterStaleMoveQueue, errors::FighterErrors,
-        manifest::FighterManifest,
-    },
-    game_settings::GameSettings,
-    math::{int::FGi32, vec::FGVec2},
-    player::Player,
-    schedule::GameplaySet,
-    scripting::FighterAttackScript,
+        Fighter, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole, FighterPendingHitReaction, FighterStaleMoveQueue, errors::FighterErrors, manifest::FighterManifest, state::FighterState,
+    }, game_settings::GameSettings, math::{int::FGi32}, player::Player, schedule::GameplaySet, scripting::FighterAttackScript,
 };

 pub fn resolve_fighter_hits(
    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,18 +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)
                },
            ));
        }
@@ -115,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
@@ -129,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(())
 }

@@ -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,

@@ -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
@@ -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,
@@ -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
@@ -33,24 +33,13 @@ pub use motion::{
 };

 use crate::{
-    AppState,
-    fighter::{
+    AppState, fighter::{
        attack::{
            AttackKind, FighterAttackPlugin, FighterAttackScriptAssets, FighterDamage,
            FighterKnockbackVelocity, FighterPendingHitReaction, FighterSolvedHurtboxes,
            FighterStaleMoveQueue,
-        },
-        baked_animation::{FighterBoneIndexMap, FighterBoneMatrices},
-        manifest::FighterManifest,
-        state::{FighterState, fall::FallState},
-        visual::FighterAnimations,
-    },
-    input::FighterInput,
-    math::{int::FGi32, vec::FGVec2},
-    player::Player,
-    schedule::GameplaySet,
-    scripting::FighterAttackScript,
-    stage::line::StageCollision,
+        }, baked_animation::{FighterBoneIndexMap, FighterBoneMatrices}, manifest::FighterManifest, state::{FighterState, air::AirborneStateCommon, 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>) {
-    for mut hitstop in query {
+pub fn decay_hitstop(query: Query<(&mut FighterHitstop, &mut FighterHitstopShake)>) {
+    for (mut hitstop, mut hitstop_shake) in query {
        hitstop.remaining_frames = hitstop.remaining_frames.saturating_sub(1);
+        hitstop_shake.remaining_frames = hitstop_shake.remaining_frames.saturating_sub(1);
    }
 }
@@ -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(
@@ -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) {
-    integrate_gravity(ctx.velocity, ctx.fighter_attributes);
+pub fn update_standard_motion(
+    ctx: &mut crate::fighter::state::UpdateContext,
+    airborne_common: &mut AirborneStateCommon,
+) {
+    process_fast_fall(airborne_common, ctx.input, &mut ctx.velocity, ctx.fighter_attributes);
+    integrate_gravity(ctx.velocity, ctx.fighter_attributes, airborne_common.is_fast_falling);
    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"),
@@ -1,13 +1,9 @@
 use crate::{
    fighter::{
-        animation::AnimKind,
-        state::{
-            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext,
-            UpdateContext, air, fall::FallState, land::LandingType,
+        animation::AnimKind, state::{
+            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, 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> {
@@ -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> {
@@ -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)]
-pub struct FallState;
+#[derive(Debug, Clone, Copy, Hash, Default)]
+pub struct FallState {
+    airborne_state_common: AirborneStateCommon
+}
+
+impl FallState {
+    pub fn new(airborne_state_common: AirborneStateCommon) -> Self {
+        Self {
+            airborne_state_common
+        }
+    }
+}

 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
-}
@@ -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()))),
    }
 }

@@ -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(
@@ -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,
+        }
+    }
 }
@@ -2,16 +2,10 @@ use bevy::prelude::*;

 use crate::{
    fighter::{
-        animation::AnimKind,
-        state::{
-            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext,
-            UpdateContext, air,
-            air_dodge::{self, AirDodgeState},
-            ground::{self, GroundedStateCommon},
+        animation::AnimKind, state::{
+            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, 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()
            })
        })
 }
@@ -69,4 +69,10 @@ impl FighterStateImpl for LandingState {
            }
        };
    }
+    
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
+        true
+    }
 }
@@ -16,8 +16,7 @@ use crate::fighter::manifest::FighterManifest;
 use crate::fighter::state::hitstun::HitstunState;
 use crate::fighter::visual::FighterAnimations;
 use crate::fighter::{
-    Fighter, FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop,
-    FighterPreviousTranslation, FighterTranslation, FighterVelocity,
+    Fighter, FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole, FighterPreviousTranslation, FighterTranslation, FighterVelocity,
 };
 use crate::game_settings::GameSettings;
 use crate::input::FighterInput;
@@ -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,6 +400,16 @@ pub fn state_interrupt_system(

        let new_state = if let Some(reaction) = pending_hit_reaction.take() {
            hitstop.remaining_frames = *reaction.hitstop_frames;
+            let shake_frames = reaction.hitstop_frames.calculate_shake_frames(&game_settings);
+            hitstop_shake.role = FighterHitstopShakeRole::Receiver;
+            hitstop_shake.total_frames = shake_frames;
+            hitstop_shake.remaining_frames = shake_frames;
+            hitstop_shake.kind = if state.is_visually_grounded() {
+                FighterHitstopShakeKind::Horizontal
+            } else {
+                FighterHitstopShakeKind::Vertical
+            };
+            
            let mut hitstop_kind = match &*state {
                FighterState::Wait(value) => {
                    hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
@@ -432,10 +451,10 @@ pub fn state_interrupt_system(
            }

            info!("Entering hitstop kind: {:?}", hitstop_kind);
-            Some(FighterState::Hitstun(HitstunState {
-                hit_reaction: reaction,
+            Some(FighterState::Hitstun(HitstunState::new(
+                reaction,
                hitstop_kind,
-            }))
+            )))
        } else if hitstop.remaining_frames > 0 {
            None
        } else {
@@ -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(
@@ -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(
@@ -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(
@@ -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(
@@ -31,6 +31,14 @@ pub struct FighterSettingsCommon {

    /// 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)]
@@ -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 {
@@ -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,
-    schedule::GameplaySchedulePlugin, stage::manifest::StageManifest,
+    camera::MatchCameraPlugin,
+    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 {
@@ -81,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
@@ -89,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,
@@ -101,9 +119,8 @@ impl Plugin for GamePlugin {
                scripting::importer::FighterScriptImportPlugin,
                stage::StagePlugin,
                MatchCameraPlugin,
-                RonAssetPlugin::<FighterManifest>::create("fighter.ron"),
-                RonAssetPlugin::<StageManifest>::create("stage.ron"),
-                RonAssetPlugin::<GameSettings>::create("ron"),
+                GameAssetPlugin,
+                InGameUIPlugin,
            ))
            .add_plugins(menus::MenuPlugin)
            .add_loading_state(
@@ -156,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);
    }
@@ -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()
-        .add_plugins(default_plugins)
+    let mut app = App::new();
+    app.add_plugins(default_plugins)
        .add_plugins(avian3d::prelude::PhysicsPlugins::default())
        .add_plugins(shinespark::GamePlugin)
-        .add_plugins(FreeCameraPlugin)
-        .add_plugins(EguiPlugin::default())
-        .add_plugins(WorldInspectorPlugin::default()) // adds default options and `InspectorEguiImpl`s
-        .insert_resource(Time::<Fixed>::from_hz(60.0))
-        .run()
+        .insert_resource(Time::<Fixed>::from_hz(60.0));
+
+    #[cfg(feature = "debug_features")]
+    app.add_plugins((
+        FreeCameraPlugin,
+        EguiPlugin::default(),
+        WorldInspectorPlugin::default(),
+    ));
+
+    app.run()
 }
@@ -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,
            (
@@ -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();
+    }
+}
@@ -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),
+}
@@ -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();
+        }
+    }
+}
@@ -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);
+    }
+}
Author	SHA1	Message	Date
EIREXE	15052e7e16	Expose LLVM tools to Windows build CI / production-build (pull_request) Successful in 22m8s Details CI / build-and-test (pull_request) Successful in 1m17s Details	2026-09-19 23:14:03 +02:00
EIREXE	48896d5c1e	Use Clang 19 for Windows cross-builds CI / build-and-test (pull_request) Successful in 1m22s Details CI / production-build (pull_request) Failing after 14m59s Details	2026-09-19 22:53:19 +02:00
EIREXE	350b37a4da	Fix blake build CI / build-and-test (pull_request) Successful in 6m54s Details CI / production-build (pull_request) Failing after 14m15s Details	2026-09-19 22:28:04 +02:00
EIREXE	4d474227cc	Install Windows tooling in production job CI / build-and-test (pull_request) Successful in 3m10s Details CI / production-build (pull_request) Failing after 8m23s Details	2026-09-19 22:15:16 +02:00
EIREXE	b5cc5428d2	Bump gc driver	2026-09-19 22:12:35 +02:00
EIREXE	49b23110ff	Build Windows binary in shared Steam depot CI / build-and-test (pull_request) Successful in 1m46s Details CI / production-build (pull_request) Failing after 4m50s Details	2026-09-19 22:01:52 +02:00
EIREXE	9ba8697d57	Include missing battlefield icon CI / build-and-test (push) Successful in 1m10s Details CI / production-build (push) Successful in 5m5s Details	2026-09-19 21:54:33 +02:00
EIREXE	7d9b6aeafc	Fix headless asset preprocessing hang (#49 ) CI / build-and-test (push) Successful in 1m9s Details CI / production-build (push) Successful in 5m23s Details ## Summary - register Bevy's image loader explicitly in the headless asset processor - use no GPU-compressed image formats because the processor has no render device - allow PNG processing tasks to complete so `ProcessorState` reaches `Finished` Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-19 19:07:39 +00:00
EIREXE	ab6aec70c5	Fix processed RON assets being ignored (#48 ) CI / build-and-test (push) Successful in 1m9s Details CI / production-build (push) Canceled after 10m37s Details ## Summary - share custom RON asset loaders between the game and asset processor - register image, font, and glTF loaders in the headless processor - prevent `game_settings.ron` and `game.stylesheet.ron` from receiving ignored processed metadata Reviewed-on: #48 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-19 18:09:40 +00:00
EIREXE	de5d8eb030	Deploy production Linux builds to Steam (#47 ) CI / production-build (push) Successful in 5m15s Details CI / build-and-test (push) Successful in 1m8s Details ## 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>	2026-09-19 17:32:04 +00:00
EIREXE	0dc5d0392d	Add production build pipeline (#46 ) CI / build-and-test (push) Successful in 1m8s Details CI / production-build (push) Successful in 4m39s Details ## Summary - split development dynamic linking from production builds - add headless processed-asset generation - add a separate production CI cache and static Bevy/Rust linkage verification - keep custom debug features enabled for production builds behind a feature gate Reviewed-on: #46 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-19 17:04:18 +00:00
EIREXE	804e5e37e0	Implement damage UI, damage and stale moves. (#45 ) CI / build-and-test (push) Successful in 1m30s Details Reviewed-on: #45 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-19 15:40:44 +00:00
EIREXE	7269a1cb49	Implement fast falling (#44 ) CI / build-and-test (push) Successful in 1m17s Details Reviewed-on: #44 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-18 22:23:03 +00:00
EIREXE	9f51207f48	Implement directional influence (#43 ) CI / build-and-test (push) Successful in 1m9s Details Reviewed-on: #43 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-18 20:43:41 +00:00
EIREXE	2b5af49e15	Implement hitstop shake (#42 ) CI / build-and-test (push) Successful in 1m22s Details Reviewed-on: #42 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-18 11:56:53 +00:00