Draft 01/29/2024

Draft of the code as of the date described above.

vash_caster/src/caster.rs

@@ -4,18 +4,18 @@ use sdl2::gfx::primitives::DrawRenderer;
 use sdl2::pixels::Color;
 use sdl2::{render::Canvas, video::Window, VideoSubsystem};
 
-use rand::prelude::*;
+use crate::game_state::GameState;
 
 pub struct Caster {
     projection_plane: Canvas<Window>,
-    title: &'static str,
-    width: u32,
-    height: u32,
+    _title: &'static str,
+    _width: u32,
+    _height: u32,
 }
 
 impl Caster {
     pub fn init(
-        video_subsystem: &VideoSubsystem,
+        video_subsystem: VideoSubsystem,
         win_title: &'static str,
         win_width: u32,
         win_height: u32,
@@ -31,69 +31,23 @@ impl Caster {
 
         Ok(Self {
             projection_plane: canvas,
-            title: win_title,
-            width: win_width,
-            height: win_height,
+            _title: win_title,
+            _width: win_width,
+            _height: win_height,
         })
     }
 
-    pub fn update(&mut self) -> Result<(), Box<dyn Error>> {
-        let mut rng = rand::thread_rng();
-        let mut d_x = rng.gen_range(1..=5);
-        let mut d_y = rng.gen_range(1..=5);
-        let mut cur_x = rng.gen_range(0..=800);
-        let mut cur_y = rng.gen_range(0..=600);
-        let mut ball_color = Color::RGB(
-            rng.gen_range(0..=255),
-            rng.gen_range(0..=255),
-            rng.gen_range(0..=255),
-        );
-
+    pub fn update(&mut self, gamestate: &GameState) -> Result<(), Box<dyn Error>> {
         self.projection_plane.set_draw_color(Color::RGB(0, 0, 0));
         self.projection_plane.clear();
-        self.projection_plane
-            .filled_circle(cur_x, cur_y, 10, ball_color)?;
+        self.projection_plane.filled_circle(
+            gamestate.player().position().x,
+            gamestate.player().position().y,
+            10,
+            gamestate.player().get_color().to_owned(),
+        )?;
         self.projection_plane.present();
 
-        cur_x += d_x;
-
-        if cur_x < 0 {
-            cur_x = 0;
-            ball_color = Color::RGB(
-                rng.gen_range(0..=255),
-                rng.gen_range(0..=255),
-                rng.gen_range(0..=255),
-            );
-            d_x = rng.gen_range(1..=5);
-        } else if cur_x > 800 {
-            cur_x = 800;
-            ball_color = Color::RGB(
-                rng.gen_range(0..=255),
-                rng.gen_range(0..=255),
-                rng.gen_range(0..=255),
-            );
-            d_x = rng.gen_range(-5..=-1);
-        }
-
-        cur_y += d_y;
-
-        if cur_y < 0 {
-            cur_y = 0;
-            ball_color = Color::RGB(
-                rng.gen_range(0..=255),
-                rng.gen_range(0..=255),
-                rng.gen_range(0..=255),
-            );
-            d_y = rng.gen_range(1..=5);
-        } else if cur_y > 600 {
-            cur_y = 600;
-            ball_color = Color::RGB(
-                rng.gen_range(0..=255),
-                rng.gen_range(0..=255),
-                rng.gen_range(0..=255),
-            );
-            d_y = rng.gen_range(-5..=-1);
-        }
         Ok(())
     }
 }

vash_caster/src/event_handler.rs

@@ -0,0 +1,20 @@
+use sdl2::event::Event;
+use sdl2::keyboard::Keycode;
+use sdl2::EventPump;
+
+use crate::game_state::GameState;
+
+pub fn process_events(event_pump: &mut EventPump, game_state: &mut GameState) {
+    for event in event_pump.poll_iter() {
+        match event {
+            Event::Quit { .. }
+            | Event::KeyDown {
+                keycode: Some(Keycode::Escape),
+                ..
+            } => {
+                game_state.set_running(false);
+            }
+            _ => {}
+        }
+    }
+}

vash_caster/src/game_state.rs

@@ -0,0 +1,82 @@
+use rand::prelude::*;
+
+mod player;
+use self::player::Player;
+
+pub struct GameState {
+    player: Player,
+    running: bool,
+    pub rng: ThreadRng,
+}
+
+impl GameState {
+    pub fn init() -> Self {
+        let mut new_rng = rand::thread_rng();
+
+        Self {
+            player: Player::init(new_rng.gen_range(0..800), new_rng.gen_range(0..600), 0.0),
+            running: true,
+            rng: new_rng,
+        }
+    }
+
+    pub fn update(&mut self) {
+        self.player.set_position(
+            self.player.position().x + self.player.dx(),
+            self.player.position().y,
+        );
+
+        if self.player.position().x < 0 {
+            self.player.set_position(0, self.player.position().y);
+            self.player.set_color(
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+            );
+            self.player.set_dx(self.rng.gen_range(1..=5));
+        } else if self.player.position().x > 800 {
+            self.player.set_position(800, self.player.position().y);
+            self.player.set_color(
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+            );
+            self.player.set_dx(self.rng.gen_range(-5..=-1));
+        }
+
+        self.player.set_position(
+            self.player.position().x,
+            self.player.position().y + self.player.dy(),
+        );
+
+        if self.player.position().y < 0 {
+            self.player.set_position(self.player.position().x, 0);
+            self.player.set_color(
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+            );
+            self.player.set_dy(self.rng.gen_range(1..=5));
+        } else if self.player.position().y > 600 {
+            self.player.set_position(self.player.position().x, 600);
+            self.player.set_color(
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+            );
+            self.player.set_dy(self.rng.gen_range(-5..=-1));
+        }
+    }
+
+    pub fn player(&self) -> &Player {
+        &self.player
+    }
+
+    pub fn running(&self) -> bool {
+        self.running
+    }
+
+    pub fn set_running(&mut self, is_running: bool) {
+        self.running = is_running;
+    }
+}

vash_caster/src/game_state/player.rs

@@ -0,0 +1,56 @@
+use sdl2::pixels::Color;
+
+use crate::Position;
+
+pub struct Player {
+    pos: Position,
+    dx: i16,
+    dy: i16,
+    _rot: f32,
+    color: Color,
+}
+
+impl Player {
+    pub fn init(x_pos: i16, y_pos: i16, rotation: f32) -> Self {
+        Self {
+            pos: Position { x: x_pos, y: y_pos },
+            dx: 1,
+            dy: 1,
+            _rot: rotation,
+            color: Color::RGB(255, 0, 0),
+        }
+    }
+
+    pub fn position(&self) -> &Position {
+        &self.pos
+    }
+
+    pub fn get_color(&self) -> &Color {
+        &self.color
+    }
+
+    pub fn set_position(&mut self, new_x: i16, new_y: i16) {
+        self.pos.x = new_x;
+        self.pos.y = new_y;
+    }
+
+    pub fn set_color(&mut self, r: u8, g: u8, b: u8) {
+        self.color = Color::RGB(r, g, b);
+    }
+
+    pub fn set_dx(&mut self, new_dx: i16) {
+        self.dx = new_dx;
+    }
+
+    pub fn set_dy(&mut self, new_dy: i16) {
+        self.dy = new_dy;
+    }
+
+    pub fn dx(&self) -> i16 {
+        self.dx
+    }
+
+    pub fn dy(&self) -> i16 {
+        self.dy
+    }
+}

vash_caster/src/lib.rs

@@ -4,8 +4,10 @@ extern crate sdl2;
 mod caster;
 use caster::Caster;
 
-use sdl2::event::Event;
-use sdl2::keyboard::Keycode;
+mod game_state;
+use game_state::GameState;
+
+mod event_handler;
 
 use std::error::Error;
 use std::time::Duration;
@@ -13,27 +15,23 @@ use std::time::Duration;
 pub fn run() -> Result<(), Box<dyn Error>> {
     let sdl_context = sdl2::init()?;
     let video_subsystem = sdl_context.video()?;
-
-    let mut caster = Caster::init(&video_subsystem, "Vash Caster", 800, 600)?;
-
     let mut event_pump = sdl_context.event_pump()?;
 
-    'running: loop {
-        for event in event_pump.poll_iter() {
-            match event {
-                Event::Quit { .. }
-                | Event::KeyDown {
-                    keycode: Some(Keycode::Escape),
-                    ..
-                } => break 'running,
-                _ => {}
-            }
-        }
+    let mut gamestate = GameState::init();
+    let mut caster = Caster::init(video_subsystem, "Vash Caster", 800, 600)?;
 
-        caster.update()?;
+    while gamestate.running() {
+        event_handler::process_events(&mut event_pump, &mut gamestate);
+        gamestate.update();
+        caster.update(&gamestate)?;
 
         ::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 144));
     }
 
     Ok(())
 }
+
+struct Position {
+    x: i16,
+    y: i16,
+}