123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483 |
- #[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,
- }
- impl Position {
- /// Lazy collision detection: returns true if the two points are
- /// within 20 units of each other
- fn close_to(&self, other: &Position) -> bool{
- let dx = self.x - other.x;
- let dy = self.y - other.y;
- (dx * dx + dy * dy).sqrt() < 20.0
- }
- }
- /// 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;
- }
- }
- }
- // This naively handles collision detection in a shitty way that
- // would never scale for anything real
- system_impl!{
- Collision(
- en: Entity,
- mut pos: Position,
- hp: HP,
- mut lifetime: Lifetime,
- mut drawn: Drawn,
- mut damage: AppliesDamage,
- ) {
- let mut seen = std::collections::HashMap::new();
- // just compare every entity to every other one
- for (e1, p1, _) in (&en, &pos, &hp).join() {
- for (e2, p2, _) in (&en, &pos, &hp).join() {
- // don't collide with ourselves, that's stupid
- if e1 == e2 {
- continue;
- }
- // if they're close and we haven't already looked at
- // this one (which we might have!) then add it to the
- // set of collisions
- if p1.close_to(p2) && !seen.contains_key(&(e1, e2)) {
- seen.insert((e1, e2), p1.clone());
- }
- }
- }
- // now, for each collision
- for ((e1, e2), p) in seen {
- // create the kaboom graphic! it'll only last 10 ticks,
- // such is the nature of kabooms. (this should probably be
- // split apart into another system, but whatevs)
- let ping = en.create();
- lifetime.insert(ping, Lifetime { lifetime: 10 }).unwrap();
- drawn.insert(ping, Drawn { sprite: Sprite::Kaboom }).unwrap();
- pos.insert(ping, p).unwrap();
- // and create the damage events
- let ev1 = en.create();
- damage.insert(ev1, AppliesDamage { target: e1 }).unwrap();
- let ev2 = en.create();
- damage.insert(ev2, 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) {
- target.hp -= 1;
- if target.hp == 0 {
- en.delete(dmg.target).unwrap();
- }
- }
- }
- dmg.clear();
- }
- }
- // * 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 {
- // 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>();
- // create our blank key state
- world.insert(KeyState::new());
- // create a 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 })
- .build();
- // 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;
- world.create_entity()
- .with(Drawn { sprite: Sprite::Hostile })
- .with(Position { x, y })
- .with(Velocity { dx, dy })
- .with(HP { hp: 50 })
- .build();
- }
- // 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)
- }
|