Fixed positioning of things in new coordinate system
authorJustin Worthe <justin@worthe-it.co.za>
Thu, 9 Aug 2018 16:13:14 +0000 (18:13 +0200)
committerJustin Worthe <justin@worthe-it.co.za>
Thu, 9 Aug 2018 16:13:14 +0000 (18:13 +0200)
Yay, camera!

src/main.rs

index db96656..060e681 100644 (file)
@@ -32,17 +32,14 @@ struct BugBasherGame {
     game_over: bool,
     time_to_next_bug: f64,
     total_time: f64,
-    cursor_pos: Vec2d
+    camera: Affine
 }
 
 impl App<AssetId> for BugBasherGame {
     fn start(&mut self, _ctx: &mut AppContext<AssetId>) {
     }
 
-    fn advance(&mut self, seconds: f64, ctx: &mut AppContext<AssetId>) {
-        let (x, y) = ctx.cursor();
-        self.cursor_pos = Vec2d::new(x, y);
-        
+    fn advance(&mut self, seconds: f64, _ctx: &mut AppContext<AssetId>) {
         if !self.game_over {
             self.bugs.retain(|b| b.alive);
             for bug in self.bugs.iter_mut() {
@@ -87,7 +84,7 @@ impl App<AssetId> for BugBasherGame {
     }
 
     fn key_down(&mut self, key: KeyCode, ctx: &mut AppContext<AssetId>) {
-        let (x, y) = ctx.cursor();
+        let (x, y) = self.camera.invert_translate().apply_f64(ctx.cursor());
         match key {
             KeyCode::MouseLeft => {
                 for bug in self.bugs.iter_mut().filter(|bug| bug.touches_point(Vec2d { x, y })) {
@@ -107,24 +104,27 @@ impl App<AssetId> for BugBasherGame {
 
     fn render(&mut self, renderer: &mut Renderer<AssetId>, ctx: &AppContext<AssetId>) {
         let (app_width, app_height) = ctx.dims();
+        let (cursor_x, cursor_y) = ctx.cursor();
+        self.camera = Affine::translate(app_width/2., app_height/2.);
+        
         renderer.clear((255,255,255));
         {
             let points_str = format!("{}", self.points);
             let lives_str = format!("{}", self.lives);
-            BugBasherGame::print_string(renderer, &points_str, Alignment::Left, - app_width / 2. + 50., app_height / 2. - 50.);
-            BugBasherGame::print_string(renderer, &lives_str, Alignment::Right, app_width / 2. - 50., app_height / 2. - 50.);
+            BugBasherGame::print_string(renderer, &points_str, Alignment::Left, 50., app_height - 50.);
+            BugBasherGame::print_string(renderer, &lives_str, Alignment::Right, app_width - 50., app_height - 50.);
         }
         {
             let mut renderer = renderer.sprite_mode();
             renderer.draw(
-                &Affine::translate(self.home.pos.x, self.home.pos.y),
+                &self.camera.post_translate(self.home.pos.x, self.home.pos.y),
                 self.home.sprite
             );
             for bug in &self.bugs {
                 let affine = if bug.rotation <= FRAC_PI_2 && bug.rotation >= -FRAC_PI_2 {
-                    Affine::translate(bug.pos.x, bug.pos.y).pre_rotate(bug.rotation)
+                    self.camera.post_translate(bug.pos.x, bug.pos.y).pre_rotate(bug.rotation)
                 } else {
-                    Affine::translate(bug.pos.x, bug.pos.y).pre_rotate(bug.rotation).pre_scale_axes(1., -1.)
+                    self.camera.post_translate(bug.pos.x, bug.pos.y).pre_rotate(bug.rotation).pre_scale_axes(1., -1.)
                 };
                 
                 renderer.draw(
@@ -138,20 +138,20 @@ impl App<AssetId> for BugBasherGame {
             {
                 let mut renderer = renderer.sprite_mode();
                 renderer.draw(
-                    &Affine::translate(0.,0.),
+                    &self.camera,
                     SpriteId::Gameover
                 );
             }
             {
                 let points_str = format!("{}", self.points);
-                BugBasherGame::print_string(renderer, &points_str, Alignment::Center, 0., -25.);
+                BugBasherGame::print_string(renderer, &points_str, Alignment::Center, app_width/2., app_height/2.-25.);
             }
         }
 
         {
             let mut renderer = renderer.sprite_mode();
             renderer.draw(
-                &Affine::translate(self.cursor_pos.x, self.cursor_pos.y),
+                &Affine::translate(cursor_x, cursor_y),
                 SpriteId::Cursor
             );
         }
@@ -175,7 +175,7 @@ impl BugBasherGame {
             game_over: true,
             time_to_next_bug: 0.,
             total_time: 0.,
-            cursor_pos: Vec2d::new(0.,0.)
+            camera: Affine::id()
         };
         game.reset();
         game
@@ -200,7 +200,7 @@ impl BugBasherGame {
         
         let mut renderer = renderer.sprite_mode();
         for (i, c) in string.chars().enumerate() {
-            let affine = Affine::translate(i as f64 * letter_spacing - left, -y);
+            let affine = Affine::translate(left + i as f64 * letter_spacing, y);
             let tile = match c {
                 '-' => SpriteId::NumberFontR0C0,
                 '0' => SpriteId::NumberFontR0C1,
@@ -222,7 +222,6 @@ impl BugBasherGame {
 
 fn main() {
     let info = AppInfo::with_max_dims(2000., 1000.)
-        .min_dims(500., 1000.)
         .tile_width(16)
         .title("Nap Attack");
     gate::run(info, BugBasherGame::new());