Fix wonky physics issues

game/src/character/collisions.rs

@@ -1,12 +1,20 @@
+use std::ops::Mul;
+
 use raylib::math::{Rectangle, Vector2};
 
 use super::{CharacterState, MainCharacter};
 
-const GRAVITY_PPS: f32 = 2.0;
+pub const GRAVITY_PPS: f32 = 2.0;
 
 pub fn modify_player_based_on_forces(player: &mut MainCharacter) -> Result<(), ()> {
-    // Convert the player to a rectangle
+    // Modify the player's velocity by the forces
+    player.movement_force += player.base_velocity;
+    player.velocity = player.movement_force;
+
+    // Predict the player's position next frame
     let predicted_player_position = player.position + player.velocity;
+
+    // Calculate a bounding rect around the player
     let player_rect = Rectangle::new(
         predicted_player_position.x - (player.size.x / 2.0),
         predicted_player_position.y - (player.size.x / 2.0),
@@ -18,23 +26,23 @@ pub fn modify_player_based_on_forces(player: &mut MainCharacter) -> Result<(), (
     let floor_rect = Rectangle::new(f32::MIN, 0.0, f32::MAX, 1.0);
 
     // If the player is colliding, only apply the x force
-    if (floor_rect.check_collision_recs(&player_rect) || player_rect.y + player_rect.height > floor_rect.y)
+    if (floor_rect.check_collision_recs(&player_rect)
+        || player_rect.y + player_rect.height > floor_rect.y)
         && player.velocity.y > 0.0
     {
         player.velocity.y = 0.0;
 
         // Handle ending a jump
-        if player.current_state == CharacterState::Jumping {
+        if player.current_state == CharacterState::Jumping
-            player.set_state(CharacterState::Running);
+            || player.current_state == CharacterState::Dashing
+        {
+            player.update_player(Some(CharacterState::Running));
+            return Ok(());
         }
     }
 
-    // TODO: Error out if colliding in the X direction
+    // Finally apply the velocity to the player
-
-    // Apply the force
     player.position += player.velocity;
 
-    // Apply gravity
-    player.velocity.y += GRAVITY_PPS;
     Ok(())
 }

game/src/character/mod.rs

@@ -6,9 +6,9 @@ use raylib::{math::Vector2, texture::Texture2D};
 
 use crate::utilities::anim_render::AnimatedSpriteSheet;
 
-use self::collisions::modify_player_based_on_forces;
+use self::collisions::{modify_player_based_on_forces, GRAVITY_PPS};
 
-#[derive(Debug, Default, PartialEq, Eq)]
+#[derive(Debug, Default, PartialEq, Eq, Clone)]
 pub enum CharacterState {
     #[default]
     Running,
@@ -19,6 +19,8 @@ pub enum CharacterState {
 #[derive(Debug)]
 pub struct MainCharacter {
     pub position: Vector2,
+    pub movement_force: Vector2,
+    pub base_velocity: Vector2,
     pub velocity: Vector2,
     pub size: Vector2,
     pub sprite_sheet: AnimatedSpriteSheet,
@@ -30,7 +32,9 @@ impl MainCharacter {
     pub fn new(position: Vector2, sprite_sheet: Texture2D) -> Self {
         Self {
             position,
-            velocity: Vector2::new(20.0, 0.0),
+            movement_force: Vector2::zero(),
+            velocity: Vector2::zero(),
+            base_velocity: Vector2::new(0.0, GRAVITY_PPS),
             size: Vector2::new(100.0, 130.0),
             sprite_sheet: AnimatedSpriteSheet::new(
                 sprite_sheet,
@@ -44,20 +48,23 @@ impl MainCharacter {
         }
     }
 
-    pub fn apply_force(&mut self, force: Vector2) -> Option<()> {
+    pub fn update_player(&mut self, state: Option<CharacterState>) {
-        self.velocity = force;
+        if let Some(state) = state {
-        modify_player_based_on_forces(self).unwrap();
+            // Update the internal state
-        Some(())
+            if state != self.current_state {
-    }
+                self.current_state = state.clone();
+                self.state_set_timestamp = Utc::now();
+            }
 
-    pub fn update_gravity(&mut self) {
+            // Handle extra external forces based on the character state
-        modify_player_based_on_forces(self).unwrap();
+            self.movement_force = match state {
-    }
+                CharacterState::Running => Vector2::new(12.0, 0.0),
-
+                CharacterState::Jumping => Vector2::new(12.0, -30.0),
-    pub fn set_state(&mut self, state: CharacterState) {
+                CharacterState::Dashing => Vector2::new(30.0, -20.0),
-        if state != self.current_state {
+            };
-            self.current_state = state;
-            self.state_set_timestamp = Utc::now();
         }
+
+        // Update the player based on the new velocity
+        modify_player_based_on_forces(self).unwrap();
     }
 }

game/src/character/render.rs

@@ -1,4 +1,4 @@
-use std::ops::{Div, Sub};
+use std::ops::{Add, Div, Mul, Sub};
 
 use chrono::Utc;
 use raylib::prelude::*;
@@ -37,4 +37,16 @@ pub fn render_character_in_camera_space(
         Some(Vector2::new(player.size.y, player.size.y)),
         Some(frame_id),
     );
+
+    // Possibly render a debug vector
+    if config.debug_view {
+        raylib.draw_line_v(
+            player.position.sub(player.size.div(2.0)),
+            player
+                .position
+                .sub(player.size.div(2.0))
+                .add(player.velocity.mul(10.0).add(Vector2::new(0.0, 100.0))),
+            Color::RED,
+        );
+    }
 }

game/src/lib.rs

@@ -106,7 +106,7 @@ pub use utilities::{datastore::StaticGameData, game_config::GameConfig};
 mod character;
 
 /// The game entrypoint
-pub async fn game_begin(game_config: &GameConfig) -> Result<(), Box<dyn std::error::Error>> {
+pub async fn game_begin(game_config: &mut GameConfig) -> Result<(), Box<dyn std::error::Error>> {
     // Set up profiling
     #[cfg(debug_assertions)]
     let _puffin_server =
@@ -209,6 +209,19 @@ pub async fn game_begin(game_config: &GameConfig) -> Result<(), Box<dyn std::err
             .update(&mut context.renderer.borrow_mut(), &raylib_thread)
             .unwrap();
 
+        // If in dev mode, allow a debug key
+        #[cfg(debug_assertions)]
+        {
+            if context.renderer.borrow().is_key_pressed(KeyboardKey::KEY_F3) {
+                game_config.debug_view = !game_config.debug_view;
+            }
+        }
+
+        // Handle fullscreen shortcut
+        if context.renderer.borrow().is_key_pressed(KeyboardKey::KEY_F11) {
+            context.renderer.borrow_mut().toggle_fullscreen();
+        }
+
         // Switch into draw mode the unsafe way (using unsafe code here to avoid borrow checker hell)
         #[allow(unsafe_code)]
         unsafe {

game/src/scenes/ingame_scene/mod.rs

@@ -43,7 +43,7 @@ impl Action<Scenes, ScreenError, GameContext> for InGameScreen {
         debug!("Running InGameScreen for the first time");
 
         // Set the player to running
-        self.player.set_state(CharacterState::Running);
+        self.player.update_player(Some(CharacterState::Running));
 
         Ok(())
     }

game/src/scenes/ingame_scene/update.rs

@@ -27,16 +27,15 @@ impl FrameUpdate for InGameScreen {
         let is_pause = raylib.is_key_pressed(KeyboardKey::KEY_ESCAPE);
 
         if is_jump {
-            self.player.apply_force(Vector2::new(0.0, -30.0));
+            self.player.update_player(Some(CharacterState::Jumping));
-            self.player.set_state(CharacterState::Jumping);
         } else if is_dash {
-            self.player.apply_force(Vector2::new(40.0, -10.0));
+            self.player.update_player(Some(CharacterState::Dashing));
-            self.player.set_state(CharacterState::Dashing);
         } else {
-            if self.player.current_state != CharacterState::Jumping {
+            if self.player.current_state != CharacterState::Jumping && self.player.current_state != CharacterState::Dashing {
-                self.player.set_state(CharacterState::Running);
+                self.player.update_player(Some(CharacterState::Running));
+            } else {
+                self.player.update_player(None);
             }
         }
-        self.player.update_gravity();
     }
 }

game/src/utilities/game_config.rs

@@ -30,6 +30,9 @@ pub struct GameConfig {
     pub sentry_dsn: String,
     pub colors: ColorTheme,
     pub animation_fps: usize,
+
+    #[serde(skip)]
+    pub debug_view: bool
 }
 
 impl GameConfig {

wrapper/src/main.rs

@@ -7,7 +7,7 @@ async fn main() {
 
     // Load the general config for the game
     // This happens here so we can properly track sentry events
-    let game_config = GameConfig::load(
+    let mut game_config = GameConfig::load(
         StaticGameData::get("configs/application.json").expect("Failed to load application.json"),
     ).unwrap();
 
@@ -22,5 +22,5 @@ async fn main() {
     ));
 
     // Start the game
-    game_begin(&game_config).await.unwrap();
+    game_begin(&mut game_config).await.unwrap();
 }