public AIBinaryTreeNode rightNode; //reference to the rightNode child
/*
* AIBinaryTreeNode method is the constructor for this class. It will set up all the variables to their initial
* state
* Parameter: (AIPolygon)polygonToAdd is the polygon that this node will hold
* Return: none
*/
public AIBinaryTreeNode(AIPolygon polygonToAdd)
{
polygonBeingHeld = polygonToAdd;
free = false;
leftNode = null;
rightNode = null;
}
/*
* enqueue method will place a new node inside the Queue at the front
* Parameters: (AIPolygon)polygonToAdd is the polygon that needs to be added
* to a node to add into the queue
* Return: None
*/
public void enqueue(AIPolygon polygonToAdd)
{
AIPolygonNode newNode = new AIPolygonNode(polygonToAdd, front);
front = newNode;
size++;
}
/* addNode adds a node to this list in order according to its fTotalCost value
* Parameter: (AIPolygon) polygonToAdd is the polygon that will be held by the node
* (AIAgentAStarSearchNode) parentNodeToAdd is the parent of the node to be added
* (float) gCostToAdd is the getGFromStartingNode value to be stored in the node to be added
* Return: none
*/
public void addNode(AIPolygon polygonToAdd, AIAgentAStarSearchNode parentNodeToAdd, float gCostToAdd)
{
AIAgentAStarSearchNode newSearchNode = new AIAgentAStarSearchNode(polygonToAdd, parentNodeToAdd, gCostToAdd, goalPosition);
if (frontOfList == null)
{
newSearchNode.setNextNode(frontOfList);
frontOfList = newSearchNode;
numberOfNodesHeld++;
return;
}
AIAgentAStarSearchNode tempFront = frontOfList;
if (tempFront.compareTo(newSearchNode.getTotalCost()) > 0f)
{
newSearchNode.setNextNode(tempFront);
frontOfList = newSearchNode;
numberOfNodesHeld++;
return;
}
AIAgentAStarSearchNode tempBack = tempFront.getNextNode();
while (tempBack != null && tempBack.compareTo(newSearchNode.getTotalCost()) < 0f)
{
tempFront = tempBack;
tempBack = tempFront.getNextNode();
}
newSearchNode.setNextNode(tempFront.getNextNode());
tempFront.setNextNode(newSearchNode);
numberOfNodesHeld++;
}
/* updateNode updates the parent of a node and the gFromStartingNodeCost of a node
* Parameter: (AIAgentAStarSearchNode) nodeToUpdate is the node to be updated
* (AIAgentAStarSearchNode) newParentNode is the new parent of the node to be updated
* (float) newCost is the new gFromStartingNodeCost of the node to be updated
* Return: none
*/
public void updateNode(AIAgentAStarSearchNode nodeToUpdate, AIAgentAStarSearchNode newParentNode, float newCost)
{
AIPolygon temp = nodeToUpdate.getPolygon();
deleteNodeOfId(nodeToUpdate.getPolygon().getID());
addNode(temp, newParentNode, newCost);
}
/*
* mergeWithNeighbors will attempt to to merge all the AIPolygons it can from its neighbor list
* Parameter: (AIPolygon)polygonToMerge is the polygon that is going to attempt to merge with
* neighbors
* return: None
*/
void mergeWithNeighbors(AIPolygon polygonToMerge)
{
if (polygonToMerge != null)
{
int[] neighborHolder = polygonToMerge.getNeighbors(); //array hold the indices for the neighbors of polygonToMerge
for (int count = 0; count < neighborHolder.Length; count++)
{
if (polygonArray [neighborHolder [count]] != null)
{
AIPolygon mergedPolygon = polygonArray [polygonToMerge.getID()].mergeRegular(polygonArray [neighborHolder [count]], polygonToMerge.getID()); // this will attempt to merge two polygons and create a new AIPolygon
if (mergedPolygon != null) //mergedPolygon will be null if the merge was not accepted
{
if (mergedPolygon.isPolygonConvex() == true) // this will check to see if the new AIPolygon is convex or not
{
mergeQueue.deleteNodeOfID(neighborHolder [count]); // delete the old polygon from the neighbor list
deleteNeighborAtIndex(polygonToMerge.getID());
deleteNeighborAtIndex(neighborHolder [count]);
polygonArray [polygonToMerge.getID()] = mergedPolygon; // add new Polygon to the polygonArray
polygonArray [neighborHolder [count]] = null; // remove the last polygon that was merged
checkAndAddNeighborAtIndex(polygonToMerge.getID()); //finds the neighbors of the new Polygon
mergeQueue.enqueue(mergedPolygon); // adds the new Polygon to the mergedQueue
return;
}
}
}
}
}
}
/* getNodeOnList returns node from list that contains a specified polygon
* Parameter: (AIPolygon) polygonToCheck is the polygon being held by the node to be returned
* Return: (AIAgentAStarSearchNode)
* node on list that is holding polygonToCheck
*/
public AIAgentAStarSearchNode getNodeOnList(AIPolygon polygonToCheck)
{
AIAgentAStarSearchNode tempFront = frontOfList;
if (tempFront == null)
{
return(null);
}
if (doesIDMatch(polygonToCheck.getID(), tempFront.getPolygon().getID()) == true)
{
return(tempFront);
}
AIAgentAStarSearchNode tempBack = tempFront.getNextNode();
while ((tempBack != null) && (tempBack.getNextNode() != null) && (doesIDMatch(polygonToCheck.getID(), tempBack.getPolygon().getID()) == false))
{
tempFront = tempBack;
tempBack = tempFront.getNextNode();
}
if (tempBack == null)
{
return(null);
}
if (doesIDMatch(polygonToCheck.getID(), tempBack.getPolygon().getID()) == true)
{
return(tempBack);
}
return(null);
}
/*
* doMethodsForSplitting method will call all the methods for splitting the the polygons with an object\
* Parameter: (AIObjects) objectToSplitWith is the object that the polygons need to be split by
* (ref int) polygonToSplitCount is the number of polygons that need to be split
*/
void doMethodsForSplitting(AIObjects objectToSplitWith, ref int polygonToSplitCount)
{
int[] indicesWithObject = markPolygonsThatSplitWithObject(ref polygonToSplitCount, objectToSplitWith);
AIPolygon[] splitingPolygons = getPolygonsThatWillBeSplit(indicesWithObject, polygonToSplitCount);
AIPolygon[] tempArray = splitPolygons(splitingPolygons, objectToSplitWith);
if (tempArray == null)
{
return;
}
AIPolygon[] newArray = new AIPolygon[tempArray.Length + polygonArray.Length - polygonToSplitCount];
int newArrayCount = 0;
for (int count = 0; count < polygonArray.Length; count++)
{
if (indicesWithObject[count] != 1)
{
newArray[newArrayCount] = new AIPolygon(polygonArray[count].getVertices(), newArrayCount);
newArrayCount++;
}
}
for (int count = 0; count < tempArray.Length; count++)
{
newArray[newArrayCount] = new AIPolygon(tempArray[count].getVertices(), newArrayCount);
newArrayCount++;
}
setNewArray(newArray);
}
/* updateNode updates the parent of a node and the gFromStartingNodeCost of a node
* Parameter: (AIDynBiDirOpNode) nodeToUpdate is the node to be updated
* (AIDynBiDirOpNode) newParentNode is the new parent of the node to be updated
* (float) newCost is the new gFromStartingNodeCost of the node to be updated
* Return: none
*/
public void updateNode(AIDynBiDirOpNode nodeToUpdate, AIDynBiDirOpNode newParentNode, float newCost)
{
AIPolygon temp = nodeToUpdate.getPolygon();
deleteNodeOfId(nodeToUpdate.getPolygon().getID());
addNode(temp, newParentNode, newCost);
}
/*
* copyAndSrink method will take a a array and take all the polygons that are not null and place them into a new array
* Parameter: (AIPolygon[[]) polygonArrayToCopy is the array that needs to be shrunk
* Return: none
*/
public void copyAndSrink(AIPolygon[] polygonArrayToCopy)
{
int counter = 0;
for (int count = 0; count < polygonArrayToCopy.Length; count++)
{
if (polygonArray[count] != null)
{
counter++;
}
}
AIPolygon[] tempArray = new AIPolygon[counter];
for (int count = 0, tempCounter = 0; count < polygonArrayToCopy.Length; count++)
{
if (polygonArrayToCopy [count] != null)
{
tempArray [tempCounter] = new AIPolygon(polygonArrayToCopy [count].getVertices(), tempCounter);
tempCounter++;
}
}
polygonArray = tempArray;
checkHasAgent();
checkHasGoal();
}
/*
* makeNewArray method will maek a new array of Polygons from the old array of Polygon and the new
* AIPolygonQueue holding the polygons that were resently split
* Parameter: (int)placeToAddNewPolygons is the place that the old polygon was at before it was split
* (AIPolygonQueue)tempQueue is the AIPolygonQueue holding the new polygons
* Return: none
*/
AIPolygon[] makeNewArray(int placeToAddNewPolygons, AIPolygonQueue tempQueue, float agentRadius, AIPolygon[] arraySomething)
{
AIPolygon[] newArray;
int placeToAdd;
if (arraySomething != null)
{
newArray = new AIPolygon[arraySomething.Length + tempQueue.getSize()]; //new arry of polygons
placeToAdd = 0;
for (int count = 0; count < arraySomething.Length; count++) //add polygons from the old array until the position of the polygon that has been split
{
if (polygonArray[count] != null)
{
newArray[placeToAdd] = new AIPolygon(arraySomething [count].getVertices(), placeToAdd);
placeToAdd++;
}
}
for (int count = tempQueue.getSize() - 1; count >= 0; count--) //add polygons that is in tempQueue
{
newArray [placeToAdd] = new AIPolygon(tempQueue.getPolygonAtIndex(count).getVertices(), placeToAdd);
placeToAdd++;
}
return(newArray);
}
newArray = new AIPolygon[tempQueue.getSize()];
placeToAdd = 0;
for (int count = tempQueue.getSize() - 1; count >= 0; count--) //add polygons that is in tempQueue
{
newArray [placeToAdd] = new AIPolygon(getVerties(tempQueue.getPolygonAtIndex(count).getVertices()), placeToAdd);
placeToAdd++;
}
return(newArray);
}
/*
* addAfter will make a new polygon and add it right after the node being passed in
* Parameter: (AIPolygon)polygonToAdd is the polygon for the new node
* (AIFringeSearchNode)parentNode is the node that will be the parent of this node
* (float)gCostToAdd is the cost to get to this node
* Return: none
*/
public void addAfter(AIPolygon polygonToAdd, AIFringeSearchNode nodeToAddAfter, float gCostToAdd)
{
AIFringeSearchNode tempNode = new AIFringeSearchNode(polygonToAdd, nodeToAddAfter, gCostToAdd, goalPosition);
tempNode.setNextNode(nodeToAddAfter.getNextNode());
nodeToAddAfter.setNextNode(tempNode);
numberOfNodesHeld++;
}
/*
* enqueue method will place a node in the front of the list
* Parameter: (AIPolygon)polygonToAdd is the polygon for the new node
* (AIFringeSearchNode)parentNode is the node that will be the parent of this node
* (float)gCostToAdd is the cost to get to this node
* Return: none
*/
public void enqueue(AIPolygon polygonToAdd, AIFringeSearchNode parentNode, float gCostToAdd)
{
AIFringeSearchNode tempNode = new AIFringeSearchNode(polygonToAdd, parentNode, gCostToAdd, goalPosition);
tempNode.setNextNode(frontOfList);
frontOfList = tempNode;
numberOfNodesHeld++;
}
/*
* setNewArray will take in an array of AIPolygon and the number of polygons added to that array and
* make a new array then set polygonArray to the new array
* Parameter: (AIPolygon[])newArray is the array of polygons that needs to be added to a new array
* (int)numberOfPolygons is the number of polygons that is being held by the array that
* has been passed in
*/
void setNewArray(AIPolygon[] newArrays)
{
AIPolygon[] tempArray = new AIPolygon[newArrays.Length];
for (int count = 0; count < tempArray.Length; count++)
{
tempArray [count] = newArrays [count];
}
polygonArray = tempArray;
}
/* AIAgentAStarSearchNode method is a constructor for this class.
* Parmeters: (AIPolygon) polygonToAdd is the polygon held by this node
* (AIAgentAStarSearchNode) parentToAdd is the parent of this node
* (float) gCostToAdd is the gFromStartingNode value for this node
* (Vector3) goalPositionToAdd is the goalPosition for this instance
*/
public AIAgentAStarSearchNode(AIPolygon polygonToAdd, AIAgentAStarSearchNode parentToAdd, float gCostToAdd, Vector3 goalPositionToAdd)
{
polygonBeingHeld = polygonToAdd;
parentNode = parentToAdd;
gFromStartingNode = gCostToAdd;
nextNode = null;
goalPosition = new Vector3(goalPositionToAdd.x, goalPositionToAdd.y, goalPositionToAdd.z);
calculateCost(gFromStartingNode, goalPosition);
}
/* addNode adds a node to this list in order according to its fTotalCost value
* Parameter: (AIPolygon) polygonToAdd is the polygon that will be held by the node
* (AIAgentAStarSearchNode) parentNodeToAdd is the parent of the node to be added
* (float) gCostToAdd is the getGFromStartingNode value to be stored in the node to be added
* Return: none
*/
public void addNode(AIPolygon polygonToAdd, AIAgentAStarSearchNode parentNodeToAdd, float gCostToAdd)
{
AIAgentAStarSearchNode newSearchNode = new AIAgentAStarSearchNode(polygonToAdd, parentNodeToAdd, gCostToAdd, goalPosition);
inList [polygonToAdd.getID()] = true;
indicesArray [polygonToAdd.getID()] = numberOfNodesHeld;
heap [numberOfNodesHeld] = newSearchNode;
shiftUp(numberOfNodesHeld);
numberOfNodesHeld++;
}
/*
* addPolygon will make a new polygon using a Vector3[] called vertices. It will add it to the array polygonArray
* and then it will check to see if any new neighbors can be made with this new polygon
* Parameter: (Vector3[])vertices is the vertices array that will be given to a new polygon object to be used
* as its vertices
* Return: None
*/
public void addPolygon(Vector3[] vertices)
{
Vector3[] temp = new Vector3[vertices.Length];
for (int count = 0; count < vertices.Length; count++)
{
temp [count] = new Vector3(vertices [count].x, vertices [count].y, vertices [count].z); //copy the vertices points into a new Vector3
}
polygonArray [polygonsHeld] = new AIPolygon(temp, polygonsHeld); //make the new AIPolygon
checkNeighbors(); //checks the Neighbors to see if a polygon needs to add this polygon as a neighbor
polygonsHeld++;
}
int epsion = 4; // used for the weight
/* AIDynamicWeightedSearchNode method is a constructor for this class.
* Parmeters: (AIPolygon) polygonToAdd is the polygon held by this node
* (AIAgentAStarSearchNode) parentToAdd is the parent of this node
* (float) gCostToAdd is the gFromStartingNode value for this node
* (Vector3) goalPositionToAdd is the goalPosition for this instance
* (flaot)HToAdd is the H value from the starting node
* (int) nodesExpandedToAdd is how many nodes were expanded to get to this nod
*/
public AIDynamicWeightedSearchNode(AIPolygon polygonToAdd, AIDynamicWeightedSearchNode parentToAdd, float gCostToAdd, Vector3 goalPositionToAdd, float HToAdd, int nodesExpandedToAdd)
{
polygonBeingHeld = polygonToAdd;
parentNode = parentToAdd;
gFromStartingNode = gCostToAdd;
nextNode = null;
goalPosition = new Vector3(goalPositionToAdd.x, goalPositionToAdd.y, goalPositionToAdd.z);
N = HToAdd / AINavigationMeshAgent.polygonLengthMin;
nodesExpandedForThis = nodesExpandedToAdd;
calculateCost(gFromStartingNode, goalPosition);
}
/*
* getFinalPathStartingWithNodes method will return a final path array that starts the the node
* containing the polygon being sent in
* Parameter: (AIPolygon) polygonToStartWith is the polygon that is in the node the caller wants the
* final path array to start with
* Return: (AIPolygon[])
* the final path array starting with the node containing the polygon being passed in
*/
public AIPolygon[] getFinalPathStartingWithNode(AIPolygon polygonToStartWith)
{
AIAgentAStarSearchNode tempNode = closedList[polygonToStartWith.getID()];
if (tempNode == null)
{
return(null);
}
finalSolutionStart = tempNode;
return(getFinalPath());
}
/*
* getPolygonsThatWillBeSplit method will gather all the polygons that are going to be split
* Parameter: (int[]) indicesWithObject is the array of indices that hold the polygons that need to be split
* (int) polygonToSplitCount is the number of polygons that are going to be split
* Return: (AIPolygon[])
* an array of polygons that will be split
*/
AIPolygon[] getPolygonsThatWillBeSplit(int[] indicesWithObject, int polygonToSplitCount)
{
AIPolygon[] splitingPolygons = new AIPolygon[polygonToSplitCount];
for (int count = 0, count2 = 0; count < polygonArray.Length; count++)
{
if (indicesWithObject[count] == 1)
{
splitingPolygons[count2] = polygonArray[count];
count2++;
}
}
return(splitingPolygons);
}
/* The method isAllVerticesDifferent checks if all the vertices in the Vector3[] vericesToCheck array are
* different
* Parameters: Vector3[] verticesToCheck - array of vertices to be checked
* Return: bool
* true if the vertices are all different, false otherwise
*/
bool isAllVerticesDifferent(Vector3[] verticesToCheck)
{
for (int count1 = 0; count1 < verticesToCheck.Length; count1++)
{
for (int count2 = count1 + 1; count2 < verticesToCheck.Length; count2++)
{
if (AIPolygon.checkVertices(verticesToCheck [count1], verticesToCheck [count2]) == true)
{
return(false);
}
}
}
return(true);
}
/*
* StartSearch method will start the fringe search. It will get the first polygon that the search starts in and then
* it will start the search
* Parameter: none
* Return: none
*/
public void startSearch()
{
fringeList = new AIFringeSearchList(goalPosition);
for (int count = 0; count < polygonArray.Length; count++) // looks for the polygon with the agent GameObject inside it
{
if (polygonArray [count].getHasAgent() == true)
{
fringeList.enqueue(polygonArray [count], null, 0); //adds the first polygon to the openList
cache[count] = fringeList.getNodeOnList(polygonArray[count]);
startingPolygon = polygonArray[count];
count = polygonArray.Length;
}
}
fringeSearch(); //does the AStar search
printFinalSolution(); //prints the finalSolution for debugging
addFinalSolutionPolygons(); //adds the finalsolution to the finalsolution array
}
/*
* mergeTwoArray method will take two arrays and return a mergedArray of the polygons in them
* Parameter: (AIPolygon[])firstArray is the array that holds the polygons
* (AIPolygon[])SecondArray is the array that holds the second polygons
* Return: (AIPolygon[])
* an array that contains all the polygons from both arrays
*/
AIPolygon[] mergeTwoArrays(AIPolygon[] firstArray, AIPolygon[] secondArray)
{
AIPolygon[] tempArray = new AIPolygon[firstArray.Length + secondArray.Length];
int counter = 0;
for (int count = 0; count < firstArray.Length; count++)
{
tempArray [counter] = new AIPolygon(firstArray [count].getVertices(), counter);
counter++;
}
for (int count = 0; count < secondArray.Length; count++)
{
tempArray [counter] = new AIPolygon(secondArray [count].getVertices(), counter);
counter++;
}
return(tempArray);
}
/* addNode adds a node to this list in order according to its fTotalCost value
* Parameter: (AIPolygon) polygonToAdd is the polygon that will be held by the node
* (AIAgentAStarSearchNode) parentNodeToAdd is the parent of the node to be added
* (float) gCostToAdd is the getGFromStartingNode value to be stored in the node to be added
* Return: none
*/
public void addNode(AIPolygon polygonToAdd, AIDynamicWeightedSearchNode parentNodeToAdd, float gCostToAdd)
{
AIDynamicWeightedSearchNode newSearchNode;
if (numberOfNodesHeld == 0)
{
newSearchNode = new AIDynamicWeightedSearchNode(polygonToAdd, parentNodeToAdd, gCostToAdd, goalPosition, AIDynamicWeightedSearch.startingH, 1);
}
else
{
newSearchNode = new AIDynamicWeightedSearchNode(polygonToAdd, parentNodeToAdd, gCostToAdd, goalPosition, AIDynamicWeightedSearch.startingH, (parentNodeToAdd.getDoFN() + 1));
}
inList [polygonToAdd.getID()] = true;
indicesArray [polygonToAdd.getID()] = numberOfNodesHeld;
heap [numberOfNodesHeld] = newSearchNode;
shiftUp(numberOfNodesHeld);
numberOfNodesHeld++;
}
/* The method getArrayOfEdgeVertices constructs an array of edge vertices from the polygons
* Return: Vector3[]
* array of edge vertices
*/
Vector3[] getArrayOfEdgeVertices()
{
Vector3[] tempArray = new Vector3[arrayOfEdges.Length / 2];
tempArray[0] = new Vector3(arrayOfEdges[0, 0].x, arrayOfEdges[0, 0].y, arrayOfEdges[0, 0].z);
tempArray[1] = new Vector3(arrayOfEdges[0, 1].x, arrayOfEdges[0, 1].y, arrayOfEdges[0, 1].z);
bool flag = true;
for (int count = 1, position = 2; count < tempArray.Length && position < tempArray.Length; count++)
{
for (int count2 = 0; count2 < position && position < tempArray.Length; count2++)
{
if (AIPolygon.checkVertices(tempArray [count2], arrayOfEdges [count, 0]) == true)
{
flag = false;
}
}
if (flag == true)
{
tempArray [position] = new Vector3(arrayOfEdges [count, 0].x, arrayOfEdges [count, 0].y, arrayOfEdges [count, 0].z);
position++;
}
flag = true;
for (int count2 = 0; count2 < position && position < tempArray.Length; count2++)
{
if (AIPolygon.checkVertices(tempArray [count2], arrayOfEdges [count, 1]) == true)
{
flag = false;
}
}
if (flag == true)
{
tempArray [position] = new Vector3(arrayOfEdges [count, 1].x, arrayOfEdges [count, 1].y, arrayOfEdges [count, 1].z);
position++;
}
flag = false;
}
return(seperateEdgesIntoVectors(tempArray));
}
/*
* loadNavigationMeshFromFile method will load all the data for the navigation mesh from the file
* Paramters: none
* Return: none
*/
public void loadNavigationMeshFromFile()
{
startTime = Time.realtimeSinceStartup;
string filePath = Application.loadedLevelName + "NavigationMesh.dat";
Stream TestFileStream = File.OpenRead(filePath);
BinaryFormatter deserializer = new BinaryFormatter();
positionToStart = 0;
AIPolygonHolderData dataholder = (AIPolygonHolderData)deserializer.Deserialize(TestFileStream);
AIPolygon[] polygons = new AIPolygon[dataholder.polygonData.Length];
for (int count = 0; count < dataholder.polygonData.Length; count++)
{
Vector3[] vertices = new Vector3[dataholder.polygonData [count].vertices.Length / 3];
int id = dataholder.polygonData [count].id;
int[] neighbors = dataholder.polygonData [count].neighbors;
int neighborsHeld = dataholder.polygonData [count].neighborCount;
bool gotGoal = dataholder.polygonData [count].gotGoal;
bool gotAgent = dataholder.polygonData [count].gotAgent;
int agentID = dataholder.polygonData[count].agentID;
for (int count2 = 0; count2 < vertices.Length; count2++)
{
vertices [count2] = new Vector3(dataholder.polygonData [count].vertices [count2, 0], dataholder.polygonData [count].vertices [count2, 1], dataholder.polygonData [count].vertices [count2, 2]);
}
polygons [count] = new AIPolygon();
polygons [count].setData(vertices, id, neighborsHeld, neighbors, gotGoal, gotAgent, agentID);
}
AINavigationMeshData.initialPolygonCount = getSurfacePolygonCount();
AINavigationMeshData.obstacleCount = staticObjects.Length;
surfacePolygonHolders = new AIPolygonHolder[1];
surfacePolygonHolders [0] = new AIPolygonHolder();
surfacePolygonHolders [0].setAll(polygons, polygons.Length);
positionToStart = 0;
AINavigationMeshData.timeTaken = Time.realtimeSinceStartup - startTime;
AINavigationMeshData.finalPolygonCount = getSurfacePolygonCount();
TestFileStream.Close();
writeNavigationMeshToFile();
}
/*
* splitPolygons method will split the polygons that was collected to be split
* Parameter: (AIPolygon[]) splitingPolygons is an array containing the polygons that need to be split
* (AIObject) objectsToSplitWith is the object that the polygons will be split by
*/
AIPolygon[] splitPolygons(AIPolygon[] splitingPolygons, AIObjects objectToSplitWith)
{
AIPolygon[] tempArray = null;
for (int count = 0; count < splitingPolygons.Length; count++)
{
AIPolygonQueue tempQueue = splitingPolygons [count].splitThisPolygon(objectToSplitWith);
if (tempQueue != null)
{
tempArray = makeNewArray(count, tempQueue, AINavigationMeshAgent.agentDiameter, tempArray);
}
}
int counter = 0;
if (tempArray == null)
{
return(tempArray);
}
for (int count = 0; count < tempArray.Length; count++)
{
if (tempArray[count] != null)
{
counter++;
}
}
AIPolygon[] temp2Array = new AIPolygon[counter];
for (int count = 0, tempCount = 0; count < tempArray.Length; count++)
{
if (tempArray[count] != null)
{
temp2Array[tempCount] = new AIPolygon(tempArray[count].getVertices(), tempCount);
tempCount++;
}
}
return(temp2Array);
}
/*
* AIBinarySpaceTree method is the constructor for this class. It will set up all the variables to their initial state.
* Parameters: (GameObject)objectToAdd will be the object that the polygons are going to be split with
* (Vector3[,])arrayOfEdgesToAdd will be the array of edges with no Y coordinate change for objectToAdd
* (AIPolygon)polygonToAdd is the starting polygon that will be the in the rootNode of the tree
* (AIPolygonQueue)polygonQueueToAdd is the reference to the Queue that the free polygons will be added to
* Return: none
*/
public AIBinarySpaceTree(GameObject objectToAdd, Vector3[,] arrayOfEdgesToAdd, Vector3[] arrayOfEdgeVerticesAdd, AIPolygon polygonToAdd, AIPolygonQueue polygonQueueToAdd)
{
rootNode = new AIBinaryTreeNode(polygonToAdd);
arrayOfEdges = arrayOfEdgesToAdd;
edgeVertices = getArrayOfEdgeVertices();
indexForEdges = 0;
indexCount = 0;
usedEdgesForObject = new bool[arrayOfEdges.Length / 2];
for (int count = 0; count < usedEdgesForObject.Length; count++)
{
usedEdgesForObject [count] = false;
}
}
/* getNodeOnList returns node from list that contains a specified polygon
* Parameter: (AIPolygon) polygonToCheck is the polygon being held by the node to be returned
* Return: (AIAgentAStarSearchNode)
* node on list that is holding polygonToCheck
*/
public AIDynBiDirOpNode getNodeOnList(AIPolygon polygonToCheck)
{
return(heap [indicesArray [polygonToCheck.getID()]]);
}
/* getNodeOnList returns node from list that contains a specified polygon
* Parameter: (AIPolygon) polygonToCheck is the polygon being held by the node to be returned
* Return: (AIAgentAStarSearchNode)
* node on list that is holding polygonToCheck
*/
public AIAgentAStarSearchNode getNodeOnList(AIPolygon polygonToCheck)
{
return(heap [indicesArray [polygonToCheck.getID()]]);
}
/* isNodeOnList checks to see if node containing a certain polygon is on the list
* Parameter: (AIPolygon) polygon whose id will be used to check if a certain node is on list
* Return: (bool)
* true if a node is on the list that contains polygonToCheck
* false if no node on the list contains polygonToCheck
*/
public bool isNodeOnList(AIPolygon polygonToCheck)
{
return(inList [polygonToCheck.getID()]);
}
