private void GenerateEdgesByRoom(Room room)
{
if (room.IsOutsideRoom())
{
// We don't want to loop over all the tiles in the outside room as this would be expensive
return;
}
Path_Node <Room> node = nodes[room];
List <Path_Edge <Room> > edges = new List <Path_Edge <Room> >();
Dictionary <Tile, Room> neighbours = room.GetNeighbours();
foreach (Tile tile in neighbours.Keys)
{
// We have found a different room to ourselves add an edge from us to them
Path_Edge <Room> edge = new Path_Edge <Room>();
edge.cost = 1;
edge.tile = tile;
edge.node = nodes[neighbours[tile]];
edges.Add(edge);
}
node.edges = edges.ToArray();
}
private void GenerateEdgesByTile(Tile t)
{
if (t == null)
{
return;
}
Path_Node <Tile> n = nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
// Get a list of neighbours for the tile
Tile[] neighbours = t.GetNeighbours(true, true);
// NOTE: Some of the array spots could be null.
// If neighbour is walkable, create an edge to the relevant node.
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours[i] != null && neighbours[i].PathfindingCost > 0 && t.IsClippingCorner(neighbours[i]) == false)
{
// This neighbour exists, is walkable, and doesn't requiring clipping a corner --> so create an edge.
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbours[i].PathfindingCost;
e.node = nodes[neighbours[i]];
// Add the edge to our temporary (and growable!) list
edges.Add(e);
}
}
n.edges = edges.ToArray();
}
private void GenerateEdgesOutside()
{
List <Path_Edge <Room> > outsideEdges = new List <Path_Edge <Room> >();
Room outsideRoom = World.Current.GetOutsideRoom();
foreach (Room room in nodes.Keys)
{
if (room.IsOutsideRoom())
{
continue;
}
Path_Edge <Room>[] edges = nodes[room].edges;
foreach (Path_Edge <Room> edge in edges)
{
if (edge.node.data.IsOutsideRoom())
{
// Edge connects to the outside room
Path_Edge <Room> outsideEdge = new Path_Edge <Room>();
// The cost of going outside should be high as to avoid needlessly leaving the base
outsideEdge.tile = edge.tile;
outsideEdge.cost = 10f;
outsideEdge.node = nodes[room];
outsideEdges.Add(outsideEdge);
}
}
}
nodes[outsideRoom].edges = outsideEdges.ToArray();
}
private void CreateEdgesForNode(Block block)
{
Path_Node <Block> n = nodes[block];
List <Path_Edge <Block> > edges = new List <Path_Edge <Block> >();
// Get a list of neighbors
// if the neighbor is walkable, create an edge
// if the block is a ramp, then blocks that are
// either at the ramp's height or one up from there
// are walkable neighbors
// TODO: Implement the part about ramps working
for (int i = 0; i < 4; i++)
{
SquareDirection dir = SquareDirectionExtensions.ReturnOrthogonal(i);
Block nBlock = block.GetNeighbor(dir);
if (nBlock != null)
{
Path_Edge <Block> e = new Path_Edge <Block>();
e.cost = nBlock.MoveCost;
e.node = nodes[nBlock];
edges.Add(e);
}
}
n.edges = edges.ToArray();
}
public Path_TileGraph(World world)
{
// Loop through all tiles of the world
// For each tile, create a node
// Do we create nodes for non-floor tiles? NO!
// Do we create nodes for tiles that are completely unwalkable (i.e. walls)? NO!
nodes = new Dictionary <Tile, Path_Node <Tile> >();
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile t = world.GetTileAt(x, y);
//if(t.movementCost > 0) { // Tiles with a move cost of 0 are unwalkable
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
nodes.Add(t, n);
//}
}
}
// Now loop through all nodes again
// Create edges for neighbours
int edgeCount = 0;
foreach (Tile t in nodes.Keys)
{
Path_Node <Tile> n = nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
// Get a list of neighbours for the tile
Tile[] neighbours = t.GetNeighbours(false); // NOTE: Some of the array spots could be null.
// If neighbour is walkable, create an edge to the relevant node.
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours[i] != null && neighbours[i].MovementCost > 0 && IsClippingCorner(t, neighbours[i]) == false)
{
// This neighbour exists, is walkable, and doesn't requiring clipping a corner --> so create an edge.
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbours[i].MovementCost;
e.node = nodes[neighbours[i]];
// Add the edge to our temporary (and growable!) list
edges.Add(e);
edgeCount++;
}
}
n.edges = edges.ToArray();
}
}
public Path_TileGraph(World world)
{
Debug.Log("Path_TileGraph Constructor");
nodes = new Dictionary <Tile, Path_Node <Tile> >();
// loop through all tiles and create nodes;
// do we create nodes for non walkable tiles? NO!
for (int x = 0; x < world.width; x++)
{
for (int y = 0; y < world.height; y++)
{
Tile t = world.GetTileAt(x, y);
//if(t.MoveCost > 0 && t.Type != TileType.Mountain && t.Type != TileType.Water && t.building == null)
//{
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
nodes.Add(t, n);
//}
}
}
// loop through all nodes again,
// create edges for neighbors
foreach (Tile t in nodes.Keys)
{
Path_Node <Tile> n = nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
// get a list of neighbors for the tile
Tile[] neighbors = t.GetNeighbours(true); // NOTE some of the array may be null.
// if neighbor is walkable, create an edge to relevant node
for (int i = 0; i < neighbors.Length; i++)
{
if (neighbors[i] == null) // Breakout of loop if at the edge of the map
{
continue;
}
//if( IsClippingCorner ( t, neighbors[i]))
//{
// continue;
//}
if (neighbors[i] != null && neighbors[i].MoveCost > 0)
{
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbors[i].MoveCost;
e.node = nodes[neighbors[i]];
// Add the edges to our temporary (and growable!) list
edges.Add(e);
}
}
n.edges = edges.ToArray();
}
Debug.Log(" Created " + nodes.Count + " nodes");
}
public Path_TileGraph(World world)
{
nodes = new Dictionary <Vector3Int, Path_Node <Vector3Int> > ();
//Loop through all tiles of the world, build a node for each tile
//Not creating nodes for tiles that are NON walkable(i.e walls, water, windows, etc)
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Vector3Int tilePos = new Vector3Int(x, y, 0);
//Creates nodes FOR EVERY tile on the map
Path_Node <Vector3Int> node = new Path_Node <Vector3Int> ();
node.data = tilePos;
nodes.Add(tilePos, node);
}
}
int edgesCount = 0;
//Now loop through all the nodes, and create the edges
foreach (Vector3Int t in nodes.Keys)
{
//Get a list of neighbors of the tile, if neighbor is walkable create an edge to the relevant node
Path_Node <Vector3Int> node = nodes[t];
List <Path_Edge <Vector3Int> > edges = new List <Path_Edge <Vector3Int> > ();
Vector3Int[] neighbors = world.GetNeighbors(t, true);
for (int i = 0; i < neighbors.Length; i++)
{
float movementSpeed = 1f;
//Get movement Speed based on the tile on tilemap Walkable layer
if (WorldController.Instance.World.foundationGameMap.ContainsKey(neighbors[i]) == true)
{
movementSpeed = WorldController.Instance.World.foundationGameMap[neighbors[i]].movementCost;
}
if (WorldController.Instance.World.foundationGameMap.ContainsKey(neighbors[i]) == false ||
(WorldController.Instance.World.foundationGameMap.ContainsKey(neighbors[i]) == true && movementSpeed > 0))
{
if (isClippingCorner(nodes[t].data, neighbors[i]))
{
continue;
}
Path_Edge <Vector3Int> e = new Path_Edge <Vector3Int> ();
e.cost = movementSpeed;
if (nodes.ContainsKey(neighbors[i]) == true)
{
e.node = nodes[neighbors[i]];
edges.Add(e);
edgesCount++;
}
}
}
node.edges = edges.ToArray();
}
}
public Path_TileGraph(Area area)
{
nodes = new Dictionary <Tile, Path_Node <Tile> >();
int edgeCount = 0;
// Use the World Grid to create Nodes from Tile data
// NODES will contain ONLY tiles that are WALKABLE
for (int x = 0; x < area.Width; x++)
{
for (int y = 0; y < area.Height; y++)
{
Tile t = area.GetTile(x, y);
if (t != null && t.MovementCost > 0)
{
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
nodes.Add(t, n);
}
}
}
//Debug.Log("Path_TileGraph -- created " + nodes.Count + " Nodes.");
// Now loop through nodes to create Edges between them
foreach (Tile t in nodes.Keys)
{
Path_Node <Tile> n = nodes[t];
Tile[] neighbors = t.GetNeighbors(true);
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
for (int i = 0; i < neighbors.Length; i++)
{
if (neighbors[i] != null && neighbors[i].MovementCost > 0)
{
// Is walkable
Path_Edge <Tile> edge = new Path_Edge <Tile>();
edge.cost = neighbors[i].MovementCost;
edge.node = nodes[neighbors[i]];
edges.Add(edge);
edgeCount++;
}
}
n.edges = edges.ToArray();
}
//Debug.Log("Path_TileGraph -- created " + edgeCount + " Edges.");
}
Dictionary <Tile, Path_Node <Tile> > nodes; // Maps from tiles to nodes
// Public constructor
// This class creates a tile compatible graph of the world, each tile is a graph, each walkable neighbour from a tile is linked via an edge
public Tile_Graph(World world)
{
Debug.Log("Tile Graph initialised");
nodes = new Dictionary <Tile, Path_Node <Tile> >();
// Loop through all tiles of the world, for each tile that is wallkable create a node, create a node
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile t = world.GetTileAt(x, y); // Fetch the tile at the looped x and y - values
if (t.MovementCost > 0) // if the tiles are walkable
{
// Create a node
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
nodes.Add(t, n); // Dictionary will now have a corresponding node for any tile in the world that is walkable
}
}
}
Debug.Log("Created" + nodes.Count + "Nodes");
int EdgeCount = 0;
foreach (Tile t in nodes.Keys) // For each tile (Key) in the dictionary
{
Path_Node <Tile> n = nodes[t]; // Get the corresponding node
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >(); // List of edges that come out of a node
// Get a list of neighbours
Tile[] neighbours = t.getNeighbours(true); // Note: Some tiles in this array could be null
// loop through the array of neighbouring tiles for each walkable tile
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours[i] != null && neighbours[i].MovementCost > 0)
{
// The nighbouring tile exists and is walkable so create an edge for that neighbour tile
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbours[i].MovementCost; // feeds the neighbouring tile to the edge constructor
e.path_Node = nodes[neighbours[i]]; // the node fed to the path_edge is the neighbouring tile that is being processed
// Returns the node for the neighbouring tile ? //
edges.Add(e); // Add the edge to temp and throwable list
EdgeCount++;
}
}
n.edges = edges.ToArray(); // Casts the List of Edges to an array that is stored in the node // so that the node is aware of how many edges it has
}
Debug.Log(EdgeCount + " Edges created");
}
public Path_TileGraph(World world)
{
// Create all nodes via tiles.
this.nodes = new Dictionary <Tile, Path_Node <Tile> >();
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile t = world.GetTileAt(x, y);
// Can actually move through the tile...
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
this.nodes.Add(t, n);
}
}
// Create edges.
foreach (Tile t in this.nodes.Keys)
{
Path_Node <Tile> n = this.nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
Tile[] neighbours = t.GetNeighbours(true); // Can walk diagonal.
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours[i] != null && neighbours[i].movementCost > 0)
{
// Ensure no corners can be clipped.
if (this.IsClippingCorner(t, neighbours[i]))
{
continue;
}
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbours[i].movementCost;
e.node = this.nodes[neighbours[i]];
edges.Add(e);
}
}
n.edges = edges.ToArray();
}
}
// Initializes a new instance of the <see cref="Path_TileGraph"/> class.
public Path_TileGraph(World world)
{
nodes = new Dictionary <Tile, Path_Node <Tile> > ();
//loop the tiles - ncrate a node
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile t = world.GetTileAt(x, y);
//if (t.movementCost > 0) {
Path_Node <Tile> n = new Path_Node <Tile> ();
n.data = t;
nodes.Add(t, n);
//}
}
}
//loop the tiles - create edges
foreach (Tile t in nodes.Keys)
{
Path_Node <Tile> n = nodes [t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> > ();
//get list of neighbours
Tile [] neighbours = t.GetNeighbours(true); // check if null
for (int i = 0; i < neighbours.Length; i++)
{
Tile nbTile = neighbours [i];
if (nbTile != null && nbTile.movementCost > 0) // is walkable SO CREATE EDGE
{
if (isClippingCorner(t, nbTile))
{
continue;
}
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.Cost = nbTile.movementCost;
e.Node = nodes [nbTile];
//ADD THE EDGE TO TEMP LIST
edges.Add(e);
}
}
n.Edges = edges.ToArray();
}
}
public Path_TileGraph(World world)
{
nodes = new Dictionary <Tile, Path_Node <Tile> > ();
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile tile = world.getTileAt(x, y);
//movementCost==0 -> impassable
//if (tile.movementCost > 0) {
Path_Node <Tile> node = new Path_Node <Tile> ();
node.data = tile;
nodes.Add(tile, node);
//}
}
}
//Debug.Log ("Path_TileGraph -- Created " + nodes.Count + " nodes");
int edgesCount = 0;
foreach (Tile tile in nodes.Keys)
{
Path_Node <Tile> node = nodes [tile];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> > (); //Heavy cumputation?
Tile[] neighbours = tile.getNeighboors(true);
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours [i] != null && neighbours [i].movementCost > 0)
{
if (isClippingCorner(tile, neighbours [i]) == true)
{
continue;
}
Path_Edge <Tile> edge = new Path_Edge <Tile> ();
edge.cost = neighbours [i].movementCost;
edge.node = nodes [neighbours [i]];
edges.Add(edge);
edgesCount++;
}
}
node.egdes = edges.ToArray();
}
//Debug.Log ("Path_TileGraph -- Created " + edgesCount + " edges");
}
public Path_TileGraph(World world)
{
nodes = new Dictionary <Tile, Path_Node <Tile> >();
//loop all tiles , create a node for each one
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile t = world.GetTileAt(x, y);
if (t.MovementCost > 0) // if unwalkable
{
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
nodes.Add(t, n);
}
}
}
//create edges for each
foreach (Tile t in nodes.Keys)
{
Path_Node <Tile> n = nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
//Get neighbors
Tile[] neighbours = t.GetNeighbours(true); //? some array spots could be null
//if walkable create edge
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours[i] != null && neighbours[i].MovementCost > 0)
{
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbours[i].MovementCost;
e.node = nodes[neighbours[i]];
edges.Add(e);
}
}
n.edges = edges.ToArray();
}
Debug.Log("Pathfinding: " + nodes.Count + " Nodes Created");
}
public Path_TileGraph(World world)
{
_nodes = new Dictionary <Tile, Path_Node <Tile> >();
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile tile = world.GetTileAt(x, y);
//if(tile.MovementCost > 0)
//{
Path_Node <Tile> node = new Path_Node <Tile>();
node.Data = tile;
_nodes.Add(tile, node);
//}
}
}
foreach (Tile tile in _nodes.Keys)
{
Path_Node <Tile> node = _nodes[tile];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
Tile[] neighbours = tile.GetNeighbours(true);
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours[i] != null && neighbours[i].MovementCost > 0)
{
if (CheckIfNeighbourIsUnwalkable(i, neighbours))
{
continue;
}
Path_Edge <Tile> edge = new Path_Edge <Tile>();
edge.Cost = neighbours[i].MovementCost;
edge.Node = _nodes[neighbours[i]];
edges.Add(edge);
}
}
node.Edges = edges.ToArray();
}
}
public Path_TileGraph(World world, bool debug = false)
{
nodes = new Dictionary <Tile, Path_Node <Tile> >();
//Loop thorugh all tiles of the world
//For each tile, create a node
//Do we create nodes for non.floor tiles? No
//Do we create nodes for tiles that are completely unwalkable (i.e. walls)? No
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile t = world.GetTileAt(x, y);
//if (t.MovementCost > 0) { //Tiles with a move cost of 0 are unwalkable
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
nodes.Add(t, n);
if (debug)
{
Debug.DrawLine(new Vector3(x + 0.4f, y + 0.25f, 0), new Vector3(x + 0.6f, y + 0.75f, 0), Color.red, 5f);
}
//}
}
}
//Now loop through all tiles again
//Create edges for neighbours
foreach (Tile t in nodes.Keys)
{
Path_Node <Tile> n = nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
//Get a list of neighbours for the tile
ReadOnlyCollection <Tile> neighbours = t.GetNeighbours(true); //NOTE: Some of the array spots could be null
//If a neighbour is walkable, create an edge to the relevant node.
for (int i = 0; i < neighbours.Count; i++)
{
if (neighbours[i] != null && neighbours[i].MovementCost > 0)
{
//This neighbours exists and is walkable, so create an edge.
//But first, make sure we aren't clipping a diagonal or trying to squeeze inappropriately
if (IsClippingCorner(neighbours, i))
{
continue;
}
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbours[i].MovementCost * (i < 4 ? 1 : 1.41421356237f);
e.node = nodes[neighbours[i]];
edges.Add(e);
if (debug && t.MovementCost > 0)
{
Debug.DrawLine(new Vector3(t.X + 0.5f, t.Y + 0.5f, 0), new Vector3(e.node.data.X + 0.5f, e.node.data.Y + 0.5f, 0), Color.green, 10f);
}
}
}
n.edges = edges.ToArray();
}
}
public Path_TileGraph(World world)
{
Debug.Log("Path_TileGraph");
//assumptions:
//create a node for each floor tile
//we don't create nodes for tiles that are unwalkable (like walls)
nodes = new Dictionary <Tile, Path_Node <Tile> >();
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile t = world.GetTileAt(x, y);
//if (t.movementCost > 0) //tiles with movement of 0 is unwalkable
//{
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
nodes.Add(t, n);
//}
}
}
Debug.Log($"Path_TileGraph: Created {nodes.Count} nodes");
int edgeCount = 0;
foreach (Tile t in nodes.Keys)
{
Path_Node <Tile> n = nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
Tile[] neighbours = t.GetNeighbours(true); //SOME ARRAY SPOTS COULD BE NULL
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours[i] != null && neighbours[i].movementCost > 0)
{
//neighbour tile is walkable, so create edge
//first we must make sure we are not clipping a diagonal inappropriately
if (IsClippingCorner(t, neighbours[i]))
{
continue;
}
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbours[i].movementCost;
e.node = nodes[neighbours[i]];
//add edge to list
edges.Add(e);
edgeCount++;
}
}
n.edges = edges.ToArray();
}
Debug.Log($"Path_TileGraph: Created {edgeCount} edges");
}
// Get World data and if they are limited tile
public Path_TileGraph(int startWidth, int endWidth, int startHeight, int endHeight)
{
// Loop through all tiles of the world
// For each tile, create a node
// Do we create nodes for non-floor tiles? NO!
// Do we create nodes for tiles that are completely unwalkable (i.e. walls)? NO!
nodes = new Dictionary <Tile, Path_Node <Tile> >();
// Search space from start -> end width & height
for (int x = startWidth; x <= endWidth; x++)
{
for (int y = startHeight; y <= endHeight; y++)
{
Tile t = WorldController.Instance.World.GetTileAt(x, y);
if (t.movementCost > 0) // Tiles with a move cost of 0 are unwalkable
{
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
nodes.Add(t, n);
//Debug.Log("Nodes have : " + t.X + "," + t.Z);
}
}
}
Debug.Log("Path_TileGraph: Created " + nodes.Count + " nodes.");
// Now loop through all nodes again
// Create edges for neighbours
int edgeCount = 0;
foreach (Tile t in nodes.Keys)
{
Path_Node <Tile> n = nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
// Get a list of neighbours for the tile
Tile[] neighbours = t.GetNeighbours(true); // NOTE: Some of the array spots could be null.
// If neighbour is walkable, create an edge to the relevant node.
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours[i] != null && neighbours[i].movementCost > 0
// Check for little tile graph not get out of bound neighbour tile
&& nodes.ContainsKey(neighbours[i])
//&& IsClippingCorner( t, neighbours[i] ) == false
)
{
// This neighbour exists, is walkable, and doesn't requiring clipping a corner --> so create an edge.
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbours[i].movementCost;
e.node = nodes[neighbours[i]];
// Add the edge to our temporary (and growable!) list
edges.Add(e);
edgeCount++;
}
}
n.edges = edges.ToArray();
}
Debug.Log("Path_TileGraph: Created " + edgeCount + " edges.");
}
public Dictionary <Tile, Path_Node <Tile> > nodes; //Define a dictonary - a link between tiles and nodes
public Path_TileGraph(World world)
{
Debug.Log("Path_TileGraph");
// Loop through all tilse of the world
// For each tile, create a node
// Do we create nodes for non-floor tiles? NO!
// Do we create nodes for tiles that are completely unwalkable? (i.e. walls?) NO!
nodes = new Dictionary <Tile, Path_Node <Tile> >(); //Instanciate a dictonary - a link between tiles and nodes
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile t = world.GetTileAt(x, y);
//if(t.MovementCost > 0) { // Tiles with a move cost of 0 are unwalkable
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
nodes.Add(t, n);
//}
}
}
Debug.Log("Path_TileGraph: Created " + nodes.Count + " nodes.");
// Now loop through all nodes again
// Create edges for neighbours
int edgeCount = 0;
foreach (Tile t in nodes.Keys) // Go through whole dictonary
{
Path_Node <Tile> n = nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
// Get a list of neighbours for the tile
Tile[] neighbours = t.GetNeighbours(true); // NOTE: Some of the array spots could be null
// If neighbour is walkable, create an edge to the relevent node
for (int i = 0; i < neighbours.Length; i++) // for each neighbour...
{
if (neighbours[i] != null && neighbours[i].MovementCost > 0) // This neighbour exists and is empty (air)
// Now check if there is a block in the right place to stand on
// If the neighbour tile is not standable, we skip to the next neighbour without building an edge
{
if (neighbours[i].IsStandable() == false)
{
continue;
}
// But first make sure we are not clipping a diagonal or trying to squeeze inappropiately
if (IsClippingCorner(t, neighbours[i]))
{
continue; // Skip to the next neighbour without building an edge
}
Path_Edge <Tile> e = new Path_Edge <Tile>(); // Create a new edge
e.cost = neighbours[i].MovementCost; // Set the movement cost
e.node = nodes[neighbours[i]]; // Set the node
edges.Add(e); // Add this new edge to our temporary (and growable) list of edges
edgeCount++; // Debug counter
}
}
n.edges = edges.ToArray(); // Give the node the list of edges
}
Debug.Log("Path_TileGraph: Created " + edgeCount + " edges.");
}
public Path_TileGraph(World world)
{
//遍历世界上所有的瓷砖
//对于每个图块，创建一个节点
//我们是否为非地砖创建节点？ 没有！
//我们是否为完全不可行走的瓷砖（即墙壁）创建节点？ 没有！
nodes = new Dictionary <Tile, Path_Node <Tile> >();
for (int x = 0; x < world.width; x++)
{
for (int y = 0; y < world.height; y++)
{
Tile tile = world.GetTileAt(x, y);
//移动成本为0的瓷砖是不能进行移动的位置
//if (tile.movementCost > 0)
//{
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = tile;
nodes.Add(tile, n);
// }
}
}
//现在再次遍历所有节点
//为邻居创建边
int edgeCount = 0;
foreach (Tile tile in nodes.Keys)
{
Path_Node <Tile> n = nodes[tile];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
// //获取Tile的邻居列表
Tile[] neighbours = tile.GetNeighbours(true); //注意：某些数组点可能为空。
//如果邻居是可步行的，则为相关节点创建边缘。
for (int i = 0; i < neighbours.Length; i++)
{
//if (neighbours[i] != null && neighbours[i].movementCost > 0)
if (neighbours[i] != null && neighbours[i].movementCost > 0 && IsClippingCorner(tile, neighbours[i]) == false)
{
{
//这个邻居存在且可以步行，所以创造一个边缘。
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbours[i].movementCost;
e.node = nodes[neighbours[i]];
//将边添加到我们的临时（和可扩展的！）列表中
edges.Add(e);
edgeCount++;
}
}
n.path_Edges = edges.ToArray();
}
}
/// <summary>
/// 是否斜角
/// </summary>
/// <param name="curr"></param>
/// <param name="neigh"></param>
/// <returns></returns>
bool IsClippingCorner(Tile curr, Tile neigh)
{
//如果从curr到neigh的运动是对角线的（例如N-E）
//然后检查以确保我们没有斜角（例如N和E都可以走路）
int dX = curr.x - neigh.x;
int dY = curr.y - neigh.y;
if (Mathf.Abs(dX) + Mathf.Abs(dY) == 2)
{
//我们是对角的
if (curr.world.GetTileAt(curr.x - dX, curr.y).movementCost == 0)
{
//东方或西方是不可行的，因此这将是一个斜角的运动。
return(true);
}
if (curr.world.GetTileAt(curr.x, curr.y - dY).movementCost == 0)
{//北或南是不可行的，因此这将是一个斜角的运动。
return(true);
}
//如果我们到达这里，我们是对角线，但不是斜角
}
//如果我们在这里，我们要么不斜角，要么不对角
return(false);
}
}
public Path_TileGraph(World world)
{
Debug.Log("Path_TileGraph");
// Loop through all tiles of the world
// For each tile, create a node
// Do we create nodes for non-floor tiles? NO!
// Do we create nodes for tiles that are completely unwalkable (i.e. walls)? NO!
nodes = new Dictionary<Tile, Path_Node<Tile>>();
for (int x = 0; x < world.Width; x++) {
for (int y = 0; y < world.Height; y++) {
Tile t = world.GetTileAt(x,y);
//if(t.movementCost > 0) { // Tiles with a move cost of 0 are unwalkable
Path_Node<Tile> n = new Path_Node<Tile>();
n.data = t;
nodes.Add(t, n);
//}
}
}
Debug.Log("Path_TileGraph: Created "+nodes.Count+" nodes.");
// Now loop through all nodes again
// Create edges for neighbours
int edgeCount = 0;
foreach(Tile t in nodes.Keys) {
Path_Node<Tile> n = nodes[t];
List<Path_Edge<Tile>> edges = new List<Path_Edge<Tile>>();
// Get a list of neighbours for the tile
Tile[] neighbours = t.GetNeighbours(true); // NOTE: Some of the array spots could be null.
// If neighbour is walkable, create an edge to the relevant node.
for (int i = 0; i < neighbours.Length; i++) {
if(neighbours[i] != null && neighbours[i].movementCost > 0 && IsClippingCorner( t, neighbours[i] ) == false) {
// This neighbour exists, is walkable, and doesn't requiring clipping a corner --> so create an edge.
Path_Edge<Tile> e = new Path_Edge<Tile>();
e.cost = neighbours[i].movementCost;
e.node = nodes[ neighbours[i] ];
// Add the edge to our temporary (and growable!) list
edges.Add(e);
edgeCount++;
}
}
n.edges = edges.ToArray();
}
Debug.Log("Path_TileGraph: Created "+edgeCount+" edges.");
}
public Path_TileGraph(World world)
{
// We don't create nodes for non-floor tiles nither unwalkable (i.e. walls) ones. <<-- IMPORTANT
nodes = new Dictionary <Tile, Path_Node <Tile> >();
// Loop through all tiles of the world, creating a node for each one.
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
// Get Tile
Tile t = world.GetTileAt(x, y);
//if (t.movementCost > 0) { // Tiles with movementCost < 0 are unwalkable or empty
// Create node
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
// Add Tile/node pair to dictionary
nodes.Add(t, n);
//}
}
}
int edgeCount = 0; // For debug only
// Loop through all nodes again creating edges for neighbours
foreach (Tile t in nodes.Keys)
{
Path_Node <Tile> node = nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
// Get a list of neighbours for this tile.
Tile[] neighbours = t.GetNeighbours(true); // NOTE: Some of the array spots could be null.
// If neighbour is walkable, create an edge.
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours[i] != null && neighbours[i].movementCost > 0)
{
// Neighbours exists and is walkable
if (IsCuttingCorner(t, neighbours[i]))
{
continue; // Skip to the next neighbour
}
//Creates edge
Path_Edge <Tile> edge = new Path_Edge <Tile>();
edge.cost = neighbours[i].movementCost;
edge.node = nodes[neighbours[i]];
//Add the edge to temporary list
edges.Add(edge);
edgeCount++; // Remove after debug
}
}
// Store edges in the node
node.edges = edges.ToArray();
}
//Debug.Log(nodes.Count + " nodes and " + edgeCount + " edges created!");
}
public Path_TileGraph(World world)
{
Debug.Log("Path_TileGraph");
//Loop through all tiles of the world
//for each tile, create a node
//do we create nodes for non-floor tiles ? NO
//Do we create nodes for tiles that are completely unwalkable (i.e walls ?) NO
nodes = new Dictionary <Tile, Path_Node <Tile> > ();
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile t = world.GetTileAt(x, y);
//if(t.movementCost > 0) { //Tiles witha move cost of 0 are unwalkable
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
nodes.Add(t, n);
//}
}
}
Debug.Log("Path_TileGraph : Created " + nodes.Count + "nodes.");
//now loop through all nodes again
//create edges for neighbours
int edgeCount = 0;
foreach (Tile t in nodes.Keys)
{
Path_Node <Tile> n = nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
//Get a list of nieghbourgs for the tile
Tile[] neighbours = t.GetNeighbours(true); // NOTE : some of the array spots could be likely null !
//if neighbour is walkable, create an edge to the revelant node
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours[i] != null && neighbours[i].movementCost > 0 && IsClippingCorner(t, neighbours[i]) == false)
{
//This neighbour exist and is walkable, and doesn't requiring clipping a corner -- > so create an edge !
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbours[i].movementCost;
e.node = nodes[neighbours[i]];
//add the edge to our temporary and growable list
edges.Add(e);
edgeCount++;
}
}
//on convert la liste en array
n.edges = edges.ToArray();
}
Debug.Log("Path_TileGraph : Created " + edgeCount + "edges.");
}
public Path_TileGraph(World world)
{
Debug.Log("Path_TileGraph");
// Loop through all tiles of the world
// For each tile, create a node
// Do we create nodes for non-floor tiles? No.
// Do we create nodes for tiles that are complete unwalkable? No.
nodes = new Dictionary <Tile, Path_Node <Tile> >();
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile t = world.GetTileAt(x, y);
//if (t.movementCost > 0) // Tiles with move cost 0 are unwalkable
//{
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
nodes.Add(t, n);
//}
}
}
Debug.Log("Path_TileGraph: Created " + nodes.Count + " nodes.");
// Now loop through all nodes again
// Create edges for neighbours
int edgeCount = 0;
foreach (Tile t in nodes.Keys)
{
Path_Node <Tile> n = nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
// Get a list of neighbours for the tile
Tile[] neighbours = t.GetNeighbours(true); // Note: some array spots could be null
// If neighbour is walkable, create an edge to the relevant node.
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours[i] != null && neighbours[i].movementCost > 0 && IsClippingCorner(t, neighbours[i]) == false)
{
// Neighbour exists and is walkable, and doesn't clip corner, create an edge
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbours[i].movementCost;
e.node = nodes[neighbours[i]];
edges.Add(e);
edgeCount++;
}
}
n.edges = edges.ToArray();
}
Debug.Log("Path_TileGraph: Created " + edgeCount + " edges.");
}
public Path_TileGraph(World world)
{
// Debug.Log ("Path_TileGraph");
// looping thourh all the tiles in the world.
// for each tile, create a node
// do not create a node for a blocked tile
nodes = new Dictionary <Tile, Path_Node <Tile> > ();
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile t = world.GetTileAt(x, y);
// tiles with a movement cost of 0 are unwalkable
//if (t.movementCost > 0) {
Path_Node <Tile> n = new Path_Node <Tile> ();
n.data = t;
nodes.Add(t, n);
//}
}
}
// Debug.Log ("Path_TileGraph: Created " + nodes.Count + " nodes.");
// now loop through all nodes again
// and create edges for neighbors
int edgeCount = 0;
foreach (Tile t in nodes.Keys)
{
// Get a list of neighbors for the tile
// for every walkable neighbor, create an edge
Path_Node <Tile> n = nodes [t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> > ();
Tile[] neighbors = t.GetNeighbors(false);
for (int i = 0; i < neighbors.Length; i++)
{
if (neighbors [i] != null && neighbors [i].movementCost > 0)
{
// this neighbor exists and is walkable so crate an edge for it
// remove next check if only going only in straight lines
if (IsClippingCorner(t, neighbors [i]))
{
continue;
}
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbors[i].movementCost;
edges.Add(e);
e.node = nodes[neighbors[i]];
edgeCount++;
}
}
n.edges = edges.ToArray();
}
// Debug.Log("Path_TileGraph: Created "+edgeCount+" edges.");
}
public Path_TileGraph(World world)
{
// Loop through all tiles in the World
// For each tile, create a node
// Do we create nodes for non-floor tiles? Maybe...not sure yet
// Do we create nodes for tiles that are completely unwalkalbe? (walls/buildings) Probably NO
tileToNodeMap = new Dictionary <Tile, Path_Node <Tile> >();
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
Tile tile = world.GetTileAt(x, y);
// Tiles with movementCost of 0 are impassable, 1 is normal & 1> is slower than normal movement
//if (tile.MovementCost > 0)
//{
//}
Path_Node <Tile> path_Node = new Path_Node <Tile>();
path_Node.data = tile;
tileToNodeMap.Add(tile, path_Node);
}
}
// Now loop through all tiles again
// Create edges for neighbours
foreach (Tile tile in tileToNodeMap.Keys)
{
// Get a list of neighbours for the tile
// If neighbour is walkable, create an edge to the relevant node.
Path_Node <Tile> path_Node = tileToNodeMap[tile];
List <Path_Edge <Tile> > path_Edges = new List <Path_Edge <Tile> >();
// Some spots in array might by null (no neighbours, e.g. corner tiles in the World)
Tile[] neighbours = tile.GetNeighbours(true);
for (int i = 0; i < neighbours.Length; i++)
{
// There is a neighbour and the movement cost is more than 0 so it's walkable
if (neighbours[i] != null && neighbours[i].MovementCost > 0)
{
// Check for invalid diagonal clipping/movement, like squeezing through two diagonal walls.
if (IsClippingCorner(tile, neighbours[i]))
{
// Skip to next neighbour, without creating an edge
continue;
}
// Create new path_Edge of type Tile
Path_Edge <Tile> path_Edge = new Path_Edge <Tile>();
// Set travelcost equal to neighbouring tile's movementcost
path_Edge.travelCost = neighbours[i].MovementCost;
// Pair a path_Node, grab that from the dictionary
path_Edge.path_Node = tileToNodeMap[neighbours[i]];
// Add the created edge to the list
path_Edges.Add(path_Edge);
}
}
// Set path_Node's array equal to the path_Edges list, casted to an array
path_Node.edges = path_Edges.ToArray();
}
}
public Path_TileGraph(World _world)
{
//loop through all world walkable floor tiles, and create a Node for each.
Debug.Log("Path_TileGraph");
nodes = new Dictionary <Tile, Path_Node <Tile> >();
for (int x = 0; x < _world.Width; x++)
{
for (int y = 0; y < _world.Height; y++)
{
Tile t = _world.GetTileAt(x, y);
//if (t.MovementCost > 0) //Tiles with cost of 0 are non-walkable
//{
Path_Node <Tile> n = new Path_Node <Tile>();
n.data = t;
nodes.Add(t, n);
//}
}
}
Debug.Log("Path_TileGraph: created " + nodes.Count + " nodes");
int edgeCount = 0;
//Now loop through all nodes and create edges
foreach (Tile t in nodes.Keys)
{
Path_Node <Tile> n = nodes[t];
List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();
//Get list of nieghbours for tiles
Tile[] neighbours = t.GetNeighbours(true); //Some array spots may be null
//create an edge if the nieghbour is walkable
for (int i = 0; i < neighbours.Length; i++)
{
//See if neighbour exists and is walkable
if (neighbours[i] != null && neighbours[i].MovementCost != 0)
{
//make sure we won't clip through wall corners, or squeeze through 2 diagonal walls
if (IsClippingCorner(t, neighbours[i]))
{
continue; //skip to next neighbor with out building edge
}
//create an edge
Path_Edge <Tile> e = new Path_Edge <Tile>();
e.cost = neighbours[i].MovementCost;
e.node = nodes[neighbours[i]];
//add edge to temporary list
edges.Add(e);
edgeCount++;
}
}
n.edges = edges.ToArray();
}
Debug.Log("Path_TileGraph: created " + edgeCount + " edges");
}
