584 lines
18 KiB
Rust
584 lines
18 KiB
Rust
use std::error;
|
|
|
|
use bevy_derive::{Deref, DerefMut};
|
|
use bevy_ecs::system::Resource;
|
|
use bevy_input::{keyboard::KeyCode, mouse::MouseButton};
|
|
#[cfg(feature = "inspector-egui")]
|
|
use bevy_inspector_egui::prelude::*;
|
|
#[cfg(all(feature = "reflect", feature = "serialize"))]
|
|
use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
|
|
use bevy_utils::HashMap;
|
|
use log::warn;
|
|
#[cfg(feature = "serialize")]
|
|
use serde::{Deserialize, Serialize};
|
|
use std::mem::discriminant;
|
|
use strum::IntoEnumIterator;
|
|
use strum_macros::EnumIter;
|
|
#[cfg(feature = "reflect")]
|
|
use {bevy_ecs::prelude::ReflectResource, bevy_reflect::Reflect};
|
|
|
|
use crate::{common_traits_conditions, hashmap};
|
|
|
|
/// Validate that all enum variants are in the hash map
|
|
pub fn validate_hash_map<K, V>(hash_map: &HashMap<K, V>) -> bool
|
|
where
|
|
K: Eq + std::hash::Hash + Copy + IntoEnumIterator,
|
|
K::Iterator: Iterator<Item = K>,
|
|
{
|
|
let all_keys = K::iter().collect::<Vec<_>>();
|
|
if hash_map.len() != all_keys.len() {
|
|
return false;
|
|
}
|
|
|
|
for key in all_keys {
|
|
if !hash_map.contains_key(&key) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
true
|
|
}
|
|
|
|
common_traits_conditions! {
|
|
/// Struct that contains user's inputs corresponding to actions
|
|
#[derive(Debug, PartialEq, Clone, Deref, DerefMut)]
|
|
pub struct Inputs(HashMap<Action, InputValue>);
|
|
|
|
/// Resource that contains current user inputs
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub struct PlayerInputs {
|
|
current: Inputs,
|
|
previous: Inputs,
|
|
}
|
|
}
|
|
|
|
impl Default for PlayerInputs {
|
|
fn default() -> Self {
|
|
PlayerInputs {
|
|
current: Inputs(
|
|
Action::iter()
|
|
.map(|action| (action, InputValue::Empty))
|
|
.collect(),
|
|
),
|
|
previous: Inputs(
|
|
Action::iter()
|
|
.map(|action| (action, InputValue::Empty))
|
|
.collect(),
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PlayerInputs {
|
|
/// Returns current input value for action
|
|
///
|
|
/// in any case faster that `get_many` method
|
|
pub fn get(&self, action: Action) -> InputValue {
|
|
// SAFETY: action is always valid
|
|
// because we iterate over all actions in `default` method
|
|
*self.current.get(&action).unwrap()
|
|
}
|
|
|
|
/// Returns current input values for actions
|
|
pub fn get_many(&self, actions: Vec<Action>) -> Vec<InputValue> {
|
|
// SAFETY: action is always valid
|
|
// because we iterate over all actions in `default` method
|
|
actions
|
|
.iter()
|
|
.map(|action| *self.current.get(action).unwrap())
|
|
.collect()
|
|
}
|
|
|
|
/// Returns `true` if current `InputValue` has become `InputValue::Boolean(true)` in this frame
|
|
/// If input has not same type as `InputValue` on previous frame call `panic`
|
|
pub fn just_pressed(&self, action: Action) -> bool {
|
|
// SAFETY: action is always valid
|
|
// because we iterate over all actions in `default` method
|
|
if let InputValue::Boolean(current) = *self.current.get(&action).unwrap() {
|
|
if let InputValue::Boolean(previous) = *self.previous.get(&action).unwrap() {
|
|
return current && !previous;
|
|
}
|
|
panic!("Previous input is not boolean");
|
|
}
|
|
panic!("This input is not boolean")
|
|
}
|
|
|
|
/// Returns `true` if current `InputValue` has become `InputValue::Boolean(true)` in this frame
|
|
/// If input has not same type as `InputValue` on previous frame return `Error()`
|
|
pub fn get_just_pressed(&self, action: Action) -> Result<bool, Box<dyn error::Error>> {
|
|
// SAFETY: action is always valid
|
|
// because we iterate over all actions in `default` method
|
|
if let InputValue::Boolean(current) = *self.current.get(&action).unwrap() {
|
|
if let InputValue::Boolean(previous) = *self.previous.get(&action).unwrap() {
|
|
return Ok(current && !previous);
|
|
}
|
|
return Err("Previous input is not boolean".into());
|
|
}
|
|
Err("This input is not boolean".into())
|
|
}
|
|
|
|
/// Set input value to new
|
|
pub fn forced_set(&mut self, action: Action, value: impl Into<InputValue>) {
|
|
// SAFETY: action is always valid
|
|
// because we iterate over all actions in `default` method
|
|
let current_input = self.current.get_mut(&action).unwrap();
|
|
*self.previous.get_mut(&action).unwrap() = *current_input;
|
|
*current_input = value.into();
|
|
}
|
|
|
|
/// Set input value to new
|
|
/// if it is not the same InputValue type return `Error()`
|
|
pub fn set(
|
|
&mut self,
|
|
action: Action,
|
|
value: impl Into<InputValue>,
|
|
) -> Result<(), Box<dyn error::Error>> {
|
|
// SAFETY: action is always valid
|
|
// because we iterate over all actions in `default` method
|
|
let current_input = self.current.get_mut(&action).unwrap();
|
|
let previos_input = self.previous.get_mut(&action).unwrap();
|
|
|
|
// check if enum type is the same ignoring value
|
|
if discriminant(current_input) == discriminant(previos_input) {
|
|
*previos_input = *current_input;
|
|
*current_input = value.into();
|
|
Ok(())
|
|
} else {
|
|
Err("Input type is not the same".into())
|
|
}
|
|
}
|
|
|
|
/// Update current inputs
|
|
pub fn forced_update(&mut self, inputs: Inputs) {
|
|
*self.previous = self.current.clone().0;
|
|
*self.current = inputs.0;
|
|
}
|
|
|
|
/// Update current inputs
|
|
/// if any input is not the same InputValue type return `Error()`
|
|
/// ! remember that it work safely but slow
|
|
pub fn update(&mut self, inputs: Inputs) -> Result<(), Box<dyn error::Error>> {
|
|
// SAFETY: action is always valid
|
|
// because we iterate over all actions in `default` method
|
|
for (action, value) in inputs.0.iter() {
|
|
let current_input = self.current.get_mut(action).unwrap();
|
|
let previos_input = self.previous.get_mut(action).unwrap();
|
|
|
|
// check if enum type is not the same ignoring value
|
|
if discriminant(current_input) != discriminant(previos_input) {
|
|
return Err("Input type is not the same".into());
|
|
}
|
|
*previos_input = *current_input;
|
|
*current_input = *value;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
common_traits_conditions! {
|
|
// TODO: it must be a trait
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub enum GameState {
|
|
LevelEditor,
|
|
InGame,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub enum InputType {
|
|
Keyboard(KeyCode),
|
|
Mouse(MouseInput),
|
|
// TODO: Gamepad(GamepadButtonType),
|
|
// TODO: Touch screen
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub enum MouseInput {
|
|
Button(MouseButton),
|
|
Axis(AxisName),
|
|
Wheel(AxisName)
|
|
// TODO: CursorPosition
|
|
// TODO: TouchPad inputs
|
|
}
|
|
|
|
/// Name of axis
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub enum AxisName {
|
|
Horizontal,
|
|
Vertical,
|
|
}
|
|
|
|
/// Represents a binding that can be changed by the player
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub enum OptionsMode {
|
|
/// Represents a binding that cannot be changed as it is crucial to the game logic
|
|
Immutable,
|
|
/// Represents a binding that the player can customize
|
|
Customizable,
|
|
}
|
|
|
|
/// Represents the manner in which input is registered
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub enum ActivationMode {
|
|
/// Action is triggered when the button is pressed
|
|
Hold,
|
|
/// Action is triggered when the button is pressed
|
|
/// and cannot be triggered again until the button is released
|
|
/// you don't need to release all buttons in chord
|
|
/// you can release only last pressed button
|
|
Tap,
|
|
}
|
|
|
|
pub struct ActivationOptions {
|
|
/// Manner in which input is registered
|
|
pub mode: ActivationMode,
|
|
/// Possibility to change this activation mode
|
|
pub option: OptionsMode,
|
|
/// Delay between activation
|
|
pub delay: f32,
|
|
}
|
|
}
|
|
|
|
impl Default for ActivationOptions {
|
|
fn default() -> Self {
|
|
Self {
|
|
mode: ActivationMode::Tap, // Because it is more safe
|
|
option: OptionsMode::Immutable,
|
|
delay: 0.05, // 20 times per second; 14 - world record?
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ActivationOptions {
|
|
pub fn new(mode: ActivationMode, option: OptionsMode) -> Self {
|
|
Self {
|
|
mode,
|
|
option,
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
pub fn with_delay(mut self, delay: f32) -> Self {
|
|
self.delay = delay;
|
|
self
|
|
}
|
|
}
|
|
|
|
common_traits_conditions! {
|
|
/// Represents a combination of buttons that triggers an action
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub enum ButtonCombination {
|
|
/// Single button press
|
|
Single(InputType),
|
|
/// Chord is a combination of buttons that must be pressed at the same time
|
|
Chord(Vec<InputType>),
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub enum BindingCondition {
|
|
/// During specific game state
|
|
InGameState(GameState),
|
|
/// Binding is active only if player is in pause menu
|
|
DuringPauseMenu(bool),
|
|
/// Binding is active only if player types text
|
|
ListeningForText(bool),
|
|
}
|
|
|
|
// TODO: it is just plug, it must be a trait
|
|
/// Actions that can be performed by player
|
|
#[derive(PartialEq, Eq, Hash, Clone, Copy, Debug, EnumIter)]
|
|
pub enum Action {
|
|
/// Move forward
|
|
LeverEditorForward,
|
|
/// Move backward
|
|
LevelEditorBackward,
|
|
/// Move left
|
|
LevelEditorLeft,
|
|
/// Move right
|
|
LevelEditorRight,
|
|
LevelEditorFly,
|
|
}
|
|
|
|
/// Binding is a combination of buttons that triggers action
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub struct Binding {
|
|
pub input: ButtonCombination,
|
|
pub conditions: Vec<BindingCondition>,
|
|
}
|
|
}
|
|
|
|
impl From<ButtonCombination> for Binding {
|
|
fn from(input: ButtonCombination) -> Self {
|
|
Binding {
|
|
input,
|
|
conditions: Vec::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Binding {
|
|
pub fn new(input: ButtonCombination) -> Self {
|
|
Self {
|
|
input,
|
|
conditions: Vec::new(),
|
|
}
|
|
}
|
|
|
|
pub fn with_condition(mut self, condition: BindingCondition) -> Self {
|
|
self.conditions.push(condition);
|
|
self
|
|
}
|
|
}
|
|
|
|
common_traits_conditions! {
|
|
/// Input value that can be used in game logic
|
|
#[derive(Default, Clone, Copy, PartialEq, Debug)]
|
|
pub enum InputValue {
|
|
#[default]
|
|
Empty,
|
|
Boolean(bool),
|
|
Float(f32),
|
|
}
|
|
}
|
|
|
|
impl From<bool> for InputValue {
|
|
fn from(value: bool) -> Self {
|
|
InputValue::Boolean(value)
|
|
}
|
|
}
|
|
|
|
impl From<f32> for InputValue {
|
|
fn from(value: f32) -> Self {
|
|
InputValue::Float(value)
|
|
}
|
|
}
|
|
|
|
impl From<InputValue> for bool {
|
|
fn from(value: InputValue) -> Self {
|
|
match value {
|
|
InputValue::Boolean(value) => value,
|
|
_ => panic!("InputValue is not boolean"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<InputValue> for f32 {
|
|
fn from(value: InputValue) -> Self {
|
|
match value {
|
|
InputValue::Float(value) => value,
|
|
_ => panic!("InputValue is not float"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl InputValue {
|
|
pub fn is_empty(&self) -> bool {
|
|
matches!(self, InputValue::Empty)
|
|
}
|
|
|
|
pub fn is_boolean(&self) -> bool {
|
|
matches!(self, InputValue::Boolean(_))
|
|
}
|
|
|
|
pub fn is_float(&self) -> bool {
|
|
matches!(self, InputValue::Float(_))
|
|
}
|
|
|
|
pub fn as_boolean(&self) -> bool {
|
|
match self {
|
|
InputValue::Boolean(value) => *value,
|
|
InputValue::Float(value) => *value > 0.0,
|
|
InputValue::Empty => false,
|
|
}
|
|
}
|
|
}
|
|
|
|
common_traits_conditions! {
|
|
pub struct Bindings {
|
|
/// List of bindings for action
|
|
list: Vec<Binding>,
|
|
/// Possibility to change this binding
|
|
options: OptionsMode,
|
|
}
|
|
}
|
|
|
|
impl Default for Bindings {
|
|
fn default() -> Self {
|
|
Self {
|
|
list: Vec::new(),
|
|
options: OptionsMode::Immutable,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Bindings {
|
|
pub fn new(bindings: Vec<Binding>, options: OptionsMode) -> Self {
|
|
Self {
|
|
list: bindings,
|
|
options,
|
|
}
|
|
}
|
|
|
|
pub fn push(&mut self, binding: Binding) {
|
|
if self.options == OptionsMode::Immutable {
|
|
warn!("You try to push binding to immutable bindings");
|
|
return;
|
|
}
|
|
self.list.push(binding);
|
|
}
|
|
|
|
pub fn clear(&mut self) {
|
|
if self.options == OptionsMode::Immutable {
|
|
warn!("You try to clear immutable bindings");
|
|
return;
|
|
}
|
|
self.list.clear();
|
|
}
|
|
|
|
pub fn retain<F>(&mut self, f: F)
|
|
where
|
|
F: FnMut(&Binding) -> bool,
|
|
{
|
|
if self.options == OptionsMode::Immutable {
|
|
warn!("You try to retain immutable bindings");
|
|
return;
|
|
}
|
|
self.list.retain(f);
|
|
}
|
|
|
|
pub fn iter(&self) -> impl Iterator<Item = &Binding> {
|
|
self.list.iter()
|
|
}
|
|
|
|
pub fn iter_mut(
|
|
&mut self,
|
|
) -> Result<impl Iterator<Item = &mut Binding>, Box<dyn error::Error>> {
|
|
if self.options == OptionsMode::Immutable {
|
|
warn!("You try to iterate over immutable bindings");
|
|
return Err("You try to iterate over immutable bindings".into());
|
|
}
|
|
Ok(self.list.iter_mut())
|
|
}
|
|
|
|
pub fn is_customizable(&self) -> bool {
|
|
self.options == OptionsMode::Customizable
|
|
}
|
|
|
|
pub fn is_immutable(&self) -> bool {
|
|
self.options == OptionsMode::Immutable
|
|
}
|
|
}
|
|
|
|
common_traits_conditions! {
|
|
/// Contains all bindings for action
|
|
/// and different activation options
|
|
#[derive(Default)]
|
|
pub struct BindingConfig {
|
|
pub bindings: Bindings,
|
|
#[cfg_attr(feature = "serialize", serde(skip))]
|
|
pub activation: ActivationOptions,
|
|
}
|
|
}
|
|
|
|
impl BindingConfig {
|
|
pub fn new(bindings: Bindings, activation: ActivationOptions) -> Self {
|
|
Self {
|
|
bindings,
|
|
activation,
|
|
}
|
|
}
|
|
}
|
|
|
|
common_traits_conditions! {
|
|
/// Contains all bindings for actions
|
|
#[derive(Resource)]
|
|
#[cfg_attr(feature = "reflect", reflect(Resource))]
|
|
// TODO: Add delay for input
|
|
pub struct Controls(HashMap<Action, BindingConfig>); // TODO: change HashMap to Vec for faster iteration
|
|
}
|
|
|
|
impl Default for Controls {
|
|
fn default() -> Self {
|
|
// TODO: default must create empty controls or fill empty / default BindingConfig on any actions
|
|
let controls = Self(hashmap! {
|
|
Action::LeverEditorForward => BindingConfig::new(
|
|
Bindings::new(
|
|
vec![Binding::from(ButtonCombination::Single(InputType::Keyboard(KeyCode::W))).with_condition(BindingCondition::InGameState(GameState::LevelEditor))],
|
|
OptionsMode::Customizable,
|
|
),
|
|
ActivationOptions::new(ActivationMode::Hold, OptionsMode::Immutable),
|
|
),
|
|
Action::LevelEditorBackward => BindingConfig::new(
|
|
Bindings::new(
|
|
vec![Binding::from(ButtonCombination::Single(InputType::Keyboard(KeyCode::S))).with_condition(BindingCondition::InGameState(GameState::LevelEditor))],
|
|
OptionsMode::Customizable,
|
|
),
|
|
ActivationOptions::new(ActivationMode::Hold, OptionsMode::Immutable),
|
|
),
|
|
Action::LevelEditorLeft => BindingConfig::new(
|
|
Bindings::new(
|
|
vec![Binding::from(ButtonCombination::Single(InputType::Keyboard(KeyCode::A))).with_condition(BindingCondition::InGameState(GameState::LevelEditor))],
|
|
OptionsMode::Customizable,
|
|
),
|
|
ActivationOptions::new(ActivationMode::Hold, OptionsMode::Immutable),
|
|
),
|
|
Action::LevelEditorRight => BindingConfig::new(
|
|
Bindings::new(
|
|
vec![Binding::from(ButtonCombination::Single(InputType::Keyboard(KeyCode::D))).with_condition(BindingCondition::InGameState(GameState::LevelEditor))],
|
|
OptionsMode::Customizable,
|
|
),
|
|
ActivationOptions::new(ActivationMode::Hold, OptionsMode::Immutable),
|
|
),
|
|
Action::LevelEditorFly => BindingConfig::new(
|
|
Bindings::new(
|
|
vec![Binding::from(ButtonCombination::Single(InputType::Keyboard(KeyCode::Space))).with_condition(BindingCondition::InGameState(GameState::LevelEditor))],
|
|
OptionsMode::Customizable,
|
|
),
|
|
ActivationOptions::new(ActivationMode::Hold, OptionsMode::Customizable),
|
|
)
|
|
});
|
|
|
|
// If you see this error, you may add new action in menu_actions
|
|
// or make sure that you have only one MenuAction with the same name in the MenuActions
|
|
assert!(validate_hash_map(&controls.0));
|
|
|
|
controls
|
|
}
|
|
}
|
|
|
|
impl Controls {
|
|
/// Returns bindings for action
|
|
pub fn get(&self, action: Action) -> Option<&BindingConfig> {
|
|
self.0.get(&action)
|
|
}
|
|
|
|
/// Push new binding for action
|
|
pub fn push(&mut self, action: Action, binding: Binding) {
|
|
// TODO: warning if config is not exist yet
|
|
self.0
|
|
.entry(action)
|
|
.or_insert_with(BindingConfig::default)
|
|
.bindings
|
|
.push(binding);
|
|
}
|
|
|
|
/// Remove all bindings for action
|
|
pub fn remove(&mut self, action: Action) {
|
|
// TODO: warning if config is not exist yet
|
|
self.0
|
|
.entry(action)
|
|
.or_insert_with(BindingConfig::default)
|
|
.bindings
|
|
.clear();
|
|
}
|
|
|
|
pub fn remove_binding(&mut self, action: Action, binding: Binding) {
|
|
if let Some(config) = self.0.get_mut(&action) {
|
|
config.bindings.retain(|b| *b == binding);
|
|
}
|
|
}
|
|
|
|
pub fn iter(&self) -> impl Iterator<Item = (&Action, &BindingConfig)> {
|
|
self.0.iter()
|
|
}
|
|
}
|