Minor cleanups for asset management

Author: Andy-Python-Programmer

resources/images/Some(nil).png

@@ -1,35 +1,53 @@
-use ggez::{graphics::Image, Context, GameResult};
+use ggez::{Context, GameResult};
 use ggez_goodies::{
     camera::{Camera, CameraDraw},
     nalgebra_glm::Vec2,
 };
 
-use crate::HEIGHT;
+use crate::{
+    utils::{AssetManager, Position},
+    HEIGHT,
+};
+
+const HEIGHT2: f32 = HEIGHT / 2.;
 
 pub struct Barrel {
-    pub pos_x: f32,
+    position: Position,
 }
 
 impl Barrel {
-    pub fn new(pos_x: f32) -> Self {
-        Self { pos_x }
+    pub fn new(pos_x: f32, asset_manager: &AssetManager) -> Self {
+        let barrel = asset_manager.get_image("Some(barrel).png");
+
+        let position = Position::new(
+            pos_x,
+            -HEIGHT2 + (barrel.height() + 40) as f32,
+            barrel.width(),
+            barrel.height(),
+        );
+
+        Self { position }
     }
 
     pub fn draw(
         &mut self,
         ctx: &mut Context,
         camera: &Camera,
-        resources: &Vec<Image>,
+        asset_manager: &AssetManager,
     ) -> GameResult<()> {
-        const HEIGHT2: f32 = HEIGHT / 2.;
+        let barrel = asset_manager.get_image("Some(barrel).png");
 
-        &resources[0].draw_camera(
+        barrel.draw_camera(
             camera,
             ctx,
-            Vec2::new(self.pos_x, -HEIGHT2 + (resources[0].height() + 40) as f32),
+            Vec2::new(self.position.pos_start.x, self.position.pos_start.y),
             0.,
-        );
+        )?;
 
         Ok(())
     }
+
+    pub fn position(&self) -> Position {
+        self.position
+    }
 }

resources/images/gopher.png

@@ -1,21 +1,28 @@
-use ggez::{graphics::Image, Context, GameResult};
+use ggez::{Context, GameResult};
 use ggez_goodies::{
     camera::{Camera, CameraDraw},
     nalgebra_glm::Vec2,
 };
 
-pub struct Turbofish {
-    pub pos_x: f32,
-    pub pos_y: f32,
+use crate::utils::{AssetManager, Position};
 
+pub struct Turbofish {
+    position: Position,
     traveled_count: i32,
 }
 
 impl Turbofish {
-    pub fn new(pos_x: f32, pos_y: f32) -> Self {
-        Self {
+    pub fn new(pos_x: f32, pos_y: f32, asset_manager: &AssetManager) -> Self {
+        let turbofish_bullet = asset_manager.get_image("Some(turbofish).png");
+        let position = Position::new(
             pos_x,
             pos_y,
+            turbofish_bullet.width(),
+            turbofish_bullet.height(),
+        );
+
+        Self {
+            position,
             traveled_count: 0,
         }
     }
@@ -24,21 +31,32 @@ impl Turbofish {
         &mut self,
         ctx: &mut Context,
         camera: &Camera,
-        resources: &Vec<Image>,
+        asset_manager: &AssetManager,
     ) -> GameResult<()> {
-        &resources[0].draw_camera(camera, ctx, Vec2::new(self.pos_x, self.pos_y), 1.5708);
+        let turbofish_bullet = asset_manager.get_image("Some(turbofish).png");
+
+        turbofish_bullet.draw_camera(
+            camera,
+            ctx,
+            Vec2::new(self.position.pos_start.x, self.position.pos_start.y),
+            1.5708,
+        )?;
 
         Ok(())
     }
 
     pub fn go_boom(&mut self) -> bool {
         if self.traveled_count < 100 {
             self.traveled_count += 1;
-            self.pos_x += 10.;
+            self.position.move_by("x+", 10.0);
 
             false
         } else {
             true
         }
     }
+
+    pub fn position(&self) -> Position {
+        self.position
+    }
 }

src/components/barrel.rs

@@ -1,54 +1,59 @@
 use ggez::{
-    graphics::{self, Image},
+    graphics,
     mint::{Point2, Vector2},
     Context, GameResult,
 };
 use graphics::DrawParam;
 
-use crate::WIDTH;
+use crate::{WIDTH, utils::{AssetManager, Position}};
 
 pub struct Cloud {
-    pos_x: f32,
-    pos_y: f32,
+    position: Position,
+
     scale: f32,
     speed: f32,
 }
 
 impl Cloud {
-    pub fn new(pos_x: f32, pos_y: f32, scale: f32, speed: f32) -> Self {
+    pub fn new(pos_x: f32, pos_y: f32, scale: f32, speed: f32, asset_manager: &AssetManager) -> Self {
+        let cloud = asset_manager.get_image("Some(cloud).png");
+        let position = Position::new(pos_x, pos_y, cloud.width(), cloud.height());
+        
         Self {
-            pos_x,
-            pos_y,
+            position,
             scale,
             speed,
         }
     }
 
-    pub fn draw(&mut self, ctx: &mut Context, resources: &Vec<Image>) -> GameResult<()> {
+    pub fn draw(&mut self, ctx: &mut Context, asset_manager: &AssetManager) -> GameResult<()> {
+        let cloud = asset_manager.get_image("Some(cloud).png");
+
         graphics::draw(
             ctx,
-            &resources[0],
+            &cloud,
             DrawParam::default()
                 .scale(Vector2 {
                     x: self.scale,
                     y: self.scale,
                 })
                 .dest(Point2 {
-                    x: self.pos_x,
-                    y: self.pos_y,
+                    x: self.position.pos_start.x,
+                    y: self.position.pos_start.y,
                 }),
         )?;
 
         Ok(())
     }
 
-    pub fn update(&mut self, ctx: &mut Context) {
+    pub fn update(&mut self, ctx: &mut Context, asset_manager: &AssetManager) {
+        let cloud = asset_manager.get_image("Some(cloud).png");
         let delta_time = ggez::timer::delta(ctx).as_secs_f32();
 
-        self.pos_x += delta_time * self.speed;
+        self.position.move_by("x+", delta_time * self.speed);
 
-        if self.pos_x > WIDTH + 100. {
-            self.pos_x = -100.;
+        if self.position.pos_start.x > WIDTH + 100. {
+            self.position = Position::new(-100., self.position.pos_start.y, cloud.width(), cloud.height());
         }
     }
 }

src/components/bullet.rs

@@ -1,38 +1,67 @@
-use ggez::{graphics, Context, GameResult};
+use ggez::{Context, GameResult};
 use ggez_goodies::{
     camera::{Camera, CameraDraw},
     nalgebra_glm::Vec2,
 };
-use graphics::Image;
 
-use crate::HEIGHT;
+use crate::{
+    utils::{AssetManager, Position},
+    HEIGHT,
+};
+
+const HEIGHT2: f32 = HEIGHT / 2.;
+
+use super::player::Player;
 
 pub struct Enemy {
-    pub pos_x: f32,
+    position: Position,
 }
 
 impl Enemy {
-    pub fn new(pos_x: f32) -> Self {
-        Self { pos_x }
+    pub fn new(pos_x: f32, asset_manager: &AssetManager) -> Self {
+        let gopher = asset_manager.get_image("gopher.png");
+
+        let position = Position::new(pos_x, -HEIGHT2 + 190., gopher.width(), gopher.height());
+
+        Self { position }
     }
 
     pub fn draw(
         &mut self,
         ctx: &mut Context,
         camera: &Camera,
-        resources: &Vec<Image>,
+        asset_manager: &AssetManager,
     ) -> GameResult<()> {
-        const HEIGHT2: f32 = HEIGHT / 2.;
+        let gopher = asset_manager.get_image("gopher.png");
+        let gun = asset_manager.get_image("Some(gun).png");
 
-        &resources[0].draw_camera(&camera, ctx, Vec2::new(self.pos_x, -HEIGHT2 + 190.), 0.0);
+        gopher.draw_camera(
+            &camera,
+            ctx,
+            Vec2::new(self.position.pos_start.x, self.position.pos_start.y),
+            0.0,
+        )?;
 
-        &resources[1].draw_camera(
+        gun.draw_camera(
             &camera,
             ctx,
-            Vec2::new(self.pos_x - 50., -HEIGHT2 + 150.),
+            Vec2::new(self.position.pos_start.x - 50., -HEIGHT2 + 150.),
             0.0,
-        );
+        )?;
 
         Ok(())
     }
+
+    pub fn update(&mut self, player: &Player) {
+        // Can the enemy see the player?
+        if player.pos_x - self.position.pos_start.x > -457.0
+            && player.pos_x - self.position.pos_start.x < 457.0
+        {
+            // TODO: The enemy shoots the player as soon as it see's the player.
+        }
+    }
+
+    pub fn position(&self) -> Position {
+        self.position
+    }
 }

src/components/cloud.rs

@@ -1,10 +1,12 @@
-use ggez::{graphics::Image, Context, GameResult};
+use ggez::{Context, GameResult};
 use ggez_goodies::{
     camera::{Camera, CameraDraw},
     nalgebra_glm::Vec2,
 };
 
-use crate::{utils::lerp, HEIGHT};
+use crate::{HEIGHT, utils::{AssetManager, lerp}};
+
+const HEIGHT2: f32 = HEIGHT / 2.;
 
 use super::bullet::Turbofish;
 
@@ -51,23 +53,24 @@ impl Player {
         &mut self,
         ctx: &mut Context,
         camera: &Camera,
-        resources: &Vec<Image>,
+        asset_manager: &AssetManager,
     ) -> GameResult<()> {
-        const HEIGHT2: f32 = HEIGHT / 2.;
+        let ferris = asset_manager.get_image("Some(ferris).png");
+        let turbofish_sniper = asset_manager.get_image("Some(sniper).png");
 
-        &resources[0].draw_camera(
+        ferris.draw_camera(
             &camera,
             ctx,
             Vec2::new(self.pos_x, (-HEIGHT2 + 155.) + self.pos_y),
             0.0,
-        );
+        )?;
 
-        &resources[1].draw_camera(
+        turbofish_sniper.draw_camera(
             &camera,
             ctx,
             Vec2::new(self.pos_x + 30., (-HEIGHT2 + 120.) + self.pos_y),
             0.0,
-        );
+        )?;
 
         Ok(())
     }
@@ -119,13 +122,12 @@ impl Player {
         }
     }
 
-    pub fn shoot(&mut self) -> Option<Turbofish> {
-        const HEIGHT2: f32 = HEIGHT / 2.;
-
+    pub fn shoot(&mut self, asset_manager: &AssetManager) -> Option<Turbofish> {
         if self.ammo as i32 != 0 {
             return Some(Turbofish::new(
                 self.pos_x + 220.,
                 (-HEIGHT2 + 106.) + self.pos_y,
+                asset_manager
             ));
         } else {
             None