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

- 치유/보호막 스킬을 즉발 자가시전에서 투사체형 아군 1인 타겟팅으로 전환 - TargetType.SingleAlly 추가, targetOverride 매개변수로 외부 타겟 주입 지원 - PlayerSkillInput: 카메라 레이캐스트 기반 아군 탐지, 서버 검증, RPC 타겟 ID 전달 - AllyTargetIndicator: 호버 아군 위에 디스크 인디케이터 표시, 사거리/초과 색상 변경 - SpawnEffect: 타겟 방향 회전 보정 - 투사체 스폰 이펙트 에셋 생성 (치유/보호막 각각) - 인디케이터 프리팹 + URP/Unlit 머티리얼 생성 - Player 프리팹에 AllyTargetIndicator 컴포넌트 추가 및 설정 - Input.mousePosition → Mouse.current.position.ReadValue() 수정 (Input System 호환)
2026-03-31 23:06:13 +09:00
parent 2c6a65d406
commit 8cd2623163
16 changed files with 6744 additions and 112 deletions
--- a/Assets/_Game/Data/Skills/Data_Skill_Player_보호막.asset
+++ b/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}
--- a/Assets/_Game/Data/Skills/Data_Skill_Player_치유.asset
+++ b/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}
--- a/Assets/_Game/Data/Skills/Effects/Data_SkillEffect_Player_보호막_0_보호막.asset
+++ b/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
--- a/Assets/_Game/Data/Skills/Effects/Data_SkillEffect_Player_보호막_1_투사체스폰.asset
+++ b/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}
--- a/Assets/_Game/Data/Skills/Effects/Data_SkillEffect_Player_치유_0_회복.asset
+++ b/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
--- a/Assets/_Game/Data/Skills/Effects/Data_SkillEffect_Player_치유_1_투사체스폰.asset
+++ b/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}
--- a/Assets/_Game/Materials/M_AllyTargetIndicator.mat
+++ b/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
--- a/Assets/_Game/Prefabs/Player/Prefab_Player_Default.prefab
+++ b/Assets/_Game/Prefabs/Player/Prefab_Player_Default.prefab
--- a/Assets/_Game/Prefabs/UI/Prefab_AllyTargetIndicator.prefab
+++ b/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}
--- a/Assets/_Game/Scripts/Editor/AllyTargetingDebugTest.cs
+++ b/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
+    }
+}
--- a/Assets/_Game/Scripts/Player/PlayerSkillInput.cs
+++ b/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 환경에서는 메인 에디터에 탱커, 가상 플레이어 복제본에 지원 프리셋을 자동 적용합니다.
--- a/Assets/_Game/Scripts/Skills/Effects/SpawnEffect.cs
+++ b/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;
        }
    }
--- a/Assets/_Game/Scripts/Skills/SkillController.cs
+++ b/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)
--- a/Assets/_Game/Scripts/Skills/SkillEffect.cs
+++ b/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
--- a/Assets/_Game/Scripts/Skills/SkillLoadoutEntry.cs
+++ b/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)
--- a/Assets/_Game/Scripts/UI/AllyTargetIndicator.cs
+++ b/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);
+        }
+    }
+}