Merge branch 'player-movement' into map_assets

game/dist/project-constants.json

@@ -5,6 +5,7 @@
         720
     ],
     "target_fps": 60,
+    "tile_size": 128,
     "discord": {
         "app_id": 954413081918857276,
         "artwork": {
@@ -15,5 +16,10 @@
             "details.sm_failure": "Game went FUBAR",
             "details.main_menu": "In the main menu"
         }
+    },
+    "player": {
+        "max_velocity": 3,
+        "acceleration": 2,
+        "deceleration": 1
     }
-}
+}

game/game_logic/src/model/player.rs

@@ -5,6 +5,7 @@ use nalgebra as na;
 pub struct Player {
     pub position: na::Vector2<f32>,
     pub velocity: na::Vector2<f32>,
+    pub size: f32,
 }
 
 impl Player {
@@ -14,7 +15,8 @@ impl Player {
         Self {
             position,
             velocity: na::Vector2::zeros(),
+            size: 1.0, 
         }
     }
 
-}
+}

game/game_logic/src/project_constants.rs

@@ -28,6 +28,20 @@ pub struct DiscordConstants {
     pub strings: HashMap<String, String>,
 }
 
+/// Constants relating to the Player
+#[derive(Debug, Deserialize)]
+pub struct PlayerConstants {
+
+    /// Maximum velocity, tiles per second
+    pub max_velocity: u32,
+
+    /// Acceleration, tiles per second per second
+    pub acceleration: u32,
+
+    /// Deceleration, tiles per second per second
+    pub deceleration: u32,
+}
+
 /// This structure is filled with the contents of `dist/project-constants.json` at runtime
 #[derive(Debug, Deserialize)]
 pub struct ProjectConstants {
@@ -40,6 +54,12 @@ pub struct ProjectConstants {
     /// The Discord constants
     pub discord: DiscordConstants,
 
+    /// The Player constants
+    pub player: PlayerConstants,
+
     /// The target framerate of the game
     pub target_fps: u32,
+
+    /// The size of the game tiles
+    pub tile_size: u32,
 }

game/game_logic/src/scenes/mod.rs

@@ -73,6 +73,9 @@ impl SceneRenderDelegate {
                 self.scene_test_fox
                     .render_frame(raylib, rl_thread, &discord, global_resources)
                     .await;
+                self.scene_playable
+                    .update_physics(raylib, constants)
+                    .await;
             }
             MenuStateSignal::QuitGame => unimplemented!(),
             MenuStateSignal::DoMainMenu => {

game/game_logic/src/scenes/player_interaction.rs

@@ -2,6 +2,7 @@
 
 use nalgebra as na;
 use raylib::prelude::*;
+use std::time::SystemTime;
 
 use crate::{
     discord::{DiscordChannel, DiscordRpcSignal},
@@ -15,26 +16,41 @@ use crate::{
 pub struct PlayableScene {
     has_updated_discord_rpc: bool,
     player: Player,
+    camera: raylib::camera::Camera2D,
+    last_update: SystemTime,
 }
 
 impl PlayableScene {
     /// Construct a new `PlayableScene`
     pub fn new(
-        raylib_handle: &mut RaylibHandle,
+        raylib_handle: &mut raylib::RaylibHandle,
-        thread: &RaylibThread,
+        thread: & raylib::RaylibThread,
         constants: &ProjectConstants,
     ) -> Self {
         Self {
             has_updated_discord_rpc: false,
             player: Player::new(na::Vector2::new(10.0, 10.0)),
+            camera: raylib::camera::Camera2D {
+                target: raylib::math::Vector2 { 
+                    x: 0.0, 
+                    y: 0.0,
+                },
+                offset: raylib::math::Vector2 { 
+                    x: (constants.base_window_size.0 as f32 / 2.0),
+                    y: (constants.base_window_size.1 as f32 / 2.0) 
+                },
+                rotation: 0.0,
+                zoom: 1.0
+            },
+            last_update: SystemTime::UNIX_EPOCH
         }
     }
 
     /// Handler for each frame
     pub async fn render_frame(
         &mut self,
-        raylib: &mut RaylibHandle,
+        raylib: &mut raylib::RaylibHandle,
-        rl_thread: &RaylibThread,
+        rl_thread: &raylib::RaylibThread,
         discord: &DiscordChannel,
         global_resources: &GlobalResources,
         constants: &ProjectConstants,
@@ -61,7 +77,71 @@ impl PlayableScene {
         // Clear the screen
         draw.clear_background(Color::WHITE);
 
-        // TODO: Render stuff
+        for i in 0..100 {
-        // self.player. <whatever>
+            for j in 0..100 {
+                draw.draw_rectangle(
+                    constants.tile_size as i32 * (i * 2),
+                    constants.tile_size as i32 * (j * 2) * -1,
+                    constants.tile_size as i32,
+                    constants.tile_size as i32,
+                    Color::RED
+                )
+            }
+        }    
+
+        draw.draw_rectangle(
+            self.player.position[0] as i32, 
+            self.player.position[1] as i32 * -1,
+            (constants.tile_size as f32 * self.player.size) as i32, 
+            (constants.tile_size as f32 * self.player.size) as i32, 
+            Color::GREEN
+        );
+    }
+        
+    // Physics
+    pub async fn update_physics(
+        &mut self,
+        raylib: & raylib::RaylibHandle,
+        constants: &ProjectConstants,
+    ) {
+
+        // Get time since last physics update
+        let time = SystemTime::now();
+        let elapsed = time.duration_since(self.last_update).expect("Time Appears to Have Moved Backwards!");
+        self.last_update = time;
+        let delta_time = elapsed.as_millis() as f32 / 1000.0; // Physics will be scaled by this value
+
+        let player = &mut self.player;
+
+        // Get input direction components
+        let h_axis = raylib.is_key_down(KeyboardKey::KEY_D) as i8 - raylib.is_key_down(KeyboardKey::KEY_A) as i8;
+        let v_axis = raylib.is_key_down(KeyboardKey::KEY_W) as i8 - raylib.is_key_down(KeyboardKey::KEY_S) as i8;
+        if h_axis != 0 || v_axis != 0 {
+            // Normalize input and accelerate in desired direction
+            let direction = na::Vector2::new(h_axis as f32, v_axis as f32).normalize();
+            player.velocity += &direction.xy() 
+                * constants.player.acceleration as f32
+                * constants.tile_size as f32 
+                * delta_time;
+        }
+
+        if player.velocity.magnitude() != 0.0 {
+            player.velocity -= player.velocity.normalize() 
+                * constants.player.deceleration as f32 
+                * constants.tile_size as f32 
+                * delta_time;
+            if player.velocity.magnitude() < 0.01 {
+                player.velocity.set_magnitude(0.0);
+            }
+        }
+
+        if ((constants.player.max_velocity * constants.tile_size) as f32) 
+            < player.velocity.magnitude() {
+            player.velocity.set_magnitude((constants.player.max_velocity * constants.tile_size) as f32);
+        }
+
+        player.position += &player.velocity * delta_time;
     }
 }
+
+