Implement Melee-style knockback stacking (#97 )

## Summary - stack residual airborne knockback per axis after the configured launch-frame threshold - apply DI after combining the launch vectors while retaining the second hit's hitstun - preserve and decay residual knockback after hitstun - make stacking state rollback-safe and include it in debug save states - clear launch state on landing, ledge interactions, KO, and respawn ## Testing - `cargo check --tests` - `cargo test` (159 tests passed) - `git diff --check` ## Asset configuration For Melee timing, `knockback_stacking_window` should be set to `10`. The local ignored asset package has been updated accordingly. Reviewed-on: #97 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>
Fix hitbox editor and add dair
2026-10-25 21:02:13 +00:00 · 2026-10-22 11:53:38 +02:00 · 2026-10-14 18:33:17 +00:00 · 2026-10-14 06:27:51 +00:00 · 2026-10-13 19:20:29 +00:00 · 2026-10-13 15:52:10 +00:00
58 changed files with 5011 additions and 917 deletions
@@ -516,6 +516,7 @@ checksum = "4bfadbebfc6599aa59289b754ac30023959854304f3d393da2cf62bb3cd5df8f"
 dependencies = [
 "bevy_dylib",
 "bevy_internal",
 "tracing",
 ]
 [[package]]
@@ -531,7 +532,7 @@ dependencies = [
 "bevy_color",
 "bevy_core_pipeline",
 "bevy_ecs",
- "bevy_egui 0.40.1",
+ "bevy_egui",
 "bevy_gizmos",
 "bevy_image",
 "bevy_light",
@@ -549,7 +550,7 @@ dependencies = [
 "bevy_window",
 "bytemuck",
 "disqualified",
- "egui 0.34.3",
+ "egui",
 "fuzzy-matcher",
 "image",
 "opener",
@@ -694,6 +695,7 @@ dependencies = [
 "downcast-rs 2.0.2",
 "log",
 "thiserror 2.0.19",
 "tracing",
 "variadics_please",
 "wasm-bindgen",
 "web-sys",
@@ -1001,6 +1003,7 @@ dependencies = [
 "slotmap",
 "smallvec",
 "thiserror 2.0.19",
 "tracing",
 "variadics_please",
 ]
@@ -1061,55 +1064,7 @@ dependencies = [
 "bevy_winit",
 "bytemuck",
 "crossbeam-channel",
- "egui 0.34.3",
+ "egui",
 "encase",
 "getrandom 0.4.3",
 "image",
 "itertools 0.14.0",
 "js-sys",
 "smithay-clipboard",
 "thread_local",
 "wasm-bindgen",
 "wasm-bindgen-futures",
 "web-sys",
 "webbrowser",
 "wgpu-types",
 "winit",
 ]
 [[package]]
 name = "bevy_egui"
 version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e99e2d018c7e567a268638d3058e57895e914e5650dcf7bd80a5fead9e6413a9"
 dependencies = [
 "arboard",
 "bevy_app",
 "bevy_asset",
 "bevy_camera",
 "bevy_color",
 "bevy_core_pipeline",
 "bevy_derive",
 "bevy_ecs",
 "bevy_image",
 "bevy_input",
 "bevy_log",
 "bevy_math",
 "bevy_mesh",
 "bevy_picking",
 "bevy_platform",
 "bevy_reflect",
 "bevy_render",
 "bevy_shader",
 "bevy_time",
 "bevy_transform",
 "bevy_ui_render",
 "bevy_utils",
 "bevy_window",
 "bevy_winit",
 "bytemuck",
 "crossbeam-channel",
 "egui 0.36.2",
 "encase",
 "getrandom 0.4.3",
 "image",
@@ -1324,7 +1279,7 @@ dependencies = [
 "bitflags 2.13.1",
 "bytemuck",
 "futures-lite",
- "guillotiere 0.6.2",
+ "guillotiere",
 "half",
 "image",
 "ktx2",
@@ -1469,9 +1424,11 @@ dependencies = [
 "bevy_platform",
 "bevy_utils",
 "tracing",
 "tracing-error",
 "tracing-log",
 "tracing-oslog",
 "tracing-subscriber",
 "tracing-tracy",
 "tracing-wasm",
 ]
@@ -1781,9 +1738,11 @@ dependencies = [
 "naga",
 "nonmax",
 "offset-allocator",
 "profiling",
 "send_wrapper",
 "smallvec",
 "thiserror 2.0.19",
 "tracy-client",
 "variadics_please",
 "wasm-bindgen",
 "weak-table",
@@ -2214,17 +2173,6 @@ dependencies = [
 "uuid",
 ]
 [[package]]
 name = "bevygraph"
 version = "0.1.0"
 source = "git+https://github.com/tbillington/bevy_debug_view#0d520f5f4e8693166408f082e8d25dd377dabc3e"
 dependencies = [
 "bevy",
 "bevy_egui 0.42.0",
 "indexmap",
 "log",
 ]
 [[package]]
 name = "bincode"
 version = "1.3.3"
@@ -3041,17 +2989,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a05fbfa222ffb51989d5ccf33e5f7aebfcf96c5023413856b0c3618a7f79896e"
 dependencies = [
 "bytemuck",
- "emath 0.34.3",
+ "emath",
 ]
 [[package]]
 name = "ecolor"
 version = "0.36.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0656a7530b9e2841ee7a5f983965bdd9840c32f4012f759cfd44b912cced6b34"
 dependencies = [
 "bytemuck",
 "emath 0.36.2",
 ]
 [[package]]
@@ -3063,8 +3001,8 @@ dependencies = [
 "accesskit",
 "ahash",
 "bitflags 2.13.1",
- "emath 0.34.3",
+ "emath",
- "epaint 0.34.3",
+ "epaint",
 "log",
 "nohash-hasher",
 "profiling",
@@ -3073,23 +3011,17 @@ dependencies = [
 ]
 [[package]]
-name = "egui"
+name = "egui_extras"
-version = "0.36.2"
+version = "0.34.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc938cc27cd911415e1e4d151bc56ff9df063d8db081374e87aeb805ea74b2ba"
+checksum = "598d8675f6fd9088db8a93d8c7aacda936b2f3d0c2b0660ad1744a45b5caf922"
 dependencies = [
 "accesskit",
 "ahash",
- "bitflags 2.13.1",
+ "egui",
- "emath 0.36.2",
+ "enum-map",
 "epaint 0.36.2",
 "itertools 0.15.0",
 "log",
- "nohash-hasher",
+ "mime_guess2",
 "profiling",
 "smallvec",
 "unicode-segmentation",
 "web-sys",
 ]
 [[package]]
@@ -3107,15 +3039,6 @@ dependencies = [
 "bytemuck",
 ]
 [[package]]
 name = "emath"
 version = "0.36.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52c8d4141cf0f60fb2f7aefaf352d3ffa5171ef0ab09731c64391801e95e48f1"
 dependencies = [
 "bytemuck",
 ]
 [[package]]
 name = "ena"
 version = "0.14.4"
@@ -3156,6 +3079,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"
@@ -3181,9 +3124,9 @@ checksum = "6675898a291ec212fc3df04f537d177fce8496120244590e6359dcaa4c25da79"
 dependencies = [
 "ahash",
 "bytemuck",
- "ecolor 0.34.3",
+ "ecolor",
- "emath 0.34.3",
+ "emath",
- "epaint_default_fonts 0.34.3",
+ "epaint_default_fonts",
 "font-types 0.11.3",
 "log",
 "nohash-hasher",
@@ -3192,32 +3135,7 @@ dependencies = [
 "self_cell",
 "skrifa 0.40.0",
 "smallvec",
- "vello_cpu 0.0.6",
+ "vello_cpu",
 ]
 [[package]]
 name = "epaint"
 version = "0.36.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0ec0308dc23130fc1a7d4623a8534c2ed069c6dc84e258ee4f3de99615aa1a3"
 dependencies = [
 "ahash",
 "bytemuck",
 "ecolor 0.36.2",
 "emath 0.36.2",
 "epaint_default_fonts 0.36.2",
 "font-types 0.12.2",
 "harfrust 0.12.0",
 "log",
 "nohash-hasher",
 "parking_lot",
 "profiling",
 "self_cell",
 "skrifa 0.44.0",
 "smallvec",
 "unicode-general-category",
 "unicode-segmentation",
 "vello_cpu 0.1.0",
 ]
 [[package]]
@@ -3226,12 +3144,6 @@ version = "0.34.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8970033a4282a7bcf899b38b5ed3a58b732fe093d03785d58648515d8d309da"
 [[package]]
 name = "epaint_default_fonts"
 version = "0.36.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773fa9c96dd0dbef887e39d0ed6177f141cce4d68e6041df77570aa3702dfa13"
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -3324,12 +3236,6 @@ dependencies = [
 "bytemuck",
 ]
 [[package]]
 name = "fearless_simd"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b97b65636e5b9ef369943878ac74335ba1c55c1cb6adbf1e2c293c624248d693"
 [[package]]
 name = "file-id"
 version = "0.2.3"
@@ -3564,6 +3470,21 @@ dependencies = [
 "rusb",
 ]
 [[package]]
 name = "generator"
 version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "54ade96dc9003043bce7c035c85a9df5a858bfb2039c5a2e6fdf00f324f6c551"
 dependencies = [
 "cc",
 "cfg-if",
 "libc",
 "log",
 "rustversion",
 "windows-link",
 "windows-result",
 ]
 [[package]]
 name = "gethostname"
 version = "1.1.0"
@@ -3715,22 +3636,6 @@ dependencies = [
 "simba",
 ]
 [[package]]
 name = "glifo"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed4a1bb24121291d27230c1b1b44e07d6a9b28cefdb32fe1581dfb84e14f940a"
 dependencies = [
 "bytemuck",
 "foldhash 0.2.0",
 "hashbrown 0.17.1",
 "log",
 "peniko",
 "skrifa 0.44.0",
 "smallvec",
 "vello_common 0.1.0",
 ]
 [[package]]
 name = "glow"
 version = "0.17.0"
@@ -3841,15 +3746,6 @@ dependencies = [
 "svg_fmt",
 ]
 [[package]]
 name = "guillotiere"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b17e70c989c36bad147b27a58d148c0741c51448aa5653436547323e524d0ab"
 dependencies = [
 "euclid",
 ]
 [[package]]
 name = "half"
 version = "2.7.1"
@@ -3876,18 +3772,6 @@ dependencies = [
 "smallvec",
 ]
 [[package]]
 name = "harfrust"
 version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c03d949a14aa089bbb282f7dd76a498a7f684428e4257202efc119ec010376f9"
 dependencies = [
 "bitflags 2.13.1",
 "bytemuck",
 "read-fonts 0.41.0",
 "smallvec",
 ]
 [[package]]
 name = "hash32"
 version = "0.3.1"
@@ -4519,6 +4403,19 @@ version = "0.4.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
 [[package]]
 name = "loom"
 version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca"
 dependencies = [
 "cfg-if",
 "generator",
 "scoped-tls",
 "tracing",
 "tracing-subscriber",
 ]
 [[package]]
 name = "mach2"
 version = "0.5.0"
@@ -4552,6 +4449,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"
@@ -5370,7 +5285,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8fad031076f48f0d4d85ce1aea9b94b4e715a4d636a030a123038f8f5b5e4343"
 dependencies = [
 "fontique",
- "harfrust 0.6.2",
+ "harfrust",
 "hashbrown 0.17.1",
 "icu_normalizer",
 "icu_properties",
@@ -5497,6 +5412,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"
@@ -5705,6 +5664,20 @@ name = "profiling"
 version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5"
 dependencies = [
 "profiling-procmacros",
 "tracing",
 ]
 [[package]]
 name = "profiling-procmacros"
 version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4488a4a36b9a4ba6b9334a32a39971f77c1436ec82c38707bce707699cc3bbcb"
 dependencies = [
 "quote",
 "syn 2.0.119",
 ]
 [[package]]
 name = "pxfm"
@@ -6272,18 +6245,19 @@ dependencies = [
 "bevy",
 "bevy-inspector-egui",
 "bevy_asset_loader",
- "bevy_egui 0.40.1",
+ "bevy_egui",
 "bevy_ggrs",
 "bevygraph",
 "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",
@@ -6335,6 +6309,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"
@@ -6898,6 +6878,16 @@ dependencies = [
 "valuable",
 ]
 [[package]]
 name = "tracing-error"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b1581020d7a273442f5b45074a6a57d5757ad0a47dac0e9f0bd57b81936f3db"
 dependencies = [
 "tracing",
 "tracing-subscriber",
 ]
 [[package]]
 name = "tracing-log"
 version = "0.2.0"
@@ -6939,6 +6929,17 @@ dependencies = [
 "tracing-log",
 ]
 [[package]]
 name = "tracing-tracy"
 version = "0.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eaa1852afa96e0fe9e44caa53dc0bd2d9d05e0f2611ce09f97f8677af56e4ba"
 dependencies = [
 "tracing-core",
 "tracing-subscriber",
 "tracy-client",
 ]
 [[package]]
 name = "tracing-wasm"
 version = "0.2.1"
@@ -6950,6 +6951,27 @@ dependencies = [
 "wasm-bindgen",
 ]
 [[package]]
 name = "tracy-client"
 version = "0.18.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6131992ff3e2cb96f407eb4eb005427ba15e2687260d99089b90e60e33169ce0"
 dependencies = [
 "loom",
 "once_cell",
 "tracy-client-sys",
 ]
 [[package]]
 name = "tracy-client-sys"
 version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab27f167b093214c68413a2e0bcd318f0591af475597405ff68138ba0a433379"
 dependencies = [
 "cc",
 "windows-targets 0.52.6",
 ]
 [[package]]
 name = "tree_magic_mini"
 version = "3.2.2"
@@ -6992,10 +7014,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "214ca0b2191785cbc06209b9ca1861e048e39b5ba33574b3cedd58363d5bb5f6"
 [[package]]
-name = "unicode-general-category"
+name = "unicase"
-version = "1.1.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b993bddc193ae5bd0d623b49ec06ac3e9312875fdae725a975c51db1cc1677f"
+checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
 [[package]]
 name = "unicode-ident"
@@ -7105,7 +7127,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bd1a4c633ce09e7d713df1a6e036644a125e15e0c169cfb5180ddf5836ca04b"
 dependencies = [
 "bytemuck",
- "fearless_simd 0.3.0",
+ "fearless_simd",
 "hashbrown 0.16.1",
 "log",
 "peniko",
@@ -7113,21 +7135,6 @@ dependencies = [
 "smallvec",
 ]
 [[package]]
 name = "vello_common"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b2e9aed918117e8152c9eddfd8362d73c465c23f26c44786aa331707b8a64fa2"
 dependencies = [
 "bytemuck",
 "fearless_simd 0.4.1",
 "guillotiere 0.7.0",
 "log",
 "peniko",
 "smallvec",
 "thiserror 2.0.19",
 ]
 [[package]]
 name = "vello_cpu"
 version = "0.0.6"
@@ -7136,19 +7143,7 @@ checksum = "0162bfe48aabf6a9fdcd401b628c7d9f260c2cbabb343c70a65feba6f7849edc"
 dependencies = [
 "bytemuck",
 "hashbrown 0.16.1",
- "vello_common 0.0.6",
+ "vello_common",
 ]
 [[package]]
 name = "vello_cpu"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac7349e1f55f6b801c7c277958df4ea53e7f20f21e8014910ad888b2ecda93ea"
 dependencies = [
 "bytemuck",
 "glifo",
 "hashbrown 0.17.1",
 "vello_common 0.1.0",
 ]
 [[package]]
@@ -8,23 +8,23 @@ authors = [""]
 [features]
 default = ["development", "debug_features", "gamecube-adapter"]
-development = ["bevy/dynamic_linking", "bevy/file_watcher", "bevy/embedded_watcher"]
+development = ["bevy/dynamic_linking", "bevy/file_watcher", "bevy/embedded_watcher", "hitbox-viewer"]
 tracy = ["bevy/trace_tracy"]
 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.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" }
 bevygraph = { git = "https://github.com/tbillington/bevy_debug_view" }
 serde = "1.0.229"
 serde_json = "1.0.145"
 bincode = "1.3.3"
@@ -53,3 +53,8 @@ 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"]
@@ -116,6 +116,7 @@ enum DebugFlag {
    AttackHitboxes,
    Hurtboxes,
    Camera,
    LedgeGrab,
    DrawThroughGeometry,
    FrameStepping,
 }
@@ -164,6 +165,10 @@ const FIGHTER_MENU: &[DebugMenuEntry] = &[
        label: "Attack hitboxes",
        flag: DebugFlag::AttackHitboxes,
    },
    DebugMenuEntry::Toggle {
        label: "Ledge grab",
        flag: DebugFlag::LedgeGrab,
    },
    DebugMenuEntry::Toggle {
        label: "Hurtboxes",
        flag: DebugFlag::Hurtboxes,
@@ -260,6 +265,7 @@ pub struct DebugSettings {
    pub attack_hitboxes: bool,
    pub hurtboxes: bool,
    pub camera: bool,
    pub ledge_grab: bool,
    pub draw_through_geometry: bool,
    pub motion_sampling: PresentationMotionMode,
    pub game_speed: GameSpeedDebug,
@@ -283,6 +289,7 @@ impl Default for DebugSettings {
            attack_hitboxes: false,
            hurtboxes: false,
            camera: false,
            ledge_grab: false,
            draw_through_geometry: false,
            motion_sampling: PresentationMotionMode::default(),
            game_speed: GameSpeedDebug::Full,
@@ -350,6 +357,7 @@ impl DebugSettings {
            DebugFlag::Hurtboxes => self.hurtboxes,
            DebugFlag::DrawThroughGeometry => self.draw_through_geometry,
            DebugFlag::Camera => self.camera,
            DebugFlag::LedgeGrab => self.ledge_grab,
            DebugFlag::FrameStepping => self.frame_stepping,
        }
    }
@@ -368,6 +376,7 @@ impl DebugSettings {
                self.draw_through_geometry = !self.draw_through_geometry
            }
            DebugFlag::Camera => self.camera = !self.camera,
            DebugFlag::LedgeGrab => self.ledge_grab = !self.ledge_grab,
            DebugFlag::FrameStepping => self.frame_stepping = !self.frame_stepping,
        }
    }
@@ -926,6 +935,10 @@ pub fn camera_debug_enabled(settings: Res<DebugSettings>) -> bool {
    settings.camera
 }
 pub fn ledge_grab_enabled(settings: Res<DebugSettings>) -> bool {
    settings.ledge_grab
 }
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -1,12 +1,26 @@
 use bevy::prelude::*;
 use crate::{
-    camera::MatchCamera, fighter::{
+    camera::MatchCamera,
-        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterInvulnerabilityState, FighterPendingRespawn, FighterPreviousFacingDirection, FighterPreviousTranslation, FighterSurfaceState, FighterTranslation, FighterVelocity, animation::FighterAnimationFrame, attack::{
+    fighter::{
-            FighterDamage, FighterKnockbackVelocity, FighterPendingHitReaction, FighterPendingHits,
+        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake,
-            FighterSolvedHurtboxes, FighterStaleMoveQueue,
+        FighterInvulnerabilityState, FighterLedgeInformation, FighterPendingRespawn,
-        }, baked_animation::FighterBoneMatrices, state::FighterState,
+        FighterPreviousFacingDirection, FighterPreviousTranslation, FighterSurfaceState,
-    }, input::FighterInput, match_runtime::MatchState, player::Player, stage::line::StageCollision,
+        FighterTranslation, FighterVelocity,
        animation::FighterAnimationFrame,
        attack::{
            FighterDamage, FighterKnockbackState, FighterKnockbackVelocity,
            FighterPendingHitReaction, FighterPendingHits, FighterSolvedHurtboxes,
            FighterStaleMoveQueue,
        },
        baked_animation::FighterBoneMatrices,
        ecb::FighterDesiredECB,
        state::FighterState,
    },
    input::FighterInput,
    match_runtime::MatchState,
    player::Player,
    stage::line::StageCollision,
 };
 #[derive(Resource, Default)]
@@ -27,6 +41,7 @@ struct FighterCheckpoint {
    entity: Entity,
    handle: usize,
    ecb: FighterECB,
    desired_ecb: FighterDesiredECB,
    previous_ecb: crate::fighter::ecb::FighterPreviousECB,
    velocity: FighterVelocity,
    translation: FighterTranslation,
@@ -41,6 +56,7 @@ struct FighterCheckpoint {
    hitstop: FighterHitstop,
    hitstop_shake: FighterHitstopShake,
    knockback_velocity: FighterKnockbackVelocity,
    knockback_state: FighterKnockbackState,
    stale_moves: FighterStaleMoveQueue,
    hitboxes: FighterHitboxes,
    solved_hurtboxes: FighterSolvedHurtboxes,
@@ -48,6 +64,7 @@ struct FighterCheckpoint {
    surface: FighterSurfaceState,
    pending_respawn: FighterPendingRespawn,
    invulnerability_state: FighterInvulnerabilityState,
    ledge_information: FighterLedgeInformation,
 }
 pub(super) fn save_or_restore(world: &mut World) {
@@ -130,6 +147,7 @@ pub(super) fn save_or_restore(world: &mut World) {
        let mut entity = world.entity_mut(saved.entity);
        entity.insert(saved.ecb);
        entity.insert(saved.desired_ecb);
        entity.insert(saved.previous_ecb);
        entity.insert(saved.velocity);
        entity.insert(saved.translation);
@@ -144,6 +162,7 @@ pub(super) fn save_or_restore(world: &mut World) {
        entity.insert(saved.hitstop);
        entity.insert(saved.hitstop_shake);
        entity.insert(saved.knockback_velocity);
        entity.insert(saved.knockback_state);
        entity.insert(saved.stale_moves.clone());
        entity.insert(saved.hitboxes.clone());
        entity.insert(saved.solved_hurtboxes.clone());
@@ -151,6 +170,7 @@ pub(super) fn save_or_restore(world: &mut World) {
        entity.insert(saved.surface.clone());
        entity.insert(saved.pending_respawn.clone());
        entity.insert(saved.invulnerability_state.clone());
        entity.insert(saved.ledge_information.clone());
    }
    world.insert_resource(checkpoint.pending_hits.clone());
    world.insert_resource(checkpoint.stage_collision);
@@ -167,6 +187,7 @@ fn capture_fighter(world: &World, entity: Entity) -> Option<FighterCheckpoint> {
        entity,
        handle: fighter.get::<Player>()?.handle,
        ecb: *fighter.get::<FighterECB>()?,
        desired_ecb: *fighter.get::<FighterDesiredECB>()?,
        previous_ecb: *fighter.get::<crate::fighter::ecb::FighterPreviousECB>()?,
        velocity: *fighter.get::<FighterVelocity>()?,
        translation: *fighter.get::<FighterTranslation>()?,
@@ -181,6 +202,7 @@ fn capture_fighter(world: &World, entity: Entity) -> Option<FighterCheckpoint> {
        hitstop: *fighter.get::<FighterHitstop>()?,
        hitstop_shake: *fighter.get::<FighterHitstopShake>()?,
        knockback_velocity: *fighter.get::<FighterKnockbackVelocity>()?,
        knockback_state: *fighter.get::<FighterKnockbackState>()?,
        stale_moves: fighter.get::<FighterStaleMoveQueue>()?.clone(),
        hitboxes: fighter.get::<FighterHitboxes>()?.clone(),
        solved_hurtboxes: fighter.get::<FighterSolvedHurtboxes>()?.clone(),
@@ -188,6 +210,7 @@ fn capture_fighter(world: &World, entity: Entity) -> Option<FighterCheckpoint> {
        surface: fighter.get::<FighterSurfaceState>()?.clone(),
        pending_respawn: fighter.get::<FighterPendingRespawn>()?.clone(),
        invulnerability_state: fighter.get::<FighterInvulnerabilityState>()?.clone(),
        ledge_information: fighter.get::<FighterLedgeInformation>()?.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,
        )
    }
 }
@@ -87,6 +87,10 @@ pub enum AnimKind {
    CrouchEnter,
    CrouchIdle,
    CrouchExit,
    LedgeWait,
    LedgeJump,
    LedgeGetUp,
    LedgeGrab,
    PlatformPass,
@@ -100,4 +104,7 @@ pub enum AnimKind {
    AttackDownTilt,
    AttackNeutralAir,
    AttackForwardAir,
    AttackDownAir,
    AttackDash,
    AttackUpSmash,
 }
@@ -15,6 +15,16 @@ pub fn apply_directional_influence(
    let (sin, cos) = attack_angle.sin_cos();
    let base_launch_direction = FGVec2::new(cos, sin);
    apply_directional_influence_to_direction(receiver_stick, base_launch_direction, di_max_angle)
 }
 /// Applies DI to an already-computed launch direction. This is used after
 /// knockback stacking, where the resulting angle may differ from either hit.
 pub fn apply_directional_influence_to_direction(
    receiver_stick: FGVec2,
    base_launch_direction: FGVec2,
    di_max_angle: FGi32,
 ) -> FGVec2 {
    let Some(base_launch_direction) = base_launch_direction.normalize() else {
        return FGVec2::ZERO;
    };
@@ -30,14 +40,20 @@ pub fn apply_directional_influence(
        -di_max_angle.to_fixed::<FGWide>(),
        di_max_angle.to_fixed::<FGWide>(),
    );
-    let (sin, cos) = (attack_angle + angle_change.to_fixed::<FGi32>()).sin_cos();
+    let (sin, cos) = angle_change.to_fixed::<FGi32>().sin_cos();
-    FGVec2::new(cos, sin).normalize_or_zero()
+    FGVec2::new(
        base_launch_direction.x * cos - base_launch_direction.y * sin,
        base_launch_direction.x * sin + base_launch_direction.y * cos,
    )
    .normalize_or_zero()
 }
 #[cfg(test)]
 mod test {
    use crate::{
-        fighter::attack::directional_influence::apply_directional_influence,
+        fighter::attack::directional_influence::{
            apply_directional_influence, apply_directional_influence_to_direction,
        },
        math::{int::FGi32, vec::FGVec2},
    };
@@ -66,4 +82,17 @@ mod test {
        assert!(di.x > FGi32::ZERO);
        assert!(di.y < FGi32::ZERO);
    }
    #[test]
    fn vector_di_preserves_a_stacked_direction_without_input() {
        let direction = FGVec2::lit("-0.6", "0.8");
        let result = apply_directional_influence_to_direction(
            FGVec2::ZERO,
            direction,
            FGi32::lit("18.0"),
        );
        const EPSILON: FGi32 = FGi32::from_bits(6);
        assert!(result.x.abs_diff(direction.x) < EPSILON);
        assert!(result.y.abs_diff(direction.y) < EPSILON);
    }
 }
@@ -33,7 +33,76 @@ 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)]
+/// Lifecycle state for the currently active launch velocity.
 ///
 /// This counts frames where knockback was actually applied to movement; hitstop
 /// therefore does not advance it. Melee uses this age to decide whether a
 /// subsequent airborne hit replaces or stacks with the previous launch.
 #[derive(Component, Default, Hash, Debug, Copy, Clone)]
 pub struct FighterKnockbackState {
    pub frames_since_launch: u32,
 }
 impl FighterKnockbackState {
    pub fn restart(&mut self) {
        self.frames_since_launch = 0;
    }
    pub fn clear(&mut self) {
        self.frames_since_launch = 0;
    }
    pub fn advance(&mut self) {
        self.frames_since_launch = self.frames_since_launch.saturating_add(1);
    }
    pub fn can_stack(&self, minimum_frames: u32) -> bool {
        self.frames_since_launch >= minimum_frames
    }
 }
 fn stack_knockback_component(previous: FGi32, new: FGi32) -> FGi32 {
    if previous.is_zero() {
        return new;
    }
    if new.is_zero() {
        return previous;
    }
    if previous.signum() != new.signum() {
        previous + new
    } else if previous.abs() > new.abs() {
        previous
    } else {
        new
    }
 }
 /// Applies Melee's knockback-stacking rule independently to both axes.
 pub fn stack_knockback(previous: FGVec2, new: FGVec2) -> FGVec2 {
    FGVec2::new(
        stack_knockback_component(previous.x, new.x),
        stack_knockback_component(previous.y, new.y),
    )
 }
 pub fn decay_knockback(
    velocity: &mut FighterKnockbackVelocity,
    state: &mut FighterKnockbackState,
    decay_per_frame: FGi32,
 ) {
    let speed = velocity.length();
    let next_speed = speed.saturating_sub(decay_per_frame).max(FGi32::ZERO);
    velocity.0 = velocity.normalize_or_zero() * next_speed;
    if next_speed.is_zero() {
        state.clear();
    } else {
        state.advance();
    }
 }
 #[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Component, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct FighterDamage(FGi32);
 impl std::fmt::Display for FighterDamage {
@@ -52,7 +121,8 @@ pub enum HitReactionKind {
 pub struct FighterHitReaction {
    pub launch_velocity: FGi32,
    pub launch_angle: FGi32,
-    pub hitstop_frames: HitStop,
+    pub victim_hitstop_frames: HitStop,
    pub attacker_hitstop_frames: HitStop,
    pub hitstun_frames: u32,
    pub kind: HitReactionKind,
    pub damage: FighterDamage,
@@ -72,6 +142,53 @@ pub struct FighterLastAttackDebug {
    pub trajectory_points: Vec<Vec3>,
 }
 #[cfg(test)]
 mod knockback_stacking_tests {
    use super::*;
    #[test]
    fn same_direction_keeps_the_stronger_component() {
        assert_eq!(
            stack_knockback(FGVec2::lit("3", "8"), FGVec2::lit("5", "4")),
            FGVec2::lit("5", "8")
        );
    }
    #[test]
    fn opposing_components_add_independently() {
        assert_eq!(
            stack_knockback(FGVec2::lit("3", "8"), FGVec2::lit("-5", "-3")),
            FGVec2::lit("-2", "5")
        );
    }
    #[test]
    fn opposing_components_can_cancel() {
        assert_eq!(
            stack_knockback(FGVec2::lit("3", "-4"), FGVec2::lit("-3", "4")),
            FGVec2::ZERO
        );
    }
    #[test]
    fn zero_components_preserve_the_nonzero_value() {
        assert_eq!(
            stack_knockback(FGVec2::lit("0", "2"), FGVec2::lit("-3", "0")),
            FGVec2::lit("-3", "2")
        );
    }
    #[test]
    fn stacking_threshold_is_inclusive() {
        let mut state = FighterKnockbackState {
            frames_since_launch: 9,
        };
        assert!(!state.can_stack(10));
        state.advance();
        assert!(state.can_stack(10));
    }
 }
 #[derive(Debug, Default, Clone, Deref, DerefMut, Hash, PartialEq, PartialOrd)]
 pub struct HitStop(u32);
@@ -80,7 +197,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 {
@@ -97,6 +214,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,
@@ -113,9 +236,15 @@ impl KnockbackType {
    }
 }
-#[derive(Debug, Default, Clone, Copy, 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))
@@ -144,6 +273,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"))
@@ -175,6 +313,13 @@ impl AttackAngle {
            },
        }
    }
    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)]
@@ -192,6 +337,7 @@ pub enum AttackKind {
    UpSmash,
    DownSmash,
    ForwardSmash,
    DashAttack,
 }
 impl AttackKind {
@@ -201,14 +347,15 @@ impl AttackKind {
            AttackKind::Jab => AnimKind::AttackJab1,
            AttackKind::UpTilt => AnimKind::AttackUpTilt,
            AttackKind::ForwardAir => AnimKind::AttackForwardAir,
            AttackKind::DownAir => AnimKind::AttackDownAir,
            AttackKind::BackAir => AnimKind::AttackUpTilt,
            AttackKind::DownAir => AnimKind::AttackUpTilt,
            AttackKind::UpAir => AnimKind::AttackUpTilt,
            AttackKind::DownTilt => AnimKind::AttackDownTilt,
            AttackKind::ForwardTilt => AnimKind::AttackForwardTilt,
-            AttackKind::UpSmash => AnimKind::AttackUpTilt,
+            AttackKind::UpSmash => AnimKind::AttackUpSmash,
            AttackKind::DownSmash => AnimKind::AttackUpTilt,
            AttackKind::ForwardSmash => AnimKind::AttackUpTilt,
            AttackKind::DashAttack => AnimKind::AttackDash,
        }
    }
 }
@@ -217,6 +364,7 @@ impl AttackKind {
 #[reflect(opaque)]
 pub struct AttackHitbox {
    pub id: u32,
    pub group: u32,
    pub bone: String,
    pub damage: FighterDamage,
    pub offset: FGVec3,
@@ -229,6 +377,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)]
@@ -276,6 +432,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());
@@ -369,6 +529,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,
@@ -571,10 +761,6 @@ pub fn intersect_attacks_with_hurtboxes(
            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");
@@ -584,6 +770,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
@@ -606,7 +801,14 @@ pub fn intersect_attacks_with_hurtboxes(
                hitbox_index: 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);
            }
        }
    }
 }
@@ -4,7 +4,7 @@ use bevy_ggrs::prelude::GgrsSchedule;
 use super::*;
 use crate::{
    fighter::{
-        Fighter, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake,
+        Fighter, FighterHitboxes, FighterHitstop, FighterHitstopShake,
        FighterHitstopShakeKind, FighterHitstopShakeRole, FighterPendingHitReaction,
        FighterStaleMoveQueue, FighterSurfaceState, errors::FighterErrors,
        manifest::FighterManifest, state::FighterState,
@@ -20,11 +20,11 @@ pub fn resolve_fighter_hits(
    mut pending_hits: ResMut<FighterPendingHits>,
    mut attacker: Query<(
        &mut FighterStaleMoveQueue,
        &FighterFacingDirection,
        &mut FighterHitboxes,
        &Player,
        &mut FighterHitstop,
        &mut FighterHitstopShake,
        &FighterTranslation,
    )>,
    mut receiver: Query<(
        &mut FighterDamage,
@@ -33,6 +33,7 @@ pub fn resolve_fighter_hits(
        &FighterState,
        &FighterInvulnerabilityState,
        &FighterSurfaceState,
        &FighterTranslation,
    )>,
    attack_scripts: Res<Assets<FighterAttackScript>>,
    game_settings: Res<GameSettings>,
@@ -55,6 +56,7 @@ pub fn resolve_fighter_hits(
            receiver_state,
            invuln_state,
            receiver_surface_state,
            receiver_translation,
        )) = receiver.get_mut(defender)
        else {
            hit_offset = next_defender;
@@ -64,7 +66,7 @@ pub fn resolve_fighter_hits(
        let damage_data = hits[hit_offset..next_defender]
            .iter()
            .filter_map(|hit| {
-                let Ok((stale_move_queue, facing_dir, _, player, _, _)) =
+                let Ok((stale_move_queue, _, player, _, _, attacker_translation)) =
                    attacker.get(hit.attacker)
                else {
                    return None;
@@ -74,12 +76,13 @@ pub fn resolve_fighter_hits(
                let damage_received = stale_move_queue
                    .get_attack_damage_multiplier(hit.attack_kind)
                    * hitbox.damage.0;
                let angle_flip = receiver_translation.0.x <= attacker_translation.0.x;
                Some((
                    hit.attacker,
                    damage_received,
                    hitbox,
                    matches!(facing_dir, FighterFacingDirection::Left),
                    player.handle,
                    angle_flip,
                ))
            })
            .collect::<Vec<_>>();
@@ -93,28 +96,35 @@ pub fn resolve_fighter_hits(
            .ok_or(FighterErrors::FighterManifestNotFound)?;
        let mut reactions = Vec::with_capacity(damage_data.len());
-        for (attacker_entity, attack_damage, hitbox, facing_left, attacker_slot) in damage_data {
+        let crouch_canceling = if let FighterState::Crouch(crouch_state) = &receiver_state {
            crouch_state.is_crouch_cancelling()
        } else {
            false
        };
        for (attacker_entity, attack_damage, hitbox, attacker_slot, angle_flip) in damage_data {
            let knockback = hitbox.calculate_knockback(
                &fighter_manifest.attributes,
                *receiver_damage,
                FighterDamage(total_damage_received_this_frame),
                false,
-                false,
+                crouch_canceling,
            );
-            let angle = hitbox.angle.get_angle(
+            let launch_angle = hitbox.angle.get_angle(
                &knockback,
                receiver_surface_state.is_grounded(),
                &game_settings,
            );
-            dbg!(knockback, angle);
+
-            let launch_angle = if facing_left {
+            let launch_angle = if angle_flip {
-                FGi32::lit("180.0") - angle
+                FGi32::lit("180.0") - launch_angle
            } else {
-                angle
+                launch_angle
            };
            // Attacker hitstop and data
-            let hitstop = HitStop::calculate(FighterDamage(attack_damage), false);
+            let victim_hitstop_frames = HitStop::calculate(FighterDamage(attack_damage), crouch_canceling);
            let attacker_hitstop_frames = HitStop::calculate(FighterDamage(attack_damage), false);
            reactions.push((
                attacker_entity,
                attacker_slot,
@@ -122,7 +132,8 @@ pub fn resolve_fighter_hits(
                    launch_velocity: knockback.get_launch_speed(&game_settings),
                    launch_angle,
                    hitstun_frames: knockback.get_hitstun_frames(&game_settings),
-                    hitstop_frames: hitstop,
+                    victim_hitstop_frames,
                    attacker_hitstop_frames,
                    kind: HitReactionKind::Flinch,
                    damage: FighterDamage(attack_damage),
                },
@@ -137,20 +148,20 @@ pub fn resolve_fighter_hits(
        }
        for (attacker_entity, _, reaction) in &reactions {
-            let Ok((.., _, mut hitstop, mut hitstop_shake)) = attacker.get_mut(*attacker_entity)
+            let Ok((.., _, mut hitstop, mut hitstop_shake, _)) = attacker.get_mut(*attacker_entity)
            else {
                continue;
            };
-            if hitstop.remaining_frames < reaction.hitstop_frames.0 {
+            if hitstop.remaining_frames < reaction.attacker_hitstop_frames.0 {
                let shake_kind = if receiver_state.is_visually_grounded() {
                    FighterHitstopShakeKind::Horizontal
                } else {
                    FighterHitstopShakeKind::Vertical
                };
-                hitstop.remaining_frames = reaction.hitstop_frames.0;
+                hitstop.remaining_frames = reaction.attacker_hitstop_frames.0;
                let shake_frames = reaction
-                    .hitstop_frames
+                    .attacker_hitstop_frames
                    .calculate_shake_frames(&game_settings);
                hitstop_shake.total_frames = shake_frames;
                hitstop_shake.remaining_frames = shake_frames;
@@ -173,7 +184,7 @@ pub fn resolve_fighter_hits(
    }
    for hit in hits {
-        let Ok((mut stale_move_queue, _facing_direction, mut hitboxes, ..)) =
+        let Ok((mut stale_move_queue, mut hitboxes, ..)) =
            attacker.get_mut(hit.attacker)
        else {
            continue;
@@ -9,6 +9,10 @@ use crate::{input::FighterInputFrame, math::int::FGi32};
 #[derive(Asset, Clone, Copy, Reflect, Serialize, Deserialize)]
 #[reflect(opaque)]
 pub struct FighterAttributes {
    /// Fixed horizontal offset of the fighter's grounded pushbox center.
    pub pushbox_offset: FGi32,
    /// Fixed horizontal radius used for grounded fighter-to-fighter pushing.
    pub pushbox_radius: FGi32,
    pub base_walk_accel: FGi32,
    pub stick_walk_accel: FGi32,
    pub max_walk_vel: FGi32,
@@ -47,6 +51,8 @@ pub struct FighterAttributes {
    pub air_dodge_intangible_duration: u32,
    pub air_dodge_intangible_start: u32,
    pub dash_attack_cancel_window: u32,
 }
 impl FighterAttributes {
@@ -54,6 +60,9 @@ impl FighterAttributes {
        if self.weight <= FGi32::ZERO {
            return Err("weight must be positive".into());
        }
        if self.pushbox_radius <= FGi32::ZERO {
            return Err("pushbox radius must be positive".into());
        }
        Ok(())
    }
@@ -27,6 +27,7 @@ struct FighterBakeSource {
    model_bytes: Vec<u8>,
    buffers: Vec<Vec<u8>>,
    animations: HashMap<AnimKind, String>,
    root_motion_bone: String,
 }
 #[derive(Default, TypePath)]
 struct FighterBakeSourceLoader;
@@ -82,6 +83,7 @@ impl AssetLoader for FighterBakeSourceLoader {
            model_bytes,
            buffers,
            animations: manifest.animations,
            root_motion_bone: manifest.root_motion_bone,
        })
    }
    fn extensions(&self) -> &[&str] {
@@ -123,7 +125,12 @@ impl AssetTransformer for FighterBakeTransformer {
        source: TransformedAsset<Self::AssetInput>,
        _: &'a Self::Settings,
    ) -> Result<TransformedAsset<Self::AssetOutput>, Self::Error> {
-        let baked = bake_gltf(&source.model_bytes, &source.buffers, &source.animations)?;
+        let baked = bake_gltf(
            &source.model_bytes,
            &source.buffers,
            &source.animations,
            &source.root_motion_bone,
        )?;
        Ok(source.replace_asset(baked))
    }
 }
@@ -201,6 +208,7 @@ fn bake_gltf(
    bytes: &[u8],
    buffer_bytes: &[Vec<u8>],
    animations: &HashMap<AnimKind, String>,
    root_motion_bone: &str,
 ) -> io::Result<BakedFighterAnimations> {
    let gltf = gltf::Gltf::from_slice(bytes)
        .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
@@ -228,13 +236,14 @@ fn bake_gltf(
            "glTF buffer data is incomplete",
        ));
    }
-    bake_gltf_document(gltf.document, buffers, animations)
+    bake_gltf_document(gltf.document, buffers, animations, root_motion_bone)
 }
 pub(super) fn bake_gltf_document(
    document: gltf::Document,
    buffers: Vec<gltf::buffer::Data>,
    animations: &HashMap<AnimKind, String>,
    root_motion_bone: &str,
 ) -> io::Result<BakedFighterAnimations> {
    let nodes: Vec<_> = document.nodes().collect();
    if nodes.is_empty() {
@@ -260,6 +269,15 @@ pub(super) fn bake_gltf_document(
            })
        })
        .collect::<io::Result<Vec<_>>>()?;
    let root_bone_index = names
        .iter()
        .position(|name| name == root_motion_bone)
        .ok_or_else(|| {
            io::Error::new(
                io::ErrorKind::InvalidData,
                format!("fighter model has no root-motion bone named {root_motion_bone}"),
            )
        })?;
    let mut pending = HashMap::<&str, Vec<AnimKind>>::new();
    for (kind, name) in animations {
        pending.entry(name).or_default().push(*kind);
@@ -286,17 +304,28 @@ pub(super) fn bake_gltf_document(
            .fold(0.0_f32, f32::max);
        let frame_count = baked_frame_count(duration, BAKED_ANIMATION_FPS);
        let mut frames = Vec::with_capacity(frame_count);
        let mut root_positions = Vec::with_capacity(frame_count);
        for frame in 0..frame_count {
            let time = (frame as f32 / BAKED_ANIMATION_FPS as f32).min(duration);
-            frames.push(
+            let local = nodes
-                nodes
+                .iter()
-                    .iter()
+                .map(|node| local_transform(node.clone(), &channels, time))
-                    .map(|node| local_transform(node.clone(), &channels, time))
+                .collect::<io::Result<Vec<_>>>()?;
-                    .collect::<io::Result<Vec<_>>>()?,
+            let mut model = vec![None; local.len()];
-            );
+            let root = super::runtime::resolve_model_transform(
                root_bone_index,
                &parents,
                &local,
                &mut model,
            )?;
            root_positions.push(root.get_translation());
            frames.push(local);
        }
        let index = clips.len();
-        clips.push(BakedAnimationClip { frames });
+        clips.push(BakedAnimationClip {
            frames,
            root_positions,
        });
        for kind in kinds {
            clip_indices.insert(kind, index);
        }
@@ -322,6 +351,7 @@ pub(super) fn bake_gltf_document(
        frame_rate: BAKED_ANIMATION_FPS,
        bone_names: names,
        parents,
        root_bone_index,
        clips,
        clip_indices,
    })
@@ -36,7 +36,13 @@ mod tests {
        ))
        .unwrap();
        let (document, buffers) = test_gltf(&manifest.animations);
-        let baked = bake_gltf_document(document, buffers, &manifest.animations).unwrap();
+        let baked = bake_gltf_document(
            document,
            buffers,
            &manifest.animations,
            &manifest.root_motion_bone,
        )
        .unwrap();
        assert_eq!(baked.frame_rate, BAKED_ANIMATION_FPS);
        assert_eq!(baked.frame_count(AnimKind::Wait), Some(121));
@@ -51,6 +57,15 @@ mod tests {
            baked.bone_names.len()
        );
        assert_eq!(baked.parents.len(), baked.bone_names.len());
        assert_eq!(baked.root_bone_index, 0);
        assert_eq!(
            baked.initial_root_position(AnimKind::Wait, FGi32::lit("2")),
            Some(FGVec3::ZERO)
        );
        assert_eq!(
            baked.root_motion_cycle_delta(AnimKind::Wait, FGi32::lit("2")),
            Some(FGVec3::lit("2", "0", "0"))
        );
    }
    /// Builds the smallest glTF document that still exercises the complete
@@ -162,8 +177,14 @@ mod tests {
            frame_rate: BAKED_ANIMATION_FPS,
            bone_names: vec!["root".into()],
            parents: vec![None],
            root_bone_index: 0,
            clips: vec![BakedAnimationClip {
                frames: vec![vec![first], vec![second], vec![terminal]],
                root_positions: vec![
                    FGVec3::ZERO,
                    FGVec3::lit("2", "0", "0"),
                    FGVec3::lit("4", "0", "0"),
                ],
            }],
            clip_indices: HashMap::from([(AnimKind::Wait, 0)]),
        };
@@ -326,6 +347,180 @@ mod tests {
        );
    }
    #[test]
    fn root_motion_delta_is_scaled_and_zero_on_initial_sample() {
        let names = ["root".into()];
        let parents = [None];
        let mut first = FixedMat4::IDENTITY;
        first.translate(FGVec3::lit("1", "0", "0"));
        let mut second = FixedMat4::IDENTITY;
        second.translate(FGVec3::lit("3", "0", "0"));
        let mut matrices = FighterBoneMatrices::default();
        let frame = crate::fighter::animation::FighterAnimationFrame::new(AnimKind::Wait, false);
        matrices.set_pose_with_frame(
            frame,
            Some(0),
            Some(FGVec3::lit("2", "0", "0")),
            FGVec3::ZERO,
            None,
            AnimKind::Wait,
            &names,
            &parents,
            &[first],
            FGi32::lit("2"),
        );
        assert_eq!(matrices.root_motion_delta(), FGVec3::ZERO);
        assert_eq!(
            matrices.root_motion_position(),
            Some(FGVec3::lit("2", "0", "0"))
        );
        matrices.set_pose_with_frame(
            crate::fighter::animation::FighterAnimationFrame { frame: 1, ..frame },
            Some(0),
            Some(FGVec3::lit("6", "0", "0")),
            FGVec3::ZERO,
            None,
            AnimKind::Wait,
            &names,
            &parents,
            &[second],
            FGi32::lit("2"),
        );
        assert_eq!(matrices.root_motion_delta(), FGVec3::lit("4", "0", "0"));
    }
    #[test]
    fn root_motion_translation_is_removed_from_published_pose() {
        let names = ["root".into(), "hand".into()];
        let parents = [None, Some(0)];
        let mut root = FixedMat4::IDENTITY;
        root.translate(FGVec3::lit("3", "4", "5"));
        let mut hand = FixedMat4::IDENTITY;
        hand.translate(FGVec3::lit("1", "2", "0"));
        let mut matrices = FighterBoneMatrices::default();
        let frame = crate::fighter::animation::FighterAnimationFrame::new(AnimKind::Wait, false);
        matrices.set_pose_with_frame(
            frame,
            Some(0),
            Some(FGVec3::lit("3", "4", "5")),
            FGVec3::ZERO,
            None,
            AnimKind::Wait,
            &names,
            &parents,
            &[root, hand],
            FGi32::ONE,
        );
        assert_eq!(matrices.root_motion_delta(), FGVec3::ZERO);
        assert_eq!(matrices.local(0).unwrap().get_translation(), FGVec3::ZERO);
        assert_eq!(matrices.get_current("root").unwrap().get_translation(), FGVec3::ZERO);
        assert_eq!(
            matrices.get_current("hand").unwrap().get_translation(),
            FGVec3::lit("1", "2", "0")
        );
    }
    #[test]
    fn every_animation_extracts_root_translation_and_retains_its_position() {
        let names = ["root".into(), "hand".into()];
        let parents = [None, Some(0)];
        let mut root = FixedMat4::IDENTITY;
        root.translate(FGVec3::lit("3", "4", "5"));
        let mut hand = FixedMat4::IDENTITY;
        hand.translate(FGVec3::lit("1", "2", "0"));
        let mut matrices = FighterBoneMatrices::default();
        let frame = crate::fighter::animation::FighterAnimationFrame::new(
            AnimKind::LedgeWait,
            true,
        );
        matrices.set_pose_with_frame(
            frame,
            Some(0),
            Some(FGVec3::lit("3", "4", "5")),
            FGVec3::ZERO,
            None,
            AnimKind::LedgeWait,
            &names,
            &parents,
            &[root, hand],
            FGi32::ONE,
        );
        assert_eq!(matrices.root_motion_delta(), FGVec3::ZERO);
        assert_eq!(
            matrices.root_motion_position(),
            Some(FGVec3::lit("3", "4", "5"))
        );
        assert_eq!(matrices.local(0).unwrap().get_translation(), FGVec3::ZERO);
        assert_eq!(
            matrices.get_current("root").unwrap().get_translation(),
            FGVec3::ZERO
        );
        assert_eq!(
            matrices.get_current("hand").unwrap().get_translation(),
            FGVec3::lit("1", "2", "0")
        );
        root.translate(FGVec3::lit("6", "4", "5"));
        matrices.set_pose_with_frame(
            crate::fighter::animation::FighterAnimationFrame { frame: 1, ..frame },
            Some(0),
            Some(FGVec3::lit("6", "4", "5")),
            FGVec3::ZERO,
            None,
            AnimKind::LedgeWait,
            &names,
            &parents,
            &[root, hand],
            FGi32::ONE,
        );
        assert_eq!(matrices.root_motion_delta(), FGVec3::lit("3", "0", "0"));
        assert_eq!(
            matrices.get_current("root").unwrap().get_translation(),
            FGVec3::ZERO
        );
    }
    #[test]
    fn repeating_root_motion_preserves_cycle_displacement_at_every_wrap() {
        let names = ["root".into()];
        let parents = [None];
        let pose = |x| FixedMat4::IDENTITY.with_translation(FGVec3::lit(x, "0", "0"));
        let mut matrices = FighterBoneMatrices::default();
        let frame = |frame| crate::fighter::animation::FighterAnimationFrame {
            kind: AnimKind::Wait,
            frame,
            repeat: true,
        };
        for (frame_number, x, expected_delta) in [
            (0, "0", FGVec3::ZERO),
            (1, "1", FGVec3::lit("1", "0", "0")),
            (2, "0", FGVec3::lit("1", "0", "0")),
            (3, "1", FGVec3::lit("1", "0", "0")),
            (4, "0", FGVec3::lit("1", "0", "0")),
        ] {
            matrices.set_pose_with_frame(
                frame(frame_number),
                Some(0),
                Some(FGVec3::lit(x, "0", "0")),
                FGVec3::lit("2", "0", "0"),
                Some(2),
                AnimKind::Wait,
                &names,
                &parents,
                &[pose(x)],
                FGi32::ONE,
            );
            assert_eq!(matrices.root_motion_delta(), expected_delta);
        }
    }
    #[test]
    fn fixed_matrix_transforms_points() {
        let transform = FixedMat4 {
@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 use bevy::prelude::*;
 use bevy_ggrs::Rollback;
 use serde::{Deserialize, Serialize};
 use super::BAKED_ANIMATION_FPS;
@@ -14,11 +15,15 @@ use crate::{
    },
    math::fixed_transform::FixedMat4,
    math::int::FGi32,
    math::vec3::FGVec3,
 };
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct BakedAnimationClip {
    pub frames: Vec<Vec<FixedMat4>>,
    /// Unscaled model-space position of the configured root-motion bone at
    /// each baked frame.
    pub root_positions: Vec<FGVec3>,
 }
 #[derive(Asset, bevy::reflect::TypePath, Clone, Debug, Serialize, Deserialize)]
@@ -27,11 +32,22 @@ pub struct BakedFighterAnimations {
    pub frame_rate: u32,
    pub bone_names: Vec<String>,
    pub parents: Vec<Option<usize>>,
    pub(super) root_bone_index: usize,
    pub(super) clips: Vec<BakedAnimationClip>,
    pub(super) clip_indices: HashMap<AnimKind, usize>,
 }
 impl BakedFighterAnimations {
    fn sample_index(&self, frame: &FighterAnimationFrame) -> Option<usize> {
        let frames = &self.clip(frame.kind)?.frames;
        let frame_index = if frame.repeat {
            let loop_frame_count = frames.len().saturating_sub(1).max(1) as u32;
            frame.frame % loop_frame_count
        } else {
            frame.frame
        };
        Some((frame_index as usize).min(frames.len().saturating_sub(1)))
    }
    pub fn contains_bone(&self, bone: &str) -> bool {
        self.bone_names.iter().any(|name| name == bone)
    }
@@ -40,21 +56,32 @@ impl BakedFighterAnimations {
        self.bone_names.iter().all(|name| names.insert(name))
    }
    pub fn sample_pose(&self, frame: &FighterAnimationFrame) -> Option<&[FixedMat4]> {
-        let frames = &self.clip(frame.kind)?.frames;
+        let clip = self.clip(frame.kind)?;
-        let frame_index = if frame.repeat {
+        clip.frames.get(self.sample_index(frame)?).map(Vec::as_slice)
-            let loop_frame_count = frames.len().saturating_sub(1).max(1) as u32;
+    }
-            frame.frame % loop_frame_count
+    pub fn sample_root_position(
-        } else {
+        &self,
-            frame.frame
+        frame: &FighterAnimationFrame,
-        };
+        model_scale: FGi32,
-        frames
+    ) -> Option<FGVec3> {
-            .get(frame_index as usize)
+        let clip = self.clip(frame.kind)?;
-            .or_else(|| frames.last())
+        let position = *clip.root_positions.get(self.sample_index(frame)?)?;
-            .map(Vec::as_slice)
+        Some(position * model_scale)
    }
    pub fn initial_root_position(&self, kind: AnimKind, model_scale: FGi32) -> Option<FGVec3> {
        self.sample_root_position(&FighterAnimationFrame::new(kind, false), model_scale)
    }
    pub fn frame_count(&self, kind: AnimKind) -> Option<u32> {
        self.clip(kind).map(|clip| clip.frames.len() as u32)
    }
    pub fn root_motion_cycle_delta(
        &self,
        kind: AnimKind,
        model_scale: FGi32,
    ) -> Option<FGVec3> {
        let clip = self.clip(kind)?;
        Some((*clip.root_positions.last()? - *clip.root_positions.first()?) * model_scale)
    }
    /// 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.
@@ -83,9 +110,13 @@ impl BakedFighterAnimations {
            .get(&kind)
            .and_then(|index| self.clips.get(*index))
    }
    pub fn get_animation_duration(&self, kind: AnimKind) -> Option<usize> {
        self.clip(kind).map(|clip| clip.frames.len())
    }
 }
-#[derive(Component, Clone, Debug, Default)]
+#[derive(Component, Clone, Debug, Default, Hash)]
 #[require(Rollback)]
 pub struct FighterBoneMatrices {
    bone_names: Vec<String>,
    parents: Vec<Option<usize>>,
@@ -95,6 +126,13 @@ pub struct FighterBoneMatrices {
    previous_local_matrices: Vec<FixedMat4>,
    model_matrices: Vec<Option<FixedMat4>>,
    presentation_kind: Option<AnimKind>,
    previous_animation_frame: Option<FighterAnimationFrame>,
    root_motion_position: Option<FGVec3>,
    /// The raw, scaled model-space root translation used as the baseline for
    /// root-motion extraction.  This is kept separately because the published
    /// pose has the root translation removed.
    previous_root_motion_translation: Option<FGVec3>,
    root_motion_delta: crate::math::vec3::FGVec3,
 }
 #[derive(Component, Clone, Debug, Default)]
@@ -111,7 +149,12 @@ impl FighterBoneMatrices {
        let Some(pose) = baked.sample_pose(frame) else {
            return false;
        };
-        self.set_pose(
+        self.set_pose_with_frame(
            *frame,
            Some(baked.root_bone_index),
            baked.sample_root_position(frame, model_scale),
            FGVec3::ZERO,
            None,
            frame.kind,
            &baked.bone_names,
            &baked.parents,
@@ -158,6 +201,16 @@ impl FighterBoneMatrices {
    pub fn get_current_index(&self, index: usize) -> Option<FixedMat4> {
        self.matrices.get(index).copied()
    }
    /// Translation of the configured root-motion bone since the previous
    /// simulation animation frame, in scaled model-space units.
    pub fn root_motion_delta(&self) -> FGVec3 {
        self.root_motion_delta
    }
    /// Current raw, scaled model-space position of the configured root-motion
    /// bone. The published skeleton has this translation removed.
    pub fn root_motion_position(&self) -> Option<FGVec3> {
        self.root_motion_position
    }
    pub fn iter(&self) -> impl Iterator<Item = (&str, FixedMat4)> {
        self.bone_names
            .iter()
@@ -180,6 +233,7 @@ impl FighterBoneMatrices {
            .unwrap_or(current);
        Some(interpolate_transform(previous, current, overstep_fraction))
    }
    #[cfg(test)]
    pub(super) fn set_pose(
        &mut self,
        kind: AnimKind,
@@ -188,8 +242,47 @@ impl FighterBoneMatrices {
        local: &[FixedMat4],
        model_scale: FGi32,
    ) {
-        self.sample_pose(kind, bone_names, parents, local, model_scale, true);
+        self.set_pose_with_frame(
            FighterAnimationFrame::new(kind, false),
            None,
            None,
            FGVec3::ZERO,
            None,
            kind,
            bone_names,
            parents,
            local,
            model_scale,
        );
    }
    pub(super) fn set_pose_with_frame(
        &mut self,
        animation_frame: FighterAnimationFrame,
        root_bone_index: Option<usize>,
        root_motion_position: Option<FGVec3>,
        root_motion_cycle_delta: FGVec3,
        root_motion_loop_frame_count: Option<u32>,
        kind: AnimKind,
        bone_names: &[String],
        parents: &[Option<usize>],
        local: &[FixedMat4],
        model_scale: FGi32,
    ) {
        self.sample_pose(
            animation_frame,
            root_bone_index,
            root_motion_position,
            root_motion_cycle_delta,
            root_motion_loop_frame_count,
            kind,
            bone_names,
            parents,
            local,
            model_scale,
            true,
        );
    }
    #[cfg(test)]
    pub(super) fn resample_pose(
        &mut self,
        kind: AnimKind,
@@ -198,10 +291,53 @@ impl FighterBoneMatrices {
        local: &[FixedMat4],
        model_scale: FGi32,
    ) {
-        self.sample_pose(kind, bone_names, parents, local, model_scale, false);
+        self.resample_pose_with_frame(
            FighterAnimationFrame::new(kind, false),
            None,
            None,
            FGVec3::ZERO,
            None,
            kind,
            bone_names,
            parents,
            local,
            model_scale,
        );
    }
    pub(super) fn resample_pose_with_frame(
        &mut self,
        animation_frame: FighterAnimationFrame,
        root_bone_index: Option<usize>,
        root_motion_position: Option<FGVec3>,
        _root_motion_cycle_delta: FGVec3,
        _root_motion_loop_frame_count: Option<u32>,
        kind: AnimKind,
        bone_names: &[String],
        parents: &[Option<usize>],
        local: &[FixedMat4],
        model_scale: FGi32,
    ) {
        self.sample_pose(
            animation_frame,
            root_bone_index,
            root_motion_position,
            FGVec3::ZERO,
            None,
            kind,
            bone_names,
            parents,
            local,
            model_scale,
            false,
        );
    }
    fn sample_pose(
        &mut self,
        animation_frame: FighterAnimationFrame,
        root_index: Option<usize>,
        raw_root_motion_translation: Option<FGVec3>,
        root_motion_cycle_delta: FGVec3,
        root_motion_loop_frame_count: Option<u32>,
        kind: AnimKind,
        bone_names: &[String],
        parents: &[Option<usize>],
@@ -219,6 +355,7 @@ impl FighterBoneMatrices {
            parents.len(),
            "baked bone parents do not match names"
        );
        let animation_changed = self.presentation_kind != Some(kind);
        if self.bone_names.is_empty() {
            self.bone_names.extend_from_slice(bone_names);
            self.parents.extend_from_slice(parents);
@@ -235,15 +372,9 @@ impl FighterBoneMatrices {
            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);
+
        self.model_matrices.fill(None);
        for index in 0..local.len() {
            resolve_model_transform(index, parents, local, &mut self.model_matrices)
                .expect("baked bone hierarchy should be valid");
        }
        let model_scale = FixedMat4 {
            cols: [
                [model_scale, FGi32::ZERO, FGi32::ZERO, FGi32::ZERO],
@@ -252,12 +383,52 @@ impl FighterBoneMatrices {
                [FGi32::ZERO, FGi32::ZERO, FGi32::ZERO, FGi32::ONE],
            ],
        };
        // Gameplay always owns root displacement. Keep rotation and scale in
        // the pose while removing the configured root bone's translation.
        if let Some(root_index) = root_index {
            self.local_matrices[root_index].translate(FGVec3::ZERO);
        }
        self.model_matrices.resize(local.len(), None);
        self.model_matrices.fill(None);
        for index in 0..local.len() {
            resolve_model_transform(index, parents, &self.local_matrices, &mut self.model_matrices)
                .expect("baked bone hierarchy should be valid");
        }
        self.matrices.clear();
        self.matrices.extend(
            self.model_matrices.iter().map(|matrix| {
                model_scale.mul(matrix.expect("baked bone hierarchy should be valid"))
            }),
        );
        self.root_motion_delta = if advance_history
            && !animation_changed
            && self.previous_animation_frame.is_some()
            && let (Some(current), Some(previous)) = (
                raw_root_motion_translation,
                self.previous_root_motion_translation,
            )
        {
            let mut delta = current - previous;
            if animation_frame.repeat
                && self.previous_animation_frame.is_some_and(|previous| {
                    previous.kind == animation_frame.kind
                        && previous.frame.saturating_add(1) == animation_frame.frame
                })
                && root_motion_loop_frame_count.is_some_and(|loop_frame_count| {
                    loop_frame_count > 0 && animation_frame.frame % loop_frame_count == 0
                })
            {
                delta = delta + root_motion_cycle_delta;
            }
            delta
        } else {
            FGVec3::ZERO
        };
        self.root_motion_position = raw_root_motion_translation;
        self.previous_root_motion_translation = raw_root_motion_translation;
        if advance_history {
            self.previous_animation_frame = Some(animation_frame);
        }
        // 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.
@@ -344,8 +515,20 @@ fn sample_fighter_bone_matrices(
    let manifest = manifests
        .get(&fighter.manifest)
        .expect("fighter manifest should be loaded before the match starts");
    let root_motion_position = baked.sample_root_position(frame, manifest.model_scale);
    let root_motion_cycle_delta = baked
        .root_motion_cycle_delta(frame.kind, manifest.model_scale)
        .unwrap_or(FGVec3::ZERO);
    let root_motion_loop_frame_count = baked
        .frame_count(frame.kind)
        .map(|count| count.saturating_sub(1).max(1));
    if advance_history {
-        matrices.set_pose(
+        matrices.set_pose_with_frame(
            *frame,
            Some(baked.root_bone_index),
            root_motion_position,
            root_motion_cycle_delta,
            root_motion_loop_frame_count,
            frame.kind,
            &baked.bone_names,
            &baked.parents,
@@ -353,7 +536,12 @@ fn sample_fighter_bone_matrices(
            manifest.model_scale,
        );
    } else {
-        matrices.resample_pose(
+        matrices.resample_pose_with_frame(
            *frame,
            Some(baked.root_bone_index),
            root_motion_position,
            FGVec3::ZERO,
            None,
            frame.kind,
            &baked.bone_names,
            &baked.parents,
@@ -372,7 +560,7 @@ fn sample_fighter_bone_matrices(
    }
 }
-fn resolve_model_transform(
+pub(super) fn resolve_model_transform(
    index: usize,
    parents: &[Option<usize>],
    local: &[FixedMat4],
@@ -1,10 +1,17 @@
 //! Resolving an integrated fighter position against the stage.
-use crate::fighter::ecb::FighterPreviousECB;
+use crate::fighter::ecb::{self as ecb_module, FighterDesiredECB};
-use crate::fighter::{FighterECB, FighterPreviousTranslation, FighterTranslation};
+use crate::fighter::{FighterPreviousTranslation, FighterTranslation};
 use crate::fighter::FighterVelocity;
 #[cfg(test)]
 use crate::fighter::{FighterECB, ecb::FighterPreviousECB};
 use crate::math::int::FGi32;
 use crate::math::rect::FGRect;
 use crate::math::segment::FGSegment2d;
 use crate::math::vec::FGVec2;
-use crate::stage::line::{StageCollision, StageLineID, StagePolyType};
+use crate::stage::line::{
    StageCollision, StageLineID, StagePolyLineSegmentType, StagePolyType, StageVertexID,
 };
 /*
 pub fn collide_fighter_with_scene(
    fighters: Query<(&FighterECB, &mut FighterVelocity, &mut FighterTranslation)>,
@@ -35,54 +42,411 @@ pub fn collide_fighter_with_scene(
 pub struct AirCollisionWithStageResult {
    pub line_id: StageLineID,
    pub hit_position: FGVec2,
    /// Fighter origin at the collision substep. The ECB remains local to this
    /// origin; callers must not rebase the ECB by the frame-sized movement.
    pub resolved_translation: FGVec2,
    pub hit_normal: FGVec2,
 }
-pub fn air_collide_with_stage(
+#[derive(Clone, Copy, Debug, Default)]
 pub struct AirCollisionOptions {
    /// Allow downward input to disable collision with pass-through platforms.
    pub can_pass_through_soft_platforms: bool,
    /// Treat an upward crossing of a pass-through platform by the ECB bottom as a landing.
    pub land_on_soft_platforms_from_below: bool,
 }
 #[cfg(test)]
 fn air_collide_with_stage(
    prev_translation: &FighterPreviousTranslation,
    translation: &FighterTranslation,
    prev_ecb: &FighterPreviousECB,
    ecb: &FighterECB,
    stage_collision: &StageCollision,
    ignored_polys: &[usize],
-    can_ignore_soft_platforms: bool,
+    options: AirCollisionOptions,
 ) -> Option<AirCollisionWithStageResult> {
-    let ray_segment = FGSegment2d::new(
+    let mut translation = *translation;
-        prev_translation.0 + prev_ecb.get_bottom_point(),
+    let mut velocity = FighterVelocity::default();
-        translation.0 + ecb.get_bottom_point(),
+    air_collide_with_stage_substepped(
-    );
+        prev_translation,
        &mut translation,
        &mut velocity,
        &mut ecb_module::FighterECB {
            top: prev_ecb.top,
            bottom: prev_ecb.bottom,
            left: prev_ecb.left,
            right: prev_ecb.right,
        },
        &FighterDesiredECB::from(*ecb),
        stage_collision,
        ignored_polys,
        options,
    )
 }
 /// Sweeps movement and ECB shape changes together.
 pub(crate) fn collision_step_count(max_change: FGi32) -> u32 {
    let six = FGi32::lit("6.0");
    if max_change <= six {
        return 1;
    }
    let mut quotient = 0;
    let mut remainder = max_change;
    while remainder >= six {
        quotient += 1;
        remainder -= six;
    }
    quotient + 1
 }
 pub fn air_collide_with_stage_substepped(
    prev_translation: &FighterPreviousTranslation,
    translation: &mut FighterTranslation,
    velocity: &mut FighterVelocity,
    ecb: &mut crate::fighter::FighterECB,
    desired: &FighterDesiredECB,
    stage_collision: &StageCollision,
    ignored_polys: &[usize],
    options: AirCollisionOptions,
 ) -> Option<AirCollisionWithStageResult> {
    let requested_translation = translation.0;
    let movement = requested_translation - prev_translation.0;
    let mut largest_change = movement.x.abs().max(movement.y.abs());
    largest_change = largest_change.max(ecb_module::ecb_max_delta(ecb, desired));
    let steps = collision_step_count(largest_change);
    let step_count = FGi32::from_num(steps);
    let movement_per_step = movement / step_count;
    let mut current_position = prev_translation.0;
    let mut current_ecb = *ecb;
    let mut collision_offset = FGVec2::ZERO;
    for step in 0..steps {
        let previous_position = current_position;
        let previous_ecb = current_ecb;
        let remaining_steps = FGi32::from_num(steps - step);
        ecb_module::interpolate_ecb(&mut current_ecb, *desired, FGi32::ONE / remaining_steps);
        current_position = if step + 1 == steps {
            // Fixed-point division may truncate. Always make the final
            // substep land exactly on the requested frame endpoint.
            requested_translation + collision_offset
        } else {
            prev_translation.0
                + movement_per_step * FGi32::from_num(step + 1)
                + collision_offset
        };
        let lower_edges = [
            (
                previous_ecb.bottom,
                previous_ecb.left,
                current_ecb.bottom,
                current_ecb.left,
            ),
            (
                previous_ecb.bottom,
                previous_ecb.right,
                current_ecb.bottom,
                current_ecb.right,
            ),
        ];
        if let Some(result) = sweep_edges(
            stage_collision,
            previous_position,
            current_position,
            &lower_edges,
            StagePolyLineSegmentType::Floor,
            ignored_polys,
            options.can_pass_through_soft_platforms,
        ) {
            *ecb = current_ecb;
            translation.0 = current_position + result.correction;
            velocity.0 -= velocity.0.project_onto_normalized(result.hit_normal);
            let bottom_contact = translation.0 + current_ecb.bottom;
            return Some(AirCollisionWithStageResult {
                line_id: result.line_id,
                hit_position: bottom_contact,
                resolved_translation: translation.0,
                hit_normal: result.hit_normal,
            });
        }
        let upper_edges = [
            (
                previous_ecb.top,
                previous_ecb.left,
                current_ecb.top,
                current_ecb.left,
            ),
            (
                previous_ecb.top,
                previous_ecb.right,
                current_ecb.top,
                current_ecb.right,
            ),
        ];
        if let Some(contact) = sweep_edges(
            stage_collision,
            previous_position,
            current_position,
            &upper_edges,
            StagePolyLineSegmentType::Ceiling,
            ignored_polys,
            true,
        ) {
            current_position += contact.correction;
            collision_offset += contact.correction;
            velocity.0 -= velocity.0.project_onto_normalized(contact.hit_normal);
        }
        if options.land_on_soft_platforms_from_below
            && let Some(result) = sweep_bottom_point_through_platforms(
                stage_collision,
                previous_position + previous_ecb.bottom,
                current_position + current_ecb.bottom,
                ignored_polys,
            )
        {
            *ecb = current_ecb;
            translation.0 = current_position + result.correction;
            velocity.0 -= velocity.0.project_onto_normalized(result.hit_normal);
            let bottom_contact = translation.0 + current_ecb.bottom;
            return Some(AirCollisionWithStageResult {
                line_id: result.line_id,
                hit_position: bottom_contact,
                resolved_translation: translation.0,
                hit_normal: result.hit_normal,
            });
        }
        let side_edges = [
            (
                previous_ecb.bottom,
                previous_ecb.right,
                current_ecb.bottom,
                current_ecb.right,
            ),
            (
                previous_ecb.right,
                previous_ecb.top,
                current_ecb.right,
                current_ecb.top,
            ),
            (
                previous_ecb.top,
                previous_ecb.left,
                current_ecb.top,
                current_ecb.left,
            ),
            (
                previous_ecb.left,
                previous_ecb.bottom,
                current_ecb.left,
                current_ecb.bottom,
            ),
        ];
        if let Some(contact) = sweep_edges(
            stage_collision,
            previous_position,
            current_position,
            &side_edges,
            StagePolyLineSegmentType::Wall,
            ignored_polys,
            true,
        ) {
            current_position += contact.correction;
            collision_offset += contact.correction;
            velocity.0 -= velocity.0.project_onto_normalized(contact.hit_normal);
        }
    }
    *ecb = current_ecb;
    translation.0 = current_position;
    None
 }
 struct PointSweepResult {
    line_id: StageLineID,
    hit_normal: FGVec2,
    correction: FGVec2,
 }
 fn sweep_bottom_point_through_platforms(
    stage_collision: &StageCollision,
    previous_bottom: FGVec2,
    current_bottom: FGVec2,
    ignored_polys: &[usize],
 ) -> Option<PointSweepResult> {
    let bottom_sweep = FGSegment2d::new(previous_bottom, current_bottom);
    stage_collision
        .stage_polys
        .iter()
        .enumerate()
        .filter(|(poly_idx, poly)| {
-            !ignored_polys.contains(poly_idx)
+            !ignored_polys.contains(poly_idx) && matches!(poly.poly_type, StagePolyType::Platform)
                && !(can_ignore_soft_platforms && matches!(poly.poly_type, StagePolyType::Platform))
        })
-        .filter_map(|(poly_idx, poly)| {
+        .flat_map(|(poly_idx, poly)| {
-            poly.intersect_ray(ray_segment).map(|intersect_result| {
+            poly.segments
-                (
+                .iter()
-                    AirCollisionWithStageResult {
+                .enumerate()
-                        line_id: {
+                .filter(|(_, segment)| {
-                            StageLineID {
+                    matches!(segment.segment_type, StagePolyLineSegmentType::Floor)
                })
                .filter_map(move |(segment_idx, segment)| {
                    let previous_distance = segment
                        .normal
                        .dot(previous_bottom - segment.segment.point1());
                    let current_distance = segment
                        .normal
                        .dot(current_bottom - segment.segment.point1());
                    if previous_distance >= crate::math::int::FGWide::ZERO
                        || current_distance < crate::math::int::FGWide::ZERO
                    {
                        return None;
                    }
                    let hit_position = segment.segment.segment_intersection(&bottom_sweep)?;
                    Some((
                        PointSweepResult {
                            line_id: StageLineID {
                                polygon: poly_idx,
-                                segment: intersect_result.segment_idx,
+                                segment: segment_idx,
-                            }
+                            },
                            hit_normal: segment.normal,
                            correction: hit_position - current_bottom,
                        },
-                        hit_position: intersect_result.position,
+                        hit_position.distance_squared(previous_bottom),
-                        hit_normal: intersect_result.normal,
+                    ))
-                    },
+                })
-                    intersect_result
+        })
-                        .position
+        .min_by_key(|(_, distance)| *distance)
-                        .distance_squared(ray_segment.point2()),
+        .map(|(result, _)| result)
-                )
+}
-            })
+
 fn sweep_edges(
    stage_collision: &StageCollision,
    previous_position: FGVec2,
    current_position: FGVec2,
    edges: &[(FGVec2, FGVec2, FGVec2, FGVec2)],
    segment_type: StagePolyLineSegmentType,
    ignored_polys: &[usize],
    ignore_platforms: bool,
 ) -> Option<PointSweepResult> {
    stage_collision
        .stage_polys
        .iter()
        .enumerate()
        .filter(|(poly_idx, poly)| {
            !ignored_polys.contains(poly_idx)
                && !(ignore_platforms && matches!(poly.poly_type, StagePolyType::Platform))
        })
        .flat_map(|(poly_idx, poly)| {
            poly.segments
                .iter()
                .enumerate()
                .filter(move |(_, segment)| segment.segment_type == segment_type)
                .filter_map(move |(segment_idx, segment)| {
                    edges
                        .iter()
                        .filter_map(|(previous_a, previous_b, current_a, current_b)| {
                            let previous_a = previous_position + *previous_a;
                            let previous_b = previous_position + *previous_b;
                            let current_a = current_position + *current_a;
                            let current_b = current_position + *current_b;
                            let previous_min = segment
                                .normal
                                .dot(previous_a - segment.segment.point1())
                                .min(segment.normal.dot(previous_b - segment.segment.point1()));
                            let current_a_distance =
                                segment.normal.dot(current_a - segment.segment.point1());
                            let current_b_distance =
                                segment.normal.dot(current_b - segment.segment.point1());
                            let current_min = current_a_distance.min(current_b_distance);
                            if previous_min < crate::math::int::FGWide::ZERO
                                || current_min > crate::math::int::FGWide::ZERO
                            {
                                return None;
                            }
                            let boundary = [
                                FGSegment2d::new(previous_a, previous_b),
                                FGSegment2d::new(previous_a, current_a),
                                FGSegment2d::new(previous_b, current_b),
                                FGSegment2d::new(current_a, current_b),
                            ];
                            let quad = [previous_a, previous_b, current_b, current_a];
                            let position = boundary
                                .iter()
                                .filter_map(|edge| segment.segment.segment_intersection(edge))
                                .max_by_key(|position| position.distance_squared(current_a))
                                .or_else(|| {
                                    [segment.segment.point1(), segment.segment.point2()]
                                        .into_iter()
                                        .find(|point| point_in_convex_quad(*point, quad))
                                })?;
                            let penetration = FGi32::from_num(-current_min);
                            Some((position, segment.normal * penetration))
                        })
                        .max_by_key(|(position, _)| {
                            position.distance_squared(segment.segment.point1())
                        })
                        .map(|(position, correction)| {
                            (
                                PointSweepResult {
                                    line_id: StageLineID {
                                        polygon: poly_idx,
                                        segment: segment_idx,
                                    },
                                    hit_normal: segment.normal,
                                    correction,
                                },
                                position.distance_squared(segment.segment.point2()),
                            )
                        })
                })
        })
        .max_by(|(_, a), (_, b)| a.cmp(b))
        .map(|(result, _)| result)
 }
 fn point_in_convex_quad(point: FGVec2, quad: [FGVec2; 4]) -> bool {
    let mut has_positive = false;
    let mut has_negative = false;
    for (a, b) in quad.into_iter().zip(quad.into_iter().cycle().skip(1)).take(4) {
        let edge = b - a;
        let offset = point - a;
        let cross = crate::math::int::FGWide::from_num(edge.x)
            * crate::math::int::FGWide::from_num(offset.y)
            - crate::math::int::FGWide::from_num(edge.y)
                * crate::math::int::FGWide::from_num(offset.x);
        has_positive |= cross > crate::math::int::FGWide::ZERO;
        has_negative |= cross < crate::math::int::FGWide::ZERO;
        if has_positive && has_negative {
            return false;
        }
    }
    true
 }
 #[derive(Clone)]
 pub struct AirCollisionWithLedgeResult {
    pub ledge: StageVertexID,
 }
 pub fn air_collide_with_ledges(
    ledge_box: &FGRect,
    stage_collision: &StageCollision,
 ) -> Option<AirCollisionWithLedgeResult> {
    stage_collision
        .intersect_ledges(ledge_box)
        .map(|result| AirCollisionWithLedgeResult {
            ledge: result.vertex_id,
        })
 }
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -111,10 +475,178 @@ mod tests {
        )
    }
    fn single_segment(
        start: FGVec2,
        end: FGVec2,
        segment_type: StagePolyLineSegmentType,
    ) -> StagePoly {
        let segment = FGSegment2d::new(start, end);
        StagePoly {
            poly_type: StagePolyType::Closed,
            segments: vec![crate::stage::line::StagePolyLineSegment {
                segment,
                normal: segment.left_normal(),
                segment_type,
            }],
        }
    }
    #[test]
    fn melee_step_count_adds_one_step_after_each_six_unit_block() {
        assert_eq!(collision_step_count(FGi32::lit("6")), 1);
        assert_eq!(collision_step_count(FGi32::lit("6.01")), 2);
        assert_eq!(collision_step_count(FGi32::lit("12")), 3);
        assert_eq!(collision_step_count(FGi32::lit("18")), 4);
    }
    #[test]
    fn collision_result_keeps_ecb_local_to_resolved_origin() {
        let stage_collision = StageCollision {
            stage_polys: vec![horizontal_platform("0")],
            ..StageCollision::default()
        };
        let previous_translation = FighterPreviousTranslation(FGVec2::lit("0", "2"));
        let mut translation = FighterTranslation(FGVec2::lit("0", "-1"));
        let mut velocity = FighterVelocity(FGVec2::lit("0", "-3"));
        let mut ecb = FighterECB {
            top: FGVec2::lit("0", "2"),
            bottom: FGVec2::lit("0", "-1"),
            left: FGVec2::lit("-1", "0.5"),
            right: FGVec2::lit("1", "0.5"),
        };
        let desired = FighterDesiredECB::from(ecb);
        let collision = air_collide_with_stage_substepped(
            &previous_translation,
            &mut translation,
            &mut velocity,
            &mut ecb,
            &desired,
            &stage_collision,
            &[],
            Default::default(),
        )
        .expect("the floor should be hit");
        assert_eq!(
            collision.resolved_translation + ecb.bottom,
            collision.hit_position
        );
        assert_eq!(velocity.0.y, FGi32::ZERO);
    }
    #[test]
    fn airborne_side_point_resolves_wall_and_projects_velocity() {
        let stage_collision = StageCollision {
            stage_polys: vec![single_segment(
                FGVec2::lit("2", "2"),
                FGVec2::lit("2", "-2"),
                StagePolyLineSegmentType::Wall,
            )],
            ..StageCollision::default()
        };
        let previous = FighterPreviousTranslation(FGVec2::lit("4", "0"));
        let mut translation = FighterTranslation(FGVec2::lit("0", "0"));
        let mut velocity = FighterVelocity(FGVec2::lit("-4", "0"));
        let mut ecb = FighterECB {
            top: FGVec2::lit("0", "1"),
            bottom: FGVec2::lit("0", "-1"),
            left: FGVec2::lit("-1", "0"),
            right: FGVec2::lit("1", "0"),
        };
        let desired = FighterDesiredECB::from(ecb);
        assert!(air_collide_with_stage_substepped(
            &previous,
            &mut translation,
            &mut velocity,
            &mut ecb,
            &desired,
            &stage_collision,
            &[],
            Default::default(),
        )
        .is_none());
        assert_eq!(translation.0, FGVec2::lit("3", "0"));
        assert_eq!(velocity.0.x, FGi32::ZERO);
    }
    #[test]
    fn stage_corner_cannot_pass_through_middle_of_diamond_edge() {
        let stage_collision = StageCollision {
            stage_polys: vec![single_segment(
                FGVec2::lit("2", "0.6"),
                FGVec2::lit("2", "0.4"),
                StagePolyLineSegmentType::Wall,
            )],
            ..StageCollision::default()
        };
        let previous = FighterPreviousTranslation(FGVec2::lit("4", "0"));
        let mut translation = FighterTranslation(FGVec2::ZERO);
        let mut velocity = FighterVelocity(FGVec2::lit("-4", "0"));
        let mut ecb = FighterECB {
            top: FGVec2::lit("0", "1"),
            bottom: FGVec2::lit("0", "-1"),
            left: FGVec2::lit("-1", "0"),
            right: FGVec2::lit("1", "0"),
        };
        let desired = FighterDesiredECB::from(ecb);
        assert!(air_collide_with_stage_substepped(
            &previous,
            &mut translation,
            &mut velocity,
            &mut ecb,
            &desired,
            &stage_collision,
            &[],
            Default::default(),
        )
        .is_none());
        assert_eq!(translation.0.x, FGi32::lit("3"));
        assert_eq!(velocity.0.x, FGi32::ZERO);
    }
    #[test]
    fn airborne_top_point_resolves_ceiling_and_projects_velocity() {
        let stage_collision = StageCollision {
            stage_polys: vec![single_segment(
                FGVec2::lit("2", "2"),
                FGVec2::lit("-2", "2"),
                StagePolyLineSegmentType::Ceiling,
            )],
            ..StageCollision::default()
        };
        let previous = FighterPreviousTranslation(FGVec2::ZERO);
        let mut translation = FighterTranslation(FGVec2::lit("0", "4"));
        let mut velocity = FighterVelocity(FGVec2::lit("0", "4"));
        let mut ecb = FighterECB {
            top: FGVec2::lit("0", "1"),
            bottom: FGVec2::lit("0", "-1"),
            left: FGVec2::lit("-1", "0"),
            right: FGVec2::lit("1", "0"),
        };
        let desired = FighterDesiredECB::from(ecb);
        assert!(air_collide_with_stage_substepped(
            &previous,
            &mut translation,
            &mut velocity,
            &mut ecb,
            &desired,
            &stage_collision,
            &[],
            Default::default(),
        )
        .is_none());
        assert_eq!(translation.0, FGVec2::lit("0", "1"));
        assert_eq!(velocity.0.y, FGi32::ZERO);
    }
    #[test]
    fn airborne_collision_skips_ignored_polygons() {
        let stage_collision = StageCollision {
            stage_polys: vec![horizontal_platform("0"), horizontal_platform("1")],
            ..StageCollision::default()
        };
        let previous_translation = FighterPreviousTranslation(FGVec2::lit("0", "2"));
        let translation = FighterTranslation(FGVec2::lit("0", "-1"));
@@ -138,7 +670,7 @@ mod tests {
            &ecb,
            &stage_collision,
            &[1],
-            false,
+            Default::default(),
        )
        .expect("the non-ignored platform should still be collidable");
@@ -150,6 +682,7 @@ mod tests {
    fn airborne_collision_skips_soft_platforms_while_passing_down() {
        let stage_collision = StageCollision {
            stage_polys: vec![horizontal_platform("0")],
            ..StageCollision::default()
        };
        let previous_translation = FighterPreviousTranslation(FGVec2::lit("0", "2"));
        let translation = FighterTranslation(FGVec2::lit("0", "-1"));
@@ -166,16 +699,21 @@ mod tests {
            right: FGVec2::ZERO,
        };
-        assert!(air_collide_with_stage(
+        assert!(
-            &previous_translation,
+            air_collide_with_stage(
-            &translation,
+                &previous_translation,
-            &previous_ecb,
+                &translation,
-            &ecb,
+                &previous_ecb,
-            &stage_collision,
+                &ecb,
-            &[],
+                &stage_collision,
-            true,
+                &[],
-        )
+                AirCollisionOptions {
-        .is_none());
+                    can_pass_through_soft_platforms: true,
                    ..Default::default()
                },
            )
            .is_none()
        );
        assert_eq!(
            air_collide_with_stage(
@@ -185,7 +723,7 @@ mod tests {
                &ecb,
                &stage_collision,
                &[],
-                false,
+                Default::default(),
            )
            .expect("air dodges still collide with soft platforms")
            .hit_position,
@@ -197,6 +735,7 @@ mod tests {
    fn airborne_collision_still_hits_solid_floors_while_passing_down() {
        let stage_collision = StageCollision {
            stage_polys: vec![solid_floor()],
            ..StageCollision::default()
        };
        let previous_translation = FighterPreviousTranslation(FGVec2::lit("0", "2"));
        let translation = FighterTranslation(FGVec2::lit("0", "-1"));
@@ -220,11 +759,131 @@ mod tests {
            &ecb,
            &stage_collision,
            &[],
-            true,
+            AirCollisionOptions {
                can_pass_through_soft_platforms: true,
                ..Default::default()
            },
        )
        .expect("solid floors remain collidable while passing down");
        assert_eq!(collision.line_id.polygon, 0);
        assert_eq!(collision.hit_position, FGVec2::lit("0", "0"));
    }
    #[test]
    fn upward_bottom_crossing_can_land_on_soft_platform() {
        let stage_collision = StageCollision {
            stage_polys: vec![horizontal_platform("0")],
            ..Default::default()
        };
        let previous_translation = FighterPreviousTranslation(FGVec2::lit("0", "-1"));
        let mut translation = FighterTranslation(FGVec2::lit("0", "1"));
        let mut velocity = FighterVelocity(FGVec2::lit("0", "2"));
        let mut ecb = FighterECB::default();
        let desired = FighterDesiredECB::from(ecb);
        let collision = air_collide_with_stage_substepped(
            &previous_translation,
            &mut translation,
            &mut velocity,
            &mut ecb,
            &desired,
            &stage_collision,
            &[],
            AirCollisionOptions {
                land_on_soft_platforms_from_below: true,
                ..Default::default()
            },
        )
        .expect("the upward bottom-point crossing should land on the platform");
        assert_eq!(collision.hit_position, FGVec2::ZERO);
        assert_eq!(collision.line_id, StageLineID { polygon: 0, segment: 0 });
        assert_eq!(translation.0, FGVec2::ZERO);
        assert_eq!(velocity.y, FGi32::ZERO);
    }
    #[test]
    fn upward_platform_landing_requires_crossing_and_opt_in() {
        let stage_collision = StageCollision {
            stage_polys: vec![horizontal_platform("0")],
            ..Default::default()
        };
        let previous_ecb = FighterPreviousECB::default();
        let ecb = FighterECB::default();
        let options = AirCollisionOptions {
            land_on_soft_platforms_from_below: true,
            ..Default::default()
        };
        assert!(
            air_collide_with_stage(
                &FighterPreviousTranslation(FGVec2::lit("0", "-2")),
                &FighterTranslation(FGVec2::lit("0", "-1")),
                &previous_ecb,
                &ecb,
                &stage_collision,
                &[],
                options,
            )
            .is_none()
        );
        assert!(
            air_collide_with_stage(
                &FighterPreviousTranslation(FGVec2::lit("0", "-1")),
                &FighterTranslation(FGVec2::lit("0", "1")),
                &previous_ecb,
                &ecb,
                &stage_collision,
                &[],
                Default::default(),
            )
            .is_none()
        );
    }
    #[test]
    fn upward_crossing_does_not_land_on_solid_or_ignored_platforms() {
        let previous_translation = FighterPreviousTranslation(FGVec2::lit("0", "-1"));
        let translation = FighterTranslation(FGVec2::lit("0", "1"));
        let previous_ecb = FighterPreviousECB::default();
        let ecb = FighterECB::default();
        let options = AirCollisionOptions {
            land_on_soft_platforms_from_below: true,
            ..Default::default()
        };
        let solid_stage = StageCollision {
            stage_polys: vec![solid_floor()],
            ..Default::default()
        };
        let platform_stage = StageCollision {
            stage_polys: vec![horizontal_platform("0")],
            ..Default::default()
        };
        assert!(
            air_collide_with_stage(
                &previous_translation,
                &translation,
                &previous_ecb,
                &ecb,
                &solid_stage,
                &[],
                options,
            )
            .is_none()
        );
        assert!(
            air_collide_with_stage(
                &previous_translation,
                &translation,
                &previous_ecb,
                &ecb,
                &platform_stage,
                &[0],
                options,
            )
            .is_none()
        );
    }
 }
@@ -28,6 +28,7 @@ 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<(
@@ -148,6 +149,8 @@ pub fn fighter_debug(
                                    last_frame.movement.x, last_frame.movement.y
                                ));
                            });
                            ui.label(format!("Flick age Y {}", input.peek_movement_flick_dbg()));
                        }
                        FighterDebugRowKind::Position => {
                            ui.label(format!("Position: {:?}", translation.0));
@@ -168,20 +171,31 @@ pub fn animation_debug(
        &FighterTranslation,
        &FighterFacingDirection,
        &FighterBoneMatrices,
        &Fighter,
    )>,
    mut gizmos: Gizmos,
    fighter_manifests: Res<Assets<FighterManifest>>,
 ) {
-    for (global_transform, facing_dir, matrices) in query {
+    for (global_transform, facing_dir, matrices, fighter) in query {
        let Some(manifest) = fighter_manifests.get(&fighter.manifest) else {
            continue;
        };
        let global_transform = global_transform.get_3d_transform(facing_dir);
        let marker_transform = global_transform.to_mat4();
-        for (_, matrix) in matrices.iter() {
+        for (bone_name, matrix) in matrices.iter() {
            let pos = marker_transform.transform_point(Vec3::new(
                matrix.cols[3][0].to_num(),
                matrix.cols[3][1].to_num(),
                matrix.cols[3][2].to_num(),
            ));
-            gizmos.cross(pos, 0.5, bevy::color::palettes::css::RED);
+
-            gizmos.axes(marker_transform, 1.0);
+            if manifest.ecb_bones.iter().any(|ecb_bone_name| ecb_bone_name == bone_name) {
                gizmos.cross(pos, 1.0, bevy::color::palettes::css::GREEN);
            } else {
                gizmos.cross(pos, 0.5, bevy::color::palettes::css::RED);
                gizmos.axes(marker_transform, 1.0);
            }
        }
    }
 }
@@ -202,6 +216,26 @@ pub fn hurtbox_debug(
    }
 }
 pub fn ledge_grab_debug(query: Query<(&FighterTranslation, &Fighter)>, fighters: Res<Assets<FighterManifest>>, mut gizmos: Gizmos) {
    for (translation, fighter) in query {
        let Some(manifest) = fighters.get(&fighter.manifest) else {
            continue;
        };
        let start_2d = translation.0 + manifest.ledge_grab_box_start;
        let start_2d = Vec2::new(start_2d.x.to_num(), start_2d.y.to_num());
        let end_2d = translation.0 + manifest.ledge_grab_box_end;
        let end_2d = Vec2::new(end_2d.x.to_num(), end_2d.y.to_num());
        let center = (start_2d + end_2d) * 0.5;
        let size = (start_2d - end_2d).abs();
        gizmos.rect(Vec3::new(center.x, center.y, 0.0), size, bevy::color::palettes::css::BLUE);
    }
 }
 /*fn draw_affine_capsule(
    gizmos: &mut Gizmos,
    capsule: FixedAffineCapsule,
@@ -368,6 +402,7 @@ pub fn attack_debug(
    )>,
    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 {
@@ -378,27 +413,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,
-                    Color::srgba(1.0, 0.0, 0.0, 0.18),
+                    hitbox_inner_color,
                );
                gizmos.cross(start, 1.0, bevy::color::palettes::css::GREEN);
@@ -4,14 +4,12 @@ use crate::{
    fighter::{
        FighterFacingDirection, FighterSurfaceState, FighterTranslation,
        baked_animation::FighterBoneMatrices,
-    }, math::{int::FGi32, vec::FGVec2},
+    },
    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, Default)]
-#[require(FighterPreviousECB)]
+#[require(FighterPreviousECB, FighterDesiredECB)]
 pub struct FighterECB {
    pub top: FGVec2,
    pub bottom: FGVec2,
@@ -19,6 +17,14 @@ pub struct FighterECB {
    pub right: FGVec2,
 }
 #[derive(Component, Debug, Clone, Copy, Hash, Default)]
 pub struct FighterDesiredECB {
    pub top: FGVec2,
    pub bottom: FGVec2,
    pub left: FGVec2,
    pub right: FGVec2,
 }
 #[derive(Component, Debug, Clone)]
 pub struct FighterECBBoneIndices {
    pub indices: Vec<usize>,
@@ -43,12 +49,96 @@ impl From<FighterECB> for FighterPreviousECB {
    }
 }
 impl From<FighterECB> for FighterDesiredECB {
    fn from(ecb: FighterECB) -> Self {
        Self {
            top: ecb.top,
            bottom: ecb.bottom,
            left: ecb.left,
            right: ecb.right,
        }
    }
 }
 impl FighterDesiredECB {
    pub fn as_ecb(self) -> FighterECB {
        FighterECB {
            top: self.top,
            bottom: self.bottom,
            left: self.left,
            right: self.right,
        }
    }
    pub fn validate(&mut self) {
        let minimum = FGi32::lit("1.0");
        if (self.top.y - self.bottom.y).abs() < minimum {
            self.top.y += minimum;
            let midpoint = (self.top.y + self.bottom.y) / FGi32::lit("2.0");
            self.left.y = midpoint;
            self.right.y = midpoint;
        }
        if self.top.y < minimum {
            self.top.y = minimum;
        }
        if self.left.x > -minimum {
            self.left.x = -minimum;
        }
        if self.right.x < minimum {
            self.right.x = minimum;
        }
        if self.top.y < self.bottom.y {
            self.top.y = self.bottom.y + minimum;
        }
        let midpoint = (self.top.y + self.bottom.y) / FGi32::lit("2.0");
        if self.left.y < self.bottom.y || self.left.y > self.top.y {
            self.left.y = midpoint;
        }
        if self.right.y < self.bottom.y || self.right.y > self.top.y {
            self.left.y = midpoint;
            self.right.y = midpoint;
        }
        let epsilon = FGi32::from_bits(66);
        if self.top.y - self.right.y < epsilon
            || self.right.y - self.bottom.y < epsilon
        {
            self.right.y = midpoint;
        }
        if self.top.y - self.left.y < epsilon
            || self.left.y - self.bottom.y < epsilon
        {
            self.left.y = midpoint;
        }
    }
 }
 pub fn snapshot_fighter_ecb(fighters: Query<(&FighterECB, &mut FighterPreviousECB)>) {
    for (ecb, mut previous_ecb) in fighters {
        *previous_ecb = (*ecb).into();
    }
 }
 pub fn interpolate_ecb(ecb: &mut FighterECB, desired: FighterDesiredECB, time: FGi32) {
    let lerp = |a: FGVec2, b: FGVec2| a + (b - a) * time;
    ecb.top = lerp(ecb.top, desired.top);
    ecb.bottom = lerp(ecb.bottom, desired.bottom);
    ecb.left = lerp(ecb.left, desired.left);
    ecb.right = lerp(ecb.right, desired.right);
 }
 pub fn ecb_max_delta(ecb: &FighterECB, desired: &FighterDesiredECB) -> FGi32 {
    [
        (desired.left.x - ecb.left.x).abs(),
        (desired.right.x - ecb.right.x).abs(),
        (desired.top.y - ecb.top.y).abs(),
        (desired.right.y - ecb.right.y).abs(),
    ]
    .into_iter()
    .max()
    .unwrap_or(FGi32::ZERO)
 }
 impl FighterECB {
    pub fn to_3d_lineloop(&self, trf: Transform) -> [Vec3; 4] {
        [self.top, self.right, self.bottom, self.left]
@@ -58,6 +148,17 @@ impl FighterECB {
    pub fn get_bottom_point(&self) -> FGVec2 {
        self.bottom
    }
    /// Change the local origin to the bottom point without moving the ECB in
    /// world space. Grounded fighters use the floor contact as their origin.
    pub fn rebase_onto_bottom(&mut self) -> FGVec2 {
        let bottom = self.bottom;
        self.top -= bottom;
        self.left -= bottom;
        self.right -= bottom;
        self.bottom = FGVec2::ZERO;
        bottom
    }
 }
 impl FighterPreviousECB {
@@ -73,7 +174,7 @@ impl FighterPreviousECB {
 pub fn update_ecb(
    query: Query<(
-        &mut FighterECB,
+        &mut FighterDesiredECB,
        &FighterSurfaceState,
        &FighterECBBoneIndices,
        &FighterBoneMatrices,
@@ -81,23 +182,44 @@ pub fn update_ecb(
        &FighterFacingDirection,
    )>,
 ) {
-    for (mut ecb, surface_state, bone_indices, bone_matrices, translation, facing_dir) in query {
+    for (mut desired, 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 transformed_ecb_bones = bone_indices
-            let Some((_, bone_matrix)) = bone_matrices.get_by_idx(*idx) else {
+            .indices
-                return None;
+            .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());
+                let pt = trf.transform_point(bone_matrix.get_translation());
-            Some(FGVec2::new(pt.x, pt.y) - translation.0)
+                Some(FGVec2::new(pt.x, pt.y) - translation.0)
-        }).collect::<Vec<_>>();
+            })
            .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 max_x = transformed_ecb_bones
-        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"));
+            .iter()
-        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"));
+            .max_by(|a, b| a.x.cmp(&b.x))
-        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"));
+            .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);
@@ -105,24 +227,29 @@ pub fn update_ecb(
        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 {
+        let ecb_lock_frames_remaining = if let FighterSurfaceState::Airborne {
            ecb_lock_frames_remaining,
            ..
        } = surface_state
        {
            *ecb_lock_frames_remaining
        } else {
            0
        };
-        ecb.top = top;
+        desired.top = top;
        if ecb_lock_frames_remaining == 0 {
-            ecb.bottom = bottom;
+            desired.bottom = bottom;
        }
-        ecb.left = left;
+        desired.left = left;
-        ecb.right = right;
+        desired.right = right;
        if surface_state.is_grounded() {
-            ecb.bottom = FGVec2::ZERO;
+            desired.bottom = FGVec2::ZERO;
        }
        desired.validate();
    }
 }
@@ -152,4 +279,60 @@ mod tests {
        assert_eq!(previous.left, current.left);
        assert_eq!(previous.right, current.right);
    }
    #[test]
    fn interpolation_reaches_target_with_full_step() {
        let mut current = FighterECB {
            top: FGVec2::lit("0", "1"),
            bottom: FGVec2::lit("0", "0"),
            left: FGVec2::lit("-1", "0.5"),
            right: FGVec2::lit("1", "0.5"),
        };
        let desired = FighterDesiredECB {
            top: FGVec2::lit("0", "3"),
            bottom: FGVec2::lit("0", "-1"),
            left: FGVec2::lit("-2", "1"),
            right: FGVec2::lit("2", "1"),
        };
        interpolate_ecb(&mut current, desired, FGi32::ONE);
        assert_eq!(current.top, desired.top);
        assert_eq!(current.bottom, desired.bottom);
        assert_eq!(current.left, desired.left);
        assert_eq!(current.right, desired.right);
    }
    #[test]
    fn validation_repairs_tiny_and_out_of_range_diamond() {
        let mut desired = FighterDesiredECB {
            top: FGVec2::lit("0", "0.25"),
            bottom: FGVec2::lit("0", "0"),
            left: FGVec2::lit("0", "4"),
            right: FGVec2::lit("0", "-4"),
        };
        desired.validate();
        assert_eq!(desired.top.y, FGi32::lit("1.25"));
        assert_eq!(desired.left.x, FGi32::lit("-1"));
        assert_eq!(desired.right.x, FGi32::lit("1"));
        assert_eq!(desired.left.y, FGi32::lit("0.625"));
        assert_eq!(desired.right.y, FGi32::lit("0.625"));
    }
    #[test]
    fn rebasing_onto_bottom_preserves_world_points() {
        let origin = FGVec2::lit("4", "8");
        let mut ecb = FighterECB {
            top: FGVec2::lit("0", "3"),
            bottom: FGVec2::lit("0", "-1"),
            left: FGVec2::lit("-2", "1"),
            right: FGVec2::lit("2", "1"),
        };
        let old_world_points = [ecb.top, ecb.bottom, ecb.left, ecb.right].map(|p| origin + p);
        let new_origin = origin + ecb.bottom;
        ecb.rebase_onto_bottom();
        let new_world_points = [ecb.top, ecb.bottom, ecb.left, ecb.right].map(|p| new_origin + p);
        assert_eq!(old_world_points, new_world_points);
        assert_eq!(ecb.bottom, FGVec2::ZERO);
    }
 }
@@ -8,11 +8,7 @@ use strum::IntoEnumIterator;
 use strum_macros::EnumIter;
 use crate::{
-    AppState,
+    AppState, fighter::{FighterAttributes, FighterCameraProfile, animation::AnimKind, attack::AttackKind}, game_settings::GameSettings, math::{int::FGi32, vec::FGVec2, vec3::FGVec3}, texture_reference::TextureReference,
    fighter::{FighterAttributes, FighterCameraProfile, animation::AnimKind, attack::AttackKind},
    game_settings::GameSettings,
    math::{int::FGi32, vec3::FGVec3},
    texture_reference::TextureReference,
 };
 #[derive(
@@ -62,10 +58,19 @@ pub struct FighterManifest {
    pub icon: TextureReference,
    pub attributes: FighterAttributes,
    pub camera: FighterCameraProfile,
    /// Bone whose model-space translation drives gameplay root motion.
    #[serde(default = "default_root_motion_bone")]
    pub root_motion_bone: String,
    pub animations: HashMap<AnimKind, String>,
    pub attack_scripts: HashMap<AttackKind, String>,
    pub hurtboxes: Vec<FighterHurtbox>,
    pub ecb_bones: Vec<String>,
    pub ledge_grab_box_start: FGVec2,
    pub ledge_grab_box_end: FGVec2,
 }
 fn default_root_motion_bone() -> String {
    "root".into()
 }
 #[derive(Resource)]
@@ -10,6 +10,7 @@ pub mod animation;
 pub mod attack;
 pub mod attributes;
 pub mod baked_animation;
 pub mod blast_zones;
 pub mod collision;
 pub mod debug;
 pub mod ecb;
@@ -17,10 +18,10 @@ pub mod errors;
 pub mod hurtbox;
 pub mod manifest;
 pub mod motion;
 pub mod push;
 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
@@ -36,13 +37,25 @@ pub use motion::{
 pub use surface::FighterSurfaceState;
 use crate::{
-    AppState, fighter::{
+    AppState,
    fighter::{
        attack::{
            AttackKind, FighterAttackPlugin, FighterAttackScriptAssets, FighterDamage,
-            FighterKnockbackVelocity, FighterPendingHitReaction, FighterSolvedHurtboxes,
+            FighterKnockbackState, FighterKnockbackVelocity, FighterPendingHitReaction,
-            FighterStaleMoveQueue,
+            FighterSolvedHurtboxes, FighterStaleMoveQueue,
-        }, baked_animation::{FighterBoneIndexMap, FighterBoneMatrices}, ecb::FighterECBBoneIndices, manifest::FighterManifest, state::{FighterState, air::AirborneStateCommon, fall::FallState}, visual::{FighterAnimations, FighterInvulnerabilityVisualState},
+        },
-    }, game_settings::GameSettings, input::FighterInput, math::{int::FGi32, vec::FGVec2}, player::Player, schedule::GameplaySet, scripting::FighterAttackScript, stage::line::StageCollision,
+        baked_animation::FighterBoneIndexMap,
        ecb::{FighterDesiredECB, FighterECBBoneIndices},
        manifest::FighterManifest,
        state::{FighterState, air::AirborneStateCommon, fall::FallState},
        visual::{FighterAnimations, FighterInvulnerabilityVisualState},
    },
    game_settings::GameSettings,
    input::FighterInput,
    math::{int::FGi32, vec::FGVec2},
    player::Player,
    schedule::GameplaySet,
    scripting::FighterAttackScript,
 };
 use state::state_interrupt_system;
@@ -85,12 +98,62 @@ pub struct FighterHitstop {
    pub remaining_frames: u32,
 }
 #[derive(Component, Default, Copy, Clone, Hash, Debug, PartialEq, Eq)]
 pub struct FighterLedgeInformation {
    pub regrab_lockout_remaining_frames: u32,
    pub grab_count: u32,
 }
 impl FighterLedgeInformation {
    pub fn start(&mut self, duration_frames: u32) {
        self.regrab_lockout_remaining_frames = duration_frames;
    }
    pub fn is_regrab_lockout_active(&self) -> bool {
        self.regrab_lockout_remaining_frames > 0
    }
    fn tick(&mut self) {
        self.regrab_lockout_remaining_frames =
            self.regrab_lockout_remaining_frames.saturating_sub(1);
    }
 }
 #[cfg(test)]
 mod ledge_grab_lockout_tests {
    use super::FighterLedgeInformation;
    #[test]
    fn lockout_expires_after_the_requested_number_of_ticks() {
        let mut lockout = FighterLedgeInformation::default();
        lockout.start(2);
        assert!(lockout.is_regrab_lockout_active());
        lockout.tick();
        assert!(lockout.is_regrab_lockout_active());
        lockout.tick();
        assert!(!lockout.is_regrab_lockout_active());
    }
    #[test]
    fn zero_duration_does_not_enable_lockout() {
        let mut lockout = FighterLedgeInformation::default();
        lockout.start(0);
        assert!(!lockout.is_regrab_lockout_active());
    }
 }
 #[derive(Component, Default, Copy, Clone, Hash)]
 pub enum FighterInvulnerabilityState {
    #[default]
    Vulnerable,
-    Invulnerable { frames_remaining: Option<u32> },
+    Invulnerable {
-    Intangible { frames_remaining: Option<u32> }
+        frames_remaining: Option<u32>,
    },
    Intangible {
        frames_remaining: Option<u32>,
    },
 }
 impl FighterFacingDirection {
@@ -147,10 +210,12 @@ pub struct FighterPendingRespawn(bool);
    FighterPendingHitReaction,
    FighterPendingRespawn,
    FighterHitstop,
    FighterLedgeInformation,
    FighterKnockbackVelocity,
    FighterKnockbackState,
    FighterTranslation,
    FighterInvulnerabilityState,
-    FighterInvulnerabilityVisualState,
+    FighterInvulnerabilityVisualState
 )]
 pub struct Fighter {
    pub manifest: Handle<FighterManifest>,
@@ -179,7 +244,10 @@ impl Plugin for FighterPlugin {
            )
            .add_systems(
                GgrsSchedule,
-                (state::state_update_system, decay_hitstop, decay_invulnerability)
+                (
                    state::state_update_system,
                    decay_invulnerability,
                )
                    .chain()
                    .in_set(GameplaySet::StateUpdate),
            )
@@ -192,12 +260,27 @@ impl Plugin for FighterPlugin {
            .add_systems(
                GgrsSchedule,
                (
-                    (blast_zones::apply_blast_zones, ecb::update_ecb, ecb::decrement_ecb_lockout, state::state_collision_interrupt_system).chain(),
+                    (
                        blast_zones::apply_blast_zones,
                        ecb::decrement_ecb_lockout,
                        ecb::update_ecb,
                        state::state_collision_interrupt_system,
                        // Every gameplay phase must observe the same hitstop value.
                        decay_hitstop,
                        decay_ledge_grab_lockout,
                    )
                        .chain(),
                    baked_animation::resample_fighter_bone_matrices,
                )
                    .chain()
                    .in_set(GameplaySet::Collision),
            )
            .add_systems(
                GgrsSchedule,
                push::apply_grounded_pushes
                    .before(state::state_update_system)
                    .in_set(GameplaySet::StateUpdate),
            )
            .add_systems(
                PostUpdate,
                (
@@ -205,6 +288,7 @@ impl Plugin for FighterPlugin {
                    animation::apply_animation,
                )
                    .chain()
                    .before(bevy::transform::TransformSystems::Propagate)
                    .run_if(in_state(crate::AppState::InMatch)),
            )
            // Rollback registration lives next to the systems that write these
@@ -212,6 +296,8 @@ impl Plugin for FighterPlugin {
            // is a desync waiting to happen.
            .rollback_component_with_copy::<FighterECB>()
            .checksum_component_with_hash::<FighterECB>()
            .rollback_component_with_copy::<FighterDesiredECB>()
            .checksum_component_with_hash::<FighterDesiredECB>()
            .rollback_component_with_clone::<FighterStaleMoveQueue>()
            .checksum_component_with_hash::<FighterStaleMoveQueue>()
            .rollback_component_with_copy::<ecb::FighterPreviousECB>()
@@ -239,16 +325,25 @@ impl Plugin for FighterPlugin {
            .checksum_component_with_hash::<FighterPendingRespawn>()
            .rollback_component_with_copy::<FighterHitstop>()
            .checksum_component_with_hash::<FighterHitstop>()
            .rollback_component_with_copy::<FighterLedgeInformation>()
            .checksum_component_with_hash::<FighterLedgeInformation>()
            .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>()
+            .rollback_component_with_copy::<FighterKnockbackState>()
            .checksum_component_with_hash::<FighterKnockbackState>()
            .rollback_component_with_clone::<baked_animation::FighterBoneMatrices>()
            .checksum_component_with_hash::<baked_animation::FighterBoneMatrices>()
            // Debug views.
            .add_systems(
                FixedPostUpdate,
                debug::debug_draw_ecb.run_if(crate::debug_tools::ecb_enabled),
            )
            .add_systems(
                FixedPostUpdate,
                debug::ledge_grab_debug.run_if(crate::debug_tools::ledge_grab_enabled),
            )
            .add_systems(
                EguiPrimaryContextPass,
                debug::fighter_debug.run_if(crate::debug_tools::fighter_info_enabled),
@@ -268,8 +363,9 @@ impl Plugin for FighterPlugin {
                    .run_if(crate::debug_tools::attack_hitboxes_enabled)
                    .run_if(in_state(AppState::InMatch)),
            )
-            .add_systems(FixedPostUpdate, 
+            .add_systems(
-                visual::update_status_colors.run_if(resource_exists::<GameSettings>)
+                FixedPostUpdate,
                visual::update_status_colors.run_if(resource_exists::<GameSettings>),
            )
            .add_systems(
                FixedPostUpdate,
@@ -277,11 +373,8 @@ impl Plugin for FighterPlugin {
            )
            .rollback_component_with_clone::<FighterState>()
            .rollback_component_with_clone::<FighterHitboxes>()
            .rollback_component_with_clone::<FighterBoneMatrices>()
            .rollback_component_with_clone::<FighterHitstopShake>()
            .checksum_component_with_hash::<FighterHitboxes>()
            .rollback_component_with_clone::<FighterSolvedHurtboxes>()
            .checksum_component_with_hash::<FighterSolvedHurtboxes>()
            .checksum_component_with_hash::<FighterState>()
            .checksum_component_with_hash::<FighterFacingDirection>()
            .register_type::<FighterFacingDirection>();
@@ -293,10 +386,16 @@ pub struct FighterActiveAttack {
    pub script: Handle<FighterAttackScript>,
    pub active_hitboxes: Vec<usize>,
    pub solved_hitboxes: Vec<attack::FighterSolvedHitbox>,
-    pub hit_fighters: Vec<Entity>,
+    pub hit_groups: Vec<FighterHitGroupState>,
    pub stalled: bool,
 }
 #[derive(Clone, Debug, Hash)]
 pub struct FighterHitGroupState {
    pub group: u32,
    pub hit_fighters: Vec<Entity>,
 }
 #[derive(Component, Clone, Debug, Default, Hash)]
 pub struct FighterHitboxes(pub Option<FighterActiveAttack>);
@@ -326,10 +425,11 @@ pub fn spawn_fighter(
            Transform::from_scale(Vec3::splat(model_scale.to_num())),
            (
                FighterECB::default(),
                FighterDesiredECB::default(),
                FighterHitboxes::default(),
                FighterECBBoneIndices {
-                    indices: ecb_bone_indices
+                    indices: ecb_bone_indices,
-                }
+                },
            ),
            (
                FighterVelocity::default(),
@@ -361,6 +461,12 @@ pub fn decay_hitstop(query: Query<(&mut FighterHitstop, &mut FighterHitstopShake
    }
 }
 pub fn decay_ledge_grab_lockout(query: Query<&mut FighterLedgeInformation>) {
    for mut lockout in query {
        lockout.tick();
    }
 }
 pub fn decay_invulnerability(query: Query<&mut FighterInvulnerabilityState>) {
    for invuln_state in query {
        let invuln_state = invuln_state.into_inner();
@@ -373,7 +479,7 @@ pub fn decay_invulnerability(query: Query<&mut FighterInvulnerabilityState>) {
                } else {
                    None
                }
-            },
+            }
            FighterInvulnerabilityState::Intangible { frames_remaining } => {
                if let Some(frames_remaining) = frames_remaining {
                    *frames_remaining = frames_remaining.saturating_sub(1);
@@ -381,7 +487,7 @@ pub fn decay_invulnerability(query: Query<&mut FighterInvulnerabilityState>) {
                } else {
                    None
                }
-            },
+            }
        };
        if let Some(frames_remaining) = frames_remaining {
@@ -0,0 +1,214 @@
 //! fighter-to-fighter pushing
 use bevy::prelude::*;
 use crate::{
    fighter::{
        Fighter, FighterFacingDirection, FighterRoster, FighterSurfaceState, FighterTranslation,
        manifest::FighterManifest,
    },
    game_settings::GameSettings,
    math::int::FGi32,
    stage::line::{StageCollision, StageLineID, StagePoly},
 };
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 struct Pushbox {
    center: FGi32,
    radius: FGi32,
    line_id: StageLineID,
 }
 fn can_interact(stage: &StageCollision, first: StageLineID, second: StageLineID) -> bool {
    if first.polygon != second.polygon {
        return false;
    }
    if first.segment == second.segment {
        return true;
    }
    let Some(poly) = stage.stage_polys.get(first.polygon) else {
        return false;
    };
    adjacent_segment(poly, first.segment, second.segment)
 }
 fn adjacent_segment(poly: &StagePoly, first: usize, second: usize) -> bool {
    poly.get_next_segment_index(first) == Some(second)
        || poly.get_prev_segment_index(first) == Some(second)
 }
 fn push_delta(first: Pushbox, second: Pushbox, nudge: FGi32) -> FGi32 {
    if (first.center - second.center).abs() >= first.radius + second.radius {
        return FGi32::ZERO;
    }
    (first.center - second.center).signum() * nudge
 }
 fn calculate_push_deltas(
    pushboxes: &[Option<Pushbox>],
    stage: &StageCollision,
    nudge: FGi32,
 ) -> Vec<FGi32> {
    let mut deltas = vec![FGi32::ZERO; pushboxes.len()];
    for first in 0..pushboxes.len() {
        let Some(first_pushbox) = pushboxes[first] else {
            continue;
        };
        for second in 0..pushboxes.len() {
            if first == second {
                continue;
            }
            let Some(second_pushbox) = pushboxes[second] else {
                continue;
            };
            if can_interact(stage, first_pushbox.line_id, second_pushbox.line_id) {
                deltas[first] += push_delta(first_pushbox, second_pushbox, nudge);
            }
        }
    }
    deltas
 }
 pub fn apply_grounded_pushes(
    roster: Res<FighterRoster>,
    mut fighters: Query<(
        &Fighter,
        &mut FighterTranslation,
        &FighterFacingDirection,
        &FighterSurfaceState,
    )>,
    manifests: Res<Assets<FighterManifest>>,
    settings: Res<GameSettings>,
    stage: Res<StageCollision>,
 ) {
    let pushboxes = roster
        .0
        .iter()
        .map(|entity| {
            let Ok((fighter, translation, facing, surface)) = fighters.get(*entity) else {
                return None;
            };
            let Some(line_id) = surface.line_id() else {
                return None;
            };
            let manifest = manifests.get(&fighter.manifest)?;
            let attributes = &manifest.attributes;
            Some(Pushbox {
                center: translation.x + facing.to_sign() * attributes.pushbox_offset,
                radius: attributes.pushbox_radius,
                line_id,
            })
        })
        .collect::<Vec<_>>();
    let deltas = calculate_push_deltas(
        &pushboxes,
        &stage,
        settings.fighter_common.grounded_push_nudge,
    );
    for (entity, delta) in roster.0.iter().zip(deltas) {
        if delta == FGi32::ZERO {
            continue;
        }
        if let Ok((_, mut translation, _, _)) = fighters.get_mut(*entity) {
            translation.x += delta;
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::math::vec::FGVec2;
    use crate::stage::line::{StagePolyLineSegmentType, StagePolyType};
    fn stage() -> StageCollision {
        StageCollision {
            stage_polys: vec![StagePoly::build(
                StagePolyType::Platform,
                &[
                    (FGVec2::lit("0", "0"), StagePolyLineSegmentType::Floor),
                    (FGVec2::lit("10", "0"), StagePolyLineSegmentType::Floor),
                    (FGVec2::lit("20", "0"), StagePolyLineSegmentType::Floor),
                    (FGVec2::lit("30", "0"), StagePolyLineSegmentType::Floor),
                ],
            )],
            ..StageCollision::default()
        }
    }
    fn box_at(x: &str, segment: usize) -> Pushbox {
        Pushbox {
            center: FGi32::lit(x),
            radius: FGi32::lit("1"),
            line_id: StageLineID {
                polygon: 0,
                segment,
            },
        }
    }
    #[test]
    fn overlapping_pair_gets_opposite_fixed_nudges() {
        let deltas = calculate_push_deltas(
            &[Some(box_at("0", 0)), Some(box_at("1", 0))],
            &stage(),
            FGi32::lit("0.3"),
        );
        assert_eq!(deltas, vec![FGi32::lit("-0.3"), FGi32::lit("0.3")]);
    }
    #[test]
    fn touching_pushboxes_do_not_nudge() {
        let deltas = calculate_push_deltas(
            &[Some(box_at("0", 0)), Some(box_at("2", 0))],
            &stage(),
            FGi32::lit("0.3"),
        );
        assert_eq!(deltas, vec![FGi32::ZERO, FGi32::ZERO]);
    }
    #[test]
    fn adjacent_segments_can_push_and_unrelated_segments_cannot() {
        let adjacent = calculate_push_deltas(
            &[Some(box_at("9.5", 0)), Some(box_at("10", 1))],
            &stage(),
            FGi32::lit("0.3"),
        );
        assert_eq!(adjacent, vec![FGi32::lit("-0.3"), FGi32::lit("0.3")]);
        let unrelated = calculate_push_deltas(
            &[Some(box_at("1", 0)), Some(box_at("2", 2))],
            &stage(),
            FGi32::lit("0.3"),
        );
        assert_eq!(unrelated, vec![FGi32::ZERO, FGi32::ZERO]);
    }
    #[test]
    fn multiple_overlaps_accumulate() {
        let deltas = calculate_push_deltas(
            &[
                Some(box_at("0", 0)),
                Some(box_at("0.5", 0)),
                Some(box_at("1", 0)),
            ],
            &stage(),
            FGi32::lit("0.3"),
        );
        assert_eq!(
            deltas,
            vec![FGi32::lit("-0.6"), FGi32::ZERO, FGi32::lit("0.6")]
        );
    }
    #[test]
    fn system_parameters_initialize_without_query_conflicts() {
        let mut world = World::new();
        let mut schedule = Schedule::default();
        schedule.add_systems(apply_grounded_pushes);
        schedule.initialize(&mut world).unwrap();
    }
 }
@@ -1,6 +1,9 @@
-use crate::fighter::state::jump::{JumpState, JumpType};
+use crate::fighter::state::jump::{self};
 use crate::fighter::state::land::{LandingState, LandingType};
-use crate::fighter::state::{CollisionContext, FighterState, InterruptContext, air_attack, air_dodge};
+use crate::fighter::state::ledge_grab::LedgeGrabState;
 use crate::fighter::state::{
    CollisionContext, FighterState, InterruptContext, air_attack, air_dodge,
 };
 use crate::fighter::*;
 use crate::input::FighterCommands;
@@ -90,6 +93,19 @@ pub fn apply_air_motion(
    translation.0 += velocity.0;
 }
 /// Applies ordinary and launch velocity together, then advances launch decay.
 /// Hitstop skips state updates entirely, so neither decay nor launch age moves
 /// while the fighter is frozen.
 pub fn apply_air_motion_with_knockback(ctx: &mut crate::fighter::state::UpdateContext) {
    let combined_velocity = FighterVelocity(ctx.velocity.0 + ctx.knockback_velocity.0);
    apply_air_motion(&combined_velocity, ctx.translation, ctx.prev_translation);
    attack::decay_knockback(
        ctx.knockback_velocity,
        ctx.knockback_state,
        ctx.game_settings.fighter_common.knockback_decay_per_frame,
    );
 }
 pub fn update_standard_motion(
    ctx: &mut crate::fighter::state::UpdateContext,
    airborne_common: &mut AirborneStateCommon,
@@ -106,38 +122,40 @@ pub fn update_standard_motion(
        airborne_common.is_fast_falling,
    );
    apply_air_drift(ctx.velocity, ctx.fighter_attributes, ctx.input);
-    apply_air_motion(
+    apply_air_motion_with_knockback(ctx);
        ctx.velocity,
        ctx.translation,
        ctx.prev_translation,
    );
 }
-pub fn air_interrupts_common(ctx: &mut InterruptContext, airborne_state_common: &AirborneStateCommon) -> Option<FighterState> {
+pub fn air_interrupts_common(
-    if ctx.input.has_command(FighterCommands::Jump) {
+    ctx: &mut InterruptContext,
-            Some(FighterState::Jump(JumpState {
+    airborne_state_common: &AirborneStateCommon,
-                jump_type: JumpType::DoubleJump,
+) -> Option<FighterState> {
-                airborne_state_common: AirborneStateCommon::default(),
+    jump::check_input_double_jump(ctx).or_else(|| {
-            }))
+        air_dodge::check_input(ctx)
-    } else {
+            .or_else(|| air_attack::check_interrupt(ctx, airborne_state_common))
-        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,
+    options: crate::fighter::collision::AirCollisionOptions,
 ) -> Option<FighterState> {
-    let res = ctx.air_collide_with_stage(can_ignore_soft_platforms)?;
+    if ctx.velocity.y <= FGi32::ZERO {
-    let diff = res.hit_position - ctx.translation.0;
+        if let Some(ledge_result) = ctx.air_collide_with_ledges() {
-    ctx.ecb.bottom -= diff;
+            ctx.apply_desired_ecb();
-    ctx.ecb.top -= diff;
+            return Some(FighterState::LedgeGrab(LedgeGrabState::new(ledge_result.ledge)));
-    ctx.ecb.left -= diff;
+        }
-    ctx.ecb.right -= diff;
+    }
-    ctx.translation.0 = res.hit_position;
+
    let res = ctx.air_collide_with_stage(options)?;
    ctx.translation.0 = res.resolved_translation;
    let bottom_offset = ctx.ecb.rebase_onto_bottom();
    ctx.translation.0 += bottom_offset;
    *ctx.desired_ecb = crate::fighter::ecb::FighterDesiredECB::from(*ctx.ecb);
    ctx.presentation_snap.0 = true;
-    ctx.surface.land(res.line_id);
+    ctx.surface.land(res.line_id, ctx.ledge_info);
    ctx.knockback_velocity.0 = FGVec2::ZERO;
    ctx.knockback_state.clear();
    Some(FighterState::Land(LandingState::create(landing_type)))
 }
@@ -151,6 +169,8 @@ mod tests {
    fn test_attributes() -> FighterAttributes {
        FighterAttributes {
            pushbox_offset: FGi32::ZERO,
            pushbox_radius: FGi32::ONE,
            base_walk_accel: FGi32::ZERO,
            stick_walk_accel: FGi32::ZERO,
            max_walk_vel: FGi32::ZERO,
@@ -183,6 +203,7 @@ mod tests {
            air_dodge_decay: FGi32::ZERO,
            air_dodge_intangible_duration: 29,
            air_dodge_intangible_start: 4,
            dash_attack_cancel_window: 3,
        }
    }
@@ -1,23 +1,42 @@
 use bevy::log::error;
 use crate::fighter::{
-    attack::{AttackKind, FighterAttackScriptAssets, update_active_hitbox_list}, state::{
+    attack::{AttackKind, FighterAttackScriptAssets, update_active_attack}, state::{
-        CollisionContext, EnterContext, ExitContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, fall::FallState,
+        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 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)))
+            Some(FighterState::Fall(FallState::new(
                self.airborne_state_common,
            )))
        } else {
            None
        }
@@ -29,16 +48,19 @@ impl FighterStateImpl for AirAttackState {
            .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,
            );
            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);
@@ -55,7 +77,7 @@ impl FighterStateImpl for AirAttackState {
            script,
            active_hitboxes: Vec::new(),
            solved_hitboxes: Vec::new(),
-            hit_fighters: Vec::new(),
+            hit_groups: Vec::new(),
            stalled: false,
        });
    }
@@ -68,11 +90,20 @@ impl FighterStateImpl for AirAttackState {
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
-        air::collision_interrupt(
+        let coll_interrupt = air::collision_interrupt(
            state_context,
            crate::fighter::state::land::LandingType::Normal,
-            false,
+            Default::default(),
-        )
+        );
        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 {
@@ -83,25 +114,33 @@ impl FighterStateImpl for AirAttackState {
 #[derive(thiserror::Error, Debug)]
 pub enum AirAttackStateCreateError {
    #[error("Attack script: {attack:?} not found")]
-    AttackScriptNotFound{attack: AttackKind},
+    AttackScriptNotFound { attack: AttackKind },
 }
 impl AirAttackState {
-    pub fn create(attack_kind: AttackKind, attack_script_assets: &FighterAttackScriptAssets, airborne_state_common: &AirborneStateCommon) -> Result<Self, AirAttackStateCreateError> {
+    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
+                attack_kind,
                is_in_autocancel_window: false,
            })
        } else {
-            Err(AirAttackStateCreateError::AttackScriptNotFound { attack: attack_kind })
+            Err(AirAttackStateCreateError::AttackScriptNotFound {
                attack: attack_kind,
            })
        }
    }
 }
-
+pub fn check_interrupt(
-pub fn check_interrupt(state_context: &InterruptContext, airborne_state_common: &AirborneStateCommon) -> Option<FighterState> {
+    state_context: &InterruptContext,
    airborne_state_common: &AirborneStateCommon,
 ) -> Option<FighterState> {
    if state_context
        .input
        .has_command(crate::input::FighterCommands::Attack)
@@ -110,16 +149,18 @@ pub fn check_interrupt(state_context: &InterruptContext, airborne_state_common:
            .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);
+        let state = AirAttackState::create(
            attack_kind,
            state_context.attack_script_assets,
            airborne_state_common,
        );
        match state {
-            Ok(state) => {
+            Ok(state) => Some(FighterState::AirAttack(state)),
                Some(FighterState::AirAttack(state))
            },
            Err(create_error) => {
                error!("{}", create_error);
                None
-            },
+            }
        }
    } else {
        None
@@ -1,17 +1,9 @@
 use crate::{
    fighter::{
-        FighterInvulnerabilityState,
+        FighterInvulnerabilityState, animation::AnimKind, state::{
-        animation::AnimKind,
+            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, fall::FallState, land::{LandingState, LandingType},
        state::{
            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext,
            UpdateContext,
            air::{self, AirborneStateCommon},
            fall::FallState,
            land::LandingType,
        },
-    },
+    }, input, math::vec::FGVec2, stage::line::{StageLineID, StagePolyLineSegmentType},
    input,
    math::vec::FGVec2,
 };
 #[derive(Debug, Clone, Hash)]
@@ -41,18 +33,44 @@ impl FighterStateImpl for AirDodgeState {
        }
        state_context.velocity.0 *= state_context.fighter_attributes.air_dodge_decay;
-        air::apply_air_motion(
+        air::apply_air_motion_with_knockback(state_context);
            state_context.velocity,
            state_context.translation,
            state_context.prev_translation,
        );
    }
    fn check_collision_interrupt(
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
-        air::collision_interrupt(state_context, LandingType::Special, false)
+        let can_wavesnap = self.direction.y.is_zero() || self.direction.y.is_negative();
        if can_wavesnap {
            for (poly_idx, poly) in state_context.stage_collision.stage_polys.iter().enumerate() {
                for (segment_idx, segment) in poly.segments.iter().enumerate() {
                    if !matches!(segment.segment_type, StagePolyLineSegmentType::Floor) {
                        continue;
                    }
                    let bottom_point = state_context.translation.0 + state_context.ecb.get_bottom_point();
                    let point_in_segment = segment.segment.closest_point(bottom_point);
                    let dist_to_segment = point_in_segment.distance(bottom_point);
                    if dist_to_segment <= state_context.waveland_snap_distance {
                        state_context.ecb.bottom = point_in_segment - state_context.translation.0;
                        state_context.ecb.rebase_onto_bottom();
                        state_context.surface.land(StageLineID { polygon: poly_idx, segment: segment_idx }, state_context.ledge_info);
                        state_context.knockback_velocity.0 = FGVec2::ZERO;
                        state_context.knockback_state.clear();
                        return Some(FighterState::Land(LandingState::create(LandingType::Special)));
                    }
                }
            }
        }
        air::collision_interrupt(
            state_context,
            LandingType::Special,
            crate::fighter::collision::AirCollisionOptions {
                land_on_soft_platforms_from_below: true,
                ..Default::default()
            },
        )
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
@@ -43,8 +43,9 @@ impl FighterStateImpl for AngelState {
    fn check_collision_interrupt(
        &mut self,
-        _state_context: &mut super::CollisionContext,
+        state_context: &mut super::CollisionContext,
    ) -> Option<super::FighterState> {
        state_context.apply_desired_ecb();
        None
    }
@@ -148,6 +148,15 @@ impl FighterStateImpl for CrouchState {
    }
 }
 impl CrouchState {
    pub fn is_crouch_cancelling(&self) -> bool {
        match self.sub_state {
            CrouchSubState::Entering { .. } | CrouchSubState::Idle => true,
            CrouchSubState::Exiting => false,
        }
    }
 }
 pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
    let input_frame = state_context.input.get_last_frame();
@@ -4,7 +4,7 @@ use super::{
 };
 use crate::fighter::FighterFacingDirection;
 use crate::fighter::animation::AnimKind;
-use crate::fighter::state::FighterState;
+use crate::fighter::state::{FighterState, ground_attack};
 use crate::input::FighterCommands::{SmashMoveLeft, SmashMoveRight};
 #[derive(Debug, Clone, Hash)]
@@ -23,6 +23,16 @@ impl FighterStateImpl for DashState {
    fn check_interrupt(&self, ctx: &mut InterruptContext) -> Option<FighterState> {
        let attributes = ctx.fighter_attributes;
        if ctx.get_current_animation_frame() <= 2 || ctx.input.get_last_frame().movement.x.signum() != self.direction.to_sign() {
            if let Some(state) = ground_attack::check_interrupt(ctx) {
                return Some(state);
            }
        } else {
            if let Some(state) = ground_attack::check_interrupt_dash_attack(ctx) {
                return Some(state);
            }
        }
        // A reverse dash can interrupt before IASA
        if let Some(direction) =
            check_smash_input_with_dir(ctx).filter(|direction| *direction != self.direction)
@@ -89,7 +99,6 @@ impl FighterStateImpl for DashState {
        ground::apply_grounded_motion(
            state_context.velocity,
            state_context.translation,
            state_context.prev_translation,
        );
    }
@@ -25,6 +25,7 @@ impl FighterStateImpl for FallState {
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        state_context.play_animation(AnimKind::Fall, true);
        state_context.velocity.x = state_context.velocity.x.clamp(-state_context.fighter_attributes.air_drift_max, state_context.fighter_attributes.air_drift_max);
    }
    fn update(&mut self, state_context: &mut UpdateContext) {
@@ -38,7 +39,10 @@ impl FighterStateImpl for FallState {
        air::collision_interrupt(
            state_context,
            crate::fighter::state::land::LandingType::Normal,
-            true,
+            crate::fighter::collision::AirCollisionOptions {
                can_pass_through_soft_platforms: true,
                ..Default::default()
            },
        )
    }
@@ -2,16 +2,20 @@
 //! ECS types so it stays cheap to reason about and to unit-test — it has to be
 //! bit-for-bit deterministic for rollback.
 use crate::fighter::state::air_dodge::AirDodgeState;
 use crate::fighter::state::{
-    CollisionContext, FighterState, InterruptContext, air, crouch, 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,
 };
 use crate::fighter::{collision, ecb};
 use crate::fighter::{FighterAttributes, FighterTranslation, FighterVelocity};
 use crate::game_settings::GameSettings;
 use crate::input::FighterInput;
 use crate::math::int::{FGWide, FGi32};
 use crate::math::vec::FGVec2;
-use crate::stage::line::{StageLineID, StagePoly, StagePolyLineSegment, StagePolyLineSegmentType};
+use crate::stage::line::{StagePoly, StagePolyLineSegment, StagePolyLineSegmentType};
 #[cfg(test)]
 use crate::stage::line::StageLineID;
 pub fn apply_grounded_friction(friction: FGi32, ground_vel: FGi32) -> FGi32 {
    if friction.abs() > ground_vel.abs() {
@@ -146,13 +150,8 @@ fn resolve_grounded_position(
    GroundedPositionResult::InAir
 }
-pub fn apply_grounded_motion(
+pub fn apply_grounded_motion(velocity: &FighterVelocity, translation: &mut FighterTranslation) {
    velocity: &FighterVelocity,
    translation: &mut FighterTranslation,
    prev_translation: &mut FighterPreviousTranslation,
 ) {
    // Vertical velocity should be 0 on the ground
    prev_translation.0 = translation.0;
    translation.0 += FGVec2::new(velocity.0.x, FGi32::ZERO);
 }
@@ -169,68 +168,84 @@ pub fn update_friction_motion(ctx: &mut crate::fighter::state::UpdateContext) {
    let ground_velocity = ctx.velocity.x;
    ctx.velocity.x += apply_grounded_friction(friction, ground_velocity);
-    apply_grounded_motion(ctx.velocity, ctx.translation, ctx.prev_translation);
+    apply_grounded_motion(ctx.velocity, ctx.translation);
 }
 pub fn collide_with_stage_grounded(
    state_context: &mut CollisionContext,
    can_walk_off: bool,
 ) -> GroundedMotionResult {
-    let translation = &mut state_context.translation;
+    let Some(mut line_id) = state_context.surface.line_id() else {
-    let ecb = &state_context.ecb;
+        state_context.apply_desired_ecb();
    let stage_collision = state_context.stage_collision;
    let Some(current_line_id) = state_context.surface.line_id() else {
        return GroundedMotionResult::InAir;
    };
    let requested_translation = state_context.translation.0;
    let movement = requested_translation - state_context.prev_translation.0;
    let largest_change = movement
        .x
        .abs()
        .max(movement.y.abs())
        .max(ecb::ecb_max_delta(state_context.ecb, state_context.desired_ecb));
    let steps = collision::collision_step_count(largest_change);
    let movement_per_step = movement / FGi32::from_num(steps);
    let mut current_position = state_context.prev_translation.0;
    let mut current_ecb = *state_context.ecb;
-    let stage_poly = stage_collision.stage_polys.get(current_line_id.polygon);
+    for step in 0..steps {
        ecb::interpolate_ecb(
            &mut current_ecb,
            *state_context.desired_ecb,
            FGi32::ONE / FGi32::from_num(steps - step),
        );
        current_position = if step + 1 == steps {
            requested_translation
        } else {
            state_context.prev_translation.0
                + movement_per_step * FGi32::from_num(step + 1)
        };
-    if let Some(stage_poly) = stage_poly {
+        let Some(stage_poly) = state_context.stage_collision.stage_polys.get(line_id.polygon) else {
-        let ecb_bottom_pos = translation.0 + ecb.get_bottom_point();
+            *state_context.ecb = current_ecb;
            state_context.translation.0 = current_position;
            state_context.surface.apply_airborne_policy(
                crate::fighter::surface::EcbLockPolicy::StartOnDetach,
                state_context.leave_ground_ecb_lock_duration,
            );
            return GroundedMotionResult::InAir;
        };
        match resolve_grounded_position(
            stage_poly,
-            current_line_id.segment,
+            line_id.segment,
-            ecb_bottom_pos,
+            current_position + current_ecb.bottom,
            can_walk_off,
        ) {
-            GroundedPositionResult::InGround {
+            GroundedPositionResult::InGround { point, segment_idx, blocked } => {
-                point,
+                line_id.segment = segment_idx;
-                segment_idx,
+                current_position = point - current_ecb.bottom;
-                blocked,
+                let segment = stage_poly.get_segment(segment_idx).unwrap();
            } => {
                let current_segment = stage_poly.get_segment(segment_idx).unwrap();
                translation.0 = point - ecb.get_bottom_point();
                state_context.velocity.0 = if blocked {
                    FGVec2::ZERO
                } else {
                    state_context.velocity.0
-                        - state_context
+                        - state_context.velocity.0.project_onto_normalized(segment.normal)
                            .velocity
                            .0
                            .project_onto_normalized(current_segment.normal)
                };
                state_context.surface.land(StageLineID {
                    polygon: current_line_id.polygon,
                    segment: segment_idx,
                });
                GroundedMotionResult::InGround
            }
            GroundedPositionResult::InAir => {
                *state_context.ecb = current_ecb;
                state_context.translation.0 = current_position;
                state_context.surface.apply_airborne_policy(
                    crate::fighter::surface::EcbLockPolicy::StartOnDetach,
                    state_context.leave_ground_ecb_lock_duration,
                );
-                GroundedMotionResult::InAir
+                return GroundedMotionResult::InAir;
            }
        }
    } else {
        state_context.surface.apply_airborne_policy(
            crate::fighter::surface::EcbLockPolicy::StartOnDetach,
            state_context.leave_ground_ecb_lock_duration,
        );
        GroundedMotionResult::InAir
    }
    *state_context.ecb = current_ecb;
    state_context.translation.0 = current_position;
    state_context.surface.land(line_id, state_context.ledge_info);
    GroundedMotionResult::InGround
 }
 pub fn collision_interrupt(ctx: &mut CollisionContext, can_walk_off: bool) -> Option<FighterState> {
@@ -245,10 +260,14 @@ pub fn collision_interrupt(ctx: &mut CollisionContext, can_walk_off: bool) -> Op
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::fighter::ecb::FighterPreviousECB;
+    use crate::fighter::attack::{FighterKnockbackState, FighterKnockbackVelocity};
-    use crate::fighter::{FighterECB, FighterSurfaceState};
+    use crate::fighter::ecb::{FighterDesiredECB, FighterPreviousECB};
-    use crate::stage::line::StagePolyType;
+    use crate::fighter::{
        FighterECB, FighterLedgeInformation, FighterPreviousTranslation, FighterSurfaceState,
    };
    use crate::input::FighterInput;
    use crate::math::rect::FGRect;
    use crate::stage::line::StagePolyType;
    fn two_segment_floor() -> StagePoly {
        StagePoly::build(
@@ -359,6 +378,7 @@ mod tests {
    fn grounded_collision_updates_surface_segment() {
        let stage_collision = crate::stage::line::StageCollision {
            stage_polys: vec![two_segment_floor()],
            ..crate::stage::line::StageCollision::default()
        };
        let mut surface = FighterSurfaceState::Grounded {
            line_id: StageLineID {
@@ -369,6 +389,9 @@ mod tests {
        let mut translation = FighterTranslation(FGVec2::lit("11", "0"));
        let previous_translation = FighterPreviousTranslation(translation.0);
        let mut velocity = FighterVelocity::default();
        let mut knockback_velocity = FighterKnockbackVelocity::default();
        let mut knockback_state = FighterKnockbackState::default();
        let mut ledge_info = FighterLedgeInformation::default();
        let mut ecb = FighterECB {
            bottom: FGVec2::lit("0.0", "-0.5"),
            top: FGVec2::lit("0.0", "0.5"),
@@ -376,19 +399,29 @@ mod tests {
            right: FGVec2::lit("0.5", "0.0"),
        };
        let previous_ecb = FighterPreviousECB::from(ecb);
        let mut desired_ecb = FighterDesiredECB::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,
            knockback_velocity: &mut knockback_velocity,
            knockback_state: &mut knockback_state,
            surface: &mut surface,
            ecb: &mut ecb,
            desired_ecb: &mut desired_ecb,
            ledge_info: &mut ledge_info,
            prev_ecb: &previous_ecb,
            stage_collision: &stage_collision,
            leave_ground_ecb_lock_duration: 10,
            presentation_snap: &mut presentation_snap,
            downward_stick_threshold: FGi32::ONE,
            fighter_ledge_collision_box: FGRect {
                origin: FGVec2::ZERO,
                end: FGVec2::ZERO,
            },
            waveland_snap_distance: FGi32::ZERO,
        };
        assert!(matches!(
@@ -414,6 +447,7 @@ mod tests {
                    (FGVec2::lit("10", "0"), StagePolyLineSegmentType::Floor),
                ],
            )],
            ..crate::stage::line::StageCollision::default()
        };
        let mut surface = FighterSurfaceState::Grounded {
            line_id: StageLineID {
@@ -424,6 +458,8 @@ mod tests {
        let mut translation = FighterTranslation(FGVec2::lit("11", "0"));
        let previous_translation = FighterPreviousTranslation(translation.0);
        let mut velocity = FighterVelocity::default();
        let mut knockback_velocity = FighterKnockbackVelocity::default();
        let mut knockback_state = FighterKnockbackState::default();
        let mut ecb = FighterECB {
            bottom: FGVec2::lit("0.0", "-0.5"),
            top: FGVec2::lit("0.0", "0.5"),
@@ -431,19 +467,30 @@ mod tests {
            right: FGVec2::lit("0.5", "0.0"),
        };
        let previous_ecb = FighterPreviousECB::from(ecb);
        let mut desired_ecb = FighterDesiredECB::from(ecb);
        let mut presentation_snap = crate::fighter::FighterPresentationSnap::default();
        let mut ledge_info = FighterLedgeInformation::default();
        let mut context = CollisionContext {
            translation: &mut translation,
            prev_translation: &previous_translation,
            input: &FighterInput::default(),
            velocity: &mut velocity,
            knockback_velocity: &mut knockback_velocity,
            knockback_state: &mut knockback_state,
            surface: &mut surface,
            ecb: &mut ecb,
            desired_ecb: &mut desired_ecb,
            ledge_info: &mut ledge_info,
            prev_ecb: &previous_ecb,
            stage_collision: &stage_collision,
            leave_ground_ecb_lock_duration: 10,
            presentation_snap: &mut presentation_snap,
            downward_stick_threshold: FGi32::ONE,
            fighter_ledge_collision_box: FGRect {
                origin: FGVec2::ZERO,
                end: FGVec2::ZERO,
            },
            waveland_snap_distance: FGi32::ZERO,
        };
        assert!(matches!(
@@ -479,3 +526,22 @@ pub fn grounded_movement_standstill_common_interrupts(
        None
    }
 }
 pub fn perform_wavedash(input: &FighterInput, game_settings: &GameSettings) -> FighterState {
    // If aiming sideways and in the deadzone, do a perfect wavedash
    // TODO: Improve this so we don't have to go through the airborne state first
    let mut wavedash_dir = input.get_last_frame().movement.normalize_or_zero();
    let movement = input.get_last_frame().movement;
    if movement.y.is_zero() && !movement.x.is_zero() {
        wavedash_dir.y = -game_settings.input_common.stick_deadzone - FGi32::lit("-0.01");
        wavedash_dir.x = movement.x.signum();
    }
    if wavedash_dir == FGVec2::ZERO {
        wavedash_dir = FGVec2::lit("0.0", "-1.0");
    }
    FighterState::AirDodge(AirDodgeState {
        direction: wavedash_dir.normalize_or_zero(),
    })
 }
@@ -1,20 +1,39 @@
-use crate::fighter::{
+use bevy::{asset::Assets, log::error};
-    attack::{AttackKind, update_active_hitbox_list},
+
-    state::{
+use crate::{
-        CollisionContext, EnterContext, ExitContext, FighterState, FighterStateImpl,
+    fighter::{
-        InterruptContext, UpdateContext, wait::WaitState,
+        attack::{AttackKind, FighterAttackScriptAssets, update_active_attack},
        state::{
            CollisionContext, EnterContext, ExitContext, FighterState, FighterStateImpl,
            InterruptContext, UpdateContext, ground, wait::WaitState,
        },
    },
    scripting::FighterAttackScript,
 };
 #[derive(Clone, Debug, Hash)]
 pub struct GroundAttackState {
    pub attack_kind: AttackKind,
    pub use_root_motion: bool,
 }
 impl FighterStateImpl for GroundAttackState {
    const NAME: &'static str = "GroundAttack";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        // Allow interrupting dash attack only into an up/down smash
        if let AttackKind::DashAttack = self.attack_kind {
            if state_context.get_current_animation_frame() < state_context.fighter_attributes.dash_attack_cancel_window {
                if let Some(state) = check_interrupt(state_context) {
                    if let FighterState::GroundAttack(state) = state {
                        if matches!(state.attack_kind, AttackKind::UpSmash) || matches!(state.attack_kind, AttackKind::DownSmash) {
                            return Some(FighterState::GroundAttack(state));
                        }
                    }
                }
            }
        }
        if state_context.is_current_animation_finished() {
            Some(FighterState::Wait(WaitState))
        } else {
@@ -28,16 +47,26 @@ 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,
            );
            // root motion
            if script.use_root_motion {
                state_context.velocity.0.x = state_context.animation_root_motion_delta.x;
                ground::apply_grounded_motion(
                    state_context.velocity,
                    state_context.translation,
                );
            } else {
                ground::update_friction_motion(state_context);
            }
        }
    }
@@ -49,10 +78,10 @@ impl FighterStateImpl for GroundAttackState {
        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,
+            script: script.clone(),
            active_hitboxes: Vec::new(),
            solved_hitboxes: Vec::new(),
-            hit_fighters: Vec::new(),
+            hit_groups: Vec::new(),
            stalled: false,
        });
    }
@@ -63,9 +92,9 @@ impl FighterStateImpl for GroundAttackState {
    fn check_collision_interrupt(
        &mut self,
-        _state_context: &mut CollisionContext,
+        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
-        None
+        ground::collision_interrupt(state_context, !self.use_root_motion)
    }
    fn is_visually_grounded<'a>(&'a self) -> bool {
@@ -73,6 +102,51 @@ impl FighterStateImpl for GroundAttackState {
    }
 }
 impl GroundAttackState {
    fn create(
        attack_kind: AttackKind,
        attack_script_assets: &FighterAttackScriptAssets,
        attack_scripts: &Assets<FighterAttackScript>,
    ) -> Result<Self, AirAttackStateCreateError> {
        let asset_script = attack_script_assets.scripts.get(&attack_kind).ok_or(
            AirAttackStateCreateError::AttackScriptAssetNotFound {
                attack: attack_kind,
            },
        )?;
        let script = attack_scripts.get(asset_script).ok_or(
            AirAttackStateCreateError::AttackScriptNotFound {
                attack: attack_kind,
            },
        )?;
        Ok(Self {
            attack_kind,
            use_root_motion: script.use_root_motion
        })
    }
 }
 #[derive(thiserror::Error, Debug)]
 pub enum AirAttackStateCreateError {
    #[error("Attack script: {attack:?} not found")]
    AttackScriptNotFound { attack: AttackKind },
    #[error("Attack script asset: {attack:?} not found")]
    AttackScriptAssetNotFound { attack: AttackKind },
 }
 pub fn check_interrupt_shared(state_context: &InterruptContext, attack_kind: AttackKind) -> Option<FighterState> {
    let state = GroundAttackState::create(attack_kind, state_context.attack_script_assets, state_context.attack_scripts);
    match state {
        Ok(state) => Some(FighterState::GroundAttack(state)),
        Err(create_error) => {
            error!("{}", create_error);
            None
        },
    }
 }
 pub fn check_interrupt(state_context: &InterruptContext) -> Option<FighterState> {
    if state_context
        .input
@@ -82,9 +156,18 @@ pub fn check_interrupt(state_context: &InterruptContext) -> Option<FighterState>
            .input
            .get_attack_command_type()
            .to_attack_kind_grounded();
-        Some(FighterState::GroundAttack(GroundAttackState {
+        check_interrupt_shared(state_context, attack_kind)
-            attack_kind,
+    } else {
-        }))
+        None
    }
 }
 pub fn check_interrupt_dash_attack(state_context: &InterruptContext) -> Option<FighterState> {
    if state_context
        .input
        .has_command(crate::input::FighterCommands::Attack)
    {
        check_interrupt_shared(state_context, AttackKind::DashAttack)
    } else {
        None
    }
@@ -1,8 +1,6 @@
 use crate::{
    fighter::{
-        animation::AnimKind,
+        animation::AnimKind, attack::{self, FighterHitReaction}, state::{
        attack::{self, FighterHitReaction},
        state::{
            CollisionContext, EnterContext, ExitContext, FighterState, FighterStateImpl,
            InterruptContext, UpdateContext,
            air::{self, AirborneStateCommon},
@@ -11,7 +9,7 @@ use crate::{
            land::LandingType,
            wait::WaitState,
        },
-    }, math::{int::FGi32, vec::FGVec2},
+    }, math::vec::FGVec2,
 };
 #[derive(Clone, Debug, Hash)]
@@ -25,14 +23,20 @@ pub struct HitstunState {
    pub hit_reaction: FighterHitReaction,
    pub hitstop_kind: HitstopStateKind,
    knockback_applied: bool,
    stack_previous_knockback: bool,
 }
 impl HitstunState {
-    pub fn new(hit_reaction: FighterHitReaction, hitstop_kind: HitstopStateKind) -> Self {
+    pub fn new(
        hit_reaction: FighterHitReaction,
        hitstop_kind: HitstopStateKind,
        stack_previous_knockback: bool,
    ) -> Self {
        Self {
            hit_reaction,
            hitstop_kind,
            knockback_applied: false,
            stack_previous_knockback,
        }
    }
 }
@@ -40,6 +44,35 @@ impl HitstunState {
 impl FighterStateImpl for HitstunState {
    const NAME: &'static str = "Hitstun";
    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 => Some(FighterState::Wait(WaitState)),
                HitstopStateKind::Airborne => Some(FighterState::Fall(FallState::new(
                    AirborneStateCommon::default(),
                ))),
            }
        } else {
            None
        }
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        let animation = match self.hitstop_kind {
            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) {
        if matches!(self.hitstop_kind, HitstopStateKind::Grounded) {
            state_context.knockback_velocity.0 = FGVec2::ZERO;
            state_context.knockback_state.clear();
        }
    }
    fn name(&self) -> String {
        let hitstop_kind = match self.hitstop_kind {
            HitstopStateKind::Grounded => "Grounded",
@@ -54,28 +87,29 @@ impl FighterStateImpl for HitstunState {
        format!("Hitstun ({hitstop_kind}, {hit_reaction_type})")
    }
    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 => Some(FighterState::Wait(WaitState)),
                HitstopStateKind::Airborne => Some(FighterState::Fall(FallState::new(
                    AirborneStateCommon::default(),
                ))),
            }
        } else {
            None
        }
    }
    fn update(&mut self, ctx: &mut UpdateContext) {
        if !self.knockback_applied {
-            let launch_direction = attack::directional_influence::apply_directional_influence(
+            let new_launch_direction = attack::directional_influence::apply_directional_influence(
-                ctx.input.get_last_frame().movement,
+                FGVec2::ZERO,
                self.hit_reaction.launch_angle,
                ctx.game_settings.fighter_common.di_max_angle,
            );
            let new_knockback = new_launch_direction * self.hit_reaction.launch_velocity;
            let combined_knockback = if self.stack_previous_knockback {
                attack::stack_knockback(ctx.knockback_velocity.0, new_knockback)
            } else {
                new_knockback
            };
            let launch_speed = combined_knockback.length();
            let launch_direction =
                attack::directional_influence::apply_directional_influence_to_direction(
                    ctx.input.get_last_frame().movement,
                    combined_knockback.normalize_or_zero(),
                    ctx.game_settings.fighter_common.di_max_angle,
                );
-            ctx.knockback_velocity.0 = launch_direction * self.hit_reaction.launch_velocity;
+            ctx.knockback_velocity.0 = launch_direction * launch_speed;
            ctx.knockback_state.restart();
            self.knockback_applied = true;
        }
@@ -83,30 +117,19 @@ impl FighterStateImpl for HitstunState {
            HitstopStateKind::Grounded => {}
            HitstopStateKind::Airborne => {
                air::integrate_gravity(ctx.velocity, ctx.fighter_attributes, false);
                air::apply_air_motion_with_knockback(ctx);
            }
        }
-        let speed = ctx.knockback_velocity.length();
+        if matches!(self.hitstop_kind, HitstopStateKind::Grounded) {
-        let next_speed = speed
+            attack::decay_knockback(
-            .saturating_sub(ctx.game_settings.fighter_common.knockback_decay_per_frame)
+                ctx.knockback_velocity,
-            .max(FGi32::ZERO);
+                ctx.knockback_state,
-
+                ctx.game_settings.fighter_common.knockback_decay_per_frame,
-        ctx.knockback_velocity.0 = ctx.knockback_velocity.normalize_or_zero() * next_speed;
+            );
-
+        }
        ctx.translation.0 += ctx.velocity.0 + ctx.knockback_velocity.0;
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        let animation = match self.hitstop_kind {
            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) {}
    fn check_collision_interrupt(
        &mut self,
        state_context: &mut CollisionContext,
@@ -114,7 +137,7 @@ impl FighterStateImpl for HitstunState {
        match &mut self.hitstop_kind {
            HitstopStateKind::Grounded => collision_interrupt(state_context, true),
            HitstopStateKind::Airborne => {
-                air::collision_interrupt(state_context, LandingType::Normal, false)
+                air::collision_interrupt(state_context, LandingType::Normal, Default::default())
            }
        }
    }
@@ -1,18 +1,10 @@
 use bevy::prelude::*;
 use crate::{
    fighter::{
-        animation::AnimKind,
+        animation::AnimKind, state::{
-        state::{
+            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, ground::{self}, ground_attack,
            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext,
            UpdateContext,
            air::{self, AirborneStateCommon},
            air_dodge::AirDodgeState,
            ground,
        },
-    },
+    }, input::{DigitalAction, FighterCommands},
    input::{DigitalAction, FighterCommands},
    math::{int::FGi32, vec::FGVec2},
 };
 #[derive(Debug, Hash, Clone, Copy)]
 pub enum JumpType {
@@ -21,21 +13,30 @@ pub enum JumpType {
    DoubleJump,
 }
 #[derive(Debug, Clone, Hash)]
 pub enum JumpStateInitiator {
    Tap,
    Button,
 }
 #[derive(Debug, Clone, Hash)]
 pub struct JumpState {
    pub jump_type: JumpType,
    pub airborne_state_common: AirborneStateCommon,
    pub initiator: JumpStateInitiator,
 }
 #[derive(Debug, Clone, Hash)]
 pub struct JumpSquatState {
    pub duration_counter: u32,
    pub initiator: JumpStateInitiator,
 }
 impl JumpSquatState {
-    pub fn create() -> Self {
+    pub fn create(initiator: JumpStateInitiator) -> Self {
        Self {
            duration_counter: 0,
            initiator,
        }
    }
 }
@@ -44,41 +45,24 @@ impl FighterStateImpl for JumpSquatState {
    const NAME: &'static str = "JumpSquat";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        if let Some(state) = ground_attack::check_interrupt(state_context) {
            return Some(state);
        }
        // Special handling for wavedash from jump squat
        if state_context.input.has_command(FighterCommands::Shield) {
-            // If aiming sideways and in the deadzone, do a perfect wavedash
+            Some(ground::perform_wavedash(state_context.input, state_context.game_settings))
            // TODO: Improve this so we don't have to go through the airborne state first
            let mut wavedash_dir = state_context
                .input
                .get_last_frame()
                .movement
                .normalize_or_zero();
            let movement = state_context.input.get_last_frame().movement;
            if movement.y.is_zero() && !movement.x.is_zero() {
                wavedash_dir.y =
                    -state_context.game_settings.input_common.stick_deadzone - FGi32::lit("-0.01");
                wavedash_dir.x = movement.x.signum();
            }
            if wavedash_dir == FGVec2::ZERO {
                wavedash_dir = FGVec2::lit("0.0", "-1.0");
            }
            Some(FighterState::AirDodge(AirDodgeState {
                direction: wavedash_dir.normalize_or_zero(),
            }))
        } else if self.duration_counter >= state_context.fighter_attributes.jumpsquat_duration {
-            info!(
+            let tap_jump_held = matches!(self.initiator, JumpStateInitiator::Tap)
-                "Jump {}",
+                && state_context.input.get_last_frame().movement.y
-                state_context
+                    > state_context
                        .game_settings
                        .input_common
                        .smash_input_axis_threshold;
            let jump_type = if tap_jump_held
                || 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 {
@@ -87,6 +71,7 @@ impl FighterStateImpl for JumpSquatState {
            Some(FighterState::Jump(JumpState {
                jump_type,
                airborne_state_common: AirborneStateCommon::default(),
                initiator: self.initiator.clone(),
            }))
        } else {
            None
@@ -109,10 +94,13 @@ impl FighterStateImpl for JumpSquatState {
        state_context.play_animation(AnimKind::JumpSquat, false);
        state_context.input.enable_hold_all(10);
        state_context.input.clear_command(FighterCommands::Jump);
        state_context.input.clear_command(FighterCommands::TapJump);
    }
    fn on_exit(&mut self, state_context: &mut crate::fighter::state::ExitContext) {
        state_context.input.disable_hold_all();
        // We clear tap jump here, it may have weird interactions with air dodging up
        state_context.input.clear_command(FighterCommands::TapJump);
    }
    fn is_visually_grounded<'a>(&'a self) -> bool {
@@ -188,7 +176,10 @@ impl FighterStateImpl for JumpState {
        air::collision_interrupt(
            state_context,
            crate::fighter::state::land::LandingType::Normal,
-            true,
+            crate::fighter::collision::AirCollisionOptions {
                can_pass_through_soft_platforms: true,
                ..Default::default()
            },
        )
    }
@@ -208,20 +199,33 @@ impl FighterStateImpl for JumpState {
 }
 pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
-    state_context
+    if state_context.input.has_command(FighterCommands::Jump) {
-        .input
+        Some(FighterState::JumpSquat(JumpSquatState::create(
-        .has_command(FighterCommands::Jump)
+            JumpStateInitiator::Button,
-        .then(|| FighterState::JumpSquat(JumpSquatState::create()))
+        )))
    } else if state_context.input.has_command(FighterCommands::TapJump) {
        Some(FighterState::JumpSquat(JumpSquatState::create(
            JumpStateInitiator::Tap,
        )))
    } else {
        None
    }
 }
 pub fn check_input_double_jump(state_context: &InterruptContext) -> Option<FighterState> {
-    state_context
+    if state_context.input.has_command(FighterCommands::Jump) {
-        .input
+        Some(FighterState::Jump(JumpState {
-        .has_command(FighterCommands::Jump)
+            jump_type: JumpType::DoubleJump,
-        .then(|| {
+            airborne_state_common: AirborneStateCommon::default(),
-            FighterState::Jump(JumpState {
+            initiator: JumpStateInitiator::Button,
-                jump_type: JumpType::DoubleJump,
+        }))
-                airborne_state_common: AirborneStateCommon::default(),
+    } else if state_context.input.has_command(FighterCommands::TapJump) {
-            })
+        Some(FighterState::Jump(JumpState {
-        })
+            jump_type: JumpType::DoubleJump,
            airborne_state_common: AirborneStateCommon::default(),
            initiator: JumpStateInitiator::Tap,
        }))
    } else {
        None
    }
 }
@@ -0,0 +1,157 @@
 use super::{CollisionContext, EnterContext, FighterStateImpl, InterruptContext, UpdateContext};
 use crate::fighter::animation::AnimKind;
 use crate::fighter::state::air::AirborneStateCommon;
 use crate::fighter::state::jump::{JumpState, JumpStateInitiator, JumpType};
 use crate::fighter::state::wait::WaitState;
 use crate::fighter::state::{FighterState, ground};
 use crate::fighter::FighterFacingDirection;
 use crate::input::FighterCommands;
 use crate::math::int::FGi32;
 use crate::math::vec::FGVec2;
 use crate::stage::line::{StageLedgeSide, StageVertexID};
 #[derive(Debug, Clone, Hash)]
 pub enum LedgeAction {
    Jump(JumpStateInitiator),
    GetUp
 }
 #[derive(Debug, Clone, Hash)]
 pub struct LedgeActionState {
    pub ledge_id: StageVertexID,
    pub ledge_action: LedgeAction,
    pub is_in_grounded_phase: bool,
 }
 impl LedgeActionState {
    pub fn create_jump(ledge_id: StageVertexID, initiator: JumpStateInitiator) -> Self {
        LedgeActionState {
            ledge_id,
            ledge_action: LedgeAction::Jump(initiator),
            is_in_grounded_phase: false,
        }
    }
    pub fn create_getup(ledge_id: StageVertexID) -> Self {
        LedgeActionState {
            ledge_id,
            ledge_action: LedgeAction::GetUp,
            is_in_grounded_phase: false,
        }
    }
 }
 impl FighterStateImpl for LedgeActionState {
    const NAME: &'static str = "LedgeAction";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        match &self.ledge_action {
            LedgeAction::Jump(initiator) => {
                if state_context.is_current_animation_finished() {
                    if state_context.input.has_command(FighterCommands::Shield) {
                        Some(ground::perform_wavedash(state_context.input, state_context.game_settings))
                    } else {
                        Some(FighterState::Jump(JumpState {
                            jump_type: JumpType::DoubleJump,
                            airborne_state_common: AirborneStateCommon::default(),
                            initiator: initiator.clone()
                        }))
                    }
                } else {
                    None
                }
            },
            LedgeAction::GetUp => {
                if state_context.is_current_animation_finished() {
                    Some(FighterState::Wait(WaitState))
                } else {
                    None
                }
            },
        }
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        match self.ledge_action {
            LedgeAction::Jump(_) => {
                state_context.play_animation(AnimKind::LedgeJump, false);
                state_context.input.enable_hold_all(10);
                state_context.input.clear_command(FighterCommands::Jump);
                state_context.input.clear_command(FighterCommands::TapJump);
            },
            LedgeAction::GetUp => {
                state_context.play_animation(AnimKind::LedgeGetUp, false);
            },
        }
        state_context.velocity.0 = FGVec2::ZERO;
        state_context.knockback_velocity.0 = FGVec2::ZERO;
        state_context.knockback_state.clear();
        let Some(ledge) = state_context.stage_collision.find_ledge_by_vertex(self.ledge_id) else {
            return;
        };
        state_context.translation.0 = ledge.position;
        *state_context.facing_direction = match ledge.hang_side {
            StageLedgeSide::Left => FighterFacingDirection::Right,
            StageLedgeSide::Right => FighterFacingDirection::Left,
        };
        if let Some(root_position) = state_context.initial_animation_root_position() {
            state_context.translation.0 = root_position;
        }
        state_context.presentation_snap.0 = true;
    }
    fn update(&mut self, state_context: &mut UpdateContext) {
        if !self.is_in_grounded_phase {
            let root_pos = state_context.animation_root_position.unwrap_or_default();
            let Some(ledge) = state_context.stage_collision.find_ledge_by_vertex(self.ledge_id) else {
                return;
            };
            let ledge_pos = ledge.position;
            let ledge_modifier = match ledge.hang_side {
                StageLedgeSide::Left => FGi32::ONE,
                StageLedgeSide::Right => FGi32::NEG_ONE,
            };
            let normalized_root_position = root_pos - ledge_pos;
            let normalized_root_position = FGVec2::new(normalized_root_position.x * ledge_modifier, normalized_root_position.y);
            if normalized_root_position.x.is_positive() && normalized_root_position.y.is_positive() {
                let Some((segment_id, _)) = state_context
                    .stage_collision
                    .find_ledge_ground_segment(self.ledge_id)
                else {
                    return;
                };
                self.is_in_grounded_phase = true;
                state_context.translation.0 = ledge.position;
                state_context.surface.land(segment_id, state_context.ledge_info);
            }
        }
        if self.is_in_grounded_phase {
            state_context.velocity.0.x = state_context.animation_root_motion_delta.x;
            ground::apply_grounded_motion(
                state_context.velocity,
                state_context.translation,
            );
        } else {
            if let Some(root_position) = state_context.animation_root_position {
                state_context.translation.0 = root_position;
            }
        }
    }
    fn check_collision_interrupt(
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
        state_context.apply_desired_ecb();
        None
    }
    fn is_visually_grounded<'a>(&'a self) -> bool {
        self.is_in_grounded_phase
    }
 }
@@ -0,0 +1,75 @@
 use super::{
    EnterContext, FighterStateImpl, InterruptContext, UpdateContext,
 };
 use crate::fighter::{FighterFacingDirection, FighterInvulnerabilityState};
 use crate::fighter::animation::AnimKind;
 use crate::fighter::state::{ExitContext, FighterState};
 use crate::fighter::state::air::AirborneStateCommon;
 use crate::fighter::state::ledge_wait::LedgeWaitState;
 use crate::stage::line::{StageLedgeSide, StageVertexID};
 #[derive(Debug, Clone, Hash)]
 pub struct LedgeGrabState {
    ledge_id: StageVertexID
 }
 impl LedgeGrabState {
    pub fn new(ledge_id: StageVertexID) -> Self {
        Self {
            ledge_id
        }
    }
 }
 impl FighterStateImpl for LedgeGrabState {
    const NAME: &'static str = "LedgeGrab";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        if state_context.is_current_animation_finished() {
            Some(FighterState::LedgeWait(LedgeWaitState {
                airborne_state_common: AirborneStateCommon::default(),
                ledge_id: self.ledge_id.clone()
            }))
        } else {
            None
        }
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        state_context.play_animation(AnimKind::LedgeGrab, false);
        state_context.knockback_velocity.0 = crate::math::vec::FGVec2::ZERO;
        state_context.knockback_state.clear();
        *state_context.vulnerability = FighterInvulnerabilityState::Intangible {
            frames_remaining: None,
        };
        let Some(ledge) = state_context.stage_collision.find_ledge_by_vertex(self.ledge_id) else {
            return;
        };
        state_context.translation.0 = ledge.position;
        *state_context.facing_direction = match ledge.hang_side {
            StageLedgeSide::Left => FighterFacingDirection::Right,
            StageLedgeSide::Right => FighterFacingDirection::Left,
        };
        if let Some(root_position) = state_context.initial_animation_root_position() {
            state_context.translation.0 = root_position;
        }
        state_context.presentation_snap.0 = true;
    }
    fn on_exit(&mut self, state_context: &mut ExitContext) {
        *state_context.vulnerability = FighterInvulnerabilityState::Vulnerable;
    }
    fn is_visually_grounded<'a>(&'a self) -> bool {
        false
    }
    fn update(&mut self, state_context: &mut UpdateContext) {
        if let Some(root_position) = state_context.animation_root_position {
            state_context.translation.0 = root_position;
        }
    }
 }
@@ -0,0 +1,167 @@
 use super::{CollisionContext, EnterContext, FighterStateImpl, InterruptContext, UpdateContext};
 use crate::fighter::animation::AnimKind;
 use crate::fighter::state::air::AirborneStateCommon;
 use crate::fighter::state::fall::FallState;
 use crate::fighter::state::FighterState;
 use crate::fighter::state::jump::JumpStateInitiator;
 use crate::fighter::state::ledge_action::{LedgeActionState};
 use crate::fighter::{FighterFacingDirection, FighterInvulnerabilityState};
 use crate::input::FighterCommands;
 use crate::math::vec::FGVec2;
 use crate::stage::line::{StageLedgeSide, StageVertexID};
 #[derive(Debug, Clone, Hash)]
 pub struct LedgeWaitState {
    pub airborne_state_common: AirborneStateCommon,
    pub ledge_id: StageVertexID,
 }
 impl FighterStateImpl for LedgeWaitState {
    const NAME: &'static str = "LedgeWait";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        if state_context.input.has_command(FighterCommands::Jump) {
            return Some(FighterState::LedgeAction(LedgeActionState::create_jump(self.ledge_id, JumpStateInitiator::Button)));
        } else if state_context.input.has_command(FighterCommands::TapJump) {
            return Some(FighterState::LedgeAction(LedgeActionState::create_jump(self.ledge_id, JumpStateInitiator::Tap)));
        }
        if is_ledge_getup_input(state_context.input.get_last_frame().movement.x,
            state_context.game_settings.input_common.run_stick_threshold,
            state_context.facing_direction) {
                return Some(FighterState::LedgeAction(LedgeActionState::create_getup(self.ledge_id)));
        }
        if is_ledge_drop_input(state_context.input.get_last_frame().movement.x,
            state_context.game_settings.input_common.run_stick_threshold,
            state_context.facing_direction) {
            state_context.ledge_grab_lockout.start(
                state_context
                    .game_settings
                    .fighter_common
                    .ledge_drop_regrab_lockout_duration_frames,
            );
            return Some(FighterState::Fall(FallState::new(
                AirborneStateCommon { is_fast_falling: false },
            )));
        }
        if is_ledge_drop_fastfall_input(
            state_context.input.get_last_frame().movement.y,
            state_context.game_settings.input_common.run_stick_threshold,
        ) {
            state_context.ledge_grab_lockout.start(
                state_context
                    .game_settings
                    .fighter_common
                    .ledge_drop_regrab_lockout_duration_frames,
            );
            return Some(FighterState::Fall(FallState::new(
                AirborneStateCommon { is_fast_falling: true },
            )));
        }
        None
    }
    fn on_enter(&mut self, state_context: &mut EnterContext) {
        state_context.velocity.0 = FGVec2::ZERO;
        state_context.knockback_velocity.0 = FGVec2::ZERO;
        state_context.knockback_state.clear();
        if state_context.ledge_info.grab_count < state_context.game_settings.fighter_common.max_ledge_grab_count {
            *state_context.vulnerability = FighterInvulnerabilityState::Intangible {
                frames_remaining: Some(
                    state_context
                    .game_settings
                    .fighter_common
                    .ledge_grab_invulnerability_duration,
                ),
            };
        }
        state_context.ledge_info.grab_count = state_context.ledge_info.grab_count.saturating_add(1);
        let Some(ledge) = state_context.stage_collision.find_ledge_by_vertex(self.ledge_id) else {
            return;
        };
        state_context.translation.0 = ledge.position;
        *state_context.facing_direction = match ledge.hang_side {
            StageLedgeSide::Left => FighterFacingDirection::Right,
            StageLedgeSide::Right => FighterFacingDirection::Left,
        };
        state_context.play_animation(AnimKind::LedgeWait, true);
        if let Some(root_position) = state_context.initial_animation_root_position() {
            state_context.translation.0 = root_position;
        }
        state_context.presentation_snap.0 = true;
    }
    fn update(&mut self, state_context: &mut UpdateContext) {
        if let Some(root_position) = state_context.animation_root_position {
            state_context.translation.0 = root_position;
        }
    }
    fn check_collision_interrupt(
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
        state_context.apply_desired_ecb();
        None
    }
    fn is_visually_grounded<'a>(&'a self) -> bool {
        false
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::math::int::FGi32;
    #[test]
    fn ledge_drop_uses_the_run_stick_threshold() {
        let threshold = FGi32::lit("0.625");
        assert!(is_ledge_drop_fastfall_input(FGi32::lit("-0.625"), threshold));
        assert!(is_ledge_drop_fastfall_input(FGi32::lit("-1.0"), threshold));
        assert!(!is_ledge_drop_fastfall_input(FGi32::lit("-0.624"), threshold));
    }
 }
 fn is_ledge_drop_fastfall_input(
    vertical_input: crate::math::int::FGi32,
    threshold: crate::math::int::FGi32,
 ) -> bool {
    vertical_input <= -threshold
 }
 fn is_ledge_drop_input(
    horizontal_input: crate::math::int::FGi32,
    threshold: crate::math::int::FGi32,
    facing_dir: &FighterFacingDirection,
 ) -> bool {
    let dir = facing_dir.to_sign();
    if horizontal_input.abs() > threshold {
        if dir != horizontal_input.signum() {
            return true;
        }
    }
    false
 }
 fn is_ledge_getup_input(
    horizontal_input: crate::math::int::FGi32,
    threshold: crate::math::int::FGi32,
    facing_dir: &FighterFacingDirection,
 ) -> bool {
    let dir = facing_dir.to_sign();
    if horizontal_input.abs() > threshold {
        if dir == horizontal_input.signum() {
            return true;
        }
    }
    false
 }
@@ -7,12 +7,12 @@ use bevy::prelude::*;
 use crate::fighter::animation::{AnimKind, FighterAnimationFrame};
 use crate::fighter::attack::{
-    FighterAttackScriptAssets, FighterKnockbackVelocity, FighterPendingHitReaction,
+    FighterAttackScriptAssets, FighterKnockbackState, FighterKnockbackVelocity,
-    FighterStaleMoveQueue, HitStop,
+    FighterPendingHitReaction, FighterStaleMoveQueue, HitStop,
 };
 use crate::fighter::attributes::FighterAttributes;
-use crate::fighter::baked_animation::BakedFighterAnimations;
+use crate::fighter::baked_animation::{BakedFighterAnimations, FighterBoneMatrices};
-use crate::fighter::ecb::FighterPreviousECB;
+use crate::fighter::ecb::{self, FighterDesiredECB, FighterPreviousECB};
 use crate::fighter::manifest::FighterManifest;
 use crate::fighter::state::hitstun::HitstunState;
 use crate::fighter::surface::EcbLockPolicy;
@@ -20,15 +20,18 @@ use crate::fighter::visual::FighterAnimations;
 use crate::fighter::{
    Fighter, FighterDamage, FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop,
    FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole,
-    FighterInvulnerabilityState, FighterPendingRespawn, FighterPresentationSnap,
+    FighterInvulnerabilityState, FighterLedgeInformation, FighterPendingRespawn,
-    FighterPreviousTranslation, FighterSurfaceState, FighterTranslation, FighterVelocity,
+    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::rect::FGRect;
 use crate::math::vec::FGVec2;
 use crate::math::vec3::FGVec3;
 use crate::player::Player;
 use crate::scripting::FighterAttackScript;
 use crate::stage::line::StageCollision;
@@ -46,6 +49,9 @@ pub mod ground_attack;
 pub mod hitstun;
 pub mod jump;
 pub mod land;
 pub mod ledge_action;
 pub mod ledge_grab;
 pub mod ledge_wait;
 pub mod platform_pass;
 pub mod run;
 pub mod turn;
@@ -114,8 +120,9 @@ pub trait FighterStateImpl: Sized {
    fn check_collision_interrupt(
        &mut self,
-        _state_context: &mut CollisionContext,
+        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
        state_context.apply_desired_ecb();
        None
    }
@@ -134,11 +141,13 @@ pub struct AnimationStatus {
 pub struct InterruptContext<'a> {
    pub input: &'a FighterInput,
    pub facing_direction: &'a mut FighterFacingDirection,
    pub ledge_grab_lockout: &'a mut FighterLedgeInformation,
    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,
 }
@@ -156,26 +165,48 @@ pub struct EnterContext<'a> {
    pub input: &'a mut FighterInput,
    pub hitboxes: &'a mut FighterHitboxes,
    pub velocity: &'a mut FighterVelocity,
    pub translation: &'a mut FighterTranslation,
    pub knockback_velocity: &'a mut FighterKnockbackVelocity,
    pub knockback_state: &'a mut FighterKnockbackState,
    pub stale_move_queue: &'a mut FighterStaleMoveQueue,
    pub facing_direction: &'a mut FighterFacingDirection,
    pub animation_frame: &'a mut FighterAnimationFrame,
    pub presentation_snap: &'a mut FighterPresentationSnap,
    pub surface: &'a mut FighterSurfaceState,
    pub vulnerability: &'a mut FighterInvulnerabilityState,
    pub ledge_info: &'a mut FighterLedgeInformation,
    pub fighter_attributes: &'a FighterAttributes,
    pub attack_script_assets: &'a FighterAttackScriptAssets,
    pub game_settings: &'a GameSettings,
    pub stage_collision: &'a StageCollision,
    baked_animations: &'a BakedFighterAnimations,
    model_scale: FGi32,
 }
 impl EnterContext<'_> {
    pub fn play_animation(&mut self, kind: AnimKind, repeat: bool) {
        self.animation_frame.reset(kind, repeat);
    }
    /// World-space root position authored for frame zero of the animation most
    /// recently selected with [`Self::play_animation`].
    pub fn initial_animation_root_position(&self) -> Option<FGVec2> {
        let position = self
            .baked_animations
            .initial_root_position(self.animation_frame.kind, self.model_scale)?;
        Some(self.translation.0 + animation_position_to_gameplay(position, self.facing_direction))
    }
    pub fn get_animation_duration(&self, kind: AnimKind) -> Option<usize> {
        self.baked_animations.get_animation_duration(kind)
    }
 }
 pub struct ExitContext<'a> {
    pub input: &'a mut FighterInput,
    pub hitboxes: &'a mut FighterHitboxes,
    pub knockback_velocity: &'a mut FighterKnockbackVelocity,
    pub knockback_state: &'a mut FighterKnockbackState,
    pub surface: &'a mut FighterSurfaceState,
    pub vulnerability: &'a mut FighterInvulnerabilityState,
 }
@@ -188,13 +219,29 @@ pub struct UpdateContext<'a> {
    pub velocity: &'a mut FighterVelocity,
    pub surface: &'a mut FighterSurfaceState,
    pub knockback_velocity: &'a mut FighterKnockbackVelocity,
    pub knockback_state: &'a mut FighterKnockbackState,
    pub vulnerability: &'a mut FighterInvulnerabilityState,
    pub ledge_info: &'a mut FighterLedgeInformation,
    pub game_settings: &'a GameSettings,
    /// Root motion in the fighter's gameplay plane: X is world-right and Y is
    /// world-up. Animation +Z is forward and is mirrored by facing direction.
    pub animation_root_motion_delta: FGVec2,
    /// Current world-space root position implied by this animation frame.
    /// States opt into root motion by assigning this to [`FighterTranslation`].
    pub animation_root_position: Option<FGVec2>,
    pub animation_frame: u32,
    pub fighter_attributes: &'a FighterAttributes,
    pub attack_scripts: &'a Assets<FighterAttackScript>,
    pub attack_script_assets: &'a FighterAttackScriptAssets,
    pub facing_direction: &'a FighterFacingDirection,
    pub stage_collision: &'a StageCollision,
 }
 fn animation_position_to_gameplay(
    position: FGVec3,
    facing_direction: &FighterFacingDirection,
 ) -> FGVec2 {
    FGVec2::new(position.z * facing_direction.to_sign(), position.y)
 }
 impl UpdateContext<'_> {
@@ -208,31 +255,55 @@ pub struct CollisionContext<'a> {
    pub prev_translation: &'a FighterPreviousTranslation,
    pub input: &'a FighterInput,
    pub velocity: &'a mut FighterVelocity,
    pub knockback_velocity: &'a mut FighterKnockbackVelocity,
    pub knockback_state: &'a mut FighterKnockbackState,
    pub surface: &'a mut FighterSurfaceState,
    pub ecb: &'a mut FighterECB,
    pub desired_ecb: &'a mut FighterDesiredECB,
    pub prev_ecb: &'a FighterPreviousECB,
    pub stage_collision: &'a StageCollision,
    pub leave_ground_ecb_lock_duration: u32,
    pub presentation_snap: &'a mut FighterPresentationSnap,
    pub ledge_info: &'a mut FighterLedgeInformation,
    pub fighter_ledge_collision_box: FGRect,
    pub downward_stick_threshold: FGi32,
    pub waveland_snap_distance: FGi32,
 }
 impl CollisionContext<'_> {
    /// Commit the target pose before resolving this frame. The collision
    /// substep resolver can later replace this with fractional steps.
    pub fn apply_desired_ecb(&mut self) {
        ecb::interpolate_ecb(self.ecb, *self.desired_ecb, FGi32::ONE);
    }
    pub fn air_collide_with_stage(
-        &self,
+        &mut self,
-        can_ignore_soft_platforms: bool,
+        mut options: crate::fighter::collision::AirCollisionOptions,
    ) -> Option<crate::fighter::collision::AirCollisionWithStageResult> {
        let ignored_polys = self.surface.ignored_polygon_ids();
-        let ignore_soft_platforms = can_ignore_soft_platforms
+        options.can_pass_through_soft_platforms = options.can_pass_through_soft_platforms
            && self.input.get_last_frame().movement.y <= -self.downward_stick_threshold;
-        crate::fighter::collision::air_collide_with_stage(
+        crate::fighter::collision::air_collide_with_stage_substepped(
            self.prev_translation,
            self.translation,
-            self.prev_ecb,
+            self.velocity,
            self.ecb,
            self.desired_ecb,
            self.stage_collision,
            &ignored_polys,
-            ignore_soft_platforms,
+            options,
        )
    }
    pub fn air_collide_with_ledges(
        &self,
    ) -> Option<crate::fighter::collision::AirCollisionWithLedgeResult> {
        if self.ledge_info.is_regrab_lockout_active() {
            return None;
        }
        crate::fighter::collision::air_collide_with_ledges(
            &self.fighter_ledge_collision_box,
            self.stage_collision,
        )
    }
 }
@@ -248,6 +319,9 @@ fighter_states! {
    JumpSquat => jump::JumpSquatState,
    Jump => jump::JumpState,
    Land => land::LandingState,
    LedgeWait => ledge_wait::LedgeWaitState,
    LedgeAction => ledge_action::LedgeActionState,
    LedgeGrab => ledge_grab::LedgeGrabState,
    AirDodge => air_dodge::AirDodgeState,
    Turn => turn::TurnState,
    GroundAttack => ground_attack::GroundAttackState,
@@ -267,13 +341,17 @@ pub struct FighterFrameQuery {
    pub velocity: &'static mut FighterVelocity,
    pub surface: &'static mut FighterSurfaceState,
    pub knockback_velocity: &'static mut FighterKnockbackVelocity,
    pub knockback_state: &'static mut FighterKnockbackState,
    pub stale_move_queue: &'static mut FighterStaleMoveQueue,
    pub ecb: &'static mut FighterECB,
    pub desired_ecb: &'static mut FighterDesiredECB,
    pub prev_ecb: &'static FighterPreviousECB,
    pub facing_direction: &'static mut FighterFacingDirection,
    pub animation_frame: &'static mut FighterAnimationFrame,
    pub vulnerability: &'static mut FighterInvulnerabilityState,
    pub ledge_information: &'static mut FighterLedgeInformation,
    pub fighter: &'static Fighter,
    pub bone_matrices: &'static FighterBoneMatrices,
 }
 impl<'w, 's> FighterFrameQueryItem<'w, 's> {
@@ -300,18 +378,21 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
        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 {
            input: &self.input,
            facing_direction: &mut self.facing_direction,
            ledge_grab_lockout: &mut self.ledge_information,
            game_settings,
            fighter_attributes: attributes,
            animation,
            surface: &self.surface,
            stage_collision,
            attack_script_assets: attack_script_assets,
            attack_scripts,
        }
    }
@@ -320,20 +401,30 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
        attributes: &'a FighterAttributes,
        attack_script_assets: &'a FighterAttackScriptAssets,
        game_settings: &'a GameSettings,
        stage_collision: &'a StageCollision,
        baked_animations: &'a BakedFighterAnimations,
        model_scale: FGi32,
    ) -> EnterContext<'a> {
        EnterContext {
            input: &mut self.input,
            hitboxes: &mut self.hitboxes,
            velocity: &mut self.velocity,
            knockback_velocity: &mut self.knockback_velocity,
            knockback_state: &mut self.knockback_state,
            translation: &mut self.translation,
            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,
            presentation_snap: &mut self.presentation_snap,
            ledge_info: &mut self.ledge_information,
            fighter_attributes: attributes,
            attack_script_assets,
            game_settings,
            stage_collision,
            baked_animations,
            model_scale,
        }
    }
@@ -341,6 +432,8 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
        ExitContext {
            input: &mut self.input,
            hitboxes: &mut self.hitboxes,
            knockback_velocity: &mut self.knockback_velocity,
            knockback_state: &mut self.knockback_state,
            surface: &mut self.surface,
            vulnerability: &mut self.vulnerability,
        }
@@ -352,7 +445,16 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
        attributes: &'a FighterAttributes,
        attack_scripts: &'a Assets<FighterAttackScript>,
        attack_script_assets: &'a FighterAttackScriptAssets,
        stage_collision: &'a StageCollision,
    ) -> UpdateContext<'a> {
        let animation_root_motion_delta = animation_position_to_gameplay(
            self.bone_matrices.root_motion_delta(),
            &self.facing_direction,
        );
        let animation_root_position = self
            .bone_matrices
            .root_motion_position()
            .map(|_| self.translation.0 + animation_root_motion_delta);
        UpdateContext {
            translation: &mut self.translation,
            prev_translation: &mut self.prev_translation,
@@ -361,35 +463,51 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
            velocity: &mut self.velocity,
            surface: &mut self.surface,
            knockback_velocity: &mut self.knockback_velocity,
            knockback_state: &mut self.knockback_state,
            game_settings,
            animation_root_motion_delta,
            animation_root_position,
            animation_frame: self.animation_frame.frame,
            vulnerability: &mut self.vulnerability,
            ledge_info: &mut self.ledge_information,
            fighter_attributes: attributes,
            attack_scripts,
            attack_script_assets,
            facing_direction: &self.facing_direction,
            stage_collision: &stage_collision,
        }
    }
    fn collision_context<'a>(
        &'a mut self,
        stage_collision: &'a StageCollision,
        fighter_manifest: &'a FighterManifest,
        game_settings: &'a GameSettings,
    ) -> CollisionContext<'a> {
        let fighter_ledge_collision_box = FGRect {
            origin: self.translation.0 + fighter_manifest.ledge_grab_box_start,
            end: self.translation.0 + fighter_manifest.ledge_grab_box_end,
        };
        CollisionContext {
            translation: &mut self.translation,
            prev_translation: &self.prev_translation,
            presentation_snap: &mut self.presentation_snap,
            input: &self.input,
            velocity: &mut self.velocity,
            knockback_velocity: &mut self.knockback_velocity,
            knockback_state: &mut self.knockback_state,
            surface: &mut self.surface,
            ecb: &mut self.ecb,
            desired_ecb: &mut self.desired_ecb,
            ledge_info: &mut self.ledge_information,
            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,
            fighter_ledge_collision_box,
            waveland_snap_distance: game_settings.fighter_common.waveland_snap_distance,
        }
    }
 }
@@ -413,6 +531,7 @@ pub struct StatefulFighterQuery {
 pub fn state_update_system(
    mut query: Query<StatefulFighterQuery>,
    game_settings: Res<GameSettings>,
    stage_collision: Res<StageCollision>,
    attack_scripts: Res<Assets<FighterAttackScript>>,
    manifests: Res<Assets<FighterManifest>>,
 ) {
@@ -436,6 +555,7 @@ pub fn state_update_system(
            &manifest.attributes,
            &attack_scripts,
            &fighter.attack_script_assets,
            &stage_collision,
        );
        state.update(&mut update_ctx);
    }
@@ -447,7 +567,10 @@ fn transition_state(
    frame: &mut FighterFrameQueryItem,
    attributes: &FighterAttributes,
    attack_script_assets: &FighterAttackScriptAssets,
    stage_collision: &StageCollision,
    game_settings: &GameSettings,
    baked_animations: &BakedFighterAnimations,
    model_scale: FGi32,
 ) {
    let old_name = current.name();
    let new_name = next.name();
@@ -461,7 +584,14 @@ fn transition_state(
                .leave_ground_ecb_frame_lock_duration,
        );
    }
-    next.on_enter(&mut frame.enter_context(attributes, attack_script_assets, game_settings));
+    next.on_enter(&mut frame.enter_context(
        attributes,
        attack_script_assets,
        game_settings,
        stage_collision,
        baked_animations,
        model_scale,
    ));
    *current = next;
    info!("{} -> {}", old_name, new_name);
 }
@@ -471,6 +601,7 @@ 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 {
@@ -488,11 +619,14 @@ pub fn state_interrupt_system(
        let manifest = fighter_manifests
            .get(&fighter.manifest)
            .expect("Fighter manifest should be valid");
        let baked = baked_animations
            .get(&animations.baked)
            .expect("Animation should exist");
        let new_state = if let Some(reaction) = pending_hit_reaction.take() {
-            hitstop.remaining_frames = *reaction.hitstop_frames;
+            hitstop.remaining_frames = *reaction.victim_hitstop_frames;
            let shake_frames = reaction
-                .hitstop_frames
+                .victim_hitstop_frames
                .calculate_shake_frames(&game_settings);
            hitstop_shake.role = FighterHitstopShakeRole::Receiver;
            hitstop_shake.total_frames = shake_frames;
@@ -511,7 +645,7 @@ pub fn state_interrupt_system(
            if let hitstun::HitstopStateKind::Grounded = hitstop_kind {
                let straight_up_angle = FGi32::lit("90.0");
-                if reaction.hitstop_frames
+                if reaction.victim_hitstop_frames
                    >= HitStop::new(game_settings.fighter_common.tumble_bounce_hitstop_threshold)
                {
                    hitstop_kind = hitstun::HitstopStateKind::Airborne;
@@ -534,9 +668,16 @@ pub fn state_interrupt_system(
            }
            info!("Entering hitstop kind: {:?}", hitstop_kind);
            let stack_previous_knockback = !frame.surface.is_grounded()
                && !frame.knockback_velocity.0.length_squared().is_zero()
                && frame
                    .knockback_state
                    .can_stack(game_settings.fighter_common.knockback_stacking_window);
            Some(FighterState::Hitstun(HitstunState::new(
                reaction,
                hitstop_kind,
                stack_previous_knockback,
            )))
        } else if hitstop.remaining_frames > 0 {
            None
@@ -547,6 +688,7 @@ pub fn state_interrupt_system(
                &baked_animations,
                &manifest.attributes,
                &stage_collision,
                &attack_scripts,
                attack_script_assets,
            ))
        };
@@ -558,7 +700,10 @@ pub fn state_interrupt_system(
                &mut frame,
                &manifest.attributes,
                attack_script_assets,
                &stage_collision,
                &game_settings,
                baked,
                manifest.model_scale,
            );
        };
    }
@@ -573,6 +718,7 @@ pub fn state_collision_interrupt_system(
    mut match_state: ResMut<MatchState>,
    stage_registry: Res<StageManifestRegistry>,
    stage_manifests: Res<Assets<StageManifest>>,
    baked_animations: Res<Assets<BakedFighterAnimations>>,
 ) {
    let Some(stage_manifest_handle) = stage_registry.get(match_config.stage) else {
        return;
@@ -587,6 +733,7 @@ pub fn state_collision_interrupt_system(
            mut state,
            mut frame,
            fighter,
            animations,
            attack_script_assets,
            mut hitstop,
            mut pending_respawn,
@@ -598,6 +745,9 @@ pub fn state_collision_interrupt_system(
        let manifest = fighter_manifests
            .get(&fighter.manifest)
            .expect("Fighter manifest should be valid");
        let baked = baked_animations
            .get(&animations.baked)
            .expect("Animation should exist");
        if pending_respawn.0 {
            **pending_respawn = false;
@@ -623,6 +773,8 @@ pub fn state_collision_interrupt_system(
            // Clear hitstop
            hitstop.remaining_frames = 0;
            frame.knockback_velocity.0 = FGVec2::ZERO;
            frame.knockback_state.clear();
            // subtract one stock
@@ -637,6 +789,9 @@ pub fn state_collision_interrupt_system(
            // reset percentage
            *damage = FighterDamage::default();
            // reset ledge
            *frame.ledge_information = FighterLedgeInformation::default();
            transition_state(
                &mut state,
@@ -644,7 +799,10 @@ pub fn state_collision_interrupt_system(
                &mut frame,
                &manifest.attributes,
                attack_script_assets,
                &stage_collision,
                &game_settings,
                baked,
                manifest.model_scale,
            );
            continue;
        }
@@ -654,7 +812,7 @@ pub fn state_collision_interrupt_system(
        }
        let new_state = state.check_collision_interrupt(
-            &mut frame.collision_context(&stage_collision, &game_settings),
+            &mut frame.collision_context(&stage_collision, manifest, &game_settings),
        );
        if let Some(new_state) = new_state {
            transition_state(
@@ -663,8 +821,97 @@ pub fn state_collision_interrupt_system(
                &mut frame,
                &manifest.attributes,
                &attack_script_assets,
                &stage_collision,
                &game_settings,
                baked,
                manifest.model_scale,
            );
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::fighter::ecb::FighterPreviousECB;
    use crate::stage::line::{StageLedge, StageLedgeSide, StageVertexID};
    #[test]
    fn animation_positions_map_forward_to_facing_and_preserve_height() {
        let position = FGVec3::lit("99", "3", "5");
        assert_eq!(
            animation_position_to_gameplay(position, &FighterFacingDirection::Right),
            FGVec2::lit("5", "3")
        );
        assert_eq!(
            animation_position_to_gameplay(position, &FighterFacingDirection::Left),
            FGVec2::lit("-5", "3")
        );
    }
    #[test]
    fn ledge_lockout_suppresses_ledge_collision() {
        let ledge_id = StageVertexID {
            polygon: 0,
            vertex: 0,
        };
        let stage_collision = StageCollision {
            ledges: vec![StageLedge {
                id: ledge_id,
                position: FGVec2::ZERO,
                hang_side: StageLedgeSide::Left,
            }],
            ..default()
        };
        let previous_translation = FighterPreviousTranslation::default();
        let input = FighterInput::default();
        let mut translation = FighterTranslation::default();
        let mut velocity = FighterVelocity::default();
        let mut knockback_velocity = FighterKnockbackVelocity::default();
        let mut knockback_state = FighterKnockbackState::default();
        let mut surface = FighterSurfaceState::default();
        let mut ecb = FighterECB::default();
        let mut desired_ecb = FighterDesiredECB {
            top: FGVec2::lit("0", "2"),
            bottom: FGVec2::ZERO,
            left: FGVec2::lit("-1", "1"),
            right: FGVec2::lit("1", "1"),
        };
        let mut ledge_info = FighterLedgeInformation {
            regrab_lockout_remaining_frames: 5,
            ..default()
        };
        let previous_ecb = FighterPreviousECB::from(ecb);
        let mut presentation_snap = FighterPresentationSnap::default();
        let context = CollisionContext {
            translation: &mut translation,
            prev_translation: &previous_translation,
            input: &input,
            velocity: &mut velocity,
            knockback_velocity: &mut knockback_velocity,
            knockback_state: &mut knockback_state,
            surface: &mut surface,
            ecb: &mut ecb,
            desired_ecb: &mut desired_ecb,
            ledge_info: &mut ledge_info,
            prev_ecb: &previous_ecb,
            stage_collision: &stage_collision,
            leave_ground_ecb_lock_duration: 0,
            presentation_snap: &mut presentation_snap,
            fighter_ledge_collision_box: FGRect {
                origin: FGVec2::lit("-1", "1"),
                end: FGVec2::lit("1", "-1"),
            },
            downward_stick_threshold: FGi32::ONE,
            waveland_snap_distance: FGi32::ZERO,
        };
        assert!(context.air_collide_with_ledges().is_none());
        context.ledge_info.regrab_lockout_remaining_frames = 0;
        assert_eq!(
            context.air_collide_with_ledges().map(|result| result.ledge),
            Some(ledge_id)
        );
    }
 }
@@ -46,7 +46,10 @@ impl FighterStateImpl for PlatformPassState {
        air::collision_interrupt(
            state_context,
            crate::fighter::state::land::LandingType::Normal,
-            true,
+            crate::fighter::collision::AirCollisionOptions {
                can_pass_through_soft_platforms: true,
                ..Default::default()
            },
        )
    }
@@ -48,7 +48,6 @@ impl FighterStateImpl for RunState {
        ground::apply_grounded_motion(
            state_context.velocity,
            state_context.translation,
            state_context.prev_translation,
        );
    }
@@ -40,7 +40,6 @@ impl FighterStateImpl for WalkState {
        ground::apply_grounded_motion(
            state_context.velocity,
            state_context.translation,
            state_context.prev_translation,
        );
    }
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
-use crate::stage::line::StageLineID;
+use crate::{fighter::FighterLedgeInformation, stage::line::StageLineID};
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub enum EcbLockPolicy {
@@ -53,8 +53,9 @@ impl FighterSurfaceState {
        }
    }
-    pub(crate) fn land(&mut self, line_id: StageLineID) {
+    pub(crate) fn land(&mut self, line_id: StageLineID, ledge_info: &mut FighterLedgeInformation) {
        *self = Self::Grounded { line_id };
        ledge_info.grab_count = 0;
    }
    pub fn clear_polygon_ignore(&mut self, polygon: usize) {
@@ -151,7 +152,11 @@ mod tests {
            polygon: 2,
            segment: 3,
        };
-        surface.land(line_id);
+        let mut ledge_info = FighterLedgeInformation {
            regrab_lockout_remaining_frames: 0,
            grab_count: 0,
        };
        surface.land(line_id, &mut ledge_info);
        assert!(surface.is_grounded());
        assert_eq!(surface.line_id(), Some(line_id));
@@ -220,8 +225,11 @@ mod tests {
        surface.ignore_polygon(3, 5);
        surface.apply_airborne_policy(EcbLockPolicy::Restart, 2);
        assert!(surface.is_polygon_ignored(3));
-
+        let mut ledge_info = FighterLedgeInformation {
-        surface.land(StageLineID { polygon: 0, segment: 0 });
+            regrab_lockout_remaining_frames: 0,
            grab_count: 0,
        };
        surface.land(StageLineID { polygon: 0, segment: 0 }, &mut ledge_info);
        assert!(!surface.is_polygon_ignored(3));
    }
 }
@@ -10,11 +10,15 @@ use crate::{math::int::FGi32, menus::style::FGUiStyle};
 pub struct FighterSettingsCommon {
    pub walk_speed_ease: FGi32,
    /// Horizontal position nudge applied to each overlapping grounded fighter.
    pub grounded_push_nudge: FGi32,
    /// Maximum allowed horizontal velocity
    pub ground_max_horizontal_velocity: FGi32,
    /// Ground friction applied when the fighter is above the walk speed
    pub ground_friction_over_walk_speed_multiplier: FGi32,
    /// Minimum active launch frames between hits before airborne knockback stacks.
    pub knockback_stacking_window: u32,
    pub knockback_decay_per_frame: FGi32,
@@ -48,6 +52,13 @@ pub struct FighterSettingsCommon {
    pub angel_platform_invulnerability_duration: u32,
    /// Frames during which a fighter cannot grab any ledge after dropping from one.
    pub ledge_drop_regrab_lockout_duration_frames: u32,
    /// How many frames (+ the ledge animation duration) the fighter will be invulnerable after grabbing the ledge
    pub ledge_grab_invulnerability_duration: u32,
    /// How many times the fighter can grab the ledge without landing and still get invulnerability
    pub max_ledge_grab_count: 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
@@ -56,6 +67,8 @@ pub struct FighterSettingsCommon {
    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,
    pub waveland_snap_distance: FGi32,
 }
 #[derive(Reflect, Serialize, Deserialize, Clone)]
 #[reflect(opaque)]
@@ -1,28 +1,31 @@
 //! Standalone, read-only attack-script previewer used by `hitbox-editor`.
-use bevy::{camera::CameraProjection, gltf::Gltf, prelude::*, world_serialization::WorldAssetRoot};
+use std::f32::consts::PI;
 use bevy::{
    camera::ScalingMode,
    dev_tools::infinite_grid::{InfiniteGrid, InfiniteGridPlugin, InfiniteGridSettings},
    gltf::Gltf,
    prelude::*,
    world_serialization::WorldAssetRoot,
 };
 use bevy_egui::{EguiContexts, EguiPrimaryContextPass, egui};
 use bevy_ggrs::SnapshotPlugin;
 use clap::{Parser, ValueEnum};
 use egui_extras::Column;
 use itertools::Itertools;
 use crate::{
-    GameAssetPlugin,
+    GameAssetPlugin, egui_color_convert::ColorToEgui, fighter::{
-    fighter::{
+        animation::FighterAnimationFrame, attack::{AttackHitbox, AttackKind, HitStop}, baked_animation::{
        animation::FighterAnimationFrame,
        attack::{AttackHitbox, AttackKind},
        baked_animation::{
            BakedAnimationAssetProcessingPlugin, BakedAnimationSamplingSet,
            BakedAnimationVisualPlugin, BakedFighterAnimations, FighterBoneIndexMap,
            FighterBoneMatrices, FixedMat4,
-        },
+        }, manifest::{FighterHurtbox, FighterManifest}, visual::FighterAnimations,
-        manifest::{FighterHurtbox, FighterManifest},
+    }, filled_gizmos::{FilledGizmos, FilledGizmosPlugin}, game_settings::GameSettings, math::{
        visual::FighterAnimations,
    },
    filled_gizmos::{FilledGizmos, FilledGizmosPlugin},
    math::{
        int::{FGi32, FGi32Ext},
        vec3::FGVec3,
-    },
+    }, scripting::{FighterAttackScript, importer::FighterScriptImportPlugin},
    scripting::{FighterAttackScript, importer::FighterScriptImportPlugin},
 };
 #[derive(Clone, Copy, Debug, ValueEnum)]
@@ -39,6 +42,7 @@ pub enum ViewerAttack {
    UpSmash,
    DownSmash,
    ForwardSmash,
    DashAttack,
 }
 impl From<ViewerAttack> for AttackKind {
@@ -56,6 +60,7 @@ impl From<ViewerAttack> for AttackKind {
            ViewerAttack::UpSmash => Self::UpSmash,
            ViewerAttack::DownSmash => Self::DownSmash,
            ViewerAttack::ForwardSmash => Self::ForwardSmash,
            ViewerAttack::DashAttack => Self::DashAttack,
        }
    }
 }
@@ -67,7 +72,7 @@ pub struct HitboxViewerArgs {
    #[arg(long, default_value = "fighters/test/test.fighter.ron")]
    pub manifest: String,
    /// Attack script and matching animation to preview.
-    #[arg(long, value_enum, default_value_t = ViewerAttack::Jab)]
+    #[arg(long, value_enum, default_value_t = ViewerAttack::NeutralAir)]
    pub attack: ViewerAttack,
    /// Start with fighter hurtboxes hidden.
    #[arg(long)]
@@ -76,10 +81,14 @@ pub struct HitboxViewerArgs {
 #[derive(Resource)]
 struct ViewerAssets {
    settings: Handle<GameSettings>,
    manifest: Handle<FighterManifest>,
    manifest_path: String,
    manifest_choices: Vec<(String, Handle<FighterManifest>)>,
    model: Option<Handle<Gltf>>,
    baked: Option<Handle<BakedFighterAnimations>>,
    script: Option<Handle<FighterAttackScript>>,
    script_attack: Option<AttackKind>,
    fighter: Option<Entity>,
    error: Option<String>,
 }
@@ -91,33 +100,59 @@ struct ViewerState {
    playing: bool,
    show_hurtboxes: bool,
    elapsed: f32,
    manifest_path: String,
 }
 const VIEWER_ATTACKS: [AttackKind; 13] = [
    AttackKind::NeutralAir,
    AttackKind::ForwardAir,
    AttackKind::BackAir,
    AttackKind::DownAir,
    AttackKind::UpAir,
    AttackKind::Jab,
    AttackKind::UpTilt,
    AttackKind::DownTilt,
    AttackKind::ForwardTilt,
    AttackKind::UpSmash,
    AttackKind::DownSmash,
    AttackKind::ForwardSmash,
    AttackKind::DashAttack,
 ];
 pub struct HitboxViewerPlugin;
 impl Plugin for HitboxViewerPlugin {
    fn build(&self, app: &mut App) {
-        let args = app.world().resource::<HitboxViewerArgs>();
+        let (attack, show_hurtboxes, manifest_path) = {
-        let attack = args.attack.into();
+            let args = app.world().resource::<HitboxViewerArgs>();
-        let show_hurtboxes = !args.hide_hurtboxes;
+            (
                args.attack.into(),
                !args.hide_hurtboxes,
                args.manifest.clone(),
            )
        };
        app.add_plugins((
            SnapshotPlugin,
            GameAssetPlugin,
            FighterScriptImportPlugin,
            BakedAnimationAssetProcessingPlugin,
            BakedAnimationVisualPlugin,
            FilledGizmosPlugin,
            InfiniteGridPlugin,
        ))
        .insert_resource(ViewerState {
            attack,
            frame: 0,
-            playing: true,
+            playing: false,
            show_hurtboxes,
            elapsed: 0.0,
            manifest_path,
        })
        .add_systems(Startup, setup)
        .add_systems(
            FixedUpdate,
            (
                apply_viewer_selection,
                request_fighter_dependencies,
                spawn_preview_fighter,
                handle_keyboard,
@@ -133,17 +168,28 @@ impl Plugin for HitboxViewerPlugin {
 }
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>, args: Res<HitboxViewerArgs>) {
    let manifest_path = args.manifest.clone();
    commands.insert_resource(ViewerAssets {
-        manifest: asset_server.load(args.manifest.clone()),
+        settings: asset_server.load("game_settings.ron"),
        manifest: asset_server.load(manifest_path.clone()),
        manifest_path: manifest_path.clone(),
        manifest_choices: vec![(manifest_path.clone(), asset_server.load(manifest_path))],
        model: None,
        baked: None,
        script: None,
        script_attack: None,
        fighter: None,
        error: None,
    });
    commands.spawn((
        Name::new("Hitbox viewer camera"),
        Camera3d::default(),
        Projection::from(OrthographicProjection {
            scaling_mode: ScalingMode::FixedVertical {
                viewport_height: 60.0,
            },
            ..OrthographicProjection::default_3d()
        }),
        Transform::from_xyz(0.0, 9.0, 38.0).looking_at(Vec3::new(0.0, 8.0, 0.0), Vec3::Y),
    ));
    commands.spawn((
@@ -160,30 +206,102 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, args: Res<Hitbo
        brightness: 250.0,
        affects_lightmapped_meshes: true,
    });
    let mut trf = Transform::IDENTITY;
    trf.rotate_local_x(PI * 0.5);
    commands.spawn((InfiniteGrid, InfiniteGridSettings { ..default() }, trf));
 }
 fn apply_viewer_selection(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    manifests: Res<Assets<FighterManifest>>,
    mut viewer: ResMut<ViewerAssets>,
    mut state: ResMut<ViewerState>,
 ) {
    if viewer.manifest_path == state.manifest_path {
        return;
    }
    viewer.manifest_path = state.manifest_path.clone();
    viewer.manifest = asset_server.load(viewer.manifest_path.clone());
    viewer.model = None;
    viewer.baked = None;
    viewer.script = None;
    viewer.script_attack = None;
    viewer.error = None;
    if let Some(fighter) = viewer.fighter.take() {
        commands.entity(fighter).despawn();
    }
    state.frame = 0;
    state.elapsed = 0.0;
    state.playing = false;
    if let Some(manifest) = manifests.get(&viewer.manifest) {
        if !manifest.attack_scripts.contains_key(&state.attack) {
            if let Some(attack) = VIEWER_ATTACKS
                .iter()
                .copied()
                .find(|attack| manifest.attack_scripts.contains_key(attack))
            {
                state.attack = attack;
            }
        }
    }
 }
 fn request_fighter_dependencies(
    asset_server: Res<AssetServer>,
    settings: Res<Assets<GameSettings>>,
    manifests: Res<Assets<FighterManifest>>,
    mut viewer: ResMut<ViewerAssets>,
-    state: Res<ViewerState>,
+    mut state: ResMut<ViewerState>,
 ) {
-    if viewer.model.is_some() {
+    if let Some(settings) = settings.get(&viewer.settings) {
-        return;
+        for path in &settings.fighter_manifest_paths {
            if !viewer
                .manifest_choices
                .iter()
                .any(|(known, _)| known == path)
            {
                viewer
                    .manifest_choices
                    .push((path.clone(), asset_server.load(path.clone())));
            }
        }
    }
    let Some(manifest) = manifests.get(&viewer.manifest) else {
        return;
    };
    let Some(script_path) = manifest.attack_scripts.get(&state.attack) else {
        if let Some(attack) = VIEWER_ATTACKS
            .iter()
            .copied()
            .find(|attack| manifest.attack_scripts.contains_key(attack))
        {
            state.attack = attack;
            return;
        }
        viewer.error = Some(format!(
            "{:?} has no {:?} attack script",
            manifest.id, state.attack
        ));
        return;
    };
-    viewer.model = Some(asset_server.load(manifest.model_path.clone()));
+    if viewer.script_attack != Some(state.attack) {
-    viewer.baked = Some(asset_server.load(manifest.baked_animation_path.clone()));
+        viewer.script = None;
-    viewer.script = Some(asset_server.load(script_path.clone()));
+        viewer.script_attack = None;
        state.frame = 0;
        state.elapsed = 0.0;
        state.playing = false;
    }
    if viewer.model.is_none() {
        viewer.model = Some(asset_server.load(manifest.model_path.clone()));
    }
    if viewer.baked.is_none() {
        viewer.baked = Some(asset_server.load(manifest.baked_animation_path.clone()));
    }
    if viewer.script.is_none() {
        viewer.script = Some(asset_server.load(script_path.clone()));
        viewer.script_attack = Some(state.attack);
    }
    viewer.error = None;
 }
@@ -349,7 +467,6 @@ fn draw_preview(
    scripts: Res<Assets<FighterAttackScript>>,
    baked_assets: Res<Assets<BakedFighterAnimations>>,
    manifests: Res<Assets<FighterManifest>>,
    mut gizmos: Gizmos,
    mut filled: FilledGizmos,
 ) {
    let (Some(script_handle), Some(baked_handle)) = (&viewer.script, &viewer.baked) else {
@@ -398,7 +515,6 @@ fn draw_preview(
            &previous_animation,
            manifest.model_scale,
            fighter_transform,
            &mut gizmos,
            &mut filled,
        );
    }
@@ -411,7 +527,6 @@ fn draw_hitbox(
    previous_animation: &FighterAnimationFrame,
    model_scale: FGi32,
    fighter_transform: FixedMat4,
    gizmos: &mut Gizmos,
    filled: &mut FilledGizmos,
 ) {
    let Some(current_bone) =
@@ -451,13 +566,16 @@ fn draw_hitbox(
        transform.to_isometry(),
        radius,
        length * 0.5,
-        Color::srgba(1.0, 0.1, 0.05, 0.32),
+        bevy::color::Srgba {
            alpha: 0.32,
            ..hitbox.get_debug_draw_color()
        },
    );
-    gizmos.primitive_3d(
+    /*gizmos.primitive_3d(
        &Capsule3d::new(radius, length),
        transform.to_isometry(),
        Color::srgb(1.0, 0.15, 0.1),
-    );
+    );*/
 }
 fn draw_hurtbox(
@@ -487,10 +605,204 @@ fn draw_hurtbox(
    );
 }
 fn draw_summary_ui(
    ui: &mut egui::Ui,
    script: &FighterAttackScript,
    end: u32,
 ) {
    egui::Grid::new("Summary Grid")
        .num_columns(4)
        .striped(true)
        .show(ui, |ui| {
            ui.label("First active");
            ui.label("Last active");
            ui.label("Total");
            ui.label("IASA");
            ui.end_row();
            ui.label(
                script
                    .hitboxes
                    .iter()
                    .map(|hb| hb.start_frame)
                    .min()
                    .map(|frame| format!("{}", frame))
                    .unwrap_or("-".to_owned()),
            );
            ui.label(
                script
                    .hitboxes
                    .iter()
                    .map(|hb| hb.end_frame)
                    .max()
                    .map(|frame| format!("{}", frame - 1))
                    .unwrap_or("-".to_owned()),
            );
            ui.label(format!("{}", end));
            let iasa_frame_label = if let Some(iasa_frame) = script.iasa_frame {
                format!("{}", iasa_frame)
            } else {
                "-".to_owned()
            };
            ui.label(iasa_frame_label);
            ui.end_row();
            ui.label("Landing lag");
            ui.label("Autocancel");
            ui.label("Damage");
            ui.end_row();
            let damages = script
                .hitboxes
                .iter()
                .map(|hb| hb.damage)
                .sorted()
                .dedup()
                .map(|d| format!("{}", d))
                .join(" / ");
            ui.label(
                script
                    .landing_duration
                    .map(|duration| format!("{}", duration))
                    .unwrap_or("-".to_string()),
            );
            let autocancel_text =
                if let Some(wont_autocancel_window) = script.wont_autocancel_window {
                    let autocancel_start = if wont_autocancel_window.0 > 0 {
                        format!("{}", wont_autocancel_window.0)
                    } else {
                        "-".to_string()
                    };
                    let autocancel_end = if wont_autocancel_window.1 < end {
                        format!("{}", wont_autocancel_window.1)
                    } else {
                        "-".to_string()
                    };
                    format!("<{} {}>", autocancel_start, autocancel_end)
                } else {
                    "-".to_string()
                };
            ui.label(autocancel_text);
            ui.label(format!("{} %", damages));
            ui.end_row();
            ui.label("Base knockback");
            ui.label("Knockback Growth");
            ui.label("Set knockback");
            ui.label("Angle");
            ui.end_row();
            let base_knockbacks = script
                .hitboxes
                .iter()
                .map(|hb| hb.knockback)
                .sorted()
                .dedup()
                .map(|d| format!("{}", d))
                .join(" / ");
            ui.label(base_knockbacks);
            let knockback_growths = script
                .hitboxes
                .iter()
                .map(|hb| hb.knockback_growth)
                .sorted()
                .dedup()
                .map(|d| format!("{}", d))
                .join(" / ");
            ui.label(knockback_growths);
            ui.label("-");
            let angles = script
                .hitboxes
                .iter()
                .map(|hb| hb.angle.to_melee_angle_representation())
                .sorted()
                .dedup()
                .map(|d| {
                    format!("{}", d)
                })
                .join(" / ");
            ui.label(angles);
        });
    ui.separator();
    const COLS: [&str; 8] = [
        "Hitbox",
        "Damage",
        "Angle",
        "Base Knockback",
        "Knockback Growth",
        "Set Knockback",
        "Hitstop Attacker",
        "Hitstop Defender",
    ];
    let table_builder = egui_extras::TableBuilder::new(ui)
        .striped(true)
        .resizable(true)
        .cell_layout(egui::Layout::left_to_right(egui::Align::Center))
        .columns(Column::remainder(), COLS.len());
    table_builder.header(20.0, |mut header| {
        for col in COLS {
            header.col(|ui| {
                ui.label(col);
            });
        }
    }).body(|body| {
        body.rows(18.0, script.hitboxes.len(), |mut row| {
            let hitbox = &script.hitboxes[row.index()];
            let hitbox_color = hitbox.get_debug_draw_color().to_egui();
            row.col(|ui| {
                let (response, painter) = ui.allocate_painter(egui::Vec2::new(16.0, 16.0), egui::Sense::empty());
                painter.rect_filled(
                    response.rect,
                    2.0,
                    hitbox_color,
                );
                ui.label(format!("ID {}", hitbox.id));
            });
            row.col(|ui| {
                ui.label(format!("{} %", hitbox.damage));
            });
            row.col(|ui| {
                ui.label(format!("{}", hitbox.angle));
            });
            row.col(|ui| {
                ui.label(format!("{}", hitbox.knockback));
            });
            row.col(|ui| {
                ui.label(format!("{}", hitbox.knockback_growth));
            });
            // TODO: Set knockback
            row.col(|ui| {
                ui.label("-");
            });
            row.col(|ui| {
                ui.label(format!("{}", HitStop::calculate(hitbox.damage, false)));
            });
            row.col(|ui| {
                ui.label(format!("{} ({} crouched)", HitStop::calculate(hitbox.damage, false), HitStop::calculate(hitbox.damage, true)));
            });
        });
    });
 }
 fn draw_ui(
    mut contexts: EguiContexts,
    mut state: ResMut<ViewerState>,
    viewer: Res<ViewerAssets>,
    manifests: Res<Assets<FighterManifest>>,
    scripts: Res<Assets<FighterAttackScript>>,
    baked_assets: Res<Assets<BakedFighterAnimations>>,
 ) -> Result {
@@ -499,10 +811,62 @@ fn draw_ui(
        .script
        .as_ref()
        .and_then(|handle| scripts.get(handle));
    egui::Window::new("Attack")
        .anchor(egui::Align2::RIGHT_TOP, egui::vec2(-10.0, 10.0))
        .resizable(true)
        .show(contexts.ctx_mut()?, |ui| {
            ui.horizontal(|ui| {
                egui::ComboBox::from_id_salt("viewer-fighter")
                    .selected_text(
                        manifests
                            .get(&viewer.manifest)
                            .map(|manifest| format!("{:?}", manifest.id))
                            .unwrap_or_else(|| state.manifest_path.clone()),
                    )
                    .show_ui(ui, |ui| {
                        for (path, handle) in &viewer.manifest_choices {
                            let label = manifests
                                .get(handle)
                                .map(|manifest| format!("{:?}", manifest.id))
                                .unwrap_or_else(|| path.clone());
                            if ui
                                .selectable_label(state.manifest_path == *path, label)
                                .clicked()
                            {
                                state.manifest_path = path.clone();
                            }
                        }
                    });
                egui::ComboBox::from_id_salt("viewer-attack")
                    .selected_text(format!("{:?}", state.attack))
                    .show_ui(ui, |ui| {
                        if let Some(manifest) = manifests.get(&viewer.manifest) {
                            for attack in VIEWER_ATTACKS {
                                if manifest.attack_scripts.contains_key(&attack) {
                                    ui.selectable_value(
                                        &mut state.attack,
                                        attack,
                                        format!("{:?}", attack),
                                    );
                                }
                            }
                        }
                    });
            });
            ui.vertical(|ui| {
                let Some(script) = script else {
                    ui.spinner();
                    ui.label("Waiting for the processed attack script…");
                    return;
                };
                draw_summary_ui(ui, script, end);
            });
        });
    egui::Window::new("Timeline")
        .anchor(egui::Align2::CENTER_BOTTOM, egui::vec2(0.0, -10.0))
-        .resizable(true)
+        .resizable(false)
-        .default_size(egui::vec2(780.0, 190.0))
+        .default_size(egui::vec2(780.0, 250.0))
        .show(contexts.ctx_mut()?, |ui| {
            ui.horizontal(|ui| {
                if ui
@@ -521,8 +885,6 @@ fn draw_ui(
                }
                ui.label(format!("Frame {} / {}", state.frame, end.saturating_sub(1)));
                ui.checkbox(&mut state.show_hurtboxes, "Hurtboxes");
                ui.separator();
                ui.label(format!("{:?}", state.attack));
            });
            if let Some(error) = &viewer.error {
                ui.colored_label(egui::Color32::RED, error);
@@ -532,82 +894,12 @@ fn draw_ui(
                ui.label("Waiting for the processed attack script…");
                return;
            };
-            draw_summary_timeline(ui, &mut state, script, end);
+            //draw_summary_timeline(ui, &mut state, script, end);
            draw_timeline(ui, &mut state, script, end);
        });
    Ok(())
 }
 fn draw_summary_timeline(
    ui: &mut egui::Ui,
    state: &mut ViewerState,
    script: &FighterAttackScript,
    end: u32,
 ) {
    let row_height = 20.0;
    let label_width = 55.0;
    let height = (row_height + 25.0f32).min(ui.available_height());
    let (response, painter) = ui.allocate_painter(
        egui::vec2(ui.available_width(), height),
        egui::Sense::click_and_drag(),
    );
    let rect = response.rect;
    let timeline = egui::Rect::from_min_max(
        egui::pos2(rect.left() + label_width, rect.top()),
        rect.right_bottom(),
    );
    if (response.clicked() || response.dragged())
        && let Some(pointer) = response.interact_pointer_pos()
        && timeline.contains(pointer)
    {
        let fraction = ((pointer.x - timeline.left()) / timeline.width()).clamp(0.0, 1.0);
        state.frame = ((end.saturating_sub(1)) as f32 * fraction).round() as u32;
        state.playing = false;
    }
    for frame in 0..end {
        if frame % 5 != 0 {
            continue;
        }
        let x = frame_x(timeline, frame, end);
        painter.line_segment(
            [egui::pos2(x, rect.top()), egui::pos2(x, rect.bottom())],
            egui::Stroke::new(1.0_f32, egui::Color32::from_gray(55)),
        );
        painter.text(
            egui::pos2(x + 2.0, rect.top()),
            egui::Align2::LEFT_TOP,
            frame.to_string(),
            egui::FontId::monospace(10.0),
            egui::Color32::GRAY,
        );
    }
    for frame in 0..end {
        let top = rect.top() + 20.0 as f32;
        painter.text(
            egui::pos2(rect.left(), top + 2.0),
            egui::Align2::LEFT_TOP,
            format!("HB {}", 2),
            egui::FontId::monospace(12.0),
            egui::Color32::LIGHT_GRAY,
        );
        let active_hitbox = script
            .hitboxes
            .iter()
            .filter(|hitbox| hitbox.start_frame <= frame && hitbox.end_frame > frame)
            .max_by(|a, b| a.id.cmp(&b.id));
        let bar = egui::Rect::from_min_max(
            egui::pos2(frame_x(timeline, frame, end), top + 2.0),
            egui::pos2(frame_x(timeline, frame + 1, end), top + row_height - 2.0),
        );
        if let Some(_active_hitbox) = active_hitbox {
            painter.rect_filled(bar, 2.0, egui::Color32::from_rgb(245, 75, 55));
        } else {
            painter.rect_stroke(bar, 2.0, egui::Stroke::new(2.0f32, egui::Color32::from_rgb(75, 75, 75)), egui::StrokeKind::Inside);
        }
    }
 }
 fn draw_timeline(
    ui: &mut egui::Ui,
    state: &mut ViewerState,
@@ -616,8 +908,9 @@ fn draw_timeline(
 ) {
    let row_height = 20.0;
    let label_width = 55.0;
    // +1 for the summary layer
    let height =
-        (script.hitboxes.len().max(1) as f32 * row_height + 25.0).min(ui.available_height());
+        ((script.hitboxes.len().max(1) + 1) as f32 * row_height + 25.0).min(ui.available_height());
    let (response, painter) = ui.allocate_painter(
        egui::vec2(ui.available_width(), height),
        egui::Sense::click_and_drag(),
@@ -652,12 +945,56 @@ fn draw_timeline(
            egui::Color32::GRAY,
        );
    }
    // Draw summary row
    for frame in 0..end {
        let top = rect.top() + 20.0 as f32;
        let active_hitbox = script
            .hitboxes
            .iter()
            .filter(|hitbox| hitbox.start_frame <= frame && hitbox.end_frame > frame)
            .max_by(|a, b| a.id.cmp(&b.id));
        let bar = egui::Rect::from_min_max(
            egui::pos2(frame_x(timeline, frame, end), top + 2.0),
            egui::pos2(frame_x(timeline, frame + 1, end), top + row_height - 2.0),
        );
        if let Some(active_hitbox) = active_hitbox {
            painter.rect_filled(bar, 2.0, active_hitbox.get_debug_draw_color().to_egui());
        }
        let stroke_color = if let Some(iasa_frame) = script.iasa_frame
            && frame == iasa_frame
        {
            Some(bevy::color::palettes::tailwind::CYAN_300)
        } else if let Some(wont_autocancel_window) = script.wont_autocancel_window
            && (frame < wont_autocancel_window.0 || frame > wont_autocancel_window.1)
        {
            Some(bevy::color::palettes::tailwind::LIME_300)
        } else if let None = active_hitbox {
            Some(bevy::color::palettes::tailwind::GRAY_600)
        } else {
            None
        };
        if let Some(stroke_color) = stroke_color {
            painter.rect_stroke(
                bar,
                2.0,
                egui::Stroke::new(2.0f32, stroke_color.to_egui()),
                egui::StrokeKind::Inside,
            );
        }
    }
    // Draw hitbox rows
    for (row, hitbox) in script.hitboxes.iter().enumerate() {
        let row = row + 1;
        let top = rect.top() + 20.0 + row as f32 * row_height;
        painter.text(
            egui::pos2(rect.left(), top + 2.0),
            egui::Align2::LEFT_TOP,
-            format!("HB {}", hitbox.id),
+            format!("{}", hitbox.id),
            egui::FontId::monospace(12.0),
            egui::Color32::LIGHT_GRAY,
        );
@@ -673,10 +1010,11 @@ fn draw_timeline(
            bar,
            2.0,
            if active {
-                egui::Color32::from_rgb(245, 75, 55)
+                hitbox.get_debug_draw_color()
            } else {
-                egui::Color32::from_rgb(125, 48, 42)
+                hitbox.get_debug_draw_color().darker(0.2)
-            },
+            }
            .to_egui(),
        );
    }
    let playhead = frame_x(timeline, state.frame, end);
@@ -9,6 +9,8 @@ use crate::fighter::FighterFacingDirection;
 use crate::fighter::attack::AttackKind;
 use crate::game_settings::GameSettings;
 use crate::input::{DigitalAction, FighterInputFrame};
 use crate::math::int::FGi32;
 use crate::math::vec::FGVec2;
 use crate::netcode::GGRSCfg;
 use crate::player::Player;
@@ -22,6 +24,7 @@ pub enum FighterCommands {
    SmashMoveDown,
    SmashMoveLeft,
    SmashMoveRight,
    TapJump,
 }
 pub(crate) fn second_binding_pressed(
@@ -32,7 +35,7 @@ pub(crate) fn second_binding_pressed(
 }
 impl FighterCommands {
-    pub const COUNT: usize = 8;
+    pub const COUNT: usize = 9;
    pub const fn index(self) -> usize {
        match self {
@@ -44,6 +47,7 @@ impl FighterCommands {
            Self::SmashMoveDown => 5,
            Self::SmashMoveLeft => 6,
            Self::SmashMoveRight => 7,
            Self::TapJump => 8,
        }
    }
 }
@@ -62,6 +66,34 @@ pub enum FighterAttackCommandType {
    TiltAttackRight,
 }
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub enum FlickDirection {
    Up,
    Down,
    Left,
    Right,
 }
 impl FlickDirection {
    const fn smash_move_command(self) -> FighterCommands {
        match self {
            Self::Up => FighterCommands::SmashMoveUp,
            Self::Down => FighterCommands::SmashMoveDown,
            Self::Left => FighterCommands::SmashMoveLeft,
            Self::Right => FighterCommands::SmashMoveRight,
        }
    }
    const fn smash_attack_command(self) -> FighterAttackCommandType {
        match self {
            Self::Up => FighterAttackCommandType::SmashAttackUp,
            Self::Down => FighterAttackCommandType::SmashAttackDown,
            Self::Left => FighterAttackCommandType::SmashAttackLeft,
            Self::Right => FighterAttackCommandType::SmashAttackRight,
        }
    }
 }
 impl FighterAttackCommandType {
    pub fn to_attack_kind_grounded(&self) -> AttackKind {
        match self {
@@ -191,6 +223,149 @@ impl ButtonHistory {
    }
 }
 #[derive(Clone, Copy, Debug, Hash)]
 struct FlickAxisState {
    age: u8,
    eligible: bool,
    consumed: bool,
    command_emitted: bool,
 }
 impl Default for FlickAxisState {
    fn default() -> Self {
        Self {
            age: u8::MAX,
            eligible: false,
            consumed: false,
            command_emitted: false,
        }
    }
 }
 impl FlickAxisState {
    fn update(
        &mut self,
        current: FGi32,
        previous: FGi32,
        reset_threshold: FGi32,
        axis_threshold: FGi32,
        frame_threshold: u8,
    ) {
        if current.abs() < reset_threshold {
            *self = Self::default();
            return;
        }
        if previous.abs() < reset_threshold || previous.signum() != current.signum() {
            self.age = 1;
            self.consumed = false;
            self.command_emitted = false;
        } else {
            self.age = self.age.saturating_add(1);
        }
        self.eligible =
            !self.consumed && current.abs() >= axis_threshold && self.age <= frame_threshold;
    }
 }
 #[derive(Clone, Copy, Debug, Default, Hash)]
 struct StickFlickState {
    x: FlickAxisState,
    y: FlickAxisState,
 }
 impl StickFlickState {
    fn update(
        &mut self,
        current: FGVec2,
        previous: FGVec2,
        reset_threshold: FGi32,
        axis_threshold: FGi32,
        frame_threshold: u8,
    ) {
        self.x.update(
            current.x,
            previous.x,
            reset_threshold,
            axis_threshold,
            frame_threshold,
        );
        self.y.update(
            current.y,
            previous.y,
            reset_threshold,
            axis_threshold,
            frame_threshold,
        );
    }
    fn peek(&self, value: FGVec2) -> Option<FlickDirection> {
        self.resolve(value, self.x.eligible, self.y.eligible)
    }
    /// Returns each axis that has not produced a passive command during this
    /// gesture. This does not consume the flick, so an attack can still use
    /// the remainder of its smash-input window.
    fn next_commands(&mut self, value: FGVec2) -> [Option<FlickDirection>; 2] {
        let use_x = self.x.eligible && !self.x.command_emitted;
        let use_y = self.y.eligible && !self.y.command_emitted;
        if use_x {
            self.x.command_emitted = true;
        }
        if use_y {
            self.y.command_emitted = true;
        }
        [
            use_x.then_some(if value.x.is_positive() {
                FlickDirection::Right
            } else {
                FlickDirection::Left
            }),
            use_y.then_some(if value.y.is_positive() {
                FlickDirection::Up
            } else {
                FlickDirection::Down
            }),
        ]
    }
    fn consume(&mut self, value: FGVec2) -> Option<FlickDirection> {
        let direction = self.peek(value)?;
        // Simultaneous eligible axes are one diagonal gesture. Consuming only
        // the selected axis would expose the other axis on the next frame.
        if self.x.eligible {
            self.x.consumed = true;
            self.x.eligible = false;
        }
        if self.y.eligible {
            self.y.consumed = true;
            self.y.eligible = false;
        }
        Some(direction)
    }
    fn resolve(&self, value: FGVec2, use_x: bool, use_y: bool) -> Option<FlickDirection> {
        if use_x {
            Some(if value.x.is_positive() {
                FlickDirection::Right
            } else {
                FlickDirection::Left
            })
        } else if use_y {
            Some(if value.y.is_positive() {
                FlickDirection::Up
            } else {
                FlickDirection::Down
            })
        } else {
            None
        }
    }
 }
 /// Per-fighter input state. Every field is deterministic rollback state.
 #[derive(Component, Clone, Copy, Hash)]
 #[require(Rollback)]
@@ -201,8 +376,8 @@ pub struct FighterInput {
    button_history: [ButtonHistory; 3],
    prev_frame: FighterInputFrame,
    current_frame: FighterInputFrame,
-    frames_in_x_flick_deadzone: u8,
+    movement_flick: StickFlickState,
-    frames_in_y_flick_deadzone: u8,
+    directional_attack_flick: StickFlickState,
    attack_command: FighterAttackCommandType,
 }
@@ -215,8 +390,8 @@ impl Default for FighterInput {
            button_history: [ButtonHistory::default(); 3],
            prev_frame: FighterInputFrame::default(),
            current_frame: FighterInputFrame::default(),
-            frames_in_x_flick_deadzone: 0xFE,
+            movement_flick: StickFlickState::default(),
-            frames_in_y_flick_deadzone: 0xFE,
+            directional_attack_flick: StickFlickState::default(),
            attack_command: FighterAttackCommandType::Neutral,
        }
    }
@@ -366,8 +541,26 @@ impl FighterInput {
        self.current_frame.bindings_for(action).count()
    }
-    pub fn get_frames_in_smash_move_deadzone(&self) -> u8 {
+    pub fn peek_movement_flick(&self) -> Option<FlickDirection> {
-        self.frames_in_x_flick_deadzone
+        self.movement_flick.peek(self.current_frame.movement)
    }
    pub fn peek_movement_flick_dbg(&self) -> u8 {
        self.movement_flick.y.age
    }
    pub fn consume_movement_flick(&mut self) -> Option<FlickDirection> {
        self.movement_flick.consume(self.current_frame.movement)
    }
    pub fn peek_directional_attack_flick(&self) -> Option<FlickDirection> {
        self.directional_attack_flick
            .peek(self.current_frame.directional_attack)
    }
    pub fn consume_directional_attack_flick(&mut self) -> Option<FlickDirection> {
        self.directional_attack_flick
            .consume(self.current_frame.directional_attack)
    }
    pub fn set_attack_command_type(&mut self, command: FighterAttackCommandType) {
        self.attack_command = command;
@@ -439,31 +632,30 @@ pub fn postprocess_input(
            );
        }
-        let x_abs = input.current_frame.movement.x.abs();
+        let movement = input.current_frame.movement;
-        let y_abs = input.current_frame.movement.y.abs();
+        let previous_movement = input.prev_frame.movement;
        let directional_attack = input.current_frame.directional_attack;
        let previous_directional_attack = input.prev_frame.directional_attack;
        let x_abs = movement.x.abs();
        let y_abs = 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.movement_flick.update(
-            input.frames_in_x_flick_deadzone = 0xFE;
+            movement,
-        } else if input.prev_frame.movement.x.abs() < reset_deadzone
+            previous_movement,
-            || input.prev_frame.movement.x.signum() != input.current_frame.movement.x.signum()
+            reset_deadzone,
-        {
+            axis_threshold,
-            input.frames_in_x_flick_deadzone = 1;
+            frame_threshold,
-        } else {
+        );
-            input.frames_in_x_flick_deadzone = input.frames_in_x_flick_deadzone.saturating_add(1);
+        input.directional_attack_flick.update(
-        }
+            directional_attack,
-
+            previous_directional_attack,
-        if y_abs < reset_deadzone {
+            reset_deadzone,
-            input.frames_in_y_flick_deadzone = 0xFE;
+            axis_threshold,
-        } else if input.prev_frame.movement.y.abs() < reset_deadzone
+            frame_threshold,
-            || 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.saturating_add(1);
        }
        let tap = game_settings.input_common.input_buffer_size;
        let jump_pressed = input.is_pressed(DigitalAction::Jump);
@@ -483,58 +675,40 @@ pub fn postprocess_input(
            input.set_lifetime(FighterCommands::GuardHold, tap);
        }
-        let mut y_flick_detected =
+        for flick in input
-            y_abs >= axis_threshold && input.frames_in_y_flick_deadzone <= frame_threshold;
+            .movement_flick
-        let mut x_flick_detected =
+            .next_commands(movement)
-            x_abs >= axis_threshold && input.frames_in_x_flick_deadzone <= frame_threshold;
+            .into_iter()
-        if y_flick_detected {
+            .flatten()
-            input.clear_command(FighterCommands::SmashMoveUp);
+        {
-            input.clear_command(FighterCommands::SmashMoveDown);
+            let command = flick.smash_move_command();
-            input.frames_in_y_flick_deadzone = 0xFF;
+            match flick {
-            let command = if input.current_frame.movement.y > 0.0 {
+                FlickDirection::Up | FlickDirection::Down => {
-                FighterCommands::SmashMoveUp
+                    input.clear_command(FighterCommands::SmashMoveUp);
-            } else {
+                    input.clear_command(FighterCommands::SmashMoveDown);
-                FighterCommands::SmashMoveDown
+                }
-            };
+                FlickDirection::Left | FlickDirection::Right => {
                    input.clear_command(FighterCommands::SmashMoveLeft);
                    input.clear_command(FighterCommands::SmashMoveRight);
                }
            }
            input.set_lifetime(command, tap);
-        }
+            if flick == FlickDirection::Up {
-        if x_flick_detected {
+                input.set_lifetime(FighterCommands::TapJump, tap);
-            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 x_flick_detected && y_flick_detected {
            x_flick_detected = x_abs > y_abs;
            y_flick_detected = !x_flick_detected;
        }
        if attack_pressed {
-            let attack_type = if y_flick_detected {
+            let attack_type = if let Some(flick) = input.consume_movement_flick() {
-                if input.current_frame.movement.y > 0.0 {
+                flick.smash_attack_command()
                    FighterAttackCommandType::SmashAttackUp
                } else {
                    FighterAttackCommandType::SmashAttackDown
                }
            } else if x_flick_detected {
                if input.current_frame.movement.x > 0.0 {
                    FighterAttackCommandType::SmashAttackRight
                } else {
                    FighterAttackCommandType::SmashAttackLeft
                }
            } else if x_abs > y_abs {
-                if input.current_frame.movement.x.is_positive() {
+                if movement.x.is_positive() {
                    FighterAttackCommandType::TiltAttackRight
                } else {
                    FighterAttackCommandType::TiltAttackLeft
                }
            } else if y_abs > x_abs {
-                if input.current_frame.movement.y.is_positive() {
+                if movement.y.is_positive() {
                    FighterAttackCommandType::TiltAttackUp
                } else {
                    FighterAttackCommandType::TiltAttackDown
@@ -542,10 +716,16 @@ pub fn postprocess_input(
            } else {
                FighterAttackCommandType::Neutral
            };
            input.set_lifetime(FighterCommands::Attack, tap);
            input.set_attack_command_type(attack_type);
        }
        if let Some(flick) = input.consume_directional_attack_flick() {
            input.set_lifetime(FighterCommands::Attack, tap);
            input.set_attack_command_type(flick.smash_attack_command());
        }
        for command in FighterCommands::iter() {
            input.update_hold(command);
        }
@@ -557,6 +737,20 @@ mod tests {
    use super::*;
    use crate::input::ActionBindingMask;
    const RESET_THRESHOLD: FGi32 = FGi32::lit("0.2");
    const AXIS_THRESHOLD: FGi32 = FGi32::lit("0.8");
    const FRAME_THRESHOLD: u8 = 3;
    fn update_flick(state: &mut StickFlickState, current: FGVec2, previous: FGVec2) {
        state.update(
            current,
            previous,
            RESET_THRESHOLD,
            AXIS_THRESHOLD,
            FRAME_THRESHOLD,
        );
    }
    fn advance_command(input: &mut FighterInput, command: FighterCommands) {
        input.reduce_command_lifetime(command);
        input.update_hold(command);
@@ -577,6 +771,94 @@ mod tests {
        assert!(second_binding_pressed(current, previous));
    }
    #[test]
    fn flick_remains_available_for_the_configured_window() {
        let mut flick = StickFlickState::default();
        let right = FGVec2::lit("1", "0");
        update_flick(&mut flick, right, FGVec2::ZERO);
        assert_eq!(flick.peek(right), Some(FlickDirection::Right));
        for _ in 2..=FRAME_THRESHOLD {
            update_flick(&mut flick, right, right);
            assert_eq!(flick.peek(right), Some(FlickDirection::Right));
        }
        update_flick(&mut flick, right, right);
        assert_eq!(flick.peek(right), None);
    }
    #[test]
    fn passive_command_does_not_consume_flick() {
        let mut flick = StickFlickState::default();
        let right = FGVec2::lit("1", "0");
        update_flick(&mut flick, right, FGVec2::ZERO);
        assert_eq!(
            flick.next_commands(right),
            [Some(FlickDirection::Right), None]
        );
        assert_eq!(flick.next_commands(right), [None, None]);
        assert_eq!(flick.peek(right), Some(FlickDirection::Right));
        update_flick(&mut flick, right, right);
        assert_eq!(flick.consume(right), Some(FlickDirection::Right));
        assert_eq!(flick.peek(right), None);
    }
    #[test]
    fn consumed_flick_rearms_after_returning_below_reset_threshold() {
        let mut flick = StickFlickState::default();
        let right = FGVec2::lit("1", "0");
        update_flick(&mut flick, right, FGVec2::ZERO);
        assert_eq!(flick.consume(right), Some(FlickDirection::Right));
        update_flick(&mut flick, right, right);
        assert_eq!(flick.peek(right), None);
        update_flick(&mut flick, FGVec2::ZERO, right);
        update_flick(&mut flick, right, FGVec2::ZERO);
        assert_eq!(flick.peek(right), Some(FlickDirection::Right));
    }
    #[test]
    fn flick_can_reach_activation_threshold_after_entering_reset_deadzone() {
        let mut flick = StickFlickState::default();
        let partial = FGVec2::lit("0.4", "0");
        let right = FGVec2::lit("1", "0");
        update_flick(&mut flick, partial, FGVec2::ZERO);
        assert_eq!(flick.peek(partial), None);
        update_flick(&mut flick, right, partial);
        assert_eq!(flick.peek(right), Some(FlickDirection::Right));
    }
    #[test]
    fn diagonal_flick_prioritizes_horizontal_and_consumes_the_gesture() {
        let mut flick = StickFlickState::default();
        let diagonal = FGVec2::lit("0.9", "1");
        update_flick(&mut flick, diagonal, FGVec2::ZERO);
        assert_eq!(
            flick.next_commands(diagonal),
            [Some(FlickDirection::Right), Some(FlickDirection::Up)]
        );
        assert_eq!(flick.consume(diagonal), Some(FlickDirection::Right));
        assert_eq!(flick.peek(diagonal), None);
    }
    #[test]
    fn direction_reversal_starts_a_new_flick() {
        let mut flick = StickFlickState::default();
        let right = FGVec2::lit("1", "0");
        let left = FGVec2::lit("-1", "0");
        update_flick(&mut flick, right, FGVec2::ZERO);
        assert_eq!(flick.consume(right), Some(FlickDirection::Right));
        update_flick(&mut flick, left, right);
        assert_eq!(flick.peek(left), Some(FlickDirection::Left));
    }
    #[test]
    fn command_can_be_consumed_without_erasing_raw_input() {
        let mut input = FighterInput::default();
@@ -9,6 +9,7 @@ use crate::math::vec::FGVec2;
 pub fn sample_gamepad(pad: &Gamepad, input_map: &BaseInputMap) -> FighterInputFrame {
    let mut input_frame = FighterInputFrame::default();
    let mut movement = Vec2::ZERO;
    let mut directional_attack = Vec2::ZERO;
    for gamepad_element in &input_map.gamepad {
        match &gamepad_element.binding {
@@ -34,12 +35,24 @@ pub fn sample_gamepad(pad: &Gamepad, input_map: &BaseInputMap) -> FighterInputFr
                            movement.y += sign as f32
                        }
                    }
                    InputMapAction::AttackXDir(sign) => {
                        if pressed {
                            directional_attack.x += sign as f32;
                        }
                    }
                    InputMapAction::AttackYDir(sign) => {
                        if pressed {
                            directional_attack.y += sign as f32;
                        }
                    }
                }
            }
            // gamepad does not have a separate axis for left and right, so sign here should be 1
            GamepadBinding::Axis(axis, sign) => {
                let value = pad.get(*axis).unwrap_or(0.0) * (*sign as f32);
                match gamepad_element.action {
                    InputMapAction::AttackXDir(_) => directional_attack.x += value,
                    InputMapAction::AttackYDir(_) => directional_attack.y += value,
                    InputMapAction::MovementXDir(_) => movement.x += value,
                    InputMapAction::MovementYDir(_) => movement.y += value,
                    _ => {}
@@ -49,6 +62,10 @@ pub fn sample_gamepad(pad: &Gamepad, input_map: &BaseInputMap) -> FighterInputFr
    }
    input_frame.movement = FGVec2::new(FGi32::from_num(movement.x), FGi32::from_num(movement.y));
    input_frame.directional_attack = FGVec2::new(
        FGi32::from_num(directional_attack.x),
        FGi32::from_num(directional_attack.y),
    );
    input_frame
 }
@@ -39,6 +39,12 @@ pub fn sample_keyboard(key: &ButtonInput<KeyCode>, input_map: &BaseInputMap) ->
                    );
                }
            }
            InputMapAction::AttackXDir(sign) => {
                input_frame.directional_attack.x += (sign) * action_strength;
            }
            InputMapAction::AttackYDir(sign) => {
                input_frame.directional_attack.y += (sign) * action_strength;
            }
        }
    }
@@ -12,6 +12,8 @@ pub enum InputActionState {
 #[derive(Debug)]
 pub enum InputMapAction {
    AttackXDir(i32),
    AttackYDir(i32),
    MovementXDir(i32),
    MovementYDir(i32),
    Jump,
@@ -26,6 +28,7 @@ impl InputMapAction {
            Self::Shield => Some(crate::input::DigitalAction::Shield),
            Self::Attack => Some(crate::input::DigitalAction::Attack),
            Self::MovementXDir(_) | Self::MovementYDir(_) => None,
            Self::AttackYDir(_) | Self::AttackXDir(_) => None,
        }
    }
 }
@@ -14,7 +14,7 @@ pub mod gamepad;
 pub mod keyboard;
 pub mod map;
-pub use buffer::{FighterCommands, FighterInput};
+pub use buffer::{FighterCommands, FighterInput, FlickDirection};
 pub use frame::{ActionBindingMask, DigitalAction, DigitalActionBindings, FighterInputFrame};
 pub use map::{
    BaseInputMap, GamepadBinding, GamepadInputMapElement, InputActionState, InputMapAction,
@@ -136,6 +136,11 @@ impl Plugin for FighterInputPlugin {
                    action: InputMapAction::Jump,
                    binding_slot: 0,
                },
                GamepadInputMapElement {
                    binding: GamepadBinding::Button(GamepadButton::West),
                    action: InputMapAction::Jump,
                    binding_slot: 1,
                },
                GamepadInputMapElement {
                    binding: GamepadBinding::Button(GamepadButton::LeftTrigger2),
                    action: InputMapAction::Shield,
@@ -152,6 +157,17 @@ impl Plugin for FighterInputPlugin {
                    action: InputMapAction::Attack,
                    binding_slot: 0,
                },
                //C-stick
                GamepadInputMapElement {
                    binding: GamepadBinding::Axis(GamepadAxis::RightStickX, 1),
                    action: InputMapAction::AttackXDir(1),
                    binding_slot: 0,
                },
                GamepadInputMapElement {
                    binding: GamepadBinding::Axis(GamepadAxis::RightStickY, 1),
                    action: InputMapAction::AttackYDir(1),
                    binding_slot: 0,
                },
            ],
        })
        .insert_resource(MenuInputMap {
@@ -259,6 +275,13 @@ fn preprocess_input_frame(frame: &mut FighterInputFrame, game_settings: &GameSet
    if frame.movement.y.abs() < game_settings.input_common.stick_deadzone {
        frame.movement.y = FGi32::ZERO;
    }
    if frame.directional_attack.x.abs() < game_settings.input_common.stick_deadzone {
        frame.directional_attack.x = FGi32::ZERO;
    }
    if frame.directional_attack.y.abs() < game_settings.input_common.stick_deadzone {
        frame.directional_attack.y = FGi32::ZERO;
    }
 }
 fn read_local_inputs(
@@ -48,6 +48,7 @@ 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;
@@ -62,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 {
@@ -363,6 +363,16 @@ pub fn prepare_match(
            );
            return;
        }
        if !baked.contains_bone(&manifest.root_motion_bone) {
            fail_match(
                &mut next_state,
                &format!(
                    "{:?} references missing root motion bone {:?}",
                    character.fighter, manifest.root_motion_bone
                ),
            );
            return;
        }
        let ecb_bone_indices = baked.bone_names.iter().enumerate().filter_map(|(idx, name)| {
            if manifest.ecb_bones.contains(name) {
@@ -1,10 +1,17 @@
-use bevy::{gltf::GltfMaterialName, pbr::{ExtendedMaterial, MaterialExtension}, prelude::*, render::render_resource::AsBindGroup, shader::ShaderRef, world_serialization::WorldInstanceReady};
+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
+    pub fighter: Entity,
 }
 #[derive(Asset, AsBindGroup, Reflect, Debug, Clone, Default)]
@@ -56,8 +63,6 @@ pub fn bind_fighter_material(
            continue;
        };
        dbg!(material_name);
        if !material_name.starts_with("Fighter_") {
            continue;
        }
@@ -66,12 +71,22 @@ pub fn bind_fighter_material(
            continue;
        };
-        commands.entity(entity).insert((MeshMaterial3d(asset_materials.add(ExtendedMaterial {
+        commands
-            base: StandardMaterial {
+            .entity(entity)
-                // can be used in forward or deferred mode
+            .remove::<MeshMaterial3d<StandardMaterial>>()
-                ..original_material.clone()
+            .insert((
-            },
+                MeshMaterial3d(asset_materials.add(ExtendedMaterial {
-            extension: FighterMaterialExtension::new(bevy::color::palettes::css::BLUE.into())
+                    base: StandardMaterial {
-        })), FighterMesh { fighter: scene_ready.entity  }));
+                        // 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,
                },
            ));
    }
 }
@@ -8,16 +8,12 @@ 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)
+        app
            .add_observer(fighter_material::bind_fighter_material)
            .add_plugins(MaterialPlugin::<fighter_material::FighterMaterial>::default());
    }
@@ -3,3 +3,4 @@ pub mod segment;
 pub mod vec;
 pub mod fixed_transform;
 pub mod vec3;
 pub mod rect;
@@ -0,0 +1,12 @@
 use crate::math::vec::FGVec2;
 pub struct FGRect {
    pub origin: FGVec2,
    pub end: FGVec2,
 }
 impl FGRect {
    pub fn contains_point(&self, point: FGVec2) -> bool {
        point.x >= self.origin.x && point.y <= self.origin.y && point.x <= self.end.x && point.y >= self.end.y
    }
 }
@@ -153,8 +153,8 @@ pub fn navigate(
            Ok(_entity) => {
                // Successfully navigated
            }
-            Err(e) => {
+            Err(_e) => {
-                error!("Navigation error: {}", e)
+                //error!("Navigation error: {}", e)
            }
        }
    }
@@ -17,14 +17,14 @@ pub enum GameplaySet {
    Input,
    /// Decide whether the current fighter state hands off to another one.
    Interrupt,
    /// Sample the animation pose selected by the interrupt pass.
    Animation,
    /// Run the fighter state that survived the interrupt pass.
    StateUpdate,
    /// Integrate velocities into positions.
    Physics,
    /// 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.
@@ -42,9 +42,9 @@ impl Plugin for GameplaySchedulePlugin {
            (
                GameplaySet::Input,
                GameplaySet::Interrupt,
                GameplaySet::Animation,
                GameplaySet::StateUpdate,
                GameplaySet::Physics,
                GameplaySet::Animation,
                GameplaySet::Collision,
                GameplaySet::Attacks,
                GameplaySet::MatchRules,
@@ -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,38 @@ 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>,
    pub use_root_motion: bool
 }
 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 {
+        
-            return Err("autocancel window end precedes its start".into());
+        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,11 +11,40 @@ 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,
    use_root_motion: bool,
 }
 #[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>> {
@@ -43,28 +73,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)?;
        }
@@ -95,16 +115,21 @@ impl MoveCompiler {
        self.iasa_frame = Some(iasa_frame);
    }
    fn enable_root_motion(&mut self) {
        self.use_root_motion = true;
    }
    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,
            use_root_motion: self.use_root_motion,
        })
    }
 }
@@ -117,7 +142,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", |str: &str| AttackAngle::make_normal(FGi32::lit(str)))
+        .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 +155,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 +238,48 @@ pub fn compile_script(text: &str) -> Result<FighterAttackScript, String> {
            );
        }
        {
            let mc = mc.clone();
            engine.register_fn(
                "enable_root_motion",
                move || -> Result<(), Box<EvalAltResult>> {
                    let mut b = mc.borrow_mut();
                    b.enable_root_motion();
                    Ok(())
                },
            );
        }
        {
            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. Melee's default collision
        // group is shared by all hitbox slots in an attack.
        {
            let mc = mc.clone();
            engine.register_fn(
@@ -214,18 +294,11 @@ 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.
                    let id = rhai_u32(id, "hitbox id")?;
                    if b.hitboxes.contains_key(&id) {
                        return Err(format!("Hitbox with ID {} already existed!", id).into());
                    }
                    let hitbox = attack::AttackHitbox {
                        id,
-                        bone: bone.to_owned(),
+                        0,
                        bone,
                        damage,
                        offset,
                        radius,
@@ -233,28 +306,92 @@ pub fn compile_script(text: &str) -> Result<FighterAttackScript, String> {
                        knockback_type,
                        knockback,
                        knockback_growth,
-                        start_frame: b.cursor,
+                    )
-                        end_frame: b.cursor,
+                },
-                    };
+            );
        }
-                    b.hitboxes.insert(id, hitbox);
+        {
-                    b.active_hitboxes.push(id);
+            let mc = mc.clone();
-
+            engine.register_fn(
-                    Ok(())
+                "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
    result
        .map(|_| {
            Rc::into_inner(mc)
                .unwrap()
                .into_inner()
                .into_attack_script()
        })
-        .map_err(|err| err.to_string())?
+        .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,
        radius,
        angle,
        knockback_type,
        knockback,
        knockback_growth,
        start_frame: frame,
        end_frame: frame,
    });
    b.active_hitboxes.insert(id, hitbox_index);
    Ok(())
 }
 #[cfg(test)]
@@ -316,4 +453,44 @@ 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);
    }
    #[test]
    fn legacy_hitboxes_share_the_default_collision_group() {
        let script = compile_script(
            r#"
                frame(1);
                hitbox(0, "hand_l", damage("1"), vec3("0", "0", "0"), fg32("1"), angle("0"), knockback_normal(), knockback("1"), fg32("1"));
                hitbox(1, "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.iter().map(|hitbox| hitbox.group).collect::<Vec<_>>(), vec![0, 0]);
    }
 }
@@ -1,15 +1,15 @@
 use bevy::{color::palettes::css::RED, prelude::*};
 use crate::{
-    match_loading::MatchConfig, math::{int::FGi32, vec3::FGVec3}, stage::{
+    game_settings::GameSettings, match_loading::MatchConfig, math::{int::FGi32, vec3::FGVec3}, stage::{
-        line::StageCollision,
+        line::{StageCollision, StageLedgeSide, StagePolyLineSegmentType}, manifest::{StageManifest, StageManifestRegistry},
        manifest::{StageManifest, StageManifestRegistry},
    },
 };
-pub fn debug_draw_scene(mut gizmos: Gizmos, stage_collision: Res<StageCollision>) {
+pub fn debug_draw_scene(mut gizmos: Gizmos, stage_collision: Res<StageCollision>, game_settings: Res<GameSettings>) {
    for poly in stage_collision.stage_polys.iter() {
-        for segment in poly.segments.iter() {
+        for (segment, next_segment) in poly.segments.iter().zip(poly.segments.iter().cycle().skip(1)) {
            let wavedash_normal = ((next_segment.normal.to_vec2() + segment.normal.to_vec2()) * 0.5).normalize();
            let from = segment.segment.point1().to_vec2();
            let to = segment.segment.point2().to_vec2();
            let from_3d = Vec3::new(from.x, from.y, 0.0);
@@ -18,8 +18,32 @@ pub fn debug_draw_scene(mut gizmos: Gizmos, stage_collision: Res<StageCollision>
            gizmos.line(from_3d, end_3d, RED);
            let midpoint = (from_3d + end_3d) * 0.5;
            gizmos.arrow(midpoint, midpoint + normal_3d, RED);
            if matches!(segment.segment_type, StagePolyLineSegmentType::Floor) {
                let radius = game_settings.fighter_common.waveland_snap_distance.to_num::<f32>();
                let a = segment.segment.point1().to_vec2();
                let a = Vec3::new(a.x, a.y, 0.0);
                let b = segment.segment.point2().to_vec2();
                let b = Vec3::new(b.x, b.y, 0.0);
                let offset = Vec3::new(wavedash_normal.x, wavedash_normal.y, 0.0) * radius;
                gizmos.line(a + offset, b + offset, bevy::color::palettes::css::HOT_PINK);
                gizmos.line(a - offset, b - offset, bevy::color::palettes::css::HOT_PINK);
            }
        }
    }
    for ledge in &stage_collision.ledges {
        let position = ledge.position.to_vec2().extend(0.0);
        let direction = match ledge.hang_side {
            StageLedgeSide::Left => Vec3::NEG_X,
            StageLedgeSide::Right => Vec3::X,
        };
        gizmos.circle(position, 1.5, bevy::color::palettes::css::LIME);
        gizmos.arrow(
            position,
            position + direction * 4.0,
            bevy::color::palettes::css::LIME,
        );
    }
 }
 pub fn debug_draw_blast_zones(
@@ -3,7 +3,7 @@
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
-use crate::math::{segment::FGSegment2d, vec::FGVec2};
+use crate::math::{rect::FGRect, segment::FGSegment2d, vec::FGVec2};
 #[derive(Reflect, Clone, Copy, PartialEq, Serialize, Deserialize)]
 pub enum StagePolyLineSegmentType {
@@ -32,6 +32,27 @@ pub struct StageLineID {
    pub segment: usize,
 }
 /// Identifies a corner in the stage collision geometry.
 #[derive(Reflect, Hash, Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub struct StageVertexID {
    pub polygon: usize,
    pub vertex: usize,
 }
 /// The side of a ledge on which a grabbing fighter hangs.
 #[derive(Reflect, Serialize, Deserialize, Hash, Debug, Clone, Copy, PartialEq, Eq)]
 pub enum StageLedgeSide {
    Left,
    Right,
 }
 #[derive(Reflect, Hash, Debug, Clone, Copy, PartialEq)]
 pub struct StageLedge {
    pub id: StageVertexID,
    pub position: FGVec2,
    pub hang_side: StageLedgeSide,
 }
 #[derive(Reflect, Clone, Default)]
 pub struct StagePoly {
    pub poly_type: StagePolyType,
@@ -44,10 +65,65 @@ pub struct StagePlaneIntersectResult {
    pub normal: FGVec2,
 }
 pub struct StageLedgeIntersectResult {
    pub vertex_id: StageVertexID,
    pub ledge_idx: usize
 }
 #[derive(Resource, Reflect, Clone, Default)]
 #[reflect(Resource)]
 pub struct StageCollision {
    pub stage_polys: Vec<StagePoly>,
    pub ledges: Vec<StageLedge>,
 }
 impl StageCollision {
    pub fn intersect_ledges(&self, ledge_grab_box: &FGRect) -> Option<StageLedgeIntersectResult> {
        for (ledge_idx, ledge) in self.ledges.iter().enumerate() {
            if ledge_grab_box.contains_point(ledge.position) {
                return Some(StageLedgeIntersectResult {
                    vertex_id: ledge.id,
                    ledge_idx
                });
            }
        }
        None
    }
    pub fn find_ledge_by_vertex(&self, vertex: StageVertexID) -> Option<&StageLedge> {
        self.ledges.iter().find(|ledge| ledge.id == vertex)
    }
    /// Returns the walkable segment on the stage side of a ledge.
    pub fn find_ledge_ground_segment(
        &self,
        vertex: StageVertexID,
    ) -> Option<(StageLineID, &StagePolyLineSegment)> {
        let ledge = self.find_ledge_by_vertex(vertex)?;
        let polygon = self.stage_polys.get(vertex.polygon)?;
        let segment = match ledge.hang_side {
            StageLedgeSide::Left => vertex.vertex,
            StageLedgeSide::Right => {
                if vertex.vertex > 0 {
                    vertex.vertex - 1
                } else if matches!(polygon.poly_type, StagePolyType::Closed) {
                    polygon.segments.len().checked_sub(1)?
                } else {
                    return None;
                }
            }
        };
        let line_id = StageLineID {
            polygon: vertex.polygon,
            segment,
        };
        Some((line_id, polygon.get_segment(segment)?))
    }
    pub fn get_segment(&self, segment: StageLineID) -> Option<&StagePolyLineSegment> {
        self.stage_polys.get(segment.polygon).map(|poly| poly.segments.get(segment.segment))?
    }
 }
 impl StagePoly {
@@ -9,7 +9,10 @@ use strum_macros::EnumIter;
 use crate::{
    AppState, game_settings::GameSettings, math::{vec::FGVec2}, stage::{
        StagePoly,
-        line::{StageCollision, StagePolyLineSegmentType, StagePolyType},
+        line::{
            StageCollision, StageLedge, StageLedgeSide, StagePolyLineSegment,
            StagePolyLineSegmentType, StagePolyType, StageVertexID,
        },
    }, texture_reference::TextureReference,
 };
 use bevy::prelude::*;
@@ -71,6 +74,16 @@ pub enum StageId {
 pub struct StagePolyDefinition {
    poly_type: StagePolyType,
    lines: Vec<(FGVec2, StagePolyLineSegmentType)>,
    #[serde(default)]
    ledges: Vec<StageLedgeDefinition>,
 }
 #[derive(Serialize, Deserialize, Clone, Copy, Reflect)]
 pub struct StageLedgeDefinition {
    /// Index into the polygon's `lines`, identifying the corner position.
    vertex: usize,
    /// Side of the corner on which a grabbing fighter will hang.
    hang_side: StageLedgeSide,
 }
 #[derive(Deserialize, Clone, Asset, Reflect, RonAsset)]
@@ -176,6 +189,13 @@ pub fn prepare_stage_manifests(
            );
            return;
        }
        if let Err(error) = manifest.validate_ledges() {
            fail(
                &mut next_state,
                &format!("{:?} has invalid ledges: {error}", manifest.id),
            );
            return;
        }
        if registry.insert(manifest.id, handle.clone()).is_some() {
            fail(
                &mut next_state,
@@ -267,6 +287,14 @@ impl StageManifest {
        Ok(())
    }
    fn validate_ledges(&self) -> Result<(), String> {
        for (polygon_index, definition) in self.polygons.iter().enumerate() {
            definition.validate_ledges(polygon_index)?;
        }
        Ok(())
    }
    pub fn to_collision(&self) -> StageCollision {
        let stage_polys: Vec<StagePoly> = self
            .polygons
@@ -274,7 +302,84 @@ impl StageManifest {
            .map(|def| StagePoly::build(def.poly_type, &def.lines))
            .collect();
-        StageCollision { stage_polys }
+        let ledges = self
            .polygons
            .iter()
            .enumerate()
            .flat_map(|(polygon, definition)| definition.resolved_ledges(polygon))
            .collect();
        StageCollision {
            stage_polys,
            ledges,
        }
    }
 }
 impl StagePolyDefinition {
    fn validate_ledges(&self, polygon_index: usize) -> Result<(), String> {
        let polygon = StagePoly::build(self.poly_type, &self.lines);
        let mut vertices = HashSet::with_capacity(self.ledges.len());
        for ledge in &self.ledges {
            if ledge.vertex >= self.lines.len() {
                return Err(format!(
                    "polygon {polygon_index} references missing vertex {}",
                    ledge.vertex
                ));
            }
            if !vertices.insert(ledge.vertex) {
                return Err(format!(
                    "polygon {polygon_index} defines vertex {} as a ledge more than once",
                    ledge.vertex
                ));
            }
            let outgoing = polygon.get_segment(ledge.vertex);
            let incoming_index = if ledge.vertex > 0 {
                Some(ledge.vertex - 1)
            } else if matches!(self.poly_type, StagePolyType::Closed) {
                polygon.segments.len().checked_sub(1)
            } else {
                None
            };
            let incoming = incoming_index.and_then(|index| polygon.get_segment(index));
            let is_walkable_floor = |segment: Option<&StagePolyLineSegment>| {
                segment.is_some_and(|segment| {
                    segment.segment_type == StagePolyLineSegmentType::Floor
                        && segment.normal.y > crate::math::int::FGi32::ZERO
                })
            };
            let (interior, exterior) = match ledge.hang_side {
                StageLedgeSide::Left => (outgoing, incoming),
                StageLedgeSide::Right => (incoming, outgoing),
            };
            if !is_walkable_floor(interior) {
                return Err(format!(
                    "polygon {polygon_index} vertex {} has no upward-facing floor opposite its {:?} hang side",
                    ledge.vertex, ledge.hang_side
                ));
            }
            if is_walkable_floor(exterior) {
                return Err(format!(
                    "polygon {polygon_index} vertex {} is between two walkable floors rather than at an exposed corner",
                    ledge.vertex
                ));
            }
        }
        Ok(())
    }
    fn resolved_ledges(&self, polygon: usize) -> impl Iterator<Item = StageLedge> + '_ {
        self.ledges.iter().map(move |ledge| StageLedge {
            id: StageVertexID {
                polygon,
                vertex: ledge.vertex,
            },
            position: self.lines[ledge.vertex].0,
            hang_side: ledge.hang_side,
        })
    }
 }
@@ -319,3 +424,115 @@ impl StageCameraProfile {
                < 90.0
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::stage::line::StageLineID;
    fn platform(ledges: Vec<StageLedgeDefinition>) -> StagePolyDefinition {
        StagePolyDefinition {
            poly_type: StagePolyType::Platform,
            lines: vec![
                (FGVec2::lit("-5", "0"), StagePolyLineSegmentType::Floor),
                (FGVec2::lit("5", "0"), StagePolyLineSegmentType::Floor),
            ],
            ledges,
        }
    }
    #[test]
    fn platform_endpoints_can_be_defined_as_ledges() {
        let definition = platform(vec![
            StageLedgeDefinition {
                vertex: 0,
                hang_side: StageLedgeSide::Left,
            },
            StageLedgeDefinition {
                vertex: 1,
                hang_side: StageLedgeSide::Right,
            },
        ]);
        assert_eq!(definition.validate_ledges(3), Ok(()));
        let ledges = definition.resolved_ledges(3).collect::<Vec<_>>();
        assert_eq!(ledges[0].id, StageVertexID { polygon: 3, vertex: 0 });
        assert_eq!(ledges[0].position, FGVec2::lit("-5", "0"));
        assert_eq!(ledges[1].id, StageVertexID { polygon: 3, vertex: 1 });
        assert_eq!(ledges[1].position, FGVec2::lit("5", "0"));
    }
    #[test]
    fn ledge_ground_segments_point_toward_the_stage_interior() {
        let definition = platform(vec![
            StageLedgeDefinition {
                vertex: 0,
                hang_side: StageLedgeSide::Left,
            },
            StageLedgeDefinition {
                vertex: 1,
                hang_side: StageLedgeSide::Right,
            },
        ]);
        let collision = StageCollision {
            stage_polys: vec![StagePoly::build(definition.poly_type, &definition.lines)],
            ledges: definition.resolved_ledges(0).collect(),
        };
        for vertex in [0, 1] {
            let (line_id, segment) = collision
                .find_ledge_ground_segment(StageVertexID { polygon: 0, vertex })
                .unwrap();
            assert_eq!(line_id, StageLineID { polygon: 0, segment: 0 });
            assert!(matches!(
                segment.segment_type,
                StagePolyLineSegmentType::Floor
            ));
        }
    }
    #[test]
    fn invalid_and_duplicate_ledge_vertices_are_rejected() {
        let missing = platform(vec![StageLedgeDefinition {
            vertex: 2,
            hang_side: StageLedgeSide::Right,
        }]);
        assert!(missing.validate_ledges(0).is_err());
        let duplicate = platform(vec![
            StageLedgeDefinition {
                vertex: 0,
                hang_side: StageLedgeSide::Left,
            },
            StageLedgeDefinition {
                vertex: 0,
                hang_side: StageLedgeSide::Right,
            },
        ]);
        assert!(duplicate.validate_ledges(0).is_err());
    }
    #[test]
    fn ledge_must_border_an_upward_facing_floor() {
        let definition = StagePolyDefinition {
            poly_type: StagePolyType::Platform,
            lines: vec![
                (FGVec2::lit("0", "0"), StagePolyLineSegmentType::Wall),
                (FGVec2::lit("0", "5"), StagePolyLineSegmentType::Wall),
            ],
            ledges: vec![StageLedgeDefinition {
                vertex: 0,
                hang_side: StageLedgeSide::Left,
            }],
        };
        assert!(definition.validate_ledges(0).is_err());
        let wrong_side = platform(vec![StageLedgeDefinition {
            vertex: 0,
            hang_side: StageLedgeSide::Right,
        }]);
        assert!(wrong_side.validate_ledges(0).is_err());
    }
 }
Author	SHA1	Message	Date
EIREXE	cbb357d30a	Implement Melee-style knockback stacking (#97 ) CI / build-and-test (push) Successful in 2m11s Details CI / production-build (push) Successful in 12m25s Details ## Summary - stack residual airborne knockback per axis after the configured launch-frame threshold - apply DI after combining the launch vectors while retaining the second hit's hitstun - preserve and decay residual knockback after hitstun - make stacking state rollback-safe and include it in debug save states - clear launch state on landing, ledge interactions, KO, and respawn ## Testing - `cargo check --tests` - `cargo test` (159 tests passed) - `git diff --check` ## Asset configuration For Melee timing, `knockback_stacking_window` should be set to `10`. The local ignored asset package has been updated accordingly. Reviewed-on: #97 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-25 21:02:13 +00:00
EIREXE	7f720119fa	Fix hitbox editor and add dair CI / build-and-test (push) Canceled after 0s Details CI / production-build (push) Canceled after 0s Details	2026-10-22 11:53:38 +02:00
EIREXE	9dfae1de77	Implement land from below, fix attacks not lifting fighters off the ground (#96 ) CI / build-and-test (push) Successful in 1m44s Details CI / production-build (push) Successful in 12m17s Details Reviewed-on: #96 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-14 18:33:17 +00:00
EIREXE	4185bd90d5	Add waveland snapping (#95 ) CI / build-and-test (push) Successful in 2m16s Details CI / production-build (push) Successful in 12m36s Details Reviewed-on: #95 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-14 06:27:51 +00:00
EIREXE	472a0b6a19	Improve ECB behaviour, add ECB interpolation, wall/ceiling support etc (#94 ) CI / build-and-test (push) Successful in 1m43s Details CI / production-build (push) Successful in 11m52s Details Reviewed-on: #94 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-13 19:20:29 +00:00
EIREXE	f1da5c1172	Add ledge getup, ledge intangibility limit & fix walk-off velocity (#93 ) CI / production-build (push) Successful in 12m14s Details CI / build-and-test (push) Successful in 1m40s Details Reviewed-on: #93 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-13 15:52:10 +00:00
EIREXE	4fe1b24b1a	Fix fighter material not removing the original material. (#92 ) CI / build-and-test (push) Failing after 16s Details CI / production-build (push) Successful in 12m10s Details Reviewed-on: #92 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-13 08:24:45 +00:00
EIREXE	f53e67d8ad	Fix ledge transitions and root motion loops (#91 ) CI / production-build (push) Successful in 12m8s Details CI / build-and-test (push) Successful in 1m39s Details ## Summary - resolve each ledge action to the walkable segment on the stage-interior side - preserve repeating root-motion displacement across every animation cycle - add regression coverage for left/right ledge segments and multiple root-motion wraps - Implement ledge intangibility Reviewed-on: #91 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-12 21:38:23 +00:00
EIREXE	9b974d0dd6	Initial work on ledge & improved baking of root motion. (#90 ) CI / build-and-test (push) Successful in 2m15s Details CI / production-build (push) Successful in 12m24s Details Reviewed-on: #90 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-12 20:58:27 +00:00
EIREXE	0642a9234b	Fix one frame visual transform delay (#89 ) CI / build-and-test (push) Successful in 2m28s Details CI / production-build (push) Successful in 12m18s Details Reviewed-on: #89 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-12 20:21:11 +00:00
EIREXE	97f2fe7065	Implement up smash, dacus and further improve input system. (#88 ) CI / build-and-test (push) Successful in 2m42s Details CI / production-build (push) Successful in 13m1s Details Reviewed-on: #88 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-09 09:15:18 +00:00
EIREXE	a1595d841a	Fix determinism being broken due to bone matrix shenanigans (#87 ) CI / build-and-test (push) Successful in 5m27s Details CI / production-build (push) Successful in 22m11s Details Reviewed-on: #87 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-07 19:31:01 +00:00
EIREXE	3dfe2fa000	Optimize rollback sync-test performance (#86 ) CI / build-and-test (push) Successful in 2m11s Details CI / production-build (push) Successful in 11m44s Details ## Summary - remove immutable stage geometry and derived animation/collision data from rollback snapshots - avoid a duplicate full skeletal hierarchy traversal during root-motion sampling - cache root-motion cycle deltas per animation clip - optimize the game crate in development builds - make Tracy profiling opt-in via the `tracy` feature Reviewed-on: #86 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-07 15:50:45 +00:00
EIREXE	259dada54f	Implement grounded fighter pushing (#85 ) CI / build-and-test (push) Successful in 1m30s Details CI / production-build (push) Successful in 11m7s Details Reviewed-on: #85 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-07 07:29:02 +00:00
EIREXE	7a9adbd6a4	Implement animation root motion deltas (#84 ) CI / build-and-test (push) Successful in 1m33s Details CI / production-build (push) Successful in 12m5s Details Implements root motion and adds a dash attack. Reviewed-on: #84 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-05 20:04:35 +00:00
EIREXE	5c277a00f0	Implement tap jump and clean some fluff (#83 ) CI / build-and-test (push) Successful in 1m33s Details CI / production-build (push) Successful in 11m45s Details Reviewed-on: #83 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-05 15:01:31 +00:00
EIREXE	d2d649b059	Attack system revamp (#82 ) CI / build-and-test (push) Successful in 1m35s Details CI / production-build (push) Successful in 11m29s Details - 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 Reviewed-on: #82 Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>	2026-10-04 18:57:29 +00: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