06. 무기 4종 — 투사체와 이펙트도 엔티티다

// Assets/GameMain/Weapon/WeaponTable.cs namespace ToyBoxNightmare { /// <summary> /// 무기 관련 상수. Addressables 주소는 여기 문자열과 Groups 창의 Address 가 /// 정확히 같아야 한다 — 다르면 ShowEntity 가 조용히 실패한다. /// /// <b>쿨다운은 전역이다.</b> 무기가 자기 타이머를 돌리지 않는다. 여기 값은 /// "이 무기로 쏘고 나면 <b>모든</b> 무기가 몇 초 잠기는가" 이고, 그 타이머는 /// <see cref="WeaponLoadout"/> 이 한 쌍만 들고 있다. /// </summary> public static class WeaponTable { // ─── 엔티티 그룹 ─── public const string WeaponGroup = "Weapon"; public const string ProjectileGroup = "Projectile"; public const string EffectGroup = "Effect"; // ─── Addressables 주소 ─── // 무기 엔티티 프리팹. 플레이어의 발사점(WeaponBase.AttachPath)에 붙는다. public const string LightningWeaponAsset = "LightningAttack"; public const string FrostWeaponAsset = "FrostAttack"; public const string StinkWeaponAsset = "StinkAttack"; public const string SlimeWeaponAsset = "SlimeAttack"; public const string LightningHitAsset = "LightningHit"; public const string StinkProjectileAsset = "StinkProjectile"; public const string StinkHitAsset = "StinkHit"; public const string SlimeProjectileAsset = "SlimeProjectile"; public const string SlimeHitAsset = "SlimeHit"; // ─── Lightning ─── // 누르고 있는 동안 발사. 쿨다운 1초. 레티클 없음. public const float LightningRange = 10f; public const int LightningDamage = 50; public const float LightningCooldown = 1f; /// <summary>착탄 이펙트 수명. 파티클이 0.5~0.75초라 여유를 둔 값.</summary> public const float LightningHitLifetime = 1f; // ─── Frost (데미지 0. Lightning 과 병행 장착이 전제다) ─── // 누르면 콘 ON, 떼면 콘 OFF. 레티클 없음. 쿨다운 없음. public const float FrostCooldown = 0f; /// <summary>콘 안의 적을 다시 훑는 주기.</summary> public const float FrostRetickInterval = 0.2f; public const float FrostConeRadius = 6f; public const float FrostConeHalfAngle = 30f; // 개구각 60° // ─── Stink ─── // **떼는 프레임에** 마우스 지면 지점으로 투척. 쿨다운 5초. 레티클 있음. public const float StinkCooldown = 5f; /// <summary> /// 투척 사거리. 플레이어와 마우스 지면 지점 사이 거리가 이 값 이내여야 던진다. /// 밖이면 레티클이 빨강이고 발사도 안 된다. /// </summary> public const float StinkThrowRange = 10f; public const float StinkSpeed = 10f; public const float StinkBlastRadius = 4f; public const float StinkFleeDuration = 4f; public const float StinkHitLifetime = 4f; // ─── Slime ─── // **떼는 프레임에** 발사. 쿨다운 3.5초. 레티클 있음. // 대상은 마우스 지면 지점에서 위로 쏜 짧은 레이에 걸린 적이다. 대상이 없으면 // 발사 자체가 실패하고 쿨다운도 걸리지 않는다. public const float SlimeCooldown = 3.5f; /// <summary>대상 판정 레이 길이. 마우스 지면 지점에서 Vector3.up 으로 이만큼 쏜다.</summary> public const float SlimeTargetRayLength = 2f; public const float SlimeSpeed = 20f; public const float SlimeHitRadius = 1f; public const float SlimeHitLifetime = 1.2f; // DoT public const int SlimeTicks = 6; public const float SlimeTickInterval = 0.5f; public const int SlimeTickDamage = 20; } }

// Assets/GameMain/Weapon/WeaponUtil.cs using System.Collections.Generic; using UnityEngine; using UnityGameFramework.Runtime; namespace ToyBoxNightmare { /// <summary> /// 레티클 3색이 뜻하는 것. "지금 이 지점에 쏠 수 있나" 를 알린다. /// </summary> public enum TargetState { /// <summary>조준 지점이 무효다. 빨강. (Stink: 사거리 밖 / Slime: 대상 없음)</summary> Invalid, /// <summary>조준은 유효한데 전역 쿨다운이 안 끝났다. 노랑.</summary> NotReady, /// <summary>지금 쏠 수 있다. 초록.</summary> Ready, } /// <summary>무기와 착탄 이펙트가 함께 쓰는 적 탐색 유틸.</summary> public static class WeaponUtil { // ─── 레티클 색 ─── public static readonly Color ColorInvalid = new Color(1f, 0f, 0f, 1f); public static readonly Color ColorNotReady = new Color(1f, 0.922f, 0.016f, 1f); public static readonly Color ColorReady = new Color(0f, 1f, 0f, 1f); public static Color GetTargetColor(TargetState state) { switch (state) { case TargetState.Ready: return ColorReady; case TargetState.NotReady: return ColorNotReady; case TargetState.Invalid: return ColorInvalid; default: // TargetState 에 값을 추가하고 여기를 안 고치면 조용히 빨강이 된다. GameAssert.Unreachable("GetTargetColor: 처리되지 않은 TargetState"); return ColorInvalid; } } // ─── 거리 ─── /// <summary> /// XZ 평면 거리. 무기 사거리는 전부 이걸로 잰다 — /// 캐릭터 콜라이더 중심이 Y 로 올라가 있어 3D 거리를 쓰면 사거리가 높이차에 흔들린다. /// </summary> public static float PlanarDistance(Vector3 a, Vector3 b) { Vector3 delta = a - b; delta.y = 0f; return delta.magnitude; } // ─── 적 탐색 ─── /// <summary>Shootable(9). 적 탐색용.</summary> public const int ShootableMask = 1 << 9; /// <summary>Shootable(9) | Blocking(10) | Environment(14) = 17920. Lightning 마스크.</summary> public const int HitscanMask = (1 << 9) | (1 << 10) | (1 << 14); /// <summary> /// OverlapSphere 결과 스크래치의 길이. /// 적 1기당 콜라이더가 2개(CapsuleCollider + Shootable 트리거 구)라 <b>실효 상한은 절반</b>인 128기다. /// </summary> private const int OverlapBufferSize = 256; /// <summary>OverlapSphere 결과 스크래치. 프레임 할당을 없앤다.</summary> private static readonly Collider[] sOverlapBuffer = new Collider[OverlapBufferSize]; /// <summary>버퍼 포화를 <b>한 번만</b> 알리기 위한 플래그.</summary> private static bool sOverlapOverflowReported = false; /// <summary> /// 구 안의 살아있는 적을 중복 없이 채운다. 반환값은 개수. /// /// 적 프리팹은 루트에 SphereCollider(trigger)와 CapsuleCollider 가 둘 다 붙어 있고 /// 둘 다 레이어 9다. OverlapSphere 가 적 1기당 원소를 2개 돌려준다 — /// 중복 제거를 빼면 디버프가 2회 적용된다. /// </summary> public static int FindEnemiesInSphere(Vector3 origin, float radius, List<Enemy> result) { GameAssert.IsTrue(result != null, "FindEnemiesInSphere: 결과 버퍼가 null 이다."); if (result == null) return 0; result.Clear(); int hitCount = Physics.OverlapSphereNonAlloc(origin, radius, sOverlapBuffer, ShootableMask); WarnOnBufferSaturation(hitCount); for (int i = 0; i < hitCount; i++) { Enemy enemy = GetAttackableEnemy(sOverlapBuffer[i]); if (enemy == null) continue; // OverlapSphere 는 **콜라이더 겹침**으로 잡는다. 적의 트리거 구가 커서 // 중심이 반경 밖에 있어도 걸린다. 최종 집합을 중심 거리 기준으로 맞춘다. if (PlanarDistance(enemy.CachedTransform.position, origin) > radius) continue; // 적 1기가 콜라이더 2개로 잡히므로 중복 제거가 필수다. if (result.Contains(enemy)) continue; result.Add(enemy); } return result.Count; } /// <summary> /// 버퍼가 가득 찼으면 <b>딱 한 번</b> 알린다. /// OverlapSphereNonAlloc 은 초과분을 조용히 버린다. /// </summary> private static void WarnOnBufferSaturation(int hitCount) { if (hitCount < sOverlapBuffer.Length || sOverlapOverflowReported) return; sOverlapOverflowReported = true; Log.Warning("WeaponUtil: 적 탐색 버퍼({0})가 가득 찼다. 초과분이 잘려 반경 안의 적이 빠질 수 있다. " + "OverlapBufferSize 를 키울 것. (이 경고는 한 번만 나온다)", OverlapBufferSize); } /// <summary> /// 콜라이더 하나에서 "지금 때릴 수 있는 적" 을 꺼낸다. 아니면 null. /// 바닥·환경 콜라이더, 시체, 회수된 엔티티가 전부 여기서 걸러진다. /// </summary> private static Enemy GetAttackableEnemy(Collider collider) { // 같은 프레임에 파괴된 콜라이더가 버퍼에 남아 있을 수 있다. if (collider == null) return null; Entity entity = collider.GetComponentInParent<Entity>(); if (entity == null) return null; Enemy enemy = entity.Logic as Enemy; // Available 을 IsDead 보다 먼저 본다. IsDead 는 스폰 데이터를 읽는데, // 회수된 엔티티의 데이터는 이미 풀로 반납된 뒤라 답을 신뢰할 수 없다. if (enemy == null || !enemy.Available || enemy.IsDead) return null; return enemy; } // ─── 이펙트 스폰 ─── /// <summary> /// 일회성 이펙트 엔티티를 띄운다. /// </summary> public static void SpawnEffect(System.Type logicType, string assetName, Vector3 position, Quaternion rotation, float lifetime) { // 주소가 비면 ShowEntity 가 조용히 실패한다. if (logicType == null || string.IsNullOrEmpty(assetName)) { Log.Error("SpawnEffect: 이펙트 종류나 주소가 비어 있다. (logicType={0}, assetName={1})", logicType, assetName); return; } GameAssert.IsTrue(lifetime > 0f, "SpawnEffect: lifetime 이 0 이하면 이펙트가 보이기 전에 회수된다."); EntityComponent entityComponent = GameEntry.GetComponent<EntityComponent>(); if (entityComponent == null) { Log.Error("SpawnEffect: EntityComponent 가 없다. GameFramework 프리팹 구성을 확인할 것."); return; } int id = EntitySerialId.Next(); entityComponent.ShowEntity( id, logicType, assetName, WeaponTable.EffectGroup, EffectData.Create(id, 1, position, rotation, lifetime)); } } }

public const int ShootableMask = 1 << 9; public const int HitscanMask = (1 << 9) | (1 << 10) | (1 << 14);

// Assets/GameMain/Entity/EntityData/WeaponData.cs using GameFramework; namespace ToyBoxNightmare { /// <summary> /// 무기 엔티티의 스폰 데이터. /// /// 무기는 혼자 서지 않는다. <see cref="OwnerId"/> 의 엔티티(플레이어)에 붙어서 쓰이고, /// 소유자가 회수되면 프레임워크가 함께 회수한다. /// </summary> public class WeaponData : EntityData { public static WeaponData Create(int entityId, int typeId, int ownerId, int slot, float cooldown) { WeaponData data = ReferencePool.Acquire<WeaponData>(); data.Fill(entityId, typeId); data.OwnerId = ownerId; data.Slot = slot; data.Cooldown = cooldown; return data; } /// <summary>이 무기를 드는 엔티티의 Id. 무기는 뜨자마자 여기에 붙는다.</summary> public int OwnerId { get; private set; } /// <summary> /// 로드아웃에서의 자리(0부터). 무기는 비동기로 로드되어 도착 순서가 요청 순서와 /// 다를 수 있으므로, Tab 순환 순서는 도착 순서가 아니라 이 값으로 정한다. /// </summary> public int Slot { get; private set; } /// <summary> /// 이 무기로 발사에 성공했을 때 걸리는 <b>전역</b> 쿨다운(초). 쿨다운이 없으면 0. /// 무기는 값만 알려 주고 타이머는 <see cref="WeaponLoadout"/> 이 하나만 돌린다. /// </summary> public float Cooldown { get; private set; } public override void Clear() { base.Clear(); // 0 으로 되돌리지 않으면 다음에 이 데이터를 받은 무기가 이전 소유자를 찾아간다. OwnerId = 0; Slot = 0; Cooldown = 0f; } } }

// Assets/GameMain/Weapon/WeaponBase.cs using System.Collections.Generic; using UnityEngine; using UnityGameFramework.Runtime; namespace ToyBoxNightmare { /// <summary> /// 무기 베이스. <b>무기도 엔티티다</b> — <see cref="WeaponLoadout"/> 이 <c>ShowEntity</c> 로 띄우고, /// 뜨자마자 <see cref="WeaponData.OwnerId"/> 의 플레이어에게 <c>AttachEntity</c> 로 붙는다. /// /// <b>무기는 스스로 발사하지 않는다.</b> 발사 시점은 <see cref="WeaponLoadout"/> 이 입력에서 뽑아 내려 주고, /// 그 호출은 <see cref="Player"/> 의 갱신 안에서 일어난다. 그래서 "플레이어가 조준점을 계산한 /// 뒤에 무기가 쏜다" 는 순서가 엔티티 갱신 순서와 무관하게 보장된다. /// /// <b>수동 발사 모델이다.</b> 조준은 플레이어가 마우스로 하고(<c>Player.AimPoint</c>), /// 발사 시점은 <see cref="WeaponLoadout"/> 이 입력에서 뽑아 /// <see cref="TryFireHeld"/>/<see cref="TryFireReleased"/>/<see cref="StopFiring"/> 로 내려 준다. /// /// <b>쿨다운은 무기가 아니라 로드아웃이 전역 하나로 관리한다.</b> /// 무기는 자기 쿨다운 <b>값</b>(<see cref="Cooldown"/>)만 알려 줄 뿐 타이머를 돌리지 않는다. /// </summary> public abstract class WeaponBase : EntityLogicBase { /// <summary> /// 소유자 프리팹에서 무기가 붙는 자리(소유자 루트 기준 경로). /// Girl/Boy 프리팹의 발사점이다. 무기 4종이 전부 여기서 쏜다. /// </summary> public const string AttachPath = "Antenna"; /// <summary>Shootable(9). 적 탐색용.</summary> protected const int ShootableMask = WeaponUtil.ShootableMask; /// <summary>Shootable(9) | Blocking(10) | Environment(14) = 17920.</summary> protected const int HitscanMask = WeaponUtil.HitscanMask; /// <summary>파생 무기가 재사용하는 스크래치 버퍼. 프레임 할당을 없앤다.</summary> protected readonly List<Enemy> Candidates = new List<Enemy>(32); private WeaponData mWeaponData = null; /// <summary>이 무기를 든 플레이어. 붙기 전과 떨어진 뒤에는 null 이다.</summary> protected Player Owner { get; private set; } /// <summary>지금 이 무기가 손에 들려 있는지. <see cref="SetActive"/> 로만 바뀐다.</summary> public bool Active { get; private set; } private bool mActiveApplied = false; /// <summary>로드아웃에서의 자리. <see cref="WeaponData.Slot"/> 그대로다.</summary> public int Slot { get { return mWeaponData != null ? mWeaponData.Slot : 0; } } /// <summary> /// 이 무기가 발사에 성공했을 때 로드아웃이 걸 전역 쿨다운(초). 쿨다운이 없으면 0. /// 값은 스폰 데이터(<see cref="WeaponData.Cooldown"/>)에서 온다. /// </summary> public float Cooldown { get { return mWeaponData != null ? mWeaponData.Cooldown : 0f; } } // ─── 생명주기 ─── protected internal override void OnInit(object userData) { base.OnInit(userData); // 인스턴스가 처음 만들어질 때 한 번. 자식 트랜스폼은 풀 재사용 사이에 바뀌지 않으므로 // 여기서 찾아 두면 스폰마다 다시 찾지 않아도 된다. OnWeaponInit(); } /// <summary>파생 무기가 자기 프리팹 안의 자식을 찾아 둘 훅. 인스턴스당 한 번 불린다.</summary> protected virtual void OnWeaponInit() { } protected internal override void OnShow(object userData) { base.OnShow(userData); // 풀에서 꺼낸 인스턴스는 이전 판의 상태를 물고 있다. 데이터 검사보다 먼저 되돌린다. Owner = null; Active = false; mActiveApplied = false; // 손에 들리기 전에는 보이지 않는다. 로드아웃이 SetActive 로 켠다. // (base.OnShow 가 방금 켰으므로 여기서 다시 꺼야 한다.) Visible = false; OnWeaponShow(); mWeaponData = userData as WeaponData; if (mWeaponData == null) { Log.Error("{0}: Weapon data is invalid.", GetType().Name); return; } AttachToOwner(); } /// <summary>파생 무기가 자기 상태를 리셋할 훅. 스폰(재사용)마다 불린다.</summary> protected virtual void OnWeaponShow() { } /// <summary> /// 소유자에게 붙는다. 무기는 비동기로 로드되므로, 뜨는 사이에 소유자가 이미 회수됐을 수 있다. /// 그때는 붙지 않고 그대로 둔다 — 다음 <see cref="OnUpdate"/> 가 주인 없는 무기를 회수한다. /// </summary> private void AttachToOwner() { EntityComponent entityComponent = GameEntry.GetComponent<EntityComponent>(); if (entityComponent == null) return; // 없는 부모에 붙이면 코어가 예외를 던진다. 먼저 확인한다. if (!entityComponent.HasEntity(mWeaponData.OwnerId)) return; entityComponent.AttachEntity(Entity, mWeaponData.OwnerId, AttachPath); } protected internal override void OnAttachTo(EntityLogic parentEntity, Transform parentTransform, object userData) { base.OnAttachTo(parentEntity, parentTransform, userData); // base 는 부모만 바꾼다. 풀 루트에 있던 월드 좌표가 로컬로 남지 않게 붙는 자리에 맞춘다. CachedTransform.localPosition = Vector3.zero; CachedTransform.localRotation = Quaternion.identity; CachedTransform.localScale = Vector3.one; Owner = parentEntity as Player; if (Owner == null) { Log.Warning("{0}: 소유자가 Player 가 아니다. 이 무기는 발사되지 않는다.", GetType().Name); } } protected internal override void OnDetachFrom(EntityLogic parentEntity, object userData) { Owner = null; base.OnDetachFrom(parentEntity, userData); } protected internal override void OnUpdate(float elapseSeconds, float realElapseSeconds) { base.OnUpdate(elapseSeconds, realElapseSeconds); // 주인 없는 무기는 쓸 수 없다. 소유자가 먼저 사라진 뒤에 로드가 끝난 경우다. if (Owner == null) { SafeHide(); } } protected internal override void OnHide(bool isShutdown, object userData) { // 켜 둔 연출을 끊고 프리팹 기본 상태로 되돌린다. 이 인스턴스는 풀에 돌아가 // 다음 판에 그대로 재사용되므로, 여기서 안 끄면 Frost 콘이 켜진 채로 다시 나온다. OnWeaponDisabled(); OnStopFiring(); Active = false; mActiveApplied = false; Owner = null; // 데이터는 base 체인 끝(EntityLogicBase)에서 ReferencePool 로 반납된다. // 반납된 것을 계속 들고 있으면 다음 주인의 값을 읽게 되므로 참조를 놓는다. mWeaponData = null; base.OnHide(isShutdown, userData); } /// <summary> /// 무기를 손에 들거나 내려놓는다. 내려놓으면 무기 엔티티가 통째로 보이지 않게 되어 /// 총구 VFX 가 함께 꺼진다 — 이걸 빠뜨리면 Tab 으로 바꿔도 이전 무기의 연출이 남는다. /// /// 보이지 않을 뿐 엔티티는 살아 있다. 회수는 소유자가 회수될 때 프레임워크가 한다. /// </summary> public void SetActive(bool active) { if (mActiveApplied && Active == active) return; mActiveApplied = true; Active = active; if (active) { Visible = true; OnWeaponEnabled(); } else { // 정리를 숨기기보다 **먼저** 한다. 먼저 숨기면 그 아래 컴포넌트가 // 비활성 상태가 되어, 스스로 멈춰야 하는 연출이 정리 기회를 잃는다. OnWeaponDisabled(); // 지속 연출(Frost 콘 등)도 여기서 확실히 끊는다. 버튼을 누른 채로 Tab 을 치면 // 이 무기의 StopFiring 이 영영 안 불리기 때문이다. OnStopFiring(); Visible = false; } } protected virtual void OnWeaponEnabled() { } protected virtual void OnWeaponDisabled() { } /// <summary> /// 무기를 굴릴 수 있는 상태인가. 소유자가 회수됐거나 죽었으면 거짓이다. /// </summary> private bool IsOwnerAlive => Owner != null && Owner.Available && !Owner.IsDead; /// <summary>손에 들려 있고 소유자도 멀쩡한가. 발사 훅의 공통 전제다.</summary> private bool CanOperate => Active && IsOwnerAlive; // ─── 발사 ─── /// <summary> /// 발사 버튼을 누르고 있는 동안 매 프레임 불린다. /// 쿨다운을 소모하는 발사를 했으면 true — 로드아웃이 그때만 전역 쿨다운을 건다. /// </summary> public bool TryFireHeld() { if (!CanOperate) return false; return OnFireHeld(); } /// <summary>기본은 "이 타이밍에 쏘지 않는다".</summary> protected virtual bool OnFireHeld() { return false; } /// <summary> /// 발사 버튼을 뗀 프레임에 불린다. /// 쿨다운을 소모하는 발사를 했으면 true — 로드아웃이 그때만 전역 쿨다운을 건다. /// </summary> public bool TryFireReleased() { if (!CanOperate) return false; return OnFireReleased(); } /// <summary>기본은 "이 타이밍에 쏘지 않는다".</summary> protected virtual bool OnFireReleased() { return false; } /// <summary> /// 발사 버튼을 뗐을 때 <b>쿨다운과 무관하게</b> 항상 불린다. 지속 연출을 끊는 용도다. /// /// 일부러 <see cref="CanOperate"/> 로 막지 않는다. 소유자가 그 프레임에 죽었더라도 /// 켜 둔 연출(Frost 콘·루프 사운드)은 반드시 꺼야 한다. /// </summary> public void StopFiring() { OnStopFiring(); } /// <summary>파생 무기가 지속 연출을 끊을 훅.</summary> protected virtual void OnStopFiring() { } // ─── 조준 ─── /// <summary> /// 활성 무기에 대해 매 프레임 불린다. /// isReady 는 <b>전역</b> 쿨다운이 끝났는지다(이 무기만의 상태가 아니다). /// </summary> public void UpdateAim(bool isReady) { if (!Active) return; if (!IsOwnerAlive) { // 소유자가 죽으면 스스로 내려놓는다. SetActive(false); return; } OnUpdateAim(isReady); } /// <summary>파생 무기가 매 프레임 할 일을 넣을 훅. 기본은 아무것도 하지 않는다.</summary> protected virtual void OnUpdateAim(bool isReady) { } // ─── 총구(발사 원점) ─── /// <summary> /// 발사 원점. 무기 엔티티가 소유자의 발사점(<see cref="AttachPath"/>)에 붙어 있으므로 /// 무기 자신의 위치가 곧 총구다. /// </summary> protected Vector3 MuzzleOrigin { get { return CachedTransform.position; } } } }

// Assets/GameMain/Weapon/WeaponLoadout.cs using System; using UnityEngine; using UnityEngine.InputSystem; using UnityGameFramework.Runtime; namespace ToyBoxNightmare { /// <summary> /// 플레이어가 장착한 무기 묶음. 장착 요청·전환·발사 입력·전역 쿨다운을 한곳에서 맡는다. /// /// <b>무기는 엔티티다</b>(<see cref="WeaponBase"/>). 이 로드아웃은 무기를 만들지 않는다 — /// <see cref="Equip"/> 이 <c>ShowEntity</c> 로 요청하면 무기가 스스로 플레이어에게 붙고, /// 플레이어가 <c>OnAttached</c>/<c>OnDetached</c> 에서 <see cref="Attach"/>/<see cref="Detach"/> 로 /// 알려 준다. 회수도 하지 않는다. 플레이어가 회수되면 코어가 붙어 있는 무기를 먼저 회수한다. /// /// 로드아웃 자체는 엔티티가 아니다. 소유 <see cref="Player"/> 가 들고 직접 굴린다 — /// "조준점 계산 → 무기" 순서가 엔티티 갱신 순서에 좌우되지 않게 하기 위해서다. /// 활성 무기는 항상 하나다. /// </summary> public class WeaponLoadout { /// <summary>시작 무기 한 종의 명세. 어떤 로직을 어떤 프리팹에 붙여 띄울지와 쿨다운.</summary> private struct WeaponSpec { public Type LogicType; public string AssetName; public float Cooldown; public WeaponSpec(Type logicType, string assetName, float cooldown) { LogicType = logicType; AssetName = assetName; Cooldown = cooldown; } } /// <summary> /// 이 캐릭터가 들고 시작하는 무기. 배열 순서가 곧 슬롯 번호이자 Tab 순환 순서다. /// </summary> private static readonly WeaponSpec[] sStartingWeapons = { new WeaponSpec(typeof(LightningWeapon), WeaponTable.LightningWeaponAsset, WeaponTable.LightningCooldown), }; /// <summary>무기 엔티티의 TypeId. 이 프로젝트는 TypeId 로 구분하지 않아 전부 1 이다.</summary> private const int WeaponTypeId = 1; /// <summary>이 로드아웃의 소유자. 무기는 이 엔티티에 붙는다.</summary> private readonly Player mOwner = null; /// <summary> /// 슬롯별 무기. 무기는 비동기로 로드되므로 <b>아직 도착하지 않은 슬롯은 null 이다.</b> /// 이 중 <see cref="mActiveSlot"/> 하나만 활성이다. /// </summary> private readonly WeaponBase[] mSlots = new WeaponBase[sStartingWeapons.Length]; private int mActiveSlot = 0; /// <summary> /// 무기를 전부 내려놓은 상태인가(사망). 이 뒤에 늦게 도착한 무기를 켜지 않기 위해 둔다. /// </summary> private bool mShutdown = false; // ─── 전역 쿨다운 ─── /// <summary> /// 쿨다운은 <b>무기별이 아니라 전역 하나</b>다. 마지막으로 발사에 성공한 /// 무기의 쿨다운 값을 여기 덮어쓴다. /// 무기를 바꿔도 리셋하지 않는다 — 리셋하면 Tab 연타로 쿨다운을 지울 수 있다. /// </summary> private float mAttackCooldown = 0f; /// <summary>마지막 발사 시각. <see cref="Time.time"/> 기준이다.</summary> private float mTimeOfLastAttack = 0f; /// <summary>지금 발사할 수 있는지.</summary> public bool IsReadyToAttack { get { return Time.time >= mTimeOfLastAttack + mAttackCooldown; } } public WeaponLoadout(Player owner) { mOwner = owner; } /// <summary>지금 들고 있는 무기. 그 슬롯의 무기가 아직 도착 전이면 null.</summary> private WeaponBase ActiveWeapon { get { GameAssert.InRange(mActiveSlot, mSlots.Length, "mActiveSlot"); return mSlots[mActiveSlot]; } } // ─── 장착 ─── /// <summary> /// 시작 무기를 요청한다. 플레이어가 스폰(재스폰)될 때마다 한 번 부른다. /// /// 여기서는 <b>요청만</b> 한다. 무기는 로드가 끝나면 스스로 플레이어에게 붙고, /// 그때 <see cref="Attach"/> 가 불려 슬롯에 들어온다. /// </summary> public void Equip() { // 재스폰 때마다 첫 무기부터, 쿨다운 없이 시작한다. mShutdown = false; mActiveSlot = 0; ClearCooldown(); // 계약: 무기는 소유자 엔티티의 Id 로 붙는다. Entity 가 없으면 붙을 곳이 없다. GameAssert.IsTrue(mOwner != null && mOwner.Entity != null, "WeaponLoadout.Equip: 소유자 엔티티가 없다."); if (mOwner == null || mOwner.Entity == null) return; EntityComponent entityComponent = GameEntry.GetComponent<EntityComponent>(); if (entityComponent == null) { Log.Error("WeaponLoadout: EntityComponent 를 찾지 못했다. 무기를 띄울 수 없다."); return; } int ownerId = mOwner.Entity.Id; for (int slot = 0; slot < sStartingWeapons.Length; slot++) { WeaponSpec spec = sStartingWeapons[slot]; int id = EntitySerialId.Next(); entityComponent.ShowEntity( id, spec.LogicType, spec.AssetName, WeaponTable.WeaponGroup, WeaponData.Create(id, WeaponTypeId, ownerId, slot, spec.Cooldown)); } Log.Info("무기 {0}종 요청. 마우스 좌클릭 발사 / Tab 으로 전환.", sStartingWeapons.Length); } /// <summary> /// 무기가 플레이어에게 붙었다. <see cref="Player.OnAttached"/> 가 부른다. /// 도착 순서와 무관하게 자기 슬롯에 들어간다. /// </summary> public void Attach(WeaponBase weapon) { if (weapon == null) return; int slot = weapon.Slot; if (slot < 0 || slot >= mSlots.Length) { Log.Error("WeaponLoadout: 슬롯 {0} 은 범위 밖이다({1}). 이 무기는 쓰이지 않는다.", slot, weapon.GetType().Name); return; } mSlots[slot] = weapon; ApplySelection(); } /// <summary>무기가 플레이어에게서 떨어졌다(회수 직전). <see cref="Player.OnDetached"/> 가 부른다.</summary> public void Detach(WeaponBase weapon) { // 슬롯 번호를 무기에게 다시 묻지 않고 참조로 찾는다. 떨어지는 시점에는 // 무기 쪽 데이터가 이미 정리 중일 수 있다. for (int i = 0; i < mSlots.Length; i++) { if (mSlots[i] == weapon) { mSlots[i] = null; } } } /// <summary> /// 활성 무기만 켠다. 꺼진 무기는 조준 갱신도 발사 입력도 받지 못하고 /// 총구 VFX 도 함께 꺼진다. /// </summary> private void ApplySelection() { for (int i = 0; i < mSlots.Length; i++) { if (mSlots[i] == null) continue; mSlots[i].SetActive(!mShutdown && i == mActiveSlot); } } // ─── 갱신 ─── /// <summary> /// 활성 무기의 조준을 갱신하고 발사 입력을 읽는다. /// 플레이어가 조준점 계산 뒤에 부르므로 조준이 한 프레임 밀리지 않는다. /// </summary> public void OnUpdate() { WeaponBase weapon = ActiveWeapon; if (weapon == null) return; // 쿨다운 판정은 프레임당 한 번만 해서 조준 표시(레티클 색)와 실제 발사 가부가 // 어긋나지 않게 한다. bool isReady = IsReadyToAttack; weapon.UpdateAim(isReady); ReadFireInput(weapon, isReady); } /// <summary> /// 누르는 동안과 떼는 프레임이 나뉘어 있고 /// 무기마다 어느 쪽에서 나가는지가 다르다(Lightning·Frost=누름 / Stink·Slime=뗌). /// </summary> private void ReadFireInput(WeaponBase weapon, bool isReady) { Mouse mouse = Mouse.current; if (mouse == null) { // 마우스가 사라져도(무선 절전, USB 분리) 지속 발사는 끊어야 한다. // 여기서 그냥 return 하면 "뗀 프레임" 이 영영 오지 않아 Frost 콘이 켜진 채 굳는다. weapon.StopFiring(); return; } if (mouse.leftButton.wasReleasedThisFrame) { // StopFiring 은 쿨다운 검사 **밖**에서 항상 부른다. weapon.StopFiring(); if (isReady && weapon.TryFireReleased()) { BeginCooldown(weapon.Cooldown); } return; } if (!mouse.leftButton.isPressed) return; if (isReady && weapon.TryFireHeld()) { BeginCooldown(weapon.Cooldown); } } /// <summary>발사에 성공한 무기의 쿨다운을 전역 타이머에 싣는다.</summary> private void BeginCooldown(float cooldown) { // 쿨다운이 없는 무기(Frost)는 0 을 준다. 음수를 실으면 다음 발사가 // 과거로 밀려 다른 무기의 쿨다운까지 건너뛴다. mAttackCooldown = Mathf.Max(0f, cooldown); mTimeOfLastAttack = Time.time; } /// <summary>전역 쿨다운을 지워 즉시 쏠 수 있게 한다. 장착(재스폰) 시점에만 쓴다.</summary> private void ClearCooldown() { mAttackCooldown = 0f; mTimeOfLastAttack = 0f; } /// <summary> /// 무기를 전부 내려놓는다. 총구 VFX·Frost 콘이 여기서 꺼진다. /// 사망 시 부른다 — 죽으면 갱신이 멈춰 무기 스스로는 못 끈다. /// /// 내려놓을 뿐 회수하지 않는다. 무기 엔티티는 플레이어가 회수될 때 함께 회수된다. /// </summary> public void Shutdown() { mShutdown = true; ApplySelection(); } /// <summary>Tab 무기 순환.</summary> public void ReadSwitchInput() { Keyboard keyboard = Keyboard.current; if (keyboard == null || !keyboard.tabKey.wasPressedThisFrame) return; int nextSlot = FindNextEquippedSlot(mActiveSlot); if (nextSlot == mActiveSlot) return; // 전환 전에 이전 무기의 지속 발사를 반드시 끊는다. 버튼을 누른 채 Tab 을 치면 // 그 무기는 "뗀 프레임" 을 영영 못 받는다 — Frost 콘이 켜진 채로 남는다. WeaponBase previous = ActiveWeapon; if (previous != null) { previous.StopFiring(); } mActiveSlot = nextSlot; ApplySelection(); Log.Info("무기 전환 → {0} ({1}/{2})", mSlots[mActiveSlot].GetType().Name, mActiveSlot + 1, mSlots.Length); } /// <summary> /// from 다음부터 돌면서 무기가 도착해 있는 첫 슬롯. 아직 로드 중인 슬롯은 건너뛴다. /// 다른 무기가 하나도 없으면 from 을 그대로 돌려준다. /// </summary> private int FindNextEquippedSlot(int from) { for (int step = 1; step < mSlots.Length; step++) { int slot = (from + step) % mSlots.Length; if (mSlots[slot] != null) return slot; } return from; } } }

/// <summary>장착 무기 묶음. 수명은 이 로직 인스턴스와 같다 — OnInit 에서 만든다.</summary> private WeaponLoadout mWeaponLoadout = null;

// 필드 초기화식에서는 this 를 넘길 수 없어 여기서 만든다. mWeaponLoadout = new WeaponLoadout(this);

ResetAim(); mWeaponLoadout.Equip(); // 상태 기계는 **맨 마지막**에 세운다. 상태가 OnEnter 에서 소유자 값을 읽기 때문이다. CreateStateMachine();

/// <summary> /// 자식 엔티티가 붙었다. 지금 붙는 것은 무기뿐이다 — /// <see cref="WeaponLoadout.Equip"/> 이 요청한 무기가 로드를 마치고 스스로 붙어 온다. /// </summary> protected internal override void OnAttached(EntityLogic childEntity, Transform parentTransform, object userData) { base.OnAttached(childEntity, parentTransform, userData); WeaponBase weapon = childEntity as WeaponBase; if (weapon != null) { mWeaponLoadout.Attach(weapon); } } /// <summary>자식 엔티티가 떨어졌다. 무기가 회수되기 직전에 온다.</summary> protected internal override void OnDetached(EntityLogic childEntity, object userData) { WeaponBase weapon = childEntity as WeaponBase; if (weapon != null) { mWeaponLoadout.Detach(weapon); } base.OnDetached(childEntity, userData); }

/// <summary>살아있는 동안의 한 프레임. 조준점 → 이동 입력 → 무기 순서다.</summary> internal void TickAliveInput() { // 무기가 이번 프레임의 조준점을 그대로 쓰므로 순서를 바꾸지 말 것. ReadInput(); mWeaponLoadout.ReadSwitchInput(); mWeaponLoadout.OnUpdate(); }

mDying = true; mDeathTimer = 0f; // 사망 후에는 OnUpdate 가 무기를 굴리지 않으므로 여기서 확실히 끈다. // 안 그러면 총구 VFX 와 타겟 마커가 시체 위에 남는다. mWeaponLoadout.Shutdown(); StopMovementAndCollision(); PlayDeathAnimation();

// Assets/GameMain/Entity/EntityData/EffectData.cs using GameFramework; using UnityEngine; namespace ToyBoxNightmare { /// <summary>수명이 지나면 스스로 회수되는 일회성 이펙트 엔티티용.</summary> public class EffectData : EntityData { /// <summary>호출부가 수명을 지정하지 않았을 때 쓸 값.</summary> private const float DefaultLifetime = 2f; public static EffectData Create(int entityId, int typeId, Vector3 position, Quaternion rotation, float lifetime) { EffectData data = ReferencePool.Acquire<EffectData>(); data.Fill(entityId, typeId); data.Position = position; data.Rotation = rotation; data.Lifetime = lifetime; return data; } /// <summary>이 시간이 지나면 회수된다.</summary> public float Lifetime { get; set; } = DefaultLifetime; public override void Clear() { base.Clear(); // 필드 초기화식은 첫 new 때만 돈다. 기본값 복원도 여기서 해야 한다. Lifetime = DefaultLifetime; } } }

// Assets/GameMain/Entity/EntityLogic/HitEffect.cs using UnityEngine; using UnityGameFramework.Runtime; namespace ToyBoxNightmare { /// <summary> /// 일회성 착탄 이펙트. 수명이 지나면 스스로 회수된다. /// </summary> public class HitEffect : EntityLogicBase { /// <summary>EffectData 가 오지 않았을 때 쓸 수명.</summary> private const float FallbackLifetime = 2f; private ParticleSystem[] mParticles = null; private float mLifetime = FallbackLifetime; private float mElapsed = 0f; protected internal override void OnInit(object userData) { base.OnInit(userData); mParticles = GetComponentsInChildren<ParticleSystem>(true); // 착탄 이펙트인데 재생할 것이 하나도 없으면 프리팹 구성이 잘못된 것이다. if (mParticles.Length == 0) { Log.Warning("HitEffect '{0}' 에 ParticleSystem 이 없다. 프리팹 구성을 확인할 것.", Name); } } protected internal override void OnShow(object userData) { base.OnShow(userData); mElapsed = 0f; ApplyEffectData(userData as EffectData); // 배치가 끝난 뒤에 재생한다. 프리팹에 따라 PlayOnAwake 가 꺼진 것도 있어 // 명시 호출이 반드시 필요하다. RestartEffects(); OnEffectStarted(); } /// <summary> /// 수명과 배치를 데이터에서 가져온다. /// 데이터가 없으면 지금 자리에서 기본 수명으로 튼다 — 이펙트를 통째로 씹는 것보다 낫다. /// </summary> private void ApplyEffectData(EffectData data) { if (data == null) { Log.Warning("HitEffect '{0}' 에 EffectData 가 오지 않았다. 배치를 건너뛰고 기본 수명 {1}초로 재생한다.", Name, FallbackLifetime); mLifetime = FallbackLifetime; return; } // 0 이하면 첫 OnUpdate 에서 곧바로 회수되어 화면에 아무것도 안 남는다. GameAssert.IsTrue(data.Lifetime > 0f, "EffectData.Lifetime 이 0 이하다. 이펙트가 즉시 회수된다."); mLifetime = data.Lifetime; CachedTransform.position = data.Position; CachedTransform.rotation = data.Rotation; } /// <summary>파생 클래스가 착탄 판정 같은 1회성 처리를 여기에 넣는다.</summary> protected virtual void OnEffectStarted() { } protected internal override void OnUpdate(float elapseSeconds, float realElapseSeconds) { base.OnUpdate(elapseSeconds, realElapseSeconds); if (IsHiding) return; mElapsed += elapseSeconds; if (mElapsed >= mLifetime) { SafeHide(); } } private void RestartEffects() { RestartParticles(); } /// <summary>풀에서 재사용되므로 이전 재생분을 지우고 처음부터 다시 튼다.</summary> private void RestartParticles() { if (mParticles == null) return; foreach (var ps in mParticles) { if (ps == null) continue; ps.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear); ps.Play(true); // 인자 true 가 자식까지 재생한다. 빼면 스파크가 안 나온다 } } } }

// Assets/GameMain/Weapon/LightningWeapon.cs using UnityEngine; using UnityGameFramework.Runtime; namespace ToyBoxNightmare { /// <summary> /// 즉발 히트스캔 무기. 발사 버튼을 누르고 있는 동안 쿨다운마다 <b>캐릭터 전방</b>으로 빔을 쏜다. /// /// 조준은 무기가 아니라 캐릭터가 한다 — 플레이어가 마우스 지면 지점을 바라보므로 /// 전방이 곧 마우스 방향이다. 그래서 레티클도 없다. /// </summary> public class LightningWeapon : WeaponBase { /// <summary>빔 연출 오브젝트. 무기 프리팹(LightningAttack) 루트 기준 경로다.</summary> private const string BoltPath = "LightningBolt"; private LightningBoltVfx mBolt = null; /// <summary>빔 연출은 무기 프리팹의 자식이라 인스턴스당 한 번만 찾으면 된다.</summary> protected override void OnWeaponInit() { ResolveBoltVfx(); } /// <summary>풀에서 다시 나올 때 이전 판의 빔이 남아 있지 않게 한다.</summary> protected override void OnWeaponShow() { if (mBolt != null) { mBolt.StopImmediate(); } } private void ResolveBoltVfx() { Transform boltTransform = CachedTransform.Find(BoltPath); if (boltTransform == null) { Log.Warning("LightningWeapon: '{0}' 을 찾지 못했다. 빔 연출 없이 동작한다.", BoltPath); return; } // 프리팹에서 비활성으로 저장돼 있다. 연출 컴포넌트가 돌아야 하므로 켜 두고, // 실제 표시 여부는 LineRenderer/Light 를 껐다 켜서 제어한다. boltTransform.gameObject.SetActive(true); mBolt = new LightningBoltVfx(boltTransform); } /// <summary> /// 빔 연출은 스스로 돌지 않는다. 이 무기가 떠 있는 동안 여기서 굴린다 — /// 손에 들려 있지 않아도 엔티티의 OnUpdate 는 불리므로, 내려놓은 뒤의 잔여 시간도 여기서 소진된다. /// </summary> protected internal override void OnUpdate(float elapseSeconds, float realElapseSeconds) { base.OnUpdate(elapseSeconds, realElapseSeconds); if (mBolt != null) { mBolt.OnUpdate(elapseSeconds); } } /// <summary> /// 발사 버튼을 누르고 있는 동안. 로드아웃이 쿨다운을 통과시킨 프레임에만 불린다. /// 자동조준도 시야 검사도 없다 — 벽에 막히면 벽에 맞는 것이 정상 동작이다. /// </summary> protected override bool OnFireHeld() { // 발사 원점은 무기 자신(소유자의 안테나에 붙어 있다). Vector3 origin = MuzzleOrigin; // Transform.forward 는 이미 단위 벡터라 정규화가 필요 없다. Vector3 direction = Owner.CachedTransform.forward; // 아무것도 안 맞으면(사이에 콜라이더가 없다) 최대 사거리까지 빔만 그린다. Vector3 beamEndPoint = origin + direction * WeaponTable.LightningRange; RaycastHit hit; if (Physics.Raycast(origin, direction, out hit, WeaponTable.LightningRange, WeaponUtil.HitscanMask)) { beamEndPoint = hit.point; ApplyHitscanHit(hit); } PlayBolt(beamEndPoint); // 빗나가도 쿨다운은 소모한다. return true; } /// <summary>레이가 맞은 것을 처리한다 — 적이면 피해를 주고, 무엇에 맞았든 착탄 이펙트를 띄운다.</summary> private void ApplyHitscanHit(RaycastHit hit) { Entity entity = hit.collider.GetComponentInParent<Entity>(); Enemy hitEnemy = entity != null ? entity.Logic as Enemy : null; if (hitEnemy != null && !hitEnemy.IsDead) { hitEnemy.ApplyDamage(Owner.Entity, WeaponTable.LightningDamage); } WeaponUtil.SpawnEffect(typeof(HitEffect), WeaponTable.LightningHitAsset, hit.point, Quaternion.identity, WeaponTable.LightningHitLifetime); } /// <summary>빔 연출은 없어도 게임플레이는 돌아간다. 프리팹에서 못 찾았으면 조용히 넘어간다.</summary> private void PlayBolt(Vector3 endPoint) { if (mBolt != null) { mBolt.Play(endPoint); } } /// <summary> /// 무기를 내려놓으면 빔 GameObject 가 무기와 함께 보이지 않게 된다. 남은 시간이 흐르기를 /// 기다리지 않고 여기서 바로 끊는다. /// </summary> protected override void OnWeaponDisabled() { if (mBolt != null) { mBolt.StopImmediate(); } } } }

Physics.Raycast(origin, direction, out hit, WeaponTable.LightningRange, WeaponUtil.HitscanMask)

// 프리팹 구조 계약. 자식 이름이 바뀌면 조용히 null 이 되므로 한곳에 모아 둔다. private const string HitParticlesChildName = "HitParticles"; // 프리팹의 HitParticles 자식(흰 솜뭉치). private ParticleSystem mHitParticles = null;

private void CacheVfxReferences() { // 이름으로 찾는다. GetComponentInChildren<ParticleSystem> 로 잡으면 // 디버프 VFX 자식을 추가하는 순간 계층 순서에 따라 엉뚱한 것이 잡힌다. Transform hit = CachedTransform.Find(HitParticlesChildName); mHitParticles = hit != null ? hit.GetComponent<ParticleSystem>() : null; if (mHitParticles == null) { mHitParticles = GetComponentInChildren<ParticleSystem>(true); } }

if (mHitParticles != null) { mHitParticles.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear); }

// ─── 피격 / 통지 ─── /// <summary>피격 파편.</summary> protected override void OnDamaged(Entity attacker, int damageHitPoints) { if (mHitParticles != null) { mHitParticles.Play(); } }

Character selected: Girl 무기 1종 요청. 마우스 좌클릭 발사 / Tab 으로 전환. Player spawned: Girl

// Assets/GameMain/Entity/EnemyDebuffs.cs using UnityEngine; using UnityGameFramework.Runtime; namespace ToyBoxNightmare { /// <summary> /// 적에게 걸리는 디버프 3종 — Frost(빙결) / Stink(도주) / Slime(공격봉인 DoT) — 의 /// 상태와 전이. 추격·공격·사망 연출은 <see cref="Enemy"/> 쪽에 남아 있다. /// /// Enemy 내부 상태로 관리한다. 엔티티가 회수되면 상태도 함께 /// 사라지므로 "주인 잃은 디버프" 가 원천적으로 생기지 않는다. /// /// <b>MonoBehaviour 가 아니다.</b> 소유 <see cref="Enemy"/> 가 인스턴스를 만들어 들고 직접 굴린다. /// /// 이 객체 자체는 엔티티 풀 재사용 사이에 살아남는다. 그래서 <c>Enemy.OnShow</c> 가 /// <see cref="ClearAll"/> 로 이전 판의 상태를 되돌린다. /// </summary> public class EnemyDebuffs { // ─── 튜닝 상수 ─── private const float FrostContactGrace = 0.35f; private const float FrostFreezeDelay = 1f; private const float FrostThawDuration = 2f; /// <summary> /// "한 번도 Frost 콘에 닿은 적 없음" 을 뜻하는 접촉 시각. /// Time.time 이 0 에 가까운 스폰 직후에도 grace 밖으로 판정되도록 충분히 과거여야 한다. /// </summary> private const float NoFrostContactTime = -999f; /// <summary>슬라임 틱 간격의 하한. 0 이하가 들어오면 매 프레임 틱이 나가 버린다.</summary> private const float MinSlimeTickInterval = 0.05f; /// <summary> /// "공격자를 모른다" 를 뜻하는 엔티티 Id. EntitySerialId 의 첫 발급이 1 이라 /// 0 은 어떤 엔티티도 갖지 않는다. /// </summary> private const int NoAttackerId = 0; /// <summary>디버프가 걸리는 대상. 생성 시점에 정해지고 바뀌지 않는다.</summary> private readonly Enemy mOwner = null; // ─── 디버프 상태 ─── // Frost private bool mFrozen = false; private float mFrostTimer = 0f; private float mFrostRefreshTime = NoFrostContactTime; // 해동 대기가 시작됐는지. 콘에서 한 번 벗어나면 재진입해도 해동을 취소하지 않는다. private bool mFrostThawing = false; // Stink private float mFleeTimer = 0f; // Slime private bool mAttackSuppressed = false; private int mSlimeTicksLeft = 0; private float mSlimeTickTimer = 0f; private float mSlimeTickInterval = 0.5f; private int mSlimeTickDamage = 20; /// <summary> /// DoT 를 넣은 공격자를 <b>참조가 아니라 Id 로</b> 들고 있다. DoT 는 최대 3초를 끄는데 /// 그 사이 발사체 엔티티는 회수되고 같은 인스턴스가 다른 발사체로 재사용될 수 있다. /// </summary> private int mSlimeAttackerId = NoAttackerId; public EnemyDebuffs(Enemy owner) { GameAssert.IsTrue(owner != null, "EnemyDebuffs 는 소유 Enemy 없이 만들 수 없다."); mOwner = owner; } // ─── 상태 질의 ─── /// <summary> /// 무력화 상태 — 얼었거나, 도주 중이거나, 공격이 봉인됐다. /// </summary> public bool IsNeutralized => mFrozen || IsFleeing || mAttackSuppressed; /// <summary>Stink 를 맞고 달아나는 중인지.</summary> public bool IsFleeing => mFleeTimer > 0f; /// <summary>Slime 에 걸려 공격이 봉인됐는지. 이동과 타이머는 그대로 돈다.</summary> public bool IsAttackSuppressed => mAttackSuppressed; /// <summary>지금 Frost 콘 안에 있는지. 콘이 grace 안에 접촉을 갱신해 주는 동안만 참이다.</summary> private bool IsInFrostCone => (Time.time - mFrostRefreshTime) <= FrostContactGrace; // ─── 디버프 수신 API ─── /// <summary>Frost 콘 안에 있는 동안 매 재판정 틱마다 호출한다.</summary> public void RefreshFrostContact() { mFrostRefreshTime = Time.time; } /// <summary>Stink 착탄. 도주 지속시간(초). 중첩 시 더 긴 쪽으로 갱신한다.</summary> public void ApplyFlee(float duration) { mFleeTimer = Mathf.Max(mFleeTimer, duration); } /// <summary> /// Slime 명중. 스택하지 않고 리셋한다. /// 첫 틱은 부착 즉시 나간다. /// </summary> public void ApplySlime(int ticks, float tickInterval, int damagePerTick, Entity attacker) { if (ticks <= 0) return; GameAssert.IsTrue(tickInterval > 0f, "Slime 의 tickInterval 은 양수여야 한다."); GameAssert.IsTrue(damagePerTick >= 0, "Slime 의 damagePerTick 이 음수면 적을 회복시킨다."); mSlimeTicksLeft = ticks; mSlimeTickInterval = Mathf.Max(MinSlimeTickInterval, tickInterval); mSlimeTickDamage = damagePerTick; mSlimeTickTimer = 0f; mAttackSuppressed = true; // 참조가 아니라 Id 만 남긴다. mSlimeAttackerId = IsUsableAttacker(attacker) ? attacker.Id : NoAttackerId; mOwner.SetSlimeFxActive(true); } /// <summary> /// 회수된 엔티티를 들고 있지 않는다. Available 은 Entity 가 아니라 Logic 쪽에 있다. /// </summary> private static bool IsUsableAttacker(Entity attacker) { return attacker != null && attacker.Logic != null && attacker.Logic.Available; } /// <summary> /// 틱 시점의 공격자. Id 로 다시 조회하므로 그 사이 회수된 엔티티를 넘기지 않는다. /// 못 찾으면 null 이다 — <b>데미지는 그대로 들어간다</b>. /// </summary> private Entity ResolveSlimeAttacker() { if (mSlimeAttackerId == NoAttackerId) return null; EntityComponent entityComponent = GameEntry.GetComponent<EntityComponent>(); if (entityComponent == null || !entityComponent.HasEntity(mSlimeAttackerId)) return null; Entity attacker = entityComponent.GetEntity(mSlimeAttackerId); return IsUsableAttacker(attacker) ? attacker : null; } // ─── 갱신 ─── /// <summary> /// 소유 Enemy 가 매 프레임 부른다. /// </summary> public void OnUpdate(float elapseSeconds) { if (mOwner.IsDying) { ClearAll(); return; } UpdateFrost(elapseSeconds); UpdateFlee(elapseSeconds); UpdateSlime(elapseSeconds); } private void UpdateFrost(float elapseSeconds) { bool inCone = IsInFrostCone; if (!mFrozen) { UpdateFreezeCharge(inCone, elapseSeconds); return; } UpdateThaw(inCone, elapseSeconds); } /// <summary>빙결 전. 콘 안에 <b>연속으로</b> 머문 시간이 freezeDelay 를 넘어야 언다.</summary> private void UpdateFreezeCharge(bool inCone, float elapseSeconds) { if (!inCone) { // 벗어나면 누적이 0 으로 돌아간다 — 끊긴 노출은 합산하지 않는다. mFrostTimer = 0f; return; } mFrostTimer += elapseSeconds; if (mFrostTimer >= FrostFreezeDelay) { Freeze(); } } /// <summary> /// 빙결 후. 콘 안에 머무는 동안은 계속 얼어 있고, 한 번 벗어나면 해동이 확정된다. /// 해동이 시작된 뒤로는 inCone 을 보지 않는다 — 재진입해도 예정대로 진행된다. /// </summary> private void UpdateThaw(bool inCone, float elapseSeconds) { if (!mFrostThawing) { // 콘 안에 머무는 동안은 계속 얼어 있다. if (inCone) return; // 벗어나는 순간 해동이 확정된다. mFrostThawing = true; mFrostTimer = 0f; } mFrostTimer += elapseSeconds; if (mFrostTimer >= FrostThawDuration) { Unfreeze(); } } private void Freeze() { mFrozen = true; mFrostThawing = false; mFrostTimer = 0f; mOwner.SetSpeedMultiplier(0f); mOwner.SetAnimatorEnabled(false); mOwner.SetFreezeFxActive(true); } private void Unfreeze() { mFrozen = false; mFrostThawing = false; mFrostTimer = 0f; mOwner.SetSpeedMultiplier(1f); mOwner.SetAnimatorEnabled(true); mOwner.SetFreezeFxActive(false); } /// <summary>Stink 도주 지속시간 소진. 0 이하로 내려가면 IsFleeing 이 자연히 꺼진다.</summary> private void UpdateFlee(float elapseSeconds) { if (!IsFleeing) return; mFleeTimer -= elapseSeconds; } private void UpdateSlime(float elapseSeconds) { if (mSlimeTicksLeft <= 0) return; mSlimeTickTimer -= elapseSeconds; if (mSlimeTickTimer > 0f) return; mSlimeTicksLeft--; mSlimeTickTimer = mSlimeTickInterval; // 이미 죽었으면 TargetableObject.ApplyDamage 의 IsDead 가드가 무시한다. // 이 한 방이 치명타면 OnDead → ClearAll → ClearSlime 으로 재진입해 // mSlimeTicksLeft 를 0 으로 만든다. 아래 마무리는 그래도 안전하도록 멱등이다. mOwner.ApplyDamage(ResolveSlimeAttacker(), mSlimeTickDamage); if (mSlimeTicksLeft <= 0) { ClearSlime(); } } private void ClearSlime() { mSlimeTicksLeft = 0; mSlimeTickTimer = 0f; mSlimeAttackerId = NoAttackerId; // 이걸 빼먹으면 한 번 걸린 적이 죽을 때까지 공격 불능이 된다. mAttackSuppressed = false; mOwner.SetSlimeFxActive(false); } /// <summary> /// 디버프 전량 해제. 풀 재사용(<c>Enemy.OnShow</c>)과 사망(<c>Enemy.OnDead</c>) 양쪽에서 부른다. /// </summary> public void ClearAll() { mFrozen = false; mFrostThawing = false; mFrostTimer = 0f; mFrostRefreshTime = NoFrostContactTime; mFleeTimer = 0f; mOwner.SetSpeedMultiplier(1f); mOwner.SetAnimatorEnabled(true); mOwner.SetFreezeFxActive(false); ClearSlime(); } } }

private const float FleeDistance = 10f; /// <summary>도주 목적지를 NavMesh 폴리곤 위로 스냅할 때 허용하는 탐색 반경.</summary> private const float FleeSampleRadius = 4f; /// <summary>도주 방향을 정규화하기 전에 요구하는 최소 제곱 길이.</summary> private const float MinFleeDirectionSqrMagnitude = 0.0001f; private const string FreezeFxChildName = "FreezeFx"; private const string SlimeFxChildName = "SlimeFx";

// 디버프 VFX. 적 프리팹에 비활성 자식으로 구워 두면 자동으로 잡힌다(없어도 동작한다). private GameObject mFreezeFx = null; private GameObject mSlimeFx = null; private float mSpeedMultiplier = 1f; /// <summary> /// Frost/Stink/Slime 상태 전부. OnInit 에서 만들어 이 인스턴스와 수명을 같이한다. /// 순수 C# 객체라 엔티티 풀 재사용 사이에 살아남는다 — 이전 판의 상태는 /// ResetCombatState 가 ClearAll 로 되돌린다. /// </summary> private EnemyDebuffs mDebuffs = null;

// 인스턴스당 1회. OnShow/OnUpdate 보다 반드시 먼저 도므로 이후 경로에서는 항상 유효하다. mDebuffs = new EnemyDebuffs(this);

// 프리팹에 구워 두면 잡히고, 없으면 null 인 채로 게임플레이만 동작한다. mFreezeFx = FindChildObject(FreezeFxChildName); mSlimeFx = FindChildObject(SlimeFxChildName); } private GameObject FindChildObject(string childName) { Transform child = CachedTransform.Find(childName); return child != null ? child.gameObject : null; }

mAttackTimer = 0f; mSpeedMultiplier = 1f; mDeathRequested = false; mSinkRequested = false; mDeathTimer = 0f; mPlayerDeadNotified = false; // 디버프 전량 리셋. 하나라도 빠지면 재사용된 적이 얼어붙은 채 또는 // 공격 불능인 채로 부활한다. mDebuffs.ClearAll();

/// <summary> /// 무력화 상태 — 얼었거나, 도주 중이거나, 공격이 봉인됐다. /// </summary> public bool IsNeutralized => mDebuffs.IsNeutralized; /// <summary>이동 속도 배율. 빙결이 0 으로 만든다.</summary> public void SetSpeedMultiplier(float multiplier) { mSpeedMultiplier = Mathf.Clamp(multiplier, 0f, 1f); } // ─── 디버프 수신 API ─── // 무기 쪽(FrostWeapon / StinkHit / SlimeProjectile)이 부르는 창구다. // 상태와 판정은 전부 EnemyDebuffs 에 있고 여기서는 위임만 한다. /// <summary>Frost 콘 안에 있는 동안 매 재판정 틱마다 호출한다.</summary> public void RefreshFrostContact() { mDebuffs.RefreshFrostContact(); } /// <summary>Stink 착탄. 도주 지속시간(초). 중첩 시 더 긴 쪽으로 갱신한다.</summary> public void ApplyFlee(float duration) { mDebuffs.ApplyFlee(duration); } /// <summary>Slime 명중.</summary> public void ApplySlime(int ticks, float tickInterval, int damagePerTick, Entity attacker) { mDebuffs.ApplySlime(ticks, tickInterval, damagePerTick, attacker); } // ─── 디버프 지원 (EnemyDebuffs 전용) ─── // 디버프가 몸에 반영해야 하는 것만 연다. 상태 필드 자체는 열지 않는다. /// <summary>Animator 를 켜고 끈다. 빙결이 끄고 해동이 되돌린다.</summary> internal void SetAnimatorEnabled(bool isEnabled) { if (mAnimator == null) return; mAnimator.enabled = isEnabled; } /// <summary>빙결 VFX 토글. 프리팹에 FreezeFx 자식이 없으면 조용히 무시된다.</summary> internal void SetFreezeFxActive(bool active) { SetFxActive(mFreezeFx, active); } /// <summary>슬라임 VFX 토글. 프리팹에 SlimeFx 자식이 없으면 조용히 무시된다.</summary> internal void SetSlimeFxActive(bool active) { SetFxActive(mSlimeFx, active); } private static void SetFxActive(GameObject fx, bool active) { if (fx != null && fx.activeSelf != active) { fx.SetActive(active); } } /// <summary> /// 디버프 타이머. <b>모든 상태에서 먼저 돌아야 한다</b> — /// 사망 연출 중에도, 플레이어가 죽은 뒤에도. /// </summary> internal void TickDebuffs(float elapseSeconds) { mDebuffs.OnUpdate(elapseSeconds); }

internal void TickChase(Player player, float elapseSeconds) { if (!IsAgentReady) return; mAgent.isStopped = false; mAgent.speed = mEnemyData.Stats.MoveSpeed * mSpeedMultiplier; mRetargetTimer += elapseSeconds; if (mRetargetTimer < EnemyTable.RetargetInterval) return; mRetargetTimer = 0f; // 추적 목적지는 발밑(트랜스폼 원점)이다. 공격 판정만 콜라이더 중심을 쓴다. // 둘째 인자는 "쫓을 좌표" 다. 지금은 플레이어 위치 그대로이고, // 아군이 생기는 뒤의 장에서 달라진다. Vector3 playerPosition = player.CachedTransform.position; mAgent.SetDestination(GetDestination(playerPosition, playerPosition)); } /// <summary> /// 추적 목적지. 도주 중이면 플레이어 반대 방향으로 달아난다. /// </summary> private Vector3 GetDestination(Vector3 playerPosition, Vector3 chasePosition) { // 도주는 언제나 플레이어 기준이다. 냄새를 뿌린 것이 플레이어이기 때문이다. if (!mDebuffs.IsFleeing) return chasePosition; return GetFleeDestination(playerPosition); } /// <summary>플레이어 반대편으로 FleeDistance 만큼 떨어진, NavMesh 위의 지점.</summary> private Vector3 GetFleeDestination(Vector3 playerPosition) { Vector3 away = CachedTransform.position - playerPosition; away.y = 0f; // 플레이어와 거의 겹쳐 있으면 방향이 없다. 그럴 때는 지금 보는 방향으로 달아난다. if (away.sqrMagnitude < MinFleeDirectionSqrMagnitude) { away = CachedTransform.forward; } Vector3 destination = CachedTransform.position + away.normalized * FleeDistance; NavMeshHit navHit; if (NavMesh.SamplePosition(destination, out navHit, FleeSampleRadius, NavMesh.AllAreas)) { return navHit.position; } // NavMesh 밖이면 도주를 포기한다. 아무 데도 못 가는 것보다 낫다. return playerPosition; }

mAttackTimer -= stats.TimeBetweenAttacks; // 슬라임에 걸리면 데미지만 막는다. 타이머는 계속 돌려야 한다 — // 멈추면 봉인 해제 직후 확정 타격이 나가 더 가혹해진다. if (mDebuffs.IsAttackSuppressed) return;

SetCollidersEnabled(false); // 빙결 중에 죽으면 Animator 가 꺼져 있어 사망 애니메이션이 통째로 안 나온다. mDebuffs.ClearAll();

// 데이터 없이 떴거나 이미 회수 요청이 나간 엔티티는 아무것도 하지 않는다. if (!owner.CanRunStates) return; owner.TickDebuffs(elapseSeconds); OnStateUpdate(fsm, owner, elapseSeconds);

// Assets/GameMain/Weapon/FrostWeapon.cs using System.Collections.Generic; using UnityEngine; using UnityGameFramework.Runtime; namespace ToyBoxNightmare { /// <summary> /// 빙결. 발사 버튼을 누르는 동안 콘을 켜고 그 안의 적을 얼린다. <b>데미지는 0이다.</b> /// Lightning 같은 딜링 무기와 병행 장착하는 것이 전제다. /// /// <b>쿨다운이 없다.</b> 콘 방향은 캐릭터 전방 고정이고, 캐릭터가 마우스를 /// 바라보므로 결과적으로 마우스 방향이 된다. /// /// 매 프레임 "지금 콘 안에 있는 집합"을 다시 계산한다. /// </summary> public class FrostWeapon : WeaponBase { // 무기 프리팹(FrostAttack) 루트 기준 경로다. private const string FrostConePath = "FrostCone"; private const string FrostArcPath = "FrostArc"; /// <summary>콘 꼭짓점의 FrostAttack 로컬 좌표.</summary> private static readonly Vector3 ApexLocal = new Vector3(-0.015296f, 0.044137f, 0.342790f); /// <summary>방향 벡터로 쓰기엔 너무 짧다고 볼 제곱 길이.</summary> private const float MinDirectionSqrMagnitude = 0.0001f; /// <summary> /// 콘이 지금 어디에 어떻게 놓여 있는지 — 꼭짓점과 바라보는 축. /// 이 둘은 항상 같이 구해서 같이 쓰이므로 한 덩어리로 묶었다. /// </summary> private struct ConePose { public Vector3 Apex; public Vector3 Axis; } private Transform mFrostAttack = null; private GameObject mFrostCone = null; /// <summary>발사 버튼을 누르고 있는가.</summary> private bool mFiring = false; /// <summary>이번 프레임에 얼릴 적들. 매 프레임 재사용해 할당을 없앤다.</summary> private readonly List<Enemy> mConeTargets = new List<Enemy>(16); /// <summary>반경 안 후보 스크래치.</summary> private readonly List<Enemy> mCandidates = new List<Enemy>(16); /// <summary>콘과 판정 기준 트랜스폼은 무기 프리팹 안에 있어 인스턴스당 한 번만 찾으면 된다.</summary> protected override void OnWeaponInit() { // 무기 프리팹의 루트가 곧 FrostAttack 이다. 콘 꼭짓점과 축을 여기서 읽는다. mFrostAttack = CachedTransform; Transform cone = CachedTransform.Find(FrostConePath); if (cone == null) { Log.Warning("FrostWeapon: '{0}' 을 찾지 못했다. 콘 연출 없이 동작한다.", FrostConePath); } mFrostCone = cone != null ? cone.gameObject : null; DisableLegacyArcCollider(); } /// <summary>풀에서 다시 나올 때 콘이 켜진 채로 등장하지 않게 한다.</summary> protected override void OnWeaponShow() { mFiring = false; SetConeActive(false); } /// <summary>코드 판정으로 갈았으므로 원본 판정용 콜라이더는 꺼 둔다(이중 판정 방지).</summary> private void DisableLegacyArcCollider() { Transform arc = CachedTransform.Find(FrostArcPath); if (arc == null) return; MeshCollider meshCollider = arc.GetComponent<MeshCollider>(); if (meshCollider != null) { meshCollider.enabled = false; } } /// <summary> /// 누르는 동안 콘을 켠다. <b>false 를 돌려준다</b> — 쿨다운을 소모하지 않는 발사라 /// 로드아웃이 전역 쿨다운을 걸면 안 된다. /// </summary> protected override bool OnFireHeld() { mFiring = true; SetConeActive(true); return false; } /// <summary> /// 버튼을 뗀 프레임. 로드아웃이 <b>쿨다운과 무관하게</b> 불러 주므로 콘이 남지 않는다. /// </summary> protected override void OnStopFiring() { mFiring = false; SetConeActive(false); } /// <summary> /// 콘이 켜져 있는 동안의 재판정. 활성 무기에 대해 매 프레임 불리는 /// 훅이 이것뿐이라 여기에 얹었다. /// </summary> protected override void OnUpdateAim(bool isReady) { if (!mFiring) return; int frozenCount = CollectCone(mConeTargets); for (int i = 0; i < frozenCount; i++) { mConeTargets[i].RefreshFrostContact(); } } /// <summary>지금 실제로 얼릴 적들 — 반경과 부채꼴 각도를 둘 다 통과한 집합이다.</summary> private int CollectCone(List<Enemy> results) { results.Clear(); ConePose cone; if (!TryGetCone(out cone)) return 0; int candidateCount = WeaponUtil.FindEnemiesInSphere( cone.Apex, WeaponTable.FrostConeRadius, mCandidates); for (int i = 0; i < candidateCount; i++) { if (IsInCone(mCandidates[i], cone)) { results.Add(mCandidates[i]); } } return results.Count; } /// <summary> /// 콘의 현재 자세. 축은 <b>캐릭터 전방</b>이다. 판정을 눈에 보이는 콘과 같은 /// 트랜스폼에서 뽑아야 둘이 어긋나지 않는다. /// </summary> private bool TryGetCone(out ConePose cone) { cone = new ConePose { Apex = Vector3.zero, Axis = Vector3.forward }; if (mFrostAttack == null || Owner == null) return false; cone.Apex = mFrostAttack.TransformPoint(ApexLocal); Vector3 axis = mFrostAttack.forward; axis.y = 0f; // 안테나가 정확히 수직을 보고 있으면 수평 성분이 사라진다. 그때만 캐릭터 정면으로 대신한다. if (axis.sqrMagnitude < MinDirectionSqrMagnitude) { axis = Owner.CachedTransform.forward; axis.y = 0f; } // 축은 반드시 수평이어야 한다. IsInCone 은 적까지의 상대 벡터만 눕히므로, // 축에 y 가 남으면 두 벡터 사이 각이 부풀려져 부채꼴이 실제보다 좁아진다. if (axis.sqrMagnitude < MinDirectionSqrMagnitude) { // 수평 방향을 만들 수 없으니 이번 판정은 포기한다. return false; } cone.Axis = axis; return true; } private static bool IsInCone(Enemy enemy, ConePose cone) { Vector3 toEnemy = enemy.CachedTransform.position - cone.Apex; toEnemy.y = 0f; return Vector3.Angle(cone.Axis, toEnemy) <= WeaponTable.FrostConeHalfAngle; } /// <summary>다른 무기로 전환되면 콘과 루프 사운드를 반드시 끈다.</summary> protected override void OnWeaponDisabled() { mFiring = false; SetConeActive(false); } private void SetConeActive(bool active) { if (mFrostCone != null && mFrostCone.activeSelf != active) { mFrostCone.SetActive(active); } } } }