public PlanWork(IReGoapAgent agent, IReGoapGoal blacklistGoal, Queue <ReGoapActionState> actions, Action <IReGoapGoal> callback) : this() { Agent = agent; BlacklistGoal = blacklistGoal; Actions = actions; Callback = callback; }
public ReGoapPlanWork(IReGoapAgent <T, W> agent, IReGoapGoal <T, W> blacklistGoal, Queue <ReGoapActionState <T, W> > actions, Action <IReGoapGoal <T, W> > callback) : this() { Agent = agent; BlacklistGoal = blacklistGoal; Actions = actions; Callback = callback; }
public override void Precalculations(IReGoapAgent goapAgent, ReGoapState goalState) { base.Precalculations(goapAgent, goalState); var bankPosition = agent.GetMemory().GetWorldState().Get <Vector3>("nearestBankPosition"); preconditions.Clear(); effects.Clear(); preconditions.Set("isAtPosition", bankPosition); effects.Set("isAtPosition", Vector3.zero); foreach (var pair in goalState.GetValues()) { if (pair.Key.StartsWith("collectedResource")) { var resourceName = pair.Key.Substring(17); preconditions.Set("hasResource" + resourceName, true); effects.Set("collectedResource" + resourceName, true); settings = new AddResourceToBankSettings { ResourceName = resourceName }; break; } } }
protected override void Awake() { agent = GetComponent <IReGoapAgent <string, object> >(); base.Awake(); goal.Set($"Has Role {type}", false); }
public override void Precalculations(IReGoapAgent goapAgent, ReGoapState goalState) { var newNeededResourceName = GetNeededResourceFromGoal(goalState); preconditions.Clear(); effects.Clear(); if (newNeededResourceName != null) { resource = agent.GetMemory().GetWorldState().Get <IResource>("nearest" + newNeededResourceName); if (resource != null) { resourcePosition = agent.GetMemory() .GetWorldState() .Get <Vector3>(string.Format("nearest{0}Position", newNeededResourceName)); preconditions.Set("isAtPosition", resourcePosition); // false preconditions are not supported //preconditions.Set("hasResource" + newNeededResourceName, false); effects.Set("hasResource" + newNeededResourceName, true); settings = new GatherResourceSettings { ResourcePosition = resourcePosition, Resource = resource }; } } base.Precalculations(goapAgent, goalState); }
public IReGoapGoal Plan(IReGoapAgent agent, IReGoapGoal blacklistGoal = null, Queue <ReGoapActionState> currentPlan = null, Action <IReGoapGoal> callback = null) { ReGoapLogger.Log("[ReGoalPlanner] Starting planning calculation for agent: " + agent); goapAgent = agent; Calculated = false; currentGoal = null; var possibleGoals = new List <IReGoapGoal>(); foreach (var goal in goapAgent.GetGoalsSet()) { if (goal == blacklistGoal) { continue; } goal.Precalculations(this); if (goal.IsGoalPossible()) //goal.GetPriority() > bestPriority && { possibleGoals.Add(goal); } } possibleGoals.Sort((x, y) => x.GetPriority().CompareTo(y.GetPriority())); while (possibleGoals.Count > 0) { currentGoal = possibleGoals[possibleGoals.Count - 1]; possibleGoals.RemoveAt(possibleGoals.Count - 1); var goalState = currentGoal.GetGoalState(); var leaf = (BGoapNode)astar.Run( new BGoapNode(this, goalState, null, null), goapAgent.GetMemory().GetWorldState(), settings.MaxIterations, settings.PlanningEarlyExit); if (leaf == null) { currentGoal = null; continue; } var path = leaf.CalculatePath(); if (currentPlan != null && currentPlan == path) { currentGoal = null; break; } currentGoal.SetPlan(path); break; } Calculated = true; if (callback != null) { callback(currentGoal); } if (currentGoal != null) { ReGoapLogger.Log(string.Format("[ReGoapPlanner] Calculated plan for goal '{0}', plan length: {1}", currentGoal, currentGoal.GetPlan().Count)); } else { ReGoapLogger.LogWarning("[ReGoapPlanner] Error while calculating plan."); } return(currentGoal); }
private void OnGUI() { if (Selection.activeGameObject != null) { agent = Selection.activeGameObject.GetComponent <IReGoapAgent>(); if (agent == null) { return; } } else { return; } DrawGrid(20, 0.2f, Color.gray); DrawGrid(100, 0.4f, Color.gray); UpdateGoapNodes(Selection.activeGameObject); DrawNodes(); ProcessNodeEvents(Event.current); ProcessEvents(Event.current); Repaint(); }
public override void Precalculations(IReGoapAgent goapAgent, ReGoapState goalState) { base.Precalculations(goapAgent, goalState); var workstationPosition = agent.GetMemory().GetWorldState().Get <Vector3>("nearestWorkstationPosition"); preconditions.Set("isAtPosition", workstationPosition); //effects.Set("isAtPosition", Vector3.zero); }
void Awake() { agent = GetComponent <IReGoapAgent <string, object> >(); foreach (var actionText in _actionTexts) { actionTexts.Add(actionText.actionName, actionText.text); } }
public override IReGoapActionSettings <string, object> GetSettings(IReGoapAgent <string, object> goapAgent, ReGoapState <string, object> goalState) { settings = new GenericGoToSettings { ObjectivePosition = GetWantedPositionFromState(goalState) }; return(base.GetSettings(goapAgent, goalState)); }
public override void Precalculations(IReGoapAgent goapAgent, ReGoapState goalState) { objectivePosition = goalState.Get <Vector3>("isAtPosition"); settings = new GenericGoToSettings { ObjectivePosition = objectivePosition }; base.Precalculations(goapAgent, goalState); }
public ReGoapPlanWork <T, W> Plan(IReGoapAgent <T, W> agent, IReGoapGoal <T, W> blacklistGoal, Queue <ReGoapActionState <T, W> > currentPlan, Action <IReGoapGoal <T, W> > callback) { var work = new ReGoapPlanWork <T, W>(agent, blacklistGoal, currentPlan, callback); lock (ReGoapPlannerThread <T, W> .WorksQueue) { ReGoapPlannerThread <T, W> .WorksQueue.Enqueue(work); } return(work); }
public PlanWork Plan(IReGoapAgent agent, IReGoapGoal blacklistGoal, Queue <ReGoapActionState> currentPlan, Action <IReGoapGoal> callback) { var work = new PlanWork(agent, blacklistGoal, currentPlan, callback); lock (worksQueue) { worksQueue.Enqueue(work); } threadEvents.Set(); return(work); }
public override IReGoapActionSettings <string, object> GetSettings(IReGoapAgent <string, object> goapAgent, ReGoapState <string, object> goalState) { settings = null; foreach (var pair in goalState.GetValues()) { if (pair.Key.StartsWith("collectedResource")) { var resourceName = pair.Key.Substring(17); settings = new AddResourceToBankSettings { ResourceName = resourceName }; break; } } return(settings); }
public override IReGoapActionSettings <string, object> GetSettings(IReGoapAgent <string, object> goapAgent, ReGoapState <string, object> goalState) { var newNeededResourceName = GetNeededResourceFromGoal(goalState); GatherResourceSettings wantedSettings = null; if (newNeededResourceName != null) { var wantedResource = agent.GetMemory().GetWorldState().Get("nearest" + newNeededResourceName) as IResource; if (wantedResource != null) { wantedSettings = new GatherResourceSettings { ResourcePosition = (Vector3)agent.GetMemory().GetWorldState() .Get(string.Format("nearest{0}Position", newNeededResourceName)), Resource = wantedResource }; } } return(wantedSettings); }
/* * private IEnumerable<IReGoapActionSettings> GenerateAllPossibleActions(IReGoapAgent goapAgent, BGoapState goalState, BGoapState genericsAssignement) { * * //this is not a real state, just a container for variables * BGoapState lockedInValues = new BGoapState(); * * BGoapState effects = staticEffects.Clone() as BGoapState; * List<IStateVarKey> freeEffects = new List<IStateVarKey>(); * //set effects * foreach (IStateVarKey iteratorKey in parametrizedEffects.Keys) * { * IStateVarKey key;// if key is a template, use it's appropriate child instead * if (iteratorKey is IGenericStateVarKeyTemplate) //appropriate child is such, that has generic argument in accordance with genericsAssignement * key = (iteratorKey as IGenericStateVarKeyTemplate).MakeGenericInstance(genericsAssignement.Get(genericParameters[iteratorKey])); * else * key = iteratorKey; * * IStateVarKey variableKey = parametrizedEffects[iteratorKey]; * if (goalState.HasKey(key)) * { * //set locked in values * if (lockedInValues.HasKey(variableKey)) * { * if (lockedInValues.ValueEqualsUntyped(variableKey, key, goalState)) * { //clash on variable value * continue; * } * } * else * { * lockedInValues.SetFromKeyUntyped(variableKey, key, goalState); * } * effects.SetFrom(key, goalState); * } * else * { * freeEffects.Add(key); * } * } * * BGoapState preconditions = staticPreconditions.Clone() as BGoapState; * * List<IStateVarKey> freePreconditions = new List<IStateVarKey>(); * foreach (IStateVarKey iteratorKey in parametrizedPreconditions.Keys) * { * IStateVarKey key;// if key is a template, use it's appropriate child instead * if (iteratorKey is IGenericStateVarKeyTemplate) //appropriate child is such, that has generic argument in accordance with genericsAssignement * key = (iteratorKey as IGenericStateVarKeyTemplate).MakeGenericInstance(genericsAssignement.Get(genericParameters[iteratorKey])); * else * key = iteratorKey; * * IStateVarKey variableKey = parametrizedPreconditions[iteratorKey]; * if (lockedInValues.HasKey(variableKey)) * { * preconditions.SetFromKeyUntyped(key, variableKey, lockedInValues); * } * else * { * freePreconditions.Add(key); * } * } * * if (freeEffects.Count + freePreconditions.Count > 0) //some variables need to be searched * { * foreach (BGoapState assignment in GetPossibleVariableCombinations(lockedInValues, goapAgent)) * { * BGoapState finalEffects = effects.Clone() as BGoapState; * BGoapState finalPreconditions = preconditions.Clone() as BGoapState; * foreach (IStateVarKey key in freeEffects) * { * IStateVarKey variableKey = parametrizedEffects[key]; * finalEffects.SetFromKeyUntyped(key, variableKey, assignment); * } * foreach (IStateVarKey key in freePreconditions) * { * IStateVarKey variableKey = parametrizedPreconditions[key]; * finalPreconditions.SetFromKeyUntyped(key, variableKey, assignment); * } * yield return new PrototypeActionSettings { effects = finalEffects, preconditions = finalPreconditions, agent = goapAgent }; * } * } * else * { //all variables locked in * yield return new PrototypeActionSettings { effects = effects, preconditions = preconditions, agent = goapAgent }; * } * * } */ public override IEnumerable <IReGoapActionSettings> MultiPrecalculations(IReGoapAgent goapAgent, BGoapState goalState) { foreach (BGoapState genericAssignments in GetPossibleGenericVariableCombinations(goapAgent)) { /// generate all possible generic assignemnts GoapStateEntry[] processedEffects = effects.Select(x => x.GenNongenericVersion(genericAssignments)).ToArray(); GoapStateEntry[] processedPreconditions = preconditions.Select(x => x.GenNongenericVersion(genericAssignments)).ToArray(); //lock in values that are in goal BGoapState lockedInValues = new BGoapState(); foreach (GoapStateEntry effect in processedEffects) { effect.LockInValues(lockedInValues, goalState); } //generate all actions available for given locked values foreach (BGoapState assignments in GetPossibleVariableCombinations(lockedInValues, goapAgent, genericAssignments)) { BGoapState combined = new BGoapState(assignments).Union(lockedInValues); //union should work here, as lockedInValues and assignemets should be mutually exclusive BGoapState generatedPreconditions = new BGoapState(); BGoapState generatedEffects = new BGoapState(); foreach (GoapStateEntry entry in processedPreconditions) { entry.AddSelfToState(generatedPreconditions, combined); } foreach (GoapStateEntry entry in processedEffects) { entry.AddSelfToState(generatedEffects, combined); } yield return(new PrototypeActionSettings { effects = generatedEffects, preconditions = generatedPreconditions, genericAssignments = genericAssignments, agent = goapAgent }); } } }
public virtual void PostPlanCalculations(IReGoapAgent <T, W> goapAgent) { agent = goapAgent; }
private void UpdateGoapNodes <T, W>(IReGoapAgent <T, W> agent) { if (nodes == null) { nodes = new List <ReGoapNodeEditor>(); } if (agentHelper == null || agent == null || !agent.IsActive() || agent.GetMemory() == null) { return; } nodes.Clear(); var width = 300f; var height = 70f; var nodePosition = new Vector2(0f, 60f); var nodeMiddleY = new Vector2(0f, height * 0.5f); ReGoapNodeEditor?previousNode = null; foreach (var goal in agent.GetGoalsSet()) { if (goal.GetGoalState() == null) { continue; } var text = string.Format("<b>GOAL</b> <i>{0}</i>\n", goal); foreach (var keyValue in goal.GetGoalState().GetValues()) { text += string.Format("<b>'{0}'</b> = <i>'{1}'</i>", keyValue.Key, keyValue.Value); } var style = nodeStyle; if (agent.IsActive() && agent.GetCurrentGoal() == goal) { style = activeStyle; } var newNode = DrawGenericNode(text, width, height, style, ref nodePosition); if (previousNode.HasValue) { var startPosition = previousNode.Value.Rect.max - nodeMiddleY - new Vector2(10f, 0f); var endPosition = newNode.Rect.min + nodeMiddleY + new Vector2(10f, 0f); Handles.DrawLine(startPosition, endPosition); } previousNode = newNode; } previousNode = null; nodePosition = new Vector2(0f, nodePosition.y + height + 10); height = 66; var maxHeight = height; var emptyGoal = agent.InstantiateNewState(); GoapActionStackData <T, W> stackData; stackData.agent = agent; stackData.currentState = agent.GetMemory().GetWorldState(); stackData.goalState = emptyGoal; stackData.next = null; stackData.settings = null; foreach (var action in agent.GetActionsSet()) { var curHeight = height; var text = string.Format("<b>POSS.ACTION</b> <i>{0}</i>\n", action.GetName()); text += "-<b>preconditions</b>-\n"; var preconditionsDifferences = agent.InstantiateNewState(); var preconditions = action.GetPreconditions(stackData); if (preconditions == null) { continue; } preconditions.MissingDifference(stackData.currentState, ref preconditionsDifferences); foreach (var preconditionPair in preconditions.GetValues()) { curHeight += 13; var color = "#004d00"; if (preconditionsDifferences.GetValues().ContainsKey(preconditionPair.Key)) { color = "#800000"; } text += string.Format("<color={2}>'<b>{0}</b>' = '<i>{1}</i>'</color>\n", preconditionPair.Key, preconditionPair.Value, color); } preconditionsDifferences.Recycle(); text += "-<b>effects</b>-\n"; foreach (var effectPair in action.GetEffects(stackData).GetValues()) { curHeight += 13; text += string.Format("'<b>{0}</b>' = '<i>{1}</i>'\n", effectPair.Key, effectPair.Value); } curHeight += 13; var proceduralCheck = action.CheckProceduralCondition(stackData); text += string.Format("<color={0}>-<b>proceduralCondition</b>: {1}</color>\n", proceduralCheck ? "#004d00" : "#800000", proceduralCheck); maxHeight = Mathf.Max(maxHeight, curHeight); nodeMiddleY = new Vector2(0f, curHeight * 0.5f); var newNode = DrawGenericNode(text, width, curHeight, possibleActionStyle, ref nodePosition); if (previousNode.HasValue) { var startPosition = previousNode.Value.Rect.max - nodeMiddleY - new Vector2(10f, 0f); var endPosition = newNode.Rect.min + nodeMiddleY + new Vector2(10f, 0f); Handles.DrawLine(startPosition, endPosition); } previousNode = newNode; } previousNode = null; nodePosition.x = 0; nodePosition.y += maxHeight + 10; height = 40; nodeMiddleY = new Vector2(0f, height * 0.5f); if (agent.GetCurrentGoal() != null) { foreach (var action in agent.GetStartingPlan().ToArray()) { var style = actionNodeStyle; if (action.Action.IsActive()) { style = activeActionNodeStyle; } var text = string.Format("<b>ACTION</b> <i>{0}</i>\n", action.Action.GetName()); var newNode = DrawGenericNode(text, width, height, style, ref nodePosition); if (previousNode.HasValue) { var startPosition = previousNode.Value.Rect.max - nodeMiddleY - new Vector2(10f, 0f); var endPosition = newNode.Rect.min + nodeMiddleY + new Vector2(10f, 0f); Handles.DrawLine(startPosition, endPosition); } previousNode = newNode; } } if (agent.GetMemory() != null) { nodePosition = new Vector2(0, nodePosition.y + height + 10); width = 500; height = 40; nodeMiddleY = new Vector2(0f, height * 0.5f); var nodeText = "<b>WORLD STATE</b>\n"; foreach (var pair in agent.GetMemory().GetWorldState().GetValues()) { nodeText += string.Format("'<b>{0}</b>' = '<i>{1}</i>'\n", pair.Key, pair.Value); height += 13; } DrawGenericNode(nodeText, width, height, worldStateStyle, ref nodePosition); } }
protected override IEnumerable <BGoapState> GetPossibleVariableCombinations(BGoapState lockInValues, IReGoapAgent goapAgent, BGoapState genericAssignments) { if (lockInValues.HasKey(itemVariable) && lockInValues.Get(itemVariable) == null) //this should be handled by place/drop item { yield break; } if (lockInValues.HasKey(itemVariable) && lockInValues.HasKey(itemTypeVariable)) //both item type and specific item are locked in { if (lockInValues.Get(itemVariable).sourceItem == lockInValues.Get(itemTypeVariable)) //check that this combination is valid { BGoapState assignment = new BGoapState(); assignment.Set(locationVariable, lockInValues.Get(itemVariable).positionCache); yield return(assignment); } } else if (lockInValues.HasKey(itemVariable) && lockInValues.Get(itemVariable) != null) //specific item locked in, fill in it's values { BGoapState assignment = new BGoapState(); assignment.Set(itemTypeVariable, lockInValues.Get(itemVariable).sourceItem); assignment.Set(locationVariable, lockInValues.Get(itemVariable).positionCache); yield return(assignment); } else if (lockInValues.HasKey(itemTypeVariable)) //item type locked in, fill in all possible items { DBItem requiredItemType = lockInValues.Get(itemTypeVariable); foreach (InGameItem item in (goapAgent.GetMemory() as GoapMemory).GetAvailableItemList()) { if (item.sourceItem == requiredItemType) { BGoapState assignment = new BGoapState(); assignment.Set(itemVariable, item); assignment.Set(locationVariable, item.positionCache); yield return(assignment); } } } yield break; }
public IReGoapGoal Plan(IReGoapAgent agent, IReGoapGoal blacklistGoal = null, Queue <ReGoapActionState> currentPlan = null, Action <IReGoapGoal> callback = null) { ReGoapLogger.Log("[ReGoalPlanner] Starting planning calculation for agent: " + agent); goapAgent = agent; Calculated = false; currentGoal = null; var possibleGoals = new List <IReGoapGoal>(); foreach (var goal in goapAgent.GetGoalsSet()) { if (goal == blacklistGoal) { continue; } goal.Precalculations(this); if (goal.IsGoalPossible()) //goal.GetPriority() > bestPriority && { possibleGoals.Add(goal); } } possibleGoals.Sort((x, y) => x.GetPriority().CompareTo(y.GetPriority())); while (possibleGoals.Count > 0) { currentGoal = possibleGoals[possibleGoals.Count - 1]; possibleGoals.RemoveAt(possibleGoals.Count - 1); var goalState = currentGoal.GetGoalState(); // can't work with dynamic actions, of course if (!settings.UsingDynamicActions) { var wantedGoalCheck = currentGoal.GetGoalState(); // we check if the goal can be archived through actions first, so we don't brute force it with A* if we can't foreach (var action in goapAgent.GetActionsSet()) { action.Precalculations(goapAgent, goalState); if (!action.CheckProceduralCondition(goapAgent, wantedGoalCheck)) { continue; } // check if the effects of all actions can archieve currentGoal var previous = wantedGoalCheck; wantedGoalCheck = new ReGoapState(); previous.MissingDifference(action.GetEffects(wantedGoalCheck), ref wantedGoalCheck); } // can't validate goal if (wantedGoalCheck.Count > 0) { currentGoal = null; continue; } } var leaf = (ReGoapNode)astar.Run( new ReGoapNode(this, goalState, null, null), goalState, settings.MaxIterations, settings.PlanningEarlyExit); if (leaf == null) { currentGoal = null; continue; } var path = leaf.CalculatePath(); if (currentPlan != null && currentPlan == path) { currentGoal = null; break; } currentGoal.SetPlan(path); break; } Calculated = true; if (callback != null) { callback(currentGoal); } if (currentGoal != null) { ReGoapLogger.Log(string.Format("[ReGoapPlanner] Calculated plan for goal '{0}', plan length: {1}", currentGoal, currentGoal.GetPlan().Count)); } else { ReGoapLogger.LogWarning("[ReGoapPlanner] Error while calculating plan."); } return(currentGoal); }
public IReGoapGoal <T, W> Plan(IReGoapAgent <T, W> agent, IReGoapGoal <T, W> blacklistGoal = null, Queue <ReGoapActionState <T, W> > currentPlan = null, Action <IReGoapGoal <T, W> > callback = null) { if (ReGoapLogger.Level == ReGoapLogger.DebugLevel.Full) { ReGoapLogger.Log("[ReGoalPlanner] Starting planning calculation for agent: " + agent); } goapAgent = agent; Calculated = false; currentGoal = null; var possibleGoals = new List <IReGoapGoal <T, W> >(); foreach (var goal in goapAgent.GetGoalsSet()) { if (goal == blacklistGoal) { continue; } goal.Precalculations(this); if (goal.IsGoalPossible()) { possibleGoals.Add(goal); } } possibleGoals.Sort((x, y) => x.GetPriority().CompareTo(y.GetPriority())); while (possibleGoals.Count > 0) { currentGoal = possibleGoals[possibleGoals.Count - 1]; possibleGoals.RemoveAt(possibleGoals.Count - 1); var goalState = currentGoal.GetGoalState(); // can't work with dynamic actions, of course if (!settings.UsingDynamicActions) { var wantedGoalCheck = currentGoal.GetGoalState(); // we check if the goal can be archived through actions first, so we don't brute force it with A* if we can't foreach (var action in goapAgent.GetActionsSet()) { action.Precalculations(goapAgent, goalState); if (!action.CheckProceduralCondition(goapAgent, wantedGoalCheck)) { continue; } // check if the effects of all actions can archieve currentGoal var previous = wantedGoalCheck; wantedGoalCheck = ReGoapState <T, W> .Instantiate(); previous.MissingDifference(action.GetEffects(wantedGoalCheck), ref wantedGoalCheck); } // can't validate goal if (wantedGoalCheck.Count > 0) { currentGoal = null; continue; } } //Utilities.ReGoapLogger.Log(string.Format("**** Goal: {0}, Expected State = ({1})", currentGoal.GetName(), goalState)); goalState = goalState.Clone(); var leaf = (ReGoapNode <T, W>)astar.Run( ReGoapNode <T, W> .Instantiate(this, goalState, null, null), goalState, settings.MaxIterations, settings.PlanningEarlyExit, debugPlan: agent.debugPlan); if (leaf == null) { currentGoal = null; continue; } var result = leaf.CalculatePath(); if (currentPlan != null && currentPlan == result) { currentGoal = null; break; } if (result.Count == 0) { currentGoal = null; continue; } currentGoal.SetPlan(result); break; } Calculated = true; if (callback != null) { callback(currentGoal); } if (currentGoal != null) { ReGoapLogger.Log(string.Format("[ReGoapPlanner] Calculated plan for goal '{0}', plan length: {1}", currentGoal, currentGoal.GetPlan().Count)); if (ReGoapLogger.Level == ReGoapLogger.DebugLevel.Full) { int i = 0; foreach (var action in currentGoal.GetPlan()) { ReGoapLogger.Log(string.Format("[ReGoapPlanner] {0}) {1}", i++, action.Action)); } } } else { ReGoapLogger.LogWarning("[ReGoapPlanner] Error while calculating plan."); } return(currentGoal); }
public virtual IReGoapActionSettings <T, W> GetSettings(IReGoapAgent <T, W> goapAgent, ReGoapState <T, W> goalState) { return(settings); }
public override bool CheckProceduralCondition(IReGoapAgent goapAgent, ReGoapState goalState, IReGoapAction next = null) { return(base.CheckProceduralCondition(goapAgent, goalState) && bag != null); }
protected override IEnumerable <BGoapState> GetPossibleVariableCombinations(BGoapState lockInValues, IReGoapAgent goapAgent, BGoapState genericAssignments) { BGoapState assignment = new BGoapState(); assignment.Set(locationVariable, genericAssignments.Get(table).positionCache); yield return(assignment); }
protected override IEnumerable <BGoapState> GetPossibleGenericVariableCombinations(IReGoapAgent goapAgent) { foreach (SmartObject so in (goapAgent.GetMemory() as GoapMemory).GetAvailableSoList()) { if (so is RPGSOTable) { BGoapState resultState = new BGoapState(); resultState.Set(table, so); yield return(resultState); } } }
public override void PostPlanCalculations(IReGoapAgent goapAgent) { }
public virtual bool CheckProceduralCondition(IReGoapAgent <T, W> goapAgent, ReGoapState <T, W> goalState, IReGoapAction <T, W> next = null) { return(true); }
public virtual void Precalculations(GoapActionStackData <T, W> stackData) { agent = stackData.agent; }
public override bool CheckProceduralCondition(IReGoapAgent <string, object> goapAgent, ReGoapState <string, object> goalState, IReGoapAction <string, object> next = null) { return(base.CheckProceduralCondition(goapAgent, goalState) && bag != null); }
public virtual void Precalculations(IReGoapAgent <T, W> goapAgent, ReGoapState <T, W> goalState) { agent = goapAgent; }