Add spawn points

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

src/debug_tools.rs

@@ -109,6 +109,7 @@ impl FighterDebugRowKind {
 enum DebugFlag {
     Network,
     Ecb,
+    BlastZones,
     StageCollision,
     AnimationBones,
     AttackHitboxes,
@@ -150,6 +151,10 @@ const FIGHTER_MENU: &[DebugMenuEntry] = &[
         label: "ECB",
         flag: DebugFlag::Ecb,
     },
+    DebugMenuEntry::Toggle {
+        label: "Blast Zones",
+        flag: DebugFlag::BlastZones,
+    },
     DebugMenuEntry::Toggle {
         label: "Animation bones",
         flag: DebugFlag::AnimationBones,
@@ -243,6 +248,7 @@ pub struct DebugSettings {
     pub frame_stepping: bool,
     pub network: bool,
     pub ecb: bool,
+    pub blast_zones: bool,
     pub stage_collision: bool,
     pub animation_bones: bool,
     pub attack_hitboxes: bool,
@@ -264,6 +270,7 @@ impl Default for DebugSettings {
             frame_stepping: false,
             network: false,
             ecb: false,
+            blast_zones: false,
             stage_collision: false,
             animation_bones: false,
             attack_hitboxes: false,
@@ -328,6 +335,7 @@ impl DebugSettings {
         match flag {
             DebugFlag::Network => self.network,
             DebugFlag::Ecb => self.ecb,
+            DebugFlag::BlastZones => self.blast_zones,
             DebugFlag::StageCollision => self.stage_collision,
             DebugFlag::AnimationBones => self.animation_bones,
             DebugFlag::AttackHitboxes => self.attack_hitboxes,
@@ -342,6 +350,7 @@ impl DebugSettings {
         match flag {
             DebugFlag::Network => self.network = !self.network,
             DebugFlag::Ecb => self.ecb = !self.ecb,
+            DebugFlag::BlastZones => self.blast_zones = !self.blast_zones,
             DebugFlag::StageCollision => self.stage_collision = !self.stage_collision,
             DebugFlag::AnimationBones => self.animation_bones = !self.animation_bones,
             DebugFlag::AttackHitboxes => self.attack_hitboxes = !self.attack_hitboxes,
@@ -884,6 +893,10 @@ pub fn stage_collision_enabled(settings: Res<DebugSettings>) -> bool {
     settings.stage_collision
 }
 
+pub fn blast_zones_enabled(settings: Res<DebugSettings>) -> bool {
+    settings.blast_zones
+}
+
 pub fn animation_bones_enabled(settings: Res<DebugSettings>) -> bool {
     settings.animation_bones
 }

src/fighter/debug.rs

@@ -1,10 +1,9 @@
 //! Fighter debug views: gizmos and the egui inspector window.
 
-use std::sync::OnceLock;
 
-use bevy::color::palettes::css::ORANGE;
+use bevy::color::palettes::css::{ORANGE, ORANGE_RED, WHITE};
-use bevy::{color::palettes::css::YELLOW, prelude::*};
+use bevy::prelude::*;
-use bevy_egui::{EguiContexts, egui};
+use bevy_egui::{egui, EguiContexts};
 
 use crate::debug_tools::{DebugSettings, FighterDebugRowKind};
 use crate::fighter::animation::FighterAnimationFrame;
@@ -15,14 +14,14 @@ use crate::fighter::attack::{
 use crate::fighter::baked_animation::{BakedFighterAnimations, FighterBoneMatrices};
 use crate::fighter::ecb::FighterPreviousECB;
 use crate::fighter::errors::FighterErrors;
-use crate::fighter::hurtbox::FixedAffineCapsule;
 use crate::fighter::manifest::FighterManifest;
-use crate::fighter::state::{FighterState, air};
+use crate::fighter::state::{air, FighterState};
 use crate::fighter::visual::FighterAnimations;
 use crate::fighter::{
     Fighter, FighterECB, FighterFacingDirection, FighterHitboxes, FighterPreviousTranslation,
     FighterTranslation, FighterVelocity,
 };
+use crate::filled_gizmos::FilledGizmos;
 use crate::game_settings::GameSettings;
 use crate::input::FighterInput;
 use crate::math::int::FGi32;
@@ -38,6 +37,7 @@ pub fn debug_draw_ecb(
         &FighterPreviousTranslation,
     )>,
     mut gizmos: Gizmos,
+    mut filled_gizmos: FilledGizmos,
 ) {
     for (ecb, trf, ecb_prev, trf_prev) in ecbs {
         gizmos.cross(
@@ -46,15 +46,18 @@ pub fn debug_draw_ecb(
             bevy::color::palettes::css::BLUE,
         );
 
+        let prev_transformed = ecb_prev.to_3d_lineloop(Transform::from_xyz(
+            trf_prev.x.to_num::<f32>(),
+            trf_prev.y.to_num(),
+            0.0,
+        ));
+        filled_gizmos.polygon(&prev_transformed, ORANGE_RED);
+
         let transformed =
             ecb.to_3d_lineloop(Transform::from_xyz(trf.x.to_num(), trf.y.to_num(), 0.0));
-        gizmos.lineloop(transformed, YELLOW);
+        filled_gizmos.polygon(&transformed, ORANGE);
-        let prev_transformed = ecb_prev.to_3d_lineloop(Transform::from_xyz(
+        gizmos.lineloop(transformed, WHITE);
-            trf_prev.x.to_num(),
+
-            trf_prev.y.to_num(),
-            -0.1,
-        ));
-        gizmos.lineloop(prev_transformed, ORANGE);
     }
 }
 pub fn fighter_debug(
@@ -183,15 +186,23 @@ pub fn animation_debug(
     }
 }
 
-pub fn hurtbox_debug(query: Query<&FighterSolvedHurtboxes>, mut gizmos: Gizmos) {
+pub fn hurtbox_debug(
+    query: Query<&FighterSolvedHurtboxes>,
+    mut filled_gizmos: FilledGizmos,
+) {
     for hurtboxes in &query {
         for hurtbox in &hurtboxes.0 {
-            draw_affine_capsule(&mut gizmos, hurtbox.capsule, YELLOW);
+            filled_gizmos.affine_capsule(
+                hurtbox.capsule.transform.to_mat4(),
+                hurtbox.capsule.radius.to_num(),
+                hurtbox.capsule.half_length.to_num(),
+                Color::srgba(1.0, 1.0, 0.0, 0.75),
+            );
         }
     }
 }
 
-fn draw_affine_capsule(
+/*fn draw_affine_capsule(
     gizmos: &mut Gizmos,
     capsule: FixedAffineCapsule,
     color: impl Into<Color> + Copy,
@@ -213,9 +224,9 @@ fn draw_affine_capsule(
     for &(start, end) in &wireframe.lines {
         gizmos.line(vertices[start], vertices[end], color);
     }
-}
+}*/
 
-struct CapsuleWireVertex {
+/*struct CapsuleWireVertex {
     direction: Vec3,
     center_sign: f32,
 }
@@ -223,9 +234,9 @@ struct CapsuleWireVertex {
 struct CapsuleWireframe {
     vertices: Vec<CapsuleWireVertex>,
     lines: Vec<(usize, usize)>,
-}
+}*/
 
-fn capsule_wireframe() -> &'static CapsuleWireframe {
+/*fn capsule_wireframe() -> &'static CapsuleWireframe {
     const RESOLUTION: usize = 16;
     const HEMISPHERE_STEPS: usize = 4;
     static WIREFRAME: OnceLock<CapsuleWireframe> = OnceLock::new();
@@ -306,7 +317,7 @@ fn capsule_wireframe() -> &'static CapsuleWireframe {
 
         CapsuleWireframe { vertices, lines }
     })
-}
+}*/
 
 #[cfg(test)]
 mod capsule_debug_tests {
@@ -326,7 +337,7 @@ mod capsule_debug_tests {
         assert!(marker.abs_diff_eq(Vec3::new(3.0, 4.0, 3.0), 1e-5));
     }
 
-    #[test]
+    /*#[test]
     fn capsule_wireframe_caps_extend_in_opposite_directions() {
         let wireframe = capsule_wireframe();
         let lower: Vec<_> = wireframe
@@ -344,7 +355,7 @@ mod capsule_debug_tests {
         assert!(upper.iter().all(|vertex| vertex.direction.y >= 0.0));
         assert!(lower.iter().any(|vertex| vertex.direction == Vec3::NEG_Y));
         assert!(upper.iter().any(|vertex| vertex.direction == Vec3::Y));
-    }
+    }*/
 }
 
 pub fn attack_debug(
@@ -356,6 +367,7 @@ pub fn attack_debug(
         &FighterAnimationFrame,
     )>,
     mut gizmos: Gizmos,
+    mut filled_gizmos: FilledGizmos,
 ) {
     for (hitboxes, _matrices, _translation, _facing_direction, _frame) in query {
         if let Some(active_attack) = &hitboxes.0 {
@@ -382,6 +394,12 @@ pub fn attack_debug(
                     capsule_draw_trf.to_isometry(),
                     bevy::color::palettes::css::RED,
                 );
+                filled_gizmos.capsule(
+                    capsule_draw_trf.to_isometry(),
+                    solved_hitbox.capsule.radius.to_num(),
+                    length * 0.5,
+                    Color::srgba(1.0, 0.0, 0.0, 0.18),
+                );
 
                 gizmos.cross(start, 1.0, bevy::color::palettes::css::GREEN);
                 gizmos.cross(end, 1.0, bevy::color::palettes::css::GREEN);

src/filled_gizmo.wgsl

@@ -0,0 +1,30 @@
+#import bevy_pbr::mesh_functions::{get_world_from_local, mesh_position_local_to_clip}
+
+@group(#{MATERIAL_BIND_GROUP}) @binding(0) var<uniform> material_color: vec4<f32>;
+
+struct Vertex {
+    @builtin(instance_index) instance_index: u32,
+    @location(0) position: vec3<f32>,
+    @location(1) color: vec4<f32>,
+};
+
+struct VertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) color: vec4<f32>,
+};
+
+@vertex
+fn vertex(vertex: Vertex) -> VertexOutput {
+    var output: VertexOutput;
+    output.clip_position = mesh_position_local_to_clip(
+        get_world_from_local(vertex.instance_index),
+        vec4<f32>(vertex.position, 1.0),
+    );
+    output.color = vertex.color;
+    return output;
+}
+
+@fragment
+fn fragment(input: VertexOutput) -> @location(0) vec4<f32> {
+    return material_color * input.color;
+}

src/filled_gizmos.rs

@@ -0,0 +1,417 @@
+//! Immediate-mode filled debug geometry.
+//!
+//! Unlike Bevy's line-only `Gizmos`, this collects triangles into one dynamic
+//! mesh. It is intended for small, transient debug overlays rather than game
+//! geometry.
+
+use std::f32::consts::{FRAC_PI_2, PI, TAU};
+
+use bevy::{
+    asset::{load_internal_asset, uuid_handle, RenderAssetUsages},
+    camera::visibility::NoFrustumCulling,
+    ecs::system::SystemParam,
+    mesh::{Indices, MeshVertexBufferLayoutRef, PrimitiveTopology},
+    pbr::{MaterialPipeline, MaterialPipelineKey},
+    prelude::*,
+    render::render_resource::{
+        AsBindGroup, RenderPipelineDescriptor, SpecializedMeshPipelineError,
+    },
+    shader::ShaderRef,
+};
+
+const SPHERE_SECTORS: usize = 16;
+const SPHERE_STACKS: usize = 8;
+const CAPSULE_SECTORS: usize = 16;
+const CAPSULE_HEMISPHERE_STEPS: usize = 4;
+
+#[derive(Default)]
+struct FilledGizmoGeometry {
+    positions: Vec<[f32; 3]>,
+    normals: Vec<[f32; 3]>,
+    colors: Vec<[f32; 4]>,
+    indices: Vec<u32>,
+}
+
+#[derive(Resource, Default)]
+struct FilledGizmoBuffer {
+    /// Geometry requested by the current schedule invocation.
+    pending: FilledGizmoGeometry,
+    /// The last completed fixed-timestep geometry. This is retained between
+    /// render frames, just like Bevy's fixed-timestep gizmos.
+    retained: FilledGizmoGeometry,
+    mesh: Option<Handle<Mesh>>,
+    fixed_commit: bool,
+}
+
+/// Immediate-mode API for drawing filled debug shapes.
+#[derive(SystemParam)]
+pub struct FilledGizmos<'w> {
+    buffer: ResMut<'w, FilledGizmoBuffer>,
+}
+
+impl FilledGizmos<'_> {
+    /// Draw a filled planar polygon. Vertices must be ordered around the
+    /// perimeter and the polygon must be convex.
+    pub fn polygon(&mut self, vertices: &[Vec3], color: impl Into<Color> + Copy) {
+        if vertices.len() < 3 {
+            return;
+        }
+        let color = color.into().to_linear().to_f32_array();
+        let normal = (vertices[1] - vertices[0])
+            .cross(vertices[2] - vertices[0])
+            .normalize_or_zero();
+        let base = self.buffer.pending.positions.len() as u32;
+        for &vertex in vertices {
+            self.push_vertex(vertex, normal, color);
+        }
+        for index in 2..vertices.len() as u32 {
+            self.buffer
+                .pending
+                .indices
+                .extend([base, base + index - 1, base + index]);
+        }
+    }
+
+    pub fn sphere(&mut self, isometry: Isometry3d, radius: f32, color: impl Into<Color> + Copy) {
+        if radius <= 0.0 {
+            return;
+        }
+        let color = color.into().to_linear().to_f32_array();
+        let base = self.buffer.pending.positions.len() as u32;
+        for stack in 0..=SPHERE_STACKS {
+            let latitude = PI * 0.5 - stack as f32 * PI / SPHERE_STACKS as f32;
+            let (sin_lat, cos_lat) = latitude.sin_cos();
+            for sector in 0..=SPHERE_SECTORS {
+                let longitude = sector as f32 * TAU / SPHERE_SECTORS as f32;
+                let (sin_lon, cos_lon) = longitude.sin_cos();
+                let normal = Vec3::new(cos_lat * cos_lon, sin_lat, cos_lat * sin_lon);
+                self.push_vertex(
+                    isometry.transform_point(normal * radius).into(),
+                    isometry.rotation * normal,
+                    color,
+                );
+            }
+        }
+        let stride = SPHERE_SECTORS + 1;
+        for stack in 0..SPHERE_STACKS {
+            for sector in 0..SPHERE_SECTORS {
+                let a = base + (stack * stride + sector) as u32;
+                let b = a + stride as u32;
+                self.buffer
+                    .pending
+                    .indices
+                    .extend([a, b, a + 1, a + 1, b, b + 1]);
+            }
+        }
+    }
+
+    pub fn capsule(
+        &mut self,
+        isometry: Isometry3d,
+        radius: f32,
+        half_length: f32,
+        color: impl Into<Color> + Copy,
+    ) {
+        let transform = Mat4::from_scale_rotation_translation(
+            Vec3::ONE,
+            isometry.rotation,
+            isometry.translation.into(),
+        );
+        self.affine_capsule(transform, radius, half_length, color);
+    }
+
+    /// Draw a capsule transformed by an arbitrary affine transform.
+    pub fn affine_capsule(
+        &mut self,
+        transform: Mat4,
+        radius: f32,
+        half_length: f32,
+        color: impl Into<Color> + Copy,
+    ) {
+        if radius <= 0.0 {
+            return;
+        }
+        let color = color.into().to_linear().to_f32_array();
+        let base = self.buffer.pending.positions.len() as u32;
+        let mut rings = Vec::new();
+        for step in 1..=CAPSULE_HEMISPHERE_STEPS {
+            let angle = -FRAC_PI_2 + step as f32 * FRAC_PI_2 / CAPSULE_HEMISPHERE_STEPS as f32;
+            rings.push((
+                radius * angle.cos(),
+                -half_length + radius * angle.sin(),
+                angle.sin(),
+            ));
+        }
+        rings.push((radius, half_length, 0.0));
+        for step in 1..CAPSULE_HEMISPHERE_STEPS {
+            let angle = step as f32 * FRAC_PI_2 / CAPSULE_HEMISPHERE_STEPS as f32;
+            rings.push((
+                radius * angle.cos(),
+                half_length + radius * angle.sin(),
+                angle.sin(),
+            ));
+        }
+
+        let mut ring_indices = Vec::new();
+        let bottom_pole = self.push_capsule_vertex(
+            &mut ring_indices,
+            transform,
+            Vec3::NEG_Y,
+            -half_length,
+            radius,
+            color,
+        );
+        for &(ring_radius, y, normal_y) in &rings {
+            let mut ring = Vec::with_capacity(CAPSULE_SECTORS);
+            for sector in 0..CAPSULE_SECTORS {
+                let angle = sector as f32 * TAU / CAPSULE_SECTORS as f32;
+                let (sin, cos) = angle.sin_cos();
+                let normal = Vec3::new(
+                    cos * (1.0 - normal_y * normal_y).sqrt(),
+                    normal_y,
+                    sin * (1.0 - normal_y * normal_y).sqrt(),
+                );
+                ring.push(self.push_transformed_vertex(
+                    transform,
+                    Vec3::new(cos * ring_radius, y, sin * ring_radius),
+                    normal,
+                    color,
+                ));
+            }
+            ring_indices.push(ring);
+        }
+        let top_pole = self.push_capsule_vertex(
+            &mut ring_indices,
+            transform,
+            Vec3::Y,
+            half_length,
+            radius,
+            color,
+        );
+        for sector in 0..CAPSULE_SECTORS {
+            let next = (sector + 1) % CAPSULE_SECTORS;
+            self.buffer.pending.indices.extend([
+                bottom_pole,
+                ring_indices[0][next],
+                ring_indices[0][sector],
+            ]);
+            for ring in ring_indices.windows(2) {
+                self.buffer.pending.indices.extend([
+                    ring[0][sector],
+                    ring[0][next],
+                    ring[1][sector],
+                    ring[1][sector],
+                    ring[0][next],
+                    ring[1][next],
+                ]);
+            }
+            let last = ring_indices.len() - 1;
+            self.buffer.pending.indices.extend([
+                ring_indices[last][sector],
+                ring_indices[last][next],
+                top_pole,
+            ]);
+        }
+        // Keep the base used by this shape observable to avoid accidental
+        // future changes making the generated indices refer to another shape.
+        debug_assert!(base <= bottom_pole);
+    }
+
+    fn push_capsule_vertex(
+        &mut self,
+        _rings: &mut Vec<Vec<u32>>,
+        transform: Mat4,
+        normal: Vec3,
+        y: f32,
+        radius: f32,
+        color: [f32; 4],
+    ) -> u32 {
+        self.push_transformed_vertex(
+            transform,
+            Vec3::new(0.0, y + normal.y * radius, 0.0),
+            normal,
+            color,
+        )
+    }
+
+    fn push_transformed_vertex(
+        &mut self,
+        transform: Mat4,
+        position: Vec3,
+        normal: Vec3,
+        color: [f32; 4],
+    ) -> u32 {
+        let transformed_normal = transform
+            .inverse()
+            .transpose()
+            .transform_vector3(normal)
+            .normalize_or_zero();
+        let index = self.buffer.pending.positions.len() as u32;
+        self.push_vertex(
+            transform.transform_point3(position),
+            transformed_normal,
+            color,
+        );
+        index
+    }
+
+    fn push_vertex(&mut self, position: Vec3, normal: Vec3, color: [f32; 4]) {
+        self.buffer.pending.positions.push(position.to_array());
+        self.buffer.pending.normals.push(normal.to_array());
+        self.buffer.pending.colors.push(color);
+    }
+}
+
+pub struct FilledGizmosPlugin;
+
+const FILLED_GIZMO_SHADER_HANDLE: Handle<Shader> =
+    uuid_handle!("0e4a979f-ea11-4e5a-91cd-19c89d4e9b53");
+
+/// A deliberately minimal material: unlike `StandardMaterial`, its fragment
+/// shader writes vertex colors directly and therefore bypasses PBR lighting
+/// and camera tonemapping.
+#[derive(Asset, AsBindGroup, Reflect, Clone, Debug)]
+struct FilledGizmoMaterial {
+    #[uniform(0)]
+    color: LinearRgba,
+}
+
+impl Material for FilledGizmoMaterial {
+    fn vertex_shader() -> ShaderRef {
+        FILLED_GIZMO_SHADER_HANDLE.clone().into()
+    }
+
+    fn fragment_shader() -> ShaderRef {
+        FILLED_GIZMO_SHADER_HANDLE.clone().into()
+    }
+
+    fn alpha_mode(&self) -> AlphaMode {
+        AlphaMode::Blend
+    }
+
+    fn enable_prepass() -> bool {
+        false
+    }
+
+    fn enable_shadows() -> bool {
+        false
+    }
+
+    fn specialize(
+        _pipeline: &MaterialPipeline,
+        descriptor: &mut RenderPipelineDescriptor,
+        layout: &MeshVertexBufferLayoutRef,
+        _key: MaterialPipelineKey<Self>,
+    ) -> Result<(), SpecializedMeshPipelineError> {
+        descriptor.vertex.buffers = vec![layout.0.get_layout(&[
+            Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
+            Mesh::ATTRIBUTE_COLOR.at_shader_location(1),
+        ])?];
+        descriptor.primitive.cull_mode = None;
+        Ok(())
+    }
+}
+
+impl Plugin for FilledGizmosPlugin {
+    fn build(&self, app: &mut App) {
+        load_internal_asset!(
+            app,
+            FILLED_GIZMO_SHADER_HANDLE,
+            "filled_gizmo.wgsl",
+            Shader::from_wgsl
+        );
+        app.add_plugins(MaterialPlugin::<FilledGizmoMaterial>::default())
+            .init_resource::<FilledGizmoBuffer>()
+            .add_systems(Startup, setup_filled_gizmo_mesh)
+            .add_systems(FixedFirst, begin_fixed_filled_gizmos)
+            .add_systems(FixedLast, commit_fixed_filled_gizmos)
+            .add_systems(Last, upload_filled_gizmo_mesh);
+    }
+}
+
+fn setup_filled_gizmo_mesh(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<FilledGizmoMaterial>>,
+    mut buffer: ResMut<FilledGizmoBuffer>,
+) {
+    let mesh = meshes.add(
+        Mesh::new(
+            PrimitiveTopology::TriangleList,
+            RenderAssetUsages::default(),
+        )
+        .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, vec![[0.0; 3]; 3])
+        .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 0.0, 1.0]; 3])
+        .with_inserted_attribute(Mesh::ATTRIBUTE_COLOR, vec![[0.0, 0.0, 0.0, 0.0]; 3])
+        .with_inserted_indices(Indices::U32(vec![0, 1, 2])),
+    );
+    let material = materials.add(FilledGizmoMaterial {
+        color: LinearRgba::WHITE,
+    });
+    commands.spawn((
+        Mesh3d(mesh.clone()),
+        MeshMaterial3d(material),
+        NoFrustumCulling,
+    ));
+    buffer.mesh = Some(mesh);
+}
+
+fn begin_fixed_filled_gizmos(mut buffer: ResMut<FilledGizmoBuffer>) {
+    buffer.pending = FilledGizmoGeometry::default();
+    buffer.fixed_commit = false;
+}
+
+fn commit_fixed_filled_gizmos(mut buffer: ResMut<FilledGizmoBuffer>) {
+    let pending = std::mem::take(&mut buffer.pending);
+    buffer.pending = std::mem::replace(&mut buffer.retained, pending);
+    buffer.fixed_commit = true;
+}
+
+fn upload_filled_gizmo_mesh(
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut buffer: ResMut<FilledGizmoBuffer>,
+) {
+    // No fixed tick and no render-frame requests means the existing mesh is
+    // already the correct image. In particular, do not replace it with the
+    // empty placeholder between fixed updates.
+    if !buffer.fixed_commit && buffer.pending.positions.is_empty() {
+        return;
+    }
+    let Some(handle) = buffer.mesh.clone() else {
+        return;
+    };
+
+    let (positions, normals, colors, indices) = if buffer.fixed_commit {
+        // Retained geometry must remain in the CPU-side buffer after upload;
+        // otherwise the next render frame would have nothing to draw.
+        (
+            buffer.retained.positions.clone(),
+            buffer.retained.normals.clone(),
+            buffer.retained.colors.clone(),
+            buffer.retained.indices.clone(),
+        )
+    } else {
+        (
+            std::mem::take(&mut buffer.pending.positions),
+            std::mem::take(&mut buffer.pending.normals),
+            std::mem::take(&mut buffer.pending.colors),
+            std::mem::take(&mut buffer.pending.indices),
+        )
+    };
+
+    if let Some(mut mesh) = meshes.get_mut(&handle) {
+        if positions.is_empty() {
+            mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, vec![[0.0; 3]; 3]);
+            mesh.insert_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 0.0, 1.0]; 3]);
+            mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, vec![[0.0, 0.0, 0.0, 0.0]; 3]);
+            mesh.insert_indices(Indices::U32(vec![0, 1, 2]));
+        } else {
+            mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, positions);
+            mesh.insert_attribute(Mesh::ATTRIBUTE_NORMAL, normals);
+            mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, colors);
+            mesh.insert_indices(Indices::U32(indices));
+        }
+    }
+    buffer.pending = FilledGizmoGeometry::default();
+    buffer.fixed_commit = false;
+}

src/lib.rs

@@ -21,6 +21,8 @@
 //! save, click Rebuild in jackdaw (or run `jd build`) and it
 //! appears in `Add Component`. No registration code is needed.
 
+#![recursion_limit = "512"]
+
 use bevy::{
     asset::processor::{AssetProcessor, ProcessorState},
     prelude::*,
@@ -42,6 +44,7 @@ pub mod blend_asset;
 pub mod camera;
 pub mod debug_tools;
 pub mod fighter;
+pub mod filled_gizmos;
 pub mod game_settings;
 pub mod input;
 pub mod match_loading;
@@ -114,6 +117,7 @@ impl Plugin for GamePlugin {
                 input::FighterInputPlugin,
                 replay::ReplayPlugin,
                 debug_tools::DebugToolsPlugin,
+                filled_gizmos::FilledGizmosPlugin,
                 fighter::FighterPlugin,
                 fighter::baked_animation::BakedAnimationPlugin,
                 scripting::importer::FighterScriptImportPlugin,

src/match_loading.rs

@@ -21,7 +21,6 @@ use crate::{
     },
     input::{LocalInputAssignments, LocalInputSource},
     match_runtime::MatchState,
-    math::{int::FGi32, vec::FGVec2},
     netcode::{
         GGRSCfg,
         session::{ConnectionStatus, SessionConfig, create_session},
@@ -277,7 +276,7 @@ pub fn prepare_match(
     if !valid_player_handles(&config.players) {
         fail_match(
             &mut next_state,
-            "player handles must be unique and cover 0..player_count",
+            "player handles must be unique and non-empty",
         );
         return;
     }
@@ -287,6 +286,20 @@ pub fn prepare_match(
         return;
     }
 
+    let stage_handle = stage_registry
+        .get(config.stage)
+        .expect("Initialization check should ensure all stages exist");
+    let stage_manifest = stage_manifests
+        .get(&stage_handle)
+        .expect("Initialization check should ensure stage manifests are kept alive");
+    let spawn_positions = match stage_manifest.neutral_spawn_positions(config.players.len()) {
+        Ok(positions) => positions,
+        Err(error) => {
+            fail_match(&mut next_state, &error);
+            return;
+        }
+    };
+
     if assets.fighters.len() != config.players.len() {
         fail_match(
             &mut next_state,
@@ -449,7 +462,8 @@ pub fn prepare_match(
         ));
     }
 
-    let session_config = match SessionConfig::from_args(&args, config.players.len()) {
+    let session_player_count = player_count_for_handles(&config.players);
+    let session_config = match SessionConfig::from_args(&args, session_player_count) {
         Ok(config) => config,
         Err(error) => {
             fail_match(
@@ -459,7 +473,7 @@ pub fn prepare_match(
             return;
         }
     };
-    let session = match create_session(&args, config.players.len()) {
+    let session = match create_session(&args, session_player_count) {
         Ok(session) => session,
         Err(error) => {
             fail_match(
@@ -472,12 +486,6 @@ pub fn prepare_match(
 
     let root = commands.spawn((Name::new("Match"), MatchRoot)).id();
 
-    let stage_handle = stage_registry
-        .get(config.stage)
-        .expect("Initialization check should ensure all stages exist");
-    let stage_manifest = stage_manifests
-        .get(&stage_handle)
-        .expect("Initialization check should ensure stage manifests are kept alive");
     stage::spawn_stage(
         &mut commands,
         root,
@@ -487,14 +495,15 @@ pub fn prepare_match(
     );
 
     let mut fighter_roster = Vec::with_capacity(config.players.len());
-    for (index, (player, (scene, animations, attack_scripts, manifest_handle, model_scale, ecb_bone_indices))) in
+
+    for (spawn_index, (player, (scene, animations, attack_scripts, manifest_handle, model_scale, ecb_bone_indices))) in
         config.players.iter().zip(prepared).enumerate()
     {
-        let spawn_x = (index as i32 * 2 + 1 - config.players.len() as i32) * 5;
+        let spawn_point = spawn_positions[spawn_index];
         fighter_roster.push(spawn_fighter(
             &mut commands,
             player.handle,
-            FGVec2::new(FGi32::from_num(spawn_x), FGi32::lit("12.5")),
+            spawn_point,
             manifest_handle.clone(),
             model_scale,
             animations,
@@ -518,12 +527,22 @@ fn fail_match(next_state: &mut NextState<AppState>, message: &str) {
 }
 
 fn valid_player_handles(players: &[MatchPlayer]) -> bool {
-    let mut handles = players
+    if players.is_empty() {
+        return false;
+    }
+
+    let mut handles = players.iter().map(|player| player.handle).collect::<Vec<_>>();
+    handles.sort_unstable();
+    handles.windows(2).all(|handles| handles[0] != handles[1])
+        && handles.last().is_none_or(|handle| *handle != usize::MAX)
+}
+
+fn player_count_for_handles(players: &[MatchPlayer]) -> usize {
+    players
         .iter()
         .map(|player| player.handle)
-        .collect::<Vec<_>>();
+        .max()
-    handles.sort_unstable();
+        .map_or(0, |handle| handle + 1)
-    handles == (0..players.len()).collect::<Vec<_>>()
 }
 
 pub fn cleanup_match(
@@ -590,6 +609,23 @@ mod tests {
         assert!(!valid_player_handles(&players));
     }
 
+    #[test]
+    fn player_handles_may_have_gaps() {
+        let players = [
+            MatchPlayer {
+                handle: 0,
+                fighter: FighterId::TestFighter,
+            },
+            MatchPlayer {
+                handle: 2,
+                fighter: FighterId::TestFighter,
+            },
+        ];
+
+        assert!(valid_player_handles(&players));
+        assert_eq!(player_count_for_handles(&players), 3);
+    }
+
     #[test]
     fn match_rules_reject_zero_limits() {
         assert!(

src/match_runtime.rs

@@ -40,7 +40,12 @@ impl MatchState {
 
         Self {
             elapsed_frames: 0,
-            players: (0..config.players.len())
+            players: (0..config
+                .players
+                .iter()
+                .map(|player| player.handle)
+                .max()
+                .map_or(0, |handle| handle + 1))
                 .map(|_| PlayerMatchState {
                     stocks_remaining,
                     score: 0,

src/replay.rs

@@ -140,7 +140,7 @@ fn validate(replay: &Replay) -> Result<(), String> {
         ));
     }
     if replay.players_are_invalid() {
-        return Err("replay player handles must cover 0..player_count".into());
+        return Err("replay player handles must be unique".into());
     }
     if replay.frames.is_empty() {
         return Err("replay must contain at least one frame".into());
@@ -169,7 +169,16 @@ fn validate(replay: &Replay) -> Result<(), String> {
     if replay
         .frames
         .iter()
-        .any(|frame| frame.inputs.len() != replay.match_config.players.len())
+        .any(|frame| {
+            frame.inputs.len()
+                != replay
+                    .match_config
+                    .players
+                    .iter()
+                    .map(|player| player.handle)
+                    .max()
+                    .map_or(0, |handle| handle + 1)
+        })
     {
         return Err("replay frame input count does not match player count".into());
     }
@@ -185,7 +194,9 @@ impl Replay {
             .map(|player| player.handle)
             .collect();
         handles.sort_unstable();
-        handles != (0..handles.len()).collect::<Vec<_>>()
+        handles.is_empty()
+            || handles.windows(2).any(|handles| handles[0] == handles[1])
+            || handles.last() == Some(&usize::MAX)
     }
 
     fn frame(&self, frame: i32) -> Option<&ReplayFrame> {

src/stage/debug.rs

@@ -1,6 +1,12 @@
 use bevy::{color::palettes::css::RED, prelude::*};
 
-use crate::stage::line::StageCollision;
+use crate::{
+    match_loading::MatchConfig,
+    stage::{
+        line::StageCollision,
+        manifest::{StageManifest, StageManifestRegistry},
+    },
+};
 
 pub fn debug_draw_scene(mut gizmos: Gizmos, stage_collision: Res<StageCollision>) {
     for poly in stage_collision.stage_polys.iter() {
@@ -16,3 +22,25 @@ pub fn debug_draw_scene(mut gizmos: Gizmos, stage_collision: Res<StageCollision>
         }
     }
 }
+
+pub fn debug_draw_blast_zones(
+    mut gizmos: Gizmos,
+    stage_registry: Res<StageManifestRegistry>,
+    stage_manifests: Res<Assets<StageManifest>>,
+    match_config: Res<MatchConfig>,
+) {
+    let Some(stage_manifest_handle) = stage_registry.get(match_config.stage) else {
+        return;
+    };
+
+    let Some(stage_manifest) = stage_manifests.get(&stage_manifest_handle) else {
+        return;
+    };
+
+    let top_left = stage_manifest.blast_zone_top_left.to_vec2();
+    let bottom_right = stage_manifest.blast_zone_bottom_right.to_vec2();
+    let center = (top_left + bottom_right) / 2.0;
+    let size = (bottom_right - top_left).abs();
+
+    gizmos.rect(Vec3::new(center.x, center.y, 0.0), size, bevy::color::palettes::css::BLUE);
+}

src/stage/manifest.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use bevy_asset_loader::asset_collection::AssetCollection;
 use ron_asset_manager::prelude::RonAsset;
@@ -7,14 +7,10 @@ use strum::IntoEnumIterator;
 use strum_macros::EnumIter;
 
 use crate::{
-    AppState,
+    AppState, game_settings::GameSettings, math::{vec::FGVec2}, stage::{
-    game_settings::GameSettings,
-    math::vec::FGVec2,
-    stage::{
         StagePoly,
         line::{StageCollision, StagePolyLineSegmentType, StagePolyType},
-    },
+    }, texture_reference::TextureReference,
-    texture_reference::TextureReference,
 };
 use bevy::prelude::*;
 
@@ -87,6 +83,15 @@ pub struct StageManifest {
     pub icon: TextureReference,
     pub camera: StageCameraProfile,
     pub polygons: Vec<StagePolyDefinition>,
+
+    #[reflect(ignore)]
+    pub blast_zone_top_left: FGVec2,
+    #[reflect(ignore)]
+    pub blast_zone_bottom_right: FGVec2,
+
+    #[reflect(ignore)]
+    pub spawn_points: Vec<FGVec2>,
+    pub neutral_spawn_point_sets: Vec<Vec<usize>>
 }
 
 #[derive(Resource)]
@@ -162,6 +167,13 @@ pub fn prepare_stage_manifests(
             );
             return;
         }
+        if let Err(error) = manifest.validate_spawn_points() {
+            fail(
+                &mut next_state,
+                &format!("{:?} has invalid spawn points: {error}", manifest.id),
+            );
+            return;
+        }
         if registry.insert(manifest.id, handle.clone()).is_some() {
             fail(
                 &mut next_state,
@@ -186,6 +198,69 @@ pub fn prepare_stage_manifests(
 }
 
 impl StageManifest {
+    pub fn neutral_spawn_positions(&self, player_count: usize) -> Result<Vec<FGVec2>, String> {
+        if player_count == 0 {
+            return Err("a match must contain at least one player".to_owned());
+        }
+
+        let layout = self
+            .neutral_spawn_point_sets
+            .get(player_count - 1)
+            .ok_or_else(|| format!("no spawn layout for {player_count} players"))?;
+
+        if layout.len() != player_count {
+            return Err(format!(
+                "the {player_count}-player layout contains {} positions",
+                layout.len()
+            ));
+        }
+
+        layout
+            .iter()
+            .map(|&index| {
+                self.spawn_points.get(index).copied().ok_or_else(|| {
+                    format!("the {player_count}-player layout references spawn point {index}")
+                })
+            })
+            .collect()
+    }
+
+    fn validate_spawn_points(&self) -> Result<(), String> {
+        if self.spawn_points.is_empty() {
+            return Err("no spawn points are configured".to_owned());
+        }
+
+        if self.neutral_spawn_point_sets.is_empty() {
+            return Err("no neutral spawn layouts are configured".to_owned());
+        }
+
+        for (layout_index, layout) in self.neutral_spawn_point_sets.iter().enumerate() {
+            let player_count = layout_index + 1;
+            if layout.len() != player_count {
+                return Err(format!(
+                    "the {player_count}-player layout contains {} positions",
+                    layout.len()
+                ));
+            }
+
+            let mut unique_indices = HashSet::with_capacity(layout.len());
+            for &spawn_point_index in layout {
+                if spawn_point_index >= self.spawn_points.len() {
+                    return Err(format!(
+                        "the {player_count}-player layout references spawn point {spawn_point_index}"
+                    ));
+                }
+                if !unique_indices.insert(spawn_point_index) {
+                    return Err(format!(
+                        "the {player_count}-player layout uses spawn point {spawn_point_index} more than once"
+                    ));
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     pub fn to_collision(&self) -> StageCollision {
         let stage_polys: Vec<StagePoly> = self
             .polygons

src/stage/mod.rs

@@ -10,7 +10,7 @@ pub mod scene;
 
 pub use line::{StagePlaneIntersectResult, StagePoly};
 
-use crate::stage::{line::StageCollision, manifest::StageCameraProfile};
+use crate::{match_loading::MatchConfig, stage::{line::StageCollision, manifest::StageCameraProfile}};
 
 /// Owns the stage geometry: which scene gets spawned and how it is drawn.
 #[derive(Default)]
@@ -20,9 +20,14 @@ impl Plugin for StagePlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(
             Update,
-            debug::debug_draw_scene
+            (
-                .run_if(resource_exists::<line::StageCollision>)
+                (debug::debug_draw_scene
-                .run_if(crate::debug_tools::stage_collision_enabled),
+                    .run_if(resource_exists::<line::StageCollision>)
+                    .run_if(crate::debug_tools::stage_collision_enabled)),
+                (debug::debug_draw_blast_zones
+                    .run_if(resource_exists::<MatchConfig>)
+                    .run_if(crate::debug_tools::blast_zones_enabled),),
+            ),
         );
     }
 }