public void Filter()
{
var root = new Operator(new Predicate(gameObject.name, Terms, true)) as IOperator;
PartialDecomp = new TimelineDecomposition(root, new List <IPredicate>(), cntgs, dcntgs, stepConstraints, dstepConstraints, SubSteps, DSubSteps, orderings, dorderings, links, dlinks, fabVarStepMap);
var camOptions = new List <CamSchema>();
if (CameraHost == null)
{
CameraHost = GameObject.FindGameObjectWithTag("Cameras");
}
for (int i = 0; i < CameraHost.transform.childCount; i++)
{
var cameraSchema = CameraHost.transform.GetChild(i).GetComponent <CamAttributesStruct>().AsSchema();
camOptions.Add(cameraSchema);
}
if (LocationHost == null)
{
LocationHost = GameObject.FindGameObjectWithTag("LocationHost");
}
var locationMap = new Dictionary <string, Vector3>();
for (int i = 0; i < LocationHost.transform.childCount; i++)
{
var locationObj = LocationHost.transform.GetChild(i);
locationMap[locationObj.name] = locationObj.transform.position;
}
GroundDecomps = TimelineDecompositionHelper.Compose(0, PartialDecomp, camOptions, locationMap);
NumGroundDecomps = GroundDecomps.Count();
// foreach cndt, create a child gameobject and create a playable director and a control track. for each action in
}
/// <summary>
/// The Decomposition is composed of a sub-plan with at least sub-step at height "height"
/// </summary>
/// <returns>A list of decompositions with ground terms and where each sub-step is ground. </returns>
public static List <TimelineDecomposition> Compose(int height, TimelineDecomposition TD, List <CamSchema> camOptions, Dictionary <string, Vector3> locationMap)
{
///////////////////////////////////////
// START BY ADDING BINDINGS TO TERMS //
///////////////////////////////////////
var permList = new List <List <string> >();
foreach (Term variable in TD.Terms)
{
permList.Add(GroundActionFactory.TypeDict[variable.Type] as List <string>);
}
var decompList = new List <TimelineDecomposition>();
foreach (var combination in EnumerableExtension.GenerateCombinations(permList))
{
// Add bindings
var decompClone = TD.Clone() as TimelineDecomposition;
var termStringList = from term in decompClone.Terms select term.Variable;
var constantStringList = combination;
decompClone.AddBindings(termStringList.ToList(), constantStringList.ToList());
/////////////////////////////////////////////////////////
// PROPAGATE BINDINGS TO NONEQUALITY CONSTRAINTS
/////////////////////////////////////////////////////////
var newNonEqualities = new List <List <ITerm> >();
if (TD.NonEqualities == null)
{
TD.NonEqualities = new List <List <ITerm> >();
}
else
{
foreach (var nonequals in TD.NonEqualities)
{
var newNonEquals = new List <ITerm>();
newNonEquals.Add(decompClone.Terms.First(dterm => dterm.Variable.Equals(nonequals[0].Variable)));
newNonEquals.Add(decompClone.Terms.First(dterm => dterm.Variable.Equals(nonequals[1].Variable)));
newNonEqualities.Add(newNonEquals);
}
decompClone.NonEqualities = newNonEqualities;
if (!decompClone.NonEqualTermsAreNonequal())
{
continue;
}
}
// zip to dict
var varDict = EnumerableExtension.Zip(termStringList, constantStringList).ToDictionary(x => x.Key, x => x.Value);
/////////////////////////////////////////////////////////
// BINDINGS ARE ADDED. NEED TO APPLY BINDINGS TO SUBSTEPS
/////////////////////////////////////////////////////////
// Need to propagate bindings to sub-steps
foreach (var substep in decompClone.SubSteps)
{
var op = substep.Action as Operator;
foreach (var term in substep.Terms)
{
op.AddBinding(term.Variable, varDict[term.Variable]);
}
foreach (var precon in substep.Preconditions)
{
foreach (var term in precon.Terms)
{
if (!term.Bound)
{
var decompTerm = decompClone.Terms.First(dterm => dterm.Variable.Equals(term.Variable));
op.Terms.Add(term);
op.AddBinding(term.Variable, decompTerm.Constant);
}
}
}
foreach (var eff in substep.Effects)
{
foreach (var term in eff.Terms)
{
if (!term.Bound)
{
var decompTerm = decompClone.Terms.First(dterm => dterm.Variable.Equals(term.Variable));
op.Terms.Add(term);
op.AddBinding(term.Variable, decompTerm.Constant);
}
}
}
}
////////////////////////////////////////////////////////////////
// FILTER CANDIDATES FOR SUBSTEPS AND PASS BACK GROUNDED DECOMPS
////////////////////////////////////////////////////////////////
// legacy for fabula subplan. returns a list of decomp packages, whose second member is a map from fabula substep IDs to substeps
var fabulaGroundedDecompMap = TimelineDecomposition.FilterDecompCandidates(decompClone);
// foreach decomposition including a mapping from fabula substep IDs to substeps
foreach (Tuple <TimelineDecomposition, Dictionary <int, IPlanStep> > decompPackage in fabulaGroundedDecompMap)
{
// get candidates and ground for camera steps
var newGroundDecomps = TimelineDecompositionHelper.FilterTimelineDecompCandidates(TD, decompPackage, height, camOptions, locationMap);
foreach (var gdecomp in newGroundDecomps)
{
// This function updates the mapping from action variable names to step-variables, and repoints mapping to grounded fabula substep. These names used by camera shots.
gdecomp.UpdateActionVarMap(decompPackage.Second);
// Add new ground decomposition to map.
decompList.Add(gdecomp);
}
}
}
return(decompList);
}
