[Abnormality] 이상 상태 시스템 구현

- 이상 상태 데이터 (버프/디버프) ScriptableObject 정의 - 런타임임 활성 이상 상태 관리 (ActiveAbnormality) - 캐릭터터별 AbnormalityManager 컴포넌트로 이상 상태 적용/제거 - 스킬 효과(AbnormalityEffect)로 스킬에 이상 상태 연동 - UI 슬롯 및 목록 표시 구현 (버프/디버프 구분) - 테스트 코드 및 씬 설정 추가 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-03-11 01:35:02 +09:00
parent 8add066c3c
commit ec99e302ed
35 changed files with 2586 additions and 38 deletions
--- a/Assets/Scripts/Abnormalities.meta
+++ b/Assets/Scripts/Abnormalities.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: bc6434195fb88a443939a5a0b2747f0a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/Scripts/Abnormalities/AbnormalityData.cs
+++ b/Assets/Scripts/Abnormalities/AbnormalityData.cs
@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using Colosseum.Stats;
+
+namespace Colosseum.Abnormalities
+{
+    /// <summary>
+    /// 제어 효과 타입
+    /// </summary>
+    public enum ControlType
+    {
+        None,       // 제어 효과 없음
+        Stun,       // 기절 (이동, 스킬 사용 불가)
+        Silence,    // 침묵 (스킬 사용 불가)
+        Slow        // 둔화 (이동 속도 감소)
+    }
+
+    /// <summary>
+    /// 스탯 수정자 엔트리
+    /// </summary>
+    [Serializable]
+    public class AbnormalityStatModifier
+    {
+        [Tooltip("수정할 스탯 타입")]
+        public StatType statType;
+
+        [Tooltip("수정값")]
+        public float value;
+
+        [Tooltip("수정 타입 (Flat: 고정값, PercentAdd: 퍼센트 합산, PercentMult: 퍼센트 곱셈)")]
+        public StatModType modType;
+
+        public AbnormalityStatModifier() { }
+
+        public AbnormalityStatModifier(StatType statType, float value, StatModType modType)
+        {
+            this.statType = statType;
+            this.value = value;
+            this.modType = modType;
+        }
+    }
+
+    /// <summary>
+    /// 이상 상태 정의 ScriptableObject
+    /// 버프/디버프의 데이터를 정의합니다.
+    /// </summary>
+    [CreateAssetMenu(fileName = "AbnormalityData", menuName = "Colosseum/Abnormalities/Abnormality")]
+    public class AbnormalityData : ScriptableObject
+    {
+        [Header("기본 정보")]
+        [Tooltip("이상 상태 이름")]
+        public string abnormalityName = "Abnormality";
+
+        [Tooltip("아이콘")]
+        public Sprite icon;
+
+        [Tooltip("지속 시간 (초, 0 이하면 영구)")]
+        public float duration = 5f;
+
+        [Tooltip("효과 레벨 (중복 처리용, 높으면 우선)")]
+        public int level = 1;
+
+        [Tooltip("디버프 여부")]
+        public bool isDebuff = false;
+
+        [Header("스탯 수정자")]
+        [Tooltip("스탯에 적용할 수정자 목록")]
+        public List<AbnormalityStatModifier> statModifiers = new List<AbnormalityStatModifier>();
+
+        [Header("주기적 효과 (DoT/HoT)")]
+        [Tooltip("주기적 효과 간격 (초, 0이면 비활성)")]
+        public float periodicInterval = 0f;
+
+        [Tooltip("주기적 효과값 (양수=힐, 음수=데미지)")]
+        public float periodicValue = 0f;
+
+        [Header("제어 효과 (CC)")]
+        [Tooltip("제어 효과 타입")]
+        public ControlType controlType = ControlType.None;
+
+        [Tooltip("둔화 배율 (Slow일 때, 0.5 = 50% 감소)")]
+        [Range(0f, 1f)]
+        public float slowMultiplier = 0.5f;
+
+        /// <summary>
+        /// 영구 효과인지 확인
+        /// </summary>
+        public bool IsPermanent => duration <= 0f;
+
+        /// <summary>
+        /// 주기적 효과가 있는지 확인
+        /// </summary>
+        public bool HasPeriodicEffect => periodicInterval > 0f && periodicValue != 0f;
+
+        /// <summary>
+        /// 제어 효과가 있는지 확인
+        /// </summary>
+        public bool HasControlEffect => controlType != ControlType.None;
+    }
+}
--- a/Assets/Scripts/Abnormalities/AbnormalityData.cs.meta
+++ b/Assets/Scripts/Abnormalities/AbnormalityData.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b08cc671f858a3b409170a5356e960a0
--- a/Assets/Scripts/Abnormalities/AbnormalityManager.cs
+++ b/Assets/Scripts/Abnormalities/AbnormalityManager.cs
@@ -0,0 +1,494 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using Unity.Netcode;
+using Colosseum.Stats;
+using Colosseum.Player;
+
+namespace Colosseum.Abnormalities
+{
+    /// <summary>
+    /// 캐릭터에 부착되어 이상 상태를 관리하는 컴포넌트
+    /// 버프/디버프의 적용, 제거, 주기적 효과를 처리합니다.
+    /// </summary>
+    public class AbnormalityManager : NetworkBehaviour
+    {
+        [Header("References")]
+        [Tooltip("CharacterStats 컴포넌트 (없으면 자동 검색)")]
+        [SerializeField] private CharacterStats characterStats;
+
+        [Tooltip("PlayerNetworkController 컴포넌트 (HP/MP 관리용)")]
+        [SerializeField] private PlayerNetworkController networkController;
+
+        // 활성화된 이상 상태 목록
+        private readonly List<ActiveAbnormality> activeAbnormalities = new List<ActiveAbnormality>();
+
+        // 제어 효과 상태
+        private int stunCount;
+        private int silenceCount;
+        private float slowMultiplier = 1f;
+
+        // 네트워크 동기화용 데이터
+        private NetworkList<AbnormalitySyncData> syncedAbnormalities;
+
+        /// <summary>
+        /// 기절 상태 여부
+        /// </summary>
+        public bool IsStunned => stunCount > 0;
+
+        /// <summary>
+        /// 침묵 상태 여부
+        /// </summary>
+        public bool IsSilenced => silenceCount > 0;
+
+        /// <summary>
+        /// 이동 속도 배율 (1.0 = 기본, 0.5 = 50% 감소)
+        /// </summary>
+        public float MoveSpeedMultiplier => slowMultiplier;
+
+        /// <summary>
+        /// 행동 가능 여부 (기절이 아닐 때)
+        /// </summary>
+        public bool CanAct => !IsStunned;
+
+        /// <summary>
+        /// 스킬 사용 가능 여부
+        /// </summary>
+        public bool CanUseSkills => !IsStunned && !IsSilenced;
+
+        /// <summary>
+        /// 활성화된 이상 상태 목록 (읽기 전용)
+        /// </summary>
+        public IReadOnlyList<ActiveAbnormality> ActiveAbnormalities => activeAbnormalities;
+
+        // 이벤트
+        public event Action<ActiveAbnormality> OnAbnormalityAdded;
+        public event Action<ActiveAbnormality> OnAbnormalityRemoved;
+        public event Action OnAbnormalitiesChanged;
+
+        /// <summary>
+        /// 네트워크 동기화용 이상 상태 데이터 구조체
+        /// </summary>
+        private struct AbnormalitySyncData : INetworkSerializable, IEquatable<AbnormalitySyncData>
+        {
+            public int AbnormalityId;
+            public float RemainingDuration;
+            public ulong SourceClientId;
+
+            public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+            {
+                serializer.SerializeValue(ref AbnormalityId);
+                serializer.SerializeValue(ref RemainingDuration);
+                serializer.SerializeValue(ref SourceClientId);
+            }
+
+            public bool Equals(AbnormalitySyncData other)
+            {
+                return AbnormalityId == other.AbnormalityId;
+            }
+        }
+
+        private void Awake()
+        {
+            if (characterStats == null)
+                characterStats = GetComponent<CharacterStats>();
+
+            if (networkController == null)
+                networkController = GetComponent<PlayerNetworkController>();
+
+            syncedAbnormalities = new NetworkList<AbnormalitySyncData>();
+        }
+
+        public override void OnNetworkSpawn()
+        {
+            syncedAbnormalities.OnListChanged += OnSyncedAbnormalitiesChanged;
+        }
+
+        public override void OnNetworkDespawn()
+        {
+            syncedAbnormalities.OnListChanged -= OnSyncedAbnormalitiesChanged;
+        }
+
+        private void Update()
+        {
+            if (!IsServer) return;
+
+            UpdateAbnormalities(Time.deltaTime);
+        }
+
+        /// <summary>
+        /// 이상 상태 적용
+        /// </summary>
+        /// <param name="data">적용할 이상 상태 데이터</param>
+        /// <param name="source">효과 시전자</param>
+        public void ApplyAbnormality(AbnormalityData data, GameObject source)
+        {
+            if (data == null)
+            {
+                Debug.LogWarning("[Abnormality] ApplyAbnormality called with null data");
+                return;
+            }
+
+            if (IsServer)
+            {
+                ApplyAbnormalityInternal(data, source);
+            }
+            else
+            {
+                var sourceNetId = source != null && source.TryGetComponent<NetworkObject>(out var netObj) ? netObj.NetworkObjectId : 0UL;
+                ApplyAbnormalityServerRpc(data.GetInstanceID(), sourceNetId);
+            }
+        }
+
+        [Rpc(SendTo.Server)]
+        private void ApplyAbnormalityServerRpc(int dataId, ulong sourceNetworkId)
+        {
+            var data = FindAbnormalityDataById(dataId);
+            if (data == null)
+            {
+                Debug.LogWarning($"[Abnormality] Could not find data with ID: {dataId}");
+                return;
+            }
+
+            GameObject source = null;
+            if (sourceNetworkId != 0UL && NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(sourceNetworkId, out var netObj))
+            {
+                source = netObj.gameObject;
+            }
+
+            ApplyAbnormalityInternal(data, source);
+        }
+
+        private void ApplyAbnormalityInternal(AbnormalityData data, GameObject source)
+        {
+            var existing = FindExistingAbnormality(data);
+
+            if (existing != null)
+            {
+                if (existing.Data == data)
+                {
+                    existing.RefreshDuration();
+                    UpdateSyncedAbnormalityDuration(existing);
+                    Debug.Log($"[Abnormality] Refreshed {data.abnormalityName} on {gameObject.name}");
+                    return;
+                }
+
+                if (data.level > existing.Data.level)
+                {
+                    RemoveAbnormalityInternal(existing);
+                }
+                else
+                {
+                    Debug.Log($"[Abnormality] Ignored {data.abnormalityName} (level {data.level}) - existing level {existing.Data.level} is higher or equal");
+                    return;
+                }
+            }
+
+            var newAbnormality = new ActiveAbnormality(data, source);
+            activeAbnormalities.Add(newAbnormality);
+
+            ApplyStatModifiers(newAbnormality);
+            ApplyControlEffect(data);
+            SyncAbnormalityAdd(newAbnormality, source);
+
+            OnAbnormalityAdded?.Invoke(newAbnormality);
+            OnAbnormalitiesChanged?.Invoke();
+
+            Debug.Log($"[Abnormality] Applied {data.abnormalityName} (level {data.level}) to {gameObject.name} for {data.duration}s");
+        }
+
+        /// <summary>
+        /// 이상 상태 제거
+        /// </summary>
+        /// <param name="data">제거할 이상 상태 데이터</param>
+        public void RemoveAbnormality(AbnormalityData data)
+        {
+            if (data == null) return;
+
+            if (IsServer)
+            {
+                var abnormality = FindExistingAbnormality(data);
+                if (abnormality != null)
+                {
+                    RemoveAbnormalityInternal(abnormality);
+                }
+            }
+            else
+            {
+                RemoveAbnormalityServerRpc(data.GetInstanceID());
+            }
+        }
+
+        [Rpc(SendTo.Server)]
+        private void RemoveAbnormalityServerRpc(int dataId)
+        {
+            var abnormality = activeAbnormalities.Find(a => a.Data.GetInstanceID() == dataId);
+            if (abnormality != null)
+            {
+                RemoveAbnormalityInternal(abnormality);
+            }
+        }
+
+        private void RemoveAbnormalityInternal(ActiveAbnormality abnormality)
+        {
+            RemoveStatModifiers(abnormality);
+            RemoveControlEffect(abnormality.Data);
+            SyncAbnormalityRemove(abnormality);
+            activeAbnormalities.Remove(abnormality);
+
+            OnAbnormalityRemoved?.Invoke(abnormality);
+            OnAbnormalitiesChanged?.Invoke();
+
+            Debug.Log($"[Abnormality] Removed {abnormality.Data.abnormalityName} from {gameObject.name}");
+        }
+
+        /// <summary>
+        /// 모든 이상 상태 제거
+        /// </summary>
+        public void RemoveAllAbnormalities()
+        {
+            if (!IsServer)
+            {
+                RemoveAllAbnormalitiesServerRpc();
+                return;
+            }
+
+            while (activeAbnormalities.Count > 0)
+            {
+                RemoveAbnormalityInternal(activeAbnormalities[0]);
+            }
+        }
+
+        [Rpc(SendTo.Server)]
+        private void RemoveAllAbnormalitiesServerRpc()
+        {
+            RemoveAllAbnormalities();
+        }
+
+        /// <summary>
+        /// 특정 출처의 모든 이상 상태 제거
+        /// </summary>
+        public void RemoveAbnormalitiesFromSource(GameObject source)
+        {
+            if (!IsServer)
+            {
+                var sourceNetId = source != null && source.TryGetComponent<NetworkObject>(out var netObj) ? netObj.NetworkObjectId : 0UL;
+                RemoveAbnormalitiesFromSourceServerRpc(sourceNetId);
+                return;
+            }
+
+            for (int i = activeAbnormalities.Count - 1; i >= 0; i--)
+            {
+                if (activeAbnormalities[i].Source == source)
+                {
+                    RemoveAbnormalityInternal(activeAbnormalities[i]);
+                }
+            }
+        }
+
+        [Rpc(SendTo.Server)]
+        private void RemoveAbnormalitiesFromSourceServerRpc(ulong sourceNetworkId)
+        {
+            for (int i = activeAbnormalities.Count - 1; i >= 0; i--)
+            {
+                var abnormality = activeAbnormalities[i];
+                var sourceNetId = abnormality.Source != null && abnormality.Source.TryGetComponent<NetworkObject>(out var netObj) ? netObj.NetworkObjectId : 0UL;
+                if (sourceNetId == sourceNetworkId)
+                {
+                    RemoveAbnormalityInternal(abnormality);
+                }
+            }
+        }
+
+        private void UpdateAbnormalities(float deltaTime)
+        {
+            for (int i = activeAbnormalities.Count - 1; i >= 0; i--)
+            {
+                var abnormality = activeAbnormalities[i];
+
+                if (abnormality.CanTriggerPeriodic())
+                {
+                    TriggerPeriodicEffect(abnormality);
+                }
+
+                if (abnormality.Tick(deltaTime))
+                {
+                    RemoveAbnormalityInternal(abnormality);
+                }
+            }
+        }
+
+        private void TriggerPeriodicEffect(ActiveAbnormality abnormality)
+        {
+            if (networkController == null) return;
+
+            float value = abnormality.Data.periodicValue;
+
+            if (value > 0)
+            {
+                networkController.RestoreHealthRpc(value);
+                Debug.Log($"[Abnormality] Periodic heal: +{value} HP from {abnormality.Data.abnormalityName}");
+            }
+            else if (value < 0)
+            {
+                networkController.TakeDamageRpc(-value);
+                Debug.Log($"[Abnormality] Periodic damage: {-value} HP from {abnormality.Data.abnormalityName}");
+            }
+        }
+
+        private ActiveAbnormality FindExistingAbnormality(AbnormalityData data)
+        {
+            return activeAbnormalities.Find(a => a.Data.abnormalityName == data.abnormalityName);
+        }
+
+        private void ApplyStatModifiers(ActiveAbnormality abnormality)
+        {
+            if (characterStats == null) return;
+
+            foreach (var entry in abnormality.Data.statModifiers)
+            {
+                var stat = characterStats.GetStat(entry.statType);
+                if (stat != null)
+                {
+                    var modifier = new StatModifier(entry.value, entry.modType, abnormality);
+                    abnormality.AppliedModifiers.Add(modifier);
+                    stat.AddModifier(modifier);
+                }
+            }
+        }
+
+        private void RemoveStatModifiers(ActiveAbnormality abnormality)
+        {
+            if (characterStats == null) return;
+
+            foreach (StatType statType in Enum.GetValues(typeof(StatType)))
+            {
+                var stat = characterStats.GetStat(statType);
+                stat?.RemoveAllModifiersFromSource(abnormality);
+            }
+
+            abnormality.AppliedModifiers.Clear();
+        }
+
+        private void ApplyControlEffect(AbnormalityData data)
+        {
+            switch (data.controlType)
+            {
+                case ControlType.Stun:
+                    stunCount++;
+                    break;
+
+                case ControlType.Silence:
+                    silenceCount++;
+                    break;
+
+                case ControlType.Slow:
+                    slowMultiplier = Mathf.Min(slowMultiplier, data.slowMultiplier);
+                    break;
+            }
+        }
+
+        private void RemoveControlEffect(AbnormalityData data)
+        {
+            switch (data.controlType)
+            {
+                case ControlType.Stun:
+                    stunCount = Mathf.Max(0, stunCount - 1);
+                    break;
+
+                case ControlType.Silence:
+                    silenceCount = Mathf.Max(0, silenceCount - 1);
+                    break;
+
+                case ControlType.Slow:
+                    RecalculateSlowMultiplier();
+                    break;
+            }
+        }
+
+        private void RecalculateSlowMultiplier()
+        {
+            slowMultiplier = 1f;
+
+            foreach (var abnormality in activeAbnormalities)
+            {
+                if (abnormality.Data.controlType == ControlType.Slow)
+                {
+                    slowMultiplier = Mathf.Min(slowMultiplier, abnormality.Data.slowMultiplier);
+                }
+            }
+        }
+
+        private void SyncAbnormalityAdd(ActiveAbnormality abnormality, GameObject source)
+        {
+            var sourceClientId = source != null && source.TryGetComponent<NetworkObject>(out var netObj) ? netObj.OwnerClientId : 0UL;
+
+            var syncData = new AbnormalitySyncData
+            {
+                AbnormalityId = abnormality.Data.GetInstanceID(),
+                RemainingDuration = abnormality.RemainingDuration,
+                SourceClientId = sourceClientId
+            };
+
+            syncedAbnormalities.Add(syncData);
+        }
+
+        private void UpdateSyncedAbnormalityDuration(ActiveAbnormality abnormality)
+        {
+            for (int i = 0; i < syncedAbnormalities.Count; i++)
+            {
+                if (syncedAbnormalities[i].AbnormalityId == abnormality.Data.GetInstanceID())
+                {
+                    var syncData = syncedAbnormalities[i];
+                    syncData.RemainingDuration = abnormality.RemainingDuration;
+                    syncedAbnormalities[i] = syncData;
+                    break;
+                }
+            }
+        }
+
+        private void SyncAbnormalityRemove(ActiveAbnormality abnormality)
+        {
+            for (int i = 0; i < syncedAbnormalities.Count; i++)
+            {
+                if (syncedAbnormalities[i].AbnormalityId == abnormality.Data.GetInstanceID())
+                {
+                    syncedAbnormalities.RemoveAt(i);
+                    break;
+                }
+            }
+        }
+
+        private void OnSyncedAbnormalitiesChanged(NetworkListEvent<AbnormalitySyncData> changeEvent)
+        {
+            OnAbnormalitiesChanged?.Invoke();
+        }
+
+        private AbnormalityData FindAbnormalityDataById(int instanceId)
+        {
+            var allData = Resources.FindObjectsOfTypeAll<AbnormalityData>();
+            foreach (var data in allData)
+            {
+                if (data.GetInstanceID() == instanceId)
+                    return data;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 특정 이름의 이상 상태가 활성화되어 있는지 확인
+        /// </summary>
+        public bool HasAbnormality(string name)
+        {
+            return activeAbnormalities.Exists(a => a.Data.abnormalityName == name);
+        }
+
+        /// <summary>
+        /// 특정 데이터의 이상 상태가 활성화되어 있는지 확인
+        /// </summary>
+        public bool HasAbnormality(AbnormalityData data)
+        {
+            return activeAbnormalities.Exists(a => a.Data.abnormalityName == data.abnormalityName);
+        }
+    }
+}
--- a/Assets/Scripts/Abnormalities/AbnormalityManager.cs.meta
+++ b/Assets/Scripts/Abnormalities/AbnormalityManager.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7a766b6ab825c1445a3385079bb32cc5
--- a/Assets/Scripts/Abnormalities/ActiveAbnormality.cs
+++ b/Assets/Scripts/Abnormalities/ActiveAbnormality.cs
@@ -0,0 +1,134 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using Colosseum.Stats;
+
+namespace Colosseum.Abnormalities
+{
+    /// <summary>
+    /// 런타임 활성 이상 상태 인스턴스
+    /// AbnormalityData의 인스턴스로, 실제 적용 중인 이상 상태를 관리합니다.
+    /// </summary>
+    public class ActiveAbnormality
+    {
+        /// <summary>
+        /// 이상 상태 데이터
+        /// </summary>
+        public AbnormalityData Data { get; }
+
+        /// <summary>
+        /// 효과를 건 대상 (버프/디버프 시전자)
+        /// </summary>
+        public GameObject Source { get; }
+
+        /// <summary>
+        /// 남은 지속 시간
+        /// </summary>
+        public float RemainingDuration { get; set; }
+
+        /// <summary>
+        /// 적용된 스탯 수정자 목록
+        /// </summary>
+        public List<StatModifier> AppliedModifiers { get; }
+
+        /// <summary>
+        /// 주기적 효과 타이머
+        /// </summary>
+        public float PeriodicTimer { get; set; }
+
+        /// <summary>
+        /// 고유 식별자 (네트워크 동기화용)
+        /// </summary>
+        public Guid Id { get; }
+
+        /// <summary>
+        /// 활성 이상 상태 생성
+        /// </summary>
+        /// <param name="data">이상 상태 데이터</param>
+        /// <param name="source">효과 시전자</param>
+        public ActiveAbnormality(AbnormalityData data, GameObject source)
+        {
+            Data = data;
+            Source = source;
+            RemainingDuration = data.duration;
+            PeriodicTimer = 0f;
+            Id = Guid.NewGuid();
+            AppliedModifiers = new List<StatModifier>();
+        }
+
+        /// <summary>
+        /// 지속 시간 갱신
+        /// </summary>
+        public void RefreshDuration()
+        {
+            RemainingDuration = Data.duration;
+            PeriodicTimer = 0f;
+        }
+
+        /// <summary>
+        /// 시간 경과 처리
+        /// </summary>
+        /// <param name="deltaTime">경과 시간</param>
+        /// <returns>효과가 만료되었으면 true</returns>
+        public bool Tick(float deltaTime)
+        {
+            // 영구 효과는 시간 감소 없음
+            if (Data.IsPermanent)
+                return false;
+
+            RemainingDuration -= deltaTime;
+
+            // 주기적 효과 타이머 업데이트
+            if (Data.HasPeriodicEffect)
+            {
+                PeriodicTimer += deltaTime;
+            }
+
+            return RemainingDuration <= 0f;
+        }
+
+        /// <summary>
+        /// 주기적 효과 발동 가능 여부 확인
+        /// </summary>
+        /// <returns>발동 가능하면 true</returns>
+        public bool CanTriggerPeriodic()
+        {
+            if (!Data.HasPeriodicEffect)
+                return false;
+
+            if (PeriodicTimer >= Data.periodicInterval)
+            {
+                PeriodicTimer -= Data.periodicInterval;
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// 진행률 (0~1)
+        /// </summary>
+        public float Progress
+        {
+            get
+            {
+                if (Data.IsPermanent)
+                    return 1f;
+                return Mathf.Clamp01(1f - (RemainingDuration / Data.duration));
+            }
+        }
+
+        /// <summary>
+        /// 남은 시간 비율 (1~0, UI 표시용)
+        /// </summary>
+        public float RemainingRatio
+        {
+            get
+            {
+                if (Data.IsPermanent)
+                    return 1f;
+                return Mathf.Clamp01(RemainingDuration / Data.duration);
+            }
+        }
+    }
+}
--- a/Assets/Scripts/Abnormalities/ActiveAbnormality.cs.meta
+++ b/Assets/Scripts/Abnormalities/ActiveAbnormality.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b90fb3ef8cb13be4383eb397857cfa2b
--- a/Assets/Scripts/Skills/Effects/AbnormalityEffect.cs
+++ b/Assets/Scripts/Skills/Effects/AbnormalityEffect.cs
@@ -0,0 +1,46 @@
+using UnityEngine;
+using Colosseum.Abnormalities;
+
+namespace Colosseum.Skills.Effects
+{
+    /// <summary>
+    /// 이상 상태 효과
+    /// AbnormalityManager를 통해 대상에게 이상 상태를 적용합니다.
+    /// </summary>
+    [CreateAssetMenu(fileName = "AbnormalityEffect", menuName = "Colosseum/Skills/Effects/Abnormality")]
+    public class AbnormalityEffect : SkillEffect
+    {
+        [Header("Abnormality")]
+        [Tooltip("적용할 이상 상태 데이터")]
+        [SerializeField] private AbnormalityData abnormalityData;
+
+        protected override void ApplyEffect(GameObject caster, GameObject target)
+        {
+            if (target == null) return;
+
+            if (abnormalityData == null)
+            {
+                Debug.LogWarning($"[AbnormalityEffect] AbnormalityData is not assigned");
+                return;
+            }
+
+            var abnormalityManager = target.GetComponent<AbnormalityManager>();
+            if (abnormalityManager == null)
+            {
+                Debug.LogWarning($"[AbnormalityEffect] Target {target.name} has no AbnormalityManager");
+                return;
+            }
+
+            abnormalityManager.ApplyAbnormality(abnormalityData, caster);
+            Debug.Log($"[AbnormalityEffect] Applied {abnormalityData.abnormalityName} to {target.name} from {caster?.name ?? "unknown"}");
+        }
+
+        /// <summary>
+        /// 이상 상태 데이터 설정 (런타임용)
+        /// </summary>
+        public void SetAbnormalityData(AbnormalityData data)
+        {
+            abnormalityData = data;
+        }
+    }
+}
--- a/Assets/Scripts/Skills/Effects/AbnormalityEffect.cs.meta
+++ b/Assets/Scripts/Skills/Effects/AbnormalityEffect.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: bf750718c64c4bd48af905d2927351de
--- a/Assets/Scripts/Skills/Effects/BuffEffect.cs
+++ b/Assets/Scripts/Skills/Effects/BuffEffect.cs
@@ -1,32 +0,0 @@
-using UnityEngine;
-
-namespace Colosseum.Skills.Effects
-{
-    /// <summary>
-    /// 버프/디버프 효과
-    /// </summary>
-    [CreateAssetMenu(fileName = "BuffEffect", menuName = "Colosseum/Skills/Effects/Buff")]
-    public class BuffEffect : SkillEffect
-    {
-        [Header("Buff Settings")]
-        [SerializeField] private string buffName = "Buff";
-        [Min(0f)] [SerializeField] private float duration = 5f;
-
-        [Header("Stat Modifiers")]
-        [Range(0f, 10f)] [SerializeField] private float moveSpeedMultiplier = 1f;
-        [Range(0f, 10f)] [SerializeField] private float attackPowerMultiplier = 1f;
-        [Range(0f, 10f)] [SerializeField] private float defenseMultiplier = 1f;
-
-        protected override void ApplyEffect(GameObject caster, GameObject target)
-        {
-            if (target == null) return;
-
-            // TODO: 실제 버프 시스템 연동
-            // var buffSystem = target.GetComponent<BuffSystem>();
-            // buffSystem?.ApplyBuff(new BuffData(buffName, duration, moveSpeedMultiplier, attackPowerMultiplier, defenseMultiplier));
-
-            Debug.Log($"[Buff] {buffName} on {target.name} for {duration}s " +
-                      $"(Speed: {moveSpeedMultiplier}x, ATK: {attackPowerMultiplier}x, DEF: {defenseMultiplier}x)");
-        }
-    }
-}
--- a/Assets/Scripts/Skills/Effects/BuffEffect.cs.meta
+++ b/Assets/Scripts/Skills/Effects/BuffEffect.cs.meta
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 32bab3b586da0d7469f63e03f18ee29f
--- a/Assets/Scripts/StatusEffects.meta
+++ b/Assets/Scripts/StatusEffects.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 148d81d9974baed45b212857d96aed37
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/Scripts/UI/AbnormalityListUI.cs
+++ b/Assets/Scripts/UI/AbnormalityListUI.cs
@@ -0,0 +1,279 @@
+using System.Collections.Generic;
+using UnityEngine;
+using Colosseum.Abnormalities;
+
+namespace Colosseum.UI
+{
+    /// <summary>
+    /// 이상 상태 목록 UI 관리자
+    /// 버프/디버프 목록을 표시하고 관리합니다.
+    /// </summary>
+    public class AbnormalityListUI : MonoBehaviour
+    {
+        [Header("Containers")]
+        [Tooltip("버프 컨테이너")]
+        [SerializeField] private Transform buffContainer;
+
+        [Tooltip("디버프 컨테이너")]
+        [SerializeField] private Transform debuffContainer;
+
+        [Header("Prefab")]
+        [Tooltip("이상 상태 슬롯 프리팹")]
+        [SerializeField] private AbnormalitySlotUI slotPrefab;
+
+        [Header("Settings")]
+        [Tooltip("최대 표시 개수")]
+        [SerializeField] private int maxSlots = 10;
+
+        [Tooltip("자동으로 플레이어 추적")]
+        [SerializeField] private bool autoFindPlayer = true;
+
+        // 추적 중인 AbnormalityManager
+        private AbnormalityManager targetManager;
+
+        // 생성된 슬롯 풀
+        private readonly List<AbnormalitySlotUI> slotPool = new List<AbnormalitySlotUI>();
+
+        // 현재 활성화된 슬롯 목록
+        private readonly List<AbnormalitySlotUI> activeSlots = new List<AbnormalitySlotUI>();
+
+        // 이전 프레임의 효과 수 (변경 감지용)
+        private int lastAbnormalityCount = -1;
+
+        private void Start()
+        {
+            if (autoFindPlayer)
+            {
+                // 로컬 플레이어 찾기
+                FindLocalPlayer();
+            }
+
+            // 슬롯 풀 초기화
+            InitializeSlotPool();
+        }
+
+        private void OnDestroy()
+        {
+            // 이벤트 구독 해제
+            if (targetManager != null)
+            {
+                targetManager.OnAbnormalityAdded -= OnAbnormalityAdded;
+                targetManager.OnAbnormalityRemoved -= OnAbnormalityRemoved;
+                targetManager.OnAbnormalitiesChanged -= OnAbnormalitiesChanged;
+            }
+        }
+
+        private void Update()
+        {
+            // 주기적으로 UI 갱신 (성능 최적화를 위해 매 프레임이 아닌 일정 간격으로)
+            if (Time.frameCount % 10 == 0) // 10프레임마다 한 번
+            {
+                RefreshUI();
+            }
+        }
+
+        /// <summary>
+        /// 로컬 플레이어 찾기
+        /// </summary>
+        private void FindLocalPlayer()
+        {
+            var playerObjects = FindObjectsByType<AbnormalityManager>(FindObjectsSortMode.None);
+
+            foreach (var manager in playerObjects)
+            {
+                // 네트워크 오브젝트인 경우 로컬 플레이어 확인
+                if (manager.TryGetComponent<Unity.Netcode.NetworkObject>(out var netObj) && netObj.IsOwner)
+                {
+                    SetTarget(manager);
+                    return;
+                }
+            }
+
+            // 네트워크 오브젝트가 없거나 로컬 플레이어를 찾지 못한 경우
+            // 첫 번째 플레이어 사용 (싱글플레이어용)
+            if (playerObjects.Length > 0)
+            {
+                SetTarget(playerObjects[0]);
+            }
+        }
+
+        /// <summary>
+        /// 추적 대상 설정
+        /// </summary>
+        /// <param name="manager">추적할 AbnormalityManager</param>
+        public void SetTarget(AbnormalityManager manager)
+        {
+            // 기존 구독 해제
+            if (targetManager != null)
+            {
+                targetManager.OnAbnormalityAdded -= OnAbnormalityAdded;
+                targetManager.OnAbnormalityRemoved -= OnAbnormalityRemoved;
+                targetManager.OnAbnormalitiesChanged -= OnAbnormalitiesChanged;
+            }
+
+            targetManager = manager;
+
+            // 새로운 대상 구독
+            if (targetManager != null)
+            {
+                targetManager.OnAbnormalityAdded += OnAbnormalityAdded;
+                targetManager.OnAbnormalityRemoved += OnAbnormalityRemoved;
+                targetManager.OnAbnormalitiesChanged += OnAbnormalitiesChanged;
+            }
+
+            // 즉시 UI 갱신
+            ForceRefreshUI();
+        }
+
+        /// <summary>
+        /// 슬롯 풀 초기화
+        /// </summary>
+        private void InitializeSlotPool()
+        {
+            if (slotPrefab == null)
+            {
+                Debug.LogWarning("[AbnormalityListUI] Slot prefab is not assigned");
+                return;
+            }
+
+            // 필요한 만큼 슬롯 미리 생성
+            for (int i = 0; i < maxSlots; i++)
+            {
+                var slot = CreateSlot();
+                slot.gameObject.SetActive(false);
+                slotPool.Add(slot);
+            }
+        }
+
+        /// <summary>
+        /// 새 슬롯 생성
+        /// </summary>
+        private AbnormalitySlotUI CreateSlot()
+        {
+            var go = Instantiate(slotPrefab.gameObject, transform);
+            return go.GetComponent<AbnormalitySlotUI>();
+        }
+
+        /// <summary>
+        /// 슬롯 가져오기 (풀에서 또는 새로 생성)
+        /// </summary>
+        private AbnormalitySlotUI GetSlot()
+        {
+            // 풀에서 비활성화된 슬롯 찾기
+            foreach (var slot in slotPool)
+            {
+                if (!slot.gameObject.activeSelf)
+                {
+                    return slot;
+                }
+            }
+
+            // 풀에 없으면 새로 생성
+            if (slotPool.Count < maxSlots)
+            {
+                var newSlot = CreateSlot();
+                slotPool.Add(newSlot);
+                return newSlot;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 슬롯 반환 (비활성화)
+        /// </summary>
+        private void ReturnSlot(AbnormalitySlotUI slot)
+        {
+            slot.gameObject.SetActive(false);
+            activeSlots.Remove(slot);
+        }
+
+        /// <summary>
+        /// 이상 상태 추가 시 호출
+        /// </summary>
+        private void OnAbnormalityAdded(ActiveAbnormality abnormality)
+        {
+            ForceRefreshUI();
+        }
+
+        /// <summary>
+        /// 이상 상태 제거 시 호출
+        /// </summary>
+        private void OnAbnormalityRemoved(ActiveAbnormality abnormality)
+        {
+            ForceRefreshUI();
+        }
+
+        /// <summary>
+        /// 이상 상태 변경 시 호출
+        /// </summary>
+        private void OnAbnormalitiesChanged()
+        {
+            ForceRefreshUI();
+        }
+
+        /// <summary>
+        /// UI 강제 갱신
+        /// </summary>
+        public void ForceRefreshUI()
+        {
+            if (targetManager == null) return;
+
+            // 모든 슬롯 반환
+            foreach (var slot in activeSlots.ToArray())
+            {
+                ReturnSlot(slot);
+            }
+
+            activeSlots.Clear();
+
+            // 활성화된 이상 상태 표시
+            var abnormalities = targetManager.ActiveAbnormalities;
+            foreach (var abnormality in abnormalities)
+            {
+                var slot = GetSlot();
+                if (slot == null) continue;
+
+                // 버프/디버프에 따라 적절한 컨테이너에 배치
+                Transform container = abnormality.Data.isDebuff ? debuffContainer : buffContainer;
+                if (container == null) container = transform;
+
+                slot.transform.SetParent(container, false);
+                slot.Initialize(abnormality);
+                slot.gameObject.SetActive(true);
+                activeSlots.Add(slot);
+            }
+
+            lastAbnormalityCount = abnormalities.Count;
+        }
+
+        /// <summary>
+        /// UI 주기적 갱신 (변경 감지 시에만)
+        /// </summary>
+        private void RefreshUI()
+        {
+            if (targetManager == null) return;
+
+            int currentCount = targetManager.ActiveAbnormalities.Count;
+
+            // 이상 상태 수가 변경되었으면 갱신
+            if (currentCount != lastAbnormalityCount)
+            {
+                ForceRefreshUI();
+            }
+        }
+
+        /// <summary>
+        /// 모든 슬롯 숨기기
+        /// </summary>
+        public void HideAll()
+        {
+            foreach (var slot in activeSlots.ToArray())
+            {
+                ReturnSlot(slot);
+            }
+
+            activeSlots.Clear();
+        }
+    }
+}
--- a/Assets/Scripts/UI/AbnormalityListUI.cs.meta
+++ b/Assets/Scripts/UI/AbnormalityListUI.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 15447f4a4d271354fb52bbdf1a526c6e
--- a/Assets/Scripts/UI/AbnormalitySlotUI.cs
+++ b/Assets/Scripts/UI/AbnormalitySlotUI.cs
@@ -0,0 +1,182 @@
+using UnityEngine;
+using UnityEngine.UI;
+using TMPro;
+using Colosseum.Abnormalities;
+
+namespace Colosseum.UI
+{
+    /// <summary>
+    /// 개별 이상 상태 UI 슬롯
+    /// 버프/디버프 아이콘, 지속 시간 등을 표시합니다.
+    /// </summary>
+    public class AbnormalitySlotUI : MonoBehaviour
+    {
+        [Header("UI References")]
+        [Tooltip("이상 상태 아이콘")]
+        [SerializeField] private Image iconImage;
+
+        [Tooltip("지속 시간 채우기 이미지 (시계 방향)")]
+        [SerializeField] private Image durationFill;
+
+        [Tooltip("남은 시간 텍스트")]
+        [SerializeField] private TMP_Text durationText;
+
+        [Tooltip("효과 이름 텍스트")]
+        [SerializeField] private TMP_Text effectNameText;
+
+        [Tooltip("배경 이미지 (버프/디버프 구분용)")]
+        [SerializeField] private Image backgroundImage;
+
+        [Header("Colors")]
+        [Tooltip("버프 배경 색상")]
+        [SerializeField] private Color buffColor = new Color(0.2f, 0.6f, 0.2f, 0.8f);
+
+        [Tooltip("디버프 배경 색상")]
+        [SerializeField] private Color debuffColor = new Color(0.6f, 0.2f, 0.2f, 0.8f);
+
+        private ActiveAbnormality trackedAbnormality;
+
+        /// <summary>
+        /// 추적 중인 활성 이상 상태
+        /// </summary>
+        public ActiveAbnormality TrackedAbnormality => trackedAbnormality;
+
+        /// <summary>
+        /// UI 초기화
+        /// </summary>
+        /// <param name="abnormality">표시할 활성 이상 상태</param>
+        public void Initialize(ActiveAbnormality abnormality)
+        {
+            trackedAbnormality = abnormality;
+
+            if (abnormality?.Data == null)
+            {
+                Debug.LogWarning("[AbnormalitySlotUI] Initialize called with null abnormality or data");
+                return;
+            }
+
+            // 아이콘 설정
+            if (iconImage != null)
+            {
+                iconImage.sprite = abnormality.Data.icon;
+                iconImage.enabled = abnormality.Data.icon != null;
+            }
+
+            // 이름 설정
+            if (effectNameText != null)
+            {
+                effectNameText.text = abnormality.Data.abnormalityName;
+            }
+
+            // 배경 색상 설정 (버프/디버프 구분)
+            if (backgroundImage != null)
+            {
+                backgroundImage.color = abnormality.Data.isDebuff ? debuffColor : buffColor;
+            }
+
+            // 초기 상태 업데이트
+            UpdateDisplay(abnormality.RemainingDuration, abnormality.Data.duration);
+        }
+
+        /// <summary>
+        /// 화면 표시 업데이트
+        /// </summary>
+        /// <param name="remainingDuration">남은 시간</param>
+        /// <param name="totalDuration">전체 시간</param>
+        public void UpdateDisplay(float remainingDuration, float totalDuration)
+        {
+            // 지속 시간 채우기 업데이트
+            if (durationFill != null)
+            {
+                if (totalDuration > 0f)
+                {
+                    float fillAmount = Mathf.Clamp01(remainingDuration / totalDuration);
+                    durationFill.fillAmount = fillAmount;
+                    durationFill.enabled = true;
+                }
+                else
+                {
+                    // 영구 효과
+                    durationFill.fillAmount = 1f;
+                }
+            }
+
+            // 남은 시간 텍스트 업데이트
+            if (durationText != null)
+            {
+                if (totalDuration > 0f)
+                {
+                    if (remainingDuration >= 60f)
+                    {
+                        durationText.text = $"{remainingDuration / 60f:F0}m";
+                    }
+                    else if (remainingDuration >= 1f)
+                    {
+                        durationText.text = $"{remainingDuration:F0}s";
+                    }
+                    else
+                    {
+                        durationText.text = $"{remainingDuration:F1}s";
+                    }
+                }
+                else
+                {
+                    // 영구 효과
+                    durationText.text = "∞";
+                }
+            }
+        }
+
+        /// <summary>
+        /// 프레임마다 호출하여 추적 중인 효과 업데이트
+        /// </summary>
+        private void Update()
+        {
+            if (trackedAbnormality == null)
+            {
+                gameObject.SetActive(false);
+                return;
+            }
+
+            UpdateDisplay(trackedAbnormality.RemainingDuration, trackedAbnormality.Data.duration);
+        }
+
+        /// <summary>
+        /// 툴팁 표시용 정보 반환
+        /// </summary>
+        public string GetTooltipText()
+        {
+            if (trackedAbnormality?.Data == null) return string.Empty;
+
+            var data = trackedAbnormality.Data;
+            string tooltip = $"<b>{data.abnormalityName}</b>\n";
+
+            if (!data.IsPermanent)
+            {
+                tooltip += $"지속 시간: {trackedAbnormality.RemainingDuration:F1}초\n";
+            }
+            else
+            {
+                tooltip += "영구 효과\n";
+            }
+
+            if (data.HasPeriodicEffect)
+            {
+                tooltip += $"주기적 효과: {data.periodicValue:+0}/ {data.periodicInterval}초\n";
+            }
+
+            if (data.HasControlEffect)
+            {
+                tooltip += $"제어 효과: {data.controlType}\n";
+            }
+
+            foreach (var mod in data.statModifiers)
+            {
+                string sign = mod.value >= 0 ? "+" : "";
+                tooltip += $"{mod.statType}: {sign}{mod.value}\n";
+            }
+
+            return tooltip;
+        }
+    }
+}
--- a/Assets/Scripts/UI/AbnormalitySlotUI.cs.meta
+++ b/Assets/Scripts/UI/AbnormalitySlotUI.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 287a45a81e69cbf48845f88759cf7eb4
--- a/Assets/Scripts/UI/AbnormalitySystemTest.cs
+++ b/Assets/Scripts/UI/AbnormalitySystemTest.cs
@@ -0,0 +1,116 @@
+using UnityEngine;
+using Colosseum.Abnormalities;
+
+namespace Colosseum.UI
+{
+    /// <summary>
+    /// 이상 상태 시스템 테스트 스크립트
+    /// Q 키: 버프 적용, E 키: 디버프 적용
+    /// 로그를 통해 OnEffect 이벤트 호출 및 이상 상태 적용 과정을 추적합니다.
+    /// </summary>
+    public class AbnormalitySystemTest : MonoBehaviour
+    {
+        private AbnormalityManager abnormalityManager;
+        private AbnormalityData testBuff;
+        private AbnormalityData testDebuff;
+
+        private float testTimer;
+
+        void Start()
+        {
+            // 플레이어에서 AbnormalityManager 찾기
+            abnormalityManager = GetComponent<AbnormalityManager>();
+            if (abnormalityManager == null)
+            {
+                Debug.LogError("[AbnormalitySystemTest] AbnormalityManager not found on player!");
+                return;
+            }
+
+            // 테스트용 이상 상태 데이터 생성 (에셋 생성)
+            testBuff = ScriptableObject.CreateInstance<AbnormalityData>();
+            testBuff.abnormalityName = "Test Buff";
+            testBuff.duration = 5f;
+            testBuff.isDebuff = false;
+
+            testDebuff = ScriptableObject.CreateInstance<AbnormalityData>();
+            testDebuff.abnormalityName = "Test Debuff";
+            testDebuff.duration = 5f;
+            testDebuff.isDebuff = true;
+
+            // 이벤트 구독
+            abnormalityManager.OnAbnormalityAdded += OnAbnormalityAdded;
+            abnormalityManager.OnAbnormalityRemoved += OnAbnormalityRemoved;
+
+            Debug.Log("=== Abnormality System Test Started ===");
+            Debug.Log("Press Q to apply buff, Press E to apply debuff");
+            Debug.Log($"Initial Active Abnormalities Count: {abnormalityManager.ActiveAbnormalities.Count}");
+        }
+
+        void Update()
+        {
+            testTimer += Time.deltaTime;
+
+            // Q 키로 버프 적용 (3초마다 1회만)
+            if (Input.GetKeyDown(KeyCode.Q) && testTimer >= 3f)
+            {
+                testTimer = 0f;
+                ApplyTestBuff();
+            }
+
+            // E 키로 디버프 적용 (3초마다 1회만)
+            if (Input.GetKeyDown(KeyCode.E) && testTimer >= 3f)
+            {
+                testTimer = 0f;
+                ApplyTestDebuff();
+            }
+        }
+
+        private void ApplyTestBuff()
+        {
+            if (testBuff == null || abnormalityManager == null)
+            {
+                Debug.LogWarning("[AbnormalitySystemTest] Cannot apply buff - data or manager is null");
+                return;
+            }
+
+            Debug.Log($"[AbnormalitySystemTest] >>> Applying BUFF: {testBuff.abnormalityName} to {gameObject.name}");
+            abnormalityManager.ApplyAbnormality(testBuff, gameObject);
+        }
+
+        private void ApplyTestDebuff()
+        {
+            if (testDebuff == null || abnormalityManager == null)
+            {
+                Debug.LogWarning("[AbnormalitySystemTest] Cannot apply debuff - data or manager is null");
+                return;
+            }
+
+            Debug.Log($"[AbnormalitySystemTest] >>> Applying DEBUFF: {testDebuff.abnormalityName} to {gameObject.name}");
+            abnormalityManager.ApplyAbnormality(testDebuff, gameObject);
+        }
+
+        private void OnAbnormalityAdded(ActiveAbnormality abnormality)
+        {
+            Debug.Log($"[AbnormalitySystemTest] <<< ABNORMALITY ADDED: {abnormality.Data.abnormalityName} | isDebuff: {abnormality.Data.isDebuff} | Duration: {abnormality.Data.duration}s | Remaining: {abnormality.RemainingDuration:F1}s");
+        }
+
+        private void OnAbnormalityRemoved(ActiveAbnormality abnormality)
+        {
+            Debug.Log($"[AbnormalitySystemTest] <<< ABNORMALITY REMOVED: {abnormality.Data.abnormalityName}");
+        }
+
+        void OnDestroy()
+        {
+            // 이벤트 구독 해제
+            if (abnormalityManager != null)
+            {
+                abnormalityManager.OnAbnormalityAdded -= OnAbnormalityAdded;
+                abnormalityManager.OnAbnormalityRemoved -= OnAbnormalityRemoved;
+            }
+
+            // 정리
+            if (testBuff != null) Destroy(testBuff);
+            if (testDebuff != null) Destroy(testDebuff);
+        }
+    }
+}
--- a/Assets/Scripts/UI/AbnormalitySystemTest.cs.meta
+++ b/Assets/Scripts/UI/AbnormalitySystemTest.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a1b2c3d4e5f6a7b8c9a0d1e5e3