feat: 아군 타게팅 시스템 구현 — SingleAlly 투사체형 치유/보호막

- 치유/보호막 스킬을 즉발 자가시전에서 투사체형 아군 1인 타겟팅으로 전환

- TargetType.SingleAlly 추가, targetOverride 매개변수로 외부 타겟 주입 지원

- PlayerSkillInput: 카메라 레이캐스트 기반 아군 탐지, 서버 검증, RPC 타겟 ID 전달

- AllyTargetIndicator: 호버 아군 위에 디스크 인디케이터 표시, 사거리/초과 색상 변경

- SpawnEffect: 타겟 방향 회전 보정

- 투사체 스폰 이펙트 에셋 생성 (치유/보호막 각각)

- 인디케이터 프리팹 + URP/Unlit 머티리얼 생성

- Player 프리팹에 AllyTargetIndicator 컴포넌트 추가 및 설정

- Input.mousePosition → Mouse.current.position.ReadValue() 수정 (Input System 호환)

Assets/_Game/Data/Skills/Data_Skill_Player_보호막.asset

@@ -34,4 +34,4 @@ MonoBehaviour:
   castStartEffects:
   - {fileID: 11400000, guid: e7d0d605c1c2449ebc41f1a713670d6b, type: 2}
   effects:
-  - {fileID: 11400000, guid: 65ed1eabc2fb73d43b86230317222608, type: 2}
+  - {fileID: 11400000, guid: 56a1bd42fcfe15f45b8accfdd52cd8ea, type: 2}

Assets/_Game/Data/Skills/Data_Skill_Player_치유.asset

@@ -33,4 +33,4 @@ MonoBehaviour:
   castStartEffects:
   - {fileID: 11400000, guid: e7d0d605c1c2449ebc41f1a713670d6b, type: 2}
   effects:
-  - {fileID: 11400000, guid: fa5f619fe89f93f4293a0d5edcfe9592, type: 2}
+  - {fileID: 11400000, guid: dcc05a9682b83014bb80da5f880094c7, type: 2}

Assets/_Game/Data/Skills/Effects/Data_SkillEffect_Player_보호막_0_보호막.asset

@@ -12,14 +12,14 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 6598d3be8b5522b4494d1f60cbc1986c, type: 3}
   m_Name: Data_SkillEffect_Player_보호막_0_보호막
   m_EditorClassIdentifier: Colosseum.Game::Colosseum.Skills.Effects.ShieldEffect
-  targetType: 1
+  targetType: 2
   targetTeam: 1
   areaCenter: 0
   areaShape: 0
   targetLayers:
     serializedVersion: 2
     m_Bits: 4294967295
-  includeCasterInArea: 1
+  includeCasterInArea: 0
   areaRadius: 6
   fanOriginDistance: 1
   fanRadius: 3

Assets/_Game/Data/Skills/Effects/Data_SkillEffect_Player_보호막_1_투사체스폰.asset

@@ -0,0 +1,32 @@
+%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: a3139ddf07cfe324fa692a88cd565e24, type: 3}
+  m_Name: "Data_SkillEffect_Player_\uBCF4\uD638\uB9C9_1_\uD22C\uC0AC\uCCB4\uC2A4\uD3F0"
+  m_EditorClassIdentifier: Colosseum.Game::Colosseum.Skills.Effects.SpawnEffect
+  targetType: 2
+  targetTeam: 1
+  areaCenter: 0
+  areaShape: 0
+  targetLayers:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  areaRadius: 3
+  fanOriginDistance: 1
+  fanRadius: 3
+  fanHalfAngle: 45
+  prefab: {fileID: 7991191450305394598, guid: b8e3d022f0a2ce84da42fe4afd4a1b13, type: 3}
+  spawnLocation: 1
+  spawnOffset: {x: 0, y: 1, z: 0}
+  parentToCaster: 0
+  autoDestroyTime: 0
+  useCombatContextTarget: 0
+  hitEffect: {fileID: 11400000, guid: 65ed1eabc2fb73d43b86230317222608, type: 2}

Assets/_Game/Data/Skills/Effects/Data_SkillEffect_Player_치유_0_회복.asset

@@ -12,7 +12,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: abc224c01f587d447bc8df723ef522ba, type: 3}
   m_Name: Data_SkillEffect_Player_치유_0_회복
   m_EditorClassIdentifier: Colosseum.Game::Colosseum.Skills.Effects.HealEffect
-  targetType: 0
+  targetType: 2
   targetTeam: 1
   areaCenter: 0
   areaShape: 0

Assets/_Game/Data/Skills/Effects/Data_SkillEffect_Player_치유_1_투사체스폰.asset

@@ -0,0 +1,32 @@
+%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: a3139ddf07cfe324fa692a88cd565e24, type: 3}
+  m_Name: "Data_SkillEffect_Player_\uCE58\uC720_1_\uD22C\uC0AC\uCCB4\uC2A4\uD3F0"
+  m_EditorClassIdentifier: Colosseum.Game::Colosseum.Skills.Effects.SpawnEffect
+  targetType: 2
+  targetTeam: 1
+  areaCenter: 0
+  areaShape: 0
+  targetLayers:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  areaRadius: 3
+  fanOriginDistance: 1
+  fanRadius: 3
+  fanHalfAngle: 45
+  prefab: {fileID: 7991191450305394598, guid: b8e3d022f0a2ce84da42fe4afd4a1b13, type: 3}
+  spawnLocation: 1
+  spawnOffset: {x: 0, y: 1, z: 0}
+  parentToCaster: 0
+  autoDestroyTime: 0
+  useCombatContextTarget: 0
+  hitEffect: {fileID: 11400000, guid: fa5f619fe89f93f4293a0d5edcfe9592, type: 2}

Assets/_Game/Materials/M_AllyTargetIndicator.mat

@@ -0,0 +1,71 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-4360240177802960395
+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: Unity.RenderPipelines.Universal.Editor::UnityEditor.Rendering.Universal.AssetVersion
+  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: M_AllyTargetIndicator
+  m_Shader: {fileID: 4800000, guid: 650dd9526735d5b46b79224bc6e94025, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  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}
+    - _MainTex:
+        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
+    - _BlendOp: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DstBlend: 0
+    - _DstBlendAlpha: 0
+    - _QueueOffset: 0
+    - _SampleGI: 0
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 0
+    - _XRMotionVectorsPass: 1
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1

Assets/_Game/Prefabs/UI/Prefab_AllyTargetIndicator.prefab

@@ -0,0 +1,92 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &7345690831946481693
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1004148243152300642}
+  - component: {fileID: 3055153972114712672}
+  - component: {fileID: 4359618419148864466}
+  m_Layer: 0
+  m_Name: Prefab_AllyTargetIndicator
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1004148243152300642
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7345690831946481693}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0.8, y: 0.02, z: 0.8}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &3055153972114712672
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7345690831946481693}
+  m_Mesh: {fileID: 10206, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &4359618419148864466
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7345690831946481693}
+  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_ForceMeshLod: -1
+  m_MeshLodSelectionBias: 0
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: fa0eebe7baa80b049b9ff8373277ea64, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_GlobalIlluminationMeshLod: 0
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_MaskInteraction: 0
+  m_AdditionalVertexStreams: {fileID: 0}

Assets/_Game/Scripts/Editor/AllyTargetingDebugTest.cs

@@ -0,0 +1,287 @@
+using System;
+using System.Collections;
+using System.Reflection;
+
+using UnityEngine;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace Colosseum.Player
+{
+    /// <summary>
+    /// 아군 타게팅 시스템의 시각적 데모 + 설정 검증.
+    /// BalanceDummy 씬에서 TrainingDummy를 임시 아군으로 만들고,
+    /// 인디케이터 프리팹 표시 → 치유 스킬 투사체 발사를 실제로 보여줍니다.
+    /// </summary>
+    public class AllyTargetingDebugTest : MonoBehaviour
+    {
+        [Header("테스트 설정")]
+        [Tooltip("가짜 아군으로 사용할 GameObject 이름")]
+        [SerializeField] private string allyTargetName = "TrainingDummy";
+        [Tooltip("치유 스킬 에셋 경로")]
+        [SerializeField] private string healSkillPath = "Assets/_Game/Data/Skills/Data_Skill_Player_치유.asset";
+        [Tooltip("보호막 스킬 에셋 경로")]
+        [SerializeField] private string shieldSkillPath = "Assets/_Game/Data/Skills/Data_Skill_Player_보호막.asset";
+        [Tooltip("인디케이터 높이 오프셋")]
+        [Min(0f)] [SerializeField] private float indicatorHeight = 2.2f;
+        [Tooltip("시작 지연 (초)")]
+        [Min(0.5f)] [SerializeField] private float startDelay = 2f;
+
+        // 복원용
+        private TeamType originalTeamType;
+        private GameObject spawnedIndicator;
+        private GameObject allyObject;
+
+        private void Start()
+        {
+            Debug.Log("═══════════════════════════════════════════════════");
+            Debug.Log("[AllyTargetDemo] 아군 타게팅 시각적 데모 시작");
+            Debug.Log("═══════════════════════════════════════════════════");
+
+            StartCoroutine(RunDemo());
+        }
+
+        private void OnDestroy()
+        {
+            // 플레이 종료 시 복원
+            if (allyObject != null)
+            {
+                RestoreTeam();
+                DestroyIndicator();
+            }
+        }
+
+        private IEnumerator RunDemo()
+        {
+            yield return new WaitForSeconds(startDelay);
+
+            var player = FindPlayer();
+            if (player == null)
+            {
+                Debug.LogError("[AllyTargetDemo] 플레이어를 찾을 수 없습니다.");
+                EndDemo();
+                yield break;
+            }
+
+            allyObject = GameObject.Find(allyTargetName);
+            if (allyObject == null)
+            {
+                Debug.LogError($"[AllyTargetDemo] '{allyTargetName}'을(를) 찾을 수 없습니다.");
+                EndDemo();
+                yield break;
+            }
+
+            // ── 1. TrainingDummy 팀을 임시 Player로 변경 ──
+            var allyTeam = allyObject.GetComponent<Team>();
+            if (allyTeam == null)
+            {
+                Debug.LogError($"[AllyTargetDemo] {allyTargetName}에 Team 컴포넌트가 없습니다.");
+                EndDemo();
+                yield break;
+            }
+
+            originalTeamType = allyTeam.TeamType;
+            SetTeamType(allyTeam, TeamType.Player);
+            Debug.Log($"[AllyTargetDemo] {allyTargetName} 팀 변경: {originalTeamType} → Player");
+
+            // 거리 로그
+            float dist = Vector3.Distance(player.transform.position, allyObject.transform.position);
+            Debug.Log($"[AllyTargetDemo] 플레이어 ↔ 아군 거리: {dist:F1}m");
+
+            // ── 2. 인디케이터 프리팹 표시 (초록색) ──
+            yield return ShowIndicator(player, allyObject);
+
+            // ── 3. 2초 대기 (인디케이터 관찰 시간) ──
+            Debug.Log("[AllyTargetDemo] ▶ 인디케이터 표시 중... 2초 대기");
+            yield return new WaitForSeconds(2f);
+
+            // ── 4. 인디케이터 색상 빨간색으로 변경 (거리 초과 시뮬레이션) ──
+            yield return ChangeIndicatorColor(new Color(1f, 0.3f, 0.3f, 0.8f));
+            Debug.Log("[AllyTargetDemo] ▶ 인디케이터 빨간색으로 변경 (거리 초과 시뮬) — 2초 대기");
+            yield return new WaitForSeconds(2f);
+
+            // ── 5. 인디케이터 제거 후 잠시 대기 ──
+            DestroyIndicator();
+            Debug.Log("[AllyTargetDemo] ▶ 인디케이터 제거");
+            yield return new WaitForSeconds(1f);
+
+            // ── 6. 치유 스킬 실행 (투사체 발사) ──
+            Debug.Log("[AllyTargetDemo] ▶ 치유 스킬 투사체 발사...");
+            yield return ExecuteSkillVisual(player, allyObject, healSkillPath, "치유");
+            yield return new WaitForSeconds(3f);
+
+            // ── 7. 보호막 스킬 실행 (투사체 발사) ──
+            Debug.Log("[AllyTargetDemo] ▶ 보호막 스킬 투사체 발사...");
+            yield return ExecuteSkillVisual(player, allyObject, shieldSkillPath, "보호막");
+            yield return new WaitForSeconds(3f);
+
+            // ── 8. 인디케이터 다시 표시 (복원 데모) ──
+            yield return ShowIndicator(player, allyObject);
+            Debug.Log("[AllyTargetDemo] ▶ 인디케이터 최종 표시 — 3초 후 종료");
+            yield return new WaitForSeconds(3f);
+
+            // ── 9. 정리 ──
+            DestroyIndicator();
+            RestoreTeam();
+            Debug.Log("[AllyTargetDemo] 팀 복원 완료");
+
+            Debug.Log("═══════════════════════════════════════════════════");
+            Debug.Log("<color=green>[AllyTargetDemo] 데모 완료</color>");
+            Debug.Log("═══════════════════════════════════════════════════");
+
+            EndDemo();
+        }
+
+        #region 시각적 데모 단계
+
+        private IEnumerator ShowIndicator(GameObject player, GameObject ally)
+        {
+            // 플레이어의 AllyTargetIndicator에서 프리팹 참조 가져오기
+            var indicator = player.GetComponent<UI.AllyTargetIndicator>();
+            if (indicator == null)
+            {
+                Debug.LogError("[AllyTargetDemo] AllyTargetIndicator 컴포넌트가 없습니다.");
+                yield break;
+            }
+
+            var prefabField = typeof(UI.AllyTargetIndicator).GetField("indicatorPrefab",
+                BindingFlags.NonPublic | BindingFlags.Instance);
+            if (prefabField == null)
+            {
+                Debug.LogError("[AllyTargetDemo] indicatorPrefab 필드 접근 실패.");
+                yield break;
+            }
+
+            var prefab = prefabField.GetValue(indicator) as GameObject;
+            if (prefab == null)
+            {
+                Debug.LogError("[AllyTargetDemo] indicatorPrefab이 null입니다.");
+                yield break;
+            }
+
+            // 아군 머리 위에 인스턴스화
+            Vector3 pos = ally.transform.position;
+            pos.y += indicatorHeight;
+            spawnedIndicator = Instantiate(prefab, pos, Quaternion.Euler(90f, 0f, 0f));
+
+            // 초록색으로 설정
+            var renderer = spawnedIndicator.GetComponent<Renderer>();
+            if (renderer != null)
+            {
+                renderer.material.color = new Color(0.2f, 1f, 0.2f, 0.8f);
+            }
+
+            Debug.Log($"[AllyTargetDemo] 인디케이터 표시: {prefab.name} @ {ally.name} (y+{indicatorHeight})");
+            yield return null;
+        }
+
+        private IEnumerator ChangeIndicatorColor(Color color)
+        {
+            if (spawnedIndicator == null) yield break;
+
+            var renderer = spawnedIndicator.GetComponent<Renderer>();
+            if (renderer != null)
+            {
+                renderer.material.color = color;
+                Debug.Log($"[AllyTargetDemo] 인디케이터 색상 변경: ({color.r:F1}, {color.g:F1}, {color.b:F1}, {color.a:F1})");
+            }
+            yield return null;
+        }
+
+        private IEnumerator ExecuteSkillVisual(GameObject player, GameObject ally, string skillPath, string skillLabel)
+        {
+#if UNITY_EDITOR
+            var skillData = AssetDatabase.LoadAssetAtPath<Skills.SkillData>(skillPath);
+            if (skillData == null)
+            {
+                Debug.LogError($"[AllyTargetDemo] 스킬 로드 실패: {skillPath}");
+                yield break;
+            }
+
+            var entry = Skills.SkillLoadoutEntry.CreateTemporary(skillData);
+            bool hasSingleAlly = entry.HasEffectWithTargetType(Skills.TargetType.SingleAlly);
+            Debug.Log($"[AllyTargetDemo] {skillLabel}: SingleAlly 효과 있음={hasSingleAlly}");
+
+            var skillController = player.GetComponent<Skills.SkillController>();
+            if (skillController == null)
+            {
+                Debug.LogError("[AllyTargetDemo] SkillController가 없습니다.");
+                yield break;
+            }
+
+            if (skillController.IsExecutingSkill)
+            {
+                Debug.LogWarning($"[AllyTargetDemo] 스킬 실행 중 — 대기");
+                yield return new WaitUntil(() => !skillController.IsExecutingSkill);
+            }
+
+            // 플레이어를 아군 방향으로 회전
+            Vector3 direction = (ally.transform.position - player.transform.position);
+            direction.y = 0;
+            if (direction.sqrMagnitude > 0.001f)
+            {
+                player.transform.rotation = Quaternion.LookRotation(direction);
+            }
+
+            Debug.Log($"[AllyTargetDemo] {skillLabel} 실행 → 타겟: {ally.name}");
+            bool success = skillController.ExecuteSkill(entry, ally);
+
+            if (success)
+                Debug.Log($"<color=green>[AllyTargetDemo] {skillLabel} 스킬 발동 성공 — 투사체 확인!</color>");
+            else
+                Debug.LogError($"<AllyTargetDemo] {skillLabel} 스킬 발동 실패");
+#else
+            Debug.LogError("[AllyTargetDemo] 에디터 전용");
+#endif
+            yield return null;
+        }
+
+        #endregion
+
+        #region 유틸리티
+
+        private static GameObject FindPlayer()
+        {
+            var controllers = FindObjectsOfType<PlayerNetworkController>();
+            return controllers.Length > 0 ? controllers[0].gameObject : null;
+        }
+
+        private static void SetTeamType(Team team, TeamType type)
+        {
+            var field = typeof(Team).GetField("teamType",
+                BindingFlags.NonPublic | BindingFlags.Instance);
+            field?.SetValue(team, type);
+        }
+
+        private void RestoreTeam()
+        {
+            if (allyObject == null) return;
+            var allyTeam = allyObject.GetComponent<Team>();
+            if (allyTeam != null)
+            {
+                SetTeamType(allyTeam, originalTeamType);
+                Debug.Log($"[AllyTargetDemo] 팀 복원: {allyObject.name} → {originalTeamType}");
+            }
+        }
+
+        private void DestroyIndicator()
+        {
+            if (spawnedIndicator != null)
+            {
+                Destroy(spawnedIndicator);
+                spawnedIndicator = null;
+            }
+        }
+
+        private static void EndDemo()
+        {
+#if UNITY_EDITOR
+            EditorApplication.isPlaying = false;
+#endif
+        }
+
+        #endregion
+    }
+}

Assets/_Game/Scripts/Player/PlayerSkillInput.cs

@@ -4,6 +4,7 @@ using Unity.Netcode;
 using System;
 using System.Collections.Generic;
 
+using Colosseum;
 using Colosseum.Skills;
 using Colosseum.Passives;
 using Colosseum.Weapons;
@@ -77,6 +78,16 @@ namespace Colosseum.Player
         [Tooltip("행동 상태 관리자 (없으면 자동 검색)")]
         [SerializeField] private PlayerActionState actionState;
 
+        [Header("아군 타게팅 설정")]
+        [Tooltip("아군 탐지용 레이캐스트 레이어")]
+        [SerializeField] private LayerMask allyDetectionLayers;
+        [Tooltip("아군 타게팅 최대 사거리 (0이면 무제한)")]
+        [Min(0f)] [SerializeField] private float allyTargetMaxRange = 30f;
+        [Tooltip("시야 차단 확인 여부")]
+        [SerializeField] private bool requireLineOfSight = true;
+        [Tooltip("시야 차단 확인용 레이어 (벽, 바닥 등)")]
+        [SerializeField] private LayerMask lineOfSightBlockLayers;
+
         private InputSystem_Actions inputActions;
         private bool gameplayInputEnabled = true;
 
@@ -305,14 +316,27 @@ namespace Colosseum.Player
             }
 
             // 서버에 스킬 실행 요청
-            RequestSkillExecutionRpc(slotIndex);
+            // SingleAlly 스킬인 경우 커서 방향으로 아군 탐지
+            ulong targetNetworkObjectId = 0;
+            if (loadoutEntry != null && loadoutEntry.HasEffectWithTargetType(TargetType.SingleAlly))
+            {
+                GameObject allyTarget = RaycastForAllyTarget();
+                if (allyTarget != null)
+                {
+                    var networkObject = allyTarget.GetComponent<NetworkObject>();
+                    if (networkObject != null)
+                        targetNetworkObjectId = networkObject.NetworkObjectId;
+                }
+            }
+
+            RequestSkillExecutionRpc(slotIndex, targetNetworkObjectId);
         }
 
         /// <summary>
         /// 서버에 스킬 실행 요청
         /// </summary>
         [Rpc(SendTo.Server)]
-        private void RequestSkillExecutionRpc(int slotIndex)
+        private void RequestSkillExecutionRpc(int slotIndex, ulong targetNetworkObjectId = 0)
         {
             if (slotIndex < 0 || slotIndex >= skillSlots.Length)
                 return;
@@ -333,6 +357,13 @@ namespace Colosseum.Player
             if (networkController != null && networkController.Mana < actualManaCost)
                 return;
 
+            // 서버에서 타겟 유효성 검증
+            if (targetNetworkObjectId != 0 && !ValidateAllyTargetOnServer(targetNetworkObjectId))
+            {
+                Debug.Log($"[Target] 아군 타겟 검증 실패. Self로 대체합니다.");
+                targetNetworkObjectId = 0;
+            }
+
             // 마나 소모 (무기 배율 적용)
             if (networkController != null && actualManaCost > 0)
             {
@@ -340,14 +371,14 @@ namespace Colosseum.Player
             }
 
             // 모든 클라이언트에 스킬 실행 전파
-            BroadcastSkillExecutionRpc(slotIndex);
+            BroadcastSkillExecutionRpc(slotIndex, targetNetworkObjectId);
         }
 
         /// <summary>
         /// 모든 클라이언트에 스킬 실행 전파
         /// </summary>
         [Rpc(SendTo.ClientsAndHost)]
-        private void BroadcastSkillExecutionRpc(int slotIndex)
+        private void BroadcastSkillExecutionRpc(int slotIndex, ulong targetNetworkObjectId = 0)
         {
             if (slotIndex < 0 || slotIndex >= skillSlots.Length)
                 return;
@@ -356,8 +387,11 @@ namespace Colosseum.Player
             SkillData skill = loadoutEntry != null ? loadoutEntry.BaseSkill : null;
             if (skill == null) return;
 
+            // 타겟 오버라이드 해석
+            GameObject targetOverride = ResolveTargetFromNetworkId(targetNetworkObjectId);
+
             // 모든 클라이언트에서 스킬 실행 (애니메이션 포함)
-            skillController.ExecuteSkill(loadoutEntry);
+            skillController.ExecuteSkill(loadoutEntry, targetOverride);
         }
 
         /// <summary>
@@ -669,6 +703,126 @@ namespace Colosseum.Player
             }
         }
 
+        #region 아군 타게팅
+
+        /// <summary>
+        /// 카메라에서 커서 방향으로 레이캐스트하여 아군 GameObject를 탐색합니다.
+        /// SingleAlly 스킬 입력 시 호출됩니다.
+        /// </summary>
+        private GameObject RaycastForAllyTarget()
+        {
+            Camera mainCamera = Camera.main;
+            if (mainCamera == null)
+            {
+                Debug.LogWarning("[Target] Camera.main을 찾을 수 없습니다.");
+                return null;
+            }
+
+            if (allyDetectionLayers.value == 0)
+            {
+                Debug.LogWarning("[Target] allyDetectionLayers가 설정되지 않았습니다.");
+                return null;
+            }
+
+            Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);
+            float maxDistance = allyTargetMaxRange > 0f ? allyTargetMaxRange : Mathf.Infinity;
+
+            if (!Physics.Raycast(ray, out RaycastHit hit, maxDistance, allyDetectionLayers))
+                return null;
+
+            GameObject hitObject = hit.collider.gameObject;
+
+            // 팀 체크: 아군만 타겟
+            if (!Team.IsSameTeam(gameObject, hitObject))
+                return null;
+
+            // 생존 체크: 사망한 아군은 타겟 불가
+            var damageable = hitObject.GetComponent<Combat.IDamageable>();
+            if (damageable != null && damageable.IsDead)
+                return null;
+
+            // 시야 차단 체크
+            if (requireLineOfSight && lineOfSightBlockLayers.value != 0)
+            {
+                Vector3 casterPos = transform.position + Vector3.up * 1.5f;
+                Vector3 targetPos = hitObject.transform.position + Vector3.up * 1.5f;
+                Vector3 direction = targetPos - casterPos;
+                float distance = direction.magnitude;
+
+                if (Physics.Raycast(casterPos, direction.normalized, out RaycastHit losHit, distance, lineOfSightBlockLayers))
+                {
+                    if (losHit.collider.gameObject != hitObject)
+                        return null;
+                }
+            }
+
+            return hitObject;
+        }
+
+        /// <summary>
+        /// 서버에서 아군 타겟의 유효성을 검증합니다.
+        /// 팀, 거리, 생존 상태를 확인합니다.
+        /// </summary>
+        private bool ValidateAllyTargetOnServer(ulong targetNetworkObjectId)
+        {
+            if (targetNetworkObjectId == 0)
+                return false;
+
+            GameObject target = ResolveTargetFromNetworkId(targetNetworkObjectId);
+            if (target == null)
+            {
+                Debug.LogWarning("[Target] NetworkObjectId를 GameObject로 변환할 수 없습니다.");
+                return false;
+            }
+
+            // 팀 검증
+            if (!Team.IsSameTeam(gameObject, target))
+            {
+                Debug.LogWarning($"[Target] 타겟 팀 불일치: {target.name}");
+                return false;
+            }
+
+            // 생존 검증
+            var damageable = target.GetComponent<Combat.IDamageable>();
+            if (damageable != null && damageable.IsDead)
+            {
+                Debug.LogWarning($"[Target] 타겟 사망 상태: {target.name}");
+                return false;
+            }
+
+            // 거리 검증
+            if (allyTargetMaxRange > 0f)
+            {
+                float distance = Vector3.Distance(transform.position, target.transform.position);
+                if (distance > allyTargetMaxRange)
+                {
+                    Debug.LogWarning($"[Target] 타겟 거리 초과: {distance:F1}m (max={allyTargetMaxRange}m)");
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// NetworkObjectId로부터 GameObject를 해석합니다.
+        /// </summary>
+        private static GameObject ResolveTargetFromNetworkId(ulong targetNetworkObjectId)
+        {
+            if (targetNetworkObjectId == 0)
+                return null;
+
+            if (NetworkManager.Singleton == null)
+                return null;
+
+            if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(targetNetworkObjectId, out NetworkObject networkObject))
+                return networkObject != null ? networkObject.gameObject : null;
+
+            return null;
+        }
+
+        #endregion
+
         #if UNITY_EDITOR
         /// <summary>
         /// MPP 환경에서는 메인 에디터에 탱커, 가상 플레이어 복제본에 지원 프리셋을 자동 적용합니다.

Assets/_Game/Scripts/Skills/Effects/SpawnEffect.cs

@@ -87,13 +87,18 @@ namespace Colosseum.Skills.Effects
 
         private Quaternion GetSpawnRotation(GameObject caster, GameObject target)
         {
-            if (target != null && (spawnLocation == SpawnLocation.Target || spawnLocation == SpawnLocation.CasterForward))
+            // target이 있으면 항상 target 방향 우선 (SingleAlly 타게팅 지원)
+            if (target != null && target != caster)
             {
                 Vector3 lookDirection = target.transform.position - caster.transform.position;
                 if (lookDirection.sqrMagnitude > 0.0001f)
                     return Quaternion.LookRotation(lookDirection);
             }
 
+            // target이 없으면 spawnLocation 기준
+            if (spawnLocation == SpawnLocation.Target)
+                return caster.transform.rotation;
+
             return caster.transform.rotation;
         }
     }

Assets/_Game/Scripts/Skills/SkillController.cs

@@ -65,6 +65,7 @@ namespace Colosseum.Skills
         private bool waitingForEndAnimation; // EndAnimation 종료 대기 중
         private int currentRepeatCount = 1;
         private int currentIterationIndex = 0;
+        private GameObject currentTargetOverride;
 
         // 쿨타임 추적
         private Dictionary<SkillData, float> cooldownTracker = new Dictionary<SkillData, float>();
@@ -80,6 +81,7 @@ namespace Colosseum.Skills
         public Animator Animator => animator;
         public SkillCancelReason LastCancelReason => lastCancelReason;
         public string LastCancelledSkillName => lastCancelledSkillName;
+        public GameObject CurrentTargetOverride => currentTargetOverride;
 
         private void Awake()
         {
@@ -152,6 +154,25 @@ namespace Colosseum.Skills
         /// 슬롯 엔트리 기준으로 스킬 시전
         /// </summary>
         public bool ExecuteSkill(SkillLoadoutEntry loadoutEntry)
+        {
+            currentTargetOverride = null;
+            return ExecuteSkillInternal(loadoutEntry);
+        }
+
+        /// <summary>
+        /// 타겟 오버라이드와 함께 스킬 시전.
+        /// SingleAlly 타입 효과에서 외부 타겟을 사용할 때 호출합니다.
+        /// </summary>
+        public bool ExecuteSkill(SkillLoadoutEntry loadoutEntry, GameObject targetOverride)
+        {
+            currentTargetOverride = targetOverride;
+            return ExecuteSkillInternal(loadoutEntry);
+        }
+
+        /// <summary>
+        /// 스킬 시전 공통 로직
+        /// </summary>
+        private bool ExecuteSkillInternal(SkillLoadoutEntry loadoutEntry)
         {
             SkillData skill = loadoutEntry != null ? loadoutEntry.BaseSkill : null;
             if (skill == null)
@@ -217,7 +238,7 @@ namespace Colosseum.Skills
                     continue;
 
                 if (debugMode) Debug.Log($"[Skill] Cast start effect: {effect.name} (index {i})");
-                effect.ExecuteOnCast(gameObject);
+                effect.ExecuteOnCast(gameObject, currentTargetOverride);
             }
 
             if (currentCastStartAbnormalities.Count <= 0)
@@ -266,7 +287,7 @@ namespace Colosseum.Skills
                     continue;
 
                 if (debugMode) Debug.Log($"[Skill] Immediate self effect: {effect.name} (index {i})");
-                effect.ExecuteOnCast(gameObject);
+                effect.ExecuteOnCast(gameObject, currentTargetOverride);
             }
         }
 
@@ -478,7 +499,7 @@ namespace Colosseum.Skills
                     effect.DrawDebugRange(gameObject, debugDrawDuration);
                 }
 
-                effect.ExecuteOnCast(gameObject);
+                effect.ExecuteOnCast(gameObject, currentTargetOverride);
             }
 
             ApplyTriggeredAbnormalities(index, effects);
@@ -564,6 +585,7 @@ namespace Colosseum.Skills
             currentCastStartAbnormalities.Clear();
             currentTriggeredAbnormalities.Clear();
             currentTriggeredTargetsBuffer.Clear();
+            currentTargetOverride = null;
             waitingForEndAnimation = false;
             currentRepeatCount = 1;
             currentIterationIndex = 0;
@@ -589,7 +611,7 @@ namespace Colosseum.Skills
                 if (effect == null || effect.TargetType == TargetType.Self)
                     continue;
 
-                effect.CollectTargets(gameObject, currentTriggeredTargetsBuffer);
+                effect.CollectTargets(gameObject, currentTriggeredTargetsBuffer, currentTargetOverride);
             }
 
             if (currentTriggeredTargetsBuffer.Count == 0)

Assets/_Game/Scripts/Skills/SkillEffect.cs

@@ -13,7 +13,7 @@ namespace Colosseum.Skills
     public abstract class SkillEffect : ScriptableObject
     {
         [Header("대상 설정")]
-        [Tooltip("Self: 시전자, Area: 범위 내 대상")]
+        [Tooltip("Self: 시전자, Area: 범위 내 대상, SingleAlly: 아군 1인 (외부에서 타겟 주입)")]
         [SerializeField] protected TargetType targetType = TargetType.Self;
 
         [Header("Area Settings (TargetType이 Area일 때)")]
@@ -49,10 +49,10 @@ namespace Colosseum.Skills
         /// <summary>
         /// 스킬 시전 시 호출
         /// </summary>
-        public void ExecuteOnCast(GameObject caster)
+        public void ExecuteOnCast(GameObject caster, GameObject targetOverride = null)
         {
             List<GameObject> targets = new List<GameObject>();
-            CollectTargets(caster, targets);
+            CollectTargets(caster, targets, targetOverride);
 
             for (int i = 0; i < targets.Count; i++)
             {
@@ -64,7 +64,7 @@ namespace Colosseum.Skills
         /// 현재 효과가 영향을 줄 대상 목록을 수집합니다.
         /// 젬의 적중 이상상태 적용 등에서 동일한 타겟 해석을 재사용하기 위한 경로입니다.
         /// </summary>
-        public void CollectTargets(GameObject caster, List<GameObject> destination)
+        public void CollectTargets(GameObject caster, List<GameObject> destination, GameObject targetOverride = null)
         {
             if (caster == null || destination == null)
                 return;
@@ -78,6 +78,13 @@ namespace Colosseum.Skills
                 case TargetType.Area:
                     CollectAreaTargets(caster, destination);
                     break;
+
+                case TargetType.SingleAlly:
+                    if (targetOverride != null && IsCorrectTeam(caster, targetOverride))
+                        AddUniqueTarget(destination, targetOverride);
+                    else
+                        AddUniqueTarget(destination, caster);
+                    break;
             }
         }
 
@@ -275,7 +282,8 @@ namespace Colosseum.Skills
     public enum TargetType
     {
         Self,
-        Area
+        Area,
+        SingleAlly
     }
 
     public enum TargetTeam

Assets/_Game/Scripts/Skills/SkillLoadoutEntry.cs

@@ -489,6 +489,60 @@ namespace Colosseum.Skills
             return true;
         }
 
+        /// <summary>
+        /// 이 로드아웃에 지정한 TargetType을 사용하는 효과가 있는지 확인합니다.
+        /// 기반 스킬과 장착된 젬의 모든 효과를 검사합니다.
+        /// </summary>
+        public bool HasEffectWithTargetType(TargetType type)
+        {
+            if (baseSkill != null)
+            {
+                if (baseSkill.CastStartEffects != null && CheckEffectsForTargetType(baseSkill.CastStartEffects, type))
+                    return true;
+                if (baseSkill.Effects != null && CheckEffectsForTargetType(baseSkill.Effects, type))
+                    return true;
+            }
+
+            if (socketedGems == null)
+                return false;
+
+            for (int i = 0; i < socketedGems.Length; i++)
+            {
+                SkillGemData gem = socketedGems[i];
+                if (gem == null) continue;
+
+                if (gem.CastStartEffects != null && CheckEffectsForTargetType(gem.CastStartEffects, type))
+                    return true;
+
+                if (gem.TriggeredEffects != null)
+                {
+                    for (int j = 0; j < gem.TriggeredEffects.Count; j++)
+                    {
+                        SkillGemTriggeredEffectEntry entry = gem.TriggeredEffects[j];
+                        if (entry == null || entry.Effects == null) continue;
+
+                        if (CheckEffectsForTargetType(entry.Effects, type))
+                            return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private static bool CheckEffectsForTargetType(IReadOnlyList<SkillEffect> effects, TargetType type)
+        {
+            if (effects == null) return false;
+
+            for (int i = 0; i < effects.Count; i++)
+            {
+                if (effects[i] != null && effects[i].TargetType == type)
+                    return true;
+            }
+
+            return false;
+        }
+
         private float GetResolvedScalarMultiplier(System.Func<SkillGemData, float> selector)
         {
             if (baseSkill == null)

Assets/_Game/Scripts/UI/AllyTargetIndicator.cs

@@ -0,0 +1,200 @@
+using System;
+
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+using Colosseum.Combat;
+
+namespace Colosseum.UI
+{
+    /// <summary>
+    /// 아군 타게팅 UI 피드백 컴포넌트.
+    /// 커서가 아군 위에 있을 때 시각적 인디케이터를 표시하고,
+    /// 현재 호버 중인 아군 정보를 외부에 제공합니다.
+    /// Player 프리팹에 부착하여 사용합니다.
+    /// </summary>
+    public class AllyTargetIndicator : MonoBehaviour
+    {
+        [Header("레이캐스트 설정")]
+        [Tooltip("아군 탐지용 레이캐스트 레이어")]
+        [SerializeField] private LayerMask allyDetectionLayers;
+        [Tooltip("아군 타게팅 최대 사거리 (0이면 무제한)")]
+        [Min(0f)] [SerializeField] private float maxRange = 30f;
+        [Tooltip("시야 차단 확인 여부")]
+        [SerializeField] private bool requireLineOfSight = true;
+        [Tooltip("시야 차단 확인용 레이어")]
+        [SerializeField] private LayerMask lineOfSightBlockLayers;
+
+        [Header("인디케이터 설정")]
+        [Tooltip("타겟 위에 표시할 인디케이터 프리팹 (World Space UI)")]
+        [SerializeField] private GameObject indicatorPrefab;
+        [Tooltip("인디케이터 높이 오프셋 (타겟 위치 + 이 값)")]
+        [Min(0f)] [SerializeField] private float indicatorHeightOffset = 2.2f;
+        [Tooltip("사거리 내 아군 색상")]
+        [SerializeField] private Color inRangeColor = new Color(0.2f, 1f, 0.2f, 0.8f);
+        [Tooltip("사거리 외 아군 색상")]
+        [SerializeField] private Color outOfRangeColor = new Color(1f, 0.3f, 0.3f, 0.8f);
+
+        [Header("범위 기준")]
+        [Tooltip("SingleAlly 스킬의 사거리를 기준으로 색상을 변경합니다")]
+        [SerializeField] private bool useSkillRange = true;
+
+        private Camera mainCamera;
+        private GameObject currentIndicator;
+        private GameObject lastHoveredTarget;
+
+        /// <summary>
+        /// 현재 호버 중인 아군 GameObject
+        /// </summary>
+        public GameObject CurrentHoverTarget => lastHoveredTarget;
+
+        /// <summary>
+        /// 호버 대상이 변경되었을 때 발생합니다.
+        /// null이면 호버 대상이 없음을 의미합니다.
+        /// </summary>
+        public event Action<GameObject> OnHoverTargetChanged;
+
+        private void Start()
+        {
+            mainCamera = Camera.main;
+        }
+
+        private void Update()
+        {
+            if (mainCamera == null)
+            {
+                mainCamera = Camera.main;
+                if (mainCamera == null)
+                    return;
+            }
+
+            if (!enabled)
+                return;
+
+            GameObject newTarget = PerformRaycast();
+
+            if (newTarget != lastHoveredTarget)
+            {
+                lastHoveredTarget = newTarget;
+                UpdateIndicator();
+                OnHoverTargetChanged?.Invoke(newTarget);
+            }
+        }
+
+        /// <summary>
+        /// 카메라에서 커서 방향으로 레이캐스트하여 아군을 탐색합니다.
+        /// </summary>
+        private GameObject PerformRaycast()
+        {
+            if (allyDetectionLayers.value == 0)
+                return null;
+
+            Ray ray = mainCamera.ScreenPointToRay(Mouse.current.position.ReadValue());
+            float maxDistance = maxRange > 0f ? maxRange : Mathf.Infinity;
+
+            if (!Physics.Raycast(ray, out RaycastHit hit, maxDistance, allyDetectionLayers))
+                return null;
+
+            GameObject hitObject = hit.collider.gameObject;
+
+            // 팀 체크
+            if (!Team.IsSameTeam(gameObject, hitObject))
+                return null;
+
+            // 생존 체크
+            var damageable = hitObject.GetComponent<IDamageable>();
+            if (damageable != null && damageable.IsDead)
+                return null;
+
+            // 시야 차단 체크
+            if (requireLineOfSight && lineOfSightBlockLayers.value != 0)
+            {
+                Vector3 casterPos = transform.position + Vector3.up * 1.5f;
+                Vector3 targetPos = hitObject.transform.position + Vector3.up * 1.5f;
+                Vector3 direction = targetPos - casterPos;
+                float distance = direction.magnitude;
+
+                if (Physics.Raycast(casterPos, direction.normalized, out RaycastHit losHit, distance, lineOfSightBlockLayers))
+                {
+                    if (losHit.collider.gameObject != hitObject)
+                        return null;
+                }
+            }
+
+            return hitObject;
+        }
+
+        /// <summary>
+        /// 인디케이터 프리팹을 생성/이동/제거하여 시각 피드백을 업데이트합니다.
+        /// </summary>
+        private void UpdateIndicator()
+        {
+            if (lastHoveredTarget == null)
+            {
+                DestroyIndicator();
+                return;
+            }
+
+            if (indicatorPrefab == null)
+                return;
+
+            if (currentIndicator == null)
+            {
+                currentIndicator = Instantiate(indicatorPrefab);
+            }
+
+            // 타겟 위치에 인디케이터 배치
+            Vector3 targetPosition = lastHoveredTarget.transform.position;
+            targetPosition.y += indicatorHeightOffset;
+            currentIndicator.transform.position = targetPosition;
+
+            // 사거리에 따라 색상 변경
+            bool isInRange = true;
+            if (useSkillRange && maxRange > 0f)
+            {
+                float distance = Vector3.Distance(transform.position, lastHoveredTarget.transform.position);
+                isInRange = distance <= maxRange;
+            }
+
+            SetIndicatorColor(isInRange ? inRangeColor : outOfRangeColor);
+        }
+
+        private void DestroyIndicator()
+        {
+            if (currentIndicator != null)
+            {
+                Destroy(currentIndicator);
+                currentIndicator = null;
+            }
+        }
+
+        private void SetIndicatorColor(Color color)
+        {
+            if (currentIndicator == null)
+                return;
+
+            var renderer = currentIndicator.GetComponent<Renderer>();
+            if (renderer != null)
+            {
+                renderer.material.color = color;
+                return;
+            }
+
+#if UNITY_UI
+            // UI Toolkit / UGUI 색상 변경 (필요 시 확장)
+#endif
+        }
+
+        private void OnDestroy()
+        {
+            DestroyIndicator();
+        }
+
+        private void OnDisable()
+        {
+            DestroyIndicator();
+            lastHoveredTarget = null;
+            OnHoverTargetChanged?.Invoke(null);
+        }
+    }
+}