유닛 생성 시 미리보기 추가

src/core/main.gd

 extends Node3D
 
+const ProjectilePoolScript: GDScript = preload("res://src/core/projectile_pool.gd")
+
 ## 메인 전장 월드 씬 루트 스크립트 (Main)
 ## 스테이지 선택에 따른 맵 데이터를 동적으로 읽어 전장에 탑재합니다.
 
+## 1스테이지에서 사용할 기본 태양광 밝기입니다.
+## 값이 클수록 DirectionalLight3D가 전장을 더 강하게 비춥니다.
+@export var stage_1_light_energy: float = 1.2
+
+## 마지막 스테이지에서 사용할 태양광 밝기입니다.
+## 스테이지가 진행될수록 이 값에 가까워져 후반부 분위기가 어두워집니다.
+@export var final_stage_light_energy: float = 0.35
+
+## 스테이지 변경 시 조명 밝기가 목표값까지 전환되는 시간입니다.
+## 0 이하로 설정하면 보간 없이 즉시 밝기가 바뀝니다.
+@export var stage_light_transition_time: float = 0.6
+
+## main.tscn 루트에 배치된 주 광원입니다.
+## 스테이지별 분위기 연출을 위해 light_energy만 런타임에 조정합니다.
+@onready var _directional_light: DirectionalLight3D = $DirectionalLight3D
+
+## 스테이지가 빠르게 바뀌는 경우 이전 밝기 전환을 중단하기 위한 Tween 참조입니다.
+var _light_tween: Tween
+
+## 런타임에 생성되는 발사체 풀입니다.
+## main.tscn 원본을 직접 수정하지 않고 코드에서 노드를 붙여 프로젝트 지침을 지킵니다.
+var _projectile_pool: Node = null
+
 func _enter_tree() -> void:
 	var map_path: String = "res://src/map/stages/stage_1_map.tscn" # 기본 맵
 	if GameManager.selected_stage_map_path != "":
@@ -11,6 +36,21 @@ func _enter_tree() -> void:
 	_load_stage_background(map_path)
 	_load_stage_map(map_path)
 
+func _ready() -> void:
+	_setup_projectile_pool()
+	
+	# GameManager의 current_stage setter가 stage_changed를 발행하므로,
+	# Main은 이 신호만 구독해 스테이지 진행과 조명 연출을 느슨하게 연결합니다.
+	GameManager.stage_changed.connect(_on_stage_changed)
+	
+	# 이미 선택된 현재 스테이지 밝기를 씬 시작 시 즉시 반영합니다.
+	# 초기 밝기는 전환 애니메이션 없이 맞춰야 첫 프레임부터 의도한 분위기가 나옵니다.
+	_apply_stage_light_energy(GameManager.current_stage, true)
+	
+	# 전장 첫 진입 직후 투사체 이펙트를 미리 준비합니다.
+	# 실제 전투가 시작되기 전에 GLB, 셰이더, 파티클 리소스가 한 번 구성되도록 유도합니다.
+	_warmup_projectile_effects_deferred()
+
 func _load_stage_map(map_path: String) -> void:
 	var map_scene: PackedScene = load(map_path) as PackedScene
 	if map_scene:
@@ -47,3 +87,53 @@ func _get_background_path_for_map(map_path: String) -> String:
 			return "res://src/map/background/swamp.tscn"
 		_:
 			return ""
+
+## 발사체 풀 노드를 런타임에 생성해 Main의 자식으로 배치합니다.
+## 원거리 유닛은 projectile_pool 그룹을 통해 이 노드를 찾아 공통으로 재사용합니다.
+func _setup_projectile_pool() -> void:
+	_projectile_pool = ProjectilePoolScript.new() as Node
+	_projectile_pool.name = "ProjectilePool"
+	add_child(_projectile_pool)
+	if _projectile_pool.has_method("initialize_pool"):
+		_projectile_pool.call("initialize_pool")
+
+## 첫 전투 중 끊김을 줄이기 위해 투사체 이펙트를 지연 워밍업합니다.
+## 한 프레임 뒤에 실행하면 Main과 카메라/월드 노드가 준비된 뒤 리소스 초기화가 진행됩니다.
+func _warmup_projectile_effects_deferred() -> void:
+	await get_tree().process_frame
+	if _projectile_pool and _projectile_pool.has_method("warmup_projectile_effects"):
+		_projectile_pool.call("warmup_projectile_effects")
+
+func _on_stage_changed(stage: int) -> void:
+	# 스테이지 숫자가 바뀔 때마다 해당 진행도에 맞는 광량으로 전환합니다.
+	_apply_stage_light_energy(stage)
+
+## 스테이지 진행도에 따라 DirectionalLight3D의 밝기를 계산하고 적용합니다.
+## - 1스테이지는 stage_1_light_energy를 사용합니다.
+## - 마지막 스테이지는 final_stage_light_energy를 사용합니다.
+## - 중간 스테이지는 두 값 사이를 선형 보간합니다.
+func _apply_stage_light_energy(stage: int, instant: bool = false) -> void:
+	if not _directional_light:
+		return
+		
+	# stage_progress는 0.0(첫 스테이지)부터 1.0(마지막 스테이지)까지의 정규화된 진행도입니다.
+	# clampf로 범위를 고정해 디버그 중 비정상 스테이지 값이 들어와도 광량이 과하게 튀지 않게 합니다.
+	var stage_progress: float = 0.0
+	if GameManager.MAX_STAGE > 1:
+		stage_progress = clampf(float(stage - 1) / float(GameManager.MAX_STAGE - 1), 0.0, 1.0)
+		
+	# 진행도에 따라 밝은 초반 광량에서 어두운 후반 광량으로 자연스럽게 이동합니다.
+	var target_energy: float = lerpf(stage_1_light_energy, final_stage_light_energy, stage_progress)
+	
+	# 이전 스테이지 전환 애니메이션이 남아 있다면 중복 적용을 막기 위해 중단합니다.
+	if _light_tween:
+		_light_tween.kill()
+		
+	# 초기 적용 또는 전환 시간이 없는 설정에서는 Tween 없이 즉시 목표 밝기를 반영합니다.
+	if instant or stage_light_transition_time <= 0.0:
+		_directional_light.light_energy = target_energy
+		return
+		
+	# 실제 플레이 중 스테이지가 넘어갈 때는 짧은 보간으로 밝기를 부드럽게 바꿉니다.
+	_light_tween = create_tween()
+	_light_tween.tween_property(_directional_light, "light_energy", target_energy, stage_light_transition_time)

src/core/projectile_pool.gd

+class_name ProjectilePool
+extends Node3D
+
+## 원거리 발사체와 투사체 비주얼 이펙트를 미리 만들어 재사용하는 런타임 풀입니다.
+## - 첫 공격 순간에 PackedScene 인스턴싱, GLB 업로드, 셰이더/파티클 준비 비용이 몰리는 현상을 줄입니다.
+## - 전투 중에는 queue_free() 대신 비활성화 후 재사용하여 잦은 생성/삭제로 인한 프레임 끊김을 줄입니다.
+
+const ProjectileScript: GDScript = preload("res://src/entities/units/base/projectile.gd")
+const FIREBALL_EFFECT_SCENE: PackedScene = preload("res://src/entities/projectiles/fireball/fireball_effect.tscn")
+const ARROW_EFFECT_SCENE: PackedScene = preload("res://src/entities/projectiles/arrow/arrow_effect.tscn")
+
+const PROJECTILE_KEY_FIREBALL: String = "fireball"
+const PROJECTILE_KEY_ARROW: String = "arrow"
+const PROJECTILE_KEY_SPHERE: String = "sphere"
+
+## 전투 시작 전 미리 준비할 화염구 발사체 수입니다.
+## 마법사 수가 늘어 동시에 여러 발이 나가도 런타임 인스턴싱이 적게 발생하도록 여유분을 둡니다.
+@export var fireball_pool_size: int = 16
+
+## 전투 시작 전 미리 준비할 화살 발사체 수입니다.
+## 레인저는 공격 속도가 빠른 편이므로 화염구보다 조금 더 넉넉히 준비합니다.
+@export var arrow_pool_size: int = 24
+
+## 커스텀 비주얼을 쓰지 않는 기본 구체 발사체 예비 수입니다.
+## 현재는 fallback 용도지만, 다른 원거리 유닛이 추가될 때 재사용할 수 있습니다.
+@export var sphere_pool_size: int = 8
+
+## 워밍업 인스턴스가 잠시 배치될 위치입니다.
+## 카메라 밖/전장 밖에 두어 플레이어에게 보이지 않게 하면서 리소스 초기화를 유도합니다.
+@export var warmup_position: Vector3 = Vector3(0.0, -100.0, 0.0)
+
+var _available_projectiles: Dictionary = {}
+var _visual_scenes: Dictionary = {}
+var _is_initialized: bool = false
+
+func _ready() -> void:
+	initialize_pool()
+
+## 풀을 한 번만 초기화합니다.
+## Main에서 명시적으로 호출해도 되고, 노드가 씬 트리에 들어올 때 _ready()를 통해 자동 실행되어도 안전합니다.
+func initialize_pool() -> void:
+	if _is_initialized:
+		return
+		
+	_is_initialized = true
+	add_to_group("projectile_pool")
+	
+	_visual_scenes = {
+		PROJECTILE_KEY_FIREBALL: FIREBALL_EFFECT_SCENE,
+		PROJECTILE_KEY_ARROW: ARROW_EFFECT_SCENE,
+		PROJECTILE_KEY_SPHERE: null
+	}
+	
+	_available_projectiles.clear()
+	_available_projectiles[PROJECTILE_KEY_FIREBALL] = []
+	_available_projectiles[PROJECTILE_KEY_ARROW] = []
+	_available_projectiles[PROJECTILE_KEY_SPHERE] = []
+	
+	_create_projectiles(PROJECTILE_KEY_FIREBALL, fireball_pool_size)
+	_create_projectiles(PROJECTILE_KEY_ARROW, arrow_pool_size)
+	_create_projectiles(PROJECTILE_KEY_SPHERE, sphere_pool_size)
+
+## 지정된 종류의 발사체를 풀에 미리 생성합니다.
+## 생성 직후에는 비활성화 상태로 보관하며, 실제 공격 시 activate_from_pool()로 켭니다.
+func _create_projectiles(projectile_key: String, count: int) -> void:
+	var safe_count: int = maxi(0, count)
+	for index: int in range(safe_count):
+		var projectile: Projectile = _create_projectile(projectile_key)
+		_store_projectile(projectile_key, projectile)
+
+## 발사체 노드 하나를 생성하고 해당 종류의 비주얼 씬을 장착합니다.
+## 이 시점에 씬 트리에 붙기 때문에 _ready()에서 비주얼 인스턴스도 함께 구성됩니다.
+func _create_projectile(projectile_key: String) -> Projectile:
+	var projectile: Projectile = ProjectileScript.new() as Projectile
+	projectile.name = "PooledProjectile_" + projectile_key
+	projectile.custom_visual_scene = _visual_scenes.get(projectile_key) as PackedScene
+	projectile.projectile_pool = self
+	projectile.pool_key = projectile_key
+	add_child(projectile)
+	projectile.global_position = warmup_position
+	projectile.deactivate_for_pool()
+	return projectile
+
+## 외부 유닛이 공격할 때 호출하는 발사체 대여 함수입니다.
+## 풀이 비어 있으면 같은 경로로 새 발사체를 확장 생성하여 공격 누락을 막습니다.
+func spawn_projectile(
+	projectile_key: String,
+	fire_position: Vector3,
+	target: Node3D,
+	damage: float,
+	speed: float,
+	color: Color
+) -> Projectile:
+	initialize_pool()
+	
+	var projectile: Projectile = _take_projectile(projectile_key)
+	projectile.activate_from_pool(self, projectile_key, fire_position, target, damage, speed, color)
+	return projectile
+
+## 발사체가 충돌/소멸 조건에 도달했을 때 다시 풀로 반환됩니다.
+## Projectile 쪽에서 직접 호출하므로 이름과 시그니처를 안정적으로 유지합니다.
+func release_projectile(projectile: Projectile) -> void:
+	if not is_instance_valid(projectile):
+		return
+		
+	var projectile_key: String = projectile.pool_key
+	if not _available_projectiles.has(projectile_key):
+		projectile.queue_free()
+		return
+		
+	projectile.deactivate_for_pool()
+	_store_projectile(projectile_key, projectile)
+
+## 워밍업용으로 미리 만들어 둔 발사체를 잠깐 켰다가 다시 끕니다.
+## 실제 첫 공격 전에 비주얼 노드, 머티리얼, 파티클 리소스가 한 번 씬 트리에 올라오도록 유도합니다.
+func warmup_projectile_effects() -> void:
+	initialize_pool()
+	
+	var warmup_keys: Array[String] = [
+		PROJECTILE_KEY_FIREBALL,
+		PROJECTILE_KEY_ARROW,
+		PROJECTILE_KEY_SPHERE
+	]
+	
+	var warmup_projectiles: Array[Projectile] = []
+	for projectile_key: String in warmup_keys:
+		var projectile: Projectile = _take_projectile(projectile_key)
+		projectile.show_for_warmup(warmup_position)
+		warmup_projectiles.append(projectile)
+		
+	# 한 렌더 프레임 이상 비주얼을 씬 트리에 켜 두어 첫 사용 리소스 준비가 진행될 시간을 줍니다.
+	await get_tree().process_frame
+	await get_tree().process_frame
+	
+	for projectile: Projectile in warmup_projectiles:
+		projectile.deactivate_for_pool()
+		_store_projectile(projectile.pool_key, projectile)
+
+## 풀에서 하나를 꺼내거나, 부족하면 새로 만들어 반환합니다.
+func _take_projectile(projectile_key: String) -> Projectile:
+	if not _available_projectiles.has(projectile_key):
+		projectile_key = PROJECTILE_KEY_SPHERE
+		
+	var available: Array = _available_projectiles[projectile_key]
+	if available.is_empty():
+		return _create_projectile(projectile_key)
+		
+	return available.pop_back() as Projectile
+
+## 비활성 발사체를 해당 종류의 대기열에 넣습니다.
+func _store_projectile(projectile_key: String, projectile: Projectile) -> void:
+	if not _available_projectiles.has(projectile_key):
+		_available_projectiles[projectile_key] = []
+		
+	var available: Array = _available_projectiles[projectile_key]
+	if not available.has(projectile):
+		available.append(projectile)

src/core/projectile_pool.gd.uid

+uid://yb0vk5n52gji

src/entities/summoner/summoner.gd

@@ -26,9 +26,18 @@ var spell_mana_costs: Dictionary = {
 
 var is_initialized: bool = false
 
+## 강타(Smite) 번개 기둥에 재사용할 메쉬 리소스입니다.
+## 첫 시전 순간 CylinderMesh를 생성하지 않도록 소환사 노드 준비 시 미리 구성합니다.
+var _lightning_mesh: CylinderMesh = null
+
+## 강타(Smite) 번개 기둥에 재사용할 발광 머티리얼입니다.
+## StandardMaterial3D 생성과 emission 설정 비용을 첫 스킬 사용 전에 끝내기 위한 캐시입니다.
+var _lightning_material: StandardMaterial3D = null
+
 func _ready() -> void:
-	# setup_summoner()를 통해 외부에서 데이터를 직접 바인딩할 때까지 대기
-	pass
+	# setup_summoner()를 통해 외부에서 데이터를 직접 바인딩할 때까지 대기합니다.
+	# 비주얼 이펙트 리소스는 스킬 첫 사용 끊김을 줄이기 위해 노드 준비 시점에 미리 만듭니다.
+	_prepare_lightning_effect_resources()
 
 ## 소환사 데이터를 주입받아 초기 셋업을 완료하는 메서드
 func setup_summoner(data: SummonerData) -> void:
@@ -177,20 +186,9 @@ func _create_lightning_strike_effect(strike_pos: Vector3) -> void:
 		return
 		
 	# 1. 번개 기둥 역할을 할 실린더 메쉬 인스턴스 생성
-	var mesh_inst = MeshInstance3D.new()
-	var cyl_mesh = CylinderMesh.new()
-	cyl_mesh.top_radius = 0.05
-	cyl_mesh.bottom_radius = 0.15
-	cyl_mesh.height = 10.0
-	
-	var mat = StandardMaterial3D.new()
-	mat.albedo_color = Color(0.1, 0.6, 1.0) # 강렬한 하늘색
-	mat.emission_enabled = true
-	mat.emission = Color(0.2, 0.7, 1.0)
-	mat.emission_energy_multiplier = 4.0
-	
-	mesh_inst.mesh = cyl_mesh
-	mesh_inst.material_override = mat
+	var mesh_inst: MeshInstance3D = MeshInstance3D.new()
+	mesh_inst.mesh = _lightning_mesh
+	mesh_inst.material_override = _lightning_material
 	root.add_child(mesh_inst)
 	# 번개 기둥 위치 정렬: 하늘에서 내리치는 연출이므로 y 오프셋
 	mesh_inst.global_position = strike_pos + Vector3(0.0, 5.0, 0.0)
@@ -210,3 +208,17 @@ func _create_lightning_strike_effect(strike_pos: Vector3) -> void:
 		if is_instance_valid(flash_light):
 			flash_light.queue_free()
 	)
+
+## 강타 번개 이펙트에서 반복 사용하는 리소스를 미리 준비합니다.
+## 실제 시전 시에는 MeshInstance3D와 OmniLight3D 노드만 짧게 만들고, 메쉬/머티리얼은 여기서 만든 것을 공유합니다.
+func _prepare_lightning_effect_resources() -> void:
+	_lightning_mesh = CylinderMesh.new()
+	_lightning_mesh.top_radius = 0.05
+	_lightning_mesh.bottom_radius = 0.15
+	_lightning_mesh.height = 10.0
+	
+	_lightning_material = StandardMaterial3D.new()
+	_lightning_material.albedo_color = Color(0.1, 0.6, 1.0) # 강렬한 하늘색
+	_lightning_material.emission_enabled = true
+	_lightning_material.emission = Color(0.2, 0.7, 1.0)
+	_lightning_material.emission_energy_multiplier = 4.0

src/entities/units/base/base_unit.gd

@@ -437,12 +437,6 @@ func _show_attack_visual() -> void:
 ## 모델별 기본 공격 애니메이션 이름을 반환합니다.
 func _get_attack_animation_name(model_name: String) -> String:
 	return ""
-#	var attack_key: String = "Slash"
-#	if model_name == "ranger":
-#		attack_key = "Draw"
-#	elif model_name == "mage":
-#		attack_key = "Casting"
-#	return model_name + "/" + attack_key
 
 ## 상태(대기, 이동, 공격)별 3D 애니메이션 트랙 제어 및 크로스페이드 블렌딩
 ## 상태(대기, 이동, 공격)별 3D 애니메이션 트랙 제어 (상속 클래스에서 재정의)
@@ -456,3 +450,13 @@ func _setup_unit_visuals() -> void:
 ## 원거리 유닛의 발사체 생성을 처리하는 가상 함수
 func _spawn_projectile(_fire_position: Vector3) -> void:
 	pass
+
+## 현재 씬에서 런타임 발사체 풀을 찾아 반환합니다.
+## - Main이 ProjectilePool을 생성해 group에 등록하면 원거리 유닛은 이 경로로 풀을 공유합니다.
+## - 풀을 찾지 못하는 테스트 씬에서는 null을 반환하여 기존 직접 생성 fallback을 사용할 수 있게 합니다.
+func _get_projectile_pool() -> Node:
+	var pools: Array[Node] = get_tree().get_nodes_in_group("projectile_pool")
+	if pools.is_empty():
+		return null
+		
+	return pools[0]

src/entities/units/base/projectile.gd

@@ -13,6 +13,20 @@ var color: Color = Color(1.0, 0.9, 0.2, 1.0) # 기본 노란색 발사체
 # 커스텀 비주얼 씬 (마법사 불덩이, 레인저 화살 등 외부 씬 연동 지원)
 var custom_visual_scene: PackedScene = null
 
+## ProjectilePool에서 관리되는 경우 풀 노드 참조를 보관합니다.
+## 값이 없으면 기존 방식처럼 충돌/소멸 시 queue_free()를 사용합니다.
+var projectile_pool: Node = null
+
+## 풀 내부에서 발사체 종류를 구분하기 위한 키입니다.
+## 예: "fireball", "arrow", "sphere"
+var pool_key: String = ""
+
+## 풀에 보관 중인 비활성 발사체가 물리 처리와 충돌 판정을 하지 않도록 막는 플래그입니다.
+var _is_active: bool = true
+
+## 커스텀 비주얼 인스턴스를 한 번만 생성해 재사용하기 위한 캐시입니다.
+var _visual_inst: Node3D = null
+
 func _ready() -> void:
 	if custom_visual_scene:
 		_setup_custom_visual()
@@ -21,8 +35,8 @@ func _ready() -> void:
 
 ## 커스텀 비주얼 씬 인스턴싱하여 자식으로 장착
 func _setup_custom_visual() -> void:
-	var visual_inst: Node3D = custom_visual_scene.instantiate() as Node3D
-	add_child(visual_inst)
+	_visual_inst = custom_visual_scene.instantiate() as Node3D
+	add_child(_visual_inst)
 
 
 ## 구체 빛 구슬 비주얼 설정 (Ranger 이외 유닛 또는 arrow 로드 실패 시 Fallback)
@@ -41,15 +55,62 @@ func _setup_sphere_visual() -> void:
 	
 	mesh_instance.mesh = sphere_mesh
 	add_child(mesh_instance)
+	_visual_inst = mesh_instance
+
+## 풀에서 꺼낸 발사체에 이번 공격에 필요한 런타임 값을 주입하고 활성화합니다.
+## 같은 발사체 노드를 재사용하므로 이전 타겟/데미지/색상 상태가 남지 않도록 여기에서 모두 덮어씁니다.
+func activate_from_pool(
+	pool: Node,
+	projectile_key: String,
+	fire_position: Vector3,
+	new_target: Node3D,
+	new_damage: float,
+	new_speed: float,
+	new_color: Color
+) -> void:
+	projectile_pool = pool
+	pool_key = projectile_key
+	target = new_target
+	damage = new_damage
+	speed = new_speed
+	color = new_color
+	global_position = fire_position
+	visible = true
+	_is_active = true
+	set_physics_process(true)
+	_restart_particle_children(self)
+
+## 풀에 반환될 때 발사체를 완전히 비활성화합니다.
+## 노드는 씬 트리에 남겨 두되 보이지 않고, 물리 프레임도 소모하지 않게 만듭니다.
+func deactivate_for_pool() -> void:
+	_is_active = false
+	target = null
+	visible = false
+	global_position = Vector3(0.0, -100.0, 0.0)
+	set_physics_process(false)
+	_stop_particle_children(self)
+
+## 이펙트 워밍업 전용 활성화입니다.
+## 타겟 추적이나 충돌 처리는 하지 않고, 비주얼 자식만 잠깐 켜서 리소스 준비를 유도합니다.
+func show_for_warmup(warmup_position: Vector3) -> void:
+	_is_active = false
+	target = null
+	global_position = warmup_position
+	visible = true
+	set_physics_process(false)
+	_restart_particle_children(self)
 
 func _physics_process(delta: float) -> void:
+	if not _is_active:
+		return
+		
 	if GameManager.is_game_over:
-		queue_free()
+		_despawn()
 		return
 		
 	# 타겟이 도중에 사라지거나 사망 시 소멸
 	if not is_instance_valid(target) or target.get("is_dead") == true:
-		queue_free()
+		_despawn()
 		return
 		
 	# 타겟 높이 오프셋 보정 (몬스터 중심부 y ~= 0.5를 향하도록)
@@ -79,4 +140,31 @@ func _impact() -> void:
 		target.call("take_damage", damage)
 		
 	# 충돌 이펙트 (필요 시 연출)
+	_despawn()
+
+## 발사체 수명이 끝났을 때 풀로 반환하거나, 풀이 없으면 기존처럼 삭제합니다.
+func _despawn() -> void:
+	if projectile_pool and projectile_pool.has_method("release_projectile"):
+		projectile_pool.call("release_projectile", self)
+	else:
 		queue_free()
+
+## 재사용 발사체가 다시 발사될 때 GPUParticles3D 자식들의 방출을 재시작합니다.
+## 파티클이 중간 상태로 남아 있지 않게 emitting을 껐다 켜는 방식으로 초기화합니다.
+func _restart_particle_children(root: Node) -> void:
+	for child: Node in root.get_children():
+		if child is GPUParticles3D:
+			var particles: GPUParticles3D = child as GPUParticles3D
+			particles.emitting = false
+			particles.restart()
+			particles.emitting = true
+		_restart_particle_children(child)
+
+## 풀에 들어간 비활성 발사체의 파티클 방출을 멈춥니다.
+## 보이지 않는 발사체가 백그라운드에서 파티클 시뮬레이션 비용을 쓰지 않게 합니다.
+func _stop_particle_children(root: Node) -> void:
+	for child: Node in root.get_children():
+		if child is GPUParticles3D:
+			var particles: GPUParticles3D = child as GPUParticles3D
+			particles.emitting = false
+		_stop_particle_children(child)

src/entities/units/mage/mage_unit.gd

@@ -112,6 +112,22 @@ func _update_animations() -> void:
 
 ## 마법사(Mage) 전용 화염 불덩이(Fireball) 발사체를 월드에 스폰하는 함수
 func _spawn_projectile(fire_position: Vector3) -> void:
+	# Main에서 준비한 ProjectilePool이 있으면 미리 생성된 화염구 발사체를 재사용합니다.
+	# 이 경로가 전투 중 반복 instantiate/free를 줄여 첫 발사와 연속 발사 끊김을 완화합니다.
+	var projectile_pool: Node = _get_projectile_pool()
+	if projectile_pool and projectile_pool.has_method("spawn_projectile"):
+		projectile_pool.call(
+			"spawn_projectile",
+			"fireball",
+			fire_position,
+			_target_monster,
+			unit_data.damage,
+			18.0,
+			Color(1.0, 0.35, 0.1, 1.0)
+		)
+		return
+		
+	# ProjectilePool이 없는 독립 테스트 씬에서는 기존 방식으로 발사체를 직접 생성합니다.
 	# 공통 Projectile 스크립트를 로드하여 발사체 인스턴스를 동적 생성합니다.
 	var projectile_script: = preload("res://src/entities/units/base/projectile.gd")
 	var proj: Node3D = projectile_script.new() as Node3D

src/entities/units/ranger/ranger_unit.gd

@@ -92,6 +92,22 @@ func _update_animations() -> void:
 
 ## 레인저 전용 발사체 생성 및 스폰
 func _spawn_projectile(fire_position: Vector3) -> void:
+	# Main에서 준비한 ProjectilePool이 있으면 미리 생성된 화살 발사체를 재사용합니다.
+	# 빠르게 반복 발사되는 레인저 특성상 풀링 효과가 크며, 전투 중 생성/삭제 비용을 줄입니다.
+	var projectile_pool: Node = _get_projectile_pool()
+	if projectile_pool and projectile_pool.has_method("spawn_projectile"):
+		projectile_pool.call(
+			"spawn_projectile",
+			"arrow",
+			fire_position,
+			_target_monster,
+			unit_data.damage,
+			28.0,
+			unit_data.unit_color
+		)
+		return
+		
+	# ProjectilePool이 없는 독립 테스트 씬에서는 기존 방식으로 발사체를 직접 생성합니다.
 	var projectile_script = preload("res://src/entities/units/base/projectile.gd")
 	var proj: Node3D = projectile_script.new() as Node3D
 	

src/map/background/desert.tscn

@@ -115,4 +115,4 @@ waterDefinition = SubResource("WaterResource_gbjga")
 terrainZones = SubResource("ZonesResource_aj3fk")
 physics_interpolation_mode = 2
 top_level = true
-metadata/_edit_lock_ = true
+metadata/_edit_lock_ = false

src/ui/hero_panel/hud_hero_panel.gd

+class_name HudHeroPanel
+extends RefCounted
+
+## HUD의 영웅 소환 버튼과 영웅 상태 패널을 담당하는 보조 클래스입니다.
+## - 영웅 소환 비용/버튼 상태, 영웅 생성, 경험치/레벨/스킬 쿨다운 UI를 한곳에 모읍니다.
+## - HUD 본문은 골드 변경 시 update_gold()만 호출하고, 세부 UI 갱신은 이 클래스가 처리합니다.
+
+const HERO_SPAWN_COST: int = 500
+const DWARF_HERO_SCENE: PackedScene = preload("res://src/entities/units/hero/dwarf/dwarf_hero.tscn")
+const DWARF_PORTRAIT_PATH: String = "res://assets/ui/hero/dwarf_portrait.jpg"
+
+var _hud: Control = null
+var _placement_manager: Object = null
+
+var hero_spawn_button: Button = null
+var hero_panel: Panel = null
+var _active_hero: BaseHero = null
+var _skill_cooldown_overlays: Dictionary = {}
+var _skill_cooldown_labels: Dictionary = {}
+
+## HUD와 유닛 배치 매니저를 주입받아 영웅 버튼을 BottomBar에 추가합니다.
+## placement_manager는 일반 유닛 배치 중 영웅 소환이 겹치지 않게 상태 확인에 사용합니다.
+func setup(hud: Control, bottom_bar: Control, placement_manager: Object) -> void:
+	_hud = hud
+	_placement_manager = placement_manager
+	hero_spawn_button = _create_hero_spawn_button()
+	bottom_bar.add_child(hero_spawn_button)
+	hero_spawn_button.pressed.connect(_on_summon_hero_pressed)
+
+## 골드 변화에 따라 영웅 소환 버튼 활성 상태를 갱신합니다.
+## HUD의 _on_gold_changed()가 호출될 때 함께 호출됩니다.
+func update_gold(gold: int) -> void:
+	if hero_spawn_button:
+		hero_spawn_button.disabled = gold < HERO_SPAWN_COST
+
+## 영웅 소환 버튼을 생성하고 시각 스타일을 적용합니다.
+## 버튼은 BottomBar에 동적으로 들어가므로 hud.tscn 원본을 수정하지 않습니다.
+func _create_hero_spawn_button() -> Button:
+	var button: Button = Button.new()
+	button.name = "SummonHeroButton"
+	button.text = "Summon Hero (500 G)"
+	
+	var style: StyleBoxFlat = StyleBoxFlat.new()
+	style.bg_color = Color(0.35, 0.1, 0.45, 0.9)
+	style.set_corner_radius_all(4)
+	button.add_theme_stylebox_override("normal", style)
+	
+	return button
+
+## 영웅 소환 버튼 클릭 처리입니다.
+## 유닛 배치 대기 중이거나 게임 종료 상태라면 소환을 막아 입력 흐름이 섞이지 않게 합니다.
+func _on_summon_hero_pressed() -> void:
+	if GameManager.is_game_over or _has_pending_unit_placement():
+		return
+		
+	if not GameManager.spend_gold(HERO_SPAWN_COST):
+		return
+		
+	if DataManager.hero_templates.is_empty():
+		GameManager.add_gold(HERO_SPAWN_COST)
+		return
+		
+	var chosen_template: UnitData = DataManager.hero_templates[0]
+	var new_hero: BaseHero = DWARF_HERO_SCENE.instantiate() as BaseHero
+	var parent_scene: Node = _hud.get_tree().current_scene
+	if not parent_scene or not new_hero:
+		GameManager.add_gold(HERO_SPAWN_COST)
+		return
+	
+	new_hero.set("unit_data", chosen_template)
+	parent_scene.add_child(new_hero)
+	new_hero.global_position = Vector3(0.0, 1.0, 0.0)
+	_active_hero = new_hero
+	
+	_setup_hero_ui(new_hero)
+
+## 일반 유닛 배치 대기 상태인지 placement_manager에 위임해 확인합니다.
+func _has_pending_unit_placement() -> bool:
+	if _placement_manager and _placement_manager.has_method("has_pending_unit_placement"):
+		return _placement_manager.call("has_pending_unit_placement")
+	return false
+
+## 영웅 전용 좌측 상단 HUD를 새로 구성합니다.
+## 기존 패널이 있으면 제거한 뒤, 새 영웅 인스턴스의 신호와 연결된 UI를 생성합니다.
+func _setup_hero_ui(hero: BaseHero) -> void:
+	if hero_panel and is_instance_valid(hero_panel):
+		hero_panel.queue_free()
+		_skill_cooldown_overlays.clear()
+		_skill_cooldown_labels.clear()
+		
+	hero_panel = _create_hero_panel()
+	_hud.add_child(hero_panel)
+	
+	var hbox: HBoxContainer = _create_panel_hbox()
+	hero_panel.add_child(hbox)
+	hbox.add_child(_create_portrait_panel())
+	
+	var detail_box: VBoxContainer = _create_detail_box()
+	hbox.add_child(detail_box)
+	
+	var name_label: Label = _create_name_label(hero)
+	var xp_bar: ProgressBar = _create_xp_bar()
+	var xp_label: Label = _create_xp_label(hero)
+	var xp_group: HBoxContainer = _create_xp_group(xp_bar, xp_label)
+	var skill_group: HBoxContainer = _create_skill_group(hero)
+	
+	detail_box.add_child(name_label)
+	detail_box.add_child(xp_group)
+	detail_box.add_child(skill_group)
+	
+	_connect_hero_signals(hero, name_label, xp_bar, xp_label)
+	hero.xp_changed.emit(hero.xp, hero.xp_to_next_level)
+	hero.level_changed.emit(hero.level)
+
+## 영웅 상태 패널의 외곽 Panel을 생성합니다.
+func _create_hero_panel() -> Panel:
+	var panel: Panel = Panel.new()
+	panel.name = "HeroStatusPanel"
+	panel.custom_minimum_size = Vector2(290, 120)
+	panel.position = Vector2(20, 120)
+	
+	var style: StyleBoxFlat = StyleBoxFlat.new()
+	style.bg_color = Color(0.12, 0.08, 0.16, 0.85)
+	style.border_width_left = 2
+	style.border_width_top = 2
+	style.border_width_right = 2
+	style.border_width_bottom = 2
+	style.border_color = Color(0.85, 0.12, 0.85, 0.9)
+	style.set_corner_radius_all(6)
+	panel.add_theme_stylebox_override("panel", style)
+	
+	return panel
+
+## 초상화와 상세 정보를 좌우로 나누는 HBoxContainer를 생성합니다.
+func _create_panel_hbox() -> HBoxContainer:
+	var hbox: HBoxContainer = HBoxContainer.new()
+	hbox.name = "HBox"
+	hbox.anchor_right = 1.0
+	hbox.anchor_bottom = 1.0
+	hbox.offset_left = 8
+	hbox.offset_top = 8
+	hbox.offset_right = -8
+	hbox.offset_bottom = -8
+	hbox.add_theme_constant_override("separation", 12)
+	return hbox
+
+## 영웅 초상화 패널을 생성합니다.
+## 초상화 이미지가 없더라도 검은 배경 패널이 남아 레이아웃이 유지됩니다.
+func _create_portrait_panel() -> Panel:
+	var portrait_panel: Panel = Panel.new()
+	portrait_panel.custom_minimum_size = Vector2(75, 75)
+	
+	var panel_style: StyleBoxFlat = StyleBoxFlat.new()
+	panel_style.bg_color = Color(0.05, 0.05, 0.05, 1.0)
+	panel_style.border_width_left = 1
+	panel_style.border_width_top = 1
+	panel_style.border_width_right = 1
+	panel_style.border_width_bottom = 1
+	panel_style.border_color = Color(1.0, 0.85, 0.0, 0.8)
+	panel_style.set_corner_radius_all(4)
+	portrait_panel.add_theme_stylebox_override("panel", panel_style)
+	
+	var portrait: TextureRect = TextureRect.new()
+	portrait.name = "Portrait"
+	portrait.anchor_right = 1.0
+	portrait.anchor_bottom = 1.0
+	portrait.offset_left = 2
+	portrait.offset_top = 2
+	portrait.offset_right = -2
+	portrait.offset_bottom = -2
+	portrait.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
+	portrait.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_COVERED
+	if ResourceLoader.exists(DWARF_PORTRAIT_PATH):
+		portrait.texture = load(DWARF_PORTRAIT_PATH) as Texture2D
+	portrait_panel.add_child(portrait)
+	
+	return portrait_panel
+
+## 이름, 경험치, 스킬 슬롯을 세로로 쌓는 상세 정보 박스를 생성합니다.
+func _create_detail_box() -> VBoxContainer:
+	var vbox: VBoxContainer = VBoxContainer.new()
+	vbox.name = "VBox"
+	vbox.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	vbox.add_theme_constant_override("separation", 4)
+	return vbox
+
+## 영웅 이름과 레벨 라벨을 생성합니다.
+func _create_name_label(hero: BaseHero) -> Label:
+	var name_label: Label = Label.new()
+	name_label.name = "NameLabel"
+	name_label.text = "Lv. %d %s" % [hero.level, hero.unit_data.unit_name]
+	name_label.add_theme_font_size_override("font_size", 13)
+	name_label.add_theme_color_override("font_color", Color(1.0, 0.9, 0.3, 1.0))
+	return name_label
+
+## 경험치 ProgressBar를 생성하고 스타일을 적용합니다.
+func _create_xp_bar() -> ProgressBar:
+	var xp_bar: ProgressBar = ProgressBar.new()
+	xp_bar.name = "XPBar"
+	xp_bar.show_percentage = false
+	xp_bar.custom_minimum_size = Vector2(110, 10)
+	xp_bar.size_flags_vertical = Control.SIZE_SHRINK_CENTER
+	
+	var background_style: StyleBoxFlat = StyleBoxFlat.new()
+	background_style.bg_color = Color(0.1, 0.1, 0.1, 1.0)
+	background_style.set_corner_radius_all(2)
+	
+	var fill_style: StyleBoxFlat = StyleBoxFlat.new()
+	fill_style.bg_color = Color(0.7, 0.15, 0.85, 1.0)
+	fill_style.set_corner_radius_all(2)
+	
+	xp_bar.add_theme_stylebox_override("background", background_style)
+	xp_bar.add_theme_stylebox_override("fill", fill_style)
+	return xp_bar
+
+## 경험치 숫자 라벨을 생성합니다.
+func _create_xp_label(hero: BaseHero) -> Label:
+	var xp_label: Label = Label.new()
+	xp_label.name = "XPLabel"
+	xp_label.text = "%d / %d" % [hero.xp, hero.xp_to_next_level]
+	xp_label.add_theme_font_size_override("font_size", 9)
+	return xp_label
+
+## 경험치 바와 숫자를 같은 줄에 배치합니다.
+func _create_xp_group(xp_bar: ProgressBar, xp_label: Label) -> HBoxContainer:
+	var xp_hbox: HBoxContainer = HBoxContainer.new()
+	xp_hbox.add_theme_constant_override("separation", 6)
+	xp_hbox.add_child(xp_bar)
+	xp_hbox.add_child(xp_label)
+	return xp_hbox
+
+## Q/W/E/R 스킬 버튼과 쿨다운 오버레이를 생성합니다.
+func _create_skill_group(hero: BaseHero) -> HBoxContainer:
+	var skill_hbox: HBoxContainer = HBoxContainer.new()
+	skill_hbox.name = "SkillGroup"
+	skill_hbox.add_theme_constant_override("separation", 6)
+	
+	var slots: Array[String] = ["Q", "W", "E", "R"]
+	var skill_names: Dictionary = {
+		"Q": "Strike",
+		"W": "Haste",
+		"E": "Clap",
+		"R": "Avatar"
+	}
+	
+	for slot: String in slots:
+		skill_hbox.add_child(_create_skill_button(hero, slot, skill_names[slot]))
+		
+	return skill_hbox
+
+## 스킬 슬롯 버튼 하나를 만들고 쿨다운 오버레이/라벨을 자식으로 붙입니다.
+func _create_skill_button(hero: BaseHero, slot: String, skill_name: String) -> Button:
+	var button: Button = Button.new()
+	button.name = "Skill_" + slot
+	button.text = slot
+	button.custom_minimum_size = Vector2(32, 32)
+	button.add_theme_font_size_override("font_size", 10)
+	button.add_theme_stylebox_override("normal", _create_skill_button_style())
+	button.tooltip_text = "%s Skill: %s\nCooldown: %.1fs" % [slot, skill_name, hero.skill_max_cooldowns[slot]]
+	button.pressed.connect(func() -> void:
+		if is_instance_valid(hero):
+			hero.use_skill(slot)
+	)
+	
+	var overlay: ColorRect = ColorRect.new()
+	overlay.name = "CooldownOverlay"
+	overlay.color = Color(0.0, 0.0, 0.0, 0.6)
+	overlay.anchor_right = 1.0
+	overlay.anchor_bottom = 1.0
+	overlay.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	overlay.visible = false
+	button.add_child(overlay)
+	_skill_cooldown_overlays[slot] = overlay
+	
+	var label: Label = Label.new()
+	label.name = "CooldownLabel"
+	label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
+	label.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
+	label.anchor_right = 1.0
+	label.anchor_bottom = 1.0
+	label.add_theme_font_size_override("font_size", 9)
+	label.add_theme_color_override("font_color", Color(1.0, 1.0, 1.0, 1.0))
+	label.visible = false
+	button.add_child(label)
+	_skill_cooldown_labels[slot] = label
+	
+	return button
+
+## 스킬 버튼 공통 배경 스타일을 생성합니다.
+func _create_skill_button_style() -> StyleBoxFlat:
+	var style: StyleBoxFlat = StyleBoxFlat.new()
+	style.bg_color = Color(0.2, 0.15, 0.3, 1.0)
+	style.border_width_left = 1
+	style.border_width_top = 1
+	style.border_width_right = 1
+	style.border_width_bottom = 1
+	style.border_color = Color(0.6, 0.4, 0.7, 0.8)
+	style.set_corner_radius_all(3)
+	return style
+
+## 영웅 데이터 신호와 UI 갱신 함수를 연결합니다.
+func _connect_hero_signals(hero: BaseHero, name_label: Label, xp_bar: ProgressBar, xp_label: Label) -> void:
+	hero.level_changed.connect(func(new_level: int) -> void:
+		if is_instance_valid(name_label) and is_instance_valid(hero):
+			name_label.text = "Lv. %d %s" % [new_level, hero.unit_data.unit_name]
+	)
+	
+	hero.xp_changed.connect(func(current_xp: int, need_xp: int) -> void:
+		if is_instance_valid(xp_bar) and is_instance_valid(xp_label):
+			xp_bar.max_value = need_xp
+			xp_bar.value = current_xp
+			xp_label.text = "%d / %d" % [current_xp, need_xp]
+	)
+	
+	hero.skill_cooldown_changed.connect(_on_hero_skill_cooldown_changed)
+
+## 스킬 쿨다운 신호를 받아 오버레이와 남은 시간 라벨을 표시/숨김 처리합니다.
+func _on_hero_skill_cooldown_changed(slot_name: String, remaining: float, _duration: float) -> void:
+	var overlay: ColorRect = _skill_cooldown_overlays.get(slot_name)
+	var label: Label = _skill_cooldown_labels.get(slot_name)
+	if is_instance_valid(overlay) and is_instance_valid(label):
+		if remaining > 0.0:
+			overlay.visible = true
+			label.visible = true
+			label.text = "%.1f" % remaining
+		else:
+			overlay.visible = false
+			label.visible = false

src/ui/hero_panel/hud_hero_panel.gd.uid

+uid://bkx7mv8uksflg

src/ui/hud.gd

 extends Control
 
 ## 메인 HUD UI 제어 스크립트 (HUD)
-## 플레이어 자원 현황, 게임 결과 팝업, 유닛 소환 메커니즘을 총괄합니다.
-
-# 유닛 씬 및 데이터 프리로드
+## 플레이어 자원/스테이지/몬스터 표시와 게임 흐름 버튼을 조율합니다.
+## 세부 기능은 아래 보조 클래스로 분리해 HUD가 지나치게 커지지 않도록 유지합니다.
+## - HudUnitPlacement: 일반 유닛 무작위 소환 및 타일 배치
+## - HudSummonerPanel: 소환사 마나/주문 UI
+## - HudHeroPanel: 영웅 소환 버튼 및 영웅 상태 UI
+
+const HudUnitPlacementScript: GDScript = preload("res://src/ui/unit_placement/hud_unit_placement.gd")
+const HudSummonerPanelScript: GDScript = preload("res://src/ui/summoner_panel/hud_summoner_panel.gd")
+const HudHeroPanelScript: GDScript = preload("res://src/ui/hero_panel/hud_hero_panel.gd")
+
+## 기본 유닛 fallback 씬입니다.
+## 유닛 ID에 맞는 전용 씬을 찾지 못하면 HudUnitPlacement가 이 씬을 사용합니다.
 @export var base_unit_scene: PackedScene = preload("res://src/entities/units/base/base_unit.tscn")
-const INVALID_TILE_CELL: Vector3i = Vector3i(2147483647, 2147483647, 2147483647)
 
-# UI 노드 자동 캐싱
+## 상단 상태 표시 UI 노드 캐시입니다.
+## hud.tscn에 이미 배치된 노드들이므로 @onready로 안전하게 참조합니다.
 @onready var gold_label: Label = $TopBar/GoldLabel
 @onready var stage_label: Label = $TopBar/StageLabel
 @onready var monster_label: Label = $TopBar/MonsterLabel
-@onready var spawn_button: Button = $BottomBar/SpawnButton
+
+## 하단 기본 버튼과 결과 팝업 노드 캐시입니다.
+@onready var unit_spawn_button: Button = $BottomBar/SpawnButton
 @onready var result_popup: Panel = $ResultPopup
 @onready var result_title: Label = $ResultPopup/ResultTitle
 @onready var restart_button: Button = $ResultPopup/RestartButton
 
-# 몬스터 일시정지 버튼 런타임 저장 변수
 var _pause_button: Button = null
 var _summoner: Summoner = null
 
-# 영웅 관리용 상태 및 UI 노드 캐시
-var hero_spawn_button: Button = null
-var hero_panel: Panel = null
-var _active_hero: BaseHero = null
-const HERO_SPAWN_COST: int = 500
-var _skill_cooldown_overlays: Dictionary = {} # {"Q": ColorRect, "W": ColorRect, ...}
-var _skill_cooldown_labels: Dictionary = {}    # {"Q": Label, "W": Label, ...}
-var _pending_unit_scene: PackedScene = null
-var _pending_unit_data: UnitData = null
-var _pending_spawn_cost: int = 0
-var _spawn_button_default_text: String = ""
-var _placement_overlay_root: Node3D = null
-var _placement_available_material: StandardMaterial3D = null
-var _placement_occupied_material: StandardMaterial3D = null
-
+## 기능별 보조 객체입니다.
+## 새 파일을 추가한 직후 Godot class_name 캐시 상태에 덜 의존하도록 Object 타입으로 보관합니다.
+var _unit_placement: Object = null
+var _summoner_panel: Object = null
+var _hero_panel: Object = null
 
+func _ready() -> void:
+	_connect_game_manager_signals()
+	_setup_unit_placement()
+	_bind_static_buttons()
+	_initialize_status_labels()
+	_setup_summoner_flow()
+	_create_runtime_bottom_buttons()
+	_on_gold_changed(GameManager.player_gold)
 
+## 마우스/터치 입력 중 유닛 배치 확정에 해당하는 입력을 HudUnitPlacement에 위임합니다.
+## 배치 입력이 처리된 경우 viewport에 handled를 표시해 같은 클릭이 다른 게임 입력으로 중복 전달되지 않게 합니다.
+func _input(event: InputEvent) -> void:
+	if _unit_placement and _unit_placement.has_method("handle_input"):
+		var handled: bool = _unit_placement.call("handle_input", event)
+		if handled:
+			get_viewport().set_input_as_handled()
 
-func _ready() -> void:
-	# GameManager 시그널 핸들러 등록
+## GameManager의 전역 상태 신호를 HUD 갱신 함수에 연결합니다.
+## UI는 GameManager 상태를 직접 폴링하지 않고 신호를 통해 변경 시점에만 갱신합니다.
+func _connect_game_manager_signals() -> void:
 	GameManager.gold_changed.connect(_on_gold_changed)
 	GameManager.stage_changed.connect(_on_stage_changed)
 	GameManager.active_monster_count_changed.connect(_on_monster_changed)
 	GameManager.game_lost.connect(_on_game_lost)
 	GameManager.game_victory.connect(_on_game_victory)
 
-	# UI 버튼 바인딩
-	_spawn_button_default_text = spawn_button.text
-	spawn_button.pressed.connect(_on_spawn_pressed)
+## 유닛 배치 전담 객체를 생성하고 HUD/버튼/기본 씬 참조를 주입합니다.
+func _setup_unit_placement() -> void:
+	_unit_placement = HudUnitPlacementScript.new()
+	if _unit_placement.has_method("setup"):
+		_unit_placement.call("setup", self, unit_spawn_button, base_unit_scene)
+	if _unit_placement.has_method("warmup_overlay_pool_deferred"):
+		_unit_placement.call("warmup_overlay_pool_deferred")
+
+## hud.tscn에 이미 존재하는 정적 버튼들의 클릭 신호를 연결합니다.
+func _bind_static_buttons() -> void:
+	unit_spawn_button.pressed.connect(_on_spawn_pressed)
 	restart_button.pressed.connect(_on_restart_pressed)
 
-	# 초기 화면 레이아웃 설정
+## 씬 진입 직후 현재 GameManager 상태를 상단 HUD와 결과 팝업에 반영합니다.
+func _initialize_status_labels() -> void:
 	result_popup.visible = false
 	_on_gold_changed(GameManager.player_gold)
 	_on_stage_changed(GameManager.current_stage)
 	_on_monster_changed(GameManager.active_monster_count)
 
-	# 소환사 노드 동적 생성 및 바인딩 (선택 전 데이터 주입 보류)
+## 소환사 노드를 생성하고 선택 데이터가 없으면 디버그 기본값 또는 선택 씬으로 보냅니다.
+## 선택 데이터가 준비되면 소환사 UI를 구성하고 StageManager 시작 신호까지 이어집니다.
+func _setup_summoner_flow() -> void:
 	var summoner_script: GDScript = preload("res://src/entities/summoner/summoner.gd")
 	_summoner = summoner_script.new() as Summoner
 	_summoner.name = "ActiveSummoner"
 	add_child(_summoner)
 	
-	# 선택된 소환사 데이터가 존재하는지 검증 (디버그 모드 대안 포함)
 	if not GameManager.selected_summoner_data:
 		if GameManager.should_skip_selection_flow():
 			GameManager.apply_debug_selection_defaults()
@@ -75,12 +101,15 @@ func _ready() -> void:
 		SceneChanger.change_scene_to_file("res://src/ui/summoner_selection/summoner_selection.tscn")
 		return
 		
-	# 소환사 데이터 초기 셋업 가동
 	_on_summoner_selected(GameManager.selected_summoner_data)
 
-	# 몬스터 생성 일시 정지, 게임 재시작 및 모든 유닛 삭제 버튼 런타임 생성
+## BottomBar에 런타임 전용 버튼들을 추가합니다.
+## Pause/Restart/Clear는 HUD가 직접 처리하고, 영웅 버튼과 패널은 HudHeroPanel에 위임합니다.
+func _create_runtime_bottom_buttons() -> void:
 	var bottom_bar: Control = get_node_or_null("BottomBar") as Control
-	if bottom_bar:
+	if not bottom_bar:
+		return
+		
 	_pause_button = Button.new()
 	_pause_button.name = "PauseSpawningButton"
 	_pause_button.text = "Pause Spawning"
@@ -99,652 +128,74 @@ func _ready() -> void:
 	bottom_bar.add_child(clear_units_button)
 	clear_units_button.pressed.connect(_on_clear_units_pressed)
 	
-		# 영웅 소환 버튼 동적 생성
-		hero_spawn_button = Button.new()
-		hero_spawn_button.name = "SummonHeroButton"
-		hero_spawn_button.text = "Summon Hero (500 G)"
-		# 멋진 보라색 영웅 테두리/에너지 느낌의 테마 스타일 적용
-		var sb: StyleBoxFlat = StyleBoxFlat.new()
-		sb.bg_color = Color(0.35, 0.1, 0.45, 0.9)
-		sb.set_corner_radius_all(4)
-		hero_spawn_button.add_theme_stylebox_override("normal", sb)
-		bottom_bar.add_child(hero_spawn_button)
-		hero_spawn_button.pressed.connect(_on_summon_hero_pressed)
-
-func _input(event: InputEvent) -> void:
-	if not _has_pending_unit_placement():
-		return
+	_hero_panel = HudHeroPanelScript.new()
+	if _hero_panel.has_method("setup"):
+		_hero_panel.call("setup", self, bottom_bar, _unit_placement)
 
-	if event is InputEventMouseButton:
-		var mouse_event: InputEventMouseButton = event as InputEventMouseButton
-		if mouse_event.button_index == MOUSE_BUTTON_LEFT and mouse_event.pressed:
-			_try_place_pending_unit(mouse_event.position)
-			get_viewport().set_input_as_handled()
-	elif event is InputEventScreenTouch:
-		var touch_event: InputEventScreenTouch = event as InputEventScreenTouch
-		if touch_event.pressed:
-			_try_place_pending_unit(touch_event.position)
-			get_viewport().set_input_as_handled()
-
-# 골드 UI 갱신 및 소환 한도 검증
+## 골드 UI 갱신 및 골드 기반 버튼 활성 상태를 반영합니다.
 func _on_gold_changed(gold: int) -> void:
 	gold_label.text = "GOLD: " + str(gold) + " G"
-	# 골드가 부족하면 유닛 소환 버튼 비활성화
-	spawn_button.disabled = (gold < GameManager.unit_spawn_cost)
-	if hero_spawn_button:
-		hero_spawn_button.disabled = (gold < HERO_SPAWN_COST)
+	unit_spawn_button.disabled = gold < GameManager.unit_spawn_cost
+	if _hero_panel and _hero_panel.has_method("update_gold"):
+		_hero_panel.call("update_gold", gold)
 
-# 스테이지 UI 갱신
+## 현재 스테이지 텍스트를 갱신합니다.
 func _on_stage_changed(stage: int) -> void:
 	stage_label.text = "STAGE: " + str(stage) + " / " + str(GameManager.MAX_STAGE)
 
-# 필드 몬스터 개수 UI 갱신
+## 필드에 남아 있는 몬스터 수를 갱신합니다.
 func _on_monster_changed(count: int) -> void:
 	monster_label.text = "MONSTERS: " + str(count) + " / " + str(GameManager.DEFEAT_MONSTER_LIMIT)
 
-# 게임 오버 시 팝업 현시
+## 게임 패배 신호를 받으면 결과 팝업을 표시합니다.
 func _on_game_lost() -> void:
 	result_title.text = "GAME OVER\nMonster Limit Exceeded!"
 	result_popup.visible = true
 
-# 게임 승리 시 팝업 현시
+## 게임 승리 신호를 받으면 결과 팝업을 표시합니다.
 func _on_game_victory() -> void:
 	result_title.text = "VICTORY!\nYou Survived All Stages!"
 	result_popup.visible = true
 
-# 유닛 무작위 소환 수행
+## 일반 유닛 소환 버튼 클릭 처리입니다.
+## 실제 유닛 선정과 타일 배치 대기 전환은 HudUnitPlacement가 담당합니다.
 func _on_spawn_pressed() -> void:
-	if GameManager.is_game_over or _has_pending_unit_placement():
-		return
-		
-	if DataManager.unit_templates.is_empty():
-		return
-		
-	if GameManager.player_gold < GameManager.unit_spawn_cost:
-		return
-		
-	# 20% 동일 확률로 5종 유닛 중 무작위 1개 선정
-	var random_index: int = randi() % DataManager.unit_templates.size()
-	var chosen_template: UnitData = DataManager.unit_templates[random_index]
-	
-	# 유닛 객체 스폰 (Striker, Guardian, Ranger 전용 씬 분기 분할)
-	var target_scene: PackedScene = base_unit_scene
-	if chosen_template.unit_id == "Unit_Striker":
-		var striker_scene: PackedScene = load("res://src/entities/units/striker/striker_unit.tscn") as PackedScene
-		if striker_scene:
-			target_scene = striker_scene
-	elif chosen_template.unit_id == "Unit_Guardian":
-		var guardian_scene: PackedScene = load("res://src/entities/units/guardian/guardian_unit.tscn") as PackedScene
-		if guardian_scene:
-			target_scene = guardian_scene
-	elif chosen_template.unit_id == "Unit_Ranger":
-		var ranger_scene: PackedScene = load("res://src/entities/units/ranger/ranger_unit.tscn") as PackedScene
-		if ranger_scene:
-			target_scene = ranger_scene
-	elif chosen_template.unit_id == "Unit_Mage":
-		var mage_scene: PackedScene = load("res://src/entities/units/mage/mage_unit.tscn") as PackedScene
-		if mage_scene:
-			target_scene = mage_scene
-			
-	_begin_unit_placement(target_scene, chosen_template, GameManager.unit_spawn_cost)
-
-func _has_pending_unit_placement() -> bool:
-	return _pending_unit_scene != null and _pending_unit_data != null
-
-func _begin_unit_placement(unit_scene: PackedScene, unit_data: UnitData, spawn_cost: int) -> void:
-	_pending_unit_scene = unit_scene
-	_pending_unit_data = unit_data
-	_pending_spawn_cost = spawn_cost
-	spawn_button.text = "Select Tile"
-	_show_placement_tile_overlays()
-
-func _clear_pending_unit_placement() -> void:
-	_pending_unit_scene = null
-	_pending_unit_data = null
-	_pending_spawn_cost = 0
-	spawn_button.text = _spawn_button_default_text
-	_clear_placement_tile_overlays()
-
-func _try_place_pending_unit(screen_pos: Vector2) -> void:
-	var tile_info: Dictionary = _get_tile_info_from_screen(screen_pos)
-	if tile_info.is_empty():
-		return
-		
-	var tile_cell: Vector3i = tile_info["cell"]
-	if _is_tile_occupied(tile_cell):
-		return
-		
-	if not GameManager.spend_gold(_pending_spawn_cost):
-		_clear_pending_unit_placement()
-		return
-		
-	var new_unit: Node = _pending_unit_scene.instantiate()
-	var parent_scene: Node = get_tree().current_scene
-	var tile_center: Vector3 = tile_info["center"]
-	
-	new_unit.set("unit_data", _pending_unit_data)
-	parent_scene.add_child(new_unit)
-	
-	if new_unit is BaseUnit:
-		(new_unit as BaseUnit).place_on_tile(tile_center, tile_cell)
-	elif new_unit is Node3D:
-		(new_unit as Node3D).global_position = tile_center
-		
-	_clear_pending_unit_placement()
-
-func _get_tile_info_from_screen(screen_pos: Vector2) -> Dictionary:
-	var camera: Camera3D = get_viewport().get_camera_3d()
-	var grid_map: GridMap = _get_stage_grid_map()
-	if not camera or not grid_map:
-		return {}
-		
-	var ray_origin: Vector3 = camera.project_ray_origin(screen_pos)
-	var ray_end: Vector3 = ray_origin + camera.project_ray_normal(screen_pos) * 1000.0
-	var query: PhysicsRayQueryParameters3D = PhysicsRayQueryParameters3D.create(ray_origin, ray_end)
-	var result: Dictionary = camera.get_world_3d().direct_space_state.intersect_ray(query)
-	if result.is_empty() or not result.has("position"):
-		return {}
-		
-	var hit_position: Vector3 = result["position"]
-	var tile_cell: Vector3i = _get_valid_tile_cell(grid_map, hit_position)
-	if tile_cell == INVALID_TILE_CELL:
-		return {}
-		
-	var tile_center: Vector3 = grid_map.to_global(grid_map.map_to_local(tile_cell))
-	tile_center.y += 1.0
-	return {
-		"cell": tile_cell,
-		"center": tile_center
-	}
-
-func _get_valid_tile_cell(grid_map: GridMap, world_position: Vector3) -> Vector3i:
-	var local_position: Vector3 = grid_map.to_local(world_position)
-	var tile_cell: Vector3i = grid_map.local_to_map(local_position)
-	if grid_map.get_cell_item(tile_cell) != -1:
-		return tile_cell
-		
-	var ground_cell: Vector3i = Vector3i(tile_cell.x, 0, tile_cell.z)
-	if grid_map.get_cell_item(ground_cell) != -1:
-		return ground_cell
-		
-	for y: int in range(tile_cell.y - 4, tile_cell.y + 5):
-		var nearby_cell: Vector3i = Vector3i(tile_cell.x, y, tile_cell.z)
-		if grid_map.get_cell_item(nearby_cell) != -1:
-			return nearby_cell
-			
-	return INVALID_TILE_CELL
-
-func _get_stage_grid_map() -> GridMap:
-	var current_scene: Node = get_tree().current_scene
-	if not current_scene:
-		return null
-	return _find_grid_map(current_scene)
-
-func _find_grid_map(node: Node) -> GridMap:
-	if node is GridMap:
-		return node as GridMap
-		
-	for child: Node in node.get_children():
-		var found_grid: GridMap = _find_grid_map(child)
-		if found_grid:
-			return found_grid
-			
-	return null
-
-func _is_tile_occupied(tile_cell: Vector3i) -> bool:
-	var units: Array[Node] = get_tree().get_nodes_in_group("units")
-	for unit_node: Node in units:
-		if unit_node is BaseUnit:
-			var unit: BaseUnit = unit_node as BaseUnit
-			if unit.is_tile_bound and unit.occupied_tile_cell == tile_cell:
-				return true
-	return false
-
-func _show_placement_tile_overlays() -> void:
-	_clear_placement_tile_overlays()
-	
-	var grid_map: GridMap = _get_stage_grid_map()
-	var parent_scene: Node = get_tree().current_scene
-	if not grid_map or not parent_scene:
-		return
-		
-	_placement_overlay_root = Node3D.new()
-	_placement_overlay_root.name = "UnitPlacementTileOverlays"
-	parent_scene.add_child(_placement_overlay_root)
-	
-	var used_cells: Array = grid_map.get_used_cells()
-	for cell: Vector3i in used_cells:
-		_add_placement_tile_overlay(grid_map, cell)
-
-func _clear_placement_tile_overlays() -> void:
-	if _placement_overlay_root and is_instance_valid(_placement_overlay_root):
-		_placement_overlay_root.queue_free()
-	_placement_overlay_root = null
-
-func _add_placement_tile_overlay(grid_map: GridMap, tile_cell: Vector3i) -> void:
-	if not _placement_overlay_root:
-		return
+	if _unit_placement and _unit_placement.has_method("begin_random_unit_placement"):
+		_unit_placement.call("begin_random_unit_placement")
 
-	var overlay_mesh: PlaneMesh = PlaneMesh.new()
-	overlay_mesh.size = Vector2(grid_map.cell_size.x * 0.92, grid_map.cell_size.z * 0.92)
-	
-	var overlay: MeshInstance3D = MeshInstance3D.new()
-	overlay.name = "OccupiedTileOverlay" if _is_tile_occupied(tile_cell) else "AvailableTileOverlay"
-	overlay.mesh = overlay_mesh
-	overlay.material_override = _get_placement_material(_is_tile_occupied(tile_cell))
-	overlay.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
-	
-	var tile_center: Vector3 = grid_map.to_global(grid_map.map_to_local(tile_cell))
-	tile_center.y += 1.03
-	overlay.global_position = tile_center
-	_placement_overlay_root.add_child(overlay)
-
-func _get_placement_material(is_occupied: bool) -> StandardMaterial3D:
-	if is_occupied:
-		if not _placement_occupied_material:
-			_placement_occupied_material = _create_placement_material(Color(1.0, 0.05, 0.02, 0.38))
-		return _placement_occupied_material
-		
-	if not _placement_available_material:
-		_placement_available_material = _create_placement_material(Color(0.05, 1.0, 0.2, 0.32))
-	return _placement_available_material
-
-func _create_placement_material(color: Color) -> StandardMaterial3D:
-	var material: StandardMaterial3D = StandardMaterial3D.new()
-	material.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
-	material.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
-	material.albedo_color = color
-	material.cull_mode = BaseMaterial3D.CULL_DISABLED
-	material.no_depth_test = true
-	return material
-			
-
-# 상시 노출되는 게임 재시작 버튼 클릭 처리
+## 상시 노출되는 게임 재시작 버튼 클릭 처리입니다.
 func _on_restart_game_pressed() -> void:
 	GameManager.restart_game()
 
-# 모든 유닛 삭제 버튼 클릭 처리
+## 모든 유닛 삭제 버튼 클릭 처리입니다.
 func _on_clear_units_pressed() -> void:
 	GameManager.clear_all_units()
 
-# 게임 결과 팝업 내 재시작 버튼 클릭 처리
+## 결과 팝업 내부 재시작 버튼 클릭 처리입니다.
 func _on_restart_pressed() -> void:
 	GameManager.restart_game()
 
-# 몬스터 스폰 일시정지 버튼 클릭 처리
+## 몬스터 스폰 일시정지 버튼 클릭 처리입니다.
+## StageManager와는 직접 강결합하지 않고, 메서드 존재 여부를 확인한 뒤 호출합니다.
 func _on_pause_spawning_pressed() -> void:
 	if not _pause_button:
 		return
-	var stage_mgr: Node = get_node_or_null("../StageManager")
-	if stage_mgr and stage_mgr.has_method("toggle_spawning_pause"):
-		var is_paused: bool = stage_mgr.call("toggle_spawning_pause")
-		if is_paused:
-			_pause_button.text = "Resume Spawning"
-		else:
-			_pause_button.text = "Pause Spawning"
-
 		
+	var stage_manager: Node = get_node_or_null("../StageManager")
+	if stage_manager and stage_manager.has_method("toggle_spawning_pause"):
+		var is_paused: bool = stage_manager.call("toggle_spawning_pause")
+		_pause_button.text = "Resume Spawning" if is_paused else "Pause Spawning"
 
-## 소환사 선택 완료 후 UI 구성 및 스테이지 타이머 시작
+## 소환사 선택 완료 후 소환사 데이터 셋업, 소환사 UI 구성, 스테이지 시작을 순서대로 처리합니다.
 func _on_summoner_selected(data: SummonerData) -> void:
-	# 1. 소환사 데이터 실 셋업 가동
 	_summoner.setup_summoner(data)
 	
-	# 2. 인게임 소환사 UI 런타임 조립하여 BottomBar에 배치
 	var bottom_bar: Control = get_node_or_null("BottomBar") as Control
 	if bottom_bar:
-		var summoner_ui: HBoxContainer = HBoxContainer.new()
-		summoner_ui.name = "SummonerUI"
-		summoner_ui.add_theme_constant_override("separation", 10)
-		
-		# 소환사 초상화
-		var portrait: TextureRect = TextureRect.new()
-		portrait.name = "SummonerPortrait"
-		portrait.custom_minimum_size = Vector2(48, 48)
-		portrait.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
-		portrait.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_COVERED
-		if data.portrait_texture:
-			portrait.texture = data.portrait_texture
-		summoner_ui.add_child(portrait)
-		
-		# 마나 정보 그룹
-		var info_group: VBoxContainer = VBoxContainer.new()
-		info_group.name = "InfoGroup"
-		info_group.custom_minimum_size = Vector2(110, 48)
-		
-		var mana_bar: ProgressBar = ProgressBar.new()
-		mana_bar.name = "ManaBar"
-		mana_bar.show_percentage = false
-		mana_bar.custom_minimum_size = Vector2(110, 14)
-		
-		var sb_bg: StyleBoxFlat = StyleBoxFlat.new()
-		sb_bg.bg_color = Color(0.12, 0.12, 0.12, 0.8)
-		sb_bg.set_corner_radius_all(2)
-		
-		var sb_fg: StyleBoxFlat = StyleBoxFlat.new()
-		sb_fg.bg_color = Color(0.15, 0.45, 0.85, 1.0)
-		sb_fg.set_corner_radius_all(2)
-		
-		mana_bar.add_theme_stylebox_override("background", sb_bg)
-		mana_bar.add_theme_stylebox_override("fill", sb_fg)
-		info_group.add_child(mana_bar)
-		
-		var mana_label: Label = Label.new()
-		mana_label.name = "ManaLabel"
-		mana_label.text = "MP: %.1f / %.1f" % [data.max_mana, data.max_mana]
-		mana_label.add_theme_font_size_override("font_size", 10)
-		info_group.add_child(mana_label)
-		
-		summoner_ui.add_child(info_group)
-		
-		# 스펠 주문 버튼 그룹
-		var spell_group: HBoxContainer = HBoxContainer.new()
-		spell_group.name = "SpellGroup"
-		spell_group.add_theme_constant_override("separation", 5)
-		
-		var btn_haste: Button = Button.new()
-		btn_haste.name = "SpellHaste"
-		btn_haste.text = "Haste (40 MP)"
-		var haste_icon_path: String = "res://assets/ui/summoner/spells/spell_haste.png"
-		if ResourceLoader.exists(haste_icon_path):
-			btn_haste.icon = load(haste_icon_path) as Texture2D
-			btn_haste.expand_icon = true
-			btn_haste.custom_minimum_size = Vector2(90, 45)
-		else:
-			btn_haste.custom_minimum_size = Vector2(90, 30)
-		btn_haste.pressed.connect(func() -> void: _summoner.cast_spell("haste"))
-		spell_group.add_child(btn_haste)
-		
-		var btn_smite: Button = Button.new()
-		btn_smite.name = "SpellSmite"
-		btn_smite.text = "Smite (50 MP)"
-		var smite_icon_path: String = "res://assets/ui/summoner/spells/spell_smite.png"
-		if ResourceLoader.exists(smite_icon_path):
-			btn_smite.icon = load(smite_icon_path) as Texture2D
-			btn_smite.expand_icon = true
-			btn_smite.custom_minimum_size = Vector2(90, 45)
-		else:
-			btn_smite.custom_minimum_size = Vector2(90, 30)
-		btn_smite.pressed.connect(func() -> void: _summoner.cast_spell("smite"))
-		spell_group.add_child(btn_smite)
-		
-		summoner_ui.add_child(spell_group)
-		
-		# UI 조립
-		bottom_bar.add_child(summoner_ui)
-		bottom_bar.move_child(summoner_ui, 0)
-		
-		# 신호 연결
-		_summoner.mana_changed.connect(func(current: float, max_v: float) -> void:
-			mana_bar.max_value = max_v
-			mana_bar.value = current
-			mana_label.text = "MP: %.1f / %.1f" % [current, max_v]
-			
-			btn_haste.disabled = (current < 40.0 or _summoner.spell_cooldowns.get("haste", 0.0) > 0.0)
-			btn_smite.disabled = (current < 50.0 or _summoner.spell_cooldowns.get("smite", 0.0) > 0.0)
-		)
-		
-		_summoner.spell_cooldown_changed.connect(func(spell_name: String, remaining: float, duration: float) -> void:
-			var btn: Button = btn_haste if spell_name == "haste" else btn_smite
-			var label_text: String = "Haste" if spell_name == "haste" else "Smite"
-			var cost: float = 40.0 if spell_name == "haste" else 50.0
-			
-			if remaining > 0.0:
-				btn.text = "%s\n(%.1fs)" % [label_text, remaining]
-				btn.disabled = true
-			else:
-				btn.text = "%s (%d MP)" % [label_text, cost]
-				if _summoner.current_mana >= cost:
-					btn.disabled = false
-		)
-		
-		# 강제 GUI 갱신용으로 신호 1회 수동 트리거
-		_summoner.mana_changed.emit(_summoner.current_mana, _summoner.max_mana)
-		
-	# 3. StageManager를 찾아 수동 게임 시작 기동
-	var stage_mgr: Node = get_node_or_null("../StageManager")
-	if stage_mgr and stage_mgr.has_method("start_game"):
-		stage_mgr.call("start_game")
-
-
-# 영웅 소환 버튼 클릭 처리
-func _on_summon_hero_pressed() -> void:
-	if GameManager.is_game_over or _has_pending_unit_placement():
-		return
-		
-	if not GameManager.spend_gold(HERO_SPAWN_COST):
-		return
-		
-	# 현재 영웅 템플릿 중 첫 번째(Dwarf Hero) 선정
-	if DataManager.hero_templates.is_empty():
-		GameManager.add_gold(HERO_SPAWN_COST)
-		return
-		
-	var chosen_template: UnitData = DataManager.hero_templates[0]
-	var hero_scene: PackedScene = load("res://src/entities/units/hero/dwarf/dwarf_hero.tscn") as PackedScene
-	if not hero_scene:
-		GameManager.add_gold(HERO_SPAWN_COST)
-		return
-		
-	var new_hero: BaseHero = hero_scene.instantiate() as BaseHero
-	var parent_scene: Node = get_tree().current_scene
-	
-	new_hero.set("unit_data", chosen_template)
-	parent_scene.add_child(new_hero)
-	new_hero.global_position = Vector3(0.0, 1.0, 0.0)
-	_active_hero = new_hero
-	
-	# 영웅은 타일 점유 배치가 아닌 맵 중앙 생성 규칙을 따릅니다.
-	_setup_hero_ui(new_hero)
-
-# 영웅 전용 좌측 상단 HUD 구성
-func _setup_hero_ui(hero: BaseHero) -> void:
-	# 기존 영웅 UI 패널이 존재하면 완전 제거
-	if hero_panel and is_instance_valid(hero_panel):
-		hero_panel.queue_free()
-		_skill_cooldown_overlays.clear()
-		_skill_cooldown_labels.clear()
-		
-	# 1. 메인 패널 생성 및 스타일 적용
-	hero_panel = Panel.new()
-	hero_panel.name = "HeroStatusPanel"
-	hero_panel.custom_minimum_size = Vector2(290, 120)
-	# 화면 좌측 상단에 알맞은 마진 할당
-	hero_panel.position = Vector2(20, 120)
-	
-	var sb: StyleBoxFlat = StyleBoxFlat.new()
-	sb.bg_color = Color(0.12, 0.08, 0.16, 0.85) # 어두운 보랏빛 판타지 배경
-	sb.border_width_left = 2
-	sb.border_width_top = 2
-	sb.border_width_right = 2
-	sb.border_width_bottom = 2
-	sb.border_color = Color(0.85, 0.12, 0.85, 0.9) # 화려한 퍼플 테두리
-	sb.set_corner_radius_all(6)
-	hero_panel.add_theme_stylebox_override("panel", sb)
-	
-	add_child(hero_panel)
-	
-	# 2. HBox 컨테이너 배치 (초상화 | 상세정보)
-	var hbox: HBoxContainer = HBoxContainer.new()
-	hbox.name = "HBox"
-	hbox.anchor_right = 1.0
-	hbox.anchor_bottom = 1.0
-	hbox.offset_left = 8
-	hbox.offset_top = 8
-	hbox.offset_right = -8
-	hbox.offset_bottom = -8
-	hbox.add_theme_constant_override("separation", 12)
-	hero_panel.add_child(hbox)
-	
-	# 3. 초상화 구성
-	var portrait_panel: Panel = Panel.new()
-	portrait_panel.custom_minimum_size = Vector2(75, 75)
-	
-	var port_sb: StyleBoxFlat = StyleBoxFlat.new()
-	port_sb.bg_color = Color(0.05, 0.05, 0.05, 1.0)
-	port_sb.border_width_left = 1
-	port_sb.border_width_top = 1
-	port_sb.border_width_right = 1
-	port_sb.border_width_bottom = 1
-	port_sb.border_color = Color(1.0, 0.85, 0.0, 0.8) # 황금빛 초상화 테두리
-	port_sb.set_corner_radius_all(4)
-	portrait_panel.add_theme_stylebox_override("panel", port_sb)
-	
-	var portrait: TextureRect = TextureRect.new()
-	portrait.name = "Portrait"
-	portrait.anchor_right = 1.0
-	portrait.anchor_bottom = 1.0
-	portrait.offset_left = 2
-	portrait.offset_top = 2
-	portrait.offset_right = -2
-	portrait.offset_bottom = -2
-	portrait.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
-	portrait.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_COVERED
-	
-	var p_path: String = "res://assets/ui/hero/dwarf_portrait.jpg"
-	if ResourceLoader.exists(p_path):
-		portrait.texture = load(p_path) as Texture2D
-	portrait_panel.add_child(portrait)
-	hbox.add_child(portrait_panel)
-	
-	# 4. 상세 정보 레이아웃 (VBox)
-	var vbox: VBoxContainer = VBoxContainer.new()
-	vbox.name = "VBox"
-	vbox.size_flags_horizontal = Control.SIZE_EXPAND_FILL
-	vbox.add_theme_constant_override("separation", 4)
-	hbox.add_child(vbox)
-	
-	# (1) 영웅 이름 및 레벨 표시 라벨
-	var name_label: Label = Label.new()
-	name_label.name = "NameLabel"
-	name_label.text = "Lv. %d %s" % [hero.level, hero.unit_data.unit_name]
-	name_label.add_theme_font_size_override("font_size", 13)
-	name_label.add_theme_color_override("font_color", Color(1.0, 0.9, 0.3, 1.0)) # 연황금색
-	vbox.add_child(name_label)
-	
-	# (2) 경험치 바 그룹 (HBox)
-	var xp_hbox: HBoxContainer = HBoxContainer.new()
-	xp_hbox.add_theme_constant_override("separation", 6)
-	
-	var xp_bar: ProgressBar = ProgressBar.new()
-	xp_bar.name = "XPBar"
-	xp_bar.show_percentage = false
-	xp_bar.custom_minimum_size = Vector2(110, 10)
-	xp_bar.size_flags_vertical = Control.SIZE_SHRINK_CENTER
-	
-	var xp_bg: StyleBoxFlat = StyleBoxFlat.new()
-	xp_bg.bg_color = Color(0.1, 0.1, 0.1, 1.0)
-	xp_bg.set_corner_radius_all(2)
-	
-	var xp_fg: StyleBoxFlat = StyleBoxFlat.new()
-	xp_fg.bg_color = Color(0.7, 0.15, 0.85, 1.0) # 강렬한 마젠타/보라색 게이지
-	xp_fg.set_corner_radius_all(2)
-	
-	xp_bar.add_theme_stylebox_override("background", xp_bg)
-	xp_bar.add_theme_stylebox_override("fill", xp_fg)
-	xp_hbox.add_child(xp_bar)
-	
-	var xp_label: Label = Label.new()
-	xp_label.name = "XPLabel"
-	xp_label.text = "%d / %d" % [hero.xp, hero.xp_to_next_level]
-	xp_label.add_theme_font_size_override("font_size", 9)
-	xp_hbox.add_child(xp_label)
-	vbox.add_child(xp_hbox)
-	
-	# (3) 스킬 단축키 그룹 (HBox)
-	var skill_hbox: HBoxContainer = HBoxContainer.new()
-	skill_hbox.name = "SkillGroup"
-	skill_hbox.add_theme_constant_override("separation", 6)
-	vbox.add_child(skill_hbox)
-	
-	# 4개 스킬 슬롯 배치 (Q, W, E, R)
-	var slots: Array[String] = ["Q", "W", "E", "R"]
-	var skill_names: Dictionary = {
-		"Q": "Strike",
-		"W": "Haste",
-		"E": "Clap",
-		"R": "Avatar"
-	}
-	
-	for slot: String in slots:
-		var btn: Button = Button.new()
-		btn.name = "Skill_" + slot
-		btn.text = slot
-		btn.custom_minimum_size = Vector2(32, 32)
-		btn.add_theme_font_size_override("font_size", 10)
-		
-		# 스킬 슬롯 배경 스타일링
-		var btn_sb: StyleBoxFlat = StyleBoxFlat.new()
-		btn_sb.bg_color = Color(0.2, 0.15, 0.3, 1.0)
-		btn_sb.border_width_left = 1
-		btn_sb.border_width_top = 1
-		btn_sb.border_width_right = 1
-		btn_sb.border_width_bottom = 1
-		btn_sb.border_color = Color(0.6, 0.4, 0.7, 0.8)
-		btn_sb.set_corner_radius_all(3)
-		btn.add_theme_stylebox_override("normal", btn_sb)
-		
-		# 툴팁 힌트 세팅
-		btn.tooltip_text = "%s Skill: %s\nCooldown: %.1fs" % [slot, skill_names[slot], hero.skill_max_cooldowns[slot]]
-		
-		# 클릭 시 스킬 사용 바인딩
-		btn.pressed.connect(func() -> void:
-			if is_instance_valid(hero):
-				hero.use_skill(slot)
-		)
-		
-		# 자식 쿨다운 오버레이 컬러렉트
-		var overlay: ColorRect = ColorRect.new()
-		overlay.name = "CooldownOverlay"
-		overlay.color = Color(0.0, 0.0, 0.0, 0.6)
-		overlay.anchor_right = 1.0
-		overlay.anchor_bottom = 1.0
-		overlay.mouse_filter = Control.MOUSE_FILTER_IGNORE
-		overlay.visible = false
-		btn.add_child(overlay)
-		_skill_cooldown_overlays[slot] = overlay
-		
-		# 자식 쿨다운 숫자 라벨
-		var label: Label = Label.new()
-		label.name = "CooldownLabel"
-		label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
-		label.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
-		label.anchor_right = 1.0
-		label.anchor_bottom = 1.0
-		label.add_theme_font_size_override("font_size", 9)
-		label.add_theme_color_override("font_color", Color(1.0, 1.0, 1.0, 1.0))
-		label.visible = false
-		btn.add_child(label)
-		_skill_cooldown_labels[slot] = label
-		
-		skill_hbox.add_child(btn)
-		
-	# 5. 영웅 시그널 연결 (실시간 UI 데이터 주입)
-	hero.level_changed.connect(func(new_lvl: int) -> void:
-		if is_instance_valid(name_label) and is_instance_valid(hero):
-			name_label.text = "Lv. %d %s" % [new_lvl, hero.unit_data.unit_name]
-	)
-	
-	hero.xp_changed.connect(func(curr_xp: int, need_xp: int) -> void:
-		if is_instance_valid(xp_bar) and is_instance_valid(xp_label):
-			xp_bar.max_value = need_xp
-			xp_bar.value = curr_xp
-			xp_label.text = "%d / %d" % [curr_xp, need_xp]
-	)
-	
-	hero.skill_cooldown_changed.connect(func(slot_name: String, remaining: float, duration: float) -> void:
-		var overlay: ColorRect = _skill_cooldown_overlays.get(slot_name)
-		var label: Label = _skill_cooldown_labels.get(slot_name)
-		if is_instance_valid(overlay) and is_instance_valid(label):
-			if remaining > 0.0:
-				overlay.visible = true
-				label.visible = true
-				label.text = "%.1f" % remaining
-			else:
-				overlay.visible = false
-				label.visible = false
-	)
+		_summoner_panel = HudSummonerPanelScript.new()
+		if _summoner_panel.has_method("build"):
+			_summoner_panel.call("build", bottom_bar, _summoner, data)
 	
-	# 초기 1회성 데이터 동기화 강제 발행
-	hero.xp_changed.emit(hero.xp, hero.xp_to_next_level)
-	hero.level_changed.emit(hero.level)
+	var stage_manager: Node = get_node_or_null("../StageManager")
+	if stage_manager and stage_manager.has_method("start_game"):
+		stage_manager.call("start_game")

src/ui/summoner_panel/hud_summoner_panel.gd

+class_name HudSummonerPanel
+extends RefCounted
+
+## HUD 하단의 소환사 상태/주문 UI를 생성하고 갱신하는 보조 클래스입니다.
+## - Summoner 노드의 mana_changed, spell_cooldown_changed 신호를 받아 버튼 상태를 갱신합니다.
+## - HUD 본문은 소환사 노드 생성과 게임 시작 호출만 담당하고, UI 세부 조립은 이 클래스가 맡습니다.
+
+const HASTE_SPELL_NAME: String = "haste"
+const SMITE_SPELL_NAME: String = "smite"
+const HASTE_MANA_COST: float = 40.0
+const SMITE_MANA_COST: float = 50.0
+
+const HASTE_ICON_PATH: String = "res://assets/ui/summoner/spells/spell_haste.png"
+const SMITE_ICON_PATH: String = "res://assets/ui/summoner/spells/spell_smite.png"
+
+var _summoner: Summoner = null
+var _mana_bar: ProgressBar = null
+var _mana_label: Label = null
+var _haste_button: Button = null
+var _smite_button: Button = null
+
+## 소환사 UI를 BottomBar 앞쪽에 조립하고 신호 연결까지 완료합니다.
+## data는 이미 GameManager에서 선택/디버그 기본값 보정이 끝난 SummonerData여야 합니다.
+func build(bottom_bar: Control, summoner: Summoner, data: SummonerData) -> void:
+	_summoner = summoner
+	
+	var summoner_ui: HBoxContainer = HBoxContainer.new()
+	summoner_ui.name = "SummonerUI"
+	summoner_ui.add_theme_constant_override("separation", 10)
+	
+	summoner_ui.add_child(_create_portrait(data))
+	summoner_ui.add_child(_create_mana_info_group(data))
+	summoner_ui.add_child(_create_spell_group())
+	
+	bottom_bar.add_child(summoner_ui)
+	bottom_bar.move_child(summoner_ui, 0)
+	_connect_summoner_signals()
+	
+	# UI 생성 직후 현재 마나 값을 한 번 강제 반영합니다.
+	# 신호 기반 UI이므로 초기 동기화도 같은 경로를 쓰면 이후 갱신과 표시 규칙이 일관됩니다.
+	_summoner.mana_changed.emit(_summoner.current_mana, _summoner.max_mana)
+
+## 소환사 초상화 TextureRect를 생성합니다.
+## 선택 데이터에 portrait_texture가 없으면 빈 영역을 유지해 레이아웃 크기만 안정적으로 잡습니다.
+func _create_portrait(data: SummonerData) -> TextureRect:
+	var portrait: TextureRect = TextureRect.new()
+	portrait.name = "SummonerPortrait"
+	portrait.custom_minimum_size = Vector2(48, 48)
+	portrait.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
+	portrait.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_COVERED
+	if data.portrait_texture:
+		portrait.texture = data.portrait_texture
+	return portrait
+
+## 마나 바와 숫자 라벨을 담는 세로 그룹을 생성합니다.
+## ProgressBar 스타일도 여기에서 함께 설정해 HUD 본문에 시각 세부사항이 새지 않게 합니다.
+func _create_mana_info_group(data: SummonerData) -> VBoxContainer:
+	var info_group: VBoxContainer = VBoxContainer.new()
+	info_group.name = "InfoGroup"
+	info_group.custom_minimum_size = Vector2(110, 48)
+	
+	_mana_bar = ProgressBar.new()
+	_mana_bar.name = "ManaBar"
+	_mana_bar.show_percentage = false
+	_mana_bar.custom_minimum_size = Vector2(110, 14)
+	_mana_bar.max_value = data.max_mana
+	_mana_bar.value = data.max_mana
+	
+	var background_style: StyleBoxFlat = StyleBoxFlat.new()
+	background_style.bg_color = Color(0.12, 0.12, 0.12, 0.8)
+	background_style.set_corner_radius_all(2)
+	
+	var fill_style: StyleBoxFlat = StyleBoxFlat.new()
+	fill_style.bg_color = Color(0.15, 0.45, 0.85, 1.0)
+	fill_style.set_corner_radius_all(2)
+	
+	_mana_bar.add_theme_stylebox_override("background", background_style)
+	_mana_bar.add_theme_stylebox_override("fill", fill_style)
+	info_group.add_child(_mana_bar)
+	
+	_mana_label = Label.new()
+	_mana_label.name = "ManaLabel"
+	_mana_label.text = "MP: %.1f / %.1f" % [data.max_mana, data.max_mana]
+	_mana_label.add_theme_font_size_override("font_size", 10)
+	info_group.add_child(_mana_label)
+	
+	return info_group
+
+## 소환사 주문 버튼 그룹을 생성합니다.
+## 각 버튼은 Summoner.cast_spell()만 호출하고, 사용 가능 여부는 신호 갱신에서 계산합니다.
+func _create_spell_group() -> HBoxContainer:
+	var spell_group: HBoxContainer = HBoxContainer.new()
+	spell_group.name = "SpellGroup"
+	spell_group.add_theme_constant_override("separation", 5)
+	
+	_haste_button = _create_spell_button("SpellHaste", "Haste (40 MP)", HASTE_ICON_PATH)
+	_haste_button.pressed.connect(func() -> void:
+		_summoner.cast_spell(HASTE_SPELL_NAME)
+	)
+	spell_group.add_child(_haste_button)
+	
+	_smite_button = _create_spell_button("SpellSmite", "Smite (50 MP)", SMITE_ICON_PATH)
+	_smite_button.pressed.connect(func() -> void:
+		_summoner.cast_spell(SMITE_SPELL_NAME)
+	)
+	spell_group.add_child(_smite_button)
+	
+	return spell_group
+
+## 주문 버튼 하나를 생성하고 아이콘이 있으면 함께 적용합니다.
+## 아이콘 파일이 없어도 버튼 크기를 유지해 UI가 갑자기 줄어들지 않게 합니다.
+func _create_spell_button(button_name: String, text: String, icon_path: String) -> Button:
+	var button: Button = Button.new()
+	button.name = button_name
+	button.text = text
+	if ResourceLoader.exists(icon_path):
+		button.icon = load(icon_path) as Texture2D
+		button.expand_icon = true
+		button.custom_minimum_size = Vector2(90, 45)
+	else:
+		button.custom_minimum_size = Vector2(90, 30)
+	return button
+
+## 소환사 신호를 UI 갱신 함수에 연결합니다.
+## 문자열 기반 연결 대신 Callable 연결을 사용해 Godot 4 스타일을 유지합니다.
+func _connect_summoner_signals() -> void:
+	_summoner.mana_changed.connect(_on_mana_changed)
+	_summoner.spell_cooldown_changed.connect(_on_spell_cooldown_changed)
+
+## 현재 마나와 쿨다운 상태를 함께 보고 주문 버튼 활성/비활성을 갱신합니다.
+func _on_mana_changed(current: float, max_value: float) -> void:
+	if not is_instance_valid(_mana_bar) or not is_instance_valid(_mana_label):
+		return
+		
+	_mana_bar.max_value = max_value
+	_mana_bar.value = current
+	_mana_label.text = "MP: %.1f / %.1f" % [current, max_value]
+	
+	_update_spell_button_enabled(_haste_button, HASTE_SPELL_NAME, HASTE_MANA_COST)
+	_update_spell_button_enabled(_smite_button, SMITE_SPELL_NAME, SMITE_MANA_COST)
+
+## 쿨다운 숫자를 버튼 텍스트에 표시하고, 쿨다운 종료 시 마나 조건을 다시 검사합니다.
+func _on_spell_cooldown_changed(spell_name: String, remaining: float, _duration: float) -> void:
+	var button: Button = _haste_button if spell_name == HASTE_SPELL_NAME else _smite_button
+	var label_text: String = "Haste" if spell_name == HASTE_SPELL_NAME else "Smite"
+	var cost: float = HASTE_MANA_COST if spell_name == HASTE_SPELL_NAME else SMITE_MANA_COST
+	
+	if remaining > 0.0:
+		button.text = "%s\n(%.1fs)" % [label_text, remaining]
+		button.disabled = true
+	else:
+		button.text = "%s (%d MP)" % [label_text, cost]
+		_update_spell_button_enabled(button, spell_name, cost)
+
+## 마나 부족 또는 쿨다운 중이면 주문 버튼을 비활성화합니다.
+func _update_spell_button_enabled(button: Button, spell_name: String, mana_cost: float) -> void:
+	if not is_instance_valid(button) or not is_instance_valid(_summoner):
+		return
+		
+	var cooldown_remaining: float = _summoner.spell_cooldowns.get(spell_name, 0.0)
+	button.disabled = _summoner.current_mana < mana_cost or cooldown_remaining > 0.0

src/ui/summoner_panel/hud_summoner_panel.gd.uid

+uid://xv3ptedjdn2o

src/ui/unit_placement/hud_unit_placement.gd

+extends RefCounted
+
+## HUD의 유닛 소환/타일 배치 흐름만 담당하는 보조 클래스입니다.
+## - HUD 본문이 입력, 타일 레이캐스트, 배치 오버레이 생성까지 모두 떠안지 않도록 책임을 분리합니다.
+## - 실제 노드는 hud.get_tree()를 통해 현재 전장 씬에 배치하며, hud.tscn 원본은 수정하지 않습니다.
+## - 배치 대기 상태는 이 클래스 내부에만 보관하여 HUD는 "배치 중인지"만 물어보면 됩니다.
+
+const INVALID_TILE_CELL: Vector3i = Vector3i(2147483647, 2147483647, 2147483647)
+
+const STRIKER_SCENE: PackedScene = preload("res://src/entities/units/striker/striker_unit.tscn")
+const GUARDIAN_SCENE: PackedScene = preload("res://src/entities/units/guardian/guardian_unit.tscn")
+const RANGER_SCENE: PackedScene = preload("res://src/entities/units/ranger/ranger_unit.tscn")
+const MAGE_SCENE: PackedScene = preload("res://src/entities/units/mage/mage_unit.tscn")
+const PLACEMENT_TILE_OVERLAY_SCENE: PackedScene = preload("res://src/ui/unit_placement/placement_tile_overlay.tscn")
+const OVERLAY_POOL_WARMUP_BATCH_SIZE: int = 16
+
+var _hud: Control = null
+var _unit_spawn_button: Button = null
+var _base_unit_scene: PackedScene = null
+var _spawn_button_default_text: String = ""
+
+var _pending_unit_scene: PackedScene = null
+var _pending_unit_data: UnitData = null
+var _pending_spawn_cost: int = 0
+
+var _placement_available_material: StandardMaterial3D = null
+var _placement_occupied_material: StandardMaterial3D = null
+var _overlay_pool: Array[Node] = []
+var _active_overlays: Array[Node] = []
+var _overlay_pool_parent: Node = null
+var _is_overlay_pool_warming_up: bool = false
+
+var _pending_preview_panel: Panel = null
+var _pending_preview_name_label: Label = null
+var _pending_preview_role_label: Label = null
+var _pending_preview_damage_label: Label = null
+var _pending_preview_cooldown_label: Label = null
+var _pending_preview_range_label: Label = null
+var _pending_preview_cost_label: Label = null
+var _pending_preview_color_swatch: ColorRect = null
+
+## HUD에서 필요한 참조를 주입받습니다.
+## RefCounted는 씬 트리에 직접 붙지 않으므로, viewport/tree 접근은 HUD 노드를 통해 수행합니다.
+func setup(hud: Control, unit_spawn_button: Button, base_unit_scene: PackedScene) -> void:
+	_hud = hud
+	_unit_spawn_button = unit_spawn_button
+	_base_unit_scene = base_unit_scene
+	_spawn_button_default_text = _unit_spawn_button.text
+
+## 전장 진입 직후 타일 오버레이 풀을 미리 준비합니다.
+## HUD _ready()에서 호출되며, 한 프레임 뒤 StageMap/GridMap이 준비된 시점에 사용 타일 수만큼 씬 인스턴스를 만들어 둡니다.
+func warmup_overlay_pool_deferred() -> void:
+	if not _hud or _is_overlay_pool_warming_up:
+		return
+		
+	_is_overlay_pool_warming_up = true
+	await _hud.get_tree().process_frame
+	var grid_map: GridMap = _get_stage_grid_map()
+	var parent_scene: Node = _hud.get_tree().current_scene
+	if not grid_map or not parent_scene:
+		_is_overlay_pool_warming_up = false
+		return
+		
+	var used_cells: Array = grid_map.get_used_cells()
+	await _warmup_overlay_pool_in_batches(parent_scene, used_cells.size())
+	_is_overlay_pool_warming_up = false
+
+## 현재 유닛 배치 위치를 기다리는 중인지 반환합니다.
+## HUD는 이 값으로 새 소환, 영웅 소환, 마우스 입력 처리 가능 여부를 판단합니다.
+func has_pending_unit_placement() -> bool:
+	return _pending_unit_scene != null and _pending_unit_data != null
+
+## 마우스/터치 입력을 받아 배치 대기 중인 유닛을 선택된 타일에 놓습니다.
+## 배치 상태가 아닐 때는 false를 반환해 HUD의 다른 입력 흐름을 방해하지 않습니다.
+func handle_input(event: InputEvent) -> bool:
+	if not has_pending_unit_placement():
+		return false
+		
+	if event is InputEventMouseButton:
+		var mouse_event: InputEventMouseButton = event as InputEventMouseButton
+		if mouse_event.button_index == MOUSE_BUTTON_LEFT and mouse_event.pressed:
+			_try_place_pending_unit(mouse_event.position)
+			return true
+	elif event is InputEventScreenTouch:
+		var touch_event: InputEventScreenTouch = event as InputEventScreenTouch
+		if touch_event.pressed:
+			_try_place_pending_unit(touch_event.position)
+			return true
+			
+	return false
+
+## 현재 보유한 유닛 템플릿 중 하나를 무작위로 골라 타일 선택 대기 상태로 전환합니다.
+## 실제 골드 차감은 타일 배치가 확정되는 순간 처리하여, 잘못 누른 소환 버튼이 즉시 비용을 쓰지 않게 합니다.
+func begin_random_unit_placement() -> void:
+	if GameManager.is_game_over or has_pending_unit_placement():
+		return
+		
+	if DataManager.unit_templates.is_empty():
+		return
+		
+	if GameManager.player_gold < GameManager.unit_spawn_cost:
+		return
+		
+	var random_index: int = randi() % DataManager.unit_templates.size()
+	var chosen_template: UnitData = DataManager.unit_templates[random_index]
+	var target_scene: PackedScene = _get_scene_for_unit(chosen_template)
+	_begin_unit_placement(target_scene, chosen_template, GameManager.unit_spawn_cost)
+
+## 유닛 ID에 대응하는 전용 씬을 반환합니다.
+## 새 유닛 타입이 추가되면 이 match에만 씬 매핑을 늘리면 배치 흐름은 그대로 재사용됩니다.
+func _get_scene_for_unit(unit_data: UnitData) -> PackedScene:
+	match unit_data.unit_id:
+		"Unit_Striker":
+			return STRIKER_SCENE
+		"Unit_Guardian":
+			return GUARDIAN_SCENE
+		"Unit_Ranger":
+			return RANGER_SCENE
+		"Unit_Mage":
+			return MAGE_SCENE
+		_:
+			return _base_unit_scene
+
+## 소환 버튼을 "타일 선택" 모드로 바꾸고, 배치 가능한 모든 타일에 오버레이를 표시합니다.
+func _begin_unit_placement(unit_scene: PackedScene, unit_data: UnitData, spawn_cost: int) -> void:
+	_pending_unit_scene = unit_scene
+	_pending_unit_data = unit_data
+	_pending_spawn_cost = spawn_cost
+	_unit_spawn_button.text = "Select Tile"
+	_show_pending_unit_preview(unit_data, spawn_cost)
+	_show_placement_tile_overlays()
+
+## 배치 대기 상태와 타일 오버레이를 함께 정리합니다.
+## 골드 부족, 성공 배치, 씬 전환 등의 경로에서 동일한 복구 로직을 사용합니다.
+func clear_pending_unit_placement() -> void:
+	_pending_unit_scene = null
+	_pending_unit_data = null
+	_pending_spawn_cost = 0
+	_unit_spawn_button.text = _spawn_button_default_text
+	_hide_pending_unit_preview()
+	_clear_placement_tile_overlays()
+
+## 화면 좌표에서 타일을 찾고, 점유/골드 조건을 검증한 뒤 유닛을 실제 전장에 배치합니다.
+func _try_place_pending_unit(screen_pos: Vector2) -> void:
+	var tile_info: Dictionary = _get_tile_info_from_screen(screen_pos)
+	if tile_info.is_empty():
+		return
+		
+	var tile_cell: Vector3i = tile_info["cell"]
+	if _is_tile_occupied(tile_cell):
+		return
+		
+	if not GameManager.spend_gold(_pending_spawn_cost):
+		clear_pending_unit_placement()
+		return
+		
+	var new_unit: Node = _pending_unit_scene.instantiate()
+	var parent_scene: Node = _hud.get_tree().current_scene
+	var tile_center: Vector3 = tile_info["center"]
+	
+	new_unit.set("unit_data", _pending_unit_data)
+	parent_scene.add_child(new_unit)
+	
+	if new_unit is BaseUnit:
+		(new_unit as BaseUnit).place_on_tile(tile_center, tile_cell)
+	elif new_unit is Node3D:
+		(new_unit as Node3D).global_position = tile_center
+		
+	clear_pending_unit_placement()
+
+## 화면 좌표에 대응하는 GridMap 셀과 배치 중심 좌표를 계산합니다.
+## 카메라에서 월드로 레이를 쏜 뒤, 맞은 지점 주변에서 실제 타일 셀을 찾습니다.
+func _get_tile_info_from_screen(screen_pos: Vector2) -> Dictionary:
+	var camera: Camera3D = _hud.get_viewport().get_camera_3d()
+	var grid_map: GridMap = _get_stage_grid_map()
+	if not camera or not grid_map:
+		return {}
+		
+	var ray_origin: Vector3 = camera.project_ray_origin(screen_pos)
+	var ray_end: Vector3 = ray_origin + camera.project_ray_normal(screen_pos) * 1000.0
+	var query: PhysicsRayQueryParameters3D = PhysicsRayQueryParameters3D.create(ray_origin, ray_end)
+	var result: Dictionary = camera.get_world_3d().direct_space_state.intersect_ray(query)
+	if result.is_empty() or not result.has("position"):
+		return {}
+		
+	var hit_position: Vector3 = result["position"]
+	var tile_cell: Vector3i = _get_valid_tile_cell(grid_map, hit_position)
+	if tile_cell == INVALID_TILE_CELL:
+		return {}
+		
+	var tile_center: Vector3 = grid_map.to_global(grid_map.map_to_local(tile_cell))
+	tile_center.y += 1.0
+	return {
+		"cell": tile_cell,
+		"center": tile_center
+	}
+
+## 레이 충돌 위치와 가장 가까운 유효 GridMap 셀을 반환합니다.
+## 모델/타일 높이가 조금 달라도 같은 x/z의 주변 y 셀을 탐색해 배치 판정이 쉽게 빗나가지 않게 합니다.
+func _get_valid_tile_cell(grid_map: GridMap, world_position: Vector3) -> Vector3i:
+	var local_position: Vector3 = grid_map.to_local(world_position)
+	var tile_cell: Vector3i = grid_map.local_to_map(local_position)
+	if grid_map.get_cell_item(tile_cell) != -1:
+		return tile_cell
+		
+	var ground_cell: Vector3i = Vector3i(tile_cell.x, 0, tile_cell.z)
+	if grid_map.get_cell_item(ground_cell) != -1:
+		return ground_cell
+		
+	for y: int in range(tile_cell.y - 4, tile_cell.y + 5):
+		var nearby_cell: Vector3i = Vector3i(tile_cell.x, y, tile_cell.z)
+		if grid_map.get_cell_item(nearby_cell) != -1:
+			return nearby_cell
+			
+	return INVALID_TILE_CELL
+
+## 현재 전장 씬에서 StageMap으로 들어간 GridMap을 찾습니다.
+## 맵 씬이 NavigationRegion3D 아래에 동적으로 붙으므로 고정 NodePath 대신 재귀 탐색을 사용합니다.
+func _get_stage_grid_map() -> GridMap:
+	var current_scene: Node = _hud.get_tree().current_scene
+	if not current_scene:
+		return null
+	return _find_grid_map(current_scene)
+
+## 자식 노드를 재귀 순회하며 첫 번째 GridMap을 반환합니다.
+func _find_grid_map(node: Node) -> GridMap:
+	if node is GridMap:
+		return node as GridMap
+		
+	for child: Node in node.get_children():
+		var found_grid: GridMap = _find_grid_map(child)
+		if found_grid:
+			return found_grid
+			
+	return null
+
+## 이미 타일에 고정 배치된 유닛이 해당 셀을 점유 중인지 확인합니다.
+## BaseUnit.place_on_tile()에서 기록한 occupied_tile_cell을 기준으로 중복 배치를 막습니다.
+func _is_tile_occupied(tile_cell: Vector3i) -> bool:
+	var units: Array[Node] = _hud.get_tree().get_nodes_in_group("units")
+	for unit_node: Node in units:
+		if unit_node is BaseUnit:
+			var unit: BaseUnit = unit_node as BaseUnit
+			if unit.is_tile_bound and unit.occupied_tile_cell == tile_cell:
+				return true
+	return false
+
+## 배치 모드 진입 시 모든 사용 타일 위에 가능/불가 오버레이를 표시합니다.
+func _show_placement_tile_overlays() -> void:
+	_clear_placement_tile_overlays()
+	
+	var grid_map: GridMap = _get_stage_grid_map()
+	var parent_scene: Node = _hud.get_tree().current_scene
+	if not grid_map or not parent_scene:
+		return
+		
+	var used_cells: Array = grid_map.get_used_cells()
+	_ensure_overlay_pool_capacity(parent_scene, used_cells.size())
+	for cell: Vector3i in used_cells:
+		_add_placement_tile_overlay(grid_map, cell)
+
+## 배치 모드에서 사용 중인 오버레이를 삭제하지 않고 풀로 반환합니다.
+## 씬 트리에 남아 있는 비활성 오버레이는 다음 배치 모드에서 즉시 재사용됩니다.
+func _clear_placement_tile_overlays() -> void:
+	for overlay: Node in _active_overlays:
+		if is_instance_valid(overlay):
+			if overlay.has_method("release_to_pool"):
+				overlay.call("release_to_pool")
+			_overlay_pool.append(overlay)
+	_active_overlays.clear()
+
+## 타일 하나에 대응하는 오버레이 씬을 풀에서 꺼내 위치/크기/재질을 설정합니다.
+## 새 MeshInstance3D나 PlaneMesh를 만들지 않고 placement_tile_overlay.tscn 인스턴스를 재사용합니다.
+func _add_placement_tile_overlay(grid_map: GridMap, tile_cell: Vector3i) -> void:
+	var is_occupied: bool = _is_tile_occupied(tile_cell)
+	var overlay: Node = _take_overlay_from_pool()
+	if not overlay:
+		return
+	
+	var tile_center: Vector3 = grid_map.to_global(grid_map.map_to_local(tile_cell))
+	tile_center.y += 1.03
+	var tile_size: Vector2 = Vector2(grid_map.cell_size.x * 0.92, grid_map.cell_size.z * 0.92)
+	if overlay.has_method("configure"):
+		overlay.call("configure", tile_center, tile_size, _get_placement_material(is_occupied), is_occupied)
+	_active_overlays.append(overlay)
+
+## 오버레이 풀이 필요한 수량만큼 준비되어 있는지 확인합니다.
+## 부족한 수량만 placement_tile_overlay.tscn을 instantiate하고, 이후 배치 모드에서는 재사용합니다.
+func _ensure_overlay_pool_capacity(parent_scene: Node, required_count: int) -> void:
+	_reset_overlay_pool_if_parent_changed(parent_scene)
+	
+	var total_count: int = _overlay_pool.size() + _active_overlays.size()
+	var missing_count: int = maxi(0, required_count - total_count)
+	for index: int in range(missing_count):
+		_add_overlay_instance_to_pool(parent_scene)
+
+## 전장 시작 직후 오버레이 풀을 여러 프레임에 나누어 채웁니다.
+## 타일 수가 많아도 한 프레임에 instantiate 비용이 몰리지 않게 하여 초기 로딩 끊김을 줄입니다.
+func _warmup_overlay_pool_in_batches(parent_scene: Node, required_count: int) -> void:
+	_reset_overlay_pool_if_parent_changed(parent_scene)
+	
+	while _overlay_pool.size() + _active_overlays.size() < required_count:
+		var batch_count: int = mini(
+			OVERLAY_POOL_WARMUP_BATCH_SIZE,
+			required_count - (_overlay_pool.size() + _active_overlays.size())
+		)
+		
+		for index: int in range(batch_count):
+			_add_overlay_instance_to_pool(parent_scene)
+			
+		await _hud.get_tree().process_frame
+
+## placement_tile_overlay.tscn 인스턴스 하나를 생성해 현재 씬에 붙이고 비활성 풀에 보관합니다.
+## 런타임 생성 위치를 이 함수로 모아, 배치 모드 표시 로직에서는 instantiate를 직접 호출하지 않게 합니다.
+func _add_overlay_instance_to_pool(parent_scene: Node) -> void:
+	var overlay: Node = PLACEMENT_TILE_OVERLAY_SCENE.instantiate()
+	if not overlay:
+		return
+		
+	parent_scene.add_child(overlay)
+	if overlay.has_method("release_to_pool"):
+		overlay.call("release_to_pool")
+	_overlay_pool.append(overlay)
+
+## 현재 씬이 바뀐 경우 이전 씬에 붙어 있던 풀 참조를 버립니다.
+## restart_game()처럼 씬 리로드가 일어나면 기존 노드는 함께 사라지므로 새 씬 기준으로 다시 워밍업합니다.
+func _reset_overlay_pool_if_parent_changed(parent_scene: Node) -> void:
+	if _overlay_pool_parent == parent_scene:
+		return
+		
+	_overlay_pool.clear()
+	_active_overlays.clear()
+	_overlay_pool_parent = parent_scene
+
+## 비활성 오버레이 하나를 풀에서 꺼냅니다.
+## 예외적으로 풀이 비어 있으면 빈 값을 반환하고, 사전에 warmup/ensure가 실패했음을 조용히 허용합니다.
+func _take_overlay_from_pool() -> Node:
+	if _overlay_pool.is_empty():
+		return null
+		
+	return _overlay_pool.pop_back()
+
+## 배치 가능/점유 상태에 맞는 오버레이 머티리얼을 반환합니다.
+## 머티리얼은 최초 1회만 생성하고 이후 타일들이 공유합니다.
+func _get_placement_material(is_occupied: bool) -> StandardMaterial3D:
+	if is_occupied:
+		if not _placement_occupied_material:
+			_placement_occupied_material = _create_placement_material(Color(1.0, 0.05, 0.02, 0.38))
+		return _placement_occupied_material
+		
+	if not _placement_available_material:
+		_placement_available_material = _create_placement_material(Color(0.05, 1.0, 0.2, 0.32))
+	return _placement_available_material
+
+## 3D 타일 위에 얹을 반투명/비조명 머티리얼을 생성합니다.
+## no_depth_test를 켜서 타일 표면과 겹칠 때 깜빡이는 z-fighting을 줄입니다.
+func _create_placement_material(color: Color) -> StandardMaterial3D:
+	var material: StandardMaterial3D = StandardMaterial3D.new()
+	material.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
+	material.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
+	material.albedo_color = color
+	material.cull_mode = BaseMaterial3D.CULL_DISABLED
+	material.no_depth_test = true
+	return material
+
+## pending 상태의 유닛 정보를 우측 상단 미리보기 패널에 표시합니다.
+## 실제 유닛 씬을 미리보기로 instantiate하면 BaseUnit._ready()가 실행되어 units 그룹/AI 상태에 섞일 수 있으므로,
+## HUD 전용 카드에 UnitData 기반 정보만 표시해 전투 로직과 완전히 분리합니다.
+func _show_pending_unit_preview(unit_data: UnitData, spawn_cost: int) -> void:
+	_ensure_pending_preview_panel()
+	
+	_pending_preview_color_swatch.color = unit_data.unit_color
+	_pending_preview_name_label.text = unit_data.unit_name
+	_pending_preview_role_label.text = _get_unit_role_text(unit_data)
+	_pending_preview_damage_label.text = "DMG  %.1f" % unit_data.damage
+	_pending_preview_cooldown_label.text = "CD   %.1fs" % unit_data.cooldown
+	_pending_preview_range_label.text = "RNG  %.1fm" % unit_data.attack_range
+	_pending_preview_cost_label.text = "COST %d G" % spawn_cost
+	_pending_preview_panel.visible = true
+
+## pending 배치가 끝났거나 취소될 때 미리보기 패널을 숨깁니다.
+## 패널 노드는 삭제하지 않고 보관해 다음 소환 대기 때 라벨 값만 교체합니다.
+func _hide_pending_unit_preview() -> void:
+	if _pending_preview_panel and is_instance_valid(_pending_preview_panel):
+		_pending_preview_panel.visible = false
+
+## 우측 상단 pending 미리보기 패널을 최초 1회 생성합니다.
+## hud.tscn 원본을 직접 수정하지 않고 런타임 노드로 붙이며, 이후에는 같은 패널을 재사용합니다.
+func _ensure_pending_preview_panel() -> void:
+	if _pending_preview_panel and is_instance_valid(_pending_preview_panel):
+		return
+		
+	_pending_preview_panel = Panel.new()
+	_pending_preview_panel.name = "PendingUnitPreviewPanel"
+	_pending_preview_panel.anchor_left = 1.0
+	_pending_preview_panel.anchor_right = 1.0
+	_pending_preview_panel.anchor_top = 0.0
+	_pending_preview_panel.anchor_bottom = 0.0
+	_pending_preview_panel.offset_left = -260.0
+	_pending_preview_panel.offset_top = 84.0
+	_pending_preview_panel.offset_right = -20.0
+	_pending_preview_panel.offset_bottom = 210.0
+	_pending_preview_panel.visible = false
+	_pending_preview_panel.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	_pending_preview_panel.add_theme_stylebox_override("panel", _create_pending_preview_panel_style())
+	_hud.add_child(_pending_preview_panel)
+	
+	var margin: MarginContainer = MarginContainer.new()
+	margin.anchor_right = 1.0
+	margin.anchor_bottom = 1.0
+	margin.add_theme_constant_override("margin_left", 12)
+	margin.add_theme_constant_override("margin_top", 10)
+	margin.add_theme_constant_override("margin_right", 12)
+	margin.add_theme_constant_override("margin_bottom", 10)
+	_pending_preview_panel.add_child(margin)
+	
+	var root_box: VBoxContainer = VBoxContainer.new()
+	root_box.add_theme_constant_override("separation", 6)
+	margin.add_child(root_box)
+	
+	var header_row: HBoxContainer = HBoxContainer.new()
+	header_row.add_theme_constant_override("separation", 8)
+	root_box.add_child(header_row)
+	
+	_pending_preview_color_swatch = ColorRect.new()
+	_pending_preview_color_swatch.name = "UnitColorSwatch"
+	_pending_preview_color_swatch.custom_minimum_size = Vector2(18, 18)
+	_pending_preview_color_swatch.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	header_row.add_child(_pending_preview_color_swatch)
+	
+	var title_box: VBoxContainer = VBoxContainer.new()
+	title_box.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	title_box.add_theme_constant_override("separation", 1)
+	header_row.add_child(title_box)
+	
+	_pending_preview_name_label = Label.new()
+	_pending_preview_name_label.name = "UnitNameLabel"
+	_pending_preview_name_label.add_theme_font_size_override("font_size", 15)
+	_pending_preview_name_label.add_theme_color_override("font_color", Color(1.0, 0.95, 0.78, 1.0))
+	title_box.add_child(_pending_preview_name_label)
+	
+	_pending_preview_role_label = Label.new()
+	_pending_preview_role_label.name = "UnitRoleLabel"
+	_pending_preview_role_label.add_theme_font_size_override("font_size", 10)
+	_pending_preview_role_label.add_theme_color_override("font_color", Color(0.74, 0.84, 0.92, 1.0))
+	title_box.add_child(_pending_preview_role_label)
+	
+	var separator: HSeparator = HSeparator.new()
+	root_box.add_child(separator)
+	
+	var stats_grid: GridContainer = GridContainer.new()
+	stats_grid.columns = 2
+	stats_grid.add_theme_constant_override("h_separation", 10)
+	stats_grid.add_theme_constant_override("v_separation", 4)
+	root_box.add_child(stats_grid)
+	
+	_pending_preview_damage_label = _create_pending_preview_stat_label()
+	_pending_preview_cooldown_label = _create_pending_preview_stat_label()
+	_pending_preview_range_label = _create_pending_preview_stat_label()
+	_pending_preview_cost_label = _create_pending_preview_stat_label()
+	stats_grid.add_child(_pending_preview_damage_label)
+	stats_grid.add_child(_pending_preview_cooldown_label)
+	stats_grid.add_child(_pending_preview_range_label)
+	stats_grid.add_child(_pending_preview_cost_label)
+
+## pending 미리보기 패널 배경 스타일을 생성합니다.
+## 어두운 반투명 배경과 얇은 테두리로 전투 화면을 가리지 않으면서도 현재 대기 유닛을 식별하게 합니다.
+func _create_pending_preview_panel_style() -> StyleBoxFlat:
+	var style: StyleBoxFlat = StyleBoxFlat.new()
+	style.bg_color = Color(0.05, 0.08, 0.11, 0.86)
+	style.border_color = Color(0.34, 0.72, 0.95, 0.85)
+	style.border_width_left = 1
+	style.border_width_top = 1
+	style.border_width_right = 1
+	style.border_width_bottom = 1
+	style.set_corner_radius_all(6)
+	return style
+
+## 미리보기 스탯 라벨 공통 스타일을 생성합니다.
+func _create_pending_preview_stat_label() -> Label:
+	var label: Label = Label.new()
+	label.add_theme_font_size_override("font_size", 11)
+	label.add_theme_color_override("font_color", Color(0.9, 0.94, 0.96, 1.0))
+	return label
+
+## UnitData의 원거리 여부를 플레이어가 바로 알아볼 수 있는 짧은 역할 문자열로 변환합니다.
+func _get_unit_role_text(unit_data: UnitData) -> String:
+	if unit_data.is_ranged:
+		return "Ranged Unit"
+	return "Melee Unit"

src/ui/unit_placement/hud_unit_placement.gd.uid

+uid://cuuq64au1mfit

src/ui/unit_placement/placement_tile_overlay.gd

+extends MeshInstance3D
+
+## 유닛 배치 모드에서 타일 위에 표시되는 3D 오버레이 노드입니다.
+## - 이 노드는 placement_tile_overlay.tscn의 루트로 사용됩니다.
+## - HudUnitPlacement는 이 씬을 풀로 미리 만들어 두고, 배치 모드마다 configure()로 재사용합니다.
+## - PlaneMesh 자체는 씬에 포함된 1x1 크기를 사용하고, 실제 타일 크기는 scale로 맞춰 런타임 Mesh 생성을 피합니다.
+
+const HIDDEN_POSITION: Vector3 = Vector3(0.0, -100.0, 0.0)
+
+## 풀에서 대기 중인지 여부입니다.
+## 디버깅 중 씬 트리에서 오버레이 상태를 확인할 때 쓸 수 있도록 명시적으로 보관합니다.
+var is_available_in_pool: bool = true
+
+func _ready() -> void:
+	# 오버레이는 순수 표시용이므로 그림자와 입력 충돌 비용을 만들지 않습니다.
+	cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
+	visible = false
+	global_position = HIDDEN_POSITION
+
+## 풀에서 꺼낸 오버레이를 실제 타일 위치/크기/재질로 설정하고 표시합니다.
+## PlaneMesh는 기본 1x1 크기이므로 scale.x/z로 GridMap 셀 크기에 맞춥니다.
+func configure(tile_center: Vector3, tile_size: Vector2, material: Material, is_occupied: bool) -> void:
+	is_available_in_pool = false
+	name = "OccupiedTileOverlay" if is_occupied else "AvailableTileOverlay"
+	global_position = tile_center
+	scale = Vector3(tile_size.x, 1.0, tile_size.y)
+	material_override = material
+	visible = true
+
+## 배치 모드가 끝나면 삭제하지 않고 풀에 반환될 수 있도록 숨깁니다.
+## 씬 트리에는 남아 있으므로 다음 배치 모드에서는 instantiate 없이 바로 재사용됩니다.
+func release_to_pool() -> void:
+	is_available_in_pool = true
+	visible = false
+	global_position = HIDDEN_POSITION
+	material_override = null

src/ui/unit_placement/placement_tile_overlay.gd.uid

+uid://bd00wvrr48mfi

src/ui/unit_placement/placement_tile_overlay.tscn

+[gd_scene format=3]
+
+[ext_resource type="Script" path="res://src/ui/unit_placement/placement_tile_overlay.gd" id="1_67clr"]
+
+[sub_resource type="PlaneMesh" id="PlaneMesh_y7kwe"]
+size = Vector2(1, 1)
+
+[node name="PlacementTileOverlay" type="MeshInstance3D" unique_id=1113555824]
+visible = false
+cast_shadow = 0
+mesh = SubResource("PlaneMesh_y7kwe")
+script = ExtResource("1_67clr")