Map

Controller Coordinates Target System Crosshair System Radar System
2026-08-13 18:42:41 +05:00
parent 487e0d72ff
commit d559ab338a
33 changed files with 2591 additions and 6 deletions
@@ -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: []
@@ -11,9 +11,7 @@ Material:
  m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
  m_Parent: {fileID: 0}
  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords:
-  - _GLOSSINESS_FROM_BASE_ALPHA
-  - _SPECULAR_COLOR
+  m_ValidKeywords: []
  m_InvalidKeywords: []
  m_LightmapFlags: 4
  m_EnableInstancingVariants: 0
@@ -25,6 +25,7 @@ Material:
  m_Parent: {fileID: 0}
  m_ModifiedSerializedProperties: 0
  m_ValidKeywords:
+  - _ENVIRONMENTREFLECTIONS_OFF
  - _SPECULARHIGHLIGHTS_OFF
  m_InvalidKeywords:
  - _GLOSSYREFLECTIONS_OFF
@@ -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:
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5da4c81b147b7544e9cb44f942ad51f0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6bc910aee46640ce911e111e1b7376b2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
@@ -0,0 +1,149 @@
+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);
+    }
+
+    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 GUIStyle CreateLabelStyle(Color color)
+    {
+        GUIStyle style = new(EditorStyles.boldLabel);
+        style.normal.textColor = color;
+        return style;
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7c020017978644e9be71242ece0e6011
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
@@ -0,0 +1,98 @@
+using UnityEngine;
+
+[DisallowMultipleComponent]
+public sealed class MapController : MonoBehaviour
+{
+    [Header("Main References")]
+    [SerializeField] private MapCrosshairController crosshair = null;
+    [SerializeField] private MapCoordinateSystem coordinateSystem = null;
+
+    [Header("Target System")]
+    [SerializeField] private MapTargetController targetController = null;
+    [SerializeField] private MapTarget targetPrefab = null;
+    [SerializeField] private Transform targetParent = null;
+    [SerializeField] private bool createTargetsOnStart = true;
+
+    [Header("Radar System")]
+    [SerializeField] private MapRadarController radarController = 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 (targetController != null)
+        {
+            targetController.Configure(
+                coordinateSystem,
+                targetPrefab,
+                targetParent);
+
+            if (createTargetsOnStart)
+                targetController.CreateAndPlaceTargets();
+        }
+
+        if (radarController != null)
+            radarController.Configure(coordinateSystem, targetController, targetPrefab);
+
+        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 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();
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5a5f18d44c314323a2550f92ba7d988a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
@@ -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;
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7206111709094332bdc9b4c7c44695b4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
@@ -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);
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f1eaeed1aba94e03b8f4b98a580444de
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
@@ -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;
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 168bf77c50d14e44a54a3a2e6717d012
@@ -0,0 +1,88 @@
+using UnityEngine;
+
+[DisallowMultipleComponent]
+public sealed class MapTarget : MonoBehaviour
+{
+    [Header("Map Position (Runtime)")]
+    [SerializeField] private Vector2 mapCoordinates;
+
+    private MapCoordinateSystem coordinateSystem;
+    private Vector2 movementDirection;
+    private float movementSpeed;
+    private bool isConfigured;
+    private Renderer[] targetRenderers;
+
+    public Vector2 MapCoordinates => mapCoordinates;
+    public MapCoordinateSystem CoordinateSystem => coordinateSystem;
+
+    public void Configure(
+        MapCoordinateSystem newCoordinateSystem,
+        Vector2 startCoordinates,
+        float newMovementSpeed,
+        Vector2 initialDirection)
+    {
+        coordinateSystem = newCoordinateSystem;
+        movementSpeed = Mathf.Max(0f, newMovementSpeed);
+        movementDirection = initialDirection.sqrMagnitude > Mathf.Epsilon
+            ? initialDirection.normalized
+            : Vector2.right;
+        isConfigured = coordinateSystem != null && coordinateSystem.HasValidCorners();
+        SetMapCoordinates(startCoordinates);
+    }
+
+    private void Update()
+    {
+        if (!isConfigured || movementSpeed <= 0f)
+            return;
+
+        Vector2 nextCoordinates = mapCoordinates + movementDirection * (movementSpeed * Time.deltaTime);
+        ReflectAtMapBounds(ref nextCoordinates);
+        SetMapCoordinates(nextCoordinates);
+    }
+
+    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;
+        }
+    }
+
+    private void ReflectAtMapBounds(ref Vector2 coordinates)
+    {
+        float maximum = MapCoordinateSystem.CoordinateMaximum;
+
+        if (coordinates.x < 0f || coordinates.x > maximum)
+        {
+            movementDirection.x = -movementDirection.x;
+            coordinates.x = Mathf.Clamp(coordinates.x, 0f, maximum);
+        }
+
+        if (coordinates.y < 0f || coordinates.y > maximum)
+        {
+            movementDirection.y = -movementDirection.y;
+            coordinates.y = Mathf.Clamp(coordinates.y, 0f, maximum);
+        }
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2ae53f81d9ed4a0fb8d3496feac79ca1
@@ -0,0 +1,113 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+[DisallowMultipleComponent]
+public sealed class MapTargetController : MonoBehaviour
+{
+    [Header("Target Settings")]
+    [SerializeField, Min(0)] private int targetCount = 5;
+    [SerializeField, Min(0f)] private float targetMovementSpeed = 1f;
+
+    private readonly List<MapTarget> targets = new();
+    private MapCoordinateSystem coordinateSystem;
+    private MapTarget targetPrefab;
+    private Transform targetParent;
+    private bool isConfigured;
+
+    public IReadOnlyList<MapTarget> Targets => targets;
+    public int TargetCount => targetCount;
+    public float TargetMovementSpeed => targetMovementSpeed;
+
+    private void OnValidate()
+    {
+        targetCount = Mathf.Max(0, targetCount);
+        targetMovementSpeed = Mathf.Max(0f, targetMovementSpeed);
+    }
+
+    public void Configure(
+        MapCoordinateSystem newCoordinateSystem,
+        MapTarget newTargetPrefab,
+        Transform newTargetParent)
+    {
+        coordinateSystem = newCoordinateSystem;
+        targetPrefab = newTargetPrefab;
+        targetParent = newTargetParent != null ? newTargetParent : transform;
+        isConfigured = coordinateSystem != null &&
+                       coordinateSystem.HasValidCorners() &&
+                       targetPrefab != null;
+    }
+
+    public void CreateAndPlaceTargets()
+    {
+        if (!isConfigured)
+        {
+            Debug.LogWarning("Target system is not configured.", this);
+            return;
+        }
+
+        RegisterExistingTargets();
+
+        while (targets.Count < targetCount)
+        {
+            MapTarget target = Instantiate(targetPrefab, targetParent);
+            target.name = $"Target_{targets.Count + 1}";
+            targets.Add(target);
+        }
+
+        while (targets.Count > targetCount)
+        {
+            int lastIndex = targets.Count - 1;
+            MapTarget target = targets[lastIndex];
+            targets.RemoveAt(lastIndex);
+
+            if (target != null)
+                Destroy(target.gameObject);
+        }
+
+        for (int index = 0; index < targets.Count; index++)
+        {
+            MapTarget target = targets[index];
+            if (target == null)
+                continue;
+
+            target.Configure(
+                coordinateSystem,
+                GetRandomCoordinates(),
+                targetMovementSpeed,
+                Random.insideUnitCircle.normalized);
+            target.SetVisualsVisible(false);
+        }
+    }
+
+    public void SetTargetVisualsVisible(bool isVisible)
+    {
+        foreach (MapTarget target in targets)
+        {
+            if (target != null)
+                target.SetVisualsVisible(isVisible);
+        }
+    }
+
+    public MapTarget GetTarget(int index)
+    {
+        return index >= 0 && index < targets.Count ? targets[index] : null;
+    }
+
+    private void RegisterExistingTargets()
+    {
+        targets.Clear();
+        MapTarget[] existingTargets = targetParent.GetComponentsInChildren<MapTarget>(true);
+
+        foreach (MapTarget target in existingTargets)
+        {
+            if (target != null && !targets.Contains(target))
+                targets.Add(target);
+        }
+    }
+
+    private static Vector2 GetRandomCoordinates()
+    {
+        float maximum = MapCoordinateSystem.CoordinateMaximum;
+        return new Vector2(Random.Range(0f, maximum), Random.Range(0f, maximum));
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 06d2f3ff739a4a4ca04d749ccf14fd9c
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d88efbc6589a4404caadb566c0e28842
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,124 @@
+%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: 2ae53f81d9ed4a0fb8d3496feac79ca1, type: 3}
+  m_Name:
+  m_EditorClassIdentifier: Assembly-CSharp::MapTarget
+  mapCoordinates: {x: 0, y: 0}
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 985d88cac4b4daa48973a1a464a3d4e5
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 01fc6a03af2e2c74a8ef1cd4a6f4ad5e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -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
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 22474510b3d8cc048bb0bc8679862784
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -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: 
@@ -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
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c57515654cf43eb4995ae19964d2ca0b
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -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
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0b8e0a594b1c84542b029378c039338e
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: