Spread state context architecture (Fixes #18) (#30)

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

src/fighter/state/mod.rs

@@ -10,6 +10,7 @@ use crate::fighter::attack::{
     FighterAttackScriptAssets, FighterKnockbackVelocity, FighterPendingHitReaction,
     FighterStaleMoveQueue,
 };
+use crate::fighter::attributes::FighterAttributes;
 use crate::fighter::baked_animation::BakedFighterAnimations;
 use crate::fighter::ecb::FighterPreviousECB;
 use crate::fighter::manifest::FighterManifest;
@@ -47,22 +48,22 @@ macro_rules! fighter_states {
             pub fn name(&self) -> &'static str {
                 match self { $(Self::$variant(_) => <$ty>::NAME),* }
             }
-            pub fn check_interrupt(&self, ctx: &mut FighterStateContext) -> Option<FighterState> {
+            pub fn check_interrupt(&self, ctx: &mut InterruptContext) -> Option<FighterState> {
                 match self { $(Self::$variant(s) => s.check_interrupt(ctx)),* }
             }
 
-            pub fn update(&mut self, ctx: &mut FighterStateContext) {
+            pub fn update(&mut self, ctx: &mut UpdateContext) {
                 match self { $(Self::$variant(s) => s.update(ctx)),* }
             }
-            pub fn on_enter(&mut self, ctx: &mut FighterStateContext) {
+            pub fn on_enter(&mut self, ctx: &mut EnterContext) {
                 match self { $(Self::$variant(s) => s.on_enter(ctx)),* }
             }
 
-            pub fn on_exit(&mut self, ctx: &mut FighterStateContext) {
+            pub fn on_exit(&mut self, ctx: &mut ExitContext) {
                 match self { $(Self::$variant(s) => s.on_exit(ctx)),* }
             }
 
-            pub fn check_collision_interrupt(&mut self, ctx: &mut FighterStateContext) -> Option<FighterState> {
+            pub fn check_collision_interrupt(&mut self, ctx: &mut CollisionContext) -> Option<FighterState> {
                 match self { $(Self::$variant(s) => s.check_collision_interrupt(ctx)),* }
             }
         }
@@ -75,62 +76,108 @@ macro_rules! fighter_states {
 
 pub trait FighterStateImpl: Sized {
     const NAME: &'static str;
-    fn check_interrupt(&self, state_context: &mut FighterStateContext) -> Option<FighterState>;
+    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState>;
 
-    fn on_enter(&mut self, _state_context: &mut FighterStateContext) {}
-    fn on_exit(&mut self, _state_context: &mut FighterStateContext) {}
+    fn on_enter(&mut self, _state_context: &mut EnterContext) {}
+    fn on_exit(&mut self, _state_context: &mut ExitContext) {}
     fn name(&self) -> String {
         Self::NAME.to_owned()
     }
-    fn update(&mut self, _state_context: &mut FighterStateContext);
+    fn update(&mut self, _state_context: &mut UpdateContext);
 
     fn check_collision_interrupt(
         &mut self,
-        _state_context: &mut FighterStateContext,
+        _state_context: &mut CollisionContext,
     ) -> Option<FighterState> {
         None
     }
 }
 
-pub struct FighterStateContext<'a> {
-    pub translation: &'a mut FighterTranslation,
-    pub prev_translation: &'a mut FighterPreviousTranslation,
+pub struct AnimationStatus {
+    pub frame: u32,
+    pub finished: bool,
+}
+
+pub struct InterruptContext<'a> {
+    pub input: &'a FighterInput,
+    pub facing_direction: &'a mut FighterFacingDirection,
+    pub game_settings: &'a GameSettings,
+    pub fighter_attributes: &'a FighterAttributes,
+    pub animation: AnimationStatus,
+}
+
+impl InterruptContext<'_> {
+    pub fn get_current_animation_frame(&self) -> u32 {
+        self.animation.frame
+    }
+
+    pub fn is_current_animation_finished(&self) -> bool {
+        self.animation.finished
+    }
+}
+
+pub struct EnterContext<'a> {
     pub input: &'a mut FighterInput,
     pub hitboxes: &'a mut FighterHitboxes,
     pub velocity: &'a mut FighterVelocity,
     pub knockback_velocity: &'a mut FighterKnockbackVelocity,
     pub stale_move_queue: &'a mut FighterStaleMoveQueue,
-    pub ecb: &'a mut FighterECB,
-    pub prev_ecb: &'a mut FighterPreviousECB,
     pub facing_direction: &'a mut FighterFacingDirection,
-    pub game_settings: &'a GameSettings,
-    pub stage_collision: &'a StageCollision,
-    pub animations: &'a FighterAnimations,
     pub animation_frame: &'a mut FighterAnimationFrame,
-    pub baked_animations: &'a Assets<BakedFighterAnimations>,
-    pub attack_scripts: &'a Assets<FighterAttackScript>,
-    pub fighter_manifest: &'a FighterManifest,
+    pub fighter_attributes: &'a FighterAttributes,
     pub attack_script_assets: &'a FighterAttackScriptAssets,
 }
 
-impl FighterStateContext<'_> {
+impl EnterContext<'_> {
     pub fn play_animation(&mut self, kind: AnimKind, repeat: bool) {
         self.animation_frame.reset(kind, repeat);
     }
+}
 
+pub struct ExitContext<'a> {
+    pub hitboxes: &'a mut FighterHitboxes,
+}
+
+pub struct UpdateContext<'a> {
+    pub translation: &'a mut FighterTranslation,
+    pub prev_translation: &'a mut FighterPreviousTranslation,
+    pub input: &'a FighterInput,
+    pub hitboxes: &'a mut FighterHitboxes,
+    pub velocity: &'a mut FighterVelocity,
+    pub knockback_velocity: &'a mut FighterKnockbackVelocity,
+    pub game_settings: &'a GameSettings,
+    pub animation_frame: u32,
+    pub fighter_attributes: &'a FighterAttributes,
+    pub attack_scripts: &'a Assets<FighterAttackScript>,
+    pub attack_script_assets: &'a FighterAttackScriptAssets,
+}
+
+impl UpdateContext<'_> {
     pub fn get_current_animation_frame(&self) -> u32 {
-        self.animation_frame.frame
+        self.animation_frame
     }
+}
 
-    pub fn is_current_animation_finished(&self) -> bool {
-        let anims_data = self
-            .baked_animations
-            .get(&self.animations.baked)
-            .expect("Animation should exist");
-        anims_data
-            .frame_count(self.animation_frame.kind)
-            .expect("Current animation should have baked frames")
-            <= self.animation_frame.frame
+pub struct CollisionContext<'a> {
+    pub translation: &'a mut FighterTranslation,
+    pub prev_translation: &'a FighterPreviousTranslation,
+    pub velocity: &'a mut FighterVelocity,
+    pub ecb: &'a FighterECB,
+    pub prev_ecb: &'a FighterPreviousECB,
+    pub stage_collision: &'a StageCollision,
+}
+
+impl CollisionContext<'_> {
+    pub fn air_collide_with_stage(
+        &self,
+    ) -> Option<crate::fighter::collision::AirCollisionWithStageResult> {
+        crate::fighter::collision::air_collide_with_stage(
+            self.prev_translation,
+            self.translation,
+            self.prev_ecb,
+            self.ecb,
+            self.stage_collision,
+        )
     }
 }
 
@@ -159,43 +206,104 @@ pub struct FighterFrameQuery {
     pub velocity: &'static mut FighterVelocity,
     pub knockback_velocity: &'static mut FighterKnockbackVelocity,
     pub stale_move_queue: &'static mut FighterStaleMoveQueue,
-    pub ecb: &'static mut FighterECB,
-    pub prev_ecb: &'static mut FighterPreviousECB,
+    pub ecb: &'static FighterECB,
+    pub prev_ecb: &'static FighterPreviousECB,
     pub facing_direction: &'static mut FighterFacingDirection,
     pub animation_frame: &'static mut FighterAnimationFrame,
     pub fighter: &'static Fighter,
 }
 
 impl<'w, 's> FighterFrameQueryItem<'w, 's> {
-    fn context<'a>(
+    fn animation_status(
+        &self,
+        animations: &FighterAnimations,
+        baked_animations: &Assets<BakedFighterAnimations>,
+    ) -> AnimationStatus {
+        let baked = baked_animations
+            .get(&animations.baked)
+            .expect("Animation should exist");
+        let frame = self.animation_frame.frame;
+        let finished = baked
+            .frame_count(self.animation_frame.kind)
+            .expect("Current animation should have baked frames")
+            <= frame;
+        AnimationStatus { frame, finished }
+    }
+
+    fn interrupt_context<'a>(
         &'a mut self,
         game_settings: &'a GameSettings,
-        stage_collision: &'a StageCollision,
         animations: &'a FighterAnimations,
         baked_animations: &'a Assets<BakedFighterAnimations>,
-        attack_scripts: &'a Assets<FighterAttackScript>,
+        attributes: &'a FighterAttributes,
+    ) -> InterruptContext<'a> {
+        let animation = self.animation_status(animations, baked_animations);
+        InterruptContext {
+            input: &self.input,
+            facing_direction: &mut self.facing_direction,
+            game_settings,
+            fighter_attributes: attributes,
+            animation,
+        }
+    }
+
+    fn enter_context<'a>(
+        &'a mut self,
+        attributes: &'a FighterAttributes,
         attack_script_assets: &'a FighterAttackScriptAssets,
-        manifest: &'a FighterManifest,
-    ) -> FighterStateContext<'a> {
-        FighterStateContext {
-            translation: &mut self.translation,
-            prev_translation: &mut self.prev_translation,
+    ) -> EnterContext<'a> {
+        EnterContext {
             input: &mut self.input,
             hitboxes: &mut self.hitboxes,
             velocity: &mut self.velocity,
             knockback_velocity: &mut self.knockback_velocity,
             stale_move_queue: &mut self.stale_move_queue,
-            ecb: &mut self.ecb,
-            prev_ecb: &mut self.prev_ecb,
             facing_direction: &mut self.facing_direction,
-            game_settings,
-            stage_collision,
-            animations,
             animation_frame: &mut self.animation_frame,
-            baked_animations,
+            fighter_attributes: attributes,
+            attack_script_assets,
+        }
+    }
+
+    fn exit_context(&mut self) -> ExitContext<'_> {
+        ExitContext {
+            hitboxes: &mut self.hitboxes,
+        }
+    }
+
+    fn update_context<'a>(
+        &'a mut self,
+        game_settings: &'a GameSettings,
+        attributes: &'a FighterAttributes,
+        attack_scripts: &'a Assets<FighterAttackScript>,
+        attack_script_assets: &'a FighterAttackScriptAssets,
+    ) -> UpdateContext<'a> {
+        UpdateContext {
+            translation: &mut self.translation,
+            prev_translation: &mut self.prev_translation,
+            input: &self.input,
+            hitboxes: &mut self.hitboxes,
+            velocity: &mut self.velocity,
+            knockback_velocity: &mut self.knockback_velocity,
+            game_settings,
+            animation_frame: self.animation_frame.frame,
+            fighter_attributes: attributes,
             attack_scripts,
             attack_script_assets,
-            fighter_manifest: manifest,
+        }
+    }
+
+    fn collision_context<'a>(
+        &'a mut self,
+        stage_collision: &'a StageCollision,
+    ) -> CollisionContext<'a> {
+        CollisionContext {
+            translation: &mut self.translation,
+            prev_translation: &self.prev_translation,
+            velocity: &mut self.velocity,
+            ecb: &self.ecb,
+            prev_ecb: &self.prev_ecb,
+            stage_collision,
         }
     }
 }
@@ -214,9 +322,7 @@ pub struct StatefulFighterQuery {
 
 pub fn state_update_system(
     mut query: Query<StatefulFighterQuery>,
-    stage_collision: Res<StageCollision>,
     game_settings: Res<GameSettings>,
-    baked_animations: Res<Assets<BakedFighterAnimations>>,
     attack_scripts: Res<Assets<FighterAttackScript>>,
     manifests: Res<Assets<FighterManifest>>,
 ) {
@@ -224,7 +330,6 @@ pub fn state_update_system(
         let StatefulFighterQueryItem {
             mut state,
             mut frame,
-            animations,
             hitstop,
             ..
         } = fighter;
@@ -233,16 +338,14 @@ pub fn state_update_system(
             continue;
         }
 
-        let mut update_ctx = frame.context(
+        let manifest = manifests
+            .get(&fighter.fighter.manifest)
+            .expect("Fighter manifest should be valid");
+        let mut update_ctx = frame.update_context(
             &game_settings,
-            &stage_collision,
-            animations,
-            &baked_animations,
+            &manifest.attributes,
             &attack_scripts,
             &fighter.attack_script_assets,
-            &manifests
-                .get(&(fighter.fighter.manifest))
-                .expect("Fighter manifest should be valid"),
         );
         state.update(&mut update_ctx);
     }
@@ -251,24 +354,24 @@ pub fn state_update_system(
 fn transition_state(
     current: &mut FighterState,
     mut next: FighterState,
-    ctx: &mut FighterStateContext,
+    frame: &mut FighterFrameQueryItem,
+    attributes: &FighterAttributes,
+    attack_script_assets: &FighterAttackScriptAssets,
 ) {
     let old_name = current.name();
     let new_name = next.name();
 
-    current.on_exit(ctx);
-    next.on_enter(ctx);
+    current.on_exit(&mut frame.exit_context());
+    next.on_enter(&mut frame.enter_context(attributes, attack_script_assets));
     *current = next;
     info!("{} -> {}", old_name, new_name);
 }
 
 pub fn state_interrupt_system(
     mut query: Query<StatefulFighterQuery>,
-    stage_collision: Res<StageCollision>,
     game_settings: Res<GameSettings>,
     baked_animations: Res<Assets<BakedFighterAnimations>>,
     fighter_manifests: Res<Assets<FighterManifest>>,
-    attack_scripts: Res<Assets<FighterAttackScript>>,
 ) {
     for fighter in &mut query {
         let StatefulFighterQueryItem {
@@ -280,17 +383,9 @@ pub fn state_interrupt_system(
             mut pending_hit_reaction,
             mut hitstop,
         } = fighter;
-        let mut state_context = frame.context(
-            &game_settings,
-            &stage_collision,
-            animations,
-            &baked_animations,
-            &attack_scripts,
-            attack_script_assets,
-            fighter_manifests
-                .get(&fighter.manifest)
-                .expect("Fighter manifest should be valid"),
-        );
+        let manifest = fighter_manifests
+            .get(&fighter.manifest)
+            .expect("Fighter manifest should be valid");
 
         let new_state = if let Some(reaction) = pending_hit_reaction.take() {
             hitstop.remaining_frames = *reaction.hitstop_frames;
@@ -322,11 +417,22 @@ pub fn state_interrupt_system(
         } else if hitstop.remaining_frames > 0 {
             None
         } else {
-            state.check_interrupt(&mut state_context)
+            state.check_interrupt(&mut frame.interrupt_context(
+                &game_settings,
+                animations,
+                &baked_animations,
+                &manifest.attributes,
+            ))
         };
 
         if let Some(new_state) = new_state {
-            transition_state(&mut state, new_state, &mut state_context);
+            transition_state(
+                &mut state,
+                new_state,
+                &mut frame,
+                &manifest.attributes,
+                attack_script_assets,
+            );
         };
     }
 }
@@ -334,39 +440,34 @@ pub fn state_interrupt_system(
 pub fn state_collision_interrupt_system(
     mut query: Query<StatefulFighterQuery>,
     stage_collision: Res<StageCollision>,
-    game_settings: Res<GameSettings>,
-    baked_animations: Res<Assets<BakedFighterAnimations>>,
     fighter_manifests: Res<Assets<FighterManifest>>,
-    attack_scripts: Res<Assets<FighterAttackScript>>,
 ) {
     for fighter in &mut query {
         let StatefulFighterQueryItem {
             mut state,
             mut frame,
-            animations,
             fighter,
             attack_script_assets,
             hitstop,
             ..
         } = fighter;
-        let mut state_context = frame.context(
-            &game_settings,
-            &stage_collision,
-            animations,
-            &baked_animations,
-            &attack_scripts,
-            &attack_script_assets,
-            fighter_manifests
-                .get(&fighter.manifest)
-                .expect("Fighter manifest should be valid"),
-        );
-
         if hitstop.remaining_frames > 0 {
             continue;
         }
 
-        if let Some(new_state) = state.check_collision_interrupt(&mut state_context) {
-            transition_state(&mut state, new_state, &mut state_context);
+        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));
+        if let Some(new_state) = new_state {
+            transition_state(
+                &mut state,
+                new_state,
+                &mut frame,
+                &manifest.attributes,
+                &attack_script_assets,
+            );
         }
     }
 }