Draft 01/28/2024

Draft of the code from date described above.

Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+members = ["vash_caster", "caster_editor"]
+resolver = "2"

caster_editor/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "caster_editor"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

caster_editor/src/main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}

vash_caster/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "vash_caster"
+version = "0.1.0"
+edition = "2021"
+default-run = "vash_caster"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+sdl2 = { version = "0.36", features = ["gfx"] }
+rand = "0.8"

vash_caster/src/caster.rs

@@ -0,0 +1,53 @@
+use std::error::Error;
+
+use sdl2::gfx::primitives::DrawRenderer;
+use sdl2::pixels::Color;
+use sdl2::{render::Canvas, video::Window, VideoSubsystem};
+
+use crate::game_state::GameState;
+
+pub struct Caster {
+    projection_plane: Canvas<Window>,
+    _title: &'static str,
+    _width: u32,
+    _height: u32,
+}
+
+impl Caster {
+    pub fn init(
+        video_subsystem: VideoSubsystem,
+        win_title: &'static str,
+        win_width: u32,
+        win_height: u32,
+    ) -> Result<Self, Box<dyn Error>> {
+        let window = video_subsystem
+            .window(win_title, win_width, win_height)
+            .position_centered()
+            .opengl()
+            .build()
+            .map_err(|e| e.to_string())?;
+
+        let canvas = window.into_canvas().build().map_err(|e| e.to_string())?;
+
+        Ok(Self {
+            projection_plane: canvas,
+            _title: win_title,
+            _width: win_width,
+            _height: win_height,
+        })
+    }
+
+    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(
+            gamestate.player().x,
+            gamestate.player().y,
+            10,
+            gamestate.p_color,
+        )?;
+        self.projection_plane.present();
+
+        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,92 @@
+use sdl2::pixels::Color;
+
+use rand::prelude::*;
+
+use crate::Point;
+
+pub struct GameState {
+    player: Point,
+    pub p_dx: i16,
+    pub p_dy: i16,
+    pub p_rot: f32,
+    pub p_color: Color,
+    running: bool,
+    pub rng: ThreadRng,
+}
+
+impl GameState {
+    pub fn init() -> Self {
+        let mut new_rng = rand::thread_rng();
+
+        Self {
+            player: Point {
+                x: new_rng.gen_range(0..800),
+                y: new_rng.gen_range(0..600),
+            },
+            p_dx: new_rng.gen_range(1..=5),
+            p_dy: new_rng.gen_range(1..=5),
+            p_rot: 90.0,
+            p_color: Color::RGB(
+                new_rng.gen_range(0..=255),
+                new_rng.gen_range(0..=255),
+                new_rng.gen_range(0..=255),
+            ),
+            running: true,
+            rng: new_rng,
+        }
+    }
+
+    pub fn update(&mut self) {
+        self.player.x += self.p_dx;
+
+        if self.player.x < 0 {
+            self.player.x = 0;
+            self.p_color = Color::RGB(
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+            );
+            self.p_dx = self.rng.gen_range(1..=5);
+        } else if self.player.x > 800 {
+            self.player.x = 800;
+            self.p_color = Color::RGB(
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+            );
+            self.p_dx = self.rng.gen_range(-5..=-1);
+        }
+
+        self.player.y += self.p_dy;
+
+        if self.player.y < 0 {
+            self.player.y = 0;
+            self.p_color = Color::RGB(
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+            );
+            self.p_dy = self.rng.gen_range(1..=5);
+        } else if self.player.y > 600 {
+            self.player.y = 600;
+            self.p_color = Color::RGB(
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+                self.rng.gen_range(0..=255),
+            );
+            self.p_dy = self.rng.gen_range(-5..=-1);
+        }
+    }
+
+    pub fn player(&self) -> &Point {
+        &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/lib.rs

@@ -0,0 +1,37 @@
+extern crate rand;
+extern crate sdl2;
+
+mod caster;
+use caster::Caster;
+
+mod game_state;
+use game_state::GameState;
+
+mod event_handler;
+
+use std::error::Error;
+use std::time::Duration;
+
+pub fn run() -> Result<(), Box<dyn Error>> {
+    let sdl_context = sdl2::init()?;
+    let video_subsystem = sdl_context.video()?;
+    let mut event_pump = sdl_context.event_pump()?;
+
+    let mut gamestate = GameState::init();
+    let mut caster = Caster::init(video_subsystem, "Vash Caster", 800, 600)?;
+
+    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 Point {
+    x: i16,
+    y: i16,
+}

vash_caster/src/main.rs

@@ -0,0 +1,9 @@
+use vash_caster::run;
+
+use std::process;
+fn main() {
+    if let Err(e) = run() {
+        println!("An error has occured: {e}");
+        process::exit(1);
+    }
+}