diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 6098be7..5e1f8f7 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -113,7 +113,7 @@ jobs:
         with:
           name: binary
           path: |
-            ${{ env.PACKAGE_NAME }}
+            ${{ env.PACKAGE_NAME }}-${{ matrix.target }}
 
   # Get itch.io target from env, because the `env` context can't be used in the `if:` condition of a job.
   # See: https://docs.github.com/en/actions/learn-github-actions/contexts#context-availability
@@ -139,8 +139,8 @@ jobs:
       - name: download all packages
         uses: actions/download-artifact@v4
         with:
-          pattern: package-*
-          path: tmp
+          pattern: "*.zip"
+          path: "./"
 
       - name: install butler
         run: |
diff --git a/Cargo.lock b/Cargo.lock
index fa84d33..c25b485 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2797,7 +2797,7 @@ dependencies = [
 
 [[package]]
 name = "lifecycler"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "bevy",
  "bevy_atmosphere",
diff --git a/Cargo.toml b/Cargo.toml
index 80ff38b..d9108c0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "lifecycler"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 license = "MIT OR Apache-2.0 OR CC0-1.0"
 
diff --git a/src/fish.rs b/src/fish.rs
deleted file mode 100644
index 5e019a7..0000000
--- a/src/fish.rs
+++ /dev/null
@@ -1,275 +0,0 @@
-use std::f32::consts::PI;
-use std::time::Duration;
-
-use bevy::prelude::*;
-use bevy::time::common_conditions::on_timer;
-use bevy::utils::HashSet;
-use rand::seq::SliceRandom;
-use rand::{RngCore, SeedableRng};
-use rand_chacha::ChaCha8Rng;
-
-use crate::pellets::Pellet;
-
-const FISH_MAX: usize = 5;
-
-pub(super) fn plugin(app: &mut App) {
-    app.add_systems(Startup, setup_fish_system).add_systems(
-        Update,
-        (
-            spawn_fishes_system,
-            fish_behavior_system,
-            fish_behavior_change_system,
-            fish_pellet_detection_system.run_if(on_timer(Duration::from_secs_f32(0.5))),
-        ),
-    );
-}
-
-#[derive(Component)]
-pub struct Fish;
-
-#[derive(Resource, Deref, DerefMut)]
-pub struct FishRng(ChaCha8Rng);
-
-#[derive(Resource, Deref)]
-pub struct FishMesh(Handle<Mesh>);
-
-#[derive(Resource, Deref)]
-pub struct FishMaterials(Vec<Handle<StandardMaterial>>);
-
-#[derive(Resource, Deref, DerefMut)]
-pub struct FishTimer(Timer);
-
-pub enum FishBehaviorVariant {
-    Idle,
-    SwimRight,
-    SwimLeft,
-    SeekPoint(Vec3),
-    SeekPellet(Entity),
-}
-
-#[derive(Component)]
-pub struct FishBehavior {
-    timer: Timer,
-    variant: FishBehaviorVariant,
-}
-
-impl Default for FishBehavior {
-    fn default() -> Self {
-        Self {
-            timer: Timer::from_seconds(5., TimerMode::Repeating),
-            variant: FishBehaviorVariant::Idle,
-        }
-    }
-}
-
-fn setup_fish_system(
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
-) {
-    let fish_mesh = asset_server.load(
-        (GltfAssetLabel::Primitive {
-            mesh: 0,
-            primitive: 0,
-        })
-        .from_asset("fish.glb"),
-    );
-    commands.insert_resource(FishMesh(fish_mesh));
-
-    let mut seeded_rng = ChaCha8Rng::seed_from_u64(19878367467712);
-    let fish_materials = (0..36)
-        .map(|_| {
-            let base_color = Color::hsl((seeded_rng.next_u32() % 360) as f32, 0.4, 0.3);
-            let emissive = base_color.to_linear() * 0.1;
-
-            materials.add(StandardMaterial {
-                base_color,
-                emissive,
-                ..default()
-            })
-        })
-        .collect();
-    commands.insert_resource(FishMaterials(fish_materials));
-    commands.insert_resource(FishRng(seeded_rng));
-
-    let fish_timer = Timer::from_seconds(0.5, TimerMode::Repeating);
-    commands.insert_resource(FishTimer(fish_timer));
-}
-
-fn spawn_fishes_system(
-    mut commands: Commands,
-    time: Res<Time>,
-    mut fish_timer: ResMut<FishTimer>,
-    fish_mesh: Res<FishMesh>,
-    fish_materials: Res<FishMaterials>,
-    mut fish_rng: ResMut<FishRng>,
-    fishes: Query<Entity, With<Fish>>,
-) {
-    fish_timer.tick(time.delta());
-
-    let fish_count = fishes.iter().len();
-
-    if fish_timer.just_finished() && fish_count < FISH_MAX {
-        let mut transform = Transform::default()
-            .with_rotation(Quat::from_euler(EulerRot::XYZ, PI / 2., PI, 0.))
-            .with_scale(Vec3::new(0.2, 0.1, 0.15));
-        transform.translation += Cuboid::new(1.5, 1.5, 0.8).sample_interior(&mut fish_rng.0);
-
-        commands.spawn((
-            Fish,
-            FishBehavior::default(),
-            PbrBundle {
-                transform,
-                mesh: fish_mesh.clone(),
-                material: fish_materials.choose(&mut fish_rng.0).unwrap().clone(),
-                ..default()
-            },
-        ));
-    }
-}
-
-fn fish_behavior_system(
-    mut commands: Commands,
-    time: Res<Time>,
-    mut fishes: Query<(&mut Transform, &mut FishBehavior)>,
-    pellets: Query<&Transform, (With<Pellet>, Without<FishBehavior>)>,
-    mut fish_rng: ResMut<FishRng>,
-) {
-    let mut despawn_set = HashSet::new();
-
-    for (mut transform, mut behavior) in fishes.iter_mut() {
-        match behavior.variant {
-            FishBehaviorVariant::Idle => {
-                transform.translation.y += time.elapsed_seconds().sin() / 3000.;
-            }
-            FishBehaviorVariant::SwimRight => {
-                transform.translation.x += time.delta_seconds() / 10.;
-                if transform.translation.x > 1.4 {
-                    *transform =
-                        transform.with_rotation(Quat::from_euler(EulerRot::XYZ, PI / 2., 0., 0.));
-                    behavior.variant = FishBehaviorVariant::SwimLeft;
-                }
-            }
-            FishBehaviorVariant::SwimLeft => {
-                transform.translation.x -= time.delta_seconds() / 10.;
-                if transform.translation.x < -1.4 {
-                    *transform =
-                        transform.with_rotation(Quat::from_euler(EulerRot::XYZ, PI / 2., PI, 0.));
-                    behavior.variant = FishBehaviorVariant::SwimRight;
-                }
-            }
-            FishBehaviorVariant::SeekPoint(target) => {
-                if transform.translation.x < target.x {
-                    *transform =
-                        transform.with_rotation(Quat::from_euler(EulerRot::XYZ, PI / 2., PI, 0.));
-                } else {
-                    *transform =
-                        transform.with_rotation(Quat::from_euler(EulerRot::XYZ, PI / 2., 0., 0.));
-                }
-
-                transform.translation = transform
-                    .translation
-                    .move_towards(target, time.delta_seconds() / 10.);
-
-                if transform.translation.distance(target) < 0.1 {
-                    behavior.variant = FishBehaviorVariant::Idle;
-                    behavior.timer.reset();
-                }
-            }
-            FishBehaviorVariant::SeekPellet(pellet_id) => {
-                if let Ok(pellet_transform) = pellets.get(pellet_id) {
-                    if transform.translation.x < pellet_transform.translation.x {
-                        *transform = transform.with_rotation(Quat::from_euler(
-                            EulerRot::XYZ,
-                            PI / 2.,
-                            PI,
-                            0.,
-                        ));
-                    } else {
-                        *transform = transform.with_rotation(Quat::from_euler(
-                            EulerRot::XYZ,
-                            PI / 2.,
-                            0.,
-                            0.,
-                        ));
-                    }
-
-                    transform.translation = transform
-                        .translation
-                        .move_towards(pellet_transform.translation, time.delta_seconds() * 0.5);
-
-                    transform.translation = transform
-                        .translation
-                        .clamp(Vec3::new(-1.7, -1.65, -0.4), Vec3::new(1.7, 1.6, 0.4));
-
-                    if transform.translation.distance(pellet_transform.translation) < 0.17 {
-                        despawn_set.insert(pellet_id);
-                    }
-                } else {
-                    let target = Cuboid::new(1.5, 1.5, 0.8).sample_interior(&mut fish_rng.0);
-                    behavior.variant = FishBehaviorVariant::SeekPoint(target);
-                    behavior.timer.reset();
-                }
-            }
-        }
-    }
-
-    for pellet_id in despawn_set.iter() {
-        if let Some(mut entity) = commands.get_entity(*pellet_id) {
-            entity.despawn();
-        }
-    }
-}
-
-fn fish_behavior_change_system(
-    time: Res<Time>,
-    mut fishes: Query<(&Transform, &mut FishBehavior)>,
-) {
-    for (transform, mut behavior) in fishes.iter_mut() {
-        behavior.timer.tick(time.delta());
-
-        if behavior.timer.just_finished() {
-            behavior.variant = match behavior.variant {
-                FishBehaviorVariant::Idle => {
-                    if transform.rotation.y == 0. {
-                        FishBehaviorVariant::SwimLeft
-                    } else {
-                        FishBehaviorVariant::SwimRight
-                    }
-                }
-                FishBehaviorVariant::SwimRight => FishBehaviorVariant::Idle,
-                FishBehaviorVariant::SwimLeft => FishBehaviorVariant::Idle,
-                FishBehaviorVariant::SeekPoint(target) => FishBehaviorVariant::SeekPoint(target),
-                FishBehaviorVariant::SeekPellet(entity) => FishBehaviorVariant::SeekPellet(entity),
-            }
-        }
-    }
-}
-
-fn fish_pellet_detection_system(
-    mut fishes: Query<(&Transform, &mut FishBehavior)>,
-    pellets: Query<(Entity, &Transform), With<Pellet>>,
-) {
-    for (transform, mut behavior) in fishes.iter_mut() {
-        let (closest_pellet_id, closest_dist) = pellets.iter().fold(
-            (None, f32::MAX),
-            |(closest_pellet_id, closest_dist), (pellet_id, pellet_transform)| {
-                let dist = transform
-                    .translation
-                    .xy()
-                    .distance(pellet_transform.translation.xy());
-                if dist < closest_dist {
-                    (Some(pellet_id), dist)
-                } else {
-                    (closest_pellet_id, closest_dist)
-                }
-            },
-        );
-
-        if let Some(closest_pellet_id) = closest_pellet_id {
-            if closest_dist < 0.8 {
-                behavior.variant = FishBehaviorVariant::SeekPellet(closest_pellet_id);
-            }
-        }
-    }
-}
diff --git a/src/fish/behavior.rs b/src/fish/behavior.rs
new file mode 100644
index 0000000..17bc4f4
--- /dev/null
+++ b/src/fish/behavior.rs
@@ -0,0 +1,260 @@
+use std::f32::consts::PI;
+use std::time::Duration;
+
+use bevy::ecs::query::QueryEntityError;
+use bevy::prelude::*;
+use bevy::time::common_conditions::on_timer;
+use rand_chacha::ChaCha8Rng;
+
+use crate::general::AttemptDespawn;
+use crate::pellets::Pellet;
+
+use super::shared::FishRng;
+
+pub(super) fn plugin(app: &mut App) {
+    app.add_systems(
+        Update,
+        (
+            fish_behavior_system,
+            fish_behavior_change_system,
+            fish_pellet_detection_system.run_if(on_timer(Duration::from_secs_f32(0.5))),
+        ),
+    );
+}
+
+pub enum FishBehaviorVariant {
+    Idle,
+    SwimRight,
+    SwimLeft,
+    SeekPoint(Vec3),
+    SeekPellet(Entity),
+}
+
+#[derive(Component)]
+pub struct FishBehavior {
+    timer: Timer,
+    variant: FishBehaviorVariant,
+}
+
+impl Default for FishBehavior {
+    fn default() -> Self {
+        Self {
+            timer: Timer::from_seconds(5., TimerMode::Repeating),
+            variant: FishBehaviorVariant::Idle,
+        }
+    }
+}
+
+pub struct FishOperations<'a> {
+    transform: &'a mut Transform,
+    behavior: &'a mut FishBehavior,
+}
+
+impl<'a> FishOperations<'a> {
+    fn new(transform: &'a mut Transform, behavior: &'a mut FishBehavior) -> Self {
+        Self {
+            transform,
+            behavior,
+        }
+    }
+
+    fn start_idle(&mut self) {
+        self.behavior.variant = FishBehaviorVariant::Idle;
+        self.behavior.timer.reset();
+    }
+
+    fn start_swim_right(&mut self) {
+        self.face_right();
+        self.behavior.variant = FishBehaviorVariant::SwimRight;
+        self.behavior.timer.reset();
+    }
+
+    fn start_swim_left(&mut self) {
+        self.face_left();
+        self.behavior.variant = FishBehaviorVariant::SwimLeft;
+        self.behavior.timer.reset();
+    }
+
+    fn start_seek_point(&mut self, rng: &mut ChaCha8Rng) {
+        let point = Cuboid::new(1.5, 1.5, 0.8).sample_interior(rng);
+
+        if self.transform.translation.x < point.x {
+            self.face_right();
+        } else {
+            self.face_left();
+        }
+
+        self.behavior.variant = FishBehaviorVariant::SeekPoint(point);
+        self.behavior.timer.reset();
+    }
+
+    fn start_seek_pellet(&mut self, pellet_id: Entity) {
+        self.behavior.variant = FishBehaviorVariant::SeekPellet(pellet_id);
+        self.behavior.timer.reset();
+    }
+
+    fn behavior_idle(&mut self, time: &Time) {
+        self.transform.translation.y += time.elapsed_seconds().sin() / 3000.;
+    }
+
+    fn behavior_swim_right(&mut self, time: &Time) {
+        self.transform.translation.x += time.delta_seconds() / 10.;
+
+        if self.transform.translation.x > 1.4 {
+            self.start_swim_left();
+        }
+    }
+
+    fn behavior_swim_left(&mut self, time: &Time) {
+        self.transform.translation.x -= time.delta_seconds() / 10.;
+
+        if self.transform.translation.x < -1.4 {
+            self.start_swim_right();
+        }
+    }
+
+    fn behavior_seek_point(&mut self, time: &Time, target: Vec3) {
+        self.transform.translation = self
+            .transform
+            .translation
+            .move_towards(target, time.delta_seconds() / 10.);
+
+        if self.transform.translation.distance(target) < 0.1 {
+            self.start_idle();
+        }
+    }
+
+    fn behavior_seek_pellet(
+        &mut self,
+        time: &Time,
+        rng: &mut FishRng,
+        pellet: Result<(Entity, &Transform), QueryEntityError>,
+        commands: &mut Commands,
+    ) {
+        if let Ok((pellet_entity, pellet_transform)) = pellet {
+            if self.transform.translation.x < pellet_transform.translation.x {
+                self.face_right();
+            } else {
+                self.face_left();
+            }
+
+            self.transform.translation = self
+                .transform
+                .translation
+                .move_towards(pellet_transform.translation, time.delta_seconds() * 0.5);
+
+            if self
+                .transform
+                .translation
+                .distance(pellet_transform.translation)
+                < 0.17
+            {
+                if let Some(mut entity) = commands.get_entity(pellet_entity) {
+                    entity.insert(AttemptDespawn);
+                }
+            }
+        } else {
+            self.start_seek_point(rng);
+        }
+    }
+
+    fn face_right(&mut self) {
+        *self.transform =
+            self.transform
+                .with_rotation(Quat::from_euler(EulerRot::XYZ, PI / 2., PI, 0.));
+    }
+
+    fn face_left(&mut self) {
+        *self.transform =
+            self.transform
+                .with_rotation(Quat::from_euler(EulerRot::XYZ, PI / 2., 0., 0.));
+    }
+
+    fn clamp(&mut self) {
+        self.transform.translation = self
+            .transform
+            .translation
+            .clamp(Vec3::new(-1.7, -1.65, -0.4), Vec3::new(1.7, 1.6, 0.4));
+    }
+}
+
+fn fish_behavior_system(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut fishes: Query<(&mut Transform, &mut FishBehavior)>,
+    pellets: Query<(Entity, &mut Transform), (With<Pellet>, Without<FishBehavior>)>,
+    mut rng: ResMut<FishRng>,
+) {
+    for (mut transform, mut behavior) in fishes.iter_mut() {
+        let mut fish = FishOperations::new(&mut transform, &mut behavior);
+
+        match fish.behavior.variant {
+            FishBehaviorVariant::Idle => fish.behavior_idle(&time),
+            FishBehaviorVariant::SwimRight => fish.behavior_swim_right(&time),
+            FishBehaviorVariant::SwimLeft => fish.behavior_swim_left(&time),
+            FishBehaviorVariant::SeekPoint(point) => fish.behavior_seek_point(&time, point),
+            FishBehaviorVariant::SeekPellet(pellet_id) => {
+                fish.behavior_seek_pellet(&time, &mut rng, pellets.get(pellet_id), &mut commands)
+            }
+        }
+
+        fish.clamp();
+    }
+}
+
+fn fish_behavior_change_system(
+    time: Res<Time>,
+    mut fishes: Query<(&mut Transform, &mut FishBehavior)>,
+) {
+    for (mut transform, mut behavior) in fishes.iter_mut() {
+        let mut fish = FishOperations::new(&mut transform, &mut behavior);
+
+        fish.behavior.timer.tick(time.delta());
+
+        if fish.behavior.timer.just_finished() {
+            match fish.behavior.variant {
+                FishBehaviorVariant::Idle => {
+                    if fish.transform.rotation.y == 0. {
+                        fish.start_swim_left();
+                    } else {
+                        fish.start_swim_right();
+                    }
+                }
+                FishBehaviorVariant::SwimRight => fish.start_idle(),
+                FishBehaviorVariant::SwimLeft => fish.start_idle(),
+                _ => {}
+            }
+        }
+    }
+}
+
+fn fish_pellet_detection_system(
+    mut fishes: Query<(&mut Transform, &mut FishBehavior)>,
+    pellets: Query<(Entity, &Transform), (With<Pellet>, Without<FishBehavior>)>,
+) {
+    for (mut transform, mut behavior) in fishes.iter_mut() {
+        let mut fish = FishOperations::new(&mut transform, &mut behavior);
+
+        let (closest_pellet_id, closest_dist) = pellets.iter().fold(
+            (None, f32::MAX),
+            |(closest_pellet_id, closest_dist), (pellet_id, pellet_transform)| {
+                let dist = fish
+                    .transform
+                    .translation
+                    .xy()
+                    .distance(pellet_transform.translation.xy());
+                if dist < closest_dist {
+                    (Some(pellet_id), dist)
+                } else {
+                    (closest_pellet_id, closest_dist)
+                }
+            },
+        );
+
+        if let Some(closest_pellet_id) = closest_pellet_id {
+            if closest_dist < 0.8 {
+                fish.start_seek_pellet(closest_pellet_id);
+            }
+        }
+    }
+}
diff --git a/src/fish/mod.rs b/src/fish/mod.rs
new file mode 100644
index 0000000..b1ecaee
--- /dev/null
+++ b/src/fish/mod.rs
@@ -0,0 +1,9 @@
+use bevy::prelude::*;
+
+mod behavior;
+mod shared;
+mod spawning;
+
+pub(super) fn plugin(app: &mut App) {
+    app.add_plugins((behavior::plugin, spawning::plugin));
+}
diff --git a/src/fish/shared.rs b/src/fish/shared.rs
new file mode 100644
index 0000000..4c77a70
--- /dev/null
+++ b/src/fish/shared.rs
@@ -0,0 +1,10 @@
+use bevy::prelude::*;
+use rand_chacha::ChaCha8Rng;
+
+pub(super) const FISH_MAX: usize = 5;
+
+#[derive(Component)]
+pub struct Fish;
+
+#[derive(Resource, Deref, DerefMut)]
+pub struct FishRng(pub(super) ChaCha8Rng);
diff --git a/src/fish/spawning.rs b/src/fish/spawning.rs
new file mode 100644
index 0000000..0d0b098
--- /dev/null
+++ b/src/fish/spawning.rs
@@ -0,0 +1,89 @@
+use std::f32::consts::PI;
+
+use bevy::prelude::*;
+use rand::seq::SliceRandom;
+use rand::{RngCore, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+
+use super::behavior::FishBehavior;
+use super::shared::{Fish, FishRng, FISH_MAX};
+
+pub(super) fn plugin(app: &mut App) {
+    app.add_systems(Startup, setup_fish_system)
+        .add_systems(Update, spawn_fish_system);
+}
+
+#[derive(Resource, Deref)]
+pub struct FishMesh(Handle<Mesh>);
+
+#[derive(Resource, Deref)]
+pub struct FishMaterials(Vec<Handle<StandardMaterial>>);
+
+#[derive(Resource, Deref, DerefMut)]
+pub struct FishTimer(Timer);
+
+fn setup_fish_system(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let fish_mesh = asset_server.load(
+        (GltfAssetLabel::Primitive {
+            mesh: 0,
+            primitive: 0,
+        })
+        .from_asset("fish.glb"),
+    );
+    commands.insert_resource(FishMesh(fish_mesh));
+
+    let mut seeded_rng = ChaCha8Rng::seed_from_u64(19878367467712);
+    let fish_materials = (0..36)
+        .map(|_| {
+            let base_color = Color::hsl((seeded_rng.next_u32() % 360) as f32, 0.4, 0.3);
+            let emissive = base_color.to_linear() * 0.1;
+
+            materials.add(StandardMaterial {
+                base_color,
+                emissive,
+                ..default()
+            })
+        })
+        .collect();
+    commands.insert_resource(FishMaterials(fish_materials));
+    commands.insert_resource(FishRng(seeded_rng));
+
+    let fish_timer = Timer::from_seconds(0.5, TimerMode::Repeating);
+    commands.insert_resource(FishTimer(fish_timer));
+}
+
+fn spawn_fish_system(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut fish_timer: ResMut<FishTimer>,
+    fish_mesh: Res<FishMesh>,
+    fish_materials: Res<FishMaterials>,
+    mut fish_rng: ResMut<FishRng>,
+    fishes: Query<Entity, With<Fish>>,
+) {
+    fish_timer.tick(time.delta());
+
+    let fish_count = fishes.iter().len();
+
+    if fish_timer.just_finished() && fish_count < FISH_MAX {
+        let mut transform = Transform::default()
+            .with_rotation(Quat::from_euler(EulerRot::XYZ, PI / 2., PI, 0.))
+            .with_scale(Vec3::new(0.2, 0.1, 0.15));
+        transform.translation += Cuboid::new(1.5, 1.5, 0.8).sample_interior(&mut fish_rng.0);
+
+        commands.spawn((
+            Fish,
+            FishBehavior::default(),
+            PbrBundle {
+                transform,
+                mesh: fish_mesh.clone(),
+                material: fish_materials.choose(&mut fish_rng.0).unwrap().clone(),
+                ..default()
+            },
+        ));
+    }
+}
diff --git a/src/general.rs b/src/general.rs
index 8607b28..6fc85ba 100644
--- a/src/general.rs
+++ b/src/general.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 pub(super) fn plugin(app: &mut App) {
-    app.add_systems(Startup, deferred_despawn_system);
+    app.add_systems(PostUpdate, deferred_despawn_system);
 }
 
 #[derive(Component)]
@@ -11,8 +11,8 @@ fn deferred_despawn_system(
     mut commands: Commands,
     to_despawn_query: Query<Entity, With<AttemptDespawn>>,
 ) {
-    for to_despawn in to_despawn.iter() {
-        if let Some(entity) = commands.get_entity(to_despawn) {
+    for to_despawn in to_despawn_query.iter() {
+        if let Some(mut entity) = commands.get_entity(to_despawn) {
             entity.despawn();
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
index 6cbb61e..4f05dc1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -11,6 +11,7 @@ use bevy_ratatui_render::RatatuiRenderPlugin;
 mod camera;
 mod draw;
 mod fish;
+mod general;
 mod input;
 mod pellets;
 mod tank;
@@ -45,6 +46,7 @@ impl Plugin for AppPlugin {
             camera::plugin,
             draw::plugin,
             fish::plugin,
+            general::plugin,
             input::plugin,
             pellets::plugin,
             tank::plugin,