//de reden dat ik dit dubbel doe is performance, nu hoef ik niet iedere keer deze variabelen te maken als ik update
public void ChangeColorGridPart(PathFinding.Node node, Color c)
{
float _x, _y, _z;
Vector3 _leftBotBack, _rightBotBack, _leftBotFront, _rightBotFront,
_leftTopBack, _rightTopBack, _leftTopFront, _rightTopFront;
_x = node.x * pathfinding.widthSizeNode;
_y = node.y * pathfinding.heightSizeNode;
_z = node.z * pathfinding.widthSizeNode;
//assign positions
//top
_leftBotBack = leftBotBack + new Vector3(_x, _y, _z);
_rightBotBack = _leftBotBack;
_rightBotBack.x += pathfinding.widthSizeNode;
_leftBotFront = _leftBotBack;
_leftBotFront.z += pathfinding.widthSizeNode;
_rightBotFront = _leftBotFront;
_rightBotFront.x += pathfinding.widthSizeNode;
//bot
_leftTopBack = leftBotBack + new Vector3(_x, _y - pathfinding.heightSizeNode, _z);
_rightTopBack = _leftTopBack;
_rightTopBack.x += pathfinding.widthSizeNode;
_leftTopFront = _leftTopBack;
_leftTopFront.z += pathfinding.widthSizeNode;
_rightTopFront = _leftTopFront;
_rightTopFront.x += pathfinding.widthSizeNode;
//bottom
Debug.DrawLine(_leftBotBack, _rightBotBack, c, durationPathVisualization);
Debug.DrawLine(_leftBotBack, _leftBotFront, c, durationPathVisualization);
Debug.DrawLine(_rightBotFront, _rightBotBack, c, durationPathVisualization);
Debug.DrawLine(_rightBotFront, _leftBotFront, c, durationPathVisualization);
//mid
Debug.DrawLine(_leftBotBack, _leftTopBack, c, durationPathVisualization);
Debug.DrawLine(_rightBotBack, _rightTopBack, c, durationPathVisualization);
Debug.DrawLine(_leftBotFront, _leftTopFront, c, durationPathVisualization);
Debug.DrawLine(_rightBotFront, _rightTopFront, c, durationPathVisualization);
//top
Debug.DrawLine(_leftTopBack, _rightTopBack, c, durationPathVisualization);
Debug.DrawLine(_leftTopBack, _leftTopFront, c, durationPathVisualization);
Debug.DrawLine(_rightTopFront, _rightTopBack, c, durationPathVisualization);
Debug.DrawLine(_rightTopFront, _leftTopFront, c, durationPathVisualization);
}
private void PrepareNode(int x, int y, int z)
{
if (x < 0 || x >= lengthX)
{
return;
}
if (y < 0 || y + 1 >= lengthY)
{
return;
}
if (z < 0 || z >= lengthZ)
{
return;
}
//hier alle checks doen
checkNode = p.grid[x, y, z];
if (closed.Contains(checkNode) || !checkNode.filled)
{
return;
}
//check if already waiting to be checked
foreach (Node node in open)
{
if (node.node == checkNode)
{
return;
}
}
//switch to node above
checkNode = p.grid[x, y + 1, z];
if (checkNode.filled && !bake.myNodes.Contains(checkNode))
{
return;
}
_position = new Vector3(x, y, z);
distanceOrigin = Vector3.Distance(_position, origin);
distanceGoal = Vector3.Distance(_position, dest);
adjecentNodes.Add(new Node(p.grid[x, y, z], nodeToCheck, (int)(distanceOrigin + distanceGoal)));
}
void Awake()
{
GenerateDungeon();
// Create the paths for every room
Dictionary <Room, List <PathFinding.Node> > roomRoutes = new Dictionary <Room, List <PathFinding.Node> >();
for (int i = 0; i < rooms.Count; i++)
{
Room s = rooms[i];
for (int j = i + 1; j < rooms.Count; j++)
{
Room g = rooms[j];
PathFinding.Node start = new PathFinding.Node(s.X_Cell, s.Y_Cell);
PathFinding.Node goal = new PathFinding.Node(g.X_Cell, g.Y_Cell);
pathFinder.findPath(cells, start, goal);
//roomRoutes.Add (s, pathFinder.findPath(cells, start, goal));
}
}
}
//Insert a Pathfinding node in the tree
public void Insert(PathFinding.Node pfNode, QuadTreeNode node = null, int DepthLevel = 0)
{
if (node == null)
{
node = Head;
}
//Make sure Box is smaller than current quadrant. If yes, go deeper, otherwise add elements here
if (DepthLevel < this.Depth)
{
//Process North-West Part
if (node.Children[0] != null)
{
if (pfNode.position.X <= node.Position.X && pfNode.position.Z <= node.Position.Y)
{
Insert(pfNode, node.Children[0], DepthLevel + 1);
}
}
//Process North-East Part
if (node.Children[1] != null)
{
if (pfNode.position.X >= node.Position.X && pfNode.position.Z <= node.Position.Y)
{
Insert(pfNode, node.Children[1], DepthLevel + 1);
}
}
//Process South-West Part
if (node.Children[2] != null)
{
if (pfNode.position.X <= node.Position.X && pfNode.position.Z >= node.Position.Y)
{
Insert(pfNode, node.Children[2], DepthLevel + 1);
}
}
//Process South-East Part
if (node.Children[3] != null)
{
if (pfNode.position.X >= node.Position.X && pfNode.position.Z >= node.Position.Y)
{
Insert(pfNode, node.Children[3], DepthLevel + 1);
}
}
}
else
{
//Add box in current layer
if (node.PathFindingNodes == null)
{
node.PathFindingNodes = new List <PathFinding.Node>();
}
if (!node.PathFindingNodes.Contains(pfNode))
{
node.PathFindingNodes.Add(pfNode);
ItemCount++;
}
}
}
public void UpdateGrid()
{
if (!(pathfinding != null))
{
return;
}
if (!pathfinding.visualize)
{
return;
}
if (!showBake)
{
return;
}
//calculate corners
CalcCorners();
#region Play Time
Color c = Color.white;
//local squire
Vector3 _leftBotBack, _rightBotBack, _leftBotFront, _rightBotFront,
_leftTopBack, _rightTopBack, _leftTopFront, _rightTopFront;
float _x, _y, _z;
for (int x = 0; x < pathfinding.widthSize; x++)
{
for (int y = 0; y < pathfinding.heightSize; y++)
{
for (int z = 0; z < pathfinding.widthSize; z++)
{
PathFinding.Node node = pathfinding.grid[x, y, z];
if (node.filled)
{
//get right color
switch (node.bakeType)
{
case PathFinding.BakeType.Enemy:
c = Color.red;
break;
case PathFinding.BakeType.Object:
c = Color.blue;
break;
case PathFinding.BakeType.Movable:
c = Color.green;
break;
default:
break;
}
_x = x * pathfinding.widthSizeNode;
_y = y * pathfinding.heightSizeNode;
_z = z * pathfinding.widthSizeNode;
//assign positions
//top
_leftBotBack = leftBotBack + new Vector3(_x, _y, _z);
_rightBotBack = _leftBotBack;
_rightBotBack.x += pathfinding.widthSizeNode;
_leftBotFront = _leftBotBack;
_leftBotFront.z += pathfinding.widthSizeNode;
_rightBotFront = _leftBotFront;
_rightBotFront.x += pathfinding.widthSizeNode;
//bot
_leftTopBack = leftBotBack + new Vector3(_x, _y - pathfinding.heightSizeNode, _z);
_rightTopBack = _leftTopBack;
_rightTopBack.x += pathfinding.widthSizeNode;
_leftTopFront = _leftTopBack;
_leftTopFront.z += pathfinding.widthSizeNode;
_rightTopFront = _leftTopFront;
_rightTopFront.x += pathfinding.widthSizeNode;
//bottom
Debug.DrawLine(_leftBotBack, _rightBotBack, c);
Debug.DrawLine(_leftBotBack, _leftBotFront, c);
Debug.DrawLine(_rightBotFront, _rightBotBack, c);
Debug.DrawLine(_rightBotFront, _leftBotFront, c);
//mid
Debug.DrawLine(_leftBotBack, _leftTopBack, c);
Debug.DrawLine(_rightBotBack, _rightTopBack, c);
Debug.DrawLine(_leftBotFront, _leftTopFront, c);
Debug.DrawLine(_rightBotFront, _rightTopFront, c);
//top
Debug.DrawLine(_leftTopBack, _rightTopBack, c);
Debug.DrawLine(_leftTopBack, _leftTopFront, c);
Debug.DrawLine(_rightTopFront, _rightTopBack, c);
Debug.DrawLine(_rightTopFront, _leftTopFront, c);
}
}
}
}
#endregion
}
public Node(PathFinding.Node _node, Node _parent, int _cost)
{
node = _node;
parent = _parent;
cost = _cost;
}
public Node(PathFinding.Node _node)
{
node = _node;
}
//bugs
//when out of bounds, will travel to last known destination
//when out of range, will repeat same checks and slow down game
//bake is raar met specifieke objecten
//z werkt niet goed met pathfinding
private IEnumerator CalculatePath(Vector3 position, Callable callable) //omhoog / omlaag moet ook werken. hiervoor moet schuin gaan kunnen
{
PathFinding.Node destination = p.GetNodeFromVector(position);
//pathfinding tools
open = new List <Node>();
closed = new List <PathFinding.Node>();
Pathfinding_Visualizer pV = PathFinding.visualizer;
PathFinding.Node start = p.GetNodeFromVector(transform.position);
PathFinding.Node reference = start;
int nodesBetween = 0;
int y;
if (start != null)
{
while (nodesBetween < maxNodesBetweenGroundAndTarget)
{
y = reference.y - nodesBetween;
if (!(y > 0 && y < p.grid.GetLength(1)))
{
nodesBetween++;
continue;
}
reference = p.grid[start.x, y, start.z];
nodesBetween++;
if (reference.filled && reference.bakeType == PathFinding.BakeType.Object)
{
break;
}
}
if (start.filled)
{
open.Add(new Node(reference));
}
else
{
Debug.Log("There is nothing walkable around the start point.");
}
}
else
{
Debug.Log("Currently not in a walkable area, unable to create a path.");
}
if (start != null)
{
reference = destination;
nodesBetween = -maxNodesBetweenGroundAndTargetReverse;
y = 0;
if (destination != null)
{
while (nodesBetween < maxNodesBetweenGroundAndTarget)
{
y = reference.y - nodesBetween;
if (!(y > 0 && y < p.grid.GetLength(1)))
{
nodesBetween++;
continue;
}
reference = p.grid[start.x, y, start.z]; //BUG
nodesBetween++;
if (reference.filled && reference.bakeType == PathFinding.BakeType.Object)
{
break;
}
}
}
}
//cost calculation
if (start != null)
{
origin = new Vector3(start.x, start.y, start.z);
}
if (destination != null)
{
dest = new Vector3(destination.x, destination.y, destination.z);
}
int checks = 0;
//main loop
if (destination != null)
{
while (open.Count > 0 && closed.Count < maxNodesCheckable) //hij gaat nu via het gevulde een pad zoeken ipv bovenop het pad
{
open.Sort();
PathFinding.Node node;
node = open[0].node;
if (closed.Contains(node))
{
open.RemoveAt(0);
continue;
}
if (p.visualize)
{
//in dit geval weet je al dat +1 bestaat omdat dat een check gaat worden
pV.ChangeColorGridPart(p.grid[node.x, node.y + 1, node.z], Color.green);
}
checks++;
if (checks >= checksPerFrame)
{
checks = 0;
yield return(null);
}
adjecentNodes = new List <Node>();
nodeToCheck = open[0];
n = nodeToCheck.node;
//check if destination
if (Vector3.Distance(dest, new Vector3(n.x, n.y, n.z)) <= stoppingNodeDistance)
{
break;
}
open.RemoveAt(0);
closed.Add(nodeToCheck.node);
//front
PrepareNode(n.x, n.y, n.z + 1);
//back
PrepareNode(n.x, n.y, n.z - 1);
//right
PrepareNode(n.x + 1, n.y, n.z);
//left
PrepareNode(n.x - 1, n.y, n.z);
if (!_2d)
{
//top checks
PrepareNode(n.x, n.y + 1, n.z + 1);
PrepareNode(n.x + 1, n.y + 1, n.z + 1);
PrepareNode(n.x + 1, n.y + 1, n.z);
PrepareNode(n.x + 1, n.y + 1, n.z - 1);
PrepareNode(n.x, n.y + 1, n.z - 1);
PrepareNode(n.x - 1, n.y + 1, n.z - 1);
PrepareNode(n.x - 1, n.y + 1, n.z);
PrepareNode(n.x - 1, n.y + 1, n.z + 1);
//bottom checks
PrepareNode(n.x, n.y - 1, n.z + 1);
PrepareNode(n.x + 1, n.y - 1, n.z + 1);
PrepareNode(n.x + 1, n.y - 1, n.z);
PrepareNode(n.x + 1, n.y - 1, n.z - 1);
PrepareNode(n.x, n.y - 1, n.z - 1);
PrepareNode(n.x - 1, n.y - 1, n.z - 1);
PrepareNode(n.x - 1, n.y - 1, n.z);
PrepareNode(n.x - 1, n.y - 1, n.z + 1);
}
foreach (Node _node in adjecentNodes)
{
open.Add(_node);
}
}
}
//check if path has been found
//if curnode != null
//if curnode == destination
//convert everything to a vector3 list
List <Vector3> _path = new List <Vector3>();
Node curNode;
Vector3 pos;
if (open.Count > 0)
{
curNode = open[0];
open.RemoveAt(0);
while (curNode.parent != null)
{
//convert
pos = p.GetVectorFromNode(curNode.node);
pos.y += p.heightSizeNode;
if (p.visualize)
{
pV.ChangeColorGridPart(curNode.node, Color.red);
}
_path.Add(pos);
curNode = curNode.parent;
}
_path.Add(p.GetVectorFromNode(curNode.node));
}
calculate = null;
if (_path.Count == 0)
{
Debug.Log("No path could be found.");
}
if (callable != null)
{
callable(_path);
}
}
