Add binary appraisals and intent utility helpers

Author: ApmeM

BrainAI.Tests/AITest.cs BrainAI.Tests/AI/AITest.csBrainAI.Tests/AITest.cs renamed to BrainAI.Tests/AI/AITest.cs

@@ -0,0 +1,69 @@
+namespace BrainAI.Tests
+{
+    using BrainAI.AI.UtilityAI;
+
+    using NUnit.Framework;
+
+    [TestFixture]
+    public class AndAppraisalTest
+    {
+        private class Context
+        {
+        }
+
+        [Test]
+        public void GetScore_NoAppraisals_False()
+        {
+            var context = new Context();
+
+            var and = new AndAppraisal<Context>();
+            var score = and.GetScore(context);
+
+            Assert.AreEqual(0, score);
+        }
+
+        [Test]
+        public void GetScore_AllAppraisalsHaveValues_True()
+        {
+            var context = new Context();
+
+            var and = new AndAppraisal<Context>(
+                new FixedAppraisal<Context>(1),
+                new FixedAppraisal<Context>(-1)
+            );
+            var score = and.GetScore(context);
+
+            Assert.AreEqual(1, score);
+        }
+
+        [Test]
+        public void GetScore_NotAllAppraisalsHaveValues_False()
+        {
+            var context = new Context();
+
+            var and = new AndAppraisal<Context>(
+                new FixedAppraisal<Context>(1),
+                new FixedAppraisal<Context>(-1),
+                new FixedAppraisal<Context>(0)
+            );
+            var score = and.GetScore(context);
+
+            Assert.AreEqual(0, score);
+        }
+
+        [Test]
+        public void GetScore_AllAppraisalsHaveNoValues_False()
+        {
+            var context = new Context();
+
+            var and = new AndAppraisal<Context>(
+                new FixedAppraisal<Context>(0),
+                new FixedAppraisal<Context>(0),
+                new FixedAppraisal<Context>(0)
+            );
+            var score = and.GetScore(context);
+
+            Assert.AreEqual(0, score);
+        }
+    }
+}

BrainAI.Tests/AI/UtilityAI/AndAppraisalTest.cs

@@ -0,0 +1,40 @@
+namespace BrainAI.Tests
+{
+    using BrainAI.AI.UtilityAI;
+
+    using NUnit.Framework;
+
+    [TestFixture]
+    public class NotAppraisalTest
+    {
+        private class Context
+        {
+        }
+
+        [Test]
+        public void GetScore_AppraisalHaveValues_False()
+        {
+            var context = new Context();
+
+            var and = new NotAppraisal<Context>(
+                new FixedAppraisal<Context>(-1)
+            );
+            var score = and.GetScore(context);
+
+            Assert.AreEqual(0, score);
+        }
+
+        [Test]
+        public void GetScore_AppraisalHaveNoValues_True()
+        {
+            var context = new Context();
+
+            var and = new NotAppraisal<Context>(
+                new FixedAppraisal<Context>(0)
+            );
+            var score = and.GetScore(context);
+
+            Assert.AreEqual(1, score);
+        }
+    }
+}

BrainAI.Tests/AI/UtilityAI/NotAppraisalTest.cs

@@ -0,0 +1,69 @@
+namespace BrainAI.Tests
+{
+    using BrainAI.AI.UtilityAI;
+
+    using NUnit.Framework;
+
+    [TestFixture]
+    public class OrAppraisalTest
+    {
+        private class Context
+        {
+        }
+
+        [Test]
+        public void GetScore_NoAppraisals_False()
+        {
+            var context = new Context();
+
+            var and = new OrAppraisal<Context>();
+            var score = and.GetScore(context);
+
+            Assert.AreEqual(0, score);
+        }
+
+        [Test]
+        public void GetScore_AllAppraisalsHaveValues_True()
+        {
+            var context = new Context();
+
+            var and = new OrAppraisal<Context>(
+                new FixedAppraisal<Context>(1),
+                new FixedAppraisal<Context>(-1)
+            );
+            var score = and.GetScore(context);
+
+            Assert.AreEqual(1, score);
+        }
+
+        [Test]
+        public void GetScore_NotAllAppraisalsHaveValues_False()
+        {
+            var context = new Context();
+
+            var and = new OrAppraisal<Context>(
+                new FixedAppraisal<Context>(1),
+                new FixedAppraisal<Context>(-1),
+                new FixedAppraisal<Context>(0)
+            );
+            var score = and.GetScore(context);
+
+            Assert.AreEqual(1, score);
+        }
+
+        [Test]
+        public void GetScore_AllAppraisalsHaveNoValues_False()
+        {
+            var context = new Context();
+
+            var and = new OrAppraisal<Context>(
+                new FixedAppraisal<Context>(0),
+                new FixedAppraisal<Context>(0),
+                new FixedAppraisal<Context>(0)
+            );
+            var score = and.GetScore(context);
+
+            Assert.AreEqual(0, score);
+        }
+    }
+}

BrainAI.Tests/AI/UtilityAI/OrAppraisalTest.cs

@@ -133,23 +133,74 @@ Selects the best Action from a list of Actions and its Appraisals attached to th
 - **LowestScoreReasoner<T>:** Selects action with minimum score
 - **Reasoner<T>:** Base class for custom implementations
 
-
 ## Appraisal
 Appraisals calculate and return a score which is used by the Reasoner to determine the action.
 
+- **IAppraisal<T>:** Base interface for custom implementations
 - **ActionAppraisal<T>:** Func wrapper for use as an Appraisal without having to create a subclass.
 - **FirstAppraisal<T>:** Returns first score that is above then threshold.
 - **FixedAppraisal<T>:** Always returns a fixed score.
 - **MaxAppraisal<T>:**  Return max score of child appraisals. For binary child appraisals (that returns 1 or 0) can be used as boolean 'OR' operator.
 - **MultiAppraisal<T>:** Scores by multiplying the score of all child Appraisals. For binary child appraisals (that returns 1 or 0) can be used as boolean 'AND' operator if threshold is set to 0.
 - **SumAppraisal<T>:** Scores if all child Appraisals score above the threshold. If threshold not specified - float.MinValue is used.
-- **IAppraisal<T>:** Base interface for custom implementations
 
+Additionaly there are a few helper Appraisals for binary operations. As an input those Appraisals take child's appraisals score and comparing them to 0 - treat it as false, other values treated as true:
+
+- **AndAppraisal** - return true(1) if all child appraisal scores treated as true, othervise false(0)
+- **OrAppraisal** - return true(1) if any child appraisal scores treated as true, othervise false(0)
+- **NotAppraisal** - return true(1) if child appraisal score treated as false, othervise false(0)
 
 ## Action
 The action that the AI executes when a specific consideration is selected.
 
-- **FirstScoreReasoner<T>:** Selects first action with score above the threshold
+- **FirstScoreReasoner<T>:** Selects first action with score above the threshold.
 - **HighestScoreReasoner<T>:** Selects the action with the highest score.
 - **LowestScoreReasoner<T>:** Selects the action with the lowest score.
 
+## Intents
+To execute lower level actions (like move to the point, or wait for attack animation) that is not eally related to decision making intents can be used.
+
+Example usecase:
+UtilityAI decide to move to specific point. But the move itself may take time, and during this time no other decisions should be made (unless something more urgent happens).
+
+To use intents the Context should implement **IIntentContainer<T>** and any low level action should implement **IIntent**
+
+To simplify integration with UtilityAI a few classes can be used:
+- **SetIntentAction** an action that sets specified IIntent to IIntentContainer.
+- **HasIntentAppraisal** checks that containser has Intent set, if yes - score is returned, othervise 0.
+- **UseIntentAction** an action that executes specified IIntent. Intent is cleared on Exit or when IIntent.Execute return true (finished).
+
+Example usage:
+
+``` csharp
+var reasoner = new FirstScoreReasoner<Unit>(1);
+// Intent phase. If there is an intent to act - intent will be executed.
+reasoner.Add(new HasIntentAppraisal<Unit>(2), new UseIntentAction<Unit>());
+// Decision phase. If there is no intent (previous one is finished, or not yet set) - find target to attack or move.
+reasoner.Add(new CanAttackAppraisal(), new SetIntentAction<Unit, AttackOpponentIntent>(new AttackIntent()));
+reasoner.Add(new CantAttackAppraisal(), new SetIntentAction<Unit, MoveIntent>(new MoveIntent()));
+```
+
+And MoveIntent can be like:
+
+``` csharp
+public class MoveIntent : IIntent<Unit>
+{
+    public void Enter(Unit unit)
+    {
+        unit.StartMoveAnimation();
+    }
+
+    public bool Execute(Unit unit)
+    {
+        // Recalculate unit position. It is done every tick.
+        unit.Position = unit.CalculateNewPosition();
+        // Finish move intent when unit at a target position.
+        return unit.Position == unit.MoveTarget;
+    }
+
+    public void Exit(Unit unit)
+    {
+    }
+}
+```

BrainAI.Tests/UtilityAITest.cs …inAI.Tests/AI/UtilityAI/UtilityAITest.csBrainAI.Tests/UtilityAITest.cs renamed to BrainAI.Tests/AI/UtilityAI/UtilityAITest.cs BrainAI.Tests/UtilityAITest.cs renamed to BrainAI.Tests/AI/UtilityAI/UtilityAITest.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+
+namespace BrainAI.AI.UtilityAI
+{
+    /// <summary>
+    /// Scores by checking each Appraisal score comparing it to 0.
+    /// Returns 1 if all the Appraisals scores were converted to 1.
+    /// Returns 0 othervise or if list of Appraisals is empty.
+    /// </summary>
+    public class AndAppraisal<T> : IAppraisal<T>
+    {
+        public readonly List<IAppraisal<T>> Appraisals = new List<IAppraisal<T>>();
+
+
+        public AndAppraisal()
+        {
+
+        }
+
+        public AndAppraisal(params IAppraisal<T>[] apparisals)
+        {
+            Appraisals.AddRange(apparisals);
+        }
+
+        public float GetScore(T context)
+        {
+            if (Appraisals.Count == 0)
+            {
+                return 0;
+            }
+
+            for (var i = 0; i < Appraisals.Count; i++)
+            {
+                if (Appraisals[i].GetScore(context) == 0)
+                {
+                    return 0;
+                }
+            }
+
+            return 1;
+        }
+    }
+}
+

BrainAI/AI/README.md

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+
+namespace BrainAI.AI.UtilityAI
+{
+    /// <summary>
+    /// Scores by checking each Appraisal score comparing it to 0.
+    /// Returns 1 if child Appraisal score were converted to 0.
+    /// Returns 0 othervise.
+    /// </summary>
+    public class NotAppraisal<T> : IAppraisal<T>
+    {
+        public readonly IAppraisal<T> ChildAppraisal;
+
+        public NotAppraisal(IAppraisal<T> apparisal)
+        {
+            ChildAppraisal = apparisal;
+        }
+
+        public float GetScore(T context)
+        {
+            if (ChildAppraisal.GetScore(context) == 0)
+            {
+                return 1;
+            }
+
+            return 0;
+        }
+    }
+}
+

BrainAI/AI/UtilityAI/Appraisals/BinaryAppraisals/AndAppraisal.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+
+namespace BrainAI.AI.UtilityAI
+{
+    /// <summary>
+    /// Scores by checking each Appraisal score comparing it to 0.
+    /// Returns 1 if any Appraisal scores were converted to 1.
+    /// Returns 0 othervise or if list of Appraisals is empty.
+    /// </summary>
+    public class OrAppraisal<T> : IAppraisal<T>
+    {
+        public readonly List<IAppraisal<T>> Appraisals = new List<IAppraisal<T>>();
+
+
+        public OrAppraisal()
+        {
+
+        }
+
+        public OrAppraisal(params IAppraisal<T>[] apparisals)
+        {
+            Appraisals.AddRange(apparisals);
+        }
+
+        public float GetScore(T context)
+        {
+            if (Appraisals.Count == 0)
+            {
+                return 0;
+            }
+
+            for (var i = 0; i < Appraisals.Count; i++)
+            {
+                if (Appraisals[i].GetScore(context) != 0)
+                {
+                    return 1;
+                }
+            }
+
+            return 0;
+        }
+    }
+}
+

BrainAI/AI/UtilityAI/Appraisals/BinaryAppraisals/NotAppraisal.cs

@@ -0,0 +1,17 @@
+namespace BrainAI.AI.UtilityAI
+{
+    public class HasIntentAppraisal<T> : IAppraisal<T> where T : IIntentContainer<T>
+    {
+        private readonly float score;
+
+        public HasIntentAppraisal(float score)
+        {
+            this.score = score;
+        }
+
+        public float GetScore(T context)
+        {
+            return context.Intent == null ? 0 : score;
+        }
+    }
+}