public void GetFullDecompositionCost(ref int cost)
{
cost++;
if (base.qualifiers.Count == 0)
{
return;
}
if (this._taskQualifiers.Count > 0)
{
for (int i = 0; i < this._taskQualifiers.Count; i++)
{
TaskQualifier item = this._taskQualifiers[i];
if (!item.isDisabled && item != null)
{
item.GetFullDecompositionCost(ref cost);
}
}
return;
}
this._taskQualifiers.Clear();
for (int j = 0; j < base.qualifiers.Count; j++)
{
TaskQualifier taskQualifier = base.qualifiers[j] as TaskQualifier;
if (taskQualifier != null)
{
if (!taskQualifier.isDisabled)
{
taskQualifier.GetFullDecompositionCost(ref cost);
}
this._taskQualifiers.Add(taskQualifier);
}
}
}
public void GetDecompositionCostFromIndex(ref int cost, int index)
{
cost++;
if (base.qualifiers.Count == 0)
{
return;
}
if (this._taskQualifiers.Count > 0)
{
for (int i = index; i < this._taskQualifiers.Count; i++)
{
TaskQualifier item = this._taskQualifiers[i];
if (!item.isDisabled && item != null)
{
item.GetFullDecompositionCost(ref cost);
}
}
return;
}
for (int j = index; j < base.qualifiers.Count; j++)
{
TaskQualifier taskQualifier = base.qualifiers[j] as TaskQualifier;
if ((taskQualifier == null || !taskQualifier.isDisabled) && taskQualifier != null)
{
taskQualifier.GetFullDecompositionCost(ref cost);
}
}
}
public void RemoveAppliedEffects(IHTNContext context, ref List <PrimitiveTaskSelector> plan)
{
for (int i = 0; i < this._taskQualifiers.Count; i++)
{
TaskQualifier item = this._taskQualifiers[i];
if (!item.isDisabled)
{
item.RemoveAppliedEffects(context, ref plan);
}
}
}
private float DecomposeTask(DomainSelector domain, ITask parent, ITask task, IHTNContext context, ref List <PrimitiveTaskSelector> plan, ref int score, int scoreThreshold, out int localCost)
{
localCost = 0;
float single = TaskQualifier.TestPreconditions(task, context);
if (single <= 0f)
{
this.GetFullDecompositionCost(ref localCost);
return(single);
}
return(task.Decompose(domain, parent, context, ref plan, ref score, scoreThreshold, out localCost));
}
public float Decompose(DomainSelector domain, ITask parent, IHTNContext context, ref List <PrimitiveTaskSelector> plan, ref int score, int scoreThreshold, out int localCost)
{
int num;
localCost = 0;
if (parent != null && !this.Parents.Contains(parent))
{
this.Parents.Clear();
this.Parents.Add(parent);
}
if (!this._UpdateTasksQualifiers())
{
return(0f);
}
localCost++;
for (int i = 0; i < this._taskQualifiers.Count; i++)
{
TaskQualifier item = this._taskQualifiers[i];
if (!item.isDisabled)
{
int num1 = score + localCost;
if (num1 >= scoreThreshold)
{
this.RemovalAtFailedDecomposition(context, ref plan);
return(0f);
}
float single = item.Decompose(domain, this, context, ref plan, ref num1, scoreThreshold, out num);
if (this._decomposition == DecompositionType.One && single > 0f)
{
localCost += num;
return(1f);
}
if (this._decomposition == DecompositionType.All && single <= 0f)
{
this.RemovalAtFailedDecomposition(context, ref plan);
this.GetDecompositionCostFromIndex(ref localCost, i);
return(0f);
}
localCost += num;
}
}
if (this._decomposition == DecompositionType.All)
{
return(1f);
}
return(0f);
}
private bool _UpdateTaskQualifiers()
{
if (base.qualifiers.Count == 0)
{
return(false);
}
if (this._tasks.Count == 0)
{
for (int i = 0; i < base.qualifiers.Count; i++)
{
TaskQualifier item = base.qualifiers[i] as TaskQualifier;
if (item != null)
{
this._tasks.Add(item);
}
}
}
return(true);
}
public override IQualifier Select(IAIContext context, IList <IQualifier> qualifiers, IDefaultQualifier defaultQualifier)
{
int num;
if (!this._UpdateTaskQualifiers())
{
return(defaultQualifier);
}
for (int i = 0; i < this._tasks.Count; i++)
{
this._tasks[i].Reset();
}
IQualifier qualifier = defaultQualifier;
IHTNContext worldState = context as IHTNContext;
bool flag = false;
this._plan.Clear();
if (worldState != null)
{
int decompositionScore = worldState.DecompositionScore;
this.DecompositionScore = 0;
worldState.PlanResult = PlanResultType.NoPlan;
for (int j = 0; j < (int)worldState.WorldStateChanges.Length; j++)
{
if (worldState.WorldStateChanges[j].Count > 0)
{
worldState.WorldStateChanges[j].Clear();
}
}
int num1 = 0;
worldState.StartDomainDecomposition();
for (int k = 0; k < this._tasks.Count; k++)
{
TaskQualifier item = this._tasks[k];
if (!item.isDisabled)
{
int num2 = num1;
if (num1 >= decompositionScore)
{
worldState.PlanResult = PlanResultType.KeepCurrentPlan;
break;
}
else if (item.Decompose(this, null, worldState, ref this._plan, ref num2, decompositionScore, out num) <= 0f)
{
num = 0;
item.GetFullDecompositionCost(ref num);
num1 += num;
num1++;
}
else
{
num1 += num;
if (worldState.PlanState != PlanStateType.Running || num1 < decompositionScore)
{
flag = true;
worldState.DecompositionScore = num1;
for (int l = 0; l < qualifiers.Count; l++)
{
IQualifier item1 = qualifiers[l];
if (item1.Score(context) > 0f)
{
IConnectorAction connectorAction = item1.action as IConnectorAction;
if (connectorAction != null)
{
connectorAction.Select(context);
}
else
{
}
qualifier = item1;
}
}
break;
}
else
{
worldState.PlanResult = PlanResultType.KeepCurrentPlan;
break;
}
}
}
}
}
if (flag)
{
if (worldState != null)
{
worldState.HtnPlan.Clear();
for (int m = this._plan.Count - 1; m >= 0; m--)
{
this._plan[m].State = PrimitiveTaskStateType.NotStarted;
worldState.HtnPlan.Push(this._plan[m]);
}
if (Application.isEditor)
{
worldState.DebugPlan.Clear();
for (int n = 0; n < this._plan.Count; n++)
{
PrimitiveTaskSelector primitiveTaskSelector = this._plan[n];
worldState.DebugPlan.Add(primitiveTaskSelector);
}
}
if (worldState.PlanState != PlanStateType.Running)
{
worldState.PlanResult = PlanResultType.FoundNewPlan;
}
else
{
worldState.PlanResult = PlanResultType.ReplacedPlan;
}
worldState.PlanState = PlanStateType.Running;
foreach (KeyValuePair <Guid, Stack <IEffect> > appliedExpectedEffect in worldState.AppliedExpectedEffects)
{
Stack <IEffect> value = appliedExpectedEffect.Value;
value.Clear();
Pool.Free <Stack <IEffect> >(ref value);
}
worldState.AppliedExpectedEffects.Clear();
foreach (KeyValuePair <Guid, Stack <IEffect> > appliedEffect in worldState.AppliedEffects)
{
Stack <IEffect> effects = appliedEffect.Value;
effects.Clear();
Pool.Free <Stack <IEffect> >(ref effects);
}
worldState.AppliedEffects.Clear();
for (int o = 0; o < (int)worldState.WorldStateChanges.Length; o++)
{
Stack <WorldStateInfo> worldStateChanges = worldState.WorldStateChanges[o];
while (worldStateChanges.Count > 0 && worldStateChanges.Peek().Temporary)
{
worldStateChanges.Pop();
}
if (worldStateChanges.Count > 0)
{
WorldStateInfo worldStateInfo = worldStateChanges.Peek();
worldState.PreviousWorldState[o] = worldState.WorldState[o];
worldState.WorldState[o] = worldStateInfo.Value;
}
}
}
}
else if (worldState != null)
{
if (worldState.PlanState != PlanStateType.Running)
{
worldState.PlanResult = PlanResultType.NoPlan;
}
else
{
worldState.PlanResult = PlanResultType.KeepCurrentPlan;
}
}
return(qualifier);
}
