diff --git a/src/bullet.rs b/src/bullet.rs
index 7b6ad84..087c533 100644
--- a/src/bullet.rs
+++ b/src/bullet.rs
@@ -8,6 +8,11 @@ impl Plugin for BulletPlugin {
             .add_system_set(
                 SystemSet::on_exit(AppState::InGame).with_system(cleanup::<CleanupMarker>),
             )
+            .add_system_set(
+                SystemSet::on_update(AppState::MechaPicker)
+                    .with_system(handle_bullet_events)
+                    .with_system(handle_bullets),
+            )
             .add_system_set(
                 SystemSet::on_update(AppState::InGame)
                     .with_system(handle_bullet_events)
diff --git a/src/follow_text.rs b/src/follow_text.rs
new file mode 100644
index 0000000..de2fb51
--- /dev/null
+++ b/src/follow_text.rs
@@ -0,0 +1,41 @@
+use crate::game_camera::PanOrbitCamera;
+use bevy::prelude::*;
+use bevy::render::camera::*;
+
+pub struct FollowTextPlugin;
+impl Plugin for FollowTextPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_system(update_text_position);
+    }
+}
+
+#[derive(Component)]
+pub struct FollowText {
+    pub following: Entity,
+}
+
+fn update_text_position(
+    windows: Res<Windows>,
+    mut text_query: Query<(&mut Style, &CalculatedSize, &FollowText)>,
+    mesh_query: Query<&Transform>,
+    camera_query: Query<(&Camera, &GlobalTransform), With<PanOrbitCamera>>,
+) {
+    for (mut style, calculated, follow) in text_query.iter_mut() {
+        if let Ok(mesh_position) = mesh_query.get(follow.following) {
+            for (camera, camera_transform) in camera_query.iter() {
+                match camera.world_to_screen(&windows, camera_transform, mesh_position.translation)
+                {
+                    Some(coords) => {
+                        style.position.left = Val::Px(coords.x - calculated.size.width / 2.0);
+                        style.position.bottom =
+                            Val::Px((coords.y * 1.4) - calculated.size.height / 2.0);
+                    }
+                    None => {
+                        // A hack to hide the text when the it's behind the camera
+                        style.position.bottom = Val::Px(-1000.0);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/game_camera.rs b/src/game_camera.rs
index f626b43..5ab4667 100644
--- a/src/game_camera.rs
+++ b/src/game_camera.rs
@@ -8,8 +8,11 @@ pub struct GameCameraPlugin;
 impl Plugin for GameCameraPlugin {
     fn build(&self, app: &mut App) {
         app.insert_resource(Perlin::new())
-            .add_system(handle_camera_shake)
-            .add_system(pan_orbit_camera);
+            .insert_resource(CameraSettings::default())
+            //.add_system(handle_camera_shake)
+            .add_system(update_camera)
+            //.add_system(pan_orbit_camera);
+;
     }
 }
 
@@ -30,6 +33,88 @@ impl Default for PanOrbitCamera {
     }
 }
 
+#[derive(Default)]
+pub struct CameraSettings {
+    look_at: Vec3,
+    height: f32,
+    orbit: bool,
+    speed: f32,
+    distance: f32,
+    target_distance: f32,
+}
+
+impl CameraSettings {
+    pub fn set_camera(
+        &mut self,
+        height: f32,
+        look_at: Vec3,
+        speed: f32,
+        orbit: bool,
+        distance: f32,
+        target_distance: f32,
+    ) {
+        self.height = height;
+        self.look_at = look_at;
+        self.speed = speed;
+        self.orbit = orbit;
+        self.distance = distance;
+        self.target_distance = target_distance;
+    }
+}
+
+fn update_camera(
+    mut cameras: Query<&mut Transform, With<PanOrbitCamera>>,
+    mut camera_settings: ResMut<CameraSettings>,
+    time: Res<Time>,
+) {
+    let mut c = camera_settings;
+
+    if (c.distance - c.target_distance).abs() > 0.1 {
+        if c.distance > c.target_distance {
+            c.distance -= time.delta_seconds() * 8.0;
+        } else {
+            c.distance += time.delta_seconds() * 8.0;
+        }
+    }
+
+    for mut transform in cameras.iter_mut() {
+        if transform.translation.is_nan() {
+            transform.translation = Vec3::new(0.1, 0.1, 0.1);
+        }
+        let height_difference = transform.translation.y - c.height;
+        if height_difference.abs() > 0.1 {
+            transform.translation.y +=
+                (c.height - transform.translation.y) * c.speed * time.delta_seconds();
+            //          if height_difference > 0.0 {
+            //              transform.translation.y -=
+            //                  (c.height - transform.translation.y)
+            //                 * c.speed
+            //                 * time.delta_seconds();
+            //          } else {
+            //              transform.translation.y +=
+            //                  (c.height - transform.translation.y)
+            //                 * c.speed
+            //                 * time.delta_seconds();
+            //          }
+        }
+
+        if c.orbit {
+            let yaw = Quat::from_rotation_y(time.delta_seconds() as f32 * 0.3);
+            transform.rotation *= yaw; // rotate around global y axis
+        } else {
+            transform.rotation = Quat::from_rotation_y((3.0 * std::f32::consts::PI) / 2.0);
+        }
+
+        let rot_matrix = Mat3::from_quat(transform.rotation);
+        let new_translation = c.look_at + rot_matrix.mul_vec3(Vec3::new(0.0, 0.0, c.distance));
+
+        transform.translation.x = new_translation.x;
+        transform.translation.z = new_translation.z;
+
+        transform.look_at(c.look_at, Vec3::Y);
+    }
+}
+
 fn handle_camera_shake(
     time: Res<Time>,
     perlin: Res<Perlin>,
@@ -70,6 +155,8 @@ pub fn pan_orbit_camera(
     input_mouse: Res<Input<MouseButton>>,
     keyboard_input: Res<Input<KeyCode>>,
     mut query: Query<(&mut PanOrbitCamera, &mut Transform, &PerspectiveProjection)>,
+    camera_settings: Res<CameraSettings>,
+    time: Res<Time>,
 ) {
     // change input mapping for orbit and panning here
     let orbit_button = MouseButton::Right;
@@ -82,6 +169,10 @@ pub fn pan_orbit_camera(
     let mut scroll = 0.0;
     let mut orbit_button_changed = false;
 
+    if camera_settings.orbit {
+        rotation_move = Vec2::new(2.0, 0.0);
+    }
+
     if input_mouse.pressed(orbit_button) || keyboard_input.pressed(orbit_key) {
         for ev in ev_motion.iter() {
             rotation_move += ev.delta;
@@ -95,6 +186,7 @@ pub fn pan_orbit_camera(
     for ev in ev_scroll.iter() {
         scroll += ev.y;
     }
+
     if input_mouse.just_released(orbit_button)
         || input_mouse.just_pressed(orbit_button)
         || keyboard_input.just_released(orbit_key)
@@ -151,8 +243,10 @@ pub fn pan_orbit_camera(
             // parent = x and y rotation
             // child = z-offset
             let rot_matrix = Mat3::from_quat(transform.rotation);
-            transform.translation =
+            let new_translation =
                 pan_orbit.focus + rot_matrix.mul_vec3(Vec3::new(0.0, 0.0, pan_orbit.radius));
+            transform.translation.x = new_translation.x;
+            transform.translation.z = new_translation.z;
         }
     }
 }
@@ -163,7 +257,8 @@ fn get_primary_window_size(windows: &Res<Windows>) -> Vec2 {
 }
 
 pub fn spawn_camera(mut commands: Commands, game_assets: Res<assets::GameAssets>) {
-    let translation = Vec3::new(-25.0, 25.0, 0.0);
+    //let translation = Vec3::new(-25.0, 25.0, 0.0);
+    let translation = Vec3::new(0.1, 0.1, 0.1);
 
     let radius = translation.length();
 
diff --git a/src/inspect.rs b/src/inspect.rs
index 6f53822..1fcd48b 100644
--- a/src/inspect.rs
+++ b/src/inspect.rs
@@ -1,4 +1,4 @@
-use crate::{asset_loading, assets::GameAssets, mesh, player};
+use crate::{asset_loading, assets::GameAssets, game_camera, mesh, player};
 use bevy::prelude::*;
 use bevy::window::WindowResized;
 use bevy_inspector_egui::bevy_egui::EguiSettings;
diff --git a/src/levels/debug.rs b/src/levels/debug.rs
index 34b3ebd..b3e6f62 100644
--- a/src/levels/debug.rs
+++ b/src/levels/debug.rs
@@ -1,6 +1,6 @@
 use crate::{
-    asset_loading, assets::GameAssets, bot, burro::Burro, cleanup, collision, game_camera,
-    game_state, mesh, player, AppState,
+    asset_loading, assets::GameAssets, bot, burro::Burro, cleanup, collision, follow_text,
+    game_camera, game_state, mesh, player, AppState,
 };
 use bevy::gltf::Gltf;
 use bevy::prelude::*;
@@ -143,7 +143,10 @@ fn setup(
     mut clear_color: ResMut<ClearColor>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut images: ResMut<Assets<Image>>,
+    mut camera_settings: ResMut<game_camera::CameraSettings>,
 ) {
+    camera_settings.set_camera(20.0, Vec3::ZERO, 0.4, false, 0.5, 30.0);
+
     *clear_color = ClearColor(Color::rgb(1.0, 0.65, 0.62));
     commands.insert_resource(AmbientLight {
         color: Color::WHITE,
@@ -199,10 +202,43 @@ fn setup(
                 .insert(CleanupMarker)
                 .insert_bundle(bot::BotBundle::new(b.skin));
         } else {
-            commands
+            let entity = commands
                 .spawn_bundle(burro_bundle)
                 .insert(CleanupMarker)
-                .insert_bundle(player::PlayerBundle::new(b.skin));
+                .insert_bundle(player::PlayerBundle::new(b.skin))
+                .id();
+
+            commands
+                .spawn_bundle(TextBundle {
+                    style: Style {
+                        align_self: AlignSelf::FlexEnd,
+                        position_type: PositionType::Absolute,
+                        position: Rect {
+                            bottom: Val::Px(5.0),
+                            left: Val::Px(15.0),
+                            ..Default::default()
+                        },
+                        size: Size {
+                            width: Val::Px(200.0),
+                            ..Default::default()
+                        },
+                        ..Default::default()
+                    },
+                    text: Text::with_section(
+                        "P1".to_string(),
+                        TextStyle {
+                            font: game_assets.font.clone(),
+                            font_size: 40.0,
+                            color: Color::YELLOW,
+                        },
+                        TextAlignment {
+                            ..Default::default()
+                        },
+                    ),
+                    ..Default::default()
+                })
+                .insert(CleanupMarker)
+                .insert(follow_text::FollowText { following: entity });
         }
     });
 
diff --git a/src/main.rs b/src/main.rs
index af7ba19..63d2da2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,6 +12,7 @@ mod bullet;
 mod burro;
 mod collision;
 mod direction;
+mod follow_text;
 mod game_camera;
 mod game_state;
 mod ingame_ui;
@@ -35,6 +36,7 @@ fn main() {
         .add_plugin(audio::GameAudioPlugin)
         .add_plugin(bot::BotPlugin)
         .add_plugin(bullet::BulletPlugin)
+        .add_plugin(follow_text::FollowTextPlugin)
         .add_plugin(game_camera::GameCameraPlugin)
         .add_plugin(game_state::GameStatePlugin)
         .add_plugin(mesh::MeshPlugin)
diff --git a/src/mecha_picker.rs b/src/mecha_picker.rs
index 0965d05..ff2d22a 100644
--- a/src/mecha_picker.rs
+++ b/src/mecha_picker.rs
@@ -1,4 +1,7 @@
-use crate::{assets::GameAssets, burro, cleanup, game_state, AppState};
+use crate::{
+    assets::GameAssets, bullet::BulletEvent, bullet::BulletType, burro, cleanup, game_camera,
+    game_state, AppState,
+};
 use bevy::prelude::*;
 use rand::seq::SliceRandom;
 use rand::thread_rng;
@@ -14,6 +17,7 @@ impl Plugin for MechaPickerPlugin {
             .add_system_set(
                 SystemSet::on_update(AppState::MechaPicker)
                     .with_system(pick_mecha)
+                    .with_system(animate_mecha_selection)
                     .with_system(handle_mecha_pick_event),
             )
             .insert_resource(TextDisplayTimers::default());
@@ -23,6 +27,9 @@ impl Plugin for MechaPickerPlugin {
 #[derive(Component)]
 struct TextMarker;
 
+#[derive(Component)]
+struct TopTextMarker;
+
 #[derive(Component)]
 struct CleanupMarker;
 
@@ -35,7 +42,106 @@ struct TextDisplayTimers {
     name_change_cooldown: f32,
     overall_name_selection_cooldown: f32,
     mecha_display_cooldown: f32,
+
     has_picked: bool,
+    selected_burro: Option<Entity>,
+    mecha_selection_stage: MechaSelectionStage,
+    mecha_selection_cooldown: f32,
+}
+
+#[derive(PartialEq, Debug)]
+enum MechaSelectionStage {
+    Initial,
+    MovingToBurro,
+    ChangingBurro,
+    LaserShot,
+    ZoomOut,
+    StartRound,
+}
+
+impl Default for MechaSelectionStage {
+    fn default() -> Self {
+        MechaSelectionStage::Initial
+    }
+}
+
+fn animate_mecha_selection(
+    mut commands: Commands,
+    mut app_state: ResMut<State<AppState>>,
+    mut text_display_timers: ResMut<TextDisplayTimers>,
+    game_state: Res<game_state::GameState>,
+    game_assets: Res<GameAssets>,
+    time: Res<Time>,
+    mut burros: Query<(
+        &mut Transform,
+        &mut burro::Burro,
+        &mut Handle<StandardMaterial>,
+    )>,
+    mut camera_settings: ResMut<game_camera::CameraSettings>,
+    mut bullet_event_writer: EventWriter<BulletEvent>,
+    top_texts: Query<Entity, With<TopTextMarker>>,
+    name_texts: Query<Entity, With<TextMarker>>,
+) {
+    if let Some(selected_burro_entity) = text_display_timers.selected_burro {
+        text_display_timers.mecha_selection_cooldown -= time.delta_seconds();
+        text_display_timers.mecha_selection_cooldown = text_display_timers
+            .mecha_selection_cooldown
+            .clamp(-10.0, 10.0);
+        if text_display_timers.mecha_selection_cooldown <= 0.0 {
+            let (next_state, cooldown) = match text_display_timers.mecha_selection_stage {
+                MechaSelectionStage::Initial => (MechaSelectionStage::MovingToBurro, 2.0),
+                MechaSelectionStage::MovingToBurro => (MechaSelectionStage::ChangingBurro, 2.0),
+                MechaSelectionStage::ChangingBurro => (MechaSelectionStage::LaserShot, 2.0),
+                MechaSelectionStage::LaserShot => (MechaSelectionStage::ZoomOut, 2.0),
+                MechaSelectionStage::ZoomOut => (MechaSelectionStage::StartRound, 0.0),
+                MechaSelectionStage::StartRound => (MechaSelectionStage::StartRound, 0.0),
+            };
+
+            text_display_timers.mecha_selection_stage = next_state;
+            text_display_timers.mecha_selection_cooldown = cooldown;
+        } else {
+            return;
+        }
+
+        if let Ok((mut transform, mut burro, mut handle)) = burros.get_mut(selected_burro_entity) {
+            match text_display_timers.mecha_selection_stage {
+                MechaSelectionStage::Initial => (),
+                MechaSelectionStage::MovingToBurro => {
+                    camera_settings.set_camera(2.0, transform.translation, 0.4, true, 30.0, 5.0);
+                    for entity in top_texts.iter() {
+                        commands.entity(entity).despawn_recursive();
+                    }
+                }
+                MechaSelectionStage::ChangingBurro => {
+                    *handle = game_assets.mechaburro_texture.material.clone();
+                    burro.is_mechaburro = true;
+                    for entity in name_texts.iter() {
+                        commands.entity(entity).despawn_recursive();
+                    }
+                }
+                MechaSelectionStage::LaserShot => {
+                    use std::f32::consts::PI;
+
+                    bullet_event_writer.send(BulletEvent {
+                        source: selected_burro_entity,
+                        speed: burro.bullet_speed,
+                        time_to_live: burro.bullet_time_alive,
+                        position: transform.translation,
+                        direction: Vec3::new(1.0, 0.0, 0.0),
+                        bullet_type: BulletType::Laser,
+                    });
+                    transform.rotation = Quat::from_axis_angle(Vec3::Y, 0.0);
+                    transform.scale = Vec3::new(0.7, 1.4, 1.0);
+                }
+                MechaSelectionStage::ZoomOut => {
+                    camera_settings.set_camera(20.0, Vec3::ZERO, 0.4, false, 30.0, 30.0);
+                }
+                MechaSelectionStage::StartRound => {
+                    app_state.set(AppState::InGame).unwrap();
+                }
+            }
+        }
+    }
 }
 
 fn setup(
@@ -43,8 +149,10 @@ fn setup(
     game_assets: Res<GameAssets>,
     mut text_display_timers: ResMut<TextDisplayTimers>,
 ) {
+    *text_display_timers = TextDisplayTimers::default();
     text_display_timers.overall_name_selection_cooldown = 3.0;
     text_display_timers.has_picked = false;
+    text_display_timers.mecha_selection_cooldown = 2.0;
 
     commands
         .spawn_bundle(NodeBundle {
@@ -83,6 +191,7 @@ fn setup(
                     ),
                     ..Default::default()
                 })
+                .insert(TopTextMarker)
                 .insert(CleanupMarker);
 
             parent
@@ -115,15 +224,13 @@ fn setup(
 
 fn handle_mecha_pick_event(
     mut pick_mecha_event_reader: EventReader<PickMechaEvent>,
-    game_state: Res<game_state::GameState>,
-    game_assets: Res<GameAssets>,
-    mut burros: Query<(&mut burro::Burro, &mut Handle<StandardMaterial>)>,
+    mut text_display_timers: ResMut<TextDisplayTimers>,
+    burros: Query<(Entity, &burro::Burro)>,
 ) {
     for event in pick_mecha_event_reader.iter() {
-        for (mut burro, mut handle) in burros.iter_mut() {
+        for (entity, burro) in burros.iter() {
             if burro.burro_skin == event.burro_skin {
-                *handle = game_assets.mechaburro_texture.material.clone();
-                burro.is_mechaburro = true;
+                text_display_timers.selected_burro = Some(entity);
                 break;
             }
         }
@@ -143,10 +250,6 @@ fn pick_mecha(
         text_display_timers.mecha_display_cooldown =
             text_display_timers.mecha_display_cooldown.clamp(-10.0, 3.0);
 
-        if text_display_timers.mecha_display_cooldown <= 0.0 {
-            app_state.set(AppState::InGame).unwrap();
-        }
-
         return;
     }
 
diff --git a/src/player.rs b/src/player.rs
index 28b6fe3..c8694b2 100644
--- a/src/player.rs
+++ b/src/player.rs
@@ -11,6 +11,7 @@ impl Plugin for PlayerPlugin {
     fn build(&self, app: &mut App) {
         app.add_plugin(InputManagerPlugin::<PlayerAction>::default())
             .add_event::<PlayerMoveEvent>()
+            .add_system_set(SystemSet::on_update(AppState::MechaPicker).with_system(move_player))
             .add_system_set(
                 SystemSet::on_update(AppState::InGame)
                     .with_system(handle_input.label("handle_input"))