ggez_tools 0.2.2

Some useful tools for ggez(i.e. state manager, and i will add ui later. It is pretty similar to amethyst' state)
Documentation
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 {
    /// when state is initialized
    fn on_start(&mut self, ctx: &mut Context) -> GameResult;

    /// update per frame
    fn update(&mut self, ctx: &mut Context) -> GameResult<Trans>;

    /// handle event
    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);
    }
}