Optimize rollback hot paths

.gitea/workflows/ci.yml

@@ -15,27 +15,6 @@ jobs:
       - name: Check out source
         uses: actions/checkout@v4
 
-      - name: Install Lore CLI
-        run: |
-          scripts/install-lore.sh "$RUNNER_TEMP/lore-bin"
-          echo "$RUNNER_TEMP/lore-bin" >> "$GITHUB_PATH"
-
-      - name: Select Lore asset branch
-        run: |
-          branch=main
-          if [[ "$GITHUB_EVENT_NAME" == pull_request ]]; then
-            branch="$(python3 -c 'import json, os; e=json.load(open(os.environ["GITHUB_EVENT_PATH"], encoding="utf-8")); p=e["pull_request"]; print(p["head"]["ref"] if p["head"]["repo"]["full_name"] == os.environ["GITHUB_REPOSITORY"] else "main")')"
-          fi
-          echo "LORE_BRANCH=$branch" >> "$GITHUB_ENV"
-          echo "Using Lore branch: $branch"
-
-      - name: Fetch assets from Lore
-        env:
-          LORE_CI_USERNAME: ${{ secrets.LORE_CI_USERNAME }}
-          LORE_CI_PASSWORD: ${{ secrets.LORE_CI_PASSWORD }}
-          LORE_AUTH_URL: https://auth.eirexe.moe
-        run: scripts/update-assets.sh "$LORE_BRANCH"
-
       - name: Install Rust toolchain
         run: |
           curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
@@ -79,27 +58,6 @@ jobs:
       - name: Check out source
         uses: actions/checkout@v4
 
-      - name: Install Lore CLI
-        run: |
-          scripts/install-lore.sh "$RUNNER_TEMP/lore-bin"
-          echo "$RUNNER_TEMP/lore-bin" >> "$GITHUB_PATH"
-
-      - name: Select Lore asset branch
-        run: |
-          branch=main
-          if [[ "$GITHUB_EVENT_NAME" == pull_request ]]; then
-            branch="$(python3 -c 'import json, os; e=json.load(open(os.environ["GITHUB_EVENT_PATH"], encoding="utf-8")); p=e["pull_request"]; print(p["head"]["ref"] if p["head"]["repo"]["full_name"] == os.environ["GITHUB_REPOSITORY"] else "main")')"
-          fi
-          echo "LORE_BRANCH=$branch" >> "$GITHUB_ENV"
-          echo "Using Lore branch: $branch"
-
-      - name: Fetch assets from Lore
-        env:
-          LORE_CI_USERNAME: ${{ secrets.LORE_CI_USERNAME }}
-          LORE_CI_PASSWORD: ${{ secrets.LORE_CI_PASSWORD }}
-          LORE_AUTH_URL: https://auth.eirexe.moe
-        run: scripts/update-assets.sh "$LORE_BRANCH"
-
       - name: Install Rust toolchain
         run: |
           curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
@@ -129,11 +87,8 @@ jobs:
             libusb-1.0-0-dev \
             libwayland-dev \
             libx11-dev \
-            libxfixes3 \
-            libxi6 \
             libxkbcommon-dev \
             libxkbcommon-x11-0 \
-            blender \
             lld-19 \
             llvm-19 \
             mesa-vulkan-drivers \
@@ -144,39 +99,9 @@ jobs:
           echo "/usr/lib/llvm-19/bin" >> "$GITHUB_PATH"
           rm -f "$HOME/.cache/cargo-xwin/clang-cl"
 
-      - name: Install pinned Blender
-        run: |
-          scripts/install-blender.sh "$RUNNER_TEMP/blender"
-          echo "BLENDER=$RUNNER_TEMP/blender/blender" >> "$GITHUB_ENV"
-
       - name: Preprocess assets
         run: cargo run --locked --bin process-assets --no-default-features --features debug_features -j 4
 
-      - name: Verify processed battlefield asset
-        run: |
-          python3 - <<'PY'
-          import json
-          import struct
-
-          path = "imported_assets/Default/stages/battlefield/bf2.blend"
-          with open(path, "rb") as asset:
-              header = asset.read(12)
-              if len(header) != 12:
-                  raise SystemExit(f"processed asset is truncated: {path}")
-              magic, version, length = struct.unpack("<4sII", header)
-              if magic != b"glTF" or version != 2 or length != asset.seek(0, 2):
-                  raise SystemExit(f"processed asset is not a valid GLB: {path}")
-              asset.seek(12)
-              json_length, chunk_type = struct.unpack("<II", asset.read(8))
-              if chunk_type != 0x4E4F534A:
-                  raise SystemExit(f"processed asset has no JSON chunk: {path}")
-              document = json.loads(asset.read(json_length))
-          meshes = document.get("meshes", [])
-          if not meshes:
-              raise SystemExit(f"processed asset contains no meshes: {path}")
-          print(f"{path}: {len(meshes)} meshes, {length} bytes")
-          PY
-
       - name: Build production binary
         run: cargo build --locked --profile production --no-default-features --features debug_features -j 4
 

.gitignore

@@ -1,7 +1,6 @@
 /target
 /.jackdaw
 imported_assets
-/assets/
 
 # Local editor configuration
 **/.vscode/

Cargo.toml

@@ -12,7 +12,7 @@ development = ["bevy/dynamic_linking", "bevy/file_watcher"]
 debug_features = ["bevy/free_camera"]
 
 [dependencies]
-bevy = { version = "0.19", features = ["asset_processor", "basis-universal", "compressed_image_saver", "bevy_settings"] }
+bevy = { version = "0.19", features = ["asset_processor", "basis-universal", "bevy_settings"] }
 # Loads the scenes you author in the editor (assets/*.bsn) and builds
 # physics colliders from them. An ordinary dependency; remove it if you
 # stop using authored scenes.

README.md

@@ -30,21 +30,4 @@ cargo run --locked \
   --bin process-assets --no-default-features --features debug_features
 cargo build --locked \
   --profile production --no-default-features --features debug_features
-```
+```
-
-## Assets
-
-Game assets are managed in Lore rather than Git. Install the Lore CLI, then
-bootstrap or update the local checkout with:
-
-```sh
-scripts/install-lore.sh
-scripts/update-assets.sh
-```
-
-The default Lore branch is `main`; pass another branch explicitly when testing
-coordinated code and asset changes:
-
-```sh
-scripts/update-assets.sh my-feature-branch
-```

assets/fighters/test/scripts/fair.attack.rhai

@@ -0,0 +1,12 @@
+frame(4);
+hitbox(0,
+    "hand_l",
+    damage("5.0"),
+    vec3("0.0", "0.0", "0.0"),
+    fg32("5.0"),
+    angle_sakurai(),
+    knockback_normal(),
+    knockback("10.0"),
+    fg32("1.0")
+);
+frame(8);

assets/fighters/test/scripts/jab.attack.rhai

@@ -0,0 +1,12 @@
+frame(3);
+hitbox(0,
+    "hand_l",
+    damage("5.0"),
+    vec3("0.0", "0.0", "0.0"),
+    fg32("5.0"),
+    angle(fg32("45.0")),
+    knockback_normal(),
+    knockback("18.0"),
+    fg32("140.0")
+);
+frame(8);

assets/fighters/test/scripts/uptilt.attack.rhai

@@ -0,0 +1,13 @@
+frame(9);
+hitbox(0,
+    "hand_l",
+    damage("5.0"),
+    vec3("1.0", "0.0", "0.0"),
+    fg32("7.0"),
+    angle_sakurai(),
+    knockback_normal(),
+    knockback("10.0"),
+    fg32("1.0")
+);
+
+frame(15);

assets/fighters/test/test.fighter.ron

@@ -0,0 +1,219 @@
+(
+    id: TestFighter,
+    model_path: "fighters/test/test_fighter.gltf",
+    model_scale: "10.0",
+    baked_animation_path: "fighters/test/test.fighterbake",
+    icon: (
+        path: "fighters/test/icon.png",
+    ),
+    attributes: (
+        base_walk_accel: "0.1",
+        stick_walk_accel: "0.16",
+        max_walk_vel: "1.0",
+        ground_friction: "0.1",
+        dash_acceleration_duration: 13,
+        dash_duration: 24,
+        base_dash_accel: "0.1",
+        stick_dash_accel: "0.05",
+        max_dash_vel: "2.0",
+        short_hop_vertical_velocity: "1.45",
+        full_jump_vertical_velocity: "2.0",
+        jump_horizontal_velocity: "0.6",
+        air_jump_horizontal_velocity: "0.96",
+        air_jump_multiplier: "1.0",
+        dash_initial_velocity: "1.4",
+        terminal_velocity: "3.0",
+        fast_fall_speed: "3.5",
+        gravity: "0.084",
+        weight: "100.0",
+        jumpsquat_duration: 5,
+        landing_iasa: 4,
+        landing_duration: 30,
+
+        max_air_horizontal_velocity: "2.5",
+        air_drift_max: "1.0",
+        air_acceleration_base: "0.03",
+        air_acceleration_stick: "0.01",
+        air_friction: "0.01",
+
+        air_dodge_duration: 49,
+        air_dodge_velocity: "2.790",
+        air_dodge_decay: "0.9",
+        ecb_vertical_midpoint_offset: "0.0"
+    ),
+    camera: (
+        vertical_origin_offset: "8.0",
+        forward_extent: "25.5",
+        backward_extent: "8.5",
+        upward_extent: "15.0",
+        downward_extent: "5.0",
+        visibility_radius: "5.0",
+    ),
+    animations: {
+        Wait: "Idle_Loop_Game",
+        Walk: "Walk_Loop_IK_Game",
+        Run: "Run_Game",
+        Dash: "Dash_Game",
+        JumpSquat: "Jump_Squat_Game",
+        JumpForward: "Jump_Start_IK_Game",
+        JumpBack: "JumpB_Game",
+        LandingSpecial: "SpecialLand_Game",
+        Landing: "Jump_Land_Game",
+        AirDodge: "Idle_Loop_Game",
+        DoubleJumpForward: "Jump_Start_IK_Game",
+        DoubleJumpBack: "JumpB_Game",
+        Fall: "Fall_Loop_Game",
+        Turn: "Turn_Game",
+
+        FlinchGround: "Air_Hit_Game",
+        FlinchAir: "Air_Hit_Game",
+
+        AttackJab1: "Punch_Jab_Game",
+        AttackUpTilt: "Idle_Loop_Game",
+        AttackForwardTilt: "Idle_Loop_Game",
+        AttackDownTilt: "Idle_Loop_Game"
+    },
+    attack_scripts: {
+        NeutralAir: "fighters/test/scripts/fair.attack.rhai",
+        Jab: "fighters/test/scripts/jab.attack.rhai",
+        UpTilt: "fighters/test/scripts/uptilt.attack.rhai",
+        ForwardTilt: "fighters/test/scripts/uptilt.attack.rhai",
+        DownTilt: "fighters/test/scripts/uptilt.attack.rhai",
+    },
+    hurtboxes: [
+        // center one
+        (
+            bone: "spine_01",
+            offset: (x: "0.0", y: "0.0", z: "0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.05",
+            radius: "0.15"
+        ),
+        (
+            bone: "spine_03",
+            offset: (x: "0.0", y: "0.0", z: "0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.05",
+            radius: "0.15"
+        ),
+        (
+            bone: "Head",
+            offset: (x: "0.0", y: "0.125", z: "0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.05",
+            radius: "0.1"
+        ),
+        (
+            bone: "thigh_r",
+            offset: (x: "0.0", y: "0.15", z: "-0.01"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.2",
+            radius: "0.07"
+        ),
+        (
+            bone: "thigh_l",
+            offset: (x: "0.0", y: "0.15", z: "-0.01"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.2",
+            radius: "0.07"
+        ),
+        (
+            bone: "calf_l",
+            offset: (x: "0.0", y: "0.15", z: "-0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.2",
+            radius: "0.05"
+        ),
+        (
+            bone: "calf_r",
+            offset: (x: "0.0", y: "0.15", z: "-0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.2",
+            radius: "0.05"
+        ),
+        (
+            bone: "foot_r",
+            offset: (x: "0.0", y: "0.1", z: "0.01"),
+            rotation: FGVec3(x: "-25.0", y: "0.0", z: "0.0"),
+            half_length: "0.1",
+            radius: "0.04"
+        ),
+        (
+            bone: "foot_l",
+            offset: (x: "0.0", y: "0.1", z: "0.01"),
+            rotation: FGVec3(x: "-25.0", y: "0.0", z: "0.0"),
+            half_length: "0.1",
+            radius: "0.04"
+        ),
+        (
+            bone: "upperarm_l",
+            offset: (x: "0.0", y: "0.09", z: "-0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.125",
+            radius: "0.05"
+        ),
+        (
+            bone: "lowerarm_l",
+            offset: (x: "0.0", y: "0.12", z: "-0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.115",
+            radius: "0.04"
+        ),
+        (
+            bone: "hand_l",
+            offset: (x: "0.0", y: "0.05", z: "-0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.01",
+            radius: "0.04"
+        ),
+        (
+            bone: "upperarm_r",
+            offset: (x: "0.0", y: "0.09", z: "-0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.125",
+            radius: "0.05"
+        ),
+        (
+            bone: "lowerarm_r",
+            offset: (x: "0.0", y: "0.12", z: "-0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.115",
+            radius: "0.04"
+        ),
+        (
+            bone: "hand_r",
+            offset: (x: "0.0", y: "0.05", z: "-0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "0.0"),
+            half_length: "0.01",
+            radius: "0.04"
+        ),
+        /*(
+            bone: "RFootJA",
+            offset: (x: "0.0", y: "0.5", z: "0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "90.0"),
+            half_length: "0.5",
+            radius: "1.0"
+        ),
+        (
+            bone: "JOBJ_47",
+            offset: (x: "0.0", y: "0.0", z: "0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "90.0"),
+            half_length: "0.5",
+            radius: "1.0"
+        ),
+        (
+            bone: "LFootJA",
+            offset: (x: "0.0", y: "0.5", z: "0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "90.0"),
+            half_length: "0.5",
+            radius: "1.0"
+        ),
+        (
+            bone: "JOBJ_41",
+            offset: (x: "0.0", y: "0.0", z: "0.0"),
+            rotation: FGVec3(x: "0.0", y: "0.0", z: "90.0"),
+            half_length: "0.5",
+            radius: "1.0"
+        ),*/
+    ]
+)

assets/fighters/test/test.fighterbake

@@ -0,0 +1,3 @@
+(
+    manifest_path: "fighters/test/test.fighter.ron",
+)

assets/game.stylesheet.ron

@@ -0,0 +1,128 @@
+(
+    cursor: (
+        path: "ui/textures/cursor.png",
+        sampling: Nearest
+    ),
+    css_token: (
+        path: "ui/textures/fighter_select_token.png",
+        sampling: Linear
+    ),
+    player_colors: [
+        Srgba((red: 0.780, green: 0.420, blue: 0.933, alpha: 1.000)),
+        Srgba((red: 0.843, green: 0.227, blue: 0.204, alpha: 1.000)),
+        Srgba((red: 0.333, green: 0.804, blue: 0.078, alpha: 1.000)),
+        Srgba((red: 0.075, green: 0.376, blue: 0.416, alpha: 1.000)),
+        Srgba((red: 0.682, green: 0.878, blue: 0.914, alpha: 1.000))
+    ],
+    button_styles: {
+        MainMenu: (
+            focus_outline_width_px: 4,
+            focus_outline_offset_px: 2,
+            focus_outline_color: Srgba((red: 1.0, green: 1.0, blue: 0.0, alpha: 1.0)),
+            normal: (
+                background_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                border_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                text_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                box_shadow: (),
+            ),
+            press: (
+                background_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                border_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                text_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                box_shadow: (),
+            ),
+            hover: (
+                background_color: Srgba((red: 0.0, green: 1.0, blue: 0.0, alpha: 1.0)),
+                border_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                text_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                box_shadow: (),
+            )
+        ),
+        CharacterSelectCharacter: (
+            focus_outline_width_px: 10,
+            focus_outline_offset_px: 5,
+            focus_outline_color: Srgba((red: 1.0, green: 1.0, blue: 0.0, alpha: 1.0)),
+            normal: (
+                background_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                text_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                box_shadow: (),
+                border_size: 10,
+            ),
+            press: (
+                background_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                text_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                box_shadow: (),
+            ),
+            hover: (
+                background_color: Srgba((red: 0.0, green: 1.0, blue: 0.0, alpha: 1.0)),
+                text_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                box_shadow: (),
+            )
+        ),
+        CharacterSelectStartBanner: (
+            focus_outline_width_px: 10,
+            focus_outline_offset_px: 5,
+            focus_outline_color: Srgba((red: 1.0, green: 1.0, blue: 0.0, alpha: 1.0)),
+            normal: (
+                background_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                text_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                box_shadow: (),
+            ),
+            press: (
+                background_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                text_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                box_shadow: (),
+            ),
+            hover: (
+                background_color: Srgba((red: 0.0, green: 1.0, blue: 0.0, alpha: 1.0)),
+                text_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                box_shadow: (),
+            )
+        ),
+        StageSelectIcon: (
+            focus_outline_width_px: 4,
+            focus_outline_offset_px: 2,
+            focus_outline_color: Srgba((red: 1.0, green: 1.0, blue: 0.0, alpha: 1.0)),
+            normal: (
+                border_color: Srgba((red: 1.0, green: 1.0, blue: 0.0, alpha: 1.0)),
+                background_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 0.0)),
+                text_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                border_size: 10,
+                border_radius: 40.0,
+                box_shadow: (
+                    spread_radius: 5.0,
+                    blur_radius: 5.0,
+                    offset_px_y: 10,
+                    offset_px_x: 10,
+                    color: Srgba((red: 1.0, green: 1.0, blue: 1.0, alpha: 1.0))
+                ),
+            ),
+            press: (
+                background_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                border_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                text_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                border_radius: 40.0,
+                border_size: 10,
+                box_shadow: (
+                    spread_radius: 5.0,
+                    offset_px_y: 10,
+                    offset_px_x: 10,
+                    color: Srgba((red: 1.0, green: 1.0, blue: 1.0, alpha: 1.0))
+                ),
+            ),
+            hover: (
+                background_color: Srgba((red: 0.0, green: 1.0, blue: 0.0, alpha: 1.0)),
+                border_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                border_radius: 40.0,
+                border_size: 10,
+                text_color: Srgba((red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)),
+                box_shadow: (
+                    spread_radius: 5.0,
+                    offset_px_y: 10,
+                    offset_px_x: 10,
+                    color: Srgba((red: 1.0, green: 1.0, blue: 1.0, alpha: 1.0))
+                ),
+            )
+        ),
+    }
+)

assets/game_settings.ron

@@ -0,0 +1,36 @@
+(   
+    input_common: (
+        stick_deadzone: "0.275",
+        trigger_deadzone: "0.3",
+        smash_input_reset_axis_threshold: "0.25",
+        smash_input_axis_threshold: "0.8",
+        run_stick_threshold: "0.625",
+        smash_input_frame_threshold: 3,
+        input_buffer_size: 3,
+        turn_into_dashback_window: 2,
+    ),
+    fighter_common: (
+        walk_speed_ease: "0.5",
+        ground_max_horizontal_velocity: "3.0",
+        ground_friction_over_walk_speed_multiplier: "2.0",
+        knockback_stacking_window: 2,
+        knockback_decay_per_frame: "0.051",
+        knockback_launch_velocity_multiplier: "0.03",
+        hitstun_frames_per_unit_knockback: "0.4",
+        tumble_bounce_hitstop_threshold: 32,
+        attack_ground_to_airborne_transition_vertical_angle_threshold: "90.0",
+        meteor_angle_threshold: "10.0",
+        visual_shake_frames_per_hitstop_frame: "1.2",
+        visual_shake_table: [
+            -3.0, -1.5, 1.5, 3.0
+        ],
+        attacker_visual_shake_multiplier: 0.4,
+        di_max_angle: "18.0"
+    ),
+    stage_manifest_paths: [
+        "stages/battlefield/test.stage.ron"
+    ],
+    fighter_manifest_paths: [
+        "fighters/test/test.fighter.ron"
+    ]
+)

assets/stages/battlefield/test.stage.ron

@@ -0,0 +1,139 @@
+(
+    id: TestStage,
+    model_path: "stages/battlefield/battlefield.glb#Scene0",
+    icon: (
+        path: "stages/battlefield/icon.png"
+    ),
+
+    // Battlefield
+    /*camera: (
+        left: -200.0,
+        right: 200.0,
+        bottom: -59.0,
+        top: 170.0,
+        origin: (0.0, 44.0),
+        vertical_fov_degrees: 30.0,
+        min_depth: 83.0,
+        max_depth: 1000.0,
+        subject_scale: 1.5,
+        fighter_forward_extent_scale: 1.5,
+        tracking_smoothness: 1.8,
+        vertical_pan_degrees: -10.0,
+        horizontal_pan_degrees_per_unit: 0.1,
+        vertical_pan_degrees_per_unit: 0.1,
+        max_horizontal_pan_degrees: 17.5,
+        max_upward_pan_degrees: 5.0,
+        max_downward_pan_degrees: 7.0,
+    ),*/
+    // Yoshi's story
+
+    /*camera: (
+        left: -180.0,
+        right: 179.0,
+        bottom: -71.0,
+        top: 169.0,
+        origin: (0.0, 44.0),
+        vertical_fov_degrees: 20.0,
+        min_depth: 100.0,
+        max_depth: 1000.0,
+        subject_scale: 1.0,
+        fighter_forward_extent_scale: 1.0,
+        tracking_smoothness: 1.0,
+        vertical_pan_degrees: -10.0,
+        horizontal_pan_degrees_per_unit: 0.05,
+        vertical_pan_degrees_per_unit: 0.15,
+        max_horizontal_pan_degrees: 17.5,
+        max_upward_pan_degrees: 5.0,
+        max_downward_pan_degrees: 7.0,
+    ),*/
+
+    camera: (
+        left: -180.0,
+        right: 179.0,
+        bottom: -71.0,
+        top: 169.0,
+        origin: (0.0, 44.0),
+        vertical_fov_degrees: 20.0,
+        min_depth: 100.0,
+        max_depth: 1000.0,
+        subject_scale: 1.5,
+        fighter_forward_extent_scale: 1.0,
+        tracking_smoothness: 1.0,
+        vertical_pan_degrees: -10.0,
+        horizontal_pan_degrees_per_unit: 0.05,
+        vertical_pan_degrees_per_unit: 0.15,
+        max_horizontal_pan_degrees: 17.5,
+        max_upward_pan_degrees: 5.0,
+        max_downward_pan_degrees: 7.0,
+    ),
+    polygons: [
+        (
+            poly_type: Platform,
+            lines: [
+                (
+                    (x: "-20.0", y: "47.0"),
+                    Floor
+                ),
+                (
+                    (x: "20.0", y: "47.0"),
+                    Floor
+                )
+            ]
+        ),
+        (
+            poly_type: Platform,
+            lines: [
+                (
+                    (x: "-65.0", y: "24.0"),
+                    Floor
+                ),
+                (
+                    (x: "-25.0", y: "24.0"),
+                    Floor
+                )
+            ]
+        ),
+        (
+            poly_type: Platform,
+            lines: [
+                (
+                    (x: "25.0", y: "24.0"),
+                    Floor
+                ),
+                (
+                    (x: "65.0", y: "24.0"),
+                    Floor
+                )
+            ]
+        ),
+        (
+            poly_type: Closed,
+            lines: [
+                (
+                    (x: "-68.0", y: "-3.0"),
+                    Wall
+                ),
+                (
+                    (x: "-68.0", y: "0.0"),
+                    Floor,
+                ),
+                (
+                    (x: "0.0", y: "0.0"),
+                    Floor
+                ),
+                (
+                    (x: "68", y: "0.0"),
+                    Wall
+                ),
+                (
+                    (x: "68.0", y: "-3.0"),
+                    Ceiling
+                ),
+                (
+                    (x: "0.0", y: "-15.0"),
+                    Ceiling
+                ),
+            ]
+        )
+    ]
+)

assets/ui/textures/fighter_select_token.svg

@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="128"
+   height="128"
+   viewBox="0 0 33.866666 33.866666"
+   version="1.1"
+   id="svg1"
+   inkscape:version="1.4.4 (dcaf3e7d9e, 2026-05-05)"
+   sodipodi:docname="cursor.svg"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview1"
+     pagecolor="#000000"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:document-units="mm"
+     inkscape:zoom="5.6568542"
+     inkscape:cx="8.6620581"
+     inkscape:cy="67.086756"
+     inkscape:window-width="2560"
+     inkscape:window-height="1006"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="layer1" />
+  <defs
+     id="defs1">
+    <linearGradient
+       id="linearGradient1"
+       inkscape:collect="always">
+      <stop
+         style="stop-color:#949494;stop-opacity:1;"
+         offset="0"
+         id="stop1" />
+      <stop
+         style="stop-color:#6c6c6c;stop-opacity:1;"
+         offset="0.77473962"
+         id="stop3" />
+      <stop
+         style="stop-color:#9f9f9f;stop-opacity:1;"
+         offset="1"
+         id="stop2" />
+    </linearGradient>
+    <radialGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient1"
+       id="radialGradient2"
+       cx="16.933332"
+       cy="16.933332"
+       fx="16.933332"
+       fy="16.933332"
+       r="12.733072"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1.2093771,0,0,1.2093771,-3.5454518,-3.5454518)" />
+  </defs>
+  <g
+     inkscape:label="Capa 1"
+     inkscape:groupmode="layer"
+     id="layer1">
+    <circle
+       style="fill:url(#radialGradient2);stroke-width:0.319981"
+       id="path1"
+       cx="16.933332"
+       cy="16.933332"
+       r="15.399086" />
+  </g>
+</svg>

scripts/install-blender.sh

@@ -1,30 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-version="5.2.2"
-sha256="84098912789dc450e95697c4184fb8a90acbe5111c2ba4aede3fecb57806a168"
-install_dir="${1:-${BLENDER_INSTALL_DIR:-${HOME}/.local/blender-${version}}}"
-
-if [[ "$(uname -s)" != Linux || "$(uname -m)" != x86_64 ]]; then
-    echo "error: this installer currently supports Linux x86_64 only" >&2
-    exit 1
-fi
-
-if [[ -x "$install_dir/blender" ]]; then
-    "$install_dir/blender" --version | head -n 1
-    exit 0
-fi
-
-mkdir -p "$(dirname "$install_dir")"
-tmp_dir="$(mktemp -d)"
-trap 'rm -rf "$tmp_dir"' EXIT
-
-archive="blender-${version}-linux-x64.tar.xz"
-url="https://download.blender.org/release/Blender5.2/${archive}"
-
-curl --fail --location --silent --show-error --output "$tmp_dir/$archive" "$url"
-printf '%s  %s\n' "$sha256" "$tmp_dir/$archive" | sha256sum --check --status
-tar --extract --xz --file "$tmp_dir/$archive" --directory "$tmp_dir"
-mv "$tmp_dir/blender-${version}-linux-x64" "$install_dir"
-
-"$install_dir/blender" --version | head -n 1

scripts/install-lore.sh

@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-version="v0.10.0"
-sha256="0d1633b71e44081c6a3ca57ad5be3df7a9563698827638838939c3c832e87351"
-install_dir="${1:-${LORE_INSTALL_DIR:-${HOME}/.local/bin}}"
-
-if [[ "$(uname -s)" != Linux || "$(uname -m)" != x86_64 ]]; then
-    echo "error: this installer currently supports Linux x86_64 only" >&2
-    exit 1
-fi
-
-mkdir -p "$install_dir"
-tmp_dir="$(mktemp -d)"
-trap 'rm -rf "$tmp_dir"' EXIT
-
-archive="lore-${version}-x86_64-unknown-linux-gnu.tar.gz"
-url="https://github.com/EpicGames/lore/releases/download/${version}/${archive}"
-
-curl --fail --location --silent --show-error --output "$tmp_dir/$archive" "$url"
-printf '%s  %s\n' "$sha256" "$tmp_dir/$archive" | sha256sum --check --status
-tar --extract --gzip --file "$tmp_dir/$archive" --directory "$tmp_dir"
-
-binary="$(find "$tmp_dir" -type f -name lore -print -quit)"
-if [[ -z "$binary" ]]; then
-    echo "error: Lore archive did not contain a lore binary" >&2
-    exit 1
-fi
-
-install -m 0755 "$binary" "$install_dir/lore"
-"$install_dir/lore" --version

scripts/update-assets.sh

@@ -1,111 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-readonly lore_url="${LORE_REPOSITORY_URL:-lore://lore.eirexe.moe/shinespark}"
-readonly default_branch="${LORE_DEFAULT_BRANCH:-main}"
-readonly assets_dir="${LORE_ASSETS_DIR:-assets}"
-branch="${1:-${LORE_BRANCH:-$default_branch}}"
-
-case "$branch" in
-    ""|*[!A-Za-z0-9._/-]*)
-        echo "error: invalid Lore branch name: $branch" >&2
-        exit 2
-        ;;
-esac
-
-if [[ -n "${LORE_IDENTITY_TOKEN:-}" ]]; then
-    lore_args=(--identity-token "$LORE_IDENTITY_TOKEN")
-elif [[ -n "${LORE_CI_USERNAME:-}" || -n "${LORE_CI_PASSWORD:-}" ]]; then
-    if [[ -z "${LORE_CI_USERNAME:-}" || -z "${LORE_CI_PASSWORD:-}" ]]; then
-        echo "error: LORE_CI_USERNAME and LORE_CI_PASSWORD must be provided together" >&2
-        exit 2
-    fi
-    : "${LORE_AUTH_URL:=https://auth.eirexe.moe}"
-    export LORE_AUTH_URL
-    token="$(python3 - <<'PY'
-import json
-import os
-import sys
-import urllib.error
-import urllib.request
-
-request = urllib.request.Request(
-    os.environ["LORE_AUTH_URL"].rstrip("/") + "/auth/login",
-    data=json.dumps({
-        "username": os.environ["LORE_CI_USERNAME"],
-        "password": os.environ["LORE_CI_PASSWORD"],
-    }).encode(),
-    headers={"Content-Type": "application/json"},
-    method="POST",
-)
-try:
-    with urllib.request.urlopen(request) as response:
-        payload = json.load(response)
-except urllib.error.HTTPError as error:
-    print(f"Lore authentication failed with HTTP {error.code}", file=sys.stderr)
-    sys.exit(1)
-
-token = payload.get("token")
-if not isinstance(token, str) or not token:
-    print("Lore authentication response did not contain a token", file=sys.stderr)
-    sys.exit(1)
-print(token)
-PY
-    )"
-    if [[ -n "${GITHUB_ENV:-}" ]]; then
-        echo "::add-mask::$token"
-    fi
-    lore_args=(--identity-token "$token")
-else
-    lore_args=()
-fi
-
-if [[ -e "$assets_dir" && ! -d "$assets_dir" ]]; then
-    echo "error: $assets_dir exists but is not a directory" >&2
-    exit 1
-fi
-
-if [[ -d "$assets_dir/.lore" ]]; then
-    if ! lore "${lore_args[@]}" --repository "$assets_dir" repository info >/dev/null; then
-        echo "error: $assets_dir is not a usable Lore checkout" >&2
-        exit 1
-    fi
-    if ! lore "${lore_args[@]}" --repository "$assets_dir" branch list --no-pager \
-        | grep -Fqx "  $branch"; then
-        if [[ "$branch" != "$default_branch" ]]; then
-            echo "warning: Lore branch does not exist: $branch; using $default_branch" >&2
-            branch="$default_branch"
-        else
-            echo "error: Lore branch does not exist: $branch" >&2
-            exit 1
-        fi
-    fi
-    lore "${lore_args[@]}" --repository "$assets_dir" sync "$branch@LATEST"
-    exit 0
-fi
-
-if [[ -d "$assets_dir" && -n "$(find "$assets_dir" -mindepth 1 -maxdepth 1 -print -quit)" ]]; then
-    echo "error: refusing to overwrite non-Lore directory: $assets_dir" >&2
-    exit 1
-fi
-
-metadata_dir="$(mktemp -d)"
-trap 'rm -rf "$metadata_dir"' EXIT
-lore "${lore_args[@]}" --non-interactive clone --bare "$lore_url" "$metadata_dir"
-
-if ! lore "${lore_args[@]}" --repository "$metadata_dir" branch list --no-pager \
-    | grep -Fqx "  $branch"; then
-    if [[ "$branch" != "$default_branch" ]]; then
-        echo "warning: Lore branch does not exist: $branch; using $default_branch" >&2
-        branch="$default_branch"
-    else
-        echo "error: Lore branch does not exist: $branch" >&2
-        echo "available branches:" >&2
-        lore "${lore_args[@]}" --repository "$metadata_dir" branch list --no-pager >&2
-        exit 1
-    fi
-fi
-
-rm -rf "$assets_dir"
-lore "${lore_args[@]}" --non-interactive clone --branch "$branch" "$lore_url" "$assets_dir"
-lore "${lore_args[@]}" --repository "$assets_dir" status --revision-only --no-pager

src/blend_asset.rs

@@ -1,394 +0,0 @@
-//! Blender `.blend` source processing.
-//!
-//! Blender is used as an offline importer. The processed result is a normal
-//! GLB, so the runtime continues to use Bevy's built-in glTF loader.
-
-use bevy::{
-    asset::{
-        AssetLoader, AssetPath, AsyncWriteExt, LoadContext,
-        io::{Reader, Writer},
-        processor::LoadTransformAndSave,
-        saver::{AssetSaver, SavedAsset},
-        transformer::{AssetTransformer, TransformedAsset},
-    },
-    gltf::GltfLoader,
-    prelude::*,
-    reflect::TypePath,
-};
-use serde::Deserialize;
-use std::{
-    collections::HashMap,
-    fs, io,
-    path::{Path, PathBuf},
-    process::Command,
-    time::{SystemTime, UNIX_EPOCH},
-};
-
-use crate::fighter::animation::AnimKind;
-
-const EXPORT_SCRIPT: &str = include_str!("blend_asset/export.py");
-
-#[derive(Asset, TypePath)]
-struct BlendSource {
-    glb: Vec<u8>,
-}
-
-#[derive(Default, TypePath)]
-struct BlendSourceLoader;
-
-#[derive(Debug, Deserialize)]
-struct ExportManifest {
-    dependencies: Vec<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct AnimationManifest {
-    animations: HashMap<AnimKind, String>,
-}
-
-impl AssetLoader for BlendSourceLoader {
-    type Asset = BlendSource;
-    type Settings = ();
-    type Error = io::Error;
-
-    async fn load(
-        &self,
-        reader: &mut dyn Reader,
-        _: &Self::Settings,
-        load_context: &mut LoadContext<'_>,
-    ) -> Result<Self::Asset, Self::Error> {
-        let mut source_bytes = Vec::new();
-        reader.read_to_end(&mut source_bytes).await?;
-
-        let temp = TempDir::new()?;
-        let source_path = locate_source(load_context.path().path());
-        let blend_path = if let Some(path) = source_path.as_deref() {
-            path.to_path_buf()
-        } else {
-            let path = temp.path().join("source.blend");
-            fs::write(&path, source_bytes)?;
-            path
-        };
-        let output = temp.path().join("export.gltf");
-        let script = temp.path().join("export.py");
-        let actions = referenced_actions(load_context, &asset_root()).await?;
-        let actions_path = temp.path().join("actions.json");
-        fs::write(
-            &actions_path,
-            serde_json::to_vec(&actions).map_err(io::Error::other)?,
-        )?;
-        fs::write(&script, EXPORT_SCRIPT)?;
-
-        let result = Command::new(std::env::var_os("BLENDER").unwrap_or_else(|| "blender".into()))
-            .arg("--background")
-            .arg(&blend_path)
-            .arg("--python")
-            .arg(&script)
-            .arg("--")
-            .arg(&output)
-            .arg(&actions_path)
-            .arg(&blend_path)
-            .output()
-            .map_err(|error| io::Error::other(format!("failed to start Blender: {error}")))?;
-        if !result.status.success() {
-            return Err(io::Error::other(format!(
-                "Blender export failed with {}:\n{}\n{}",
-                result.status,
-                String::from_utf8_lossy(&result.stdout),
-                String::from_utf8_lossy(&result.stderr)
-            )));
-        }
-
-        let manifest: ExportManifest =
-            serde_json::from_slice(&fs::read(temp.path().join("export-manifest.json"))?)
-                .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
-
-        let asset_root = asset_root();
-        let mut dependencies = manifest.dependencies;
-        let document: serde_json::Value = serde_json::from_slice(&fs::read(&output)?)
-            .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
-        validate_export(&document, &output)?;
-        if let Some(images) = document.get("images").and_then(serde_json::Value::as_array) {
-            for image in images {
-                if let Some(uri) = image.get("uri").and_then(serde_json::Value::as_str) {
-                    let path = temp.path().join(uri);
-                    dependencies.push(path.to_string_lossy().into_owned());
-                }
-            }
-        }
-
-        let mut seen = std::collections::HashSet::new();
-        for dependency in dependencies {
-            let physical = PathBuf::from(&dependency);
-            let Some(asset_path) = physical_to_asset_path(&physical, &asset_root) else {
-                continue;
-            };
-            if seen.insert(asset_path.clone()) {
-                // This read is intentionally discarded: it registers the file and
-                // its processed hash as a processor dependency.
-                load_context
-                    .read_asset_bytes(asset_path)
-                    .await
-                    .map_err(|error| {
-                        io::Error::other(format!("failed to read blend dependency: {error}"))
-                    })?;
-            }
-        }
-
-        let glb = make_glb(&output, &temp, load_context.path().path(), &asset_root)?;
-        Ok(BlendSource { glb })
-    }
-
-    fn extensions(&self) -> &[&str] {
-        &["blend"]
-    }
-}
-
-fn validate_export(document: &serde_json::Value, output: &Path) -> io::Result<()> {
-    for key in ["scenes", "nodes", "meshes"] {
-        let count = document
-            .get(key)
-            .and_then(serde_json::Value::as_array)
-            .map_or(0, Vec::len);
-        if count == 0 {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidData,
-                format!("Blender export {} contains no {key}", output.display()),
-            ));
-        }
-    }
-    Ok(())
-}
-
-async fn referenced_actions(
-    load_context: &mut LoadContext<'_>,
-    root: &Path,
-) -> io::Result<Vec<String>> {
-    let model_path = load_context.path().path();
-    let Some(stem) = model_path.file_stem().and_then(|stem| stem.to_str()) else {
-        return Ok(Vec::new());
-    };
-    let manifest_path = model_path
-        .parent()
-        .unwrap_or_else(|| Path::new(""))
-        .join(format!("{stem}.fighter.ron"));
-    if !root.join(&manifest_path).is_file() {
-        return Ok(Vec::new());
-    }
-    let bytes = load_context
-        .read_asset_bytes(manifest_path)
-        .await
-        .map_err(|error| io::Error::other(error.to_string()))?;
-    let manifest: AnimationManifest = ron::de::from_bytes(&bytes)
-        .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
-    Ok(manifest.animations.into_values().collect())
-}
-
-#[derive(Asset, TypePath)]
-struct ProcessedBlend {
-    bytes: Vec<u8>,
-}
-
-#[derive(Default, TypePath)]
-struct BlendTransformer;
-
-impl AssetTransformer for BlendTransformer {
-    type AssetInput = BlendSource;
-    type AssetOutput = ProcessedBlend;
-    type Settings = ();
-    type Error = io::Error;
-
-    async fn transform<'a>(
-        &'a self,
-        source: TransformedAsset<Self::AssetInput>,
-        _: &'a Self::Settings,
-    ) -> Result<TransformedAsset<Self::AssetOutput>, Self::Error> {
-        let bytes = source.glb.clone();
-        Ok(source.replace_asset(ProcessedBlend { bytes }))
-    }
-}
-
-#[derive(Default, TypePath)]
-struct BlendSaver;
-
-impl AssetSaver for BlendSaver {
-    type Asset = ProcessedBlend;
-    type Settings = ();
-    type OutputLoader = GltfLoader;
-    type Error = io::Error;
-
-    async fn save(
-        &self,
-        writer: &mut Writer,
-        asset: SavedAsset<'_, '_, Self::Asset>,
-        _: &Self::Settings,
-        _: AssetPath<'_>,
-    ) -> Result<<Self::OutputLoader as AssetLoader>::Settings, Self::Error> {
-        writer.write_all(&asset.bytes).await?;
-        Ok(default())
-    }
-}
-
-type BlendProcessor = LoadTransformAndSave<BlendSourceLoader, BlendTransformer, BlendSaver>;
-
-pub struct BlendAssetProcessingPlugin;
-
-impl Plugin for BlendAssetProcessingPlugin {
-    fn build(&self, app: &mut App) {
-        app.init_asset::<BlendSource>()
-            .init_asset::<ProcessedBlend>()
-            .register_asset_loader(BlendSourceLoader)
-            .register_asset_processor(BlendProcessor::new(BlendTransformer, BlendSaver))
-            .set_default_asset_processor::<BlendProcessor>("blend");
-    }
-}
-
-struct TempDir(PathBuf);
-
-impl TempDir {
-    fn new() -> io::Result<Self> {
-        let stamp = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap_or_default()
-            .as_nanos();
-        let path =
-            std::env::temp_dir().join(format!("shinespark-blend-{}-{stamp}", std::process::id()));
-        fs::create_dir_all(&path)?;
-        Ok(Self(path))
-    }
-    fn path(&self) -> &Path {
-        &self.0
-    }
-}
-
-impl Drop for TempDir {
-    fn drop(&mut self) {
-        let _ = fs::remove_dir_all(&self.0);
-    }
-}
-
-fn asset_root() -> PathBuf {
-    std::env::var_os("BEVY_ASSET_ROOT")
-        .map(PathBuf::from)
-        .unwrap_or_else(|| std::env::current_dir().unwrap_or_default().join("assets"))
-}
-
-fn locate_source(path: &Path) -> Option<PathBuf> {
-    let root = asset_root();
-    [root.join(path), PathBuf::from(path)]
-        .into_iter()
-        .find(|candidate| candidate.is_file())
-}
-
-fn physical_to_asset_path(path: &Path, root: &Path) -> Option<String> {
-    let canonical = fs::canonicalize(path).ok()?;
-    let root = fs::canonicalize(root).ok()?;
-    let relative = canonical.strip_prefix(root).ok()?;
-    Some(relative.to_string_lossy().replace('\\', "/"))
-}
-
-fn make_glb(
-    gltf_path: &Path,
-    temp: &TempDir,
-    model_asset_path: &Path,
-    asset_root: &Path,
-) -> io::Result<Vec<u8>> {
-    let mut json: serde_json::Value = serde_json::from_slice(&fs::read(gltf_path)?)
-        .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
-    let bin_name = json["buffers"][0]["uri"].as_str().ok_or_else(|| {
-        io::Error::new(io::ErrorKind::InvalidData, "glTF has no binary buffer URI")
-    })?;
-    let mut bin = fs::read(temp.path().join(bin_name))?;
-    let model_parent = model_asset_path.parent().unwrap_or_else(|| Path::new(""));
-    let image_count = json["images"].as_array().map_or(0, Vec::len);
-    if image_count > 0 && !json["bufferViews"].is_array() {
-        return Err(io::Error::new(
-            io::ErrorKind::InvalidData,
-            "glTF bufferViews are not an array",
-        ));
-    }
-    for index in 0..image_count {
-        let uri = json["images"][index]
-            .get("uri")
-            .and_then(serde_json::Value::as_str)
-            .map(str::to_owned);
-        let Some(uri) = uri else { continue };
-        if uri.starts_with("data:") {
-            continue;
-        }
-        let uri_path = temp.path().join(uri);
-        if let Some(asset_path) = physical_to_asset_path(&uri_path, asset_root) {
-            json["images"][index]["uri"] =
-                serde_json::Value::String(relative_uri(model_parent, Path::new(&asset_path)));
-        } else {
-            let bytes = fs::read(&uri_path)?;
-            while bin.len() % 4 != 0 {
-                bin.push(0);
-            }
-            let offset = bin.len();
-            bin.extend_from_slice(&bytes);
-            let mime = mime_type(&uri_path);
-            let view = json["bufferViews"].as_array().unwrap().len();
-            json["bufferViews"]
-                .as_array_mut()
-                .unwrap()
-                .push(serde_json::json!({
-                    "buffer": 0,
-                    "byteOffset": offset,
-                    "byteLength": bytes.len(),
-                }));
-            json["images"][index].as_object_mut().unwrap().remove("uri");
-            json["images"][index]["bufferView"] = serde_json::Value::from(view);
-            json["images"][index]["mimeType"] = serde_json::Value::String(mime.to_owned());
-        }
-    }
-    json["buffers"][0]["byteLength"] = serde_json::Value::from(bin.len());
-    json["buffers"][0].as_object_mut().unwrap().remove("uri");
-    let mut json_bytes = serde_json::to_vec(&json).map_err(io::Error::other)?;
-    while json_bytes.len() % 4 != 0 {
-        json_bytes.push(b' ');
-    }
-    while bin.len() % 4 != 0 {
-        bin.push(0);
-    }
-    let length = 12 + 8 + json_bytes.len() + 8 + bin.len();
-    let mut glb = Vec::with_capacity(length);
-    glb.extend_from_slice(b"glTF");
-    glb.extend_from_slice(&2u32.to_le_bytes());
-    glb.extend_from_slice(&(length as u32).to_le_bytes());
-    glb.extend_from_slice(&(json_bytes.len() as u32).to_le_bytes());
-    glb.extend_from_slice(b"JSON");
-    glb.extend_from_slice(&json_bytes);
-    glb.extend_from_slice(&(bin.len() as u32).to_le_bytes());
-    glb.extend_from_slice(b"BIN\0");
-    glb.extend_from_slice(&bin);
-    Ok(glb)
-}
-
-fn relative_uri(from: &Path, to: &Path) -> String {
-    let from: Vec<_> = from.components().collect();
-    let to: Vec<_> = to.components().collect();
-    let common = from.iter().zip(&to).take_while(|(a, b)| a == b).count();
-    let mut result = PathBuf::new();
-    for _ in common..from.len() {
-        result.push("..");
-    }
-    for component in &to[common..] {
-        result.push(component.as_os_str());
-    }
-    result.to_string_lossy().replace('\\', "/")
-}
-
-fn mime_type(path: &Path) -> &'static str {
-    match path
-        .extension()
-        .and_then(|e| e.to_str())
-        .unwrap_or_default()
-        .to_ascii_lowercase()
-        .as_str()
-    {
-        "jpg" | "jpeg" => "image/jpeg",
-        "webp" => "image/webp",
-        _ => "image/png",
-    }
-}

src/blend_asset/export.py

@@ -1,80 +0,0 @@
-import bpy
-import json
-import os
-import sys
-
-
-def main():
-    output = sys.argv[sys.argv.index("--") + 1]
-    actions_path = sys.argv[sys.argv.index("--") + 2]
-    source_path = sys.argv[sys.argv.index("--") + 3]
-    loaded_path = os.path.realpath(bpy.data.filepath)
-    expected_path = os.path.realpath(source_path)
-    if loaded_path != expected_path:
-        raise RuntimeError(
-            f"Blender loaded {loaded_path!r} instead of {expected_path!r}"
-        )
-    if not bpy.data.objects or not bpy.data.meshes:
-        raise RuntimeError("Blender loaded an empty scene")
-    with open(actions_path) as file:
-        actions_to_keep = set(json.load(file))
-
-    for obj in bpy.data.objects:
-        if not obj.animation_data:
-            continue
-        for track in list(obj.animation_data.nla_tracks):
-            if track.name.startswith("[Action Stash]"):
-                obj.animation_data.nla_tracks.remove(track)
-
-    nla_tracks = [
-        track
-        for obj in bpy.data.objects
-        if obj.animation_data
-        for track in obj.animation_data.nla_tracks
-    ]
-    use_nla_tracks = bool(nla_tracks)
-
-    # For blends without NLA tracks, use the actions referenced by the fighter
-    # manifest instead of sampling every source action.
-    if not use_nla_tracks and actions_to_keep:
-        from io_scene_gltf2 import GLTF2_filter_action
-
-        if not hasattr(bpy.types.Scene, "gltf_action_filter"):
-            bpy.types.Scene.gltf_action_filter = bpy.props.CollectionProperty(
-                type=GLTF2_filter_action
-            )
-        scene = bpy.context.scene
-        scene.gltf_action_filter.clear()
-        for action in bpy.data.actions:
-            item = scene.gltf_action_filter.add()
-            item.action = action
-            item.keep = action.name in actions_to_keep
-
-    bpy.ops.export_scene.gltf(
-        filepath=output,
-        export_format="GLTF_SEPARATE",
-        export_keep_originals=True,
-        export_extras=True,
-        export_animations=True,
-        export_skins=True,
-        export_morph=True,
-        export_yup=True,
-        export_def_bones=True,
-        export_action_filter=False,
-        export_animation_mode="NLA_TRACKS" if use_nla_tracks else "ACTIONS",
-    )
-
-    dependencies = []
-    for image in bpy.data.images:
-        if image.source not in {"FILE", "TILED"}:
-            continue
-        path = image.filepath_raw or image.filepath
-        if path and not image.packed_file:
-            dependencies.append(bpy.path.abspath(path))
-
-    with open(os.path.join(os.path.dirname(output), "export-manifest.json"), "w") as file:
-        json.dump({"dependencies": sorted(set(dependencies))}, file)
-
-
-if __name__ == "__main__":
-    main()

src/debug_tools.rs

@@ -3,9 +3,11 @@
 use std::{collections::HashMap, time::Duration};
 
 use bevy::{
-    camera::{CameraOutputMode, visibility::RenderLayers}, input::InputSystems, prelude::*, render::render_resource::BlendState, settings::{ReflectSettingsGroup, SaveSettingsDeferred, SettingsGroup},
+    input::InputSystems,
+    prelude::*,
+    settings::{ReflectSettingsGroup, SaveSettingsDeferred, SettingsGroup},
 };
-use bevy_egui::{EguiContexts, EguiGlobalSettings, EguiPrimaryContextPass, PrimaryEguiContext, egui};
+use bevy_egui::{EguiContexts, EguiPrimaryContextPass, egui};
 use bevy_ggrs::{RollbackFrameRate, RunGgrsSystems};
 use enum_cycling::EnumCycle;
 use enum_cycling_derive::EnumCycle;
@@ -395,7 +397,6 @@ impl Plugin for DebugToolsPlugin {
                     .before(RunGgrsSystems)
                     .run_if(in_state(AppState::InMatch)),
             )
-            .add_systems(Startup, spawn_egui_camera)
             .add_systems(PreUpdate, restore_frame_step_time.after(RunGgrsSystems))
             .add_systems(
                 Update,
@@ -407,26 +408,6 @@ impl Plugin for DebugToolsPlugin {
     }
 }
 
-pub fn spawn_egui_camera(mut commands: Commands, mut egui_global_settings: ResMut<EguiGlobalSettings>,) {
-    egui_global_settings.auto_create_primary_context = false;
-    commands.spawn((
-        // The `PrimaryEguiContext` component requires everything needed to render a primary context.
-        PrimaryEguiContext,
-        Camera2d,
-        // Setting RenderLayers to none makes sure we won't render anything apart from the UI.
-        RenderLayers::none(),
-        Camera {
-            order: 2,
-            output_mode: CameraOutputMode::Write {
-                blend_state: Some(BlendState::ALPHA_BLENDING),
-                clear_color: ClearColorConfig::None,
-            },
-            clear_color: ClearColorConfig::Custom(Color::NONE),
-            ..default()
-        },
-    ));
-}
-
 fn player_handles(players: &Query<&Player>) -> Vec<usize> {
     let mut handles = players
         .iter()

src/debug_tools/save_state.rs

@@ -1,22 +1,12 @@
 use bevy::prelude::*;
 
 use crate::{
-    camera::MatchCamera,
+    camera::MatchCamera, fighter::{
-    fighter::{
+        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterPreviousFacingDirection, FighterPreviousTranslation, FighterTranslation, FighterVelocity, Grounded, animation::FighterAnimationFrame, attack::{
-        FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake,
-        FighterPreviousFacingDirection, FighterPreviousTranslation, FighterSurfaceState,
-        FighterTranslation, FighterVelocity,
-        animation::FighterAnimationFrame,
-        attack::{
             FighterDamage, FighterKnockbackVelocity, FighterPendingHitReaction, FighterPendingHits,
             FighterSolvedHurtboxes, FighterStaleMoveQueue,
-        },
+        }, baked_animation::FighterBoneMatrices, state::FighterState,
-        baked_animation::FighterBoneMatrices,
+    }, input::FighterInput, player::Player, stage::line::StageCollision,
-        state::FighterState,
-    },
-    input::FighterInput,
-    player::Player,
-    stage::line::StageCollision,
 };
 
 #[derive(Resource, Default)]
@@ -54,7 +44,7 @@ struct FighterCheckpoint {
     hitboxes: FighterHitboxes,
     solved_hurtboxes: FighterSolvedHurtboxes,
     bone_matrices: FighterBoneMatrices,
-    surface: FighterSurfaceState,
+    grounded: bool,
 }
 
 pub(super) fn save_or_restore(world: &mut World) {
@@ -153,7 +143,11 @@ pub(super) fn save_or_restore(world: &mut World) {
         entity.insert(saved.hitboxes.clone());
         entity.insert(saved.solved_hurtboxes.clone());
         entity.insert(saved.bone_matrices.clone());
-        entity.insert(saved.surface);
+        if saved.grounded {
+            entity.insert(Grounded);
+        } else {
+            entity.remove::<Grounded>();
+        }
     }
     world.insert_resource(checkpoint.pending_hits.clone());
     world.insert_resource(checkpoint.stage_collision);
@@ -187,7 +181,7 @@ fn capture_fighter(world: &World, entity: Entity) -> Option<FighterCheckpoint> {
         hitboxes: fighter.get::<FighterHitboxes>()?.clone(),
         solved_hurtboxes: fighter.get::<FighterSolvedHurtboxes>()?.clone(),
         bone_matrices: fighter.get::<FighterBoneMatrices>()?.clone(),
-        surface: *fighter.get::<FighterSurfaceState>()?,
+        grounded: fighter.contains::<Grounded>(),
     })
 }
 

src/fighter/baked_animation/asset_baking.rs

@@ -2,8 +2,8 @@ use super::{
     BAKED_ANIMATION_FPS,
     runtime::{BakedAnimationClip, BakedFighterAnimations},
 };
-use crate::fighter::{animation::AnimKind, manifest::FighterManifest};
 use crate::math::fixed_transform::FixedMat4;
+use crate::fighter::{animation::AnimKind, manifest::FighterManifest};
 use bevy::{
     asset::{
         AssetLoader, AssetPath, AsyncWriteExt, LoadContext,
@@ -51,9 +51,6 @@ impl AssetLoader for FighterBakeSourceLoader {
             .map_err(|error| io::Error::other(error.to_string()))?;
         let manifest: FighterManifest = ron::de::from_bytes(&manifest_bytes)
             .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
-        // `read_asset_bytes` uses the processor's processed asset source. This
-        // deliberately allows `model_path` to point at a `.blend`: the blend
-        // processor has already converted it to a hybrid GLB by this point.
         let model_bytes = load_context
             .read_asset_bytes(&manifest.model_path)
             .await

src/fighter/baked_animation/mod.rs

@@ -21,7 +21,6 @@ mod tests {
     use asset_baking::{
         Channel, ChannelValues, bake_gltf_document, baked_frame_count, sample_vec3,
     };
-    use serde_json::json;
     use std::collections::HashMap;
 
     #[test]
@@ -30,7 +29,11 @@ mod tests {
             "../../../assets/fighters/test/test.fighter.ron"
         ))
         .unwrap();
-        let (document, buffers) = test_gltf(&manifest.animations);
+        let (document, buffers, _) = gltf::import(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/assets/fighters/test/test_fighter.gltf"
+        ))
+        .unwrap();
         let baked = bake_gltf_document(document, buffers, &manifest.animations).unwrap();
 
         assert_eq!(baked.frame_rate, BAKED_ANIMATION_FPS);
@@ -48,104 +51,6 @@ mod tests {
         assert_eq!(baked.parents.len(), baked.bone_names.len());
     }
 
-    /// Builds the smallest glTF document that still exercises the complete
-    /// animation-baking path. Keeping this fixture in memory avoids making
-    /// unit tests depend on the production Blender asset or Blender itself.
-    fn test_gltf(
-        animations: &HashMap<AnimKind, String>,
-    ) -> (gltf::Document, Vec<gltf::buffer::Data>) {
-        let mut names: Vec<_> = animations.values().cloned().collect();
-        names.sort();
-        names.dedup();
-
-        let mut data = Vec::new();
-        let mut buffer_views = Vec::new();
-        let mut accessors = Vec::new();
-        let mut gltf_animations = Vec::new();
-
-        for name in names {
-            let duration: f32 = match name.as_str() {
-                "Idle_Loop_Game" => 2.0,
-                "Walk_Loop_IK_Game" | "Run_Game" => 0.533333361,
-                "Dash_Game" => 0.333333343,
-                "Jump_Land_Game" => 0.133333340,
-                "JumpB_Game" => 56.0 / 60.0,
-                _ => 0.0,
-            };
-            let input_offset = data.len();
-            data.extend_from_slice(&0.0_f32.to_le_bytes());
-            data.extend_from_slice(&duration.to_le_bytes());
-            let output_offset = data.len();
-            data.extend_from_slice(
-                &[0.0_f32, 0.0, 0.0]
-                    .into_iter()
-                    .flat_map(f32::to_le_bytes)
-                    .collect::<Vec<_>>(),
-            );
-            data.extend_from_slice(
-                &[1.0_f32, 0.0, 0.0]
-                    .into_iter()
-                    .flat_map(f32::to_le_bytes)
-                    .collect::<Vec<_>>(),
-            );
-
-            let input_view = buffer_views.len();
-            buffer_views.push(json!({
-                "buffer": 0,
-                "byteOffset": input_offset,
-                "byteLength": 8
-            }));
-            let output_view = buffer_views.len();
-            buffer_views.push(json!({
-                "buffer": 0,
-                "byteOffset": output_offset,
-                "byteLength": 24
-            }));
-            let input_accessor = accessors.len();
-            accessors.push(json!({
-                "bufferView": input_view,
-                "componentType": 5126,
-                "count": 2,
-                "type": "SCALAR",
-                "min": [0.0],
-                "max": [duration]
-            }));
-            let output_accessor = accessors.len();
-            accessors.push(json!({
-                "bufferView": output_view,
-                "componentType": 5126,
-                "count": 2,
-                "type": "VEC3"
-            }));
-            gltf_animations.push(json!({
-                "name": name,
-                "samplers": [{
-                    "input": input_accessor,
-                    "output": output_accessor,
-                    "interpolation": "LINEAR"
-                }],
-                "channels": [{
-                    "sampler": 0,
-                    "target": { "node": 0, "path": "translation" }
-                }]
-            }));
-        }
-
-        let document = json!({
-            "asset": { "version": "2.0" },
-            "scene": 0,
-            "scenes": [{ "nodes": [0] }],
-            "nodes": [{ "name": "root", "children": [1] }, { "name": "hand" }],
-            "buffers": [{ "byteLength": data.len() }],
-            "bufferViews": buffer_views,
-            "accessors": accessors,
-            "animations": gltf_animations
-        });
-        let bytes = serde_json::to_vec(&document).unwrap();
-        let gltf = gltf::Gltf::from_slice(&bytes).unwrap();
-        (gltf.document, vec![gltf::buffer::Data(data)])
-    }
-
     #[test]
     fn pose_sampling_wraps_repeating_frames_and_clamps_finished_frames() {
         let first = FixedMat4::IDENTITY;

src/fighter/mod.rs

@@ -18,7 +18,6 @@ pub mod hurtbox;
 pub mod manifest;
 pub mod motion;
 pub mod state;
-pub mod surface;
 pub mod visual;
 
 // The fighter components are re-exported so the rest of the crate can say
@@ -29,29 +28,18 @@ pub use attributes::FighterAttributes;
 pub use ecb::FighterECB;
 pub use manifest::FighterId;
 pub use motion::{
-    FighterPreviousFacingDirection, FighterPreviousTranslation, FighterTranslation, FighterVelocity,
+    FighterPreviousFacingDirection, FighterPreviousTranslation, FighterTranslation,
+    FighterVelocity, Grounded,
 };
-pub use surface::FighterSurfaceState;
 
 use crate::{
-    AppState,
+    AppState, fighter::{
-    fighter::{
         attack::{
             AttackKind, FighterAttackPlugin, FighterAttackScriptAssets, FighterDamage,
             FighterKnockbackVelocity, FighterPendingHitReaction, FighterSolvedHurtboxes,
             FighterStaleMoveQueue,
-        },
+        }, baked_animation::{FighterBoneIndexMap, FighterBoneMatrices}, manifest::FighterManifest, state::{FighterState, air::AirborneStateCommon, fall::FallState}, visual::FighterAnimations,
-        baked_animation::{FighterBoneIndexMap, FighterBoneMatrices},
+    }, input::FighterInput, math::{int::FGi32, vec::FGVec2}, player::Player, schedule::GameplaySet, scripting::FighterAttackScript, stage::line::StageCollision,
-        manifest::FighterManifest,
-        state::{FighterState, air::AirborneStateCommon, fall::FallState},
-        visual::FighterAnimations,
-    },
-    input::FighterInput,
-    math::{int::FGi32, vec::FGVec2},
-    player::Player,
-    schedule::GameplaySet,
-    scripting::FighterAttackScript,
-    stage::line::StageCollision,
 };
 use state::state_interrupt_system;
 
@@ -70,14 +58,14 @@ pub enum FighterFacingDirection {
 pub enum FighterHitstopShakeKind {
     #[default]
     Horizontal,
-    Vertical,
+    Vertical
 }
 
 #[derive(Component, Copy, Clone, Hash, Debug, PartialEq, Reflect, Default)]
 pub enum FighterHitstopShakeRole {
     #[default]
     Attacker,
-    Receiver,
+    Receiver
 }
 
 #[derive(Component, Default, Copy, Clone, Hash)]
@@ -85,7 +73,7 @@ pub struct FighterHitstopShake {
     pub remaining_frames: u32,
     pub total_frames: u32,
     pub kind: FighterHitstopShakeKind,
-    pub role: FighterHitstopShakeRole,
+    pub role: FighterHitstopShakeRole
 }
 
 #[derive(Component, Default, Copy, Clone, Hash)]
@@ -145,7 +133,7 @@ pub struct FighterVisual;
     FighterPendingHitReaction,
     FighterHitstop,
     FighterKnockbackVelocity,
-    FighterTranslation
+    FighterTranslation,
 )]
 pub struct Fighter {
     pub manifest: Handle<FighterManifest>,
@@ -212,8 +200,8 @@ impl Plugin for FighterPlugin {
             .checksum_component_with_hash::<FighterPreviousFacingDirection>()
             .rollback_component_with_copy::<animation::FighterAnimationFrame>()
             .checksum_component_with_hash::<animation::FighterAnimationFrame>()
-            .rollback_component_with_copy::<FighterSurfaceState>()
+            .rollback_component_with_copy::<Grounded>()
-            .checksum_component_with_hash::<FighterSurfaceState>()
+            .checksum_component_with_hash::<Grounded>()
             .rollback_component_with_copy::<FighterFacingDirection>()
             .rollback_component_with_copy::<FighterDamage>()
             .checksum_component_with_hash::<FighterDamage>()
@@ -271,7 +259,7 @@ pub struct FighterActiveAttack {
     pub active_hitboxes: Vec<usize>,
     pub solved_hitboxes: Vec<attack::FighterSolvedHitbox>,
     pub hit_fighters: Vec<Entity>,
-    pub stalled: bool,
+    pub stalled: bool
 }
 
 #[derive(Component, Clone, Debug, Default, Hash)]
@@ -296,7 +284,6 @@ pub fn spawn_fighter(
             Fighter { manifest: manifest },
             FighterFacingDirection::Right,
             FighterPreviousFacingDirection(FighterFacingDirection::Right),
-            FighterSurfaceState::Airborne,
             Transform::from_scale(Vec3::splat(model_scale.to_num())),
             (
                 FighterECB {

src/fighter/motion.rs

@@ -5,7 +5,7 @@ use bevy::prelude::*;
 use bevy_ggrs::GgrsFrameTiming;
 
 use crate::debug_tools::PresentationMotionMode;
-use crate::fighter::FighterHitstopShake;
+use crate::fighter::{FighterHitstopShake};
 use crate::game_settings::GameSettings;
 use crate::{
     fighter::{FighterECB, FighterFacingDirection, baked_animation::FixedMat4},
@@ -15,6 +15,9 @@ use crate::{
 #[derive(Component, Clone, Copy, Hash)]
 pub struct FighterPreviousFacingDirection(pub FighterFacingDirection);
 
+#[derive(Component, Clone, Copy, Hash)]
+pub struct Grounded;
+
 #[derive(Component, Deref, DerefMut, Default, Debug, Clone, Copy, Hash)]
 pub struct FighterVelocity(pub FGVec2);
 
@@ -79,29 +82,19 @@ pub fn apply_fighter_translation_to_visuals(
             0.0,
         );
 
-        if hitstop_shake.remaining_frames > 0
+        if hitstop_shake.remaining_frames > 0 && hitstop_shake.total_frames > 0 && !game_settings.fighter_common.visual_shake_table.is_empty() {
-            && hitstop_shake.total_frames > 0
-            && !game_settings.fighter_common.visual_shake_table.is_empty()
-        {
             let total = hitstop_shake.total_frames as f32;
             let curr = hitstop_shake.remaining_frames as f32;
             let elapsed = 1.0 - curr / total;
 
-            let access_index = (hitstop_shake.remaining_frames as usize)
+            
-                % game_settings.fighter_common.visual_shake_table.len();
+            let access_index = (hitstop_shake.remaining_frames as usize) % game_settings.fighter_common.visual_shake_table.len();
             let shake_multiplier = match hitstop_shake.role {
-                super::FighterHitstopShakeRole::Attacker => {
+                super::FighterHitstopShakeRole::Attacker => game_settings.fighter_common.attacker_visual_shake_multiplier,
-                    game_settings
-                        .fighter_common
-                        .attacker_visual_shake_multiplier
-                }
                 super::FighterHitstopShakeRole::Receiver => 1.0,
             };
-            let shake_amount: f32 =
+            let shake_amount: f32 = 1.0 - EaseFunction::QuinticIn.sample(elapsed).unwrap_or_default();
-                1.0 - EaseFunction::QuinticIn.sample(elapsed).unwrap_or_default();
+            let shake_amount = game_settings.fighter_common.visual_shake_table[access_index] * shake_amount * shake_multiplier;
-            let shake_amount = game_settings.fighter_common.visual_shake_table[access_index]
-                * shake_amount
-                * shake_multiplier;
 
             let shake_offset = match hitstop_shake.kind {
                 super::FighterHitstopShakeKind::Horizontal => Vec3::new(shake_amount, 0.0, 0.0),

src/fighter/state/air.rs

@@ -1,3 +1,4 @@
+use crate::fighter::state::ground::GroundedStateCommon;
 use crate::fighter::state::land::{LandingState, LandingType};
 use crate::fighter::state::{CollisionContext, FighterState};
 use crate::fighter::*;
@@ -29,7 +30,7 @@ pub fn process_fast_fall(
 pub fn integrate_gravity(
     velocity: &mut FighterVelocity,
     attributes: &FighterAttributes,
-    fast_fall: bool,
+    fast_fall: bool
 ) {
     velocity.y -= attributes.gravity;
 
@@ -83,9 +84,7 @@ pub fn apply_air_motion(
     velocity: &FighterVelocity,
     translation: &mut FighterTranslation,
     prev_translation: &mut FighterPreviousTranslation,
-    surface: &mut FighterSurfaceState,
 ) {
-    surface.leave_ground();
     // Vertical velocity should be 0 on the ground
     prev_translation.0 = translation.0;
     translation.0 += velocity.0;
@@ -95,24 +94,10 @@ pub fn update_standard_motion(
     ctx: &mut crate::fighter::state::UpdateContext,
     airborne_common: &mut AirborneStateCommon,
 ) {
-    process_fast_fall(
+    process_fast_fall(airborne_common, ctx.input, &mut ctx.velocity, ctx.fighter_attributes);
-        airborne_common,
+    integrate_gravity(ctx.velocity, ctx.fighter_attributes, airborne_common.is_fast_falling);
-        ctx.input,
-        &mut ctx.velocity,
-        ctx.fighter_attributes,
-    );
-    integrate_gravity(
-        ctx.velocity,
-        ctx.fighter_attributes,
-        airborne_common.is_fast_falling,
-    );
     apply_air_drift(ctx.velocity, ctx.fighter_attributes, ctx.input);
-    apply_air_motion(
+    apply_air_motion(ctx.velocity, ctx.translation, ctx.prev_translation);
-        ctx.velocity,
-        ctx.translation,
-        ctx.prev_translation,
-        ctx.surface,
-    );
 }
 
 pub fn collision_interrupt(
@@ -121,8 +106,13 @@ pub fn collision_interrupt(
 ) -> Option<FighterState> {
     let res = ctx.air_collide_with_stage()?;
     ctx.translation.0 = res.hit_position - ctx.ecb.get_bottom_point();
-    ctx.surface.land(res.line_id);
+    let grounded_common = GroundedStateCommon {
-    Some(FighterState::Land(LandingState::create(landing_type)))
+        current_line_id: res.line_id,
+    };
+    Some(FighterState::Land(LandingState::create(
+        grounded_common,
+        landing_type,
+    )))
 }
 
 #[cfg(test)]

src/fighter/state/air_dodge.rs

@@ -1,16 +1,9 @@
 use crate::{
     fighter::{
-        animation::AnimKind,
+        animation::AnimKind, state::{
-        state::{
+            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, fall::FallState, land::LandingType,
-            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext,
-            UpdateContext,
-            air::{self, AirborneStateCommon},
-            fall::FallState,
-            land::LandingType,
         },
-    },
+    }, input, math::vec::FGVec2,
-    input,
-    math::vec::FGVec2,
 };
 
 #[derive(Debug, Clone, Hash)]
@@ -23,9 +16,7 @@ impl FighterStateImpl for AirDodgeState {
 
     fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
         if state_context.is_current_animation_finished() {
-            Some(FighterState::Fall(FallState::new(
+            Some(FighterState::Fall(FallState::new(AirborneStateCommon::default())))
-                AirborneStateCommon::default(),
-            )))
         } else {
             None
         }
@@ -38,7 +29,6 @@ impl FighterStateImpl for AirDodgeState {
             state_context.velocity,
             state_context.translation,
             state_context.prev_translation,
-            state_context.surface,
         );
     }
 
@@ -55,8 +45,10 @@ impl FighterStateImpl for AirDodgeState {
         state_context.velocity.0 =
             self.direction * state_context.fighter_attributes.air_dodge_velocity;
     }
-
+    
-    fn is_visually_grounded<'a>(&'a self) -> bool {
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
         false
     }
 }

src/fighter/state/dash.rs

@@ -5,43 +5,52 @@ use super::{
 use crate::fighter::FighterFacingDirection;
 use crate::fighter::animation::AnimKind;
 use crate::fighter::state::FighterState;
+use crate::fighter::state::ground::GroundedStateCommon;
 use crate::input::FighterCommands::{SmashMoveLeft, SmashMoveRight};
 
 #[derive(Debug, Clone, Hash)]
 pub struct DashState {
     direction: FighterFacingDirection,
+    pub ground_common: GroundedStateCommon,
 }
 
 impl DashState {
-    pub fn new(direction: FighterFacingDirection) -> Self {
+    pub fn new(direction: FighterFacingDirection, ground_common: GroundedStateCommon) -> Self {
-        Self { direction }
+        Self {
+            direction,
+            ground_common,
+        }
     }
 }
 
 impl FighterStateImpl for DashState {
     const NAME: &'static str = "Dash";
     fn check_interrupt(&self, ctx: &mut InterruptContext) -> Option<FighterState> {
+        let ground = &self.ground_common;
         let attributes = ctx.fighter_attributes;
 
         // A reverse dash can interrupt before IASA
         if let Some(direction) =
             check_smash_input_with_dir(ctx).filter(|direction| *direction != self.direction)
         {
-            return Some(FighterState::Dash(DashState::new(direction)));
+            return Some(FighterState::Dash(DashState::new(
+                direction,
+                ground.clone(),
+            )));
         }
 
-        if let Some(state) = ground::grounded_movement_common_interrupts(ctx) {
+        if let Some(state) = ground::grounded_movement_common_interrupts(ctx, ground) {
             return Some(state);
         }
 
         if ctx.is_current_animation_finished() {
-            return run::check_input(ctx)
+            return run::check_input(ctx, ground)
-                .or_else(|| walk::check_input(ctx))
+                .or_else(|| walk::check_input(ctx, ground))
-                .or_else(|| wait::check_input(ctx));
+                .or_else(|| wait::check_input(ctx, ground));
         }
 
         if ctx.get_current_animation_frame() > attributes.dash_acceleration_duration {
-            return run::check_input(ctx);
+            return run::check_input(ctx, ground);
         }
 
         None
@@ -97,10 +106,12 @@ impl FighterStateImpl for DashState {
         &mut self,
         state_context: &mut CollisionContext,
     ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, true)
+        ground::collision_interrupt(state_context, &mut self.ground_common, true)
     }
-
+    
-    fn is_visually_grounded<'a>(&'a self) -> bool {
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
         true
     }
 }
@@ -115,6 +126,10 @@ fn check_smash_input_with_dir(state_context: &InterruptContext) -> Option<Fighte
     }
 }
 
-pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
+pub fn check_input(
-    check_smash_input_with_dir(state_context).map(|dir| FighterState::Dash(DashState::new(dir)))
+    state_context: &InterruptContext,
+    ground_common: &GroundedStateCommon,
+) -> Option<FighterState> {
+    check_smash_input_with_dir(state_context)
+        .map(|dir| FighterState::Dash(DashState::new(dir, ground_common.clone())))
 }

src/fighter/state/ground.rs

@@ -3,8 +3,7 @@
 //! bit-for-bit deterministic for rollback.
 
 use crate::fighter::state::{
-    CollisionContext, FighterState, InterruptContext, air, dash, fall, ground_attack, turn, wait,
+    CollisionContext, FighterState, InterruptContext, air, dash, fall, ground_attack, turn, wait, walk,
-    walk,
 };
 use crate::fighter::{
     FighterAttributes, FighterPreviousTranslation, FighterTranslation, FighterVelocity,
@@ -14,6 +13,13 @@ use crate::math::int::{FGWide, FGi32};
 use crate::math::vec::FGVec2;
 use crate::stage::line::{StageLineID, StagePoly, StagePolyLineSegment, StagePolyLineSegmentType};
 
+use bevy::prelude::*;
+
+#[derive(Reflect, Hash, Clone, Debug)]
+pub struct GroundedStateCommon {
+    pub current_line_id: StageLineID,
+}
+
 pub fn apply_grounded_friction(friction: FGi32, ground_vel: FGi32) -> FGi32 {
     if friction.abs() > ground_vel.abs() {
         -ground_vel
@@ -175,23 +181,22 @@ pub fn update_friction_motion(ctx: &mut crate::fighter::state::UpdateContext) {
 
 pub fn collide_with_stage_grounded(
     state_context: &mut CollisionContext,
+    ground_common: &mut GroundedStateCommon,
     can_walk_off: bool,
 ) -> GroundedMotionResult {
     let translation = &mut state_context.translation;
     let ecb = state_context.ecb;
     let stage_collision = state_context.stage_collision;
 
-    let Some(current_line_id) = state_context.surface.line_id() else {
+    let stage_poly = stage_collision
-        return GroundedMotionResult::InAir;
+        .stage_polys
-    };
+        .get(ground_common.current_line_id.polygon);
-
-    let stage_poly = stage_collision.stage_polys.get(current_line_id.polygon);
 
     if let Some(stage_poly) = stage_poly {
         let ecb_bottom_pos = translation.0 + ecb.get_bottom_point();
         match resolve_grounded_position(
             stage_poly,
-            current_line_id.segment,
+            ground_common.current_line_id.segment,
             ecb_bottom_pos,
             can_walk_off,
         ) {
@@ -211,37 +216,30 @@ pub fn collide_with_stage_grounded(
                             .0
                             .project_onto_normalized(current_segment.normal)
                 };
-                state_context.surface.land(StageLineID {
+                ground_common.current_line_id.segment = segment_idx;
-                    polygon: current_line_id.polygon,
-                    segment: segment_idx,
-                });
                 GroundedMotionResult::InGround
             }
-            GroundedPositionResult::InAir => {
+            GroundedPositionResult::InAir => GroundedMotionResult::InAir,
-                state_context.surface.leave_ground();
-                GroundedMotionResult::InAir
-            }
         }
     } else {
-        state_context.surface.leave_ground();
         GroundedMotionResult::InAir
     }
 }
 
-pub fn collision_interrupt(ctx: &mut CollisionContext, can_walk_off: bool) -> Option<FighterState> {
+pub fn collision_interrupt(
-    match collide_with_stage_grounded(ctx, can_walk_off) {
+    ctx: &mut CollisionContext,
+    common: &mut GroundedStateCommon,
+    can_walk_off: bool,
+) -> Option<FighterState> {
+    match collide_with_stage_grounded(ctx, common, can_walk_off) {
         GroundedMotionResult::InGround => None,
-        GroundedMotionResult::InAir => Some(FighterState::Fall(fall::FallState::new(
+        GroundedMotionResult::InAir => Some(FighterState::Fall(fall::FallState::new(air::AirborneStateCommon::default()))),
-            air::AirborneStateCommon::default(),
-        ))),
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::fighter::ecb::FighterPreviousECB;
-    use crate::fighter::{FighterECB, FighterSurfaceState};
     use crate::stage::line::StagePolyType;
 
     fn two_segment_floor() -> StagePoly {
@@ -348,110 +346,28 @@ mod tests {
             GroundedPositionResult::InAir
         ));
     }
-
-    #[test]
-    fn grounded_collision_updates_surface_segment() {
-        let stage_collision = crate::stage::line::StageCollision {
-            stage_polys: vec![two_segment_floor()],
-        };
-        let mut surface = FighterSurfaceState::Grounded {
-            line_id: StageLineID {
-                polygon: 0,
-                segment: 0,
-            },
-        };
-        let mut translation = FighterTranslation(FGVec2::lit("11", "0"));
-        let previous_translation = FighterPreviousTranslation(translation.0);
-        let mut velocity = FighterVelocity::default();
-        let ecb = FighterECB {
-            vertical_half: FGi32::ONE,
-            horizontal_half: FGi32::ONE,
-        };
-        let previous_ecb = FighterPreviousECB::from(ecb);
-        let mut context = CollisionContext {
-            translation: &mut translation,
-            prev_translation: &previous_translation,
-            velocity: &mut velocity,
-            surface: &mut surface,
-            ecb: &ecb,
-            prev_ecb: &previous_ecb,
-            stage_collision: &stage_collision,
-        };
-
-        assert!(matches!(
-            collide_with_stage_grounded(&mut context, true),
-            GroundedMotionResult::InGround
-        ));
-        assert_eq!(
-            surface.line_id(),
-            Some(StageLineID {
-                polygon: 0,
-                segment: 1,
-            })
-        );
-    }
-
-    #[test]
-    fn walking_off_edge_clears_surface_contact() {
-        let stage_collision = crate::stage::line::StageCollision {
-            stage_polys: vec![StagePoly::build(
-                StagePolyType::Platform,
-                &[
-                    (FGVec2::lit("0", "0"), StagePolyLineSegmentType::Floor),
-                    (FGVec2::lit("10", "0"), StagePolyLineSegmentType::Floor),
-                ],
-            )],
-        };
-        let mut surface = FighterSurfaceState::Grounded {
-            line_id: StageLineID {
-                polygon: 0,
-                segment: 0,
-            },
-        };
-        let mut translation = FighterTranslation(FGVec2::lit("11", "0"));
-        let previous_translation = FighterPreviousTranslation(translation.0);
-        let mut velocity = FighterVelocity::default();
-        let ecb = FighterECB {
-            vertical_half: FGi32::ONE,
-            horizontal_half: FGi32::ONE,
-        };
-        let previous_ecb = FighterPreviousECB::from(ecb);
-        let mut context = CollisionContext {
-            translation: &mut translation,
-            prev_translation: &previous_translation,
-            velocity: &mut velocity,
-            surface: &mut surface,
-            ecb: &ecb,
-            prev_ecb: &previous_ecb,
-            stage_collision: &stage_collision,
-        };
-
-        assert!(matches!(
-            collide_with_stage_grounded(&mut context, true),
-            GroundedMotionResult::InAir
-        ));
-        assert_eq!(surface, FighterSurfaceState::Airborne);
-    }
 }
 
 pub fn grounded_movement_common_interrupts(
     state_context: &InterruptContext,
+    ground_common: &GroundedStateCommon,
 ) -> Option<FighterState> {
-    super::jump::check_input(state_context)
+    super::jump::check_input(state_context, ground_common)
 }
 
 pub fn grounded_movement_standstill_common_interrupts(
     state_context: &InterruptContext,
+    ground_common: &GroundedStateCommon,
 ) -> Option<FighterState> {
-    if let Some(state) = ground_attack::check_interrupt(state_context) {
+    if let Some(state) = ground_attack::check_interrupt(state_context, &ground_common) {
         Some(state)
-    } else if let Some(state) = dash::check_input(state_context) {
+    } else if let Some(state) = dash::check_input(state_context, &ground_common) {
         Some(state)
-    } else if let Some(state) = turn::check_input(state_context) {
+    } else if let Some(state) = turn::check_input(state_context, &ground_common) {
         Some(state)
-    } else if let Some(state) = walk::check_input(state_context) {
+    } else if let Some(state) = walk::check_input(state_context, &ground_common) {
         Some(state)
-    } else if let Some(state) = wait::check_input(state_context) {
+    } else if let Some(state) = wait::check_input(state_context, &ground_common) {
         Some(state)
     } else {
         None

src/fighter/state/ground_attack.rs

@@ -2,13 +2,14 @@ use crate::fighter::{
     attack::{AttackKind, update_active_hitbox_list},
     state::{
         CollisionContext, EnterContext, ExitContext, FighterState, FighterStateImpl,
-        InterruptContext, UpdateContext, wait::WaitState,
+        InterruptContext, UpdateContext, ground::GroundedStateCommon, wait::WaitState,
     },
 };
 
 #[derive(Clone, Debug, Hash)]
 pub struct GroundAttackState {
     pub attack_kind: AttackKind,
+    pub grounded_common: GroundedStateCommon,
 }
 
 impl FighterStateImpl for GroundAttackState {
@@ -16,7 +17,9 @@ impl FighterStateImpl for GroundAttackState {
 
     fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
         if state_context.is_current_animation_finished() {
-            Some(FighterState::Wait(WaitState))
+            Some(FighterState::Wait(WaitState {
+                grounded_common: self.grounded_common.clone(),
+            }))
         } else {
             None
         }
@@ -50,7 +53,7 @@ impl FighterStateImpl for GroundAttackState {
             active_hitboxes: Vec::new(),
             solved_hitboxes: Vec::new(),
             hit_fighters: Vec::new(),
-            stalled: false,
+            stalled: false
         });
     }
 
@@ -64,13 +67,18 @@ impl FighterStateImpl for GroundAttackState {
     ) -> Option<FighterState> {
         None
     }
-
+    
-    fn is_visually_grounded<'a>(&'a self) -> bool {
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
         true
     }
 }
 
-pub fn check_interrupt(state_context: &InterruptContext) -> Option<FighterState> {
+pub fn check_interrupt(
+    state_context: &InterruptContext,
+    grounded_common: &GroundedStateCommon,
+) -> Option<FighterState> {
     if state_context
         .input
         .has_command(crate::input::FighterCommands::Attack)
@@ -81,6 +89,7 @@ pub fn check_interrupt(state_context: &InterruptContext) -> Option<FighterState>
             .to_attack_kind_grounded();
         Some(FighterState::GroundAttack(GroundAttackState {
             attack_kind,
+            grounded_common: grounded_common.clone(),
         }))
     } else {
         None

src/fighter/state/hitstun.rs

@@ -7,7 +7,7 @@ use crate::{
             InterruptContext, UpdateContext,
             air::{self, AirborneStateCommon},
             fall::FallState,
-            ground::collision_interrupt,
+            ground::{GroundedStateCommon, collision_interrupt},
             land::LandingType,
             wait::WaitState,
         },
@@ -17,7 +17,7 @@ use crate::{
 
 #[derive(Clone, Debug, Hash)]
 pub enum HitstopStateKind {
-    Grounded,
+    Grounded(GroundedStateCommon),
     Airborne,
 }
 
@@ -43,7 +43,7 @@ impl FighterStateImpl for HitstunState {
 
     fn name(&self) -> String {
         let hitstop_kind = match self.hitstop_kind {
-            HitstopStateKind::Grounded => "Grounded",
+            HitstopStateKind::Grounded(_) => "Grounded",
             HitstopStateKind::Airborne => "Airborne",
         };
 
@@ -58,10 +58,14 @@ impl FighterStateImpl for HitstunState {
     fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
         if state_context.get_current_animation_frame() > self.hit_reaction.hitstun_frames {
             match &self.hitstop_kind {
-                HitstopStateKind::Grounded => Some(FighterState::Wait(WaitState)),
+                HitstopStateKind::Grounded(grounded_state_common) => {
-                HitstopStateKind::Airborne => Some(FighterState::Fall(FallState::new(
+                    Some(FighterState::Wait(WaitState {
-                    AirborneStateCommon::default(),
+                        grounded_common: grounded_state_common.clone(),
-                ))),
+                    }))
+                }
+                HitstopStateKind::Airborne => {
+                    Some(FighterState::Fall(FallState::new(AirborneStateCommon::default())))
+                }
             }
         } else {
             None
@@ -81,9 +85,8 @@ impl FighterStateImpl for HitstunState {
         }
 
         match self.hitstop_kind {
-            HitstopStateKind::Grounded => {}
+            HitstopStateKind::Grounded(_) => {}
             HitstopStateKind::Airborne => {
-                ctx.surface.leave_ground();
                 air::integrate_gravity(ctx.velocity, ctx.fighter_attributes, false);
             }
         }
@@ -100,7 +103,7 @@ impl FighterStateImpl for HitstunState {
 
     fn on_enter(&mut self, state_context: &mut EnterContext) {
         let animation = match self.hitstop_kind {
-            HitstopStateKind::Grounded => AnimKind::FlinchGround,
+            HitstopStateKind::Grounded(_) => AnimKind::FlinchGround,
             HitstopStateKind::Airborne => AnimKind::FlinchAir,
         };
         state_context.play_animation(animation, false);
@@ -113,7 +116,9 @@ impl FighterStateImpl for HitstunState {
         state_context: &mut CollisionContext,
     ) -> Option<FighterState> {
         match &mut self.hitstop_kind {
-            HitstopStateKind::Grounded => collision_interrupt(state_context, true),
+            HitstopStateKind::Grounded(grounded_state_common) => {
+                collision_interrupt(state_context, grounded_state_common, true)
+            }
             HitstopStateKind::Airborne => {
                 air::collision_interrupt(state_context, LandingType::Normal)
             }
@@ -122,7 +127,7 @@ impl FighterStateImpl for HitstunState {
 
     fn is_visually_grounded<'a>(&'a self) -> bool {
         match self.hitstop_kind {
-            HitstopStateKind::Grounded => true,
+            HitstopStateKind::Grounded(_) => true,
             HitstopStateKind::Airborne => false,
         }
     }

src/fighter/state/jump.rs

@@ -2,17 +2,10 @@ use bevy::prelude::*;
 
 use crate::{
     fighter::{
-        animation::AnimKind,
+        animation::AnimKind, state::{
-        state::{
+            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, air_dodge::{self, AirDodgeState}, ground::{self, GroundedStateCommon},
-            CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext,
-            UpdateContext,
-            air::{self, AirborneStateCommon},
-            air_dodge::{self, AirDodgeState},
-            ground,
         },
-    },
+    }, input::FighterCommands, math::{int::FGi32, vec::FGVec2},
-    input::FighterCommands,
-    math::{int::FGi32, vec::FGVec2},
 };
 #[derive(Debug, Hash, Clone, Copy)]
 pub enum JumpType {
@@ -29,12 +22,14 @@ pub struct JumpState {
 
 #[derive(Debug, Clone, Hash)]
 pub struct JumpSquatState {
+    pub grounded_common: GroundedStateCommon,
     pub duration_counter: u32,
 }
 
 impl JumpSquatState {
-    pub fn create() -> Self {
+    pub fn create(grounded_common: GroundedStateCommon) -> Self {
         Self {
+            grounded_common,
             duration_counter: 0,
         }
     }
@@ -74,10 +69,7 @@ impl FighterStateImpl for JumpSquatState {
             } else {
                 JumpType::ShortHop
             };
-            Some(FighterState::Jump(JumpState {
+            Some(FighterState::Jump(JumpState { jump_type, airborne_state_common: AirborneStateCommon::default() }))
-                jump_type,
-                airborne_state_common: AirborneStateCommon::default(),
-            }))
         } else {
             None
         }
@@ -92,15 +84,17 @@ impl FighterStateImpl for JumpSquatState {
         &mut self,
         state_context: &mut CollisionContext,
     ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, false)
+        ground::collision_interrupt(state_context, &mut self.grounded_common, false)
     }
 
     fn on_enter(&mut self, state_context: &mut EnterContext) {
         state_context.play_animation(AnimKind::JumpSquat, false);
         state_context.input.clear_command(FighterCommands::Jump);
     }
-
+    
-    fn is_visually_grounded<'a>(&'a self) -> bool {
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
         true
     }
 }
@@ -111,7 +105,7 @@ impl FighterStateImpl for JumpState {
         if state_context.input.has_command(FighterCommands::Jump) {
             Some(FighterState::Jump(JumpState {
                 jump_type: JumpType::DoubleJump,
-                airborne_state_common: AirborneStateCommon::default(),
+                airborne_state_common: AirborneStateCommon::default()
             }))
         } else {
             air_dodge::check_input(state_context)
@@ -182,17 +176,22 @@ impl FighterStateImpl for JumpState {
             crate::fighter::state::land::LandingType::Normal,
         )
     }
-
+    
-    fn is_visually_grounded<'a>(&'a self) -> bool {
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
         false
     }
 }
 
-pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
+pub fn check_input(
+    state_context: &InterruptContext,
+    ground_common: &GroundedStateCommon,
+) -> Option<FighterState> {
     state_context
         .input
         .has_command(FighterCommands::Jump)
-        .then(|| FighterState::JumpSquat(JumpSquatState::create()))
+        .then(|| FighterState::JumpSquat(JumpSquatState::create(ground_common.clone())))
 }
 
 pub fn check_input_double_jump(state_context: &InterruptContext) -> Option<FighterState> {
@@ -202,7 +201,7 @@ pub fn check_input_double_jump(state_context: &InterruptContext) -> Option<Fight
         .then(|| {
             FighterState::Jump(JumpState {
                 jump_type: JumpType::DoubleJump,
-                airborne_state_common: AirborneStateCommon::default(),
+                airborne_state_common: AirborneStateCommon::default()
             })
         })
 }

src/fighter/state/land.rs

@@ -3,7 +3,7 @@ use crate::fighter::{
     state::{
         CollisionContext, EnterContext, FighterState, FighterStateImpl, InterruptContext,
         UpdateContext, dash,
-        ground::{self, grounded_movement_standstill_common_interrupts},
+        ground::{self, GroundedStateCommon, grounded_movement_standstill_common_interrupts},
         walk,
     },
 };
@@ -16,12 +16,16 @@ pub enum LandingType {
 
 #[derive(Debug, Clone, Hash)]
 pub struct LandingState {
+    pub grounded_common: GroundedStateCommon,
     pub landing_type: LandingType,
 }
 
 impl LandingState {
-    pub fn create(landing_type: LandingType) -> Self {
+    pub fn create(grounded_common: GroundedStateCommon, landing_type: LandingType) -> Self {
-        Self { landing_type }
+        Self {
+            grounded_common,
+            landing_type,
+        }
     }
 }
 
@@ -30,14 +34,14 @@ impl FighterStateImpl for LandingState {
 
     fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
         if state_context.is_current_animation_finished() {
-            grounded_movement_standstill_common_interrupts(state_context)
+            grounded_movement_standstill_common_interrupts(state_context, &self.grounded_common)
         } else if state_context.get_current_animation_frame()
             >= state_context.fighter_attributes.landing_iasa
             && let LandingType::Normal = self.landing_type
         {
-            dash::check_input(state_context).or_else(|| {
+            dash::check_input(state_context, &self.grounded_common).or_else(|| {
-                ground::grounded_movement_common_interrupts(state_context)
+                ground::grounded_movement_common_interrupts(state_context, &self.grounded_common)
-                    .or_else(|| walk::check_input(state_context))
+                    .or_else(|| walk::check_input(state_context, &self.grounded_common))
             })
         } else {
             None
@@ -52,7 +56,7 @@ impl FighterStateImpl for LandingState {
         &mut self,
         state_context: &mut CollisionContext,
     ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, true)
+        ground::collision_interrupt(state_context, &mut self.grounded_common, true)
     }
 
     fn on_enter(&mut self, state_context: &mut EnterContext) {
@@ -65,8 +69,10 @@ impl FighterStateImpl for LandingState {
             }
         };
     }
-
+    
-    fn is_visually_grounded<'a>(&'a self) -> bool {
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
         true
     }
 }

src/fighter/state/mod.rs

@@ -7,8 +7,7 @@ use bevy::prelude::*;
 
 use crate::fighter::animation::{AnimKind, FighterAnimationFrame};
 use crate::fighter::attack::{
-    FighterAttackScriptAssets, FighterKnockbackVelocity, FighterPendingHitReaction,
+    FighterAttackScriptAssets, FighterKnockbackVelocity, FighterPendingHitReaction, FighterStaleMoveQueue, HitStop,
-    FighterStaleMoveQueue, HitStop,
 };
 use crate::fighter::attributes::FighterAttributes;
 use crate::fighter::baked_animation::BakedFighterAnimations;
@@ -17,9 +16,7 @@ use crate::fighter::manifest::FighterManifest;
 use crate::fighter::state::hitstun::HitstunState;
 use crate::fighter::visual::FighterAnimations;
 use crate::fighter::{
-    Fighter, FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop,
+    Fighter, FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole, FighterPreviousTranslation, FighterTranslation, FighterVelocity,
-    FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole,
-    FighterPreviousTranslation, FighterSurfaceState, FighterTranslation, FighterVelocity,
 };
 use crate::game_settings::GameSettings;
 use crate::input::FighterInput;
@@ -98,7 +95,9 @@ pub trait FighterStateImpl: Sized {
         None
     }
 
-    fn is_visually_grounded<'a>(&'a self) -> bool;
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool;
 }
 
 pub struct AnimationStatus {
@@ -152,7 +151,6 @@ pub struct UpdateContext<'a> {
     pub input: &'a mut FighterInput,
     pub hitboxes: &'a mut FighterHitboxes,
     pub velocity: &'a mut FighterVelocity,
-    pub surface: &'a mut FighterSurfaceState,
     pub knockback_velocity: &'a mut FighterKnockbackVelocity,
     pub game_settings: &'a GameSettings,
     pub animation_frame: u32,
@@ -172,7 +170,6 @@ pub struct CollisionContext<'a> {
     pub translation: &'a mut FighterTranslation,
     pub prev_translation: &'a FighterPreviousTranslation,
     pub velocity: &'a mut FighterVelocity,
-    pub surface: &'a mut FighterSurfaceState,
     pub ecb: &'a FighterECB,
     pub prev_ecb: &'a FighterPreviousECB,
     pub stage_collision: &'a StageCollision,
@@ -215,7 +212,6 @@ pub struct FighterFrameQuery {
     pub input: &'static mut FighterInput,
     pub hitboxes: &'static mut FighterHitboxes,
     pub velocity: &'static mut FighterVelocity,
-    pub surface: &'static mut FighterSurfaceState,
     pub knockback_velocity: &'static mut FighterKnockbackVelocity,
     pub stale_move_queue: &'static mut FighterStaleMoveQueue,
     pub ecb: &'static FighterECB,
@@ -296,14 +292,13 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
             input: &mut self.input,
             hitboxes: &mut self.hitboxes,
             velocity: &mut self.velocity,
-            surface: &mut self.surface,
             knockback_velocity: &mut self.knockback_velocity,
             game_settings,
             animation_frame: self.animation_frame.frame,
             fighter_attributes: attributes,
             attack_scripts,
             attack_script_assets,
-            facing_direction: &self.facing_direction,
+            facing_direction: &self.facing_direction
         }
     }
 
@@ -315,7 +310,6 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> {
             translation: &mut self.translation,
             prev_translation: &self.prev_translation,
             velocity: &mut self.velocity,
-            surface: &mut self.surface,
             ecb: &self.ecb,
             prev_ecb: &self.prev_ecb,
             stage_collision,
@@ -406,9 +400,7 @@ pub fn state_interrupt_system(
 
         let new_state = if let Some(reaction) = pending_hit_reaction.take() {
             hitstop.remaining_frames = *reaction.hitstop_frames;
-            let shake_frames = reaction
+            let shake_frames = reaction.hitstop_frames.calculate_shake_frames(&game_settings);
-                .hitstop_frames
-                .calculate_shake_frames(&game_settings);
             hitstop_shake.role = FighterHitstopShakeRole::Receiver;
             hitstop_shake.total_frames = shake_frames;
             hitstop_shake.remaining_frames = shake_frames;
@@ -417,26 +409,36 @@ pub fn state_interrupt_system(
             } else {
                 FighterHitstopShakeKind::Vertical
             };
-
+            
-            let mut hitstop_kind = if frame.surface.is_grounded() {
+            let mut hitstop_kind = match &*state {
-                hitstun::HitstopStateKind::Grounded
+                FighterState::Wait(value) => {
-            } else {
+                    hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
-                hitstun::HitstopStateKind::Airborne
+                }
+                FighterState::Walk(value) => {
+                    hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
+                }
+                FighterState::Dash(value) => {
+                    hitstun::HitstopStateKind::Grounded(value.ground_common.clone())
+                }
+                FighterState::Run(value) => {
+                    hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
+                }
+                FighterState::Turn(value) => {
+                    hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
+                }
+                FighterState::GroundAttack(value) => {
+                    hitstun::HitstopStateKind::Grounded(value.grounded_common.clone())
+                }
+                _ => hitstun::HitstopStateKind::Airborne,
             };
 
-            if let hitstun::HitstopStateKind::Grounded = hitstop_kind {
+            if let hitstun::HitstopStateKind::Grounded(_) = hitstop_kind {
                 let straight_up_angle = FGi32::lit("90.0");
-                if reaction.hitstop_frames
+                if reaction.hitstop_frames >= HitStop::new(game_settings.fighter_common.tumble_bounce_hitstop_threshold) {
-                    >= HitStop::new(game_settings.fighter_common.tumble_bounce_hitstop_threshold)
-                {
                     hitstop_kind = hitstun::HitstopStateKind::Airborne;
                 // TODO: Use floor normal here
-                } else if reaction.launch_angle.abs_diff(straight_up_angle)
+                } else if reaction.launch_angle.abs_diff(straight_up_angle) < game_settings.fighter_common.attack_ground_to_airborne_transition_vertical_angle_threshold {
-                    < game_settings
+                        hitstop_kind = hitstun::HitstopStateKind::Airborne;
-                        .fighter_common
-                        .attack_ground_to_airborne_transition_vertical_angle_threshold
-                {
-                    hitstop_kind = hitstun::HitstopStateKind::Airborne;
                 } else {
                     // straight down is 270
                     let straight_down_angle = FGi32::lit("270.0");
@@ -448,10 +450,6 @@ pub fn state_interrupt_system(
                 }
             }
 
-            if matches!(hitstop_kind, hitstun::HitstopStateKind::Airborne) {
-                frame.surface.leave_ground();
-            }
-
             info!("Entering hitstop kind: {:?}", hitstop_kind);
             Some(FighterState::Hitstun(HitstunState::new(
                 reaction,

src/fighter/state/run.rs

@@ -6,14 +6,19 @@ use super::{
 };
 use crate::fighter::animation::AnimKind;
 use crate::fighter::state::FighterState;
+use crate::fighter::state::ground::GroundedStateCommon;
 
 #[derive(Component, Debug, Clone, Hash)]
-pub struct RunState;
+pub struct RunState {
+    pub grounded_common: GroundedStateCommon,
+}
 
 impl FighterStateImpl for RunState {
     const NAME: &'static str = "Run";
     fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
-        if let Some(state) = ground::grounded_movement_common_interrupts(state_context) {
+        if let Some(state) =
+            ground::grounded_movement_common_interrupts(state_context, &self.grounded_common)
+        {
             return Some(state);
         }
 
@@ -23,7 +28,8 @@ impl FighterStateImpl for RunState {
         {
             None
         } else {
-            walk::check_input(state_context).or_else(|| wait::check_input(state_context))
+            walk::check_input(state_context, &self.grounded_common)
+                .or_else(|| wait::check_input(state_context, &self.grounded_common))
         }
     }
 
@@ -56,19 +62,26 @@ impl FighterStateImpl for RunState {
         &mut self,
         state_context: &mut CollisionContext,
     ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, true)
+        ground::collision_interrupt(state_context, &mut self.grounded_common, true)
     }
-
+    
-    fn is_visually_grounded<'a>(&'a self) -> bool {
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
         true
     }
 }
 
-pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
+pub fn check_input(
+    state_context: &InterruptContext,
+    ground_state_common: &GroundedStateCommon,
+) -> Option<FighterState> {
     let input_frame = state_context.input.get_last_frame();
     if input_frame.movement.x.abs() >= state_context.game_settings.input_common.run_stick_threshold
     {
-        return Some(FighterState::Run(RunState));
+        return Some(FighterState::Run(RunState {
+            grounded_common: ground_state_common.clone(),
+        }));
     }
     None
 }

src/fighter/state/turn.rs

@@ -1,11 +1,13 @@
 use super::{CollisionContext, EnterContext, FighterStateImpl, InterruptContext, UpdateContext};
 use crate::fighter::animation::AnimKind;
-use crate::fighter::state::ground;
+use crate::fighter::state::ground::{self, GroundedStateCommon};
 use crate::fighter::state::{FighterState, dash, jump, wait, walk};
 use crate::input::FighterCommands;
 
 #[derive(Debug, Clone, Hash)]
-pub struct TurnState;
+pub struct TurnState {
+    pub grounded_common: GroundedStateCommon,
+}
 
 impl FighterStateImpl for TurnState {
     const NAME: &'static str = "Turn";
@@ -17,19 +19,19 @@ impl FighterStateImpl for TurnState {
                 .input_common
                 .turn_into_dashback_window as u32
         {
-            if let Some(state) = dash::check_input(state_context) {
+            if let Some(state) = dash::check_input(state_context, &self.grounded_common) {
                 return Some(state);
             }
         }
-        if let Some(state) = jump::check_input(state_context) {
+        if let Some(state) = jump::check_input(state_context, &self.grounded_common) {
             *state_context.facing_direction = state_context.facing_direction.reverse();
             Some(state)
         } else if state_context.is_current_animation_finished() {
-            if let Some(state) = dash::check_input(state_context) {
+            if let Some(state) = dash::check_input(state_context, &self.grounded_common) {
                 Some(state)
-            } else if let Some(state) = walk::check_input(state_context) {
+            } else if let Some(state) = walk::check_input(state_context, &self.grounded_common) {
                 Some(state)
-            } else if let Some(state) = wait::check_input(state_context) {
+            } else if let Some(state) = wait::check_input(state_context, &self.grounded_common) {
                 Some(state)
             } else {
                 None
@@ -52,15 +54,20 @@ impl FighterStateImpl for TurnState {
         &mut self,
         state_context: &mut CollisionContext,
     ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, false)
+        ground::collision_interrupt(state_context, &mut self.grounded_common, false)
     }
-
+    
-    fn is_visually_grounded<'a>(&'a self) -> bool {
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
         true
     }
 }
 
-pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
+pub fn check_input(
+    state_context: &InterruptContext,
+    grounded_common: &GroundedStateCommon,
+) -> Option<FighterState> {
     let input_frame = state_context.input.get_last_frame();
 
     let has_smash_input = state_context
@@ -74,7 +81,9 @@ pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
         && input_frame.movement.x.signum() != state_context.facing_direction.to_sign()
         && !has_smash_input
     {
-        return Some(FighterState::Turn(TurnState));
+        return Some(FighterState::Turn(TurnState {
+            grounded_common: grounded_common.clone(),
+        }));
     }
     None
 }

src/fighter/state/wait.rs

@@ -3,18 +3,24 @@ use super::{
 };
 use crate::fighter::animation::AnimKind;
 use crate::fighter::state::FighterState;
+use crate::fighter::state::ground::GroundedStateCommon;
 
 #[derive(Debug, Clone, Hash)]
-pub struct WaitState;
+pub struct WaitState {
+    pub grounded_common: GroundedStateCommon,
+}
 
 impl FighterStateImpl for WaitState {
     const NAME: &'static str = "Wait";
     fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
-        if let Some(state) = ground::grounded_movement_common_interrupts(state_context) {
+        if let Some(state) =
-            Some(state)
+            ground::grounded_movement_common_interrupts(state_context, &self.grounded_common)
-        } else if let Some(state) =
-            ground::grounded_movement_standstill_common_interrupts(state_context)
         {
+            Some(state)
+        } else if let Some(state) = ground::grounded_movement_standstill_common_interrupts(
+            state_context,
+            &self.grounded_common,
+        ) {
             // Don't transition into yourself
             if let FighterState::Wait(_) = state {
                 None
@@ -38,19 +44,26 @@ impl FighterStateImpl for WaitState {
         &mut self,
         state_context: &mut CollisionContext,
     ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, false)
+        ground::collision_interrupt(state_context, &mut self.grounded_common, false)
     }
-
+    
-    fn is_visually_grounded<'a>(&'a self) -> bool {
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
         true
     }
 }
 
-pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
+pub fn check_input(
+    state_context: &InterruptContext,
+    ground_state_common: &GroundedStateCommon,
+) -> Option<FighterState> {
     let input_frame = state_context.input.get_last_frame();
 
     if input_frame.movement.x.abs() < state_context.game_settings.input_common.stick_deadzone {
-        return Some(FighterState::Wait(WaitState));
+        return Some(FighterState::Wait(WaitState {
+            grounded_common: ground_state_common.clone(),
+        }));
     }
     None
 }

src/fighter/state/walk.rs

@@ -4,17 +4,23 @@ use super::{
 };
 use crate::fighter::animation::AnimKind;
 use crate::fighter::state::FighterState;
+use crate::fighter::state::ground::GroundedStateCommon;
 
 #[derive(Debug, Clone, Hash)]
-pub struct WalkState;
+pub struct WalkState {
+    pub grounded_common: GroundedStateCommon,
+}
 
 impl FighterStateImpl for WalkState {
     const NAME: &'static str = "Walk";
     fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
-        if let Some(state) = ground::grounded_movement_common_interrupts(state_context) {
+        if let Some(state) =
+            ground::grounded_movement_common_interrupts(state_context, &self.grounded_common)
+        {
             return Some(state);
         }
-        wait::check_input(state_context).or_else(|| dash::check_input(state_context))
+        wait::check_input(state_context, &self.grounded_common)
+            .or_else(|| dash::check_input(state_context, &self.grounded_common))
     }
 
     fn on_enter(&mut self, state_context: &mut EnterContext) {
@@ -48,19 +54,26 @@ impl FighterStateImpl for WalkState {
         &mut self,
         state_context: &mut CollisionContext,
     ) -> Option<FighterState> {
-        ground::collision_interrupt(state_context, false)
+        ground::collision_interrupt(state_context, &mut self.grounded_common, false)
     }
-
+    
-    fn is_visually_grounded<'a>(&'a self) -> bool {
+    fn is_visually_grounded<'a>(
+        &'a self,
+    ) -> bool {
         true
     }
 }
 
-pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
+pub fn check_input(
+    state_context: &InterruptContext,
+    ground_state_common: &GroundedStateCommon,
+) -> Option<FighterState> {
     let input_frame = state_context.input.get_last_frame();
 
     if !input_frame.movement.x.is_zero() {
-        return Some(FighterState::Walk(WalkState));
+        return Some(FighterState::Walk(WalkState {
+            grounded_common: ground_state_common.clone(),
+        }));
     }
 
     None

src/fighter/surface.rs

@@ -1,62 +0,0 @@
-use bevy::prelude::*;
-
-use crate::stage::line::StageLineID;
-
-/// The stage surface currently supporting a fighter.
-///
-/// This is physics state rather than fighter-state-machine state. Keeping it
-/// separate means grounded, landing, and hitstun states all share one source
-/// of truth for stage contact.
-#[derive(Component, Clone, Copy, Debug, Default, Hash, PartialEq, Eq)]
-pub enum FighterSurfaceState {
-    #[default]
-    Airborne,
-    Grounded {
-        line_id: StageLineID,
-    },
-}
-
-impl FighterSurfaceState {
-    pub fn is_grounded(self) -> bool {
-        matches!(self, Self::Grounded { .. })
-    }
-
-    pub fn line_id(self) -> Option<StageLineID> {
-        match self {
-            Self::Airborne => None,
-            Self::Grounded { line_id } => Some(line_id),
-        }
-    }
-
-    pub(crate) fn land(&mut self, line_id: StageLineID) {
-        *self = Self::Grounded { line_id };
-    }
-
-    pub(crate) fn leave_ground(&mut self) {
-        *self = Self::Airborne;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn contact_lifecycle_has_one_source_of_truth() {
-        let mut surface = FighterSurfaceState::default();
-        assert!(!surface.is_grounded());
-        assert_eq!(surface.line_id(), None);
-
-        let line_id = StageLineID {
-            polygon: 2,
-            segment: 3,
-        };
-        surface.land(line_id);
-        assert!(surface.is_grounded());
-        assert_eq!(surface.line_id(), Some(line_id));
-
-        surface.leave_ground();
-        assert!(!surface.is_grounded());
-        assert_eq!(surface.line_id(), None);
-    }
-}

src/input/gamecube/poll.rs

@@ -1,8 +1,6 @@
 use std::panic::{self, AssertUnwindSafe};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
-use std::thread::JoinHandle;
-use std::time::{Duration, Instant};
 
 use bevy::prelude::*;
 use gc_adapter_neo::{Controller, GcAdapter};
@@ -57,11 +55,10 @@ impl GcPortState {
 /// Shared, `Send + Sync` handle to the latest snapshot from the poll
 /// thread. Safe to store as an ordinary [`Resource`] (no `NonSend` needed)
 /// because the `GcAdapter` itself never leaves its thread.
-#[derive(Resource)]
+#[derive(Resource, Clone)]
 pub struct GcAdapterSnapshot {
     ports: Arc<Mutex<[GcPortState; 4]>>,
     shutdown: Arc<AtomicBool>,
-    poll_thread: Option<JoinHandle<()>>,
 }
 
 impl GcAdapterSnapshot {
@@ -72,38 +69,14 @@ impl GcAdapterSnapshot {
 
 impl Drop for GcAdapterSnapshot {
     fn drop(&mut self) {
-        self.shutdown.store(true, Ordering::Release);
+        // Only actually signals shutdown once the last clone (this resource
-
+        // is never cloned in practice, but be defensive) is dropped.
-        if let Some(poll_thread) = self.poll_thread.take() {
+        if Arc::strong_count(&self.shutdown) <= 1 {
-            if let Err(payload) = poll_thread.join() {
+            self.shutdown.store(true, Ordering::Relaxed);
-                error!(
-                    "GameCube Controller Adapter poll thread panicked during shutdown: {payload:?}"
-                );
-            }
         }
     }
 }
 
-const INITIAL_ERROR_BACKOFF: Duration = Duration::from_millis(1);
-const MAX_ERROR_BACKOFF: Duration = Duration::from_millis(100);
-
-fn next_error_backoff(backoff: Duration) -> Duration {
-    backoff.saturating_mul(2).min(MAX_ERROR_BACKOFF)
-}
-
-/// Wait for a retry while still allowing the owner to shut the poll thread down promptly.
-fn wait_for_retry(shutdown: &AtomicBool, delay: Duration) -> bool {
-    let deadline = Instant::now() + delay;
-    while !shutdown.load(Ordering::Acquire) {
-        let remaining = deadline.saturating_duration_since(Instant::now());
-        if remaining.is_zero() {
-            return true;
-        }
-        std::thread::sleep(remaining.min(Duration::from_millis(10)));
-    }
-    false
-}
-
 /// Connects to the first GameCube adapter found on the USB bus and starts
 /// polling it on a dedicated thread. Returns `None` (after logging a
 /// warning) if no adapter is plugged in
@@ -121,7 +94,7 @@ pub fn spawn_poll_thread() -> Result<GcAdapterSnapshot, gc_adapter_neo::UsbError
 
     let thread_ports = ports.clone();
     let thread_shutdown = shutdown.clone();
-    let poll_thread = std::thread::Builder::new()
+    std::thread::Builder::new()
         .name("gc-adapter-poll".into())
         .spawn(move || {
             // Flush whatever the adapter had buffered before we started
@@ -134,27 +107,17 @@ pub fn spawn_poll_thread() -> Result<GcAdapterSnapshot, gc_adapter_neo::UsbError
             let mut rate_window_start = std::time::Instant::now();
             #[cfg(debug_assertions)]
             let mut rate_window_count: u32 = 0;
-            let mut error_backoff = INITIAL_ERROR_BACKOFF;
 
-            while !thread_shutdown.load(Ordering::Acquire) {
+            while !thread_shutdown.load(Ordering::Relaxed) {
                 let result = panic::catch_unwind(AssertUnwindSafe(|| adapter.read_controllers()));
 
                 let controllers = match result {
-                    Ok(Ok(controllers)) => {
+                    Ok(Ok(controllers)) => controllers,
-                        error_backoff = INITIAL_ERROR_BACKOFF;
-                        controllers
-                    }
                     // Ignore this, for some reason we get a bunch of these when we start reading
                     Ok(Err(
                         gc_adapter_neo::AdapterError::Parse(_)
                         | gc_adapter_neo::AdapterError::ShortRead(_),
-                    )) => {
+                    )) => continue,
-                        if !wait_for_retry(&thread_shutdown, error_backoff) {
-                            break;
-                        }
-                        error_backoff = next_error_backoff(error_backoff);
-                        continue;
-                    }
                     Ok(Err(gc_adapter_neo::AdapterError::Usb(err))) => {
                         error!(
                             "GameCube Controller Adapter USB read failed ({err:?}); stopping \
@@ -197,32 +160,5 @@ pub fn spawn_poll_thread() -> Result<GcAdapterSnapshot, gc_adapter_neo::UsbError
         })
         .expect("failed to spawn gc-adapter poll thread");
 
-    Ok(GcAdapterSnapshot {
+    Ok(GcAdapterSnapshot { ports, shutdown })
-        ports,
-        shutdown,
-        poll_thread: Some(poll_thread),
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn error_backoff_is_capped() {
-        let mut backoff = INITIAL_ERROR_BACKOFF;
-        for _ in 0..16 {
-            backoff = next_error_backoff(backoff);
-        }
-
-        assert_eq!(backoff, MAX_ERROR_BACKOFF);
-        assert_eq!(next_error_backoff(MAX_ERROR_BACKOFF), MAX_ERROR_BACKOFF);
-    }
-
-    #[test]
-    fn retry_wait_stops_when_shutdown_is_requested() {
-        let shutdown = AtomicBool::new(true);
-
-        assert!(!wait_for_retry(&shutdown, Duration::from_secs(1)));
-    }
 }

src/lib.rs

@@ -38,7 +38,6 @@ use crate::{
 };
 
 mod args;
-pub mod blend_asset;
 pub mod camera;
 pub mod debug_tools;
 pub mod fighter;
@@ -90,7 +89,6 @@ pub struct GameAssetPlugin;
 impl Plugin for GameAssetPlugin {
     fn build(&self, app: &mut App) {
         app.add_plugins((
-            blend_asset::BlendAssetProcessingPlugin,
             RonAssetPlugin::<FighterManifest>::create("fighter.ron"),
             RonAssetPlugin::<StageManifest>::create("stage.ron"),
             RonAssetPlugin::<GameSettings>::create("ron"),

src/main.rs

@@ -1,7 +1,6 @@
 use bevy::asset::AssetMode::Processed;
 #[cfg(feature = "debug_features")]
 use bevy::camera_controller::free_camera::FreeCameraPlugin;
-use bevy::gltf::GltfPlugin;
 use bevy::image::{ImageAddressMode, ImagePlugin, ImageSamplerDescriptor};
 use bevy::prelude::*;
 #[cfg(feature = "debug_features")]
@@ -13,18 +12,14 @@ fn main() -> AppExit {
     // A `Repeat` sampler so the tileable materials authored in the
     // editor render the same way at runtime; Bevy's default
     // `ClampToEdge` smears texture edges on brush geometry.
-    let default_sampler = ImageSamplerDescriptor::linear()
-        .set_address_mode(ImageAddressMode::Repeat)
-        .set_anisotropic_filter(16)
-        .clone();
-
     let default_plugins = DefaultPlugins
         .set(ImagePlugin {
-            default_sampler: default_sampler.clone(),
+            default_sampler: ImageSamplerDescriptor {
-        })
+                address_mode_u: ImageAddressMode::Repeat,
-        .set(GltfPlugin {
+                address_mode_v: ImageAddressMode::Repeat,
-            default_sampler,
+                address_mode_w: ImageAddressMode::Repeat,
-            ..default()
+                ..ImageSamplerDescriptor::linear()
+            },
         })
         .set(AssetPlugin {
             mode: Processed,

src/menus/character_select/mod.rs

@@ -1,8 +1,19 @@
 use bevy::{picking::pointer::PointerId, prelude::*};
 
 use crate::{
-    AppState, fighter::manifest::{FighterManifest, FighterManifestRegistry}, game_settings::CommonAssets, input::{LocalInputAssignments, LocalInputSource}, menus::{
+    AppState,
-        MenuCameraMarker, MenuMarker, button::FGUiButton, character_select::{character_box::CharacterBox, token::CharacterSelectToken}, cursor::{FGMenuCursor, MenuCursorInputSource}, errors::MenuErrors::FighterManifestNotFound, match_config::{MenuMatchConfig, MenuMatchPlayerSlot}, scaling, spawn_menu, style::{FGUiButtonType, FGUiStyle},
+    fighter::manifest::{FighterManifest, FighterManifestRegistry},
+    game_settings::CommonAssets,
+    input::{LocalInputAssignments, LocalInputSource},
+    menus::{
+        MenuMarker,
+        button::FGUiButton,
+        character_select::{character_box::CharacterBox, token::CharacterSelectToken},
+        cursor::{FGMenuCursor, MenuCursorInputSource},
+        errors::MenuErrors::FighterManifestNotFound,
+        match_config::{MenuMatchConfig, MenuMatchPlayerSlot},
+        scaling, spawn_menu,
+        style::{FGUiButtonType, FGUiStyle},
     },
 };
 
@@ -230,7 +241,7 @@ pub fn copy_cursor_transform_to_token(
     character_boxes: Query<(&CharacterBox, &ComputedNode, &UiGlobalTransform)>,
     match_config: Res<MenuMatchConfig>,
     cursors: Query<&UiGlobalTransform, With<FGMenuCursor>>,
-    cam: Single<&Camera, With<MenuCameraMarker>>,
+    cam: Single<&Camera, With<IsDefaultUiCamera>>,
     ui_scale: Res<UiScale>,
 ) -> Result {
     let camera = cam.into_inner();

src/menus/cursor.rs

@@ -9,8 +9,11 @@ use bevy::{
 };
 
 use crate::{
-    input::{LocalInputAssignments, LocalInputSource}, menus::{
+    input::{LocalInputAssignments, LocalInputSource},
-        MenuCameraMarker, input::{MenuInput, MenuInputState}, scaling, style::FGUiStyle,
+    menus::{
+        input::{MenuInput, MenuInputState},
+        scaling,
+        style::FGUiStyle,
     },
 };
 
@@ -178,7 +181,7 @@ pub fn cursor_input(
 }
 
 pub fn update_cursor_transform(
-    camera: Single<&Camera, With<MenuCameraMarker>>,
+    camera: Single<&Camera, With<IsDefaultUiCamera>>,
     query: Query<(&mut Node, &PointerLocation), With<FGMenuCursor>>,
     ui_scale: Res<UiScale>,
 ) {

src/menus/mod.rs

@@ -25,8 +25,6 @@ pub mod style;
 
 #[derive(Component, Clone, Default)]
 pub struct MenuMarker {}
-#[derive(Component, Clone, Default)]
-pub struct MenuCameraMarker {}
 
 pub struct MenuPlugin;
 
@@ -40,7 +38,6 @@ pub fn wrap_menu(menu: impl Scene) -> impl Scene {
     bsn! {
         #MenuRoot
         MenuMarker
-        Transform
         Node {
             width: percent(100),
             height: percent(100),
@@ -49,12 +46,6 @@ pub fn wrap_menu(menu: impl Scene) -> impl Scene {
             flex_direction: FlexDirection::Column,
         }
         Children [
-            (
-                #MenuCamera
-                Camera
-                Camera2d
-                MenuCameraMarker
-            ),
             (
                 #MenuContainer
                 Node {
@@ -79,9 +70,10 @@ pub fn despawn_menu(
     if let Some(entity) = existing_menu {
         commands
             .entity(entity.into_inner())
+            .remove::<Camera2d>()
+            .remove::<Camera>()
             .despawn();
     }
-
 }
 
 pub fn spawn_menu(
@@ -92,6 +84,8 @@ pub fn spawn_menu(
     if let Some(entity) = existing_menu {
         commands
             .entity(entity.into_inner())
+            .remove::<Camera2d>()
+            .remove::<Camera>()
             .despawn();
     }
     commands.queue_spawn_scene(wrap_menu(menu));
@@ -119,7 +113,16 @@ impl Plugin for MenuPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(
             OnEnter(AppState::MainMenu),
-            build_menu::<MainMenu>,
+            (build_menu::<MainMenu>, |mut commands: Commands| {
+                commands.spawn((Camera2d, IsDefaultUiCamera));
+                commands.spawn((
+                    Camera2d,
+                    Camera {
+                        order: 1,
+                        ..default()
+                    },
+                ));
+            }),
         )
         .add_message::<character_select::PlayerSlotAssigned>()
         .init_resource::<navigation::UINavigationActionState>()

src/stage/line.rs

@@ -26,7 +26,7 @@ pub enum StagePolyType {
     Platform,
 }
 
-#[derive(Reflect, Hash, Debug, Clone, Copy, Default, PartialEq, Eq)]
+#[derive(Reflect, Hash, Debug, Clone, Copy, Default)]
 pub struct StageLineID {
     pub polygon: usize,
     pub segment: usize,