diff --git a/.gitattributes b/.gitattributes
index c1e5f83..35820e4 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -2,3 +2,4 @@
 *.glb filter=lfs diff=lfs merge=lfs -text
 *.wav filter=lfs diff=lfs merge=lfs -text
 *.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ttf filter=lfs diff=lfs merge=lfs -text
diff --git a/Cargo.toml b/Cargo.toml
index a785866..f2a11f1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,6 +24,7 @@ bevy = { version = "0.18.0", features = [
     "3d",
     "wav",
     "mp3",
+    "bevy_ui_debug",
     "bevy_dev_tools",
 ] }
 bevy_atmosphere = { git = "https://github.com/Arthur-Aillet/bevy_atmosphere", branch = "feat/z-up" }
diff --git a/assets/VCR_OSD_MONO_1.001.ttf b/assets/VCR_OSD_MONO_1.001.ttf
new file mode 100644
index 0000000..227241f
--- /dev/null
+++ b/assets/VCR_OSD_MONO_1.001.ttf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01918d86cb163a715dcb97165b997256734dfcc9f550beeb7c142fa4a064cf1c
+size 75864
diff --git a/src/debug.rs b/src/debug.rs
index dc1f8bf..cc575f6 100644
--- a/src/debug.rs
+++ b/src/debug.rs
@@ -1,10 +1,13 @@
 use avian3d::prelude::{PhysicsDebugPlugin, PhysicsGizmos};
 use bevy::dev_tools::fps_overlay::{FpsOverlayConfig, FpsOverlayPlugin, FrameTimeGraphConfig};
 use bevy::prelude::*;
+use bevy::ui_render::UiDebugOptions;
 use bevy_inspector_egui::bevy_egui::EguiPlugin;
 use bevy_inspector_egui::quick::WorldInspectorPlugin;
 
+use crate::node::OilNode;
 use crate::player::WorldModelCamera;
+use crate::player::marker::PLAYER_PLACE_DIST;
 use crate::settings::Settings;
 use crate::ui::OverlayImage;
 
@@ -31,14 +34,30 @@ impl Plugin for DebugPlugin {
         })
         .add_plugins((EguiPlugin::default(), PhysicsDebugPlugin))
         .add_plugins(WorldInspectorPlugin::new().run_if(if_debug_display))
-        .add_systems(Update, toggle_debug);
+        .add_systems(
+            Update,
+            (
+                toggle_debug,
+                display_oil_nodes_debug.run_if(if_debug_display),
+            ),
+        );
     }
 }
 
-pub fn if_debug_display(settings: Res<Settings>) -> bool {
+fn if_debug_display(settings: Res<Settings>) -> bool {
     settings.debug_display
 }
 
+fn display_oil_nodes_debug(mut gizmos: Gizmos, oil_nodes: Query<&GlobalTransform, With<OilNode>>) {
+    for oil_node in oil_nodes {
+        gizmos.sphere(
+            oil_node.translation(),
+            PLAYER_PLACE_DIST,
+            Color::srgb(1., 0.7, 0.7),
+        );
+    }
+}
+
 fn toggle_debug(
     input: Res<ButtonInput<KeyCode>>,
     mut fps_overlay: ResMut<FpsOverlayConfig>,
@@ -46,6 +65,7 @@ fn toggle_debug(
     mut image_overlay: Single<&mut Visibility, With<OverlayImage>>,
     mut settings: ResMut<Settings>,
     mut store: ResMut<GizmoConfigStore>,
+    mut debug_ui: ResMut<UiDebugOptions>,
 ) {
     if input.just_pressed(KeyCode::F1) {
         fps_overlay.enabled = !fps_overlay.enabled;
@@ -67,6 +87,7 @@ fn toggle_debug(
     } else {
         **image_overlay = Visibility::Visible;
     }
+    debug_ui.enabled = settings.debug && !settings.debug_display;
 
     let phys_config = store.config_mut::<PhysicsGizmos>().0;
     if settings.debug_display == true {
diff --git a/src/ladder.rs b/src/ladder.rs
new file mode 100644
index 0000000..b186809
--- /dev/null
+++ b/src/ladder.rs
@@ -0,0 +1,146 @@
+use bevy::{light::NotShadowCaster, prelude::*};
+use bevy_sprite3d::Sprite3d;
+
+use crate::{node::OilNodeResource, player::PlayerCamera, ui::CenteredText};
+
+pub struct LadderPlugin;
+
+impl Plugin for LadderPlugin {
+    fn build(&self, app: &mut App) {
+        app.insert_resource(Ladder::default())
+            .add_systems(Startup, load_ladder)
+            .add_systems(Update, spawn_ladder)
+            .add_systems(PostUpdate, game_state)
+            .insert_resource(GameState::default());
+    }
+}
+
+#[derive(Resource, Default)]
+pub struct GameState {
+    current_step: Step,
+    since_last_change: Timer,
+}
+
+#[derive(Default, PartialEq)]
+pub enum Step {
+    #[default]
+    LocateOil,
+    Exit,
+    SorryBuddy,
+}
+
+pub fn game_state(
+    text: Single<(&mut Node, &mut Text), With<CenteredText>>,
+    oil_res: If<Res<OilNodeResource>>,
+    mut game_state: ResMut<GameState>,
+    ladder: Single<&GlobalTransform, With<LadderInteract>>,
+    mut ladder_parent: Single<&mut Transform, With<LadderParent>>,
+    player_cam: Single<&GlobalTransform, With<PlayerCamera>>,
+    time: Res<Time>,
+) {
+    if !game_state.since_last_change.is_finished() {
+        game_state.since_last_change.tick(time.delta());
+    }
+
+    let (mut node, mut text) = text.into_inner();
+
+    if oil_res.nodes_left <= 0 && game_state.current_step == Step::LocateOil {
+        game_state.current_step = Step::Exit;
+        game_state.since_last_change = Timer::from_seconds(10.0, TimerMode::Once);
+
+        node.display = Display::Block;
+        text.0 = "Just get back to the ladder now!".to_string();
+    }
+
+    if game_state.current_step == Step::Exit {
+        if game_state.since_last_change.just_finished() {
+            node.display = Display::None;
+        }
+        if !game_state.since_last_change.is_finished() {
+            ladder_parent.translation += Vec3::Z * 30.0 * time.delta_secs();
+        }
+    }
+
+    if game_state.current_step == Step::Exit
+        && (ladder.translation().xy() - player_cam.translation().xy()).length() <= 7.0
+    {
+        game_state.current_step = Step::SorryBuddy;
+
+        node.display = Display::Block;
+        text.0 = "Sorry buddy... got an order from up there...".to_string();
+    }
+}
+
+#[derive(Resource, Default)]
+pub struct Ladder(Handle<Image>);
+
+#[derive(Component)]
+pub struct LadderInteract;
+
+#[derive(Component)]
+pub struct LadderParent;
+
+fn load_ladder(asset_server: Res<AssetServer>, mut ladder: ResMut<Ladder>) {
+    ladder.0 = asset_server.load("ladder.png");
+}
+
+fn spawn_ladder(
+    asset_server: Res<AssetServer>,
+    ladder: Res<Ladder>,
+    mut commands: Commands,
+    mut loaded: Local<bool>,
+) {
+    if *loaded {
+        return;
+    }
+
+    if !asset_server
+        .get_load_state(ladder.0.id())
+        .is_some_and(|s| s.is_loaded())
+    {
+        return;
+    }
+
+    *loaded = true;
+
+    let mut ladder_parent = commands.spawn((
+        Visibility::Visible,
+        LadderParent,
+        Transform::from_xyz(-72.0, -85.0, 25.)
+            .looking_to(Vec3::Y, Vec3::Z)
+            .with_scale(Vec3::splat(3.)),
+    ));
+
+    ladder_parent.with_child((
+        Sprite3d {
+            pixels_per_metre: 400.,
+            alpha_mode: AlphaMode::Blend,
+            unlit: false,
+            ..default()
+        },
+        Sprite {
+            image: ladder.0.clone(),
+            ..default()
+        },
+        Visibility::Visible,
+        LadderInteract,
+        Transform::from_xyz(0., 0., 0.),
+    ));
+    for i in 1..72 {
+        ladder_parent.with_child((
+            Sprite3d {
+                pixels_per_metre: 400.,
+                alpha_mode: AlphaMode::Blend,
+                unlit: false,
+                ..default()
+            },
+            Sprite {
+                image: ladder.0.clone(),
+                ..default()
+            },
+            NotShadowCaster,
+            Visibility::Visible,
+            Transform::from_xyz(0., i as f32 * 2.24, 0.),
+        ));
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 70478cb..1c50c18 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,5 @@
 mod debug;
-mod marker;
+mod ladder;
 mod monster;
 mod node;
 mod particle;
@@ -7,7 +7,7 @@ mod player;
 mod settings;
 mod speaker;
 mod ui;
-mod world;
+pub mod world;
 
 use avian3d::{PhysicsPlugins, prelude::Gravity};
 use bevy::prelude::*;
@@ -16,7 +16,7 @@ use bevy_atmosphere::plugin::AtmospherePlugin;
 use particle::ParticlePlugin;
 
 use crate::{
-    debug::DebugPlugin, marker::MarkerPlugin, monster::MonsterPlugin, player::PlayerPlugin,
+    debug::DebugPlugin, ladder::LadderPlugin, monster::MonsterPlugin, player::PlayerPlugin,
     settings::Settings, speaker::SpeakerPlugin, ui::UiPlugin, world::WorldPlugin,
 };
 
@@ -28,8 +28,8 @@ fn main() {
                 .set(ImagePlugin::default_nearest())
                 .set(WindowPlugin {
                     primary_window: Some(Window {
-                        title: "550fathom".into(),
-                        name: Some("550fathom".into()),
+                        title: "550fathoms".into(),
+                        name: Some("550fathoms".into()),
                         ..default()
                     }),
                     ..default()
@@ -51,8 +51,8 @@ fn main() {
             WorldPlugin,
             PlayerPlugin,
             MonsterPlugin,
-            MarkerPlugin,
             SpeakerPlugin,
+            LadderPlugin,
         ))
         .insert_resource(Gravity(Vec3::NEG_Z * 0.3))
         .run();
diff --git a/src/marker.rs b/src/marker.rs
deleted file mode 100644
index cfcdc05..0000000
--- a/src/marker.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use bevy::{
-    app::{Plugin, Startup},
-    asset::{AssetServer, Handle},
-    ecs::{
-        component::Component,
-        resource::Resource,
-        system::{Commands, Res},
-    },
-    gltf::GltfAssetLabel,
-    scene::Scene,
-};
-
-pub struct MarkerPlugin;
-
-impl Plugin for MarkerPlugin {
-    fn build(&self, app: &mut bevy::app::App) {
-        app.add_systems(Startup, load_marker_gltf);
-        // .add_systems(Update, spawn_marker);
-    }
-}
-
-#[derive(Component)]
-pub struct Marker;
-
-#[derive(Resource)]
-pub struct MarkerAssets {
-    pub model: Handle<Scene>,
-    // pub material_blink: Option<Handle<StandardMaterial>>,
-}
-
-fn load_marker_gltf(mut commands: Commands, assets: Res<AssetServer>) {
-    // let model = assets.load::<Gltf>("marker.glb");
-
-    let model = assets.load::<Scene>(GltfAssetLabel::Scene(0).from_asset("marker.glb"));
-
-    commands.insert_resource(MarkerAssets { model });
-}
-
-// fn spawn_marker(
-//     mut commands: Commands,
-//     gltf: Res<Assets<Gltf>>,
-//     mut Marker_assets: ResMut<MarkerAssets>,
-//     mut materials: ResMut<Assets<StandardMaterial>>,
-//     mut stop: Local<bool>,
-// ) {
-//     if *stop {
-//         return;
-//     }
-
-//     let Some(gltf) = gltf.get(&Marker_assets.model) else {
-//         return;
-//     };
-
-//     let Some(blink) = gltf.named_materials.get("light") else {
-//         return;
-//     };
-
-//     let Some(material) = materials.get_mut(blink) else {
-//         return;
-//     };
-
-//     material.emissive = LinearRgba::rgb(0.0, 4.0, 0.0);
-
-//     Marker_assets.material_blink = Some(blink.clone());
-
-//     *stop = true;
-
-//     commands.spawn((
-//         SceneRoot(gltf.scenes[0].clone()),
-//         Marker::default(),
-//         avian3d::dynamics::prelude::RigidBody::Kinematic,
-//         LinearVelocity::default(),
-//         Transform::from_xyz(-64.0, -81.0, 22.25),
-//     ));
-// }
diff --git a/src/monster.rs b/src/monster.rs
index b947b0c..576f904 100644
--- a/src/monster.rs
+++ b/src/monster.rs
@@ -255,6 +255,6 @@ pub fn spawn_monster(
         PlaybackSettings::LOOP
             .with_spatial(true)
             .with_spatial_scale(SpatialScale::new(0.07))
-            .with_volume(bevy::audio::Volume::Linear(0.2)),
+            .with_volume(bevy::audio::Volume::Linear(0.4)),
     ));
 }
diff --git a/src/node.rs b/src/node.rs
index 9511de7..99027ff 100644
--- a/src/node.rs
+++ b/src/node.rs
@@ -1,5 +1,3 @@
-use std::f32::consts::PI;
-
 use bevy::{light::NotShadowCaster, prelude::*};
 use bevy_sprite3d::Sprite3d;
 
@@ -12,31 +10,33 @@ pub struct OilNodeResource {
 }
 
 #[derive(Resource, Default)]
-pub struct OilAsset(Handle<Image>);
+pub struct OilAsset {
+    asset: Handle<Image>,
+    pub loaded: bool,
+}
 
 pub fn load_oil(asset_server: Res<AssetServer>, mut oil: ResMut<OilAsset>) {
-    oil.0 = asset_server.load("oilspil.png");
+    oil.asset = asset_server.load("oilspil.png");
 }
 
 pub fn spawn_world_nodes(
     mut commands: Commands,
-    oil: Res<OilAsset>,
+    mut oil: ResMut<OilAsset>,
     asset_server: Res<AssetServer>,
-    mut loaded: Local<bool>,
 ) {
-    if *loaded {
+    if oil.loaded {
         return;
     }
 
     if !asset_server
-        .get_load_state(oil.0.id())
+        .get_load_state(oil.asset.id())
         .is_some_and(|s| s.is_loaded())
     {
         return;
     }
-    *loaded = true;
+    oil.loaded = true;
 
-    for transform in [
+    let node_transforms = [
         Transform::from_xyz(-62.5, -80.9, 22.16).with_rotation(Quat::from_euler(
             EulerRot::XYZ,
             0.0783,
@@ -61,9 +61,15 @@ pub fn spawn_world_nodes(
             -0.07,
             0.,
         )),
-    ] {
+    ];
+
+    commands.insert_resource(OilNodeResource {
+        nodes_left: node_transforms.len(),
+    });
+
+    for (idx, transform) in node_transforms.iter().enumerate() {
         commands.spawn((
-            Name::new("Decal"),
+            Name::new(format!("OilNode-{idx}")),
             Sprite3d {
                 pixels_per_metre: 400.,
                 alpha_mode: AlphaMode::Blend,
@@ -72,7 +78,7 @@ pub fn spawn_world_nodes(
                 ..default()
             },
             Sprite {
-                image: oil.0.clone(),
+                image: oil.asset.clone(),
                 ..default()
             },
             NotShadowCaster,
diff --git a/src/player/action.rs b/src/player/action.rs
index 59d7c7f..e476223 100644
--- a/src/player/action.rs
+++ b/src/player/action.rs
@@ -1,56 +1,25 @@
-use std::ops::{Add, Sub};
+use std::{
+    ops::{Add, Sub},
+    process::exit,
+};
 
-use avian3d::prelude::RayHits;
-use avian3d::prelude::{RigidBody, RigidBodyDisabled};
 use bevy::prelude::*;
 
 use crate::{
-    marker::MarkerAssets,
-    player::{Player, PlayerAction, PlayerCamera, marker::Pickup},
-    speaker::{Speaker, SpeakerMode, SpeakerResource, grab, ungrab},
+    player::{Player, PlayerAction, PlayerCamera, marker::TryPlaceMarker},
+    speaker::{Pickup, grab, ungrab},
     ui,
 };
 
-/// distance from the speaker in which the player may place a marker
-const PLAYER_SPEAKER_PLACE_DIST: f32 = 4.0;
-/// squared distance for easy compute
-const PLAYER_SPEAKER_PLACE_DIST_2: f32 = PLAYER_SPEAKER_PLACE_DIST * PLAYER_SPEAKER_PLACE_DIST;
-
-pub fn player_place_marker(
-    commands: &mut Commands,
-    node: Entity,
-    player_transform: &GlobalTransform,
-    marker_model: &Handle<Scene>,
-) {
-    let origin = player_transform.transform_point((0.0, 0.5, 0.0).into());
-
-    commands.entity(node).despawn();
-
-    commands.spawn((
-        SceneRoot(marker_model.clone()),
-        Transform::from_translation(origin),
-        Visibility::default(),
-    ));
-}
-
 pub fn player_action(
     mut commands: Commands,
     time: Res<Time>,
     player: Single<
-        (
-            Entity,
-            &GlobalTransform,
-            &mut Transform,
-            &mut Player,
-            &RayHits,
-        ),
+        (&GlobalTransform, &mut Transform, &mut Player),
         (Without<PlayerCamera>, Without<Pickup>),
     >,
-    speaker: Single<&GlobalTransform, With<Speaker>>,
-    speaker_resource: Res<SpeakerResource>,
+    mut place_speaker: MessageWriter<TryPlaceMarker>,
     input: Res<ButtonInput<MouseButton>>,
-    marker_assets: Res<MarkerAssets>,
-
     mut cursor_icon: Single<&mut Visibility, With<ui::Cursor>>,
     camera: Single<
         (Entity, &GlobalTransform, &mut Transform),
@@ -65,7 +34,7 @@ pub fn player_action(
         (Without<Player>, Without<PlayerCamera>, Without<Pickup>),
     >,
 ) {
-    let (player_entity, player_global, mut player_tm, mut player, player_hits) = player.into_inner();
+    let (player_global, mut player_tm, mut player) = player.into_inner();
 
     let (camera_entity, camera_global, mut camera_tm) = camera.into_inner();
 
@@ -99,23 +68,8 @@ pub fn player_action(
             } else {
                 **cursor_icon = Visibility::Hidden;
 
-                if let SpeakerMode::Ready(node) = &speaker_resource.mode {
-                    if player_global
-                        .translation()
-                        .distance_squared(speaker.translation())
-                        < PLAYER_SPEAKER_PLACE_DIST_2
-                        && player.action == PlayerAction::None
-                        && input.just_pressed(MouseButton::Left)
-                        && !player_hits.is_empty()
-                    {
-                        player_place_marker(
-                            &mut commands,
-                            node.clone(),
-                            &player_global,
-                            &marker_assets.model,
-                        );
-                    }
-                } else {
+                if lmb {
+                    place_speaker.write(TryPlaceMarker);
                 }
                 None
             }
@@ -138,6 +92,7 @@ pub fn player_action(
         }
         PlayerAction::Dying(timeout, e) => {
             if timeout.gt(&1.0) {
+                exit(0);
                 Some(PlayerAction::Dead)
             } else {
                 if let Ok((_, global)) = entities.get(e.entity()) {
diff --git a/src/player/flashlight.rs b/src/player/flashlight.rs
index e477197..4283f03 100644
--- a/src/player/flashlight.rs
+++ b/src/player/flashlight.rs
@@ -1,14 +1,12 @@
 use bevy::prelude::*;
 
-use crate::{player::WorldModelCamera, ui::Cursor};
+use crate::ui::Cursor;
 
 #[derive(Component)]
 pub struct Flashlight;
 
 pub fn control_flashlight(
     mouse: Res<ButtonInput<KeyCode>>,
-    mut cam: Single<&mut DistanceFog, With<WorldModelCamera>>,
-
     mut flashlight: Single<&mut Visibility, With<Flashlight>>,
     mut hand_ui: Single<&mut ImageNode, With<Cursor>>,
 ) {
diff --git a/src/player/marker.rs b/src/player/marker.rs
index a34b22f..d63e3ca 100644
--- a/src/player/marker.rs
+++ b/src/player/marker.rs
@@ -1,37 +1,94 @@
-use std::ops::{Add, Sub};
-
+use avian3d::prelude::*;
 use bevy::prelude::*;
 
 use crate::{
-    player::{Player, PlayerAction, PlayerCamera},
-    speaker::grab,
-    ui::Cursor,
+    node::{OilNode, OilNodeResource},
+    player::PlayerCamera,
 };
 
 pub struct MarkerPlugin;
 
 impl Plugin for MarkerPlugin {
-    fn build(&self, app: &mut App) {
-        app.add_systems(Startup, load_marker_gltf);
-        // .add_systems(Update, (spawn_marker, grab_pickup));
+    fn build(&self, app: &mut bevy::app::App) {
+        app.add_message::<TryPlaceMarker>()
+            .add_systems(Startup, load_marker_gltf)
+            .add_systems(PostUpdate, place_markers);
     }
 }
 
+/// distance from the oil node in which the player may place a marker
+pub const PLAYER_PLACE_DIST: f32 = 4.0;
+
 #[derive(Resource)]
-pub struct MarkerAssets {
+struct MarkerAssets {
     pub model: Handle<Gltf>,
     pub material_light: Handle<StandardMaterial>,
 }
 
-// fn grab_pickup(
-//     mut commands: Commands,
-//     mut cursor_icon: Single<&mut Visibility, With<Cursor>>,
-//     mut player: Single<(Entity, &mut Player), Without<PlayerCamera>>,
-//     camera: Single<&GlobalTransform, (With<PlayerCamera>, Without<Player>)>,
-//     mut pickups: Query<(Entity, &GlobalTransform, &mut Transform), With<Pickup>>,
-// ) {
+#[derive(Message)]
+pub struct TryPlaceMarker;
 
-// }
+fn place_markers(
+    mut reader: MessageReader<TryPlaceMarker>,
+    mut commands: Commands,
+    marker_assets: Res<MarkerAssets>,
+    gltf: Res<Assets<Gltf>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut oil_node_res: If<ResMut<OilNodeResource>>,
+    spatial_query: SpatialQuery,
+    cam: Single<&GlobalTransform, With<PlayerCamera>>,
+    nodes: Query<(Entity, &GlobalTransform), With<OilNode>>,
+) {
+    for TryPlaceMarker in reader.read() {
+        let Some(gltf) = gltf.get(&marker_assets.model) else {
+            return;
+        };
+
+        let Some(light) = gltf.named_materials.get("light") else {
+            return;
+        };
+
+        *materials.get_mut(light).unwrap() = materials
+            .get(&marker_assets.material_light)
+            .unwrap()
+            .clone();
+
+        if let Some(hits) = spatial_query.cast_ray(
+            cam.translation(),
+            cam.forward(),
+            4.0,
+            false,
+            &SpatialQueryFilter::default(),
+        ) {
+            let contact_pos = cam.translation() + hits.distance * cam.forward();
+
+            for (id, transform) in nodes {
+                if contact_pos.distance(transform.translation()) < PLAYER_PLACE_DIST {
+                    oil_node_res.nodes_left -= 1;
+
+                    commands.entity(id).despawn();
+
+                    commands
+                        .spawn((
+                            SceneRoot(gltf.scenes[0].clone()),
+                            Transform::from_translation(contact_pos),
+                            Visibility::default(),
+                        ))
+                        .with_children(|parent| {
+                            parent.spawn((
+                                PointLight {
+                                    color: Color::srgb(1., 0.5, 0.5),
+                                    intensity: 5000.0,
+                                    ..Default::default()
+                                },
+                                Transform::from_xyz(0.0, 0.0, 0.8),
+                            ));
+                        });
+                }
+            }
+        }
+    }
+}
 
 pub fn load_marker_gltf(
     mut commands: Commands,
@@ -50,49 +107,3 @@ pub fn load_marker_gltf(
         material_light,
     });
 }
-
-#[derive(Component)]
-pub struct Pickup;
-
-pub fn spawn_marker(
-    mut commands: Commands,
-    marker_assets: Res<MarkerAssets>,
-    gltf: Res<Assets<Gltf>>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
-    mut loaded: Local<bool>,
-) {
-    if *loaded {
-        return;
-    }
-
-    let Some(gltf) = gltf.get(&marker_assets.model) else {
-        return;
-    };
-
-    *loaded = true;
-
-    let Some(light) = gltf.named_materials.get("light") else {
-        return;
-    };
-
-    *materials.get_mut(light).unwrap() = materials
-        .get(&marker_assets.material_light)
-        .unwrap()
-        .clone();
-
-    commands
-        .spawn((
-            SceneRoot(gltf.scenes[0].clone()),
-            Pickup,
-            Transform::from_xyz(-62.0, -84.0, 22.3).with_scale(Vec3::splat(1.1)),
-        ))
-        .with_children(|parent| {
-            parent.spawn((
-                PointLight {
-                    color: Color::srgb(1., 0.5, 0.5),
-                    ..Default::default()
-                },
-                Transform::from_xyz(0.0, 0.0, 0.5),
-            ));
-        });
-}
diff --git a/src/speaker.rs b/src/speaker.rs
index c9845e4..9cdf11a 100644
--- a/src/speaker.rs
+++ b/src/speaker.rs
@@ -20,7 +20,6 @@ use bevy::{
 };
 
 use crate::node::OilNode;
-use crate::player::marker::Pickup;
 
 pub struct SpeakerPlugin;
 
@@ -57,12 +56,15 @@ impl Speaker {
     }
 }
 
+#[derive(Component)]
+pub struct Pickup;
+
 #[derive(Default)]
 pub enum SpeakerMode {
     #[default]
     None,
     Blink(f32),
-    Ready(Entity),
+    Ready,
 }
 
 #[derive(Resource)]
@@ -118,7 +120,7 @@ fn spawn_speaker(
         PlaybackSettings::LOOP
             .with_spatial(true)
             .with_spatial_scale(SpatialScale::new(0.5))
-            .with_volume(bevy::audio::Volume::Linear(0.25)),
+            .with_volume(bevy::audio::Volume::Linear(0.5)),
     ));
 }
 
@@ -151,7 +153,7 @@ pub fn apply_color(speaker_resource: &SpeakerResource, materials: &mut Assets<St
     let color = match speaker_resource.mode {
         SpeakerMode::None => LinearRgba::BLACK,
         SpeakerMode::Blink(blink) => EMIT_RED * blink,
-        SpeakerMode::Ready(_) => EMIT_GREEN,
+        SpeakerMode::Ready => EMIT_GREEN,
     };
 
     let need_change = if let Some(mat_handle) = &speaker_resource.material_blink {
@@ -175,19 +177,19 @@ pub fn apply_color(speaker_resource: &SpeakerResource, materials: &mut Assets<St
 
 pub fn speaker_preupdate(
     time: Res<Time>,
-    nodes: Query<(Entity, &GlobalTransform), With<OilNode>>,
+    nodes: Query<&GlobalTransform, With<OilNode>>,
     speaker: Single<&GlobalTransform, With<Speaker>>,
     mut speaker_resource: ResMut<SpeakerResource>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    speaker_resource.mode = if let Some((e, n, power)) = nodes
+    speaker_resource.mode = if let Some((n, power)) = nodes
         .iter()
-        .map(|(e, n)| (e, n, bias(&speaker, n)))
-        .reduce(|a, b| if a.2 < b.2 { b } else { a })
+        .map(|n| (n, bias(&speaker, n)))
+        .reduce(|a, b| if a.1 < b.1 { b } else { a })
     {
         if n.translation().distance_squared(speaker.translation()) < NODE_SPEAKER_ACTIVATION_DIST_2
         {
-            SpeakerMode::Ready(e)
+            SpeakerMode::Ready
         } else {
             speaker_resource.time += (power * 40.0) * time.delta_secs();
             SpeakerMode::Blink(speaker_resource.time.sin().abs().squared())
diff --git a/src/ui.rs b/src/ui.rs
index 5b24e18..994b6f5 100644
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -51,26 +51,61 @@ fn spawn_ui(mut commands: Commands, asset_server: Res<AssetServer>, hud: Res<Hud
             Outline::new(Val::Px(200.0), Val::Px(0.0), Color::BLACK),
             OverlayImage::default(),
         ));
-        parent.spawn((
-            Node {
-                top: Val::Px((900.0 - 70.0) / 2.),
-                left: Val::Px((1600.0 - 70.0) / 2.),
+        parent
+            .spawn((Node {
                 position_type: PositionType::Absolute,
-                width: Val::Px(70.0),
-                height: Val::Px(70.0),
-                ..Default::default()
-            },
-            Visibility::Hidden,
-            Cursor,
-            ImageNode {
-                image: asset_server.load("hand_icon.png"),
-                color: Color::WHITE,
-                ..Default::default()
-            },
-        ));
+                justify_content: JustifyContent::Center,
+                align_content: AlignContent::Center,
+                align_self: AlignSelf::Center,
+                justify_self: JustifySelf::Center,
+                width: Val::Vw(100.0),
+                height: Val::Vh(100.0),
+                ..default()
+            },))
+            .with_children(|centered| {
+                centered.spawn((
+                    Node {
+                        position_type: PositionType::Absolute,
+                        align_self: AlignSelf::Center,
+                        justify_self: JustifySelf::Center,
+                        display: Display::None,
+                        ..default()
+                    },
+                    Text::new(""),
+                    TextFont {
+                        font: asset_server.load("VCR_OSD_MONO_1.001.ttf"),
+                        font_size: 16.0,
+                        ..default()
+                    },
+                    TextLayout::new_with_justify(Justify::Center).with_no_wrap(),
+                    TextColor(Color::WHITE),
+                    CenteredText,
+                ));
+
+                centered.spawn((
+                    Node {
+                        position_type: PositionType::Absolute,
+                        align_self: AlignSelf::Center,
+                        justify_self: JustifySelf::Center,
+                        width: Val::Px(70.0),
+                        height: Val::Px(70.0),
+                        ..Default::default()
+                    },
+                    Visibility::Hidden,
+                    Cursor,
+                    ImageNode {
+                        image: asset_server.load("hand_icon.png"),
+                        color: Color::WHITE,
+                        ..Default::default()
+                    },
+                ));
+            });
     });
 }
 
+#[derive(Component)]
+pub struct CenteredText;
+
 fn move_overlay(
     overlay: Single<(&mut Node, &mut OverlayImage), With<OverlayImage>>,
     accumulated_mouse_motion: Res<AccumulatedMouseMotion>,
diff --git a/src/world.rs b/src/world.rs
index b9d1441..5479bbe 100644
--- a/src/world.rs
+++ b/src/world.rs
@@ -16,14 +16,13 @@ impl Plugin for WorldPlugin {
                 Startup,
                 (
                     load_ground_gltf,
-                    load_ladder,
                     setup_world,
                     play_background_audio,
                     load_oil,
+                    spawn_world,
                 ),
             )
-            .add_systems(Update, (spawn_ground, spawn_world, spawn_world_nodes))
-            .insert_resource(Ladder::default())
+            .add_systems(Update, (spawn_ground, spawn_world_nodes))
             .insert_resource(OilAsset::default());
     }
 }
@@ -59,82 +58,18 @@ fn load_ground_gltf(mut commands: Commands, assets: Res<AssetServer>) {
     ));
 }
 
-#[derive(Resource, Default)]
-struct Ladder(Handle<Image>);
-
-fn load_ladder(asset_server: Res<AssetServer>, mut ladder: ResMut<Ladder>) {
-    ladder.0 = asset_server.load("ladder.png");
-}
-
 fn play_background_audio(asset_server: Res<AssetServer>, mut commands: Commands) {
     commands.spawn((
         AudioPlayer::new(asset_server.load("ambience.wav")),
-        PlaybackSettings::LOOP.with_volume(bevy::audio::Volume::Linear(0.06)),
+        PlaybackSettings::LOOP.with_volume(bevy::audio::Volume::Linear(0.12)),
     ));
 }
 
 fn spawn_world(
-    asset_server: Res<AssetServer>,
-    ladder: Res<Ladder>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     mut commands: Commands,
-    mut loaded: Local<bool>,
 ) {
-    if *loaded {
-        return;
-    }
-
-    if !asset_server
-        .get_load_state(ladder.0.id())
-        .is_some_and(|s| s.is_loaded())
-    {
-        return;
-    }
-
-    *loaded = true;
-
-    let mut ladder_parent = commands.spawn((
-        Visibility::Visible,
-        Transform::from_xyz(-72.0, -85.0, 25.)
-            .looking_to(Vec3::Y, Vec3::Z)
-            .with_scale(Vec3::splat(3.)),
-    ));
-
-    ladder_parent.with_child((
-        Sprite3d {
-            pixels_per_metre: 400.,
-            alpha_mode: AlphaMode::Blend,
-            unlit: false,
-            // pivot: Some(Vec2::new(0.5, 0.5)),
-            ..default()
-        },
-        Sprite {
-            image: ladder.0.clone(),
-            ..default()
-        },
-        Visibility::Visible,
-        Transform::from_xyz(0., 0., 0.),
-    ));
-    for i in 1..72 {
-        ladder_parent.with_child((
-            Sprite3d {
-                pixels_per_metre: 400.,
-                alpha_mode: AlphaMode::Blend,
-                unlit: false,
-                // pivot: Some(Vec2::new(0.5, 0.5)),
-                ..default()
-            },
-            Sprite {
-                image: ladder.0.clone(),
-                ..default()
-            },
-            NotShadowCaster,
-            Visibility::Visible,
-            Transform::from_xyz(0., i as f32 * 2.24, 0.),
-        ));
-    }
-
     commands.spawn((
         Mesh3d(meshes.add(Capsule3d::default().mesh().latitudes(7).longitudes(7))),
         MeshMaterial3d(materials.add(Color::srgb_u8(165, 42, 42))),