Initial Commit

Assets/Scripts/AI/FSM/IdleSystem.cs

@@ -0,0 +1,290 @@
+using System;
+using System.Collections.Generic;
+using Unity.Collections;
+using Unity.Entities;
+
+namespace AI.FSM
+{
+	public class IdleSystem : ComponentSystem
+	{
+		protected override void OnUpdate()
+		{
+			var toRemove = new NativeList<KeyValuePair<Entity, ComponentType>>(8, Allocator.Temp);
+			var toAdd = new List<ValueTuple<Entity, NativeArray<GoapActionReference>>>();
+			var actionValidation = GetComponentDataFromEntity<GoapActionValidation>();
+
+			Entities.ForEach(
+				(Entity entity, GoapAgentData agent, ref IdleInitializedState idleInitialized) =>
+				{
+					var hasValidatingFlag = false;
+					for (var j = 0; j < agent.Actions.Count; j++)
+					{
+						if (EntityManager.Exists(agent.Actions[j]) &&
+						    actionValidation.Exists(agent.Actions[j]) &&
+						    actionValidation[agent.Actions[j]].Validating)
+						{
+							hasValidatingFlag = true;
+							break;
+						}
+					}
+
+					if (!hasValidatingFlag)
+					{
+						//remove validation component as all elements have been validated
+						agent.Actions.ForEach(PostUpdateCommands.RemoveComponent<GoapActionValidation>);
+
+						var usableActions = new List<GoapActionReference>(agent.Actions.Count);
+						for (var j = 0; j < agent.Actions.Count; j++)
+						{
+							if (actionValidation[agent.Actions[j]].Valid)
+							{
+								usableActions.Add(new GoapActionReference { Entity = agent.Actions[j] });
+							}
+						}
+
+						var leaves = new List<Node>();
+						var worldState = new HashSet<(GoapKeys, object)>(agent.States);
+						var goal = new HashSet<(GoapKeys, object)>(agent.Goals);
+						var start = new Node(null, 0, worldState, new GoapActionReference { Entity = Entity.Null });
+						var success = buildGraph(start, leaves, usableActions, goal);
+
+						if (!success)
+						{
+							//no valid action path, reset to idle
+							PostUpdateCommands.RemoveComponent<IdleInitializedState>(entity);
+							PostUpdateCommands.AddComponent(entity, new IdleState());
+							return;
+						}
+
+						Node cheapest = null;
+						foreach (var leaf in leaves)
+						{
+							if (cheapest == null)
+							{
+								cheapest = leaf;
+							}
+							else
+							{
+								if (leaf.RunningCost < cheapest.RunningCost)
+								{
+									cheapest = leaf;
+								}
+							}
+						}
+
+						// get its node and work back through the parents
+						var result = new List<GoapActionReference>();
+						var n = cheapest;
+						while (n != null)
+						{
+							if (n.Action.Entity != Entity.Null)
+							{
+								result.Insert(0, n.Action); // insert the action in the front
+							}
+							n = n.Parent;
+						}
+
+						//start processing the action chain
+						PostUpdateCommands.RemoveComponent<IdleInitializedState>(entity);
+						PostUpdateCommands.AddComponent(entity, new PerformActionState());
+						var ar = new NativeArray<GoapActionReference>(result.Count, Allocator.Temp);
+						for (var j = 0; j < result.Count; j++)
+						{
+							if (j == 0)
+							{
+								PostUpdateCommands.AddComponent(result[j].Entity, new GoapActiveAction());
+							}
+							ar[j] = result[j];
+						}
+
+						toAdd.Add(new ValueTuple<Entity, NativeArray<GoapActionReference>>(entity, ar));
+					}
+				});
+
+			Entities.ForEach(
+				(Entity agentEntity, GoapAgentData agent, ref IdleState idleState) =>
+				{
+					for (var j = 0; j < agent.Actions.Count; j++)
+					{
+						var actionEntity = agent.Actions[j];
+						//only add validation if none is present
+						if (!actionValidation.Exists(actionEntity))
+						{
+							var validationData = new GoapActionValidation { Validating = true };
+							PostUpdateCommands.AddComponent(actionEntity, validationData);
+							//reset the action
+							PostUpdateCommands.SetComponent(actionEntity, new GoapAction());
+							if (EntityManager.HasComponent<GoapActiveAction>(actionEntity))
+							{
+								PostUpdateCommands.RemoveComponent<GoapActiveAction>(actionEntity);
+							}
+							if (EntityManager.HasComponent<GoapProcessingAction>(actionEntity))
+							{
+								PostUpdateCommands.RemoveComponent<GoapProcessingAction>(actionEntity);
+							}
+						}
+					}
+
+					PostUpdateCommands.RemoveComponent<IdleState>(agentEntity);
+					PostUpdateCommands.AddComponent(agentEntity, new IdleInitializedState());
+				});
+
+			for (var i = 0; i < toRemove.Length; i++)
+			{
+				EntityManager.RemoveComponent(toRemove[i].Key, toRemove[i].Value);
+			}
+
+			for (var i = 0; i < toAdd.Count; i++)
+			{
+				EntityManager.AddBuffer<GoapActionReference>(toAdd[i].Item1);
+				var ar = EntityManager.GetBuffer<GoapActionReference>(toAdd[i].Item1);
+				ar.CopyFrom(toAdd[i].Item2);
+				toAdd[i].Item2.Dispose();
+			}
+
+			toRemove.Dispose();
+		}
+
+		private bool buildGraph(Node parent, List<Node> leaves, List<GoapActionReference> usableActions, HashSet<(GoapKeys, object)> goal)
+		{
+			var foundOne = false;
+
+			// go through each action available at this node and see if we can use it here
+			for (var i = 0; i < usableActions.Count; i++)
+			{
+				var actionReference = usableActions[i];
+				var action = EntityManager.GetSharedComponentData<GoapSharedAction>(actionReference.Entity);
+
+				// if the parent state has the conditions for this action's preconditions, we can use it here
+				if (inState(action.Preconditions, parent.State))
+				{
+					// apply the action's effects to the parent state
+					var currentState = populateState(parent.State, action.Effects);
+					//Debug.Log(GoapAgent.prettyPrint(currentState));
+					var node = new Node(parent, parent.RunningCost + action.Cost, currentState, actionReference);
+
+					if (inState(goal, currentState))
+					{
+						// we found a solution!
+						leaves.Add(node);
+						foundOne = true;
+					}
+					else
+					{
+						// not at a solution yet, so test all the remaining actions and branch out the tree
+						var subset = actionSubset(usableActions, actionReference);
+						var found = buildGraph(node, leaves, subset, goal);
+						if (found)
+						{
+							foundOne = true;
+						}
+					}
+				}
+			}
+
+			return foundOne;
+		}
+
+		/**
+		 * Create a subset of the actions excluding the removeMe one. Creates a new set.
+		 */
+		private List<GoapActionReference> actionSubset(List<GoapActionReference> actions, GoapActionReference removeMe)
+		{
+			var subset = new List<GoapActionReference>();
+			foreach (var a in actions)
+			{
+				if (!a.Equals(removeMe))
+				{
+					subset.Add(a);
+				}
+			}
+			return subset;
+		}
+
+		/**
+		 * Check that all items in 'test' are in 'state'. If just one does not match or is not there
+		 * then this returns false.
+		 */
+		private bool inState(HashSet<(GoapKeys, object)> test, HashSet<(GoapKeys, object)> state)
+		{
+			var allMatch = true;
+			foreach (var t in test)
+			{
+				var match = false;
+				foreach (var s in state)
+				{
+					if (s.Equals(t))
+					{
+						match = true;
+						break;
+					}
+				}
+
+				if (!match)
+				{
+					allMatch = false;
+				}
+			}
+
+			return allMatch;
+		}
+
+		/**
+	 * Apply the stateChange to the currentState
+	 */
+		private HashSet<(GoapKeys, object)> populateState(HashSet<(GoapKeys, object)> currentState, HashSet<(GoapKeys, object)> stateChange)
+		{
+			var state = new HashSet<(GoapKeys, object)>();
+			// copy the KVPs over as new objects
+			foreach (var s in currentState)
+			{
+				state.Add((s.Item1, s.Item2));
+			}
+
+			foreach (var change in stateChange)
+			{
+				// if the key exists in the current state, update the Value
+				var exists = false;
+
+				foreach (var s in state)
+				{
+					if (s.Equals(change))
+					{
+						exists = true;
+						break;
+					}
+				}
+
+				if (exists)
+				{
+					state.RemoveWhere(kvp => kvp.Item1.Equals(change.Item1));
+					var updated = (change.Item1, change.Item2);
+					state.Add(updated);
+				}
+				// if it does not exist in the current state, add it
+				else
+				{
+					state.Add((change.Item1, change.Item2));
+				}
+			}
+
+			return state;
+		}
+
+		private class Node
+		{
+			public readonly GoapActionReference Action;
+			public readonly Node Parent;
+			public readonly float RunningCost;
+			public readonly HashSet<(GoapKeys, object)> State;
+
+			public Node(Node parent, float runningCost, HashSet<(GoapKeys, object)> state, GoapActionReference action)
+			{
+				Parent = parent;
+				RunningCost = runningCost;
+				State = state;
+				Action = action;
+			}
+		}
+	}
+}