diff --git a/.gitignore b/.gitignore
index d744ce2..0015b4e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 /target
 
 Cargo.lock
+
+*.blend1
diff --git a/Cargo.toml b/Cargo.toml
index 6ec1a73..bedf268 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,15 +27,13 @@ proc_macros = { path = "proc_macros" }
 bevy = { workspace = true }
 server = { workspace = true, optional = true, default-features = false }
 spectator_client = { workspace = true, optional = true, default-features = false }
-rand = "0.9.0"
 
 [features]
-default = ["debug"]
-debug = ["bevy/bevy_dev_tools", "bevy/file_watcher"]
+default = []
 server = ["server/server"]
-server_debug = ["debug", "server", "server/debug"]
+server_debug = ["server", "server/debug"]
 spectator_client = ["spectator_client/spectator_client"]
-spectator_client_debug = ["debug", "spectator_client", "spectator_client/debug"]
+spectator_client_debug = ["spectator_client", "spectator_client/debug"]
 
 # Enable a small amount of optimization in debug mode
 [profile.dev]
diff --git a/README.md b/README.md
index 725c6b6..60dcb34 100644
--- a/README.md
+++ b/README.md
@@ -53,3 +53,6 @@ The project is split into multiple members.
     - Smoke: low damage, high splash, low visibility (great for cover)
 - Generally bad vision
   - Depends much on the vision of other units
+
+# Credit
+- Tank Models made by Alexander Siegmann
\ No newline at end of file
diff --git a/assets/config/config.tanks.ron b/assets/config/config.tanks.ron
index 4e6cf70..14dc30c 100644
--- a/assets/config/config.tanks.ron
+++ b/assets/config/config.tanks.ron
@@ -32,6 +32,7 @@
                 RIGHT: 0.2,
             },
             respawnTimer: 25,
+            model: "light_tank",
         ),
         HEAVY_TANK: (
             moveSpeed: 0.25,
@@ -65,6 +66,7 @@
                 RIGHT: 0.2,
             },
             respawnTimer: 25,
+            model: "heavy_tank",
         ),
         SELF_PROPELLED_ARTILLERY: (
             moveSpeed: 0.1,
@@ -98,6 +100,7 @@
                 RIGHT: 0.2,
             },
             respawnTimer: 25,
+            model: "light_tank",
         ),
     },
 )
\ No newline at end of file
diff --git a/assets/models/tanks/blend/heavy_tank.blend b/assets/models/tanks/blend/heavy_tank.blend
new file mode 100644
index 0000000..3b82068
Binary files /dev/null and b/assets/models/tanks/blend/heavy_tank.blend differ
diff --git a/assets/models/tanks/blend/light_tank.blend b/assets/models/tanks/blend/light_tank.blend
new file mode 100644
index 0000000..a2bf580
Binary files /dev/null and b/assets/models/tanks/blend/light_tank.blend differ
diff --git a/assets/models/tanks/exported/heavy_tank.glb b/assets/models/tanks/exported/heavy_tank.glb
new file mode 100644
index 0000000..17d7f46
Binary files /dev/null and b/assets/models/tanks/exported/heavy_tank.glb differ
diff --git a/assets/models/tanks/exported/light_tank.glb b/assets/models/tanks/exported/light_tank.glb
new file mode 100644
index 0000000..ec067a3
Binary files /dev/null and b/assets/models/tanks/exported/light_tank.glb differ
diff --git a/server/Cargo.toml b/server/Cargo.toml
index 87e748a..8092ba5 100644
--- a/server/Cargo.toml
+++ b/server/Cargo.toml
@@ -21,5 +21,13 @@ server = [
     "bevy/bevy_color",
     "bevy/serialize",
     "bevy/multi_threaded",
+    "bevy/file_watcher",
+    "shared/server",
+]
+debug = [
+    "bevy/default",
+    "bevy-inspector-egui",
+    "shared/debug",
+    "bevy_flycam",
+    "bevy/bevy_dev_tools",
 ]
-debug = ["bevy/default", "bevy-inspector-egui", "shared/debug", "bevy_flycam"]
diff --git a/server/src/gameplay/handle_players/dummy_handling.rs b/server/src/gameplay/handle_players/dummy_handling.rs
index d150307..b34bdb0 100644
--- a/server/src/gameplay/handle_players/dummy_handling.rs
+++ b/server/src/gameplay/handle_players/dummy_handling.rs
@@ -54,7 +54,7 @@ pub fn simulate_movement(
                 .get_tank_type_config(tank_type)
                 .expect("Failed to get tank config");
 
-            // Simulate movement (always forward)
+            /* // Simulate movement (always forward)
             commands.trigger_targets(
                 MoveTankCommandTrigger {
                     sender: None,
@@ -86,7 +86,7 @@ pub fn simulate_movement(
                     },
                 },
                 *player,
-            );
+            ); */
 
             // Simulate movement (randomly)
             /* if rand::random::<bool>() {
diff --git a/server/src/gameplay/mod.rs b/server/src/gameplay/mod.rs
index 06917c2..c660dfa 100644
--- a/server/src/gameplay/mod.rs
+++ b/server/src/gameplay/mod.rs
@@ -22,6 +22,7 @@ pub struct MyGameplayPlugin;
 impl Plugin for MyGameplayPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<CleanupNextTick>()
+            .register_type::<LobbyWaitTicksUntilStart>()
             .configure_sets(
                 Update,
                 (
@@ -69,3 +70,13 @@ fn add_observers_to_lobby(trigger: Trigger<OnAdd, MyLobby>, mut commands: Comman
         .observe(process_messages::process_lobby_messages)
         .observe(lobby_cleanup::cleanup_entities);
 }
+
+#[derive(Debug, Component, Reflect, Deref, DerefMut)]
+#[reflect(Component)]
+pub struct LobbyWaitTicksUntilStart(pub u32);
+
+impl Default for LobbyWaitTicksUntilStart {
+    fn default() -> Self {
+        Self(1)
+    }
+}
diff --git a/server/src/gameplay/start_lobby.rs b/server/src/gameplay/start_lobby.rs
index 00116ee..bd3457c 100644
--- a/server/src/gameplay/start_lobby.rs
+++ b/server/src/gameplay/start_lobby.rs
@@ -23,8 +23,9 @@ use shared::{
 
 use crate::networking::handle_clients::lib::MyNetworkClient;
 
-use super::handle_players::{
-    dummy_handling::DummyClientMarker, handle_spawning::RespawnPlayerTrigger,
+use super::{
+    handle_players::{dummy_handling::DummyClientMarker, handle_spawning::RespawnPlayerTrigger},
+    LobbyWaitTicksUntilStart,
 };
 
 #[derive(Debug, Event)]
@@ -244,6 +245,10 @@ pub fn start_lobby(
                         tank_configs: tank_configs.tanks.clone(),
                     }),
                 ));
+
+                commands
+                    .entity(lobby_entity)
+                    .insert(LobbyWaitTicksUntilStart::default());
             }
 
             lobby_management
diff --git a/server/src/gameplay/tick_systems.rs b/server/src/gameplay/tick_systems.rs
index 2941ca9..0663ea2 100644
--- a/server/src/gameplay/tick_systems.rs
+++ b/server/src/gameplay/tick_systems.rs
@@ -6,7 +6,9 @@ use shared::{
 
 use crate::gameplay::triggers::CollectAndTriggerMessagesTrigger;
 
-use super::{system_sets::MyGameplaySet, triggers::StartNextTickProcessingTrigger};
+use super::{
+    system_sets::MyGameplaySet, triggers::StartNextTickProcessingTrigger, LobbyWaitTicksUntilStart,
+};
 
 pub struct TickSystemsPlugin;
 
@@ -22,13 +24,21 @@ impl Plugin for TickSystemsPlugin {
 
 fn process_tick_timer(
     mut commands: Commands,
-    mut lobbies: Query<(Entity, &mut MyLobby)>,
+    mut lobbies: Query<(Entity, &mut MyLobby, Option<&mut LobbyWaitTicksUntilStart>)>,
     time: Res<Time>,
 ) {
-    for (entity, mut lobby) in lobbies.iter_mut() {
+    for (entity, mut lobby, lobby_wait_tick_until_start) in lobbies.iter_mut() {
         if LobbyState::InProgress == lobby.state {
             if lobby.tick_timer.tick(time.delta()).just_finished() {
-                commands.trigger_targets(StartNextTickProcessingTrigger, entity);
+                if let Some(mut lobby_wait_tick_until_start) = lobby_wait_tick_until_start {
+                    if lobby_wait_tick_until_start.0 > 0 {
+                        lobby_wait_tick_until_start.0 -= 1;
+                    } else {
+                        commands.entity(entity).remove::<LobbyWaitTicksUntilStart>();
+                    }
+                } else {
+                    commands.trigger_targets(StartNextTickProcessingTrigger, entity);
+                }
             }
         }
     }
diff --git a/shared/Cargo.toml b/shared/Cargo.toml
index 80bdb32..08087b8 100644
--- a/shared/Cargo.toml
+++ b/shared/Cargo.toml
@@ -16,3 +16,5 @@ serde_json = { workspace = true }
 default = ["shared", "debug"]
 shared = ["bevy/serialize"]
 debug = []
+server = []
+spectator_client = []
\ No newline at end of file
diff --git a/shared/src/asset_handling/config.rs b/shared/src/asset_handling/config.rs
index 6cad1bb..dce853e 100644
--- a/shared/src/asset_handling/config.rs
+++ b/shared/src/asset_handling/config.rs
@@ -5,6 +5,7 @@ use bevy_asset_loader::{
         config::{ConfigureLoadingState, LoadingStateConfig},
         LoadingStateAppExt,
     },
+    mapped::AssetFileStem,
 };
 use bevy_common_assets::ron::RonAssetPlugin;
 use serde::{Deserialize, Serialize};
@@ -43,6 +44,10 @@ struct MyConfigAsset {
     client: Handle<ClientConfig>,
     #[asset(path = "config/config.tanks.ron")]
     tank: Handle<TankConfigs>,
+    #[cfg(feature = "spectator_client")]
+    #[reflect(ignore)]
+    #[asset(path = "models/tanks/exported", collection(mapped, typed))]
+    tank_models: HashMap<AssetFileStem, Handle<Gltf>>,
 }
 
 #[derive(Debug, Default, Reflect, Clone, Asset, Deserialize)]
@@ -102,6 +107,10 @@ pub struct TankConfig {
     pub armor: HashMap<Side, f32>,
     /// The time in ticks it takes for the tank to respawn after dying
     pub respawn_timer: u32,
+    #[cfg(feature = "spectator_client")]
+    /// The model of the tank
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub model: String,
 }
 
 #[derive(SystemParam)]
@@ -154,4 +163,14 @@ impl<'w> TankConfigSystemParam<'w> {
             .get(self.config_asset.tank.id())
             .expect("Tank configs not loaded")
     }
+
+    #[cfg(feature = "spectator_client")]
+    pub fn get_tank_model(&self, model: &str) -> Handle<Gltf> {
+        self.config_asset
+            .tank_models
+            .iter()
+            .find(|(stem, _)| stem.as_ref() == model)
+            .map(|(_, handle)| handle.clone())
+            .expect("Failed to get tank model")
+    }
 }
diff --git a/spectator_client/Cargo.toml b/spectator_client/Cargo.toml
index a2f9c25..5115da1 100644
--- a/spectator_client/Cargo.toml
+++ b/spectator_client/Cargo.toml
@@ -16,5 +16,11 @@ bevy_mod_billboard = { git = "https://github.com/voximity/bevy_mod_billboard.git
 
 [features]
 default = ["spectator_client", "debug"]
-spectator_client = ["bevy/default", "bevy/serialize"]
-debug = ["bevy-inspector-egui", "shared/debug"]
+spectator_client = [
+    "bevy/default",
+    "bevy/serialize",
+    "shared/spectator_client",
+    "bevy/file_watcher",
+    "shared/spectator_client",
+]
+debug = ["bevy-inspector-egui", "shared/debug", "bevy/bevy_dev_tools"]
diff --git a/spectator_client/src/game_handling/mod.rs b/spectator_client/src/game_handling/mod.rs
index 84b1646..7ca79a6 100644
--- a/spectator_client/src/game_handling/mod.rs
+++ b/spectator_client/src/game_handling/mod.rs
@@ -29,7 +29,7 @@ fn add_observers(trigger: Trigger<OnAdd, MyNetworkStream>, mut commands: Command
     commands
         .entity(trigger.entity())
         .observe(game_starts::game_starts)
-        .observe(player_handling::update_player_state_on_game_state_update)
+        //.observe(player_handling::update_player_state_on_game_state_update)
         .observe(projectile_handling::handle_projectile_on_game_state_update)
         .observe(despawn_delayed::despawn_delayed_entites);
 }
diff --git a/spectator_client/src/game_handling/player_handling.rs b/spectator_client/src/game_handling/player_handling.rs
index 79e02ce..56e473e 100644
--- a/spectator_client/src/game_handling/player_handling.rs
+++ b/spectator_client/src/game_handling/player_handling.rs
@@ -7,6 +7,8 @@ use shared::{
     networking::messages::message_container::GameStateTrigger,
 };
 
+use crate::VisualOffset;
+
 use super::entity_mapping::MyEntityMapping;
 
 pub fn update_player_state_on_game_state_update(
@@ -20,6 +22,7 @@ pub fn update_player_state_on_game_state_update(
             &mut ShootCooldown,
             &mut PlayerState,
             &TankBodyMarker,
+            &VisualOffset,
         ),
         Without<TankTurretMarker>,
     >,
@@ -37,6 +40,7 @@ pub fn update_player_state_on_game_state_update(
                 mut shoot_cooldown,
                 mut player_state,
                 tank_body,
+                body_visual_offset,
             )) = tank_body.get_mut(client_side_entity)
             {
                 health.health = server_side_client_state
@@ -56,12 +60,13 @@ pub fn update_player_state_on_game_state_update(
                     .clone();
 
                 // TRANSFORM UPDATES
-                let new_body_transform = server_side_client_state
+                let mut new_body_transform = server_side_client_state
                     .as_ref()
                     .expect("Client state is missing")
                     .transform_body
                     .clone()
                     .expect("Position is missing");
+                new_body_transform.translation -= body_visual_offset.0;
 
                 // Setting the actual current body transform to the next target body transform (the one that was previously set)
                 current_body_transform.translation = next_target_body_transform.translation;
@@ -71,15 +76,16 @@ pub fn update_player_state_on_game_state_update(
                 next_target_body_transform.translation = new_body_transform.translation;
                 next_target_body_transform.rotation = new_body_transform.rotation;
 
+                let (mut current_turret_transform, mut next_target_turret_transform) = tank_turret
+                    .get_mut(tank_body.turret.expect("Failed to get turret entity"))
+                    .expect("Failed to get turret");
+
                 let new_turret_transform = server_side_client_state
                     .as_ref()
                     .expect("Client state is missing")
                     .transform_turret
                     .clone()
                     .expect("Position is missing");
-                let (mut current_turret_transform, mut next_target_turret_transform) = tank_turret
-                    .get_mut(tank_body.turret.expect("Failed to get turret entity"))
-                    .expect("Failed to get turret");
 
                 current_turret_transform.translation = next_target_turret_transform.translation;
                 current_turret_transform.rotation = next_target_turret_transform.rotation;
diff --git a/spectator_client/src/lib.rs b/spectator_client/src/lib.rs
index ad54231..533922c 100644
--- a/spectator_client/src/lib.rs
+++ b/spectator_client/src/lib.rs
@@ -41,7 +41,8 @@ impl Plugin for MySpectatorClientPlugin {
         .add_sub_state::<MyGameState>()
         .enable_state_scoped_entities::<MyGameState>()
         .register_type::<MyEntityMapping>()
-        .init_resource::<MyEntityMapping>();
+        .init_resource::<MyEntityMapping>()
+        .register_type::<VisualOffset>();
 
         #[cfg(feature = "debug")]
         {
@@ -71,3 +72,7 @@ fn change_camera_transform(
     let center_of_map = game_config.map_definition.get_center_of_map();
     camera_transform.look_at(center_of_map, Vec3::Y);
 }
+
+#[derive(Debug, Component, Reflect, Default, Deref, DerefMut)]
+#[reflect(Component)]
+pub struct VisualOffset(pub Vec3);
diff --git a/spectator_client/src/map_visualization/mod.rs b/spectator_client/src/map_visualization/mod.rs
index d6f4c8d..4682e45 100644
--- a/spectator_client/src/map_visualization/mod.rs
+++ b/spectator_client/src/map_visualization/mod.rs
@@ -7,6 +7,7 @@ use shared::{
 };
 use visualize_colliders::{visualize_colliders, MyColliderGizmos};
 use visualize_markers::{draw_markers, MyMarkerGizmos};
+use visualize_players::{setup_tank, AwaitsSetup, TeamColorMaterialsResource};
 use visualize_positions::{visualize_cells, MyPositionGizmos};
 use visulize_turret_ranges::{draw_turret_ranges, MyTurretRangeGizmos};
 
@@ -24,6 +25,8 @@ pub struct MyMapVisualizationPlugin;
 impl Plugin for MyMapVisualizationPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<MapMeshMarker>()
+            .register_type::<AwaitsSetup>()
+            .register_type::<TeamColorMaterialsResource>()
             .init_gizmo_group::<MyMarkerGizmos>()
             .init_gizmo_group::<MyPositionGizmos>()
             .init_gizmo_group::<MyTurretRangeGizmos>()
@@ -34,7 +37,7 @@ impl Plugin for MyMapVisualizationPlugin {
                     (listen_for_map_changes,).run_if(any_with_component::<MapMeshMarker>),
                     (draw_turret_ranges,).run_if(any_with_component::<TankTurretMarker>),
                     (visualize_colliders,).run_if(any_with_component::<Collider>),
-                    (draw_markers, visualize_cells),
+                    (draw_markers, visualize_cells, setup_tank),
                 )
                     .run_if(resource_exists::<GameStarts>),)
                     .run_if(in_state(MyMainState::Ready)),
diff --git a/spectator_client/src/map_visualization/visualize_colliders.rs b/spectator_client/src/map_visualization/visualize_colliders.rs
index 952c335..0856be8 100644
--- a/spectator_client/src/map_visualization/visualize_colliders.rs
+++ b/spectator_client/src/map_visualization/visualize_colliders.rs
@@ -1,15 +1,22 @@
 use bevy::{color::palettes::css::WHITE, prelude::*};
 use shared::game::collision_handling::{components::Collider, structs::Obb3d};
 
+use crate::VisualOffset;
+
 #[derive(Default, Reflect, GizmoConfigGroup)]
 pub struct MyColliderGizmos {}
 
 pub fn visualize_colliders(
     mut my_gizmos: Gizmos<MyColliderGizmos>,
-    query: Query<(&Transform, &Collider)>,
+    query: Query<(&Transform, &Collider, Option<&VisualOffset>)>,
 ) {
-    for (transform, collider) in query.iter() {
-        let obb = Obb3d::from_transform(transform, collider);
+    for (transform, collider, visual_offset) in query.iter() {
+        let mut transform = *transform;
+        if let Some(offset) = visual_offset {
+            transform.translation += offset.0;
+        }
+
+        let obb = Obb3d::from_transform(&transform, collider);
 
         my_gizmos.primitive_3d(
             &Cuboid {
diff --git a/spectator_client/src/map_visualization/visualize_players.rs b/spectator_client/src/map_visualization/visualize_players.rs
index 7ea11fe..10efb54 100644
--- a/spectator_client/src/map_visualization/visualize_players.rs
+++ b/spectator_client/src/map_visualization/visualize_players.rs
@@ -1,9 +1,7 @@
-use bevy::{
-    color::palettes::css::{GREEN, WHITE},
-    prelude::*,
-};
+use bevy::{color::palettes::css::WHITE, gltf::GltfMaterialName, prelude::*, utils::HashMap};
 use bevy_mod_billboard::BillboardText;
 use shared::{
+    asset_handling::config::TankConfigSystemParam,
     game::{
         collision_handling::components::WantedTransform,
         player_handling::{Health, TankBodyMarker, TankTurretMarker},
@@ -11,19 +9,21 @@ use shared::{
     networking::{lobby_management::InTeam, messages::message_container::GameStartsTrigger},
 };
 
-use crate::game_handling::entity_mapping::MyEntityMapping;
+use crate::{game_handling::entity_mapping::MyEntityMapping, VisualOffset};
 
 pub fn create_player_visualisation(
     trigger: Trigger<GameStartsTrigger>,
     mut commands: Commands,
-    mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     asset_server: Res<AssetServer>,
     mut entity_mapping: ResMut<MyEntityMapping>,
+    client_side_loaded_tank_assets: TankConfigSystemParam,
+    gltf_assets: Res<Assets<Gltf>>,
 ) {
     let game_start = trigger.event();
     let tank_configs = &game_start.tank_configs;
     let font = asset_server.load("fonts/FiraSans-Regular.ttf");
+    let mut team_materials = HashMap::default();
 
     for server_side_client_config in game_start.connected_clients.iter() {
         let team_color = game_start
@@ -32,24 +32,42 @@ pub fn create_player_visualisation(
             .map(|config| Color::from(config.color.clone()))
             .unwrap_or(WHITE.into());
 
+        let team_material = materials.add(StandardMaterial {
+            base_color: team_color,
+            ..Default::default()
+        });
+        team_materials.insert(server_side_client_config.client_team.clone(), team_material);
+
         let tank_type = &server_side_client_config.client_tank_type;
-        let tank_config = tank_configs
+        let server_side_tank_config = tank_configs
             .get(tank_type)
             .expect("Failed to get tank config");
+        let client_side_tank_config = client_side_loaded_tank_assets
+            .get_tank_type_config(tank_type)
+            .expect("Failed to get tank assets");
+        let tank_model_handle =
+            client_side_loaded_tank_assets.get_tank_model(client_side_tank_config.model.as_ref());
+        let tank_gltf = gltf_assets
+            .get(tank_model_handle.id())
+            .expect("Failed to get tank gltf");
+        let tank_y_visual_offset = server_side_tank_config.size.y / 2.0;
 
         // Tank Body
         let client_side_tank_body_entity = commands
             .spawn((
                 Name::new(server_side_client_config.client_name.clone()),
-                Mesh3d(meshes.add(Cuboid::from_size(tank_config.size))),
-                MeshMaterial3d(materials.add(team_color)),
                 tank_type.clone(),
                 InTeam(server_side_client_config.client_team.clone()),
-                Health::new(tank_config.max_health),
+                Health::new(server_side_tank_config.max_health),
+                VisualOffset(Vec3::new(0.0, tank_y_visual_offset, 0.0)),
+                Visibility::Inherited,
+                TankBodyMarker { turret: None },
+                AwaitsSetup::default(),
             ))
             .with_children(|commands| {
                 // Name tag
                 commands.spawn((
+                    Name::new("Name Tag"),
                     BillboardText::new(&server_side_client_config.client_name),
                     TextFont::from_font(font.clone()).with_font_size(60.0),
                     TextColor(Color::WHITE),
@@ -58,54 +76,84 @@ pub fn create_player_visualisation(
                         .with_scale(Vec3::splat(0.0085)),
                 ));
 
-                // Forward marker
-                commands.spawn((
-                    Name::new("Forward marker"),
-                    Mesh3d(meshes.add(Cuboid::new(0.1, 0.1, 0.1))),
-                    MeshMaterial3d(materials.add(StandardMaterial {
-                        base_color: GREEN.into(),
-                        ..Default::default()
-                    })),
-                    Transform::from_translation(Vec3::new(0.0, 0.0, tank_config.size.z + 0.2)),
-                ));
-            })
-            .id();
-
-        // Turret
-        let client_side_turret_entity = commands
-            .spawn((
-                Name::new("Turret Root"),
-                TankTurretMarker {
-                    body: client_side_tank_body_entity,
-                },
-                WantedTransform::default(),
-                Visibility::Inherited,
-            ))
-            .with_children(|commands| {
-                // Turret, placed a bit in front of the turret root. This is just for visualization.
-                // more rectangle, long not wide or tall
+                // GLTF Scene
                 commands.spawn((
-                    Name::new("Turret"),
-                    Mesh3d(meshes.add(Cuboid::new(0.1, 0.1, 0.5))),
-                    MeshMaterial3d(materials.add(StandardMaterial {
-                        base_color: team_color,
-                        ..Default::default()
-                    })),
-                    Transform::from_translation(Vec3::new(0.0, 0.0, 0.25)),
+                    Name::new("GLTF Scene"),
+                    SceneRoot(tank_gltf.scenes[0].clone()),
                 ));
             })
             .id();
 
-        commands
-            .entity(client_side_tank_body_entity)
-            .insert((TankBodyMarker {
-                turret: Some(client_side_turret_entity),
-            },))
-            .add_child(client_side_turret_entity);
-
         entity_mapping.mapping.insert(
             server_side_client_config.client_id,
             client_side_tank_body_entity,
         );
     }
+
+    commands.insert_resource(TeamColorMaterialsResource {
+        materials: team_materials,
+    });
+}
+
+#[derive(Debug, Default, Component, Reflect)]
+#[reflect(Component)]
+pub struct AwaitsSetup;
+
+#[derive(Debug, Default, Resource, Reflect)]
+#[reflect(Resource)]
+pub struct TeamColorMaterialsResource {
+    pub materials: HashMap<String, Handle<StandardMaterial>>,
+}
+
+pub fn setup_tank(
+    mut commands: Commands,
+    team_materials: Res<TeamColorMaterialsResource>,
+    mut tank: Query<(Entity, &mut TankBodyMarker, &InTeam), With<AwaitsSetup>>,
+    children: Query<&Children>,
+    tank_turret: Query<(&Name, &Transform)>,
+    mat_query: Query<&GltfMaterialName, With<MeshMaterial3d<StandardMaterial>>>,
+) {
+    for (awaits_setup_entity, mut tank_body, in_team) in tank.iter_mut() {
+        let team_name = in_team.0.clone();
+        let team_color = team_materials
+            .materials
+            .get(&team_name)
+            .expect("Failed to get team color material");
+
+        let mut setup_color = false;
+        let mut setup_turret = false;
+        for child in children.iter_descendants(awaits_setup_entity) {
+            // Updating the material of the tank body to match the team color
+            if let Ok(material_name) = mat_query.get(child) {
+                if material_name.0 != "TeamColor" {
+                    continue;
+                }
+
+                let material = team_color.clone();
+                commands.entity(child).insert(MeshMaterial3d(material));
+                setup_color = true;
+            }
+
+            // Inserting marker component for the turret
+            if let Ok((name, transform)) = tank_turret.get(child) {
+                if **name == *"Turret" {
+                    commands.entity(child).insert((
+                        TankTurretMarker {
+                            body: awaits_setup_entity,
+                        },
+                        WantedTransform(*transform),
+                    ));
+
+                    tank_body.turret = Some(child);
+                    setup_turret = true;
+                }
+            }
+
+            if setup_color && setup_turret {
+                commands.entity(awaits_setup_entity).remove::<AwaitsSetup>();
+
+                break;
+            }
+        }
+    }
 }