diff --git a/src/core.rs b/src/core.rs
index 08aac68ad1..fd1a6be4e2 100644
--- a/src/core.rs
+++ b/src/core.rs
@@ -31,8 +31,8 @@ use crate::{prelude::*, settings::PlayerControlMapping};
 pub mod prelude {
     pub use super::{
         attachment::*, audio::*, bullet::*, camera::*, damage::*, debug::*, editor::*, editor::*,
-        elements::prelude::*, globals::*, input::*, item::*, lifetime::*, map::*,
-        map_constructor::*, metadata::*, physics::*, player::*, random::*, utils::*, FPS,
+        elements::prelude::*, flappy_jellyfish::*, globals::*, input::*, item::*, lifetime::*,
+        map::*, map_constructor::*, metadata::*, physics::*, player::*, random::*, utils::*, FPS,
         MAX_PLAYERS,
     };
 }
diff --git a/src/core/camera.rs b/src/core/camera.rs
index 8e6ade06ed..b853e3475b 100644
--- a/src/core/camera.rs
+++ b/src/core/camera.rs
@@ -22,17 +22,24 @@ pub struct ParallaxBackgroundSprite {
     pub meta: ParallaxLayerMeta,
 }
 
+/// A subject of the camera.
+///
+/// The camera will move and zoom to ensure that all subjects remain visible. Entities must also
+/// have a `Transform` component and a `KinematicBody` component for this to work properly.
+#[derive(Clone, Copy, Debug, Default, HasSchema)]
+pub struct CameraSubject {
+    /// A rectangle around the subject that is larger than the subject, and will always move to
+    /// contain it. The camera will seek to contain this rectangle, instead of the subject itself.
+    ///
+    /// The advantage of this processing method is that the larger rect doesn't move as much as the
+    /// subject, because, for instance, a player jumping up and down in place will still be inside
+    /// of their camera rect, so the camera will not move around annoyingly.
+    rect: Rect,
+}
+
 /// The state of the camera.
 #[derive(Clone, Debug, HasSchema, Default)]
 pub struct CameraState {
-    /// A rectangle around the player that is larger than the player, and will always move to
-    /// contain the player. The camra will seek to contain this rectangle, instead of the player
-    /// itself.
-    ///
-    /// The advantage of this processing method is that the larger rect doesn't move as much as the
-    /// player, because, for instance, while jumping up and down in place, the player will still be
-    /// inside of their camera rect, so the camera will not move around annoyingly.
-    pub player_camera_rects: [Rect; MAX_PLAYERS],
     /// Disables the default camera controller. Useful, for example, when taking over the camera
     /// from the editor.
     pub disable_controller: bool,
@@ -45,16 +52,16 @@ fn camera_controller(
     map: Res<LoadedMap>,
     mut cameras: CompMut<Camera>,
     mut camera_shakes: CompMut<CameraShake>,
-    mut camera_states: CompMut<CameraState>,
+    camera_states: Comp<CameraState>,
+    mut camera_subjects: CompMut<CameraSubject>,
     transforms: Comp<Transform>,
-    player_indexes: Comp<PlayerIdx>,
     bodies: Comp<KinematicBody>,
     window: Res<Window>,
 ) {
     let meta = &meta.core.camera;
 
     let Some((_ent, (camera, camera_shake, camera_state))) = entities
-        .iter_with((&mut cameras, &mut camera_shakes, &mut camera_states))
+        .iter_with((&mut cameras, &mut camera_shakes, &camera_states))
         .next()
     else {
         return;
@@ -64,13 +71,13 @@ fn camera_controller(
     }
 
     // Update player camera rects
-    for (_ent, (transform, player_idx, body)) in
-        entities.iter_with((&transforms, &player_indexes, &bodies))
+    for (_ent, (camera_subj, transform, body)) in
+        entities.iter_with((&mut camera_subjects, &transforms, &bodies))
     {
         let camera_box_size = meta.player_camera_box_size;
 
         // Get the player's camera box
-        let camera_box = &mut camera_state.player_camera_rects[player_idx.0 as usize];
+        let camera_box = &mut camera_subj.rect;
 
         // If it's not be initialized.
         if camera_box.min == Vec2::ZERO && camera_box.max == Vec2::ZERO {
@@ -112,27 +119,19 @@ fn camera_controller(
         .unwrap_or(window.size);
     let viewport_aspect = viewport_size.x / viewport_size.y;
     let default_height = meta.default_height;
-    let camera_height = if let CameraSize::FixedHeight(height) = &camera.size {
-        *height
+    let default_width = viewport_aspect * default_height;
+    let camera_height = if let CameraSize::FixedHeight(height) = camera.size {
+        height
     } else {
         400.0
     };
     let mut scale = camera_height / default_height;
-    let default_width = viewport_aspect * default_height;
     let map_size = map.grid_size.as_vec2() * map.tile_size;
 
-    let mut min = Vec2::new(f32::MAX, f32::MAX);
-    let mut max = Vec2::new(f32::MIN, f32::MIN);
-
-    let players: Vec<u32> = entities
-        .iter_with(&player_indexes)
-        .map(|x| x.1 .0)
-        .collect();
-    let player_count = players.len();
-
-    for player_idx in players {
-        let rect = camera_state.player_camera_rects[player_idx as usize];
+    let mut min = Vec2::MAX;
+    let mut max = Vec2::MIN;
 
+    for CameraSubject { rect } in camera_subjects.iter_mut() {
         min = (rect.min - vec2(meta.border_left, meta.border_bottom))
             .min(min)
             .max(Vec2::ZERO);
@@ -142,7 +141,8 @@ fn camera_controller(
 
     let camera_pos = &mut camera_shake.center;
 
-    let mut middle_point = if player_count == 0 {
+    let subject_count = camera_subjects.iter().count();
+    let mut middle_point = if subject_count == 0 {
         camera_pos.truncate()
     } else {
         Rect { min, max }.center()
diff --git a/src/core/elements/flappy_jellyfish.rs b/src/core/elements/flappy_jellyfish.rs
index b7fd223429..b7986c8e94 100644
--- a/src/core/elements/flappy_jellyfish.rs
+++ b/src/core/elements/flappy_jellyfish.rs
@@ -26,13 +26,13 @@ impl FlappyJellyfishMeta {
     }
 }
 
-pub trait AssetGetFlappyJellyfishMeta {
+pub trait FlappyJellyfishMetaSchemaExts {
     /// Try to cast the `asset` to a `JellyfishMeta` and get the
     /// `FlappyJellyfishMeta` from it.
     fn try_get_flappy_meta(&self) -> Option<Handle<FlappyJellyfishMeta>>;
 }
 
-impl AssetGetFlappyJellyfishMeta for SchemaBox {
+impl FlappyJellyfishMetaSchemaExts for SchemaBox {
     fn try_get_flappy_meta(&self) -> Option<Handle<FlappyJellyfishMeta>> {
         self.try_cast_ref::<JellyfishMeta>()
             .ok()
@@ -43,7 +43,7 @@ impl AssetGetFlappyJellyfishMeta for SchemaBox {
 pub fn session_plugin(session: &mut Session) {
     session
         .stages
-        .add_system_to_stage(CoreStage::PostUpdate, move_flappy_jellyfish)
+        .add_system_to_stage(CoreStage::PostUpdate, control_flappy_jellyfish)
         .add_system_to_stage(CoreStage::PostUpdate, explode_flappy_jellyfish);
 }
 
@@ -53,17 +53,54 @@ pub struct FlappyJellyfish {
     pub jellyfish: Entity,
 }
 
-pub fn spawn(owner: Entity, jellyfish_ent: Entity) -> StaticSystem<(), ()> {
+/// A player with a jellyfish is holding shoot. Take control of the flappy if
+/// one exists or spawn one.
+pub fn spawn_or_take_control(
+    owner: Entity,
+    jellyfish_ent: Entity,
+    flappy_ent: Option<Entity>,
+) -> StaticSystem<(), ()> {
+    (move |world: &World| {
+        if let Some(flappy_ent) = flappy_ent {
+            take_control(owner, flappy_ent).run(world, ());
+        } else {
+            {
+                let mut jellyfishes = world.components.get::<Jellyfish>().borrow_mut();
+                let Some(jellyfish) = jellyfishes.get_mut(jellyfish_ent) else {
+                    return;
+                };
+                if jellyfish.ammo == 0 {
+                    return;
+                }
+                jellyfish.ammo -= 1;
+            }
+            spawn(owner, jellyfish_ent).run(world, ());
+        }
+    })
+    .system()
+}
+
+/// Take control of the flappy associated with a jellyfish for a player.
+fn take_control(owner: Entity, flappy_ent: Entity) -> StaticSystem<(), ()> {
+    (move |mut player_driving: CompMut<PlayerDrivingJellyfish>| {
+        player_driving.insert(owner, PlayerDrivingJellyfish { flappy: flappy_ent });
+    })
+    .system()
+}
+
+/// Spawn a flappy jellyfish.
+fn spawn(owner: Entity, jellyfish_ent: Entity) -> StaticSystem<(), ()> {
     (move |mut entities: ResMut<Entities>,
            element_handles: Comp<ElementHandle>,
-           mut driving_jellyfishes: CompMut<DrivingJellyfish>,
+           mut player_driving: CompMut<PlayerDrivingJellyfish>,
+           mut jellyfishes: CompMut<Jellyfish>,
            mut flappy_jellyfishes: CompMut<FlappyJellyfish>,
            mut bodies: CompMut<KinematicBody>,
-           mut fall_velocities: CompMut<FallVelocity>,
            assets: Res<AssetServer>,
            mut atlas_sprites: CompMut<AtlasSprite>,
            mut animated_sprites: CompMut<AnimatedSprite>,
-           mut transforms: CompMut<Transform>| {
+           mut transforms: CompMut<Transform>,
+           mut camera_subjects: CompMut<CameraSubject>| {
         let Some(flappy_meta) = element_handles
             .get(jellyfish_ent)
             .map(|element_h| assets.get(element_h.0))
@@ -76,13 +113,12 @@ pub fn spawn(owner: Entity, jellyfish_ent: Entity) -> StaticSystem<(), ()> {
         };
 
         let flappy_ent = entities.create();
-        driving_jellyfishes.insert(
-            jellyfish_ent,
-            DrivingJellyfish {
-                owner,
-                flappy: flappy_ent,
-            },
-        );
+
+        player_driving.insert(owner, PlayerDrivingJellyfish { flappy: flappy_ent });
+        if let Some(jellyfish) = jellyfishes.get_mut(jellyfish_ent) {
+            jellyfish.flappy = Some(flappy_ent);
+        }
+
         flappy_jellyfishes.insert(
             flappy_ent,
             FlappyJellyfish {
@@ -96,11 +132,13 @@ pub fn spawn(owner: Entity, jellyfish_ent: Entity) -> StaticSystem<(), ()> {
                 shape: ColliderShape::Rectangle {
                     size: flappy_meta.body_size,
                 },
-                is_deactivated: true,
+                has_mass: true,
+                gravity: GRAVITY,
+                fall_through: true,
+                is_controlled: true,
                 ..default()
             },
         );
-        fall_velocities.insert(flappy_ent, FallVelocity::default());
         atlas_sprites.insert(flappy_ent, AtlasSprite::new(flappy_meta.atlas));
         animated_sprites.insert(
             flappy_ent,
@@ -114,10 +152,61 @@ pub fn spawn(owner: Entity, jellyfish_ent: Entity) -> StaticSystem<(), ()> {
         let mut transf = *transforms.get(owner).unwrap();
         transf.translation += flappy_meta.spawn_offset.extend(0.0);
         transforms.insert(flappy_ent, transf);
+        camera_subjects.insert(flappy_ent, default());
     })
     .system()
 }
 
+const SPEED_X: f32 = 324.0;
+const SPEED_JUMP: f32 = 3.5;
+const GRAVITY: f32 = 0.1;
+const MIN_SPEED: Vec2 = vec2(-SPEED_X, -4.0);
+const MAX_SPEED: Vec2 = vec2(SPEED_X, 4.0);
+
+fn control_flappy_jellyfish(
+    time: Res<Time>,
+    entities: Res<Entities>,
+    player_driving: Comp<PlayerDrivingJellyfish>,
+    player_indexes: Comp<PlayerIdx>,
+    player_inputs: Res<MatchInputs>,
+    mut explode_flappies: CompMut<ExplodeFlappyJellyfish>,
+    mut bodies: CompMut<KinematicBody>,
+    flappy_jellyfishes: Comp<FlappyJellyfish>,
+) {
+    let t = time.delta_seconds();
+
+    for (_player_ent, (driving, player_idx)) in
+        entities.iter_with((&player_driving, &player_indexes))
+    {
+        let owner_control = player_inputs.players[player_idx.0 as usize].control;
+
+        if owner_control.grab_just_pressed {
+            explode_flappies.insert(driving.flappy, ExplodeFlappyJellyfish);
+            continue;
+        }
+
+        let Some(body) = bodies.get_mut(driving.flappy) else {
+            continue;
+        };
+
+        if owner_control.left == owner_control.right {
+            body.velocity.x = 0.0;
+        } else if owner_control.left > f32::EPSILON {
+            body.velocity.x = -owner_control.left * SPEED_X * t;
+        } else if owner_control.right > f32::EPSILON {
+            body.velocity.x = owner_control.right * SPEED_X * t;
+        }
+
+        if owner_control.jump_just_pressed {
+            body.velocity.y += SPEED_JUMP;
+        }
+    }
+
+    for (_, (_, body)) in entities.iter_with((&flappy_jellyfishes, &mut bodies)) {
+        body.velocity = body.velocity.clamp(MIN_SPEED, MAX_SPEED);
+    }
+}
+
 /// A marker component for flappy jellyfish to indicate that it should explode.
 #[derive(Clone, Copy, Debug, Default, HasSchema)]
 pub struct ExplodeFlappyJellyfish;
@@ -127,9 +216,12 @@ pub struct ExplodeFlappyJellyfish;
 fn explode_flappy_jellyfish(
     mut entities: ResMut<Entities>,
     explode_flappies: Comp<ExplodeFlappyJellyfish>,
-    killed_players: Comp<PlayerKilled>,
     flappy_jellyfishes: Comp<FlappyJellyfish>,
-    mut driving_jellyfishes: CompMut<DrivingJellyfish>,
+    mut jellyfishes: CompMut<Jellyfish>,
+    player_indexes: Comp<PlayerIdx>,
+    invincibles: Comp<Invincibility>,
+    bodies: Comp<KinematicBody>,
+    map: Res<LoadedMap>,
     element_handles: Comp<ElementHandle>,
     assets: Res<AssetServer>,
     mut transforms: CompMut<Transform>,
@@ -139,39 +231,56 @@ fn explode_flappy_jellyfish(
     mut animated_sprites: CompMut<AnimatedSprite>,
     mut damage_regions: CompMut<DamageRegion>,
     mut lifetimes: CompMut<Lifetime>,
+    mut dehydrate_jellyfish: CompMut<DehydrateJellyfish>,
 ) {
-    let mut explode_flappy_entities = Vec::with_capacity(flappy_jellyfishes.bitset().bit_count());
-
-    explode_flappy_entities.extend(entities.iter_with_bitset(explode_flappies.bitset()));
-
-    explode_flappy_entities.extend(
+    // Collect the hitboxes of all players
+    let mut player_hitboxes = SmallVec::<[Rect; MAX_PLAYERS]>::with_capacity(MAX_PLAYERS);
+    player_hitboxes.extend(
         entities
-            .iter_with(&flappy_jellyfishes)
-            .filter(|&(flappy_ent, flappy)| {
-                !explode_flappies.contains(flappy_ent) && killed_players.contains(flappy.owner)
-            })
-            .map(|(e, _)| e),
+            .iter_with((&player_indexes, &transforms, &bodies))
+            .filter(|(player_ent, _)| !invincibles.contains(*player_ent))
+            .map(|(_, (_, transform, body))| body.bounding_box(*transform)),
     );
 
-    for (flappy_ent, flappy_jellyfish) in entities.iter_with(&flappy_jellyfishes) {
-        if killed_players.contains(flappy_jellyfish.owner) {
+    let mut explode_flappy_entities =
+        SmallVec::<[Entity; 8]>::with_capacity(flappy_jellyfishes.bitset().bit_count());
+
+    for (flappy_ent, (_flappy_jellyfish, transform, body)) in
+        entities.iter_with((&flappy_jellyfishes, &transforms, &bodies))
+    {
+        // If flappy has the explode marker
+        if explode_flappies.contains(flappy_ent) {
             explode_flappy_entities.push(flappy_ent);
+            continue;
+        }
+        // If the flappy collides with any player
+        let flappy_hitbox = body.bounding_box(*transform);
+        if player_hitboxes.iter().any(|b| b.overlaps(&flappy_hitbox)) {
+            explode_flappy_entities.push(flappy_ent);
+            continue;
+        }
+        // If the flappy is out of bounds
+        if map.is_out_of_bounds(&transform.translation) {
+            explode_flappy_entities.push(flappy_ent);
+            continue;
         }
     }
 
-    for flappy in explode_flappy_entities {
-        let Some(jellyfish) = flappy_jellyfishes.get(flappy).map(|f| f.jellyfish) else {
+    for flappy_ent in explode_flappy_entities {
+        let Some(flappy) = flappy_jellyfishes.get(flappy_ent) else {
             continue;
         };
+        let Some(jellyfish) = jellyfishes.get_mut(flappy.jellyfish) else {
+            continue;
+        };
+        jellyfish.flappy.take();
 
-        // Stop the jellyfish from driving
-
-        driving_jellyfishes.remove(jellyfish);
-
-        // Get data for the explosion
+        /*
+         * Get explosion data
+         */
 
         let Some(flappy_meta) = element_handles
-            .get(jellyfish)
+            .get(flappy.jellyfish)
             .map(|element_h| assets.get(element_h.0))
             .map(|element_meta| assets.get(element_meta.data))
             .as_deref()
@@ -181,16 +290,16 @@ fn explode_flappy_jellyfish(
             return;
         };
 
-        let Some(mut explosion_transform) = transforms.get(flappy).copied() else {
+        let Some(mut explosion_transform) = transforms.get(flappy_ent).copied() else {
             return;
         };
         explosion_transform.translation.z = -10.0;
 
-        // Despawn the flappy
-
-        entities.kill(flappy);
+        /*
+         * Setup the explosion
+         */
 
-        // Setup the explosion
+        entities.kill(flappy_ent);
 
         audio_events.play(flappy_meta.explosion_sound, flappy_meta.explosion_volume);
 
@@ -234,98 +343,18 @@ fn explode_flappy_jellyfish(
                 Lifetime::new(flappy_meta.damage_region_lifetime),
             );
         }
-    }
-}
-
-#[derive(Clone, Copy, Default, Deref, DerefMut, HasSchema)]
-struct FallVelocity(f32);
-
-const SPEED_X: f32 = 200.0;
-const SPEED_JUMP: f32 = 500.0;
-const GRAVITY: f32 = -700.0;
-const MAX_SPEED_Y: f32 = 300.0;
-const MIN_SPEED_Y: f32 = -MAX_SPEED_Y;
-
-fn move_flappy_jellyfish(
-    entities: Res<Entities>,
-    flappy_jellyfishes: Comp<FlappyJellyfish>,
-    player_indexes: Comp<PlayerIdx>,
-    player_inputs: Res<MatchInputs>,
-    mut commands: Commands,
-    bodies: Comp<KinematicBody>,
-    invincibles: Comp<Invincibility>,
-    time: Res<Time>,
-    mut fall_velocities: CompMut<FallVelocity>,
-    mut transforms: CompMut<Transform>,
-    mut explode_flappies: CompMut<ExplodeFlappyJellyfish>,
-    map: Res<LoadedMap>,
-) {
-    let t = time.delta_seconds();
 
-    // Collect the hitboxes of all players
-    let mut player_hitboxes = SmallVec::<[Rect; 8]>::with_capacity(8);
-    player_hitboxes.extend(
-        entities
-            .iter_with((&player_indexes, &transforms, &bodies))
-            .filter(|(player_ent, _)| !invincibles.contains(*player_ent))
-            .map(|(_, (_, transform, body))| body.bounding_box(*transform)),
-    );
+        /*
+         * Despawn the jellyfish if out of ammo
+         */
 
-    for (flappy_ent, (&FlappyJellyfish { owner, jellyfish }, body, fall_velocity, transform)) in
-        entities.iter_with((
-            &flappy_jellyfishes,
-            &bodies,
-            &mut fall_velocities,
-            &mut transforms,
-        ))
-    {
-        let Some(owner_idx) = player_indexes.get(owner).cloned() else {
-            continue;
-        };
-        let owner_control = player_inputs.players[owner_idx.0 as usize].control;
-
-        if owner_control.grab_just_pressed {
-            commands.add(
-                move |mut entities: ResMut<Entities>,
-                      mut driving_jellyfishes: CompMut<DrivingJellyfish>,
-                      mut jellyfishes: CompMut<Jellyfish>| {
-                    driving_jellyfishes.remove(jellyfish);
-                    entities.kill(flappy_ent);
-                    if let Some(jellyfish) = jellyfishes.get_mut(jellyfish) {
-                        jellyfish.ammo += 1;
-                    }
+        if jellyfish.ammo == 0 {
+            dehydrate_jellyfish.insert(
+                flappy.jellyfish,
+                DehydrateJellyfish {
+                    owner: flappy.owner,
                 },
             );
-            continue;
-        }
-
-        let mut delta_pos = Vec2::ZERO;
-
-        if owner_control.left != owner_control.right {
-            delta_pos.x -= owner_control.left * SPEED_X * t;
-            delta_pos.x += owner_control.right * SPEED_X * t;
-        }
-
-        if owner_control.jump_just_pressed {
-            **fall_velocity += SPEED_JUMP;
-        }
-
-        // Velocity formula: `vₜ = vᵢ + tg`
-        **fall_velocity = (**fall_velocity + t * GRAVITY).clamp(MIN_SPEED_Y, MAX_SPEED_Y);
-
-        // Displacement formula: `y = gt²/2 + tvₜ`
-        delta_pos.y += GRAVITY * t.powi(2) / 2.0 + **fall_velocity * t;
-
-        transform.translation += delta_pos.extend(0.0);
-
-        if map.is_out_of_bounds(&transform.translation) {
-            explode_flappies.insert(flappy_ent, ExplodeFlappyJellyfish);
-        }
-
-        // Explode the flappy if collided with any player
-        let flappy_hitbox = body.bounding_box(*transform);
-        if player_hitboxes.iter().any(|b| b.overlaps(&flappy_hitbox)) {
-            explode_flappies.insert(flappy_ent, ExplodeFlappyJellyfish);
         }
     }
 }
diff --git a/src/core/elements/jellyfish.rs b/src/core/elements/jellyfish.rs
index 7ee7efd2e4..007f7b2298 100644
--- a/src/core/elements/jellyfish.rs
+++ b/src/core/elements/jellyfish.rs
@@ -1,6 +1,6 @@
 use crate::{core::player::idle, prelude::*};
 
-use super::flappy_jellyfish::{self, ExplodeFlappyJellyfish, FlappyJellyfishMeta};
+use super::flappy_jellyfish::{self, FlappyJellyfishMeta};
 
 #[derive(HasSchema, Default, Debug, Clone)]
 #[type_data(metadata_asset("jellyfish"))]
@@ -35,8 +35,8 @@ pub fn session_plugin(session: &mut Session) {
     session
         .stages
         .add_system_to_stage(CoreStage::PreUpdate, hydrate)
-        .add_system_to_stage(CoreStage::PostUpdate, update_unused_jellyfish)
-        .add_system_to_stage(CoreStage::PostUpdate, update_driving_jellyfish);
+        .add_system_to_stage(CoreStage::PreUpdate, dehydrate)
+        .add_system_to_stage(CoreStage::PostUpdate, update_player_driving);
     flappy_jellyfish::session_plugin(session);
 }
 
@@ -44,13 +44,19 @@ pub fn session_plugin(session: &mut Session) {
 #[derive(Clone, Debug, Default, HasSchema)]
 pub struct Jellyfish {
     pub ammo: u32,
+    pub flappy: Option<Entity>,
 }
 
-/// A marker component for jellyfish items to indicate that it is being driven
-/// by a player.
-#[derive(Clone, Copy, Debug, Default, HasSchema)]
-pub struct DrivingJellyfish {
-    pub owner: Entity,
+impl Jellyfish {
+    pub fn new(ammo: u32) -> Self {
+        Self { ammo, flappy: None }
+    }
+}
+
+/// A marker component for players to indicate that they are driving a flappy
+/// jellyfish.
+#[derive(Clone, Debug, Default, HasSchema)]
+pub struct PlayerDrivingJellyfish {
     pub flappy: Entity,
 }
 
@@ -62,7 +68,7 @@ fn hydrate(
     assets: Res<AssetServer>,
     mut jellyfishes: CompMut<Jellyfish>,
     mut atlas_sprites: CompMut<AtlasSprite>,
-    mut respawn_points: CompMut<DehydrateOutOfBounds>,
+    mut spawners: CompMut<DehydrateOutOfBounds>,
     mut items: CompMut<Item>,
     mut item_grabs: CompMut<ItemGrab>,
     mut item_throws: CompMut<ItemThrow>,
@@ -97,8 +103,9 @@ fn hydrate(
             hydrated.insert(spawner_ent, MapElementHydrated);
 
             let entity = entities.create();
+            spawners.insert(entity, DehydrateOutOfBounds(spawner_ent));
             hydrated.insert(entity, MapElementHydrated);
-            jellyfishes.insert(entity, Jellyfish { ammo: *max_ammo });
+            jellyfishes.insert(entity, Jellyfish::new(*max_ammo));
             items.insert(entity, Item);
             item_grabs.insert(
                 entity,
@@ -110,13 +117,10 @@ fn hydrate(
             );
             item_throws.insert(
                 entity,
-                ItemThrow::strength(*throw_velocity)
-                    .with_spin(*angular_velocity)
-                    .with_system(on_jellyfish_drop(entity, *max_ammo)),
+                ItemThrow::strength(*throw_velocity).with_spin(*angular_velocity),
             );
             element_handles.insert(entity, element_handle);
             atlas_sprites.insert(entity, AtlasSprite::new(*atlas));
-            respawn_points.insert(entity, DehydrateOutOfBounds(spawner_ent));
             transforms.insert(entity, transform);
             bodies.insert(
                 entity,
@@ -133,55 +137,73 @@ fn hydrate(
     }
 }
 
-fn on_jellyfish_drop(entity: Entity, max_ammo: u32) -> StaticSystem<(), ()> {
-    (move |mut jellyfishes: CompMut<Jellyfish>| {
-        // Reload
-        jellyfishes.get_mut(entity).unwrap().ammo = max_ammo;
-    })
-    .system()
+/// A marker component for jellyfish items to indicate that it has been used and
+/// should dehydrate. This will also remove and despawn the jellyfish from the
+/// player's inventory.
+#[derive(Clone, Debug, Default, HasSchema)]
+pub struct DehydrateJellyfish {
+    pub owner: Entity,
 }
 
-fn update_unused_jellyfish(
+fn dehydrate(
     entities: Res<Entities>,
-    mut jellyfishes: CompMut<Jellyfish>,
-    driving_jellyfishes: Comp<DrivingJellyfish>,
-    mut items_used: CompMut<ItemUsed>,
-    player_inventories: PlayerInventories,
-    player_states: Comp<PlayerState>,
+    dehydrate_jellyfish: Comp<DehydrateJellyfish>,
+    spawners: Comp<DehydrateOutOfBounds>,
+    mut player_driving: CompMut<PlayerDrivingJellyfish>,
+    mut player_inventories: CompMut<Inventory>,
     mut commands: Commands,
+    mut hydrated: CompMut<MapElementHydrated>,
 ) {
-    for (jellyfish_ent, jellyfish) in entities.iter_with(&mut jellyfishes) {
-        if driving_jellyfishes.contains(jellyfish_ent) {
-            continue;
-        }
-
-        if items_used.remove(jellyfish_ent).is_some() && jellyfish.ammo > 0 {
-            jellyfish.ammo -= 1;
-
-            // Get the owner of the jellyfish, if any
-            let Some(Inv { player, .. }) = player_inventories.find_item(jellyfish_ent) else {
-                continue;
-            };
-
-            // Prevent the jellyfish from being used if the owner isn't idle
-            if player_states.get(player).map(|s| s.current) != Some(*idle::ID) {
-                continue;
-            }
-
-            commands.add(flappy_jellyfish::spawn(player, jellyfish_ent));
+    for (jellyfish_ent, (dehydrate, spawner)) in
+        entities.iter_with((&dehydrate_jellyfish, &spawners))
+    {
+        if player_inventories
+            .get(dehydrate.owner)
+            .and_then(|inv| inv.0)
+            .filter(|item| *item == jellyfish_ent)
+            .is_some()
+        {
+            player_driving.remove(dehydrate.owner);
+            player_inventories.insert(dehydrate.owner, Inventory(None));
         }
+        commands.add(move |mut entities: ResMut<Entities>| entities.kill(jellyfish_ent));
+        hydrated.remove(**spawner);
     }
 }
 
-fn update_driving_jellyfish(
+fn update_player_driving(
     entities: Res<Entities>,
-    driving_jellyfishes: Comp<DrivingJellyfish>,
-    mut items_used: CompMut<ItemUsed>,
-    mut explode_flappies: CompMut<ExplodeFlappyJellyfish>,
+    player_indexes: Comp<PlayerIdx>,
+    player_inventories: Comp<Inventory>,
+    player_states: Comp<PlayerState>,
+    mut jellyfishes: CompMut<Jellyfish>,
+    player_inputs: Res<MatchInputs>,
+    mut player_driving: CompMut<PlayerDrivingJellyfish>,
+    mut commands: Commands,
 ) {
-    for (jellyfish_ent, driving_jellyfish) in entities.iter_with(&driving_jellyfishes) {
-        if items_used.remove(jellyfish_ent).is_some() {
-            explode_flappies.insert(driving_jellyfish.flappy, ExplodeFlappyJellyfish);
+    for (player_ent, (player_idx, player_inv, player_state)) in
+        entities.iter_with((&player_indexes, &player_inventories, &player_states))
+    {
+        let Some(jellyfish_ent) = player_inv.0 else {
+            continue;
+        };
+        let Some(jellyfish) = jellyfishes.get_mut(jellyfish_ent) else {
+            continue;
+        };
+
+        let player_control = player_inputs.players[player_idx.0 as usize].control;
+
+        if player_control.shoot_pressed {
+            if player_state.current != *idle::ID || player_driving.contains(player_ent) {
+                continue;
+            }
+            commands.add(flappy_jellyfish::spawn_or_take_control(
+                player_ent,
+                jellyfish_ent,
+                jellyfish.flappy,
+            ));
+        } else {
+            player_driving.remove(player_ent);
         }
     }
 }
diff --git a/src/core/player.rs b/src/core/player.rs
index ec205fd449..f7efdea0f2 100644
--- a/src/core/player.rs
+++ b/src/core/player.rs
@@ -487,6 +487,7 @@ fn hydrate_players(
     mut animation_bank_sprites: CompMut<AnimationBankSprite>,
     mut atlas_sprites: CompMut<AtlasSprite>,
     mut kinematic_bodies: CompMut<KinematicBody>,
+    mut camera_subjects: CompMut<CameraSubject>,
     mut player_layers: CompMut<PlayerLayers>,
     mut player_body_attachments: CompMut<PlayerBodyAttachment>,
     mut transforms: CompMut<Transform>,
@@ -563,6 +564,7 @@ fn hydrate_players(
                 ..default()
             },
         );
+        camera_subjects.insert(player_entity, default());
 
         // Spawn the player's fin and face
         let fin_entity = new_entities.next().unwrap();
diff --git a/src/core/player/state/states/drive_jellyfish.rs b/src/core/player/state/states/drive_jellyfish.rs
index 7cd2855059..3ffb79dafd 100644
--- a/src/core/player/state/states/drive_jellyfish.rs
+++ b/src/core/player/state/states/drive_jellyfish.rs
@@ -4,61 +4,24 @@ pub static ID: Lazy<Ustr> = Lazy::new(|| ustr("core::drive_jellyfish"));
 
 pub fn install(session: &mut Session) {
     PlayerState::add_player_state_transition_system(session, player_state_transition);
-    PlayerState::add_player_state_update_system(session, handle_player_state);
 }
 
 pub fn player_state_transition(
     entities: Res<Entities>,
-    jellyfishes: Comp<Jellyfish>,
-    driving_jellyfishes: Comp<DrivingJellyfish>,
+    player_driving: Comp<PlayerDrivingJellyfish>,
     mut player_states: CompMut<PlayerState>,
     killed_players: Comp<PlayerKilled>,
-    player_inventories: PlayerInventories,
 ) {
-    for (jellyfish_ent, _) in entities.iter_with(&jellyfishes) {
-        if let Some(driving) = driving_jellyfishes.get(jellyfish_ent) {
-            let Some(player_state) = player_states.get_mut(driving.owner) else {
-                continue;
-            };
-            if killed_players.contains(driving.owner) {
+    for (player_ent, player_state) in entities.iter_with(&mut player_states) {
+        if player_driving.contains(player_ent) {
+            if killed_players.contains(player_ent) {
                 continue;
             }
             if player_state.current != *ID {
                 player_state.current = *ID;
             }
-        } else {
-            let Some(player_state) = player_inventories
-                .find_item(jellyfish_ent)
-                .and_then(|inventory| player_states.get_mut(inventory.player))
-            else {
-                continue;
-            };
-            if player_state.current == *ID {
-                player_state.current = *idle::ID;
-            }
-        }
-    }
-}
-
-pub fn handle_player_state(
-    entities: Res<Entities>,
-    player_indexes: Comp<PlayerIdx>,
-    player_states: Comp<PlayerState>,
-    inventories: Comp<Inventory>,
-    player_inputs: Res<MatchInputs>,
-    mut commands: Commands,
-) {
-    for (player_ent, (player_idx, player_state, inventory)) in
-        entities.iter_with((&player_indexes, &player_states, &inventories))
-    {
-        if player_state.current != *ID {
-            continue;
-        }
-
-        let control = &player_inputs.players[player_idx.0 as usize].control;
-
-        if control.shoot_just_pressed && inventory.is_some() {
-            commands.add(PlayerCommand::use_item(player_ent));
+        } else if player_state.current == *ID {
+            player_state.current = *idle::ID;
         }
     }
 }