src/main.rs

   1 extern crate gate;
   2
   3 use gate::{App, Audio};
   4 use gate::app_info::AppInfo;
   5 use gate::input::*;
   6 use gate::renderer::{Renderer, Affine};
   7
   8 mod asset_id { include!(concat!(env!("OUT_DIR"), "/asset_id.rs")); }
   9 use asset_id::*;
  10
  11 mod geometry;
  12 use geometry::*;
  13
  14 mod entities;
  15 use entities::bug::Bug;
  16
  17 struct BugBasherGame {
  18     bugs: Vec<Bug>,
  19     points: i64
  20 }
  21
  22 impl App<AssetId> for BugBasherGame {
  23     fn start(&mut self, _audio: &mut Audio<AssetId>) {
  24     }
  25
  26     fn advance(&mut self, seconds: f64, _audio: &mut Audio<AssetId>) -> bool {
  27         self.bugs.retain(|b| b.alive);
  28         for bug in self.bugs.iter_mut() {
  29             bug.advance(seconds);
  30         }
  31
  32         true
  33     }
  34
  35     fn input(&mut self, evt: InputEvent, _audio: &mut Audio<AssetId>) -> bool {
  36         match evt {
  37             InputEvent::MousePressed(MouseButton::Left, x, y) => {
  38                 for bug in self.bugs.iter_mut() {
  39                     bug.click(Vec2d { x, y });
  40                 }
  41             },
  42             _ => {}
  43         }
  44         true
  45     }
  46
  47     fn render(&mut self, renderer: &mut Renderer<AssetId>) {
  48         let (app_width, app_height) = (renderer.app_width(), renderer.app_height());
  49         renderer.clear((255,255,255));
  50         {
  51             let mut renderer = renderer.tiled_mode(app_width / 2. - 50., -app_height / 2. + 50.);
  52             let spacing = 25.;
  53             let point_str = format!("{}", self.points);
  54             for (i, c) in point_str.chars().enumerate() {
  55                 let affine = Affine::translate(i as f64 * spacing, 0.);
  56                 let tile = match c {
  57                     '-' => TileId::NumberFontR0C0,
  58                     '0' => TileId::NumberFontR0C1,
  59                     '1' => TileId::NumberFontR0C2,
  60                     '2' => TileId::NumberFontR0C3,
  61                     '3' => TileId::NumberFontR0C4,
  62                     '4' => TileId::NumberFontR0C5,
  63                     '5' => TileId::NumberFontR0C6,
  64                     '6' => TileId::NumberFontR0C7,
  65                     '7' => TileId::NumberFontR0C8,
  66                     '8' => TileId::NumberFontR0C9,
  67                     '9' => TileId::NumberFontR0C10,
  68                     _ => TileId::NumberFontR0C0,
  69                 };
  70                 renderer.draw(&affine, tile);
  71             };
  72
  73         }
  74         {
  75             let mut renderer = renderer.sprite_mode();
  76             for bug in &self.bugs {
  77                 renderer.draw(
  78                     &Affine::translate(bug.pos.x, bug.pos.y).pre_rotate(bug.rotation),
  79                     SpriteId::Bug
  80                 );
  81             }
  82         }
  83     }
  84 }
  85
  86 impl BugBasherGame {
  87 }
  88
  89 fn main() {
  90     let info = AppInfo::with_app_height(1000.).title("Bug Basher").build();
  91     gate::run(info, BugBasherGame {
  92         bugs: vec!(
  93             Bug::new(500., 200., 0.3),
  94             Bug::new(-200., -200., 1.5),
  95             Bug::new(-1000., 200., 0.),
  96             Bug::new(1200., 0., 0.3),
  97             Bug::new(-1300., 0., 1.5),
  98             Bug::new(0., 1100., 0.),
  99             Bug::new(0., -1500., 0.3),
 100             Bug::new(300., -1200., 1.5),
 101         ),
 102         points: 0
 103     });
 104 }