use ggez::event::{Axis, Button, EventHandler, GamepadId};
use ggez::input::keyboard::{KeyCode, KeyMods};
use ggez::input::mouse::MouseButton;
use ggez::{Context, GameResult};
pub enum Trans {
None,
Push(Box<dyn State>),
Switch(Box<dyn State>),
Replace(Box<dyn State>),
Pop,
}
pub trait State {
fn on_start(&mut self, _ctx: &mut Context) -> GameResult {
Ok(())
}
fn on_stop(&mut self, _ctx: &mut Context) -> GameResult {
Ok(())
}
fn update(&mut self, ctx: &mut Context) -> GameResult<Trans>;
fn draw(&mut self, ctx: &mut Context) -> GameResult<Trans>;
fn on_pause(&mut self, _ctx: &mut Context) -> GameResult {
Ok(())
}
fn on_resume(&mut self, _ctx: &mut Context) -> GameResult {
Ok(())
}
fn mouse_button_down_event(
&mut self,
_ctx: &mut Context,
_button: MouseButton,
_x: f32,
_y: f32,
) -> GameResult<Trans> {
Ok(Trans::None)
}
fn mouse_button_up_event(
&mut self,
_ctx: &mut Context,
_button: MouseButton,
_x: f32,
_y: f32,
) -> GameResult<Trans> {
Ok(Trans::None)
}
fn mouse_motion_event(
&mut self,
_ctx: &mut Context,
_x: f32,
_y: f32,
_dx: f32,
_dy: f32,
) -> GameResult<Trans> {
Ok(Trans::None)
}
fn mouse_wheel_event(&mut self, _ctx: &mut Context, _x: f32, _y: f32) -> GameResult<Trans> {
Ok(Trans::None)
}
fn key_down_event(
&mut self,
_ctx: &mut Context,
_keycode: KeyCode,
_keymods: KeyMods,
_repeat: bool,
) -> GameResult<Trans> {
Ok(Trans::None)
}
fn key_up_event(
&mut self,
_ctx: &mut Context,
_keycode: KeyCode,
_keymods: KeyMods,
) -> GameResult<Trans> {
Ok(Trans::None)
}
fn text_input_event(&mut self, _ctx: &mut Context, _character: char) -> GameResult<Trans> {
Ok(Trans::None)
}
fn gamepad_button_down_event(
&mut self,
_ctx: &mut Context,
_btn: Button,
_id: GamepadId,
) -> GameResult<Trans> {
Ok(Trans::None)
}
fn gamepad_button_up_event(
&mut self,
_ctx: &mut Context,
_btn: Button,
_id: GamepadId,
) -> GameResult<Trans> {
Ok(Trans::None)
}
fn gamepad_axis_event(
&mut self,
_ctx: &mut Context,
_axis: Axis,
_value: f32,
_id: GamepadId,
) -> GameResult<Trans> {
Ok(Trans::None)
}
fn focus_event(&mut self, _ctx: &mut Context, _gained: bool) -> GameResult<Trans> {
Ok(Trans::None)
}
fn quit_event(&mut self, _ctx: &mut Context) -> bool {
println!("quit_event() callback called, quitting...");
false
}
fn resize_event(&mut self, _ctx: &mut Context, _width: f32, _height: f32) -> GameResult<Trans> {
Ok(Trans::None)
}
}
pub struct StateManager {
state_stack: Vec<Box<dyn State>>,
}
impl StateManager {
pub fn new(ctx: &mut Context, mut initial_state: Box<dyn State>) -> Self {
let mut states = Vec::new();
initial_state.on_start(ctx).unwrap();
states.push(initial_state);
Self {
state_stack: states,
}
}
fn handle_transform(&mut self, ctx: &mut Context, transform: Trans) {
match transform {
Trans::None => {}
Trans::Pop => {
if let Some(state) = self.state_stack.last_mut() {
state.on_stop(ctx).unwrap();
}
self.state_stack.pop();
if let Some(state) = self.state_stack.last_mut() {
state.on_resume(ctx).unwrap();
}
}
Trans::Push(mut state) => {
if let Some(state) = self.state_stack.last_mut() {
state.on_pause(ctx).unwrap();
}
state.on_start(ctx).unwrap();
self.state_stack.push(state);
}
Trans::Switch(mut state) => {
if let Some(state) = self.state_stack.last_mut() {
state.on_stop(ctx).unwrap();
}
self.state_stack.pop();
state.on_start(ctx).unwrap();
self.state_stack.push(state);
}
Trans::Replace(mut state) => {
while let Some(mut state) = self.state_stack.pop() {
state.on_stop(ctx).unwrap()
}
state.on_start(ctx).unwrap();
self.state_stack.push(state);
}
}
}
}
impl EventHandler for StateManager {
fn update(&mut self, ctx: &mut Context) -> GameResult<()> {
let current_state = self.state_stack.last_mut().unwrap();
let transform = current_state.update(ctx)?;
self.handle_transform(ctx, transform);
Ok(())
}
fn draw(&mut self, ctx: &mut Context) -> GameResult<()> {
let current_state = self.state_stack.last_mut().unwrap();
let transform = current_state.draw(ctx)?;
self.handle_transform(ctx, transform);
Ok(())
}
fn mouse_button_down_event(&mut self, ctx: &mut Context, button: MouseButton, x: f32, y: f32) {
let current_state = self.state_stack.last_mut().unwrap();
let transform = current_state
.mouse_button_down_event(ctx, button, x, y)
.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.state_stack.last_mut().unwrap();
let transform = current_state
.mouse_button_up_event(ctx, button, x, y)
.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.state_stack.last_mut().unwrap();
let transform = current_state.mouse_motion_event(ctx, 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.state_stack.last_mut().unwrap();
let transform = current_state.mouse_wheel_event(ctx, 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.state_stack.last_mut().unwrap();
let transform = current_state
.key_down_event(ctx, keycode, keymods, repeat)
.unwrap();
self.handle_transform(ctx, transform);
}
fn key_up_event(&mut self, ctx: &mut Context, keycode: KeyCode, keymods: KeyMods) {
let current_state = self.state_stack.last_mut().unwrap();
let transform = current_state.key_up_event(ctx, keycode, keymods).unwrap();
self.handle_transform(ctx, transform);
}
fn gamepad_button_down_event(&mut self, ctx: &mut Context, btn: Button, id: GamepadId) {
let current_state = self.state_stack.last_mut().unwrap();
let transform = current_state
.gamepad_button_down_event(ctx, btn, id)
.unwrap();
self.handle_transform(ctx, transform);
}
fn gamepad_button_up_event(&mut self, ctx: &mut Context, btn: Button, id: GamepadId) {
let current_state = self.state_stack.last_mut().unwrap();
let transform = current_state.gamepad_button_up_event(ctx, btn, id).unwrap();
self.handle_transform(ctx, transform);
}
fn gamepad_axis_event(&mut self, ctx: &mut Context, axis: Axis, value: f32, id: GamepadId) {
let current_state = self.state_stack.last_mut().unwrap();
let transform = current_state
.gamepad_axis_event(ctx, axis, value, id)
.unwrap();
self.handle_transform(ctx, transform);
}
fn focus_event(&mut self, ctx: &mut Context, gained: bool) {
let current_state = self.state_stack.last_mut().unwrap();
let transform = current_state.focus_event(ctx, gained).unwrap();
self.handle_transform(ctx, transform);
}
fn resize_event(&mut self, ctx: &mut Context, width: f32, height: f32) {
let current_state = self.state_stack.last_mut().unwrap();
let transform = current_state.resize_event(ctx, width, height).unwrap();
self.handle_transform(ctx, transform);
}
}