Merge pull request #3 from pnstack/copilot/create-2d-platformer-game

Implement 2D Mario-style platformer with gravity, jumping, and collision detection

Author: npv2k1

examples/basic_usage.rs

@@ -1,13 +1,18 @@
 //! Basic usage example for the Bevy game template
 //!
 //! This example demonstrates how to use the template's
-//! components, resources, and systems.
+//! components, resources, and systems for a 2D platformer.
 
 use bevy::prelude::*;
-use template_bevy::components::{Health, Player, Speed, Velocity};
+use template_bevy::components::{
+    BoxCollider, Gravity, Grounded, Health, JumpConfig, Platform, Player, Speed, Velocity,
+};
 use template_bevy::resources::{GameSettings, Score};
 use template_bevy::states::GameState;
 
+/// Threshold for detecting landing on platforms (in pixels)
+const LANDING_THRESHOLD: f32 = 10.0;
+
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
@@ -17,7 +22,16 @@ fn main() {
         .add_systems(Startup, setup)
         .add_systems(
             Update,
-            (update_player, print_score).run_if(in_state(GameState::Playing)),
+            (
+                player_horizontal_movement,
+                player_jump,
+                apply_gravity,
+                apply_velocity,
+                check_collisions,
+                print_score,
+            )
+                .chain()
+                .run_if(in_state(GameState::Playing)),
         )
         .add_systems(OnEnter(GameState::Loading), start_game)
         .run();
@@ -31,55 +45,147 @@ fn setup(mut commands: Commands) {
     // Spawn camera
     commands.spawn(Camera2d);
 
-    // Spawn player with components
+    // Spawn player with platformer components
+    let player_size = Vec2::new(40.0, 50.0);
     commands.spawn((
         Player,
-        Speed(300.0),
+        Speed(250.0),
         Health::new(100.0),
         Velocity::default(),
+        Gravity::default(),
+        Grounded(false),
+        JumpConfig::default(),
+        BoxCollider::new(player_size.x, player_size.y),
         Sprite {
-            color: Color::srgb(0.25, 0.75, 0.25),
-            custom_size: Some(Vec2::new(50.0, 50.0)),
+            color: Color::srgb(0.2, 0.6, 1.0),
+            custom_size: Some(player_size),
             ..default()
         },
-        Transform::default(),
+        Transform::from_xyz(0.0, 100.0, 0.0),
     ));
 
-    println!("Game initialized!");
-    println!("Use WASD or Arrow keys to move");
-    println!("Press ESC to quit");
+    // Spawn ground
+    let ground_size = Vec2::new(800.0, 40.0);
+    commands.spawn((
+        Platform,
+        BoxCollider::new(ground_size.x, ground_size.y),
+        Sprite {
+            color: Color::srgb(0.4, 0.3, 0.2),
+            custom_size: Some(ground_size),
+            ..default()
+        },
+        Transform::from_xyz(0.0, -250.0, 0.0),
+    ));
+
+    // Spawn floating platforms
+    for (x, y, width) in [
+        (-200.0, -100.0, 150.0),
+        (150.0, 0.0, 120.0),
+        (-50.0, 100.0, 180.0),
+    ] {
+        let size = Vec2::new(width, 20.0);
+        commands.spawn((
+            Platform,
+            BoxCollider::new(size.x, size.y),
+            Sprite {
+                color: Color::srgb(0.3, 0.5, 0.3),
+                custom_size: Some(size),
+                ..default()
+            },
+            Transform::from_xyz(x, y, 0.0),
+        ));
+    }
+
+    println!("2D Platformer initialized!");
+    println!("Use A/D or Arrow keys to move left/right");
+    println!("Press SPACE to jump (only when on ground)");
 }
 
-fn update_player(
+fn player_horizontal_movement(
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    time: Res<Time>,
-    mut query: Query<(&Speed, &mut Transform), With<Player>>,
-    mut score: ResMut<Score>,
+    mut query: Query<(&Speed, &mut Velocity), With<Player>>,
 ) {
-    for (speed, mut transform) in query.iter_mut() {
-        let mut direction = Vec2::ZERO;
-
-        if keyboard_input.pressed(KeyCode::KeyW) || keyboard_input.pressed(KeyCode::ArrowUp) {
-            direction.y += 1.0;
-        }
-        if keyboard_input.pressed(KeyCode::KeyS) || keyboard_input.pressed(KeyCode::ArrowDown) {
-            direction.y -= 1.0;
-        }
+    for (speed, mut velocity) in query.iter_mut() {
+        let mut direction = 0.0;
         if keyboard_input.pressed(KeyCode::KeyA) || keyboard_input.pressed(KeyCode::ArrowLeft) {
-            direction.x -= 1.0;
+            direction -= 1.0;
         }
         if keyboard_input.pressed(KeyCode::KeyD) || keyboard_input.pressed(KeyCode::ArrowRight) {
-            direction.x += 1.0;
+            direction += 1.0;
         }
+        velocity.0.x = direction * speed.0;
+    }
+}
+
+fn player_jump(
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    mut query: Query<(&mut Velocity, &Grounded, &JumpConfig), With<Player>>,
+) {
+    for (mut velocity, grounded, jump_config) in query.iter_mut() {
+        if keyboard_input.just_pressed(KeyCode::Space) && grounded.0 {
+            velocity.0.y = jump_config.jump_velocity;
+        }
+        if keyboard_input.just_released(KeyCode::Space) && velocity.0.y > 0.0 {
+            velocity.0.y *= jump_config.jump_cut_multiplier;
+        }
+    }
+}
+
+fn apply_gravity(time: Res<Time>, mut query: Query<(&Gravity, &mut Velocity, &Grounded)>) {
+    for (gravity, mut velocity, grounded) in query.iter_mut() {
+        if !grounded.0 {
+            velocity.0.y -= gravity.0 * time.delta_seconds();
+        }
+    }
+}
+
+fn apply_velocity(time: Res<Time>, mut query: Query<(&Velocity, &mut Transform)>) {
+    for (velocity, mut transform) in query.iter_mut() {
+        transform.translation.x += velocity.0.x * time.delta_seconds();
+        transform.translation.y += velocity.0.y * time.delta_seconds();
+    }
+}
+
+#[allow(clippy::type_complexity)]
+fn check_collisions(
+    mut player_query: Query<
+        (&mut Transform, &mut Velocity, &BoxCollider, &mut Grounded),
+        With<Player>,
+    >,
+    platform_query: Query<(&Transform, &BoxCollider), (With<Platform>, Without<Player>)>,
+) {
+    for (mut player_tf, mut velocity, player_col, mut grounded) in player_query.iter_mut() {
+        let mut is_grounded = false;
+        let ph_w = player_col.width / 2.0;
+        let ph_h = player_col.height / 2.0;
+
+        for (platform_tf, platform_col) in platform_query.iter() {
+            let plat_h_w = platform_col.width / 2.0;
+            let plat_h_h = platform_col.height / 2.0;
+
+            let p_left = player_tf.translation.x - ph_w;
+            let p_right = player_tf.translation.x + ph_w;
+            let p_bottom = player_tf.translation.y - ph_h;
+            let p_top = player_tf.translation.y + ph_h;
+
+            let plat_left = platform_tf.translation.x - plat_h_w;
+            let plat_right = platform_tf.translation.x + plat_h_w;
+            let plat_top = platform_tf.translation.y + plat_h_h;
 
-        let movement = direction.normalize_or_zero() * speed.0 * time.delta_seconds();
-        transform.translation.x += movement.x;
-        transform.translation.y += movement.y;
+            let h_overlap = p_left < plat_right && p_right > plat_left;
 
-        // Add score for moving
-        if direction != Vec2::ZERO {
-            score.add(1);
+            if h_overlap && velocity.0.y <= 0.0 {
+                if p_bottom <= plat_top
+                    && p_bottom >= plat_top - LANDING_THRESHOLD
+                    && p_top > plat_top
+                {
+                    player_tf.translation.y = plat_top + ph_h;
+                    velocity.0.y = 0.0;
+                    is_grounded = true;
+                }
+            }
         }
+        grounded.0 = is_grounded;
     }
 }
 

src/components/mod.rs

@@ -74,6 +74,62 @@ impl Collider {
     }
 }
 
+/// Gravity component for entities affected by gravity
+#[derive(Component, Debug, Clone)]
+pub struct Gravity(pub f32);
+
+impl Default for Gravity {
+    fn default() -> Self {
+        Self(980.0) // Pixels per second squared
+    }
+}
+
+/// Component tracking if entity is on the ground
+#[derive(Component, Debug, Default, Clone)]
+pub struct Grounded(pub bool);
+
+/// Marker component for static platform entities
+#[derive(Component, Debug, Default)]
+pub struct Platform;
+
+/// Box collider for AABB collision detection
+#[derive(Component, Debug, Clone)]
+pub struct BoxCollider {
+    pub width: f32,
+    pub height: f32,
+}
+
+impl BoxCollider {
+    pub fn new(width: f32, height: f32) -> Self {
+        Self { width, height }
+    }
+}
+
+impl Default for BoxCollider {
+    fn default() -> Self {
+        Self {
+            width: 50.0,
+            height: 50.0,
+        }
+    }
+}
+
+/// Jump configuration component for Mario-like jumping
+#[derive(Component, Debug, Clone)]
+pub struct JumpConfig {
+    pub jump_velocity: f32,
+    pub jump_cut_multiplier: f32,
+}
+
+impl Default for JumpConfig {
+    fn default() -> Self {
+        Self {
+            jump_velocity: 450.0,
+            jump_cut_multiplier: 0.5,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -122,4 +178,37 @@ mod tests {
         health.take_damage(25.0);
         assert!((health.percentage() - 0.75).abs() < f32::EPSILON);
     }
+
+    #[test]
+    fn test_gravity_default() {
+        let gravity = Gravity::default();
+        assert_eq!(gravity.0, 980.0);
+    }
+
+    #[test]
+    fn test_grounded_default() {
+        let grounded = Grounded::default();
+        assert!(!grounded.0);
+    }
+
+    #[test]
+    fn test_box_collider_new() {
+        let collider = BoxCollider::new(100.0, 50.0);
+        assert_eq!(collider.width, 100.0);
+        assert_eq!(collider.height, 50.0);
+    }
+
+    #[test]
+    fn test_box_collider_default() {
+        let collider = BoxCollider::default();
+        assert_eq!(collider.width, 50.0);
+        assert_eq!(collider.height, 50.0);
+    }
+
+    #[test]
+    fn test_jump_config_default() {
+        let config = JumpConfig::default();
+        assert_eq!(config.jump_velocity, 450.0);
+        assert_eq!(config.jump_cut_multiplier, 0.5);
+    }
 }

src/game/mod.rs

@@ -10,5 +10,5 @@ pub mod constants {
     /// Default window height
     pub const WINDOW_HEIGHT: f32 = 720.0;
     /// Game title
-    pub const GAME_TITLE: &str = "Template Bevy Game";
+    pub const GAME_TITLE: &str = "2D Mario-Style Platformer";
 }

src/main.rs

@@ -5,7 +5,7 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins.set(WindowPlugin {
             primary_window: Some(Window {
-                title: "Template Bevy Game".to_string(),
+                title: "2D Mario-Style Platformer".to_string(),
                 resolution: (1280.0, 720.0).into(),
                 ..default()
             }),

src/plugins/mod.rs

@@ -7,7 +7,10 @@ use bevy::prelude::*;
 
 use crate::resources::{GameSettings, GameTimer, Score};
 use crate::states::GameState;
-use crate::systems::{apply_velocity, player_movement, setup_camera, spawn_player};
+use crate::systems::{
+    apply_gravity, apply_velocity, check_platform_collisions, player_jump, player_movement,
+    setup_camera, spawn_platforms, spawn_player,
+};
 
 /// Main game plugin that sets up all game systems
 pub struct GamePlugin;
@@ -22,11 +25,18 @@ impl Plugin for GamePlugin {
             .init_resource::<Score>()
             .init_resource::<GameTimer>()
             // Setup systems (run once on startup)
-            .add_systems(Startup, (setup_camera, spawn_player))
+            .add_systems(Startup, (setup_camera, spawn_player, spawn_platforms))
             // Update systems (run every frame during Playing state)
+            // Order: input -> physics -> collision -> movement
             .add_systems(
                 Update,
-                (player_movement, apply_velocity)
+                (
+                    player_movement,
+                    player_jump,
+                    apply_gravity,
+                    apply_velocity,
+                    check_platform_collisions,
+                )
                     .chain()
                     .run_if(in_state(GameState::Playing)),
             )

src/systems/mod.rs

@@ -6,5 +6,8 @@
 mod movement;
 mod setup;
 
-pub use movement::*;
-pub use setup::*;
+// Re-export specific systems for clarity
+pub use movement::{
+    apply_gravity, apply_velocity, check_platform_collisions, player_jump, player_movement,
+};
+pub use setup::{setup_camera, spawn_platforms, spawn_player};