Draft 01/29/2024

Draft of the code as of the 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().position().x,
+            gamestate.player().position().y,
+            10,
+            gamestate.player().get_color().to_owned(),
+        )?;
+        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,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

@@ -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 Position {
+    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);
+    }
+}