Add the ability to respawn and improve controller port mapping (#72)

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

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<StageManifestRegistry>,
+    stage_manifests: Res<Assets<StageManifest>>,
+    match_config: Res<MatchConfig>,
+    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;
+            }
+        }
+    }
+}

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::<FighterDamage>()
             .rollback_component_with_clone::<FighterPendingHitReaction>()
             .checksum_component_with_hash::<FighterPendingHitReaction>()
+            .rollback_component_with_copy::<FighterPendingRespawn>()
+            .checksum_component_with_hash::<FighterPendingRespawn>()
             .rollback_component_with_copy::<FighterHitstop>()
             .checksum_component_with_hash::<FighterHitstop>()
             .rollback_component_with_copy::<FighterKnockbackVelocity>()
@@ -281,6 +288,7 @@ pub struct FighterHitboxes(pub Option<FighterActiveAttack>);
 pub fn spawn_fighter(
     commands: &mut Commands,
     player_handle: usize,
+    controller_port: usize,
     spawn_position: FGVec2,
     manifest: Handle<FighterManifest>,
     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,

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<super::FighterState> {
+        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<super::FighterState> {
+        None
+    }
+    
+    fn surface_policy(&self) -> super::SurfacePolicy {
+        super::SurfacePolicy::Airborne(crate::fighter::surface::EcbLockPolicy::Clear)
+    }
+}

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<crate::fighter::collision::AirCollisionWithStageResult> {
         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<StageCollision>,
     fighter_manifests: Res<Assets<FighterManifest>>,
     game_settings: Res<GameSettings>,
+    match_config: Res<MatchConfig>,
+    mut match_state: ResMut<MatchState>,
+    stage_registry: Res<StageManifestRegistry>,
+    stage_manifests: Res<Assets<StageManifest>>,
 ) {
+    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,