Merge pull request #20 from Ewpratten/world/base_gfx

Add a background testing texture, and fix the player's many bugs

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(())
-    }
-
-    pub fn update_gravity(&mut self) {
-        modify_player_based_on_forces(self).unwrap();
-    }
-
-    pub fn set_state(&mut self, state: CharacterState) {
             if state != self.current_state {
-            self.current_state = state;
+                self.current_state = state.clone();
                 self.state_set_timestamp = Utc::now();
             }
+
+            // Handle extra external forces based on the character state
+            self.movement_force = match state {
+                CharacterState::Running => Vector2::new(12.0, 0.0),
+                CharacterState::Jumping => Vector2::new(12.0, -30.0),
+                CharacterState::Dashing => Vector2::new(30.0, -20.0),
+            };
+        }
+
+        // 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

@@ -1,7 +1,7 @@
 use dirty_fsm::{Action, ActionFlag};
 use raylib::prelude::*;
 
-use crate::{character::{CharacterState, MainCharacter}, context::GameContext, utilities::render_layer::{FrameUpdate, ScreenSpaceRender, WorldSpaceRender}};
+use crate::{character::{CharacterState, MainCharacter}, context::GameContext, utilities::{render_layer::{FrameUpdate, ScreenSpaceRender, WorldSpaceRender}, world_paint_texture::WorldPaintTexture}};
 
 use super::{Scenes, ScreenError};
 use tracing::{debug, trace};
@@ -14,11 +14,12 @@ mod world;
 pub struct InGameScreen {
     camera: Camera2D,
     player: MainCharacter,
+    world_background: WorldPaintTexture
 }
 
 impl InGameScreen {
     /// Construct a new `InGameScreen`
-    pub fn new(player_sprite_sheet: Texture2D) -> Self {
+    pub fn new(player_sprite_sheet: Texture2D, background_texture: Texture2D) -> Self {
         Self {
             camera: Camera2D {
                 offset: Vector2::zero(),
@@ -27,6 +28,7 @@ impl InGameScreen {
                 zoom: 1.0,
             },
             player: MainCharacter::new(Vector2::new(0.0, -80.0), player_sprite_sheet),
+            world_background: WorldPaintTexture::new(background_texture)
         }
     }
 }
@@ -41,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

@@ -22,21 +22,23 @@ impl FrameUpdate for InGameScreen {
         self.camera.target = Vector2::new(self.player.position.x, self.camera.target.y);
 
         // Check the only possible keyboard inputs
-        let is_jump = raylib.is_key_pressed(KeyboardKey::KEY_SPACE);
+        let is_jump = raylib.is_key_pressed(KeyboardKey::KEY_SPACE)
-        let is_dash = raylib.is_key_pressed(KeyboardKey::KEY_LEFT_SHIFT);
+            && !(self.player.current_state == CharacterState::Jumping);
-        let is_pause = raylib.is_key_pressed(KeyboardKey::KEY_ESCAPE);
+        let is_dash = raylib.is_key_pressed(KeyboardKey::KEY_LEFT_SHIFT)
+            && !(self.player.current_state == CharacterState::Dashing);
 
         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.set_state(CharacterState::Running);
+                && self.player.current_state != CharacterState::Dashing
+            {
+                self.player.update_player(Some(CharacterState::Running));
+            } else {
+                self.player.update_player(None);
             }
         }
-        self.player.update_gravity();
     }
 }

game/src/scenes/ingame_scene/world.rs

@@ -15,8 +15,9 @@ impl WorldSpaceRender for InGameScreen {
         config: &GameConfig,
     ) {
         puffin::profile_function!();
-        // Render the player
+
-        render_character_in_camera_space(raylib, &self.player, &config);
+        // Render the world background
+        self.world_background.render(raylib, Vector2::new(0.0, -1080.0), &self.camera);
 
         // Render the floor as a line
         let screen_world_zero = raylib.get_screen_to_world2D(Vector2::zero(), self.camera);
@@ -30,5 +31,9 @@ impl WorldSpaceRender for InGameScreen {
             5,
             config.colors.white,
         );
+
+
+        // Render the player
+        render_character_in_camera_space(raylib, &self.player, &config);
     }
 }

game/src/scenes/mod.rs

@@ -46,6 +46,8 @@ pub fn build_screen_state_machine(
     // Load the various textures needed by the states
     let player_sprite_sheet =
         load_texture_from_internal_data(raylib_handle, thread, "character/player_run.png").unwrap();
+    let world_background =
+        load_texture_from_internal_data(raylib_handle, thread, "default-texture.png").unwrap();
 
     // Set up the state machine
     let mut machine = StateMachine::new();
@@ -55,6 +57,6 @@ pub fn build_screen_state_machine(
         LoadingScreen::new(raylib_handle, thread)?,
     )?;
     machine.add_action(Scenes::MainMenuScreen, MainMenuScreen::new())?;
-    machine.add_action(Scenes::InGameScene, InGameScreen::new(player_sprite_sheet))?;
+    machine.add_action(Scenes::InGameScene, InGameScreen::new(player_sprite_sheet, world_background))?;
     Ok(machine)
 }

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 {

game/src/utilities/mod.rs

@@ -1,3 +1,4 @@
+pub mod anim_render;
 pub mod datastore;
 pub mod discord;
 pub mod game_config;
@@ -6,4 +7,4 @@ pub mod math;
 pub mod non_ref_raylib;
 pub mod render_layer;
 pub mod shaders;
-pub mod anim_render;
+pub mod world_paint_texture;

game/src/utilities/world_paint_texture.rs

@@ -0,0 +1,57 @@
+//! Defines a texture that tiles across the whole screen in world space
+
+use raylib::{
+    camera::Camera2D,
+    color::Color,
+    math::Vector2,
+    prelude::{RaylibDraw, RaylibMode2D},
+    texture::Texture2D,
+    RaylibHandle,
+};
+
+use super::non_ref_raylib::HackedRaylibHandle;
+
+#[derive(Debug)]
+pub struct WorldPaintTexture {
+    texture: Texture2D,
+}
+
+impl WorldPaintTexture {
+    /// Construct a new world paint texture
+    pub fn new(texture: Texture2D) -> Self {
+        Self { texture }
+    }
+
+    pub fn render(
+        &self,
+        raylib: &mut RaylibMode2D<'_, HackedRaylibHandle>,
+        origin: Vector2,
+        camera: &Camera2D,
+    ) {
+        // Convert the screen edges to world space
+        let top_left = raylib.get_screen_to_world2D(Vector2::new(0.0, 0.0), camera);
+        let bottom_right = raylib.get_screen_to_world2D(raylib.get_screen_size(), camera);
+
+        // Calculate the distance between the edges and the origin
+        let left_edge_distance = top_left.x - origin.x;
+        let right_edge_distance = bottom_right.x - origin.x;
+
+        // Calculate the x position to draw the tile in order for there always to be a tile covering the edges
+        let left_tile_x =
+            (left_edge_distance / self.texture.width as f32).floor() * self.texture.width as f32;
+        let right_tile_x =
+        left_tile_x + self.texture.width as f32;
+
+        // Render the tiles
+        raylib.draw_texture_v(
+            &self.texture,
+            Vector2::new(left_tile_x, origin.y),
+            Color::WHITE,
+        );
+        raylib.draw_texture_v(
+            &self.texture,
+            Vector2::new(right_tile_x, origin.y),
+            Color::WHITE,
+        );
+    }
+}

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();
 }