Refactor

Author: serg.morozov

NuclearAbilitySystem.Implementation/CombatStateBuilder.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+
+namespace Nuclear.AbilitySystem.Tests
+{
+    public class CombatStateBuilder
+    {
+        private readonly List<IUnitMutable> _units = new();
+        private IAbilityContextHolderMutable? _abilityContextHolder;
+
+        public CombatStateBuilder WithUnit(IUnitMutable unit)
+        {
+            _units.Add(unit);
+            return this;
+        }
+
+        public CombatStateBuilder WithAbilityContext(IAbilityContextHolderMutable contextHolder)
+        {
+            _abilityContextHolder = contextHolder;
+            return this;
+        }
+
+        public ICombatState Build()
+        {
+            return new CombatState(_units, _abilityContextHolder ?? new AbilityContextHolder());
+        }
+    }
+}

NuclearAbilitySystem.Implementation/Features/Abilities/AbilityContextHolder.cs

@@ -3,13 +3,13 @@
 
 namespace Nuclear.AbilitySystem
 {
-    public sealed class AbilityContextHolder : IAbilityContextHolder
+    public sealed class AbilityContextHolder : IAbilityContextHolderMutable
     {
         private readonly Dictionary<Type, IAbilityContext> _contexts = new();
 
         public AbilityContextHolder()
         {
-            _contexts.Add(typeof(ITimeAbilityContext), new TimeAbilityContext(0));
+            _contexts.Add(typeof(ITurnAbilityContext), new TurnAbilityContext(0));
             _contexts.Add(typeof(IDistanceBetweenUnitsAbilityContext), new DistanceBetweenUnitsAbilityContext());
         }
 
@@ -25,24 +25,24 @@ public T GetContext<T>() where T : IAbilityContext
             return (T)_contexts[typeof(T)];
         }
 
-        public IAbilityContextHolder DeepClone()
+        public IAbilityContextHolderMutable DeepClone()
         {
             return new AbilityContextHolder(this);
         }
 
-        public void Subscribe(ICombatState combatState)
+        public void Connect(ICombatState combatState)
         {
             foreach (var context in _contexts.Values)
             {
-                context.Subscribe(combatState);
+                context.Connect(combatState);
             }
         }
 
-        public void UnSubscribe()
+        public void Disconnect()
         {
             foreach (var context in _contexts.Values)
             {
-                context.UnSubscribe();
+                context.Disconnect();
             }
         }
     }

…eatures/Abilities/AbilityActionTarget.cs …Abilities/Actions/AbilityActionTarget.csNuclearAbilitySystem.Implementation/Features/Abilities/AbilityActionTarget.cs renamed to NuclearAbilitySystem.Implementation/Features/Abilities/Actions/AbilityActionTarget.cs NuclearAbilitySystem.Implementation/Features/Abilities/AbilityActionTarget.cs renamed to NuclearAbilitySystem.Implementation/Features/Abilities/Actions/AbilityActionTarget.cs

@@ -13,8 +13,8 @@ public enum AbilityActionTarget
     public static class AbilityActionTargetExtensions
     {
         public static void UpdateAbilityActionTarget(AbilityActionTarget skillActionTarget, 
-            IUnitId? source, IUnitId? target,
-            out IUnitId? effectSource, out IUnitId? effectTarget)
+            UnitId? source, UnitId? target,
+            out UnitId? effectSource, out UnitId? effectTarget)
         {
             switch (skillActionTarget)
             {

NuclearAbilitySystem.Implementation/Features/Abilities/Checks/CooldownAbilityCheck.cs

@@ -13,21 +13,21 @@ public CooldownAbilityCheck(int cooldown, int? startValue = null)
             _lastCastTime = -startValue ?? -cooldown;
         }
 
-        public bool CanExecute(IUnitId source, IUnitId? target, ICombatState context)
+        public bool CanExecute(UnitId source, UnitId? target, ICombatState context)
         {
-            var timeContext = context.AbilityContextHolder.GetContext<ITimeAbilityContext>();
+            var timeContext = context.AbilityContextHolder.GetContext<ITurnAbilityContext>();
             return GetCooldownTimer(timeContext) == 0;
         }
 
-        public void Execute(IUnitId source, IUnitId? target, ICombatState context)
+        public void Execute(UnitId source, UnitId? target, ICombatState context)
         {
-            var timeContext = context.AbilityContextHolder.GetContext<ITimeAbilityContext>();
-            _lastCastTime = timeContext.Time;
+            var timeContext = context.AbilityContextHolder.GetContext<ITurnAbilityContext>();
+            _lastCastTime = timeContext.Turn;
         }
 
-        public int GetCooldownTimer(ITimeAbilityContext timeContext)
+        public int GetCooldownTimer(ITurnAbilityContext turnContext)
         {
-            return Math.Max(0, _lastCastTime + _cooldown + 1 - timeContext.Time);
+            return Math.Max(0, _lastCastTime + _cooldown + 1 - turnContext.Turn);
         }
 
         public IAbilityCheck DeepClone()

NuclearAbilitySystem.Implementation/Features/Abilities/Checks/ICooldownAbilityCheck.cs

@@ -2,6 +2,6 @@ namespace Nuclear.AbilitySystem
 {
     public interface ICooldownAbilityCheck : IAbilityCheck
     {
-        int GetCooldownTimer(ITimeAbilityContext context);
+        int GetCooldownTimer(ITurnAbilityContext context);
     }
 }

NuclearAbilitySystem.Implementation/Features/Abilities/Checks/ITimeAbilityContext.cs

@@ -0,0 +1,8 @@
+namespace Nuclear.AbilitySystem
+{
+    public interface ITurnAbilityContext : IAbilityContext
+    {
+        int Turn { get; }
+        void NextTurn();
+    }
+}

NuclearAbilitySystem.Implementation/Features/Abilities/Checks/ITurnAbilityContext.cs

@@ -0,0 +1,29 @@
+namespace Nuclear.AbilitySystem
+{
+    public sealed class TurnAbilityContext : ITurnAbilityContext
+    {
+        public TurnAbilityContext(int turn)
+        {
+            Turn = turn;
+        }
+
+        public int Turn { get; private set; }
+        public void NextTurn()
+        {
+            Turn++;
+        }
+
+        public IAbilityContext DeepClone()
+        {
+            return new TurnAbilityContext(Turn);
+        }
+
+        public void Connect(ICombatState combatState)
+        {
+        }
+
+        public void Disconnect()
+        {
+        }
+    }
+}

NuclearAbilitySystem.Implementation/Features/Abilities/Checks/TimeAbilityContext.cs

@@ -14,7 +14,7 @@ public DelayAbilityAction(int time,
 
         public int Time { get; }
         public ReadOnlyCollection<IAbilityAction> OnEnd { get; }
-        public void Execute(IUnitId sourceId, IUnitId? targetId, ICombatState context)
+        public void Execute(UnitId sourceId, UnitId? targetId, ICombatStateMutable context)
         {
 
             context.CommandQueue.AddTimeEvent(context.CommandQueue.Time + Time, () =>