/// Returns whether another conflict was found
public bool ChooseNextConflict()
{
bool hasNext = this.nextConflicts.MoveNext();
if (hasNext)
{
this.conflict = this.nextConflicts.Current;
}
return(hasNext);
}
/// <summary>
/// Chooses an internal conflict to work on.
/// Resets conflicts iteration if it's used.
/// </summary>
public void ChooseConflict()
{
if (this.nodeConflicts.Count != 0)
{
this.conflict = this.nodeConflicts[0];
}
else
{
this.conflict = null;
}
}
} // Nonsense values until Init, just allocate move
public CFMCbsConstraint(CFMCbsConflict conflict, ProblemInstance instance, bool agentA)
{
Move move;
int agentNum;
int minTime;
if (agentA)
{
minTime = conflict.timeStepAgentA;
}
else
{
minTime = conflict.timeStepAgentB;
}
if (agentA)
{
move = conflict.agentAmove;
agentNum = instance.m_vAgents[conflict.agentAIndex].agentIndex;
this.move = new TimedMove(move, minTime);
}
else
{
move = conflict.agentBmove;
agentNum = instance.m_vAgents[conflict.agentBIndex].agentIndex;
this.move = new TimedMove(move, minTime);
}
this.agentNum = (byte)agentNum;
if (conflict.vertex)
{
this.move.direction = Move.Direction.NO_DIRECTION;
}
}
protected virtual void addToGlobalConflictCount(CFMCbsConflict conflict)
{
}
/// <summary>
/// Create Constraints from conflict
/// </summary>
/// <param name="node"></param>
/// <param name="doLeftChild"></param>
/// <param name="closedListHitChildCost"></param>
/// <returns></returns>
protected CFMCbsNode ConstraintExpand(CFMCbsNode node, bool doLeftChild, out int closedListHitChildCost)
{
CFMCbsConflict conflict = node.GetConflict();
int conflictingAgentIndex = doLeftChild? conflict.agentAIndex : conflict.agentBIndex;
CFMCbsNode.ExpansionState expansionsState = doLeftChild ? node.agentAExpansion : node.agentBExpansion;
CFMCbsNode.ExpansionState otherChildExpansionsState = doLeftChild ? node.agentBExpansion : node.agentAExpansion;
string agentSide = doLeftChild? "left" : "right";
int groupSize = node.GetGroupSize(conflictingAgentIndex);
closedListHitChildCost = -1;
if (expansionsState != CFMCbsNode.ExpansionState.EXPANDED)
// Agent expansion already skipped in the past or not forcing it from its goal - finally generate the child:
{
if (debug)
{
Debug.WriteLine("Generating " + agentSide + " child");
}
if (doLeftChild)
{
node.agentAExpansion = CFMCbsNode.ExpansionState.EXPANDED;
}
else
{
node.agentBExpansion = CFMCbsNode.ExpansionState.EXPANDED;
}
var newConstraint = new CFMCbsConstraint(conflict, instance, doLeftChild);
CFMCbsNode child = new CFMCbsNode(node, newConstraint, conflictingAgentIndex);
if (closedList.ContainsKey(child) == false)
{
bool success = child.Solve();
if (success == false)
{
return(null); // A timeout probably occured
}
return(child);
}
else
{
this.closedListHits++;
closedListHitChildCost = this.closedList[child].totalCost;
if (debug)
{
Debug.WriteLine("Child already in closed list!");
}
}
}
else
{
if (debug)
{
Debug.WriteLine("Child already generated before");
}
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="children"></param>
/// <param name="adoptBy">If not given, adoption is done by expanded node</param>
/// <returns>true if adopted - need to rerun this method, ignoring the returned children from this call, bacause adoption was performed</returns>
protected bool ExpandImpl(CFMCbsNode node, out IList <CFMCbsNode> children, out bool reinsertParent)
{
CFMCbsConflict conflict = node.GetConflict();
children = new List <CFMCbsNode>();
CFMCbsNode child;
reinsertParent = false;
int closedListHitChildCost;
bool leftSameCost = false; // To quiet the compiler
bool rightSameCost = false;
// Generate left child:
child = ConstraintExpand(node, true, out closedListHitChildCost);
if (child != null)
{
if (child == node) // Expansion deferred
{
reinsertParent = true;
}
else // New child
{
children.Add(child);
leftSameCost = child.totalCost == node.totalCost;
}
}
else // A timeout occured, or the child was already in the closed list.
{
if (closedListHitChildCost != -1)
{
leftSameCost = closedListHitChildCost == node.totalCost;
}
}
if (runner.ElapsedMilliseconds() > Constants.MAX_TIME)
{
return(false);
}
// Generate right child:
child = ConstraintExpand(node, false, out closedListHitChildCost);
if (child != null)
{
if (child == node) // Expansion deferred
{
reinsertParent = true;
}
else // New child
{
children.Add(child);
rightSameCost = child.totalCost == node.totalCost;
}
}
else // A timeout occured, or the child was already in the closed list.
{
if (closedListHitChildCost != -1)
{
rightSameCost = closedListHitChildCost == node.totalCost;
}
}
return(false);
}
