Merge pull request #3 from ArthurBugan/feat/add-debug-and-more-enemies

feat: add debug panel, reorder spritesheet and more assets

Author: ArthurBugan

.gitignore

@@ -1,2 +1,3 @@
 /target
 /out
+.DS_Store

Cargo.lock

@@ -5,18 +5,25 @@ edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[dependencies]
-bevy = { version = "0.13.1", features = ["dynamic_linking"] }
-bevy_pancam = "0.11.0"
-kd-tree = "0.5.3"
-rand = "0.8.5"
-typenum = "1.17.0"
-
-[workspace]
-resolver = "2"
-
+# Enable a small amount of optimization in debug mode
 [profile.dev]
 opt-level = 1
 
 [profile.dev.package."*"]
-opt-level = 3
+opt-level = 3
+
+[profile.release]
+lto = true
+opt-level = 3
+codegen-units = 1
+incremental = false
+debug = false
+
+[dependencies]
+bevy = "0.13.*"
+bevy-inspector-egui = "0.24.*"
+iyes_perf_ui = "0.2.*"
+bevy_pancam = "0.11.0"
+kd-tree = "0.5.3"
+rand = "0.8.5"
+typenum = "1.17.0"

Cargo.toml

@@ -13,6 +13,12 @@ pub struct AnimationPlugin;
 #[derive(Component, Deref, DerefMut)]
 pub struct AnimationTimer(pub Timer);
 
+#[derive(Component)]
+pub struct AnimationIndices {
+    pub first: usize,
+    pub last: usize,
+}
+
 impl Plugin for AnimationPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(
@@ -47,14 +53,20 @@ fn animate_player(
     }
 
     let (mut atlas, state, timer) = player_query.single_mut();
+
     if timer.just_finished() {
-        let base_sprite_index = match state {
-            PlayerState::Idle => 0,
-            PlayerState::Run => 32,
+        let base_sprite_index: AnimationIndices = match state {
+            PlayerState::Idle => AnimationIndices { first: 0, last: 5 },
+            PlayerState::Run => AnimationIndices { first: 6, last: 11 },
         };
 
-        atlas.index = base_sprite_index + ((atlas.index + 1) * 2) % 10;
-        info!("atlas.index: {}", atlas.index);
+        if base_sprite_index.last <= atlas.index {
+            atlas.index = base_sprite_index.first;
+        } else if base_sprite_index.first > atlas.index {
+            atlas.index = base_sprite_index.first;
+        } else {
+            atlas.index = atlas.index + 1
+        }
     }
 }
 
@@ -67,7 +79,13 @@ fn animate_enemy(
 
     for (mut atlas, timer, enemy_type) in enemy_query.iter_mut() {
         if timer.just_finished() {
-            atlas.index = enemy_type.get_base_sprite_index() + ((atlas.index + 1) * 2) % 10;
+            if enemy_type.get_base_sprite_index().last <= atlas.index {
+                atlas.index = enemy_type.get_base_sprite_index().first;
+            } else if enemy_type.get_base_sprite_index().first > atlas.index {
+                atlas.index = enemy_type.get_base_sprite_index().first;
+            } else {
+                atlas.index = atlas.index + 1
+            }
         }
     }
 }

assets/monogram.ttf

@@ -3,15 +3,14 @@ pub const WW: f32 = 1200.0;
 pub const WH: f32 = 900.0;
 
 // Sprites
-pub const SPRITE_SHEET_PATH: &str = "textures/Pawn_Blue.png";
-pub const SPRITE_SCALE_FACTOR: f32 = 0.5;
+pub const SPRITE_SCALE_FACTOR: f32 = 1.5;
 pub const TILE_W: usize = 64;
 pub const TILE_H: usize = 64;
 pub const SPRITE_SHEET_W: usize = 16;
 pub const SPRITE_SHEET_H: usize = 16;
 
 // World
-pub const NUM_WORLD_DECORATIONS: usize = 500;
+pub const NUM_WORLD_DECORATIONS: usize = 200;
 pub const WORLD_W: f32 = 3000.0;
 pub const WORLD_H: f32 = 2500.0;
 
@@ -20,7 +19,7 @@ pub const PLAYER_SPEED: f32 = 2.0;
 pub const PLAYER_HEALTH: f32 = 100.0;
 
 // Enemy
-pub const MAX_NUM_ENEMIES: usize = 20;
+pub const MAX_NUM_ENEMIES: usize = 5;
 pub const ENEMY_DAMAGE: f32 = 1.0;
 pub const SPAWN_RATE_PER_SECOND: usize = 2;
 pub const ENEMY_HEALTH: f32 = 100.0;

assets/textures/Pawn_Blue.png

@@ -0,0 +1,26 @@
+use bevy::prelude::*;
+use bevy_inspector_egui::quick::WorldInspectorPlugin;
+use iyes_perf_ui::PerfUiCompleteBundle;
+use iyes_perf_ui::PerfUiPlugin;
+
+use crate::state::GameState;
+
+pub struct DebugPlugin;
+
+impl Plugin for DebugPlugin {
+    fn build(&self, app: &mut App) {
+        #[cfg(debug_assertions)]
+        app.add_systems(OnEnter(GameState::InGame), debug_show_perf_stats);
+
+        app.add_plugins(WorldInspectorPlugin::new())
+            .add_plugins(PerfUiPlugin)
+            .add_plugins(bevy::diagnostic::FrameTimeDiagnosticsPlugin)
+            .add_plugins(bevy::diagnostic::EntityCountDiagnosticsPlugin)
+            .add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin);
+    }
+}
+
+#[cfg(debug_assertions)]
+fn debug_show_perf_stats(mut commands: Commands) {
+    commands.spawn(PerfUiCompleteBundle::default());
+}

assets/textures/Pawn_Purple.png

@@ -1,3 +1,4 @@
+use animation::AnimationIndices;
 use bevy::utils::Duration;
 use std::f32::consts::PI;
 
@@ -20,9 +21,18 @@ pub struct Enemy {
 
 #[derive(Component)]
 pub enum EnemyType {
-    Green,
-    Red,
-    Skin,
+    TorchBlue,
+    TorchRed,
+    TorchPurple,
+    TorchYellow,
+    BarrelBlue,
+    BarrelRed,
+    BarrelPurple,
+    BarrelYellow,
+    TntBlue,
+    TntRed,
+    TntPurple,
+    TntYellow,
 }
 
 impl Plugin for EnemyPlugin {
@@ -83,12 +93,13 @@ fn spawn_enemies(
     for _ in 0..enemy_spawn_count {
         let (x, y) = get_random_position_around(player_pos);
         let enemy_type = EnemyType::get_rand_enemy();
+
         commands.spawn((
             SpriteSheetBundle {
                 texture: handle.image.clone().unwrap(),
                 atlas: TextureAtlas {
                     layout: handle.layout.clone().unwrap(),
-                    index: enemy_type.get_base_sprite_index(),
+                    index: enemy_type.get_base_sprite_index().first,
                 },
                 transform: Transform::from_translation(vec3(x, y, 1.0))
                     .with_scale(Vec3::splat(SPRITE_SCALE_FACTOR)),
@@ -127,19 +138,76 @@ impl Default for Enemy {
 impl EnemyType {
     fn get_rand_enemy() -> Self {
         let mut rng = rand::thread_rng();
-        let rand_index = rng.gen_range(0..3);
+        let rand_index = rng.gen_range(0..11);
+
         return match rand_index {
-            0 => Self::Green,
-            1 => Self::Red,
-            _ => Self::Skin,
+            0 => Self::TorchBlue,
+            1 => Self::TorchYellow,
+            2 => Self::TorchPurple,
+            3 => Self::TorchRed,
+            4 => Self::BarrelBlue,
+            5 => Self::BarrelRed,
+            6 => Self::BarrelPurple,
+            7 => Self::BarrelYellow,
+            8 => Self::TntBlue,
+            9 => Self::TntRed,
+            10 => Self::TntPurple,
+            11 => Self::TntYellow,
+            _ => Self::TorchBlue,
         };
     }
 
-    pub fn get_base_sprite_index(&self) -> usize {
+    pub fn get_base_sprite_index(&self) -> AnimationIndices {
         match self {
-            EnemyType::Green => 200,
-            EnemyType::Red => 300,
-            EnemyType::Skin => 400,
+            EnemyType::TorchBlue => AnimationIndices {
+                first: 606,
+                last: 611,
+            },
+            EnemyType::TorchYellow => AnimationIndices {
+                first: 606,
+                last: 611,
+            },
+            EnemyType::TorchPurple => AnimationIndices {
+                first: 606,
+                last: 611,
+            },
+            EnemyType::TorchRed => AnimationIndices {
+                first: 606,
+                last: 611,
+            },
+
+            EnemyType::BarrelBlue => AnimationIndices {
+                first: 606,
+                last: 611,
+            },
+            EnemyType::BarrelRed => AnimationIndices {
+                first: 606,
+                last: 611,
+            },
+            EnemyType::BarrelPurple => AnimationIndices {
+                first: 606,
+                last: 611,
+            },
+            EnemyType::BarrelYellow => AnimationIndices {
+                first: 606,
+                last: 611,
+            },
+            EnemyType::TntBlue => AnimationIndices {
+                first: 606,
+                last: 611,
+            },
+            EnemyType::TntRed => AnimationIndices {
+                first: 606,
+                last: 611,
+            },
+            EnemyType::TntPurple => AnimationIndices {
+                first: 606,
+                last: 611,
+            },
+            EnemyType::TntYellow => AnimationIndices {
+                first: 606,
+                last: 611,
+            },
         }
     }
 }

assets/textures/Pawn_Red.png

@@ -1,4 +1,3 @@
-use bevy::diagnostic::{DiagnosticsStore, FrameTimeDiagnosticsPlugin};
 use bevy::prelude::*;
 
 use crate::enemy::Enemy;
@@ -15,91 +14,15 @@ struct MainMenuItem;
 
 impl Plugin for GuiPlugin {
     fn build(&self, app: &mut App) {
-        app.add_plugins(FrameTimeDiagnosticsPlugin)
-            .add_systems(OnEnter(GameState::MainMenu), setup_main_menu)
+        app.add_systems(OnEnter(GameState::MainMenu), setup_main_menu)
             .add_systems(OnExit(GameState::MainMenu), despawn_main_menu)
             .add_systems(
                 Update,
                 handle_main_menu_buttons.run_if(in_state(GameState::MainMenu)),
-            )
-            .add_systems(OnEnter(GameState::GameInit), spawn_debug_text)
-            .add_systems(
-                Update,
-                update_debug_text.run_if(in_state(GameState::InGame)),
             );
     }
 }
 
-fn spawn_debug_text(mut commands: Commands, asset_server: Res<AssetServer>) {
-    commands
-        .spawn((
-            NodeBundle {
-                style: Style {
-                    width: Val::Percent(100.0),
-                    height: Val::Percent(100.0),
-                    align_items: AlignItems::Start,
-                    justify_content: JustifyContent::Start,
-                    flex_direction: FlexDirection::Column,
-                    ..default()
-                },
-                ..default()
-            },
-            GameEntity,
-        ))
-        .with_children(|parent| {
-            parent
-                .spawn(NodeBundle {
-                    style: Style {
-                        width: Val::Px(345.0),
-                        height: Val::Px(125.0),
-                        align_items: AlignItems::Center,
-                        flex_direction: FlexDirection::Column,
-                        justify_content: JustifyContent::Center,
-                        padding: UiRect::all(Val::Px(8.0)),
-                        margin: UiRect::px(10.0, 10.0, 10.0, 0.0),
-                        ..default()
-                    },
-                    background_color: BackgroundColor::from(Color::BLACK.with_a(0.9)),
-                    ..default()
-                })
-                .with_children(|parent| {
-                    parent.spawn((
-                        TextBundle::from_section(
-                            "Hello Bevy!",
-                            TextStyle {
-                                font: asset_server.load("monogram.ttf"),
-                                font_size: 40.0,
-                                color: Color::WHITE,
-                                ..default()
-                            },
-                        ),
-                        DebugText,
-                    ));
-                });
-        });
-}
-
-fn update_debug_text(
-    mut query: Query<&mut Text, With<DebugText>>,
-    diagnostics: Res<DiagnosticsStore>,
-    enemy_query: Query<(), With<Enemy>>,
-    player_query: Query<&Health, With<Player>>,
-) {
-    if query.is_empty() || player_query.is_empty() || enemy_query.is_empty() {
-        return;
-    }
-
-    let num_enemies = enemy_query.iter().count();
-    let player_health = player_query.single().0;
-    let mut text = query.single_mut();
-    if let Some(fps) = diagnostics.get(&FrameTimeDiagnosticsPlugin::FPS) {
-        if let Some(value) = fps.smoothed() {
-            text.sections[0].value =
-                format!("Fps: {value:.2}\nEnemies: {num_enemies}\nHealth: {player_health}");
-        }
-    }
-}
-
 fn setup_main_menu(mut commands: Commands) {
     commands
         .spawn(NodeBundle {

assets/textures/Pawn_Yellow.png

@@ -90,6 +90,7 @@ fn handle_gun_input(
     }
 
     let (gun_transform, mut gun_timer) = gun_query.single_mut();
+
     let gun_pos = gun_transform.translation.truncate();
     gun_timer.0.tick(time.delta());
 
@@ -108,6 +109,7 @@ fn handle_gun_input(
                 bullet_direction.y + rng.gen_range(-0.5..0.5),
                 bullet_direction.z,
             );
+
             commands.spawn((
                 SpriteSheetBundle {
                     texture: handle.image.clone().unwrap(),

assets/textures/Torch_Blue.png

@@ -2,6 +2,7 @@ pub mod animation;
 pub mod camera;
 pub mod collision;
 pub mod configs;
+pub mod debug;
 pub mod enemy;
 pub mod gui;
 pub mod gun;

assets/textures/all_textures.png

@@ -1,9 +1,14 @@
-use bevy::prelude::*;
 use bevy::window::close_on_esc;
+use bevy::{
+    log::LogPlugin,
+    prelude::*,
+    window::{PresentMode, WindowMode},
+};
 
 use coding_pet::animation::AnimationPlugin;
 use coding_pet::camera::FollowCameraPlugin;
 use coding_pet::collision::CollisionPlugin;
+use coding_pet::debug::DebugPlugin;
 use coding_pet::enemy::EnemyPlugin;
 use coding_pet::gui::GuiPlugin;
 use coding_pet::gun::GunPlugin;
@@ -17,13 +22,24 @@ fn main() {
         .init_state::<GameState>()
         .add_plugins(
             DefaultPlugins
+                .set(LogPlugin {
+                    filter: "info,wgpu_core=warn,wgpu_hal=warn,coding_pet=debug".into(),
+                    level: bevy::log::Level::DEBUG,
+                    ..default()
+                })
                 .set(ImagePlugin::default_nearest())
                 .set(WindowPlugin {
                     primary_window: Some(Window {
-                        // mode: bevy::window::WindowMode::Fullscreen,
-                        resizable: true,
-                        focused: true,
-                        resolution: (WW, WH).into(),
+                        title: "Tiktok game + Bevy!".into(),
+                        name: Some("MyWindow".into()),
+                        resolution: (1920., 1080.).into(),
+                        present_mode: PresentMode::AutoVsync,
+                        mode: WindowMode::Windowed,
+                        enabled_buttons: bevy::window::EnabledButtons {
+                            maximize: false,
+                            ..Default::default()
+                        },
+                        visible: true,
                         ..default()
                     }),
                     ..default()
@@ -35,6 +51,7 @@ fn main() {
         .add_plugins(FollowCameraPlugin)
         .add_plugins(GuiPlugin)
         .add_plugins(GunPlugin)
+        .add_plugins(DebugPlugin)
         .add_plugins(PlayerPlugin)
         .add_plugins(AnimationPlugin)
         .add_plugins(ResourcesPlugin)

src/animation.rs

@@ -5,14 +5,22 @@ use bevy::window::PrimaryWindow;
 use crate::state::GameState;
 
 pub struct ResourcesPlugin;
-use crate::*;
 
 #[derive(Resource)]
 pub struct GlobalTextureAtlas {
     pub layout: Option<Handle<TextureAtlasLayout>>,
     pub image: Option<Handle<Image>>,
 }
 
+impl Default for GlobalTextureAtlas {
+    fn default() -> Self {
+        Self {
+            layout: None,
+            image: None,
+        }
+    }
+}
+
 #[derive(Resource)]
 pub struct CursorPosition(pub Option<Vec2>);
 
@@ -53,6 +61,7 @@ fn check_textures(
 }
 
 fn setup(
+    mut commands: Commands,
     rpg_sprite_handles: Res<RpgSpriteFolder>,
     loaded_folders: Res<Assets<LoadedFolder>>,
     mut textures: ResMut<Assets<Image>>,
@@ -68,13 +77,27 @@ fn setup(
 
     let atlas = textures.get(&linear_texture).unwrap();
 
-    info!("{} {}", atlas.width(), atlas.height());
+    info!(
+        "atlas width {:?}, atlas height {:?}",
+        atlas.width(),
+        atlas.height()
+    );
 
-    // Separate the TextureAtlasLayout into a grid using from_grid
+    /*
+      commands.spawn(SpriteBundle {
+        texture: linear_texture.clone(),
+        transform: Transform {
+            translation: Vec3::new(-250.0, -130.0, 0.0),
+            scale: Vec3::splat(0.8),
+            ..default()
+        },
+        ..default()
+    });
+    */
     let grid_layout = TextureAtlasLayout::from_grid(
         Vec2::new(128.0, 128.0),     // Tile size
-        20,                          // Width of the texture atlas
-        20,                          // Height of the texture atlas
+        50,                          // Width of the texture atlas
+        50,                          // Height of the texture atlas
         Some(Vec2::new(64.0, 64.0)), // Optional minimum size
         Some(Vec2::new(32.0, 32.0)), // Optional maximum size
     );
@@ -95,7 +118,7 @@ fn create_texture_atlas(
     // Build a texture atlas using the individual sprites
     let mut texture_atlas_builder = TextureAtlasBuilder::default()
         .padding(padding.unwrap_or_default())
-        .max_size(Vec2::new(4000.0, 4000.0));
+        .max_size(Vec2::new(8000.0, 10000.0));
 
     for handle in folder.handles.iter() {
         let id = handle.id().typed_unchecked::<Image>();
@@ -107,11 +130,13 @@ fn create_texture_atlas(
             continue;
         };
 
+        info!("id {}, path {:?}", id, handle.path());
         texture_atlas_builder.add_texture(Some(id), texture);
     }
 
     let (texture_atlas_layout, texture) = texture_atlas_builder.finish().unwrap();
 
+    info!("size {}", texture_atlas_layout.size);
     let texture = textures.add(texture);
 
     (texture_atlas_layout, texture)
@@ -175,12 +200,3 @@ fn update_cursor_position(
         .and_then(|cursor| camera.viewport_to_world(camera_transform, cursor))
         .map(|ray| ray.origin.truncate());
 }
-
-impl Default for GlobalTextureAtlas {
-    fn default() -> Self {
-        Self {
-            layout: None,
-            image: None,
-        }
-    }
-}

src/configs.rs

@@ -51,7 +51,7 @@ fn init_world(
             texture: handle.image.clone().unwrap(),
             atlas: TextureAtlas {
                 layout: handle.layout.clone().unwrap(),
-                index: 118,
+                index: 0,
             },
             transform: Transform::from_scale(Vec3::splat(SPRITE_SCALE_FACTOR)),
             ..default()
@@ -69,12 +69,15 @@ fn spawn_world_decorations(mut commands: Commands, handle: Res<GlobalTextureAtla
     for _ in 0..NUM_WORLD_DECORATIONS {
         let x = rng.gen_range(-WORLD_W..WORLD_W);
         let y = rng.gen_range(-WORLD_H..WORLD_H);
+
+        let index = rng.gen_range(1200..=1240);
+
         commands.spawn((
             SpriteSheetBundle {
                 texture: handle.image.clone().unwrap(),
                 atlas: TextureAtlas {
                     layout: handle.layout.clone().unwrap(),
-                    index: rng.gen_range(49..=53),
+                    index,
                 },
                 transform: Transform::from_translation(vec3(x, y, 0.0))
                     .with_scale(Vec3::splat(SPRITE_SCALE_FACTOR)),