Fix more typing

RPGLibrary.Implementation/AttackCommand.cs

@@ -1,16 +1,15 @@
-using RPGLibrary.Abstraction.Character;
+using RPGLibrary.Abstraction.Services;
-using RPGLibrary.Abstraction.Services;
 using RPGLibrary.Command;
 
 namespace RPGLibrary.Implementation.Command
 {
-  public class AttackCommand : ICommand
+  public class AttackCommand : ICommand<Character>
   {
     private readonly Character[] _target;
     private readonly StrengthAttackData _attackData;
-    private readonly IDamageCalculator<StrengthAttackData> _damageCalculator;
+    private readonly IDamageCalculator<Character, StrengthAttackData> _damageCalculator;
 
-    public AttackCommand(Character[] target, StrengthAttackData attackData, IDamageCalculator<StrengthAttackData> damageCalculator)
+    public AttackCommand(Character[] target, StrengthAttackData attackData, IDamageCalculator<Character, StrengthAttackData> damageCalculator)
     {
       _target = target;
       _attackData = attackData;
@@ -18,11 +17,12 @@ namespace RPGLibrary.Implementation.Command
     }
 
 
-    public async IAsyncEnumerable<ICharacter> Execute()
+    public async IAsyncEnumerable<Character> Execute()
+
     {
       foreach (var character in _target)
       {
-        var damage = _damageCalculator.Calculate(character, (dynamic)_attackData);
+        var damage = _damageCalculator.Calculate(character, _attackData);
         var newCurrentHP = new HP(character.HP.Value - damage, character.HP.Maximum);
         yield return character.With(newCurrentHP);
       }

RPGLibrary.Implementation/Character.cs

@@ -25,7 +25,7 @@ namespace RPGLibrary.Implementation
       return $"{HP}, {Strength}, {Defense}";
     }
 
-    public ICharacter With(HP hp) => new Character(Name, hp, Strength, Defense);
+    public Character With(HP hp) => new Character(Name, hp, Strength, Defense);
   }
 
 }

RPGLibrary.Implementation/StrengthAttackData.cs

@@ -2,7 +2,6 @@
 
 namespace RPGLibrary.Implementation
 {
-  public record StrengthAttackData(ICharacter Source, StrengthAttribute Strength)
+  public record StrengthAttackData(ICharacter Source, StrengthAttribute Strength) : AttackData(Source, Strength);
-        : AttackData(Source, Strength);
 
 }

RPGLibrary.Implementation/StrengthBasedDamageCalculator.cs

@@ -1,15 +1,11 @@
-using RPGLibrary.Abstraction.Character;
+using RPGLibrary.Abstraction.Services;
-using RPGLibrary.Abstraction.Services;
 
 namespace RPGLibrary.Implementation
 {
-  public class StrengthBasedDamageCalculator : IDamageCalculator<StrengthAttackData>
+  public class StrengthBasedDamageCalculator : IDamageCalculator<Character, StrengthAttackData>
   {
-    public double Calculate(ICharacter target, StrengthAttackData attackData)
+    public double Calculate(Character target, StrengthAttackData attackData)
-        => CalculateInternal((dynamic)target, attackData);
+        => Math.Clamp(attackData.Strength.Value - target.Defense.Value, RPGConstants.MinDamage, RPGConstants.MaxDamage);
-
-    private double CalculateInternal(Character target, StrengthAttackData attackData)
-      => Math.Clamp(attackData.Strength.Value - target.Defense.Value, RPGConstants.MinDamage, RPGConstants.MaxDamage);
 
   }
 

RPGLibrary.Test/CommandExecuterTest.cs

@@ -16,13 +16,13 @@ namespace RPGLibrary.Test
       var attackData = new StrengthAttackData(source, source.Strength);
       var command = new AttackCommand(new[] { target }, attackData, damageCalculator);
       var commands = new[] { command };
-      var results = CommandExecuter.Singleton.Execute(commands, new CancellationToken());
+      var results = CommandExecuter.Singleton.Execute<Character>(commands, new CancellationToken());
       var actual = new List<Character>();
 
       await foreach (var resultOfCommand in results)
       {
         await foreach (var resultOfAttack in resultOfCommand)
-          actual.Add((Character)resultOfAttack);
+          actual.Add(resultOfAttack);
 
       }
 
@@ -45,13 +45,13 @@ namespace RPGLibrary.Test
       var command = new AttackCommand(target, attackData, damageCalculator);
 
       var commands = new[] { command };
-      var results = CommandExecuter.Singleton.Execute(commands, new CancellationToken());
+      var results = CommandExecuter.Singleton.Execute<Character>(commands, new CancellationToken());
       var actual = new List<Character>();
 
       await foreach (var resultOfCommand in results)
       {
         await foreach (var resultOfAttack in resultOfCommand)
-          actual.Add((Character)resultOfAttack);
+          actual.Add(resultOfAttack);
 
       }
 
@@ -78,14 +78,14 @@ namespace RPGLibrary.Test
       var commandC = new AttackCommand(target, attackData, damageCalculator);
 
       var commands = new[] { commandA, commandB, commandC };
-      var results = CommandExecuter.Singleton.Execute(commands, new CancellationToken());
+      var results = CommandExecuter.Singleton.Execute<Character>(commands, new CancellationToken());
 
       await foreach (var resultOfCommand in results)
       {
         var characterList = new List<Character>();
         await foreach (var r in resultOfCommand)
         {
-          characterList.Add((Character)r);
+          characterList.Add(r);
         }
 
         Assert.That(characterList[0].HP.Value, Is.EqualTo(32));

RPGLibrary/Command/CommandExecuter.cs

@@ -1,5 +1,4 @@
 using System.Runtime.CompilerServices;
-using RPGLibrary.Abstraction.Character;
 
 namespace RPGLibrary.Command
 {
@@ -12,8 +11,8 @@ namespace RPGLibrary.Command
 
     private CommandExecuter() { }
 
-    public async IAsyncEnumerable<IAsyncEnumerable<ICharacter>> Execute(
+    public async IAsyncEnumerable<IAsyncEnumerable<T>> Execute<T>(
-      IEnumerable<ICommand> commands,
+      IEnumerable<ICommand<T>> commands,
       [EnumeratorCancellation] CancellationToken ct)
     {
       foreach (var command in commands)

RPGLibrary/Command/ICommand.cs

@@ -1,10 +1,8 @@
-using RPGLibrary.Abstraction.Character;
+namespace RPGLibrary.Command
-
-namespace RPGLibrary.Command
 {
-  public interface ICommand
+  public interface ICommand<T>
   {
-    public IAsyncEnumerable<ICharacter> Execute();
+    public IAsyncEnumerable<T> Execute();
   }
 
 }

RPGLibrary/Services/IDamageCalculator.cs

@@ -2,10 +2,12 @@
 
 namespace RPGLibrary.Abstraction.Services
 {
-  public interface IDamageCalculator<TAttackData>
+  public interface IDamageCalculator<TCharacter, TAttackData>
-        where TAttackData : AttackData
+    where TCharacter : ICharacter
+    where TAttackData : AttackData
+
   {
-    double Calculate(ICharacter target, TAttackData attackData);
+    double Calculate(TCharacter target, TAttackData attackData);
   }
 
 }