use ggez::event::EventHandler;
use ggez::input::keyboard::{KeyCode, KeyMods};
use ggez::input::mouse::MouseButton;
use ggez::{graphics, Context, GameResult};
pub enum Trans {
None,
Push(Box<dyn State>),
Switch(Box<dyn State>),
Pop,
}
pub enum Event {
MouseEvent(MouseEvent),
KeyEvent(KeyEvent),
WindowEvent(WindowEvent),
}
pub enum MouseEvent {
MouseMotionEvent { x: f32, y: f32, dx: f32, dy: f32 },
MouseButtonDownEvent { button: MouseButton, x: f32, y: f32 },
MouseButtonUpEvent { button: MouseButton, x: f32, y: f32 },
MouseWheelEvent { x: f32, y: f32 },
}
pub enum KeyEvent {
KeyDownEvent {
keycode: KeyCode,
keymods: KeyMods,
repeat: bool,
},
KeyUpEvent {
keycode: KeyCode,
keymods: KeyMods,
},
}
pub enum WindowEvent {
FocusEvent { gained: bool },
ResizeEvent { width: f32, height: f32 },
}
pub trait State {
fn on_start(&mut self, ctx: &mut Context) -> GameResult;
fn update(&mut self, ctx: &mut Context) -> GameResult<Trans>;
fn handle_event(&mut self, ctx: &mut Context, event: Event) -> GameResult<Trans>;
}
pub struct StateManager {
states: Vec<Box<dyn State>>,
}
impl StateManager {
pub fn new(ctx: &mut Context, mut current_state: Box<dyn State>) -> Self {
let mut states = Vec::new();
current_state.on_start(ctx).unwrap();
states.push(current_state);
graphics::clear(ctx, graphics::WHITE);
Self { states }
}
fn handle_transform(&mut self, ctx: &mut Context, transform: Trans) {
match transform {
Trans::None => {}
Trans::Pop => {
self.states.pop();
}
Trans::Push(mut state) => {
state.on_start(ctx).unwrap();
self.states.push(state);
}
Trans::Switch(mut state) => {
self.states.pop();
state.on_start(ctx).unwrap();
self.states.push(state);
}
}
}
}
impl EventHandler for StateManager {
fn update(&mut self, ctx: &mut Context) -> GameResult<()> {
let current_state = self.states.last_mut().unwrap();
let transform = current_state.update(ctx)?;
self.handle_transform(ctx, transform);
Ok(())
}
fn draw(&mut self, _: &mut Context) -> GameResult<()> {
Ok(())
}
fn mouse_button_down_event(&mut self, ctx: &mut Context, button: MouseButton, x: f32, y: f32) {
let current_state = self.states.last_mut().unwrap();
let transform = current_state
.handle_event(
ctx,
Event::MouseEvent(MouseEvent::MouseButtonDownEvent { x, y, button }),
)
.unwrap();
self.handle_transform(ctx, transform);
}
fn mouse_button_up_event(&mut self, ctx: &mut Context, button: MouseButton, x: f32, y: f32) {
let current_state = self.states.last_mut().unwrap();
let transform = current_state
.handle_event(
ctx,
Event::MouseEvent(MouseEvent::MouseButtonUpEvent { x, y, button }),
)
.unwrap();
self.handle_transform(ctx, transform);
}
fn mouse_motion_event(&mut self, ctx: &mut Context, x: f32, y: f32, dx: f32, dy: f32) {
let current_state = self.states.last_mut().unwrap();
let transform = current_state
.handle_event(
ctx,
Event::MouseEvent(MouseEvent::MouseMotionEvent { x, y, dx, dy }),
)
.unwrap();
self.handle_transform(ctx, transform);
}
fn mouse_wheel_event(&mut self, ctx: &mut Context, x: f32, y: f32) {
let current_state = self.states.last_mut().unwrap();
let transform = current_state
.handle_event(ctx, Event::MouseEvent(MouseEvent::MouseWheelEvent { x, y }))
.unwrap();
self.handle_transform(ctx, transform);
}
fn key_down_event(
&mut self,
ctx: &mut Context,
keycode: KeyCode,
keymods: KeyMods,
repeat: bool,
) {
let current_state = self.states.last_mut().unwrap();
let transform = current_state
.handle_event(
ctx,
Event::KeyEvent(KeyEvent::KeyDownEvent {
keymods,
keycode,
repeat,
}),
)
.unwrap();
self.handle_transform(ctx, transform);
}
fn key_up_event(&mut self, ctx: &mut Context, keycode: KeyCode, keymods: KeyMods) {
let current_state = self.states.last_mut().unwrap();
let transform = current_state
.handle_event(
ctx,
Event::KeyEvent(KeyEvent::KeyUpEvent { keymods, keycode }),
)
.unwrap();
self.handle_transform(ctx, transform);
}
fn focus_event(&mut self, ctx: &mut Context, gained: bool) {
let current_state = self.states.last_mut().unwrap();
let transform = current_state
.handle_event(ctx, Event::WindowEvent(WindowEvent::FocusEvent { gained }))
.unwrap();
self.handle_transform(ctx, transform);
}
fn resize_event(&mut self, ctx: &mut Context, width: f32, height: f32) {
let current_state = self.states.last_mut().unwrap();
let transform = current_state
.handle_event(
ctx,
Event::WindowEvent(WindowEvent::ResizeEvent { width, height }),
)
.unwrap();
self.handle_transform(ctx, transform);
}
}