Very basic collisions with the world (janky)

game/src/character/collisions.rs

@@ -2,11 +2,17 @@ use std::ops::Mul;
 
 use raylib::math::{Rectangle, Vector2};
 
+use crate::scenes::ingame_scene::world::WORLD_LEVEL_X_OFFSET;
+
 use super::{CharacterState, MainCharacter};
 
 pub const GRAVITY_PPS: f32 = 2.0;
 
-pub fn modify_player_based_on_forces(player: &mut MainCharacter) -> Result<(), ()> {
+pub fn modify_player_based_on_forces(
+    player: &mut MainCharacter,
+    colliders: &Vec<Rectangle>,
+    level_height_offset: f32,
+) -> Result<(), ()> {
     // Modify the player's velocity by the forces
     player.movement_force += player.base_velocity;
     player.velocity = player.movement_force;
@@ -14,7 +20,7 @@ pub fn modify_player_based_on_forces(player: &mut MainCharacter) -> Result<(), (
     // Predict the player's position next frame
     let predicted_player_position = player.position + player.velocity;
 
-    // Calculate a bounding rect around the player
+    // Calculate a bounding rect around the player both now, and one frame in the future
     let player_rect = Rectangle::new(
         predicted_player_position.x - (player.size.x / 2.0),
         predicted_player_position.y - (player.size.x / 2.0),
@@ -25,10 +31,24 @@ pub fn modify_player_based_on_forces(player: &mut MainCharacter) -> Result<(), (
     // Calculate a generic "floor" to always collide with
     let floor_rect = Rectangle::new(f32::MIN, 0.0, f32::MAX, 1.0);
 
+    // Check collision conditions
+    let check_player_colliding_with_floor = || floor_rect.check_collision_recs(&player_rect);
+    let check_player_colliding_with_floor_next_frame =
+        || player_rect.y + player_rect.height > floor_rect.y;
+    let check_player_colliding_with_colliders = || {
+        colliders.iter().any(|rect| {
+            let mut translated_rect = rect.clone();
+            translated_rect.y += level_height_offset;
+            translated_rect.x += WORLD_LEVEL_X_OFFSET;
+            translated_rect.check_collision_recs(&player_rect)
+        })
+    };
+
     // 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)
-        && player.velocity.y > 0.0
+    if (check_player_colliding_with_floor()
+        || check_player_colliding_with_floor_next_frame()
+        || check_player_colliding_with_colliders())
+        && player.velocity.y != 0.0
     {
         player.velocity.y = 0.0;
 
@@ -36,11 +56,17 @@ pub fn modify_player_based_on_forces(player: &mut MainCharacter) -> Result<(), (
         if player.current_state == CharacterState::Jumping
             || player.current_state == CharacterState::Dashing
         {
-            player.update_player(Some(CharacterState::Running));
+            player.update_player(
+                Some(CharacterState::Running),
+                colliders,
+                level_height_offset,
+            );
             return Ok(());
         }
     }
 
+    // Check sideways collisions
+
     // Finally apply the velocity to the player
     player.position += player.velocity;
 

game/src/character/mod.rs

@@ -2,7 +2,10 @@ pub mod collisions;
 pub mod render;
 
 use chrono::{DateTime, Utc};
-use raylib::{math::Vector2, texture::Texture2D};
+use raylib::{
+    math::{Rectangle, Vector2},
+    texture::Texture2D,
+};
 
 use crate::utilities::anim_render::AnimatedSpriteSheet;
 
@@ -48,7 +51,12 @@ impl MainCharacter {
         }
     }
 
-    pub fn update_player(&mut self, state: Option<CharacterState>) {
+    pub fn update_player(
+        &mut self,
+        state: Option<CharacterState>,
+        colliders: &Vec<Rectangle>,
+        level_height_offset: f32,
+    ) {
         if let Some(state) = state {
             // Update the internal state
             if state != self.current_state {
@@ -65,6 +73,6 @@ impl MainCharacter {
         }
 
         // Update the player based on the new velocity
-        modify_player_based_on_forces(self).unwrap();
+        modify_player_based_on_forces(self, colliders, level_height_offset).unwrap();
     }
 }

game/src/scenes/ingame_scene/mod.rs

@@ -18,7 +18,7 @@ use tracing::{debug, trace};
 mod hud;
 pub mod level;
 mod update;
-mod world;
+pub mod world;
 
 #[derive(Debug)]
 pub struct InGameScreen {
@@ -43,7 +43,7 @@ impl InGameScreen {
                 rotation: 0.0,
                 zoom: 1.0,
             },
-            player: MainCharacter::new(Vector2::new(0.0, -80.0), player_sprite_sheet),
+            player: MainCharacter::new(Vector2::new(0.0, -85.0), player_sprite_sheet),
             world_background: WorldPaintTexture::new(background_texture),
             levels,
             current_level_idx: 0,
@@ -61,7 +61,12 @@ impl Action<Scenes, ScreenError, GameContext> for InGameScreen {
         debug!("Running InGameScreen for the first time");
 
         // Set the player to running
-        self.player.update_player(Some(CharacterState::Running));
+        let cur_level = self.levels.get(self.current_level_idx).unwrap();
+        self.player.update_player(
+            Some(CharacterState::Running),
+            &cur_level.colliders,
+            -cur_level.platform_tex.height as f32,
+        );
 
         Ok(())
     }

game/src/scenes/ingame_scene/update.rs

@@ -17,6 +17,11 @@ impl FrameUpdate for InGameScreen {
         config: &GameConfig,
     ) {
         puffin::profile_function!();
+
+        // Get the current level
+        let cur_level = self.levels.get(self.current_level_idx).unwrap();
+
+
         // Set the camera's offset based on screen size
         self.camera.offset = raylib.get_screen_size().div(Vector2::new(2.0, 1.05));
         self.camera.target = Vector2::new(self.player.position.x, self.camera.target.y);
@@ -28,16 +33,20 @@ impl FrameUpdate for InGameScreen {
             && !(self.player.current_state == CharacterState::Dashing);
 
         if is_jump {
-            self.player.update_player(Some(CharacterState::Jumping));
+            self.player.update_player(Some(CharacterState::Jumping), &cur_level.colliders,
+            -cur_level.platform_tex.height as f32,);
         } else if is_dash {
-            self.player.update_player(Some(CharacterState::Dashing));
+            self.player.update_player(Some(CharacterState::Dashing), &cur_level.colliders,
+            -cur_level.platform_tex.height as f32,);
         } else {
             if self.player.current_state != CharacterState::Jumping
                 && self.player.current_state != CharacterState::Dashing
             {
-                self.player.update_player(Some(CharacterState::Running));
+                self.player.update_player(Some(CharacterState::Running), &cur_level.colliders,
+                -cur_level.platform_tex.height as f32,);
             } else {
-                self.player.update_player(None);
+                self.player.update_player(None, &cur_level.colliders,
+                    -cur_level.platform_tex.height as f32,);
             }
         }
     }

game/src/scenes/ingame_scene/world.rs

@@ -8,6 +8,8 @@ use crate::{
 };
 use raylib::prelude::*;
 
+pub const WORLD_LEVEL_X_OFFSET: f32 = 200.0;
+
 impl WorldSpaceRender for InGameScreen {
     fn render_world_space(
         &self,
@@ -23,7 +25,7 @@ impl WorldSpaceRender for InGameScreen {
         // self.world_background.render(raylib, Vector2::new(0.0, -1080.0), &self.camera);
 
         // Render the platform layer
-        raylib.draw_texture_v(&cur_level.platform_tex, Vector2::new(-10.0, -cur_level.platform_tex.height as f32), Color::WHITE);
+        raylib.draw_texture_v(&cur_level.platform_tex, Vector2::new(WORLD_LEVEL_X_OFFSET, -cur_level.platform_tex.height as f32), Color::WHITE);
 
         // Render the floor as a line
         let screen_world_zero = raylib.get_screen_to_world2D(Vector2::zero(), self.camera);