src/core/game.rs

   1 use sdl2::controller::{Axis, Button};
   2 use core::controller::ControllerManager;
   3 use std::cell::RefCell;
   4 use std::rc::Rc;
   5 use core::controller::Controller;
   6 use common::Point2D;
   7 use sdl2::rect::Rect;
   8 use common::Nanoseconds;
   9 use sdl2::event::Event;
  10 use sprites::SpriteManager;
  11 use sdl2::render::Canvas;
  12 use sdl2::video::Window;
  13 use AppState;
  14 use point;
  15
  16 ////////// GAMESTATE ///////////////////////////////////////////////////////////
  17
  18 #[derive(Default)]
  19 pub struct GameState {
  20     world: World,
  21 }
  22
  23 impl GameState {
  24     pub fn new() -> Self {
  25         GameState {
  26             world: World::new(),
  27         }
  28     }
  29 }
  30
  31 impl AppState for GameState {
  32     fn enter(&mut self, ctrl_man: &mut ControllerManager) {
  33         if let Some(ctrl) = ctrl_man.controllers.get(&0) {
  34             self.world.add(Box::new(Character::new(ctrl.clone())));
  35         }
  36     }
  37
  38     fn leave(&mut self) {}
  39
  40     fn update(&mut self, dt: Nanoseconds) {
  41         self.world.update(dt);
  42     }
  43
  44     fn render(&mut self, canvas: &mut Canvas<Window>, sprites: &mut SpriteManager) {
  45         self.world.render(canvas, sprites);
  46     }
  47
  48     fn handle_event(&mut self, _event: Event) {}
  49 }
  50
  51 ////////// WORLD ///////////////////////////////////////////////////////////////
  52
  53 #[derive(Default)]
  54 pub struct World {
  55     level: Level,
  56     objects: Objects,
  57 }
  58
  59 impl World {
  60     pub fn new() -> Self {
  61         World {
  62             level: Level {
  63                 gravity: point!(0.0, 0.1),
  64                 ground: 600.0,
  65             },
  66             ..Default::default()
  67         }
  68     }
  69
  70     pub fn update(&mut self, dt: Nanoseconds) {
  71         let mut breeding_ground = vec!();
  72
  73         for i in (0..self.objects.len()).rev() {
  74             if self.objects[i].update(&mut breeding_ground, &self.level, dt) == Dead {
  75                 self.objects.remove(i); // swap_remove is more efficient, but changes the order of the array
  76             }
  77         }
  78
  79         for o in breeding_ground {
  80             self.add(o);
  81         }
  82     }
  83
  84     pub fn render(&mut self, canvas: &mut Canvas<Window>, sprites: &mut SpriteManager) {
  85         self.level.render(canvas, sprites);
  86         for o in &mut self.objects {
  87             o.render(canvas, sprites);
  88         }
  89     }
  90
  91     pub fn add(&mut self, object: Box<dyn Object>) {
  92         self.objects.push(object);
  93     }
  94 }
  95
  96 ////////// LEVEL ///////////////////////////////////////////////////////////////
  97
  98 #[derive(Default)]
  99 pub struct Level {
 100     gravity: Point2D<f64>,
 101     ground: f64,                // just to have something
 102 }
 103
 104 impl Level {
 105     pub fn render(&mut self, canvas: &mut Canvas<Window>, _sprites: &mut SpriteManager) {
 106         let w = canvas.viewport().width() as i32;
 107         for i in 1..11 {
 108             let y = (i * i - 1) as i32 + self.ground as i32;
 109             canvas.set_draw_color((255 - i * 20, 255 - i * 20, 0));
 110             canvas.draw_line((0, y), (w, y)).unwrap();
 111         }
 112     }
 113 }
 114
 115 ////////// OBJECT //////////////////////////////////////////////////////////////
 116
 117 type Objects = Vec<Box<dyn Object>>;
 118
 119 pub trait Object {
 120     fn update(&mut self, objects: &mut Objects, lvl: &Level, dt: Nanoseconds) -> ObjectState;
 121     fn render(&self, _canvas: &mut Canvas<Window>, _sprites: &mut SpriteManager) {}
 122 }
 123
 124 #[derive(PartialEq)]
 125 pub enum ObjectState { Alive, Dead }
 126 use self::ObjectState::*;
 127
 128
 129 pub trait Physical {}
 130 pub trait Drawable {}
 131
 132 ////////// CHARACTER ///////////////////////////////////////////////////////////
 133
 134 pub struct Character {
 135     ctrl: Rc<RefCell<Controller>>,
 136     pos: Point2D<f64>,
 137     vel: Point2D<f64>,
 138 }
 139
 140 impl Character {
 141     pub fn new(ctrl: Rc<RefCell<Controller>>) -> Self {
 142         Character {
 143             ctrl,
 144             pos: point!(100.0, 100.0),
 145             vel: point!(0.0, 0.0),
 146         }
 147     }
 148 }
 149
 150 impl Object for Character {
 151     fn update(&mut self, objects: &mut Objects, lvl: &Level, _dt: Nanoseconds) -> ObjectState {
 152         self.vel += lvl.gravity;
 153         self.pos += self.vel;
 154
 155         let ctrl = &self.ctrl.borrow().ctrl;
 156         let right_stick = point!(ctrl.axis(Axis::RightX) as f64 / 32768.0, ctrl.axis(Axis::RightY) as f64 / 32768.0);
 157
 158         if self.pos.y >= lvl.ground {
 159             self.pos.y = lvl.ground;
 160             self.vel.y = 0.0;
 161             self.vel.x *= 0.9;
 162
 163             if ctrl.button(Button::LeftShoulder) {
 164                 self.vel = right_stick * 5.0;
 165             }
 166         }
 167
 168         if ctrl.button(Button::RightShoulder) {
 169             use rand::distributions::{Distribution, Normal};
 170             let normal = Normal::new(0.0, 0.1);
 171             for _i in 0..100 {
 172                 objects.push(Box::new(Boll {
 173                     pos: self.pos,
 174                     vel: right_stick * (3.0 + rand::random::<f64>()) + point!(normal.sample(&mut rand::thread_rng()), normal.sample(&mut rand::thread_rng())) + self.vel,
 175                     bounces: 2,
 176                 }));
 177             }
 178         }
 179
 180         match ctrl.axis(Axis::LeftX) as f64 / 32768.0 {
 181             v if v < -0.9 => { self.vel.x -= 0.5 }
 182             v if v > 0.9 => { self.vel.x += 0.5 }
 183             _ => {}
 184         }
 185
 186         Alive
 187     }
 188
 189     fn render(&self, canvas: &mut Canvas<Window>, sprites: &mut SpriteManager) {
 190         let block = sprites.get("mario");
 191         let size = 32;
 192         canvas.copy(block, None, Rect::new(self.pos.x as i32 - size as i32 / 2, self.pos.y as i32 - size as i32, size, size)).unwrap();
 193         let ctrl = &self.ctrl.borrow().ctrl;
 194         let (x, y) = (ctrl.axis(Axis::RightX) as f64 / 32768.0, ctrl.axis(Axis::RightY) as f64 / 32768.0);
 195         canvas.set_draw_color((0, 255, 0));
 196         canvas.draw_line((self.pos.x as i32, self.pos.y as i32), ((self.pos.x + x * size as f64) as i32, (self.pos.y + y * size as f64) as i32)).unwrap();
 197     }
 198 }
 199
 200 pub struct Boll {
 201     pos: Point2D<f64>,
 202     vel: Point2D<f64>,
 203     bounces: u8,
 204 }
 205
 206 impl Object for Boll {
 207     fn update(&mut self, _objects: &mut Objects, lvl: &Level, _dt: Nanoseconds) -> ObjectState {
 208         self.vel += lvl.gravity;
 209         self.pos += self.vel;
 210
 211         if self.pos.y >= lvl.ground {
 212             if self.bounces == 0 {
 213                 return Dead
 214             } else {
 215                 self.bounces -= 1;
 216                 self.pos.y = lvl.ground;
 217                 self.vel.y = -self.vel.y;
 218             }
 219         }
 220
 221         Alive
 222     }
 223
 224     fn render(&self, canvas: &mut Canvas<Window>, _sprites: &mut SpriteManager) {
 225         let block = _sprites.get("block");
 226         let size = 4 + self.bounces * 6;
 227         canvas.copy(block, None, Rect::new(self.pos.x as i32 - size as i32 / 2, self.pos.y as i32 - size as i32 / 2, size as u32, size as u32)).unwrap();
 228         // canvas.set_draw_color((0, self.bounces * 100, 255));
 229         // canvas.draw_point((self.pos.x as i32, self.pos.y as i32)).unwrap();
 230     }
 231 }