public void RemovePlanningNode(PlanningNode node, int t)
{
if (t > 0)
{
for (int i = _timeLevels[t - 1].mEdges.Count - 1; i >= 0; i--)
{
if (_timeLevels[t - 1].mEdges[i].to == node)
{
_timeLevels[t - 1].mEdges.RemoveAt(i);
}
}
}
for (int i = _timeLevels[t].mEdges.Count - 1; i >= 0; i--)
{
if (_timeLevels[t].mEdges[i].from == node)
{
_timeLevels[t].mEdges.RemoveAt(i);
}
}
for (int i = _timeLevels[t].mNodes.Count - 1; i >= 0; i--)
{
if (_timeLevels[t].mNodes[i] == node)
{
_timeLevels[t].mNodes.RemoveAt(i);
}
}
}
public void Connect(PlanningNode from, PlanningNode to)
{
PlanningEdge edge = new PlanningEdge(from, to);
mEdges.Add(edge);
edge.parent = this;
}
void UpdateNodeReward(ExpandingNode node, HexaPath path, double[,] entropy, PathPlanningGraph graph)
{
PlanningNode planNode = node.planningNode;
double[,] localEntropy = (double[, ])entropy.Clone();
node.instRwd = GetInstantReward(path, localEntropy, graph);
node.futrRwd = GetEstimatedMaxFutureReward(planNode, path, localEntropy, graph);
// update max val
node.maxVal = node.instRwd + node.futrRwd;
}
ExpandingNode NodeSpanning(ExpandingTree tree, ExpandingNode node, HexaPath path, double[,] entropy, PathPlanningGraph graph, HexagonalMap map)
{
PlanningNode planNode = node.planningNode;
List <ExpandingNode> newGenerated = new List <ExpandingNode>();
// find all child nodes
int curLevel = path.Length - 1;
if (curLevel < graph.planningLength - 1)
{
List <PlanningEdge> nextEdges = graph[curLevel].GetEdges(planNode);
List <PlanningEdge> .Enumerator enumEd = nextEdges.GetEnumerator();
while (enumEd.MoveNext())
{
ExpandingNode newNode = new ExpandingNode(enumEd.Current.to);
tree.AddToParent(newNode, node);
newGenerated.Add(newNode);
// if new node is already end level,
// set it as EXPANDED
if (curLevel == graph.planningLength - 2)
{
newNode.state = ExpandingNode.STATE.EXPANDED;
}
}
}
// set node to EXPANDED
node.state = ExpandingNode.STATE.EXPANDED;
//update the new generated node
List <ExpandingNode> .Enumerator e2 = newGenerated.GetEnumerator();
while (e2.MoveNext())
{
HexaPath tempPath = tree.GetPath(e2.Current);
double[,] tempEntropy = (double[, ])entropy.Clone();
UpdateNodeReward(e2.Current, tempPath, tempEntropy, graph);
}
//find max node
double maxNodeVal = 0.0;
ExpandingNode maxNode = null;
List <ExpandingNode> .Enumerator e3 = newGenerated.GetEnumerator();
while (e3.MoveNext())
{
if (e3.Current.maxVal > maxNodeVal)
{
maxNode = e3.Current;
maxNodeVal = e3.Current.maxVal;
}
}
return(maxNode);
}
public ExpandingNode(PlanningNode node)
{
planningNode = node;
parentNode = null;
childrenNodes = new List <ExpandingNode>();
minVal = 0.0;
maxVal = Double.MaxValue;
level = -1;
instRwd = 0.0;
futrRwd = 0.0;
state = STATE.NEW;
}
public int GetIndex(PlanningNode node)
{
for (int i = 0; i < mNodes.Count; i++)
{
if (mNodes[i] == node)
{
return(i);
}
}
return(-1);
}
public HexaPath FindPath(PathPlanningGraph graph, HexaPos start)
{
HexaPath path = null;
double currentScore = 0.0;
PlanningNode startNode = graph[0].GetNode(start);
ExpandingNode root = new ExpandingNode(startNode);
ExpandingTree expandingTree = new ExpandingTree(root);
Console.WriteLine("The number of complete expanding node is " + graph.GetExpandingNodeNumber());
bool exhaustivelyEnumerated = false;
bool stopCritera = false;
int counter = 0;
HexaPath maxPath = null;
double maxScore = 0.0;
do
{
path = ExpandToFindPath(expandingTree, graph, _localEntropy);
if (path == null)
{
stopCritera = true;
}
else
{
currentScore = ScorePath(_agent, _localEntropy, path);
if (currentScore > maxScore)
{
maxScore = currentScore;
maxPath = path;
}
}
//expandingTree.Draw("Expanding-Tree-" + counter.ToString());
counter++;
Console.WriteLine(counter + ", " + maxScore + ", " + expandingTree.nodeNum);
}while((iteratingOnce == false || exhaustivelyEnumerated == true) && (stopCritera == false));
//expandingTree.Draw("Expanding-Tree-N");
Console.WriteLine("The number of node expanded is " + expandingTree.nodeNum);
return(maxPath);
}
public PathPlanningGraph GetPathPlanningGraph(HexaPath path, int radius, HexaPos startPos)
{
int planningLength = path.Length;
PathPlanningGraph planningGraph = new PathPlanningGraph(planningLength);
// create vertex
for (int t = 0; t < planningLength; t++)
{
HexaPos pivot = path[t];
List <HexaPos> hexes = _topologicalGraph.GetMap().GetHexes(pivot.X, pivot.Y, radius, true);
List <HexaPos> .Enumerator e = hexes.GetEnumerator();
while (e.MoveNext())
{
Hex currentHex = _topologicalGraph.GetMap().GetHex(e.Current.X, e.Current.Y);
if (false == _topologicalGraph.GetMap().MapState.IsObstacle(currentHex))
{
PlanningNode node = new PlanningNode(e.Current);
planningGraph.AddPlanningNode(node, t);
}
}
}
// create edge
for (int t = 0; t < planningLength - 1; t++)
{
LevelPartite currentPartite = planningGraph[t];
LevelPartite nextPartite = planningGraph[t + 1];
List <PlanningNode> .Enumerator e1 = currentPartite.mNodes.GetEnumerator();
List <PlanningNode> .Enumerator e2 = nextPartite.mNodes.GetEnumerator();
while (e1.MoveNext())
{
while (e2.MoveNext())
{
if (_topologicalGraph.IsConnected(e1.Current.pos, e2.Current.pos))
{
currentPartite.Connect(e1.Current, e2.Current);
}
}
e2 = nextPartite.mNodes.GetEnumerator();
}
}
return(planningGraph);
}
public bool hasOut(PlanningNode node, int level)
{
if (level < 0 || level >= _planningLength - 1)
{
return(false);
}
List <PlanningEdge> .Enumerator e = _timeLevels[level].mEdges.GetEnumerator();
while (e.MoveNext())
{
if (e.Current.from == node)
{
return(true);
}
}
return(true);
}
public List <PlanningEdge> GetEdges(PlanningNode node)
{
List <PlanningEdge> edges = new List <PlanningEdge>();
List <PlanningEdge> .Enumerator e = mEdges.GetEnumerator();
while (e.MoveNext())
{
if (e.Current.from.pos.X == node.pos.X &&
e.Current.from.pos.Y == node.pos.Y)
{
edges.Add(e.Current);
}
}
return(edges);
}
public bool hasEdge(PlanningNode from, PlanningNode to)
{
if (to.parent.Level != from.parent.Level + 1)
{
return(false);
}
List <PlanningEdge> .Enumerator e = from.parent.mEdges.GetEnumerator();
while (e.MoveNext())
{
if (e.Current.from == from && e.Current.to == to)
{
return(true);
}
}
return(false);
}
ExpandingTree GetExclusiveExpandingTree(PathPlanningGraph graph, HexaPos start)
{
PlanningNode startNode = graph[0].GetNode(start);
ExpandingNode root = new ExpandingNode(startNode);
ExpandingTree expandingTree = new ExpandingTree(root);
bool quit = false;
for (int l = 0; l < graph.planningLength - 1; l++)
{
while (expandingTree.GetNewNodeCountByLevel(l) > 0)
{
quit = false;
for (int i = 0; i < expandingTree.nodeList.Count && quit == false; i++)
{
ExpandingNode currentNode = expandingTree.nodeList[i];
if (currentNode.level == l && currentNode.state == ExpandingNode.STATE.NEW)
{
PlanningNode planNode = currentNode.planningNode;
List <PlanningEdge> edges = graph[l].GetEdges(planNode);
List <PlanningEdge> .Enumerator e2 = edges.GetEnumerator();
while (e2.MoveNext())
{
ExpandingNode newNode = new ExpandingNode(e2.Current.to);
expandingTree.AddToParent(newNode, currentNode);
if (l == graph.planningLength - 2)
{
newNode.state = ExpandingNode.STATE.EXPANDED;
}
}
currentNode.state = ExpandingNode.STATE.EXPANDED;
quit = true;
}
}
}
}
return(expandingTree);
}
double GetEstimatedMaxFutureReward(PlanningNode node, HexaPath path, double[,] entropy, PathPlanningGraph graph)
{
int endLevel = graph.planningLength - 1;
int currentLevel = path.Length - 1;
if (endLevel == currentLevel)
{
return(0.0);
}
double maxFutureScore = 0.0;
// backtrack
//start from end level, init future score as 0
int nodeNum = 0;
double[] futureScore = null;
double[] instantScore = null;
double[] totalScore = null;
for (int l = endLevel; l > currentLevel; l--)
{
nodeNum = graph[l].mNodes.Count;
futureScore = new double[nodeNum];
instantScore = new double[nodeNum];
for (int i = 0; i < nodeNum; i++)
{
PlanningNode tempNode = graph[l].mNodes[i];
instantScore[i] = GetEstimation(_agent, entropy, tempNode.pos, _map);
if (l < endLevel)
{
List <PlanningEdge> edges = graph[l].GetEdges(tempNode);
List <PlanningEdge> .Enumerator e = edges.GetEnumerator();
while (e.MoveNext())
{
int j = graph[l + 1].GetIndex(e.Current.to);
if (totalScore[j] > futureScore[i])
{
futureScore[i] = totalScore[j];
}
}
}
else
{
futureScore[i] = 0.0;
}
}
totalScore = new double[nodeNum];
for (int i = 0; i < nodeNum; i++)
{
totalScore[i] = instantScore[i] + futureScore[i];
}
}
// estimate future reward
HexaPos currentPos = node.pos;
List <PlanningEdge> nextEdges = graph[currentLevel].GetEdges(node);
List <PlanningEdge> .Enumerator enumEdge = nextEdges.GetEnumerator();
while (enumEdge.MoveNext())
{
int j = graph[currentLevel + 1].GetIndex(enumEdge.Current.to);
if (totalScore[j] > maxFutureScore)
{
maxFutureScore = totalScore[j];
}
}
return(maxFutureScore);
}
public PlanningEdge(PlanningNode from, PlanningNode to)
{
_from = from;
_to = to;
}
public PathPlanningGraph GetPathPlanningGraph(HexaPos startPos, int planningLength)
{
PathPlanningGraph planningGraph = new PathPlanningGraph(planningLength);
List <HexaPos> currentSet = new List <HexaPos>();
List <HexaPos> nextSet = new List <HexaPos>();
currentSet.Add(startPos);
PlanningNode start_node = new PlanningNode(startPos);
planningGraph.AddPlanningNode(start_node, 0);
// create vertex
for (int t = 1; t < planningLength; t++)
{
List <HexaPos> .Enumerator e1 = currentSet.GetEnumerator();
nextSet.Clear();
while (e1.MoveNext())
{
HexaPos currentPos = e1.Current;
List <HexaPos> hexes = _topologicalGraph.GetMap().GetHexes(currentPos.X, currentPos.Y, 1, true);
List <HexaPos> .Enumerator e = hexes.GetEnumerator();
while (e.MoveNext())
{
Hex currentHex = _topologicalGraph.GetMap().GetHex(e.Current.X, e.Current.Y);
if (false == _topologicalGraph.GetMap().MapState.IsObstacle(currentHex))
{
if (false == planningGraph[t].hasNode(e.Current.X, e.Current.Y))
{
PlanningNode node = new PlanningNode(e.Current);
planningGraph.AddPlanningNode(node, t);
nextSet.Add(new HexaPos(e.Current.X, e.Current.Y));
}
}
}
}
currentSet.Clear();
foreach (HexaPos pos in nextSet)
{
currentSet.Add(pos);
}
}
// create edge
for (int t = 0; t < planningLength - 1; t++)
{
LevelPartite currentPartite = planningGraph[t];
LevelPartite nextPartite = planningGraph[t + 1];
List <PlanningNode> .Enumerator e1 = currentPartite.mNodes.GetEnumerator();
List <PlanningNode> .Enumerator e2 = nextPartite.mNodes.GetEnumerator();
while (e1.MoveNext())
{
while (e2.MoveNext())
{
if (_topologicalGraph.IsConnected(e1.Current.pos, e2.Current.pos))
{
currentPartite.Connect(e1.Current, e2.Current);
}
}
e2 = nextPartite.mNodes.GetEnumerator();
}
}
return(planningGraph);
}
public void AddPlanningNode(PlanningNode node, int t)
{
_timeLevels[t].AddPlanningNode(node);
}
public void AddPlanningNode(PlanningNode node)
{
mNodes.Add(node);
node.parent = this;
}