diff --git a/Assets/CONTENT/FEATURES/MapRadar/Editor/MapRadarNetworkSetup.cs b/Assets/CONTENT/FEATURES/MapRadar/Editor/MapRadarNetworkSetup.cs
new file mode 100644
index 0000000..2db3138
--- /dev/null
+++ b/Assets/CONTENT/FEATURES/MapRadar/Editor/MapRadarNetworkSetup.cs
@@ -0,0 +1,289 @@
+using Unity.Netcode;
+using Unity.Netcode.Components;
+using UnityEditor;
+using UnityEngine;
+
+public static class MapRadarNetworkSetup
+{
+    private const string LeverPrefabPath =
+        "Assets/CONTENT/Game/Prefabs/Interaction/PhysicalLever.prefab";
+
+    [MenuItem("FORT-BO/Map Radar/Configure Network Prototype")]
+    public static void ConfigureNetworkPrototype()
+    {
+        MapController mapController = Object.FindFirstObjectByType<MapController>();
+        if (mapController == null)
+        {
+            Debug.LogError("MapController was not found in the open scene.");
+            return;
+        }
+
+        MapCoordinateSystem coordinateSystem = mapController.CoordinateSystem;
+        if (coordinateSystem == null || !coordinateSystem.HasValidCorners())
+        {
+            Debug.LogError("MapCoordinateSystem is not configured.", mapController);
+            return;
+        }
+
+        Undo.RegisterFullObjectHierarchyUndo(mapController.transform.root.gameObject,
+            "Configure network map prototype");
+
+        GetOrAdd<NetworkObject>(mapController.gameObject);
+        NetworkBaseHealth baseHealth = GetOrAdd<NetworkBaseHealth>(mapController.gameObject);
+        MapControlBinder binder = GetOrAdd<MapControlBinder>(mapController.gameObject);
+
+        Transform controlsRoot = GetOrCreateChild(
+            mapController.transform.root,
+            "Map Controls");
+
+        MapBasis basis = CreateBasis(coordinateSystem);
+        NetworkPhysicalWheelInteractable horizontalWheel = CreateWheel(
+            controlsRoot,
+            "Map Horizontal Wheel",
+            basis.ControlCenter - basis.Horizontal * 1.8f,
+            basis.Rotation,
+            "Aim horizontal");
+        NetworkPhysicalWheelInteractable verticalWheel = CreateWheel(
+            controlsRoot,
+            "Map Vertical Wheel",
+            basis.ControlCenter - basis.Horizontal * 0.6f,
+            basis.Rotation,
+            "Aim vertical");
+        NetworkPhysicalLeverInteractable fireLever = CreateFireLever(
+            controlsRoot,
+            basis.ControlCenter + basis.Horizontal * 0.8f,
+            basis.Rotation);
+        NetworkButtonInteractable scanButton = CreateScanButton(
+            controlsRoot,
+            basis.ControlCenter + basis.Horizontal * 2f,
+            basis.Rotation);
+
+        SerializedObject map = new(mapController);
+        SetObject(map, "roundGameLoop",
+            Object.FindFirstObjectByType<RoundGameLoopController>());
+        SetObject(map, "baseHealth", baseHealth);
+        map.ApplyModifiedPropertiesWithoutUndo();
+
+        SerializedObject binding = new(binder);
+        SetObject(binding, "mapController", mapController);
+        SetObject(binding, "horizontalWheel", horizontalWheel);
+        SetObject(binding, "verticalWheel", verticalWheel);
+        SetObject(binding, "fireLever", fireLever);
+        SetObject(binding, "scanButton", scanButton);
+        binding.ApplyModifiedPropertiesWithoutUndo();
+
+        EditorUtility.SetDirty(mapController);
+        EditorUtility.SetDirty(binder);
+        EditorUtility.SetDirty(baseHealth);
+        UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(
+            mapController.gameObject.scene);
+        UnityEditor.SceneManagement.EditorSceneManager.SaveOpenScenes();
+        Selection.activeObject = controlsRoot.gameObject;
+
+        Debug.Log(
+            "[Map] Network prototype configured: X/Y wheels, fire lever, " +
+            "scan button and base health are connected.",
+            mapController);
+    }
+
+    private static NetworkPhysicalWheelInteractable CreateWheel(
+        Transform parent,
+        string name,
+        Vector3 position,
+        Quaternion rotation,
+        string interactionLabel)
+    {
+        Transform root = GetOrCreateChild(parent, name);
+        root.SetPositionAndRotation(position, rotation);
+        root.localScale = Vector3.one;
+
+        GetOrAdd<NetworkObject>(root.gameObject);
+        NetworkTransform networkTransform = GetOrAdd<NetworkTransform>(root.gameObject);
+        networkTransform.AuthorityMode = NetworkTransform.AuthorityModes.Server;
+        networkTransform.UseUnreliableDeltas = true;
+
+        Transform legacyVisual = root.Find("Wheel Visual");
+        Transform visual = root.Find("Wheel Pivot");
+        if (visual == null)
+        {
+            if (legacyVisual != null)
+                Object.DestroyImmediate(legacyVisual.gameObject);
+            visual = new GameObject("Wheel Pivot").transform;
+            visual.SetParent(root, false);
+        }
+
+        visual.localPosition = Vector3.zero;
+        visual.localRotation = Quaternion.identity;
+        visual.localScale = Vector3.one;
+
+        Transform disk = visual.Find("Wheel Disk");
+        if (disk == null)
+        {
+            GameObject cylinder = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
+            cylinder.name = "Wheel Disk";
+            disk = cylinder.transform;
+            disk.SetParent(visual, false);
+        }
+
+        disk.localPosition = Vector3.zero;
+        disk.localRotation = Quaternion.Euler(90f, 0f, 0f);
+        disk.localScale = new Vector3(0.48f, 0.08f, 0.48f);
+
+        Transform handle = visual.Find("Handle");
+        if (handle == null)
+        {
+            GameObject handleObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            handleObject.name = "Handle";
+            handle = handleObject.transform;
+            handle.SetParent(visual, false);
+            Object.DestroyImmediate(handleObject.GetComponent<Collider>());
+        }
+
+        handle.localPosition = new Vector3(0f, 0.65f, 0f);
+        handle.localRotation = Quaternion.identity;
+        handle.localScale = new Vector3(0.14f, 0.4f, 0.14f);
+
+        NetworkPhysicalWheelInteractable wheel =
+            GetOrAdd<NetworkPhysicalWheelInteractable>(root.gameObject);
+        SerializedObject serializedWheel = new(wheel);
+        SetObject(serializedWheel, "wheelVisual", visual);
+        SetVector3(serializedWheel, "neutralLocalEulerAngles", Vector3.zero);
+        SetString(serializedWheel, "interactionLabel", interactionLabel);
+        SetVector3(serializedWheel, "localRotationAxis", Vector3.forward);
+        SetVector3(serializedWheel, "localReferenceDirection", Vector3.up);
+        SetFloat(serializedWheel, "minimumAngle", -180f);
+        SetFloat(serializedWheel, "maximumAngle", 180f);
+        SetFloat(serializedWheel, "initialNormalizedValue", 0.5f);
+        SetFloat(serializedWheel, "maximumInteractionDistance", 3.5f);
+        SetFloat(serializedWheel, "maximumControlDistance", 4f);
+        serializedWheel.ApplyModifiedPropertiesWithoutUndo();
+        return wheel;
+    }
+
+    private static NetworkPhysicalLeverInteractable CreateFireLever(
+        Transform parent,
+        Vector3 position,
+        Quaternion rotation)
+    {
+        Transform existing = parent.Find("Map Fire Lever");
+        GameObject root;
+        if (existing != null)
+        {
+            root = existing.gameObject;
+        }
+        else
+        {
+            GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(LeverPrefabPath);
+            if (prefab == null)
+                throw new MissingReferenceException($"Lever prefab not found: {LeverPrefabPath}");
+            root = (GameObject)PrefabUtility.InstantiatePrefab(prefab, parent);
+            root.name = "Map Fire Lever";
+        }
+
+        root.transform.SetPositionAndRotation(position, rotation);
+        root.transform.localScale = Vector3.one * 0.55f;
+        NetworkPhysicalLeverInteractable lever =
+            root.GetComponent<NetworkPhysicalLeverInteractable>();
+        SerializedObject serializedLever = new(lever);
+        SetString(serializedLever, "interactionLabel", "Fire");
+        SetBool(serializedLever, "initialPositionIsMaximum", false);
+        SetBool(serializedLever, "returnToInitialPositionAfterSwitch", true);
+        SetFloat(serializedLever, "automaticReturnDelay", 0.2f);
+        SetFloat(serializedLever, "maximumInteractionDistance", 3.5f);
+        SetFloat(serializedLever, "maximumControlDistance", 4f);
+        serializedLever.ApplyModifiedPropertiesWithoutUndo();
+        return lever;
+    }
+
+    private static NetworkButtonInteractable CreateScanButton(
+        Transform parent,
+        Vector3 position,
+        Quaternion rotation)
+    {
+        Transform root = GetOrCreateChild(parent, "Map Scan Button");
+        root.SetPositionAndRotation(position, rotation);
+        root.localScale = Vector3.one;
+
+        GetOrAdd<NetworkObject>(root.gameObject);
+        NetworkTransform networkTransform = GetOrAdd<NetworkTransform>(root.gameObject);
+        networkTransform.AuthorityMode = NetworkTransform.AuthorityModes.Server;
+
+        Transform visual = root.Find("Button Visual");
+        if (visual == null)
+        {
+            GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            cube.name = "Button Visual";
+            visual = cube.transform;
+            visual.SetParent(root, false);
+        }
+
+        visual.localPosition = Vector3.zero;
+        visual.localRotation = Quaternion.identity;
+        visual.localScale = new Vector3(0.55f, 0.55f, 0.18f);
+
+        NetworkButtonInteractable button = GetOrAdd<NetworkButtonInteractable>(root.gameObject);
+        SerializedObject serializedButton = new(button);
+        SetString(serializedButton, "interactionLabel", "Scan map");
+        SetFloat(serializedButton, "maximumInteractionDistance", 3.5f);
+        serializedButton.ApplyModifiedPropertiesWithoutUndo();
+        return button;
+    }
+
+    private static MapBasis CreateBasis(MapCoordinateSystem coordinates)
+    {
+        Vector3 bottomLeft = coordinates.BottomLeft.position;
+        Vector3 horizontalEdge = coordinates.BottomRight.position - bottomLeft;
+        Vector3 verticalEdge = coordinates.TopLeft.position - bottomLeft;
+        Vector3 horizontal = horizontalEdge.normalized;
+        Vector3 vertical = verticalEdge.normalized;
+        Vector3 normal = Vector3.Cross(horizontal, vertical).normalized;
+        Vector3 bottomCenter = bottomLeft + horizontalEdge * 0.5f;
+        Vector3 controlCenter = bottomCenter - vertical * 0.85f + normal * 0.55f;
+        return new MapBasis(
+            horizontal,
+            controlCenter,
+            Quaternion.LookRotation(normal, vertical));
+    }
+
+    private static Transform GetOrCreateChild(Transform parent, string name)
+    {
+        Transform existing = parent.Find(name);
+        if (existing != null)
+            return existing;
+        GameObject child = new(name);
+        child.transform.SetParent(parent, false);
+        Undo.RegisterCreatedObjectUndo(child, $"Create {name}");
+        return child.transform;
+    }
+
+    private static T GetOrAdd<T>(GameObject target) where T : Component
+    {
+        T component = target.GetComponent<T>();
+        return component != null ? component : Undo.AddComponent<T>(target);
+    }
+
+    private static void SetObject(SerializedObject target, string property, Object value) =>
+        target.FindProperty(property).objectReferenceValue = value;
+    private static void SetString(SerializedObject target, string property, string value) =>
+        target.FindProperty(property).stringValue = value;
+    private static void SetFloat(SerializedObject target, string property, float value) =>
+        target.FindProperty(property).floatValue = value;
+    private static void SetBool(SerializedObject target, string property, bool value) =>
+        target.FindProperty(property).boolValue = value;
+    private static void SetVector3(SerializedObject target, string property, Vector3 value) =>
+        target.FindProperty(property).vector3Value = value;
+
+    private readonly struct MapBasis
+    {
+        public readonly Vector3 Horizontal;
+        public readonly Vector3 ControlCenter;
+        public readonly Quaternion Rotation;
+
+        public MapBasis(Vector3 horizontal, Vector3 controlCenter, Quaternion rotation)
+        {
+            Horizontal = horizontal;
+            ControlCenter = controlCenter;
+            Rotation = rotation;
+        }
+    }
+}
diff --git a/Assets/CONTENT/FEATURES/MapRadar/Editor/MapRadarNetworkSetup.cs.meta b/Assets/CONTENT/FEATURES/MapRadar/Editor/MapRadarNetworkSetup.cs.meta
new file mode 100644
index 0000000..01be682
--- /dev/null
+++ b/Assets/CONTENT/FEATURES/MapRadar/Editor/MapRadarNetworkSetup.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 3807965ea93055647ad20aa098cd2032
\ No newline at end of file
diff --git a/Assets/CONTENT/FEATURES/MapRadar/MapControlBinder.cs b/Assets/CONTENT/FEATURES/MapRadar/MapControlBinder.cs
new file mode 100644
index 0000000..4475426
--- /dev/null
+++ b/Assets/CONTENT/FEATURES/MapRadar/MapControlBinder.cs
@@ -0,0 +1,73 @@
+using UnityEngine;
+
+[DisallowMultipleComponent]
+public sealed class MapControlBinder : MonoBehaviour
+{
+    [SerializeField] private MapController mapController;
+    [SerializeField] private NetworkPhysicalWheelInteractable horizontalWheel;
+    [SerializeField] private NetworkPhysicalWheelInteractable verticalWheel;
+    [SerializeField] private NetworkPhysicalLeverInteractable fireLever;
+    [SerializeField] private NetworkButtonInteractable scanButton;
+
+    private bool initialValuesApplied;
+
+    private void Reset() => mapController = GetComponent<MapController>();
+
+    private void OnEnable()
+    {
+        if (horizontalWheel != null)
+            horizontalWheel.ValueChanged += HandleHorizontalChanged;
+        if (verticalWheel != null)
+            verticalWheel.ValueChanged += HandleVerticalChanged;
+        if (fireLever != null)
+            fireLever.StateChanged += HandleFireChanged;
+        if (scanButton != null)
+            scanButton.Pressed += HandleScanPressed;
+    }
+
+    private void OnDisable()
+    {
+        if (horizontalWheel != null)
+            horizontalWheel.ValueChanged -= HandleHorizontalChanged;
+        if (verticalWheel != null)
+            verticalWheel.ValueChanged -= HandleVerticalChanged;
+        if (fireLever != null)
+            fireLever.StateChanged -= HandleFireChanged;
+        if (scanButton != null)
+            scanButton.Pressed -= HandleScanPressed;
+    }
+
+    private void Update()
+    {
+        if (initialValuesApplied || mapController == null || !mapController.IsSpawned ||
+            horizontalWheel == null || verticalWheel == null ||
+            !horizontalWheel.IsSpawned || !verticalWheel.IsSpawned)
+        {
+            return;
+        }
+
+        initialValuesApplied = true;
+        HandleHorizontalChanged(horizontalWheel.NormalizedValue);
+        HandleVerticalChanged(verticalWheel.NormalizedValue);
+    }
+
+    private void HandleHorizontalChanged(float value) =>
+        ApplyOnServer(() => mapController.SetHorizontalNormalized(value));
+
+    private void HandleVerticalChanged(float value) =>
+        ApplyOnServer(() => mapController.SetVerticalNormalized(value));
+
+    private void HandleFireChanged(bool active)
+    {
+        if (active)
+            ApplyOnServer(mapController.RequestPseudoFire);
+    }
+
+    private void HandleScanPressed() => ApplyOnServer(mapController.RequestRadarScan);
+
+    private void ApplyOnServer(System.Action action)
+    {
+        if (mapController != null && mapController.IsSpawned && mapController.IsServer)
+            action?.Invoke();
+    }
+}
diff --git a/Assets/CONTENT/FEATURES/MapRadar/MapControlBinder.cs.meta b/Assets/CONTENT/FEATURES/MapRadar/MapControlBinder.cs.meta
new file mode 100644
index 0000000..e4ea4d1
--- /dev/null
+++ b/Assets/CONTENT/FEATURES/MapRadar/MapControlBinder.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1a23aadbde3d31042abf625ff22e6fd8
\ No newline at end of file
diff --git a/Assets/CONTENT/FEATURES/MapRadar/MapController.cs b/Assets/CONTENT/FEATURES/MapRadar/MapController.cs
index cb08857..a3d001a 100644
--- a/Assets/CONTENT/FEATURES/MapRadar/MapController.cs
+++ b/Assets/CONTENT/FEATURES/MapRadar/MapController.cs
@@ -1,100 +1,534 @@
+using System;
+using Unity.Netcode;
 using UnityEngine;
+using UnityEngine.Events;
 using UnityEngine.Serialization;
 
 [DisallowMultipleComponent]
-public sealed class MapController : MonoBehaviour
+[RequireComponent(typeof(NetworkObject))]
+public sealed class MapController : NetworkBehaviour
 {
     [Header("Main References")]
-    [SerializeField] private MapCrosshairController crosshair = null;
-    [SerializeField] private MapCoordinateSystem coordinateSystem = null;
-    [SerializeField] private MapPlayer mapPlayer = null;
+    [SerializeField] private MapCrosshairController crosshair;
+    [SerializeField] private MapCoordinateSystem coordinateSystem;
+    [SerializeField] private MapPlayer mapPlayer;
+    [SerializeField] private RoundGameLoopController roundGameLoop;
+    [SerializeField] private NetworkBaseHealth baseHealth;
 
     [Header("Target System")]
-    [SerializeField] private MapTargetController targetController = null;
-    [SerializeField] private Transform targetParent = null;
+    [SerializeField] private MapTargetController targetController;
+    [SerializeField] private Transform targetParent;
+    [SerializeField, Min(0.02f)] private float simulationStep = 0.1f;
 
     [Header("Radar System")]
-    [SerializeField] private MapRadarController radarController = null;
+    [SerializeField] private MapRadarController radarController;
     [FormerlySerializedAs("targetPrefab")]
-    [SerializeField] private MapTarget radarMarkPrefab = null;
+    [SerializeField] private MapTarget radarMarkPrefab;
 
     [Header("Crosshair Objects")]
-    [SerializeField] private Transform relayX = null;
-    [SerializeField] private Transform relayY = null;
-    [SerializeField] private Transform crosshairVisual = null;
+    [SerializeField] private Transform relayX;
+    [SerializeField] private Transform relayY;
+    [SerializeField] private Transform crosshairVisual;
 
-    [Header("Input")]
-    [SerializeField, Min(0f)] private float movementSpeed = 1f;
-    [SerializeField] private bool useKeyboardInput = true;
+    [Header("Pseudo Shot")]
+    [SerializeField, Min(0.01f)] private float hitRadius = 0.65f;
+    [SerializeField, Min(1)] private int shotDamage = 1;
+    [SerializeField] private MissileType pseudoMissileType = MissileType.Standard;
+    [SerializeField] private bool ignoreMissileTypeForPrototype = true;
+
+    [Header("Network Events")]
+    [SerializeField] private UnityEvent<int> waveStarted;
+    [SerializeField] private UnityEvent<bool> shotResolved;
+    [SerializeField] private UnityEvent allTargetsResolved;
+    [SerializeField] private UnityEvent allTargetsDestroyed;
+
+    private readonly NetworkVariable<Vector2> crosshairCoordinates = new(
+        new Vector2(5f, 5f), NetworkVariableReadPermission.Everyone,
+        NetworkVariableWritePermission.Server);
+    private readonly NetworkVariable<int> currentWave = new(
+        0, NetworkVariableReadPermission.Everyone,
+        NetworkVariableWritePermission.Server);
+    private readonly NetworkVariable<double> radarReadyAt = new(
+        0d, NetworkVariableReadPermission.Everyone,
+        NetworkVariableWritePermission.Server);
+    private readonly NetworkVariable<MapShotResultState> lastShotResult = new(
+        default, NetworkVariableReadPermission.Everyone,
+        NetworkVariableWritePermission.Server);
+    private readonly NetworkVariable<uint> resolvedSequence = new(
+        0, NetworkVariableReadPermission.Everyone,
+        NetworkVariableWritePermission.Server);
+    private readonly NetworkVariable<uint> destroyedSequence = new(
+        0, NetworkVariableReadPermission.Everyone,
+        NetworkVariableWritePermission.Server);
+
+    private readonly NetworkList<MapTargetNetworkState> activeTargets = new();
+    private readonly NetworkList<Vector2> radarMarks = new();
+
+    private float simulationAccumulator;
+    private int nextTargetId = 1;
+    private int initialTargetCount;
+    private int escapedTargetCount;
+    private bool waveIsActive;
+    private bool roundEventsBound;
 
     public MapCoordinateSystem CoordinateSystem => coordinateSystem;
     public Transform CrosshairVisual => crosshairVisual;
+    public Vector2 CrosshairCoordinates => crosshairCoordinates.Value;
+    public int CurrentWave => currentWave.Value;
+    public int ActiveTargetCount => activeTargets.Count;
+    public bool WaveIsActive => waveIsActive;
+    public double RadarCooldownRemaining => IsSpawned && NetworkManager != null
+        ? Math.Max(0d, radarReadyAt.Value - NetworkManager.ServerTime.Time)
+        : 0d;
 
-    private void Awake()
+    public event Action<int> WaveStarted;
+    public event Action<MapShotResultState> ShotResolved;
+    public event Action AllTargetsResolved;
+    public event Action AllTargetsDestroyed;
+
+    private void Awake() => ConfigurePresentation();
+
+    private void OnValidate()
     {
-        if (mapPlayer != null)
-            mapPlayer.Configure(coordinateSystem);
+        simulationStep = Mathf.Max(0.02f, simulationStep);
+        hitRadius = Mathf.Max(0.01f, hitRadius);
+        shotDamage = Mathf.Max(1, shotDamage);
+    }
 
-        if (targetController != null)
-            targetController.Configure(coordinateSystem, targetParent, mapPlayer);
+    public override void OnNetworkSpawn()
+    {
+        activeTargets.OnListChanged += HandleTargetListChanged;
+        radarMarks.OnListChanged += HandleRadarListChanged;
+        crosshairCoordinates.OnValueChanged += HandleCrosshairChanged;
+        currentWave.OnValueChanged += HandleWaveChanged;
+        radarReadyAt.OnValueChanged += HandleRadarReadyAtChanged;
+        lastShotResult.OnValueChanged += HandleShotResultChanged;
+        resolvedSequence.OnValueChanged += HandleResolvedSequenceChanged;
+        destroyedSequence.OnValueChanged += HandleDestroyedSequenceChanged;
 
+        ConfigurePresentation();
+        BindRoundEvents();
+        ApplyPresentation();
+
+        if (IsServer && roundGameLoop != null &&
+            roundGameLoop.Phase == RoundPhase.WorkInProgress && currentWave.Value == 0)
+            StartNextWaveOnServer();
+    }
+
+    public override void OnNetworkDespawn()
+    {
+        activeTargets.OnListChanged -= HandleTargetListChanged;
+        radarMarks.OnListChanged -= HandleRadarListChanged;
+        crosshairCoordinates.OnValueChanged -= HandleCrosshairChanged;
+        currentWave.OnValueChanged -= HandleWaveChanged;
+        radarReadyAt.OnValueChanged -= HandleRadarReadyAtChanged;
+        lastShotResult.OnValueChanged -= HandleShotResultChanged;
+        resolvedSequence.OnValueChanged -= HandleResolvedSequenceChanged;
+        destroyedSequence.OnValueChanged -= HandleDestroyedSequenceChanged;
+        UnbindRoundEvents();
+    }
+
+    private void OnDestroy()
+    {
+        activeTargets.Dispose();
+        radarMarks.Dispose();
+    }
+
+    private void Update()
+    {
+        if (!roundEventsBound)
+            BindRoundEvents();
         if (radarController != null)
-            radarController.Configure(coordinateSystem, targetController, radarMarkPrefab);
-
-        if (crosshair == null)
+            radarController.SetCooldownRemaining((float)RadarCooldownRemaining);
+        if (!IsServer || !IsSpawned || !waveIsActive)
             return;
 
-        crosshair.Configure(
-            coordinateSystem,
-            relayX,
-            relayY,
-            crosshairVisual,
-            movementSpeed,
-            useKeyboardInput,
-            targetController);
-
+        simulationAccumulator += Time.deltaTime;
+        while (simulationAccumulator >= simulationStep)
+        {
+            simulationAccumulator -= simulationStep;
+            SimulateTargets(simulationStep);
+        }
     }
 
-    public void SetHorizontalAxis(float value)
+    public void SetHorizontalNormalized(float value)
     {
-        if (crosshair != null)
-            crosshair.SetHorizontalAxis(value);
+        Vector2 next = crosshairCoordinates.Value;
+        next.x = Mathf.Clamp01(value) * MapCoordinateSystem.CoordinateMaximum;
+        RequestCrosshairCoordinates(next);
     }
 
-    public void SetVerticalAxis(float value)
+    public void SetVerticalNormalized(float value)
     {
-        if (crosshair != null)
-            crosshair.SetVerticalAxis(value);
+        Vector2 next = crosshairCoordinates.Value;
+        next.y = Mathf.Clamp01(value) * MapCoordinateSystem.CoordinateMaximum;
+        RequestCrosshairCoordinates(next);
     }
 
-    public Vector2 GetCrosshairCoordinates()
+    public void SetHorizontalAxis(float value) =>
+        SetHorizontalNormalized(Mathf.InverseLerp(-1f, 1f, value));
+    public void SetVerticalAxis(float value) =>
+        SetVerticalNormalized(Mathf.InverseLerp(-1f, 1f, value));
+    public Vector2 GetCrosshairCoordinates() => crosshairCoordinates.Value;
+
+    public void RequestPseudoFire()
     {
-        return crosshair != null ? crosshair.GetCrosshairCoordinates() : Vector2.zero;
+        if (!IsSpawned)
+            return;
+        if (IsServer)
+            ResolvePseudoShotOnServer();
+        else
+            RequestPseudoFireRpc();
     }
 
-    public void CreateAndPlaceTargets()
+    public void RequestRadarScan()
     {
-        if (targetController != null)
-            targetController.CreateAndPlaceTargets();
+        if (!IsSpawned)
+            return;
+        if (IsServer)
+            ScanRadarOnServer();
+        else
+            RequestRadarScanRpc();
     }
 
+    public bool ActivateRadar()
+    {
+        if (!IsSpawned || RadarCooldownRemaining > 0d)
+            return false;
+        RequestRadarScan();
+        return true;
+    }
+
+    public void CreateAndPlaceTargets() => StartNextWave();
+
     public bool StartNextWave()
     {
-        return targetController != null && targetController.StartNextWave();
+        if (!IsSpawned)
+            return false;
+        if (IsServer)
+            return StartNextWaveOnServer();
+        RequestStartNextWaveRpc();
+        return true;
     }
 
     public bool TryGetNearestTarget(out MapTarget target, out float distance)
     {
         if (crosshair != null)
             return crosshair.TryGetNearestTarget(out target, out distance);
-
         target = null;
         distance = -1f;
         return false;
     }
 
-    public bool ActivateRadar()
+    [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Everyone)]
+    private void SetCrosshairCoordinatesRpc(Vector2 coordinates) =>
+        SetCrosshairCoordinatesOnServer(coordinates);
+    [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Everyone)]
+    private void RequestPseudoFireRpc() => ResolvePseudoShotOnServer();
+    [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Everyone)]
+    private void RequestRadarScanRpc() => ScanRadarOnServer();
+    [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Everyone)]
+    private void RequestStartNextWaveRpc() => StartNextWaveOnServer();
+
+    private void RequestCrosshairCoordinates(Vector2 coordinates)
     {
-        return radarController != null && radarController.ActivateRadar();
+        if (!IsSpawned)
+            return;
+        if (IsServer)
+            SetCrosshairCoordinatesOnServer(coordinates);
+        else
+            SetCrosshairCoordinatesRpc(coordinates);
+    }
+
+    private void SetCrosshairCoordinatesOnServer(Vector2 coordinates)
+    {
+        if (!IsServer)
+            return;
+        crosshairCoordinates.Value = coordinateSystem != null
+            ? coordinateSystem.ClampCoordinates(coordinates)
+            : new Vector2(
+                Mathf.Clamp(coordinates.x, 0f, MapCoordinateSystem.CoordinateMaximum),
+                Mathf.Clamp(coordinates.y, 0f, MapCoordinateSystem.CoordinateMaximum));
+    }
+
+    private bool StartNextWaveOnServer()
+    {
+        if (!IsServer || targetController == null ||
+            !targetController.HasValidConfiguration())
+        {
+            Debug.LogWarning("[Map] Cannot start target wave: map or target configs are incomplete.", this);
+            return false;
+        }
+
+        activeTargets.Clear();
+        radarMarks.Clear();
+        currentWave.Value++;
+        escapedTargetCount = 0;
+        initialTargetCount = 0;
+        waveIsActive = true;
+        simulationAccumulator = 0f;
+
+        for (int index = 0; index < targetController.TargetsPerWave; index++)
+        {
+            int configIndex = targetController.GetRandomValidConfigIndex();
+            TargetConfig config = targetController.GetConfig(configIndex);
+            if (config == null)
+                continue;
+
+            Vector2 coordinates = new(
+                UnityEngine.Random.Range(0f, MapCoordinateSystem.CoordinateMaximum),
+                UnityEngine.Random.Range(0f, MapCoordinateSystem.CoordinateMaximum));
+            activeTargets.Add(new MapTargetNetworkState(
+                nextTargetId++, configIndex, coordinates,
+                config.Health, config.TimeBeforeAttack));
+            initialTargetCount++;
+        }
+
+        Debug.Log($"[Map] Wave {currentWave.Value} started with {initialTargetCount} targets.", this);
+        if (initialTargetCount == 0)
+            CompleteWaveOnServer();
+        return true;
+    }
+
+    private void SimulateTargets(float deltaTime)
+    {
+        for (int index = activeTargets.Count - 1; index >= 0; index--)
+        {
+            MapTargetNetworkState state = activeTargets[index];
+            TargetConfig config = targetController.GetConfig(state.ConfigIndex);
+            if (config == null)
+            {
+                ResolveEscapedTarget(index, state, null);
+                continue;
+            }
+
+            bool isAirTarget = config.TargetPrefab is AirTarget;
+            if (isAirTarget && mapPlayer != null && config.MovementSpeed > 0f)
+            {
+                Vector2 destination = mapPlayer.MapCoordinates;
+                state.Coordinates = Vector2.MoveTowards(
+                    state.Coordinates, destination, config.MovementSpeed * deltaTime);
+                if (Vector2.Distance(state.Coordinates, destination) <= config.StoppingDistance)
+                {
+                    ResolveEscapedTarget(index, state, config);
+                    continue;
+                }
+            }
+            else
+            {
+                state.AttackTimeRemaining = Mathf.Max(
+                    0f, state.AttackTimeRemaining - deltaTime);
+                if (state.AttackTimeRemaining <= 0f)
+                {
+                    ResolveEscapedTarget(index, state, config);
+                    continue;
+                }
+            }
+
+            activeTargets[index] = state;
+        }
+
+        TryCompleteWaveOnServer();
+    }
+
+    private void ResolveEscapedTarget(int index, MapTargetNetworkState target, TargetConfig config)
+    {
+        int damage = config != null ? config.BaseDamage : 1;
+        escapedTargetCount++;
+        activeTargets.RemoveAt(index);
+        if (baseHealth != null)
+            baseHealth.ApplyDamage(damage);
+        Debug.Log($"[Map] Target {target.TargetId} reached the base. Base damage: {damage}.", this);
+    }
+
+    private void ResolvePseudoShotOnServer()
+    {
+        if (!IsServer || !waveIsActive)
+        {
+            PublishShotResult(false, -1, -1f);
+            return;
+        }
+
+        int nearestIndex = -1;
+        float nearestDistance = float.PositiveInfinity;
+        for (int index = 0; index < activeTargets.Count; index++)
+        {
+            float distance = Vector2.Distance(
+                crosshairCoordinates.Value, activeTargets[index].Coordinates);
+            if (distance >= nearestDistance)
+                continue;
+            nearestDistance = distance;
+            nearestIndex = index;
+        }
+
+        if (nearestIndex >= 0 && nearestDistance <= hitRadius)
+        {
+            MapTargetNetworkState target = activeTargets[nearestIndex];
+            TargetConfig config = targetController.GetConfig(target.ConfigIndex);
+            bool missileMatches = ignoreMissileTypeForPrototype || config == null ||
+                config.RequiredMissileType == MissileType.None ||
+                config.RequiredMissileType == pseudoMissileType;
+            if (missileMatches)
+            {
+                target.Health -= shotDamage;
+                if (target.Health <= 0)
+                    activeTargets.RemoveAt(nearestIndex);
+                else
+                    activeTargets[nearestIndex] = target;
+
+                PublishShotResult(true, target.TargetId, nearestDistance);
+                Debug.Log($"[Map] HIT target {target.TargetId} at {nearestDistance:0.00} map units.", this);
+                TryCompleteWaveOnServer();
+                return;
+            }
+        }
+
+        int missedTargetId = nearestIndex >= 0 ? activeTargets[nearestIndex].TargetId : -1;
+        PublishShotResult(false, missedTargetId, nearestDistance);
+        float printedDistance = float.IsPositiveInfinity(nearestDistance) ? -1f : nearestDistance;
+        Debug.Log($"[Map] MISS at {crosshairCoordinates.Value}. Nearest distance: {printedDistance:0.00}.", this);
+    }
+
+    private void PublishShotResult(bool hit, int targetId, float distance)
+    {
+        lastShotResult.Value = new MapShotResultState(
+            lastShotResult.Value.Sequence + 1, hit, targetId,
+            crosshairCoordinates.Value,
+            float.IsPositiveInfinity(distance) ? -1f : distance);
+    }
+
+    private void ScanRadarOnServer()
+    {
+        if (!IsServer || radarController == null || NetworkManager == null ||
+            NetworkManager.ServerTime.Time < radarReadyAt.Value)
+            return;
+
+        radarMarks.Clear();
+        foreach (MapTargetNetworkState target in activeTargets)
+            radarMarks.Add(target.Coordinates);
+        radarReadyAt.Value = NetworkManager.ServerTime.Time + radarController.Cooldown;
+        Debug.Log($"[Map] Radar scan found {radarMarks.Count} targets.", this);
+    }
+
+    private void TryCompleteWaveOnServer()
+    {
+        if (waveIsActive && activeTargets.Count == 0)
+            CompleteWaveOnServer();
+    }
+
+    private void CompleteWaveOnServer()
+    {
+        waveIsActive = false;
+        resolvedSequence.Value++;
+        if (initialTargetCount > 0 && escapedTargetCount == 0)
+            destroyedSequence.Value++;
+        Debug.Log(
+            $"[Map] Wave {currentWave.Value} resolved. " +
+            $"Destroyed: {Mathf.Max(0, initialTargetCount - escapedTargetCount)}, " +
+            $"escaped: {escapedTargetCount}.", this);
+    }
+
+    private void ConfigurePresentation()
+    {
+        mapPlayer?.Configure(coordinateSystem);
+        targetController?.Configure(coordinateSystem, targetParent, mapPlayer);
+        radarController?.Configure(coordinateSystem, radarMarkPrefab);
+        crosshair?.Configure(
+            coordinateSystem, relayX, relayY, crosshairVisual, targetController);
+    }
+
+    private void ApplyPresentation()
+    {
+        crosshair?.SetCoordinates(crosshairCoordinates.Value);
+        targetController?.ApplyNetworkTargets(CreateTargetSnapshot(), currentWave.Value);
+        radarController?.ApplyRadarMarks(CreateRadarSnapshot());
+        if (radarController != null)
+            radarController.SetCooldownRemaining((float)RadarCooldownRemaining);
+    }
+
+    private void BindRoundEvents()
+    {
+        if (roundEventsBound)
+            return;
+        if (roundGameLoop == null)
+            roundGameLoop = FindFirstObjectByType<RoundGameLoopController>();
+        if (roundGameLoop == null || !roundGameLoop.IsSpawned)
+            return;
+        roundGameLoop.PhaseChanged += HandleRoundPhaseChanged;
+        roundEventsBound = true;
+    }
+
+    private void UnbindRoundEvents()
+    {
+        if (!roundEventsBound || roundGameLoop == null)
+            return;
+        roundGameLoop.PhaseChanged -= HandleRoundPhaseChanged;
+        roundEventsBound = false;
+    }
+
+    private void HandleRoundPhaseChanged(RoundPhase phase)
+    {
+        if (IsServer && phase == RoundPhase.WorkInProgress && !waveIsActive)
+            StartNextWaveOnServer();
+    }
+
+    private void HandleTargetListChanged(NetworkListEvent<MapTargetNetworkState> _) =>
+        targetController?.ApplyNetworkTargets(CreateTargetSnapshot(), currentWave.Value);
+    private void HandleRadarListChanged(NetworkListEvent<Vector2> _) =>
+        radarController?.ApplyRadarMarks(CreateRadarSnapshot());
+    private void HandleCrosshairChanged(Vector2 _, Vector2 current) =>
+        crosshair?.SetCoordinates(current);
+
+    private void HandleWaveChanged(int _, int current)
+    {
+        targetController?.ApplyNetworkTargets(CreateTargetSnapshot(), current);
+        WaveStarted?.Invoke(current);
+        waveStarted?.Invoke(current);
+    }
+
+    private void HandleRadarReadyAtChanged(double _, double __)
+    {
+        if (radarController != null)
+            radarController.SetCooldownRemaining((float)RadarCooldownRemaining);
+    }
+
+    private void HandleShotResultChanged(MapShotResultState previous, MapShotResultState current)
+    {
+        if (current.Sequence == 0 || current.Sequence == previous.Sequence)
+            return;
+        ShotResolved?.Invoke(current);
+        shotResolved?.Invoke(current.Hit);
+    }
+
+    private void HandleResolvedSequenceChanged(uint previous, uint current)
+    {
+        if (current == previous)
+            return;
+        AllTargetsResolved?.Invoke();
+        allTargetsResolved?.Invoke();
+    }
+
+    private void HandleDestroyedSequenceChanged(uint previous, uint current)
+    {
+        if (current == previous)
+            return;
+        AllTargetsDestroyed?.Invoke();
+        allTargetsDestroyed?.Invoke();
+    }
+
+    private MapTargetNetworkState[] CreateTargetSnapshot()
+    {
+        MapTargetNetworkState[] snapshot = new MapTargetNetworkState[activeTargets.Count];
+        for (int index = 0; index < snapshot.Length; index++)
+            snapshot[index] = activeTargets[index];
+        return snapshot;
+    }
+
+    private Vector2[] CreateRadarSnapshot()
+    {
+        Vector2[] snapshot = new Vector2[radarMarks.Count];
+        for (int index = 0; index < snapshot.Length; index++)
+            snapshot[index] = radarMarks[index];
+        return snapshot;
     }
 }
diff --git a/Assets/CONTENT/FEATURES/MapRadar/MapCrosshairController.cs b/Assets/CONTENT/FEATURES/MapRadar/MapCrosshairController.cs
index 46cc2af..fd2c815 100644
--- a/Assets/CONTENT/FEATURES/MapRadar/MapCrosshairController.cs
+++ b/Assets/CONTENT/FEATURES/MapRadar/MapCrosshairController.cs
@@ -1,11 +1,10 @@
 using UnityEngine;
-using UnityEngine.InputSystem;
 
 [DisallowMultipleComponent]
 public sealed class MapCrosshairController : MonoBehaviour
 {
     [Header("Nearest Target (Runtime)")]
-    [SerializeField] private MapTarget nearestTarget = null;
+    [SerializeField] private MapTarget nearestTarget;
     [SerializeField] private float distanceToNearestTarget = -1f;
 
     private MapCoordinateSystem coordinateSystem;
@@ -13,79 +12,42 @@ public sealed class MapCrosshairController : MonoBehaviour
     private Transform relayX;
     private Transform relayY;
     private Transform crosshairVisual;
-    private float movementSpeed;
-    private bool useKeyboardInput;
-    private float horizontalAxis;
-    private float verticalAxis;
     private Vector2 crosshairCoordinates;
     private Vector3 relayXOffset;
     private Vector3 relayYOffset;
     private bool isConfigured;
 
     public MapCoordinateSystem CoordinateSystem => coordinateSystem;
+    public Vector2 Coordinates => crosshairCoordinates;
 
     public void Configure(
         MapCoordinateSystem newCoordinateSystem,
         Transform newRelayX,
         Transform newRelayY,
         Transform newCrosshairVisual,
-        float newMovementSpeed,
-        bool enableKeyboardInput,
         MapTargetController newTargetController)
     {
         coordinateSystem = newCoordinateSystem;
         relayX = newRelayX;
         relayY = newRelayY;
         crosshairVisual = newCrosshairVisual;
-        movementSpeed = Mathf.Max(0f, newMovementSpeed);
-        useKeyboardInput = enableKeyboardInput;
         targetController = newTargetController;
-        crosshairCoordinates = Vector2.zero;
         isConfigured = CalibrateObjects();
-
-        if (isConfigured)
-            ApplyCoordinates();
     }
 
-    private void Update()
+    public void SetCoordinates(Vector2 coordinates)
     {
         if (!isConfigured)
             return;
 
-        if (useKeyboardInput)
-            ReadKeyboardInput();
-
-        Vector2 movement = new(horizontalAxis, verticalAxis);
-        crosshairCoordinates += movement * (movementSpeed * Time.deltaTime);
-        crosshairCoordinates = coordinateSystem.ClampCoordinates(crosshairCoordinates);
+        crosshairCoordinates = coordinateSystem.ClampCoordinates(coordinates);
         ApplyCoordinates();
         UpdateNearestTarget();
     }
 
-    public void SetHorizontalAxis(float value)
-    {
-        horizontalAxis = Mathf.Clamp(value, -1f, 1f);
-    }
-
-    public void SetVerticalAxis(float value)
-    {
-        verticalAxis = Mathf.Clamp(value, -1f, 1f);
-    }
-
-    public Vector2 GetCrosshairCoordinates()
-    {
-        return crosshairCoordinates;
-    }
-
-    public MapTarget GetNearestTarget()
-    {
-        return nearestTarget;
-    }
-
-    public float GetDistanceToNearestTarget()
-    {
-        return distanceToNearestTarget;
-    }
+    public Vector2 GetCrosshairCoordinates() => crosshairCoordinates;
+    public MapTarget GetNearestTarget() => nearestTarget;
+    public float GetDistanceToNearestTarget() => distanceToNearestTarget;
 
     public bool TryGetNearestTarget(out MapTarget target, out float distance)
     {
@@ -94,62 +56,49 @@ public sealed class MapCrosshairController : MonoBehaviour
         return target != null;
     }
 
-    private void ReadKeyboardInput()
-    {
-        Keyboard keyboard = Keyboard.current;
-        if (keyboard == null)
-        {
-            SetHorizontalAxis(0f);
-            SetVerticalAxis(0f);
-            return;
-        }
-
-        SetHorizontalAxis(
-            (keyboard.lKey.isPressed ? 1f : 0f) - (keyboard.jKey.isPressed ? 1f : 0f));
-        SetVerticalAxis(
-            (keyboard.iKey.isPressed ? 1f : 0f) - (keyboard.kKey.isPressed ? 1f : 0f));
-    }
-
     private void ApplyCoordinates()
     {
-        Vector3 targetWorldPosition = coordinateSystem.CoordinatesToWorldPosition(crosshairCoordinates);
-        crosshairVisual.position = targetWorldPosition;
+        crosshairVisual.position =
+            coordinateSystem.CoordinatesToWorldPosition(crosshairCoordinates);
 
         if (relayX != null)
+        {
             relayX.position = coordinateSystem.CoordinatesToWorldPosition(
                 new Vector2(crosshairCoordinates.x, 0f)) + relayXOffset;
+        }
 
         if (relayY != null)
+        {
             relayY.position = coordinateSystem.CoordinatesToWorldPosition(
                 new Vector2(0f, crosshairCoordinates.y)) + relayYOffset;
+        }
     }
 
     private bool CalibrateObjects()
     {
-        if (coordinateSystem == null || crosshairVisual == null || !coordinateSystem.HasValidCorners())
+        if (coordinateSystem == null || crosshairVisual == null ||
+            !coordinateSystem.HasValidCorners())
+        {
             return false;
+        }
 
         Vector3 origin = coordinateSystem.CoordinatesToWorldPosition(Vector2.zero);
-        Vector3 horizontalDirection =
-            coordinateSystem.CoordinatesToWorldPosition(new Vector2(MapCoordinateSystem.CoordinateMaximum, 0f)) -
-            origin;
-        Vector3 verticalDirection =
-            coordinateSystem.CoordinatesToWorldPosition(new Vector2(0f, MapCoordinateSystem.CoordinateMaximum)) -
-            origin;
-
+        Vector3 horizontalDirection = coordinateSystem.CoordinatesToWorldPosition(
+            new Vector2(MapCoordinateSystem.CoordinateMaximum, 0f)) - origin;
+        Vector3 verticalDirection = coordinateSystem.CoordinatesToWorldPosition(
+            new Vector2(0f, MapCoordinateSystem.CoordinateMaximum)) - origin;
         if (horizontalDirection.sqrMagnitude <= Mathf.Epsilon ||
             verticalDirection.sqrMagnitude <= Mathf.Epsilon)
+        {
             return false;
+        }
 
         horizontalDirection.Normalize();
         verticalDirection.Normalize();
-
         if (relayX != null)
             relayXOffset = Vector3.ProjectOnPlane(relayX.position - origin, horizontalDirection);
-
         if (relayY != null)
             relayYOffset = Vector3.ProjectOnPlane(relayY.position - origin, verticalDirection);
-
         return true;
     }
 
@@ -157,7 +106,6 @@ public sealed class MapCrosshairController : MonoBehaviour
     {
         nearestTarget = null;
         distanceToNearestTarget = -1f;
-
         if (targetController == null)
             return;
 
diff --git a/Assets/CONTENT/FEATURES/MapRadar/MapRadarController.cs b/Assets/CONTENT/FEATURES/MapRadar/MapRadarController.cs
index 4ba31b1..4e37c32 100644
--- a/Assets/CONTENT/FEATURES/MapRadar/MapRadarController.cs
+++ b/Assets/CONTENT/FEATURES/MapRadar/MapRadarController.cs
@@ -1,90 +1,56 @@
 using System.Collections.Generic;
 using UnityEngine;
-using UnityEngine.InputSystem;
 
 [DisallowMultipleComponent]
 public sealed class MapRadarController : MonoBehaviour
 {
     [Header("Radar Settings")]
     [SerializeField, Min(0f)] private float cooldown = 5f;
-    [SerializeField] private bool useKeyboardInput = true;
 
     [Header("Radar State (Runtime)")]
     [SerializeField] private float cooldownRemaining;
 
     private readonly List<GameObject> radarMarks = new();
     private MapCoordinateSystem coordinateSystem;
-    private MapTargetController targetController;
     private MapTarget radarMarkPrefab;
-    private float nextActivationTime;
-    private bool isConfigured;
 
+    public float Cooldown => Mathf.Max(0f, cooldown);
     public float CooldownRemaining => cooldownRemaining;
     public bool IsReady => cooldownRemaining <= 0f;
 
-    private void OnValidate()
-    {
-        cooldown = Mathf.Max(0f, cooldown);
-    }
+    private void OnValidate() => cooldown = Mathf.Max(0f, cooldown);
 
     public void Configure(
         MapCoordinateSystem newCoordinateSystem,
-        MapTargetController newTargetController,
         MapTarget newRadarMarkPrefab)
     {
         coordinateSystem = newCoordinateSystem;
-        targetController = newTargetController;
         radarMarkPrefab = newRadarMarkPrefab;
-        isConfigured = coordinateSystem != null &&
-                       coordinateSystem.HasValidCorners() &&
-                       targetController != null &&
-                       radarMarkPrefab != null;
-
-        if (targetController != null)
-            targetController.SetTargetVisualsVisible(false);
     }
 
-    private void Update()
-    {
-        cooldownRemaining = Mathf.Max(0f, nextActivationTime - Time.time);
+    public void SetCooldownRemaining(float seconds) =>
+        cooldownRemaining = Mathf.Max(0f, seconds);
 
-        if (!useKeyboardInput)
+    public void ApplyRadarMarks(IReadOnlyList<Vector2> coordinates)
+    {
+        if (coordinateSystem == null || !coordinateSystem.HasValidCorners() ||
+            radarMarkPrefab == null)
+        {
             return;
+        }
 
-        Keyboard keyboard = Keyboard.current;
-        if (keyboard != null && keyboard.oKey.wasPressedThisFrame)
-            ActivateRadar();
-    }
-
-    public bool ActivateRadar()
-    {
-        if (!isConfigured || Time.time < nextActivationTime)
-            return false;
-
-        PlaceRadarMarks();
-        nextActivationTime = Time.time + Mathf.Max(0f, cooldown);
-        cooldownRemaining = Mathf.Max(0f, nextActivationTime - Time.time);
-        return true;
-    }
-
-    private void PlaceRadarMarks()
-    {
-        int targetCount = targetController.Targets.Count;
-        EnsureRadarMarkCount(targetCount);
-
+        EnsureRadarMarkCount(coordinates.Count);
         for (int index = 0; index < radarMarks.Count; index++)
         {
-            bool hasTarget = index < targetCount && targetController.Targets[index] != null;
+            bool active = index < coordinates.Count;
             GameObject radarMark = radarMarks[index];
-            radarMark.SetActive(hasTarget);
-
-            if (!hasTarget)
-                continue;
-
-            MapTarget target = targetController.Targets[index];
-            radarMark.name = $"Radar Mark - {target.name}";
-            radarMark.transform.position =
-                coordinateSystem.CoordinatesToWorldPosition(target.MapCoordinates);
+            radarMark.SetActive(active);
+            if (active)
+            {
+                radarMark.name = $"Radar Mark {index + 1}";
+                radarMark.transform.position =
+                    coordinateSystem.CoordinatesToWorldPosition(coordinates[index]);
+            }
         }
     }
 
@@ -100,9 +66,9 @@ public sealed class MapRadarController : MonoBehaviour
 
     private static void PrepareRadarMark(GameObject radarMark)
     {
-        MapTarget targetMovement = radarMark.GetComponent<MapTarget>();
-        if (targetMovement != null)
-            targetMovement.enabled = false;
+        MapTarget target = radarMark.GetComponent<MapTarget>();
+        if (target != null)
+            target.enabled = false;
 
         foreach (Collider targetCollider in radarMark.GetComponentsInChildren<Collider>(true))
             targetCollider.enabled = false;
diff --git a/Assets/CONTENT/FEATURES/MapRadar/MapTarget.cs b/Assets/CONTENT/FEATURES/MapRadar/MapTarget.cs
index 0229fce..1cce680 100644
--- a/Assets/CONTENT/FEATURES/MapRadar/MapTarget.cs
+++ b/Assets/CONTENT/FEATURES/MapRadar/MapTarget.cs
@@ -1,4 +1,3 @@
-using System;
 using UnityEngine;
 
 [DisallowMultipleComponent]
@@ -6,17 +5,18 @@ public class MapTarget : MonoBehaviour
 {
     [Header("Target State (Runtime)")]
     [SerializeField] private TargetConfig config;
+    [SerializeField] private int targetId = -1;
     [SerializeField] private float timeUntilAttack;
     [SerializeField] private Vector2 mapCoordinates;
     [SerializeField] private int currentHealth;
     [SerializeField] private MissileType requiredMissileType;
-    [SerializeField] private bool isReadyToAttack;
 
     private MapCoordinateSystem coordinateSystem;
     private MapPlayer player;
-    private bool isConfigured;
     private Renderer[] targetRenderers;
+    private Collider[] targetColliders;
 
+    public int TargetId => targetId;
     public Vector2 MapCoordinates => mapCoordinates;
     public MapCoordinateSystem CoordinateSystem => coordinateSystem;
     public TargetConfig Config => config;
@@ -24,34 +24,26 @@ public class MapTarget : MonoBehaviour
     public float TimeUntilAttack => timeUntilAttack;
     public int CurrentHealth => currentHealth;
     public MissileType RequiredMissileType => requiredMissileType;
-    public bool IsReadyToAttack => isReadyToAttack;
-
-    public event Action<MapTarget> AttackReady;
 
     public void Configure(
         TargetConfig newConfig,
         MapCoordinateSystem newCoordinateSystem,
-        Vector2 startCoordinates,
         MapPlayer newPlayer)
     {
         config = newConfig;
         coordinateSystem = newCoordinateSystem;
         player = newPlayer;
-        timeUntilAttack = config != null ? config.TimeBeforeAttack : 0f;
-        currentHealth = config != null ? config.Health : 1;
-        requiredMissileType = config != null ? config.RequiredMissileType : MissileType.None;
-        isReadyToAttack = false;
-        isConfigured = coordinateSystem != null && coordinateSystem.HasValidCorners();
-        SetMapCoordinates(startCoordinates);
     }
 
-    protected virtual void Update()
+    public void ApplyNetworkState(MapTargetNetworkState state)
     {
-        if (!isConfigured)
-            return;
-
-        TickAttackTimer(Time.deltaTime);
-        TickMovement(Time.deltaTime);
+        targetId = state.TargetId;
+        timeUntilAttack = state.AttackTimeRemaining;
+        currentHealth = state.Health;
+        requiredMissileType = config != null
+            ? config.RequiredMissileType
+            : MissileType.None;
+        SetMapCoordinates(state.Coordinates);
     }
 
     public void SetMapCoordinates(Vector2 coordinates)
@@ -62,41 +54,34 @@ public class MapTarget : MonoBehaviour
                 Mathf.Clamp(coordinates.x, 0f, MapCoordinateSystem.CoordinateMaximum),
                 Mathf.Clamp(coordinates.y, 0f, MapCoordinateSystem.CoordinateMaximum));
 
-        if (isConfigured)
+        if (coordinateSystem != null && coordinateSystem.HasValidCorners())
             transform.position = coordinateSystem.CoordinatesToWorldPosition(mapCoordinates);
     }
 
-    public Vector2 GetMapCoordinates()
-    {
-        return mapCoordinates;
-    }
+    public Vector2 GetMapCoordinates() => mapCoordinates;
 
     public void SetVisualsVisible(bool isVisible)
     {
         if (targetRenderers == null)
             targetRenderers = GetComponentsInChildren<Renderer>(true);
+        if (targetColliders == null)
+            targetColliders = GetComponentsInChildren<Collider>(true);
 
         foreach (Renderer targetRenderer in targetRenderers)
         {
             if (targetRenderer != null)
                 targetRenderer.enabled = isVisible;
         }
+
+        // Map targets are presentation objects, never physical world objects.
+        foreach (Collider targetCollider in targetColliders)
+        {
+            if (targetCollider != null)
+                targetCollider.enabled = false;
+        }
     }
 
     protected virtual void TickMovement(float deltaTime)
     {
     }
-
-    private void TickAttackTimer(float deltaTime)
-    {
-        if (isReadyToAttack)
-            return;
-
-        timeUntilAttack = Mathf.Max(0f, timeUntilAttack - deltaTime);
-        if (timeUntilAttack > 0f)
-            return;
-
-        isReadyToAttack = true;
-        AttackReady?.Invoke(this);
-    }
 }
diff --git a/Assets/CONTENT/FEATURES/MapRadar/MapTargetController.cs b/Assets/CONTENT/FEATURES/MapRadar/MapTargetController.cs
index d5d4a68..d59e747 100644
--- a/Assets/CONTENT/FEATURES/MapRadar/MapTargetController.cs
+++ b/Assets/CONTENT/FEATURES/MapRadar/MapTargetController.cs
@@ -1,33 +1,31 @@
+using System;
 using System.Collections.Generic;
 using UnityEngine;
 
 [DisallowMultipleComponent]
 public sealed class MapTargetController : MonoBehaviour
 {
-    [Header("Random Wave Settings")]
+    [Header("Wave Settings")]
     [SerializeField, Min(0)] private int targetsPerWave = 5;
-    [SerializeField] private TargetConfig[] randomTargetConfigs = System.Array.Empty<TargetConfig>();
+    [SerializeField] private TargetConfig[] randomTargetConfigs = Array.Empty<TargetConfig>();
+    [SerializeField] private bool showLiveTargetVisuals;
 
     [Header("Current Wave (Runtime)")]
     [SerializeField, Min(0)] private int currentWave;
     [SerializeField] private List<MapTarget> currentWaveTargets = new();
 
     private readonly List<MapTarget> pooledTargets = new();
+    private readonly Dictionary<int, MapTarget> targetsById = new();
+    private readonly HashSet<int> synchronizedTargetIds = new();
     private MapCoordinateSystem coordinateSystem;
     private Transform targetParent;
     private MapPlayer player;
-    private bool isConfigured;
 
     public IReadOnlyList<MapTarget> Targets => currentWaveTargets;
+    public IReadOnlyList<TargetConfig> TargetConfigs => randomTargetConfigs;
     public int CurrentWave => currentWave;
     public int TargetsPerWave => targetsPerWave;
 
-    private void Start()
-    {
-        if (currentWave == 0)
-            StartNextWave();
-    }
-
     private void OnValidate()
     {
         targetsPerWave = Mathf.Max(0, targetsPerWave);
@@ -42,9 +40,10 @@ public sealed class MapTargetController : MonoBehaviour
         coordinateSystem = newCoordinateSystem;
         targetParent = newTargetParent != null ? newTargetParent : transform;
         player = newPlayer;
-        isConfigured = coordinateSystem != null && coordinateSystem.HasValidCorners();
 
         pooledTargets.Clear();
+        targetsById.Clear();
+        currentWaveTargets.Clear();
         foreach (MapTarget existingTarget in targetParent.GetComponentsInChildren<MapTarget>(true))
         {
             existingTarget.SetVisualsVisible(false);
@@ -53,44 +52,78 @@ public sealed class MapTargetController : MonoBehaviour
         }
     }
 
-    public bool StartNextWave()
+    public void ApplyNetworkTargets(
+        IReadOnlyList<MapTargetNetworkState> states,
+        int wave)
     {
-        if (!isConfigured || !HasValidTargetConfig())
+        currentWave = Mathf.Max(0, wave);
+        synchronizedTargetIds.Clear();
+
+        for (int index = 0; index < states.Count; index++)
         {
-            Debug.LogWarning("Target controller has no coordinate system or valid TargetConfig.", this);
-            return false;
-        }
+            MapTargetNetworkState state = states[index];
+            TargetConfig config = GetConfig(state.ConfigIndex);
+            if (config == null || config.TargetPrefab == null)
+                continue;
 
-        RetireCurrentWave();
-        currentWave++;
+            synchronizedTargetIds.Add(state.TargetId);
+            if (!targetsById.TryGetValue(state.TargetId, out MapTarget target) || target == null)
+            {
+                target = GetPooledTarget(config);
+                if (target == null)
+                    target = Instantiate(config.TargetPrefab, targetParent);
 
-        for (int index = 0; index < targetsPerWave; index++)
-        {
-            TargetConfig config = GetRandomValidConfig();
-            if (config == null)
-                break;
+                targetsById[state.TargetId] = target;
+                currentWaveTargets.Add(target);
+            }
 
-            MapTarget target = GetPooledTarget(config);
-            if (target == null)
-                target = Instantiate(config.TargetPrefab, targetParent);
-
-            target.name = $"Wave {currentWave} - {config.name} - {index + 1}";
-            target.Configure(config, coordinateSystem, GetRandomCoordinates(), player);
-            target.SetVisualsVisible(false);
+            target.name = $"Wave {currentWave} - {config.name} - {state.TargetId}";
+            target.Configure(config, coordinateSystem, player);
+            target.ApplyNetworkState(state);
+            target.SetVisualsVisible(showLiveTargetVisuals);
             target.gameObject.SetActive(true);
-            currentWaveTargets.Add(target);
         }
 
-        return currentWaveTargets.Count > 0 || targetsPerWave == 0;
+        for (int index = currentWaveTargets.Count - 1; index >= 0; index--)
+        {
+            MapTarget target = currentWaveTargets[index];
+            if (target != null && synchronizedTargetIds.Contains(target.TargetId))
+                continue;
+
+            RetireTarget(target);
+            currentWaveTargets.RemoveAt(index);
+        }
     }
 
-    public void CreateAndPlaceTargets()
+    public TargetConfig GetConfig(int index) =>
+        index >= 0 && index < randomTargetConfigs.Length
+            ? randomTargetConfigs[index]
+            : null;
+
+    public int GetRandomValidConfigIndex()
     {
-        StartNextWave();
+        if (randomTargetConfigs == null || randomTargetConfigs.Length == 0)
+            return -1;
+
+        int startIndex = UnityEngine.Random.Range(0, randomTargetConfigs.Length);
+        for (int offset = 0; offset < randomTargetConfigs.Length; offset++)
+        {
+            int index = (startIndex + offset) % randomTargetConfigs.Length;
+            TargetConfig config = randomTargetConfigs[index];
+            if (config != null && config.TargetPrefab != null)
+                return index;
+        }
+
+        return -1;
     }
 
+    public bool HasValidConfiguration() =>
+        coordinateSystem != null && coordinateSystem.HasValidCorners() &&
+        GetRandomValidConfigIndex() >= 0;
+
     public void SetTargetVisualsVisible(bool isVisible)
     {
+        showLiveTargetVisuals = isVisible;
         foreach (MapTarget target in currentWaveTargets)
         {
             if (target != null)
@@ -98,28 +131,15 @@ public sealed class MapTargetController : MonoBehaviour
         }
     }
 
-    public MapTarget GetTarget(int index)
-    {
-        return index >= 0 && index < currentWaveTargets.Count
+    public MapTarget GetTarget(int index) =>
+        index >= 0 && index < currentWaveTargets.Count
             ? currentWaveTargets[index]
             : null;
-    }
 
-    private void RetireCurrentWave()
+    public bool StartNextWave()
     {
-        foreach (MapTarget target in currentWaveTargets)
-        {
-            if (target == null)
-                continue;
-
-            target.SetVisualsVisible(false);
-            target.gameObject.SetActive(false);
-
-            if (!pooledTargets.Contains(target))
-                pooledTargets.Add(target);
-        }
-
-        currentWaveTargets.Clear();
+        MapController mapController = FindFirstObjectByType<MapController>();
+        return mapController != null && mapController.StartNextWave();
     }
 
     private MapTarget GetPooledTarget(TargetConfig config)
@@ -143,30 +163,15 @@ public sealed class MapTargetController : MonoBehaviour
         return null;
     }
 
-    private bool HasValidTargetConfig()
+    private void RetireTarget(MapTarget target)
     {
-        return GetRandomValidConfig() != null;
-    }
+        if (target == null)
+            return;
 
-    private TargetConfig GetRandomValidConfig()
-    {
-        if (randomTargetConfigs == null || randomTargetConfigs.Length == 0)
-            return null;
-
-        int startIndex = Random.Range(0, randomTargetConfigs.Length);
-        for (int offset = 0; offset < randomTargetConfigs.Length; offset++)
-        {
-            TargetConfig config = randomTargetConfigs[(startIndex + offset) % randomTargetConfigs.Length];
-            if (config != null && config.TargetPrefab != null)
-                return config;
-        }
-
-        return null;
-    }
-
-    private static Vector2 GetRandomCoordinates()
-    {
-        float maximum = MapCoordinateSystem.CoordinateMaximum;
-        return new Vector2(Random.Range(0f, maximum), Random.Range(0f, maximum));
+        targetsById.Remove(target.TargetId);
+        target.SetVisualsVisible(false);
+        target.gameObject.SetActive(false);
+        if (!pooledTargets.Contains(target))
+            pooledTargets.Add(target);
     }
 }
diff --git a/Assets/CONTENT/FEATURES/MapRadar/MapTargetNetworkState.cs b/Assets/CONTENT/FEATURES/MapRadar/MapTargetNetworkState.cs
new file mode 100644
index 0000000..879d612
--- /dev/null
+++ b/Assets/CONTENT/FEATURES/MapRadar/MapTargetNetworkState.cs
@@ -0,0 +1,83 @@
+using System;
+using Unity.Netcode;
+using UnityEngine;
+
+public struct MapTargetNetworkState : INetworkSerializable,
+    IEquatable<MapTargetNetworkState>
+{
+    public int TargetId;
+    public int ConfigIndex;
+    public Vector2 Coordinates;
+    public int Health;
+    public float AttackTimeRemaining;
+
+    public MapTargetNetworkState(
+        int targetId,
+        int configIndex,
+        Vector2 coordinates,
+        int health,
+        float attackTimeRemaining)
+    {
+        TargetId = targetId;
+        ConfigIndex = configIndex;
+        Coordinates = coordinates;
+        Health = health;
+        AttackTimeRemaining = attackTimeRemaining;
+    }
+
+    public void NetworkSerialize<T>(BufferSerializer<T> serializer)
+        where T : IReaderWriter
+    {
+        serializer.SerializeValue(ref TargetId);
+        serializer.SerializeValue(ref ConfigIndex);
+        serializer.SerializeValue(ref Coordinates);
+        serializer.SerializeValue(ref Health);
+        serializer.SerializeValue(ref AttackTimeRemaining);
+    }
+
+    public bool Equals(MapTargetNetworkState other) =>
+        TargetId == other.TargetId &&
+        ConfigIndex == other.ConfigIndex &&
+        Coordinates == other.Coordinates &&
+        Health == other.Health &&
+        AttackTimeRemaining.Equals(other.AttackTimeRemaining);
+}
+
+public struct MapShotResultState : INetworkSerializable,
+    IEquatable<MapShotResultState>
+{
+    public uint Sequence;
+    public bool Hit;
+    public int TargetId;
+    public Vector2 Coordinates;
+    public float Distance;
+
+    public MapShotResultState(
+        uint sequence,
+        bool hit,
+        int targetId,
+        Vector2 coordinates,
+        float distance)
+    {
+        Sequence = sequence;
+        Hit = hit;
+        TargetId = targetId;
+        Coordinates = coordinates;
+        Distance = distance;
+    }
+
+    public void NetworkSerialize<T>(BufferSerializer<T> serializer)
+        where T : IReaderWriter
+    {
+        serializer.SerializeValue(ref Sequence);
+        serializer.SerializeValue(ref Hit);
+        serializer.SerializeValue(ref TargetId);
+        serializer.SerializeValue(ref Coordinates);
+        serializer.SerializeValue(ref Distance);
+    }
+
+    public bool Equals(MapShotResultState other) =>
+        Sequence == other.Sequence && Hit == other.Hit &&
+        TargetId == other.TargetId && Coordinates == other.Coordinates &&
+        Distance.Equals(other.Distance);
+}
diff --git a/Assets/CONTENT/FEATURES/MapRadar/MapTargetNetworkState.cs.meta b/Assets/CONTENT/FEATURES/MapRadar/MapTargetNetworkState.cs.meta
new file mode 100644
index 0000000..35a34ea
--- /dev/null
+++ b/Assets/CONTENT/FEATURES/MapRadar/MapTargetNetworkState.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 374f32cae69b9184fb3fffe2969c6cce
\ No newline at end of file
diff --git a/Assets/CONTENT/FEATURES/MapRadar/NetworkBaseHealth.cs b/Assets/CONTENT/FEATURES/MapRadar/NetworkBaseHealth.cs
new file mode 100644
index 0000000..feacbf6
--- /dev/null
+++ b/Assets/CONTENT/FEATURES/MapRadar/NetworkBaseHealth.cs
@@ -0,0 +1,79 @@
+using System;
+using Unity.Netcode;
+using UnityEngine;
+using UnityEngine.Events;
+
+[DisallowMultipleComponent]
+[RequireComponent(typeof(NetworkObject))]
+public sealed class NetworkBaseHealth : NetworkBehaviour
+{
+    [SerializeField, Min(1)] private int maximumHealth = 10;
+    [SerializeField] private UnityEvent<int> healthChanged;
+    [SerializeField] private UnityEvent depleted;
+
+    private readonly NetworkVariable<int> currentHealth = new(
+        0,
+        NetworkVariableReadPermission.Everyone,
+        NetworkVariableWritePermission.Server);
+
+    public int MaximumHealth => Mathf.Max(1, maximumHealth);
+    public int CurrentHealth => currentHealth.Value;
+    public bool IsDepleted => CurrentHealth <= 0;
+
+    public event Action<int> Changed;
+    public event Action Depleted;
+
+    private void OnValidate() => maximumHealth = Mathf.Max(1, maximumHealth);
+
+    public override void OnNetworkSpawn()
+    {
+        currentHealth.OnValueChanged += HandleHealthChanged;
+
+        if (IsServer)
+            currentHealth.Value = MaximumHealth;
+
+        ApplyState(currentHealth.Value, false);
+    }
+
+    public override void OnNetworkDespawn()
+    {
+        currentHealth.OnValueChanged -= HandleHealthChanged;
+    }
+
+    public bool ApplyDamage(int amount)
+    {
+        if (!IsServer || !IsSpawned || amount <= 0 || IsDepleted)
+            return false;
+
+        currentHealth.Value = Mathf.Max(0, CurrentHealth - amount);
+        return true;
+    }
+
+    public void ResetHealth()
+    {
+        if (IsServer && IsSpawned)
+            currentHealth.Value = MaximumHealth;
+    }
+
+    [ContextMenu("Debug/Apply One Damage (Server Play Mode)")]
+    private void ApplyDebugDamage()
+    {
+        if (Application.isPlaying)
+            ApplyDamage(1);
+    }
+
+    private void HandleHealthChanged(int previous, int current) =>
+        ApplyState(current, previous > 0 && current <= 0);
+
+    private void ApplyState(int health, bool becameDepleted)
+    {
+        Changed?.Invoke(health);
+        healthChanged?.Invoke(health);
+
+        if (!becameDepleted)
+            return;
+
+        Depleted?.Invoke();
+        depleted?.Invoke();
+    }
+}
diff --git a/Assets/CONTENT/FEATURES/MapRadar/NetworkBaseHealth.cs.meta b/Assets/CONTENT/FEATURES/MapRadar/NetworkBaseHealth.cs.meta
new file mode 100644
index 0000000..ce7a4f9
--- /dev/null
+++ b/Assets/CONTENT/FEATURES/MapRadar/NetworkBaseHealth.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f171a6cd9e9609e4e8a4822dbefe982f
\ No newline at end of file
diff --git a/Assets/CONTENT/FEATURES/MapRadar/TargetConfig.cs b/Assets/CONTENT/FEATURES/MapRadar/TargetConfig.cs
index 2477f6d..279b65f 100644
--- a/Assets/CONTENT/FEATURES/MapRadar/TargetConfig.cs
+++ b/Assets/CONTENT/FEATURES/MapRadar/TargetConfig.cs
@@ -9,6 +9,7 @@ public sealed class TargetConfig : ScriptableObject
     [Header("Target Stats")]
     [SerializeField, Min(0f)] private float timeBeforeAttack = 5f;
     [SerializeField, Min(1)] private int health = 100;
+    [SerializeField, Min(1)] private int baseDamage = 1;
     [SerializeField] private MissileType requiredMissileType = MissileType.Standard;
 
     [Header("Air Target Movement")]
@@ -18,6 +19,7 @@ public sealed class TargetConfig : ScriptableObject
     public MapTarget TargetPrefab => targetPrefab;
     public float TimeBeforeAttack => timeBeforeAttack;
     public int Health => health;
+    public int BaseDamage => baseDamage;
     public MissileType RequiredMissileType => requiredMissileType;
     public float MovementSpeed => movementSpeed;
     public float StoppingDistance => stoppingDistance;
@@ -26,6 +28,7 @@ public sealed class TargetConfig : ScriptableObject
     {
         timeBeforeAttack = Mathf.Max(0f, timeBeforeAttack);
         health = Mathf.Max(1, health);
+        baseDamage = Mathf.Max(1, baseDamage);
         movementSpeed = Mathf.Max(0f, movementSpeed);
         stoppingDistance = Mathf.Max(0f, stoppingDistance);
     }
diff --git a/Assets/CONTENT/Game/Scripts/Interaction/NetworkButtonInteractable.cs b/Assets/CONTENT/Game/Scripts/Interaction/NetworkButtonInteractable.cs
index 8462122..f7e8aa3 100644
--- a/Assets/CONTENT/Game/Scripts/Interaction/NetworkButtonInteractable.cs
+++ b/Assets/CONTENT/Game/Scripts/Interaction/NetworkButtonInteractable.cs
@@ -1,3 +1,4 @@
+using System;
 using Unity.Netcode;
 using UnityEngine;
 using UnityEngine.Events;
@@ -13,6 +14,9 @@ public sealed class NetworkButtonInteractable : NetworkInteractable
 
     public bool IsPressed => isPressed.Value;
 
+    public event Action Pressed;
+    public event Action<bool> StateChanged;
+
     public override void OnNetworkSpawn()
     {
         isPressed.OnValueChanged += HandleStateChanged;
@@ -28,11 +32,15 @@ public sealed class NetworkButtonInteractable : NetworkInteractable
 
     protected override void InteractOnServer(ulong senderClientId, NetworkObject playerObject)
     {
+        Pressed?.Invoke();
         isPressed.Value = !isPressed.Value;
-        ApplyState(isPressed.Value);
     }
 
     private void HandleStateChanged(bool _, bool currentValue) => ApplyState(currentValue);
 
-    private void ApplyState(bool currentValue) => buttonStateChanged?.Invoke(currentValue);
+    private void ApplyState(bool currentValue)
+    {
+        StateChanged?.Invoke(currentValue);
+        buttonStateChanged?.Invoke(currentValue);
+    }
 }
diff --git a/Assets/CONTENT/Game/Scripts/Interaction/NetworkPhysicalLeverInteractable.cs b/Assets/CONTENT/Game/Scripts/Interaction/NetworkPhysicalLeverInteractable.cs
index cdf6e64..a99295b 100644
--- a/Assets/CONTENT/Game/Scripts/Interaction/NetworkPhysicalLeverInteractable.cs
+++ b/Assets/CONTENT/Game/Scripts/Interaction/NetworkPhysicalLeverInteractable.cs
@@ -1,3 +1,4 @@
+using System;
 using Unity.Netcode;
 using UnityEngine;
 using UnityEngine.Events;
@@ -52,7 +53,10 @@ public sealed class NetworkPhysicalLeverInteractable :
     public bool IsControlled => controllingClientId.Value != NoController;
     public bool IsControlledByLocalPlayer =>
         NetworkManager != null && IsControlledBy(NetworkManager.LocalClientId);
-    public string ReleasePrompt => "[Hold E] Pulling lever";
+    public string ReleasePrompt => "[Hold LMB] Pulling lever";
+
+    public event Action<float> ValueChanged;
+    public event Action<bool> StateChanged;
 
     public override string InteractionPrompt => IsControlledByLocalPlayer
         ? ReleasePrompt
@@ -304,11 +308,15 @@ public sealed class NetworkPhysicalLeverInteractable :
     private void HandleValueChanged(float _, float currentValue)
     {
         ApplyVisual(currentValue);
+        ValueChanged?.Invoke(currentValue);
         leverValueChanged?.Invoke(currentValue);
     }
 
-    private void HandleActivationChanged(bool _, bool currentState) =>
+    private void HandleActivationChanged(bool _, bool currentState)
+    {
+        StateChanged?.Invoke(currentState);
         leverStateChanged?.Invoke(currentState);
+    }
 
     private void ApplyVisual(float value)
     {
diff --git a/Assets/CONTENT/Game/Scripts/Interaction/NetworkPhysicalWheelInteractable.cs b/Assets/CONTENT/Game/Scripts/Interaction/NetworkPhysicalWheelInteractable.cs
new file mode 100644
index 0000000..b2dd12b
--- /dev/null
+++ b/Assets/CONTENT/Game/Scripts/Interaction/NetworkPhysicalWheelInteractable.cs
@@ -0,0 +1,270 @@
+using System;
+using Unity.Netcode;
+using UnityEngine;
+using UnityEngine.Events;
+
+[DisallowMultipleComponent]
+public sealed class NetworkPhysicalWheelInteractable :
+    NetworkInteractable,
+    IPlayerInteractionSession
+{
+    private const ulong NoController = ulong.MaxValue;
+
+    [Header("Wheel visual")]
+    [SerializeField] private Transform wheelVisual;
+    [SerializeField] private Vector3 neutralLocalEulerAngles;
+    [SerializeField] private Vector3 localRotationAxis = Vector3.right;
+    [SerializeField] private Vector3 localReferenceDirection = Vector3.up;
+    [SerializeField, Range(-720f, 0f)] private float minimumAngle = -180f;
+    [SerializeField, Range(0f, 720f)] private float maximumAngle = 180f;
+    [SerializeField, Range(0f, 1f)] private float initialNormalizedValue = 0.5f;
+    [SerializeField, Min(1f)] private float maximumRotationSpeed = 360f;
+
+    [Header("Control")]
+    [SerializeField, Min(0.5f)] private float maximumControlDistance = 4f;
+    [SerializeField] private UnityEvent<float> normalizedValueChanged;
+
+    private readonly NetworkVariable<ulong> controllingClientId = new(
+        NoController,
+        NetworkVariableReadPermission.Everyone,
+        NetworkVariableWritePermission.Server);
+
+    private readonly NetworkVariable<float> synchronizedAngle = new(
+        0f,
+        NetworkVariableReadPermission.Everyone,
+        NetworkVariableWritePermission.Server);
+
+    private float lastPointerAngle;
+    private bool hasPointerAngle;
+
+    public float Angle => synchronizedAngle.Value;
+    public float NormalizedValue => Mathf.InverseLerp(
+        minimumAngle,
+        maximumAngle,
+        synchronizedAngle.Value);
+    public bool IsControlled => controllingClientId.Value != NoController;
+    public bool IsControlledByLocalPlayer =>
+        NetworkManager != null && IsControlledBy(NetworkManager.LocalClientId);
+    public string ReleasePrompt => "[Hold LMB] Turning wheel";
+
+    public override string InteractionPrompt => IsControlledByLocalPlayer
+        ? ReleasePrompt
+        : IsControlled
+            ? "Wheel in use"
+            : InteractionLabel;
+
+    public override bool IsInteractionAvailable =>
+        base.IsInteractionAvailable && (!IsControlled || IsControlledByLocalPlayer);
+
+    public event Action<float> ValueChanged;
+
+    private Quaternion NeutralLocalRotation => Quaternion.Euler(neutralLocalEulerAngles);
+    private Vector3 RotationAxis => localRotationAxis.sqrMagnitude > 0.0001f
+        ? localRotationAxis.normalized
+        : Vector3.right;
+    private Vector3 ReferenceDirection => localReferenceDirection.sqrMagnitude > 0.0001f
+        ? localReferenceDirection.normalized
+        : Vector3.up;
+
+    private void Reset()
+    {
+        wheelVisual = transform;
+        neutralLocalEulerAngles = wheelVisual.localEulerAngles;
+    }
+
+    private void OnValidate()
+    {
+        if (maximumAngle <= minimumAngle)
+            maximumAngle = minimumAngle + 1f;
+    }
+
+    public override void OnNetworkSpawn()
+    {
+        PlayerInteractionSessionRegistry.Register(this);
+        if (IsServer)
+        {
+            synchronizedAngle.Value = Mathf.Lerp(
+                minimumAngle,
+                maximumAngle,
+                initialNormalizedValue);
+        }
+
+        synchronizedAngle.OnValueChanged += HandleAngleChanged;
+        ApplyVisual(synchronizedAngle.Value);
+        InvokeValueChanged();
+    }
+
+    public override void OnNetworkDespawn()
+    {
+        PlayerInteractionSessionRegistry.Unregister(this);
+        synchronizedAngle.OnValueChanged -= HandleAngleChanged;
+    }
+
+    private void FixedUpdate()
+    {
+        if (!IsServer || !IsSpawned || !IsControlled || wheelVisual == null)
+            return;
+
+        if (!TryGetPlayerObject(controllingClientId.Value, out NetworkObject playerObject) ||
+            !IsPlayerWithinControlDistance(playerObject))
+        {
+            EndControl();
+            return;
+        }
+
+        if (!TryCalculatePointerAngle(playerObject, out float pointerAngle))
+        {
+            hasPointerAngle = false;
+            return;
+        }
+
+        if (!hasPointerAngle)
+        {
+            lastPointerAngle = pointerAngle;
+            hasPointerAngle = true;
+            return;
+        }
+
+        float pointerDelta = Mathf.DeltaAngle(lastPointerAngle, pointerAngle);
+        lastPointerAngle = pointerAngle;
+        float maximumStep = maximumRotationSpeed * Time.fixedDeltaTime;
+        float nextAngle = Mathf.Clamp(
+            synchronizedAngle.Value + Mathf.Clamp(pointerDelta, -maximumStep, maximumStep),
+            minimumAngle,
+            maximumAngle);
+        if (!Mathf.Approximately(nextAngle, synchronizedAngle.Value))
+            synchronizedAngle.Value = nextAngle;
+    }
+
+    public bool IsControlledBy(ulong clientId) =>
+        controllingClientId.Value == clientId;
+
+    public void RequestRelease()
+    {
+        if (IsSpawned && IsControlledByLocalPlayer)
+            RequestReleaseServerRpc();
+    }
+
+    protected override bool CanInteractOnServer(ulong senderClientId) =>
+        !IsControlled || IsControlledBy(senderClientId);
+
+    protected override void InteractOnServer(
+        ulong senderClientId,
+        NetworkObject playerObject)
+    {
+        if (IsControlledBy(senderClientId))
+            EndControl();
+        else
+            BeginControl(senderClientId, playerObject);
+    }
+
+    [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Everyone)]
+    private void RequestReleaseServerRpc(RpcParams rpcParams = default)
+    {
+        if (IsControlledBy(rpcParams.Receive.SenderClientId))
+            EndControl();
+    }
+
+    private void BeginControl(ulong clientId, NetworkObject playerObject)
+    {
+        controllingClientId.Value = clientId;
+        hasPointerAngle = TryCalculatePointerAngle(playerObject, out lastPointerAngle);
+    }
+
+    private void EndControl()
+    {
+        controllingClientId.Value = NoController;
+        hasPointerAngle = false;
+    }
+
+    private bool IsPlayerWithinControlDistance(NetworkObject playerObject)
+    {
+        float maximumDistanceSquared = maximumControlDistance * maximumControlDistance;
+        return (playerObject.transform.position - wheelVisual.position).sqrMagnitude <=
+            maximumDistanceSquared;
+    }
+
+    private bool TryCalculatePointerAngle(
+        NetworkObject playerObject,
+        out float pointerAngle)
+    {
+        pointerAngle = 0f;
+        FirstPersonCameraController cameraController =
+            playerObject.GetComponent<FirstPersonCameraController>();
+        Transform aimTransform = cameraController != null
+            ? cameraController.AimTransform
+            : playerObject.transform;
+
+        Transform wheelParent = wheelVisual.parent;
+        Vector3 axisWorld = wheelParent != null
+            ? wheelParent.TransformDirection(NeutralLocalRotation * RotationAxis)
+            : NeutralLocalRotation * RotationAxis;
+        Vector3 referenceWorld = wheelParent != null
+            ? wheelParent.TransformDirection(NeutralLocalRotation * ReferenceDirection)
+            : NeutralLocalRotation * ReferenceDirection;
+
+        Ray aimRay = new(aimTransform.position, aimTransform.forward);
+        Plane wheelPlane = new(axisWorld, wheelVisual.position);
+        Vector3 targetPoint;
+        if (wheelPlane.Raycast(aimRay, out float enter) && enter >= 0f)
+        {
+            targetPoint = aimRay.GetPoint(enter);
+        }
+        else
+        {
+            float distanceAlongRay = Mathf.Max(
+                0.25f,
+                Vector3.Dot(wheelVisual.position - aimRay.origin, aimRay.direction));
+            targetPoint = aimRay.GetPoint(distanceAlongRay);
+        }
+
+        Vector3 pointerDirection = Vector3.ProjectOnPlane(
+            targetPoint - wheelVisual.position,
+            axisWorld);
+        if (pointerDirection.sqrMagnitude < 0.0001f)
+            return false;
+
+        pointerAngle = Vector3.SignedAngle(
+            referenceWorld,
+            pointerDirection.normalized,
+            axisWorld);
+        return true;
+    }
+
+    private void HandleAngleChanged(float _, float current) =>
+        ApplyNetworkValue(current);
+
+    private void ApplyNetworkValue(float angle)
+    {
+        ApplyVisual(angle);
+        InvokeValueChanged();
+    }
+
+    private void InvokeValueChanged()
+    {
+        float value = NormalizedValue;
+        ValueChanged?.Invoke(value);
+        normalizedValueChanged?.Invoke(value);
+    }
+
+    private void ApplyVisual(float angle)
+    {
+        if (wheelVisual != null)
+        {
+            wheelVisual.localRotation = NeutralLocalRotation *
+                Quaternion.AngleAxis(angle, RotationAxis);
+        }
+    }
+
+    [ContextMenu("Preview/Minimum")]
+    private void PreviewMinimum() => ApplyVisual(minimumAngle);
+
+    [ContextMenu("Preview/Center")]
+    private void PreviewCenter() => ApplyVisual(Mathf.Lerp(
+        minimumAngle,
+        maximumAngle,
+        0.5f));
+
+    [ContextMenu("Preview/Maximum")]
+    private void PreviewMaximum() => ApplyVisual(maximumAngle);
+}
diff --git a/Assets/CONTENT/Game/Scripts/Interaction/NetworkPhysicalWheelInteractable.cs.meta b/Assets/CONTENT/Game/Scripts/Interaction/NetworkPhysicalWheelInteractable.cs.meta
new file mode 100644
index 0000000..cafc472
--- /dev/null
+++ b/Assets/CONTENT/Game/Scripts/Interaction/NetworkPhysicalWheelInteractable.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: c645663bb9dcbaf43991bd38665923da
\ No newline at end of file
diff --git a/Assets/CONTENT/Game/Scripts/Player/PlayerInteractionController.cs b/Assets/CONTENT/Game/Scripts/Player/PlayerInteractionController.cs
index d84ec97..de12fd1 100644
--- a/Assets/CONTENT/Game/Scripts/Player/PlayerInteractionController.cs
+++ b/Assets/CONTENT/Game/Scripts/Player/PlayerInteractionController.cs
@@ -22,7 +22,7 @@ public sealed class PlayerInteractionController : NetworkBehaviour, IPlayerSyste
 
     private void Update()
     {
-        if (!isInitialized || !IsOwner || Keyboard.current == null)
+        if (!isInitialized || !IsOwner)
             return;
 
         if (PlayerInteractionSessionRegistry.TryGetControlledSession(
@@ -31,7 +31,9 @@ public sealed class PlayerInteractionController : NetworkBehaviour, IPlayerSyste
         {
             focusedInteractable = null;
 
-            if (!Keyboard.current.eKey.isPressed && !activeSessionReleaseRequested)
+            bool isHoldingControl = Mouse.current != null &&
+                Mouse.current.leftButton.isPressed;
+            if (!isHoldingControl && !activeSessionReleaseRequested)
             {
                 activeSessionReleaseRequested = true;
                 activeSession.RequestRelease();
@@ -44,9 +46,14 @@ public sealed class PlayerInteractionController : NetworkBehaviour, IPlayerSyste
         activeSessionReleaseRequested = false;
         focusedInteractable = FindFocusedInteractable();
 
-        if (Keyboard.current.eKey.wasPressedThisFrame &&
-            focusedInteractable != null &&
-            focusedInteractable.IsInteractionAvailable)
+        if (focusedInteractable == null || !focusedInteractable.IsInteractionAvailable)
+            return;
+
+        bool startsHoldSession = focusedInteractable is IPlayerInteractionSession &&
+            Mouse.current != null && Mouse.current.leftButton.wasPressedThisFrame;
+        bool performsRegularInteraction = focusedInteractable is not IPlayerInteractionSession &&
+            Keyboard.current != null && Keyboard.current.eKey.wasPressedThisFrame;
+        if (startsHoldSession || performsRegularInteraction)
         {
             focusedInteractable.RequestInteraction();
         }
@@ -128,8 +135,11 @@ public sealed class PlayerInteractionController : NetworkBehaviour, IPlayerSyste
         if (focusedInteractable == null)
             return;
 
+        string inputPrompt = focusedInteractable is IPlayerInteractionSession
+            ? "[Hold LMB] "
+            : "[E] ";
         string prompt = focusedInteractable.IsInteractionAvailable
-            ? "[E] " + focusedInteractable.InteractionPrompt
+            ? inputPrompt + focusedInteractable.InteractionPrompt
             : "In use";
         DrawPrompt(prompt);
     }
diff --git a/Assets/CONTENT/Scenes/Factory.unity b/Assets/CONTENT/Scenes/Factory.unity
index ab3218b..cebe0fa 100644
--- a/Assets/CONTENT/Scenes/Factory.unity
+++ b/Assets/CONTENT/Scenes/Factory.unity
@@ -311,14 +311,122 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 334.3335
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 334.3335
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
+--- !u!1 &4428893
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4428897}
+  - component: {fileID: 4428896}
+  - component: {fileID: 4428895}
+  - component: {fileID: 4428894}
+  m_Layer: 0
+  m_Name: Cube (5)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!65 &4428894
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4428893}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &4428895
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4428893}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!33 &4428896
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4428893}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &4428897
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4428893}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 126.31, y: 5.62, z: 45.56}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!43 &6376554
 Mesh:
   m_ObjectHideFlags: 0
@@ -476,8 +584,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 9666.173
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 9666.173
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -641,8 +749,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 386.89713
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 386.89713
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -837,8 +945,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 45.697628
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 45.697628
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -2161,8 +2269,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 12.294557
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 12.294557
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -2331,8 +2439,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 462.01846
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 462.01846
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -2568,8 +2676,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 49.280445
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 49.280445
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -2816,6 +2924,92 @@ Transform:
   m_Children: []
   m_Father: {fileID: 786956262}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &39023598
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 39023599}
+  - component: {fileID: 39023601}
+  - component: {fileID: 39023600}
+  m_Layer: 0
+  m_Name: Handle
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &39023599
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 39023598}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0.65, z: 0}
+  m_LocalScale: {x: 0.14, y: 0.4, z: 0.14}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 1675809488}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!23 &39023600
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 39023598}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!33 &39023601
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 39023598}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!43 &39633677
 Mesh:
   m_ObjectHideFlags: 0
@@ -2973,8 +3167,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 45.697628
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 45.697628
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -3138,8 +3332,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 969.28046
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 969.28046
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -3184,6 +3378,41 @@ Transform:
   - {fileID: 1567925255}
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &41157266
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 41157267}
+  m_Layer: 0
+  m_Name: Map Controls
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &41157267
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 41157266}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 70596736}
+  - {fileID: 1558199899}
+  - {fileID: 2107159078}
+  - {fileID: 1413415458}
+  m_Father: {fileID: 1023903076}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &42108507
 GameObject:
   m_ObjectHideFlags: 0
@@ -3693,8 +3922,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -3858,8 +4087,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -5669,8 +5898,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 18.500467
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 18.500467
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -5834,8 +6063,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1131.4993
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1131.4993
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -5999,8 +6228,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2.6666691
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2.6666691
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -6164,8 +6393,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2.6666691
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2.6666691
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -7401,8 +7630,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -7950,8 +8179,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.1794492
-  m_MeshMetrics[1]: 690.5579
+  'm_MeshMetrics[0]': 1.1794492
+  'm_MeshMetrics[1]': 690.5579
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -8115,8 +8344,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 66.44819
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 66.44819
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -8475,6 +8704,140 @@ Transform:
   m_Children: []
   m_Father: {fileID: 467964023}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &70596735
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 70596736}
+  - component: {fileID: 70596737}
+  - component: {fileID: 70596739}
+  - component: {fileID: 70596738}
+  m_Layer: 0
+  m_Name: Map Horizontal Wheel
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &70596736
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 70596735}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0.09229644, y: 0.7010573, z: -0.09229648, w: 0.7010574}
+  m_LocalPosition: {x: -15.783112, y: -3.270503, z: 7.043751}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 1016872193}
+  m_Father: {fileID: 41157267}
+  m_LocalEulerAnglesHint: {x: 15, y: 90, z: 0}
+--- !u!114 &70596737
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 70596735}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d5a57f767e5e46a458fc5d3c628d0cbb, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  GlobalObjectIdHash: 3607072143
+  InScenePlacedSourceGlobalObjectIdHash: 0
+  DeferredDespawnTick: 0
+  Ownership: 1
+  AlwaysReplicateAsRoot: 0
+  SynchronizeTransform: 1
+  m_InScenePlaced: 1
+  ActiveSceneSynchronization: 0
+  SceneMigrationSynchronization: 0
+  SpawnWithObservers: 1
+  DontDestroyWithOwner: 0
+  AutoObjectParentSync: 1
+  SyncOwnerTransformWhenParented: 1
+  AllowOwnerToParent: 0
+--- !u!114 &70596738
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 70596735}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: c645663bb9dcbaf43991bd38665923da, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  ShowTopMostFoldoutHeaderGroup: 1
+  interactionLabel: Aim horizontal
+  maximumInteractionDistance: 3.5
+  wheelVisual: {fileID: 1016872193}
+  neutralLocalEulerAngles: {x: 0, y: 0, z: 0}
+  localRotationAxis: {x: 0, y: 0, z: 1}
+  localReferenceDirection: {x: 0, y: 1, z: 0}
+  minimumAngle: -180
+  maximumAngle: 180
+  initialNormalizedValue: 0.5
+  maximumRotationSpeed: 360
+  maximumControlDistance: 4
+  normalizedValueChanged:
+    m_PersistentCalls:
+      m_Calls: []
+--- !u!114 &70596739
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 70596735}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: e96cb6065543e43c4a752faaa1468eb1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  ShowTopMostFoldoutHeaderGroup: 1
+  NetworkTransformExpanded: 0
+  AutoOwnerAuthorityTickOffset: 1
+  PositionInterpolationType: 0
+  RotationInterpolationType: 0
+  ScaleInterpolationType: 0
+  PositionLerpSmoothing: 1
+  PositionMaxInterpolationTime: 0.1
+  RotationLerpSmoothing: 1
+  RotationMaxInterpolationTime: 0.1
+  ScaleLerpSmoothing: 1
+  ScaleMaxInterpolationTime: 0.1
+  AuthorityMode: 0
+  TickSyncChildren: 0
+  UseUnreliableDeltas: 1
+  SyncPositionX: 1
+  SyncPositionY: 1
+  SyncPositionZ: 1
+  SyncRotAngleX: 1
+  SyncRotAngleY: 1
+  SyncRotAngleZ: 1
+  SyncScaleX: 1
+  SyncScaleY: 1
+  SyncScaleZ: 1
+  PositionThreshold: 0.001
+  RotAngleThreshold: 0.01
+  ScaleThreshold: 0.01
+  UseQuaternionSynchronization: 0
+  UseQuaternionCompression: 0
+  UseHalfFloatPrecision: 0
+  InLocalSpace: 0
+  SwitchTransformSpaceWhenParented: 0
+  Interpolate: 1
+  SlerpPosition: 0
 --- !u!1 &73742984
 GameObject:
   m_ObjectHideFlags: 0
@@ -9903,8 +10266,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 386.89713
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 386.89713
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -14255,8 +14618,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -14420,8 +14783,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 8.092484
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 8.092484
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -16199,8 +16562,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1773.2571
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1773.2571
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -17196,8 +17559,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -17361,8 +17724,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -17526,8 +17889,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0186558
-  m_MeshMetrics[1]: 37.890778
+  'm_MeshMetrics[0]': 1.0186558
+  'm_MeshMetrics[1]': 37.890778
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -18395,8 +18758,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -18560,8 +18923,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3.5043876
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3.5043876
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -18869,8 +19232,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000044
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.0000044
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -19034,8 +19397,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -19199,8 +19562,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2.2707164
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2.2707164
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -19364,8 +19727,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1110.3453
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1110.3453
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -19662,8 +20025,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 8.223069
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 8.223069
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -19827,8 +20190,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 52.647034
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 52.647034
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -19992,8 +20355,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 55.85217
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 55.85217
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -20157,8 +20520,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -21161,8 +21524,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 124.36223
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 124.36223
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -21326,8 +21689,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 8.223069
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 8.223069
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -21591,8 +21954,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 325.78534
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 325.78534
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -21732,37 +22095,6 @@ CanvasRenderer:
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 216081775}
   m_CullTransparentMesh: 1
---- !u!1 &234250881
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 234250882}
-  m_Layer: 0
-  m_Name: Targets
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &234250882
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 234250881}
-  serializedVersion: 2
-  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
-  m_LocalPosition: {x: 0, y: 0, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_ConstrainProportionsScale: 0
-  m_Children: []
-  m_Father: {fileID: 1170400902}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!43 &217507502
 Mesh:
   m_ObjectHideFlags: 0
@@ -21920,8 +22252,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 9365.838
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 9365.838
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -22085,8 +22417,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 47.2355
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 47.2355
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -22250,14 +22582,27 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 4.425231
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 4.425231
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
+--- !u!134 &226781566
+PhysicsMaterial:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  serializedVersion: 2
+  m_DynamicFriction: 0.6
+  m_StaticFriction: 0.6
+  m_Bounciness: 0
+  m_FrictionCombine: 0
+  m_BounceCombine: 0
 --- !u!43 &226986240
 Mesh:
   m_ObjectHideFlags: 0
@@ -22415,14 +22760,45 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000004
-  m_MeshMetrics[1]: 8.051083
+  'm_MeshMetrics[0]': 1.0000004
+  'm_MeshMetrics[1]': 8.051083
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
+--- !u!1 &234250881
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 234250882}
+  m_Layer: 0
+  m_Name: Targets
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &234250882
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 234250881}
+  serializedVersion: 2
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 1170400902}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!43 &238525238
 Mesh:
   m_ObjectHideFlags: 0
@@ -22580,8 +22956,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -23584,8 +23960,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 6407.088
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 6407.088
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -24139,8 +24515,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -24304,8 +24680,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1.542762
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1.542762
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -24469,8 +24845,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 2.8974767
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 2.8974767
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -24634,8 +25010,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 55.85217
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 55.85217
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -24799,8 +25175,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 89.741066
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 89.741066
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -26469,8 +26845,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1299.5497
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1299.5497
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -26634,8 +27010,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1425.2627
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1425.2627
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -26799,8 +27175,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -27601,14 +27977,27 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 56.582462
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 56.582462
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
+--- !u!134 &301590112
+PhysicsMaterial:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  serializedVersion: 2
+  m_DynamicFriction: 0.6
+  m_StaticFriction: 0.6
+  m_Bounciness: 0
+  m_FrictionCombine: 0
+  m_BounceCombine: 0
 --- !u!43 &301711001
 Mesh:
   m_ObjectHideFlags: 0
@@ -27766,8 +28155,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 291.9253
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 291.9253
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -28283,8 +28672,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 18.328592
-  m_MeshMetrics[1]: 754.4199
+  'm_MeshMetrics[0]': 18.328592
+  'm_MeshMetrics[1]': 754.4199
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -28448,8 +28837,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 5.9528213
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 5.9528213
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -28997,8 +29386,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -95238,8 +95627,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 124.36223
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 124.36223
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -95541,8 +95930,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2650.1956
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2650.1956
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -95706,8 +96095,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -95871,8 +96260,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 116.812126
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 116.812126
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -96036,8 +96425,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 56.582462
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 56.582462
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -96201,8 +96590,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1.6068655
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1.6068655
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -96366,8 +96755,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1117.5837
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1117.5837
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -96531,8 +96920,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1038.9902
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1038.9902
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -96764,8 +97153,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 312.06613
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 312.06613
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -97526,8 +97915,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 962.5641
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 962.5641
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -97759,8 +98148,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -97960,8 +98349,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 334.3335
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 334.3335
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -100252,8 +100641,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -100417,8 +100806,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1614.4955
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1614.4955
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -100582,8 +100971,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 845.41644
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 845.41644
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -100747,8 +101136,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2.2707164
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2.2707164
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -103330,8 +103719,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000044
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.0000044
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -103847,8 +104236,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -104012,8 +104401,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -104177,8 +104566,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -105334,8 +105723,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 36.020058
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 36.020058
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -105499,8 +105888,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -105696,8 +106085,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -108079,8 +108468,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -108244,8 +108633,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 18.336514
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 18.336514
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -108409,8 +108798,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.4446633
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.4446633
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -108574,8 +108963,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 349.22705
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 349.22705
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -109091,8 +109480,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -109256,8 +109645,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1225.7922
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1225.7922
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -109466,8 +109855,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000002
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.0000002
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -109631,8 +110020,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -109796,8 +110185,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -110173,8 +110562,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 45.697628
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 45.697628
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -110338,8 +110727,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -110503,8 +110892,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 56.582462
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 56.582462
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -111020,8 +111409,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 16.978947
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 16.978947
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -111678,8 +112067,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 56.582462
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 56.582462
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -111843,8 +112232,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.4446633
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.4446633
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -112008,8 +112397,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -112173,8 +112562,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -113042,8 +113431,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2.1199381
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2.1199381
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -113315,8 +113704,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 386.89713
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 386.89713
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -113512,8 +113901,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -113677,8 +114066,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 386.89713
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 386.89713
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -113842,8 +114231,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -114007,8 +114396,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 269.5903
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 269.5903
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -114172,8 +114561,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3.5043876
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3.5043876
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -114337,8 +114726,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.056883
-  m_MeshMetrics[1]: 13.774295
+  'm_MeshMetrics[0]': 1.056883
+  'm_MeshMetrics[1]': 13.774295
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -114502,8 +114891,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 54.83502
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 54.83502
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -114667,8 +115056,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 116.15874
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 116.15874
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -114963,8 +115352,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 45.697628
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 45.697628
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -116880,8 +117269,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -117045,8 +117434,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3.5043876
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3.5043876
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -117210,8 +117599,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000002
-  m_MeshMetrics[1]: 991.8196
+  'm_MeshMetrics[0]': 1.0000002
+  'm_MeshMetrics[1]': 991.8196
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -117375,8 +117764,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -117540,8 +117929,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 6.215597
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 6.215597
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -117705,8 +118094,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -118902,8 +119291,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.4446633
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.4446633
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -119067,8 +119456,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -119300,8 +119689,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -119817,8 +120206,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000002
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.0000002
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -121018,8 +121407,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -121183,8 +121572,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 386.89713
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 386.89713
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -121348,8 +121737,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -122521,8 +122910,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.4446633
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.4446633
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -122686,8 +123075,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 45.697628
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 45.697628
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -123270,8 +123659,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 4954.4126
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 4954.4126
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -123787,8 +124176,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 75.487625
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 75.487625
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -126065,8 +126454,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 55.85217
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 55.85217
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -126230,8 +126619,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 9215.725
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 9215.725
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -126395,8 +126784,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1085.7098
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1085.7098
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -126560,8 +126949,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -126725,8 +127114,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 0.8294989
-  m_MeshMetrics[1]: 93939.7
+  'm_MeshMetrics[0]': 0.8294989
+  'm_MeshMetrics[1]': 93939.7
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -126890,8 +127279,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -127407,8 +127796,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3.5043876
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3.5043876
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -127572,8 +127961,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 52.22459
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 52.22459
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -128860,8 +129249,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -129025,8 +129414,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1.6068655
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1.6068655
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -129190,8 +129579,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 407.0833
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 407.0833
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -129355,8 +129744,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -129872,8 +130261,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.00976
-  m_MeshMetrics[1]: 55.255543
+  'm_MeshMetrics[0]': 1.00976
+  'm_MeshMetrics[1]': 55.255543
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -130037,8 +130426,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 6.866744
-  m_MeshMetrics[1]: 1810.9646
+  'm_MeshMetrics[0]': 6.866744
+  'm_MeshMetrics[1]': 1810.9646
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -130202,8 +130591,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -130917,8 +131306,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 35.320896
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 35.320896
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -131082,8 +131471,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1.6068655
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1.6068655
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -131247,8 +131636,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 55.85217
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 55.85217
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -131549,8 +131938,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 6.866744
-  m_MeshMetrics[1]: 1810.9646
+  'm_MeshMetrics[0]': 6.866744
+  'm_MeshMetrics[1]': 1810.9646
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -131714,8 +132103,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 8600.676
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 8600.676
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -132107,8 +132496,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 56.582462
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 56.582462
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -132272,8 +132661,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.4446633
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.4446633
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -132711,93 +133100,6 @@ Transform:
   m_Children: []
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &765942004
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 765942005}
-  - component: {fileID: 765942006}
-  m_Layer: 0
-  m_Name: MapSprite
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &765942005
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 765942004}
-  serializedVersion: 2
-  m_LocalRotation: {x: -0, y: -0.7071068, z: -0, w: 0.7071068}
-  m_LocalPosition: {x: -11.166046, y: 2.1812387, z: 5.256874}
-  m_LocalScale: {x: 0.6, y: 0.6, z: 0.6}
-  m_ConstrainProportionsScale: 1
-  m_Children: []
-  m_Father: {fileID: 1023903076}
-  m_LocalEulerAnglesHint: {x: 0, y: -90, z: 0}
---- !u!212 &765942006
-SpriteRenderer:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 765942004}
-  m_Enabled: 1
-  m_CastShadows: 0
-  m_ReceiveShadows: 0
-  m_DynamicOccludee: 1
-  m_StaticShadowCaster: 0
-  m_MotionVectors: 1
-  m_LightProbeUsage: 1
-  m_ReflectionProbeUsage: 1
-  m_RayTracingMode: 0
-  m_RayTraceProcedural: 0
-  m_RayTracingAccelStructBuildFlagsOverride: 0
-  m_RayTracingAccelStructBuildFlags: 1
-  m_SmallMeshCulling: 1
-  m_RenderingLayerMask: 1
-  m_RendererPriority: 0
-  m_Materials:
-  - {fileID: 2100000, guid: 9dfc825aed78fcd4ba02077103263b40, type: 2}
-  m_StaticBatchInfo:
-    firstSubMesh: 0
-    subMeshCount: 0
-  m_StaticBatchRoot: {fileID: 0}
-  m_ProbeAnchor: {fileID: 0}
-  m_LightProbeVolumeOverride: {fileID: 0}
-  m_ScaleInLightmap: 1
-  m_ReceiveGI: 1
-  m_PreserveUVs: 0
-  m_IgnoreNormalsForChartDetection: 0
-  m_ImportantGI: 0
-  m_StitchLightmapSeams: 1
-  m_SelectedEditorRenderState: 0
-  m_MinimumChartSize: 4
-  m_AutoUVMaxDistance: 0.5
-  m_AutoUVMaxAngle: 89
-  m_LightmapParameters: {fileID: 0}
-  m_SortingLayerID: 0
-  m_SortingLayer: 0
-  m_SortingOrder: 0
-  m_Sprite: {fileID: 21300000, guid: 71c6f8835ecab4c489ead4e40a5aafef, type: 3}
-  m_Color: {r: 1, g: 1, b: 1, a: 1}
-  m_FlipX: 0
-  m_FlipY: 0
-  m_DrawMode: 0
-  m_Size: {x: 12.54, y: 12.54}
-  m_AdaptiveModeThreshold: 0.5
-  m_SpriteTileMode: 0
-  m_WasSpriteAssigned: 1
-  m_MaskInteraction: 0
-  m_SpriteSortPoint: 0
 --- !u!1 &756469910
 GameObject:
   m_ObjectHideFlags: 0
@@ -133023,8 +133325,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1.0010681
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1.0010681
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -133188,8 +133490,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 11.699817
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 11.699817
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -133353,14 +133655,101 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.4446633
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.4446633
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
+--- !u!1 &765942004
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 765942005}
+  - component: {fileID: 765942006}
+  m_Layer: 0
+  m_Name: MapSprite
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &765942005
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 765942004}
+  serializedVersion: 2
+  m_LocalRotation: {x: -0, y: -0.7071068, z: -0, w: 0.7071068}
+  m_LocalPosition: {x: -11.166046, y: 2.1812387, z: 5.256874}
+  m_LocalScale: {x: 0.6, y: 0.6, z: 0.6}
+  m_ConstrainProportionsScale: 1
+  m_Children: []
+  m_Father: {fileID: 1023903076}
+  m_LocalEulerAnglesHint: {x: 0, y: -90, z: 0}
+--- !u!212 &765942006
+SpriteRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 765942004}
+  m_Enabled: 1
+  m_CastShadows: 0
+  m_ReceiveShadows: 0
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 0
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 9dfc825aed78fcd4ba02077103263b40, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 0
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_Sprite: {fileID: 21300000, guid: 71c6f8835ecab4c489ead4e40a5aafef, type: 3}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_FlipX: 0
+  m_FlipY: 0
+  m_DrawMode: 0
+  m_Size: {x: 12.54, y: 12.54}
+  m_AdaptiveModeThreshold: 0.5
+  m_SpriteTileMode: 0
+  m_WasSpriteAssigned: 1
+  m_MaskInteraction: 0
+  m_SpriteSortPoint: 0
 --- !u!43 &768016245
 Mesh:
   m_ObjectHideFlags: 0
@@ -133518,8 +133907,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 967.5343
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 967.5343
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -133795,8 +134184,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -134312,8 +134701,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 35.18685
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 35.18685
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -134477,8 +134866,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 89.741066
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 89.741066
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -134642,8 +135031,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -141472,8 +141861,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -141725,8 +142114,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 49.280445
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 49.280445
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -142274,8 +142663,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 213.92307
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 213.92307
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -142572,8 +142961,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 17.223066
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 17.223066
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -143945,8 +144334,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.708519
-  m_MeshMetrics[1]: 3695.6487
+  'm_MeshMetrics[0]': 1.708519
+  'm_MeshMetrics[1]': 3695.6487
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -144183,8 +144572,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 4.226945
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 4.226945
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -144348,8 +144737,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 0.40379617
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 0.40379617
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -144513,8 +144902,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 136.04715
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 136.04715
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -145662,8 +146051,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 36.692123
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 36.692123
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -145827,8 +146216,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -146032,8 +146421,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 9666.175
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 9666.175
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -146197,8 +146586,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -147434,8 +147823,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 91.53315
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 91.53315
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -150004,8 +150393,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2463.174
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2463.174
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -150555,8 +150944,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -150720,8 +151109,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1.6068655
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1.6068655
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -151022,8 +151411,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3.5043876
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3.5043876
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -151187,8 +151576,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0578377
-  m_MeshMetrics[1]: 6.15665
+  'm_MeshMetrics[0]': 1.0578377
+  'm_MeshMetrics[1]': 6.15665
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -151352,8 +151741,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -151369,7 +151758,7 @@ PrefabInstance:
     m_TransformParent: {fileID: 0}
     m_Modifications:
     - target: {fileID: 1146083900248343034, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
-      propertyPath: m_Materials.Array.data[0]
+      propertyPath: 'm_Materials.Array.data[0]'
       value: 
       objectReference: {fileID: 2100000, guid: 9403e023e1ff61b4f9dbd0d77f1f4148, type: 2}
     - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
@@ -151513,7 +151902,7 @@ PrefabInstance:
       value: UnityEngine.Object, UnityEngine
       objectReference: {fileID: 0}
     - target: {fileID: 3216989811936523488, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
-      propertyPath: m_Materials.Array.data[0]
+      propertyPath: 'm_Materials.Array.data[0]'
       value: 
       objectReference: {fileID: 2100000, guid: 9403e023e1ff61b4f9dbd0d77f1f4148, type: 2}
     - target: {fileID: 8522563728462659335, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
@@ -151529,7 +151918,7 @@ PrefabInstance:
       value: 3431110216
       objectReference: {fileID: 0}
     - target: {fileID: 8704740599923309004, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
-      propertyPath: m_Materials.Array.data[0]
+      propertyPath: 'm_Materials.Array.data[0]'
       value: 
       objectReference: {fileID: 2100000, guid: 9403e023e1ff61b4f9dbd0d77f1f4148, type: 2}
     - target: {fileID: 8815354352711425077, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
@@ -152402,8 +152791,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3763.551
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3763.551
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -152567,8 +152956,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 17.781729
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 17.781729
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -153204,8 +153593,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -153369,8 +153758,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -153988,14 +154377,122 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
+--- !u!1 &1005120809
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1005120813}
+  - component: {fileID: 1005120812}
+  - component: {fileID: 1005120811}
+  - component: {fileID: 1005120810}
+  m_Layer: 0
+  m_Name: Cube (6)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!65 &1005120810
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1005120809}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &1005120811
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1005120809}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!33 &1005120812
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1005120809}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &1005120813
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1005120809}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 126.31, y: 6.62, z: 45.56}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!43 &1005576577
 Mesh:
   m_ObjectHideFlags: 0
@@ -154153,8 +154650,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 0.41901672
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 0.41901672
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -154318,8 +154815,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 111.47388
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 111.47388
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -155307,8 +155804,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3003.004
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3003.004
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -155553,14 +156050,47 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 0.63755363
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 0.63755363
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
+--- !u!1 &1016872192
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1016872193}
+  m_Layer: 0
+  m_Name: Wheel Pivot
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1016872193
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1016872192}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 1822506674}
+  - {fileID: 1970597875}
+  m_Father: {fileID: 70596736}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!43 &1018003674
 Mesh:
   m_ObjectHideFlags: 0
@@ -155718,8 +156248,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 28.004581
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 28.004581
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -155789,8 +156319,8 @@ Transform:
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 1023903075}
   serializedVersion: 2
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 20.1, y: 5.27, z: 52.78}
+  m_LocalRotation: {x: -0, y: -0, z: 0.11597007, w: 0.9932527}
+  m_LocalPosition: {x: 148.61928, y: 9.181449, z: 37.379997}
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_ConstrainProportionsScale: 0
   m_Children:
@@ -155801,8 +156331,9 @@ Transform:
   - {fileID: 1170400902}
   - {fileID: 1568403066}
   - {fileID: 2100000101}
+  - {fileID: 41157267}
   m_Father: {fileID: 0}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 13.319}
 --- !u!43 &1027360240
 Mesh:
   m_ObjectHideFlags: 0
@@ -155960,8 +156491,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 386.89713
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 386.89713
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -156125,8 +156656,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 79.47624
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 79.47624
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -156321,8 +156852,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 0.78721267
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 0.78721267
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -156486,8 +157017,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -156651,8 +157182,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -156816,8 +157347,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -157013,8 +157544,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -159527,8 +160058,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 26.87958
-  m_MeshMetrics[1]: 34.28295
+  'm_MeshMetrics[0]': 26.87958
+  'm_MeshMetrics[1]': 34.28295
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -161004,8 +161535,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1.1498481
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1.1498481
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -161201,8 +161732,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 13.41682
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 13.41682
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -162531,8 +163062,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 386.89713
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 386.89713
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -162696,8 +163227,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 718.34174
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 718.34174
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -163365,8 +163896,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 22.63551
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 22.63551
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -163882,8 +164413,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -164399,8 +164930,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0450655
-  m_MeshMetrics[1]: 9191.234
+  'm_MeshMetrics[0]': 1.0450655
+  'm_MeshMetrics[1]': 9191.234
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -164564,8 +165095,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1287.9543
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1287.9543
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -164729,8 +165260,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1604.4154
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1604.4154
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -164894,8 +165425,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -165144,8 +165675,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 724.9413
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 724.9413
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -165309,8 +165840,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 89.741066
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 89.741066
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -165474,8 +166005,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 21.889816
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 21.889816
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -165947,6 +166478,114 @@ CapsuleCollider:
   m_Height: 0.44984567
   m_Direction: 0
   m_Center: {x: -0.22492284, y: 0, z: 0}
+--- !u!1 &1162394427
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1162394431}
+  - component: {fileID: 1162394430}
+  - component: {fileID: 1162394429}
+  - component: {fileID: 1162394428}
+  m_Layer: 0
+  m_Name: Cube (4)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!65 &1162394428
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1162394427}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &1162394429
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1162394427}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!33 &1162394430
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1162394427}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &1162394431
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1162394427}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 126.31, y: 4.7200003, z: 45.56}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1001 &1162802339
 PrefabInstance:
   m_ObjectHideFlags: 0
@@ -166076,6 +166715,7 @@ MonoBehaviour:
   randomTargetConfigs:
   - {fileID: 11400000, guid: 35ee36b62afb47cd817570f494b93eae, type: 2}
   - {fileID: 11400000, guid: e454536a6e36466c92a7cc8b5650d081, type: 2}
+  showLiveTargetVisuals: 0
   currentWave: 0
   currentWaveTargets: []
 --- !u!43 &1171899960
@@ -166235,8 +166875,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 904.9391
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 904.9391
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -166752,8 +167392,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2650.2314
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2650.2314
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -166949,8 +167589,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -167114,8 +167754,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -167279,8 +167919,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -167796,8 +168436,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2163.694
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2163.694
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -167961,8 +168601,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3.5043876
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3.5043876
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -168478,8 +169118,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 124.36223
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 124.36223
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -168643,8 +169283,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2970.2615
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2970.2615
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -182902,8 +183542,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 95.24977
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 95.24977
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -183067,8 +183707,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 5.845267
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 5.845267
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -183232,8 +183872,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -183397,8 +184037,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0034189
-  m_MeshMetrics[1]: 11.504256
+  'm_MeshMetrics[0]': 1.0034189
+  'm_MeshMetrics[1]': 11.504256
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -183631,8 +184271,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 276636.94
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 276636.94
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -183832,14 +184472,122 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
+--- !u!1 &1254420476
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1254420480}
+  - component: {fileID: 1254420479}
+  - component: {fileID: 1254420478}
+  - component: {fileID: 1254420477}
+  m_Layer: 0
+  m_Name: Cube (2)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!65 &1254420477
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1254420476}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &1254420478
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1254420476}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!33 &1254420479
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1254420476}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &1254420480
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1254420476}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 126.31, y: 2.7200003, z: 45.56}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1256268348
 GameObject:
   m_ObjectHideFlags: 0
@@ -184349,8 +185097,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 718.34174
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 718.34174
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -184514,8 +185262,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -185031,8 +185779,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -185227,8 +185975,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -185392,8 +186140,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -187047,8 +187795,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 124.36223
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 124.36223
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -188364,8 +189112,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.62743
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.62743
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -189398,8 +190146,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 56.582462
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 56.582462
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -189563,8 +190311,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 319.38135
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 319.38135
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -189728,8 +190476,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 584.74786
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 584.74786
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -190732,8 +191480,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 9.443598
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 9.443598
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -190897,8 +191645,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -191062,8 +191810,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 35.18685
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 35.18685
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -191863,8 +192611,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 0.98366165
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 0.98366165
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -192067,8 +192815,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3.5043876
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3.5043876
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -192232,8 +192980,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3845.2515
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3845.2515
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -192749,8 +193497,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1.6068655
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1.6068655
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -193448,8 +194196,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -193613,8 +194361,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -194239,8 +194987,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3.5043876
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3.5043876
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -194404,8 +195152,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -194569,8 +195317,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.165834
-  m_MeshMetrics[1]: 22.806295
+  'm_MeshMetrics[0]': 1.165834
+  'm_MeshMetrics[1]': 22.806295
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -195185,8 +195933,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2650.1956
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2650.1956
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -196887,8 +197635,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 9666.173
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 9666.173
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -197204,8 +197952,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 45.697628
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 45.697628
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -197369,8 +198117,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000002
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.0000002
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -197886,8 +198634,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 45.697628
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 45.697628
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -198051,8 +198799,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 16.32358
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 16.32358
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -198216,8 +198964,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 303.97498
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 303.97498
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -198462,8 +199210,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.4446633
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.4446633
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -198553,6 +199301,131 @@ GameObject:
   m_CorrespondingSourceObject: {fileID: 1000011945391522, guid: 78b71003e8b357d4bbf89c8b5e5e4f0e, type: 3}
   m_PrefabInstance: {fileID: 1412963029}
   m_PrefabAsset: {fileID: 0}
+--- !u!1 &1413415457
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1413415458}
+  - component: {fileID: 1413415459}
+  - component: {fileID: 1413415461}
+  - component: {fileID: 1413415460}
+  m_Layer: 0
+  m_Name: Map Scan Button
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1413415458
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1413415457}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0.09229644, y: 0.7010573, z: -0.09229648, w: 0.7010574}
+  m_LocalPosition: {x: -15.783112, y: -3.270503, z: 3.2437515}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 1812892442}
+  m_Father: {fileID: 41157267}
+  m_LocalEulerAnglesHint: {x: 15, y: 90, z: 0}
+--- !u!114 &1413415459
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1413415457}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d5a57f767e5e46a458fc5d3c628d0cbb, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  GlobalObjectIdHash: 3655742860
+  InScenePlacedSourceGlobalObjectIdHash: 0
+  DeferredDespawnTick: 0
+  Ownership: 1
+  AlwaysReplicateAsRoot: 0
+  SynchronizeTransform: 1
+  m_InScenePlaced: 1
+  ActiveSceneSynchronization: 0
+  SceneMigrationSynchronization: 0
+  SpawnWithObservers: 1
+  DontDestroyWithOwner: 0
+  AutoObjectParentSync: 1
+  SyncOwnerTransformWhenParented: 1
+  AllowOwnerToParent: 0
+--- !u!114 &1413415460
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1413415457}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 43cd66292a303c3478352a33bc74db87, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  ShowTopMostFoldoutHeaderGroup: 1
+  interactionLabel: Scan map
+  maximumInteractionDistance: 3.5
+  buttonStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+--- !u!114 &1413415461
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1413415457}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: e96cb6065543e43c4a752faaa1468eb1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  ShowTopMostFoldoutHeaderGroup: 1
+  NetworkTransformExpanded: 0
+  AutoOwnerAuthorityTickOffset: 1
+  PositionInterpolationType: 0
+  RotationInterpolationType: 0
+  ScaleInterpolationType: 0
+  PositionLerpSmoothing: 1
+  PositionMaxInterpolationTime: 0.1
+  RotationLerpSmoothing: 1
+  RotationMaxInterpolationTime: 0.1
+  ScaleLerpSmoothing: 1
+  ScaleMaxInterpolationTime: 0.1
+  AuthorityMode: 0
+  TickSyncChildren: 0
+  UseUnreliableDeltas: 0
+  SyncPositionX: 1
+  SyncPositionY: 1
+  SyncPositionZ: 1
+  SyncRotAngleX: 1
+  SyncRotAngleY: 1
+  SyncRotAngleZ: 1
+  SyncScaleX: 1
+  SyncScaleY: 1
+  SyncScaleZ: 1
+  PositionThreshold: 0.001
+  RotAngleThreshold: 0.01
+  ScaleThreshold: 0.01
+  UseQuaternionSynchronization: 0
+  UseQuaternionCompression: 0
+  UseHalfFloatPrecision: 0
+  InLocalSpace: 0
+  SwitchTransformSpaceWhenParented: 0
+  Interpolate: 1
+  SlerpPosition: 0
 --- !u!1 &1419500099
 GameObject:
   m_ObjectHideFlags: 0
@@ -201469,8 +202342,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -201986,8 +202859,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 79.47624
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 79.47624
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -202151,8 +203024,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -202316,8 +203189,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 0.13804509
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 0.13804509
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -202481,8 +203354,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 49.280445
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 49.280445
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -202998,8 +203871,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 269.5903
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 269.5903
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -203515,8 +204388,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -204173,8 +205046,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1938.2242
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1938.2242
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -204403,8 +205276,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 21.194195
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 21.194195
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -204639,8 +205512,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1.6068655
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1.6068655
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -204804,8 +205677,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -205115,8 +205988,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -205417,8 +206290,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2212.2993
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2212.2993
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -205582,8 +206455,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2833.844
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2833.844
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -205790,8 +206663,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000004
-  m_MeshMetrics[1]: 6.634698
+  'm_MeshMetrics[0]': 1.0000004
+  'm_MeshMetrics[1]': 6.634698
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -205989,14 +206862,148 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1.6068655
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1.6068655
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
+--- !u!1 &1558199898
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1558199899}
+  - component: {fileID: 1558199900}
+  - component: {fileID: 1558199902}
+  - component: {fileID: 1558199901}
+  m_Layer: 0
+  m_Name: Map Vertical Wheel
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1558199899
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1558199898}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0.09229644, y: 0.7010573, z: -0.09229648, w: 0.7010574}
+  m_LocalPosition: {x: -15.783112, y: -3.270503, z: 5.84375}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 1675809488}
+  m_Father: {fileID: 41157267}
+  m_LocalEulerAnglesHint: {x: 15, y: 90, z: 0}
+--- !u!114 &1558199900
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1558199898}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d5a57f767e5e46a458fc5d3c628d0cbb, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  GlobalObjectIdHash: 6490192
+  InScenePlacedSourceGlobalObjectIdHash: 0
+  DeferredDespawnTick: 0
+  Ownership: 1
+  AlwaysReplicateAsRoot: 0
+  SynchronizeTransform: 1
+  m_InScenePlaced: 1
+  ActiveSceneSynchronization: 0
+  SceneMigrationSynchronization: 0
+  SpawnWithObservers: 1
+  DontDestroyWithOwner: 0
+  AutoObjectParentSync: 1
+  SyncOwnerTransformWhenParented: 1
+  AllowOwnerToParent: 0
+--- !u!114 &1558199901
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1558199898}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: c645663bb9dcbaf43991bd38665923da, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  ShowTopMostFoldoutHeaderGroup: 1
+  interactionLabel: Aim vertical
+  maximumInteractionDistance: 3.5
+  wheelVisual: {fileID: 1675809488}
+  neutralLocalEulerAngles: {x: 0, y: 0, z: 0}
+  localRotationAxis: {x: 0, y: 0, z: 1}
+  localReferenceDirection: {x: 0, y: 1, z: 0}
+  minimumAngle: -180
+  maximumAngle: 180
+  initialNormalizedValue: 0.5
+  maximumRotationSpeed: 360
+  maximumControlDistance: 4
+  normalizedValueChanged:
+    m_PersistentCalls:
+      m_Calls: []
+--- !u!114 &1558199902
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1558199898}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: e96cb6065543e43c4a752faaa1468eb1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  ShowTopMostFoldoutHeaderGroup: 1
+  NetworkTransformExpanded: 0
+  AutoOwnerAuthorityTickOffset: 1
+  PositionInterpolationType: 0
+  RotationInterpolationType: 0
+  ScaleInterpolationType: 0
+  PositionLerpSmoothing: 1
+  PositionMaxInterpolationTime: 0.1
+  RotationLerpSmoothing: 1
+  RotationMaxInterpolationTime: 0.1
+  ScaleLerpSmoothing: 1
+  ScaleMaxInterpolationTime: 0.1
+  AuthorityMode: 0
+  TickSyncChildren: 0
+  UseUnreliableDeltas: 1
+  SyncPositionX: 1
+  SyncPositionY: 1
+  SyncPositionZ: 1
+  SyncRotAngleX: 1
+  SyncRotAngleY: 1
+  SyncRotAngleZ: 1
+  SyncScaleX: 1
+  SyncScaleY: 1
+  SyncScaleZ: 1
+  PositionThreshold: 0.001
+  RotAngleThreshold: 0.01
+  ScaleThreshold: 0.01
+  UseQuaternionSynchronization: 0
+  UseQuaternionCompression: 0
+  UseHalfFloatPrecision: 0
+  InLocalSpace: 0
+  SwitchTransformSpaceWhenParented: 0
+  Interpolate: 1
+  SlerpPosition: 0
 --- !u!43 &1559327247
 Mesh:
   m_ObjectHideFlags: 0
@@ -206154,8 +207161,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1794.7045
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1794.7045
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -206351,8 +207358,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -206560,6 +207567,160 @@ Transform:
   m_Children: []
   m_Father: {fileID: 40753648}
   m_LocalEulerAnglesHint: {x: 90, y: 0, z: 0}
+--- !u!1 &1568403065
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1568403066}
+  - component: {fileID: 1568403069}
+  - component: {fileID: 1568403068}
+  - component: {fileID: 1568403071}
+  - component: {fileID: 1568403070}
+  m_Layer: 0
+  m_Name: MapController
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1568403066
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1568403065}
+  serializedVersion: 2
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0.34467316, y: 2.6314569, z: 4.701664}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 1023903076}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &1568403067
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1979767273}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f1eaeed1aba94e03b8f4b98a580444de, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Assembly-CSharp::MapCrosshairController
+  nearestTarget: {fileID: 0}
+  distanceToNearestTarget: -1
+--- !u!114 &1568403068
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1568403065}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5a5f18d44c314323a2550f92ba7d988a, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Assembly-CSharp::MapController
+  ShowTopMostFoldoutHeaderGroup: 1
+  crosshair: {fileID: 1568403067}
+  coordinateSystem: {fileID: 2100000002}
+  mapPlayer: {fileID: 2477721892431383766}
+  roundGameLoop: {fileID: 35551887}
+  baseHealth: {fileID: 1568403071}
+  targetController: {fileID: 1170400903}
+  targetParent: {fileID: 234250882}
+  simulationStep: 0.1
+  radarController: {fileID: 2100000102}
+  radarMarkPrefab: {fileID: 878491239745611204, guid: 985d88cac4b4daa48973a1a464a3d4e5, type: 3}
+  relayX: {fileID: 1833728127}
+  relayY: {fileID: 495285245}
+  crosshairVisual: {fileID: 1818350634}
+  hitRadius: 0.65
+  shotDamage: 1
+  pseudoMissileType: 1
+  ignoreMissileTypeForPrototype: 1
+  waveStarted:
+    m_PersistentCalls:
+      m_Calls: []
+  shotResolved:
+    m_PersistentCalls:
+      m_Calls: []
+  allTargetsResolved:
+    m_PersistentCalls:
+      m_Calls: []
+  allTargetsDestroyed:
+    m_PersistentCalls:
+      m_Calls: []
+--- !u!114 &1568403069
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1568403065}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d5a57f767e5e46a458fc5d3c628d0cbb, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  GlobalObjectIdHash: 122325670
+  InScenePlacedSourceGlobalObjectIdHash: 0
+  DeferredDespawnTick: 0
+  Ownership: 1
+  AlwaysReplicateAsRoot: 0
+  SynchronizeTransform: 1
+  m_InScenePlaced: 1
+  ActiveSceneSynchronization: 0
+  SceneMigrationSynchronization: 0
+  SpawnWithObservers: 1
+  DontDestroyWithOwner: 0
+  AutoObjectParentSync: 1
+  SyncOwnerTransformWhenParented: 1
+  AllowOwnerToParent: 0
+--- !u!114 &1568403070
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1568403065}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 1a23aadbde3d31042abf625ff22e6fd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  mapController: {fileID: 1568403068}
+  horizontalWheel: {fileID: 70596738}
+  verticalWheel: {fileID: 1558199901}
+  fireLever: {fileID: 2107159079}
+  scanButton: {fileID: 1413415460}
+--- !u!114 &1568403071
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1568403065}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f171a6cd9e9609e4e8a4822dbefe982f, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  ShowTopMostFoldoutHeaderGroup: 1
+  maximumHealth: 10
+  healthChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  depleted:
+    m_PersistentCalls:
+      m_Calls: []
 --- !u!43 &1569533576
 Mesh:
   m_ObjectHideFlags: 0
@@ -206717,8 +207878,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000002
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.0000002
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -206882,8 +208043,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -207082,8 +208243,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -207247,8 +208408,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -207444,84 +208605,14 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 315.1494
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 315.1494
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
---- !u!1 &1568403065
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 1568403066}
-  - component: {fileID: 1568403068}
-  m_Layer: 0
-  m_Name: MapController
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &1568403066
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1568403065}
-  serializedVersion: 2
-  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
-  m_LocalPosition: {x: 0.34467316, y: 2.6314569, z: 4.701664}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_ConstrainProportionsScale: 0
-  m_Children: []
-  m_Father: {fileID: 1023903076}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!114 &1568403067
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1979767273}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: f1eaeed1aba94e03b8f4b98a580444de, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: Assembly-CSharp::MapCrosshairController
-  nearestTarget: {fileID: 0}
-  distanceToNearestTarget: -1
---- !u!114 &1568403068
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1568403065}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 5a5f18d44c314323a2550f92ba7d988a, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: Assembly-CSharp::MapController
-  crosshair: {fileID: 1568403067}
-  coordinateSystem: {fileID: 2100000002}
-  mapPlayer: {fileID: 2477721892431383766}
-  targetController: {fileID: 1170400903}
-  targetParent: {fileID: 234250882}
-  radarController: {fileID: 2100000102}
-  radarMarkPrefab: {fileID: 878491239745611204, guid: 985d88cac4b4daa48973a1a464a3d4e5, type: 3}
-  relayX: {fileID: 1833728127}
-  relayY: {fileID: 495285245}
-  crosshairVisual: {fileID: 1818350634}
-  movementSpeed: 1
-  useKeyboardInput: 1
 --- !u!1 &1597495176
 GameObject:
   m_ObjectHideFlags: 0
@@ -209510,8 +210601,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -209675,8 +210766,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -211031,8 +212122,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1.0342807
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1.0342807
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -211580,8 +212671,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -211745,8 +212836,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2.2733366
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2.2733366
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -211987,8 +213078,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2051.6982
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2051.6982
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -212152,8 +213243,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 54.83502
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 54.83502
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -213492,8 +214583,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 136.04715
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 136.04715
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -213688,8 +214779,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 20.011942
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 20.011942
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -214016,8 +215107,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 775.8566
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 775.8566
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -214181,8 +215272,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -214346,8 +215437,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2.666667
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2.666667
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -215910,8 +217001,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 56.582462
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 56.582462
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -215950,6 +217041,39 @@ Transform:
   - {fileID: 1251175781}
   m_Father: {fileID: 671847851}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1675809487
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1675809488}
+  m_Layer: 0
+  m_Name: Wheel Pivot
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1675809488
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1675809487}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 1853342551}
+  - {fileID: 39023599}
+  m_Father: {fileID: 1558199899}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1678839001
 GameObject:
   m_ObjectHideFlags: 0
@@ -216244,8 +217368,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 674.3336
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 674.3336
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -216409,8 +217533,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 158.53271
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 158.53271
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -218326,8 +219450,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -218491,8 +219615,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 55.85217
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 55.85217
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -220812,8 +221936,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 45.697628
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 45.697628
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -220977,8 +222101,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 452.73895
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 452.73895
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -221142,8 +222266,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 962.5641
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 962.5641
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -221307,8 +222431,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 0.5966177
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 0.5966177
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -221472,8 +222596,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.4446633
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.4446633
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -224345,8 +225469,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 530.40265
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 530.40265
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -224510,8 +225634,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2650.1956
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2650.1956
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -224675,8 +225799,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 444.28867
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 444.28867
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -224915,8 +226039,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -225080,8 +226204,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -225245,8 +226369,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 386.89713
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 386.89713
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -225410,8 +226534,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -226887,8 +228011,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -227404,8 +228528,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -227981,8 +229105,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 153.79318
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 153.79318
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -228178,8 +229302,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 68.56499
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 68.56499
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -228695,8 +229819,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3208.9382
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3208.9382
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -229415,8 +230539,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -229580,8 +230704,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -229745,15 +230869,15 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1417.7668
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1417.7668
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
---- !u!1 &1818350633
+--- !u!1 &1812892441
 GameObject:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
@@ -229761,62 +230885,39 @@ GameObject:
   m_PrefabAsset: {fileID: 0}
   serializedVersion: 6
   m_Component:
-  - component: {fileID: 1818350634}
-  - component: {fileID: 1818350637}
-  - component: {fileID: 1818350636}
-  - component: {fileID: 1818350635}
+  - component: {fileID: 1812892442}
+  - component: {fileID: 1812892445}
+  - component: {fileID: 1812892444}
+  - component: {fileID: 1812892443}
   m_Layer: 0
-  m_Name: Cylinder
+  m_Name: Button Visual
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 1
---- !u!4 &1818350634
+--- !u!4 &1812892442
 Transform:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1818350633}
+  m_GameObject: {fileID: 1812892441}
   serializedVersion: 2
-  m_LocalRotation: {x: -0, y: -0, z: 0.7071068, w: 0.7071068}
-  m_LocalPosition: {x: -11.317, y: 1.0938563, z: 7.34375}
-  m_LocalScale: {x: 0.61, y: 0.122, z: 0.61}
-  m_ConstrainProportionsScale: 1
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0.55, y: 0.55, z: 0.18}
+  m_ConstrainProportionsScale: 0
   m_Children: []
-  m_Father: {fileID: 1979767274}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 90}
---- !u!136 &1818350635
-CapsuleCollider:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1818350633}
-  m_Material: {fileID: 0}
-  m_IncludeLayers:
-    serializedVersion: 2
-    m_Bits: 0
-  m_ExcludeLayers:
-    serializedVersion: 2
-    m_Bits: 0
-  m_LayerOverridePriority: 0
-  m_IsTrigger: 0
-  m_ProvidesContacts: 0
-  m_Enabled: 1
-  serializedVersion: 2
-  m_Radius: 0.5000001
-  m_Height: 2
-  m_Direction: 1
-  m_Center: {x: 0.000000059604645, y: 0, z: -0.00000008940697}
---- !u!23 &1818350636
+  m_Father: {fileID: 1413415458}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!23 &1812892443
 MeshRenderer:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1818350633}
+  m_GameObject: {fileID: 1812892441}
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
@@ -229833,7 +230934,7 @@ MeshRenderer:
   m_RenderingLayerMask: 1
   m_RendererPriority: 0
   m_Materials:
-  - {fileID: 2100000, guid: 0b8e0a594b1c84542b029378c039338e, type: 2}
+  - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
@@ -229842,7 +230943,7 @@ MeshRenderer:
   m_LightProbeVolumeOverride: {fileID: 0}
   m_ScaleInLightmap: 1
   m_ReceiveGI: 1
-  m_PreserveUVs: 0
+  m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
   m_StitchLightmapSeams: 1
@@ -229855,14 +230956,35 @@ MeshRenderer:
   m_SortingLayer: 0
   m_SortingOrder: 0
   m_AdditionalVertexStreams: {fileID: 0}
---- !u!33 &1818350637
+--- !u!65 &1812892444
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1812892441}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!33 &1812892445
 MeshFilter:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1818350633}
-  m_Mesh: {fileID: 10206, guid: 0000000000000000e000000000000000, type: 0}
+  m_GameObject: {fileID: 1812892441}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!43 &1813946918
 Mesh:
   m_ObjectHideFlags: 0
@@ -230020,14 +231142,124 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3997.5542
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3997.5542
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
+--- !u!1 &1818350633
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1818350634}
+  - component: {fileID: 1818350637}
+  - component: {fileID: 1818350636}
+  - component: {fileID: 1818350635}
+  m_Layer: 0
+  m_Name: Cylinder
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1818350634
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1818350633}
+  serializedVersion: 2
+  m_LocalRotation: {x: -0, y: -0, z: 0.7071068, w: 0.7071068}
+  m_LocalPosition: {x: -11.317, y: 1.0938563, z: 7.34375}
+  m_LocalScale: {x: 0.61, y: 0.122, z: 0.61}
+  m_ConstrainProportionsScale: 1
+  m_Children: []
+  m_Father: {fileID: 1979767274}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 90}
+--- !u!136 &1818350635
+CapsuleCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1818350633}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Radius: 0.5000001
+  m_Height: 2
+  m_Direction: 1
+  m_Center: {x: 0.000000059604645, y: 0, z: -0.00000008940697}
+--- !u!23 &1818350636
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1818350633}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 0b8e0a594b1c84542b029378c039338e, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!33 &1818350637
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1818350633}
+  m_Mesh: {fileID: 10206, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!1 &1822248537
 GameObject:
   m_ObjectHideFlags: 0
@@ -230161,6 +231393,116 @@ CanvasRenderer:
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 1822248537}
   m_CullTransparentMesh: 1
+--- !u!1 &1822506673
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1822506674}
+  - component: {fileID: 1822506677}
+  - component: {fileID: 1822506676}
+  - component: {fileID: 1822506675}
+  m_Layer: 0
+  m_Name: Wheel Disk
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1822506674
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1822506673}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0.7071068, y: 0, z: 0, w: 0.7071068}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0.48, y: 0.08, z: 0.48}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 1016872193}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!23 &1822506675
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1822506673}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!136 &1822506676
+CapsuleCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1822506673}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Radius: 0.5
+  m_Height: 2
+  m_Direction: 1
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!33 &1822506677
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1822506673}
+  m_Mesh: {fileID: 10206, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!1 &1822890861
 GameObject:
   m_ObjectHideFlags: 0
@@ -231170,8 +232512,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -231335,8 +232677,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1393.165
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1393.165
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -231852,8 +233194,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3683.8772
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3683.8772
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -232369,8 +233711,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -232534,8 +233876,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -233191,8 +234533,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3676.6416
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3676.6416
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -233356,8 +234698,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1509.5383
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1509.5383
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -233521,8 +234863,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -237894,8 +239236,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1567.4668
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1567.4668
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -238091,14 +239433,124 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
+--- !u!1 &1853342550
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1853342551}
+  - component: {fileID: 1853342554}
+  - component: {fileID: 1853342553}
+  - component: {fileID: 1853342552}
+  m_Layer: 0
+  m_Name: Wheel Disk
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1853342551
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1853342550}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0.7071068, y: 0, z: 0, w: 0.7071068}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0.48, y: 0.08, z: 0.48}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 1675809488}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!23 &1853342552
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1853342550}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!136 &1853342553
+CapsuleCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1853342550}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Radius: 0.5
+  m_Height: 2
+  m_Direction: 1
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!33 &1853342554
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1853342550}
+  m_Mesh: {fileID: 10206, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!43 &1856416568
 Mesh:
   m_ObjectHideFlags: 0
@@ -238256,8 +239708,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.025893
-  m_MeshMetrics[1]: 2424.921
+  'm_MeshMetrics[0]': 1.025893
+  'm_MeshMetrics[1]': 2424.921
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -238421,8 +239873,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -239425,8 +240877,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 27.813684
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 27.813684
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -240422,8 +241874,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 4.7152605
-  m_MeshMetrics[1]: 9365.843
+  'm_MeshMetrics[0]': 4.7152605
+  'm_MeshMetrics[1]': 9365.843
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -240587,8 +242039,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 28.004581
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 28.004581
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -241104,8 +242556,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 17.653618
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 17.653618
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -241269,8 +242721,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 0.4237541
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 0.4237541
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -241434,8 +242886,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 45.697628
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 45.697628
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -241632,8 +243084,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 8.8318815
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 8.8318815
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -241797,8 +243249,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 45.697628
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 45.697628
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -241994,8 +243446,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -242159,8 +243611,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 191.5087
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 191.5087
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -243163,8 +244615,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 6.0300684
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 6.0300684
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -243395,8 +244847,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 21.070381
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 21.070381
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -243560,8 +245012,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1.6050068
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1.6050068
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -243725,8 +245177,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.4446633
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.4446633
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -243922,8 +245374,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 124.36223
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 124.36223
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -244118,8 +245570,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -245104,8 +246556,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 49.280445
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 49.280445
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -245269,8 +246721,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 21.248226
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 21.248226
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -248617,8 +250069,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 344.66632
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 344.66632
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -248782,8 +250234,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 725.73157
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 725.73157
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -248947,8 +250399,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 164.65845
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 164.65845
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -249012,7 +250464,7 @@ MeshCollider:
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 1960000913}
-  m_Material: {fileID: 0}
+  m_Material: {fileID: 226781566}
   m_IncludeLayers:
     serializedVersion: 2
     m_Bits: 0
@@ -251157,6 +252609,92 @@ Transform:
   m_Children: []
   m_Father: {fileID: 931295333}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1970597874
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1970597875}
+  - component: {fileID: 1970597877}
+  - component: {fileID: 1970597876}
+  m_Layer: 0
+  m_Name: Handle
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1970597875
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1970597874}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0.65, z: 0}
+  m_LocalScale: {x: 0.14, y: 0.4, z: 0.14}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 1016872193}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!23 &1970597876
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1970597874}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!33 &1970597877
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1970597874}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!43 &1971637914
 Mesh:
   m_ObjectHideFlags: 0
@@ -251314,8 +252852,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2953.4333
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2953.4333
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -251785,41 +253323,6 @@ MeshRenderer:
   m_CorrespondingSourceObject: {fileID: 2532840798063846378, guid: 36442a5302f803e43b19f759e4547a93, type: 3}
   m_PrefabInstance: {fileID: 1976815478}
   m_PrefabAsset: {fileID: 0}
---- !u!1 &1979767273
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 1979767274}
-  - component: {fileID: 1568403067}
-  m_Layer: 0
-  m_Name: Crosshair
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &1979767274
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1979767273}
-  serializedVersion: 2
-  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
-  m_LocalPosition: {x: 0, y: 0, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_ConstrainProportionsScale: 0
-  m_Children:
-  - {fileID: 1818350634}
-  - {fileID: 495285245}
-  - {fileID: 1833728127}
-  m_Father: {fileID: 1023903076}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!43 &1977026396
 Mesh:
   m_ObjectHideFlags: 0
@@ -251977,8 +253480,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1.6068655
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1.6068655
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -252016,6 +253519,41 @@ Transform:
   m_Children: []
   m_Father: {fileID: 1347128320}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1979767273
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1979767274}
+  - component: {fileID: 1568403067}
+  m_Layer: 0
+  m_Name: Crosshair
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1979767274
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1979767273}
+  serializedVersion: 2
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 1818350634}
+  - {fileID: 495285245}
+  - {fileID: 1833728127}
+  m_Father: {fileID: 1023903076}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1985178560
 GameObject:
   m_ObjectHideFlags: 0
@@ -254246,8 +255784,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.7144343
-  m_MeshMetrics[1]: 59.006336
+  'm_MeshMetrics[0]': 1.7144343
+  'm_MeshMetrics[1]': 59.006336
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -254411,8 +255949,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 55.965088
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 55.965088
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -254576,8 +256114,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0934765
-  m_MeshMetrics[1]: 14.664914
+  'm_MeshMetrics[0]': 1.0934765
+  'm_MeshMetrics[1]': 14.664914
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -254741,8 +256279,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -255302,8 +256840,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 40.863724
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 40.863724
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -255467,8 +257005,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3.5043876
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3.5043876
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -255632,8 +257170,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.00976
-  m_MeshMetrics[1]: 55.255543
+  'm_MeshMetrics[0]': 1.00976
+  'm_MeshMetrics[1]': 55.255543
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -256988,8 +258526,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 83.30811
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 83.30811
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -257165,7 +258703,7 @@ MeshCollider:
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 2018473234}
-  m_Material: {fileID: 0}
+  m_Material: {fileID: 301590112}
   m_IncludeLayers:
     serializedVersion: 2
     m_Bits: 0
@@ -257646,8 +259184,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 45.697628
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 45.697628
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -258163,8 +259701,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 9666.173
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 9666.173
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -258403,8 +259941,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -259123,8 +260661,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 55.85217
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 55.85217
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -259385,8 +260923,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 48.677944
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 48.677944
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -259550,8 +261088,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 5741.4
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 5741.4
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -259715,8 +261253,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 217.01709
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 217.01709
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -260477,8 +262015,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1012.4551
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1012.4551
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -260642,8 +262180,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 6710879.5
-  m_MeshMetrics[1]: 7.993909
+  'm_MeshMetrics[0]': 6710879.5
+  'm_MeshMetrics[1]': 7.993909
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -260807,8 +262345,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -261008,8 +262546,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -261525,8 +263063,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 56.582462
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 56.582462
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -261690,8 +263228,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3124.2417
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3124.2417
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -261855,8 +263393,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -262020,8 +263558,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -262063,6 +263601,222 @@ Transform:
   - {fileID: 1162802340}
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &2084479193
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2084479197}
+  - component: {fileID: 2084479196}
+  - component: {fileID: 2084479195}
+  - component: {fileID: 2084479194}
+  m_Layer: 0
+  m_Name: Cube (3)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!65 &2084479194
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2084479193}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &2084479195
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2084479193}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!33 &2084479196
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2084479193}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &2084479197
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2084479193}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 126.31, y: 3.72, z: 45.56}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &2091867398
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2091867402}
+  - component: {fileID: 2091867401}
+  - component: {fileID: 2091867400}
+  - component: {fileID: 2091867399}
+  m_Layer: 0
+  m_Name: Cube (1)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!65 &2091867399
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2091867398}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &2091867400
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2091867398}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!33 &2091867401
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2091867398}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &2091867402
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2091867398}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 126.31, y: 1.72, z: 45.56}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &2093331238
 GameObject:
   m_ObjectHideFlags: 0
@@ -263195,244 +264949,14 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 3.5043876
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 3.5043876
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
---- !u!1 &2100000000
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 2100000001}
-  - component: {fileID: 2100000002}
-  m_Layer: 0
-  m_Name: MapCoordinates
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &2100000001
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 2100000000}
-  serializedVersion: 2
-  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
-  m_LocalPosition: {x: 0, y: -2.54, z: 1.5499992}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_ConstrainProportionsScale: 0
-  m_Children:
-  - {fileID: 2100000011}
-  - {fileID: 2100000021}
-  - {fileID: 2100000031}
-  - {fileID: 2100000041}
-  m_Father: {fileID: 1023903076}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!114 &2100000002
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 2100000000}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 7206111709094332bdc9b4c7c44695b4, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: Assembly-CSharp::MapCoordinateSystem
-  bottomLeft: {fileID: 2100000011}
-  bottomRight: {fileID: 2100000021}
-  topLeft: {fileID: 2100000031}
-  topRight: {fileID: 2100000041}
-  squareSize: 7.3
-  showSceneVisualization: 1
-  gridDivisions: 10
-  showCoordinateLabels: 1
-  boundaryColor: {r: 1, g: 1, b: 1, a: 1}
-  gridColor: {r: 1, g: 1, b: 1, a: 0.3}
-  markerSize: 0.06
---- !u!1 &2100000010
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 2100000011}
-  m_Layer: 0
-  m_Name: Bottom Left (0, 0)
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &2100000011
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 2100000010}
-  serializedVersion: 2
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: -11.317, y: 1.0938563, z: 7.34375}
-  m_LocalScale: {x: 1, y: 1, z: 1.2337}
-  m_ConstrainProportionsScale: 0
-  m_Children: []
-  m_Father: {fileID: 2100000001}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &2100000020
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 2100000021}
-  m_Layer: 0
-  m_Name: Bottom Right (10, 0)
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &2100000021
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 2100000020}
-  serializedVersion: 2
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: -11.317, y: 1.0938563, z: 0.043750763}
-  m_LocalScale: {x: 1, y: 1, z: 1.2337}
-  m_ConstrainProportionsScale: 0
-  m_Children: []
-  m_Father: {fileID: 2100000001}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &2100000030
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 2100000031}
-  m_Layer: 0
-  m_Name: Top Left (0, 10)
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &2100000031
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 2100000030}
-  serializedVersion: 2
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: -11.317, y: 8.393856, z: 7.34375}
-  m_LocalScale: {x: 1, y: 1, z: 1.2337}
-  m_ConstrainProportionsScale: 0
-  m_Children: []
-  m_Father: {fileID: 2100000001}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &2100000040
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 2100000041}
-  m_Layer: 0
-  m_Name: Top Right (10, 10)
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &2100000041
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 2100000040}
-  serializedVersion: 2
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: -11.317, y: 8.393856, z: 0.043750763}
-  m_LocalScale: {x: 1, y: 1, z: 1.2337}
-  m_ConstrainProportionsScale: 0
-  m_Children: []
-  m_Father: {fileID: 2100000001}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &2100000100
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 2100000101}
-  - component: {fileID: 2100000102}
-  m_Layer: 0
-  m_Name: Radar
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &2100000101
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 2100000100}
-  serializedVersion: 2
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0, y: 0, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_ConstrainProportionsScale: 0
-  m_Children: []
-  m_Father: {fileID: 1023903076}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!114 &2100000102
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 2100000100}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 168bf77c50d14e44a54a3a2e6717d012, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: Assembly-CSharp::MapRadarController
-  cooldown: 5
-  useKeyboardInput: 1
-  cooldownRemaining: 0
 --- !u!43 &2098662875
 Mesh:
   m_ObjectHideFlags: 0
@@ -263590,14 +265114,243 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 193.49586
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 193.49586
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
     offset: 0
     size: 0
     path: 
+--- !u!1 &2100000000
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2100000001}
+  - component: {fileID: 2100000002}
+  m_Layer: 0
+  m_Name: MapCoordinates
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2100000001
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2100000000}
+  serializedVersion: 2
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: -2.54, z: 1.5499992}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 2100000011}
+  - {fileID: 2100000021}
+  - {fileID: 2100000031}
+  - {fileID: 2100000041}
+  m_Father: {fileID: 1023903076}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &2100000002
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2100000000}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7206111709094332bdc9b4c7c44695b4, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Assembly-CSharp::MapCoordinateSystem
+  bottomLeft: {fileID: 2100000011}
+  bottomRight: {fileID: 2100000021}
+  topLeft: {fileID: 2100000031}
+  topRight: {fileID: 2100000041}
+  squareSize: 7.3
+  showSceneVisualization: 1
+  gridDivisions: 10
+  showCoordinateLabels: 1
+  boundaryColor: {r: 1, g: 1, b: 1, a: 1}
+  gridColor: {r: 1, g: 1, b: 1, a: 0.3}
+  markerSize: 0.06
+--- !u!1 &2100000010
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2100000011}
+  m_Layer: 0
+  m_Name: Bottom Left (0, 0)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2100000011
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2100000010}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -11.317, y: 1.0938563, z: 7.34375}
+  m_LocalScale: {x: 1, y: 1, z: 1.2337}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 2100000001}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &2100000020
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2100000021}
+  m_Layer: 0
+  m_Name: Bottom Right (10, 0)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2100000021
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2100000020}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -11.317004, y: 1.0938573, z: 0.043750763}
+  m_LocalScale: {x: 1, y: 1, z: 1.2337}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 2100000001}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &2100000030
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2100000031}
+  m_Layer: 0
+  m_Name: Top Left (0, 10)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2100000031
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2100000030}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -11.3169985, y: 8.393857, z: 7.34375}
+  m_LocalScale: {x: 1, y: 1, z: 1.2337}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 2100000001}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &2100000040
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2100000041}
+  m_Layer: 0
+  m_Name: Top Right (10, 10)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2100000041
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2100000040}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -11.3169985, y: 8.393857, z: 0.043750763}
+  m_LocalScale: {x: 1, y: 1, z: 1.2337}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 2100000001}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &2100000100
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2100000101}
+  - component: {fileID: 2100000102}
+  m_Layer: 0
+  m_Name: Radar
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2100000101
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2100000100}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 1023903076}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &2100000102
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2100000100}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 168bf77c50d14e44a54a3a2e6717d012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Assembly-CSharp::MapRadarController
+  cooldown: 5
+  cooldownRemaining: 0
 --- !u!1 &2100407432
 GameObject:
   m_ObjectHideFlags: 0
@@ -263820,8 +265573,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 45.697628
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 45.697628
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -263985,8 +265738,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -264124,6 +265877,119 @@ Transform:
   - {fileID: 1158026240}
   m_Father: {fileID: 910531642}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1001 &2107159077
+PrefabInstance:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    serializedVersion: 3
+    m_TransformParent: {fileID: 41157267}
+    m_Modifications:
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalScale.x
+      value: 0.55
+      objectReference: {fileID: 0}
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalScale.y
+      value: 0.55
+      objectReference: {fileID: 0}
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalScale.z
+      value: 0.55
+      objectReference: {fileID: 0}
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalPosition.x
+      value: -15.783112
+      objectReference: {fileID: 0}
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalPosition.y
+      value: -3.270503
+      objectReference: {fileID: 0}
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalPosition.z
+      value: 4.4437523
+      objectReference: {fileID: 0}
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalRotation.w
+      value: 0.7010574
+      objectReference: {fileID: 0}
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalRotation.x
+      value: 0.09229644
+      objectReference: {fileID: 0}
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalRotation.y
+      value: 0.7010573
+      objectReference: {fileID: 0}
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalRotation.z
+      value: -0.09229648
+      objectReference: {fileID: 0}
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.x
+      value: 15
+      objectReference: {fileID: 0}
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: 90
+      objectReference: {fileID: 0}
+    - target: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 2476357789053846530, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: interactionLabel
+      value: Fire
+      objectReference: {fileID: 0}
+    - target: {fileID: 2476357789053846530, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: automaticReturnDelay
+      value: 0.2
+      objectReference: {fileID: 0}
+    - target: {fileID: 2476357789053846530, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: maximumInteractionDistance
+      value: 3.5
+      objectReference: {fileID: 0}
+    - target: {fileID: 2476357789053846530, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: returnToInitialPositionAfterSwitch
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 8522563728462659335, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_InScenePlaced
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 8522563728462659335, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: GlobalObjectIdHash
+      value: 3592729868
+      objectReference: {fileID: 0}
+    - target: {fileID: 8522563728462659335, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: InScenePlacedSourceGlobalObjectIdHash
+      value: 3431110216
+      objectReference: {fileID: 0}
+    - target: {fileID: 8815354352711425077, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+      propertyPath: m_Name
+      value: Map Fire Lever
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+    m_RemovedGameObjects: []
+    m_AddedGameObjects: []
+    m_AddedComponents: []
+  m_SourcePrefab: {fileID: 100100000, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+--- !u!4 &2107159078 stripped
+Transform:
+  m_CorrespondingSourceObject: {fileID: 2407670811493793166, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+  m_PrefabInstance: {fileID: 2107159077}
+  m_PrefabAsset: {fileID: 0}
+--- !u!114 &2107159079 stripped
+MonoBehaviour:
+  m_CorrespondingSourceObject: {fileID: 2476357789053846530, guid: 593b09321d7982e48a7d65a32da0d96a, type: 3}
+  m_PrefabInstance: {fileID: 2107159077}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 262775fc01b9c8a47a82f30b50d7b12a, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
 --- !u!43 &2110670409
 Mesh:
   m_ObjectHideFlags: 0
@@ -264281,8 +266147,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1.0000001
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1.0000001
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -264446,8 +266312,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 709.33234
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 709.33234
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -264611,8 +266477,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 7.238174
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 7.238174
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -264776,8 +266642,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 1
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 1
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -265645,8 +267511,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 2650.2314
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 2650.2314
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -265810,8 +267676,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 208.69763
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 208.69763
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -266042,8 +267908,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 4954.4126
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 4954.4126
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -266429,8 +268295,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 311.9579
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 311.9579
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -266594,8 +268460,8 @@ Mesh:
   m_CookingOptions: 30
   m_BakedConvexCollisionMesh: 
   m_BakedTriangleCollisionMesh: 
-  m_MeshMetrics[0]: 1
-  m_MeshMetrics[1]: 4.569583
+  'm_MeshMetrics[0]': 1
+  'm_MeshMetrics[1]': 4.569583
   m_MeshOptimizationFlags: 1
   m_StreamData:
     serializedVersion: 2
@@ -306611,6 +308477,82 @@ MeshCollider:
   m_Convex: 0
   m_CookingOptions: 30
   m_Mesh: {fileID: 184362975}
+--- !u!1001 &2477721892431383765
+PrefabInstance:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    serializedVersion: 3
+    m_TransformParent: {fileID: 1023903076}
+    m_Modifications:
+    - target: {fileID: 2177866398127073846, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: m_Name
+      value: MapPlayer
+      objectReference: {fileID: 0}
+    - target: {fileID: 3288838730342684678, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: mapCoordinates.x
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 3288838730342684678, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: mapCoordinates.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: m_LocalPosition.x
+      value: -11.339558
+      objectReference: {fileID: 0}
+    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: m_LocalPosition.y
+      value: -0.48904037
+      objectReference: {fileID: 0}
+    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: m_LocalPosition.z
+      value: 8.11739
+      objectReference: {fileID: 0}
+    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: m_LocalRotation.w
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: m_LocalRotation.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: m_LocalRotation.y
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: m_LocalRotation.z
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.z
+      value: 0
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+    m_RemovedGameObjects: []
+    m_AddedGameObjects: []
+    m_AddedComponents: []
+  m_SourcePrefab: {fileID: 100100000, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+--- !u!114 &2477721892431383766 stripped
+MonoBehaviour:
+  m_CorrespondingSourceObject: {fileID: 3288838730342684678, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+  m_PrefabInstance: {fileID: 2477721892431383765}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: e8c0e4a1fa154b5ca06510a1443335bf, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Assembly-CSharp::MapPlayer
 --- !u!1 &2479355979561634002
 GameObject:
   m_ObjectHideFlags: 0
@@ -307213,82 +309155,6 @@ MonoBehaviour:
     - rid: 7183058067760611539
       type: {class: Cube, ns: UnityEngine.ProBuilder.Shapes, asm: Unity.ProBuilder}
       data: 
---- !u!1001 &2477721892431383765
-PrefabInstance:
-  m_ObjectHideFlags: 0
-  serializedVersion: 2
-  m_Modification:
-    serializedVersion: 3
-    m_TransformParent: {fileID: 1023903076}
-    m_Modifications:
-    - target: {fileID: 2177866398127073846, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: m_Name
-      value: MapPlayer
-      objectReference: {fileID: 0}
-    - target: {fileID: 3288838730342684678, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: mapCoordinates.x
-      value: 1
-      objectReference: {fileID: 0}
-    - target: {fileID: 3288838730342684678, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: mapCoordinates.y
-      value: 1
-      objectReference: {fileID: 0}
-    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: m_LocalPosition.x
-      value: -11.339558
-      objectReference: {fileID: 0}
-    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: m_LocalPosition.y
-      value: -0.48904037
-      objectReference: {fileID: 0}
-    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: m_LocalPosition.z
-      value: 8.11739
-      objectReference: {fileID: 0}
-    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: m_LocalRotation.w
-      value: 1
-      objectReference: {fileID: 0}
-    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: m_LocalRotation.x
-      value: -0
-      objectReference: {fileID: 0}
-    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: m_LocalRotation.y
-      value: -0
-      objectReference: {fileID: 0}
-    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: m_LocalRotation.z
-      value: -0
-      objectReference: {fileID: 0}
-    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: m_LocalEulerAnglesHint.x
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: m_LocalEulerAnglesHint.y
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-      propertyPath: m_LocalEulerAnglesHint.z
-      value: 0
-      objectReference: {fileID: 0}
-    m_RemovedComponents: []
-    m_RemovedGameObjects: []
-    m_AddedGameObjects: []
-    m_AddedComponents: []
-  m_SourcePrefab: {fileID: 100100000, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
---- !u!114 &2477721892431383766 stripped
-MonoBehaviour:
-  m_CorrespondingSourceObject: {fileID: 3288838730342684678, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-  m_PrefabInstance: {fileID: 2477721892431383765}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 0}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: e8c0e4a1fa154b5ca06510a1443335bf, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: Assembly-CSharp::MapPlayer
 --- !u!1001 &2589992063474871117
 PrefabInstance:
   m_ObjectHideFlags: 0
@@ -307370,11 +309236,6 @@ PrefabInstance:
     m_AddedGameObjects: []
     m_AddedComponents: []
   m_SourcePrefab: {fileID: 100100000, guid: 9712e2459410a6d43b55ea9d3847e29a, type: 3}
---- !u!4 &3273208810517680420 stripped
-Transform:
-  m_CorrespondingSourceObject: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
-  m_PrefabInstance: {fileID: 2477721892431383765}
-  m_PrefabAsset: {fileID: 0}
 --- !u!64 &2590580287886866592
 MeshCollider:
   m_ObjectHideFlags: 0
@@ -313968,6 +315829,11 @@ GameObject:
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 2147483647
   m_IsActive: 1
+--- !u!4 &3273208810517680420 stripped
+Transform:
+  m_CorrespondingSourceObject: {fileID: 8348844199957468506, guid: 87ea05b44a3faf5489e6266f985c5324, type: 3}
+  m_PrefabInstance: {fileID: 2477721892431383765}
+  m_PrefabAsset: {fileID: 0}
 --- !u!64 &3276760324153824582
 MeshCollider:
   m_ObjectHideFlags: 0
@@ -374150,3 +376016,9 @@ SceneRoots:
   - {fileID: 794328120}
   - {fileID: 943709098}
   - {fileID: 1023903076}
+  - {fileID: 2091867402}
+  - {fileID: 2084479197}
+  - {fileID: 4428897}
+  - {fileID: 1254420480}
+  - {fileID: 1162394431}
+  - {fileID: 1005120813}