142 lines
3.6 KiB
Rust
142 lines
3.6 KiB
Rust
use std::any::{Any, TypeId};
|
|
use std::collections::HashMap;
|
|
|
|
use crate::world::World;
|
|
|
|
pub trait StateAgent {}
|
|
|
|
pub trait State: Any
|
|
{
|
|
fn get_state_name(&self) -> &'static str;
|
|
fn on_state_enter(&mut self, world: &mut World) {}
|
|
fn on_state_exit(&mut self, world: &mut World) {}
|
|
fn on_state_update(&mut self, world: &mut World, delta: f32) {}
|
|
fn on_state_physics_update(&mut self, world: &mut World, delta: f32) {}
|
|
}
|
|
|
|
impl dyn State
|
|
{
|
|
fn dyn_type_id(&self) -> std::any::TypeId
|
|
{
|
|
Any::type_id(self)
|
|
}
|
|
}
|
|
|
|
pub struct StateTransition
|
|
{
|
|
to_state_id: TypeId,
|
|
condition: Box<dyn Fn(&World) -> bool>,
|
|
}
|
|
|
|
pub struct StateMachine
|
|
{
|
|
state_transitions: HashMap<TypeId, Vec<StateTransition>>,
|
|
current_state_id: TypeId,
|
|
states: HashMap<TypeId, Box<dyn State>>,
|
|
pub time_in_state: f32,
|
|
}
|
|
|
|
impl StateMachine
|
|
{
|
|
pub fn new(enter_state: Box<dyn State>) -> Self
|
|
{
|
|
let state_id = enter_state.dyn_type_id();
|
|
let mut states = HashMap::new();
|
|
states.insert(state_id, enter_state);
|
|
|
|
Self {
|
|
state_transitions: HashMap::new(),
|
|
current_state_id: state_id,
|
|
states,
|
|
time_in_state: 0.0,
|
|
}
|
|
}
|
|
|
|
pub fn update(&mut self, world: &mut World, delta: f32)
|
|
{
|
|
if let Some(next_state_id) = self.get_transition_state_id(world)
|
|
{
|
|
self.time_in_state = 0.0;
|
|
self.transition_to(world, next_state_id);
|
|
}
|
|
|
|
if let Some(current_state) = self.states.get_mut(&self.current_state_id)
|
|
{
|
|
current_state.on_state_update(world, delta);
|
|
}
|
|
|
|
self.time_in_state += delta;
|
|
}
|
|
|
|
fn get_transition_state_id(&self, world: &World) -> Option<TypeId>
|
|
{
|
|
if let Some(transitions) = self.state_transitions.get(&self.current_state_id)
|
|
{
|
|
for transition in transitions
|
|
{
|
|
if (transition.condition)(world)
|
|
{
|
|
return Some(transition.to_state_id);
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn transition_to(&mut self, world: &mut World, new_state_id: TypeId)
|
|
{
|
|
if let Some(current_state) = self.states.get_mut(&self.current_state_id)
|
|
{
|
|
current_state.on_state_exit(world);
|
|
}
|
|
|
|
self.current_state_id = new_state_id;
|
|
|
|
if let Some(new_state) = self.states.get_mut(&self.current_state_id)
|
|
{
|
|
new_state.on_state_enter(world);
|
|
}
|
|
}
|
|
|
|
pub fn get_current_state(&self) -> Option<&dyn State>
|
|
{
|
|
self.states.get(&self.current_state_id).map(|b| b.as_ref())
|
|
}
|
|
|
|
pub fn get_current_state_mut(&mut self) -> Option<&mut dyn State>
|
|
{
|
|
self.states
|
|
.get_mut(&self.current_state_id)
|
|
.map(|b| b.as_mut())
|
|
}
|
|
|
|
pub fn add_state<T: State + 'static>(&mut self, state: T)
|
|
{
|
|
let state_id = TypeId::of::<T>();
|
|
self.states.insert(state_id, Box::new(state));
|
|
}
|
|
|
|
pub fn add_transition<TFrom: State + 'static, TTo: State + 'static>(
|
|
&mut self,
|
|
condition: impl Fn(&World) -> bool + 'static,
|
|
)
|
|
{
|
|
let from_id = TypeId::of::<TFrom>();
|
|
let to_id = TypeId::of::<TTo>();
|
|
|
|
let transitions = self.state_transitions.entry(from_id).or_default();
|
|
transitions.push(StateTransition {
|
|
to_state_id: to_id,
|
|
condition: Box::new(condition),
|
|
});
|
|
}
|
|
|
|
pub fn get_available_transitions_count(&self) -> usize
|
|
{
|
|
self.state_transitions
|
|
.get(&self.current_state_id)
|
|
.map(|transitions| transitions.len())
|
|
.unwrap_or(0)
|
|
}
|
|
}
|