95 lines
3.0 KiB
Rust
95 lines
3.0 KiB
Rust
use std::time::Duration;
|
|
|
|
use bevy::prelude::*;
|
|
|
|
use super::{FighterStateContext, FighterStateImpl, ground, walk};
|
|
use crate::fighter::animation::AnimKind;
|
|
use crate::fighter::state::fall::FallState;
|
|
use crate::fighter::state::ground::{
|
|
GroundedMotionResult, GroundedStateCommon, grounded_movement_common_interrupts,
|
|
};
|
|
use crate::fighter::state::{FighterState, dash, turn};
|
|
|
|
#[derive(Debug, Clone, Hash)]
|
|
pub struct WaitState {
|
|
pub grounded_common: GroundedStateCommon,
|
|
}
|
|
|
|
impl FighterStateImpl for WaitState {
|
|
const NAME: &'static str = "Wait";
|
|
fn check_interrupt(&self, state_context: &mut FighterStateContext) -> Option<FighterState> {
|
|
if let Some(state) = ground::grounded_movement_standstill_common_interrupts(
|
|
state_context,
|
|
&self.grounded_common,
|
|
) {
|
|
// Prevent transitioning into myself
|
|
if let FighterState::Wait(_) = state {
|
|
None
|
|
} else {
|
|
Some(state)
|
|
}
|
|
} else if let Some(state) =
|
|
ground::grounded_movement_common_interrupts(state_context, &self.grounded_common)
|
|
{
|
|
Some(state)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn on_enter(&mut self, state_context: &mut super::FighterStateContext) {
|
|
state_context.play_animation(AnimKind::Wait, true);
|
|
}
|
|
|
|
fn update(&mut self, state_context: &mut super::FighterStateContext) {
|
|
let friction = if state_context.velocity.x.abs()
|
|
> state_context.fighter_manifest.attributes.max_walk_vel
|
|
{
|
|
state_context.fighter_manifest.attributes.ground_friction
|
|
* state_context
|
|
.game_settings
|
|
.fighter_common
|
|
.ground_friction_over_walk_speed_multiplier
|
|
} else {
|
|
state_context.fighter_manifest.attributes.ground_friction
|
|
};
|
|
|
|
let ground_velocity = state_context.velocity.x;
|
|
|
|
state_context.velocity.x += ground::apply_grounded_friction(friction, ground_velocity);
|
|
|
|
ground::apply_grounded_motion(
|
|
state_context.velocity,
|
|
state_context.translation,
|
|
state_context.prev_translation,
|
|
);
|
|
}
|
|
|
|
fn check_collision_interrupt(
|
|
&mut self,
|
|
state_context: &mut FighterStateContext,
|
|
) -> Option<FighterState> {
|
|
if let GroundedMotionResult::InAir =
|
|
ground::collide_with_stage_grounded(state_context, &mut self.grounded_common, false)
|
|
{
|
|
Some(FighterState::Fall(FallState))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn check_input(
|
|
state_context: &FighterStateContext,
|
|
ground_state_common: &GroundedStateCommon,
|
|
) -> Option<FighterState> {
|
|
let input_frame = state_context.input.get_last_frame();
|
|
|
|
if input_frame.movement.x.abs() < state_context.game_settings.input_common.stick_deadzone {
|
|
return Some(FighterState::Wait(WaitState {
|
|
grounded_common: ground_state_common.clone(),
|
|
}));
|
|
}
|
|
None
|
|
}
|