Merge branch 'master' into pause_menu

game/assets/levels/level_0/colliders.json

@@ -0,0 +1,32 @@
+[
+    {
+        "x": 322,
+        "y": 926,
+        "width": 610,
+        "height": 73
+    },
+    {
+        "x": 852,
+        "y": 882,
+        "width": 81,
+        "height": 178
+    },
+    {
+        "x": 852,
+        "y": 882,
+        "width": 258,
+        "height": 33
+    },
+    {
+        "x": 1599,
+        "y": 699,
+        "width": 918,
+        "height": 63
+    },
+    {
+        "x": 2733,
+        "y": 789,
+        "width": 108,
+        "height": 211
+    }
+]

game/assets/levels/levels.json

@@ -0,0 +1,3 @@
+[
+    "level_0"
+]

game/src/character/collisions.rs

@@ -1,12 +1,26 @@
+use std::ops::Mul;
+
 use raylib::math::{Rectangle, Vector2};
 
+use crate::scenes::ingame_scene::world::WORLD_LEVEL_X_OFFSET;
+
 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<(), ()> {
+pub fn modify_player_based_on_forces(
-    // Convert the player to a rectangle
+    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;
+
+    // Predict the player's position next frame
     let predicted_player_position = player.position + player.velocity;
+
+    // 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),
@@ -17,24 +31,44 @@ 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)
+    if (check_player_colliding_with_floor()
-        && player.velocity.y > 0.0
+        || check_player_colliding_with_floor_next_frame()
+        || check_player_colliding_with_colliders())
+        && 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),
+                colliders,
+                level_height_offset,
+            );
+            return Ok(());
         }
     }
 
-    // TODO: Error out if colliding in the X direction
+    // Check sideways collisions
 
-    // Apply the force
+    // Finally apply the velocity to the player
     player.position += player.velocity;
 
-    // Apply gravity
-    player.velocity.y += GRAVITY_PPS;
     Ok(())
 }

game/src/character/mod.rs

@@ -2,13 +2,16 @@ 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;
 
-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,
@@ -20,6 +23,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,
@@ -31,8 +36,10 @@ impl MainCharacter {
     pub fn new(position: Vector2, sprite_sheet: Texture2D) -> Self {
         Self {
             position,
-            velocity: Vector2::new(20.0, 0.0),
+            movement_force: Vector2::zero(),
-            size: Vector2::new(100.0, 130.0),
+            velocity: Vector2::zero(),
+            base_velocity: Vector2::new(0.0, GRAVITY_PPS),
+            size: Vector2::new(100.0, 100.0),
             sprite_sheet: AnimatedSpriteSheet::new(
                 sprite_sheet,
                 Vector2::new(300.0, 300.0),
@@ -45,20 +52,28 @@ impl MainCharacter {
         }
     }
 
-    pub fn apply_force(&mut self, force: Vector2) -> Option<()> {
+    pub fn update_player(
-        self.velocity = force;
+        &mut self,
-        modify_player_based_on_forces(self).unwrap();
+        state: Option<CharacterState>,
-        Some(())
+        colliders: &Vec<Rectangle>,
-    }
+        level_height_offset: f32,
+    ) {
+        if let Some(state) = state {
+            // Update the internal state
+            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, colliders, level_height_offset).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/level/loader.rs

@@ -0,0 +1,53 @@
+use raylib::{RaylibHandle, RaylibThread};
+
+use crate::{
+    utilities::datastore::{load_texture_from_internal_data, ResourceLoadError},
+    StaticGameData,
+};
+
+use super::Level;
+
+pub fn load_all_levels(
+    raylib_handle: &mut RaylibHandle,
+    thread: &RaylibThread,
+) -> Result<Vec<Level>, ResourceLoadError> {
+    // Get a listing of all levels we have
+    let level_names: Vec<String> = serde_json::from_str(
+        &String::from_utf8(
+            StaticGameData::get("levels/levels.json")
+                .expect("Could not load levels.json")
+                .data
+                .into(),
+        )
+        .unwrap(),
+    )?;
+
+    // Build a level list
+    let mut levels = Vec::new();
+
+    for level_name in &level_names {
+        levels.push(Level {
+            name: level_name.to_string(),
+            background_tex: load_texture_from_internal_data(
+                raylib_handle,
+                thread,
+                &format!("levels/{}/background.png", level_name),
+            )?,
+            platform_tex: load_texture_from_internal_data(
+                raylib_handle,
+                thread,
+                &format!("levels/{}/platforms.png", level_name),
+            )?,
+            colliders: serde_json::from_str(
+                &String::from_utf8(
+                    StaticGameData::get(&format!("levels/{}/colliders.json", level_name))
+                        .unwrap()
+                        .data
+                        .into(),
+                )
+                .unwrap(),
+            )?,
+        });
+    }
+    Ok(levels)
+}

game/src/scenes/ingame_scene/level/mod.rs

@@ -0,0 +1,11 @@
+use raylib::{math::Rectangle, texture::Texture2D};
+
+pub mod loader;
+
+#[derive(Debug)]
+pub struct Level {
+    pub name: String,
+    pub background_tex: Texture2D,
+    pub platform_tex: Texture2D,
+    pub colliders: Vec<Rectangle>
+}

game/src/scenes/ingame_scene/mod.rs

@@ -1,24 +1,41 @@
 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 self::level::Level;
 
 use super::{Scenes, ScreenError};
 use tracing::{debug, trace};
 
 mod hud;
+pub mod level;
 mod update;
-mod world;
+pub mod world;
 
 #[derive(Debug)]
 pub struct InGameScreen {
     camera: Camera2D,
     player: MainCharacter,
+    world_background: WorldPaintTexture,
+    levels: Vec<Level>,
+    current_level_idx: usize,
 }
 
 impl InGameScreen {
     /// Construct a new `InGameScreen`
-    pub fn new(player_sprite_sheet: Texture2D) -> Self {
+    pub fn new(
+        player_sprite_sheet: Texture2D,
+        background_texture: Texture2D,
+        levels: Vec<Level>,
+    ) -> Self {
         Self {
             camera: Camera2D {
                 offset: Vector2::zero(),
@@ -26,7 +43,10 @@ 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,
         }
     }
 }
@@ -41,7 +61,12 @@ 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);
+        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,38 +17,37 @@ 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);
 
         // 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)
-        //let is_left_click = raylib.is_mouse_button_down(MouseButton::MOUSE_LEFT_BUTTON);
+            && !(self.player.current_state == CharacterState::Dashing);
-        //let mouse_position: Vector2 = raylib.get_mouse_position();
-
-        //Stoping the character.
-        if is_pause {
-            //println!("Pause : {}", is_pause);
-            self.player.set_state(CharacterState::Halt);
-        } else if is_pause == false {
-            //println!("Pause : {}", is_pause);
-            self.player.set_state(CharacterState::Running);
-        }
 
         if is_jump {
-            self.player.apply_force(Vector2::new(0.0, -30.0));
+            self.player.update_player(Some(CharacterState::Jumping), &cur_level.colliders,
-            self.player.set_state(CharacterState::Jumping);
+            -cur_level.platform_tex.height as f32,);
         } else if is_dash {
-            self.player.apply_force(Vector2::new(40.0, -10.0));
+            self.player.update_player(Some(CharacterState::Dashing), &cur_level.colliders,
-            self.player.set_state(CharacterState::Dashing);
+            -cur_level.platform_tex.height as f32,);
         } 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), &cur_level.colliders,
+                -cur_level.platform_tex.height as f32,);
+            } else {
+                self.player.update_player(None, &cur_level.colliders,
+                    -cur_level.platform_tex.height as f32,);
             }
         }
-
-        self.player.update_gravity();
     }
 }

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,
@@ -15,8 +17,15 @@ impl WorldSpaceRender for InGameScreen {
         config: &GameConfig,
     ) {
         puffin::profile_function!();
-        // Render the player
+
-        render_character_in_camera_space(raylib, &self.player, &config);
+        // Get the current level
+        let cur_level = self.levels.get(self.current_level_idx).unwrap();
+
+        // Render the world background
+        // 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(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);
@@ -30,5 +39,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

@@ -1,6 +1,9 @@
 use self::{
-    fsm_error_screen::FsmErrorScreen, ingame_scene::InGameScreen, loading_screen::LoadingScreen,
+  pause_screen::PauseScreen
-    main_menu_screen::MainMenuScreen, pause_screen::PauseScreen
+    fsm_error_screen::FsmErrorScreen,
+    ingame_scene::{level::loader::load_all_levels, InGameScreen},
+    loading_screen::LoadingScreen,
+    main_menu_screen::MainMenuScreen,
 };
 use crate::{
     context::GameContext,
@@ -49,6 +52,9 @@ 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();
+    let levels = load_all_levels(raylib_handle, thread).unwrap();
 
     // Set up the state machine
     let mut machine = StateMachine::new();
@@ -59,6 +65,9 @@ pub fn build_screen_state_machine(
     )?;
     machine.add_action(Scenes::MainMenuScreen, MainMenuScreen::new())?;
     machine.add_action(Scenes::PauseScreen, PauseScreen::new())?;
-    machine.add_action(Scenes::InGameScene, InGameScreen::new(player_sprite_sheet))?;
+    machine.add_action(
+        Scenes::InGameScene,
+        InGameScreen::new(player_sprite_sheet, world_background, levels),
+    )?;
     Ok(machine)
 }

game/src/utilities/datastore.rs

@@ -14,6 +14,8 @@ pub struct StaticGameData;
 
 #[derive(Debug, Error)]
 pub enum ResourceLoadError {
+    #[error(transparent)]
+    JsonDeser(#[from] serde_json::Error),
     #[error(transparent)]
     Io(#[from] std::io::Error),
     #[error("Could not load embedded asset: {0}")]

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