evented-sample/src/main.rs

#[macro_use]
extern crate specs_derive;
#[macro_use]
extern crate specs_system_macro;

use ggez::graphics::Drawable;
use specs::prelude::*;
use specs::world::WorldExt;

// * constants

const WIDTH: f32 = 640.0;
const HEIGHT: f32 = 480.0;
const MAX_HP: u32 = 100;

// * utility functions

fn clamp(x: f32, min: f32, max: f32) -> f32 {
    if x < min {
        min
    } else if x > max {
        max
    } else {
        x
    }
}

// * components

/// This is a component for things which can appear on the screen
#[derive(Component)]
pub struct Drawn {
    sprite: Sprite,
}

/// We only have three things which appear: the player, the hostile
/// red dots, and the green 'collision' that appears when they hit
/// each other
pub enum Sprite {
    Player,
    Hostile,
    Kaboom,
}

impl Sprite {
    /// Convert one of the pre-known sprites to is intended visual appearance
    fn to_mesh(&self, ctx: &mut ggez::Context) -> ggez::GameResult<ggez::graphics::Mesh> {
        match self {
            Sprite::Player => ggez::graphics::Mesh::new_circle(
                ctx,
                ggez::graphics::DrawMode::fill(),
                [0.0, 0.0],
                10.0,
                0.1,
                ggez::graphics::WHITE,
            ),
            Sprite::Hostile => ggez::graphics::Mesh::new_circle(
                ctx,
                ggez::graphics::DrawMode::fill(),
                [0.0, 0.0],
                10.0,
                0.1,
                (1.0, 0.0, 0.0).into(),
            ),
            Sprite::Kaboom => ggez::graphics::Mesh::new_circle(
                ctx,
                ggez::graphics::DrawMode::stroke(1.0),
                [0.0, 0.0],
                20.0,
                0.1,
                (0.0, 1.0, 0.0).into(),
            ),
        }
    }
}

/// A component for things which can be positioned somewhere on the
/// screen
#[derive(Component, Copy, Clone)]
pub struct Position {
    x: f32,
    y: f32,
}

/// A component for things which move around the screen at a specific
/// velocity
#[derive(Component)]
pub struct Velocity {
    dx: f32,
    dy: f32,
}

/// A component for things which are player-controlled: that is, the
/// player.
#[derive(Component)]
pub struct Controlled;

/// A component for apply damage events
#[derive(Component)]
pub struct AppliesDamage {
    target: specs::Entity,
}

/// A component for things which are ephemeral: when lifetime hits 0,
/// the thing is removed
#[derive(Component)]
pub struct Lifetime {
    lifetime: usize,
}

#[derive(Component)]
pub struct HP {
    hp: u32,
}

// * KeyState impl

/// A KeyState contains four bools that indicate whether particular
/// keys are held (the only four keys we care about, the famous
/// Gamer's Square: W, A, S, and who can forget D?)
pub struct KeyState {
    w_pressed: bool,
    a_pressed: bool,
    s_pressed: bool,
    d_pressed: bool,
}

impl KeyState {
    /// By default, none of them are held down
    fn new() -> KeyState {
        KeyState {
            w_pressed: false,
            a_pressed: false,
            s_pressed: false,
            d_pressed: false,
        }
    }

    /// On a key-down event, we might flip some to true
    fn handle_down(&mut self, kc: winit::VirtualKeyCode) {
        if kc == winit::VirtualKeyCode::W {
            self.w_pressed = true;
        }
        if kc == winit::VirtualKeyCode::A {
            self.a_pressed = true;
        }
        if kc == winit::VirtualKeyCode::S {
            self.s_pressed = true;
        }
        if kc == winit::VirtualKeyCode::D {
            self.d_pressed = true;
        }
    }

    /// On a key-up event, we might flip some to false
    fn handle_up(&mut self, kc: winit::VirtualKeyCode) {
        if kc == winit::VirtualKeyCode::W {
            self.w_pressed = false;
        }
        if kc == winit::VirtualKeyCode::A {
            self.a_pressed = false;
        }
        if kc == winit::VirtualKeyCode::S {
            self.s_pressed = false;
        }
        if kc == winit::VirtualKeyCode::D {
            self.d_pressed = false;
        }
    }
}

// * systems

/// The Draw system, which needs access to the ggez context in order
/// to, uh, draw stuff
struct Draw<'t> {
    pub ctx: &'t mut ggez::Context,
}

impl<'a, 't> specs::System<'a> for Draw<'t> {
    type SystemData = (
        // Position and Drawn are for the usual screen entities
        specs::ReadStorage<'a, Position>,
        specs::ReadStorage<'a, Drawn>,
        // HP and Controlled is so we can display the player HP
        specs::ReadStorage<'a, HP>,
        specs::ReadStorage<'a, Controlled>,
    );

    fn run(&mut self, (pos, draw, hp, controlled): Self::SystemData) {
        // clear to black
        ggez::graphics::clear(self.ctx, ggez::graphics::BLACK);
        // draw all the drawable things
        for (pos, draw) in (&pos, &draw).join() {
            let param = ggez::graphics::DrawParam {
                dest: [pos.x, pos.y].into(),
                ..ggez::graphics::DrawParam::default()
            };
            draw.sprite
                .to_mesh(self.ctx)
                .unwrap()
                .draw(self.ctx, param)
                .unwrap();
        }
        // find the HP of the player and print it on the screen
        for (hp, _) in (&hp, &controlled).join() {
            let player_hp = format!("HP: {}/{}", hp.hp, MAX_HP);
            let display = ggez::graphics::Text::new(player_hp);
            display.draw(self.ctx, ([50.0, 50.0],).into()).unwrap();
        }
        // show it, yo
        ggez::graphics::present(self.ctx).unwrap();
    }
}

// The Control system is for adjusting the current velocity of things
// based on the current state of the keys. The longer you hold keys,
// the more it'll accelerate, up to some fixed speed (20 units per
// tick)
system! {
    Control(resource kc: KeyState, _c: Controlled, mut v: Velocity) {
        const SPEEDUP: f32 = 0.2;
        if kc.w_pressed {
            v.dy -= SPEEDUP;
        }
        if kc.a_pressed {
            v.dx -= SPEEDUP;
        }
        if kc.s_pressed {
            v.dy += SPEEDUP;
        }
        if kc.d_pressed {
            v.dx += SPEEDUP;
        }
        v.dx = clamp(v.dx, -20.0, 20.0);
        v.dy = clamp(v.dy, -20.0, 20.0);
    }
}

// This applies friction to components, currently by a global amount
system! {
    Slowdown(mut v: Velocity, _c: Controlled) {
        const ROUNDING: f32 = 0.01;
        const FRICTION: f32 = 0.95;
        if v.dx.abs() < ROUNDING {
            v.dx = 0.0;
        } else {
            v.dx *= FRICTION;
        }
        if v.dy.abs() < ROUNDING {
            v.dy = 0.0
        } else {
            v.dy *= FRICTION;
        }
    }
}

// This moves components around and handles wrapping them
system! {
    Move(mut pos: Position, v: Velocity) {
        pos.x += v.dx;
        pos.y += v.dy;
        if pos.x < 0.0 {
            pos.x += WIDTH;
        } else if pos.x > WIDTH {
            pos.x -= WIDTH;
        }
        if pos.y < 0.0 {
            pos.y += HEIGHT;
        } else if pos.y > HEIGHT {
            pos.y -= HEIGHT;
        }
    }
}

system_impl! {
    Collision(
        en: Entity,
        resource mut world: ncollide2d::world::CollisionWorld<f32, CollisionData>,
        mut pos: Position,
        col: Collidable,
        mut lifetime: Lifetime,
        mut drawn: Drawn,
        mut damage: AppliesDamage,
    ) {
        use nalgebra::Isometry2;
        for (p, c) in (&mut pos, &col).join() {
            world.get_mut(c.handle).expect("Unable to find collision object")
                .set_position(Isometry2::translation(p.x / 10.0, p.y / 10.0));
        }

        world.update();
        for (c1, c2, _, man) in world.contact_pairs(true) {
            if let Some(m) = man.deepest_contact() {
                let a = m.contact.world1;
                let ping = en.create();
                lifetime.insert(ping, Lifetime { lifetime: 10 }).unwrap();
                drawn.insert(ping, Drawn { sprite: Sprite::Kaboom }).unwrap();
                pos.insert(ping, Position {x: a.x * 10.0, y: a.y * 10.0}).unwrap();

                if let Some(e1) = world.collision_object(c1).unwrap().data().for_entity {
                    damage.insert(en.create(), AppliesDamage { target: e1 }).unwrap();
                }
                if let Some(e2) = world.collision_object(c2).unwrap().data().for_entity {
                    damage.insert(en.create(), AppliesDamage { target: e2 }).unwrap();
                }
            }
        }
    }
}

// This handles lifetimes ticking back down, and removing entities if
// their lifetimes get too low
system_impl! {
    TheInexorablePassageOfTime(en: Entity, mut l: Lifetime) {
        for (e, mut l) in (&en, &mut l).join() {
            l.lifetime -= 1;
            if l.lifetime == 0 {
                en.delete(e).unwrap();
            }
        }
    }
}

// This handles applying damage to entities, and removing them if
// their HP gets too low.
system_impl! {
    TheSlingsAndArrowsOfOutrageousFortune(
        en: Entity,
        mut dmg: AppliesDamage,
        mut hp: HP,
    ) {
        for dmg in (&dmg).join() {
            if let Some(target) = hp.get_mut(dmg.target) {
                if target.hp == 0 {
                    en.delete(dmg.target).unwrap();
                }
                target.hp -= 1;
            }
        }
        dmg.clear();
    }
}

pub struct CollisionData {
    for_entity: Option<specs::Entity>,
}

#[derive(Component)]
pub struct Collidable {
    handle: ncollide2d::pipeline::CollisionObjectSlabHandle,
}

// * game definition

/// A game just needs a specs world! All our state is in there
struct MyGame {
    pub world: specs::World,
}

impl MyGame {
    fn setup() -> MyGame {
        use nalgebra::Isometry2;
        use ncollide2d::pipeline::{CollisionGroups, GeometricQueryType};
        use ncollide2d::shape::{Ball, ShapeHandle};
        use ncollide2d::world::CollisionWorld;

        // this is the first step in making apple pie from scratch
        let mut world = specs::World::new();
        // register some component types
        world.register::<Position>();
        world.register::<Drawn>();
        world.register::<Controlled>();
        world.register::<Velocity>();
        world.register::<HP>();
        world.register::<Lifetime>();
        world.register::<AppliesDamage>();
        world.register::<Collidable>();

        // create our blank key state
        world.insert(KeyState::new());

        // create a collision world
        let mut collision_world = CollisionWorld::<f32, CollisionData>::new(0.02);
        let mut group = CollisionGroups::new();
        group.set_membership(&[0]);
        group.set_whitelist(&[0]);

        let contacts_query = GeometricQueryType::Contacts(0.0, 0.0);

        // create a player
        let (player_handle, object) = collision_world.add(
            Isometry2::translation(20.0, 20.0),
            ShapeHandle::new(Ball::new(1.0)),
            group,
            contacts_query,
            CollisionData { for_entity: None },
        );
        let player = world
            .create_entity()
            .with(Drawn {
                sprite: Sprite::Player,
            })
            .with(Position { x: 200.0, y: 200.0 })
            .with(Controlled)
            .with(Velocity { dx: 0.0, dy: 0.0 })
            .with(HP { hp: MAX_HP })
            .with(Collidable {
                handle: player_handle,
            })
            .build();
        object.data_mut().for_entity = Some(player);

        // create ten ENEMY ORBS!!!!!!!11111one
        for _ in 0..10 {
            let x = rand::random::<f32>() * WIDTH;
            let y = rand::random::<f32>() * HEIGHT;
            let dx = (rand::random::<f32>() * 20.0) - 10.0;
            let dy = (rand::random::<f32>() * 20.0) - 10.0;
            let (handle, object) = collision_world.add(
                Isometry2::translation(x / 10.0, y / 10.0),
                ShapeHandle::new(Ball::new(1.0)),
                group,
                contacts_query,
                CollisionData { for_entity: None },
            );
            let orb = world
                .create_entity()
                .with(Drawn {
                    sprite: Sprite::Hostile,
                })
                .with(Position { x, y })
                .with(Velocity { dx, dy })
                .with(HP { hp: 50 })
                .with(Collidable { handle })
                .build();
            object.data_mut().for_entity = Some(orb);
        }

        world.insert(collision_world);

        // this is the world I have created. observe it and despair
        MyGame { world }
    }
}

impl ggez::event::EventHandler for MyGame {
    // To draw things, we just run the Draw system
    fn draw(&mut self, ctx: &mut ggez::Context) -> ggez::GameResult<()> {
        Draw { ctx }.run_now(&self.world);
        Ok(())
    }

    // To update things, we just run a bunch of these systems, and
    // make sure we call maintain
    fn update(&mut self, _ctx: &mut ggez::Context) -> ggez::GameResult<()> {
        TheSlingsAndArrowsOfOutrageousFortune.run_now(&self.world);
        Slowdown.run_now(&self.world);
        Control.run_now(&self.world);
        Move.run_now(&self.world);
        Collision.run_now(&self.world);
        TheInexorablePassageOfTime.run_now(&self.world);
        self.world.maintain();
        Ok(())
    }

    // to handle events, we modify the stored KeyState resource
    fn key_down_event(
        &mut self,
        ctx: &mut ggez::Context,
        keycode: winit::VirtualKeyCode,
        _keymod: ggez::event::KeyMods,
        _repeat: bool,
    ) {
        if keycode == winit::VirtualKeyCode::Escape {
            ggez::event::quit(ctx);
        }
        KeyState::handle_down(&mut self.world.write_resource(), keycode);
    }

    fn key_up_event(
        &mut self,
        _ctx: &mut ggez::Context,
        keycode: winit::VirtualKeyCode,
        _keymod: ggez::event::KeyMods,
    ) {
        KeyState::handle_up(&mut self.world.write_resource(), keycode);
    }
}

// * main

fn main() -> ggez::GameResult<()> {
    // And here, we make a context and an event loop
    let (mut ctx, mut evloop) = ggez::ContextBuilder::new("game", "me")
        // make our window a, uh, size
        .window_mode(ggez::conf::WindowMode {
            width: WIDTH,
            height: HEIGHT,
            ..ggez::conf::WindowMode::default()
        })
        // and build it
        .build()?;

    // then run the shit yo
    let mut my_game = MyGame::setup();
    ggez::event::run(&mut ctx, &mut evloop, &mut my_game)
}