Fix prod build

Attack system revamp
- Add crouch cancelling - Add IASA for aerial attacks - Add scaffolding for autocancel - Add hitbox group system - Add new ergonomic features for attack scripting - Add more information to the hitbox viewer - Improve the looks of debug capsules
2026-10-04 18:51:29 +02:00 · 2026-10-04 17:16:42 +02:00 · 2026-10-04 11:32:28 +00:00 · 2026-10-03 10:47:00 +00:00 · 2026-10-03 09:20:56 +00:00 · 2026-10-02 11:19:01 +00:00
85 changed files with 6374 additions and 1125 deletions
@@ -63,7 +63,6 @@ jobs:
            libxkbcommon-dev \
            libxkbcommon-x11-0 \
            mesa-vulkan-drivers \
            blender \
            mold \
            pkg-config
@@ -130,22 +129,54 @@ jobs:
            libusb-1.0-0-dev \
            libwayland-dev \
            libx11-dev \
            libxfixes3 \
            libxi6 \
            libxkbcommon-dev \
            libxkbcommon-x11-0 \
            blender \
            lld-19 \
            llvm-19 \
            mesa-vulkan-drivers \
            mold \
            blender \
            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: Install pinned Blender
        run: |
          scripts/install-blender.sh "$RUNNER_TEMP/blender"
          echo "BLENDER=$RUNNER_TEMP/blender/blender" >> "$GITHUB_ENV"
      - name: Preprocess assets
        run: cargo run --locked --bin process-assets --no-default-features --features debug_features -j 4
      - name: Verify processed battlefield asset
        run: |
          python3 - <<'PY'
          import json
          import struct
          path = "imported_assets/Default/stages/battlefield/bf2.blend"
          with open(path, "rb") as asset:
              header = asset.read(12)
              if len(header) != 12:
                  raise SystemExit(f"processed asset is truncated: {path}")
              magic, version, length = struct.unpack("<4sII", header)
              if magic != b"glTF" or version != 2 or length != asset.seek(0, 2):
                  raise SystemExit(f"processed asset is not a valid GLB: {path}")
              asset.seek(12)
              json_length, chunk_type = struct.unpack("<II", asset.read(8))
              if chunk_type != 0x4E4F534A:
                  raise SystemExit(f"processed asset has no JSON chunk: {path}")
              document = json.loads(asset.read(json_length))
          meshes = document.get("meshes", [])
          if not meshes:
              raise SystemExit(f"processed asset contains no meshes: {path}")
          print(f"{path}: {len(meshes)} meshes, {length} bytes")
          PY
      - name: Build production binary
        run: cargo build --locked --profile production --no-default-features --features debug_features -j 4
@@ -279,6 +279,7 @@ dependencies = [
 "parking_lot",
 "percent-encoding",
 "windows-sys 0.60.2",
 "wl-clipboard-rs",
 "x11rb",
 ]
@@ -509,9 +510,9 @@ dependencies = [
 [[package]]
 name = "bevy"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "950238d3049d81006a6fd6b898a34cfc01bb5462a7668795a54d640aed19fd0a"
+checksum = "4bfadbebfc6599aa59289b754ac30023959854304f3d393da2cf62bb3cd5df8f"
 dependencies = [
 "bevy_dylib",
 "bevy_internal",
@@ -570,9 +571,9 @@ dependencies = [
 [[package]]
 name = "bevy-settings"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04372da0c37bab175e0bfbc4ad8f214ffcbea01850225573b6e49132db11e18b"
+checksum = "3776102c41a5a212fced1a9ef76cb8aed8db96fcee397c1a869ea871d30b86df"
 dependencies = [
 "bevy_app",
 "bevy_ecs",
@@ -590,9 +591,9 @@ dependencies = [
 [[package]]
 name = "bevy_a11y"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e86f2cb45b000a9d121a5a7606f9af4a49e72b8b6a3885dc2acac2f0897a04f1"
+checksum = "3c02cd43f914ef7a0f5b16f8a3d88c378c07c92f1a8c32ac5ac4d4f73e55f9e2"
 dependencies = [
 "accesskit",
 "bevy_app",
@@ -603,18 +604,18 @@ dependencies = [
 [[package]]
 name = "bevy_android"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e5e2a949be318bf7184eb084622892afcc1e8b2af44973ac53ab53201756e0"
+checksum = "ae5ea5245a845cefa8efb5ff7c2a8a36cdebfb99596068780f340f0b5aba6689"
 dependencies = [
 "android-activity",
 ]
 [[package]]
 name = "bevy_animation"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7da2fcd94cc32ba1c875c62e88506c0ba4775555a413e34cd172ea95fa26098e"
+checksum = "dc513aac5cda673fb138236e969b4514e0a9b9f93fd33288111f147baa8af623"
 dependencies = [
 "bevy_animation_macros",
 "bevy_app",
@@ -645,9 +646,9 @@ dependencies = [
 [[package]]
 name = "bevy_animation_macros"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fa3d816d7788e27da936b9c7ec27f9828906d53cb1d06e26c58cac5c5ee799f"
+checksum = "eed2910d9ca5c3b48968a54c4571789e4e81935cf3c823383fcac34ca28e2b0e"
 dependencies = [
 "bevy_macro_utils",
 "quote",
@@ -656,9 +657,9 @@ dependencies = [
 [[package]]
 name = "bevy_anti_alias"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "815414ea2e11afe1f2396d89279cfa0986907ef3ec673ec936d9fa695b2bfbf9"
+checksum = "dde973fc942cb596b03cae0dbece0a4d9dc2d2790bbc9852aa415affc1210d3a"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -678,9 +679,9 @@ dependencies = [
 [[package]]
 name = "bevy_app"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "671ae6f3a8d84f9ed696c531a138558596e041231a8414b6efeafa8469e841f9"
+checksum = "5fd2aa472d43b4d081ef41d26300d17bd22cba6d68df2a223eb358782fa40bc6"
 dependencies = [
 "bevy_derive",
 "bevy_ecs",
@@ -700,9 +701,9 @@ dependencies = [
 [[package]]
 name = "bevy_asset"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a05907de6a362d2c609a7a1d1b4dca3b58b768f746b719ca1a3c7dfa87d391"
+checksum = "1624eddbf2293441b2158506aba75e523432b898d9da26eb6ed3e20af4c7fd38"
 dependencies = [
 "async-broadcast",
 "async-channel",
@@ -774,9 +775,9 @@ dependencies = [
 [[package]]
 name = "bevy_asset_macros"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9444998cc37b51dfd1572c23a501865733ea65619a7d88b47aa654ae2290a4f"
+checksum = "735611c80e926e960d279cba2a6f6ab27a61291752ec3b26e76bf9a0957e11e1"
 dependencies = [
 "bevy_macro_utils",
 "proc-macro2",
@@ -786,9 +787,9 @@ dependencies = [
 [[package]]
 name = "bevy_audio"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06af3bd91de885f2a5c024569779a7fb43349df611d92f7b795c66c8797378db"
+checksum = "750809b7b007dd6de6e5c730e67973027a3d22392fa7fd6f5331f8cefb489a18"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -802,9 +803,9 @@ dependencies = [
 [[package]]
 name = "bevy_camera"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20105c3e77c2fb391bf3ded3a473d60e4058b837c9bf4e3412225833e524c75a"
+checksum = "96de20d0babfb51e3907eb4eb56f1e36096a6f8c77acd997f5de611df4ee067d"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -828,9 +829,9 @@ dependencies = [
 [[package]]
 name = "bevy_camera_controller"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be74e5b6c7238f204b41642cf60d3846b2abda0a2252252035a58bc362072944"
+checksum = "bfb356016add201b084008c4320d8ef1696a843f0dcf92db35992731cfef65b1"
 dependencies = [
 "bevy_app",
 "bevy_camera",
@@ -846,10 +847,11 @@ dependencies = [
 [[package]]
 name = "bevy_clipboard"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dc5fb913f25c5a16a2a1aa2942ba3f1365a6d0f2db3c0ea5bc0be01f85dca5d"
+checksum = "d0a9792c7f2e8b5b71b9572a6d98fca4ee88ed186c8a02e164540c461ae3a92e"
 dependencies = [
 "arboard",
 "bevy_app",
 "bevy_ecs",
 "bevy_log",
@@ -861,9 +863,9 @@ dependencies = [
 [[package]]
 name = "bevy_color"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e2dfc0091be6eb62fec9158b2d3e6f21b002be7bdb42dd3b8322e949c8426b0"
+checksum = "5e5370beae13bea2db64744f370bb33566aa770dff91c2beae245ce82217fbbc"
 dependencies = [
 "bevy_math",
 "bevy_reflect",
@@ -877,9 +879,9 @@ dependencies = [
 [[package]]
 name = "bevy_core_pipeline"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "885d640bbff6c4fa3beadbb043d0d1ae53b2fda864da18a2bf2670fb90428865"
+checksum = "2564f1ba766532e8eeb20059133ff6703e8dd5c3864b92378d0d1c541096ef12"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -906,9 +908,9 @@ dependencies = [
 [[package]]
 name = "bevy_derive"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "293df2b2f7ed65ef2ce02b2e7359faac1a9a92a8cc96c182c9de77eb06049ae0"
+checksum = "9d2a03321f3bd8016a041b3ae6afe83e636b3540fbc61d571bf069a21fda3231"
 dependencies = [
 "bevy_macro_utils",
 "quote",
@@ -917,9 +919,9 @@ dependencies = [
 [[package]]
 name = "bevy_dev_tools"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db815000affd21545a6d6986f180a66393aee8c84330843e854d376c8537b10f"
+checksum = "ee5887919325facb6142d98de3e3d156c1b86c2375ac569e2e3547601ab05eaf"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -949,9 +951,9 @@ dependencies = [
 [[package]]
 name = "bevy_diagnostic"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a73e11555051f37c3e0e9ef7775e77108f2482310242996fb5bb6ef8b685b78e"
+checksum = "07a3a736f15486650c4c6866798a78d625c7063c991a3cc7b13f1577d89c82ae"
 dependencies = [
 "atomic-waker",
 "bevy_app",
@@ -967,18 +969,18 @@ dependencies = [
 [[package]]
 name = "bevy_dylib"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70547c664f17a903cdef1e8e673496e9bdfa3d69dece9c01523d79067a876e34"
+checksum = "e3c03a128bac8b59a8699b81038b574e3cfa33dfae18e375d46be028d3d13c0e"
 dependencies = [
 "bevy_internal",
 ]
 [[package]]
 name = "bevy_ecs"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4654b9b3535fa7813d2878a50e1b5ad80a361dc1c913b96ded57667f65d70a01"
+checksum = "a350b2e4c2e47f7903d688affb8a723b31bca63af9789f1da88703f1ba04e354"
 dependencies = [
 "arrayvec",
 "bevy_ecs_macros",
@@ -1004,9 +1006,9 @@ dependencies = [
 [[package]]
 name = "bevy_ecs_macro_logic"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee0b98a74141ce8dce4654c60020ebbaefab32646f42af6bbae55f282ae65ff7"
+checksum = "76a10fef45a3e7dad717ba03e8b5f7ecdf3b3fd1cd1c5e425793525938e90d5f"
 dependencies = [
 "bevy_macro_utils",
 "proc-macro2",
@@ -1016,9 +1018,9 @@ dependencies = [
 [[package]]
 name = "bevy_ecs_macros"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dc958a194d226d618404e0fea99a3c8b4146207a00a3ba07fa712bf71607240"
+checksum = "3916d712264b6f3ec9c964ba10719450ea371e537e202a2ffcfa9f6a5e68169d"
 dependencies = [
 "bevy_ecs_macro_logic",
 "bevy_macro_utils",
@@ -1077,9 +1079,9 @@ dependencies = [
 [[package]]
 name = "bevy_encase_derive"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14dc5bf9e6cb46c4401a66625b5f7eb9654a7f3c8586423c428b79586a1c55cd"
+checksum = "be03820f64f2279ae9d826c882e4ef764516ff75ab7bdc39bb40801891533b89"
 dependencies = [
 "bevy_macro_utils",
 "encase_derive_impl",
@@ -1087,9 +1089,9 @@ dependencies = [
 [[package]]
 name = "bevy_feathers"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e744e047f9328a9c072982569fabbbc837db0474fd902473b5f438f8688c30b6"
+checksum = "e2bb6cfa726defd90add3eb71dc8b1ab32ca441f2531130679bfa880af2fb1f1"
 dependencies = [
 "accesskit",
 "bevy_a11y",
@@ -1132,9 +1134,9 @@ dependencies = [
 [[package]]
 name = "bevy_gilrs"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7998fe83c89d527efa83c85c574a17f7bb6e34881d638ecb7f706d9d79e82f3c"
+checksum = "b8215d166d5c4a9f821713a1a549a57c5f8bdf404745c84f7a8b920b7b7d92b2"
 dependencies = [
 "bevy_app",
 "bevy_ecs",
@@ -1148,9 +1150,9 @@ dependencies = [
 [[package]]
 name = "bevy_gizmos"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c0cbd55cc33b6412777d60d8c24a96bee148c82a5731f35ac85b2df4a7cf957"
+checksum = "2ac5bcad0b8d141ef64f4a89643f74f11827ea6ef48073192b39d69156ed1b92"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -1171,9 +1173,9 @@ dependencies = [
 [[package]]
 name = "bevy_gizmos_macros"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9903f2614f53bacacb92bef1e407afe3a27a4abddb500bfd479909c5d7b254df"
+checksum = "b37bbaa6241480b119da406fc261c9cf85d435addad880ae564c9b0f54a89a28"
 dependencies = [
 "bevy_macro_utils",
 "quote",
@@ -1182,9 +1184,9 @@ dependencies = [
 [[package]]
 name = "bevy_gizmos_render"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd569456c4b19bafa6d37c1bd9cc743fdadda3a2f23d79d2ceb0a088ea8d475f"
+checksum = "2ea2b6266d210bca0aa3bcba7e17204e437b4e86cecd4021ab7dcd32da576a02"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -1211,9 +1213,9 @@ dependencies = [
 [[package]]
 name = "bevy_gltf"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84e21ad83b7dc8d456491ea3d50057685d8c4cca8bc52a1b4a7161c86c369842"
+checksum = "0d17df73b26adfb8be89f0716b8667c60660bdd2d589863b8901caca58c99841"
 dependencies = [
 "async-lock",
 "base64 0.22.1",
@@ -1258,9 +1260,9 @@ dependencies = [
 [[package]]
 name = "bevy_image"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37bc41f69a0c6ade2e7961602517545b39ab8e42bc8c4a729bd24ffee3bcd904"
+checksum = "ca63218585b83f98831214431449e9344b363349dd5cab98dae0b8129f0a0e2f"
 dependencies = [
 "basis-universal",
 "bevy_app",
@@ -1288,9 +1290,9 @@ dependencies = [
 [[package]]
 name = "bevy_input"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd221cf0732f5bf06caf594bdb233361ac735d4d416cf5849757b64bf4e8472a"
+checksum = "b22e8b1119ff5c0b551cc11b672d25732c4e3eda72aceabc380595bd0e7bbe88"
 dependencies = [
 "bevy_app",
 "bevy_ecs",
@@ -1305,9 +1307,9 @@ dependencies = [
 [[package]]
 name = "bevy_input_focus"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e1a14f56c6e722048ec9dc20dbbc6f46b8037f61e319ea776829199278da166"
+checksum = "c4d5573eb503387f73d12acde3010d49c808c790d34691e2fb410fc54b8c72b9"
 dependencies = [
 "bevy_app",
 "bevy_ecs",
@@ -1322,9 +1324,9 @@ dependencies = [
 [[package]]
 name = "bevy_internal"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d52a85632a749f956f92b7b391c31ce1f229e57b06de879d1b60a3bb91e4e240"
+checksum = "4ba99ca2e501f14f4af3322d66ae41b5c5b6ebd3aac4d00cda47dea4c00290ae"
 dependencies = [
 "bevy-settings",
 "bevy_a11y",
@@ -1383,9 +1385,9 @@ dependencies = [
 [[package]]
 name = "bevy_light"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd7b5009e9cc765c30b21daf2277ea4423cbd347b05280ea0943b50c5a80cd42"
+checksum = "a4f91fb900c2412c5cb7ff5083d428d8361a1d39b605df86eb259aff82f7ac45"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -1409,9 +1411,9 @@ dependencies = [
 [[package]]
 name = "bevy_log"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2017a5fe12ea230d00cfdca00c65c262924be26e0324f7e0033c64f8cc265888"
+checksum = "e24488594832237c1e3abc823642823fa057b810c3a21e14e65bdbd15d1579d5"
 dependencies = [
 "android_log-sys",
 "bevy_app",
@@ -1427,9 +1429,9 @@ dependencies = [
 [[package]]
 name = "bevy_macro_utils"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "746a19912c6dc1bbe79188778573e8a253d5832c696b2fcb95578c17b29ff7ba"
+checksum = "7164fe229422295bba15f1885048f34f4660db069aacb895208f996b0c7784fb"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1439,9 +1441,9 @@ dependencies = [
 [[package]]
 name = "bevy_material"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "423710403b4a4d8e9ee872c6ac8108787f2396422b582d15a660a40731ddfbf0"
+checksum = "3efcdb3ba04a57f6e05548884745684a2051e9692398915f57c5c276306b7f10"
 dependencies = [
 "bevy_asset",
 "bevy_derive",
@@ -1462,9 +1464,9 @@ dependencies = [
 [[package]]
 name = "bevy_material_macros"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6928e167592472f6ee900f80de199cc2dafd31d4f082a86e8d594b81b973e3d"
+checksum = "854f95c8f3374ef6242790de50b5cb8f5a601c698772d1447bf856067b53ee64"
 dependencies = [
 "bevy_macro_utils",
 "quote",
@@ -1473,9 +1475,9 @@ dependencies = [
 [[package]]
 name = "bevy_math"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7c280440d2a5bc07ea393b5346b5712eec73ea30f0133097b8b13dade385beb"
+checksum = "98ead494dcfaa9b4594eed7f09a27d868b7cc7fc9ebd655c5643322778f4a8a2"
 dependencies = [
 "approx",
 "arrayvec",
@@ -1493,9 +1495,9 @@ dependencies = [
 [[package]]
 name = "bevy_mesh"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c59863e6f37ef0ba1f37021bce9dd940f9dc31d15e03f548cda5fd3e674f409e"
+checksum = "e2adbf8e5a5817c345986756eb0377e18a510e1d7685ef62d6c7bafcd3bab85e"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -1527,9 +1529,9 @@ checksum = "bff34eb29ff4b8a8688bc7299f14fb6b597461ca80fec03ed7d22939ab33e48f"
 [[package]]
 name = "bevy_pbr"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38ebc777de2d7f45888c68e8e04949bfb8a40aee62f700283fc340f525e67f52"
+checksum = "244ae7d618b51a59c913c36b0564a295cd85ea91a5e777b542bb7bdb846a23d6"
 dependencies = [
 "arrayvec",
 "bevy_app",
@@ -1570,9 +1572,9 @@ dependencies = [
 [[package]]
 name = "bevy_picking"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93468ac5937f76be3af763d496f01e899edf6d9c1a1d39a87ae4ce8eba36f78b"
+checksum = "235d1ea0cd7d0ff2f37592f37b4d8504c597884296058ecadcb0d206d0258ab7"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -1594,9 +1596,9 @@ dependencies = [
 [[package]]
 name = "bevy_platform"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3120670bb2308980f723477c9d82476fcda31f08be9b256c3f0acdee82a65094"
+checksum = "fd610a417e7b4a3b9602cf11264d16cbbff8eabe689c5fed8be4e84c6a2680a3"
 dependencies = [
 "critical-section",
 "foldhash 0.2.0",
@@ -1616,9 +1618,9 @@ dependencies = [
 [[package]]
 name = "bevy_post_process"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57379b51aa0f1b2066c956263e1f12686d22cf8939cf9644eebf2ee42d3dd460"
+checksum = "8eb9340107f7a4292b3b1d138cffb2700f31cef580f5777f2e83f4f00eae4dc1"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -1641,15 +1643,15 @@ dependencies = [
 [[package]]
 name = "bevy_ptr"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b511e89f7078fd21fdea77061a0ca3e737297c7011bb10c073e0aecb17c9fea6"
+checksum = "1974de4b140f102fded747229ff4a61921acec07f02f0d1dcdadfe9ce177d0ff"
 [[package]]
 name = "bevy_reflect"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92abd59cbba1524c1847e9a50f74d94e6b7836c80a8edfa9c47e59f7fd81021d"
+checksum = "9b76c3d056da3e299b84652ccf914c487b786857225d8ffbc8fc9509441a9e6b"
 dependencies = [
 "assert_type_match",
 "bevy_platform",
@@ -1676,9 +1678,9 @@ dependencies = [
 [[package]]
 name = "bevy_reflect_derive"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90fa4e6b97fd2d582dd5ed96762a70d04505a477c833cf4f69d016dcd03d2d04"
+checksum = "5fc5f820ee52afeca6d3bb83f15c1bf61ea6196c840a761a21a8bc266a3b166e"
 dependencies = [
 "bevy_macro_utils",
 "indexmap",
@@ -1690,9 +1692,9 @@ dependencies = [
 [[package]]
 name = "bevy_render"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a89b2cc850a4c3fd12a6a088a4fc3e80118b2e1b569da8936f6d4d99ca1b6ee7"
+checksum = "fc86a32b2eef9859e1e7d323c6d1a9150fe77aa17c30fd05abebc12f645929dc"
 dependencies = [
 "async-channel",
 "bevy_app",
@@ -1744,9 +1746,9 @@ dependencies = [
 [[package]]
 name = "bevy_render_macros"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0eb5cffe5253a6ab4e4b84b2e40a6a2f4673deb16fd63ab9dfc4a015449873a"
+checksum = "6be6eba0ce9770ae4576693804d6c605f8afd9c4769787414254efcf92196a90"
 dependencies = [
 "bevy_macro_utils",
 "proc-macro2",
@@ -1756,9 +1758,9 @@ dependencies = [
 [[package]]
 name = "bevy_scene"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28a3c891148c40e1352fc41001c0e1894ba63fc4e2d3aca33447343c4122b782"
+checksum = "33f6f4f24cd771c6fd67286a8f264a45a644dc798a36614252db220d4fbbd63b"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -1777,9 +1779,9 @@ dependencies = [
 [[package]]
 name = "bevy_scene_macros"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4bc33a36a4e9e344985a96cd8b4abc816cf2c5d2fa002d72fd7bcd11396589c"
+checksum = "4fc7844c3410e228581200f73be123467c424f62fc40499c3e869b641b582748"
 dependencies = [
 "bevy_ecs_macro_logic",
 "bevy_macro_utils",
@@ -1790,9 +1792,9 @@ dependencies = [
 [[package]]
 name = "bevy_shader"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa0ac51378bb6a021165ee334f846b515cd06082e24ce962adce58ad7df1c39a"
+checksum = "50ba4fa5c5102a9ad1b0508c5bf8a6d02a22d5dc13c23ba908ee6d3d16a357cd"
 dependencies = [
 "bevy_asset",
 "bevy_platform",
@@ -1809,9 +1811,9 @@ dependencies = [
 [[package]]
 name = "bevy_sprite"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c679b88cc655881d403929bcdf02d30f688fd8916eb1635e6e7f8585d8ae6894"
+checksum = "e93e631436ff9c08613843d46521ee60f2fcb2eb5f4754eec59591ca817a2ba0"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -1835,9 +1837,9 @@ dependencies = [
 [[package]]
 name = "bevy_sprite_render"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5a65ca9a286dd5815ca4d2d41d4f83bdbb22c8a639d10b4c33eac114b369c36"
+checksum = "0c0a13c775880fe8fb3e7928921b2a1b549fd92c17571e7ca5e1250e53f0e56c"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -1868,9 +1870,9 @@ dependencies = [
 [[package]]
 name = "bevy_state"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c22e694ea52e42994aea6ed2d0b378fa1e9d5a9b615db88626e33508bc03f35"
+checksum = "f69ce6a0066eb4626165e2f8c85d3cf4808cfe4cb2027df8840d5cbfe8a3428d"
 dependencies = [
 "bevy_app",
 "bevy_ecs",
@@ -1884,9 +1886,9 @@ dependencies = [
 [[package]]
 name = "bevy_state_macros"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "835f45091fa0df1ff3cb10f4ca5a397d4e9249b550f1be6893b08a2a06d6eed7"
+checksum = "a36dd49049023a0abbd0bd1e2b99580ed83a18c5351c64caba4c06e3b584cf9c"
 dependencies = [
 "bevy_macro_utils",
 "quote",
@@ -1895,9 +1897,9 @@ dependencies = [
 [[package]]
 name = "bevy_tasks"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa34e6b9b804851ec08a41c0346c859d82e2fa98c906d74b965ee61bbbb688e4"
+checksum = "1f787d4ba7237b64b30bd2d690a8cbae1ba775e0eec326711c446654cb720e7c"
 dependencies = [
 "async-channel",
 "async-executor",
@@ -1914,9 +1916,9 @@ dependencies = [
 [[package]]
 name = "bevy_text"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38e1d7eb8b10229f424b4fc56c864a26c32ac02b8cd184e2cc25eceea7b5e892"
+checksum = "c0b275f50fb01b1e2d411326a7750ecc2fe629c48b89997cf2a3c93fe786e076"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -1943,9 +1945,9 @@ dependencies = [
 [[package]]
 name = "bevy_time"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c21e3be2aa4426ea1e0a7036d3d1dbbded84c319459d9f3e2a616b33563372f2"
+checksum = "f6896d83d7ed32a2f89da127b7aeddf01eb702e603897cf5ddac231480a1870e"
 dependencies = [
 "bevy_app",
 "bevy_ecs",
@@ -1958,9 +1960,9 @@ dependencies = [
 [[package]]
 name = "bevy_transform"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c95fefe69c9223d10e6b52a0fdf12811bab9d0c7dcb27570cb86824b451f180d"
+checksum = "d94cc6065320ebeb58ae88a0863a4c4c2a642c6db698e283eb50be01a834ca5a"
 dependencies = [
 "bevy_app",
 "bevy_ecs",
@@ -1984,9 +1986,9 @@ dependencies = [
 [[package]]
 name = "bevy_ui"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5519c799ecf14e2eeece8b9b823250a00c9df14523e2638b647fccfe4ff0d20"
+checksum = "8a2f97c39dadfef97dbe295fc1ce212825bb9fda2becc8f558d1d7e7d7dbbedf"
 dependencies = [
 "accesskit",
 "bevy_a11y",
@@ -2022,9 +2024,9 @@ dependencies = [
 [[package]]
 name = "bevy_ui_render"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f1d3921936d88bd2638dd4d87bff8fc3b9908a046a50658548045102249f93e"
+checksum = "30a36be1c251417421ee070ecd1a393f0036631f7495564a8c9d4abb6042dc40"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -2055,9 +2057,9 @@ dependencies = [
 [[package]]
 name = "bevy_ui_widgets"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5fc616ccc51b36dea5cb1de91ed82569b41649923388e5ba82cb7d2f1ef18d8"
+checksum = "a71063099a056a010bdbbcc1f1daf2d50bff517d69d62e5334d4c32d7bf9e9e0"
 dependencies = [
 "accesskit",
 "bevy_a11y",
@@ -2079,9 +2081,9 @@ dependencies = [
 [[package]]
 name = "bevy_utils"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3aceea6c7ffdd568f866d5ca4dfe50c33440c54f7bc230c13a9ba7ab0c91aed1"
+checksum = "de51fa7ea2e95d4c2d1278c5629285d59eec951cc60c992964c03f30910ef5a1"
 dependencies = [
 "async-channel",
 "bevy_platform",
@@ -2092,9 +2094,9 @@ dependencies = [
 [[package]]
 name = "bevy_window"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efcc255b43db156fba393b2ff8fa552aac5e7e02ae4c6298eacdbab655ddf988"
+checksum = "38373ee93a9248c14afe41d2025f4aa5e68b004b06ae7702816b180e72b39ea3"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -2111,9 +2113,9 @@ dependencies = [
 [[package]]
 name = "bevy_winit"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "308c9eb04f74f340593b3def6a7c1778fd42581d779c6db836d690c7d471f94c"
+checksum = "c1e9c615f4194b1e00ba536892a3d3d3300c2a1f8e66112fdebd7077bf2744c9"
 dependencies = [
 "accesskit",
 "accesskit_winit",
@@ -2144,9 +2146,9 @@ dependencies = [
 [[package]]
 name = "bevy_world_serialization"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de58ae74410d4f940e3f00484f58603b4f1a53a7d84ebe3fca258d2a3aa96620"
+checksum = "36855264b9b5d229bde74f01730eb6251c72dc052404ae144a9295cc0abdefc1"
 dependencies = [
 "bevy_app",
 "bevy_asset",
@@ -3001,6 +3003,20 @@ dependencies = [
 "unicode-segmentation",
 ]
 [[package]]
 name = "egui_extras"
 version = "0.34.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "598d8675f6fd9088db8a93d8c7aacda936b2f3d0c2b0660ad1744a45b5caf922"
 dependencies = [
 "ahash",
 "egui",
 "enum-map",
 "log",
 "mime_guess2",
 "profiling",
 ]
 [[package]]
 name = "either"
 version = "1.17.0"
@@ -3056,6 +3072,26 @@ dependencies = [
 "syn 2.0.119",
 ]
 [[package]]
 name = "enum-map"
 version = "2.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6866f3bfdf8207509a033af1a75a7b08abda06bbaaeae6669323fd5a097df2e9"
 dependencies = [
 "enum-map-derive",
 ]
 [[package]]
 name = "enum-map-derive"
 version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f282cfdfe92516eb26c2af8589c274c7c17681f5ecc03c18255fe741c6aa64eb"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn 2.0.119",
 ]
 [[package]]
 name = "enum_cycling"
 version = "0.2.1"
@@ -4378,6 +4414,24 @@ dependencies = [
 "libc",
 ]
 [[package]]
 name = "mime"
 version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 [[package]]
 name = "mime_guess2"
 version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1706dc14a2e140dec0a7a07109d9a3d5890b81e85bd6c60b906b249a77adf0ca"
 dependencies = [
 "mime",
 "phf",
 "phf_shared",
 "unicase",
 ]
 [[package]]
 name = "miniz_oxide"
 version = "0.8.9"
@@ -4529,6 +4583,15 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
 [[package]]
 name = "nom"
 version = "8.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
 dependencies = [
 "memchr",
 ]
 [[package]]
 name = "nonmax"
 version = "0.5.5"
@@ -5126,6 +5189,16 @@ dependencies = [
 "num-traits",
 ]
 [[package]]
 name = "os_pipe"
 version = "1.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
 dependencies = [
 "libc",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "owned_ttf_parser"
 version = "0.25.1"
@@ -5304,6 +5377,50 @@ dependencies = [
 "serde_derive",
 ]
 [[package]]
 name = "phf"
 version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
 dependencies = [
 "phf_macros",
 "phf_shared",
 ]
 [[package]]
 name = "phf_generator"
 version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
 dependencies = [
 "phf_shared",
 "rand 0.8.7",
 ]
 [[package]]
 name = "phf_macros"
 version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
 dependencies = [
 "phf_generator",
 "phf_shared",
 "proc-macro2",
 "quote",
 "syn 2.0.119",
 "unicase",
 ]
 [[package]]
 name = "phf_shared"
 version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
 dependencies = [
 "siphasher",
 "unicase",
 ]
 [[package]]
 name = "pin-project"
 version = "1.1.13"
@@ -6084,12 +6201,14 @@ dependencies = [
 "bincode",
 "blake3",
 "clap",
 "egui_extras",
 "enum_cycling",
 "enum_cycling_derive",
 "fixed",
 "fixed_math",
 "gc-adapter-neo",
 "gltf",
 "itertools 0.15.0",
 "rhai",
 "ron",
 "ron_asset_manager",
@@ -6141,6 +6260,12 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 [[package]]
 name = "siphasher"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256"
 [[package]]
 name = "skrifa"
 version = "0.40.0"
@@ -6756,6 +6881,17 @@ dependencies = [
 "wasm-bindgen",
 ]
 [[package]]
 name = "tree_magic_mini"
 version = "3.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
 dependencies = [
 "memchr",
 "nom",
 "petgraph",
 ]
 [[package]]
 name = "ttf-parser"
 version = "0.25.1"
@@ -6786,6 +6922,12 @@ version = "1.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "214ca0b2191785cbc06209b9ca1861e048e39b5ba33574b3cedd58363d5bb5f6"
 [[package]]
 name = "unicase"
 version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
@@ -7819,6 +7961,24 @@ version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
 [[package]]
 name = "wl-clipboard-rs"
 version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4d7888ccd4896447b2d14d3a9350a85df2aeb6f181e2e7a31349d104ac46cac1"
 dependencies = [
 "libc",
 "log",
 "os_pipe",
 "rustix 1.1.4",
 "thiserror 2.0.19",
 "tree_magic_mini",
 "wayland-backend",
 "wayland-client",
 "wayland-protocols",
 "wayland-protocols-wlr",
 ]
 [[package]]
 name = "writeable"
 version = "0.6.3"
@@ -7,21 +7,22 @@ authors = [""]
 [workspace]
 [features]
-default = ["development", "debug_features"]
+default = ["development", "debug_features", "gamecube-adapter"]
-development = ["bevy/dynamic_linking", "bevy/file_watcher"]
+development = ["bevy/dynamic_linking", "bevy/file_watcher", "bevy/embedded_watcher", "hitbox-viewer"]
 debug_features = ["bevy/free_camera"]
 gamecube-adapter = ["dep:gc-adapter-neo"]
 hitbox-viewer = ["bevy/bevy_dev_tools", "dep:egui_extras"]
 [dependencies]
-bevy = { version = "0.19", features = ["asset_processor", "basis-universal", "compressed_image_saver", "bevy_settings"] }
+bevy = { version = "0.19.1", features = ["asset_processor", "basis-universal", "compressed_image_saver", "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" ] }
 itertools = "0.15.0"
 thiserror = "2"
 avian3d = "0.7"
 arrayvec = "0.7.8"
 bevy-inspector-egui = "0.37.0"
 bevy_egui = "0.40.0"
 egui_extras = { version =  "0.34.3", optional = true}
 bevy_ggrs = { git = "https://github.com/gschup/bevy_ggrs" }
 serde = "1.0.229"
 serde_json = "1.0.145"
@@ -34,7 +35,6 @@ 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.1", features = ["libusb"] }
 rhai = "1.26.0"
 enum_cycling = "0.2.1"
 enum_cycling_derive = "0.2.1"
@@ -49,3 +49,11 @@ inherits = "release"
 lto = "thin"
 codegen-units = 1
 strip = "symbols"
 [target.'cfg(not(target_os = "windows"))'.dependencies]
 gc-adapter-neo = { version = "1.1.1", features = ["libusb"], optional = true }
 [[bin]]
 name = "hitbox-editor"
 path = "src/bin/hitbox-editor.rs"
 required-features = ["hitbox-viewer"]
@@ -23,6 +23,19 @@ cargo run -- --debug-match --players 2 --local-port 7001 \
  --net-player 0=127.0.0.1:7000 --net-player 1=local
 ```
 ## Hitbox viewer
 Run the live attack-script previewer with a fighter manifest and attack:
 ```sh
 cargo run --bin hitbox-editor -- \
  --manifest fighters/test/test.fighter.ron --attack jab
 ```
 The timeline is read-only and refreshes through Bevy's asset hot reloading.
 Press Space to pause or resume, use the arrow keys to step, or click and drag
 the timeline to scrub.
 ## Production Build
 ```sh
@@ -0,0 +1,30 @@
 #!/usr/bin/env bash
 set -euo pipefail
 version="5.2.2"
 sha256="84098912789dc450e95697c4184fb8a90acbe5111c2ba4aede3fecb57806a168"
 install_dir="${1:-${BLENDER_INSTALL_DIR:-${HOME}/.local/blender-${version}}}"
 if [[ "$(uname -s)" != Linux || "$(uname -m)" != x86_64 ]]; then
    echo "error: this installer currently supports Linux x86_64 only" >&2
    exit 1
 fi
 if [[ -x "$install_dir/blender" ]]; then
    "$install_dir/blender" --version | head -n 1
    exit 0
 fi
 mkdir -p "$(dirname "$install_dir")"
 tmp_dir="$(mktemp -d)"
 trap 'rm -rf "$tmp_dir"' EXIT
 archive="blender-${version}-linux-x64.tar.xz"
 url="https://download.blender.org/release/Blender5.2/${archive}"
 curl --fail --location --silent --show-error --output "$tmp_dir/$archive" "$url"
 printf '%s  %s\n' "$sha256" "$tmp_dir/$archive" | sha256sum --check --status
 tar --extract --xz --file "$tmp_dir/$archive" --directory "$tmp_dir"
 mv "$tmp_dir/blender-${version}-linux-x64" "$install_dir"
 "$install_dir/blender" --version | head -n 1
@@ -0,0 +1,37 @@
 use bevy::{
    asset::{AssetMode, AssetPlugin},
    gltf::GltfPlugin,
    image::{ImageAddressMode, ImagePlugin, ImageSamplerDescriptor},
    prelude::*,
 };
 use bevy_egui::EguiPlugin;
 use clap::Parser;
 use shinespark::hitbox_viewer::{HitboxViewerArgs, HitboxViewerPlugin};
 fn main() -> AppExit {
    let args = HitboxViewerArgs::parse();
    let default_sampler = ImageSamplerDescriptor::linear()
        .set_address_mode(ImageAddressMode::Repeat)
        .set_anisotropic_filter(16)
        .clone();
    let default_plugins = DefaultPlugins
        .set(ImagePlugin {
            default_sampler: default_sampler.clone(),
        })
        .set(GltfPlugin {
            default_sampler,
            ..default()
        })
        .set(AssetPlugin {
            mode: AssetMode::Processed,
            use_asset_processor_override: Some(cfg!(feature = "development")),
            ..default()
        });
    App::new()
        .add_plugins(default_plugins)
        .add_plugins(EguiPlugin::default())
        .insert_resource(args)
        .add_plugins(HitboxViewerPlugin)
        .run()
 }
@@ -87,6 +87,7 @@ impl AssetLoader for BlendSourceLoader {
            .arg("--")
            .arg(&output)
            .arg(&actions_path)
            .arg(&blend_path)
            .output()
            .map_err(|error| io::Error::other(format!("failed to start Blender: {error}")))?;
        if !result.status.success() {
@@ -106,6 +107,7 @@ impl AssetLoader for BlendSourceLoader {
        let mut dependencies = manifest.dependencies;
        let document: serde_json::Value = serde_json::from_slice(&fs::read(&output)?)
            .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
        validate_export(&document, &output)?;
        if let Some(images) = document.get("images").and_then(serde_json::Value::as_array) {
            for image in images {
                if let Some(uri) = image.get("uri").and_then(serde_json::Value::as_str) {
@@ -142,6 +144,22 @@ impl AssetLoader for BlendSourceLoader {
    }
 }
 fn validate_export(document: &serde_json::Value, output: &Path) -> io::Result<()> {
    for key in ["scenes", "nodes", "meshes"] {
        let count = document
            .get(key)
            .and_then(serde_json::Value::as_array)
            .map_or(0, Vec::len);
        if count == 0 {
            return Err(io::Error::new(
                io::ErrorKind::InvalidData,
                format!("Blender export {} contains no {key}", output.display()),
            ));
        }
    }
    Ok(())
 }
 async fn referenced_actions(
    load_context: &mut LoadContext<'_>,
    root: &Path,
@@ -7,6 +7,15 @@ import sys
 def main():
    output = sys.argv[sys.argv.index("--") + 1]
    actions_path = sys.argv[sys.argv.index("--") + 2]
    source_path = sys.argv[sys.argv.index("--") + 3]
    loaded_path = os.path.realpath(bpy.data.filepath)
    expected_path = os.path.realpath(source_path)
    if loaded_path != expected_path:
        raise RuntimeError(
            f"Blender loaded {loaded_path!r} instead of {expected_path!r}"
        )
    if not bpy.data.objects or not bpy.data.meshes:
        raise RuntimeError("Blender loaded an empty scene")
    with open(actions_path) as file:
        actions_to_keep = set(json.load(file))
@@ -5,7 +5,7 @@ use bevy_ggrs::GgrsFrameTiming;
 use crate::{
    debug_tools::DebugSettings,
-    fighter::{manifest::FighterManifest, motion::sample_presentation_translation},
+    fighter::{manifest::FighterManifest, motion::{sample_presentation_translation_with_snap, FighterPresentationSnap}},
    stage::manifest::StageCameraProfile,
 };
@@ -313,6 +313,7 @@ fn update_match_camera(
            &crate::fighter::motion::FighterPreviousTranslation,
            &crate::fighter::Fighter,
            &crate::fighter::FighterFacingDirection,
            &FighterPresentationSnap,
            &mut FighterCameraExtents,
        ),
        With<crate::player::Player>,
@@ -329,16 +330,17 @@ fn update_match_camera(
    let subjects = fighters
        .iter_mut()
        .map(
-            |(translation, previous_translation, fighter, facing, mut extents)| {
+            |(translation, previous_translation, fighter, facing, presentation_snap, mut extents)| {
                let manifest = manifests
                    .get(&fighter.manifest)
                    .expect("Fighter manifest should be valid");
                fighter_subject_bounds(
-                    sample_presentation_translation(
+                    sample_presentation_translation_with_snap(
                        *previous_translation,
                        *translation,
                        timing.overstep_fraction(),
                        debug_settings.motion_sampling,
                        *presentation_snap,
                    ),
                    manifest.camera,
                    *facing,
@@ -465,6 +467,7 @@ fn debug_draw_camera(
            &crate::fighter::motion::FighterPreviousTranslation,
            &crate::fighter::Fighter,
            &crate::fighter::FighterFacingDirection,
            &FighterPresentationSnap,
            &FighterCameraExtents,
        ),
        With<crate::player::Player>,
@@ -486,15 +489,16 @@ fn debug_draw_camera(
            Color::srgb(1.0, 0.5, 0.0),
        );
        draw_rectangle(&mut gizmos, camera.frame, Color::srgb(1.0, 1.0, 0.0));
-        for (translation, previous_translation, fighter, _facing, extents) in &fighters {
+        for (translation, previous_translation, fighter, _facing, presentation_snap, extents) in &fighters {
            let manifest = manifests
                .get(&fighter.manifest)
                .expect("Fighter manifest should be valid");
-            let center = sample_presentation_translation(
+            let center = sample_presentation_translation_with_snap(
                *previous_translation,
                *translation,
                timing.overstep_fraction(),
                debug_settings.motion_sampling,
                *presentation_snap,
            ) + Vec2::Y * manifest.camera.vertical_origin_offset.to_num::<f32>();
            draw_rectangle(
                &mut gizmos,
@@ -3,11 +3,9 @@
 use std::{collections::HashMap, time::Duration};
 use bevy::{
-    input::InputSystems,
+    camera::{CameraOutputMode, visibility::RenderLayers}, input::InputSystems, prelude::*, render::render_resource::BlendState, settings::{ReflectSettingsGroup, SaveSettingsDeferred, SettingsGroup},
    prelude::*,
    settings::{ReflectSettingsGroup, SaveSettingsDeferred, SettingsGroup},
 };
-use bevy_egui::{EguiContexts, EguiPrimaryContextPass, egui};
+use bevy_egui::{EguiContexts, EguiGlobalSettings, EguiPrimaryContextPass, PrimaryEguiContext, egui};
 use bevy_ggrs::{RollbackFrameRate, RunGgrsSystems};
 use enum_cycling::EnumCycle;
 use enum_cycling_derive::EnumCycle;
@@ -111,7 +109,9 @@ impl FighterDebugRowKind {
 enum DebugFlag {
    Network,
    Ecb,
    BlastZones,
    StageCollision,
    SpawnPositions,
    AnimationBones,
    AttackHitboxes,
    Hurtboxes,
@@ -175,6 +175,14 @@ const WORLD_MENU: &[DebugMenuEntry] = &[
        label: "Stage collision",
        flag: DebugFlag::StageCollision,
    },
    DebugMenuEntry::Toggle {
        label: "Blast zones",
        flag: DebugFlag::BlastZones,
    },
    DebugMenuEntry::Toggle {
        label: "Spawn points",
        flag: DebugFlag::SpawnPositions,
    },
    DebugMenuEntry::GameSpeed {
        label: "Game speed",
    },
@@ -245,7 +253,9 @@ pub struct DebugSettings {
    pub frame_stepping: bool,
    pub network: bool,
    pub ecb: bool,
    pub blast_zones: bool,
    pub stage_collision: bool,
    pub spawn_positions: bool,
    pub animation_bones: bool,
    pub attack_hitboxes: bool,
    pub hurtboxes: bool,
@@ -266,7 +276,9 @@ impl Default for DebugSettings {
            frame_stepping: false,
            network: false,
            ecb: false,
            blast_zones: false,
            stage_collision: false,
            spawn_positions: false,
            animation_bones: false,
            attack_hitboxes: false,
            hurtboxes: false,
@@ -330,6 +342,8 @@ impl DebugSettings {
        match flag {
            DebugFlag::Network => self.network,
            DebugFlag::Ecb => self.ecb,
            DebugFlag::BlastZones => self.blast_zones,
            DebugFlag::SpawnPositions => self.spawn_positions,
            DebugFlag::StageCollision => self.stage_collision,
            DebugFlag::AnimationBones => self.animation_bones,
            DebugFlag::AttackHitboxes => self.attack_hitboxes,
@@ -344,7 +358,9 @@ impl DebugSettings {
        match flag {
            DebugFlag::Network => self.network = !self.network,
            DebugFlag::Ecb => self.ecb = !self.ecb,
            DebugFlag::BlastZones => self.blast_zones = !self.blast_zones,
            DebugFlag::StageCollision => self.stage_collision = !self.stage_collision,
            DebugFlag::SpawnPositions => self.spawn_positions = !self.spawn_positions,
            DebugFlag::AnimationBones => self.animation_bones = !self.animation_bones,
            DebugFlag::AttackHitboxes => self.attack_hitboxes = !self.attack_hitboxes,
            DebugFlag::Hurtboxes => self.hurtboxes = !self.hurtboxes,
@@ -397,6 +413,7 @@ impl Plugin for DebugToolsPlugin {
                    .before(RunGgrsSystems)
                    .run_if(in_state(AppState::InMatch)),
            )
            .add_systems(Startup, spawn_egui_camera)
            .add_systems(PreUpdate, restore_frame_step_time.after(RunGgrsSystems))
            .add_systems(
                Update,
@@ -408,6 +425,26 @@ impl Plugin for DebugToolsPlugin {
    }
 }
 pub fn spawn_egui_camera(mut commands: Commands, mut egui_global_settings: ResMut<EguiGlobalSettings>,) {
    egui_global_settings.auto_create_primary_context = false;
    commands.spawn((
        // The `PrimaryEguiContext` component requires everything needed to render a primary context.
        PrimaryEguiContext,
        Camera2d,
        // Setting RenderLayers to none makes sure we won't render anything apart from the UI.
        RenderLayers::none(),
        Camera {
            order: 2,
            output_mode: CameraOutputMode::Write {
                blend_state: Some(BlendState::ALPHA_BLENDING),
                clear_color: ClearColorConfig::None,
            },
            clear_color: ClearColorConfig::Custom(Color::NONE),
            ..default()
        },
    ));
 }
 fn player_handles(players: &Query<&Player>) -> Vec<usize> {
    let mut handles = players
        .iter()
@@ -865,6 +902,14 @@ pub fn stage_collision_enabled(settings: Res<DebugSettings>) -> bool {
    settings.stage_collision
 }
 pub fn blast_zones_enabled(settings: Res<DebugSettings>) -> bool {
    settings.blast_zones
 }
 pub fn spawn_positions_enabled(settings: Res<DebugSettings>) -> bool {
    settings.spawn_positions
 }
 pub fn animation_bones_enabled(settings: Res<DebugSettings>) -> bool {
    settings.animation_bones
 }
@@ -2,11 +2,11 @@ use bevy::prelude::*;
 use crate::{
    camera::MatchCamera, fighter::{
-        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterPreviousFacingDirection, FighterPreviousTranslation, FighterTranslation, FighterVelocity, Grounded, animation::FighterAnimationFrame, attack::{
+        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterInvulnerabilityState, FighterPendingRespawn, FighterPreviousFacingDirection, FighterPreviousTranslation, FighterSurfaceState, FighterTranslation, FighterVelocity, animation::FighterAnimationFrame, attack::{
            FighterDamage, FighterKnockbackVelocity, FighterPendingHitReaction, FighterPendingHits,
            FighterSolvedHurtboxes, FighterStaleMoveQueue,
        }, baked_animation::FighterBoneMatrices, state::FighterState,
-    }, input::FighterInput, player::Player, stage::line::StageCollision,
+    }, input::FighterInput, match_runtime::MatchState, player::Player, stage::line::StageCollision,
 };
 #[derive(Resource, Default)]
@@ -19,6 +19,7 @@ struct Checkpoint {
    fighters: Vec<FighterCheckpoint>,
    stage_collision: StageCollision,
    pending_hits: FighterPendingHits,
    match_state: MatchState,
 }
 #[derive(Clone)]
@@ -44,7 +45,9 @@ struct FighterCheckpoint {
    hitboxes: FighterHitboxes,
    solved_hurtboxes: FighterSolvedHurtboxes,
    bone_matrices: FighterBoneMatrices,
-    grounded: bool,
+    surface: FighterSurfaceState,
    pending_respawn: FighterPendingRespawn,
    invulnerability_state: FighterInvulnerabilityState,
 }
 pub(super) fn save_or_restore(world: &mut World) {
@@ -89,10 +92,12 @@ pub(super) fn save_or_restore(world: &mut World) {
            checkpoint_fighters.push(checkpoint);
        }
        let pending_hits = world.resource::<FighterPendingHits>().clone();
        let match_state = world.resource::<MatchState>().clone();
        world.resource_mut::<DebugSaveState>().checkpoint = Some(Checkpoint {
            fighters: checkpoint_fighters,
            stage_collision,
            pending_hits,
            match_state,
        });
        info!("Saved debug game state");
        return;
@@ -143,14 +148,13 @@ pub(super) fn save_or_restore(world: &mut World) {
        entity.insert(saved.hitboxes.clone());
        entity.insert(saved.solved_hurtboxes.clone());
        entity.insert(saved.bone_matrices.clone());
-        if saved.grounded {
+        entity.insert(saved.surface.clone());
-            entity.insert(Grounded);
+        entity.insert(saved.pending_respawn.clone());
-        } else {
+        entity.insert(saved.invulnerability_state.clone());
            entity.remove::<Grounded>();
        }
    }
    world.insert_resource(checkpoint.pending_hits.clone());
    world.insert_resource(checkpoint.stage_collision);
    world.insert_resource(checkpoint.match_state);
    for mut match_camera in world.query::<&mut MatchCamera>().iter_mut(world) {
        match_camera.needs_snap = true;
    }
@@ -181,7 +185,9 @@ fn capture_fighter(world: &World, entity: Entity) -> Option<FighterCheckpoint> {
        hitboxes: fighter.get::<FighterHitboxes>()?.clone(),
        solved_hurtboxes: fighter.get::<FighterSolvedHurtboxes>()?.clone(),
        bone_matrices: fighter.get::<FighterBoneMatrices>()?.clone(),
-        grounded: fighter.contains::<Grounded>(),
+        surface: fighter.get::<FighterSurfaceState>()?.clone(),
        pending_respawn: fighter.get::<FighterPendingRespawn>()?.clone(),
        invulnerability_state: fighter.get::<FighterInvulnerabilityState>()?.clone(),
    })
 }
@@ -0,0 +1,16 @@
 use bevy_egui::egui::Color32;
 pub trait ColorToEgui {
    fn to_egui(&self) -> Color32;
 }
 impl ColorToEgui for bevy::color::Srgba {
    fn to_egui(&self) -> Color32 {
        Color32::from_rgba_unmultiplied(
            (self.red * 255.0) as u8,
            (self.green * 255.0) as u8,
            (self.blue * 255.0) as u8,
            (self.alpha * 255.0) as u8,
        )
    }
 }
@@ -84,6 +84,11 @@ pub enum AnimKind {
    AirDodge,
    Fall,
    Turn,
    CrouchEnter,
    CrouchIdle,
    CrouchExit,
    PlatformPass,
    FlinchGround,
    FlinchAir,
@@ -93,4 +98,6 @@ pub enum AnimKind {
    AttackUpTilt,
    AttackForwardTilt,
    AttackDownTilt,
    AttackNeutralAir,
    AttackForwardAir,
 }
@@ -8,6 +8,7 @@ use bevy::prelude::*;
 use bevy_ggrs::{Rollback, RollbackApp, prelude::GgrsSchedule};
 use serde::{Deserialize, Serialize};
 use crate::fighter::FighterInvulnerabilityState;
 use crate::{
    fighter::{
        Fighter, FighterAttributes, FighterFacingDirection, FighterHitboxes,
@@ -32,7 +33,7 @@ use crate::{
 #[derive(Deref, Component, Default, Hash, Debug, Copy, Clone)]
 pub struct FighterKnockbackVelocity(pub FGVec2);
-#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Component, Hash, PartialEq)]
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Component, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct FighterDamage(FGi32);
 impl std::fmt::Display for FighterDamage {
@@ -79,7 +80,7 @@ impl HitStop {
        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 a = (attack_damage_stalled.0 / FGi32::lit("3.0") + FGi32::lit("3.0")).round_to_zero();
        let crouch_cancelling_factor = if crouch_cancelling {
            FGi32::lit("0.66666666")
        } else {
@@ -96,6 +97,12 @@ impl HitStop {
    }
 }
 impl std::fmt::Display for HitStop {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
 }
 #[derive(Clone, Copy, Debug, Serialize, Deserialize)]
 pub enum KnockbackType {
    Normal,
@@ -112,9 +119,15 @@ impl KnockbackType {
    }
 }
-#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Knockback(FGi32);
 impl std::fmt::Display for Knockback {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:.2}", self.0)
    }
 }
 impl Knockback {
    pub fn lit(val: &str) -> Self {
        Self(FGi32::lit(val))
@@ -143,6 +156,15 @@ pub enum AttackAngle {
    Sakurai,
 }
 impl std::fmt::Display for AttackAngle {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            AttackAngle::Normal(fixed_i32) => write!(f, "{:.2}º", fixed_i32),
            AttackAngle::Sakurai => write!(f, "Sakurai"),
        }
    }
 }
 impl Default for AttackAngle {
    fn default() -> Self {
        AttackAngle::Normal(FGi32::lit("0"))
@@ -157,6 +179,30 @@ impl AttackAngle {
    pub fn make_sakurai() -> Self {
        Self::Sakurai
    }
    pub fn get_angle(&self, knockback: &Knockback, is_receiver_grounded: bool, game_settings: &GameSettings) -> FGi32 {
        match self {
            AttackAngle::Normal(angle) => {
                *angle
            },
            AttackAngle::Sakurai => {
                if !is_receiver_grounded {
                    game_settings.fighter_common.sakurai_angle_aerial_angle
                } else if knockback.0 > game_settings.fighter_common.sakurai_angle_knockback_threshold {
                    game_settings.fighter_common.sakurai_angle_high_knockback_angle
                } else {
                    game_settings.fighter_common.sakurai_angle_low_knockback_angle
                }
            },
        }
    }
    pub fn to_melee_angle_representation(&self) -> FGi32 {
        match self {
            AttackAngle::Normal(fixed_i32) => *fixed_i32,
            AttackAngle::Sakurai => FGi32::lit("361"),
        }
    }
 }
 #[derive(Serialize, Deserialize, Reflect, PartialEq, Eq, Hash, Clone, Debug, Default, Copy)]
@@ -179,10 +225,10 @@ pub enum AttackKind {
 impl AttackKind {
    pub fn get_animation(&self) -> AnimKind {
        match self {
-            AttackKind::NeutralAir => AnimKind::AttackJab1,
+            AttackKind::NeutralAir => AnimKind::AttackNeutralAir,
            AttackKind::Jab => AnimKind::AttackJab1,
            AttackKind::UpTilt => AnimKind::AttackUpTilt,
-            AttackKind::ForwardAir => AnimKind::AttackUpTilt,
+            AttackKind::ForwardAir => AnimKind::AttackForwardAir,
            AttackKind::BackAir => AnimKind::AttackUpTilt,
            AttackKind::DownAir => AnimKind::AttackUpTilt,
            AttackKind::UpAir => AnimKind::AttackUpTilt,
@@ -199,6 +245,7 @@ impl AttackKind {
 #[reflect(opaque)]
 pub struct AttackHitbox {
    pub id: u32,
    pub group: u32,
    pub bone: String,
    pub damage: FighterDamage,
    pub offset: FGVec3,
@@ -211,6 +258,14 @@ pub struct AttackHitbox {
    pub end_frame: u32,
 }
 static ATTACK_HITBOX_ID_PALETTE: [bevy::color::Srgba; 5] = [
    bevy::color::palettes::tailwind::RED_500,
    bevy::color::palettes::tailwind::GREEN_500,
    bevy::color::palettes::tailwind::BLUE_500,
    bevy::color::palettes::tailwind::FUCHSIA_500,
    bevy::color::palettes::tailwind::ORANGE_500,
 ];
 const STALE_MOVE_QUEUE_COUNT: usize = 9;
 #[derive(Component, Hash, Clone, Default)]
@@ -258,6 +313,10 @@ impl FighterStaleMoveQueue {
 }
 impl AttackHitbox {
    pub fn get_debug_draw_color(&self) -> bevy::color::Srgba {
        ATTACK_HITBOX_ID_PALETTE[self.id as usize % ATTACK_HITBOX_ID_PALETTE.len()]
    }
    pub fn validate(&self) -> Result<(), String> {
        if self.bone.trim().is_empty() {
            return Err("bone name is empty".into());
@@ -351,6 +410,36 @@ pub fn update_active_hitbox_list(script: &FighterAttackScript, list: &mut Vec<us
    );
 }
 /// Updates both the currently active hitbox intervals and the lifetime of
 /// their per-group victim histories. A group remains immune only while at
 /// least one hitbox belonging to that group is active.
 pub fn update_active_attack(
    script: &FighterAttackScript,
    attack: &mut super::FighterActiveAttack,
    frame: u32,
 ) {
    update_active_hitbox_list(script, &mut attack.active_hitboxes, frame);
    let mut active_groups = Vec::new();
    for &index in &attack.active_hitboxes {
        let group = script.hitboxes[index].group;
        if !active_groups.contains(&group) {
            active_groups.push(group);
        }
    }
    attack.hit_groups.retain(|state| active_groups.contains(&state.group));
    for group in active_groups {
        if !attack.hit_groups.iter().any(|state| state.group == group) {
            attack.hit_groups.push(super::FighterHitGroupState {
                group,
                hit_fighters: Vec::new(),
            });
        }
    }
    attack.hit_groups.sort_unstable_by_key(|state| state.group);
 }
 #[derive(Clone, Debug, PartialEq, Hash)]
 pub struct FighterSolvedHurtbox {
    pub hurtbox_idx: usize,
@@ -526,31 +615,33 @@ pub fn intersect_attacks_with_hurtboxes(
        &Player,
        &FighterStaleMoveQueue,
    )>,
-    query_attacked: Query<(Entity, &FighterSolvedHurtboxes)>,
+    query_attacked: Query<(Entity, &FighterSolvedHurtboxes, &FighterInvulnerabilityState)>,
    mut pending_hits: ResMut<FighterPendingHits>,
    attack_scripts: Res<Assets<FighterAttackScript>>,
 ) {
    pending_hits.0.clear();
    for &entity_receiving in &roster.0 {
-        let Ok((_, hurtboxes)) = query_attacked.get(entity_receiving) else {
+        let Ok((_, hurtboxes, invuln_state)) = query_attacked.get(entity_receiving) else {
            continue;
        };
        if matches!(*invuln_state, FighterInvulnerabilityState::Intangible { .. }) {
            continue;
        }
        for &entity_hurting in &roster.0 {
            if entity_hurting == entity_receiving {
                continue;
            }
            let Ok((_, mut hitboxes, _, _, _)) = query_attacker.get_mut(entity_hurting) else {
                continue;
            };
            let Some(active_attack) = hitboxes.0.as_mut() else {
                continue;
            };
            if active_attack.hit_fighters.contains(&entity_receiving) {
                continue;
            }
            let attack_script = attack_scripts
                .get(&active_attack.script)
                .expect("Attack script should be valid");
@@ -560,6 +651,15 @@ pub fn intersect_attacks_with_hurtboxes(
                for solved_hitbox in active_attack.solved_hitboxes.iter() {
                    if hurtbox.capsule.intersects(solved_hitbox.capsule) {
                        let candidate = solved_hitbox.hitbox_idx;
                        let group = attack_script.hitboxes[candidate].group;
                        let already_hit = active_attack
                            .hit_groups
                            .iter()
                            .find(|state| state.group == group)
                            .is_some_and(|state| state.hit_fighters.contains(&entity_receiving));
                        if already_hit {
                            continue;
                        }
                        if hitting_hitbox_idx.is_none_or(|current: usize| {
                            attack_script.hitboxes[candidate].id
                                < attack_script.hitboxes[current].id
@@ -581,9 +681,15 @@ pub fn intersect_attacks_with_hurtboxes(
                attack_kind: active_attack.kind,
                hitbox_index: hitting_hitbox_idx,
            });
            info!("Hit by hitbox {}!!!!", hitting_hitbox_idx);
-            active_attack.hit_fighters.push(entity_receiving);
+            let group = attack_script.hitboxes[hitting_hitbox_idx].group;
            if let Some(state) = active_attack
                .hit_groups
                .iter_mut()
                .find(|state| state.group == group)
            {
                state.hit_fighters.push(entity_receiving);
            }
        }
    }
 }
@@ -605,7 +711,6 @@ impl Plugin for FighterAttackPlugin {
                intersect_attacks_with_hurtboxes,
            )
                .chain()
                .after(crate::fighter::baked_animation::update_fighter_bone_matrices)
                .in_set(GameplaySet::Attacks),
        );
    }
@@ -4,8 +4,16 @@ use bevy_ggrs::prelude::GgrsSchedule;
 use super::*;
 use crate::{
    fighter::{
-        Fighter, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole, FighterPendingHitReaction, FighterStaleMoveQueue, errors::FighterErrors, manifest::FighterManifest, state::FighterState,
+        Fighter, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake,
-    }, game_settings::GameSettings, math::{int::FGi32}, player::Player, schedule::GameplaySet, scripting::FighterAttackScript,
+        FighterHitstopShakeKind, FighterHitstopShakeRole, FighterPendingHitReaction,
        FighterStaleMoveQueue, FighterSurfaceState, errors::FighterErrors,
        manifest::FighterManifest, state::FighterState,
    },
    game_settings::GameSettings,
    math::int::FGi32,
    player::Player,
    schedule::GameplaySet,
    scripting::FighterAttackScript,
 };
 pub fn resolve_fighter_hits(
@@ -18,7 +26,14 @@ pub fn resolve_fighter_hits(
        &mut FighterHitstop,
        &mut FighterHitstopShake,
    )>,
-    mut receiver: Query<(&mut FighterDamage, &Fighter, &mut FighterPendingHitReaction, &FighterState)>,
+    mut receiver: Query<(
        &mut FighterDamage,
        &Fighter,
        &mut FighterPendingHitReaction,
        &FighterState,
        &FighterInvulnerabilityState,
        &FighterSurfaceState,
    )>,
    attack_scripts: Res<Assets<FighterAttackScript>>,
    game_settings: Res<GameSettings>,
    fighter_manifests: Res<Assets<FighterManifest>>,
@@ -33,7 +48,14 @@ pub fn resolve_fighter_hits(
            .position(|hit| hit.defender != defender)
            .map_or(hits.len(), |offset| hit_offset + offset);
-        let Ok((mut receiver_damage, fighter, mut pending_reaction, receiver_state)) = receiver.get_mut(defender)
+        let Ok((
            mut receiver_damage,
            fighter,
            mut pending_reaction,
            receiver_state,
            invuln_state,
            receiver_surface_state,
        )) = receiver.get_mut(defender)
        else {
            hit_offset = next_defender;
            continue;
@@ -79,10 +101,12 @@ pub fn resolve_fighter_hits(
                false,
                false,
            );
-            let angle = match &hitbox.angle {
+            let angle = hitbox.angle.get_angle(
-                AttackAngle::Normal(angle) => *angle,
+                &knockback,
-                AttackAngle::Sakurai => FGi32::lit("32.0"),
+                receiver_surface_state.is_grounded(),
-            };
+                &game_settings,
            );
            dbg!(knockback, angle);
            let launch_angle = if facing_left {
                FGi32::lit("180.0") - angle
            } else {
@@ -90,7 +114,7 @@ pub fn resolve_fighter_hits(
            };
            // Attacker hitstop and data
-            let hitstop = HitStop::calculate(FighterDamage(attack_damage), false);
+            let hitstop = HitStop::calculate(FighterDamage(attack_damage), matches!(receiver_state, FighterState::Crouch(..)));
            reactions.push((
                attacker_entity,
                attacker_slot,
@@ -100,15 +124,21 @@ pub fn resolve_fighter_hits(
                    hitstun_frames: knockback.get_hitstun_frames(&game_settings),
                    hitstop_frames: hitstop,
                    kind: HitReactionKind::Flinch,
-                    damage: FighterDamage(attack_damage)
+                    damage: FighterDamage(attack_damage),
                },
            ));
        }
-        receiver_damage.0 += total_damage_received_this_frame;
+        match invuln_state {
            FighterInvulnerabilityState::Vulnerable => {
                receiver_damage.0 += total_damage_received_this_frame
            }
            _ => (),
        }
        for (attacker_entity, _, reaction) in &reactions {
-            let Ok((.., _, mut hitstop, mut hitstop_shake)) = attacker.get_mut(*attacker_entity) else {
+            let Ok((.., _, mut hitstop, mut hitstop_shake)) = attacker.get_mut(*attacker_entity)
            else {
                continue;
            };
@@ -119,7 +149,9 @@ pub fn resolve_fighter_hits(
                    FighterHitstopShakeKind::Vertical
                };
                hitstop.remaining_frames = reaction.hitstop_frames.0;
-                let shake_frames = reaction.hitstop_frames.calculate_shake_frames(&game_settings);
+                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;
@@ -127,16 +159,23 @@ pub fn resolve_fighter_hits(
            }
        }
        match invuln_state {
            FighterInvulnerabilityState::Vulnerable => {
                pending_reaction.0 = reactions
                    .into_iter()
                    .min_by(|(_, port_a, _), (_, port_b, _)| port_a.cmp(port_b))
                    .map(|(_, _, reaction)| reaction);
            }
            _ => (),
        }
        hit_offset = next_defender;
    }
    for hit in hits {
-        let Ok((mut stale_move_queue, _facing_direction, mut hitboxes, ..)) = attacker.get_mut(hit.attacker) else {
+        let Ok((mut stale_move_queue, _facing_direction, mut hitboxes, ..)) =
            attacker.get_mut(hit.attacker)
        else {
            continue;
        };
@@ -44,6 +44,9 @@ pub struct FighterAttributes {
    pub air_dodge_duration: u32,
    pub air_dodge_velocity: FGi32,
    pub air_dodge_decay: FGi32,
    pub air_dodge_intangible_duration: u32,
    pub air_dodge_intangible_start: u32,
 }
 impl FighterAttributes {
@@ -154,6 +154,7 @@ type FighterBakeProcessor = LoadTransformAndSave<
 >;
 pub struct BakedAnimationPlugin;
 pub struct BakedAnimationVisualPlugin;
 pub struct BakedAnimationAssetProcessingPlugin;
@@ -172,15 +173,25 @@ impl Plugin for BakedAnimationAssetProcessingPlugin {
 impl Plugin for BakedAnimationPlugin {
    fn build(&self, app: &mut App) {
-        app.add_plugins(BakedAnimationAssetProcessingPlugin)
+        app.add_plugins((
            BakedAnimationAssetProcessingPlugin,
            BakedAnimationVisualPlugin,
        ))
        .add_systems(
            bevy_ggrs::prelude::GgrsSchedule,
            super::runtime::update_fighter_bone_matrices
                .in_set(super::BakedAnimationSamplingSet)
                .in_set(crate::schedule::GameplaySet::Animation),
-            )
+        );
-            .add_systems(
+    }
 }
 impl Plugin for BakedAnimationVisualPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(
            Update,
-                super::visual_binding::apply_baked_fighter_visual_pose,
+            super::visual_binding::apply_baked_fighter_visual_pose
                .after(super::BakedAnimationSamplingSet),
        )
        .add_observer(super::visual_binding::bind_fighter_visual_bones);
    }
@@ -5,12 +5,17 @@ mod runtime;
 mod visual_binding;
 pub use crate::math::fixed_transform::FixedMat4;
-pub use asset_baking::{BakedAnimationAssetProcessingPlugin, BakedAnimationPlugin};
+pub use asset_baking::{
    BakedAnimationAssetProcessingPlugin, BakedAnimationPlugin, BakedAnimationVisualPlugin,
 };
 pub use runtime::{
    BakedAnimationClip, BakedFighterAnimations, FighterBoneIndexMap, FighterBoneMatrices,
-    update_fighter_bone_matrices,
+    resample_fighter_bone_matrices, update_fighter_bone_matrices,
 };
 #[derive(bevy::prelude::SystemSet, Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct BakedAnimationSamplingSet;
 pub const BAKED_ANIMATION_FPS: u32 = 60;
 #[cfg(test)]
@@ -219,6 +224,7 @@ mod tests {
        second.translate(FGVec3::lit("0", "3", "0"));
        let mut matrices = FighterBoneMatrices::default();
        matrices.set_pose(
            AnimKind::Wait,
            &["root".into(), "hand".into()],
            &[None, Some(0)],
            &[first, second],
@@ -239,6 +245,7 @@ mod tests {
        hand.translate(FGVec3::lit("0", "3", "0"));
        let mut matrices = FighterBoneMatrices::default();
        matrices.set_pose(
            AnimKind::Wait,
            &["root".into(), "hand".into()],
            &[None, Some(0)],
            &[root, hand],
@@ -266,13 +273,38 @@ mod tests {
        let parents = [None, Some(0)];
        let pose = [FixedMat4::IDENTITY, FixedMat4::IDENTITY];
-        matrices.set_pose(&names, &parents, &pose, FGi32::ONE);
+        matrices.set_pose(AnimKind::Wait, &names, &parents, &pose, FGi32::ONE);
        let capacities = matrices.buffer_capacities();
-        matrices.set_pose(&names, &parents, &pose, FGi32::ONE);
+        matrices.set_pose(AnimKind::Wait, &names, &parents, &pose, FGi32::ONE);
        assert_eq!(capacities, matrices.buffer_capacities());
    }
    #[test]
    fn same_frame_resample_preserves_previous_gameplay_pose() {
        let names = ["root".into()];
        let parents = [None];
        let mut pose_a = FixedMat4::IDENTITY;
        pose_a.translate(FGVec3::lit("1", "0", "0"));
        let mut pose_b = FixedMat4::IDENTITY;
        pose_b.translate(FGVec3::lit("2", "0", "0"));
        let mut snapped_pose = FixedMat4::IDENTITY;
        snapped_pose.translate(FGVec3::lit("3", "0", "0"));
        let mut matrices = FighterBoneMatrices::default();
        matrices.set_pose(AnimKind::Wait, &names, &parents, &[pose_a], FGi32::ONE);
        matrices.set_pose(AnimKind::Wait, &names, &parents, &[pose_b], FGi32::ONE);
        matrices.resample_pose(
            AnimKind::Landing,
            &names,
            &parents,
            &[snapped_pose],
            FGi32::ONE,
        );
        assert_eq!(matrices.get_index(0), Some((pose_a, snapped_pose)));
    }
    #[test]
    fn model_scale_affects_gameplay_bones_without_changing_visual_locals() {
        let mut root = FixedMat4::IDENTITY;
@@ -281,6 +313,7 @@ mod tests {
        hand.translate(FGVec3::lit("0", "2", "0"));
        let mut matrices = FighterBoneMatrices::default();
        matrices.set_pose(
            AnimKind::Wait,
            &["root".into(), "hand".into()],
            &[None, Some(0)],
            &[root, hand],
@@ -55,6 +55,29 @@ impl BakedFighterAnimations {
    pub fn frame_count(&self, kind: AnimKind) -> Option<u32> {
        self.clip(kind).map(|clip| clip.frames.len() as u32)
    }
    /// Samples one bone in model space without depending on the runtime's
    /// previous-frame buffers. Tooling uses this when the user scrubs between
    /// unrelated frames.
    pub fn sample_bone_model_transform(
        &self,
        frame: &FighterAnimationFrame,
        bone: &str,
        model_scale: FGi32,
    ) -> Option<FixedMat4> {
        let local = self.sample_pose(frame)?;
        let index = self.bone_names.iter().position(|name| name == bone)?;
        let mut model = vec![None; local.len()];
        resolve_model_transform(index, &self.parents, local, &mut model).ok()?;
        let scale = FixedMat4 {
            cols: [
                [model_scale, FGi32::ZERO, FGi32::ZERO, FGi32::ZERO],
                [FGi32::ZERO, model_scale, FGi32::ZERO, FGi32::ZERO],
                [FGi32::ZERO, FGi32::ZERO, model_scale, FGi32::ZERO],
                [FGi32::ZERO, FGi32::ZERO, FGi32::ZERO, FGi32::ONE],
            ],
        };
        Some(scale.mul(model[index]?))
    }
    pub(super) fn clip(&self, kind: AnimKind) -> Option<&BakedAnimationClip> {
        self.clip_indices
            .get(&kind)
@@ -71,12 +94,33 @@ pub struct FighterBoneMatrices {
    local_matrices: Vec<FixedMat4>,
    previous_local_matrices: Vec<FixedMat4>,
    model_matrices: Vec<Option<FixedMat4>>,
    presentation_kind: Option<AnimKind>,
 }
 #[derive(Component, Clone, Debug, Default)]
 pub struct FighterBoneIndexMap(pub HashMap<String, usize>);
 impl FighterBoneMatrices {
    /// Samples a baked pose for a preview or other non-gameplay caller.
    pub fn sample_baked_pose(
        &mut self,
        baked: &BakedFighterAnimations,
        frame: &FighterAnimationFrame,
        model_scale: FGi32,
    ) -> bool {
        let Some(pose) = baked.sample_pose(frame) else {
            return false;
        };
        self.set_pose(
            frame.kind,
            &baked.bone_names,
            &baked.parents,
            pose,
            model_scale,
        );
        true
    }
    #[cfg(test)]
    pub(super) fn buffer_capacities(&self) -> [usize; 5] {
        [
@@ -88,6 +132,12 @@ impl FighterBoneMatrices {
        ]
    }
    pub fn get_by_idx(&self, index: usize) -> Option<(FixedMat4, FixedMat4)> {
        Some((
            *self.previous_frame_matrices.get(index)?,
            *self.matrices.get(index)?,
        ))
    }
    pub fn get(&self, bone: &str) -> Option<(FixedMat4, FixedMat4)> {
        let index = self.bone_names.iter().position(|name| name == bone)?;
        Some((
@@ -132,10 +182,32 @@ impl FighterBoneMatrices {
    }
    pub(super) fn set_pose(
        &mut self,
        kind: AnimKind,
        bone_names: &[String],
        parents: &[Option<usize>],
        local: &[FixedMat4],
        model_scale: FGi32,
    ) {
        self.sample_pose(kind, bone_names, parents, local, model_scale, true);
    }
    pub(super) fn resample_pose(
        &mut self,
        kind: AnimKind,
        bone_names: &[String],
        parents: &[Option<usize>],
        local: &[FixedMat4],
        model_scale: FGi32,
    ) {
        self.sample_pose(kind, bone_names, parents, local, model_scale, false);
    }
    fn sample_pose(
        &mut self,
        kind: AnimKind,
        bone_names: &[String],
        parents: &[Option<usize>],
        local: &[FixedMat4],
        model_scale: FGi32,
        advance_history: bool,
    ) {
        assert_eq!(
            bone_names.len(),
@@ -159,8 +231,11 @@ impl FighterBoneMatrices {
        self.local_matrices.reserve(local.len());
        self.previous_local_matrices.reserve(local.len());
        self.model_matrices.reserve(local.len());
        if advance_history {
            std::mem::swap(&mut self.matrices, &mut self.previous_frame_matrices);
            std::mem::swap(&mut self.local_matrices, &mut self.previous_local_matrices);
        }
        let animation_changed = self.presentation_kind != Some(kind);
        self.local_matrices.clear();
        self.local_matrices.extend_from_slice(local);
        self.model_matrices.resize(local.len(), None);
@@ -183,6 +258,14 @@ impl FighterBoneMatrices {
                model_scale.mul(matrix.expect("baked bone hierarchy should be valid"))
            }),
        );
        // A state transition is a discontinuity, not an animation frame to
        // interpolate from the previous clip.  Keep the presentation pose at
        // the new clip's first/current frame immediately.
        if animation_changed {
            self.previous_local_matrices
                .clone_from(&self.local_matrices);
        }
        self.presentation_kind = Some(kind);
    }
 }
@@ -198,6 +281,56 @@ pub fn update_fighter_bone_matrices(
    manifests: Res<Assets<FighterManifest>>,
 ) {
    for (frame, animations, fighter, mut matrices, mut bone_indices) in &mut fighters {
        sample_fighter_bone_matrices(
            frame,
            animations,
            fighter,
            &mut matrices,
            &mut bone_indices,
            &baked_assets,
            &manifests,
            true,
        );
    }
 }
 /// Resamples the current pose after collision-driven state transitions without
 /// advancing the previous-frame pose used for swept gameplay volumes.
 pub fn resample_fighter_bone_matrices(
    mut fighters: Query<(
        &FighterAnimationFrame,
        &FighterAnimations,
        &Fighter,
        &mut FighterBoneMatrices,
        &mut FighterBoneIndexMap,
    )>,
    baked_assets: Res<Assets<BakedFighterAnimations>>,
    manifests: Res<Assets<FighterManifest>>,
 ) {
    for (frame, animations, fighter, mut matrices, mut bone_indices) in &mut fighters {
        sample_fighter_bone_matrices(
            frame,
            animations,
            fighter,
            &mut matrices,
            &mut bone_indices,
            &baked_assets,
            &manifests,
            false,
        );
    }
 }
 fn sample_fighter_bone_matrices(
    frame: &FighterAnimationFrame,
    animations: &FighterAnimations,
    fighter: &Fighter,
    matrices: &mut FighterBoneMatrices,
    bone_indices: &mut FighterBoneIndexMap,
    baked_assets: &Assets<BakedFighterAnimations>,
    manifests: &Assets<FighterManifest>,
    advance_history: bool,
 ) {
    let baked = baked_assets
        .get(&animations.baked)
        .expect("fighter baked animation asset should be loaded before the match starts");
@@ -211,12 +344,23 @@ pub fn update_fighter_bone_matrices(
    let manifest = manifests
        .get(&fighter.manifest)
        .expect("fighter manifest should be loaded before the match starts");
    if advance_history {
        matrices.set_pose(
            frame.kind,
            &baked.bone_names,
            &baked.parents,
            pose,
            manifest.model_scale,
        );
    } else {
        matrices.resample_pose(
            frame.kind,
            &baked.bone_names,
            &baked.parents,
            pose,
            manifest.model_scale,
        );
    }
    if bone_indices.0.is_empty() {
        bone_indices.0.extend(
            baked
@@ -226,7 +370,6 @@ pub fn update_fighter_bone_matrices(
                .map(|(index, name)| (name.clone(), index)),
        );
    }
    }
 }
 fn resolve_model_transform(
@@ -92,9 +92,12 @@ pub(super) fn bind_fighter_visual_bones(
 pub(super) fn apply_baked_fighter_visual_pose(
    mut nodes: Query<(&mut Transform, &BakedFighterBone)>,
    fighters: Query<&FighterBoneMatrices>,
-    timing: Res<GgrsFrameTiming>,
+    timing: Option<Res<GgrsFrameTiming>>,
 ) {
-    let overstep_fraction = timing.overstep_fraction();
+    let overstep_fraction = timing
        .as_deref()
        .map(GgrsFrameTiming::overstep_fraction)
        .unwrap_or(0.0);
    for (mut transform, bone) in &mut nodes {
        let Ok(matrices) = fighters.get(bone.fighter) else {
            continue;
@@ -0,0 +1,36 @@
 //! Various interactions with the blast zones
 use bevy::prelude::*;
 use crate::{fighter::{FighterPendingRespawn, FighterTranslation, state::FighterState}, match_loading::MatchConfig, stage::manifest::{StageManifest, StageManifestRegistry}};
 pub fn apply_blast_zones(
    stage_registry: Res<StageManifestRegistry>,
    stage_manifests: Res<Assets<StageManifest>>,
    match_config: Res<MatchConfig>,
    fighters: Query<(&FighterTranslation, &mut FighterPendingRespawn, &FighterState)>
 ) {
    let Some(stage_manifest_handle) = stage_registry.get(match_config.stage) else {
        return;
    };
    let Some(stage_manifest) = stage_manifests.get(&stage_manifest_handle) else {
        return;
    };
    for (translation, mut pending_respawn, state) in fighters {
        let is_off_the_left = translation.x < stage_manifest.blast_zone_top_left.x;
        let is_off_the_right = translation.x > stage_manifest.blast_zone_bottom_right.x;
        let is_off_the_top = translation.y > stage_manifest.blast_zone_top_left.y;
        let is_off_the_bottom = translation.y < stage_manifest.blast_zone_bottom_right.y;
        if is_off_the_left || is_off_the_bottom || is_off_the_right {
            pending_respawn.0 = true;
        } else if is_off_the_top {
            let is_in_hitstun = matches!(state, FighterState::Hitstun(..));
            if is_in_hitstun {
                pending_respawn.0 = true;
            }
        }
    }
 }
@@ -4,7 +4,7 @@ use crate::fighter::ecb::FighterPreviousECB;
 use crate::fighter::{FighterECB, FighterPreviousTranslation, FighterTranslation};
 use crate::math::segment::FGSegment2d;
 use crate::math::vec::FGVec2;
-use crate::stage::line::{StageCollision, StageLineID};
+use crate::stage::line::{StageCollision, StageLineID, StagePolyType};
 /*
 pub fn collide_fighter_with_scene(
    fighters: Query<(&FighterECB, &mut FighterVelocity, &mut FighterTranslation)>,
@@ -44,6 +44,8 @@ pub fn air_collide_with_stage(
    prev_ecb: &FighterPreviousECB,
    ecb: &FighterECB,
    stage_collision: &StageCollision,
    ignored_polys: &[usize],
    can_ignore_soft_platforms: bool,
 ) -> Option<AirCollisionWithStageResult> {
    let ray_segment = FGSegment2d::new(
        prev_translation.0 + prev_ecb.get_bottom_point(),
@@ -54,6 +56,10 @@ pub fn air_collide_with_stage(
        .stage_polys
        .iter()
        .enumerate()
        .filter(|(poly_idx, poly)| {
            !ignored_polys.contains(poly_idx)
                && !(can_ignore_soft_platforms && matches!(poly.poly_type, StagePolyType::Platform))
        })
        .filter_map(|(poly_idx, poly)| {
            poly.intersect_ray(ray_segment).map(|intersect_result| {
                (
@@ -76,3 +82,149 @@ pub fn air_collide_with_stage(
        .max_by(|(_, a), (_, b)| a.cmp(b))
        .map(|(result, _)| result)
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::fighter::ecb::{FighterECB, FighterPreviousECB};
    use crate::stage::line::{StagePoly, StagePolyLineSegmentType, StagePolyType};
    fn horizontal_platform(y: &str) -> StagePoly {
        StagePoly::build(
            StagePolyType::Platform,
            &[
                (FGVec2::lit("-2", y), StagePolyLineSegmentType::Floor),
                (FGVec2::lit("2", y), StagePolyLineSegmentType::Floor),
            ],
        )
    }
    fn solid_floor() -> StagePoly {
        StagePoly::build(
            StagePolyType::Closed,
            &[
                (FGVec2::lit("-2", "0"), StagePolyLineSegmentType::Floor),
                (FGVec2::lit("2", "0"), StagePolyLineSegmentType::Floor),
                (FGVec2::lit("2", "-2"), StagePolyLineSegmentType::Wall),
                (FGVec2::lit("-2", "-2"), StagePolyLineSegmentType::Wall),
            ],
        )
    }
    #[test]
    fn airborne_collision_skips_ignored_polygons() {
        let stage_collision = StageCollision {
            stage_polys: vec![horizontal_platform("0"), horizontal_platform("1")],
        };
        let previous_translation = FighterPreviousTranslation(FGVec2::lit("0", "2"));
        let translation = FighterTranslation(FGVec2::lit("0", "-1"));
        let previous_ecb = FighterPreviousECB {
            bottom: FGVec2::ZERO,
            top: FGVec2::ZERO,
            left: FGVec2::ZERO,
            right: FGVec2::ZERO,
        };
        let ecb = FighterECB {
            bottom: FGVec2::ZERO,
            top: FGVec2::ZERO,
            left: FGVec2::ZERO,
            right: FGVec2::ZERO,
        };
        let collision = air_collide_with_stage(
            &previous_translation,
            &translation,
            &previous_ecb,
            &ecb,
            &stage_collision,
            &[1],
            false,
        )
        .expect("the non-ignored platform should still be collidable");
        assert_eq!(collision.line_id.polygon, 0);
        assert_eq!(collision.hit_position, FGVec2::lit("0", "0"));
    }
    #[test]
    fn airborne_collision_skips_soft_platforms_while_passing_down() {
        let stage_collision = StageCollision {
            stage_polys: vec![horizontal_platform("0")],
        };
        let previous_translation = FighterPreviousTranslation(FGVec2::lit("0", "2"));
        let translation = FighterTranslation(FGVec2::lit("0", "-1"));
        let previous_ecb = FighterPreviousECB {
            bottom: FGVec2::ZERO,
            top: FGVec2::ZERO,
            left: FGVec2::ZERO,
            right: FGVec2::ZERO,
        };
        let ecb = FighterECB {
            bottom: FGVec2::ZERO,
            top: FGVec2::ZERO,
            left: FGVec2::ZERO,
            right: FGVec2::ZERO,
        };
        assert!(air_collide_with_stage(
            &previous_translation,
            &translation,
            &previous_ecb,
            &ecb,
            &stage_collision,
            &[],
            true,
        )
        .is_none());
        assert_eq!(
            air_collide_with_stage(
                &previous_translation,
                &translation,
                &previous_ecb,
                &ecb,
                &stage_collision,
                &[],
                false,
            )
            .expect("air dodges still collide with soft platforms")
            .hit_position,
            FGVec2::lit("0", "0")
        );
    }
    #[test]
    fn airborne_collision_still_hits_solid_floors_while_passing_down() {
        let stage_collision = StageCollision {
            stage_polys: vec![solid_floor()],
        };
        let previous_translation = FighterPreviousTranslation(FGVec2::lit("0", "2"));
        let translation = FighterTranslation(FGVec2::lit("0", "-1"));
        let previous_ecb = FighterPreviousECB {
            bottom: FGVec2::ZERO,
            top: FGVec2::ZERO,
            left: FGVec2::ZERO,
            right: FGVec2::ZERO,
        };
        let ecb = FighterECB {
            bottom: FGVec2::ZERO,
            top: FGVec2::ZERO,
            left: FGVec2::ZERO,
            right: FGVec2::ZERO,
        };
        let collision = air_collide_with_stage(
            &previous_translation,
            &translation,
            &previous_ecb,
            &ecb,
            &stage_collision,
            &[],
            true,
        )
        .expect("solid floors remain collidable while passing down");
        assert_eq!(collision.line_id.polygon, 0);
        assert_eq!(collision.hit_position, FGVec2::lit("0", "0"));
    }
 }
@@ -1,10 +1,9 @@
 //! Fighter debug views: gizmos and the egui inspector window.
 use std::sync::OnceLock;
-use bevy::color::palettes::css::ORANGE;
+use bevy::color::palettes::css::{ORANGE, ORANGE_RED, WHITE};
-use bevy::{color::palettes::css::YELLOW, prelude::*};
+use bevy::prelude::*;
-use bevy_egui::{EguiContexts, egui};
+use bevy_egui::{egui, EguiContexts};
 use crate::debug_tools::{DebugSettings, FighterDebugRowKind};
 use crate::fighter::animation::FighterAnimationFrame;
@@ -15,19 +14,21 @@ use crate::fighter::attack::{
 use crate::fighter::baked_animation::{BakedFighterAnimations, FighterBoneMatrices};
 use crate::fighter::ecb::FighterPreviousECB;
 use crate::fighter::errors::FighterErrors;
 use crate::fighter::hurtbox::FixedAffineCapsule;
 use crate::fighter::manifest::FighterManifest;
-use crate::fighter::state::{FighterState, air};
+use crate::fighter::state::{air, FighterState};
 use crate::fighter::visual::FighterAnimations;
 use crate::fighter::{
    Fighter, FighterECB, FighterFacingDirection, FighterHitboxes, FighterPreviousTranslation,
    FighterTranslation, FighterVelocity,
 };
 use crate::filled_gizmos::FilledGizmos;
 use crate::game_settings::GameSettings;
 use crate::input::FighterInput;
 use crate::math::int::FGi32;
 use crate::math::vec::FGVec2;
 use crate::math::vec3::FGVec3;
 use crate::player::Player;
 use crate::scripting::FighterAttackScript;
 pub fn debug_draw_ecb(
    ecbs: Query<(
@@ -37,17 +38,27 @@ pub fn debug_draw_ecb(
        &FighterPreviousTranslation,
    )>,
    mut gizmos: Gizmos,
    mut filled_gizmos: FilledGizmos,
 ) {
    for (ecb, trf, ecb_prev, trf_prev) in ecbs {
        gizmos.cross(
            FGVec3::new(trf.0.x, trf.0.y, FGi32::ZERO).to_vec3(),
            2.0,
            bevy::color::palettes::css::BLUE,
        );
        let prev_transformed = ecb_prev.to_3d_lineloop(Transform::from_xyz(
            trf_prev.x.to_num::<f32>(),
            trf_prev.y.to_num(),
            0.0,
        ));
        filled_gizmos.polygon(&prev_transformed, ORANGE_RED);
        let transformed =
            ecb.to_3d_lineloop(Transform::from_xyz(trf.x.to_num(), trf.y.to_num(), 0.0));
-        gizmos.lineloop(transformed, YELLOW);
+        filled_gizmos.polygon(&transformed, ORANGE);
-        let prev_transformed = ecb_prev.to_3d_lineloop(Transform::from_xyz(
+        gizmos.lineloop(transformed, WHITE);
-            trf_prev.x.to_num(),
+
            trf_prev.y.to_num(),
            -0.1,
        ));
        gizmos.lineloop(prev_transformed, ORANGE);
    }
 }
 pub fn fighter_debug(
@@ -153,10 +164,17 @@ pub fn fighter_debug(
    Ok(())
 }
-pub fn animation_debug(query: Query<(&GlobalTransform, &FighterBoneMatrices)>, mut gizmos: Gizmos) {
+pub fn animation_debug(
-    for (global_transform, matrices) in query {
+    query: Query<(
-        let (_, rotation, translation) = global_transform.to_scale_rotation_translation();
+        &FighterTranslation,
-        let marker_transform = Transform::from_translation(translation).with_rotation(rotation);
+        &FighterFacingDirection,
        &FighterBoneMatrices,
    )>,
    mut gizmos: Gizmos,
 ) {
    for (global_transform, facing_dir, matrices) in query {
        let global_transform = global_transform.get_3d_transform(facing_dir);
        let marker_transform = global_transform.to_mat4();
        for (_, matrix) in matrices.iter() {
            let pos = marker_transform.transform_point(Vec3::new(
                matrix.cols[3][0].to_num(),
@@ -169,15 +187,23 @@ pub fn animation_debug(query: Query<(&GlobalTransform, &FighterBoneMatrices)>, m
    }
 }
-pub fn hurtbox_debug(query: Query<&FighterSolvedHurtboxes>, mut gizmos: Gizmos) {
+pub fn hurtbox_debug(
    query: Query<&FighterSolvedHurtboxes>,
    mut filled_gizmos: FilledGizmos,
 ) {
    for hurtboxes in &query {
        for hurtbox in &hurtboxes.0 {
-            draw_affine_capsule(&mut gizmos, hurtbox.capsule, YELLOW);
+            filled_gizmos.affine_capsule(
                hurtbox.capsule.transform.to_mat4(),
                hurtbox.capsule.radius.to_num(),
                hurtbox.capsule.half_length.to_num(),
                Color::srgba(1.0, 1.0, 0.0, 0.75),
            );
        }
    }
 }
-fn draw_affine_capsule(
+/*fn draw_affine_capsule(
    gizmos: &mut Gizmos,
    capsule: FixedAffineCapsule,
    color: impl Into<Color> + Copy,
@@ -199,9 +225,9 @@ fn draw_affine_capsule(
    for &(start, end) in &wireframe.lines {
        gizmos.line(vertices[start], vertices[end], color);
    }
-}
+}*/
-struct CapsuleWireVertex {
+/*struct CapsuleWireVertex {
    direction: Vec3,
    center_sign: f32,
 }
@@ -209,9 +235,9 @@ struct CapsuleWireVertex {
 struct CapsuleWireframe {
    vertices: Vec<CapsuleWireVertex>,
    lines: Vec<(usize, usize)>,
-}
+}*/
-fn capsule_wireframe() -> &'static CapsuleWireframe {
+/*fn capsule_wireframe() -> &'static CapsuleWireframe {
    const RESOLUTION: usize = 16;
    const HEMISPHERE_STEPS: usize = 4;
    static WIREFRAME: OnceLock<CapsuleWireframe> = OnceLock::new();
@@ -292,7 +318,7 @@ fn capsule_wireframe() -> &'static CapsuleWireframe {
        CapsuleWireframe { vertices, lines }
    })
-}
+}*/
 #[cfg(test)]
 mod capsule_debug_tests {
@@ -312,7 +338,7 @@ mod capsule_debug_tests {
        assert!(marker.abs_diff_eq(Vec3::new(3.0, 4.0, 3.0), 1e-5));
    }
-    #[test]
+    /*#[test]
    fn capsule_wireframe_caps_extend_in_opposite_directions() {
        let wireframe = capsule_wireframe();
        let lower: Vec<_> = wireframe
@@ -330,7 +356,7 @@ mod capsule_debug_tests {
        assert!(upper.iter().all(|vertex| vertex.direction.y >= 0.0));
        assert!(lower.iter().any(|vertex| vertex.direction == Vec3::NEG_Y));
        assert!(upper.iter().any(|vertex| vertex.direction == Vec3::Y));
-    }
+    }*/
 }
 pub fn attack_debug(
@@ -342,6 +368,8 @@ pub fn attack_debug(
        &FighterAnimationFrame,
    )>,
    mut gizmos: Gizmos,
    mut filled_gizmos: FilledGizmos,
    attack_scripts: Res<Assets<FighterAttackScript>>
 ) {
    for (hitboxes, _matrices, _translation, _facing_direction, _frame) in query {
        if let Some(active_attack) = &hitboxes.0 {
@@ -352,21 +380,35 @@ pub fn attack_debug(
                    (solved_hitbox.capsule.start + solved_hitbox.capsule.end) * FGi32::lit("0.5");
                let length = (start - end).length();
                let attack_capsule = Capsule3d {
                    half_length: length * 0.5,
                    radius: solved_hitbox.capsule.radius.to_num(),
                };
                let aim_dir = (end - start).normalize_or(Vec3::Y);
                let mut capsule_draw_trf = Transform::IDENTITY;
                capsule_draw_trf.translation = center.to_vec3();
                capsule_draw_trf.align(Dir3::Y, aim_dir, Dir3::X, aim_dir.any_orthonormal_vector());
                let Some(script) = attack_scripts.get(&active_attack.script) else {
                    continue;
                };
                let hitbox_color =  script.hitboxes.get(solved_hitbox.hitbox_idx).expect("This hitbox should be valid").get_debug_draw_color();
                /*
                let attack_capsule = Capsule3d {
                    half_length: length * 0.5,
                    radius: solved_hitbox.capsule.radius.to_num(),
                };
                gizmos.primitive_3d(
                    &attack_capsule,
                    capsule_draw_trf.to_isometry(),
-                    bevy::color::palettes::css::RED,
+                    hitbox_color,
                );*/
                let hitbox_inner_color = bevy::color::Srgba { alpha: 0.18, ..hitbox_color };
                filled_gizmos.capsule(
                    capsule_draw_trf.to_isometry(),
                    solved_hitbox.capsule.radius.to_num(),
                    length * 0.5,
                    hitbox_inner_color,
                );
                gizmos.cross(start, 1.0, bevy::color::palettes::css::GREEN);
@@ -1,28 +1,44 @@
 use bevy::prelude::*;
-use crate::math::{int::FGi32, vec::FGVec2};
+use crate::{
    fighter::{
        FighterFacingDirection, FighterSurfaceState, FighterTranslation,
        baked_animation::FighterBoneMatrices,
    }, math::{int::FGi32, vec::FGVec2},
 };
 /// Environment collision box: the diamond used to resolve a fighter against
 /// the stage. Purely geometry — the collision response lives in
 /// [`super::collision`].
-#[derive(Component, Debug, Clone, Copy, Hash)]
+#[derive(Component, Debug, Clone, Copy, Hash, Default)]
 #[require(FighterPreviousECB)]
 pub struct FighterECB {
-    pub vertical_half: FGi32,
+    pub top: FGVec2,
-    pub horizontal_half: FGi32,
+    pub bottom: FGVec2,
    pub left: FGVec2,
    pub right: FGVec2,
 }
 #[derive(Component, Debug, Clone)]
 pub struct FighterECBBoneIndices {
    pub indices: Vec<usize>,
 }
 #[derive(Component, Debug, Clone, Copy, Default, Hash)]
 pub struct FighterPreviousECB {
-    pub vertical_half: FGi32,
+    pub top: FGVec2,
-    pub horizontal_half: FGi32,
+    pub bottom: FGVec2,
    pub left: FGVec2,
    pub right: FGVec2,
 }
 impl From<FighterECB> for FighterPreviousECB {
    fn from(ecb: FighterECB) -> Self {
        Self {
-            vertical_half: ecb.vertical_half,
+            top: ecb.top,
-            horizontal_half: ecb.horizontal_half,
+            bottom: ecb.bottom,
            left: ecb.left,
            right: ecb.right,
        }
    }
 }
@@ -35,53 +51,85 @@ pub fn snapshot_fighter_ecb(fighters: Query<(&FighterECB, &mut FighterPreviousEC
 impl FighterECB {
    pub fn to_3d_lineloop(&self, trf: Transform) -> [Vec3; 4] {
-        let rel_up = trf.transform_point(Vec3::new(
+        [self.top, self.right, self.bottom, self.left]
-            0.0,
+            .map(|point| trf.transform_point(Vec3::new(point.x.to_num(), point.y.to_num(), 0.0)))
            (self.vertical_half + self.vertical_half).to_num(),
            0.0,
        ));
        let rel_down = trf.transform_point(Vec3::new(0.0, 0.0, 0.0));
        let rel_left = trf.transform_point(Vec3::new(
            (-self.horizontal_half).to_num(),
            self.vertical_half.to_num(),
            0.0,
        ));
        let rel_right = trf.transform_point(Vec3::new(
            self.horizontal_half.to_num(),
            self.vertical_half.to_num(),
            0.0,
        ));
        [rel_up, rel_right, rel_down, rel_left]
    }
    pub fn get_bottom_point(&self) -> FGVec2 {
-        FGVec2::new(FGi32::ZERO, FGi32::ZERO)
+        self.bottom
    }
 }
 impl FighterPreviousECB {
    pub fn to_3d_lineloop(&self, trf: Transform) -> [Vec3; 4] {
-        let rel_up = trf.transform_point(Vec3::new(
+        [self.top, self.right, self.bottom, self.left]
-            0.0,
+            .map(|point| trf.transform_point(Vec3::new(point.x.to_num(), point.y.to_num(), 0.0)))
            (self.vertical_half + self.vertical_half).to_num(),
            0.0,
        ));
        let rel_down = trf.transform_point(Vec3::new(0.0, 0.0, 0.0));
        let rel_left = trf.transform_point(Vec3::new(
            (-self.horizontal_half).to_num(),
            self.vertical_half.to_num(),
            0.0,
        ));
        let rel_right = trf.transform_point(Vec3::new(
            self.horizontal_half.to_num(),
            self.vertical_half.to_num(),
            0.0,
        ));
        [rel_up, rel_right, rel_down, rel_left]
    }
    pub fn get_bottom_point(&self) -> FGVec2 {
-        FGVec2::new(FGi32::ZERO, FGi32::ZERO)
+        self.bottom
    }
 }
 pub fn update_ecb(
    query: Query<(
        &mut FighterECB,
        &FighterSurfaceState,
        &FighterECBBoneIndices,
        &FighterBoneMatrices,
        &FighterTranslation,
        &FighterFacingDirection,
    )>,
 ) {
    for (mut ecb, surface_state, bone_indices, bone_matrices, translation, facing_dir) in query {
        let trf = translation.get_3d_transform(facing_dir);
        let transformed_ecb_bones = bone_indices.indices.iter().filter_map(|idx| {
            let Some((_, bone_matrix)) = bone_matrices.get_by_idx(*idx) else {
                return None;
            };
            let pt = trf.transform_point(bone_matrix.get_translation());
            Some(FGVec2::new(pt.x, pt.y) - translation.0)
        }).collect::<Vec<_>>();
        let max_x = transformed_ecb_bones.iter().max_by(|a, b| a.x.cmp(&b.x)).map(|final_val| final_val.x).unwrap_or(FGi32::lit("0.5"));
        let min_x = transformed_ecb_bones.iter().min_by(|a, b| a.x.cmp(&b.x)).map(|final_val| final_val.x).unwrap_or(FGi32::lit("-0.5"));
        let max_y = transformed_ecb_bones.iter().max_by(|a, b| a.y.cmp(&b.y)).map(|final_val| final_val.y).unwrap_or(FGi32::lit("0.5"));
        let min_y = transformed_ecb_bones.iter().min_by(|a, b| a.y.cmp(&b.y)).map(|final_val| final_val.y).unwrap_or(FGi32::lit("-0.5"));
        let midpoint_height = (max_y + min_y) / FGi32::lit("2.0");
        let top = FGVec2::new(FGi32::ZERO, max_y);
        let bottom = FGVec2::new(FGi32::ZERO, min_y);
        let left = FGVec2::new(min_x, midpoint_height);
        let right = FGVec2::new(max_x, midpoint_height);
        let ecb_lock_frames_remaining = if let FighterSurfaceState::Airborne { ecb_lock_frames_remaining, .. } = surface_state {
            *ecb_lock_frames_remaining
        } else {
            0
        };
        ecb.top = top;
        if ecb_lock_frames_remaining == 0 {
            ecb.bottom = bottom;
        }
        ecb.left = left;
        ecb.right = right;
        if surface_state.is_grounded() {
            ecb.bottom = FGVec2::ZERO;
        }
    }
 }
 pub fn decrement_ecb_lockout(surface_states: Query<&mut FighterSurfaceState>) {
    for mut state in surface_states {
        state.tick_ecb_lock();
        state.tick_ignored_polygons();
    }
 }
@@ -92,12 +140,16 @@ mod tests {
    #[test]
    fn previous_ecb_copies_current_dimensions() {
        let current = FighterECB {
-            vertical_half: FGi32::lit("0.5"),
+            bottom: FGVec2::lit("0.0", "-0.5"),
-            horizontal_half: FGi32::lit("0.25"),
+            top: FGVec2::lit("0.0", "0.5"),
            left: FGVec2::lit("-0.5", "0.0"),
            right: FGVec2::lit("0.5", "0.0"),
        };
        let previous = FighterPreviousECB::from(current);
-        assert_eq!(previous.vertical_half, current.vertical_half);
+        assert_eq!(previous.top, current.top);
-        assert_eq!(previous.horizontal_half, current.horizontal_half);
+        assert_eq!(previous.bottom, current.bottom);
        assert_eq!(previous.left, current.left);
        assert_eq!(previous.right, current.right);
    }
 }
@@ -65,6 +65,7 @@ pub struct FighterManifest {
    pub animations: HashMap<AnimKind, String>,
    pub attack_scripts: HashMap<AttackKind, String>,
    pub hurtboxes: Vec<FighterHurtbox>,
    pub ecb_bones: Vec<String>,
 }
 #[derive(Resource)]
@@ -18,7 +18,9 @@ pub mod hurtbox;
 pub mod manifest;
 pub mod motion;
 pub mod state;
 pub mod surface;
 pub mod visual;
 pub mod blast_zones;
 // The fighter components are re-exported so the rest of the crate can say
 // `fighter::FighterVelocity` without caring which file it lives in. Named
@@ -28,9 +30,10 @@ pub use attributes::FighterAttributes;
 pub use ecb::FighterECB;
 pub use manifest::FighterId;
 pub use motion::{
-    FighterPreviousFacingDirection, FighterPreviousTranslation, FighterTranslation,
+    FighterPresentationSnap, FighterPreviousFacingDirection, FighterPreviousTranslation,
-    FighterVelocity, Grounded,
+    FighterTranslation, FighterVelocity,
 };
 pub use surface::FighterSurfaceState;
 use crate::{
    AppState, fighter::{
@@ -38,8 +41,8 @@ use crate::{
            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}, ecb::FighterECBBoneIndices, manifest::FighterManifest, state::{FighterState, air::AirborneStateCommon, fall::FallState}, visual::{FighterAnimations, FighterInvulnerabilityVisualState},
-    }, input::FighterInput, math::{int::FGi32, vec::FGVec2}, player::Player, schedule::GameplaySet, scripting::FighterAttackScript, stage::line::StageCollision,
+    }, game_settings::GameSettings, input::FighterInput, math::{int::FGi32, vec::FGVec2}, player::Player, schedule::GameplaySet, scripting::FighterAttackScript, stage::line::StageCollision,
 };
 use state::state_interrupt_system;
@@ -58,14 +61,14 @@ pub enum FighterFacingDirection {
 pub enum FighterHitstopShakeKind {
    #[default]
    Horizontal,
-    Vertical
+    Vertical,
 }
 #[derive(Component, Copy, Clone, Hash, Debug, PartialEq, Reflect, Default)]
 pub enum FighterHitstopShakeRole {
    #[default]
    Attacker,
-    Receiver
+    Receiver,
 }
 #[derive(Component, Default, Copy, Clone, Hash)]
@@ -73,7 +76,7 @@ pub struct FighterHitstopShake {
    pub remaining_frames: u32,
    pub total_frames: u32,
    pub kind: FighterHitstopShakeKind,
-    pub role: FighterHitstopShakeRole
+    pub role: FighterHitstopShakeRole,
 }
 #[derive(Component, Default, Copy, Clone, Hash)]
@@ -82,6 +85,14 @@ pub struct FighterHitstop {
    pub remaining_frames: u32,
 }
 #[derive(Component, Default, Copy, Clone, Hash)]
 pub enum FighterInvulnerabilityState {
    #[default]
    Vulnerable,
    Invulnerable { frames_remaining: Option<u32> },
    Intangible { frames_remaining: Option<u32> }
 }
 impl FighterFacingDirection {
    fn reverse(&self) -> Self {
        match self {
@@ -126,14 +137,20 @@ impl FighterFacingDirection {
 #[require(Transform)]
 pub struct FighterVisual;
 #[derive(Component, DerefMut, Deref, Debug, Default, Hash, Clone, Copy)]
 pub struct FighterPendingRespawn(bool);
 #[derive(Component)]
 #[require(
    FighterStaleMoveQueue,
    FighterDamage,
    FighterPendingHitReaction,
    FighterPendingRespawn,
    FighterHitstop,
    FighterKnockbackVelocity,
    FighterTranslation,
    FighterInvulnerabilityState,
    FighterInvulnerabilityVisualState,
 )]
 pub struct Fighter {
    pub manifest: Handle<FighterManifest>,
@@ -146,6 +163,10 @@ impl Plugin for FighterPlugin {
    fn build(&self, app: &mut App) {
        app.add_plugins(FighterAttackPlugin)
            // Every state gets a chance to interrupt itself, in priority order.
            .add_systems(
                GgrsSchedule,
                motion::clear_fighter_presentation_snaps.in_set(GameplaySet::Input),
            )
            .add_systems(
                GgrsSchedule,
                (
@@ -158,7 +179,7 @@ impl Plugin for FighterPlugin {
            )
            .add_systems(
                GgrsSchedule,
-                (state::state_update_system, decay_hitstop)
+                (state::state_update_system, decay_hitstop, decay_invulnerability)
                    .chain()
                    .in_set(GameplaySet::StateUpdate),
            )
@@ -170,10 +191,15 @@ impl Plugin for FighterPlugin {
            )*/
            .add_systems(
                GgrsSchedule,
-                state::state_collision_interrupt_system.in_set(GameplaySet::Collision),
+                (
                    (blast_zones::apply_blast_zones, ecb::update_ecb, ecb::decrement_ecb_lockout, state::state_collision_interrupt_system).chain(),
                    baked_animation::resample_fighter_bone_matrices,
                )
                    .chain()
                    .in_set(GameplaySet::Collision),
            )
            .add_systems(
-                Update,
+                PostUpdate,
                (
                    motion::apply_fighter_translation_to_visuals,
                    animation::apply_animation,
@@ -196,19 +222,25 @@ impl Plugin for FighterPlugin {
            .checksum_component_with_hash::<FighterTranslation>()
            .rollback_component_with_copy::<FighterPreviousTranslation>()
            .checksum_component_with_hash::<FighterPreviousTranslation>()
            .rollback_component_with_copy::<FighterPresentationSnap>()
            .checksum_component_with_hash::<FighterPresentationSnap>()
            .rollback_component_with_copy::<FighterPreviousFacingDirection>()
            .checksum_component_with_hash::<FighterPreviousFacingDirection>()
            .rollback_component_with_copy::<animation::FighterAnimationFrame>()
            .checksum_component_with_hash::<animation::FighterAnimationFrame>()
-            .rollback_component_with_copy::<Grounded>()
+            .rollback_component_with_clone::<FighterSurfaceState>()
-            .checksum_component_with_hash::<Grounded>()
+            .checksum_component_with_hash::<FighterSurfaceState>()
            .rollback_component_with_copy::<FighterFacingDirection>()
            .rollback_component_with_copy::<FighterDamage>()
            .checksum_component_with_hash::<FighterDamage>()
            .rollback_component_with_clone::<FighterPendingHitReaction>()
            .checksum_component_with_hash::<FighterPendingHitReaction>()
            .rollback_component_with_copy::<FighterPendingRespawn>()
            .checksum_component_with_hash::<FighterPendingRespawn>()
            .rollback_component_with_copy::<FighterHitstop>()
            .checksum_component_with_hash::<FighterHitstop>()
            .rollback_component_with_copy::<FighterInvulnerabilityState>()
            .checksum_component_with_hash::<FighterInvulnerabilityState>()
            .rollback_component_with_copy::<FighterKnockbackVelocity>()
            .checksum_component_with_hash::<FighterKnockbackVelocity>()
            .rollback_resource_with_reflect::<StageCollision>()
@@ -236,6 +268,9 @@ impl Plugin for FighterPlugin {
                    .run_if(crate::debug_tools::attack_hitboxes_enabled)
                    .run_if(in_state(AppState::InMatch)),
            )
            .add_systems(FixedPostUpdate, 
                visual::update_status_colors.run_if(resource_exists::<GameSettings>)
            )
            .add_systems(
                FixedPostUpdate,
                debug::hurtbox_debug.run_if(crate::debug_tools::hurtboxes_enabled),
@@ -258,8 +293,14 @@ pub struct FighterActiveAttack {
    pub script: Handle<FighterAttackScript>,
    pub active_hitboxes: Vec<usize>,
    pub solved_hitboxes: Vec<attack::FighterSolvedHitbox>,
    pub hit_groups: Vec<FighterHitGroupState>,
    pub stalled: bool,
 }
 #[derive(Clone, Debug, Hash)]
 pub struct FighterHitGroupState {
    pub group: u32,
    pub hit_fighters: Vec<Entity>,
    pub stalled: bool
 }
 #[derive(Component, Clone, Debug, Default, Hash)]
@@ -268,34 +309,39 @@ pub struct FighterHitboxes(pub Option<FighterActiveAttack>);
 pub fn spawn_fighter(
    commands: &mut Commands,
    player_handle: usize,
    controller_port: usize,
    spawn_position: FGVec2,
    manifest: Handle<FighterManifest>,
    model_scale: FGi32,
    animations: FighterAnimations,
    attack_scripts: FighterAttackScriptAssets,
    visual_root: WorldAssetRoot,
    ecb_bone_indices: Vec<usize>,
 ) -> Entity {
    commands
        .spawn((
            Name(format!("Fighter {player_handle}").into()),
            Player {
                handle: player_handle,
                controller_port,
            },
            Fighter { manifest: manifest },
            FighterFacingDirection::Right,
            FighterPreviousFacingDirection(FighterFacingDirection::Right),
            FighterSurfaceState::default(),
            Transform::from_scale(Vec3::splat(model_scale.to_num())),
            (
-                FighterECB {
+                FighterECB::default(),
                    vertical_half: FGi32::lit("5.0"),
                    horizontal_half: FGi32::lit("2.5"),
                },
                FighterHitboxes::default(),
                FighterECBBoneIndices {
                    indices: ecb_bone_indices
                }
            ),
            (
                FighterVelocity::default(),
                FighterTranslation(spawn_position),
                FighterPreviousTranslation(spawn_position),
                FighterPresentationSnap::default(),
            ),
            visual_root,
            animations,
@@ -320,3 +366,34 @@ pub fn decay_hitstop(query: Query<(&mut FighterHitstop, &mut FighterHitstopShake
        hitstop_shake.remaining_frames = hitstop_shake.remaining_frames.saturating_sub(1);
    }
 }
 pub fn decay_invulnerability(query: Query<&mut FighterInvulnerabilityState>) {
    for invuln_state in query {
        let invuln_state = invuln_state.into_inner();
        let frames_remaining = match invuln_state {
            FighterInvulnerabilityState::Vulnerable => None,
            FighterInvulnerabilityState::Invulnerable { frames_remaining } => {
                if let Some(frames_remaining) = frames_remaining {
                    *frames_remaining = frames_remaining.saturating_sub(1);
                    Some(*frames_remaining)
                } else {
                    None
                }
            },
            FighterInvulnerabilityState::Intangible { frames_remaining } => {
                if let Some(frames_remaining) = frames_remaining {
                    *frames_remaining = frames_remaining.saturating_sub(1);
                    Some(*frames_remaining)
                } else {
                    None
                }
            },
        };
        if let Some(frames_remaining) = frames_remaining {
            if frames_remaining == 0 {
                *invuln_state = FighterInvulnerabilityState::Vulnerable;
            }
        }
    }
 }
@@ -5,25 +5,27 @@ use bevy::prelude::*;
 use bevy_ggrs::GgrsFrameTiming;
 use crate::debug_tools::PresentationMotionMode;
-use crate::fighter::{FighterHitstopShake};
+use crate::fighter::FighterHitstopShake;
 use crate::game_settings::GameSettings;
 use crate::{
-    fighter::{FighterECB, FighterFacingDirection, baked_animation::FixedMat4},
+    fighter::{FighterFacingDirection, baked_animation::FixedMat4},
    math::{int::FGi32, vec::FGVec2, vec3::FGVec3},
 };
 #[derive(Component, Clone, Copy, Hash)]
 pub struct FighterPreviousFacingDirection(pub FighterFacingDirection);
 #[derive(Component, Clone, Copy, Hash)]
 pub struct Grounded;
 #[derive(Component, Deref, DerefMut, Default, Debug, Clone, Copy, Hash)]
 pub struct FighterVelocity(pub FGVec2);
 #[derive(Component, Deref, DerefMut, Default, Clone, Copy, Hash)]
 pub struct FighterPreviousTranslation(pub FGVec2);
 /// Marks a simulation frame whose position changed discontinuously for
 /// presentation purposes (for example, a landing correction).
 #[derive(Component, Default, Clone, Copy, Hash, Debug, PartialEq, Eq)]
 pub struct FighterPresentationSnap(pub bool);
 #[derive(Component, Deref, DerefMut, Default, Clone, Copy, Hash)]
 #[require(FighterPreviousTranslation)]
 pub struct FighterTranslation(pub FGVec2);
@@ -55,11 +57,31 @@ pub fn sample_presentation_translation(
    }
 }
 pub fn sample_presentation_translation_with_snap(
    previous: FighterPreviousTranslation,
    current: FighterTranslation,
    overstep_fraction: f32,
    mode: PresentationMotionMode,
    snapped: FighterPresentationSnap,
 ) -> Vec2 {
    if snapped.0 {
        Vec2::new(current.x.to_num(), current.y.to_num())
    } else {
        sample_presentation_translation(previous, current, overstep_fraction, mode)
    }
 }
 pub fn clear_fighter_presentation_snaps(mut fighters: Query<&mut FighterPresentationSnap>) {
    for mut snap in &mut fighters {
        snap.0 = false;
    }
 }
 pub fn apply_fighter_translation_to_visuals(
    query: Query<(
        &FighterTranslation,
        &FighterPreviousTranslation,
-        &FighterECB,
+        &FighterPresentationSnap,
        &FighterHitstopShake,
        &mut Transform,
    )>,
@@ -68,33 +90,43 @@ pub fn apply_fighter_translation_to_visuals(
    game_settings: Res<GameSettings>,
 ) {
    let overstep_fraction = timing.overstep_fraction();
-    for (translation, previous_translation, ecb, hitstop_shake, mut transform) in query {
+    for (translation, previous_translation, presentation_snap, hitstop_shake, mut transform) in query {
-        let translation = sample_presentation_translation(
+        let translation = sample_presentation_translation_with_snap(
            *previous_translation,
            *translation,
            overstep_fraction,
            debug_settings.motion_sampling,
            *presentation_snap,
        );
        let bottom = ecb.get_bottom_point();
        transform.translation = Vec3::new(
-            translation.x + bottom.x.to_num::<f32>(),
+            translation.x,
-            translation.y + bottom.y.to_num::<f32>(),
+            translation.y,
            0.0,
        );
-        if hitstop_shake.remaining_frames > 0 && hitstop_shake.total_frames > 0 && !game_settings.fighter_common.visual_shake_table.is_empty() {
+        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)
-            let access_index = (hitstop_shake.remaining_frames as usize) % game_settings.fighter_common.visual_shake_table.len();
+                % 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::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: f32 =
-            let shake_amount = game_settings.fighter_common.visual_shake_table[access_index] * shake_amount * shake_multiplier;
+                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),
@@ -164,6 +196,19 @@ mod tests {
        assert_eq!(position, Vec2::new(7.0, 14.0));
    }
    #[test]
    fn presentation_translation_uses_current_sample_after_snap() {
        let position = sample_presentation_translation_with_snap(
            FighterPreviousTranslation(FGVec2::new(FGi32::lit("2"), FGi32::lit("4"))),
            FighterTranslation(FGVec2::new(FGi32::lit("6"), FGi32::lit("12"))),
            0.25,
            PresentationMotionMode::Extrapolation,
            FighterPresentationSnap(true),
        );
        assert_eq!(position, Vec2::new(6.0, 12.0));
    }
    #[test]
    fn snapshot_fighter_motion_copies_current_world_state() {
        let mut world = World::new();
@@ -1,6 +1,6 @@
-use crate::fighter::state::ground::GroundedStateCommon;
+use crate::fighter::state::jump::{JumpState, JumpType};
 use crate::fighter::state::land::{LandingState, LandingType};
-use crate::fighter::state::{CollisionContext, FighterState};
+use crate::fighter::state::{CollisionContext, FighterState, InterruptContext, air_attack, air_dodge};
 use crate::fighter::*;
 use crate::input::FighterCommands;
@@ -30,7 +30,7 @@ pub fn process_fast_fall(
 pub fn integrate_gravity(
    velocity: &mut FighterVelocity,
    attributes: &FighterAttributes,
-    fast_fall: bool
+    fast_fall: bool,
 ) {
    velocity.y -= attributes.gravity;
@@ -94,25 +94,51 @@ 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);
+    process_fast_fall(
-    integrate_gravity(ctx.velocity, ctx.fighter_attributes, airborne_common.is_fast_falling);
+        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);
+    apply_air_motion(
        ctx.velocity,
        ctx.translation,
        ctx.prev_translation,
    );
 }
 pub fn air_interrupts_common(ctx: &mut InterruptContext, airborne_state_common: &AirborneStateCommon) -> Option<FighterState> {
    if ctx.input.has_command(FighterCommands::Jump) {
            Some(FighterState::Jump(JumpState {
                jump_type: JumpType::DoubleJump,
                airborne_state_common: AirborneStateCommon::default(),
            }))
    } else {
        air_dodge::check_input(ctx).or_else(|| air_attack::check_interrupt(ctx, airborne_state_common))
    }
 }
 pub fn collision_interrupt(
    ctx: &mut CollisionContext,
    landing_type: LandingType,
    can_ignore_soft_platforms: bool,
 ) -> Option<FighterState> {
-    let res = ctx.air_collide_with_stage()?;
+    let res = ctx.air_collide_with_stage(can_ignore_soft_platforms)?;
-    ctx.translation.0 = res.hit_position - ctx.ecb.get_bottom_point();
+    let diff = res.hit_position - ctx.translation.0;
-    let grounded_common = GroundedStateCommon {
+    ctx.ecb.bottom -= diff;
-        current_line_id: res.line_id,
+    ctx.ecb.top -= diff;
-    };
+    ctx.ecb.left -= diff;
-    Some(FighterState::Land(LandingState::create(
+    ctx.ecb.right -= diff;
-        grounded_common,
+    ctx.translation.0 = res.hit_position;
-        landing_type,
+    ctx.presentation_snap.0 = true;
-    )))
+    ctx.surface.land(res.line_id);
    Some(FighterState::Land(LandingState::create(landing_type)))
 }
 #[cfg(test)]
@@ -155,6 +181,8 @@ mod tests {
            air_dodge_duration: 0,
            air_dodge_velocity: FGi32::ZERO,
            air_dodge_decay: FGi32::ZERO,
            air_dodge_intangible_duration: 29,
            air_dodge_intangible_start: 4,
        }
    }
@@ -0,0 +1,168 @@
 use bevy::log::error;
 use crate::fighter::{
    attack::{AttackKind, FighterAttackScriptAssets, update_active_attack}, state::{
        CollisionContext, EnterContext, ExitContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, air_attack, fall::FallState, jump,
    },
 };
 #[derive(Clone, Debug, Hash)]
 pub struct AirAttackState {
    pub attack_kind: AttackKind,
    pub airborne_state_common: AirborneStateCommon,
    pub is_in_autocancel_window: bool,
 }
 impl FighterStateImpl for AirAttackState {
    const NAME: &'static str = "AirAttack";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        let animation_frame = state_context.get_current_animation_frame();
        let script = state_context
            .attack_scripts
            .get(&state_context.attack_script_assets.scripts[&self.attack_kind]);
        if let Some(script) = script {
            if let Some(iasa_frame) = script.iasa_frame {
                if animation_frame >= iasa_frame {
                    let new_state = jump::check_input_double_jump(state_context).or_else(|| air_attack::check_interrupt(state_context, &self.airborne_state_common));
                    if let Some(new_state) = new_state {
                        return Some(new_state);
                    }
                }
            }
        }
        if state_context.is_current_animation_finished() {
            Some(FighterState::Fall(FallState::new(
                self.airborne_state_common,
            )))
        } else {
            None
        }
    }
    fn update(&mut self, state_context: &mut UpdateContext) {
        let animation_frame = state_context.get_current_animation_frame();
        let script = state_context
            .attack_scripts
            .get(&state_context.attack_script_assets.scripts[&self.attack_kind]);
        if let Some(script) = script {
            update_active_attack(
                script,
                state_context
                    .hitboxes
                    .0
                    .as_mut()
                    .expect("ground attack must have active hitboxes"),
                animation_frame,
            );
            if let Some((autocancel_start, autocancel_end)) = script.wont_autocancel_window {
                self.is_in_autocancel_window =
                    animation_frame < autocancel_start || animation_frame > autocancel_end;
            }
        }
        air::update_standard_motion(state_context, &mut self.airborne_state_common);
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        state_context
            .input
            .consume_command(crate::input::FighterCommands::Attack);
        state_context.play_animation(self.attack_kind.get_animation(), false);
        let script = state_context.attack_script_assets.scripts[&self.attack_kind].clone();
        state_context.hitboxes.0 = Some(crate::fighter::FighterActiveAttack {
            kind: self.attack_kind,
            script,
            active_hitboxes: Vec::new(),
            solved_hitboxes: Vec::new(),
            hit_groups: Vec::new(),
            stalled: false,
        });
    }
    fn on_exit(&mut self, state_context: &mut ExitContext) {
        state_context.hitboxes.0 = None;
    }
    fn check_collision_interrupt(
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
        let coll_interrupt = air::collision_interrupt(
            state_context,
            crate::fighter::state::land::LandingType::Normal,
            false,
        );
        coll_interrupt.map(|state| {
            if self.is_in_autocancel_window {
                state
            } else {
                // TODO: Implement proper landing lag
                state
            }
        })
    }
    fn is_visually_grounded<'a>(&'a self) -> bool {
        false
    }
 }
 #[derive(thiserror::Error, Debug)]
 pub enum AirAttackStateCreateError {
    #[error("Attack script: {attack:?} not found")]
    AttackScriptNotFound { attack: AttackKind },
 }
 impl AirAttackState {
    pub fn create(
        attack_kind: AttackKind,
        attack_script_assets: &FighterAttackScriptAssets,
        airborne_state_common: &AirborneStateCommon,
    ) -> Result<Self, AirAttackStateCreateError> {
        if attack_script_assets.scripts.contains_key(&attack_kind) {
            Ok(AirAttackState {
                airborne_state_common: airborne_state_common.clone(),
                attack_kind,
                is_in_autocancel_window: false,
            })
        } else {
            Err(AirAttackStateCreateError::AttackScriptNotFound {
                attack: attack_kind,
            })
        }
    }
 }
 pub fn check_interrupt(
    state_context: &InterruptContext,
    airborne_state_common: &AirborneStateCommon,
 ) -> Option<FighterState> {
    if state_context
        .input
        .has_command(crate::input::FighterCommands::Attack)
    {
        let attack_kind = state_context
            .input
            .get_attack_command_type()
            .to_attack_kind_airborne(state_context.facing_direction);
        let state = AirAttackState::create(
            attack_kind,
            state_context.attack_script_assets,
            airborne_state_common,
        );
        match state {
            Ok(state) => Some(FighterState::AirAttack(state)),
            Err(create_error) => {
                error!("{}", create_error);
                None
            }
        }
    } else {
        None
    }
 }
@@ -1,9 +1,17 @@
 use crate::{
    fighter::{
-        animation::AnimKind, state::{
+        FighterInvulnerabilityState,
-            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, 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)]
@@ -16,13 +24,21 @@ impl FighterStateImpl for AirDodgeState {
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        if state_context.is_current_animation_finished() {
-            Some(FighterState::Fall(FallState::new(AirborneStateCommon::default())))
+            Some(FighterState::Fall(FallState::new(
                AirborneStateCommon::default(),
            )))
        } else {
            None
        }
    }
    fn update(&mut self, state_context: &mut UpdateContext) {
        let airdodge_intangible_end = state_context.fighter_attributes.air_dodge_intangible_start + state_context.fighter_attributes.air_dodge_intangible_duration;
        if state_context.animation_frame == state_context.fighter_attributes.air_dodge_intangible_start {
            *state_context.vulnerability = FighterInvulnerabilityState::Intangible { frames_remaining: Some(state_context.fighter_attributes.air_dodge_intangible_duration) };
        } else if state_context.animation_frame >= airdodge_intangible_end {
            *state_context.vulnerability = FighterInvulnerabilityState::Vulnerable;
        }
        state_context.velocity.0 *= state_context.fighter_attributes.air_dodge_decay;
        air::apply_air_motion(
@@ -36,28 +52,52 @@ impl FighterStateImpl for AirDodgeState {
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
-        air::collision_interrupt(state_context, LandingType::Special)
+        air::collision_interrupt(state_context, LandingType::Special, false)
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        state_context.play_animation(AnimKind::AirDodge, false);
        state_context
            .input
            .clear_command(input::FighterCommands::Shield);
        state_context
            .input
            .clear_command(input::FighterCommands::GuardHold);
        state_context.velocity.0 =
            self.direction * state_context.fighter_attributes.air_dodge_velocity;
    }
-    fn is_visually_grounded<'a>(
+    fn is_visually_grounded<'a>(&'a self) -> bool {
        &'a self,
    ) -> bool {
        false
    }
    fn surface_policy(&self) -> super::SurfacePolicy {
        super::SurfacePolicy::Airborne(crate::fighter::surface::EcbLockPolicy::StartOnDetach)
    }
    fn on_exit(&mut self, state_context: &mut super::ExitContext) {
        *state_context.vulnerability = FighterInvulnerabilityState::Vulnerable;
    }
    fn name(&self) -> String {
        Self::NAME.to_owned()
    }
 }
 pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
    state_context
        .input
        .has_command(input::FighterCommands::Shield)
-        .then(|| {
+        .then_some(())
        .or_else(|| {
            state_context
                .input
                .has_command(input::FighterCommands::GuardHold)
                .then_some(())
        })
        .map(|_| {
            FighterState::AirDodge(AirDodgeState {
                direction: state_context
                    .input
@@ -0,0 +1,54 @@
 use crate::{fighter::{FighterInvulnerabilityState, animation::AnimKind, state::{FighterState, FighterStateImpl, air::AirborneStateCommon, fall::FallState}}, math::vec::FGVec2};
 #[derive(Debug, Clone, Hash)]
 pub struct AngelState {
    frames_remaining: u32
 }
 impl AngelState {
    pub fn new(duration: u32) -> Self {
        Self {
            frames_remaining: duration
        }
    }
 }
 impl FighterStateImpl for AngelState {
    const NAME: &'static str = "Angel";
    fn check_interrupt(&self, state_context: &mut super::InterruptContext) -> Option<super::FighterState> {
        let moved_sideways = !state_context.input.get_last_frame().movement.x.is_zero();
        let moved_vertically = !state_context.input.get_last_frame().movement.y.is_zero();
        if self.frames_remaining == 0 || moved_sideways || moved_vertically {
            Some(FighterState::Fall(FallState::new(AirborneStateCommon::default())))
        } else {
            None
        }
    }
    fn update(&mut self, _state_context: &mut super::UpdateContext) {
        self.frames_remaining = self.frames_remaining.saturating_sub(1);
    }
    fn is_visually_grounded<'a>(&'a self) -> bool {
        false
    }
    fn on_enter(&mut self, state_context: &mut super::EnterContext) {
        state_context.play_animation(AnimKind::Wait, true);
        state_context.velocity.0 = FGVec2::ZERO;
        *state_context.vulnerability = FighterInvulnerabilityState::Invulnerable { frames_remaining: Some(state_context.game_settings.fighter_common.angel_platform_invulnerability_duration) };
    }
    fn check_collision_interrupt(
        &mut self,
        _state_context: &mut super::CollisionContext,
    ) -> Option<super::FighterState> {
        None
    }
    fn surface_policy(&self) -> super::SurfacePolicy {
        super::SurfacePolicy::Airborne(crate::fighter::surface::EcbLockPolicy::Clear)
    }
 }
@@ -0,0 +1,160 @@
 use super::{
    CollisionContext, EnterContext, FighterStateImpl, InterruptContext, UpdateContext, ground,
 };
 use crate::fighter::FighterSurfaceState;
 use crate::fighter::animation::AnimKind;
 use crate::fighter::state::air::AirborneStateCommon;
 use crate::fighter::state::ground::{
    grounded_movement_common_interrupts, grounded_movement_standstill_common_interrupts,
 };
 use crate::fighter::state::platform_pass::PlatformPassState;
 use crate::fighter::state::{FighterState, dash, ground_attack, turn, walk};
 use crate::input::FighterCommands;
 use crate::stage::line::StagePolyType;
 #[derive(Debug, Clone, Hash)]
 pub enum CrouchSubState {
    Entering { pass_queued: bool },
    Idle,
    Exiting,
 }
 #[derive(Debug, Clone, Hash)]
 pub struct CrouchState {
    sub_state: CrouchSubState,
 }
 pub fn crouch_idle_interrupts(state_context: &InterruptContext) -> Option<FighterState> {
    if let Some(state) = ground_attack::check_interrupt(state_context) {
        Some(state)
    } else if let Some(state) = dash::check_input(state_context) {
        Some(state)
    } else if let Some(state) = turn::check_input(state_context) {
        Some(state)
    } else if let Some(state) = walk::check_input(state_context) {
        Some(state)
    } else {
        None
    }
 }
 pub fn crouch_entering_interrupts(state_context: &InterruptContext) -> Option<FighterState> {
    if let Some(state) = ground_attack::check_interrupt(state_context) {
        Some(state)
    } else {
        None
    }
 }
 impl FighterStateImpl for CrouchState {
    const NAME: &'static str = "Crouch";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        if let Some(state) = grounded_movement_common_interrupts(state_context) {
            return Some(state);
        }
        match self.sub_state {
            CrouchSubState::Entering { pass_queued } => {
                // pass
                if let FighterSurfaceState::Grounded { line_id } = state_context.surface {
                    if let Some(stage_poly) = state_context
                        .stage_collision
                        .stage_polys
                        .get(line_id.polygon)
                    {
                        let is_inputting_crouch = -state_context.game_settings.input_common.run_stick_threshold > state_context.input.get_last_frame().movement.y;
                        let is_on_a_soft_platform = matches!(stage_poly.poly_type, StagePolyType::Platform);
                        if pass_queued && is_inputting_crouch && is_on_a_soft_platform 
                        {
                            return Some(FighterState::PlatformPass(PlatformPassState::new(
                                AirborneStateCommon::default(),
                                line_id.polygon,
                            )));
                        }
                    }
                }
                // While entering the crouch animation we do not allow movement inputs, but we do allow attacks and jumps
                if state_context.is_current_animation_finished() {
                    return Some(FighterState::Crouch(CrouchState {
                        sub_state: CrouchSubState::Idle,
                    }));
                } else {
                    return crouch_entering_interrupts(state_context);
                }
            }
            CrouchSubState::Idle => {
                if state_context.input.get_last_frame().movement.y
                    > -state_context.game_settings.input_common.run_stick_threshold
                {
                    return Some(FighterState::Crouch(CrouchState {
                        sub_state: CrouchSubState::Exiting,
                    }));
                } else {
                    return crouch_idle_interrupts(state_context);
                }
            }
            CrouchSubState::Exiting => {
                if state_context.is_current_animation_finished() {
                    return grounded_movement_standstill_common_interrupts(state_context);
                } else {
                    return crouch_idle_interrupts(state_context);
                }
            }
        }
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        match self.sub_state {
            CrouchSubState::Entering { .. } => {
                state_context.play_animation(AnimKind::CrouchEnter, false);
            }
            CrouchSubState::Idle => {
                state_context.play_animation(AnimKind::CrouchIdle, true);
            }
            CrouchSubState::Exiting => {
                state_context.play_animation(AnimKind::CrouchExit, false);
            }
        }
    }
    fn update(&mut self, state_context: &mut UpdateContext) {
        if let CrouchSubState::Entering {
            pass_queued,
        } = &mut self.sub_state
        {
            if state_context
                .input
                .has_command(FighterCommands::SmashMoveDown)
            {
                state_context
                    .input
                    .clear_command(FighterCommands::SmashMoveDown);
                *pass_queued = true;
            }
        }
        ground::update_friction_motion(state_context);
    }
    fn check_collision_interrupt(
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
        ground::collision_interrupt(state_context, false)
    }
    fn is_visually_grounded<'a>(&'a self) -> bool {
        true
    }
 }
 pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
    let input_frame = state_context.input.get_last_frame();
    if input_frame.movement.y <= -state_context.game_settings.input_common.run_stick_threshold {
        return Some(FighterState::Crouch(CrouchState {
            sub_state: CrouchSubState::Entering { pass_queued: false },
        }));
    }
    None
 }
@@ -5,52 +5,43 @@ use super::{
 use crate::fighter::FighterFacingDirection;
 use crate::fighter::animation::AnimKind;
 use crate::fighter::state::FighterState;
 use crate::fighter::state::ground::GroundedStateCommon;
 use crate::input::FighterCommands::{SmashMoveLeft, SmashMoveRight};
 #[derive(Debug, Clone, Hash)]
 pub struct DashState {
    direction: FighterFacingDirection,
    pub ground_common: GroundedStateCommon,
 }
 impl DashState {
-    pub fn new(direction: FighterFacingDirection, ground_common: GroundedStateCommon) -> Self {
+    pub fn new(direction: FighterFacingDirection) -> Self {
-        Self {
+        Self { direction }
            direction,
            ground_common,
        }
    }
 }
 impl FighterStateImpl for DashState {
    const NAME: &'static str = "Dash";
    fn check_interrupt(&self, ctx: &mut InterruptContext) -> Option<FighterState> {
        let ground = &self.ground_common;
        let attributes = ctx.fighter_attributes;
        // A reverse dash can interrupt before IASA
        if let Some(direction) =
            check_smash_input_with_dir(ctx).filter(|direction| *direction != self.direction)
        {
-            return Some(FighterState::Dash(DashState::new(
+            return Some(FighterState::Dash(DashState::new(direction)));
                direction,
                ground.clone(),
            )));
        }
-        if let Some(state) = ground::grounded_movement_common_interrupts(ctx, ground) {
+        if let Some(state) = ground::grounded_movement_common_interrupts(ctx) {
            return Some(state);
        }
        if ctx.is_current_animation_finished() {
-            return run::check_input(ctx, ground)
+            return run::check_input(ctx)
-                .or_else(|| walk::check_input(ctx, ground))
+                .or_else(|| walk::check_input(ctx))
-                .or_else(|| wait::check_input(ctx, ground));
+                .or_else(|| wait::check_input(ctx));
        }
        if ctx.get_current_animation_frame() > attributes.dash_acceleration_duration {
-            return run::check_input(ctx, ground);
+            return run::check_input(ctx);
        }
        None
@@ -106,12 +97,10 @@ impl FighterStateImpl for DashState {
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, &mut self.ground_common, true)
+        ground::collision_interrupt(state_context, true)
    }
-    fn is_visually_grounded<'a>(
+    fn is_visually_grounded<'a>(&'a self) -> bool {
        &'a self,
    ) -> bool {
        true
    }
 }
@@ -126,10 +115,6 @@ fn check_smash_input_with_dir(state_context: &InterruptContext) -> Option<Fighte
    }
 }
-pub fn check_input(
+pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
-    state_context: &InterruptContext,
+    check_smash_input_with_dir(state_context).map(|dir| FighterState::Dash(DashState::new(dir)))
    ground_common: &GroundedStateCommon,
 ) -> Option<FighterState> {
    check_smash_input_with_dir(state_context)
        .map(|dir| FighterState::Dash(DashState::new(dir, ground_common.clone())))
 }
@@ -1,7 +1,7 @@
 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};
+use crate::fighter::state::{FighterState, air, air_attack, jump};
 #[derive(Debug, Clone, Copy, Hash, Default)]
 pub struct FallState {
@@ -20,7 +20,7 @@ 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)
+        jump::check_input_double_jump(state_context).or_else(|| air_attack::check_interrupt(state_context, &self.airborne_state_common))
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
@@ -38,6 +38,7 @@ impl FighterStateImpl for FallState {
        air::collision_interrupt(
            state_context,
            crate::fighter::state::land::LandingType::Normal,
            true,
        )
    }
@@ -46,5 +47,8 @@ impl FighterStateImpl for FallState {
    ) -> bool {
        false
    }
 }
    fn surface_policy(&self) -> super::SurfacePolicy {
        super::SurfacePolicy::Airborne(crate::fighter::surface::EcbLockPolicy::StartOnDetach)
    }
 }
@@ -3,7 +3,7 @@
 //! bit-for-bit deterministic for rollback.
 use crate::fighter::state::{
-    CollisionContext, FighterState, InterruptContext, air, dash, fall, ground_attack, turn, wait, walk,
+    CollisionContext, FighterState, InterruptContext, air, crouch, dash, fall, ground_attack, turn, wait, walk,
 };
 use crate::fighter::{
    FighterAttributes, FighterPreviousTranslation, FighterTranslation, FighterVelocity,
@@ -13,13 +13,6 @@ use crate::math::int::{FGWide, FGi32};
 use crate::math::vec::FGVec2;
 use crate::stage::line::{StageLineID, StagePoly, StagePolyLineSegment, StagePolyLineSegmentType};
 use bevy::prelude::*;
 #[derive(Reflect, Hash, Clone, Debug)]
 pub struct GroundedStateCommon {
    pub current_line_id: StageLineID,
 }
 pub fn apply_grounded_friction(friction: FGi32, ground_vel: FGi32) -> FGi32 {
    if friction.abs() > ground_vel.abs() {
        -ground_vel
@@ -181,22 +174,23 @@ pub fn update_friction_motion(ctx: &mut crate::fighter::state::UpdateContext) {
 pub fn collide_with_stage_grounded(
    state_context: &mut CollisionContext,
    ground_common: &mut GroundedStateCommon,
    can_walk_off: bool,
 ) -> GroundedMotionResult {
    let translation = &mut state_context.translation;
-    let ecb = state_context.ecb;
+    let ecb = &state_context.ecb;
    let stage_collision = state_context.stage_collision;
-    let stage_poly = stage_collision
+    let Some(current_line_id) = state_context.surface.line_id() else {
-        .stage_polys
+        return GroundedMotionResult::InAir;
-        .get(ground_common.current_line_id.polygon);
+    };
    let stage_poly = stage_collision.stage_polys.get(current_line_id.polygon);
    if let Some(stage_poly) = stage_poly {
        let ecb_bottom_pos = translation.0 + ecb.get_bottom_point();
        match resolve_grounded_position(
            stage_poly,
-            ground_common.current_line_id.segment,
+            current_line_id.segment,
            ecb_bottom_pos,
            can_walk_off,
        ) {
@@ -216,31 +210,45 @@ pub fn collide_with_stage_grounded(
                            .0
                            .project_onto_normalized(current_segment.normal)
                };
-                ground_common.current_line_id.segment = segment_idx;
+                state_context.surface.land(StageLineID {
                    polygon: current_line_id.polygon,
                    segment: segment_idx,
                });
                GroundedMotionResult::InGround
            }
-            GroundedPositionResult::InAir => GroundedMotionResult::InAir,
+            GroundedPositionResult::InAir => {
                state_context.surface.apply_airborne_policy(
                    crate::fighter::surface::EcbLockPolicy::StartOnDetach,
                    state_context.leave_ground_ecb_lock_duration,
                );
                GroundedMotionResult::InAir
            }
        }
    } else {
        state_context.surface.apply_airborne_policy(
            crate::fighter::surface::EcbLockPolicy::StartOnDetach,
            state_context.leave_ground_ecb_lock_duration,
        );
        GroundedMotionResult::InAir
    }
 }
-pub fn collision_interrupt(
+pub fn collision_interrupt(ctx: &mut CollisionContext, can_walk_off: bool) -> Option<FighterState> {
-    ctx: &mut CollisionContext,
+    match collide_with_stage_grounded(ctx, can_walk_off) {
    common: &mut GroundedStateCommon,
    can_walk_off: bool,
 ) -> Option<FighterState> {
    match collide_with_stage_grounded(ctx, common, can_walk_off) {
        GroundedMotionResult::InGround => None,
-        GroundedMotionResult::InAir => Some(FighterState::Fall(fall::FallState::new(air::AirborneStateCommon::default()))),
+        GroundedMotionResult::InAir => Some(FighterState::Fall(fall::FallState::new(
            air::AirborneStateCommon::default(),
        ))),
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::fighter::ecb::FighterPreviousECB;
    use crate::fighter::{FighterECB, FighterSurfaceState};
    use crate::stage::line::StagePolyType;
    use crate::input::FighterInput;
    fn two_segment_floor() -> StagePoly {
        StagePoly::build(
@@ -346,28 +354,126 @@ mod tests {
            GroundedPositionResult::InAir
        ));
    }
    #[test]
    fn grounded_collision_updates_surface_segment() {
        let stage_collision = crate::stage::line::StageCollision {
            stage_polys: vec![two_segment_floor()],
        };
        let mut surface = FighterSurfaceState::Grounded {
            line_id: StageLineID {
                polygon: 0,
                segment: 0,
            },
        };
        let mut translation = FighterTranslation(FGVec2::lit("11", "0"));
        let previous_translation = FighterPreviousTranslation(translation.0);
        let mut velocity = FighterVelocity::default();
        let mut ecb = FighterECB {
            bottom: FGVec2::lit("0.0", "-0.5"),
            top: FGVec2::lit("0.0", "0.5"),
            left: FGVec2::lit("-0.5", "0.0"),
            right: FGVec2::lit("0.5", "0.0"),
        };
        let previous_ecb = FighterPreviousECB::from(ecb);
        let mut presentation_snap = crate::fighter::FighterPresentationSnap::default();
        let mut context = CollisionContext {
            translation: &mut translation,
            prev_translation: &previous_translation,
            input: &FighterInput::default(),
            velocity: &mut velocity,
            surface: &mut surface,
            ecb: &mut ecb,
            prev_ecb: &previous_ecb,
            stage_collision: &stage_collision,
            leave_ground_ecb_lock_duration: 10,
            presentation_snap: &mut presentation_snap,
            downward_stick_threshold: FGi32::ONE,
        };
        assert!(matches!(
            collide_with_stage_grounded(&mut context, true),
            GroundedMotionResult::InGround
        ));
        assert_eq!(
            surface.line_id(),
            Some(StageLineID {
                polygon: 0,
                segment: 1,
            })
        );
    }
    #[test]
    fn walking_off_edge_clears_surface_contact() {
        let stage_collision = crate::stage::line::StageCollision {
            stage_polys: vec![StagePoly::build(
                StagePolyType::Platform,
                &[
                    (FGVec2::lit("0", "0"), StagePolyLineSegmentType::Floor),
                    (FGVec2::lit("10", "0"), StagePolyLineSegmentType::Floor),
                ],
            )],
        };
        let mut surface = FighterSurfaceState::Grounded {
            line_id: StageLineID {
                polygon: 0,
                segment: 0,
            },
        };
        let mut translation = FighterTranslation(FGVec2::lit("11", "0"));
        let previous_translation = FighterPreviousTranslation(translation.0);
        let mut velocity = FighterVelocity::default();
        let mut ecb = FighterECB {
            bottom: FGVec2::lit("0.0", "-0.5"),
            top: FGVec2::lit("0.0", "0.5"),
            left: FGVec2::lit("-0.5", "0.0"),
            right: FGVec2::lit("0.5", "0.0"),
        };
        let previous_ecb = FighterPreviousECB::from(ecb);
        let mut presentation_snap = crate::fighter::FighterPresentationSnap::default();
        let mut context = CollisionContext {
            translation: &mut translation,
            prev_translation: &previous_translation,
            input: &FighterInput::default(),
            velocity: &mut velocity,
            surface: &mut surface,
            ecb: &mut ecb,
            prev_ecb: &previous_ecb,
            stage_collision: &stage_collision,
            leave_ground_ecb_lock_duration: 10,
            presentation_snap: &mut presentation_snap,
            downward_stick_threshold: FGi32::ONE,
        };
        assert!(matches!(
            collide_with_stage_grounded(&mut context, true),
            GroundedMotionResult::InAir
        ));
        assert!(matches!(surface, FighterSurfaceState::Airborne { .. }));
    }
 }
 pub fn grounded_movement_common_interrupts(
    state_context: &InterruptContext,
    ground_common: &GroundedStateCommon,
 ) -> Option<FighterState> {
-    super::jump::check_input(state_context, ground_common)
+    super::jump::check_input(state_context)
 }
 pub fn grounded_movement_standstill_common_interrupts(
    state_context: &InterruptContext,
    ground_common: &GroundedStateCommon,
 ) -> Option<FighterState> {
-    if let Some(state) = ground_attack::check_interrupt(state_context, &ground_common) {
+    if let Some(state) = ground_attack::check_interrupt(state_context) {
        Some(state)
-    } else if let Some(state) = dash::check_input(state_context, &ground_common) {
+    } else if let Some(state) = dash::check_input(state_context) {
        Some(state)
-    } else if let Some(state) = turn::check_input(state_context, &ground_common) {
+    } else if let Some(state) = turn::check_input(state_context) {
        Some(state)
-    } else if let Some(state) = walk::check_input(state_context, &ground_common) {
+    } else if let Some(state) = crouch::check_input(state_context) {
        Some(state)
-    } else if let Some(state) = wait::check_input(state_context, &ground_common) {
+    } else if let Some(state) = walk::check_input(state_context) {
        Some(state)
    } else if let Some(state) = wait::check_input(state_context) {
        Some(state)
    } else {
        None
@@ -1,15 +1,14 @@
 use crate::fighter::{
-    attack::{AttackKind, update_active_hitbox_list},
+    attack::{AttackKind, update_active_attack},
    state::{
        CollisionContext, EnterContext, ExitContext, FighterState, FighterStateImpl,
-        InterruptContext, UpdateContext, ground::GroundedStateCommon, wait::WaitState,
+        InterruptContext, UpdateContext, wait::WaitState,
    },
 };
 #[derive(Clone, Debug, Hash)]
 pub struct GroundAttackState {
    pub attack_kind: AttackKind,
    pub grounded_common: GroundedStateCommon,
 }
 impl FighterStateImpl for GroundAttackState {
@@ -17,9 +16,7 @@ impl FighterStateImpl for GroundAttackState {
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        if state_context.is_current_animation_finished() {
-            Some(FighterState::Wait(WaitState {
+            Some(FighterState::Wait(WaitState))
                grounded_common: self.grounded_common.clone(),
            }))
        } else {
            None
        }
@@ -31,20 +28,22 @@ impl FighterStateImpl for GroundAttackState {
            .attack_scripts
            .get(&state_context.attack_script_assets.scripts[&self.attack_kind]);
        if let Some(script) = script {
-            update_active_hitbox_list(
+            update_active_attack(
                script,
-                &mut state_context
+                state_context
                    .hitboxes
                    .0
                    .as_mut()
-                    .expect("ground attack must have active hitboxes")
+                    .expect("ground attack must have active hitboxes"),
                    .active_hitboxes,
                animation_frame,
            );
        }
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        state_context
            .input
            .consume_command(crate::input::FighterCommands::Attack);
        state_context.play_animation(self.attack_kind.get_animation(), false);
        let script = state_context.attack_script_assets.scripts[&self.attack_kind].clone();
        state_context.hitboxes.0 = Some(crate::fighter::FighterActiveAttack {
@@ -52,8 +51,8 @@ impl FighterStateImpl for GroundAttackState {
            script,
            active_hitboxes: Vec::new(),
            solved_hitboxes: Vec::new(),
-            hit_fighters: Vec::new(),
+            hit_groups: Vec::new(),
-            stalled: false
+            stalled: false,
        });
    }
@@ -68,17 +67,12 @@ impl FighterStateImpl for GroundAttackState {
        None
    }
-    fn is_visually_grounded<'a>(
+    fn is_visually_grounded<'a>(&'a self) -> bool {
        &'a self,
    ) -> bool {
        true
    }
 }
-pub fn check_interrupt(
+pub fn check_interrupt(state_context: &InterruptContext) -> Option<FighterState> {
    state_context: &InterruptContext,
    grounded_common: &GroundedStateCommon,
 ) -> Option<FighterState> {
    if state_context
        .input
        .has_command(crate::input::FighterCommands::Attack)
@@ -89,7 +83,6 @@ pub fn check_interrupt(
            .to_attack_kind_grounded();
        Some(FighterState::GroundAttack(GroundAttackState {
            attack_kind,
            grounded_common: grounded_common.clone(),
        }))
    } else {
        None
@@ -7,17 +7,16 @@ use crate::{
            InterruptContext, UpdateContext,
            air::{self, AirborneStateCommon},
            fall::FallState,
-            ground::{GroundedStateCommon, collision_interrupt},
+            ground::collision_interrupt,
            land::LandingType,
            wait::WaitState,
        },
-    },
+    }, math::{int::FGi32, vec::FGVec2},
    math::int::FGi32,
 };
 #[derive(Clone, Debug, Hash)]
 pub enum HitstopStateKind {
-    Grounded(GroundedStateCommon),
+    Grounded,
    Airborne,
 }
@@ -43,7 +42,7 @@ impl FighterStateImpl for HitstunState {
    fn name(&self) -> String {
        let hitstop_kind = match self.hitstop_kind {
-            HitstopStateKind::Grounded(_) => "Grounded",
+            HitstopStateKind::Grounded => "Grounded",
            HitstopStateKind::Airborne => "Airborne",
        };
@@ -58,14 +57,10 @@ impl FighterStateImpl for HitstunState {
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        if state_context.get_current_animation_frame() > self.hit_reaction.hitstun_frames {
            match &self.hitstop_kind {
-                HitstopStateKind::Grounded(grounded_state_common) => {
+                HitstopStateKind::Grounded => Some(FighterState::Wait(WaitState)),
-                    Some(FighterState::Wait(WaitState {
+                HitstopStateKind::Airborne => Some(FighterState::Fall(FallState::new(
-                        grounded_common: grounded_state_common.clone(),
+                    AirborneStateCommon::default(),
-                    }))
+                ))),
                }
                HitstopStateKind::Airborne => {
                    Some(FighterState::Fall(FallState::new(AirborneStateCommon::default())))
                }
            }
        } else {
            None
@@ -85,7 +80,7 @@ impl FighterStateImpl for HitstunState {
        }
        match self.hitstop_kind {
-            HitstopStateKind::Grounded(_) => {}
+            HitstopStateKind::Grounded => {}
            HitstopStateKind::Airborne => {
                air::integrate_gravity(ctx.velocity, ctx.fighter_attributes, false);
            }
@@ -103,10 +98,11 @@ impl FighterStateImpl for HitstunState {
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        let animation = match self.hitstop_kind {
-            HitstopStateKind::Grounded(_) => AnimKind::FlinchGround,
+            HitstopStateKind::Grounded => AnimKind::FlinchGround,
            HitstopStateKind::Airborne => AnimKind::FlinchAir,
        };
        state_context.play_animation(animation, false);
        state_context.velocity.0 = FGVec2::ZERO;
    }
    fn on_exit(&mut self, _state_context: &mut ExitContext) {}
@@ -116,19 +112,26 @@ impl FighterStateImpl for HitstunState {
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
        match &mut self.hitstop_kind {
-            HitstopStateKind::Grounded(grounded_state_common) => {
+            HitstopStateKind::Grounded => collision_interrupt(state_context, true),
                collision_interrupt(state_context, grounded_state_common, true)
            }
            HitstopStateKind::Airborne => {
-                air::collision_interrupt(state_context, LandingType::Normal)
+                air::collision_interrupt(state_context, LandingType::Normal, false)
            }
        }
    }
    fn is_visually_grounded<'a>(&'a self) -> bool {
        match self.hitstop_kind {
-            HitstopStateKind::Grounded(_) => true,
+            HitstopStateKind::Grounded => true,
            HitstopStateKind::Airborne => false,
        }
    }
    fn surface_policy(&self) -> super::SurfacePolicy {
        match self.hitstop_kind {
            HitstopStateKind::Grounded => super::SurfacePolicy::Grounded,
            HitstopStateKind::Airborne => super::SurfacePolicy::Airborne(
                crate::fighter::surface::EcbLockPolicy::StartOnDetach,
            ),
        }
    }
 }
@@ -2,10 +2,17 @@ use bevy::prelude::*;
 use crate::{
    fighter::{
-        animation::AnimKind, state::{
+        animation::AnimKind,
-            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, air_dodge::{self, AirDodgeState}, ground::{self, GroundedStateCommon},
+        state::{
            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext,
            UpdateContext,
            air::{self, AirborneStateCommon},
            air_dodge::AirDodgeState,
            ground,
        },
-    }, input::FighterCommands, math::{int::FGi32, vec::FGVec2},
+    },
    input::{DigitalAction, FighterCommands},
    math::{int::FGi32, vec::FGVec2},
 };
 #[derive(Debug, Hash, Clone, Copy)]
 pub enum JumpType {
@@ -16,20 +23,18 @@ pub enum JumpType {
 #[derive(Debug, Clone, Hash)]
 pub struct JumpState {
-    jump_type: JumpType,
+    pub jump_type: JumpType,
-    airborne_state_common: AirborneStateCommon,
+    pub airborne_state_common: AirborneStateCommon,
 }
 #[derive(Debug, Clone, Hash)]
 pub struct JumpSquatState {
    pub grounded_common: GroundedStateCommon,
    pub duration_counter: u32,
 }
 impl JumpSquatState {
-    pub fn create(grounded_common: GroundedStateCommon) -> Self {
+    pub fn create() -> Self {
        Self {
            grounded_common,
            duration_counter: 0,
        }
    }
@@ -63,13 +68,26 @@ impl FighterStateImpl for JumpSquatState {
                direction: wavedash_dir.normalize_or_zero(),
            }))
        } else if self.duration_counter >= state_context.fighter_attributes.jumpsquat_duration {
-            info!("Jump {}", state_context.input.get_last_frame().jump);
+            info!(
-            let jump_type = if state_context.input.get_last_frame().jump {
+                "Jump {}",
                state_context
                    .input
                    .get_last_frame()
                    .is_held(DigitalAction::Jump)
            );
            let jump_type = if state_context
                .input
                .get_last_frame()
                .is_held(DigitalAction::Jump)
            {
                JumpType::LongJump
            } else {
                JumpType::ShortHop
            };
-            Some(FighterState::Jump(JumpState { jump_type, airborne_state_common: AirborneStateCommon::default() }))
+            Some(FighterState::Jump(JumpState {
                jump_type,
                airborne_state_common: AirborneStateCommon::default(),
            }))
        } else {
            None
        }
@@ -84,17 +102,20 @@ impl FighterStateImpl for JumpSquatState {
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, &mut self.grounded_common, false)
+        ground::collision_interrupt(state_context, false)
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        state_context.play_animation(AnimKind::JumpSquat, false);
        state_context.input.enable_hold_all(10);
        state_context.input.clear_command(FighterCommands::Jump);
    }
-    fn is_visually_grounded<'a>(
+    fn on_exit(&mut self, state_context: &mut crate::fighter::state::ExitContext) {
-        &'a self,
+        state_context.input.disable_hold_all();
-    ) -> bool {
+    }
    fn is_visually_grounded<'a>(&'a self) -> bool {
        true
    }
 }
@@ -102,14 +123,7 @@ impl FighterStateImpl for JumpSquatState {
 impl FighterStateImpl for JumpState {
    const NAME: &'static str = "Jump";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
-        if state_context.input.has_command(FighterCommands::Jump) {
+        air::air_interrupts_common(state_context, &self.airborne_state_common)
            Some(FighterState::Jump(JumpState {
                jump_type: JumpType::DoubleJump,
                airborne_state_common: AirborneStateCommon::default()
            }))
        } else {
            air_dodge::check_input(state_context)
        }
    }
    fn update(&mut self, state_context: &mut UpdateContext) {
@@ -174,24 +188,30 @@ impl FighterStateImpl for JumpState {
        air::collision_interrupt(
            state_context,
            crate::fighter::state::land::LandingType::Normal,
            true,
        )
    }
-    fn is_visually_grounded<'a>(
+    fn is_visually_grounded<'a>(&'a self) -> bool {
        &'a self,
    ) -> bool {
        false
    }
    fn surface_policy(&self) -> super::SurfacePolicy {
        use crate::fighter::surface::EcbLockPolicy;
        match self.jump_type {
            JumpType::DoubleJump => super::SurfacePolicy::Airborne(EcbLockPolicy::Restart),
            JumpType::ShortHop | JumpType::LongJump => {
                super::SurfacePolicy::Airborne(EcbLockPolicy::StartOnDetach)
            }
        }
    }
 }
-pub fn check_input(
+pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
    state_context: &InterruptContext,
    ground_common: &GroundedStateCommon,
 ) -> Option<FighterState> {
    state_context
        .input
        .has_command(FighterCommands::Jump)
-        .then(|| FighterState::JumpSquat(JumpSquatState::create(ground_common.clone())))
+        .then(|| FighterState::JumpSquat(JumpSquatState::create()))
 }
 pub fn check_input_double_jump(state_context: &InterruptContext) -> Option<FighterState> {
@@ -201,7 +221,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()
+                airborne_state_common: AirborneStateCommon::default(),
            })
        })
 }
@@ -3,7 +3,7 @@ use crate::fighter::{
    state::{
        CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext,
        UpdateContext, dash,
-        ground::{self, GroundedStateCommon, grounded_movement_standstill_common_interrupts},
+        ground::{self, grounded_movement_standstill_common_interrupts},
        walk,
    },
 };
@@ -16,16 +16,12 @@ pub enum LandingType {
 #[derive(Debug, Clone, Hash)]
 pub struct LandingState {
    pub grounded_common: GroundedStateCommon,
    pub landing_type: LandingType,
 }
 impl LandingState {
-    pub fn create(grounded_common: GroundedStateCommon, landing_type: LandingType) -> Self {
+    pub fn create(landing_type: LandingType) -> Self {
-        Self {
+        Self { landing_type }
            grounded_common,
            landing_type,
        }
    }
 }
@@ -34,14 +30,14 @@ impl FighterStateImpl for LandingState {
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        if state_context.is_current_animation_finished() {
-            grounded_movement_standstill_common_interrupts(state_context, &self.grounded_common)
+            grounded_movement_standstill_common_interrupts(state_context)
        } else if state_context.get_current_animation_frame()
            >= state_context.fighter_attributes.landing_iasa
            && let LandingType::Normal = self.landing_type
        {
-            dash::check_input(state_context, &self.grounded_common).or_else(|| {
+            dash::check_input(state_context).or_else(|| {
-                ground::grounded_movement_common_interrupts(state_context, &self.grounded_common)
+                ground::grounded_movement_common_interrupts(state_context)
-                    .or_else(|| walk::check_input(state_context, &self.grounded_common))
+                    .or_else(|| walk::check_input(state_context))
            })
        } else {
            None
@@ -56,7 +52,7 @@ impl FighterStateImpl for LandingState {
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, &mut self.grounded_common, true)
+        ground::collision_interrupt(state_context, true)
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
@@ -70,9 +66,7 @@ impl FighterStateImpl for LandingState {
        };
    }
-    fn is_visually_grounded<'a>(
+    fn is_visually_grounded<'a>(&'a self) -> bool {
        &'a self,
    ) -> bool {
        true
    }
 }
@@ -7,25 +7,38 @@ use bevy::prelude::*;
 use crate::fighter::animation::{AnimKind, FighterAnimationFrame};
 use crate::fighter::attack::{
-    FighterAttackScriptAssets, FighterKnockbackVelocity, FighterPendingHitReaction, FighterStaleMoveQueue, HitStop,
+    FighterAttackScriptAssets, FighterKnockbackVelocity, FighterPendingHitReaction,
    FighterStaleMoveQueue, HitStop,
 };
 use crate::fighter::attributes::FighterAttributes;
 use crate::fighter::baked_animation::BakedFighterAnimations;
 use crate::fighter::ecb::FighterPreviousECB;
 use crate::fighter::manifest::FighterManifest;
 use crate::fighter::state::hitstun::HitstunState;
 use crate::fighter::surface::EcbLockPolicy;
 use crate::fighter::visual::FighterAnimations;
 use crate::fighter::{
-    Fighter, FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole, FighterPreviousTranslation, FighterTranslation, FighterVelocity,
+    Fighter, FighterDamage, FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop,
    FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole,
    FighterInvulnerabilityState, FighterPendingRespawn, FighterPresentationSnap,
    FighterPreviousTranslation, FighterSurfaceState, FighterTranslation, FighterVelocity,
 };
 use crate::game_settings::GameSettings;
 use crate::input::FighterInput;
 use crate::match_loading::MatchConfig;
 use crate::match_runtime::MatchState;
 use crate::math::int::FGi32;
 use crate::math::vec::FGVec2;
 use crate::player::Player;
 use crate::scripting::FighterAttackScript;
 use crate::stage::line::StageCollision;
 use crate::stage::manifest::{StageManifest, StageManifestRegistry};
 pub mod air;
 pub mod air_attack;
 pub mod air_dodge;
 pub mod angel;
 pub mod crouch;
 pub mod dash;
 pub mod fall;
 pub mod ground;
@@ -33,11 +46,18 @@ pub mod ground_attack;
 pub mod hitstun;
 pub mod jump;
 pub mod land;
 pub mod platform_pass;
 pub mod run;
 pub mod turn;
 pub mod wait;
 pub mod walk;
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub enum SurfacePolicy {
    Grounded,
    Airborne(EcbLockPolicy),
 }
 macro_rules! fighter_states {
    ($($variant:ident => $ty:ty),* $(,)?) => {
        #[derive(Component, Clone, Debug, Hash)]
@@ -69,6 +89,10 @@ macro_rules! fighter_states {
            pub fn is_visually_grounded(&self) -> bool {
                match self { $(Self::$variant(s) => s.is_visually_grounded()),* }
            }
            pub fn surface_policy(&self) -> SurfacePolicy {
                match self { $(Self::$variant(s) => s.surface_policy()),* }
            }
        }
        $(impl From<$ty> for FighterState {
@@ -95,9 +119,11 @@ pub trait FighterStateImpl: Sized {
        None
    }
-    fn is_visually_grounded<'a>(
+    fn is_visually_grounded<'a>(&'a self) -> bool;
-        &'a self,
+
-    ) -> bool;
+    fn surface_policy(&self) -> SurfacePolicy {
        SurfacePolicy::Grounded
    }
 }
 pub struct AnimationStatus {
@@ -110,7 +136,11 @@ pub struct InterruptContext<'a> {
    pub facing_direction: &'a mut FighterFacingDirection,
    pub game_settings: &'a GameSettings,
    pub fighter_attributes: &'a FighterAttributes,
    pub surface: &'a FighterSurfaceState,
    pub animation: AnimationStatus,
    pub stage_collision: &'a StageCollision,
    pub attack_scripts: &'a Assets<FighterAttackScript>,
    pub attack_script_assets: &'a FighterAttackScriptAssets,
 }
 impl InterruptContext<'_> {
@@ -131,8 +161,11 @@ pub struct EnterContext<'a> {
    pub stale_move_queue: &'a mut FighterStaleMoveQueue,
    pub facing_direction: &'a mut FighterFacingDirection,
    pub animation_frame: &'a mut FighterAnimationFrame,
    pub surface: &'a mut FighterSurfaceState,
    pub vulnerability: &'a mut FighterInvulnerabilityState,
    pub fighter_attributes: &'a FighterAttributes,
    pub attack_script_assets: &'a FighterAttackScriptAssets,
    pub game_settings: &'a GameSettings,
 }
 impl EnterContext<'_> {
@@ -142,7 +175,10 @@ impl EnterContext<'_> {
 }
 pub struct ExitContext<'a> {
    pub input: &'a mut FighterInput,
    pub hitboxes: &'a mut FighterHitboxes,
    pub surface: &'a mut FighterSurfaceState,
    pub vulnerability: &'a mut FighterInvulnerabilityState,
 }
 pub struct UpdateContext<'a> {
@@ -151,7 +187,9 @@ pub struct UpdateContext<'a> {
    pub input: &'a mut FighterInput,
    pub hitboxes: &'a mut FighterHitboxes,
    pub velocity: &'a mut FighterVelocity,
    pub surface: &'a mut FighterSurfaceState,
    pub knockback_velocity: &'a mut FighterKnockbackVelocity,
    pub vulnerability: &'a mut FighterInvulnerabilityState,
    pub game_settings: &'a GameSettings,
    pub animation_frame: u32,
    pub fighter_attributes: &'a FighterAttributes,
@@ -169,22 +207,33 @@ impl UpdateContext<'_> {
 pub struct CollisionContext<'a> {
    pub translation: &'a mut FighterTranslation,
    pub prev_translation: &'a FighterPreviousTranslation,
    pub input: &'a FighterInput,
    pub velocity: &'a mut FighterVelocity,
-    pub ecb: &'a FighterECB,
+    pub surface: &'a mut FighterSurfaceState,
    pub ecb: &'a mut FighterECB,
    pub prev_ecb: &'a FighterPreviousECB,
    pub stage_collision: &'a StageCollision,
    pub leave_ground_ecb_lock_duration: u32,
    pub presentation_snap: &'a mut FighterPresentationSnap,
    pub downward_stick_threshold: FGi32,
 }
 impl CollisionContext<'_> {
    pub fn air_collide_with_stage(
        &self,
        can_ignore_soft_platforms: bool,
    ) -> Option<crate::fighter::collision::AirCollisionWithStageResult> {
        let ignored_polys = self.surface.ignored_polygon_ids();
        let ignore_soft_platforms = can_ignore_soft_platforms
            && self.input.get_last_frame().movement.y <= -self.downward_stick_threshold;
        crate::fighter::collision::air_collide_with_stage(
            self.prev_translation,
            self.translation,
            self.prev_ecb,
            self.ecb,
            self.stage_collision,
            &ignored_polys,
            ignore_soft_platforms,
        )
    }
 }
@@ -192,6 +241,8 @@ impl CollisionContext<'_> {
 fighter_states! {
    Wait => wait::WaitState,
    Walk => walk::WalkState,
    PlatformPass => platform_pass::PlatformPassState,
    Crouch => crouch::CrouchState,
    Dash => dash::DashState,
    Run => run::RunState,
    Fall => fall::FallState,
@@ -202,6 +253,8 @@ fighter_states! {
    Turn => turn::TurnState,
    GroundAttack => ground_attack::GroundAttackState,
    Hitstun => hitstun::HitstunState,
    Angel => angel::AngelState,
    AirAttack => air_attack::AirAttackState,
 }
 #[derive(QueryData)]
@@ -209,15 +262,18 @@ fighter_states! {
 pub struct FighterFrameQuery {
    pub translation: &'static mut FighterTranslation,
    pub prev_translation: &'static mut FighterPreviousTranslation,
    pub presentation_snap: &'static mut FighterPresentationSnap,
    pub input: &'static mut FighterInput,
    pub hitboxes: &'static mut FighterHitboxes,
    pub velocity: &'static mut FighterVelocity,
    pub surface: &'static mut FighterSurfaceState,
    pub knockback_velocity: &'static mut FighterKnockbackVelocity,
    pub stale_move_queue: &'static mut FighterStaleMoveQueue,
-    pub ecb: &'static FighterECB,
+    pub ecb: &'static mut FighterECB,
    pub prev_ecb: &'static FighterPreviousECB,
    pub facing_direction: &'static mut FighterFacingDirection,
    pub animation_frame: &'static mut FighterAnimationFrame,
    pub vulnerability: &'static mut FighterInvulnerabilityState,
    pub fighter: &'static Fighter,
 }
@@ -244,6 +300,9 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
        animations: &'a FighterAnimations,
        baked_animations: &'a Assets<BakedFighterAnimations>,
        attributes: &'a FighterAttributes,
        stage_collision: &'a StageCollision,
        attack_scripts: &'a Assets<FighterAttackScript>,
        attack_script_assets: &'a FighterAttackScriptAssets,
    ) -> InterruptContext<'a> {
        let animation = self.animation_status(animations, baked_animations);
        InterruptContext {
@@ -252,6 +311,10 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
            game_settings,
            fighter_attributes: attributes,
            animation,
            surface: &self.surface,
            stage_collision,
            attack_script_assets: attack_script_assets,
            attack_scripts,
        }
    }
@@ -259,6 +322,7 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
        &'a mut self,
        attributes: &'a FighterAttributes,
        attack_script_assets: &'a FighterAttackScriptAssets,
        game_settings: &'a GameSettings,
    ) -> EnterContext<'a> {
        EnterContext {
            input: &mut self.input,
@@ -268,14 +332,20 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
            stale_move_queue: &mut self.stale_move_queue,
            facing_direction: &mut self.facing_direction,
            animation_frame: &mut self.animation_frame,
            surface: &mut self.surface,
            vulnerability: &mut self.vulnerability,
            fighter_attributes: attributes,
            attack_script_assets,
            game_settings,
        }
    }
    fn exit_context(&mut self) -> ExitContext<'_> {
        ExitContext {
            input: &mut self.input,
            hitboxes: &mut self.hitboxes,
            surface: &mut self.surface,
            vulnerability: &mut self.vulnerability,
        }
    }
@@ -292,27 +362,37 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
            input: &mut self.input,
            hitboxes: &mut self.hitboxes,
            velocity: &mut self.velocity,
            surface: &mut self.surface,
            knockback_velocity: &mut self.knockback_velocity,
            game_settings,
            animation_frame: self.animation_frame.frame,
            vulnerability: &mut self.vulnerability,
            fighter_attributes: attributes,
            attack_scripts,
            attack_script_assets,
-            facing_direction: &self.facing_direction
+            facing_direction: &self.facing_direction,
        }
    }
    fn collision_context<'a>(
        &'a mut self,
        stage_collision: &'a StageCollision,
        game_settings: &'a GameSettings,
    ) -> CollisionContext<'a> {
        CollisionContext {
            translation: &mut self.translation,
            prev_translation: &self.prev_translation,
            presentation_snap: &mut self.presentation_snap,
            input: &self.input,
            velocity: &mut self.velocity,
-            ecb: &self.ecb,
+            surface: &mut self.surface,
            ecb: &mut self.ecb,
            prev_ecb: &self.prev_ecb,
            stage_collision,
            leave_ground_ecb_lock_duration: game_settings
                .fighter_common
                .leave_ground_ecb_frame_lock_duration,
            downward_stick_threshold: game_settings.input_common.run_stick_threshold,
        }
    }
 }
@@ -325,9 +405,12 @@ pub struct StatefulFighterQuery {
    pub animations: &'static FighterAnimations,
    pub fighter: &'static Fighter,
    pub attack_script_assets: &'static FighterAttackScriptAssets,
    pub player: &'static Player,
    pub pending_hit_reaction: &'static mut FighterPendingHitReaction,
    pub hitstop: &'static mut FighterHitstop,
    pub hitstop_shake: &'static mut FighterHitstopShake,
    pub pending_respawn: &'static mut FighterPendingRespawn,
    pub damage: &'static mut FighterDamage,
 }
 pub fn state_update_system(
@@ -367,12 +450,21 @@ fn transition_state(
    frame: &mut FighterFrameQueryItem,
    attributes: &FighterAttributes,
    attack_script_assets: &FighterAttackScriptAssets,
    game_settings: &GameSettings,
 ) {
    let old_name = current.name();
    let new_name = next.name();
    current.on_exit(&mut frame.exit_context());
-    next.on_enter(&mut frame.enter_context(attributes, attack_script_assets));
+    if let SurfacePolicy::Airborne(lock_policy) = next.surface_policy() {
        frame.surface.apply_airborne_policy(
            lock_policy,
            game_settings
                .fighter_common
                .leave_ground_ecb_frame_lock_duration,
        );
    }
    next.on_enter(&mut frame.enter_context(attributes, attack_script_assets, game_settings));
    *current = next;
    info!("{} -> {}", old_name, new_name);
 }
@@ -382,6 +474,8 @@ pub fn state_interrupt_system(
    game_settings: Res<GameSettings>,
    baked_animations: Res<Assets<BakedFighterAnimations>>,
    fighter_manifests: Res<Assets<FighterManifest>>,
    attack_scripts: Res<Assets<FighterAttackScript>>,
    stage_collision: Res<StageCollision>,
 ) {
    for fighter in &mut query {
        let StatefulFighterQueryItem {
@@ -393,6 +487,7 @@ pub fn state_interrupt_system(
            mut pending_hit_reaction,
            mut hitstop,
            mut hitstop_shake,
            ..
        } = fighter;
        let manifest = fighter_manifests
            .get(&fighter.manifest)
@@ -400,7 +495,9 @@ 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);
+            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;
@@ -410,34 +507,24 @@ pub fn state_interrupt_system(
                FighterHitstopShakeKind::Vertical
            };
-            let mut hitstop_kind = match &*state {
+            let mut hitstop_kind = if frame.surface.is_grounded() {
-                FighterState::Wait(value) => {
+                hitstun::HitstopStateKind::Grounded
-                    hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
+            } else {
-                }
+                hitstun::HitstopStateKind::Airborne
                FighterState::Walk(value) => {
                    hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
                }
                FighterState::Dash(value) => {
                    hitstun::HitstopStateKind::Grounded(value.ground_common.clone())
                }
                FighterState::Run(value) => {
                    hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
                }
                FighterState::Turn(value) => {
                    hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
                }
                FighterState::GroundAttack(value) => {
                    hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
                }
                _ => hitstun::HitstopStateKind::Airborne,
            };
-            if let hitstun::HitstopStateKind::Grounded(_) = hitstop_kind {
+            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) {
+                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 {
+                } 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
@@ -463,6 +550,9 @@ pub fn state_interrupt_system(
                animations,
                &baked_animations,
                &manifest.attributes,
                &stage_collision,
                &attack_scripts,
                attack_script_assets,
            ))
        };
@@ -473,6 +563,7 @@ pub fn state_interrupt_system(
                &mut frame,
                &manifest.attributes,
                attack_script_assets,
                &game_settings,
            );
        };
    }
@@ -482,25 +573,94 @@ pub fn state_collision_interrupt_system(
    mut query: Query<StatefulFighterQuery>,
    stage_collision: Res<StageCollision>,
    fighter_manifests: Res<Assets<FighterManifest>>,
    game_settings: Res<GameSettings>,
    match_config: Res<MatchConfig>,
    mut match_state: ResMut<MatchState>,
    stage_registry: Res<StageManifestRegistry>,
    stage_manifests: Res<Assets<StageManifest>>,
 ) {
    let Some(stage_manifest_handle) = stage_registry.get(match_config.stage) else {
        return;
    };
    let Some(stage_manifest) = stage_manifests.get(&stage_manifest_handle) else {
        return;
    };
    for fighter in &mut query {
        let StatefulFighterQueryItem {
            mut state,
            mut frame,
            fighter,
            attack_script_assets,
-            hitstop,
+            mut hitstop,
            mut pending_respawn,
            player,
            mut damage,
            ..
        } = fighter;
        if hitstop.remaining_frames > 0 {
            continue;
        }
        let manifest = fighter_manifests
            .get(&fighter.manifest)
            .expect("Fighter manifest should be valid");
-        let new_state =
+
-            state.check_collision_interrupt(&mut frame.collision_context(&stage_collision));
+        if pending_respawn.0 {
            **pending_respawn = false;
            let respawn_state = FighterState::Angel(angel::AngelState::new(
                game_settings
                    .fighter_common
                    .angel_platform_invulnerability_duration,
            ));
            // Find the angel platform position
            let respawn_point = stage_manifest
                .respawn_points
                .get(player.controller_port % stage_manifest.respawn_points.len());
            if let None = respawn_point {
                error!("Couldn't get a respawn point, falling back to the world origin");
            }
            let respawn_point = respawn_point.copied().unwrap_or(FGVec2::ZERO);
            frame.translation.0 = respawn_point;
            frame.presentation_snap.0 = true;
            // Clear hitstop
            hitstop.remaining_frames = 0;
            // subtract one stock
            let player_state = match_state.players.get_mut(player.handle).expect(&format!(
                "Failed to get fighter for GGRS slot {} (controller port {})",
                player.handle, player.controller_port
            ));
            if let Some(stocks_remaining) = &mut player_state.stocks_remaining {
                *stocks_remaining = stocks_remaining.saturating_sub(1);
            }
            // reset percentage
            *damage = FighterDamage::default();
            transition_state(
                &mut state,
                respawn_state,
                &mut frame,
                &manifest.attributes,
                attack_script_assets,
                &game_settings,
            );
            continue;
        }
        if hitstop.remaining_frames > 0 {
            continue;
        }
        let new_state = state.check_collision_interrupt(
            &mut frame.collision_context(&stage_collision, &game_settings),
        );
        if let Some(new_state) = new_state {
            transition_state(
                &mut state,
@@ -508,6 +668,7 @@ pub fn state_collision_interrupt_system(
                &mut frame,
                &manifest.attributes,
                &attack_script_assets,
                &game_settings,
            );
        }
    }
@@ -0,0 +1,62 @@
 use super::{CollisionContext, EnterContext, FighterStateImpl, InterruptContext, UpdateContext};
 use crate::fighter::animation::AnimKind;
 use crate::fighter::state::air::AirborneStateCommon;
 use crate::fighter::state::{ExitContext, FighterState, air, jump};
 #[derive(Debug, Clone, Copy, Hash, Default)]
 pub struct PlatformPassState {
    airborne_state_common: AirborneStateCommon,
    ignored_polygon: usize,
 }
 impl PlatformPassState {
    pub fn new(airborne_state_common: AirborneStateCommon, ignored_polygon: usize) -> Self {
        Self {
            airborne_state_common,
            ignored_polygon
        }
    }
 }
 impl FighterStateImpl for PlatformPassState {
    const NAME: &'static str = "PlatformPass";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        jump::check_input_double_jump(state_context)
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        state_context.surface.ignore_polygon(self.ignored_polygon, state_context.game_settings.fighter_common.platform_pass_platform_ignore_duration_frames);
        state_context.velocity.y = state_context.game_settings.fighter_common.platform_pass_initial_downwards_velocity;
        state_context.play_animation(AnimKind::PlatformPass, false);
    }
    fn on_exit(&mut self, state_context: &mut ExitContext) {
        state_context.surface.clear_polygon_ignore(self.ignored_polygon);
    }
    fn update(&mut self, state_context: &mut UpdateContext) {
        air::update_standard_motion(state_context, &mut self.airborne_state_common);
    }
    fn check_collision_interrupt(
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
        air::collision_interrupt(
            state_context,
            crate::fighter::state::land::LandingType::Normal,
            true,
        )
    }
    fn is_visually_grounded<'a>(
        &'a self,
    ) -> bool {
        false
    }
    fn surface_policy(&self) -> super::SurfacePolicy {
        super::SurfacePolicy::Airborne(crate::fighter::surface::EcbLockPolicy::StartOnDetach)
    }
 }
@@ -6,19 +6,14 @@ use super::{
 };
 use crate::fighter::animation::AnimKind;
 use crate::fighter::state::FighterState;
 use crate::fighter::state::ground::GroundedStateCommon;
 #[derive(Component, Debug, Clone, Hash)]
-pub struct RunState {
+pub struct RunState;
    pub grounded_common: GroundedStateCommon,
 }
 impl FighterStateImpl for RunState {
    const NAME: &'static str = "Run";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
-        if let Some(state) =
+        if let Some(state) = ground::grounded_movement_common_interrupts(state_context) {
            ground::grounded_movement_common_interrupts(state_context, &self.grounded_common)
        {
            return Some(state);
        }
@@ -28,8 +23,7 @@ impl FighterStateImpl for RunState {
        {
            None
        } else {
-            walk::check_input(state_context, &self.grounded_common)
+            walk::check_input(state_context).or_else(|| wait::check_input(state_context))
                .or_else(|| wait::check_input(state_context, &self.grounded_common))
        }
    }
@@ -62,26 +56,19 @@ impl FighterStateImpl for RunState {
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, &mut self.grounded_common, true)
+        ground::collision_interrupt(state_context, true)
    }
-    fn is_visually_grounded<'a>(
+    fn is_visually_grounded<'a>(&'a self) -> bool {
        &'a self,
    ) -> bool {
        true
    }
 }
-pub fn check_input(
+pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
    state_context: &InterruptContext,
    ground_state_common: &GroundedStateCommon,
 ) -> Option<FighterState> {
    let input_frame = state_context.input.get_last_frame();
    if input_frame.movement.x.abs() >= state_context.game_settings.input_common.run_stick_threshold
    {
-        return Some(FighterState::Run(RunState {
+        return Some(FighterState::Run(RunState));
            grounded_common: ground_state_common.clone(),
        }));
    }
    None
 }
@@ -1,13 +1,11 @@
 use super::{CollisionContext, EnterContext, FighterStateImpl, InterruptContext, UpdateContext};
 use crate::fighter::animation::AnimKind;
-use crate::fighter::state::ground::{self, GroundedStateCommon};
+use crate::fighter::state::ground;
 use crate::fighter::state::{FighterState, dash, jump, wait, walk};
 use crate::input::FighterCommands;
 #[derive(Debug, Clone, Hash)]
-pub struct TurnState {
+pub struct TurnState;
    pub grounded_common: GroundedStateCommon,
 }
 impl FighterStateImpl for TurnState {
    const NAME: &'static str = "Turn";
@@ -19,19 +17,19 @@ impl FighterStateImpl for TurnState {
                .input_common
                .turn_into_dashback_window as u32
        {
-            if let Some(state) = dash::check_input(state_context, &self.grounded_common) {
+            if let Some(state) = dash::check_input(state_context) {
                return Some(state);
            }
        }
-        if let Some(state) = jump::check_input(state_context, &self.grounded_common) {
+        if let Some(state) = jump::check_input(state_context) {
            *state_context.facing_direction = state_context.facing_direction.reverse();
            Some(state)
        } else if state_context.is_current_animation_finished() {
-            if let Some(state) = dash::check_input(state_context, &self.grounded_common) {
+            if let Some(state) = dash::check_input(state_context) {
                Some(state)
-            } else if let Some(state) = walk::check_input(state_context, &self.grounded_common) {
+            } else if let Some(state) = walk::check_input(state_context) {
                Some(state)
-            } else if let Some(state) = wait::check_input(state_context, &self.grounded_common) {
+            } else if let Some(state) = wait::check_input(state_context) {
                Some(state)
            } else {
                None
@@ -54,20 +52,15 @@ impl FighterStateImpl for TurnState {
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, &mut self.grounded_common, false)
+        ground::collision_interrupt(state_context, false)
    }
-    fn is_visually_grounded<'a>(
+    fn is_visually_grounded<'a>(&'a self) -> bool {
        &'a self,
    ) -> bool {
        true
    }
 }
-pub fn check_input(
+pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
    state_context: &InterruptContext,
    grounded_common: &GroundedStateCommon,
 ) -> Option<FighterState> {
    let input_frame = state_context.input.get_last_frame();
    let has_smash_input = state_context
@@ -81,9 +74,7 @@ pub fn check_input(
        && input_frame.movement.x.signum() != state_context.facing_direction.to_sign()
        && !has_smash_input
    {
-        return Some(FighterState::Turn(TurnState {
+        return Some(FighterState::Turn(TurnState));
            grounded_common: grounded_common.clone(),
        }));
    }
    None
 }
@@ -3,24 +3,18 @@ use super::{
 };
 use crate::fighter::animation::AnimKind;
 use crate::fighter::state::FighterState;
 use crate::fighter::state::ground::GroundedStateCommon;
 #[derive(Debug, Clone, Hash)]
-pub struct WaitState {
+pub struct WaitState;
    pub grounded_common: GroundedStateCommon,
 }
 impl FighterStateImpl for WaitState {
    const NAME: &'static str = "Wait";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
-        if let Some(state) =
+        if let Some(state) = ground::grounded_movement_common_interrupts(state_context) {
            ground::grounded_movement_common_interrupts(state_context, &self.grounded_common)
        {
            Some(state)
-        } else if let Some(state) = ground::grounded_movement_standstill_common_interrupts(
+        } else if let Some(state) =
-            state_context,
+            ground::grounded_movement_standstill_common_interrupts(state_context)
-            &self.grounded_common,
+        {
        ) {
            // Don't transition into yourself
            if let FighterState::Wait(_) = state {
                None
@@ -44,26 +38,19 @@ impl FighterStateImpl for WaitState {
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, &mut self.grounded_common, false)
+        ground::collision_interrupt(state_context, false)
    }
-    fn is_visually_grounded<'a>(
+    fn is_visually_grounded<'a>(&'a self) -> bool {
        &'a self,
    ) -> bool {
        true
    }
 }
-pub fn check_input(
+pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
    state_context: &InterruptContext,
    ground_state_common: &GroundedStateCommon,
 ) -> 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::Wait(WaitState {
+        return Some(FighterState::Wait(WaitState));
            grounded_common: ground_state_common.clone(),
        }));
    }
    None
 }
@@ -3,24 +3,18 @@ use super::{
    ground, wait,
 };
 use crate::fighter::animation::AnimKind;
-use crate::fighter::state::FighterState;
+use crate::fighter::state::{self, FighterState};
 use crate::fighter::state::ground::GroundedStateCommon;
 #[derive(Debug, Clone, Hash)]
-pub struct WalkState {
+pub struct WalkState;
    pub grounded_common: GroundedStateCommon,
 }
 impl FighterStateImpl for WalkState {
    const NAME: &'static str = "Walk";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
-        if let Some(state) =
+        if let Some(state) = ground::grounded_movement_common_interrupts(state_context) {
            ground::grounded_movement_common_interrupts(state_context, &self.grounded_common)
        {
            return Some(state);
        }
-        wait::check_input(state_context, &self.grounded_common)
+        wait::check_input(state_context).or_else(|| dash::check_input(state_context)).or_else(|| state::ground_attack::check_interrupt(state_context))
            .or_else(|| dash::check_input(state_context, &self.grounded_common))
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
@@ -54,26 +48,19 @@ impl FighterStateImpl for WalkState {
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, &mut self.grounded_common, false)
+        ground::collision_interrupt(state_context, false)
    }
-    fn is_visually_grounded<'a>(
+    fn is_visually_grounded<'a>(&'a self) -> bool {
        &'a self,
    ) -> bool {
        true
    }
 }
-pub fn check_input(
+pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
    state_context: &InterruptContext,
    ground_state_common: &GroundedStateCommon,
 ) -> Option<FighterState> {
    let input_frame = state_context.input.get_last_frame();
    if !input_frame.movement.x.is_zero() {
-        return Some(FighterState::Walk(WalkState {
+        return Some(FighterState::Walk(WalkState));
            grounded_common: ground_state_common.clone(),
        }));
    }
    None
@@ -0,0 +1,227 @@
 use bevy::prelude::*;
 use crate::stage::line::StageLineID;
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub enum EcbLockPolicy {
    StartOnDetach,
    Restart,
    Preserve,
    Clear,
 }
 /// The stage surface currently supporting a fighter.
 ///
 /// This is physics state rather than fighter-state-machine state. Keeping it
 /// separate means grounded, landing, and hitstun states all share one source
 /// of truth for stage contact.
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct IgnoredPolygon {
    pub polygon: usize,
    pub frames_remaining: u32,
 }
 #[derive(Component, Clone, Debug, Hash, PartialEq, Eq)]
 pub enum FighterSurfaceState {
    Airborne {
        ecb_lock_frames_remaining: u32,
        ignored_polys: Vec<IgnoredPolygon>,
    },
    Grounded {
        line_id: StageLineID,
    },
 }
 impl Default for FighterSurfaceState {
    fn default() -> Self {
        Self::Airborne {
            ecb_lock_frames_remaining: 0,
            ignored_polys: vec![],
        }
    }
 }
 impl FighterSurfaceState {
    pub fn is_grounded(&self) -> bool {
        matches!(self, Self::Grounded { .. })
    }
    pub fn line_id(&self) -> Option<StageLineID> {
        match self {
            Self::Airborne { .. } => None,
            Self::Grounded { line_id } => Some(*line_id),
        }
    }
    pub(crate) fn land(&mut self, line_id: StageLineID) {
        *self = Self::Grounded { line_id };
    }
    pub fn clear_polygon_ignore(&mut self, polygon: usize) {
        let Self::Airborne { ignored_polys, .. } = self else {
            return;
        };
        ignored_polys.retain(|element| element.polygon != polygon);
    }
    pub fn ignore_polygon(&mut self, polygon: usize, duration_frames: u32) {
        let Self::Airborne { ignored_polys, .. } = self else {
            return;
        };
        if duration_frames == 0 {
            return;
        }
        if let Some(ignored) = ignored_polys.iter_mut().find(|ignored| ignored.polygon == polygon) {
            ignored.frames_remaining = duration_frames;
        } else {
            ignored_polys.push(IgnoredPolygon {
                polygon,
                frames_remaining: duration_frames,
            });
        }
    }
    pub fn is_polygon_ignored(&self, polygon: usize) -> bool {
        matches!(self, Self::Airborne { ignored_polys, .. }
            if ignored_polys.iter().any(|ignored| ignored.polygon == polygon))
    }
    pub(crate) fn ignored_polygon_ids(&self) -> Vec<usize> {
        match self {
            Self::Airborne { ignored_polys, .. } => {
                ignored_polys.iter().map(|ignored| ignored.polygon).collect()
            }
            Self::Grounded { .. } => vec![],
        }
    }
    pub(crate) fn apply_airborne_policy(
        &mut self,
        policy: EcbLockPolicy,
        ecb_lock_duration: u32,
    ) {
        let current_lock = match self {
            Self::Airborne { ecb_lock_frames_remaining, .. } => *ecb_lock_frames_remaining,
            Self::Grounded { .. } => 0,
        };
        let ecb_lock_frames_remaining = match policy {
            EcbLockPolicy::StartOnDetach if self.is_grounded() => ecb_lock_duration,
            EcbLockPolicy::StartOnDetach => current_lock,
            EcbLockPolicy::Restart => ecb_lock_duration,
            EcbLockPolicy::Preserve => current_lock,
            EcbLockPolicy::Clear => 0,
        };
        let ignored_polys = match self {
            Self::Airborne { ignored_polys, .. } => ignored_polys.clone(),
            Self::Grounded { .. } => vec![],
        };
        *self = Self::Airborne { ecb_lock_frames_remaining, ignored_polys };
    }
    pub(crate) fn tick_ecb_lock(&mut self) {
        if let Self::Airborne { ecb_lock_frames_remaining, .. } = self {
            *ecb_lock_frames_remaining = ecb_lock_frames_remaining.saturating_sub(1);
        }
    }
    pub(crate) fn tick_ignored_polygons(&mut self) {
        if let Self::Airborne { ignored_polys, .. } = self {
            for ignored in ignored_polys.iter_mut() {
                ignored.frames_remaining = ignored.frames_remaining.saturating_sub(1);
            }
            ignored_polys.retain(|ignored| ignored.frames_remaining > 0);
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn contact_lifecycle_has_one_source_of_truth() {
        let mut surface = FighterSurfaceState::default();
        assert!(!surface.is_grounded());
        assert_eq!(surface.line_id(), None);
        let line_id = StageLineID {
            polygon: 2,
            segment: 3,
        };
        surface.land(line_id);
        assert!(surface.is_grounded());
        assert_eq!(surface.line_id(), Some(line_id));
        surface.apply_airborne_policy(EcbLockPolicy::Clear, 0);
        assert!(!surface.is_grounded());
        assert_eq!(surface.line_id(), None);
    }
    #[test]
    fn start_on_detach_does_not_reset_an_existing_lock() {
        let mut surface = FighterSurfaceState::default();
        surface.apply_airborne_policy(EcbLockPolicy::Restart, 5);
        surface.tick_ecb_lock();
        surface.apply_airborne_policy(EcbLockPolicy::StartOnDetach, 5);
        assert_eq!(
            surface,
            FighterSurfaceState::Airborne {
                ecb_lock_frames_remaining: 4,
                ignored_polys: vec![],
            }
        );
    }
    #[test]
    fn restart_retriggers_an_existing_lock() {
        let mut surface = FighterSurfaceState::default();
        surface.apply_airborne_policy(EcbLockPolicy::Restart, 5);
        surface.tick_ecb_lock();
        surface.apply_airborne_policy(EcbLockPolicy::Restart, 5);
        assert_eq!(
            surface,
            FighterSurfaceState::Airborne {
                ecb_lock_frames_remaining: 5,
                ignored_polys: vec![],
            }
        );
    }
    #[test]
    fn ignored_polygon_expires_after_requested_frames() {
        let mut surface = FighterSurfaceState::default();
        surface.ignore_polygon(3, 2);
        assert!(surface.is_polygon_ignored(3));
        surface.tick_ignored_polygons();
        assert!(surface.is_polygon_ignored(3));
        surface.tick_ignored_polygons();
        assert!(!surface.is_polygon_ignored(3));
    }
    #[test]
    fn ignoring_polygon_refreshes_existing_entry() {
        let mut surface = FighterSurfaceState::default();
        surface.ignore_polygon(3, 2);
        surface.ignore_polygon(3, 5);
        surface.tick_ignored_polygons();
        surface.tick_ignored_polygons();
        assert!(surface.is_polygon_ignored(3));
    }
    #[test]
    fn airborne_policy_preserves_ignored_polygons_and_landing_clears_them() {
        let mut surface = FighterSurfaceState::default();
        surface.ignore_polygon(3, 5);
        surface.apply_airborne_policy(EcbLockPolicy::Restart, 2);
        assert!(surface.is_polygon_ignored(3));
        surface.land(StageLineID { polygon: 0, segment: 0 });
        assert!(!surface.is_polygon_ignored(3));
    }
 }
@@ -1,4 +1,8 @@
-use crate::fighter::baked_animation::BakedFighterAnimations;
+use crate::{
    fighter::{FighterInvulnerabilityState, baked_animation::BakedFighterAnimations},
    game_settings::GameSettings,
    materials::fighter_material::{FighterMaterial, FighterMesh},
 };
 use bevy::prelude::*;
 #[derive(Component, Clone)]
@@ -6,3 +10,82 @@ pub struct FighterAnimations {
    /// The single animation source for gameplay and the visual skeleton.
    pub baked: Handle<BakedFighterAnimations>,
 }
 #[derive(Clone, Copy, Default, PartialEq)]
 pub enum LastKnownInvulnerabilityState {
    #[default]
    Vulnerable,
    Intangible,
    Invulnerable,
 }
 impl From<&FighterInvulnerabilityState> for LastKnownInvulnerabilityState {
    fn from(value: &FighterInvulnerabilityState) -> Self {
        match value {
            FighterInvulnerabilityState::Vulnerable => Self::Vulnerable,
            FighterInvulnerabilityState::Invulnerable { .. } => Self::Invulnerable,
            FighterInvulnerabilityState::Intangible { .. } => Self::Intangible,
        }
    }
 }
 #[derive(Component, Clone, Default)]
 pub struct FighterInvulnerabilityVisualState {
    pub last_known_state: LastKnownInvulnerabilityState,
    pub frames_in_state: u32,
 }
 pub fn update_status_colors(
    mut fighters: Query<(
        &FighterInvulnerabilityState,
        &mut FighterInvulnerabilityVisualState,
    )>,
    meshes: Query<(&FighterMesh, &MeshMaterial3d<FighterMaterial>)>,
    mut materials: ResMut<Assets<FighterMaterial>>,
    game_settings: Res<GameSettings>,
 ) {
    for (invuln_state, mut invuln_state_visual) in &mut fighters {
        let curr_state = invuln_state.into();
        let last_known_state = invuln_state_visual.last_known_state;
        if curr_state != last_known_state {
            invuln_state_visual.last_known_state = curr_state;
            invuln_state_visual.frames_in_state = 0;
        }
    }
    for (mesh, mat) in meshes {
        let (_, invuln_state_visual) = fighters
            .get(mesh.fighter)
            .expect("Material should have relevant fighter available");
        let status_color = match invuln_state_visual.last_known_state {
            LastKnownInvulnerabilityState::Vulnerable => bevy::color::palettes::css::WHITE.into(),
            LastKnownInvulnerabilityState::Invulnerable => {
                game_settings.fighter_common.intangible_color
            }
            LastKnownInvulnerabilityState::Intangible => {
                game_settings.fighter_common.intangible_color
            }
        };
        let intensity = match invuln_state_visual.last_known_state {
            LastKnownInvulnerabilityState::Vulnerable => 0.0,
            LastKnownInvulnerabilityState::Invulnerable | LastKnownInvulnerabilityState::Intangible => {
                let cycle_frames = invuln_state_visual.frames_in_state
                    % game_settings.fighter_common.intangible_pulse_duration;
                1.0 - cycle_frames as f32
                    / ((game_settings.fighter_common.intangible_pulse_duration) as f32)
            }
        };
        let mut material = materials
            .get_mut(mat.id())
            .expect("Material should exist here...");
        material
            .extension
            .update_status_color(status_color.into(), intensity);
    }
    for (_, mut invuln_state_visual) in fighters {
        invuln_state_visual.frames_in_state = invuln_state_visual.frames_in_state.saturating_add(1);
    }
 }
@@ -0,0 +1,30 @@
 #import bevy_pbr::mesh_functions::{get_world_from_local, mesh_position_local_to_clip}
@group(#{MATERIAL_BIND_GROUP}) @binding(0) var<uniform> material_color: vec4<f32>;
 struct Vertex {
    @builtin(instance_index) instance_index: u32,
    @location(0) position: vec3<f32>,
    @location(1) color: vec4<f32>,
 };
 struct VertexOutput {
    @builtin(position) clip_position: vec4<f32>,
    @location(0) color: vec4<f32>,
 };
@vertex
 fn vertex(vertex: Vertex) -> VertexOutput {
    var output: VertexOutput;
    output.clip_position = mesh_position_local_to_clip(
        get_world_from_local(vertex.instance_index),
        vec4<f32>(vertex.position, 1.0),
    );
    output.color = vertex.color;
    return output;
 }
@fragment
 fn fragment(input: VertexOutput) -> @location(0) vec4<f32> {
    return material_color * input.color;
 }
@@ -0,0 +1,417 @@
 //! Immediate-mode filled debug geometry.
 //!
 //! Unlike Bevy's line-only `Gizmos`, this collects triangles into one dynamic
 //! mesh. It is intended for small, transient debug overlays rather than game
 //! geometry.
 use std::f32::consts::{FRAC_PI_2, PI, TAU};
 use bevy::{
    asset::{load_internal_asset, uuid_handle, RenderAssetUsages},
    camera::visibility::NoFrustumCulling,
    ecs::system::SystemParam,
    mesh::{Indices, MeshVertexBufferLayoutRef, PrimitiveTopology},
    pbr::{MaterialPipeline, MaterialPipelineKey},
    prelude::*,
    render::render_resource::{
        AsBindGroup, RenderPipelineDescriptor, SpecializedMeshPipelineError,
    },
    shader::ShaderRef,
 };
 const SPHERE_SECTORS: usize = 16;
 const SPHERE_STACKS: usize = 8;
 const CAPSULE_SECTORS: usize = 16;
 const CAPSULE_HEMISPHERE_STEPS: usize = 4;
 #[derive(Default)]
 struct FilledGizmoGeometry {
    positions: Vec<[f32; 3]>,
    normals: Vec<[f32; 3]>,
    colors: Vec<[f32; 4]>,
    indices: Vec<u32>,
 }
 #[derive(Resource, Default)]
 struct FilledGizmoBuffer {
    /// Geometry requested by the current schedule invocation.
    pending: FilledGizmoGeometry,
    /// The last completed fixed-timestep geometry. This is retained between
    /// render frames, just like Bevy's fixed-timestep gizmos.
    retained: FilledGizmoGeometry,
    mesh: Option<Handle<Mesh>>,
    fixed_commit: bool,
 }
 /// Immediate-mode API for drawing filled debug shapes.
 #[derive(SystemParam)]
 pub struct FilledGizmos<'w> {
    buffer: ResMut<'w, FilledGizmoBuffer>,
 }
 impl FilledGizmos<'_> {
    /// Draw a filled planar polygon. Vertices must be ordered around the
    /// perimeter and the polygon must be convex.
    pub fn polygon(&mut self, vertices: &[Vec3], color: impl Into<Color> + Copy) {
        if vertices.len() < 3 {
            return;
        }
        let color = color.into().to_linear().to_f32_array();
        let normal = (vertices[1] - vertices[0])
            .cross(vertices[2] - vertices[0])
            .normalize_or_zero();
        let base = self.buffer.pending.positions.len() as u32;
        for &vertex in vertices {
            self.push_vertex(vertex, normal, color);
        }
        for index in 2..vertices.len() as u32 {
            self.buffer
                .pending
                .indices
                .extend([base, base + index - 1, base + index]);
        }
    }
    pub fn sphere(&mut self, isometry: Isometry3d, radius: f32, color: impl Into<Color> + Copy) {
        if radius <= 0.0 {
            return;
        }
        let color = color.into().to_linear().to_f32_array();
        let base = self.buffer.pending.positions.len() as u32;
        for stack in 0..=SPHERE_STACKS {
            let latitude = PI * 0.5 - stack as f32 * PI / SPHERE_STACKS as f32;
            let (sin_lat, cos_lat) = latitude.sin_cos();
            for sector in 0..=SPHERE_SECTORS {
                let longitude = sector as f32 * TAU / SPHERE_SECTORS as f32;
                let (sin_lon, cos_lon) = longitude.sin_cos();
                let normal = Vec3::new(cos_lat * cos_lon, sin_lat, cos_lat * sin_lon);
                self.push_vertex(
                    isometry.transform_point(normal * radius).into(),
                    isometry.rotation * normal,
                    color,
                );
            }
        }
        let stride = SPHERE_SECTORS + 1;
        for stack in 0..SPHERE_STACKS {
            for sector in 0..SPHERE_SECTORS {
                let a = base + (stack * stride + sector) as u32;
                let b = a + stride as u32;
                self.buffer
                    .pending
                    .indices
                    .extend([a, b, a + 1, a + 1, b, b + 1]);
            }
        }
    }
    pub fn capsule(
        &mut self,
        isometry: Isometry3d,
        radius: f32,
        half_length: f32,
        color: impl Into<Color> + Copy,
    ) {
        let transform = Mat4::from_scale_rotation_translation(
            Vec3::ONE,
            isometry.rotation,
            isometry.translation.into(),
        );
        self.affine_capsule(transform, radius, half_length, color);
    }
    /// Draw a capsule transformed by an arbitrary affine transform.
    pub fn affine_capsule(
        &mut self,
        transform: Mat4,
        radius: f32,
        half_length: f32,
        color: impl Into<Color> + Copy,
    ) {
        if radius <= 0.0 {
            return;
        }
        let color = color.into().to_linear().to_f32_array();
        let base = self.buffer.pending.positions.len() as u32;
        let mut rings = Vec::new();
        for step in 1..=CAPSULE_HEMISPHERE_STEPS {
            let angle = -FRAC_PI_2 + step as f32 * FRAC_PI_2 / CAPSULE_HEMISPHERE_STEPS as f32;
            rings.push((
                radius * angle.cos(),
                -half_length + radius * angle.sin(),
                angle.sin(),
            ));
        }
        rings.push((radius, half_length, 0.0));
        for step in 1..CAPSULE_HEMISPHERE_STEPS {
            let angle = step as f32 * FRAC_PI_2 / CAPSULE_HEMISPHERE_STEPS as f32;
            rings.push((
                radius * angle.cos(),
                half_length + radius * angle.sin(),
                angle.sin(),
            ));
        }
        let mut ring_indices = Vec::new();
        let bottom_pole = self.push_capsule_vertex(
            &mut ring_indices,
            transform,
            Vec3::NEG_Y,
            -half_length,
            radius,
            color,
        );
        for &(ring_radius, y, normal_y) in &rings {
            let mut ring = Vec::with_capacity(CAPSULE_SECTORS);
            for sector in 0..CAPSULE_SECTORS {
                let angle = sector as f32 * TAU / CAPSULE_SECTORS as f32;
                let (sin, cos) = angle.sin_cos();
                let normal = Vec3::new(
                    cos * (1.0 - normal_y * normal_y).sqrt(),
                    normal_y,
                    sin * (1.0 - normal_y * normal_y).sqrt(),
                );
                ring.push(self.push_transformed_vertex(
                    transform,
                    Vec3::new(cos * ring_radius, y, sin * ring_radius),
                    normal,
                    color,
                ));
            }
            ring_indices.push(ring);
        }
        let top_pole = self.push_capsule_vertex(
            &mut ring_indices,
            transform,
            Vec3::Y,
            half_length,
            radius,
            color,
        );
        for sector in 0..CAPSULE_SECTORS {
            let next = (sector + 1) % CAPSULE_SECTORS;
            self.buffer.pending.indices.extend([
                bottom_pole,
                ring_indices[0][next],
                ring_indices[0][sector],
            ]);
            for ring in ring_indices.windows(2) {
                self.buffer.pending.indices.extend([
                    ring[0][sector],
                    ring[0][next],
                    ring[1][sector],
                    ring[1][sector],
                    ring[0][next],
                    ring[1][next],
                ]);
            }
            let last = ring_indices.len() - 1;
            self.buffer.pending.indices.extend([
                ring_indices[last][sector],
                ring_indices[last][next],
                top_pole,
            ]);
        }
        // Keep the base used by this shape observable to avoid accidental
        // future changes making the generated indices refer to another shape.
        debug_assert!(base <= bottom_pole);
    }
    fn push_capsule_vertex(
        &mut self,
        _rings: &mut Vec<Vec<u32>>,
        transform: Mat4,
        normal: Vec3,
        y: f32,
        radius: f32,
        color: [f32; 4],
    ) -> u32 {
        self.push_transformed_vertex(
            transform,
            Vec3::new(0.0, y + normal.y * radius, 0.0),
            normal,
            color,
        )
    }
    fn push_transformed_vertex(
        &mut self,
        transform: Mat4,
        position: Vec3,
        normal: Vec3,
        color: [f32; 4],
    ) -> u32 {
        let transformed_normal = transform
            .inverse()
            .transpose()
            .transform_vector3(normal)
            .normalize_or_zero();
        let index = self.buffer.pending.positions.len() as u32;
        self.push_vertex(
            transform.transform_point3(position),
            transformed_normal,
            color,
        );
        index
    }
    fn push_vertex(&mut self, position: Vec3, normal: Vec3, color: [f32; 4]) {
        self.buffer.pending.positions.push(position.to_array());
        self.buffer.pending.normals.push(normal.to_array());
        self.buffer.pending.colors.push(color);
    }
 }
 pub struct FilledGizmosPlugin;
 const FILLED_GIZMO_SHADER_HANDLE: Handle<Shader> =
    uuid_handle!("0e4a979f-ea11-4e5a-91cd-19c89d4e9b53");
 /// A deliberately minimal material: unlike `StandardMaterial`, its fragment
 /// shader writes vertex colors directly and therefore bypasses PBR lighting
 /// and camera tonemapping.
 #[derive(Asset, AsBindGroup, Reflect, Clone, Debug)]
 struct FilledGizmoMaterial {
    #[uniform(0)]
    color: LinearRgba,
 }
 impl Material for FilledGizmoMaterial {
    fn vertex_shader() -> ShaderRef {
        FILLED_GIZMO_SHADER_HANDLE.clone().into()
    }
    fn fragment_shader() -> ShaderRef {
        FILLED_GIZMO_SHADER_HANDLE.clone().into()
    }
    fn alpha_mode(&self) -> AlphaMode {
        AlphaMode::Blend
    }
    fn enable_prepass() -> bool {
        false
    }
    fn enable_shadows() -> bool {
        false
    }
    fn specialize(
        _pipeline: &MaterialPipeline,
        descriptor: &mut RenderPipelineDescriptor,
        layout: &MeshVertexBufferLayoutRef,
        _key: MaterialPipelineKey<Self>,
    ) -> Result<(), SpecializedMeshPipelineError> {
        descriptor.vertex.buffers = vec![layout.0.get_layout(&[
            Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
            Mesh::ATTRIBUTE_COLOR.at_shader_location(1),
        ])?];
        descriptor.primitive.cull_mode = None;
        Ok(())
    }
 }
 impl Plugin for FilledGizmosPlugin {
    fn build(&self, app: &mut App) {
        load_internal_asset!(
            app,
            FILLED_GIZMO_SHADER_HANDLE,
            "filled_gizmo.wgsl",
            Shader::from_wgsl
        );
        app.add_plugins(MaterialPlugin::<FilledGizmoMaterial>::default())
            .init_resource::<FilledGizmoBuffer>()
            .add_systems(Startup, setup_filled_gizmo_mesh)
            .add_systems(FixedFirst, begin_fixed_filled_gizmos)
            .add_systems(FixedLast, commit_fixed_filled_gizmos)
            .add_systems(Last, upload_filled_gizmo_mesh);
    }
 }
 fn setup_filled_gizmo_mesh(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<FilledGizmoMaterial>>,
    mut buffer: ResMut<FilledGizmoBuffer>,
 ) {
    let mesh = meshes.add(
        Mesh::new(
            PrimitiveTopology::TriangleList,
            RenderAssetUsages::default(),
        )
        .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, vec![[0.0; 3]; 3])
        .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 0.0, 1.0]; 3])
        .with_inserted_attribute(Mesh::ATTRIBUTE_COLOR, vec![[0.0, 0.0, 0.0, 0.0]; 3])
        .with_inserted_indices(Indices::U32(vec![0, 1, 2])),
    );
    let material = materials.add(FilledGizmoMaterial {
        color: LinearRgba::WHITE,
    });
    commands.spawn((
        Mesh3d(mesh.clone()),
        MeshMaterial3d(material),
        NoFrustumCulling,
    ));
    buffer.mesh = Some(mesh);
 }
 fn begin_fixed_filled_gizmos(mut buffer: ResMut<FilledGizmoBuffer>) {
    buffer.pending = FilledGizmoGeometry::default();
    buffer.fixed_commit = false;
 }
 fn commit_fixed_filled_gizmos(mut buffer: ResMut<FilledGizmoBuffer>) {
    let pending = std::mem::take(&mut buffer.pending);
    buffer.pending = std::mem::replace(&mut buffer.retained, pending);
    buffer.fixed_commit = true;
 }
 fn upload_filled_gizmo_mesh(
    mut meshes: ResMut<Assets<Mesh>>,
    mut buffer: ResMut<FilledGizmoBuffer>,
 ) {
    // No fixed tick and no render-frame requests means the existing mesh is
    // already the correct image. In particular, do not replace it with the
    // empty placeholder between fixed updates.
    if !buffer.fixed_commit && buffer.pending.positions.is_empty() {
        return;
    }
    let Some(handle) = buffer.mesh.clone() else {
        return;
    };
    let (positions, normals, colors, indices) = if buffer.fixed_commit {
        // Retained geometry must remain in the CPU-side buffer after upload;
        // otherwise the next render frame would have nothing to draw.
        (
            buffer.retained.positions.clone(),
            buffer.retained.normals.clone(),
            buffer.retained.colors.clone(),
            buffer.retained.indices.clone(),
        )
    } else {
        (
            std::mem::take(&mut buffer.pending.positions),
            std::mem::take(&mut buffer.pending.normals),
            std::mem::take(&mut buffer.pending.colors),
            std::mem::take(&mut buffer.pending.indices),
        )
    };
    if let Some(mut mesh) = meshes.get_mut(&handle) {
        if positions.is_empty() {
            mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, vec![[0.0; 3]; 3]);
            mesh.insert_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 0.0, 1.0]; 3]);
            mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, vec![[0.0, 0.0, 0.0, 0.0]; 3]);
            mesh.insert_indices(Indices::U32(vec![0, 1, 2]));
        } else {
            mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, positions);
            mesh.insert_attribute(Mesh::ATTRIBUTE_NORMAL, normals);
            mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, colors);
            mesh.insert_indices(Indices::U32(indices));
        }
    }
    buffer.pending = FilledGizmoGeometry::default();
    buffer.fixed_commit = false;
 }
@@ -39,6 +39,23 @@ pub struct FighterSettingsCommon {
    /// Maximum angle changed caused by directional influence
    pub di_max_angle: FGi32,
    pub leave_ground_ecb_frame_lock_duration: u32,
    pub platform_pass_platform_ignore_duration_frames: u32,
    pub platform_pass_initial_downwards_velocity: FGi32,
    pub intangible_color: Color,
    pub intangible_pulse_duration: u32,
    pub angel_platform_invulnerability_duration: u32,
    /// When hit while the receiver is in the air, use this angle
    pub sakurai_angle_aerial_angle: FGi32,
    /// When hit while the receiver is in the ground and at low knockback, use this angle
    pub sakurai_angle_low_knockback_angle: FGi32,
    /// When hit while the receiver is in the ground and at high knockback, use this angle
    pub sakurai_angle_high_knockback_angle: FGi32,
    /// past this threshold, the knockback is considered high, so it will use [sakurai_angle_high_knockback_angle]
    pub sakurai_angle_knockback_threshold: FGi32,
 }
 #[derive(Reflect, Serialize, Deserialize, Clone)]
 #[reflect(opaque)]
@@ -1,24 +1,22 @@
-//! Per-fighter input state: the current and previous frame, plus the buffered
+//! Rollback-safe input history and command buffering.
 //! commands (smash inputs and friends) that states query when deciding whether
 //! to interrupt.
 use std::ops::{Index, IndexMut};
 use bevy::prelude::*;
 use bevy_ggrs::{PlayerInputs, Rollback};
 use strum::IntoEnumIterator;
 use strum_macros::EnumIter;
 use crate::fighter::FighterFacingDirection;
 use crate::fighter::attack::AttackKind;
 use crate::game_settings::GameSettings;
-use crate::input::FighterInputFrame;
+use crate::input::{DigitalAction, FighterInputFrame};
 use crate::netcode::GGRSCfg;
 use crate::player::Player;
-#[derive(Clone, Copy, EnumIter, Debug)]
+#[derive(Clone, Copy, EnumIter, Debug, PartialEq, Eq, Hash)]
 pub enum FighterCommands {
    Jump,
    Shield,
    GuardHold,
    Attack,
    SmashMoveUp,
    SmashMoveDown,
@@ -26,7 +24,31 @@ pub enum FighterCommands {
    SmashMoveRight,
 }
-#[derive(Default, Clone, Hash, Copy)]
+pub(crate) fn second_binding_pressed(
    current: crate::input::ActionBindingMask,
    previous: crate::input::ActionBindingMask,
 ) -> bool {
    current.count() >= 2 && current.pressed_since(previous).0 != 0
 }
 impl FighterCommands {
    pub const COUNT: usize = 8;
    pub const fn index(self) -> usize {
        match self {
            Self::Jump => 0,
            Self::Shield => 1,
            Self::GuardHold => 2,
            Self::Attack => 3,
            Self::SmashMoveUp => 4,
            Self::SmashMoveDown => 5,
            Self::SmashMoveLeft => 6,
            Self::SmashMoveRight => 7,
        }
    }
 }
 #[derive(Default, Clone, Hash, Copy, Debug)]
 pub enum FighterAttackCommandType {
    #[default]
    Neutral,
@@ -43,66 +65,140 @@ pub enum FighterAttackCommandType {
 impl FighterAttackCommandType {
    pub fn to_attack_kind_grounded(&self) -> AttackKind {
        match self {
-            FighterAttackCommandType::Neutral => AttackKind::Jab,
+            Self::Neutral => AttackKind::Jab,
-            FighterAttackCommandType::SmashAttackUp => AttackKind::UpSmash,
+            Self::SmashAttackUp => AttackKind::UpSmash,
-            FighterAttackCommandType::SmashAttackDown => AttackKind::DownSmash,
+            Self::SmashAttackDown => AttackKind::DownSmash,
-            FighterAttackCommandType::SmashAttackLeft => AttackKind::ForwardSmash,
+            Self::SmashAttackLeft | Self::SmashAttackRight => AttackKind::ForwardSmash,
-            FighterAttackCommandType::SmashAttackRight => AttackKind::ForwardSmash,
+            Self::TiltAttackUp => AttackKind::UpTilt,
-            FighterAttackCommandType::TiltAttackUp => AttackKind::UpTilt,
+            Self::TiltAttackDown => AttackKind::DownTilt,
-            FighterAttackCommandType::TiltAttackDown => AttackKind::DownTilt,
+            Self::TiltAttackLeft | Self::TiltAttackRight => AttackKind::ForwardTilt,
-            FighterAttackCommandType::TiltAttackLeft => AttackKind::ForwardTilt,
+        }
-            FighterAttackCommandType::TiltAttackRight => AttackKind::ForwardTilt,
+    }
    pub fn to_attack_kind_airborne(&self, facing_direction: &FighterFacingDirection) -> AttackKind {
        match self {
            Self::Neutral => AttackKind::NeutralAir,
            Self::SmashAttackUp | Self::TiltAttackUp => AttackKind::UpAir,
            Self::SmashAttackDown | Self::TiltAttackDown => AttackKind::DownAir,
            Self::SmashAttackLeft | Self::TiltAttackLeft => match facing_direction {
                FighterFacingDirection::Left => AttackKind::ForwardAir,
                FighterFacingDirection::Right => AttackKind::BackAir,
            },
            Self::SmashAttackRight | Self::TiltAttackRight => match facing_direction {
                FighterFacingDirection::Left => AttackKind::BackAir,
                FighterFacingDirection::Right => AttackKind::ForwardAir,
            },
        }
    }
 }
-/// Frames of life remaining for each buffered command. Indexed by
+#[derive(Clone, Copy, Debug, Hash)]
-/// [`FighterCommands`] so adding a command is a two-line change here.
+struct CommandSlot {
-#[derive(Default, Clone, Copy, Hash)]
+    lifetime: u8,
-pub struct FighterCommandLifetimes {
+    age: u16,
-    smash_move_left: u8,
+    hold_remaining: HoldLimit,
-    smash_move_right: u8,
+    consumed: bool,
    smash_move_down: u8,
    smash_move_up: u8,
    jump: u8,
    shield: u8,
    attack: u8,
 }
-impl Index<FighterCommands> for FighterCommandLifetimes {
+impl Default for CommandSlot {
-    type Output = u8;
+    fn default() -> Self {
-
+        Self {
-    fn index(&self, command: FighterCommands) -> &Self::Output {
+            lifetime: 0,
-        match command {
+            age: 0,
-            FighterCommands::SmashMoveLeft => &self.smash_move_left,
+            hold_remaining: HoldLimit::Disabled,
-            FighterCommands::SmashMoveRight => &self.smash_move_right,
+            consumed: false,
            FighterCommands::SmashMoveDown => &self.smash_move_down,
            FighterCommands::SmashMoveUp => &self.smash_move_up,
            FighterCommands::Jump => &self.jump,
            FighterCommands::Shield => &self.shield,
            FighterCommands::Attack => &self.attack,
        }
    }
 }
-impl IndexMut<FighterCommands> for FighterCommandLifetimes {
+#[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq)]
-    fn index_mut(&mut self, command: FighterCommands) -> &mut Self::Output {
+enum HoldLimit {
-        match command {
+    #[default]
-            FighterCommands::SmashMoveLeft => &mut self.smash_move_left,
+    Disabled,
-            FighterCommands::SmashMoveRight => &mut self.smash_move_right,
+    Frames(u16),
-            FighterCommands::SmashMoveDown => &mut self.smash_move_down,
+    Infinite,
-            FighterCommands::SmashMoveUp => &mut self.smash_move_up,
+}
-            FighterCommands::Jump => &mut self.jump,
+
-            FighterCommands::Shield => &mut self.shield,
+#[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq)]
-            FighterCommands::Attack => &mut self.attack,
+enum HoldOverride {
    #[default]
    Inherit,
    Disabled,
    Frames(u16),
    Infinite,
 }
 impl HoldOverride {
    fn from_max_frames(max_frames: u16) -> Self {
        if max_frames == 0 {
            Self::Infinite
        } else {
            Self::Frames(max_frames)
        }
    }
 }
-#[derive(Component, Default, Clone, Copy, Hash)]
+impl HoldLimit {
    fn from_max_frames(max_frames: u16) -> Self {
        if max_frames == 0 {
            Self::Infinite
        } else {
            Self::Frames(max_frames)
        }
    }
 }
 #[derive(Clone, Copy, Debug, Hash)]
 struct ButtonHistory {
    trigger_age: u16,
    release_age: u16,
    held_frames: u16,
    secondary_trigger_age: u16,
 }
 impl Default for ButtonHistory {
    fn default() -> Self {
        Self {
            trigger_age: u16::MAX,
            release_age: u16::MAX,
            held_frames: 0,
            secondary_trigger_age: u16::MAX,
        }
    }
 }
 impl ButtonHistory {
    fn update(&mut self, current: u16, previous: u16) {
        let pressed = current & !previous;
        let released = previous & !current;
        self.trigger_age = self.trigger_age.saturating_add(1);
        self.release_age = self.release_age.saturating_add(1);
        self.secondary_trigger_age = self.secondary_trigger_age.saturating_add(1);
        if pressed != 0 {
            self.trigger_age = 0;
        }
        if released != 0 {
            self.release_age = 0;
        }
        if current != 0 {
            self.held_frames = self.held_frames.saturating_add(1);
        } else {
            self.held_frames = 0;
        }
        if current.count_ones() >= 2 && (pressed != 0 || previous.count_ones() < 2) {
            self.secondary_trigger_age = 0;
        }
    }
 }
 /// Per-fighter input state. Every field is deterministic rollback state.
 #[derive(Component, Clone, Copy, Hash)]
 #[require(Rollback)]
 pub struct FighterInput {
-    command_lifetimes: FighterCommandLifetimes,
+    command_slots: [CommandSlot; FighterCommands::COUNT],
    hold_limits: [HoldOverride; FighterCommands::COUNT],
    hold_all: HoldLimit,
    button_history: [ButtonHistory; 3],
    prev_frame: FighterInputFrame,
    current_frame: FighterInputFrame,
    frames_in_x_flick_deadzone: u8,
@@ -110,6 +206,22 @@ pub struct FighterInput {
    attack_command: FighterAttackCommandType,
 }
 impl Default for FighterInput {
    fn default() -> Self {
        Self {
            command_slots: [CommandSlot::default(); FighterCommands::COUNT],
            hold_limits: [HoldOverride::default(); FighterCommands::COUNT],
            hold_all: HoldLimit::default(),
            button_history: [ButtonHistory::default(); 3],
            prev_frame: FighterInputFrame::default(),
            current_frame: FighterInputFrame::default(),
            frames_in_x_flick_deadzone: 0xFE,
            frames_in_y_flick_deadzone: 0xFE,
            attack_command: FighterAttackCommandType::Neutral,
        }
    }
 }
 impl FighterInput {
    pub fn get_last_frame(&self) -> FighterInputFrame {
        self.current_frame
@@ -121,40 +233,188 @@ impl FighterInput {
    }
    pub fn clear_buffer(&mut self) {
-        self.command_lifetimes = FighterCommandLifetimes::default()
+        self.command_slots = [CommandSlot::default(); FighterCommands::COUNT];
    }
    pub fn clear_command(&mut self, command: FighterCommands) {
-        self.command_lifetimes[command] = 0;
+        let slot = &mut self.command_slots[command.index()];
        slot.lifetime = 0;
        slot.hold_remaining = HoldLimit::Disabled;
        slot.consumed = true;
    }
    pub fn consume_command(&mut self, command: FighterCommands) -> bool {
        if self.has_command(command) {
            self.clear_command(command);
            true
        } else {
            false
        }
    }
    pub fn set_lifetime(&mut self, command: FighterCommands, lifetime: u8) {
-        self.command_lifetimes[command] = lifetime;
+        let slot = &mut self.command_slots[command.index()];
        slot.lifetime = lifetime;
        slot.age = 0;
        slot.hold_remaining = HoldLimit::Disabled;
        slot.consumed = false;
        self.latch_if_hold_enabled(command);
    }
    pub fn has_command(&self, command: FighterCommands) -> bool {
-        self.command_lifetimes[command] > 0
+        self.command_slots[command.index()].lifetime > 0
    }
    pub fn reduce_command_lifetime(&mut self, command: FighterCommands) {
-        self.command_lifetimes[command] = self.command_lifetimes[command].saturating_sub(1);
+        self.command_slots[command.index()].lifetime = self.command_slots[command.index()]
            .lifetime
            .saturating_sub(1);
    }
    /// Holds all inputs for n frames
    pub fn enable_hold_all(&mut self, max_frames: u16) {
        self.hold_all = HoldLimit::from_max_frames(max_frames);
        self.latch_active_commands();
    }
    pub fn disable_hold_all(&mut self) {
        self.hold_all = HoldLimit::Disabled;
    }
    /// Stops global enrollment and immediately cancels every latched command.
    pub fn cancel_hold_all(&mut self) {
        self.disable_hold_all();
        for slot in &mut self.command_slots {
            slot.hold_remaining = HoldLimit::Disabled;
        }
    }
    pub fn enable_hold(&mut self, command: FighterCommands, max_frames: u16) {
        self.hold_limits[command.index()] = HoldOverride::from_max_frames(max_frames);
        if self.has_command(command) {
            self.latch_if_hold_enabled(command);
        }
    }
    /// Explicitly prevents this command from using either command-specific or
    /// global hold buffering, while preserving an existing latch.
    pub fn disable_hold(&mut self, command: FighterCommands) {
        self.hold_limits[command.index()] = HoldOverride::Disabled;
    }
    /// Removes the command-specific policy so this command inherits the
    /// global policy again.
    pub fn reset_hold_override(&mut self, command: FighterCommands) {
        self.hold_limits[command.index()] = HoldOverride::Inherit;
    }
    /// Stops enrollment and immediately cancels this command's hold lifetime.
    pub fn cancel_hold(&mut self, command: FighterCommands) {
        self.disable_hold(command);
        self.command_slots[command.index()].hold_remaining = HoldLimit::Disabled;
    }
    fn latch_if_hold_enabled(&mut self, command: FighterCommands) {
        let limit = self.hold_limit(command);
        let slot = &mut self.command_slots[command.index()];
        slot.hold_remaining = match limit {
            HoldLimit::Disabled => return,
            HoldLimit::Infinite => HoldLimit::Infinite,
            // The limit includes tap-buffer frames already elapsed.
            HoldLimit::Frames(max_frames) => {
                let remaining = max_frames.saturating_sub(slot.age);
                if remaining == 0 {
                    return;
                }
                HoldLimit::Frames(remaining)
            }
        };
    }
    fn latch_active_commands(&mut self) {
        for command in FighterCommands::iter() {
            if self.has_command(command) {
                self.latch_if_hold_enabled(command);
            }
        }
    }
    pub fn is_pressed(&self, action: DigitalAction) -> bool {
        self.current_frame
            .bindings_for(action)
            .pressed_since(self.prev_frame.bindings_for(action))
            .0
            != 0
    }
    pub fn is_released(&self, action: DigitalAction) -> bool {
        self.current_frame
            .bindings_for(action)
            .released_since(self.prev_frame.bindings_for(action))
            .0
            != 0
    }
    pub fn pressed_bindings(&self, action: DigitalAction) -> u16 {
        self.current_frame
            .bindings_for(action)
            .pressed_since(self.prev_frame.bindings_for(action))
            .0
    }
    pub fn binding_count(&self, action: DigitalAction) -> u32 {
        self.current_frame.bindings_for(action).count()
    }
    pub fn get_frames_in_smash_move_deadzone(&self) -> u8 {
        self.frames_in_x_flick_deadzone
    }
    pub fn set_attack_command_type(&mut self, command: FighterAttackCommandType) {
        self.attack_command = command;
    }
    pub fn get_attack_command_type(&self) -> FighterAttackCommandType {
        self.attack_command
    }
    fn hold_limit(&self, command: FighterCommands) -> HoldLimit {
        let specific = self.hold_limits[command.index()];
        match specific {
            HoldOverride::Inherit => self.hold_all,
            HoldOverride::Disabled => HoldLimit::Disabled,
            HoldOverride::Frames(frames) => HoldLimit::Frames(frames),
            HoldOverride::Infinite => HoldLimit::Infinite,
        }
    }
    fn update_hold(&mut self, command: FighterCommands) {
        let index = command.index();
        let slot = &mut self.command_slots[index];
        slot.age = slot.age.saturating_add(1);
        match slot.hold_remaining {
            HoldLimit::Disabled => {}
            HoldLimit::Infinite => {
                if slot.lifetime == 0 {
                    slot.lifetime = 1;
                }
            }
            HoldLimit::Frames(remaining) => {
                // This tick consumes one of the total persistent frames, but
                // the command remains active for the tick that consumes the
                // final frame.
                let remaining = remaining.saturating_sub(1);
                slot.hold_remaining = if remaining == 0 {
                    HoldLimit::Disabled
                } else {
                    HoldLimit::Frames(remaining)
                };
                if slot.lifetime == 0 {
                    slot.lifetime = 1;
                }
            }
        }
    }
 }
 /// Turns this frame's rolled-back inputs into per-fighter [`FighterInput`]
 /// state. Runs in `GameplaySet::Input`, before any state looks at it.
 pub fn postprocess_input(
    query: Query<(&mut FighterInput, &Player)>,
    inputs: Res<PlayerInputs<GGRSCfg>>,
@@ -166,93 +426,95 @@ pub fn postprocess_input(
        }
        input.push_input_frame(inputs[player.handle].0);
        let current_bindings = input.current_frame.bindings;
        let previous_bindings = input.prev_frame.bindings;
        for (history, action) in input.button_history.iter_mut().zip([
            DigitalAction::Jump,
            DigitalAction::Shield,
            DigitalAction::Attack,
        ]) {
            history.update(
                current_bindings.get(action).0,
                previous_bindings.get(action).0,
            );
        }
        // Directional smash detection
        let x_abs = input.current_frame.movement.x.abs();
        let y_abs = input.current_frame.movement.y.abs();
        let reset_deadzone = game_settings.input_common.smash_input_reset_axis_threshold;
        let axis_threshold = game_settings.input_common.smash_input_axis_threshold;
        let frame_threshold = game_settings.input_common.smash_input_frame_threshold;
        if x_abs < reset_deadzone {
            input.frames_in_x_flick_deadzone = 0xFE;
-        } else {
+        } else if input.prev_frame.movement.x.abs() < reset_deadzone
            let prev_x_abs = input.prev_frame.movement.x.abs();
            if prev_x_abs < reset_deadzone
            || input.prev_frame.movement.x.signum() != input.current_frame.movement.x.signum()
        {
            input.frames_in_x_flick_deadzone = 1;
        } else {
-                input.frames_in_x_flick_deadzone =
+            input.frames_in_x_flick_deadzone = input.frames_in_x_flick_deadzone.saturating_add(1);
                    input.frames_in_x_flick_deadzone.saturating_add(1);
            }
        }
        if y_abs < reset_deadzone {
            input.frames_in_y_flick_deadzone = 0xFE;
-        } else {
+        } else if input.prev_frame.movement.y.abs() < reset_deadzone
            let prev_y_abs = input.prev_frame.movement.y.abs();
            if prev_y_abs < reset_deadzone
            || input.prev_frame.movement.y.signum() != input.current_frame.movement.y.signum()
        {
            input.frames_in_y_flick_deadzone = 1;
        } else {
-                input.frames_in_y_flick_deadzone =
+            input.frames_in_y_flick_deadzone = input.frames_in_y_flick_deadzone.saturating_add(1);
                    input.frames_in_y_flick_deadzone.saturating_add(1);
            }
        }
-        if !input.prev_frame.jump && input.current_frame.jump {
+        let tap = game_settings.input_common.input_buffer_size;
-            input.set_lifetime(
+        let jump_pressed = input.is_pressed(DigitalAction::Jump);
-                FighterCommands::Jump,
+        let shield_pressed = input.is_pressed(DigitalAction::Shield);
-                game_settings.input_common.input_buffer_size,
+        let attack_pressed = input.is_pressed(DigitalAction::Attack);
-            );
+        if jump_pressed {
            input.set_lifetime(FighterCommands::Jump, tap);
        }
        if shield_pressed {
            input.set_lifetime(FighterCommands::Shield, tap);
        }
-        if !input.prev_frame.shield && input.current_frame.shield {
+        let shield_now = input.current_frame.bindings_for(DigitalAction::Shield);
-            input.set_lifetime(
+        let shield_previous = input.prev_frame.bindings_for(DigitalAction::Shield);
-                FighterCommands::Shield,
+        let second_shield_pressed = second_binding_pressed(shield_now, shield_previous);
-                game_settings.input_common.input_buffer_size,
+        if second_shield_pressed {
-            );
+            input.set_lifetime(FighterCommands::GuardHold, tap);
        }
        if !input.prev_frame.attack && input.current_frame.attack {
            input.set_lifetime(
                FighterCommands::Attack,
                game_settings.input_common.input_buffer_size,
            );
        }
        let mut y_flick_detected =
            y_abs >= axis_threshold && input.frames_in_y_flick_deadzone <= frame_threshold;
        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);
-
+            input.frames_in_y_flick_deadzone = 0xFF;
-            let command_to_set = if input.current_frame.movement.y > 0.0 {
+            let command = if input.current_frame.movement.y > 0.0 {
                FighterCommands::SmashMoveUp
            } else {
                FighterCommands::SmashMoveDown
            };
-
+            input.set_lifetime(command, tap);
-            input.set_lifetime(command_to_set, game_settings.input_common.input_buffer_size);
+        }
        if x_flick_detected {
            input.clear_command(FighterCommands::SmashMoveLeft);
            input.clear_command(FighterCommands::SmashMoveRight);
            input.frames_in_x_flick_deadzone = 0xFF;
            let command = if input.current_frame.movement.x > 0.0 {
                FighterCommands::SmashMoveRight
            } else {
                FighterCommands::SmashMoveLeft
            };
            input.set_lifetime(command, tap);
        }
        // if both flicks are detected, only one wins
        if x_flick_detected && y_flick_detected {
            x_flick_detected = x_abs > y_abs;
            y_flick_detected = !x_flick_detected;
        }
-        let attack_detected = input.current_frame.attack && !input.prev_frame.attack;
+        if attack_pressed {
        // Tilt/smash up/down
        if attack_detected {
            let attack_type = if y_flick_detected {
                if input.current_frame.movement.y > 0.0 {
                    FighterAttackCommandType::SmashAttackUp
@@ -280,25 +542,142 @@ pub fn postprocess_input(
            } else {
                FighterAttackCommandType::Neutral
            };
-
+            input.set_lifetime(FighterCommands::Attack, tap);
            input.set_lifetime(
                FighterCommands::Attack,
                game_settings.input_common.input_buffer_size,
            );
            input.set_attack_command_type(attack_type);
        }
-        if x_flick_detected {
+        for command in FighterCommands::iter() {
-            input.clear_command(FighterCommands::SmashMoveLeft);
+            input.update_hold(command);
            input.clear_command(FighterCommands::SmashMoveRight);
            let command_to_set = if input.current_frame.movement.x > 0.0 {
                FighterCommands::SmashMoveRight
            } else {
                FighterCommands::SmashMoveLeft
            };
            input.set_lifetime(command_to_set, game_settings.input_common.input_buffer_size);
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::input::ActionBindingMask;
    fn advance_command(input: &mut FighterInput, command: FighterCommands) {
        input.reduce_command_lifetime(command);
        input.update_hold(command);
    }
    #[test]
    fn second_binding_is_an_edge_not_a_level() {
        let first = ActionBindingMask(0b0001);
        let both = ActionBindingMask(0b0011);
        assert!(second_binding_pressed(both, first));
        assert!(!second_binding_pressed(both, both));
    }
    #[test]
    fn replacing_a_binding_still_triggers_the_combination() {
        let previous = ActionBindingMask(0b0011);
        let current = ActionBindingMask(0b0101);
        assert!(second_binding_pressed(current, previous));
    }
    #[test]
    fn command_can_be_consumed_without_erasing_raw_input() {
        let mut input = FighterInput::default();
        input.set_lifetime(FighterCommands::GuardHold, 3);
        assert!(input.consume_command(FighterCommands::GuardHold));
        assert!(!input.has_command(FighterCommands::GuardHold));
        assert_eq!(input.get_last_frame(), FighterInputFrame::default());
    }
    #[test]
    fn hold_extension_does_not_resurrect_consumed_commands() {
        let mut input = FighterInput::default();
        input.enable_hold(FighterCommands::Shield, 10);
        input.set_lifetime(FighterCommands::Shield, 1);
        input.update_hold(FighterCommands::Shield);
        input.reduce_command_lifetime(FighterCommands::Shield);
        input.update_hold(FighterCommands::Shield);
        assert!(input.has_command(FighterCommands::Shield));
        input.consume_command(FighterCommands::Shield);
        input.update_hold(FighterCommands::Shield);
        assert!(!input.has_command(FighterCommands::Shield));
    }
    #[test]
    fn hold_buffer_keeps_released_attack_through_jump_squat() {
        let mut input = FighterInput::default();
        input.set_lifetime(FighterCommands::Attack, 3);
        // Recognition happened before jump squat enabled persistence.
        input.update_hold(FighterCommands::Attack);
        input.enable_hold_all(10);
        // Five simulation ticks cover the test fighter's jump squat. The
        // physical attack binding is released, but persistence belongs to the
        // recognized command rather than the binding's held state.
        for _ in 0..5 {
            advance_command(&mut input, FighterCommands::Attack);
        }
        assert!(input.has_command(FighterCommands::Attack));
        // Jump-squat exit stops enrollment. The latch crosses into Jump and
        // remains visible on its first airborne interrupt frame.
        input.disable_hold_all();
        advance_command(&mut input, FighterCommands::Attack);
        assert!(input.has_command(FighterCommands::Attack));
        assert!(input.consume_command(FighterCommands::Attack));
        assert!(!input.has_command(FighterCommands::Attack));
    }
    #[test]
    fn finite_hold_limit_includes_elapsed_tap_frames() {
        let mut input = FighterInput::default();
        input.set_lifetime(FighterCommands::Attack, 3);
        // The recognition frame has already elapsed when jump squat starts.
        input.update_hold(FighterCommands::Attack);
        input.enable_hold_all(10);
        for _ in 0..9 {
            advance_command(&mut input, FighterCommands::Attack);
            assert!(input.has_command(FighterCommands::Attack));
        }
        advance_command(&mut input, FighterCommands::Attack);
        assert!(!input.has_command(FighterCommands::Attack));
    }
    #[test]
    fn stopping_enrollment_and_cancelling_latches_are_distinct() {
        let mut input = FighterInput::default();
        input.enable_hold_all(10);
        input.set_lifetime(FighterCommands::Shield, 1);
        input.disable_hold_all();
        advance_command(&mut input, FighterCommands::Shield);
        assert!(input.has_command(FighterCommands::Shield));
        input.cancel_hold_all();
        advance_command(&mut input, FighterCommands::Shield);
        assert!(!input.has_command(FighterCommands::Shield));
    }
    #[test]
    fn command_override_can_disable_global_hold() {
        let mut input = FighterInput::default();
        input.enable_hold_all(10);
        input.disable_hold(FighterCommands::Attack);
        input.set_lifetime(FighterCommands::Attack, 1);
        advance_command(&mut input, FighterCommands::Attack);
        assert!(!input.has_command(FighterCommands::Attack));
        input.reset_hold_override(FighterCommands::Attack);
        input.set_lifetime(FighterCommands::Attack, 1);
        advance_command(&mut input, FighterCommands::Attack);
        assert!(input.has_command(FighterCommands::Attack));
    }
    #[test]
    fn infinite_hold_uses_an_explicit_state() {
        let mut input = FighterInput::default();
        input.enable_hold(FighterCommands::Shield, 0);
        input.set_lifetime(FighterCommands::Shield, 1);
        for _ in 0..u16::MAX as usize + 1 {
            advance_command(&mut input, FighterCommands::Shield);
        }
        assert!(input.has_command(FighterCommands::Shield));
    }
 }
@@ -2,13 +2,119 @@ use serde::{Deserialize, Serialize};
 use crate::math::vec::FGVec2;
 /// A fixed-width set of distinct bindings assigned to one logical action.
 /// Keeping binding identity in the rollback frame allows combinations such as
 /// pressing a second shield binding while the first one is still held.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
 pub struct ActionBindingMask(pub u16);
 impl ActionBindingMask {
    pub const fn empty() -> Self {
        Self(0)
    }
    pub const fn from_slot(slot: u8) -> Self {
        Self(if slot < 16 { 1u16 << slot } else { 0 })
    }
    pub const fn contains(self, other: Self) -> bool {
        self.0 & other.0 == other.0
    }
    pub const fn intersects(self, other: Self) -> bool {
        self.0 & other.0 != 0
    }
    pub const fn count(self) -> u32 {
        self.0.count_ones()
    }
    pub const fn pressed_since(self, previous: Self) -> Self {
        Self(self.0 & !previous.0)
    }
    pub const fn released_since(self, previous: Self) -> Self {
        Self(previous.0 & !self.0)
    }
 }
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
 pub struct DigitalActionBindings {
    pub jump: ActionBindingMask,
    pub shield: ActionBindingMask,
    pub attack: ActionBindingMask,
 }
 impl DigitalActionBindings {
    pub fn set(&mut self, action: DigitalAction, slot: u8, pressed: bool) {
        let mask = match action {
            DigitalAction::Jump => &mut self.jump,
            DigitalAction::Shield => &mut self.shield,
            DigitalAction::Attack => &mut self.attack,
        };
        let bit = ActionBindingMask::from_slot(slot).0;
        if pressed {
            mask.0 |= bit;
        } else {
            mask.0 &= !bit;
        }
    }
    pub const fn get(self, action: DigitalAction) -> ActionBindingMask {
        match action {
            DigitalAction::Jump => self.jump,
            DigitalAction::Shield => self.shield,
            DigitalAction::Attack => self.attack,
        }
    }
 }
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum DigitalAction {
    Jump,
    Shield,
    Attack,
 }
 /// One frame of a player's raw input. This is the type GGRS serializes and
 /// sends over the wire, so keep it small and keep it `PartialEq`.
 #[derive(Copy, Clone, Debug, PartialEq, Default, Serialize, Deserialize, Hash)]
 pub struct FighterInputFrame {
    pub movement: FGVec2,
    pub directional_attack: FGVec2,
-    pub jump: bool,
+    pub bindings: DigitalActionBindings,
-    pub shield: bool,
+}
-    pub attack: bool,
+
 impl FighterInputFrame {
    pub const fn bindings_for(self, action: DigitalAction) -> ActionBindingMask {
        self.bindings.get(action)
    }
    pub const fn is_held(self, action: DigitalAction) -> bool {
        self.bindings_for(action).0 != 0
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn binding_masks_preserve_distinct_same_action_bindings() {
        let mut bindings = DigitalActionBindings::default();
        bindings.set(DigitalAction::Shield, 0, true);
        bindings.set(DigitalAction::Shield, 1, true);
        assert_eq!(bindings.shield.0, 0b11);
        assert_eq!(bindings.shield.count(), 2);
        assert_eq!(bindings.shield.pressed_since(ActionBindingMask(1)).0, 0b10);
    }
    #[test]
    fn clearing_one_binding_does_not_clear_the_other() {
        let mut bindings = DigitalActionBindings::default();
        bindings.set(DigitalAction::Shield, 0, true);
        bindings.set(DigitalAction::Shield, 1, true);
        bindings.set(DigitalAction::Shield, 0, false);
        assert_eq!(bindings.shield.0, 0b10);
    }
 }
@@ -7,7 +7,8 @@ use bevy::input::gamepad::{
 };
 use bevy::prelude::*;
-use super::poll::{GcAdapterSnapshot, GcPortState};
+use super::GcPorts;
 use super::poll::GcAdapterSnapshot;
 /// GameCube adapters report 4 ports.
 pub const GC_PORT_COUNT: usize = 4;
@@ -23,15 +24,6 @@ const GC_ADAPTER_PID: u16 = 0x0337;
 #[derive(Component, Debug, Clone, Copy)]
 pub struct GcPort(pub u8);
 /// Tracks which entity (if any) represents each of the 4 adapter ports,
 /// and the last snapshot seen, so both systems below can diff instead of
 /// re-deriving state every frame.
 #[derive(Resource, Default)]
 pub struct GcPorts {
    pub entities: [Option<Entity>; GC_PORT_COUNT],
    last: [GcPortState; GC_PORT_COUNT],
 }
 fn passthrough_gamepad_settings() -> GamepadSettings {
    let mut settings = GamepadSettings::default();
    for axis in GamepadAxis::all() {
@@ -1,10 +1,23 @@
 #[cfg(all(feature = "gamecube-adapter", not(target_os = "windows")))]
 pub mod bridge;
 #[cfg(all(feature = "gamecube-adapter", not(target_os = "windows")))]
 pub mod poll;
-pub use bridge::{GC_PORT_COUNT, GcPort, GcPorts};
+#[cfg(all(feature = "gamecube-adapter", not(target_os = "windows")))]
 pub use bridge::{GC_PORT_COUNT, GcPort};
 #[cfg(all(feature = "gamecube-adapter", not(target_os = "windows")))]
 pub use poll::{GcAdapterSnapshot, GcPortState};
 #[derive(Resource, Default)]
 pub struct GcPorts {
    pub entities: [Option<Entity>; 4],
    #[cfg(all(feature = "gamecube-adapter", not(target_os = "windows")))]
    pub(super) last: [poll::GcPortState; 4],
 }
 #[cfg(all(feature = "gamecube-adapter", not(target_os = "windows")))]
 use bevy::input::InputSystems;
 #[cfg(all(feature = "gamecube-adapter", not(target_os = "windows")))]
 use bevy::input::gamepad::{gamepad_connection_system, gamepad_event_processing_system};
 use bevy::prelude::*;
@@ -15,6 +28,8 @@ impl Plugin for GamecubeAdapterPlugin {
    fn build(&self, app: &mut App) {
        app.init_resource::<GcPorts>();
        #[cfg(all(feature = "gamecube-adapter", not(target_os = "windows")))]
        {
            let Ok(snapshot) = poll::spawn_poll_thread() else {
                // No adapter connected; leave GcPorts empty and skip wiring the
                // polling systems.
@@ -32,4 +47,5 @@ impl Plugin for GamecubeAdapterPlugin {
                    .in_set(InputSystems),
            );
        }
    }
 }
@@ -1,6 +1,8 @@
 use std::panic::{self, AssertUnwindSafe};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
 use bevy::prelude::*;
 use gc_adapter_neo::{Controller, GcAdapter};
@@ -55,10 +57,11 @@ impl GcPortState {
 /// Shared, `Send + Sync` handle to the latest snapshot from the poll
 /// thread. Safe to store as an ordinary [`Resource`] (no `NonSend` needed)
 /// because the `GcAdapter` itself never leaves its thread.
-#[derive(Resource, Clone)]
+#[derive(Resource)]
 pub struct GcAdapterSnapshot {
    ports: Arc<Mutex<[GcPortState; 4]>>,
    shutdown: Arc<AtomicBool>,
    poll_thread: Option<JoinHandle<()>>,
 }
 impl GcAdapterSnapshot {
@@ -69,12 +72,36 @@ impl GcAdapterSnapshot {
 impl Drop for GcAdapterSnapshot {
    fn drop(&mut self) {
-        // Only actually signals shutdown once the last clone (this resource
+        self.shutdown.store(true, Ordering::Release);
-        // is never cloned in practice, but be defensive) is dropped.
+
-        if Arc::strong_count(&self.shutdown) <= 1 {
+        if let Some(poll_thread) = self.poll_thread.take() {
-            self.shutdown.store(true, Ordering::Relaxed);
+            if let Err(payload) = poll_thread.join() {
                error!(
                    "GameCube Controller Adapter poll thread panicked during shutdown: {payload:?}"
                );
            }
        }
    }
 }
 const INITIAL_ERROR_BACKOFF: Duration = Duration::from_millis(1);
 const MAX_ERROR_BACKOFF: Duration = Duration::from_millis(100);
 fn next_error_backoff(backoff: Duration) -> Duration {
    backoff.saturating_mul(2).min(MAX_ERROR_BACKOFF)
 }
 /// Wait for a retry while still allowing the owner to shut the poll thread down promptly.
 fn wait_for_retry(shutdown: &AtomicBool, delay: Duration) -> bool {
    let deadline = Instant::now() + delay;
    while !shutdown.load(Ordering::Acquire) {
        let remaining = deadline.saturating_duration_since(Instant::now());
        if remaining.is_zero() {
            return true;
        }
        std::thread::sleep(remaining.min(Duration::from_millis(10)));
    }
    false
 }
 /// Connects to the first GameCube adapter found on the USB bus and starts
@@ -94,7 +121,7 @@ pub fn spawn_poll_thread() -> Result<GcAdapterSnapshot, gc_adapter_neo::UsbError
    let thread_ports = ports.clone();
    let thread_shutdown = shutdown.clone();
-    std::thread::Builder::new()
+    let poll_thread = std::thread::Builder::new()
        .name("gc-adapter-poll".into())
        .spawn(move || {
            // Flush whatever the adapter had buffered before we started
@@ -107,17 +134,27 @@ pub fn spawn_poll_thread() -> Result<GcAdapterSnapshot, gc_adapter_neo::UsbError
            let mut rate_window_start = std::time::Instant::now();
            #[cfg(debug_assertions)]
            let mut rate_window_count: u32 = 0;
            let mut error_backoff = INITIAL_ERROR_BACKOFF;
-            while !thread_shutdown.load(Ordering::Relaxed) {
+            while !thread_shutdown.load(Ordering::Acquire) {
                let result = panic::catch_unwind(AssertUnwindSafe(|| adapter.read_controllers()));
                let controllers = match result {
-                    Ok(Ok(controllers)) => controllers,
+                    Ok(Ok(controllers)) => {
                        error_backoff = INITIAL_ERROR_BACKOFF;
                        controllers
                    }
                    // Ignore this, for some reason we get a bunch of these when we start reading
                    Ok(Err(
                        gc_adapter_neo::AdapterError::Parse(_)
                        | gc_adapter_neo::AdapterError::ShortRead(_),
-                    )) => continue,
+                    )) => {
                        if !wait_for_retry(&thread_shutdown, error_backoff) {
                            break;
                        }
                        error_backoff = next_error_backoff(error_backoff);
                        continue;
                    }
                    Ok(Err(gc_adapter_neo::AdapterError::Usb(err))) => {
                        error!(
                            "GameCube Controller Adapter USB read failed ({err:?}); stopping \
@@ -160,5 +197,32 @@ pub fn spawn_poll_thread() -> Result<GcAdapterSnapshot, gc_adapter_neo::UsbError
        })
        .expect("failed to spawn gc-adapter poll thread");
-    Ok(GcAdapterSnapshot { ports, shutdown })
+    Ok(GcAdapterSnapshot {
        ports,
        shutdown,
        poll_thread: Some(poll_thread),
    })
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn error_backoff_is_capped() {
        let mut backoff = INITIAL_ERROR_BACKOFF;
        for _ in 0..16 {
            backoff = next_error_backoff(backoff);
        }
        assert_eq!(backoff, MAX_ERROR_BACKOFF);
        assert_eq!(next_error_backoff(MAX_ERROR_BACKOFF), MAX_ERROR_BACKOFF);
    }
    #[test]
    fn retry_wait_stops_when_shutdown_is_requested() {
        let shutdown = AtomicBool::new(true);
        assert!(!wait_for_retry(&shutdown, Duration::from_secs(1)));
    }
 }
@@ -14,10 +14,13 @@ pub fn sample_gamepad(pad: &Gamepad, input_map: &BaseInputMap) -> FighterInputFr
        match &gamepad_element.binding {
            GamepadBinding::Button(button) => {
                let pressed = pad.pressed(*button);
                if let Some(action) = gamepad_element.action.digital_action() {
                    input_frame
                        .bindings
                        .set(action, gamepad_element.binding_slot, pressed);
                }
                match gamepad_element.action {
-                    InputMapAction::Jump => input_frame.jump |= pressed,
+                    InputMapAction::Jump | InputMapAction::Shield | InputMapAction::Attack => {}
                    InputMapAction::Shield => input_frame.shield |= pressed,
                    InputMapAction::Attack => input_frame.attack |= pressed,
                    // Digital buttons driving movement isn't used by the
                    // default bindings (the stick covers that), but stay
                    // consistent with the keyboard backend if one is added.
@@ -30,9 +30,15 @@ pub fn sample_keyboard(key: &ButtonInput<KeyCode>, input_map: &BaseInputMap) ->
            InputMapAction::MovementYDir(sign) => {
                input_frame.movement.y += (sign) * action_strength
            }
-            InputMapAction::Jump => input_frame.jump = action_strength != FGi32::ZERO,
+            InputMapAction::Jump | InputMapAction::Shield | InputMapAction::Attack => {
-            InputMapAction::Shield => input_frame.shield = action_strength != FGi32::ZERO,
+                if let Some(action) = keyboard_elment.action.digital_action() {
-            InputMapAction::Attack => input_frame.attack = action_strength != FGi32::ZERO,
+                    input_frame.bindings.set(
                        action,
                        keyboard_elment.binding_slot,
                        action_strength != FGi32::ZERO,
                    );
                }
            }
        }
    }
@@ -19,6 +19,17 @@ pub enum InputMapAction {
    Attack,
 }
 impl InputMapAction {
    pub const fn digital_action(&self) -> Option<crate::input::DigitalAction> {
        match self {
            Self::Jump => Some(crate::input::DigitalAction::Jump),
            Self::Shield => Some(crate::input::DigitalAction::Shield),
            Self::Attack => Some(crate::input::DigitalAction::Attack),
            Self::MovementXDir(_) | Self::MovementYDir(_) => None,
        }
    }
 }
 #[derive(Debug)]
 pub enum MenuInputMapAction {
    MovementXDir(i32),
@@ -32,6 +43,7 @@ pub enum MenuInputMapAction {
 pub struct KeyboardInputMapElement {
    pub key: KeyCode,
    pub action: InputMapAction,
    pub binding_slot: u8,
 }
 #[derive(Debug)]
@@ -44,6 +56,7 @@ pub enum GamepadBinding {
 pub struct GamepadInputMapElement {
    pub binding: GamepadBinding,
    pub action: InputMapAction,
    pub binding_slot: u8,
 }
 #[derive(Debug)]
@@ -15,7 +15,7 @@ pub mod keyboard;
 pub mod map;
 pub use buffer::{FighterCommands, FighterInput};
-pub use frame::FighterInputFrame;
+pub use frame::{ActionBindingMask, DigitalAction, DigitalActionBindings, FighterInputFrame};
 pub use map::{
    BaseInputMap, GamepadBinding, GamepadInputMapElement, InputActionState, InputMapAction,
    KeyboardInputMapElement, MenuGamepadInputMapElement, MenuInputMap, MenuInputMapAction,
@@ -28,7 +28,7 @@ pub enum LocalInputSource {
    Gamepad(Entity),
 }
-/// Maps an input source to a player index
+/// Persistent mapping from physical/menu controller slots to input sources.
 #[derive(Resource, Clone, Debug, Default, Deref, DerefMut)]
 pub struct LocalInputAssignments(pub Vec<(usize, LocalInputSource)>);
@@ -50,6 +50,16 @@ impl LocalInputAssignments {
    }
 }
 /// Match-local mapping from dense GGRS handles to physical input sources.
 #[derive(Resource, Clone, Debug, Default, Deref, DerefMut)]
 pub struct MatchInputAssignments(pub Vec<Option<LocalInputSource>>);
 impl MatchInputAssignments {
    pub fn get_for_handle(&self, handle: usize) -> Option<LocalInputSource> {
        self.0.get(handle).copied().flatten()
    }
 }
 use crate::game_settings::GameSettings;
 use crate::math::int::FGi32;
 use crate::netcode::GGRSCfg;
@@ -68,36 +78,43 @@ impl Plugin for FighterInputPlugin {
                KeyboardInputMapElement {
                    key: KeyCode::KeyD,
                    action: InputMapAction::MovementXDir(1),
                    binding_slot: 0,
                },
                // left
                KeyboardInputMapElement {
                    key: KeyCode::KeyA,
                    action: InputMapAction::MovementXDir(-1),
                    binding_slot: 0,
                },
                // up
                KeyboardInputMapElement {
                    key: KeyCode::KeyW,
                    action: InputMapAction::MovementYDir(1),
                    binding_slot: 0,
                },
                // down
                KeyboardInputMapElement {
                    key: KeyCode::KeyS,
                    action: InputMapAction::MovementYDir(-1),
                    binding_slot: 0,
                },
                // jump
                KeyboardInputMapElement {
                    key: KeyCode::Space,
                    action: InputMapAction::Jump,
                    binding_slot: 0,
                },
                // shield/airdodge
                KeyboardInputMapElement {
                    key: KeyCode::ShiftLeft,
                    action: InputMapAction::Shield,
                    binding_slot: 0,
                },
                // attack
                KeyboardInputMapElement {
                    key: KeyCode::KeyJ,
                    action: InputMapAction::Attack,
                    binding_slot: 0,
                },
                // Menu
            ],
@@ -106,29 +123,34 @@ impl Plugin for FighterInputPlugin {
                GamepadInputMapElement {
                    binding: GamepadBinding::Axis(GamepadAxis::LeftStickX, 1),
                    action: InputMapAction::MovementXDir(1),
                    binding_slot: 0,
                },
                GamepadInputMapElement {
                    binding: GamepadBinding::Axis(GamepadAxis::LeftStickY, 1),
                    action: InputMapAction::MovementYDir(1),
                    binding_slot: 0,
                },
                // jump
                GamepadInputMapElement {
                    binding: GamepadBinding::Button(GamepadButton::North),
                    action: InputMapAction::Jump,
-                },
+                    binding_slot: 0,
                // shield/airdodge -- both shoulder buttons, Melee-style
                GamepadInputMapElement {
                    binding: GamepadBinding::Button(GamepadButton::LeftTrigger),
                    action: InputMapAction::Shield,
                },
                GamepadInputMapElement {
-                    binding: GamepadBinding::Button(GamepadButton::RightTrigger),
+                    binding: GamepadBinding::Button(GamepadButton::LeftTrigger2),
                    action: InputMapAction::Shield,
                    binding_slot: 0,
                },
                GamepadInputMapElement {
                    binding: GamepadBinding::Button(GamepadButton::RightTrigger2),
                    action: InputMapAction::Shield,
                    binding_slot: 1,
                },
                // attack
                GamepadInputMapElement {
                    binding: GamepadBinding::Button(GamepadButton::East),
                    action: InputMapAction::Attack,
                    binding_slot: 0,
                },
            ],
        })
@@ -245,20 +267,17 @@ fn read_local_inputs(
    input_map: Res<BaseInputMap>,
    gc_ports: Res<gamecube::GcPorts>,
    gamepads: Query<&Gamepad>,
-    assignments: Res<LocalInputAssignments>,
+    assignments: Res<MatchInputAssignments>,
    local_players: Res<LocalPlayers>,
    game_settings: Res<GameSettings>,
 ) {
    let mut local_inputs = HashMap::new();
    for handle in &local_players.0 {
-        let assigned = assignments
+        let assigned = assignments.get_for_handle(*handle);
            .0
            .iter()
            .find(|(player_handle, _)| player_handle == handle);
        let gamepad = match assigned {
-            Some((_, LocalInputSource::Gamepad(entity))) => gamepads.get(*entity).ok(),
+            Some(LocalInputSource::Gamepad(entity)) => gamepads.get(entity).ok(),
-            Some((_, LocalInputSource::Keyboard)) => None,
+            Some(LocalInputSource::Keyboard) => None,
            None => gc_ports
                .entities
                .get(*handle)
@@ -268,8 +287,8 @@ fn read_local_inputs(
        };
        let mut input_frame = match assigned {
-            Some((_, LocalInputSource::Keyboard)) => keyboard::sample_keyboard(&key, &input_map),
+            Some(LocalInputSource::Keyboard) => keyboard::sample_keyboard(&key, &input_map),
-            Some((_, LocalInputSource::Gamepad(_))) => gamepad
+            Some(LocalInputSource::Gamepad(_)) => gamepad
                .map(|pad| gamepad::sample_gamepad(pad, &input_map))
                .unwrap_or_default(),
            None => FighterInputFrame::default(),
@@ -21,6 +21,8 @@
 //! save, click Rebuild in jackdaw (or run `jd build`) and it
 //! appears in `Add Component`. No registration code is needed.
 #![recursion_limit = "512"]
 use bevy::{
    asset::processor::{AssetProcessor, ProcessorState},
    prelude::*,
@@ -33,8 +35,9 @@ use ron_asset_manager::RonAssetPlugin;
 use crate::{
    camera::MatchCameraPlugin, fighter::manifest::FighterManifest, game_settings::GameSettings,
-    match_runtime::MatchRuntimePlugin, menus::style::FGUiStyle, schedule::GameplaySchedulePlugin,
+    match_runtime::MatchRuntimePlugin, materials::ShinesparkMaterialPlugin,
-    stage::manifest::StageManifest, ui::InGameUIPlugin,
+    menus::style::FGUiStyle, schedule::GameplaySchedulePlugin, stage::manifest::StageManifest,
    ui::InGameUIPlugin,
 };
 mod args;
@@ -42,10 +45,14 @@ pub mod blend_asset;
 pub mod camera;
 pub mod debug_tools;
 pub mod fighter;
 pub mod filled_gizmos;
 pub mod game_settings;
 pub mod input;
 #[cfg(feature = "hitbox-viewer")]
 pub mod hitbox_viewer;
 pub mod match_loading;
 pub mod match_runtime;
 pub mod materials;
 mod math;
 pub mod menus;
 pub mod netcode;
@@ -56,6 +63,7 @@ pub mod scripting;
 pub mod stage;
 pub mod texture_reference;
 pub mod ui;
 pub mod egui_color_convert;
 #[derive(States, Debug, Clone, Copy, Eq, PartialEq, Hash, Default)]
 pub enum AppState {
@@ -74,6 +82,7 @@ pub enum AppState {
    LoadingMatch,
    PreparingMatch,
    InMatch,
    MatchResults,
    MatchDisconnected,
    MatchLoadFailed,
 }
@@ -106,6 +115,7 @@ impl Plugin for GamePlugin {
        // game-level content and configuration.
        app.init_state::<AppState>()
            .add_plugins((
                (
                    SettingsPlugin::new("moe.eirteam.shinespark.debug_settings"),
                    // Brings up GGRS (and with it `GgrsSchedule`), so it goes first.
                    netcode::FighterNetcodePlugin::default(),
@@ -114,6 +124,7 @@ impl Plugin for GamePlugin {
                    input::FighterInputPlugin,
                    replay::ReplayPlugin,
                    debug_tools::DebugToolsPlugin,
                    filled_gizmos::FilledGizmosPlugin,
                    fighter::FighterPlugin,
                    fighter::baked_animation::BakedAnimationPlugin,
                    scripting::importer::FighterScriptImportPlugin,
@@ -121,6 +132,8 @@ impl Plugin for GamePlugin {
                    MatchCameraPlugin,
                    GameAssetPlugin,
                    InGameUIPlugin,
                ),
                ShinesparkMaterialPlugin,
            ))
            .add_plugins(menus::MenuPlugin)
            .add_loading_state(
@@ -8,9 +8,7 @@ use bevy_ggrs::prelude::Session;
 use serde::{Deserialize, Serialize};
 use crate::{
-    AppState,
+    AppState, args::Args, fighter::{
    args::Args,
    fighter::{
        FighterId, FighterRoster,
        animation::AnimKind,
        attack::{AttackKind, FighterAttackScriptAssets},
@@ -18,16 +16,10 @@ use crate::{
        manifest::{FighterManifest, FighterManifestRegistry},
        spawn_fighter,
        visual::FighterAnimations,
-    },
+    }, input::{LocalInputAssignments, LocalInputSource, MatchInputAssignments}, match_runtime::MatchState, netcode::{
    input::{LocalInputAssignments, LocalInputSource},
    match_runtime::MatchState,
    math::{int::FGi32, vec::FGVec2},
    netcode::{
        GGRSCfg,
        session::{ConnectionStatus, SessionConfig, create_session},
-    },
+    }, scripting::FighterAttackScript, stage::{
    scripting::FighterAttackScript,
    stage::{
        self,
        manifest::{StageId, StageManifest, StageManifestRegistry},
    },
@@ -35,7 +27,10 @@ use crate::{
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub struct MatchPlayer {
    /// Dense index used by GGRS and rollback-simulated player state.
    pub handle: usize,
    /// Physical controller port selected in the menu.
    pub controller_port: usize,
    pub fighter: FighterId,
 }
@@ -46,6 +41,22 @@ pub struct MatchConfig {
    pub rules: MatchRules,
 }
 impl MatchConfig {
    /// Maps a GGRS handle to the controller port used by gameplay.
    ///
    /// Multiplayer uses the stable, dense GGRS handle as the port. A
    /// single-player match preserves the physical controller port selected in
    /// the menu (for example, port 3 remains port 3).
    pub fn controller_port_for_handle(&self, handle: usize) -> Option<usize> {
        let player = self.players.iter().find(|player| player.handle == handle)?;
        Some(if self.players.len() > 1 {
            handle
        } else {
            player.controller_port
        })
    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum MatchRules {
    Stock {
@@ -228,6 +239,7 @@ pub fn initiate_default_match(
    let players = (0..args.players)
        .map(|handle| MatchPlayer {
            handle,
            controller_port: handle,
            fighter: FighterId::TestFighter,
        })
        .collect();
@@ -263,6 +275,7 @@ pub fn initiate_default_match(
 pub fn prepare_match(
    mut commands: Commands,
    config: Res<MatchConfig>,
    input_assignments: Res<LocalInputAssignments>,
    assets: Res<MatchAssets>,
    gltfs: Res<Assets<Gltf>>,
    baked_animations: Res<Assets<BakedFighterAnimations>>,
@@ -277,7 +290,7 @@ pub fn prepare_match(
    if !valid_player_handles(&config.players) {
        fail_match(
            &mut next_state,
-            "player handles must be unique and cover 0..player_count",
+            "player handles must be dense, unique, and non-empty",
        );
        return;
    }
@@ -287,6 +300,20 @@ pub fn prepare_match(
        return;
    }
    let stage_handle = stage_registry
        .get(config.stage)
        .expect("Initialization check should ensure all stages exist");
    let stage_manifest = stage_manifests
        .get(&stage_handle)
        .expect("Initialization check should ensure stage manifests are kept alive");
    let spawn_positions = match stage_manifest.neutral_spawn_positions(config.players.len()) {
        Ok(positions) => positions,
        Err(error) => {
            fail_match(&mut next_state, &error);
            return;
        }
    };
    if assets.fighters.len() != config.players.len() {
        fail_match(
            &mut next_state,
@@ -336,6 +363,15 @@ pub fn prepare_match(
            );
            return;
        }
        let ecb_bone_indices = baked.bone_names.iter().enumerate().filter_map(|(idx, name)| {
            if manifest.ecb_bones.contains(name) {
                Some(idx)
            } else {
                None
            }
        }).collect::<Vec<_>>();
        if let Err(error) = manifest.attributes.validate() {
            fail_match(
                &mut next_state,
@@ -436,10 +472,12 @@ pub fn prepare_match(
            attack_scripts,
            manifest_handle,
            manifest.model_scale,
            ecb_bone_indices,
        ));
    }
-    let session_config = match SessionConfig::from_args(&args, config.players.len()) {
+    let session_player_count = player_count_for_handles(&config.players);
    let session_config = match SessionConfig::from_args(&args, session_player_count) {
        Ok(config) => config,
        Err(error) => {
            fail_match(
@@ -449,7 +487,7 @@ pub fn prepare_match(
            return;
        }
    };
-    let session = match create_session(&args, config.players.len()) {
+    let session = match create_session(&args, session_player_count) {
        Ok(session) => session,
        Err(error) => {
            fail_match(
@@ -460,14 +498,13 @@ pub fn prepare_match(
        }
    };
    commands.insert_resource(create_match_input_assignments(
        &input_assignments,
        &config.players,
    ));
    let root = commands.spawn((Name::new("Match"), MatchRoot)).id();
    let stage_handle = stage_registry
        .get(config.stage)
        .expect("Initialization check should ensure all stages exist");
    let stage_manifest = stage_manifests
        .get(&stage_handle)
        .expect("Initialization check should ensure stage manifests are kept alive");
    stage::spawn_stage(
        &mut commands,
        root,
@@ -477,19 +514,24 @@ pub fn prepare_match(
    );
    let mut fighter_roster = Vec::with_capacity(config.players.len());
-    for (index, (player, (scene, animations, attack_scripts, manifest_handle, model_scale))) in
+
    for (spawn_index, (player, (scene, animations, attack_scripts, manifest_handle, model_scale, ecb_bone_indices))) in
        config.players.iter().zip(prepared).enumerate()
    {
-        let spawn_x = (index as i32 * 2 + 1 - config.players.len() as i32) * 5;
+        let spawn_point = spawn_positions[spawn_index];
        fighter_roster.push(spawn_fighter(
            &mut commands,
            player.handle,
-            FGVec2::new(FGi32::from_num(spawn_x), FGi32::lit("12.5")),
+            config
                .controller_port_for_handle(player.handle)
                .expect("validated match config contains every player handle"),
            spawn_point,
            manifest_handle.clone(),
            model_scale,
            animations,
            attack_scripts,
            WorldAssetRoot(scene),
            ecb_bone_indices
        ));
    }
@@ -507,12 +549,30 @@ fn fail_match(next_state: &mut NextState<AppState>, message: &str) {
 }
 fn valid_player_handles(players: &[MatchPlayer]) -> bool {
-    let mut handles = players
+    if players.is_empty() {
-        .iter()
+        return false;
-        .map(|player| player.handle)
+    }
-        .collect::<Vec<_>>();
+
    let mut handles = players.iter().map(|player| player.handle).collect::<Vec<_>>();
    handles.sort_unstable();
-    handles == (0..players.len()).collect::<Vec<_>>()
+    handles.into_iter().eq(0..players.len())
 }
 fn player_count_for_handles(players: &[MatchPlayer]) -> usize {
    players.len()
 }
 fn create_match_input_assignments(
    assignments: &LocalInputAssignments,
    players: &[MatchPlayer],
 ) -> MatchInputAssignments {
    let mut match_assignments = vec![None; players.len()];
    for player in players {
        match_assignments[player.handle] = assignments
            .get_from_slot(player.controller_port)
            .copied();
    }
    MatchInputAssignments(match_assignments)
 }
 pub fn cleanup_match(
@@ -533,6 +593,7 @@ pub fn cleanup_match(
    commands.remove_resource::<MatchAssets>();
    commands.remove_resource::<MatchConfig>();
    commands.remove_resource::<MatchState>();
    commands.remove_resource::<MatchInputAssignments>();
    commands.remove_resource::<FighterRoster>();
 }
@@ -547,10 +608,12 @@ mod tests {
            players: vec![
                MatchPlayer {
                    handle: 0,
                    controller_port: 0,
                    fighter: FighterId::TestFighter,
                },
                MatchPlayer {
                    handle: 1,
                    controller_port: 1,
                    fighter: FighterId::TestFighter,
                },
            ],
@@ -568,10 +631,12 @@ mod tests {
        let players = [
            MatchPlayer {
                handle: 0,
                controller_port: 0,
                fighter: FighterId::TestFighter,
            },
            MatchPlayer {
                handle: 0,
                controller_port: 1,
                fighter: FighterId::TestFighter,
            },
        ];
@@ -579,6 +644,88 @@ mod tests {
        assert!(!valid_player_handles(&players));
    }
    #[test]
    fn player_handles_must_not_have_gaps() {
        let players = [
            MatchPlayer {
                handle: 0,
                controller_port: 0,
                fighter: FighterId::TestFighter,
            },
            MatchPlayer {
                handle: 2,
                controller_port: 3,
                fighter: FighterId::TestFighter,
            },
        ];
        assert!(!valid_player_handles(&players));
        assert_eq!(player_count_for_handles(&players), 2);
    }
    #[test]
    fn controller_ports_use_ggrs_handles_only_in_multiplayer() {
        let single_player = MatchConfig {
            stage: StageId::TestStage,
            players: vec![MatchPlayer {
                handle: 0,
                controller_port: 3,
                fighter: FighterId::TestFighter,
            }],
            rules: MatchRules::default(),
        };
        assert_eq!(single_player.controller_port_for_handle(0), Some(3));
        let multiplayer = MatchConfig {
            stage: StageId::TestStage,
            players: vec![
                MatchPlayer {
                    handle: 0,
                    controller_port: 0,
                    fighter: FighterId::TestFighter,
                },
                MatchPlayer {
                    handle: 1,
                    controller_port: 3,
                    fighter: FighterId::TestFighter,
                },
            ],
            rules: MatchRules::default(),
        };
        assert_eq!(multiplayer.controller_port_for_handle(0), Some(0));
        assert_eq!(multiplayer.controller_port_for_handle(1), Some(1));
    }
    #[test]
    fn match_input_assignments_map_ports_to_ggrs_handles_without_mutating_ports() {
        let players = [
            MatchPlayer {
                handle: 0,
                controller_port: 0,
                fighter: FighterId::TestFighter,
            },
            MatchPlayer {
                handle: 1,
                controller_port: 3,
                fighter: FighterId::TestFighter,
            },
        ];
        let assignments = LocalInputAssignments(vec![
            (0, LocalInputSource::Keyboard),
            (3, LocalInputSource::Gamepad(Entity::PLACEHOLDER)),
        ]);
        let match_assignments = create_match_input_assignments(&assignments, &players);
        assert_eq!(match_assignments.get_for_handle(0), Some(LocalInputSource::Keyboard));
        assert_eq!(
            match_assignments.get_for_handle(1),
            Some(LocalInputSource::Gamepad(Entity::PLACEHOLDER))
        );
        assert_eq!(assignments[0].0, 0);
        assert_eq!(assignments[1].0, 3);
    }
    #[test]
    fn match_rules_reject_zero_limits() {
        assert!(
@@ -1,15 +1,22 @@
 //! Rollback-simulated state for an active match.
 use bevy::input::InputSystems;
 use bevy::prelude::*;
-use bevy_ggrs::prelude::*;
+use bevy_ggrs::{ConfirmedFrameCount, RollbackFrameCount, RunGgrsSystems, prelude::*};
-use crate::match_loading::{MatchConfig, MatchRules};
+use crate::{
    AppState,
    match_loading::{MatchConfig, MatchRules},
    netcode::session::SessionConfig,
 };
 #[derive(Resource, Clone, Debug, Hash, PartialEq, Eq)]
 pub struct MatchState {
    pub elapsed_frames: u32,
    /// Indexed by the player's session handle.
    pub players: Vec<PlayerMatchState>,
    /// The rollback frame on which the match first finished.
    pub finished_at_frame: Option<i32>,
 }
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
@@ -19,6 +26,11 @@ pub struct PlayerMatchState {
    pub deaths: u32,
 }
 #[derive(Resource, Debug, Default, Clone, Copy, PartialEq, Eq)]
 pub struct PauseState {
    pub paused: bool,
 }
 impl MatchState {
    pub fn from_config(config: &MatchConfig) -> Self {
        let stocks_remaining = match &config.rules {
@@ -37,8 +49,66 @@ impl MatchState {
                    deaths: 0,
                })
                .collect(),
            finished_at_frame: None,
        }
    }
    pub fn is_match_finished(&self, config: &MatchConfig) -> bool {
        let time_limit = match config.rules {
            MatchRules::Stock {
                starting_stocks: _,
                time_limit_frames,
            } => time_limit_frames,
            MatchRules::Timed { time_limit_frames } => Some(time_limit_frames),
        };
        if let Some(time_limit) = time_limit {
            if self.elapsed_frames >= time_limit {
                return true;
            }
        }
        if config.players.len() > 1
            && let MatchRules::Stock {
                starting_stocks: _,
                time_limit_frames: _,
            } = config.rules
        {
            let alive_fighter_count = self
                .players
                .iter()
                .filter(|fighter| {
                    fighter
                        .stocks_remaining
                        .map(|stocks| stocks)
                        .unwrap_or_default()
                        > 0
                })
                .count();
            if alive_fighter_count <= 1 {
                return true;
            }
        }
        false
    }
    fn advance_frame(&mut self, config: &MatchConfig, frame: i32) {
        if self.finished_at_frame.is_some() {
            return;
        }
        self.elapsed_frames = self.elapsed_frames.saturating_add(1);
        if self.is_match_finished(config) {
            self.finished_at_frame = Some(frame);
        }
    }
    fn finish_is_confirmed(&self, confirmed_frame: i32) -> bool {
        self.finished_at_frame
            .is_some_and(|finished_at| confirmed_frame >= finished_at)
    }
 }
 pub struct MatchRuntimePlugin;
@@ -46,7 +116,80 @@ pub struct MatchRuntimePlugin;
 impl Plugin for MatchRuntimePlugin {
    fn build(&self, app: &mut App) {
        app.rollback_resource_with_clone::<MatchState>()
-            .checksum_resource_with_hash::<MatchState>();
+            .checksum_resource_with_hash::<MatchState>()
            .init_resource::<PauseState>()
            .configure_sets(PreUpdate, RunGgrsSystems.run_if(ggrs_should_run))
            .add_systems(OnEnter(AppState::InMatch), reset_pause)
            .add_systems(OnExit(AppState::InMatch), reset_pause)
            .add_systems(
                GgrsSchedule,
                update_match_rules.in_set(crate::schedule::GameplaySet::MatchRules),
            )
            .add_systems(
                PreUpdate,
                toggle_pause
                    .after(InputSystems)
                    .before(RunGgrsSystems)
                    .run_if(in_state(AppState::InMatch)),
            )
            .add_systems(
                Update,
                transition_after_confirmed_finish.run_if(in_state(AppState::InMatch)),
            );
    }
 }
 pub fn ggrs_should_run(pause: Option<Res<PauseState>>) -> bool {
    !pause.is_some_and(|pause| pause.paused)
 }
 pub(crate) fn match_is_ongoing(match_state: Option<Res<MatchState>>) -> bool {
    match_state.is_none_or(|match_state| match_state.finished_at_frame.is_none())
 }
 fn toggle_pause(
    key: Res<ButtonInput<KeyCode>>,
    gamepads: Query<&Gamepad>,
    session: Res<SessionConfig>,
    mut pause: ResMut<PauseState>,
    mut virtual_time: ResMut<Time<Virtual>>,
 ) {
    if session.is_multiplayer() {
        return;
    }
    let pressed = key.just_pressed(KeyCode::Escape)
        || gamepads
            .iter()
            .any(|gamepad| gamepad.just_pressed(GamepadButton::Start));
    if !pressed {
        return;
    }
    pause.paused = !pause.paused;
    virtual_time.toggle();
 }
 fn reset_pause(mut pause: ResMut<PauseState>, mut virtual_time: ResMut<Time<Virtual>>) {
    pause.paused = false;
    virtual_time.unpause();
 }
 fn update_match_rules(
    mut match_state: ResMut<MatchState>,
    match_config: Res<MatchConfig>,
    frame: Res<RollbackFrameCount>,
 ) {
    match_state.advance_frame(&match_config, frame.0);
 }
 fn transition_after_confirmed_finish(
    match_state: Res<MatchState>,
    confirmed_frame: Res<ConfirmedFrameCount>,
    mut next_state: ResMut<NextState<AppState>>,
 ) {
    if match_state.finish_is_confirmed(confirmed_frame.0) {
        next_state.set(AppState::MatchResults);
    }
 }
@@ -61,10 +204,12 @@ mod tests {
            players: vec![
                MatchPlayer {
                    handle: 1,
                    controller_port: 3,
                    fighter: FighterId::TestFighter,
                },
                MatchPlayer {
                    handle: 0,
                    controller_port: 0,
                    fighter: FighterId::TestFighter,
                },
            ],
@@ -80,6 +225,7 @@ mod tests {
        }));
        assert_eq!(state.elapsed_frames, 0);
        assert_eq!(state.finished_at_frame, None);
        assert_eq!(state.players.len(), 2);
        assert!(state.players.iter().all(|player| {
            player.stocks_remaining == Some(4) && player.score == 0 && player.deaths == 0
@@ -99,4 +245,74 @@ mod tests {
                .all(|player| player.stocks_remaining.is_none())
        );
    }
    #[test]
    fn timed_match_finishes_on_its_rollback_frame() {
        let config = config(MatchRules::Timed {
            time_limit_frames: 2,
        });
        let mut state = MatchState::from_config(&config);
        state.advance_frame(&config, 10);
        assert_eq!(state.elapsed_frames, 1);
        assert_eq!(state.finished_at_frame, None);
        state.advance_frame(&config, 11);
        assert_eq!(state.elapsed_frames, 2);
        assert_eq!(state.finished_at_frame, Some(11));
        assert!(!state.finish_is_confirmed(10));
        assert!(state.finish_is_confirmed(11));
        state.advance_frame(&config, 12);
        assert_eq!(state.finished_at_frame, Some(11));
        assert_eq!(state.elapsed_frames, 2);
    }
    #[test]
    fn corrected_rollback_state_does_not_keep_speculative_finish() {
        let config = config(MatchRules::Stock {
            starting_stocks: 1,
            time_limit_frames: None,
        });
        let state_before_prediction = MatchState::from_config(&config);
        let mut predicted_state = state_before_prediction.clone();
        predicted_state.players[1].stocks_remaining = Some(0);
        predicted_state.advance_frame(&config, 20);
        assert_eq!(predicted_state.finished_at_frame, Some(20));
        let mut corrected_state = state_before_prediction;
        corrected_state.advance_frame(&config, 20);
        assert_eq!(corrected_state.finished_at_frame, None);
        assert!(!corrected_state.finish_is_confirmed(20));
    }
    #[test]
    fn single_player_stock_match_does_not_finish_by_elimination() {
        let mut config = config(MatchRules::Stock {
            starting_stocks: 1,
            time_limit_frames: None,
        });
        config.players.truncate(1);
        let mut state = MatchState::from_config(&config);
        state.advance_frame(&config, 1);
        assert_eq!(state.finished_at_frame, None);
        state.players[0].stocks_remaining = Some(0);
        state.advance_frame(&config, 2);
        assert_eq!(state.finished_at_frame, None);
    }
    #[test]
    fn single_player_stock_match_can_finish_by_time_limit() {
        let mut config = config(MatchRules::Stock {
            starting_stocks: 1,
            time_limit_frames: Some(1),
        });
        config.players.truncate(1);
        let mut state = MatchState::from_config(&config);
        state.advance_frame(&config, 7);
        assert_eq!(state.finished_at_frame, Some(7));
    }
 }
@@ -0,0 +1,77 @@
 use bevy::{gltf::GltfMaterialName, pbr::{ExtendedMaterial, MaterialExtension}, prelude::*, render::render_resource::AsBindGroup, shader::ShaderRef, world_serialization::WorldInstanceReady};
 pub type FighterMaterial = ExtendedMaterial<StandardMaterial, FighterMaterialExtension>;
 #[derive(Component)]
 pub struct FighterMesh {
    pub fighter: Entity
 }
 #[derive(Asset, AsBindGroup, Reflect, Debug, Clone, Default)]
 pub struct FighterMaterialExtension {
    #[uniform(100)]
    status_color: LinearRgba,
    #[uniform(100)]
    status_color_intensity: f32,
 }
 const SHADER_ASSET_PATH: &str = "embedded://shinespark/shaders/fighter.wgsl";
 impl FighterMaterialExtension {
    pub fn new(status_color: Color) -> Self {
        Self {
            status_color: status_color.into(),
            status_color_intensity: 0.0,
            ..default()
        }
    }
    pub fn update_status_color(&mut self, status_color: LinearRgba, intensity: f32) {
        self.status_color = status_color;
        self.status_color_intensity = intensity;
    }
 }
 impl MaterialExtension for FighterMaterialExtension {
    fn fragment_shader() -> ShaderRef {
        SHADER_ASSET_PATH.into()
    }
    fn deferred_fragment_shader() -> ShaderRef {
        SHADER_ASSET_PATH.into()
    }
 }
 pub fn bind_fighter_material(
    scene_ready: On<WorldInstanceReady>,
    mut commands: Commands,
    children: Query<&Children>,
    //color_override: Query<&ColorOverride>,
    mesh_materials: Query<(Entity, &MeshMaterial3d<StandardMaterial>, &GltfMaterialName)>,
    mut asset_materials: ResMut<Assets<FighterMaterial>>,
    original_materials: Res<Assets<StandardMaterial>>,
 ) {
    for descendant in children.iter_descendants(scene_ready.entity) {
        let Ok((entity, id, material_name)) = mesh_materials.get(descendant) else {
            continue;
        };
        dbg!(material_name);
        if !material_name.starts_with("Fighter_") {
            continue;
        }
        let Some(original_material) = original_materials.get(id.id()) else {
            continue;
        };
        commands.entity(entity).insert((MeshMaterial3d(asset_materials.add(ExtendedMaterial {
            base: StandardMaterial {
                // can be used in forward or deferred mode
                ..original_material.clone()
            },
            extension: FighterMaterialExtension::new(bevy::color::palettes::css::BLUE.into())
        })), FighterMesh { fighter: scene_ready.entity  }));
    }
 }
@@ -0,0 +1,24 @@
 use bevy::{
    asset::embedded_asset, prelude::*,
 };
 pub mod fighter_material;
 pub struct ShinesparkMaterialPlugin;
 pub fn startup_test(asset_server: Res<AssetServer>) {
    let test: Handle<Shader> = asset_server.load("embedded://shinespark/shaders/fighter.wgsl");
    dbg!(test);
 }
 impl Plugin for ShinesparkMaterialPlugin {
    fn build(&self, app: &mut App) {
        let omit_prefix = "";
        embedded_asset!(app, omit_prefix, "shaders/fighter.wgsl");
        app.add_systems(Startup, startup_test)
            .add_observer(fighter_material::bind_fighter_material)
            .add_plugins(MaterialPlugin::<fighter_material::FighterMaterial>::default());
    }
 }
@@ -0,0 +1,67 @@
 #import bevy_pbr::{
    pbr_fragment::pbr_input_from_standard_material,
    pbr_functions::alpha_discard,
 }
 #ifdef PREPASS_PIPELINE
 #import bevy_pbr::{
    prepass_io::{VertexOutput, FragmentOutput},
    pbr_deferred_functions::deferred_output,
 }
 #else
 #import bevy_pbr::{
    forward_io::{VertexOutput, FragmentOutput},
    pbr_functions::{apply_pbr_lighting, main_pass_post_lighting_processing},
 }
 #endif
 struct FighterExtendedMaterial {
    status_color: vec4<f32>,
    status_color_intensity: f32,
 #ifdef SIXTEEN_BYTE_ALIGNMENT
    // Web examples WebGL2 support: structs must be 16 byte aligned.
    _webgl2_padding_8b: u32,
    _webgl2_padding_12b: u32,
    _webgl2_padding_16b: u32,
 #endif
 }
@group(#{MATERIAL_BIND_GROUP}) @binding(100)
 var<uniform> fighter_material: FighterExtendedMaterial;
@fragment
 fn fragment(
    in: VertexOutput,
    @builtin(front_facing) is_front: bool,
 ) -> FragmentOutput {
    // generate a PbrInput struct from the StandardMaterial bindings
    var pbr_input = pbr_input_from_standard_material(in, is_front);
    // we can optionally modify the input before lighting and alpha_discard is applied
    //pbr_input.material.base_color.b = pbr_input.material.base_color.r;
    // alpha discard
    pbr_input.material.base_color = alpha_discard(pbr_input.material, pbr_input.material.base_color);
 #ifdef PREPASS_PIPELINE
    // in deferred mode we can't modify anything after that, as lighting is run in a separate fullscreen shader.
    let out = deferred_output(in, pbr_input);
 #else
    var out: FragmentOutput;
    // apply lighting
    out.color = apply_pbr_lighting(pbr_input);
    // we can optionally modify the lit color before post-processing is applied
    var quantize_steps: i32 = 2;
    out.color = vec4<f32>(vec4<u32>(out.color * f32(quantize_steps))) / f32(quantize_steps);
    // apply in-shader post processing (fog, alpha-premultiply, and also tonemapping, debanding if the camera is non-hdr)
    // note this does not include fullscreen postprocessing effects like bloom.
    out.color = main_pass_post_lighting_processing(pbr_input, out.color);
    out.color = mix(out.color, fighter_material.status_color, fighter_material.status_color_intensity * 0.5);
 #endif
    return out;
 }
@@ -2,7 +2,7 @@ use bevy::math::Vec2;
 use bevy::prelude::*;
 use fixed::types::I32F32;
 use serde::{Deserialize, Serialize};
-use std::ops::{Add, AddAssign, Div, Mul, MulAssign, Sub};
+use std::ops::{Add, AddAssign, Div, Mul, MulAssign, Sub, SubAssign};
 use super::int::{FGWide, FGi32};
@@ -227,6 +227,15 @@ impl AddAssign for FGVec2 {
    }
 }
 impl SubAssign for FGVec2 {
    fn sub_assign(&mut self, rhs: Self) {
        *self = Self {
            x: self.x - rhs.x,
            y: self.y - rhs.y,
        }
    }
 }
 impl MulAssign for FGVec2 {
    fn mul_assign(&mut self, rhs: Self) {
        *self = Self {
@@ -1,19 +1,8 @@
 use bevy::{picking::pointer::PointerId, prelude::*};
 use crate::{
-    AppState,
+    AppState, fighter::manifest::{FighterManifest, FighterManifestRegistry}, game_settings::CommonAssets, input::{LocalInputAssignments, LocalInputSource}, menus::{
-    fighter::manifest::{FighterManifest, FighterManifestRegistry},
+        MenuCameraMarker, MenuMarker, button::FGUiButton, character_select::{character_box::CharacterBox, token::CharacterSelectToken}, cursor::{FGMenuCursor, MenuCursorInputSource}, errors::MenuErrors::FighterManifestNotFound, match_config::{MenuMatchConfig, MenuMatchPlayerSlot}, scaling, spawn_menu, style::{FGUiButtonType, FGUiStyle},
    game_settings::CommonAssets,
    input::{LocalInputAssignments, LocalInputSource},
    menus::{
        MenuMarker,
        button::FGUiButton,
        character_select::{character_box::CharacterBox, token::CharacterSelectToken},
        cursor::{FGMenuCursor, MenuCursorInputSource},
        errors::MenuErrors::FighterManifestNotFound,
        match_config::{MenuMatchConfig, MenuMatchPlayerSlot},
        scaling, spawn_menu,
        style::{FGUiButtonType, FGUiStyle},
    },
 };
@@ -241,7 +230,7 @@ pub fn copy_cursor_transform_to_token(
    character_boxes: Query<(&CharacterBox, &ComputedNode, &UiGlobalTransform)>,
    match_config: Res<MenuMatchConfig>,
    cursors: Query<&UiGlobalTransform, With<FGMenuCursor>>,
-    cam: Single<&Camera>,
+    cam: Single<&Camera, With<MenuCameraMarker>>,
    ui_scale: Res<UiScale>,
 ) -> Result {
    let camera = cam.into_inner();
@@ -9,11 +9,8 @@ use bevy::{
 };
 use crate::{
-    input::{LocalInputAssignments, LocalInputSource},
+    input::{LocalInputAssignments, LocalInputSource}, menus::{
-    menus::{
+        MenuCameraMarker, input::{MenuInput, MenuInputState}, scaling, style::FGUiStyle,
        input::{MenuInput, MenuInputState},
        scaling,
        style::FGUiStyle,
    },
 };
@@ -181,7 +178,7 @@ pub fn cursor_input(
 }
 pub fn update_cursor_transform(
-    camera: Single<&Camera>,
+    camera: Single<&Camera, With<MenuCameraMarker>>,
    query: Query<(&mut Node, &PointerLocation), With<FGMenuCursor>>,
    ui_scale: Res<UiScale>,
 ) {
@@ -226,7 +226,7 @@ fn gamepad_input(
                input.accept.accumulate(&status);
            }
            MenuInputMapAction::Start => {
-                input.accept.accumulate(&status);
+                input.start.accumulate(&status);
            }
        }
    }
@@ -65,7 +65,10 @@ impl MenuMatchConfig {
        let stage = self.stage.ok_or(MenuMatchConfigErrors::StageNotSelected)?;
-        for player in self.players.iter() {
+        let mut players = self.players.iter().collect::<Vec<_>>();
        players.sort_unstable_by_key(|player| player.slot);
        for (handle, player) in players.into_iter().enumerate() {
            let fighter_id =
                player
                    .fighter
@@ -74,7 +77,8 @@ impl MenuMatchConfig {
                    ))?;
            match_players.push(MatchPlayer {
                fighter: fighter_id,
-                handle: player.slot,
+                handle,
                controller_port: player.slot,
            });
        }
@@ -102,4 +106,27 @@ mod tests {
        assert_eq!(menu.to_match_config().unwrap().rules, MatchRules::default());
    }
    #[test]
    fn sparse_controller_ports_get_dense_ggrs_handles() {
        let menu = MenuMatchConfig {
            stage: Some(StageId::TestStage),
            players: vec![
                MenuMatchPlayerSlot {
                    slot: 3,
                    fighter: Some(FighterId::TestFighter),
                },
                MenuMatchPlayerSlot {
                    slot: 0,
                    fighter: Some(FighterId::TestFighter),
                },
            ],
        };
        let config = menu.to_match_config().unwrap();
        assert_eq!(config.players[0].handle, 0);
        assert_eq!(config.players[0].controller_port, 0);
        assert_eq!(config.players[1].handle, 1);
        assert_eq!(config.players[1].controller_port, 3);
    }
 }
@@ -0,0 +1,44 @@
 use bevy::{prelude::*, text::FontSourceTemplate};
 use crate::{AppState, menus::{MenuMarker, spawn_menu}};
 pub fn setup_post_match_menu(
    existing_menu: Option<Single<Entity, With<MenuMarker>>>,
    commands: Commands,
 ) {
    let menu = bsn! {
        Node {
                flex_direction: FlexDirection::Column,
                width: percent(100),
                height: percent(100),
                justify_content: JustifyContent::Center,
                align_items: AlignItems::Center
        }
        Children [
        (
            Text("[Insert beautiful post-match screen here]")
            TextFont {
                font: FontSourceTemplate::Handle("fonts/roboto.ttf"),
                font_size: px(super::style::H1_SIZE),
            }
            TextColor(Color::srgb(0.9, 0.9, 0.9))
        ),
            Text("Press any button/key to continue...")
            TextFont {
                font: FontSourceTemplate::Handle("fonts/roboto.ttf"),
                font_size: px(super::style::H3_SIZE),
            }
            TextColor(Color::srgb(0.9, 0.9, 0.9))
        ]
    };
    spawn_menu(existing_menu, commands, menu);
 }
 pub fn check_return_to_character_select(gamepads: Query<&Gamepad>, keyboard: Res<ButtonInput<KeyCode>>, mut next_state: ResMut<NextState<AppState>>) {
    let any_pressed = gamepads.iter().any(|gp| gp.get_just_pressed().count() > 0);
    let any_pressed = any_pressed || keyboard.get_just_pressed().count() > 0;
    if any_pressed {
        next_state.set(AppState::MainMenu);
    }
 }
@@ -18,6 +18,7 @@ pub mod errors;
 pub mod input;
 pub mod main_menu;
 pub mod match_config;
 pub mod match_results;
 pub mod navigation;
 pub mod scaling;
 pub mod stage_select;
@@ -53,6 +54,7 @@ pub fn wrap_menu(menu: impl Scene) -> impl Scene {
                #MenuCamera
                Camera
                Camera2d
                MenuCameraMarker
            ),
            (
                #MenuContainer
@@ -73,17 +75,10 @@ pub fn wrap_menu(menu: impl Scene) -> impl Scene {
 pub fn despawn_menu(
    existing_menu: Option<Single<Entity, With<MenuMarker>>>,
    existing_menu_camera: Option<Single<Entity, With<MenuCameraMarker>>>,
    mut commands: Commands,
 ) {
    if let Some(entity) = existing_menu {
-        commands
+        commands.entity(entity.into_inner()).despawn();
            .entity(entity.into_inner())
            .despawn();
    }
    if let Some(menu_cam) = existing_menu_camera {
        commands.entity(*menu_cam).despawn();
    }
 }
@@ -93,9 +88,7 @@ pub fn spawn_menu(
    menu: impl Scene,
 ) {
    if let Some(entity) = existing_menu {
-        commands
+        commands.entity(entity.into_inner()).despawn();
            .entity(entity.into_inner())
            .despawn();
    }
    commands.queue_spawn_scene(wrap_menu(menu));
 }
@@ -120,19 +113,13 @@ where
 impl Plugin for MenuPlugin {
    fn build(&self, app: &mut App) {
-        app.add_systems(
+        app.add_systems(OnEnter(AppState::MainMenu), build_menu::<MainMenu>)
            OnEnter(AppState::MainMenu),
            build_menu::<MainMenu>,
        )
            .add_message::<character_select::PlayerSlotAssigned>()
            .init_resource::<navigation::UINavigationActionState>()
            .init_resource::<navigation::UINavigationRepeat>()
            .init_resource::<input::MenuInputState>()
            .insert_resource(InputFocusVisible(true))
-        .insert_resource(GlobalUiDebugOptions {
+            .insert_resource(GlobalUiDebugOptions { ..default() })
            enabled: true,
            ..default()
        })
            // Configure auto-navigation behavior
            .insert_resource(AutoNavigationConfig {
                // Require at least 10% overlap in perpendicular axis for cardinal directions
@@ -197,7 +184,9 @@ impl Plugin for MenuPlugin {
                OnExit(AppState::CharacterSelect),
                (cursor::despawn_cursors, character_select::despawn_tokens),
            )
-        .add_observer(character_select::select_fighter.run_if(in_state(AppState::CharacterSelect)))
+            .add_observer(
                character_select::select_fighter.run_if(in_state(AppState::CharacterSelect)),
            )
            .add_observer(
                character_select::update_start_banner_visibility
                    .run_if(in_state(AppState::CharacterSelect)),
@@ -220,6 +209,21 @@ impl Plugin for MenuPlugin {
            //---------
            // STAGE SELECT END
            //---------
            //---------
            // MATCH RESULT START
            //---------
            .add_systems(
                OnEnter(AppState::MatchResults),
                match_results::setup_post_match_menu,
            )
            .add_systems(
                PostUpdate,
                match_results::check_return_to_character_select
                    .run_if(in_state(AppState::MatchResults)),
            )
            //---------
            // MATCH RESULT END
            //---------
            .add_systems(
                Update,
                (
@@ -102,7 +102,7 @@ pub fn process_inputs(
                .insert(DirectionalNavigationAction::Right);
        }
    }
-    if input.accept.is_pressed() {
+    if input.accept.is_just_pressed() {
        action_state
            .pressed_actions
            .insert(DirectionalNavigationAction::Select);
@@ -42,6 +42,15 @@ pub enum SessionConfigError {
 }
 impl SessionConfig {
    /// Returns whether this match has more than one remote participant.
    pub fn is_multiplayer(&self) -> bool {
        self.players.len() > 1
            || self
                .players
                .iter()
                .any(|player| matches!(player, PlayerConnection::Remote(_)))
    }
    pub fn from_args(args: &Args, player_count: usize) -> Result<Self, SessionConfigError> {
        if player_count == 0 {
            return Err(SessionConfigError::NoPlayers);
@@ -196,6 +205,13 @@ mod tests {
            config.players,
            [PlayerConnection::Local, PlayerConnection::Local]
        );
        assert!(config.is_multiplayer());
    }
    #[test]
    fn single_local_player_is_not_multiplayer() {
        let config = SessionConfig::from_args(&args(&["game", "--players", "1"]), 1).unwrap();
        assert!(!config.is_multiplayer());
    }
    #[test]
@@ -207,6 +223,7 @@ mod tests {
        .unwrap();
        assert!(matches!(config.players[0], PlayerConnection::Local));
        assert!(matches!(config.players[1], PlayerConnection::Remote(_)));
        assert!(config.is_multiplayer());
    }
    #[test]
@@ -10,5 +10,8 @@ use bevy_ggrs::prelude::*;
 #[derive(Default, Component)]
 #[require(Rollback, Transform)]
 pub struct Player {
    /// Dense GGRS session index.
    pub handle: usize,
    /// Port used for port-dependent gameplay such as respawn placement.
    pub controller_port: usize,
 }
@@ -17,7 +17,7 @@ use crate::{
 };
 const MAGIC: &[u8; 8] = b"SPRPLY01";
-pub const REPLAY_VERSION: u32 = 2;
+pub const REPLAY_VERSION: u32 = 3;
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq, ValueEnum)]
 pub enum ReplayFormat {
@@ -140,7 +140,7 @@ fn validate(replay: &Replay) -> Result<(), String> {
        ));
    }
    if replay.players_are_invalid() {
-        return Err("replay player handles must cover 0..player_count".into());
+        return Err("replay player handles must be unique".into());
    }
    if replay.frames.is_empty() {
        return Err("replay must contain at least one frame".into());
@@ -185,7 +185,7 @@ impl Replay {
            .map(|player| player.handle)
            .collect();
        handles.sort_unstable();
-        handles != (0..handles.len()).collect::<Vec<_>>()
+        handles.is_empty() || !handles.into_iter().eq(0..self.match_config.players.len())
    }
    fn frame(&self, frame: i32) -> Option<&ReplayFrame> {
@@ -374,6 +374,7 @@ mod tests {
                stage: StageId::TestStage,
                players: vec![MatchPlayer {
                    handle: 0,
                    controller_port: 0,
                    fighter: FighterId::TestFighter,
                }],
                rules: MatchRules::Timed {
@@ -9,6 +9,8 @@
 use bevy::prelude::*;
 use bevy_ggrs::prelude::*;
 use crate::match_runtime::match_is_ongoing;
 #[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
 pub enum GameplaySet {
    /// Turn this frame's netcode inputs into per-fighter input state.
@@ -19,12 +21,14 @@ pub enum GameplaySet {
    StateUpdate,
    /// Integrate velocities into positions.
    Physics,
    /// Solve collision boxes
    Animation,
    /// Resolve the integrated positions against the stage.
    Collision,
    /// Solve collision boxes
    Animation,
    /// Resolve attacks
    Attacks,
    /// Advance match rules and detect the end of the match.
    MatchRules,
 }
 /// Declares the order of [`GameplaySet`] inside [`GgrsSchedule`]. Added by
@@ -40,11 +44,13 @@ impl Plugin for GameplaySchedulePlugin {
                GameplaySet::Interrupt,
                GameplaySet::StateUpdate,
                GameplaySet::Physics,
                GameplaySet::Collision,
                GameplaySet::Animation,
                GameplaySet::Collision,
                GameplaySet::Attacks,
                GameplaySet::MatchRules,
            )
-                .chain(),
+                .chain()
                .run_if(match_is_ongoing),
        );
    }
 }
@@ -1,6 +1,5 @@
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use crate::{fighter::attack::AttackHitbox, math::int::FGi32};
@@ -15,22 +14,37 @@ pub enum MoveAngleKind {
 #[derive(Asset, Reflect, Serialize, Deserialize)]
 pub struct FighterAttackScript {
    pub hitboxes: Vec<AttackHitbox>,
-    pub iasa_frame: u32,
+    pub iasa_frame: Option<u32>,
-    pub wont_autocancel_window: (u32, u32),
+    pub wont_autocancel_window: Option<(u32, u32)>,
    pub landing_duration: Option<u32>,
 }
 impl FighterAttackScript {
    pub fn validate(&self) -> Result<(), String> {
        let mut ids = HashSet::with_capacity(self.hitboxes.len());
        for hitbox in &self.hitboxes {
            hitbox.validate()?;
-            if !ids.insert(hitbox.id) {
+        }
-                return Err(format!("duplicate hitbox id {}", hitbox.id));
+        for (index, left) in self.hitboxes.iter().enumerate() {
            for right in self.hitboxes.iter().skip(index + 1) {
                if left.id == right.id
                    && left.start_frame < right.end_frame
                    && right.start_frame < left.end_frame
                {
                    return Err(format!(
                        "hitbox id {} has overlapping intervals {}..{} and {}..{}",
                        left.id, left.start_frame, left.end_frame, right.start_frame,
                        right.end_frame
                    ));
                }
            }
-        if self.wont_autocancel_window.0 > self.wont_autocancel_window.1 {
+        }
        if let Some(wont_autocancel_window) = self.wont_autocancel_window {
            if wont_autocancel_window.0 > wont_autocancel_window.1 {
                return Err("autocancel window end precedes its start".into());
            }
        }
        Ok(())
    }
 }
@@ -1,6 +1,7 @@
 use std::{cell::RefCell, collections::HashMap, rc::Rc};
 use rhai::EvalAltResult;
 use serde::{Deserialize, Serialize};
 use crate::{
    fighter::attack::{self, AttackAngle, FighterDamage, Knockback, KnockbackType},
@@ -10,13 +11,41 @@ use crate::{
 #[derive(Debug, Default)]
 struct MoveCompiler {
-    hitboxes: HashMap<u32, attack::AttackHitbox>,
+    hitboxes: Vec<attack::AttackHitbox>,
-    active_hitboxes: Vec<u32>,
+    active_hitboxes: HashMap<u32, usize>,
    wont_autocancel_window: Option<(u32, u32)>,
    iasa_frame: Option<u32>,
    landing_duration: Option<u32>,
    cursor: u32,
 }
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct SharedHitboxInfo {
    damage: FighterDamage,
    angle: AttackAngle,
    knockback_type: KnockbackType,
    knockback: Knockback,
    knockback_growth: FGi32,
 }
 impl SharedHitboxInfo {
    pub fn make(
        damage: FighterDamage,
        angle: AttackAngle,
        knockback_type: KnockbackType,
        knockback: Knockback,
        knockback_growth: FGi32,
    ) -> Self {
        Self {
            damage,
            angle,
            knockback_type,
            knockback,
            knockback_growth,
        }
    }
 }
 fn rhai_u32(value: i64, parameter: &str) -> Result<u32, Box<EvalAltResult>> {
    u32::try_from(value).map_err(|_| {
        format!(
@@ -43,28 +72,18 @@ impl MoveCompiler {
    }
    fn remove_hitbox(&mut self, id: u32) -> Result<(), Box<EvalAltResult>> {
-        let hb = self
+        let hitbox_index = *self
-            .hitboxes
+            .active_hitboxes
-            .get_mut(&id)
+            .get(&id)
            .ok_or(format!("Can't remove hitbox with {id}: Hitbox not found"))?;
-
+        self.hitboxes[hitbox_index].end_frame = self.cursor;
-        let active_hbox_position =
+        self.active_hitboxes.remove(&id);
            self.active_hitboxes
                .iter()
                .position(|i| *i == id)
                .ok_or(format!(
                    "Can't remove hitbox with ID {id}: Hitbox was not active"
                ))?;
        hb.end_frame = self.cursor;
        self.active_hitboxes.remove(active_hbox_position);
        Ok(())
    }
    fn remove_all_hitboxes(&mut self) -> Result<(), Box<EvalAltResult>> {
        // We are gonna modify the array, so take a copy...
-        for hitbox_id in self.active_hitboxes.clone() {
+        for hitbox_id in self.active_hitboxes.keys().copied().collect::<Vec<_>>() {
            self.remove_hitbox(hitbox_id)?;
        }
@@ -97,14 +116,14 @@ impl MoveCompiler {
    fn into_attack_script(mut self) -> Result<FighterAttackScript, String> {
        self.remove_all_hitboxes().map_err(|err| err.to_string())?;
-        let mut hitboxes: Vec<_> = self.hitboxes.into_values().collect();
+        let mut hitboxes = self.hitboxes;
-        hitboxes.sort_unstable_by_key(|hitbox| hitbox.id);
+        hitboxes.sort_unstable_by_key(|hitbox| (hitbox.id, hitbox.start_frame));
-        let iasa_frame = self.iasa_frame.unwrap_or(100000);
+
        let wont_autocancel_window = self.wont_autocancel_window.unwrap_or((0, 100000));
        Ok(FighterAttackScript {
            hitboxes,
-            iasa_frame,
+            iasa_frame: self.iasa_frame,
-            wont_autocancel_window,
+            wont_autocancel_window: self.wont_autocancel_window,
            landing_duration: self.landing_duration,
        })
    }
 }
@@ -117,7 +136,9 @@ pub fn register_common_types(engine: &mut rhai::Engine) {
        .register_fn("knockback_normal", KnockbackType::make_normal)
        .register_fn("knockback_fixed", KnockbackType::make_fixed)
        .register_type_with_name::<AttackAngle>("Angle")
-        .register_fn("angle", AttackAngle::make_normal)
+        .register_fn("angle", |str: &str| {
            AttackAngle::make_normal(FGi32::lit(str))
        })
        .register_fn("angle_sakurai", AttackAngle::make_sakurai)
        .register_type_with_name::<Knockback>("Knockback")
        .register_fn("knockback", Knockback::lit)
@@ -128,6 +149,17 @@ pub fn register_common_types(engine: &mut rhai::Engine) {
        .register_type_with_name::<FGVec3>("Vec3")
        .register_fn("vec3", FGVec3::lit)
        .register_type_with_name::<FighterDamage>("FighterDamage")
        .register_type_with_name::<SharedHitboxInfo>("SharedHitboxInfo")
        .register_fn(
            "make_hitbox_info",
            |damage: FighterDamage,
             angle: AttackAngle,
             knockback_type: KnockbackType,
             knockback: Knockback,
             knockback_growth: FGi32| {
                SharedHitboxInfo::make(damage, angle, knockback_type, knockback, knockback_growth)
            },
        )
        .register_fn("damage", FighterDamage::lit);
 }
@@ -200,6 +232,37 @@ pub fn compile_script(text: &str) -> Result<FighterAttackScript, String> {
            );
        }
        {
            let mc = mc.clone();
            engine.register_fn(
                "hitbox",
                move |id: i64,
                      group: i64,
                      bone: &str,
                      offset: FGVec3,
                      radius: FGi32,
                      shared: SharedHitboxInfo|
                      -> Result<(), Box<EvalAltResult>> {
                    add_hitbox(
                        &mc,
                        id,
                        group,
                        bone,
                        shared.damage,
                        offset,
                        radius,
                        shared.angle.clone(),
                        shared.knockback_type,
                        shared.knockback,
                        shared.knockback_growth,
                    )
                },
            );
        }
        // Keep the original script syntax working. A hitbox without an
        // explicit group behaves as its own group, which preserves the old
        // one-hit-per-target behavior.
        {
            let mc = mc.clone();
            engine.register_fn(
@@ -214,17 +277,91 @@ pub fn compile_script(text: &str) -> Result<FighterAttackScript, String> {
                      knockback: Knockback,
                      knockback_growth: FGi32|
                      -> Result<(), Box<EvalAltResult>> {
-                    let mut b = mc.borrow_mut();
+                    add_hitbox(
-
+                        &mc,
-                    // Rhai does not have first class u32 support, so we have to do this.
+                        id,
-                    let id = rhai_u32(id, "hitbox id")?;
+                        id,
-
+                        bone,
-                    if b.hitboxes.contains_key(&id) {
+                        damage,
-                        return Err(format!("Hitbox with ID {} already existed!", id).into());
+                        offset,
                        radius,
                        angle,
                        knockback_type,
                        knockback,
                        knockback_growth,
                    )
                },
            );
        }
-                    let hitbox = attack::AttackHitbox {
+        {
            let mc = mc.clone();
            engine.register_fn(
                "hitbox",
                move |id: i64,
                      group: i64,
                      bone: &str,
                      damage: FighterDamage,
                      offset: FGVec3,
                      radius: FGi32,
                      angle: AttackAngle,
                      knockback_type: KnockbackType,
                      knockback: Knockback,
                      knockback_growth: FGi32|
                      -> Result<(), Box<EvalAltResult>> {
                    add_hitbox(
                        &mc,
                        id,
                        group,
                        bone,
                        damage,
                        offset,
                        radius,
                        angle,
                        knockback_type,
                        knockback,
                        knockback_growth,
                    )
                },
            );
        }
        engine.run(&text)
    };
    let script = result
        .map(|_| {
            Rc::into_inner(mc)
                .unwrap()
                .into_inner()
                .into_attack_script()
        })
        .map_err(|err| err.to_string())??;
    script.validate().map(|()| script)
 }
 fn add_hitbox(
    mc: &Rc<RefCell<MoveCompiler>>,
    raw_id: i64,
    raw_group: i64,
    bone: &str,
    damage: FighterDamage,
    offset: FGVec3,
    radius: FGi32,
    angle: AttackAngle,
    knockback_type: KnockbackType,
    knockback: Knockback,
    knockback_growth: FGi32,
 ) -> Result<(), Box<EvalAltResult>> {
    let mut b = mc.borrow_mut();
    let id = rhai_u32(raw_id, "hitbox id")?;
    let group = rhai_u32(raw_group, "hitbox group")?;
    if b.active_hitboxes.contains_key(&id) {
        return Err(format!("Hitbox with ID {} is already active!", id).into());
    }
    let hitbox_index = b.hitboxes.len();
    let frame = b.cursor;
    b.hitboxes.push(attack::AttackHitbox {
        id,
        group,
        bone: bone.to_owned(),
        damage,
        offset,
@@ -233,46 +370,29 @@ pub fn compile_script(text: &str) -> Result<FighterAttackScript, String> {
        knockback_type,
        knockback,
        knockback_growth,
-                        start_frame: b.cursor,
+        start_frame: frame,
-                        end_frame: b.cursor,
+        end_frame: frame,
-                    };
+    });
-
+    b.active_hitboxes.insert(id, hitbox_index);
                    b.hitboxes.insert(id, hitbox);
                    b.active_hitboxes.push(id);
    Ok(())
                },
            );
        }
        engine.run(&text)
    };
    result
        .map(|_| {
            Rc::into_inner(mc)
                .unwrap()
                .into_inner()
                .into_attack_script()
        })
        .map_err(|err| err.to_string())?
 }
 #[cfg(test)]
 mod tests {
    use super::*;
-    const HITBOX: &str = "hitbox(0, \"hand_l\", damage(\"1\"), vec3(\"0\", \"0\", \"0\"), fg32(\"1\"), angle(fg32(\"0\")), knockback_normal(), knockback(\"1\"), fg32(\"1\"));";
+    const HITBOX: &str = "hitbox(0, \"hand_l\", damage(\"1\"), vec3(\"0\", \"0\", \"0\"), fg32(\"1\"), angle(\"0\"), knockback_normal(), knockback(\"1\"), fg32(\"1\"));";
    #[test]
    fn compiled_hitboxes_are_sorted_by_authored_id() {
        let script = compile_script(
            r#"
                frame(1);
-                hitbox(20, "hand_l", damage("1"), vec3("0", "0", "0"), fg32("1"), angle(fg32("0")), knockback_normal(), knockback("1"), fg32("1"));
+                hitbox(20, "hand_l", damage("1"), vec3("0", "0", "0"), fg32("1"), angle("0"), knockback_normal(), knockback("1"), fg32("1"));
                frame(2);
-                hitbox(3, "hand_l", damage("2"), vec3("0", "0", "0"), fg32("1"), angle(fg32("0")), knockback_normal(), knockback("1"), fg32("1"));
+                hitbox(3, "hand_l", damage("2"), vec3("0", "0", "0"), fg32("1"), angle("0"), knockback_normal(), knockback("1"), fg32("1"));
                frame(3);
-                hitbox(10, "hand_l", damage("3"), vec3("0", "0", "0"), fg32("1"), angle(fg32("0")), knockback_normal(), knockback("1"), fg32("1"));
+                hitbox(10, "hand_l", damage("3"), vec3("0", "0", "0"), fg32("1"), angle("0"), knockback_normal(), knockback("1"), fg32("1"));
                frame(4);
            "#,
        )
@@ -316,4 +436,29 @@ mod tests {
        assert_eq!(script.hitboxes[0].start_frame, 1);
        assert_eq!(script.hitboxes[0].end_frame, 2);
    }
    #[test]
    fn hitbox_ids_can_be_reused_after_removal() {
        let script = compile_script(&format!(
            "frame(1); {HITBOX} frame(2); remove_hitbox(0); frame(4); {HITBOX} frame(5);"
        ))
        .unwrap();
        assert_eq!(script.hitboxes.len(), 2);
        assert_eq!(script.hitboxes[0].start_frame, 1);
        assert_eq!(script.hitboxes[0].end_frame, 2);
        assert_eq!(script.hitboxes[1].start_frame, 4);
        assert_eq!(script.hitboxes[1].end_frame, 5);
    }
    #[test]
    fn explicit_hitbox_group_is_compiled() {
        let script = compile_script(
            r#"frame(1); hitbox(7, 3, "hand_l", damage("1"), vec3("0", "0", "0"), fg32("1"), angle("0"), knockback_normal(), knockback("1"), fg32("1")); frame(2);"#,
        )
        .unwrap();
        assert_eq!(script.hitboxes[0].id, 7);
        assert_eq!(script.hitboxes[0].group, 3);
    }
 }
@@ -1,6 +1,11 @@
 use bevy::{color::palettes::css::RED, prelude::*};
-use crate::stage::line::StageCollision;
+use crate::{
    match_loading::MatchConfig, math::{int::FGi32, vec3::FGVec3}, stage::{
        line::StageCollision,
        manifest::{StageManifest, StageManifestRegistry},
    },
 };
 pub fn debug_draw_scene(mut gizmos: Gizmos, stage_collision: Res<StageCollision>) {
    for poly in stage_collision.stage_polys.iter() {
@@ -16,3 +21,52 @@ pub fn debug_draw_scene(mut gizmos: Gizmos, stage_collision: Res<StageCollision>
        }
    }
 }
 pub fn debug_draw_blast_zones(
    mut gizmos: Gizmos,
    stage_registry: Res<StageManifestRegistry>,
    stage_manifests: Res<Assets<StageManifest>>,
    match_config: Res<MatchConfig>,
 ) {
    let Some(stage_manifest_handle) = stage_registry.get(match_config.stage) else {
        return;
    };
    let Some(stage_manifest) = stage_manifests.get(&stage_manifest_handle) else {
        return;
    };
    let top_left = stage_manifest.blast_zone_top_left.to_vec2();
    let bottom_right = stage_manifest.blast_zone_bottom_right.to_vec2();
    let center = (top_left + bottom_right) / 2.0;
    let size = (bottom_right - top_left).abs();
    gizmos.rect(
        Vec3::new(center.x, center.y, 0.0),
        size,
        bevy::color::palettes::css::BLUE,
    );
 }
 pub fn debug_draw_spawn_positions(
    mut gizmos: Gizmos,
    stage_registry: Res<StageManifestRegistry>,
    stage_manifests: Res<Assets<StageManifest>>,
    match_config: Res<MatchConfig>,
 ) {
    let Some(stage_manifest_handle) = stage_registry.get(match_config.stage) else {
        return;
    };
    let Some(stage_manifest) = stage_manifests.get(&stage_manifest_handle) else {
        return;
    };
    for spawn_point in stage_manifest.spawn_points.iter() {
        gizmos.cross(FGVec3::new(spawn_point.x, spawn_point.y, FGi32::ZERO).to_vec3(), 2.0, bevy::color::palettes::css::BLUE);
    }
    for respawn_point in stage_manifest.respawn_points.iter() {
        gizmos.cross(FGVec3::new(respawn_point.x, respawn_point.y, FGi32::ZERO).to_vec3(), 2.0, bevy::color::palettes::css::HOT_PINK);
    }
 }
@@ -26,7 +26,7 @@ pub enum StagePolyType {
    Platform,
 }
-#[derive(Reflect, Hash, Debug, Clone, Copy, Default)]
+#[derive(Reflect, Hash, Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub struct StageLineID {
    pub polygon: usize,
    pub segment: usize,
@@ -34,7 +34,7 @@ pub struct StageLineID {
 #[derive(Reflect, Clone, Default)]
 pub struct StagePoly {
-    poly_type: StagePolyType,
+    pub poly_type: StagePolyType,
    pub segments: Vec<StagePolyLineSegment>,
 }
@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use bevy_asset_loader::asset_collection::AssetCollection;
 use ron_asset_manager::prelude::RonAsset;
@@ -7,14 +7,10 @@ use strum::IntoEnumIterator;
 use strum_macros::EnumIter;
 use crate::{
-    AppState,
+    AppState, game_settings::GameSettings, math::{vec::FGVec2}, stage::{
    game_settings::GameSettings,
    math::vec::FGVec2,
    stage::{
        StagePoly,
        line::{StageCollision, StagePolyLineSegmentType, StagePolyType},
-    },
+    }, texture_reference::TextureReference,
    texture_reference::TextureReference,
 };
 use bevy::prelude::*;
@@ -87,6 +83,17 @@ pub struct StageManifest {
    pub icon: TextureReference,
    pub camera: StageCameraProfile,
    pub polygons: Vec<StagePolyDefinition>,
    #[reflect(ignore)]
    pub blast_zone_top_left: FGVec2,
    #[reflect(ignore)]
    pub blast_zone_bottom_right: FGVec2,
    #[reflect(ignore)]
    pub spawn_points: Vec<FGVec2>,
    pub neutral_spawn_point_sets: Vec<Vec<usize>>,
    #[reflect(ignore)]
    pub respawn_points: Vec<FGVec2>,
 }
 #[derive(Resource)]
@@ -162,6 +169,13 @@ pub fn prepare_stage_manifests(
            );
            return;
        }
        if let Err(error) = manifest.validate_spawn_points() {
            fail(
                &mut next_state,
                &format!("{:?} has invalid spawn points: {error}", manifest.id),
            );
            return;
        }
        if registry.insert(manifest.id, handle.clone()).is_some() {
            fail(
                &mut next_state,
@@ -186,6 +200,73 @@ pub fn prepare_stage_manifests(
 }
 impl StageManifest {
    pub fn neutral_spawn_positions(&self, player_count: usize) -> Result<Vec<FGVec2>, String> {
        if player_count == 0 {
            return Err("a match must contain at least one player".to_owned());
        }
        let layout = self
            .neutral_spawn_point_sets
            .get(player_count - 1)
            .ok_or_else(|| format!("no spawn layout for {player_count} players"))?;
        if layout.len() != player_count {
            return Err(format!(
                "the {player_count}-player layout contains {} positions",
                layout.len()
            ));
        }
        layout
            .iter()
            .map(|&index| {
                self.spawn_points.get(index).copied().ok_or_else(|| {
                    format!("the {player_count}-player layout references spawn point {index}")
                })
            })
            .collect()
    }
    fn validate_spawn_points(&self) -> Result<(), String> {
        if self.spawn_points.is_empty() {
            return Err("no spawn points are configured".to_owned());
        }
        if self.respawn_points.is_empty() {
            return Err("no respawn points are configured".to_owned());
        }
        if self.neutral_spawn_point_sets.is_empty() {
            return Err("no neutral spawn layouts are configured".to_owned());
        }
        for (layout_index, layout) in self.neutral_spawn_point_sets.iter().enumerate() {
            let player_count = layout_index + 1;
            if layout.len() != player_count {
                return Err(format!(
                    "the {player_count}-player layout contains {} positions",
                    layout.len()
                ));
            }
            let mut unique_indices = HashSet::with_capacity(layout.len());
            for &spawn_point_index in layout {
                if spawn_point_index >= self.spawn_points.len() {
                    return Err(format!(
                        "the {player_count}-player layout references spawn point {spawn_point_index}"
                    ));
                }
                if !unique_indices.insert(spawn_point_index) {
                    return Err(format!(
                        "the {player_count}-player layout uses spawn point {spawn_point_index} more than once"
                    ));
                }
            }
        }
        Ok(())
    }
    pub fn to_collision(&self) -> StageCollision {
        let stage_polys: Vec<StagePoly> = self
            .polygons
@@ -10,7 +10,7 @@ pub mod scene;
 pub use line::{StagePlaneIntersectResult, StagePoly};
-use crate::stage::{line::StageCollision, manifest::StageCameraProfile};
+use crate::{match_loading::MatchConfig, stage::{line::StageCollision, manifest::StageCameraProfile}};
 /// Owns the stage geometry: which scene gets spawned and how it is drawn.
 #[derive(Default)]
@@ -20,9 +20,17 @@ impl Plugin for StagePlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(
            Update,
-            debug::debug_draw_scene
+            (
                (debug::debug_draw_scene
                    .run_if(resource_exists::<line::StageCollision>)
-                .run_if(crate::debug_tools::stage_collision_enabled),
+                    .run_if(crate::debug_tools::stage_collision_enabled)),
                (debug::debug_draw_blast_zones
                    .run_if(resource_exists::<MatchConfig>)
                    .run_if(crate::debug_tools::blast_zones_enabled),),
                (debug::debug_draw_spawn_positions
                    .run_if(resource_exists::<MatchConfig>)
                    .run_if(crate::debug_tools::spawn_positions_enabled),),
            ),
        );
    }
 }
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 use crate::{
    AppState,
    match_loading::{MatchConfig, MatchRules},
-    match_runtime::MatchState,
+    match_runtime::{MatchState, PauseState},
 };
 pub mod battle_ui;
@@ -11,6 +11,9 @@ pub mod errors;
 pub mod fighter_info;
 pub mod stock_icon;
 #[derive(Component)]
 pub struct PauseOverlay;
 #[derive(Default)]
 pub struct InGameUIPlugin;
@@ -32,6 +35,54 @@ impl Plugin for InGameUIPlugin {
                            }
                    }),
                ),
-            );
+            )
            .add_systems(Update, sync_pause_overlay);
    }
 }
 pub fn sync_pause_overlay(
    pause: Res<PauseState>,
    overlay: Query<Entity, With<PauseOverlay>>,
    mut commands: Commands,
 ) {
    if !pause.is_changed() {
        return;
    }
    if pause.paused {
        if overlay.is_empty() {
            commands.spawn((
                PauseOverlay,
                Node {
                    position_type: PositionType::Absolute,
                    left: px(0),
                    right: px(0),
                    top: px(0),
                    bottom: px(0),
                    align_items: AlignItems::Center,
                    justify_content: JustifyContent::Center,
                    flex_direction: FlexDirection::Column,
                    ..default()
                },
                BackgroundColor(Color::srgba(0.0, 0.0, 0.0, 0.7)),
                ZIndex(100),
                children![
                    (
                        Text::new("Paused"),
                        TextFont::from_font_size(crate::menus::style::H1_SIZE as f32),
                        TextColor(Color::WHITE),
                    ),
                    (
                        Text::new("Press Esc or Start to resume"),
                        TextFont::from_font_size(crate::menus::style::TEXT_SIZE as f32),
                        TextColor(Color::WHITE),
                    ),
                ],
            ));
        }
    } else {
        for entity in &overlay {
            commands.entity(entity).despawn();
        }
    }
 }
Author	SHA1	Message	Date
EIREXE	f8aa76bb52	Fix prod build	2026-10-04 18:51:29 +02:00
EIREXE	a0f6813387	Attack system revamp - Add crouch cancelling - Add IASA for aerial attacks - Add scaffolding for autocancel - Add hitbox group system - Add new ergonomic features for attack scripting - Add more information to the hitbox viewer - Improve the looks of debug capsules	2026-10-04 17:16:42 +02:00
EIREXE	04aceb05a9	Implement hitbox viewer (#81 ) CI / build-and-test (push) Successful in 1m26s Details CI / production-build (push) Successful in 12m55s Details Reviewed-on: #81 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-04 11:32:28 +00:00
EIREXE	02d444f749	Implement invulnerability/intangibility and sakurai angle (#78 ) CI / build-and-test (push) Successful in 1m22s Details CI / production-build (push) Successful in 11m48s Details Reviewed-on: #78 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-03 10:47:00 +00:00
EIREXE	aca3886113	Rework input buffer to match HDR closer (#79 ) CI / build-and-test (push) Successful in 1m24s Details CI / production-build (push) Successful in 11m47s Details ## Summary - Preserve distinct same-action bindings in rollback input frames. - Add independent command lifetimes with tap and state-scoped hold buffering. - Detect second shield bindings and consume shield commands for air dodge. - Fix duplicate keyboard mappings being overwritten. Reviewed-on: #79 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-03 09:20:56 +00:00
EIREXE	47f7ae1e69	Disable GameCube adapter on Windows (#80 ) CI / build-and-test (push) Successful in 1m24s Details CI / production-build (push) Successful in 11m34s Details ## Summary - add a feature flag for the GameCube adapter driver - keep the driver enabled by default on supported platforms - exclude the adapter dependency and polling systems on Windows Reviewed-on: #80 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-02 11:19:01 +00:00
EIREXE	adf83ba03f	Fix match state remaining mutable after and of match and implement initial work on aerials (#77 ) CI / build-and-test (push) Successful in 2m7s Details CI / production-build (push) Successful in 11m36s Details Reviewed-on: #77 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-29 12:40:14 +00:00
EIREXE	88ad9ed951	Implement post-match screen and match finishing. (#76 ) CI / build-and-test (push) Failing after 2m8s Details CI / production-build (push) Successful in 11m40s Details Reviewed-on: #76 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-28 18:29:01 +00:00
EIREXE	3af36c4bc8	Add pulsing effect when invulnerable/intangible, make airdodge make the player intangible. (#75 ) CI / build-and-test (push) Successful in 2m3s Details CI / production-build (push) Successful in 15m42s Details Reviewed-on: #75 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-28 15:44:50 +00:00
EIREXE	ccf2657d29	Fix various minor issues (#74 ) CI / production-build (push) Canceled after 0s Details CI / build-and-test (push) Canceled after 29s Details Reviewed-on: #74 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-28 15:08:39 +00:00
EIREXE	e02dff58e5	Fix bone resampling breaking hitbox interpolation (#73 ) CI / build-and-test (push) Successful in 1m57s Details CI / production-build (push) Successful in 11m37s Details Reviewed-on: #73 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-27 15:52:42 +00:00
EIREXE	6f1d8a7706	Add the ability to respawn and improve controller port mapping (#72 ) CI / build-and-test (push) Successful in 2m2s Details CI / production-build (push) Successful in 12m18s Details Reviewed-on: #72 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-27 11:54:08 +00:00
EIREXE	bb238d2cbc	Add spawn points (#71 ) CI / build-and-test (push) Successful in 2m1s Details CI / production-build (push) Successful in 11m33s Details Reviewed-on: #71 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-27 10:06:55 +00:00
EIREXE	ce00af0809	Add the ability to debug draw blastzones & update blastzone formatting (#69 ) CI / build-and-test (push) Successful in 1m45s Details CI / production-build (push) Successful in 11m22s Details Reviewed-on: #69 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-26 18:05:10 +00:00
EIREXE	0d1b98d406	Implement filled gizmos (#70 ) CI / production-build (push) Canceled after 0s Details CI / build-and-test (push) Canceled after 1m57s Details Reviewed-on: #70 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-26 17:55:35 +00:00
EIREXE	90412fa80d	Add the ability to pause singleplayer matches (#68 ) CI / build-and-test (push) Successful in 1m54s Details CI / production-build (push) Successful in 11m11s Details Reviewed-on: #68 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-26 16:25:36 +00:00
EIREXE	94e292026e	Fix fighter visuals after landing snap (#67 ) CI / build-and-test (push) Successful in 1m47s Details CI / production-build (push) Successful in 11m8s Details ## Summary - Mark landing position corrections as presentation discontinuities. - Render and frame fighters from the current position for the snap frame. - Keep previous translation history unchanged for gameplay collision and attack logic. Reviewed-on: #67 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-26 15:54:25 +00:00
EIREXE	62aa598324	Make triggers be bound to airdodge on non-gamecube controllers (#66 ) CI / build-and-test (push) Successful in 1m51s Details CI / production-build (push) Successful in 11m10s Details Reviewed-on: #66 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-26 13:07:11 +00:00
EIREXE	a58b5eeec7	Allow airborne fighters to pass through platforms while holding down (#65 ) CI / build-and-test (push) Successful in 1m50s Details CI / production-build (push) Canceled after 18s Details ## Summary - Ignore soft-platform collision while an airborne fighter holds down. - Preserve existing momentum and collision with solid floors. - Add regression coverage for soft and solid platform behavior. Reviewed-on: #65 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-26 12:07:38 +00:00
EIREXE	615872f29c	Implement being able to drop through soft platforms (#64 ) CI / build-and-test (push) Successful in 1m47s Details CI / production-build (push) Successful in 10m53s Details Reviewed-on: #64 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-26 10:38:51 +00:00
EIREXE	66a817cd05	Add mechanism to ignore platforms (#63 ) CI / build-and-test (push) Successful in 1m30s Details CI / production-build (push) Successful in 10m48s Details Reviewed-on: #63 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-25 21:43:49 +00:00
EIREXE	946bbc4cbd	Implement crouching (#62 ) CI / build-and-test (push) Successful in 1m29s Details CI / production-build (push) Successful in 10m48s Details Reviewed-on: #62 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-25 18:14:09 +00:00
EIREXE	b56b7b0421	Merge pull request 'Add shifting ECB based on bone positions (melee-like)' (#61 ) from ecb into master CI / build-and-test (push) Successful in 1m32s Details CI / production-build (push) Successful in 11m4s Details Reviewed-on: #61	2026-09-25 14:42:54 +00:00
EIREXE	84e731fbc8	Fix various runtime shenanigans CI / build-and-test (pull_request) Successful in 1m32s Details CI / production-build (pull_request) Successful in 10m22s Details	2026-09-25 16:29:11 +02:00
EIREXE	65727ed04f	Remove gizmo shenanigans	2026-09-25 16:00:21 +02:00
EIREXE	0cb81ec2e9	Add shifting ECB based on bone positions (melee-like) CI / build-and-test (pull_request) Successful in 1m33s Details CI / production-build (pull_request) Successful in 10m48s Details	2026-09-25 15:45:55 +02:00
EIREXE	d521461625	Add authoritative fighter surface state (#60 ) CI / build-and-test (push) Successful in 1m28s Details CI / production-build (push) Successful in 11m59s Details ## Summary - add a rollback-tracked `FighterSurfaceState` as the single source of truth for stage contact - move active stage line ownership out of individual grounded fighter states - update landing, airborne motion, ledge departure, hit reactions, and debug save states to maintain surface contact - add tests for contact lifecycle, connected-segment traversal, and ledge departure Reviewed-on: #60 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-25 10:45:27 +00:00
EIREXE	3daf8f2e21	Fix GameCube poll thread shutdown and error backoff (#55 ) CI / build-and-test (push) Successful in 1m42s Details CI / production-build (push) Successful in 10m57s Details ## Summary - signal GameCube poll thread shutdown unconditionally when the snapshot is dropped - retain and join the poll thread during resource cleanup - add bounded, shutdown-aware backoff for recoverable parse and short-read errors - add unit coverage for backoff capping and shutdown-aware waits Fixes #25 Reviewed-on: #55 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-25 08:04:35 +00:00
EIREXE	aea1cf35ff	Merge pull request 'Fix debug UI not working at all' (#59 ) from ui_fix into master CI / build-and-test (push) Successful in 1m37s Details CI / production-build (push) Successful in 10m55s Details Reviewed-on: #59	2026-09-24 20:56:45 +00:00
EIREXE	2e06cbb4b7	Fix debug UI not working at all CI / build-and-test (pull_request) Successful in 1m30s Details CI / production-build (pull_request) Successful in 10m51s Details	2026-09-24 22:29:34 +02:00
EIREXE	9a3a1383ff	Pin Blender for CI asset processing (#58 ) CI / production-build (push) Successful in 13m8s Details CI / build-and-test (push) Successful in 1m31s Details Reviewed-on: #58 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-24 14:45:37 +00:00
EIREXE	1ba29b817b	Implement .blend asset processor (#56 ) CI / build-and-test (push) Successful in 1m51s Details CI / production-build (push) Successful in 12m11s Details Reviewed-on: #56 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-09-24 10:47:19 +00:00