Merge pull request #4 from pnstack/copilot/design-game-template-bevy

Add core game template features: auto-movement, collision, obstacles, camera follow, and UI

Author: npv2k1

README.md

@@ -9,6 +9,11 @@ A Bevy game engine template designed for indie game developers. This template pr
 - 🧩 Modular plugin system
 - 🎯 Game state management (Loading, Menu, Playing, Paused, GameOver)
 - 🏃 Movement and physics components
+- 🤖 Auto-movement system for obstacles and NPCs
+- 💥 AABB collision detection system
+- 🎯 Dynamic obstacle spawning with randomization
+- 📷 Smooth camera follow system
+- 🎨 User interface with score display and health bar
 - ❤️ Health and combat systems
 - 🎵 Audio and settings resources
 - 🧪 Comprehensive test suite
@@ -53,7 +58,8 @@ cargo run --release
 
 ### Controls
 
-- **WASD** or **Arrow Keys** - Move player
+- **A/D** or **Arrow Left/Right** - Move player horizontally
+- **Spacebar** - Jump (only when on ground)
 - **ESC** - Quit game
 
 ## Project Structure
@@ -132,6 +138,60 @@ use template_bevy::states::GameState;
 app.add_systems(Update, gameplay_system.run_if(in_state(GameState::Playing)));
 ```
 
+## Core Systems
+
+The template includes several ready-to-use systems:
+
+### Auto-Movement
+
+Entities with the `AutoMove` component will automatically move in the specified direction:
+
+```rust
+use template_bevy::components::{AutoMove, Obstacle};
+
+// Create an obstacle that moves left
+commands.spawn((
+    Obstacle,
+    AutoMove::left(150.0), // Speed of 150 pixels/second
+    // ... other components
+));
+```
+
+### Obstacle Spawning
+
+The `spawn_obstacles` system automatically spawns obstacles at regular intervals with random properties (position, size, speed).
+
+### Camera Follow
+
+The camera automatically follows the player with smooth interpolation:
+
+```rust
+use template_bevy::components::{CameraFollow, MainCamera};
+
+// Camera will smoothly follow the target
+commands.spawn((
+    MainCamera,
+    CameraFollow::new(player_entity)
+        .with_offset(Vec3::new(0.0, 50.0, 0.0))
+        .with_smoothing(0.05),
+    Camera2dBundle::default(),
+));
+```
+
+### Collision Detection
+
+AABB collision detection between player and obstacles:
+
+- Platform collisions for landing and ground detection
+- Obstacle collisions that apply damage to the player
+
+### User Interface
+
+Built-in UI components for displaying game information:
+
+- **Score Display**: Shows current score in the top-left corner
+- **Health Bar**: Visual health indicator with color changes based on health level
+
 ## Development
 
 ### Prerequisites

src/components/mod.rs

@@ -6,6 +6,8 @@
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
 
+use crate::game::constants::camera::{MAX_SMOOTHING, MIN_SMOOTHING};
+
 /// Marker component for the player entity
 #[derive(Component, Debug, Default)]
 pub struct Player;
@@ -130,6 +132,125 @@ impl Default for JumpConfig {
     }
 }
 
+/// Marker component for obstacle entities
+#[derive(Component, Debug, Default)]
+pub struct Obstacle;
+
+/// Auto-movement component for entities that move automatically
+#[derive(Component, Debug, Clone)]
+pub struct AutoMove {
+    /// Direction of movement (normalized)
+    pub direction: Vec2,
+    /// Movement speed
+    pub speed: f32,
+}
+
+impl Default for AutoMove {
+    fn default() -> Self {
+        Self {
+            direction: Vec2::new(-1.0, 0.0), // Move left by default
+            speed: 150.0,
+        }
+    }
+}
+
+impl AutoMove {
+    pub fn new(direction: Vec2, speed: f32) -> Self {
+        Self {
+            direction: direction.normalize_or_zero(),
+            speed,
+        }
+    }
+
+    /// Creates a left-moving auto-move component
+    pub fn left(speed: f32) -> Self {
+        Self::new(Vec2::new(-1.0, 0.0), speed)
+    }
+
+    /// Creates a right-moving auto-move component
+    pub fn right(speed: f32) -> Self {
+        Self::new(Vec2::new(1.0, 0.0), speed)
+    }
+}
+
+/// Marker component for the main camera that follows the player
+#[derive(Component, Debug, Default)]
+pub struct MainCamera;
+
+/// Camera follow configuration component
+#[derive(Component, Debug, Clone)]
+pub struct CameraFollow {
+    /// Target entity to follow (usually the player)
+    pub target: Option<Entity>,
+    /// Offset from the target position
+    pub offset: Vec3,
+    /// Smoothing factor (0.0 = instant, 1.0 = very smooth/slow)
+    pub smoothing: f32,
+}
+
+impl Default for CameraFollow {
+    fn default() -> Self {
+        Self {
+            target: None,
+            offset: Vec3::ZERO,
+            smoothing: 0.1,
+        }
+    }
+}
+
+impl CameraFollow {
+    pub fn new(target: Entity) -> Self {
+        Self {
+            target: Some(target),
+            ..Default::default()
+        }
+    }
+
+    pub fn with_offset(mut self, offset: Vec3) -> Self {
+        self.offset = offset;
+        self
+    }
+
+    pub fn with_smoothing(mut self, smoothing: f32) -> Self {
+        self.smoothing = smoothing.clamp(MIN_SMOOTHING, MAX_SMOOTHING);
+        self
+    }
+}
+
+/// Marker component for UI root node
+#[derive(Component, Debug, Default)]
+pub struct GameUI;
+
+/// Marker component for score display UI
+#[derive(Component, Debug, Default)]
+pub struct ScoreDisplay;
+
+/// Marker component for health bar UI
+#[derive(Component, Debug, Default)]
+pub struct HealthBar;
+
+/// Marker component for health bar fill (the colored part)
+#[derive(Component, Debug, Default)]
+pub struct HealthBarFill;
+
+/// Damage value component for obstacles
+#[derive(Component, Debug, Clone)]
+pub struct DamageOnContact {
+    pub damage: f32,
+}
+
+impl Default for DamageOnContact {
+    fn default() -> Self {
+        Self { damage: 10.0 }
+    }
+}
+
+impl DamageOnContact {
+    pub fn new(damage: f32) -> Self {
+        Self { damage }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -211,4 +332,52 @@ mod tests {
         assert_eq!(config.jump_velocity, 450.0);
         assert_eq!(config.jump_cut_multiplier, 0.5);
     }
+
+    #[test]
+    fn test_auto_move_default() {
+        let auto_move = AutoMove::default();
+        assert_eq!(auto_move.direction, Vec2::new(-1.0, 0.0));
+        assert_eq!(auto_move.speed, 150.0);
+    }
+
+    #[test]
+    fn test_auto_move_new() {
+        let auto_move = AutoMove::new(Vec2::new(2.0, 0.0), 200.0);
+        assert!((auto_move.direction.x - 1.0).abs() < f32::EPSILON);
+        assert_eq!(auto_move.speed, 200.0);
+    }
+
+    #[test]
+    fn test_auto_move_left() {
+        let auto_move = AutoMove::left(100.0);
+        assert_eq!(auto_move.direction, Vec2::new(-1.0, 0.0));
+        assert_eq!(auto_move.speed, 100.0);
+    }
+
+    #[test]
+    fn test_auto_move_right() {
+        let auto_move = AutoMove::right(100.0);
+        assert_eq!(auto_move.direction, Vec2::new(1.0, 0.0));
+        assert_eq!(auto_move.speed, 100.0);
+    }
+
+    #[test]
+    fn test_camera_follow_default() {
+        let follow = CameraFollow::default();
+        assert!(follow.target.is_none());
+        assert_eq!(follow.offset, Vec3::ZERO);
+        assert!((follow.smoothing - 0.1).abs() < f32::EPSILON);
+    }
+
+    #[test]
+    fn test_damage_on_contact_default() {
+        let damage = DamageOnContact::default();
+        assert_eq!(damage.damage, 10.0);
+    }
+
+    #[test]
+    fn test_damage_on_contact_new() {
+        let damage = DamageOnContact::new(25.0);
+        assert_eq!(damage.damage, 25.0);
+    }
 }

src/game/mod.rs

@@ -11,4 +11,44 @@ pub mod constants {
     pub const WINDOW_HEIGHT: f32 = 720.0;
     /// Game title
     pub const GAME_TITLE: &str = "2D Mario-Style Platformer";
+
+    /// Camera smoothing constants
+    pub mod camera {
+        /// Target framerate for smoothing calculations
+        pub const TARGET_FRAMERATE: f32 = 60.0;
+        /// Minimum smoothing factor (instant follow)
+        pub const MIN_SMOOTHING: f32 = 0.01;
+        /// Maximum smoothing factor (slowest follow)
+        pub const MAX_SMOOTHING: f32 = 1.0;
+    }
+
+    /// Obstacle spawning constants
+    pub mod obstacles {
+        /// X position where obstacles spawn (right side of screen)
+        pub const SPAWN_X: f32 = 700.0;
+        /// Minimum Y position for obstacle spawn
+        pub const SPAWN_Y_MIN: f32 = -200.0;
+        /// Maximum Y position for obstacle spawn
+        pub const SPAWN_Y_MAX: f32 = 150.0;
+        /// Minimum obstacle width
+        pub const WIDTH_MIN: f32 = 30.0;
+        /// Maximum obstacle width
+        pub const WIDTH_MAX: f32 = 60.0;
+        /// Minimum obstacle height
+        pub const HEIGHT_MIN: f32 = 30.0;
+        /// Maximum obstacle height
+        pub const HEIGHT_MAX: f32 = 60.0;
+        /// Minimum obstacle speed
+        pub const SPEED_MIN: f32 = 100.0;
+        /// Maximum obstacle speed
+        pub const SPEED_MAX: f32 = 250.0;
+        /// X position at which obstacles are despawned (left side of screen)
+        pub const DESPAWN_X: f32 = -800.0;
+    }
+
+    /// Scoring constants
+    pub mod scoring {
+        /// Points awarded for surviving obstacle collision
+        pub const OBSTACLE_SURVIVE_POINTS: u32 = 10;
+    }
 }

src/plugins/mod.rs

@@ -5,11 +5,13 @@
 
 use bevy::prelude::*;
 
-use crate::resources::{GameSettings, GameTimer, Score};
+use crate::resources::{GameSettings, GameTimer, ObstacleSpawnTimer, Score};
 use crate::states::GameState;
 use crate::systems::{
-    apply_gravity, apply_velocity, check_platform_collisions, player_jump, player_movement,
-    setup_camera, spawn_platforms, spawn_player,
+    apply_auto_movement, apply_gravity, apply_velocity, camera_follow_system,
+    check_obstacle_collisions, check_platform_collisions, despawn_offscreen_obstacles, player_jump,
+    player_movement, setup_camera, setup_camera_follow, spawn_game_ui, spawn_obstacles,
+    spawn_platforms, spawn_player, update_health_bar, update_score_display,
 };
 
 /// Main game plugin that sets up all game systems
@@ -24,18 +26,37 @@ impl Plugin for GamePlugin {
             .init_resource::<GameSettings>()
             .init_resource::<Score>()
             .init_resource::<GameTimer>()
+            .init_resource::<ObstacleSpawnTimer>()
             // Setup systems (run once on startup)
-            .add_systems(Startup, (setup_camera, spawn_player, spawn_platforms))
+            .add_systems(
+                Startup,
+                (setup_camera, spawn_player, spawn_platforms, spawn_game_ui),
+            )
+            // Post-startup setup for camera follow (after player is spawned)
+            .add_systems(OnEnter(GameState::Playing), setup_camera_follow)
             // Update systems (run every frame during Playing state)
-            // Order: input -> physics -> collision -> movement
+            // Order: input -> physics -> collision -> movement -> camera -> UI
             .add_systems(
                 Update,
                 (
+                    // Player input systems
                     player_movement,
                     player_jump,
+                    // Physics systems
                     apply_gravity,
                     apply_velocity,
+                    apply_auto_movement,
+                    // Collision systems
                     check_platform_collisions,
+                    check_obstacle_collisions,
+                    // Obstacle spawning and cleanup
+                    spawn_obstacles,
+                    despawn_offscreen_obstacles,
+                    // Camera system
+                    camera_follow_system,
+                    // UI systems
+                    update_score_display,
+                    update_health_bar,
                 )
                     .chain()
                     .run_if(in_state(GameState::Playing)),