From 2b711f12d6a3f9eab3caae43dc838bebe6bf2daa Mon Sep 17 00:00:00 2001
From: mikeder <mikedernet@gmail.com>
Date: Wed, 14 Jun 2023 16:01:32 -0400
Subject: [PATCH] add npc goose, release 0.8.0

---
 Cargo.lock                |   2 +-
 Cargo.toml                |   4 +-
 assets/textures/goose.png | Bin 0 -> 1912 bytes
 src/debug/components.rs   |   4 +
 src/debug/console.rs      |  47 ++++++-----
 src/debug/plugin.rs       |  14 +++-
 src/graphics.rs           |  21 ++++-
 src/lib.rs                |  15 ++--
 src/loading.rs            |   2 +
 src/main.rs               |  17 ++--
 src/npc/components.rs     |  15 ++++
 src/npc/mod.rs            |   3 +
 src/npc/plugin.rs         |  38 +++++++++
 src/npc/systems.rs        | 167 ++++++++++++++++++++++++++++++++++++++
 src/player/components.rs  |  29 ++++---
 src/player/plugin.rs      |  12 ++-
 src/player/round.rs       |  37 ++++++++-
 src/player/systems.rs     | 114 ++++++++++++++++----------
 18 files changed, 435 insertions(+), 106 deletions(-)
 create mode 100644 assets/textures/goose.png
 create mode 100644 src/npc/components.rs
 create mode 100644 src/npc/mod.rs
 create mode 100644 src/npc/plugin.rs
 create mode 100644 src/npc/systems.rs

diff --git a/Cargo.lock b/Cargo.lock
index 8997931..9fed945 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5055,7 +5055,7 @@ dependencies = [
 
 [[package]]
 name = "turtle_time"
-version = "0.7.3"
+version = "0.8.0"
 dependencies = [
  "bevy",
  "bevy-inspector-egui",
diff --git a/Cargo.toml b/Cargo.toml
index de973dc..d54b23a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
 name = "turtle_time"
-version = "0.7.3"
+version = "0.8.0"
 publish = false
-authors = ["Mike Eder <mikedernet@gmail.com>"]   # ToDo: you are the author 
+authors = ["Mike Eder <mikedernet@gmail.com>"]
 edition = "2021"
 exclude = ["dist", "build", "assets", "credits"]
 
diff --git a/assets/textures/goose.png b/assets/textures/goose.png
new file mode 100644
index 0000000000000000000000000000000000000000..67af23f8a1668cfd4180f950fc07d81eb8934110
GIT binary patch
literal 1912
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

literal 0
HcmV?d00001

diff --git a/src/debug/components.rs b/src/debug/components.rs
index 9d7d7b2..983a1de 100644
--- a/src/debug/components.rs
+++ b/src/debug/components.rs
@@ -15,5 +15,9 @@ pub struct ConsoleReady(pub bool);
 
 pub struct PeerInfo(pub String);
 
+#[derive(Resource)]
+
+pub struct EdibleCount(pub usize);
+
 #[derive(Resource)]
 pub struct ConsoleUpdateTimer(pub Timer);
diff --git a/src/debug/console.rs b/src/debug/console.rs
index ab4164a..cde8e97 100644
--- a/src/debug/console.rs
+++ b/src/debug/console.rs
@@ -1,4 +1,6 @@
-use super::components::{ConsoleReady, ConsoleText, ConsoleUI, ConsoleUpdateTimer, PeerInfo};
+use super::components::{
+    ConsoleReady, ConsoleText, ConsoleUI, ConsoleUpdateTimer, EdibleCount, PeerInfo,
+};
 use crate::loading::FontAssets;
 use bevy::prelude::*;
 
@@ -58,7 +60,12 @@ pub fn setup_ui(mut commands: Commands, font_assets: Res<FontAssets>) {
                 ..Default::default()
             },
             visibility: Visibility::Hidden,
-            background_color: BackgroundColor(Color::BLACK),
+            background_color: BackgroundColor(Color::Rgba {
+                red: 0.,
+                green: 0.,
+                blue: 0.,
+                alpha: 0.7,
+            }),
             ..Default::default()
         })
         .with_children(|parent| {
@@ -71,24 +78,14 @@ pub fn setup_ui(mut commands: Commands, font_assets: Res<FontAssets>) {
                         ..Default::default()
                     },
                     text: Text {
-                        sections: vec![
-                            TextSection {
-                                value: "Peer Info: ".to_owned(),
-                                style: TextStyle {
-                                    font: font_assets.fira_sans.clone(),
-                                    font_size: 15.0,
-                                    color: Color::GREEN,
-                                },
+                        sections: vec![TextSection {
+                            value: "".to_owned(),
+                            style: TextStyle {
+                                font: font_assets.fira_sans.clone(),
+                                font_size: 15.0,
+                                color: Color::GREEN,
                             },
-                            TextSection {
-                                value: "".to_owned(),
-                                style: TextStyle {
-                                    font: font_assets.fira_sans.clone(),
-                                    font_size: 15.0,
-                                    color: Color::GREEN,
-                                },
-                            },
-                        ],
+                        }],
                         ..Default::default()
                     },
                     ..Default::default()
@@ -100,14 +97,22 @@ pub fn setup_ui(mut commands: Commands, font_assets: Res<FontAssets>) {
         .insert(ConsoleUI);
 
     commands.insert_resource(PeerInfo("".to_string()));
+    commands.insert_resource(EdibleCount(0));
     commands.insert_resource(ConsoleUpdateTimer(Timer::from_seconds(
         1.0,
         TimerMode::Repeating,
     )))
 }
 
-pub fn set_peer_info(peer_info: ResMut<PeerInfo>, mut query: Query<&mut Text, With<ConsoleText>>) {
+pub fn update_console_text(
+    edible_count: ResMut<EdibleCount>,
+    peer_info: ResMut<PeerInfo>,
+    mut query: Query<&mut Text, With<ConsoleText>>,
+) {
     for mut text in query.iter_mut() {
-        text.sections[1].value = peer_info.0.to_string();
+        text.sections[0].value = format!(
+            "Edible count: {}\nPeer Info: \n{}",
+            edible_count.0, peer_info.0
+        );
     }
 }
diff --git a/src/debug/plugin.rs b/src/debug/plugin.rs
index 6c84e06..0569965 100644
--- a/src/debug/plugin.rs
+++ b/src/debug/plugin.rs
@@ -5,15 +5,16 @@ use bevy_inspector_egui::quick::WorldInspectorPlugin;
 
 use crate::{
     menu::connect::LocalHandle,
+    npc::components::EdibleTarget,
     player::input::GGRSConfig,
     player::{
         checksum::Checksum,
-        components::{EdibleSpawnTimer, Player, PlayerHealth},
+        components::{Edible, EdibleSpawnTimer, Player, PlayerHealth},
     },
     AppState, GameState,
 };
 
-use super::components::{ConsoleReady, ConsoleUpdateTimer, PeerInfo};
+use super::components::{ConsoleReady, ConsoleUpdateTimer, EdibleCount, PeerInfo};
 use super::console::*;
 
 pub struct DebugPlugin;
@@ -25,6 +26,8 @@ impl Plugin for DebugPlugin {
                 .register_type::<Checksum>()
                 .register_type::<ConsoleReady>()
                 .register_type::<LocalHandle>()
+                .register_type::<EdibleTarget>()
+                .register_type::<Edible>()
                 .register_type::<EdibleSpawnTimer>()
                 .register_type::<Player>()
                 .register_type::<PlayerHealth>();
@@ -39,12 +42,17 @@ impl Plugin for ConsolePlugin {
         app.add_system(setup_ui.in_schedule(OnExit(AppState::Loading)))
             .add_system(log_ggrs_events.in_set(OnUpdate(GameState::Playing)))
             .add_system(open_console)
-            .add_system(set_peer_info.run_if(resource_exists::<PeerInfo>()))
+            .add_system(count_edibles.run_if(resource_exists::<EdibleCount>()))
+            .add_system(update_console_text.run_if(resource_exists::<PeerInfo>()))
             .add_system(reset_console_ready.run_if(resource_exists::<PeerInfo>()))
             .add_system(update_peer_info.run_if(resource_exists::<Session<GGRSConfig>>()));
     }
 }
 
+pub fn count_edibles(mut edible_count: ResMut<EdibleCount>, edible_query: Query<&Edible>) {
+    edible_count.0 = edible_query.iter().collect::<Vec<_>>().len();
+}
+
 pub fn update_peer_info(
     session: Res<Session<GGRSConfig>>,
     time: Res<Time>,
diff --git a/src/graphics.rs b/src/graphics.rs
index 1dfa623..b2a1b24 100644
--- a/src/graphics.rs
+++ b/src/graphics.rs
@@ -6,8 +6,10 @@ pub struct GraphicsPlugin;
 
 #[derive(Resource)]
 pub struct CharacterSheet {
-    pub handle: Handle<TextureAtlas>,
+    pub turtle_handle: Handle<TextureAtlas>,
+    pub goose_handle: Handle<TextureAtlas>,
     pub turtle_frames: [usize; 4],
+    pub goose_frames: [usize; 4],
 }
 
 #[derive(Component)]
@@ -32,6 +34,7 @@ impl GraphicsPlugin {
         mut commands: Commands,
         mut texture_atlases: ResMut<Assets<TextureAtlas>>,
     ) {
+        // load turtle atlas sheet
         let turtle_atlas = TextureAtlas::from_grid(
             assets.texture_turtle_cheeks_frame_party_hat.clone(),
             Vec2::splat(TILE_SIZE),
@@ -40,11 +43,23 @@ impl GraphicsPlugin {
             Some(Vec2 { x: 2.0, y: 0. }),
             Some(Vec2 { x: 0.0, y: 0. }),
         );
-        let atlas_handle = texture_atlases.add(turtle_atlas);
 
+        // load goose atlas sheet
+        let goose_atlas = TextureAtlas::from_grid(
+            assets.texture_goose.clone(),
+            Vec2::splat(TILE_SIZE),
+            4,
+            1,
+            Some(Vec2 { x: 1.0, y: 0. }),
+            Some(Vec2 { x: 0.0, y: 0. }),
+        );
+
+        // add character sheet with atlas and frame instructions
         commands.insert_resource(CharacterSheet {
-            handle: atlas_handle,
+            turtle_handle: texture_atlases.add(turtle_atlas),
             turtle_frames: [0, 1, 2, 3],
+            goose_handle: texture_atlases.add(goose_atlas),
+            goose_frames: [0, 1, 2, 3],
         });
     }
 
diff --git a/src/lib.rs b/src/lib.rs
index be85104..2c03c8c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,18 +6,20 @@ mod graphics;
 mod loading;
 mod map;
 mod menu;
+pub mod npc;
 pub mod player;
 
 use crate::actions::ActionsPlugin;
 use crate::audio::InternalAudioPlugin;
 use crate::loading::LoadingPlugin;
 use ascii::AsciiPlugin;
-use bevy::app::App;
 use bevy::prelude::*;
+use bevy::{app::App, diagnostic::FrameTimeDiagnosticsPlugin};
 use debug::plugin::{ConsolePlugin, DebugPlugin};
 use graphics::GraphicsPlugin;
 use map::tilemap::TileMapPlugin;
 use menu::plugin::MenuPlugin;
+use npc::plugin::GoosePlugin;
 use player::plugin::PlayerPlugin;
 
 #[cfg(debug_assertions)]
@@ -85,18 +87,19 @@ impl Plugin for GamePlugin {
             .add_plugin(ActionsPlugin)
             .add_plugin(InternalAudioPlugin)
             .add_plugin(PlayerPlugin)
+            .add_plugin(GoosePlugin)
             .add_plugin(ConsolePlugin);
 
         #[cfg(debug_assertions)]
         {
             // With FPS
-            // app.add_plugin(FrameTimeDiagnosticsPlugin::default())
-            //     .add_plugin(DebugPlugin)
-            //     .add_plugin(LogDiagnosticsPlugin::default());
+            app.add_plugin(FrameTimeDiagnosticsPlugin::default())
+                .add_plugin(DebugPlugin)
+                .add_plugin(LogDiagnosticsPlugin::default());
 
             // Without FPS
-            app.add_plugin(DebugPlugin)
-                .add_plugin(LogDiagnosticsPlugin::default());
+            // app.add_plugin(DebugPlugin)
+            //     .add_plugin(LogDiagnosticsPlugin::default());
         }
     }
 }
diff --git a/src/loading.rs b/src/loading.rs
index b067113..6f49f0e 100644
--- a/src/loading.rs
+++ b/src/loading.rs
@@ -60,6 +60,8 @@ pub struct TextureAssets {
     pub texture_fireball: Handle<Image>,
     #[asset(path = "textures/lettuce.png")]
     pub texture_lettuce: Handle<Image>,
+    #[asset(path = "textures/goose.png")]
+    pub texture_goose: Handle<Image>,
     // map textures
     #[asset(path = "textures/dirt.png")]
     pub texture_dirt: Handle<Image>,
diff --git a/src/main.rs b/src/main.rs
index 475d709..7265655 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -7,10 +7,12 @@ use bevy::winit::WinitWindows;
 use bevy::DefaultPlugins;
 use bevy_ggrs::GGRSPlugin;
 use std::io::Cursor;
+use turtle_time::npc::components::{EdibleTarget, Goose, HasTarget};
 use turtle_time::player::checksum::Checksum;
 use turtle_time::player::components::{
-    ChiliPepper, EdibleSpawnTimer, Fireball, FireballAmmo, FireballMovement, FireballReady,
-    Lettuce, Player, PlayerHealth, PlayerPoop, PlayerSpeed, PlayerSpeedBoost, Strawberry,
+    Edible, EdibleSpawnTimer, Expired, Fireball, FireballAmmo, FireballMovement, FireballReady,
+    FireballTimer, Player, PlayerHealth, PlayerPoop, PlayerPoopTimer, PlayerSpeed,
+    PlayerSpeedBoost, RoundComponent,
 };
 use turtle_time::player::input::{input, GGRSConfig, PlayerControls};
 use turtle_time::{GamePlugin, ASPECT_RATIO, FPS, MAP_HEIGHT};
@@ -23,19 +25,24 @@ fn main() {
         .with_update_frequency(FPS)
         .with_input_system(input)
         .register_rollback_component::<Checksum>()
-        .register_rollback_component::<ChiliPepper>()
+        .register_rollback_component::<Edible>()
+        .register_rollback_component::<EdibleTarget>()
+        .register_rollback_component::<Expired>()
         .register_rollback_component::<Fireball>()
         .register_rollback_component::<FireballAmmo>()
         .register_rollback_component::<FireballReady>()
         .register_rollback_component::<FireballMovement>()
-        .register_rollback_component::<Lettuce>()
+        .register_rollback_component::<FireballTimer>()
+        .register_rollback_component::<Goose>()
+        .register_rollback_component::<HasTarget>()
         .register_rollback_component::<Player>()
         .register_rollback_component::<PlayerHealth>()
         .register_rollback_component::<PlayerSpeed>()
         .register_rollback_component::<PlayerSpeedBoost>()
         .register_rollback_component::<PlayerControls>()
         .register_rollback_component::<PlayerPoop>()
-        .register_rollback_component::<Strawberry>()
+        .register_rollback_component::<PlayerPoopTimer>()
+        .register_rollback_component::<RoundComponent>()
         .register_rollback_component::<Transform>()
         .register_rollback_resource::<EdibleSpawnTimer>()
         .build(&mut app);
diff --git a/src/npc/components.rs b/src/npc/components.rs
new file mode 100644
index 0000000..3dba231
--- /dev/null
+++ b/src/npc/components.rs
@@ -0,0 +1,15 @@
+use bevy::prelude::*;
+
+pub const GOOSE_SPEED: i32 = 105;
+
+#[derive(Component, Default, Hash, Reflect)]
+#[reflect(Component, Hash)]
+pub struct Goose;
+
+#[derive(Component, Default, Hash, Reflect)]
+#[reflect(Component, Hash)]
+pub struct HasTarget;
+
+#[derive(Component, Default, Hash, Reflect)]
+#[reflect(Component, Hash)]
+pub struct EdibleTarget;
diff --git a/src/npc/mod.rs b/src/npc/mod.rs
new file mode 100644
index 0000000..fc06ca5
--- /dev/null
+++ b/src/npc/mod.rs
@@ -0,0 +1,3 @@
+pub mod components;
+pub mod plugin;
+pub mod systems;
diff --git a/src/npc/plugin.rs b/src/npc/plugin.rs
new file mode 100644
index 0000000..77c7662
--- /dev/null
+++ b/src/npc/plugin.rs
@@ -0,0 +1,38 @@
+use bevy::prelude::*;
+use bevy_ggrs::GGRSSchedule;
+
+use crate::{
+    player::plugin::{EdibleSystemSet, PlayerSystemSet, SpawnSystemSet},
+    GameState,
+};
+
+use super::systems::{
+    geese_target_closest_edible, goose_ate_edible, move_geese_toward_target, spawn_geese,
+};
+
+pub struct GoosePlugin;
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
+pub struct NpcSystemSet;
+
+/// This plugin handles player related stuff like movement
+/// Player logic is only active during the State `GameState::Playing`
+impl Plugin for GoosePlugin {
+    fn build(&self, app: &mut App) {
+        app.add_system(spawn_geese.in_schedule(OnEnter(GameState::Playing)))
+            .add_systems(
+                (
+                    geese_target_closest_edible,
+                    move_geese_toward_target,
+                    goose_ate_edible,
+                )
+                    .chain()
+                    .in_set(NpcSystemSet)
+                    .after(EdibleSystemSet)
+                    .after(SpawnSystemSet)
+                    .after(PlayerSystemSet)
+                    .distributive_run_if(in_state(GameState::Playing))
+                    .in_schedule(GGRSSchedule),
+            );
+    }
+}
diff --git a/src/npc/systems.rs b/src/npc/systems.rs
new file mode 100644
index 0000000..c8b8778
--- /dev/null
+++ b/src/npc/systems.rs
@@ -0,0 +1,167 @@
+use bevy::{math::Vec3Swizzles, prelude::*};
+use bevy_ggrs::RollbackIdProvider;
+use rand::Rng;
+
+use crate::{
+    debug,
+    graphics::{CharacterSheet, FrameAnimation},
+    map::tilemap::EncounterSpawner,
+    npc::components::{EdibleTarget, Goose, HasTarget},
+    player::{
+        components::{Edible, Expired, RoundComponent},
+        resources::AgreedRandom,
+    },
+    FPS, TILE_SIZE,
+};
+
+use super::components::GOOSE_SPEED;
+
+pub fn spawn_geese(
+    mut commands: Commands,
+    characters: Res<CharacterSheet>,
+    mut rip: ResMut<RollbackIdProvider>,
+    mut agreed_seed: ResMut<AgreedRandom>,
+    spawner_query: Query<&Transform, With<EncounterSpawner>>,
+) {
+    trace!("spawn_geese");
+
+    let spawn_area: Vec<&Transform> = spawner_query.iter().collect();
+    let idx = agreed_seed.rng.gen_range(0..spawn_area.len());
+    let pos = spawn_area[idx].translation;
+
+    let mut sprite = TextureAtlasSprite::new(characters.goose_frames[0]);
+    sprite.custom_size = Some(Vec2::splat(TILE_SIZE * 2.));
+
+    commands.spawn((
+        Name::new("Goose"),
+        SpriteSheetBundle {
+            sprite,
+            texture_atlas: characters.goose_handle.clone(),
+            transform: Transform {
+                translation: Vec3::new(pos.x, pos.y, 1.),
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+        FrameAnimation {
+            timer: Timer::from_seconds(0.2, TimerMode::Repeating),
+            frames: characters.goose_frames.to_vec(),
+            current_frame: 0,
+        },
+        Goose,
+        RoundComponent,
+        rip.next(),
+    ));
+}
+
+pub fn geese_target_closest_edible(
+    mut commands: Commands,
+    edible_query: Query<(Entity, &Transform), (With<Edible>, Without<Expired>)>,
+    goose_query: Query<(Entity, &Transform), (With<Goose>, Without<HasTarget>)>,
+) {
+    trace!("geese_target_closest_edible");
+
+    for (goose_entity, transform) in goose_query.iter() {
+        let mut closest_entity = Entity::PLACEHOLDER;
+        let mut closest_transform = Vec3::splat(0.);
+        let goose_pos = transform.translation;
+
+        // find closest edible entity
+        for (edible_entity, edible_transform) in edible_query.iter() {
+            // replace placeholder values on first iteration to avoid failing to
+            // find a target in certain locations
+            if closest_entity == Entity::PLACEHOLDER && edible_entity != Entity::PLACEHOLDER {
+                closest_entity = edible_entity;
+                closest_transform = edible_transform.translation;
+            }
+
+            let distance_to_next = goose_pos.distance(edible_transform.translation);
+            let distance_to_previous = goose_pos.distance(closest_transform);
+
+            if distance_to_next < distance_to_previous {
+                closest_entity = edible_entity;
+                closest_transform = edible_transform.translation;
+            }
+        }
+
+        if closest_entity == Entity::PLACEHOLDER {
+            // do not target placeholder entities
+            // they may be outside of the map
+            debug!("skip target placeholder entity");
+            continue;
+        }
+
+        debug!(
+            "goose targeting closest entity {:?} at distance {:?}",
+            closest_entity,
+            goose_pos.distance(closest_transform)
+        );
+        commands.entity(closest_entity).insert(EdibleTarget);
+        commands.entity(goose_entity).insert(HasTarget);
+    }
+}
+
+pub fn move_geese_toward_target(
+    mut commands: Commands,
+    target_query: Query<(Entity, &Transform), (With<EdibleTarget>, Without<Expired>)>,
+    mut goose_query: Query<
+        (Entity, &mut Transform, &mut TextureAtlasSprite),
+        (With<Goose>, With<HasTarget>, Without<EdibleTarget>),
+    >,
+) {
+    trace!("move_geese_toward_target");
+
+    // collect and sort all targets in play so we move towards them in a deterministic order
+    let mut targets = target_query.iter().collect::<Vec<_>>();
+    targets.sort_by_key(|e| e.0);
+    debug!("number of targets: {:?}", targets.len());
+
+    for (goose_entity, mut goose_pos, mut sprite) in goose_query.iter_mut() {
+        debug!("goose loop");
+        if targets.len() == 0 {
+            commands.entity(goose_entity).remove::<HasTarget>();
+            return;
+        }
+        let target = &targets[0]; // move towards first target
+
+        let dir = (goose_pos.translation.xy() - target.1.translation.xy()).normalize();
+        let movement = (dir * GOOSE_SPEED as f32 / FPS as f32).extend(0.);
+        if movement.x != 0.0 {
+            if movement.x > 0.0 {
+                sprite.flip_x = true;
+            } else {
+                sprite.flip_x = false;
+            }
+        }
+        let target = goose_pos.translation - Vec3::new(movement.x, movement.y, 0.0);
+        goose_pos.translation = target; // TODO: prevent goose from clipping through walls
+    }
+}
+
+pub fn goose_ate_edible(
+    mut commands: Commands,
+    goose_query: Query<(Entity, &Transform), (With<Goose>, With<HasTarget>)>,
+    target_query: Query<(Entity, &Transform), (With<EdibleTarget>, Without<Expired>)>,
+) {
+    trace!("goose_ate_edible");
+
+    // collect and sort all fireballs in play so we despawn them in a deterministic order
+    let mut targets = target_query.iter().collect::<Vec<_>>();
+    targets.sort_by_key(|e| e.0);
+
+    for (goose_entity, goose_pos) in goose_query.iter() {
+        for target in &targets {
+            let distance = goose_pos.translation.distance(target.1.translation);
+            debug!(
+                "goose distance from target: {:?} - {:?}",
+                target.0, distance
+            );
+
+            if distance < TILE_SIZE / 2. {
+                debug!("goose reached target, despawn and find new one");
+                commands.entity(goose_entity).remove::<HasTarget>();
+                commands.entity(target.0).insert(Expired);
+            }
+        }
+    }
+}
diff --git a/src/player/components.rs b/src/player/components.rs
index c1c04f6..21086d2 100644
--- a/src/player/components.rs
+++ b/src/player/components.rs
@@ -31,7 +31,18 @@ pub const POOP_SIZE: f32 = 16.0;
 pub const POOP_DAMAGE: i32 = 2;
 pub const POOP_LIFETIME: f32 = 10.0;
 
-#[derive(Component)]
+#[derive(Component, Default, Hash, Reflect)]
+#[reflect(Component, Hash)]
+pub enum Edible {
+    #[default]
+    PLACEHOLDER,
+    ChiliPepper,
+    Strawberry,
+    Lettuce,
+}
+
+#[derive(Component, Default, Hash, Reflect)]
+#[reflect(Component, Hash)]
 pub struct RoundComponent;
 
 #[derive(Component, Default, Hash, Reflect)]
@@ -80,10 +91,6 @@ impl Default for EdibleSpawnTimer {
     }
 }
 
-#[derive(Component, Default, Hash, Reflect)]
-#[reflect(Component, Hash)]
-pub struct ChiliPepper;
-
 #[derive(Component, Default, Reflect, Hash)]
 #[reflect(Component, Hash)]
 pub struct PlayerPoop {
@@ -112,14 +119,6 @@ pub struct FireballAmmo(pub i32);
 #[reflect(Component)]
 pub struct FireballReady(pub bool);
 
-#[derive(Component, Default, Reflect, Hash)]
-#[reflect(Component, Hash)]
-pub struct Strawberry;
-
-#[derive(Component, Default, Hash, Reflect)]
-#[reflect(Component, Hash)]
-pub struct Lettuce;
-
 #[derive(Component, Copy, Clone, Debug, Reflect, InspectorOptions, Hash)]
 #[reflect(Component, InspectorOptions, Hash)]
 pub struct Player {
@@ -193,3 +192,7 @@ impl Default for Player {
         }
     }
 }
+
+#[derive(Component, Default, Hash, Reflect)]
+#[reflect(Component, Hash)]
+pub struct Expired;
diff --git a/src/player/plugin.rs b/src/player/plugin.rs
index 3738a61..b4174ab 100644
--- a/src/player/plugin.rs
+++ b/src/player/plugin.rs
@@ -1,7 +1,9 @@
 use super::checksum::checksum_players;
 use super::components::EdibleSpawnTimer;
 use super::resources::{HealthBarsAdded, PlayersReady};
-use super::round::{cleanup_round, cleanup_session, disconnect_remote_players, setup_round};
+use super::round::{
+    cleanup_round, cleanup_session, disconnect_remote_players, remove_expired, setup_round,
+};
 use crate::player::systems::*;
 use crate::{AppState, GameState};
 use bevy::prelude::*;
@@ -25,8 +27,11 @@ impl Plugin for PlayerPlugin {
             .add_system(camera_follow.run_if(in_state(GameState::Playing)))
             // round cleanup
             .add_system(disconnect_remote_players.in_schedule(OnExit(AppState::RoundOnline)))
-            .add_system(cleanup_round.in_schedule(OnEnter(AppState::Win)))
-            .add_system(cleanup_session.in_schedule(OnExit(AppState::Win)))
+            .add_systems(
+                (cleanup_session, cleanup_round)
+                    .chain()
+                    .in_schedule(OnEnter(AppState::Win)),
+            )
             // stateless timers and UI text updates
             .add_systems(
                 (
@@ -72,6 +77,7 @@ impl Plugin for PlayerPlugin {
                     despawn_old_poops,
                     tick_fireball_timers,
                     tick_poop_timers,
+                    remove_expired,
                 )
                     .chain()
                     .in_set(EdibleSystemSet)
diff --git a/src/player/round.rs b/src/player/round.rs
index 2266e22..cb634d3 100644
--- a/src/player/round.rs
+++ b/src/player/round.rs
@@ -10,7 +10,11 @@ use crate::{
     },
 };
 
-use super::{components::RoundComponent, input::GGRSConfig, resources::AgreedRandom};
+use super::{
+    components::{Expired, RoundComponent},
+    input::GGRSConfig,
+    resources::AgreedRandom,
+};
 
 pub fn setup_round(mut commands: Commands) {
     trace!("setup_round");
@@ -55,12 +59,20 @@ pub fn cleanup_round(
 ) {
     info!("Cleanup Round");
 
-    for e in query.iter() {
+    let mut targets = query.iter().collect::<Vec<_>>();
+    targets.sort_by_key(|e| *e);
+    debug!(
+        "number of non-rollback entities to remove: {:?}",
+        targets.len()
+    );
+
+    for e in targets {
+        debug!("Despawn entity: {:?}", e);
         commands.entity(e).despawn_recursive();
     }
 }
 
-pub fn cleanup_session(mut commands: Commands, rollback_query: Query<Entity, With<Rollback>>) {
+pub fn cleanup_session(mut commands: Commands, query: Query<Entity, With<Rollback>>) {
     debug!("Cleanup Session");
 
     commands.remove_resource::<PlayersReady>();
@@ -78,8 +90,25 @@ pub fn cleanup_session(mut commands: Commands, rollback_query: Query<Entity, Wit
     // remove edible spawn timer, we will spawn a new one each round
     commands.remove_resource::<EdibleSpawnTimer>();
 
-    for e in rollback_query.iter() {
+    let mut targets = query.iter().collect::<Vec<_>>();
+    targets.sort_by_key(|e| *e);
+    debug!("number of rollback entities to remove: {:?}", targets.len());
+
+    for e in targets {
         debug!("Despawn entity: {:?}", e);
         commands.entity(e).despawn_recursive()
     }
 }
+
+pub fn remove_expired(mut commands: Commands, expired_query: Query<Entity, With<Expired>>) {
+    trace!("remove_expired");
+
+    let mut expired = expired_query.iter().collect::<Vec<_>>();
+    expired.sort_by_key(|e| *e);
+    debug!("expiring entities: {:?}", expired.len());
+
+    for e in expired {
+        commands.entity(e).despawn_recursive();
+        debug!("expired: {:?}", e);
+    }
+}
diff --git a/src/player/systems.rs b/src/player/systems.rs
index 7064fda..7961ae5 100644
--- a/src/player/systems.rs
+++ b/src/player/systems.rs
@@ -2,13 +2,13 @@ use std::time::Duration;
 
 use super::checksum::Checksum;
 use super::components::{
-    ChiliPepper, EdibleSpawnTimer, Fireball, FireballAmmo, FireballMovement, FireballReady,
-    FireballTimer, Lettuce, Player, PlayerFireballText, PlayerHealth, PlayerHealthBar,
-    PlayerHealthText, PlayerPoop, PlayerPoopTimer, PlayerSpeed, PlayerSpeedBoost,
-    PlayerSpeedBoostText, RoundComponent, Strawberry, CHILI_PEPPER_AMMO_COUNT, CHILI_PEPPER_SIZE,
-    FIREBALL_DAMAGE, FIREBALL_RADIUS, LETTUCE_HEALTH_GAIN, LETTUCE_SIZE, PLAYER_HEALTH_LOW,
-    PLAYER_HEALTH_MAX, PLAYER_HEALTH_MID, PLAYER_SPEED_BOOST, PLAYER_SPEED_MAX, PLAYER_SPEED_START,
-    POOP_DAMAGE, POOP_SIZE, STRAWBERRY_AMMO_COUNT, STRAWBERRY_SIZE,
+    Edible, EdibleSpawnTimer, Fireball, FireballAmmo, FireballMovement, FireballReady,
+    FireballTimer, Player, PlayerFireballText, PlayerHealth, PlayerHealthBar, PlayerHealthText,
+    PlayerPoop, PlayerPoopTimer, PlayerSpeed, PlayerSpeedBoost, PlayerSpeedBoostText,
+    RoundComponent, CHILI_PEPPER_AMMO_COUNT, CHILI_PEPPER_SIZE, FIREBALL_DAMAGE, FIREBALL_RADIUS,
+    LETTUCE_HEALTH_GAIN, LETTUCE_SIZE, PLAYER_HEALTH_LOW, PLAYER_HEALTH_MAX, PLAYER_HEALTH_MID,
+    PLAYER_SPEED_BOOST, PLAYER_SPEED_MAX, PLAYER_SPEED_START, POOP_DAMAGE, POOP_SIZE,
+    STRAWBERRY_AMMO_COUNT, STRAWBERRY_SIZE,
 };
 use super::input::{
     GGRSConfig, PlayerControls, INPUT_DOWN, INPUT_EXIT, INPUT_FIRE, INPUT_LEFT, INPUT_RIGHT,
@@ -22,6 +22,7 @@ use crate::map::tilemap::{EncounterSpawner, PlayerSpawn, TileCollider};
 use crate::menu::connect::LocalHandle;
 use crate::menu::online::PlayerCount;
 use crate::menu::win::MatchData;
+use crate::player::components::Expired;
 use crate::player::resources::PlayersReady;
 use crate::{AppState, FIXED_TICK_MS, FPS};
 use crate::{GameState, TILE_SIZE};
@@ -245,7 +246,7 @@ pub fn spawn_players(
             Name::new(name),
             SpriteSheetBundle {
                 sprite: sprite.clone(),
-                texture_atlas: characters.handle.clone(),
+                texture_atlas: characters.turtle_handle.clone(),
                 transform: Transform {
                     translation: Vec3::new(spawns[handle].pos.x, spawns[handle].pos.y, 1.),
                     ..Default::default()
@@ -367,17 +368,6 @@ pub fn move_players(
         }
 
         let movement = (controls.dir * speed.0 as f32 / FPS as f32).extend(0.);
-        if movement.x != 0. {
-            if movement.x > 0. {
-                // moving to the right
-                sprite.flip_x = false
-            }
-            if movement.x < 0. {
-                // moving to the left
-                sprite.flip_x = true
-            }
-        }
-
         let target = transform.translation + Vec3::new(0.0, movement.y, 0.0);
         if !walls
             .iter()
@@ -434,7 +424,7 @@ pub fn player_poops(
                     shat_by: player.handle,
                 },
                 PlayerPoopTimer::default(),
-                RoundComponent {},
+                RoundComponent,
                 SpriteBundle {
                     sprite: Sprite {
                         ..Default::default()
@@ -454,7 +444,7 @@ pub fn player_poops(
 pub fn player_stepped_in_poop(
     mut commands: Commands,
     mut player_query: Query<(&Transform, &mut PlayerHealth, &Player)>,
-    poop_query: Query<(Entity, &Transform, &PlayerPoop), With<Rollback>>,
+    poop_query: Query<(Entity, &Transform, &PlayerPoop), (With<Rollback>, Without<Expired>)>,
 ) {
     for (player_transform, mut health, player) in player_query.iter_mut() {
         for (poop_ent, poop_transform, poop) in poop_query.iter() {
@@ -468,13 +458,13 @@ pub fn player_stepped_in_poop(
             if distance < TILE_SIZE / 2.0 + POOP_SIZE / 2.0 {
                 // stepped in shit, take a little damage
                 health.0 -= POOP_DAMAGE;
-                commands.entity(poop_ent).despawn_recursive();
+                commands.entity(poop_ent).insert(Expired);
             }
         }
     }
 }
 
-pub fn tick_poop_timers(mut query: Query<(Entity, &mut PlayerPoopTimer)>) {
+pub fn tick_poop_timers(mut query: Query<(Entity, &mut PlayerPoopTimer), Without<Expired>>) {
     // collect and sort all poop timers in play so we tick them in a deterministic order
     let mut poop_timers = query.iter_mut().collect::<Vec<_>>();
     poop_timers.sort_by_key(|e| e.0);
@@ -484,14 +474,19 @@ pub fn tick_poop_timers(mut query: Query<(Entity, &mut PlayerPoopTimer)>) {
     }
 }
 
-pub fn despawn_old_poops(mut commands: Commands, mut query: Query<(Entity, &PlayerPoopTimer)>) {
+pub fn despawn_old_poops(
+    mut commands: Commands,
+    mut query: Query<(Entity, &PlayerPoopTimer), Without<Expired>>,
+) {
+    trace!("despawn_old_poops");
+
     // collect and sort all poops in play so we move them in a deterministic order
     let mut poops = query.iter_mut().collect::<Vec<_>>();
     poops.sort_by_key(|e| e.0);
 
     for (poop, timer) in poops {
         if timer.lifetime.finished() {
-            commands.entity(poop).despawn_recursive()
+            commands.entity(poop).insert(Expired);
         }
     }
 }
@@ -524,8 +519,8 @@ pub fn spawn_strawberry_over_time(
 
         commands.spawn((
             Name::new("Strawberry"),
-            Strawberry {},
-            RoundComponent {},
+            Edible::Strawberry,
+            RoundComponent,
             SpriteBundle {
                 transform: Transform::from_xyz(pos.translation.x, pos.translation.y, 1.0),
                 texture: asset_server.texture_strawberry.clone(),
@@ -540,18 +535,24 @@ pub fn spawn_strawberry_over_time(
 pub fn player_ate_strawberry_system(
     mut commands: Commands,
     mut player_query: Query<(&Transform, &mut PlayerSpeedBoost), With<Player>>,
-    strawberry_query: Query<(Entity, &Transform), (With<Strawberry>, With<Rollback>)>,
+    edible_query: Query<(Entity, &Edible, &Transform), Without<Expired>>,
 ) {
-    let mut strawberries = strawberry_query.iter().collect::<Vec<_>>();
+    let mut strawberries = edible_query
+        .iter()
+        .filter(|x| match x.1 {
+            Edible::Strawberry => true,
+            _ => false,
+        })
+        .collect::<Vec<_>>();
     strawberries.sort_by_key(|e| e.0);
 
     for (pt, mut p) in player_query.iter_mut() {
-        for (s, st) in strawberries.clone() {
+        for (s, _, st) in &strawberries {
             let distance = pt.translation.distance(st.translation);
 
             if distance < TILE_SIZE / 2.0 + STRAWBERRY_SIZE / 2.0 {
                 p.0 += STRAWBERRY_AMMO_COUNT;
-                commands.entity(s).despawn_recursive();
+                commands.entity(*s).insert(Expired);
             }
         }
     }
@@ -573,8 +574,8 @@ pub fn spawn_chili_pepper_over_time(
 
         commands.spawn((
             Name::new("ChiliPepper"),
-            ChiliPepper {},
-            RoundComponent {},
+            Edible::ChiliPepper,
+            RoundComponent,
             SpriteBundle {
                 sprite: Sprite {
                     custom_size: Some(Vec2::splat(CHILI_PEPPER_SIZE * 1.5)),
@@ -593,15 +594,24 @@ pub fn spawn_chili_pepper_over_time(
 pub fn player_ate_chili_pepper_system(
     mut commands: Commands,
     mut player_query: Query<(&Transform, &mut FireballAmmo), (With<Player>, Without<Fireball>)>,
-    pepper_query: Query<(Entity, &Transform), (With<ChiliPepper>, With<Rollback>)>,
+    edible_query: Query<(Entity, &Edible, &Transform), Without<Expired>>,
 ) {
+    let mut peppers = edible_query
+        .iter()
+        .filter(|x| match x.1 {
+            Edible::ChiliPepper => true,
+            _ => false,
+        })
+        .collect::<Vec<_>>();
+    peppers.sort_by_key(|e| e.0);
+
     for (pt, mut ammo) in player_query.iter_mut() {
-        for (s, st) in pepper_query.iter() {
+        for (s, _, st) in &peppers {
             let distance = pt.translation.distance(st.translation);
 
             if distance < TILE_SIZE / 2.0 + CHILI_PEPPER_SIZE / 2.0 {
                 ammo.0 += CHILI_PEPPER_AMMO_COUNT;
-                commands.entity(s).despawn_recursive();
+                commands.entity(*s).insert(Expired);
             }
         }
     }
@@ -623,8 +633,8 @@ pub fn spawn_lettuce_over_time(
 
         commands.spawn((
             Name::new("Lettuce"),
-            Lettuce {},
-            RoundComponent {},
+            Edible::Lettuce,
+            RoundComponent,
             SpriteBundle {
                 transform: Transform::from_xyz(pos.translation.x, pos.translation.y, 1.0),
                 texture: asset_server.texture_lettuce.clone(),
@@ -638,10 +648,19 @@ pub fn spawn_lettuce_over_time(
 pub fn player_ate_lettuce_system(
     mut commands: Commands,
     mut player_query: Query<(&Transform, &mut PlayerHealth), (With<Player>, Without<Fireball>)>,
-    lettuce_query: Query<(Entity, &Transform), (With<Lettuce>, With<Rollback>)>,
+    edible_query: Query<(Entity, &Edible, &Transform), Without<Expired>>,
 ) {
+    let mut lettuce = edible_query
+        .iter()
+        .filter(|x| match x.1 {
+            Edible::Lettuce => true,
+            _ => false,
+        })
+        .collect::<Vec<_>>();
+    lettuce.sort_by_key(|e| e.0);
+
     for (pt, mut health) in player_query.iter_mut() {
-        for (s, st) in lettuce_query.iter() {
+        for (s, _, st) in &lettuce {
             let distance = pt.translation.distance(st.translation);
 
             if distance < TILE_SIZE / 2.0 + LETTUCE_SIZE / 2.0 {
@@ -649,7 +668,7 @@ pub fn player_ate_lettuce_system(
                     // clamp health game to max health
                     health.0 = (health.0 + LETTUCE_HEALTH_GAIN).clamp(0, PLAYER_HEALTH_MAX);
                 }
-                commands.entity(s).despawn_recursive();
+                commands.entity(*s).insert(Expired);
             }
         }
     }
@@ -764,7 +783,7 @@ pub fn move_fireballs(
     }
 }
 
-pub fn tick_fireball_timers(mut query: Query<(Entity, &mut FireballTimer)>) {
+pub fn tick_fireball_timers(mut query: Query<(Entity, &mut FireballTimer), Without<Expired>>) {
     // collect and sort all timers in play so we tick them in a deterministic order
     let mut timers = query.iter_mut().collect::<Vec<_>>();
     timers.sort_by_key(|t| t.0);
@@ -774,7 +793,12 @@ pub fn tick_fireball_timers(mut query: Query<(Entity, &mut FireballTimer)>) {
     }
 }
 
-pub fn despawn_old_fireballs(mut commands: Commands, mut query: Query<(Entity, &FireballTimer)>) {
+pub fn despawn_old_fireballs(
+    mut commands: Commands,
+    mut query: Query<(Entity, &FireballTimer), Without<Expired>>,
+) {
+    trace!("despawn_old_fireballs");
+
     // collect and sort all fireballs in play so we despawn them in a deterministic order
     let mut fireballs = query.iter_mut().collect::<Vec<_>>();
     fireballs.sort_by_key(|e| e.0);
@@ -782,7 +806,7 @@ pub fn despawn_old_fireballs(mut commands: Commands, mut query: Query<(Entity, &
     for (fireball, timer) in fireballs {
         if timer.lifetime.finished() {
             debug!("Despawning old fireball {:?}", fireball);
-            commands.entity(fireball).despawn_recursive()
+            commands.entity(fireball).insert(Expired);
         }
     }
 }
@@ -817,7 +841,7 @@ pub fn fireball_damage_players(
 
             if distance < TILE_SIZE + FIREBALL_RADIUS {
                 health.0 -= FIREBALL_DAMAGE;
-                commands.entity(entity).despawn_recursive(); // despawn fireball
+                commands.entity(entity).insert(Expired); // despawn fireball
                 debug!(
                     "Fireball {:?} hit player, new health {:?}",
                     entity, health.0