Squashed commit of the following:

commit 173bbb165c
Author: henjkey <henjkey@gmail.com>
Date:   Fri Aug 14 18:51:23 2026 +0500

    Mappp

commit d559ab338a
Author: henjkey <henjkey@gmail.com>
Date:   Thu Aug 13 18:42:41 2026 +0500

    Map

    Controller
    Coordinates
    Target System
    Crosshair System
    Radar System

Assets/Bakery/examples/content/ftlogo.mat

@@ -39,6 +39,7 @@ Material:
   disabledShaderPasses:
   - MOTIONVECTORS
   - DepthOnly
+  - SHADOWCASTER
   m_LockedProperties: 
   m_SavedProperties:
     serializedVersion: 3
@@ -68,7 +69,7 @@ Material:
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _MainTex:
-        m_Texture: {fileID: 0}
+        m_Texture: {fileID: 2800000, guid: a75118087a5b8ea41a9f58ce5debb2d2, type: 3}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _MetallicGlossMap:
@@ -136,7 +137,7 @@ Material:
     - _ZWrite: 0
     m_Colors:
     - _BaseColor: {r: 0, g: 0, b: 0, a: 1}
-    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 0, g: 0, b: 0, a: 1}
     - _EmissionColor: {r: 0.9705882, g: 0.947554, b: 0.9063581, a: 1}
     - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
   m_BuildTextureStacks: []

Assets/Bakery/examples/content/light.mat

@@ -11,9 +11,7 @@ Material:
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
   m_Parent: {fileID: 0}
   m_ModifiedSerializedProperties: 0
-  m_ValidKeywords:
+  m_ValidKeywords: []
-  - _GLOSSINESS_FROM_BASE_ALPHA
-  - _SPECULAR_COLOR
   m_InvalidKeywords: []
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0

Assets/Bakery/examples/content/sponza/Materials/Material__47.mat

@@ -25,6 +25,7 @@ Material:
   m_Parent: {fileID: 0}
   m_ModifiedSerializedProperties: 0
   m_ValidKeywords:
+  - _ENVIRONMENTREFLECTIONS_OFF
   - _SPECULARHIGHLIGHTS_OFF
   m_InvalidKeywords:
   - _GLOSSYREFLECTIONS_OFF

Assets/Bakery/examples/content/sponza/Materials/background.mat

@@ -12,6 +12,7 @@ Material:
   m_Parent: {fileID: 0}
   m_ModifiedSerializedProperties: 0
   m_ValidKeywords:
+  - _ENVIRONMENTREFLECTIONS_OFF
   - _SPECULARHIGHLIGHTS_OFF
   m_InvalidKeywords:
   - _GLOSSYREFLECTIONS_OFF
@@ -52,7 +53,7 @@ Material:
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _MainTex:
-        m_Texture: {fileID: 0}
+        m_Texture: {fileID: 2800000, guid: 4a3ea3eb16909a646a66ff7b19d31788, type: 3}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _MetallicGlossMap:

Assets/CONTENT/FEATURES/MapRadar.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5da4c81b147b7544e9cb44f942ad51f0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/FEATURES/MapRadar/AirTarget.cs

@@ -0,0 +1,21 @@
+using UnityEngine;
+
+[DisallowMultipleComponent]
+public sealed class AirTarget : MapTarget
+{
+    protected override void TickMovement(float deltaTime)
+    {
+        if (Player == null || Config == null || Config.MovementSpeed <= 0f)
+            return;
+
+        Vector2 playerCoordinates = Player.MapCoordinates;
+        if (Vector2.Distance(MapCoordinates, playerCoordinates) <= Config.StoppingDistance)
+            return;
+
+        Vector2 nextCoordinates = Vector2.MoveTowards(
+            MapCoordinates,
+            playerCoordinates,
+            Config.MovementSpeed * deltaTime);
+        SetMapCoordinates(nextCoordinates);
+    }
+}

Assets/CONTENT/FEATURES/MapRadar/AirTarget.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d5316cf7562b473d9513878ea906a1b2

Assets/CONTENT/FEATURES/MapRadar/Configs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 91a48705d8024711b1d912580a4c8bca
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

Assets/CONTENT/FEATURES/MapRadar/Configs/AirTargetConfig.asset

@@ -0,0 +1,20 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: c4e7ec8e55a847eaa5c7914bf08d1f98, type: 3}
+  m_Name: AirTargetConfig
+  m_EditorClassIdentifier: Assembly-CSharp::TargetConfig
+  targetPrefab: {fileID: 878491239745611204, guid: 7ef28d9e428a4b94ab7ea4f36fd44d9c, type: 3}
+  timeBeforeAttack: 30
+  health: 2
+  requiredMissileType: 2
+  movementSpeed: 0.05
+  stoppingDistance: 0.25

Assets/CONTENT/FEATURES/MapRadar/Configs/AirTargetConfig.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e454536a6e36466c92a7cc8b5650d081
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData:
+  assetBundleName:
+  assetBundleVariant:

Assets/CONTENT/FEATURES/MapRadar/Configs/GroundTargetConfig.asset

@@ -0,0 +1,20 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: c4e7ec8e55a847eaa5c7914bf08d1f98, type: 3}
+  m_Name: GroundTargetConfig
+  m_EditorClassIdentifier: Assembly-CSharp::TargetConfig
+  targetPrefab: {fileID: 878491239745611204, guid: 985d88cac4b4daa48973a1a464a3d4e5, type: 3}
+  timeBeforeAttack: 50
+  health: 5
+  requiredMissileType: 3
+  movementSpeed: 0
+  stoppingDistance: 0.25

Assets/CONTENT/FEATURES/MapRadar/Configs/GroundTargetConfig.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 35ee36b62afb47cd817570f494b93eae
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData:
+  assetBundleName:
+  assetBundleVariant:

Assets/CONTENT/FEATURES/MapRadar/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6bc910aee46640ce911e111e1b7376b2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

Assets/CONTENT/FEATURES/MapRadar/Editor/MapCoordinateSystemEditor.cs

@@ -0,0 +1,167 @@
+using UnityEditor;
+using UnityEngine;
+
+[CustomEditor(typeof(MapCoordinateSystem))]
+public sealed class MapCoordinateSystemEditor : Editor
+{
+    public override void OnInspectorGUI()
+    {
+        DrawDefaultInspector();
+        EditorGUILayout.HelpBox(
+            "Select MapCoordinates to display its grid and live crosshair coordinates in the Scene view. " +
+            "This visualization is not rendered in the Game view or in builds.",
+            MessageType.Info);
+    }
+
+    private void OnSceneGUI()
+    {
+        MapCoordinateSystem coordinateSystem = (MapCoordinateSystem)target;
+        if (!coordinateSystem.ShowSceneVisualization || !coordinateSystem.HasValidCorners())
+            return;
+
+        DrawGrid(coordinateSystem);
+        DrawCorners(coordinateSystem);
+        DrawCrosshairs(coordinateSystem);
+        DrawTargets(coordinateSystem);
+        DrawPlayers(coordinateSystem);
+    }
+
+    private static void DrawGrid(MapCoordinateSystem coordinateSystem)
+    {
+        int divisions = coordinateSystem.GridDivisions;
+        GUIStyle labelStyle = CreateLabelStyle(coordinateSystem.BoundaryColor);
+
+        for (int index = 0; index <= divisions; index++)
+        {
+            float normalized = (float)index / divisions;
+
+            Vector3 verticalStart = Vector3.Lerp(
+                coordinateSystem.BottomLeft.position,
+                coordinateSystem.BottomRight.position,
+                normalized);
+            Vector3 verticalEnd = Vector3.Lerp(
+                coordinateSystem.TopLeft.position,
+                coordinateSystem.TopRight.position,
+                normalized);
+            Vector3 horizontalStart = Vector3.Lerp(
+                coordinateSystem.BottomLeft.position,
+                coordinateSystem.TopLeft.position,
+                normalized);
+            Vector3 horizontalEnd = Vector3.Lerp(
+                coordinateSystem.BottomRight.position,
+                coordinateSystem.TopRight.position,
+                normalized);
+
+            bool isBoundary = index == 0 || index == divisions;
+            Handles.color = isBoundary ? coordinateSystem.BoundaryColor : coordinateSystem.GridColor;
+            Handles.DrawLine(verticalStart, verticalEnd);
+            Handles.DrawLine(horizontalStart, horizontalEnd);
+
+            if (!coordinateSystem.ShowCoordinateLabels)
+                continue;
+
+            float horizontalCoordinate = coordinateSystem.MaximumCoordinates.x * normalized;
+            float verticalCoordinate = coordinateSystem.MaximumCoordinates.y * normalized;
+            Handles.Label(verticalStart, horizontalCoordinate.ToString("0.##"), labelStyle);
+            Handles.Label(horizontalStart, verticalCoordinate.ToString("0.##"), labelStyle);
+        }
+    }
+
+    private static void DrawCorners(MapCoordinateSystem coordinateSystem)
+    {
+        Handles.color = coordinateSystem.BoundaryColor;
+        DrawCorner(coordinateSystem.BottomLeft, "(0, 0)", coordinateSystem);
+        DrawCorner(
+            coordinateSystem.BottomRight,
+            $"({coordinateSystem.MaximumCoordinates.x:0.##}, 0)",
+            coordinateSystem);
+        DrawCorner(
+            coordinateSystem.TopLeft,
+            $"(0, {coordinateSystem.MaximumCoordinates.y:0.##})",
+            coordinateSystem);
+        DrawCorner(
+            coordinateSystem.TopRight,
+            $"({coordinateSystem.MaximumCoordinates.x:0.##}, " +
+            $"{coordinateSystem.MaximumCoordinates.y:0.##})",
+            coordinateSystem);
+    }
+
+    private static void DrawCorner(
+        Transform corner,
+        string label,
+        MapCoordinateSystem coordinateSystem)
+    {
+        float size = coordinateSystem.MarkerSize * HandleUtility.GetHandleSize(corner.position);
+        Handles.SphereHandleCap(0, corner.position, Quaternion.identity, size, EventType.Repaint);
+
+        if (coordinateSystem.ShowCoordinateLabels)
+            Handles.Label(corner.position, label, CreateLabelStyle(coordinateSystem.BoundaryColor));
+    }
+
+    private static void DrawCrosshairs(MapCoordinateSystem coordinateSystem)
+    {
+        MapController[] controllers =
+            Object.FindObjectsByType<MapController>(FindObjectsSortMode.None);
+
+        foreach (MapController controller in controllers)
+        {
+            if (controller.CoordinateSystem != coordinateSystem || controller.CrosshairVisual == null)
+                continue;
+
+            Vector3 position = controller.CrosshairVisual.position;
+            Vector2 coordinates = coordinateSystem.WorldPositionToCoordinates(position);
+            float size = coordinateSystem.MarkerSize * 1.35f * HandleUtility.GetHandleSize(position);
+
+            Handles.color = Color.yellow;
+            Handles.SphereHandleCap(0, position, Quaternion.identity, size, EventType.Repaint);
+            Handles.Label(
+                position,
+                $"Crosshair ({coordinates.x:0.00}, {coordinates.y:0.00})",
+                CreateLabelStyle(Color.yellow));
+        }
+    }
+
+    private static void DrawTargets(MapCoordinateSystem coordinateSystem)
+    {
+        if (!coordinateSystem.ShowCoordinateLabels)
+            return;
+
+        MapTarget[] targets = Object.FindObjectsByType<MapTarget>(FindObjectsSortMode.None);
+        foreach (MapTarget mapTarget in targets)
+        {
+            if (mapTarget.CoordinateSystem != null && mapTarget.CoordinateSystem != coordinateSystem)
+                continue;
+
+            Vector3 position = mapTarget.transform.position;
+            Vector2 coordinates = coordinateSystem.WorldPositionToCoordinates(position);
+            Handles.Label(
+                position,
+                $"{mapTarget.name} ({coordinates.x:0.00}, {coordinates.y:0.00})",
+                CreateLabelStyle(Color.red));
+        }
+    }
+
+    private static void DrawPlayers(MapCoordinateSystem coordinateSystem)
+    {
+        MapPlayer[] players = Object.FindObjectsByType<MapPlayer>(FindObjectsSortMode.None);
+        foreach (MapPlayer mapPlayer in players)
+        {
+            if (mapPlayer.CoordinateSystem != null && mapPlayer.CoordinateSystem != coordinateSystem)
+                continue;
+
+            Vector3 position = mapPlayer.transform.position;
+            Vector2 coordinates = coordinateSystem.WorldPositionToCoordinates(position);
+            Handles.Label(
+                position,
+                $"MapPlayer ({coordinates.x:0.00}, {coordinates.y:0.00})",
+                CreateLabelStyle(Color.green));
+        }
+    }
+
+    private static GUIStyle CreateLabelStyle(Color color)
+    {
+        GUIStyle style = new(EditorStyles.boldLabel);
+        style.normal.textColor = color;
+        return style;
+    }
+}

Assets/CONTENT/FEATURES/MapRadar/Editor/MapCoordinateSystemEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7c020017978644e9be71242ece0e6011
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

Assets/CONTENT/FEATURES/MapRadar/Editor/MapTargetControllerEditor.cs

@@ -0,0 +1,25 @@
+using UnityEditor;
+using UnityEngine;
+
+[CustomEditor(typeof(MapTargetController))]
+public sealed class MapTargetControllerEditor : Editor
+{
+    public override void OnInspectorGUI()
+    {
+        DrawDefaultInspector();
+        EditorGUILayout.Space();
+
+        using (new EditorGUI.DisabledScope(!Application.isPlaying))
+        {
+            if (GUILayout.Button("Start Next Wave"))
+                ((MapTargetController)target).StartNextWave();
+        }
+
+        if (!Application.isPlaying)
+        {
+            EditorGUILayout.HelpBox(
+                "Start Next Wave becomes available in Play Mode.",
+                MessageType.Info);
+        }
+    }
+}

Assets/CONTENT/FEATURES/MapRadar/Editor/MapTargetControllerEditor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 09f50d05321d420f86622f0dc7a6fa14

Assets/CONTENT/FEATURES/MapRadar/GroundTarget.cs

@@ -0,0 +1,4 @@
+[UnityEngine.DisallowMultipleComponent]
+public sealed class GroundTarget : MapTarget
+{
+}

Assets/CONTENT/FEATURES/MapRadar/GroundTarget.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8be0d56377aa4082a276cfe31702e80c

Assets/CONTENT/FEATURES/MapRadar/MapController.cs

@@ -0,0 +1,100 @@
+using UnityEngine;
+using UnityEngine.Serialization;
+
+[DisallowMultipleComponent]
+public sealed class MapController : MonoBehaviour
+{
+    [Header("Main References")]
+    [SerializeField] private MapCrosshairController crosshair = null;
+    [SerializeField] private MapCoordinateSystem coordinateSystem = null;
+    [SerializeField] private MapPlayer mapPlayer = null;
+
+    [Header("Target System")]
+    [SerializeField] private MapTargetController targetController = null;
+    [SerializeField] private Transform targetParent = null;
+
+    [Header("Radar System")]
+    [SerializeField] private MapRadarController radarController = null;
+    [FormerlySerializedAs("targetPrefab")]
+    [SerializeField] private MapTarget radarMarkPrefab = null;
+
+    [Header("Crosshair Objects")]
+    [SerializeField] private Transform relayX = null;
+    [SerializeField] private Transform relayY = null;
+    [SerializeField] private Transform crosshairVisual = null;
+
+    [Header("Input")]
+    [SerializeField, Min(0f)] private float movementSpeed = 1f;
+    [SerializeField] private bool useKeyboardInput = true;
+
+    public MapCoordinateSystem CoordinateSystem => coordinateSystem;
+    public Transform CrosshairVisual => crosshairVisual;
+
+    private void Awake()
+    {
+        if (mapPlayer != null)
+            mapPlayer.Configure(coordinateSystem);
+
+        if (targetController != null)
+            targetController.Configure(coordinateSystem, targetParent, mapPlayer);
+
+        if (radarController != null)
+            radarController.Configure(coordinateSystem, targetController, radarMarkPrefab);
+
+        if (crosshair == null)
+            return;
+
+        crosshair.Configure(
+            coordinateSystem,
+            relayX,
+            relayY,
+            crosshairVisual,
+            movementSpeed,
+            useKeyboardInput,
+            targetController);
+
+    }
+
+    public void SetHorizontalAxis(float value)
+    {
+        if (crosshair != null)
+            crosshair.SetHorizontalAxis(value);
+    }
+
+    public void SetVerticalAxis(float value)
+    {
+        if (crosshair != null)
+            crosshair.SetVerticalAxis(value);
+    }
+
+    public Vector2 GetCrosshairCoordinates()
+    {
+        return crosshair != null ? crosshair.GetCrosshairCoordinates() : Vector2.zero;
+    }
+
+    public void CreateAndPlaceTargets()
+    {
+        if (targetController != null)
+            targetController.CreateAndPlaceTargets();
+    }
+
+    public bool StartNextWave()
+    {
+        return targetController != null && targetController.StartNextWave();
+    }
+
+    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()
+    {
+        return radarController != null && radarController.ActivateRadar();
+    }
+}

Assets/CONTENT/FEATURES/MapRadar/MapController.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5a5f18d44c314323a2550f92ba7d988a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

Assets/CONTENT/FEATURES/MapRadar/MapCoordinateSystem.cs

@@ -0,0 +1,147 @@
+using UnityEngine;
+
+[DisallowMultipleComponent]
+public sealed class MapCoordinateSystem : MonoBehaviour
+{
+    public const float CoordinateMaximum = 10f;
+
+    [Header("Coordinate Bounds")]
+    [SerializeField] private Transform bottomLeft = null;
+    [SerializeField] private Transform bottomRight = null;
+    [SerializeField] private Transform topLeft = null;
+    [SerializeField] private Transform topRight = null;
+
+    [Header("Square Bounds")]
+    [SerializeField, Min(0.001f)] private float squareSize = 5.14925f;
+
+    [Header("Scene View Visualization")]
+    [SerializeField] private bool showSceneVisualization = true;
+    [SerializeField, Range(1, 20)] private int gridDivisions = 10;
+    [SerializeField] private bool showCoordinateLabels = true;
+    [SerializeField] private Color boundaryColor = new(0f, 0.85f, 1f, 1f);
+    [SerializeField] private Color gridColor = new(0f, 0.85f, 1f, 0.3f);
+    [SerializeField, Min(0.001f)] private float markerSize = 0.06f;
+
+    public Vector2 MaximumCoordinates => new(CoordinateMaximum, CoordinateMaximum);
+    public float SquareSize => Mathf.Max(0.001f, squareSize);
+    public bool ShowSceneVisualization => showSceneVisualization;
+    public int GridDivisions => Mathf.Max(1, gridDivisions);
+    public bool ShowCoordinateLabels => showCoordinateLabels;
+    public Color BoundaryColor => boundaryColor;
+    public Color GridColor => gridColor;
+    public float MarkerSize => Mathf.Max(0.001f, markerSize);
+    public Transform BottomLeft => bottomLeft;
+    public Transform BottomRight => bottomRight;
+    public Transform TopLeft => topLeft;
+    public Transform TopRight => topRight;
+
+    private void OnValidate()
+    {
+        squareSize = Mathf.Max(0.001f, squareSize);
+        ApplySquareBounds();
+    }
+
+    public void ApplySquareBounds()
+    {
+        if (!HasValidCorners())
+            return;
+
+        Vector3 origin = bottomLeft.position;
+        Vector3 rightDirection = bottomRight.position - origin;
+        Vector3 upDirection = topLeft.position - origin;
+        if (rightDirection.sqrMagnitude <= Mathf.Epsilon || upDirection.sqrMagnitude <= Mathf.Epsilon)
+            return;
+
+        rightDirection.Normalize();
+        upDirection = Vector3.ProjectOnPlane(upDirection, rightDirection);
+        if (upDirection.sqrMagnitude <= Mathf.Epsilon)
+            return;
+
+        upDirection.Normalize();
+        float size = SquareSize;
+        bottomRight.position = origin + rightDirection * size;
+        topLeft.position = origin + upDirection * size;
+        topRight.position = origin + (rightDirection + upDirection) * size;
+    }
+
+    public Vector2 ClampCoordinates(Vector2 coordinates)
+    {
+        return new Vector2(
+            Mathf.Clamp(coordinates.x, 0f, CoordinateMaximum),
+            Mathf.Clamp(coordinates.y, 0f, CoordinateMaximum));
+    }
+
+    public Vector3 CoordinatesToWorldPosition(Vector2 coordinates)
+    {
+        if (!HasValidCorners())
+            return transform.position;
+
+        Vector2 clamped = ClampCoordinates(coordinates);
+        float horizontal = clamped.x / CoordinateMaximum;
+        float vertical = clamped.y / CoordinateMaximum;
+
+        Vector3 bottom = Vector3.Lerp(bottomLeft.position, bottomRight.position, horizontal);
+        Vector3 top = Vector3.Lerp(topLeft.position, topRight.position, horizontal);
+        return Vector3.Lerp(bottom, top, vertical);
+    }
+
+    public Vector2 WorldPositionToCoordinates(Vector3 worldPosition)
+    {
+        if (!HasValidCorners())
+            return Vector2.zero;
+
+        Vector3 horizontalEdge = bottomRight.position - bottomLeft.position;
+        Vector3 verticalEdge = topLeft.position - bottomLeft.position;
+        Vector3 fromBottomLeft = worldPosition - bottomLeft.position;
+
+        float horizontal = horizontalEdge.sqrMagnitude > Mathf.Epsilon
+            ? Vector3.Dot(fromBottomLeft, horizontalEdge) / horizontalEdge.sqrMagnitude
+            : 0f;
+        float vertical = verticalEdge.sqrMagnitude > Mathf.Epsilon
+            ? Vector3.Dot(fromBottomLeft, verticalEdge) / verticalEdge.sqrMagnitude
+            : 0f;
+
+        for (int iteration = 0; iteration < 6; iteration++)
+        {
+            Vector3 current = BilinearPosition(horizontal, vertical);
+            Vector3 error = worldPosition - current;
+            Vector3 horizontalDerivative = Vector3.Lerp(
+                bottomRight.position - bottomLeft.position,
+                topRight.position - topLeft.position,
+                vertical);
+            Vector3 verticalDerivative = Vector3.Lerp(
+                topLeft.position - bottomLeft.position,
+                topRight.position - bottomRight.position,
+                horizontal);
+
+            float horizontalLength = Vector3.Dot(horizontalDerivative, horizontalDerivative);
+            float mixedLength = Vector3.Dot(horizontalDerivative, verticalDerivative);
+            float verticalLength = Vector3.Dot(verticalDerivative, verticalDerivative);
+            float determinant = horizontalLength * verticalLength - mixedLength * mixedLength;
+            if (Mathf.Abs(determinant) <= Mathf.Epsilon)
+                break;
+
+            float horizontalError = Vector3.Dot(horizontalDerivative, error);
+            float verticalError = Vector3.Dot(verticalDerivative, error);
+            horizontal += (horizontalError * verticalLength - verticalError * mixedLength) / determinant;
+            vertical += (verticalError * horizontalLength - horizontalError * mixedLength) / determinant;
+        }
+
+        Vector2 coordinates = new(
+            horizontal * CoordinateMaximum,
+            vertical * CoordinateMaximum);
+        return ClampCoordinates(coordinates);
+    }
+
+    private Vector3 BilinearPosition(float horizontal, float vertical)
+    {
+        Vector3 bottom = Vector3.LerpUnclamped(bottomLeft.position, bottomRight.position, horizontal);
+        Vector3 top = Vector3.LerpUnclamped(topLeft.position, topRight.position, horizontal);
+        return Vector3.LerpUnclamped(bottom, top, vertical);
+    }
+
+    public bool HasValidCorners()
+    {
+        return bottomLeft != null && bottomRight != null && topLeft != null && topRight != null;
+    }
+}

Assets/CONTENT/FEATURES/MapRadar/MapCoordinateSystem.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7206111709094332bdc9b4c7c44695b4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

Assets/CONTENT/FEATURES/MapRadar/MapCrosshairController.cs

@@ -0,0 +1,181 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+[DisallowMultipleComponent]
+public sealed class MapCrosshairController : MonoBehaviour
+{
+    [Header("Nearest Target (Runtime)")]
+    [SerializeField] private MapTarget nearestTarget = null;
+    [SerializeField] private float distanceToNearestTarget = -1f;
+
+    private MapCoordinateSystem coordinateSystem;
+    private MapTargetController targetController;
+    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 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()
+    {
+        if (!isConfigured)
+            return;
+
+        if (useKeyboardInput)
+            ReadKeyboardInput();
+
+        Vector2 movement = new(horizontalAxis, verticalAxis);
+        crosshairCoordinates += movement * (movementSpeed * Time.deltaTime);
+        crosshairCoordinates = coordinateSystem.ClampCoordinates(crosshairCoordinates);
+        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 bool TryGetNearestTarget(out MapTarget target, out float distance)
+    {
+        target = nearestTarget;
+        distance = distanceToNearestTarget;
+        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;
+
+        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())
+            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;
+
+        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;
+    }
+
+    private void UpdateNearestTarget()
+    {
+        nearestTarget = null;
+        distanceToNearestTarget = -1f;
+
+        if (targetController == null)
+            return;
+
+        float nearestSqrDistance = float.PositiveInfinity;
+        foreach (MapTarget target in targetController.Targets)
+        {
+            if (target == null)
+                continue;
+
+            float sqrDistance = (target.MapCoordinates - crosshairCoordinates).sqrMagnitude;
+            if (sqrDistance >= nearestSqrDistance)
+                continue;
+
+            nearestSqrDistance = sqrDistance;
+            nearestTarget = target;
+        }
+
+        if (nearestTarget != null)
+            distanceToNearestTarget = Mathf.Sqrt(nearestSqrDistance);
+    }
+}

Assets/CONTENT/FEATURES/MapRadar/MapCrosshairController.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f1eaeed1aba94e03b8f4b98a580444de
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

Assets/CONTENT/FEATURES/MapRadar/MapPlayer.cs

@@ -0,0 +1,36 @@
+using UnityEngine;
+
+[DisallowMultipleComponent]
+public sealed class MapPlayer : MonoBehaviour
+{
+    [Header("Map Position")]
+    [SerializeField] private Vector2 mapCoordinates = new(5f, 5f);
+
+    private MapCoordinateSystem coordinateSystem;
+
+    public Vector2 MapCoordinates => mapCoordinates;
+    public MapCoordinateSystem CoordinateSystem => coordinateSystem;
+
+    public void Configure(MapCoordinateSystem newCoordinateSystem)
+    {
+        coordinateSystem = newCoordinateSystem;
+        SetMapCoordinates(mapCoordinates);
+    }
+
+    public void SetMapCoordinates(Vector2 coordinates)
+    {
+        mapCoordinates = coordinateSystem != null
+            ? coordinateSystem.ClampCoordinates(coordinates)
+            : new Vector2(
+                Mathf.Clamp(coordinates.x, 0f, MapCoordinateSystem.CoordinateMaximum),
+                Mathf.Clamp(coordinates.y, 0f, MapCoordinateSystem.CoordinateMaximum));
+
+        if (coordinateSystem != null && coordinateSystem.HasValidCorners())
+            transform.position = coordinateSystem.CoordinatesToWorldPosition(mapCoordinates);
+    }
+
+    public Vector2 GetMapCoordinates()
+    {
+        return mapCoordinates;
+    }
+}

Assets/CONTENT/FEATURES/MapRadar/MapPlayer.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e8c0e4a1fa154b5ca06510a1443335bf

Assets/CONTENT/FEATURES/MapRadar/MapRadarController.cs

@@ -0,0 +1,113 @@
+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 CooldownRemaining => cooldownRemaining;
+    public bool IsReady => cooldownRemaining <= 0f;
+
+    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);
+
+        if (!useKeyboardInput)
+            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);
+
+        for (int index = 0; index < radarMarks.Count; index++)
+        {
+            bool hasTarget = index < targetCount && targetController.Targets[index] != null;
+            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);
+        }
+    }
+
+    private void EnsureRadarMarkCount(int requiredCount)
+    {
+        while (radarMarks.Count < requiredCount)
+        {
+            GameObject radarMark = Instantiate(radarMarkPrefab.gameObject, transform);
+            PrepareRadarMark(radarMark);
+            radarMarks.Add(radarMark);
+        }
+    }
+
+    private static void PrepareRadarMark(GameObject radarMark)
+    {
+        MapTarget targetMovement = radarMark.GetComponent<MapTarget>();
+        if (targetMovement != null)
+            targetMovement.enabled = false;
+
+        foreach (Collider targetCollider in radarMark.GetComponentsInChildren<Collider>(true))
+            targetCollider.enabled = false;
+
+        foreach (Renderer targetRenderer in radarMark.GetComponentsInChildren<Renderer>(true))
+            targetRenderer.enabled = true;
+    }
+}

Assets/CONTENT/FEATURES/MapRadar/MapRadarController.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 168bf77c50d14e44a54a3a2e6717d012

Assets/CONTENT/FEATURES/MapRadar/MapTarget.cs

@@ -0,0 +1,102 @@
+using System;
+using UnityEngine;
+
+[DisallowMultipleComponent]
+public class MapTarget : MonoBehaviour
+{
+    [Header("Target State (Runtime)")]
+    [SerializeField] private TargetConfig config;
+    [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;
+
+    public Vector2 MapCoordinates => mapCoordinates;
+    public MapCoordinateSystem CoordinateSystem => coordinateSystem;
+    public TargetConfig Config => config;
+    public MapPlayer Player => player;
+    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()
+    {
+        if (!isConfigured)
+            return;
+
+        TickAttackTimer(Time.deltaTime);
+        TickMovement(Time.deltaTime);
+    }
+
+    public void SetMapCoordinates(Vector2 coordinates)
+    {
+        mapCoordinates = coordinateSystem != null
+            ? coordinateSystem.ClampCoordinates(coordinates)
+            : new Vector2(
+                Mathf.Clamp(coordinates.x, 0f, MapCoordinateSystem.CoordinateMaximum),
+                Mathf.Clamp(coordinates.y, 0f, MapCoordinateSystem.CoordinateMaximum));
+
+        if (isConfigured)
+            transform.position = coordinateSystem.CoordinatesToWorldPosition(mapCoordinates);
+    }
+
+    public Vector2 GetMapCoordinates()
+    {
+        return mapCoordinates;
+    }
+
+    public void SetVisualsVisible(bool isVisible)
+    {
+        if (targetRenderers == null)
+            targetRenderers = GetComponentsInChildren<Renderer>(true);
+
+        foreach (Renderer targetRenderer in targetRenderers)
+        {
+            if (targetRenderer != null)
+                targetRenderer.enabled = isVisible;
+        }
+    }
+
+    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);
+    }
+}

Assets/CONTENT/FEATURES/MapRadar/MapTarget.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2ae53f81d9ed4a0fb8d3496feac79ca1

Assets/CONTENT/FEATURES/MapRadar/MapTargetController.cs

@@ -0,0 +1,172 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+[DisallowMultipleComponent]
+public sealed class MapTargetController : MonoBehaviour
+{
+    [Header("Random Wave Settings")]
+    [SerializeField, Min(0)] private int targetsPerWave = 5;
+    [SerializeField] private TargetConfig[] randomTargetConfigs = System.Array.Empty<TargetConfig>();
+
+    [Header("Current Wave (Runtime)")]
+    [SerializeField, Min(0)] private int currentWave;
+    [SerializeField] private List<MapTarget> currentWaveTargets = new();
+
+    private readonly List<MapTarget> pooledTargets = new();
+    private MapCoordinateSystem coordinateSystem;
+    private Transform targetParent;
+    private MapPlayer player;
+    private bool isConfigured;
+
+    public IReadOnlyList<MapTarget> Targets => currentWaveTargets;
+    public int CurrentWave => currentWave;
+    public int TargetsPerWave => targetsPerWave;
+
+    private void Start()
+    {
+        if (currentWave == 0)
+            StartNextWave();
+    }
+
+    private void OnValidate()
+    {
+        targetsPerWave = Mathf.Max(0, targetsPerWave);
+        currentWave = Mathf.Max(0, currentWave);
+    }
+
+    public void Configure(
+        MapCoordinateSystem newCoordinateSystem,
+        Transform newTargetParent,
+        MapPlayer newPlayer)
+    {
+        coordinateSystem = newCoordinateSystem;
+        targetParent = newTargetParent != null ? newTargetParent : transform;
+        player = newPlayer;
+        isConfigured = coordinateSystem != null && coordinateSystem.HasValidCorners();
+
+        pooledTargets.Clear();
+        foreach (MapTarget existingTarget in targetParent.GetComponentsInChildren<MapTarget>(true))
+        {
+            existingTarget.SetVisualsVisible(false);
+            existingTarget.gameObject.SetActive(false);
+            pooledTargets.Add(existingTarget);
+        }
+    }
+
+    public bool StartNextWave()
+    {
+        if (!isConfigured || !HasValidTargetConfig())
+        {
+            Debug.LogWarning("Target controller has no coordinate system or valid TargetConfig.", this);
+            return false;
+        }
+
+        RetireCurrentWave();
+        currentWave++;
+
+        for (int index = 0; index < targetsPerWave; index++)
+        {
+            TargetConfig config = GetRandomValidConfig();
+            if (config == null)
+                break;
+
+            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.gameObject.SetActive(true);
+            currentWaveTargets.Add(target);
+        }
+
+        return currentWaveTargets.Count > 0 || targetsPerWave == 0;
+    }
+
+    public void CreateAndPlaceTargets()
+    {
+        StartNextWave();
+    }
+
+    public void SetTargetVisualsVisible(bool isVisible)
+    {
+        foreach (MapTarget target in currentWaveTargets)
+        {
+            if (target != null)
+                target.SetVisualsVisible(isVisible);
+        }
+    }
+
+    public MapTarget GetTarget(int index)
+    {
+        return index >= 0 && index < currentWaveTargets.Count
+            ? currentWaveTargets[index]
+            : null;
+    }
+
+    private void RetireCurrentWave()
+    {
+        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();
+    }
+
+    private MapTarget GetPooledTarget(TargetConfig config)
+    {
+        for (int index = pooledTargets.Count - 1; index >= 0; index--)
+        {
+            MapTarget candidate = pooledTargets[index];
+            if (candidate == null)
+            {
+                pooledTargets.RemoveAt(index);
+                continue;
+            }
+
+            if (candidate.GetType() != config.TargetPrefab.GetType())
+                continue;
+
+            pooledTargets.RemoveAt(index);
+            return candidate;
+        }
+
+        return null;
+    }
+
+    private bool HasValidTargetConfig()
+    {
+        return GetRandomValidConfig() != null;
+    }
+
+    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));
+    }
+}

Assets/CONTENT/FEATURES/MapRadar/MapTargetController.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 06d2f3ff739a4a4ca04d749ccf14fd9c

Assets/CONTENT/FEATURES/MapRadar/MissileType.cs

@@ -0,0 +1,7 @@
+public enum MissileType
+{
+    None = 0,
+    Standard = 1,
+    AntiAir = 2,
+    AntiGround = 3
+}

Assets/CONTENT/FEATURES/MapRadar/MissileType.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7c284b720e314585add2b38671f83ccf

Assets/CONTENT/FEATURES/MapRadar/Prefabs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d88efbc6589a4404caadb566c0e28842
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/FEATURES/MapRadar/Prefabs/AirTargetTest.prefab

@@ -0,0 +1,129 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &4012125527390687084
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2929517388927179322}
+  - component: {fileID: 1898238889115289471}
+  - component: {fileID: 5321613745555827914}
+  - component: {fileID: 212733908007784450}
+  - component: {fileID: 878491239745611204}
+  m_Layer: 0
+  m_Name: AirTargetTest
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2929517388927179322
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4012125527390687084}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0.39, y: 0.39, z: 0.39}
+  m_ConstrainProportionsScale: 1
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &1898238889115289471
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4012125527390687084}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &5321613745555827914
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4012125527390687084}
+  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: c57515654cf43eb4995ae19964d2ca0b, 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!65 &212733908007784450
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4012125527390687084}
+  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!114 &878491239745611204
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4012125527390687084}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d5316cf7562b473d9513878ea906a1b2, type: 3}
+  m_Name:
+  m_EditorClassIdentifier: Assembly-CSharp::AirTarget
+  config: {fileID: 0}
+  timeUntilAttack: 0
+  mapCoordinates: {x: 0, y: 0}
+  currentHealth: 0
+  requiredMissileType: 0
+  isReadyToAttack: 0

Assets/CONTENT/FEATURES/MapRadar/Prefabs/AirTargetTest.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 7ef28d9e428a4b94ab7ea4f36fd44d9c
+PrefabImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

Assets/CONTENT/FEATURES/MapRadar/Prefabs/MapPlayer.prefab

@@ -0,0 +1,124 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &2177866398127073846
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 8348844199957468506}
+  - component: {fileID: 272982991980855488}
+  - component: {fileID: 2419606774366489511}
+  - component: {fileID: 7430463338199182122}
+  - component: {fileID: 3288838730342684678}
+  m_Layer: 0
+  m_Name: MapPlayer
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &8348844199957468506
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2177866398127073846}
+  serializedVersion: 2
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: -11.339558, y: -0.48904037, z: 8.11739}
+  m_LocalScale: {x: 0.39, y: 0.39, z: 0.39}
+  m_ConstrainProportionsScale: 1
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &272982991980855488
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2177866398127073846}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &2419606774366489511
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2177866398127073846}
+  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: b27d30c59586fb4499180239a9bd64f1, 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!65 &7430463338199182122
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2177866398127073846}
+  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!114 &3288838730342684678
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2177866398127073846}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: e8c0e4a1fa154b5ca06510a1443335bf, type: 3}
+  m_Name:
+  m_EditorClassIdentifier: Assembly-CSharp::MapPlayer
+  mapCoordinates: {x: 5, y: 5}

Assets/CONTENT/FEATURES/MapRadar/Prefabs/MapPlayer.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 87ea05b44a3faf5489e6266f985c5324
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/FEATURES/MapRadar/Prefabs/TargetTest.prefab

@@ -0,0 +1,129 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &4012125527390687084
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2929517388927179322}
+  - component: {fileID: 1898238889115289471}
+  - component: {fileID: 5321613745555827914}
+  - component: {fileID: 212733908007784450}
+  - component: {fileID: 878491239745611204}
+  m_Layer: 0
+  m_Name: TargetTest
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2929517388927179322
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4012125527390687084}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -0.42, y: 3.280054, z: 2.6187859}
+  m_LocalScale: {x: 0.39, y: 0.39, z: 0.39}
+  m_ConstrainProportionsScale: 1
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &1898238889115289471
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4012125527390687084}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &5321613745555827914
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4012125527390687084}
+  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: c57515654cf43eb4995ae19964d2ca0b, 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!65 &212733908007784450
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4012125527390687084}
+  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!114 &878491239745611204
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 4012125527390687084}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 8be0d56377aa4082a276cfe31702e80c, type: 3}
+  m_Name:
+  m_EditorClassIdentifier: Assembly-CSharp::GroundTarget
+  config: {fileID: 0}
+  timeUntilAttack: 0
+  mapCoordinates: {x: 0, y: 0}
+  currentHealth: 0
+  requiredMissileType: 0
+  isReadyToAttack: 0

Assets/CONTENT/FEATURES/MapRadar/Prefabs/TargetTest.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 985d88cac4b4daa48973a1a464a3d4e5
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/FEATURES/MapRadar/TargetConfig.cs

@@ -0,0 +1,32 @@
+using UnityEngine;
+
+[CreateAssetMenu(fileName = "TargetConfig", menuName = "Map Radar/Target Config")]
+public sealed class TargetConfig : ScriptableObject
+{
+    [Header("Target Prefab")]
+    [SerializeField] private MapTarget targetPrefab = null;
+
+    [Header("Target Stats")]
+    [SerializeField, Min(0f)] private float timeBeforeAttack = 5f;
+    [SerializeField, Min(1)] private int health = 100;
+    [SerializeField] private MissileType requiredMissileType = MissileType.Standard;
+
+    [Header("Air Target Movement")]
+    [SerializeField, Min(0f)] private float movementSpeed = 1f;
+    [SerializeField, Min(0f)] private float stoppingDistance = 0.25f;
+
+    public MapTarget TargetPrefab => targetPrefab;
+    public float TimeBeforeAttack => timeBeforeAttack;
+    public int Health => health;
+    public MissileType RequiredMissileType => requiredMissileType;
+    public float MovementSpeed => movementSpeed;
+    public float StoppingDistance => stoppingDistance;
+
+    private void OnValidate()
+    {
+        timeBeforeAttack = Mathf.Max(0f, timeBeforeAttack);
+        health = Mathf.Max(1, health);
+        movementSpeed = Mathf.Max(0f, movementSpeed);
+        stoppingDistance = Mathf.Max(0f, stoppingDistance);
+    }
+}

Assets/CONTENT/FEATURES/MapRadar/TargetConfig.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: c4e7ec8e55a847eaa5c7914bf08d1f98

Assets/CONTENT/FEATURES/MapRadar/TestMaterial.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 01fc6a03af2e2c74a8ef1cd4a6f4ad5e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/FEATURES/MapRadar/TestMaterial/Crosshair.mat

@@ -0,0 +1,137 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Crosshair
+  m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords:
+  - _EMISSION
+  m_InvalidKeywords: []
+  m_LightmapFlags: 2
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap:
+    RenderType: Opaque
+  disabledShaderPasses:
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 2800000, guid: 8b6daeadfc1e345a792cbbff1ceeabb9, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendModePreserveSpecular: 1
+    - _BumpScale: 1
+    - _ClearCoatMask: 0
+    - _ClearCoatSmoothness: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailAlbedoMapScale: 1
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _DstBlendAlpha: 0
+    - _EnvironmentReflections: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0.632
+    - _OcclusionStrength: 1
+    - _Parallax: 0.005
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 0.106
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 0
+    - _WorkflowMode: 1
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0, g: 0.9233861, b: 1, a: 1}
+    - _Color: {r: 0, g: 0.9233861, b: 1, a: 1}
+    - _EmissionColor: {r: 0.15221034, g: 1.493739, b: 1.5365998, a: 1}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &3289058871599513036
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 10

Assets/CONTENT/FEATURES/MapRadar/TestMaterial/Crosshair.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 22474510b3d8cc048bb0bc8679862784
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/FEATURES/MapRadar/TestMaterial/MapPlayer.mat

@@ -0,0 +1,137 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: MapPlayer
+  m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords:
+  - _EMISSION
+  m_InvalidKeywords: []
+  m_LightmapFlags: 2
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap:
+    RenderType: Opaque
+  disabledShaderPasses:
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 2800000, guid: 2b2440b1910ed4bb6a835e2d074a9865, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendModePreserveSpecular: 1
+    - _BumpScale: 1
+    - _ClearCoatMask: 0
+    - _ClearCoatSmoothness: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailAlbedoMapScale: 1
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _DstBlendAlpha: 0
+    - _EnvironmentReflections: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0.632
+    - _OcclusionStrength: 1
+    - _Parallax: 0.005
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 0.106
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 0
+    - _WorkflowMode: 1
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0, g: 0.0816164, b: 1, a: 1}
+    - _Color: {r: 0, g: 0.08161638, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0.23383103, b: 2.7913604, a: 1}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &3289058871599513036
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 10

Assets/CONTENT/FEATURES/MapRadar/TestMaterial/MapPlayer.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b27d30c59586fb4499180239a9bd64f1
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/FEATURES/MapRadar/TestMaterial/MapSpriteTest.png.meta

@@ -0,0 +1,117 @@
+fileFormatVersion: 2
+guid: 71c6f8835ecab4c489ead4e40a5aafef
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/FEATURES/MapRadar/TestMaterial/Target.mat

@@ -0,0 +1,137 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Target
+  m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords:
+  - _EMISSION
+  m_InvalidKeywords: []
+  m_LightmapFlags: 2
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap:
+    RenderType: Opaque
+  disabledShaderPasses:
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 2800000, guid: 8b6daeadfc1e345a792cbbff1ceeabb9, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendModePreserveSpecular: 1
+    - _BumpScale: 1
+    - _ClearCoatMask: 0
+    - _ClearCoatSmoothness: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailAlbedoMapScale: 1
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _DstBlendAlpha: 0
+    - _EnvironmentReflections: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0.632
+    - _OcclusionStrength: 1
+    - _Parallax: 0.005
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 0.106
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 0
+    - _WorkflowMode: 1
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 0, b: 0.050980568, a: 1}
+    - _Color: {r: 1, g: 0, b: 0.050980546, a: 1}
+    - _EmissionColor: {r: 2.0907834, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &3289058871599513036
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 10

Assets/CONTENT/FEATURES/MapRadar/TestMaterial/Target.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c57515654cf43eb4995ae19964d2ca0b
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/CONTENT/FEATURES/MapRadar/TestMaterial/Test.mat

@@ -0,0 +1,137 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-4452286349835602218
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 10
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Test
+  m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords:
+  - _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap:
+    RenderType: Opaque
+  disabledShaderPasses:
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendModePreserveSpecular: 1
+    - _BumpScale: 1
+    - _ClearCoatMask: 0
+    - _ClearCoatSmoothness: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailAlbedoMapScale: 1
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _DstBlendAlpha: 0
+    - _EnvironmentReflections: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.005
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 0
+    - _SmoothnessTextureChannel: 1
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 0
+    - _WorkflowMode: 1
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1

Assets/CONTENT/FEATURES/MapRadar/TestMaterial/Test.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0b8e0a594b1c84542b029378c039338e
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: