/// <summary>
/// Computes the forward cost heuristics for the given state in the relaxed planning graph.
/// </summary>
/// <param name="state">Starting state.</param>
/// <param name="goalConditions">Goal conditions.</param>
/// <param name="evaluationStrategy">Evaluation strategy.</param>
/// <returns>Forward cost heuristic value from the specified state.</returns>
private double ComputeForwardCost(IState state, IConditions goalConditions, ForwardCostEvaluationStrategy evaluationStrategy)
{
IStateLayer previousStateLayer = null;
IStateLayer stateLayer = CreateLabeledStateLayer(state.GetRelaxedState());
ActionLayer actionLayer = new ActionLayer();
while (!stateLayer.Equals(previousStateLayer))
{
// check goal conditions
if (goalConditions.Evaluate(stateLayer.GetState()))
{
return(goalConditions.EvaluateOperatorPlanningGraphLabel(stateLayer.GetStateLabels(), evaluationStrategy));
}
// build new action layer
actionLayer.Clear();
foreach (var successor in RelaxedProblem.GetSuccessors(stateLayer.GetState()))
{
IOperator appliedOperator = successor.GetAppliedOperator();
double label = appliedOperator.ComputePlanningGraphLabel(stateLayer.GetStateLabels(), evaluationStrategy);
actionLayer.Add(new ActionNode(appliedOperator, label + appliedOperator.GetCost()));
}
// build new state layer
previousStateLayer = stateLayer;
stateLayer = CreateLabeledStateLayer(stateLayer, actionLayer);
}
// failure, solution cannot be found from the specified state
return(int.MaxValue);
}
// Use this for initialization
void Start()
{
FSM_action = GameManager.Instance.fsm_layer.a_layer;
_pickHolder = new GameObject("test");
_pickHolder.transform.parent = gameObject.transform;
picks = _pickHolder.AddComponent<Pickingclass>();
picks.name = "pick";
speed = 10.0f;
pickPOS.x = 0.0f;
pickPOS.y = 1.0f;
pickPOS.z = 0.0f;
}
/// <summary>
/// Constructs the state layer from the preceding state layer and action layer.
/// </summary>
/// <param name="sLayer">State layer.</param>
/// <param name="aLayer">Action layer.</param>
public StateLayer(StateLayer sLayer, ActionLayer aLayer) : this(sLayer)
{
foreach (var actionNode in aLayer)
{
var appliedOperator = (Operator)actionNode.Operator;
var operatorLabel = actionNode.Label;
foreach (var effect in appliedOperator.Effects)
{
if (effect.IsApplicable(sLayer.State))
{
var assignment = effect.GetAssignment();
StoreLabel(assignment, operatorLabel);
}
}
State = (RelaxedState)appliedOperator.Apply(State);
}
}
public void ActionDataTest()
{
var input = new ActionLayer
{
Hotkey = 'h',
Name = "Name",
Parent = new ResourceRef("Parent", 42),
Prerequisite = "Prerequisite",
Verbs = new[] { "verb1", "verb2" }
};
var serializer = new ActionLayerHandler();
var output = (ActionLayer)serializer.Reserialize(input);
Assert.That(output.Hotkey, Is.EqualTo(input.Hotkey));
Assert.That(output.Name, Is.EqualTo(input.Name));
Assert.That(output.Parent.Name, Is.EqualTo(input.Parent.Name));
Assert.That(output.Parent.Version, Is.EqualTo(input.Parent.Version));
Assert.That(output.Prerequisite, Is.EqualTo(input.Prerequisite));
Assert.That(output.Verbs, Is.EquivalentTo(input.Verbs));
}
/// <summary>
/// Constructs the state layer from the preceding state layer and action layer.
/// </summary>
/// <param name="sLayer">State layer.</param>
/// <param name="aLayer">Action layer.</param>
public StateLayer(StateLayer sLayer, ActionLayer aLayer) : this(sLayer)
{
foreach (var actionNode in aLayer)
{
var appliedOperator = actionNode.Operator;
var operatorLabel = actionNode.Label;
var newState = (IState)appliedOperator.Apply(State);
foreach (var atom in newState.GetPredicates())
{
if (sLayer.State.HasPredicate(atom))
{
// this atom is not a result of the operator application -> ignore
continue;
}
StoreLabel(atom, operatorLabel);
State.AddPredicate(atom);
}
}
}
void Awake()
{
m_layer = new MovementLayer();
a_layer = new ActionLayer();
}
/// <summary>
/// Creates the labeled state layer for the forward cost evaluation, from the previous state layer and the action layer.
/// </summary>
/// <param name="sLayer">Previous state layer.</param>
/// <param name="aLayer">Action layer.</param>
/// <returns>New state layer.</returns>
protected override IStateLayer CreateLabeledStateLayer(IStateLayer sLayer, ActionLayer aLayer)
{
return(new StateLayer((StateLayer)sLayer, aLayer));
}
public virtual void OnGUI()
{
EditorGUILayout.Space();
using (new EditorHelper.Box(true, 0))
{
using (new EditorHelper.Indent(-4))
using (new EditorHelper.Horizontal())
{
enabled = EditorGUILayout.Toggle(enabled, GUILayout.ExpandWidth(false), GUILayout.Width(15));
bool existed = Config.actionFold.ContainsKey(this);
if (!existed)
{
Config.actionFold[this] = true;
}
bool foldout = Config.actionFold[this];
GUIStyle gs = new GUIStyle(EditorStyles.foldout);
GUIStyleState normal = new GUIStyleState();
normal.textColor = new Color(226 / 255f, 100 / 255f, 226 / 255f, 1);
gs.fontStyle = FontStyle.Bold;
gs.normal = normal;
gs.focused = normal;
gs.hover = normal;
gs.active = normal;
gs.onActive = normal;
gs.onFocused = normal;
gs.onHover = normal;
gs.onNormal = normal;
foldout = GUILayout.Toggle(
foldout, $"{GetTitleText()}", gs,
GUILayout.ExpandWidth(false), GUILayout.Width(150)
);
if (Config.actionFold[this] != foldout)
{
Config.ResetCacheRectData();
}
Config.actionFold[this] = foldout;
if (!foldout)
{
return;
}
IsRemoved = GUILayout.Button("Remove", GUILayout.Width(80));
if (GUILayout.Button("Copy", GUILayout.Width(80)))
{
copiedAction = this;
}
IsPasted = GUILayout.Button("Paste", GUILayout.Width(80));
}
using (new EditorHelper.Indent(-3))
{
ActionLayer layer = ShowActionLayer();
layer = (ActionLayer)EditorGUILayout.EnumPopup("Active Layer", layer);
actionLayer = layer.ToString();
if (!Config.showSpawnerMode)
{
ActionName oldActionName = ShowActionName();
ActionName newActionName = (ActionName)EditorGUILayout.EnumPopup(
"Action Name", oldActionName);
actionName = newActionName.ToString();
IsActionChanged = !oldActionName.Equals(newActionName);
}
ActionTriggerCondition oldCondition = ShowTriggerCondition();
ActionTriggerCondition newCondition = (ActionTriggerCondition)EditorGUILayout.EnumPopup("Trigger Condition", oldCondition);
triggerCondition = newCondition.ToString();
if (newCondition == ActionTriggerCondition.Time)
{
waitTime = EditorGUILayout.FloatField("Activate at(s)", waitTime);
waitTime = Mathf.Max(0, waitTime);
}
else if (newCondition == ActionTriggerCondition.ByEvent)
{
eventId = EditorGUILayout.IntField("Event ID", eventId);
}
else if (newCondition == ActionTriggerCondition.OnWaveFinish)
{
waveOrder = EditorGUILayout.IntField("Wave Order", waveOrder);
waveOrder = Mathf.Max(1, waveOrder);
}
DrawGUI();
}
}
}
/// <summary>
/// Gets the best (lowest cost) relevant action node satisfying the given proposition during the FF evaluation.
/// </summary>
/// <param name="proposition">Proposition to satisfy.</param>
/// <param name="actionLayer">Action layer.</param>
/// <returns>Best relevant action node.</returns>
private static ActionNode GetBestRelevantActionNodeFF(IProposition proposition, ActionLayer actionLayer)
{
ActionNode bestActionNode = null;
foreach (var actionNode in actionLayer)
{
if (actionNode.Successors.Contains(proposition))
{
if (bestActionNode == null || actionNode.Operator.GetCost() < bestActionNode.Operator.GetCost())
{
bestActionNode = actionNode;
}
}
}
return(bestActionNode);
}
/// <summary> /// Creates the labeled state layer for the forward cost evaluation, from the previous state layer and the action layer. /// </summary> /// <param name="sLayer">Previous state layer.</param> /// <param name="aLayer">Action layer.</param> /// <returns>New state layer.</returns> protected abstract IStateLayer CreateLabeledStateLayer(IStateLayer sLayer, ActionLayer aLayer);
/// <summary>
/// Builds the relaxed planning graph and computes the FF heuristic value.
/// </summary>
/// <param name="state">Starting state.</param>
/// <param name="goalConditions">Goal conditions.</param>
/// <returns>FF cost heuristic value from the specified state.</returns>
private double ComputeFFCost(IState state, IConditions goalConditions)
{
// build an explicit relaxed planning graph
StateLayers.Clear();
ActionLayers.Clear();
StateLayers.Add(CreateFFStateLayer(state.GetRelaxedState()));
while (true)
{
// check goal conditions
IStateLayer stateLayer = StateLayers[StateLayers.Count - 1];
if (goalConditions.Evaluate(stateLayer.GetState()))
{
ActionLayers.Add(new ActionLayer {
CreateFFGoalActionNode(goalConditions, stateLayer.GetState())
});
break;
}
// build new action layer and the next state layer
ActionLayer actionLayer = new ActionLayer();
IState newState = stateLayer.GetState().Clone();
foreach (var successor in RelaxedProblem.GetSuccessors(stateLayer.GetState()))
{
IOperator appliedOperator = successor.GetAppliedOperator();
actionLayer.Add(CreateFFActionNode(appliedOperator, stateLayer.GetState()));
newState = appliedOperator.Apply(newState, true);
}
ActionLayers.Add(actionLayer);
StateLayers.Add(CreateFFStateLayer(newState));
}
// compute FF value
UnsatisfiedOnCurrentLayer.Clear();
UnsatisfiedOnNextLayer.Clear();
MarkedActionNodes.Clear();
var goalNode = ActionLayers[ActionLayers.Count - 1][0];
foreach (var proposition in goalNode.Predecessors)
{
UnsatisfiedOnCurrentLayer.Push(proposition);
}
for (int i = StateLayers.Count - 1; i > 0; --i)
{
IStateLayer nextStateLayer = StateLayers[i - 1];
ActionLayer currentActionLayer = ActionLayers[i - 1];
while (UnsatisfiedOnCurrentLayer.Count != 0)
{
IProposition proposition = UnsatisfiedOnCurrentLayer.Pop();
// 1.) try to satisfy the proposition by an idle arc to the next state layer
if (nextStateLayer.HasProposition(proposition))
{
UnsatisfiedOnNextLayer.Push(proposition);
continue;
}
// 2.) try to satisfy the proposition by a support action node
ActionNode relevantActionNode = GetBestRelevantActionNodeFF(proposition, currentActionLayer);
if (relevantActionNode != null)
{
MarkedActionNodes.Add(relevantActionNode.Operator);
foreach (var prevProposition in relevantActionNode.Predecessors)
{
UnsatisfiedOnNextLayer.Push(prevProposition);
}
}
}
UnsatisfiedSwapper = UnsatisfiedOnNextLayer;
UnsatisfiedOnNextLayer = UnsatisfiedOnCurrentLayer;
UnsatisfiedOnCurrentLayer = UnsatisfiedSwapper;
UnsatisfiedOnNextLayer.Clear();
}
// the result value is a sum of costs of marked action nodes
double result = 0;
foreach (var markedActionNode in MarkedActionNodes)
{
result += markedActionNode.GetCost();
}
return(result);
}
