131 lines
4.2 KiB
Rust
131 lines
4.2 KiB
Rust
//! Per-fighter input state: the current and previous frame, plus the buffered
|
|
//! commands (smash inputs and friends) that states query when deciding whether
|
|
//! to interrupt.
|
|
|
|
use std::ops::{Index, IndexMut};
|
|
|
|
use bevy::prelude::*;
|
|
use bevy_ggrs::{PlayerInputs, Rollback};
|
|
|
|
use crate::game_settings::GameSettings;
|
|
use crate::input::FighterInputFrame;
|
|
use crate::netcode::GGRSCfg;
|
|
use crate::player::Player;
|
|
|
|
struct FighterInputBufferedActions {}
|
|
|
|
pub enum FighterCommands {
|
|
SmashMoveLeft,
|
|
SmashMoveRight,
|
|
}
|
|
|
|
/// Frames of life remaining for each buffered command. Indexed by
|
|
/// [`FighterCommands`] so adding a command is a two-line change here.
|
|
#[derive(Default, Clone, Copy)]
|
|
pub struct FighterCommandLifetimes {
|
|
smash_move_left: u8,
|
|
smash_move_right: u8,
|
|
}
|
|
|
|
impl Index<FighterCommands> for FighterCommandLifetimes {
|
|
type Output = u8;
|
|
|
|
fn index(&self, command: FighterCommands) -> &Self::Output {
|
|
match command {
|
|
FighterCommands::SmashMoveLeft => &self.smash_move_left,
|
|
FighterCommands::SmashMoveRight => &self.smash_move_right,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl IndexMut<FighterCommands> for FighterCommandLifetimes {
|
|
fn index_mut(&mut self, command: FighterCommands) -> &mut Self::Output {
|
|
match command {
|
|
FighterCommands::SmashMoveLeft => &mut self.smash_move_left,
|
|
FighterCommands::SmashMoveRight => &mut self.smash_move_right,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Component, Default, Clone, Copy)]
|
|
#[require(Rollback)]
|
|
pub struct FighterInput {
|
|
command_lifetimes: FighterCommandLifetimes,
|
|
prev_frame: FighterInputFrame,
|
|
current_frame: FighterInputFrame,
|
|
frames_in_smash_move_deadzone: u8,
|
|
}
|
|
|
|
impl FighterInput {
|
|
pub fn get_last_frame(&self) -> FighterInputFrame {
|
|
self.current_frame
|
|
}
|
|
|
|
pub fn push_input_frame(&mut self, frame: FighterInputFrame) {
|
|
self.prev_frame = self.current_frame;
|
|
self.current_frame = frame;
|
|
}
|
|
|
|
pub fn clear_buffer(&mut self) {
|
|
self.command_lifetimes = FighterCommandLifetimes::default()
|
|
}
|
|
|
|
pub fn clear_command(&mut self, command: FighterCommands) {
|
|
self.command_lifetimes[command] = 0;
|
|
}
|
|
|
|
pub fn set_lifetime(&mut self, command: FighterCommands, lifetime: u8) {
|
|
self.command_lifetimes[command] = lifetime;
|
|
}
|
|
|
|
pub fn has_command(&self, command: FighterCommands) -> bool {
|
|
self.command_lifetimes[command] > 0
|
|
}
|
|
}
|
|
|
|
/// Turns this frame's rolled-back inputs into per-fighter [`FighterInput`]
|
|
/// state. Runs in `GameplaySet::Input`, before any state looks at it.
|
|
pub fn postprocess_input(
|
|
query: Query<(&mut FighterInput, &Player)>,
|
|
inputs: Res<PlayerInputs<GGRSCfg>>,
|
|
game_settings: Res<GameSettings>,
|
|
) {
|
|
for (mut input, player) in query {
|
|
input.push_input_frame(inputs[player.handle].0);
|
|
|
|
// Directional smash detection
|
|
let x_abs = input.current_frame.movement.x.abs();
|
|
|
|
let reset_deadzone = game_settings.input_common.smash_input_reset_axis_threshold;
|
|
let axis_threshold = game_settings.input_common.smash_input_axis_threshold;
|
|
let frame_threshold = game_settings.input_common.smash_input_frame_threshold;
|
|
|
|
if x_abs < reset_deadzone {
|
|
input.frames_in_smash_move_deadzone = 0xFE;
|
|
} else {
|
|
let prev_x_abs = input.prev_frame.movement.x.abs();
|
|
if prev_x_abs < reset_deadzone
|
|
|| input.prev_frame.movement.x.signum() != input.current_frame.movement.x.signum()
|
|
{
|
|
input.frames_in_smash_move_deadzone = 0;
|
|
} else {
|
|
input.frames_in_smash_move_deadzone += 1;
|
|
}
|
|
}
|
|
|
|
if x_abs >= axis_threshold && input.frames_in_smash_move_deadzone <= frame_threshold {
|
|
input.clear_command(FighterCommands::SmashMoveLeft);
|
|
input.clear_command(FighterCommands::SmashMoveRight);
|
|
|
|
let command_to_set = if input.current_frame.movement.x > 0.0 {
|
|
FighterCommands::SmashMoveRight
|
|
} else {
|
|
FighterCommands::SmashMoveLeft
|
|
};
|
|
input.set_lifetime(command_to_set, game_settings.input_common.input_buffer_size);
|
|
|
|
if input.current_frame.movement.x > 0.0 {}
|
|
}
|
|
}
|
|
}
|