First commit

Author: serg.morozov

.gitignore

@@ -0,0 +1,42 @@
+using System;
+
+namespace Nuclear.AbilitySystem
+{
+    public enum AbilityActionTarget
+    {
+        FromSourceToTarget,
+        FromTargetToSource,
+        FromTargetToTarget,
+        FromSourceToSource
+    }
+    
+    public static class AbilityActionTargetExtensions
+    {
+        public static void UpdateAbilityActionTarget(AbilityActionTarget skillActionTarget, 
+            IUnitId? source, IUnitId? target,
+            out IUnitId? effectSource, out IUnitId? effectTarget)
+        {
+            switch (skillActionTarget)
+            {
+                case AbilityActionTarget.FromSourceToTarget:
+                    effectTarget = target;
+                    effectSource = source;
+                    return;
+                case AbilityActionTarget.FromTargetToSource:
+                    effectTarget = source;
+                    effectSource = target;
+                    return;
+                case AbilityActionTarget.FromTargetToTarget:
+                    effectTarget = target;
+                    effectSource = target;
+                    return;
+                case AbilityActionTarget.FromSourceToSource:
+                    effectTarget = source;
+                    effectSource = source;
+                    return;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+    }
+}

NuclearAbilitySystem.Implementation/Features/Abilities/AbilityActionTarget.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+
+namespace Nuclear.AbilitySystem
+{
+    public sealed class AbilityContextHolder : IAbilityContextHolder
+    {
+        private readonly ICombatEventBus _combatEventsContext;
+        private readonly Dictionary<Type, IAbilityContext> _contexts = new();
+
+        public AbilityContextHolder(ICombatEventBus combatEventsContext)
+        {
+            _combatEventsContext = combatEventsContext;
+            _contexts.Add(typeof(ITimeAbilityContext), new TimeAbilityContext(0));
+            _contexts.Add(typeof(IDistanceBetweenUnitsAbilityContext), new DistanceBetweenUnitsAbilityContext(_combatEventsContext));
+        }
+        
+        private AbilityContextHolder(AbilityContextHolder abilityContextHolder)
+        {
+            _combatEventsContext = abilityContextHolder._combatEventsContext;
+            foreach (var (type, context) in abilityContextHolder._contexts)
+            {
+                _contexts.Add(type, context.DeepClone());
+            }
+        }
+        public T GetContext<T>() where T : IAbilityContext
+        {
+            return (T)_contexts[typeof(T)];
+        }
+
+        public IAbilityContextHolder DeepClone()
+        {
+            return new AbilityContextHolder(this);
+        }
+    }
+}

NuclearAbilitySystem.Implementation/Features/Abilities/AbilityContextHolder.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace Nuclear.AbilitySystem
+{
+    public sealed class CooldownAbilityCheck : ICooldownAbilityCheck
+    {
+        private readonly int _cooldown;
+        private int _lastCastTime;
+
+        public CooldownAbilityCheck(int cooldown, int? startValue = null)
+        {
+            _cooldown = cooldown;
+            _lastCastTime = -startValue ?? -cooldown;
+        }
+
+        public bool CanExecute(IUnitId source, IUnitId? target, IAbilityContextHolder context)
+        {
+            var timeContext = context.GetContext<ITimeAbilityContext>();
+            return GetCooldownTimer(timeContext) == 0;
+        }
+
+        public void Execute(IUnitId source, IUnitId? target, IAbilityContextHolder context)
+        {
+            var timeContext = context.GetContext<ITimeAbilityContext>();
+            _lastCastTime = timeContext.Time;
+        }
+
+        public int GetCooldownTimer(ITimeAbilityContext timeContext)
+        {
+            return Math.Max(0, _lastCastTime + _cooldown + 1 - timeContext.Time);
+        }
+
+        public IAbilityCheck DeepClone()
+        {
+            var result = new CooldownAbilityCheck(_cooldown);
+            result._lastCastTime = _lastCastTime;
+            return result;
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+namespace Nuclear.AbilitySystem
+{
+    public interface ICooldownAbilityCheck : IAbilityCheck
+    {
+        int GetCooldownTimer(ITimeAbilityContext context);
+    }
+}

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

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

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

@@ -0,0 +1,21 @@
+namespace Nuclear.AbilitySystem
+{
+    public sealed class TimeAbilityContext : ITimeAbilityContext
+    {
+        public TimeAbilityContext(int time)
+        {
+            Time = time;
+        }
+
+        public int Time { get; private set; }
+        public void NextTurn()
+        {
+            Time++;
+        }
+
+        public IAbilityContext DeepClone()
+        {
+            return new TimeAbilityContext(Time);
+        }
+    }
+}

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

@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+
+namespace Nuclear.AbilitySystem
+{
+    public sealed class Bully : IStatusEffect
+    {
+        private readonly IUnitId _unitId;
+        private ICombatEventBus? _combatEventBus;
+
+        public Bully(IUnitId unitId)
+        {
+            _unitId = unitId;
+        }
+        
+        public void Subscribe(ICombatEventBus combatEventBus)
+        {
+            _combatEventBus = combatEventBus;
+            _combatEventBus.Subscribe<AfterDamageEvent, DamageEventResult>(OnAfterDamage);
+        }
+
+        public void UnSubscribe()
+        {
+            if (_combatEventBus == null)
+            {
+                return;
+            }
+            _combatEventBus.Unsubscribe<AfterDamageEvent, DamageEventResult>(OnAfterDamage);
+            _combatEventBus = null;
+        }
+
+        public IStatusEffect DeepClone()
+        {
+            return new Bully(_unitId);
+        }
+
+        private DamageEventResult? OnAfterDamage(AfterDamageEvent @event, DamageEventResult? previousResult)
+        {
+            if (previousResult is {ContinueExecution: false})
+            {
+                return previousResult;
+            }
+            if (_combatEventBus == null)
+            {
+                throw new();
+            }
+            
+            if (EqualityComparer<IUnitId>.Default.Equals(_unitId, @event.Source.Id) ||
+                EqualityComparer<IUnitId>.Default.Equals(_unitId, @event.Target.Id))
+            {
+                return previousResult ?? new (true);
+            }
+
+            var unit = _combatEventBus.GetUnit(_unitId);
+            
+            unit.GetCombatFeature<IDamageable>().DealDamage(@event.Target, 1);
+            return new(false);
+        }
+    }
+}

NuclearAbilitySystem.Implementation/Features/Bully/Bully.cs

@@ -0,0 +1,21 @@
+using System.Linq;
+
+namespace Nuclear.AbilitySystem
+{
+    public static class BullyExtensions
+    {
+        public static bool IsBully(this IUnit unit)
+        {
+            return unit.GetCombatFeature<IStatusEffectsHolder>().StatusEffects.Any(s => s is Bully);
+        }
+        
+        public static void AddBullyStatusEffect(this IUnit unit)
+        {
+            if (!unit.IsBully())
+            {
+                unit.GetCombatFeature<IStatusEffectsHolder>().AddStatusEffect(
+                    new Bully(unit.Id));
+            }
+        }
+    }
+}

NuclearAbilitySystem.Implementation/Features/Bully/BullyExtensions.cs

@@ -0,0 +1,4 @@
+namespace Nuclear.AbilitySystem
+{
+    public record AttackCombatCommand(IUnitId AttackerId, IUnitId TargetId, int Damage, int Time) : ICombatCommand;
+}