Add stocks UI

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

.gitea/workflows/ci.yml

@@ -65,6 +65,11 @@ jobs:
           echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
           "$HOME/.cargo/bin/rustup" toolchain install nightly-2026-09-14 --profile minimal
 
+      - name: Install Windows build tooling
+        run: |
+          "$HOME/.cargo/bin/rustup" target add x86_64-pc-windows-msvc --toolchain nightly-2026-09-14
+          "$HOME/.cargo/bin/cargo" install cargo-xwin --locked
+
       - name: Cache production Rust dependencies and build artifacts
         uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
         with:
@@ -76,7 +81,7 @@ jobs:
         run: |
           sudo apt-get update
           sudo apt-get install --no-install-recommends -y \
-            clang \
+            clang-19 \
             libasound2-dev \
             libudev-dev \
             libusb-1.0-0-dev \
@@ -84,9 +89,15 @@ jobs:
             libx11-dev \
             libxkbcommon-dev \
             libxkbcommon-x11-0 \
+            lld-19 \
+            llvm-19 \
             mesa-vulkan-drivers \
             mold \
             pkg-config
+          sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-19 100
+          sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-19 100
+          echo "/usr/lib/llvm-19/bin" >> "$GITHUB_PATH"
+          rm -f "$HOME/.cache/cargo-xwin/clang-cl"
 
       - name: Preprocess assets
         run: cargo run --locked --bin process-assets --no-default-features --features debug_features -j 4
@@ -94,6 +105,39 @@ jobs:
       - name: Build production binary
         run: cargo build --locked --profile production --no-default-features --features debug_features -j 4
 
+      - name: Build Windows production binary
+        run: |
+          clang --version
+          cargo xwin build --locked --target x86_64-pc-windows-msvc --profile production --no-default-features --features debug_features -j 4 --bin shinespark
+
       - name: Verify production binary is not Bevy/Rust dynamically linked
         run: |
           ! readelf -d target/production/shinespark | grep -E 'libbevy_dylib|libstd-.*\.so'
+
+      - name: Package Linux Steam depot
+        if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+        run: |
+          mkdir -p build/game
+          cp target/production/shinespark build/game/shinespark
+          cp target/x86_64-pc-windows-msvc/production/shinespark.exe build/game/shinespark.exe
+          cp -R imported_assets build/game/imported_assets
+
+      - if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+        uses: CyberAndrii/steam-totp@v1
+        name: Generate Steam TOTP
+        id: steam-totp
+        with:
+          shared_secret: ${{ secrets.STEAM_SHARED_SECRET }}
+
+      - name: Deploy Linux build to Steam
+        if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+        uses: game-ci/steam-deploy@v3
+        with:
+          username: ${{ secrets.STEAM_USERNAME }}
+          password: ${{ secrets.STEAM_PASSWORD }}
+          totp: ${{ steps.steam-totp.outputs.code }}
+          appId: 3409670
+          buildDescription: ${{ github.sha }}
+          rootPath: build
+          depot1Path: game
+          releaseBranch: master

Cargo.lock

@@ -94,12 +94,6 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
-[[package]]
-name = "adler32"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
-
 [[package]]
 name = "ahash"
 version = "0.8.12"
@@ -3208,16 +3202,6 @@ dependencies = [
  "windows-sys 0.60.2",
 ]
 
-[[package]]
-name = "filetime"
-version = "0.2.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"
-dependencies = [
- "cfg-if",
- "libc",
-]
-
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.9"
@@ -3434,9 +3418,9 @@ dependencies = [
 
 [[package]]
 name = "gc-adapter-neo"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "120a5b3858ae854c4674ae41a38173e8ea04b814fb3212fd3bdd1b04d414a9d7"
+checksum = "a8d3e10c6c4b928cb559f641765ebaa40f5f099bf51bc0227af7431859f8bd84"
 dependencies = [
  "binread",
  "modular-bitfield",
@@ -4266,26 +4250,6 @@ version = "0.2.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
-[[package]]
-name = "libflate"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ff4ae71b685bbad2f2f391fe74f6b7659a34871c08b210fdc039e43bee07d18"
-dependencies = [
- "adler32",
- "crc32fast",
- "libflate_lz77",
-]
-
-[[package]]
-name = "libflate_lz77"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a52d3a8bfc85f250440e4424db7d857e241a3aebbbe301f3eb606ab15c39acbf"
-dependencies = [
- "rle-decode-fast",
-]
-
 [[package]]
 name = "libloading"
 version = "0.8.9"
@@ -4326,15 +4290,13 @@ dependencies = [
 
 [[package]]
 name = "libusb1-sys"
-version = "0.4.4"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be241693102a24766d0b8526c8988771edac2842630d7e730f8e9fbc014f3703"
+checksum = "da050ade7ac4ff1ba5379af847a10a10a8e284181e060105bf8d86960ce9ce0f"
 dependencies = [
  "cc",
  "libc",
- "libflate",
  "pkg-config",
- "tar",
  "vcpkg",
 ]
 
@@ -5840,12 +5802,6 @@ dependencies = [
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "rle-decode-fast"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3582f63211428f83597b51b2ddb88e2a91a9d52d12831f9d08f5e624e8977422"
-
 [[package]]
 name = "robust"
 version = "1.2.0"
@@ -5916,9 +5872,9 @@ dependencies = [
 
 [[package]]
 name = "rusb"
-version = "0.6.5"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f32cd45962594f9f8cd4547b5757132715600e2c8840aa9ccd3d1a9ed6fdc6"
+checksum = "ab9f9ff05b63a786553a4c02943b74b34a988448671001e9a27e2f0565cc05a4"
 dependencies = [
  "libc",
  "libusb1-sys",
@@ -6126,6 +6082,7 @@ dependencies = [
  "bevy_egui",
  "bevy_ggrs",
  "bincode",
+ "blake3",
  "clap",
  "enum_cycling",
  "enum_cycling_derive",
@@ -6495,17 +6452,6 @@ dependencies = [
  "slotmap",
 ]
 
-[[package]]
-name = "tar"
-version = "0.4.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840"
-dependencies = [
- "filetime",
- "libc",
- "xattr",
-]
-
 [[package]]
 name = "termcolor"
 version = "1.4.1"
@@ -7911,16 +7857,6 @@ version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"
 
-[[package]]
-name = "xattr"
-version = "1.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
-dependencies = [
- "libc",
- "rustix 1.1.4",
-]
-
 [[package]]
 name = "xcursor"
 version = "0.3.11"

Cargo.toml

@@ -16,6 +16,7 @@ bevy = { version = "0.19", features = ["asset_processor", "basis-universal", "be
 # Loads the scenes you author in the editor (assets/*.bsn) and builds
 # physics colliders from them. An ordinary dependency; remove it if you
 # stop using authored scenes.
+blake3 = { version = "1.8.5", features = [ "pure" ] }
 thiserror = "2"
 avian3d = "0.7"
 arrayvec = "0.7.8"
@@ -33,7 +34,7 @@ strum = "0.28.0"
 strum_macros = "0.28.0"
 bevy_asset_loader = "0.27.0"
 ron_asset_manager = "0.9.0"
-gc-adapter-neo = { version = "1.1.0", features = ["libusb"] }
+gc-adapter-neo = { version = "1.1.1", features = ["libusb"] }
 rhai = "1.26.0"
 enum_cycling = "0.2.1"
 enum_cycling_derive = "0.2.1"

src/bin/process-assets.rs

@@ -1,8 +1,11 @@
 use bevy::{
     app::ScheduleRunnerPlugin,
     asset::{AssetMode, AssetPlugin, processor::AssetProcessor, processor::ProcessorState},
+    gltf::GltfPlugin,
+    image::{CompressedImageFormats, ImageLoader, ImagePlugin},
     prelude::*,
     tasks::block_on,
+    text::TextPlugin,
 };
 use shinespark::AssetProcessingPlugin;
 use std::{process::ExitCode, time::Duration};
@@ -15,6 +18,8 @@ fn main() -> ExitCode {
             use_asset_processor_override: Some(true),
             ..default()
         })
+        .add_plugins((ImagePlugin::default(), TextPlugin, GltfPlugin::default()))
+        .register_asset_loader(ImageLoader::new(CompressedImageFormats::NONE))
         .add_plugins(AssetProcessingPlugin)
         .add_systems(Update, finish_when_processed);
 

src/lib.rs

@@ -32,7 +32,9 @@ use clap::Parser;
 use ron_asset_manager::RonAssetPlugin;
 
 use crate::{
-    camera::MatchCameraPlugin, fighter::manifest::FighterManifest, game_settings::GameSettings, schedule::GameplaySchedulePlugin, stage::manifest::StageManifest, ui::InGameUIPlugin,
+    camera::MatchCameraPlugin, fighter::manifest::FighterManifest, game_settings::GameSettings,
+    match_runtime::MatchRuntimePlugin, menus::style::FGUiStyle, schedule::GameplaySchedulePlugin,
+    stage::manifest::StageManifest, ui::InGameUIPlugin,
 };
 
 mod args;
@@ -42,6 +44,7 @@ pub mod fighter;
 pub mod game_settings;
 pub mod input;
 pub mod match_loading;
+pub mod match_runtime;
 mod math;
 pub mod menus;
 pub mod netcode;
@@ -80,6 +83,20 @@ pub enum AppState {
 #[derive(Default)]
 pub struct GamePlugin;
 
+/// Registers every custom asset loader used by the game and asset processor.
+pub struct GameAssetPlugin;
+
+impl Plugin for GameAssetPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins((
+            RonAssetPlugin::<FighterManifest>::create("fighter.ron"),
+            RonAssetPlugin::<StageManifest>::create("stage.ron"),
+            RonAssetPlugin::<GameSettings>::create("ron"),
+            RonAssetPlugin::<FGUiStyle>::create("stylesheet.ron"),
+        ));
+    }
+}
+
 impl Plugin for GamePlugin {
     fn build(&self, app: &mut App) {
         // Each module owns its own systems, rollback registrations and
@@ -91,6 +108,7 @@ impl Plugin for GamePlugin {
                 // Brings up GGRS (and with it `GgrsSchedule`), so it goes first.
                 netcode::FighterNetcodePlugin::default(),
                 GameplaySchedulePlugin,
+                MatchRuntimePlugin,
                 input::FighterInputPlugin,
                 replay::ReplayPlugin,
                 debug_tools::DebugToolsPlugin,
@@ -99,9 +117,7 @@ impl Plugin for GamePlugin {
                 scripting::importer::FighterScriptImportPlugin,
                 stage::StagePlugin,
                 MatchCameraPlugin,
-                RonAssetPlugin::<FighterManifest>::create("fighter.ron"),
-                RonAssetPlugin::<StageManifest>::create("stage.ron"),
-                RonAssetPlugin::<GameSettings>::create("ron"),
+                GameAssetPlugin,
                 InGameUIPlugin,
             ))
             .add_plugins(menus::MenuPlugin)
@@ -155,13 +171,14 @@ impl Plugin for GamePlugin {
     }
 }
 
-/// Registers only the custom asset processors used by CI and release builds.
-/// The processing binary adds this plugin without starting the game.
+/// Registers the custom asset loaders and processors used by CI and release
+/// builds. The processing binary adds this plugin without starting the game.
 pub struct AssetProcessingPlugin;
 
 impl Plugin for AssetProcessingPlugin {
     fn build(&self, app: &mut App) {
         app.add_plugins((
+            GameAssetPlugin,
             scripting::importer::FighterScriptImportPlugin,
             fighter::baked_animation::BakedAnimationAssetProcessingPlugin,
         ));

src/match_loading.rs

@@ -8,28 +8,29 @@ use bevy_ggrs::prelude::Session;
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    AppState,
     args::Args,
     fighter::{
+        FighterId, FighterRoster,
         animation::AnimKind,
         attack::{AttackKind, FighterAttackScriptAssets},
-        baked_animation::{BakedFighterAnimations, BAKED_ANIMATION_FPS},
+        baked_animation::{BAKED_ANIMATION_FPS, BakedFighterAnimations},
         manifest::{FighterManifest, FighterManifestRegistry},
         spawn_fighter,
         visual::FighterAnimations,
-        FighterId, FighterRoster,
     },
     input::{LocalInputAssignments, LocalInputSource},
+    match_runtime::MatchState,
     math::{int::FGi32, vec::FGVec2},
     netcode::{
-        session::{create_session, ConnectionStatus, SessionConfig},
         GGRSCfg,
+        session::{ConnectionStatus, SessionConfig, create_session},
     },
     scripting::FighterAttackScript,
     stage::{
         self,
         manifest::{StageId, StageManifest, StageManifestRegistry},
     },
-    AppState,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@@ -38,10 +39,49 @@ pub struct MatchPlayer {
     pub fighter: FighterId,
 }
 
-#[derive(Resource, Debug, Clone, PartialEq, Eq)]
-pub struct PendingMatch {
+#[derive(Resource, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct MatchConfig {
     pub stage: StageId,
     pub players: Vec<MatchPlayer>,
+    pub rules: MatchRules,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum MatchRules {
+    Stock {
+        starting_stocks: u8,
+        time_limit_frames: Option<u32>,
+    },
+    Timed {
+        time_limit_frames: u32,
+    },
+}
+
+impl Default for MatchRules {
+    fn default() -> Self {
+        Self::Stock {
+            starting_stocks: 3,
+            time_limit_frames: None,
+        }
+    }
+}
+
+impl MatchRules {
+    fn validate(&self) -> Result<(), &'static str> {
+        match self {
+            Self::Stock {
+                starting_stocks: 0, ..
+            } => Err("stock matches must start with at least one stock"),
+            Self::Stock {
+                time_limit_frames: Some(0),
+                ..
+            } => Err("stock match time limits must be greater than zero frames"),
+            Self::Timed {
+                time_limit_frames: 0,
+            } => Err("timed match limits must be greater than zero frames"),
+            _ => Ok(()),
+        }
+    }
 }
 
 pub struct SelectedFighterAssets {
@@ -59,7 +99,7 @@ pub struct MatchAssets {
 
 impl MatchAssets {
     fn requested(world: &World) -> Self {
-        let request = world.resource::<PendingMatch>();
+        let config = world.resource::<MatchConfig>();
         let asset_server = world.resource::<AssetServer>();
         let registry = world.resource::<FighterManifestRegistry>();
         let stage_registry = world.resource::<StageManifestRegistry>();
@@ -67,7 +107,7 @@ impl MatchAssets {
         let stage_manifests = world.resource::<Assets<StageManifest>>();
 
         let stage_handle = stage_registry
-            .get(request.stage)
+            .get(config.stage)
             .expect("Startup validation guarantees every stage has a manifest");
         let stage_manifest = stage_manifests
             .get(&stage_handle)
@@ -75,7 +115,7 @@ impl MatchAssets {
 
         Self {
             stage: asset_server.load(stage_manifest.model_path.clone()),
-            fighters: request
+            fighters: config
                 .players
                 .iter()
                 .map(|player| {
@@ -141,10 +181,10 @@ pub struct MatchRoot;
 pub fn initiate_match(
     commands: &mut Commands,
     next_state: &mut NextState<AppState>,
-    request: PendingMatch,
+    config: MatchConfig,
 ) {
     commands.remove_resource::<crate::netcode::session::MatchDisconnected>();
-    commands.insert_resource(request);
+    commands.insert_resource(config);
     next_state.set(AppState::LoadingMatch);
 }
 
@@ -166,12 +206,9 @@ pub fn initiate_default_match(
     if let Some(path) = &args.play_replay {
         match crate::replay::load(path) {
             Ok(replay) => {
-                let request = PendingMatch {
-                    stage: replay.match_config.stage,
-                    players: replay.match_config.players.clone(),
-                };
+                let config = replay.match_config.clone();
                 commands.insert_resource(crate::replay::LoadedReplay(replay));
-                initiate_match(&mut commands, &mut next_state, request);
+                initiate_match(&mut commands, &mut next_state, config);
             }
             Err(error) => {
                 error!("Replay load failed: {error}");
@@ -215,16 +252,17 @@ pub fn initiate_default_match(
     initiate_match(
         &mut commands,
         &mut next_state,
-        PendingMatch {
+        MatchConfig {
             stage: StageId::TestStage,
             players,
+            rules: MatchRules::default(),
         },
     );
 }
 
 pub fn prepare_match(
     mut commands: Commands,
-    request: Res<PendingMatch>,
+    config: Res<MatchConfig>,
     assets: Res<MatchAssets>,
     gltfs: Res<Assets<Gltf>>,
     baked_animations: Res<Assets<BakedFighterAnimations>>,
@@ -236,7 +274,7 @@ pub fn prepare_match(
     args: Res<Args>,
     mut next_state: ResMut<NextState<AppState>>,
 ) {
-    if !valid_player_handles(&request.players) {
+    if !valid_player_handles(&config.players) {
         fail_match(
             &mut next_state,
             "player handles must be unique and cover 0..player_count",
@@ -244,7 +282,12 @@ pub fn prepare_match(
         return;
     }
 
-    if assets.fighters.len() != request.players.len() {
+    if let Err(error) = config.rules.validate() {
+        fail_match(&mut next_state, error);
+        return;
+    }
+
+    if assets.fighters.len() != config.players.len() {
         fail_match(
             &mut next_state,
             "loaded character assets do not match the requested player slots",
@@ -396,7 +439,7 @@ pub fn prepare_match(
         ));
     }
 
-    let session_config = match SessionConfig::from_args(&args, request.players.len()) {
+    let session_config = match SessionConfig::from_args(&args, config.players.len()) {
         Ok(config) => config,
         Err(error) => {
             fail_match(
@@ -406,7 +449,7 @@ pub fn prepare_match(
             return;
         }
     };
-    let session = match create_session(&args, request.players.len()) {
+    let session = match create_session(&args, config.players.len()) {
         Ok(session) => session,
         Err(error) => {
             fail_match(
@@ -420,7 +463,7 @@ pub fn prepare_match(
     let root = commands.spawn((Name::new("Match"), MatchRoot)).id();
 
     let stage_handle = stage_registry
-        .get(request.stage)
+        .get(config.stage)
         .expect("Initialization check should ensure all stages exist");
     let stage_manifest = stage_manifests
         .get(&stage_handle)
@@ -433,11 +476,11 @@ pub fn prepare_match(
         stage_manifest.camera.clone(),
     );
 
-    let mut fighter_roster = Vec::with_capacity(request.players.len());
+    let mut fighter_roster = Vec::with_capacity(config.players.len());
     for (index, (player, (scene, animations, attack_scripts, manifest_handle, model_scale))) in
-        request.players.iter().zip(prepared).enumerate()
+        config.players.iter().zip(prepared).enumerate()
     {
-        let spawn_x = (index as i32 * 2 + 1 - request.players.len() as i32) * 5;
+        let spawn_x = (index as i32 * 2 + 1 - config.players.len() as i32) * 5;
         fighter_roster.push(spawn_fighter(
             &mut commands,
             player.handle,
@@ -451,6 +494,7 @@ pub fn prepare_match(
     }
 
     commands.insert_resource(FighterRoster(fighter_roster));
+    commands.insert_resource(MatchState::from_config(&config));
     commands.insert_resource(session_config);
     commands.insert_resource(ConnectionStatus::default());
     commands.insert_resource::<Session<GGRSCfg>>(session);
@@ -487,7 +531,8 @@ pub fn cleanup_match(
     commands.remove_resource::<ConnectionStatus>();
     commands.remove_resource::<stage::line::StageCollision>();
     commands.remove_resource::<MatchAssets>();
-    commands.remove_resource::<PendingMatch>();
+    commands.remove_resource::<MatchConfig>();
+    commands.remove_resource::<MatchState>();
     commands.remove_resource::<FighterRoster>();
 }
 
@@ -496,8 +541,8 @@ mod tests {
     use super::*;
 
     #[test]
-    fn match_request_keeps_duplicate_fighter_slots() {
-        let request = PendingMatch {
+    fn match_config_keeps_duplicate_fighter_slots() {
+        let config = MatchConfig {
             stage: StageId::TestStage,
             players: vec![
                 MatchPlayer {
@@ -509,12 +554,13 @@ mod tests {
                     fighter: FighterId::TestFighter,
                 },
             ],
+            rules: MatchRules::default(),
         };
 
-        assert_eq!(request.players.len(), 2);
-        assert_eq!(request.players[0].handle, 0);
-        assert_eq!(request.players[1].handle, 1);
-        assert!(valid_player_handles(&request.players));
+        assert_eq!(config.players.len(), 2);
+        assert_eq!(config.players[0].handle, 0);
+        assert_eq!(config.players[1].handle, 1);
+        assert!(valid_player_handles(&config.players));
     }
 
     #[test]
@@ -533,6 +579,53 @@ mod tests {
         assert!(!valid_player_handles(&players));
     }
 
+    #[test]
+    fn match_rules_reject_zero_limits() {
+        assert!(
+            MatchRules::Stock {
+                starting_stocks: 0,
+                time_limit_frames: None,
+            }
+            .validate()
+            .is_err()
+        );
+        assert!(
+            MatchRules::Stock {
+                starting_stocks: 3,
+                time_limit_frames: Some(0),
+            }
+            .validate()
+            .is_err()
+        );
+        assert!(
+            MatchRules::Timed {
+                time_limit_frames: 0,
+            }
+            .validate()
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn match_rules_accept_valid_modes() {
+        assert!(MatchRules::default().validate().is_ok());
+        assert!(
+            MatchRules::Stock {
+                starting_stocks: 3,
+                time_limit_frames: Some(60),
+            }
+            .validate()
+            .is_ok()
+        );
+        assert!(
+            MatchRules::Timed {
+                time_limit_frames: 60,
+            }
+            .validate()
+            .is_ok()
+        );
+    }
+
     #[test]
     fn match_loading_waits_for_attack_scripts() {
         let mut attack_scripts = HashMap::new();

src/match_runtime.rs

@@ -0,0 +1,102 @@
+//! Rollback-simulated state for an active match.
+
+use bevy::prelude::*;
+use bevy_ggrs::prelude::*;
+
+use crate::match_loading::{MatchConfig, MatchRules};
+
+#[derive(Resource, Clone, Debug, Hash, PartialEq, Eq)]
+pub struct MatchState {
+    pub elapsed_frames: u32,
+    /// Indexed by the player's session handle.
+    pub players: Vec<PlayerMatchState>,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct PlayerMatchState {
+    pub stocks_remaining: Option<u8>,
+    pub score: i32,
+    pub deaths: u32,
+}
+
+impl MatchState {
+    pub fn from_config(config: &MatchConfig) -> Self {
+        let stocks_remaining = match &config.rules {
+            MatchRules::Stock {
+                starting_stocks, ..
+            } => Some(*starting_stocks),
+            MatchRules::Timed { .. } => None,
+        };
+
+        Self {
+            elapsed_frames: 0,
+            players: (0..config.players.len())
+                .map(|_| PlayerMatchState {
+                    stocks_remaining,
+                    score: 0,
+                    deaths: 0,
+                })
+                .collect(),
+        }
+    }
+}
+
+pub struct MatchRuntimePlugin;
+
+impl Plugin for MatchRuntimePlugin {
+    fn build(&self, app: &mut App) {
+        app.rollback_resource_with_clone::<MatchState>()
+            .checksum_resource_with_hash::<MatchState>();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{fighter::FighterId, match_loading::MatchPlayer, stage::manifest::StageId};
+
+    fn config(rules: MatchRules) -> MatchConfig {
+        MatchConfig {
+            stage: StageId::TestStage,
+            players: vec![
+                MatchPlayer {
+                    handle: 1,
+                    fighter: FighterId::TestFighter,
+                },
+                MatchPlayer {
+                    handle: 0,
+                    fighter: FighterId::TestFighter,
+                },
+            ],
+            rules,
+        }
+    }
+
+    #[test]
+    fn stock_state_starts_with_configured_stocks() {
+        let state = MatchState::from_config(&config(MatchRules::Stock {
+            starting_stocks: 4,
+            time_limit_frames: Some(60),
+        }));
+
+        assert_eq!(state.elapsed_frames, 0);
+        assert_eq!(state.players.len(), 2);
+        assert!(state.players.iter().all(|player| {
+            player.stocks_remaining == Some(4) && player.score == 0 && player.deaths == 0
+        }));
+    }
+
+    #[test]
+    fn timed_state_has_no_stock_counter() {
+        let state = MatchState::from_config(&config(MatchRules::Timed {
+            time_limit_frames: 60,
+        }));
+
+        assert!(
+            state
+                .players
+                .iter()
+                .all(|player| player.stocks_remaining.is_none())
+        );
+    }
+}

src/menus/match_config.rs

@@ -3,7 +3,7 @@ use thiserror::Error;
 
 use crate::{
     fighter::FighterId,
-    match_loading::{MatchPlayer, PendingMatch},
+    match_loading::{MatchConfig, MatchPlayer, MatchRules},
     stage::manifest::StageId,
 };
 
@@ -60,7 +60,7 @@ impl MenuMatchConfig {
         !has_unselected_fighter
     }
 
-    pub fn to_pending_match(&self) -> Result<PendingMatch, MenuMatchConfigErrors> {
+    pub fn to_match_config(&self) -> Result<MatchConfig, MenuMatchConfigErrors> {
         let mut match_players = vec![];
 
         let stage = self.stage.ok_or(MenuMatchConfigErrors::StageNotSelected)?;
@@ -78,9 +78,28 @@ impl MenuMatchConfig {
             });
         }
 
-        Ok(PendingMatch {
+        Ok(MatchConfig {
             players: match_players,
             stage,
+            rules: MatchRules::default(),
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn menu_config_uses_default_match_rules() {
+        let menu = MenuMatchConfig {
+            stage: Some(StageId::TestStage),
+            players: vec![MenuMatchPlayerSlot {
+                slot: 0,
+                fighter: Some(FighterId::TestFighter),
+            }],
+        };
+
+        assert_eq!(menu.to_match_config().unwrap().rules, MatchRules::default());
+    }
+}

src/menus/mod.rs

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

src/menus/stage_select/mod.rs

@@ -77,7 +77,7 @@ pub fn stage_selected(
         initiate_match(
             &mut commands,
             &mut next_state,
-            match_config.to_pending_match()?,
+            match_config.to_match_config()?,
         );
     }
     Ok(())

src/replay.rs

@@ -12,16 +12,12 @@ use clap::ValueEnum;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    AppState,
-    args::Args,
-    input::FighterInputFrame,
-    match_loading::{MatchPlayer, PendingMatch},
-    netcode::GGRSCfg,
+    AppState, args::Args, input::FighterInputFrame, match_loading::MatchConfig, netcode::GGRSCfg,
     schedule::GameplaySet,
 };
 
 const MAGIC: &[u8; 8] = b"SPRPLY01";
-pub const REPLAY_VERSION: u32 = 1;
+pub const REPLAY_VERSION: u32 = 2;
 
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq, ValueEnum)]
 pub enum ReplayFormat {
@@ -34,17 +30,11 @@ pub enum ReplayFormat {
 pub struct Replay {
     pub replay_version: u32,
     pub game_version: String,
-    pub match_config: ReplayMatch,
+    pub match_config: MatchConfig,
     pub frames: Vec<ReplayFrame>,
     pub checksums: Vec<ReplayChecksum>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct ReplayMatch {
-    pub stage: crate::stage::manifest::StageId,
-    pub players: Vec<MatchPlayer>,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct ReplayFrame {
     pub frame: i32,
@@ -267,27 +257,27 @@ fn stop_recording(
     mut commands: Commands,
     stop_request: Option<Res<StopReplayRecording>>,
     runtime: Option<ResMut<ReplayRuntime>>,
-    request: Option<Res<PendingMatch>>,
+    config: Option<Res<MatchConfig>>,
 ) {
     if stop_request.is_none() {
         return;
     }
     commands.remove_resource::<StopReplayRecording>();
-    finish_recording_inner(&mut commands, runtime, request);
+    finish_recording_inner(&mut commands, runtime, config);
 }
 
 fn finish_recording(
     mut commands: Commands,
     runtime: Option<ResMut<ReplayRuntime>>,
-    request: Option<Res<PendingMatch>>,
+    config: Option<Res<MatchConfig>>,
 ) {
-    finish_recording_inner(&mut commands, runtime, request);
+    finish_recording_inner(&mut commands, runtime, config);
 }
 
 fn finish_recording_inner(
     commands: &mut Commands,
     runtime: Option<ResMut<ReplayRuntime>>,
-    request: Option<Res<PendingMatch>>,
+    config: Option<Res<MatchConfig>>,
 ) {
     let Some(mut runtime) = runtime else { return };
     let ReplayMode::Record { path, format } = &runtime.mode else {
@@ -296,16 +286,13 @@ fn finish_recording_inner(
     if runtime.finished || runtime.frames.is_empty() {
         return;
     }
-    let Some(request) = request else { return };
+    let Some(config) = config else { return };
     let path = path.clone();
     let format = *format;
     let replay = Replay {
         replay_version: REPLAY_VERSION,
         game_version: env!("CARGO_PKG_VERSION").into(),
-        match_config: ReplayMatch {
-            stage: request.stage,
-            players: request.players.clone(),
-        },
+        match_config: config.as_ref().clone(),
         frames: runtime
             .frames
             .iter()
@@ -355,7 +342,7 @@ mod tests {
     use super::*;
     use crate::{
         fighter::FighterId,
-        match_loading::MatchPlayer,
+        match_loading::{MatchPlayer, MatchRules},
         math::{int::FGi32, vec::FGVec2},
         stage::manifest::StageId,
     };
@@ -364,12 +351,15 @@ mod tests {
         Replay {
             replay_version: REPLAY_VERSION,
             game_version: "test".into(),
-            match_config: ReplayMatch {
+            match_config: MatchConfig {
                 stage: StageId::TestStage,
                 players: vec![MatchPlayer {
                     handle: 0,
                     fighter: FighterId::TestFighter,
                 }],
+                rules: MatchRules::Timed {
+                    time_limit_frames: 21_600,
+                },
             },
             frames: vec![ReplayFrame {
                 frame: 1,
@@ -406,4 +396,15 @@ mod tests {
         replay.frames[0].inputs.clear();
         assert!(validate(&replay).is_err());
     }
+
+    #[test]
+    fn unsupported_replay_version_is_rejected() {
+        let mut replay = sample();
+        replay.replay_version = 1;
+
+        assert_eq!(
+            validate(&replay).unwrap_err(),
+            "unsupported replay version 1"
+        );
+    }
 }

src/ui/battle_ui.rs

@@ -1,20 +1,29 @@
 use bevy::prelude::*;
 
 use crate::{
-    fighter::manifest::{FighterManifest, FighterManifestRegistry}, match_loading::{PendingMatch}, ui::{errors::UIErrors, fighter_info::FighterInfoUI},
+    fighter::manifest::{FighterManifest, FighterManifestRegistry},
+    match_loading::MatchConfig,
+    ui::{errors::UIErrors, fighter_info::FighterInfoUI},
 };
 
 #[derive(Component, FromTemplate)]
-pub struct BattleUI {
-}
-
-pub fn spawn_battle_ui(mut commands: Commands, request: Res<PendingMatch>, fighter_registry: Res<FighterManifestRegistry>, manifests: Res<Assets<FighterManifest>>) -> Result {
+pub struct BattleUI {}
 
+pub fn spawn_battle_ui(
+    mut commands: Commands,
+    config: Res<MatchConfig>,
+    fighter_registry: Res<FighterManifestRegistry>,
+    manifests: Res<Assets<FighterManifest>>,
+) -> Result {
     let mut fighter_uis = vec![];
 
-    for player in &request.players {
-        let manifest = fighter_registry.get(player.fighter).ok_or_else(|| UIErrors::FighterManifestHandleNotFound(player.fighter))?;
-        let manifest = manifests.get(manifest).ok_or_else(|| UIErrors::FighterManifestNotFound(player.fighter))?;
+    for player in &config.players {
+        let manifest = fighter_registry
+            .get(player.fighter)
+            .ok_or_else(|| UIErrors::FighterManifestHandleNotFound(player.fighter))?;
+        let manifest = manifests
+            .get(manifest)
+            .ok_or_else(|| UIErrors::FighterManifestNotFound(player.fighter))?;
 
         fighter_uis.push(FighterInfoUI::build(manifest, player));
     }
@@ -54,4 +63,4 @@ pub fn cleanup_battle_ui(mut commands: Commands, battle_ui: Query<Entity, With<B
     for entity in battle_ui {
         commands.entity(entity).despawn();
     }
-}
+}

src/ui/fighter_info.rs

@@ -1,13 +1,17 @@
 use bevy::prelude::*;
 
-use crate::{fighter::{attack::FighterDamage, manifest::{FighterManifest}}, match_loading::MatchPlayer, player::Player};
+use crate::{
+    fighter::{attack::FighterDamage, manifest::FighterManifest}, match_loading::{MatchPlayer}, match_runtime::MatchState, player::Player, ui::stock_icon::BattleUIStockIcon,
+};
 
 #[derive(Component, FromTemplate)]
 pub struct FighterInfoUI {
     percentage_text: Entity,
+    stock_icon_container: Entity,
     _name_text: Entity,
     player_handle: usize,
     visible_damage: FighterDamage,
+    visible_stocks: u8,
 }
 
 impl FighterInfoUI {
@@ -16,6 +20,7 @@ impl FighterInfoUI {
         bsn! {
             FighterInfoUI {
                 percentage_text: #PercentageText,
+                stock_icon_container: #StockIconContainer,
                 _name_text: #NameText,
                 player_handle: {match_player.handle}
             }
@@ -25,6 +30,10 @@ impl FighterInfoUI {
                 justify_content: JustifyContent::Center,
             }
             Children [
+                (
+                    #StockIconContainer
+                    Node
+                )
                 (
                     #PercentageText
                     Text("0.00%")
@@ -41,17 +50,54 @@ impl FighterInfoUI {
     }
 }
 
-pub fn update_fighter_info_damage(fighters: Query<(&Player, &FighterDamage)>, ui_elements: Query<&mut FighterInfoUI>, mut commands: Commands) {
+pub fn update_fighter_info_damage(
+    fighters: Query<(&Player, &FighterDamage)>,
+    ui_elements: Query<&mut FighterInfoUI>,
+    mut commands: Commands,
+) {
     for mut ui_element in ui_elements {
-        let Some((_, damage)) = fighters.iter().find(|(player, _)| {
-            player.handle == ui_element.player_handle
-        }) else {
+        let Some((_, damage)) = fighters
+            .iter()
+            .find(|(player, _)| player.handle == ui_element.player_handle)
+        else {
             continue;
         };
 
         if *damage != ui_element.visible_damage {
-            commands.entity(ui_element.percentage_text).insert(Text(format!("{}%", damage)));
+            commands
+                .entity(ui_element.percentage_text)
+                .insert(Text(format!("{}%", damage)));
             ui_element.visible_damage = damage.clone();
         }
     }
-}
+}
+
+pub fn update_fighter_info_stocks(
+    match_state: Res<MatchState>,
+    ui_elements: Query<&mut FighterInfoUI>,
+    mut commands: Commands,
+) {
+
+    for mut ui_element in ui_elements {
+        let handle = ui_element.player_handle;
+        let Some(match_player) = match_state.players.get(handle) else {
+            continue;
+        };
+
+        let Some(stocks) = match_player.stocks_remaining else {
+            continue;
+        };
+
+        if stocks != ui_element.visible_stocks {
+            commands
+                .entity(ui_element.stock_icon_container)
+                .despawn_children()
+                .with_children(|spawner| {
+                    for _ in 0..stocks {
+                        spawner.spawn_empty().apply_scene(BattleUIStockIcon::scene());
+                    }
+                });
+            ui_element.visible_stocks = stocks;
+        }
+    }
+}

src/ui/mod.rs

@@ -1,10 +1,15 @@
 use bevy::prelude::*;
 
-use crate::AppState;
+use crate::{
+    AppState,
+    match_loading::{MatchConfig, MatchRules},
+    match_runtime::MatchState,
+};
 
 pub mod battle_ui;
 pub mod errors;
 pub mod fighter_info;
+pub mod stock_icon;
 
 #[derive(Default)]
 pub struct InGameUIPlugin;
@@ -13,6 +18,20 @@ impl Plugin for InGameUIPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(OnEnter(AppState::InMatch), battle_ui::spawn_battle_ui)
             .add_systems(OnExit(AppState::InMatch), battle_ui::cleanup_battle_ui)
-            .add_systems(PostUpdate, fighter_info::update_fighter_info_damage);
+            .add_systems(PostUpdate, fighter_info::update_fighter_info_damage)
+            .add_systems(
+                PostUpdate,
+                fighter_info::update_fighter_info_stocks.run_if(
+                    resource_exists::<MatchState>
+                        .and_then(resource_exists::<MatchConfig>)
+                        .and_then(|match_config: Res<MatchConfig>| {
+                            if let MatchRules::Stock { .. } = match_config.rules {
+                                true
+                            } else {
+                                false
+                            }
+                        }),
+                ),
+            );
     }
 }

src/ui/stock_icon.rs

@@ -0,0 +1,17 @@
+use bevy::prelude::*;
+
+#[derive(SceneComponent, Clone, FromTemplate)]
+pub struct BattleUIStockIcon;
+
+impl BattleUIStockIcon {
+    pub fn scene() -> impl Scene {
+        bsn! {
+            Node {
+                width: px(32),
+                height: px(32),
+                border_radius: BorderRadius::MAX,
+            }
+            BackgroundColor({bevy::color::palettes::css::RED})
+        }
+    }
+}