Implement NAir and initial work on aerials

2026-09-29 11:42:26 +02:00
parent b9611c1b42
commit d2d00ed7bb
8 changed files with 171 additions and 14 deletions
@@ -0,0 +1,124 @@
+use bevy::log::error;
+
+use crate::fighter::{
+    FighterId, attack::{AttackKind, FighterAttackScriptAssets, update_active_hitbox_list}, state::{
+        CollisionContext, EnterContext, ExitContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, fall::FallState, wait::WaitState,
+    },
+};
+
+#[derive(Clone, Debug, Hash)]
+pub struct AirAttackState {
+    pub attack_kind: AttackKind,
+    pub airborne_state_common: AirborneStateCommon
+}
+
+impl FighterStateImpl for AirAttackState {
+    const NAME: &'static str = "AirAttack";
+
+    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
+        if state_context.is_current_animation_finished() {
+            Some(FighterState::Fall(FallState::new(self.airborne_state_common)))
+        } else {
+            None
+        }
+    }
+
+    fn update(&mut self, state_context: &mut UpdateContext) {
+        let animation_frame = state_context.get_current_animation_frame();
+        let script = state_context
+            .attack_scripts
+            .get(&state_context.attack_script_assets.scripts[&self.attack_kind]);
+        if let Some(script) = script {
+            update_active_hitbox_list(
+                script,
+                &mut state_context
+                    .hitboxes
+                    .0
+                    .as_mut()
+                    .expect("ground attack must have active hitboxes")
+                    .active_hitboxes,
+                animation_frame,
+            );
+        }
+
+        air::update_standard_motion(state_context, &mut self.airborne_state_common);
+    }
+
+    fn on_enter(&mut self, state_context: &mut EnterContext) {
+        state_context.play_animation(self.attack_kind.get_animation(), false);
+        let script = state_context.attack_script_assets.scripts[&self.attack_kind].clone();
+        state_context.hitboxes.0 = Some(crate::fighter::FighterActiveAttack {
+            kind: self.attack_kind,
+            script,
+            active_hitboxes: Vec::new(),
+            solved_hitboxes: Vec::new(),
+            hit_fighters: Vec::new(),
+            stalled: false,
+        });
+    }
+
+    fn on_exit(&mut self, state_context: &mut ExitContext) {
+        state_context.hitboxes.0 = None;
+    }
+
+    fn check_collision_interrupt(
+        &mut self,
+        state_context: &mut CollisionContext,
+    ) -> Option<FighterState> {
+        air::collision_interrupt(
+            state_context,
+            crate::fighter::state::land::LandingType::Normal,
+            false,
+        )
+    }
+
+    fn is_visually_grounded<'a>(&'a self) -> bool {
+        false
+    }
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum AirAttackStateCreateError {
+    #[error("Attack script: {attack:?} not found")]
+    AttackScriptNotFound{attack: AttackKind},
+}
+
+impl AirAttackState {
+    pub fn create(attack_kind: AttackKind, attack_script_assets: &FighterAttackScriptAssets, airborne_state_common: &AirborneStateCommon) -> Result<Self, AirAttackStateCreateError> {
+        if attack_script_assets.scripts.contains_key(&attack_kind) {
+            Ok(AirAttackState {
+                airborne_state_common: airborne_state_common.clone(),
+                attack_kind
+            })
+        } else {
+            Err(AirAttackStateCreateError::AttackScriptNotFound { attack: attack_kind })
+        }
+    }
+
+}
+
+
+pub fn check_interrupt(state_context: &InterruptContext, airborne_state_common: &AirborneStateCommon) -> Option<FighterState> {
+    if state_context
+        .input
+        .has_command(crate::input::FighterCommands::Attack)
+    {
+        let attack_kind = state_context
+            .input
+            .get_attack_command_type()
+            .to_attack_kind_airborne(state_context.facing_direction);
+        let state = AirAttackState::create(attack_kind, state_context.attack_script_assets, airborne_state_common);
+
+        match state {
+            Ok(state) => {
+                Some(FighterState::AirAttack(state))
+            },
+            Err(create_error) => {
+                error!("{}", create_error);
+                None
+            },
+        }
+    } else {
+        None
+    }
+}