diff --git a/src/debug_tools.rs b/src/debug_tools.rs index 6273bae..6bbfc8b 100644 --- a/src/debug_tools.rs +++ b/src/debug_tools.rs @@ -111,6 +111,7 @@ enum DebugFlag { Ecb, BlastZones, StageCollision, + SpawnPositions, AnimationBones, AttackHitboxes, Hurtboxes, @@ -151,10 +152,6 @@ 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, @@ -178,6 +175,14 @@ const WORLD_MENU: &[DebugMenuEntry] = &[ label: "Stage collision", flag: DebugFlag::StageCollision, }, + DebugMenuEntry::Toggle { + label: "Blast zones", + flag: DebugFlag::BlastZones, + }, + DebugMenuEntry::Toggle { + label: "Spawn points", + flag: DebugFlag::SpawnPositions, + }, DebugMenuEntry::GameSpeed { label: "Game speed", }, @@ -250,6 +255,7 @@ pub struct DebugSettings { pub ecb: bool, pub blast_zones: bool, pub stage_collision: bool, + pub spawn_positions: bool, pub animation_bones: bool, pub attack_hitboxes: bool, pub hurtboxes: bool, @@ -272,6 +278,7 @@ impl Default for DebugSettings { ecb: false, blast_zones: false, stage_collision: false, + spawn_positions: false, animation_bones: false, attack_hitboxes: false, hurtboxes: false, @@ -336,6 +343,7 @@ impl DebugSettings { DebugFlag::Network => self.network, DebugFlag::Ecb => self.ecb, DebugFlag::BlastZones => self.blast_zones, + DebugFlag::SpawnPositions => self.spawn_positions, DebugFlag::StageCollision => self.stage_collision, DebugFlag::AnimationBones => self.animation_bones, DebugFlag::AttackHitboxes => self.attack_hitboxes, @@ -352,6 +360,7 @@ impl DebugSettings { DebugFlag::Ecb => self.ecb = !self.ecb, DebugFlag::BlastZones => self.blast_zones = !self.blast_zones, DebugFlag::StageCollision => self.stage_collision = !self.stage_collision, + DebugFlag::SpawnPositions => self.spawn_positions = !self.spawn_positions, DebugFlag::AnimationBones => self.animation_bones = !self.animation_bones, DebugFlag::AttackHitboxes => self.attack_hitboxes = !self.attack_hitboxes, DebugFlag::Hurtboxes => self.hurtboxes = !self.hurtboxes, @@ -897,6 +906,10 @@ pub fn blast_zones_enabled(settings: Res) -> bool { settings.blast_zones } +pub fn spawn_positions_enabled(settings: Res) -> bool { + settings.spawn_positions +} + pub fn animation_bones_enabled(settings: Res) -> bool { settings.animation_bones } diff --git a/src/debug_tools/save_state.rs b/src/debug_tools/save_state.rs index 70405c9..57f25fb 100644 --- a/src/debug_tools/save_state.rs +++ b/src/debug_tools/save_state.rs @@ -1,22 +1,12 @@ use bevy::prelude::*; use crate::{ - camera::MatchCamera, - fighter::{ - FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, - FighterPreviousFacingDirection, FighterPreviousTranslation, FighterSurfaceState, - FighterTranslation, FighterVelocity, - animation::FighterAnimationFrame, - attack::{ + camera::MatchCamera, fighter::{ + FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, FighterHitstopShake, FighterPendingRespawn, FighterPreviousFacingDirection, FighterPreviousTranslation, FighterSurfaceState, FighterTranslation, FighterVelocity, animation::FighterAnimationFrame, attack::{ FighterDamage, FighterKnockbackVelocity, FighterPendingHitReaction, FighterPendingHits, FighterSolvedHurtboxes, FighterStaleMoveQueue, - }, - baked_animation::FighterBoneMatrices, - state::FighterState, - }, - input::FighterInput, - player::Player, - stage::line::StageCollision, + }, baked_animation::FighterBoneMatrices, state::FighterState, + }, input::FighterInput, player::Player, stage::line::StageCollision, }; #[derive(Resource, Default)] @@ -55,6 +45,7 @@ struct FighterCheckpoint { solved_hurtboxes: FighterSolvedHurtboxes, bone_matrices: FighterBoneMatrices, surface: FighterSurfaceState, + pending_respawn: FighterPendingRespawn, } pub(super) fn save_or_restore(world: &mut World) { @@ -154,6 +145,7 @@ pub(super) fn save_or_restore(world: &mut World) { entity.insert(saved.solved_hurtboxes.clone()); entity.insert(saved.bone_matrices.clone()); entity.insert(saved.surface.clone()); + entity.insert(saved.pending_respawn.clone()); } world.insert_resource(checkpoint.pending_hits.clone()); world.insert_resource(checkpoint.stage_collision); @@ -188,6 +180,7 @@ fn capture_fighter(world: &World, entity: Entity) -> Option { solved_hurtboxes: fighter.get::()?.clone(), bone_matrices: fighter.get::()?.clone(), surface: fighter.get::()?.clone(), + pending_respawn: fighter.get::()?.clone(), }) } diff --git a/src/fighter/blast_zones.rs b/src/fighter/blast_zones.rs new file mode 100644 index 0000000..b8e059a --- /dev/null +++ b/src/fighter/blast_zones.rs @@ -0,0 +1,36 @@ +//! Various interactions with the blast zones + +use bevy::prelude::*; + +use crate::{fighter::{FighterPendingRespawn, FighterTranslation, state::FighterState}, match_loading::MatchConfig, stage::manifest::{StageManifest, StageManifestRegistry}}; + +pub fn apply_blast_zones( + stage_registry: Res, + stage_manifests: Res>, + match_config: Res, + fighters: Query<(&FighterTranslation, &mut FighterPendingRespawn, &FighterState)> +) { + let Some(stage_manifest_handle) = stage_registry.get(match_config.stage) else { + return; + }; + + let Some(stage_manifest) = stage_manifests.get(&stage_manifest_handle) else { + return; + }; + + for (translation, mut pending_respawn, state) in fighters { + let is_off_the_left = translation.x < stage_manifest.blast_zone_top_left.x; + let is_off_the_right = translation.x > stage_manifest.blast_zone_bottom_right.x; + let is_off_the_top = translation.y > stage_manifest.blast_zone_top_left.y; + let is_off_the_bottom = translation.y < stage_manifest.blast_zone_bottom_right.y; + + if is_off_the_left || is_off_the_bottom || is_off_the_right { + pending_respawn.0 = true; + } else if is_off_the_top { + let is_in_hitstun = matches!(state, FighterState::Hitstun(..)); + if is_in_hitstun { + pending_respawn.0 = true; + } + } + } +} \ No newline at end of file diff --git a/src/fighter/mod.rs b/src/fighter/mod.rs index fdde068..c52df73 100644 --- a/src/fighter/mod.rs +++ b/src/fighter/mod.rs @@ -20,6 +20,7 @@ pub mod motion; pub mod state; pub mod surface; pub mod visual; +pub mod blast_zones; // The fighter components are re-exported so the rest of the crate can say // `fighter::FighterVelocity` without caring which file it lives in. Named @@ -128,11 +129,15 @@ impl FighterFacingDirection { #[require(Transform)] pub struct FighterVisual; +#[derive(Component, DerefMut, Deref, Debug, Default, Hash, Clone, Copy)] +pub struct FighterPendingRespawn(bool); + #[derive(Component)] #[require( FighterStaleMoveQueue, FighterDamage, FighterPendingHitReaction, + FighterPendingRespawn, FighterHitstop, FighterKnockbackVelocity, FighterTranslation @@ -177,7 +182,7 @@ impl Plugin for FighterPlugin { .add_systems( GgrsSchedule, ( - (ecb::update_ecb, ecb::decrement_ecb_lockout, state::state_collision_interrupt_system).chain(), + (blast_zones::apply_blast_zones, ecb::update_ecb, ecb::decrement_ecb_lockout, state::state_collision_interrupt_system).chain(), baked_animation::update_fighter_bone_matrices, ) .chain() @@ -220,6 +225,8 @@ impl Plugin for FighterPlugin { .checksum_component_with_hash::() .rollback_component_with_clone::() .checksum_component_with_hash::() + .rollback_component_with_copy::() + .checksum_component_with_hash::() .rollback_component_with_copy::() .checksum_component_with_hash::() .rollback_component_with_copy::() @@ -281,6 +288,7 @@ pub struct FighterHitboxes(pub Option); pub fn spawn_fighter( commands: &mut Commands, player_handle: usize, + controller_port: usize, spawn_position: FGVec2, manifest: Handle, model_scale: FGi32, @@ -294,6 +302,7 @@ pub fn spawn_fighter( Name(format!("Fighter {player_handle}").into()), Player { handle: player_handle, + controller_port, }, Fighter { manifest: manifest }, FighterFacingDirection::Right, diff --git a/src/fighter/state/angel.rs b/src/fighter/state/angel.rs new file mode 100644 index 0000000..e49a126 --- /dev/null +++ b/src/fighter/state/angel.rs @@ -0,0 +1,53 @@ +use crate::{fighter::{animation::AnimKind, state::{FighterState, FighterStateImpl, air::AirborneStateCommon, fall::FallState}}, math::vec::FGVec2}; + +#[derive(Debug, Clone, Hash)] +pub struct AngelState { + frames_remaining: u32 +} + +impl AngelState { + pub fn new(duration: u32) -> Self { + Self { + frames_remaining: duration + } + } +} + +impl FighterStateImpl for AngelState { + const NAME: &'static str = "Angel"; + + fn check_interrupt(&self, state_context: &mut super::InterruptContext) -> Option { + let moved_sideways = !state_context.input.get_last_frame().movement.x.is_zero(); + let moved_vertically = !state_context.input.get_last_frame().movement.y.is_zero(); + + if self.frames_remaining == 0 || moved_sideways || moved_vertically { + Some(FighterState::Fall(FallState::new(AirborneStateCommon::default()))) + } else { + None + } + } + + fn update(&mut self, _state_context: &mut super::UpdateContext) { + self.frames_remaining = self.frames_remaining.saturating_sub(1); + } + + fn is_visually_grounded<'a>(&'a self) -> bool { + false + } + + fn on_enter(&mut self, state_context: &mut super::EnterContext) { + state_context.play_animation(AnimKind::Wait, true); + state_context.velocity.0 = FGVec2::ZERO; + } + + fn check_collision_interrupt( + &mut self, + _state_context: &mut super::CollisionContext, + ) -> Option { + None + } + + fn surface_policy(&self) -> super::SurfacePolicy { + super::SurfacePolicy::Airborne(crate::fighter::surface::EcbLockPolicy::Clear) + } +} \ No newline at end of file diff --git a/src/fighter/state/mod.rs b/src/fighter/state/mod.rs index 67c39a4..08bc6bf 100644 --- a/src/fighter/state/mod.rs +++ b/src/fighter/state/mod.rs @@ -15,22 +15,29 @@ use crate::fighter::baked_animation::BakedFighterAnimations; use crate::fighter::ecb::FighterPreviousECB; use crate::fighter::manifest::FighterManifest; use crate::fighter::state::hitstun::HitstunState; +use crate::fighter::surface::EcbLockPolicy; use crate::fighter::visual::FighterAnimations; use crate::fighter::{ Fighter, FighterECB, FighterFacingDirection, FighterHitboxes, FighterHitstop, - FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole, - FighterPreviousTranslation, FighterSurfaceState, FighterTranslation, FighterVelocity, - FighterPresentationSnap, + FighterHitstopShake, FighterHitstopShakeKind, FighterHitstopShakeRole, FighterPendingRespawn, + FighterPresentationSnap, FighterPreviousTranslation, FighterSurfaceState, FighterTranslation, + FighterVelocity, FighterDamage, }; -use crate::fighter::surface::EcbLockPolicy; use crate::game_settings::GameSettings; use crate::input::FighterInput; +use crate::match_loading::MatchConfig; +use crate::match_runtime::MatchState; use crate::math::int::FGi32; +use crate::math::vec::FGVec2; +use crate::player::Player; use crate::scripting::FighterAttackScript; use crate::stage::line::StageCollision; +use crate::stage::manifest::{StageManifest, StageManifestRegistry}; pub mod air; pub mod air_dodge; +pub mod angel; +pub mod crouch; pub mod dash; pub mod fall; pub mod ground; @@ -38,12 +45,11 @@ pub mod ground_attack; pub mod hitstun; pub mod jump; pub mod land; +pub mod platform_pass; pub mod run; pub mod turn; pub mod wait; pub mod walk; -pub mod crouch; -pub mod platform_pass; #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)] pub enum SurfacePolicy { @@ -210,8 +216,8 @@ impl CollisionContext<'_> { &self, ) -> Option { let ignored_polys = self.surface.ignored_polygon_ids(); - let ignore_soft_platforms = self.input.get_last_frame().movement.y - <= -self.downward_stick_threshold; + let ignore_soft_platforms = + self.input.get_last_frame().movement.y <= -self.downward_stick_threshold; crate::fighter::collision::air_collide_with_stage( self.prev_translation, self.translation, @@ -239,6 +245,7 @@ fighter_states! { Turn => turn::TurnState, GroundAttack => ground_attack::GroundAttackState, Hitstun => hitstun::HitstunState, + Angel => angel::AngelState, } #[derive(QueryData)] @@ -314,7 +321,7 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> { surface: &mut self.surface, fighter_attributes: attributes, attack_script_assets, - game_settings + game_settings, } } @@ -364,7 +371,9 @@ impl<'w, 's> FighterFrameQueryItem<'w, 's> { ecb: &mut self.ecb, prev_ecb: &self.prev_ecb, stage_collision, - leave_ground_ecb_lock_duration: game_settings.fighter_common.leave_ground_ecb_frame_lock_duration, + leave_ground_ecb_lock_duration: game_settings + .fighter_common + .leave_ground_ecb_frame_lock_duration, downward_stick_threshold: game_settings.input_common.run_stick_threshold, } } @@ -378,9 +387,12 @@ pub struct StatefulFighterQuery { pub animations: &'static FighterAnimations, pub fighter: &'static Fighter, pub attack_script_assets: &'static FighterAttackScriptAssets, + pub player: &'static Player, pub pending_hit_reaction: &'static mut FighterPendingHitReaction, pub hitstop: &'static mut FighterHitstop, pub hitstop_shake: &'static mut FighterHitstopShake, + pub pending_respawn: &'static mut FighterPendingRespawn, + pub damage: &'static mut FighterDamage, } pub fn state_update_system( @@ -429,7 +441,9 @@ fn transition_state( if let SurfacePolicy::Airborne(lock_policy) = next.surface_policy() { frame.surface.apply_airborne_policy( lock_policy, - game_settings.fighter_common.leave_ground_ecb_frame_lock_duration, + game_settings + .fighter_common + .leave_ground_ecb_frame_lock_duration, ); } next.on_enter(&mut frame.enter_context(attributes, attack_script_assets, game_settings)); @@ -454,6 +468,7 @@ pub fn state_interrupt_system( mut pending_hit_reaction, mut hitstop, mut hitstop_shake, + .. } = fighter; let manifest = fighter_manifests .get(&fighter.manifest) @@ -516,7 +531,7 @@ pub fn state_interrupt_system( animations, &baked_animations, &manifest.attributes, - &stage_collision + &stage_collision, )) }; @@ -538,25 +553,89 @@ pub fn state_collision_interrupt_system( stage_collision: Res, fighter_manifests: Res>, game_settings: Res, + match_config: Res, + mut match_state: ResMut, + stage_registry: Res, + stage_manifests: Res>, ) { + let Some(stage_manifest_handle) = stage_registry.get(match_config.stage) else { + return; + }; + + let Some(stage_manifest) = stage_manifests.get(&stage_manifest_handle) else { + return; + }; + for fighter in &mut query { let StatefulFighterQueryItem { mut state, mut frame, fighter, attack_script_assets, - hitstop, + mut hitstop, + mut pending_respawn, + player, + mut damage, .. } = fighter; - if hitstop.remaining_frames > 0 { - continue; - } let manifest = fighter_manifests .get(&fighter.manifest) .expect("Fighter manifest should be valid"); - let new_state = - state.check_collision_interrupt(&mut frame.collision_context(&stage_collision, &game_settings)); + + if pending_respawn.0 { + **pending_respawn = false; + let respawn_state = FighterState::Angel(angel::AngelState::new(60 * 3)); + + // Find the angel platform position + let respawn_point = stage_manifest + .respawn_points + .get(player.controller_port % stage_manifest.respawn_points.len()); + + if let None = respawn_point { + error!("Couldn't get a respawn point, falling back to the world origin"); + } + + let respawn_point = respawn_point.copied().unwrap_or(FGVec2::ZERO); + + frame.translation.0 = respawn_point; + frame.presentation_snap.0 = true; + + // Clear hitstop + hitstop.remaining_frames = 0; + + // subtract one stock + + let player_state = match_state.players.get_mut(player.handle).expect(&format!( + "Failed to get fighter for GGRS slot {} (controller port {})", + player.handle, player.controller_port + )); + + if let Some(stocks_remaining) = &mut player_state.stocks_remaining { + *stocks_remaining = stocks_remaining.saturating_sub(1); + } + + // reset percentage + *damage = FighterDamage::default(); + + transition_state( + &mut state, + respawn_state, + &mut frame, + &manifest.attributes, + attack_script_assets, + &game_settings, + ); + continue; + } + + if hitstop.remaining_frames > 0 { + continue; + } + + let new_state = state.check_collision_interrupt( + &mut frame.collision_context(&stage_collision, &game_settings), + ); if let Some(new_state) = new_state { transition_state( &mut state, diff --git a/src/match_loading.rs b/src/match_loading.rs index 4d0411f..0d976e3 100644 --- a/src/match_loading.rs +++ b/src/match_loading.rs @@ -34,7 +34,10 @@ use crate::{ #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] pub struct MatchPlayer { + /// Dense index used by GGRS and rollback-simulated player state. pub handle: usize, + /// Physical controller port selected for a single-player match. + pub controller_port: usize, pub fighter: FighterId, } @@ -45,6 +48,22 @@ pub struct MatchConfig { pub rules: MatchRules, } +impl MatchConfig { + /// Maps a GGRS handle to the controller port used by gameplay. + /// + /// Multiplayer uses the stable, dense GGRS handle as the port. A + /// single-player match preserves the physical controller port selected in + /// the menu (for example, port 3 remains port 3). + pub fn controller_port_for_handle(&self, handle: usize) -> Option { + let player = self.players.iter().find(|player| player.handle == handle)?; + Some(if self.players.len() > 1 { + handle + } else { + player.controller_port + }) + } +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub enum MatchRules { Stock { @@ -227,6 +246,7 @@ pub fn initiate_default_match( let players = (0..args.players) .map(|handle| MatchPlayer { handle, + controller_port: handle, fighter: FighterId::TestFighter, }) .collect(); @@ -262,6 +282,7 @@ pub fn initiate_default_match( pub fn prepare_match( mut commands: Commands, config: Res, + mut input_assignments: ResMut, assets: Res, gltfs: Res>, baked_animations: Res>, @@ -276,7 +297,7 @@ pub fn prepare_match( if !valid_player_handles(&config.players) { fail_match( &mut next_state, - "player handles must be unique and non-empty", + "player handles must be dense, unique, and non-empty", ); return; } @@ -484,6 +505,8 @@ pub fn prepare_match( } }; + remap_local_input_assignments(&mut input_assignments, &config.players); + let root = commands.spawn((Name::new("Match"), MatchRoot)).id(); stage::spawn_stage( @@ -503,6 +526,9 @@ pub fn prepare_match( fighter_roster.push(spawn_fighter( &mut commands, player.handle, + config + .controller_port_for_handle(player.handle) + .expect("validated match config contains every player handle"), spawn_point, manifest_handle.clone(), model_scale, @@ -533,16 +559,25 @@ fn valid_player_handles(players: &[MatchPlayer]) -> bool { let mut handles = players.iter().map(|player| player.handle).collect::>(); handles.sort_unstable(); - handles.windows(2).all(|handles| handles[0] != handles[1]) - && handles.last().is_none_or(|handle| *handle != usize::MAX) + handles.into_iter().eq(0..players.len()) } fn player_count_for_handles(players: &[MatchPlayer]) -> usize { - players - .iter() - .map(|player| player.handle) - .max() - .map_or(0, |handle| handle + 1) + players.len() +} + +fn remap_local_input_assignments( + assignments: &mut LocalInputAssignments, + players: &[MatchPlayer], +) { + for (assigned_port, _) in assignments.iter_mut() { + if let Some(player) = players + .iter() + .find(|player| player.controller_port == *assigned_port) + { + *assigned_port = player.handle; + } + } } pub fn cleanup_match( @@ -577,10 +612,12 @@ mod tests { players: vec![ MatchPlayer { handle: 0, + controller_port: 0, fighter: FighterId::TestFighter, }, MatchPlayer { handle: 1, + controller_port: 1, fighter: FighterId::TestFighter, }, ], @@ -598,10 +635,12 @@ mod tests { let players = [ MatchPlayer { handle: 0, + controller_port: 0, fighter: FighterId::TestFighter, }, MatchPlayer { handle: 0, + controller_port: 1, fighter: FighterId::TestFighter, }, ]; @@ -610,20 +649,80 @@ mod tests { } #[test] - fn player_handles_may_have_gaps() { + fn player_handles_must_not_have_gaps() { let players = [ MatchPlayer { handle: 0, + controller_port: 0, fighter: FighterId::TestFighter, }, MatchPlayer { handle: 2, + controller_port: 3, fighter: FighterId::TestFighter, }, ]; - assert!(valid_player_handles(&players)); - assert_eq!(player_count_for_handles(&players), 3); + assert!(!valid_player_handles(&players)); + assert_eq!(player_count_for_handles(&players), 2); + } + + #[test] + fn controller_ports_use_ggrs_handles_only_in_multiplayer() { + let single_player = MatchConfig { + stage: StageId::TestStage, + players: vec![MatchPlayer { + handle: 0, + controller_port: 3, + fighter: FighterId::TestFighter, + }], + rules: MatchRules::default(), + }; + assert_eq!(single_player.controller_port_for_handle(0), Some(3)); + + let multiplayer = MatchConfig { + stage: StageId::TestStage, + players: vec![ + MatchPlayer { + handle: 0, + controller_port: 0, + fighter: FighterId::TestFighter, + }, + MatchPlayer { + handle: 1, + controller_port: 3, + fighter: FighterId::TestFighter, + }, + ], + rules: MatchRules::default(), + }; + assert_eq!(multiplayer.controller_port_for_handle(0), Some(0)); + assert_eq!(multiplayer.controller_port_for_handle(1), Some(1)); + } + + #[test] + fn input_assignments_are_remapped_from_ports_to_ggrs_handles() { + let players = [ + MatchPlayer { + handle: 0, + controller_port: 0, + fighter: FighterId::TestFighter, + }, + MatchPlayer { + handle: 1, + controller_port: 3, + fighter: FighterId::TestFighter, + }, + ]; + let mut assignments = LocalInputAssignments(vec![ + (0, LocalInputSource::Keyboard), + (3, LocalInputSource::Gamepad(Entity::PLACEHOLDER)), + ]); + + remap_local_input_assignments(&mut assignments, &players); + + assert_eq!(assignments[0].0, 0); + assert_eq!(assignments[1].0, 1); } #[test] diff --git a/src/match_runtime.rs b/src/match_runtime.rs index c2d9875..5e8bca0 100644 --- a/src/match_runtime.rs +++ b/src/match_runtime.rs @@ -40,12 +40,7 @@ impl MatchState { Self { elapsed_frames: 0, - players: (0..config - .players - .iter() - .map(|player| player.handle) - .max() - .map_or(0, |handle| handle + 1)) + players: (0..config.players.len()) .map(|_| PlayerMatchState { stocks_remaining, score: 0, @@ -122,10 +117,12 @@ mod tests { players: vec![ MatchPlayer { handle: 1, + controller_port: 3, fighter: FighterId::TestFighter, }, MatchPlayer { handle: 0, + controller_port: 0, fighter: FighterId::TestFighter, }, ], diff --git a/src/menus/match_config.rs b/src/menus/match_config.rs index b5e1308..bef11fd 100644 --- a/src/menus/match_config.rs +++ b/src/menus/match_config.rs @@ -65,7 +65,10 @@ impl MenuMatchConfig { let stage = self.stage.ok_or(MenuMatchConfigErrors::StageNotSelected)?; - for player in self.players.iter() { + let mut players = self.players.iter().collect::>(); + players.sort_unstable_by_key(|player| player.slot); + + for (handle, player) in players.into_iter().enumerate() { let fighter_id = player .fighter @@ -74,7 +77,8 @@ impl MenuMatchConfig { ))?; match_players.push(MatchPlayer { fighter: fighter_id, - handle: player.slot, + handle, + controller_port: player.slot, }); } @@ -102,4 +106,27 @@ mod tests { assert_eq!(menu.to_match_config().unwrap().rules, MatchRules::default()); } + + #[test] + fn sparse_controller_ports_get_dense_ggrs_handles() { + let menu = MenuMatchConfig { + stage: Some(StageId::TestStage), + players: vec![ + MenuMatchPlayerSlot { + slot: 3, + fighter: Some(FighterId::TestFighter), + }, + MenuMatchPlayerSlot { + slot: 0, + fighter: Some(FighterId::TestFighter), + }, + ], + }; + + let config = menu.to_match_config().unwrap(); + assert_eq!(config.players[0].handle, 0); + assert_eq!(config.players[0].controller_port, 0); + assert_eq!(config.players[1].handle, 1); + assert_eq!(config.players[1].controller_port, 3); + } } diff --git a/src/player.rs b/src/player.rs index 6323766..a49c631 100644 --- a/src/player.rs +++ b/src/player.rs @@ -10,5 +10,8 @@ use bevy_ggrs::prelude::*; #[derive(Default, Component)] #[require(Rollback, Transform)] pub struct Player { + /// Dense GGRS session index. pub handle: usize, + /// Port used for port-dependent gameplay such as respawn placement. + pub controller_port: usize, } diff --git a/src/replay.rs b/src/replay.rs index 1440b90..95367bb 100644 --- a/src/replay.rs +++ b/src/replay.rs @@ -17,7 +17,7 @@ use crate::{ }; const MAGIC: &[u8; 8] = b"SPRPLY01"; -pub const REPLAY_VERSION: u32 = 2; +pub const REPLAY_VERSION: u32 = 3; #[derive(Clone, Copy, Debug, Default, Eq, PartialEq, ValueEnum)] pub enum ReplayFormat { @@ -169,16 +169,7 @@ fn validate(replay: &Replay) -> Result<(), String> { if replay .frames .iter() - .any(|frame| { - frame.inputs.len() - != replay - .match_config - .players - .iter() - .map(|player| player.handle) - .max() - .map_or(0, |handle| handle + 1) - }) + .any(|frame| frame.inputs.len() != replay.match_config.players.len()) { return Err("replay frame input count does not match player count".into()); } @@ -194,9 +185,7 @@ impl Replay { .map(|player| player.handle) .collect(); handles.sort_unstable(); - handles.is_empty() - || handles.windows(2).any(|handles| handles[0] == handles[1]) - || handles.last() == Some(&usize::MAX) + handles.is_empty() || !handles.into_iter().eq(0..self.match_config.players.len()) } fn frame(&self, frame: i32) -> Option<&ReplayFrame> { @@ -385,6 +374,7 @@ mod tests { stage: StageId::TestStage, players: vec![MatchPlayer { handle: 0, + controller_port: 0, fighter: FighterId::TestFighter, }], rules: MatchRules::Timed { diff --git a/src/stage/debug.rs b/src/stage/debug.rs index e6a0625..651556f 100644 --- a/src/stage/debug.rs +++ b/src/stage/debug.rs @@ -1,8 +1,7 @@ use bevy::{color::palettes::css::RED, prelude::*}; use crate::{ - match_loading::MatchConfig, - stage::{ + match_loading::MatchConfig, math::{int::FGi32, vec3::FGVec3}, stage::{ line::StageCollision, manifest::{StageManifest, StageManifestRegistry}, }, @@ -42,5 +41,32 @@ pub fn debug_draw_blast_zones( 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); + gizmos.rect( + Vec3::new(center.x, center.y, 0.0), + size, + bevy::color::palettes::css::BLUE, + ); +} + +pub fn debug_draw_spawn_positions( + mut gizmos: Gizmos, + stage_registry: Res, + stage_manifests: Res>, + match_config: Res, +) { + let Some(stage_manifest_handle) = stage_registry.get(match_config.stage) else { + return; + }; + + let Some(stage_manifest) = stage_manifests.get(&stage_manifest_handle) else { + return; + }; + + for spawn_point in stage_manifest.spawn_points.iter() { + gizmos.cross(FGVec3::new(spawn_point.x, spawn_point.y, FGi32::ZERO).to_vec3(), 2.0, bevy::color::palettes::css::BLUE); + } + + for respawn_point in stage_manifest.respawn_points.iter() { + gizmos.cross(FGVec3::new(respawn_point.x, respawn_point.y, FGi32::ZERO).to_vec3(), 2.0, bevy::color::palettes::css::HOT_PINK); + } } diff --git a/src/stage/manifest.rs b/src/stage/manifest.rs index e1eb7ff..831f491 100644 --- a/src/stage/manifest.rs +++ b/src/stage/manifest.rs @@ -91,7 +91,9 @@ pub struct StageManifest { #[reflect(ignore)] pub spawn_points: Vec, - pub neutral_spawn_point_sets: Vec> + pub neutral_spawn_point_sets: Vec>, + #[reflect(ignore)] + pub respawn_points: Vec, } #[derive(Resource)] diff --git a/src/stage/mod.rs b/src/stage/mod.rs index 01a7190..1d60562 100644 --- a/src/stage/mod.rs +++ b/src/stage/mod.rs @@ -27,6 +27,9 @@ impl Plugin for StagePlugin { (debug::debug_draw_blast_zones .run_if(resource_exists::) .run_if(crate::debug_tools::blast_zones_enabled),), + (debug::debug_draw_spawn_positions + .run_if(resource_exists::) + .run_if(crate::debug_tools::spawn_positions_enabled),), ), ); }