public static List <Grid.Position> FindPath(Tile[,] tiles, Grid.Position fromPosition, Grid.Position toPosition)
{
var path = new List <Grid.Position>();
path.Add(fromPosition);
while (fromPosition.x != toPosition.x || fromPosition.y != toPosition.y)
{
if (fromPosition.x < toPosition.x)
{
fromPosition.x += 1;
}
else if (fromPosition.x > toPosition.x)
{
fromPosition.x -= 1;
}
if (fromPosition.y < toPosition.y)
{
fromPosition.y += 1;
}
else if (fromPosition.y > toPosition.y)
{
fromPosition.y -= 1;
}
path.Add(fromPosition);
}
path.Add(toPosition);
return(path);
}
public static List <Grid.Position> FindPath(Tile[,] tiles, Grid.Position fromPosition, Grid.Position toPosition)
{
var path = new List <Grid.Position>();
path.Add(fromPosition);
Grid.Position posi = fromPosition;
while (posi.x != toPosition.x || posi.y != toPosition.y)
{
if (posi.x < toPosition.x)
{
posi.x++;
}
else if (posi.x > toPosition.x)
{
posi.x--;
}
if (posi.y < toPosition.y)
{
posi.y++;
}
else if (posi.y > toPosition.y)
{
posi.y--;
}
path.Add(posi);
}
path.Add(toPosition);
return(path);
}
private static PathNode BreadthFirstSearch(Tile[,] tiles, Grid.Position fromPosition, Grid.Position toPosition)
{
HashSet <PathNode> nodes = new HashSet <PathNode>();
var queue = new Queue <PathNode>();
var root = new PathNode(fromPosition, null);
nodes.Add(root);
queue.Enqueue(root);
while (queue.Count > 0)
{
PathNode node = queue.Dequeue();
if (node.position.x == toPosition.x && node.position.y == toPosition.y)
{
Debug.Log("ACHEI O CARA");
return(node);
}
else
{
TryEnqueueNode(tiles, queue, nodes, node, new Grid.Position(node.position.x + 1, node.position.y));
TryEnqueueNode(tiles, queue, nodes, node, new Grid.Position(node.position.x - 1, node.position.y));
TryEnqueueNode(tiles, queue, nodes, node, new Grid.Position(node.position.x, node.position.y + 1));
TryEnqueueNode(tiles, queue, nodes, node, new Grid.Position(node.position.x, node.position.y - 1));
}
}
return(null);
}
public static List <Grid.Position> FindPath(Tile[,] tiles, Grid.Position fromPosition, Grid.Position toPosition)
{
PathNode node = BreadthFirstSearch(tiles, fromPosition, toPosition);
var path = new List <Grid.Position>();
path.Reverse();
return(path);
}
public static List <Grid.Position> FindPath(Tile[,] tiles, Grid.Position fromPos, Grid.Position toPosition)
{
Queue <Grid.Position> queue = new Queue <Grid.Position>();
HashSet <Grid.Position> path = new HashSet <Grid.Position>();
List <Grid.Position> returnPath = new List <Grid.Position>();
Grid.Position[,] Tiles = new Grid.Position[tiles.GetLength(0), tiles.GetLength(1)];
Tiles[fromPos.x, fromPos.y] = fromPos;
queue.Enqueue(fromPos);
while (queue.Count > 0)
{
Grid.Position posDequeued = queue.Dequeue();
if (posDequeued.Equals(toPosition))
{
returnPath.Add(posDequeued);
while (posDequeued.x != fromPos.x || posDequeued.y != fromPos.y)
{
posDequeued = Tiles[posDequeued.x, posDequeued.y];
returnPath.Add(posDequeued);
}
returnPath.Reverse();
break;
}
else
{
if (Tile.InsideGrid(new Grid.Position(posDequeued.x, posDequeued.y + 1), tiles) &&
!path.Contains(new Grid.Position(posDequeued.x, posDequeued.y + 1)))
{
queue.Enqueue(new Grid.Position(posDequeued.x, posDequeued.y + 1));
path.Add(posDequeued);
Tiles[posDequeued.x, posDequeued.y + 1] = posDequeued;
}
if (Tile.InsideGrid(new Grid.Position(posDequeued.x, posDequeued.y - 1), tiles) &&
!path.Contains(new Grid.Position(posDequeued.x, posDequeued.y - 1)))
{
queue.Enqueue(new Grid.Position(posDequeued.x, posDequeued.y - 1));
path.Add(posDequeued);
Tiles[posDequeued.x, posDequeued.y - 1] = posDequeued;
}
if (Tile.InsideGrid(new Grid.Position(posDequeued.x + 1, posDequeued.y), tiles) &&
!path.Contains(new Grid.Position(posDequeued.x + 1, posDequeued.y)))
{
queue.Enqueue(new Grid.Position(posDequeued.x + 1, posDequeued.y));
path.Add(posDequeued);
Tiles[posDequeued.x + 1, posDequeued.y] = posDequeued;
}
if (Tile.InsideGrid(new Grid.Position(posDequeued.x - 1, posDequeued.y), tiles) &&
!path.Contains(new Grid.Position(posDequeued.x - 1, posDequeued.y)))
{
queue.Enqueue(new Grid.Position(posDequeued.x - 1, posDequeued.y));
path.Add(posDequeued);
Tiles[posDequeued.x - 1, posDequeued.y] = posDequeued;
}
}
}
return(returnPath);
}
IEnumerator IgoToPosition(List <Grid.Position> path, Vector3 tileSpacing)
{
foreach (Grid.Position p in path)
{
position = p;
transform.localPosition = p.ToWorldPosition(tileSpacing, 1.0f);
yield return(new WaitForSeconds(0.1f));
}
}
public override bool Equals(object pos)
{
if (!(pos is Grid.Position))
{
return(false);
}
Grid.Position position = (Grid.Position)pos;
return(position.x == this.x && position.y == this.y);
}
private static void Solve(Grid.Grid grid, GridWalker.GridSolver solver)
{
int height;
int width;
var position = new Grid.Position(grid);
solver.Solve(position, out height, out width);
Console.WriteLine("Solved [{0}x{1}] using {2} with {3} wall checks, {4} steps, and {5} turns", height, width, solver.GetType()
, position.WallChecksMade, position.StepsTaken, position.TurnsMade);
}
public static bool InsideGrid(Grid.Position pos, Tile[,] tiles)
{
if (pos.x < 0 || pos.x >= tiles.GetLength(0) || pos.y < 0 || pos.y >= tiles.GetLength(1) || tiles[pos.x, pos.y].isWall)
{
return(false);
}
else
{
return(true);
}
}
public static bool IsinTile(Grid.Position posi, Tile[,] tiles)
{
if (posi.x >= 0 && posi.x < tiles.GetLength(0) && posi.y >= 0 && posi.y < tiles.GetLength(1) && !tiles[posi.x, posi.y].isWall)
{
return(true);
}
else
{
return(false);
}
}
public static List <Grid.Position> FindPath(Tile[,] tiles, Grid.Position fromPosition, Grid.Position toPosition)
{
PathNode node = BreadthFirstSearch(tiles, fromPosition, toPosition);
var path = new List <Grid.Position>();
while (node != null)
{
path.Add(node.position);
node = node.parent;
}
path.Reverse();
return(path);
}
public IEnumerator Walk(List <Grid.Position> positionsToWalk, Vector2 spacing)
{
Ismoving = true;
for (int i = 1; i < positionsToWalk.Count; i++)
{
while (Vector3.Distance(transform.position, positionsToWalk[i].ToWorldPosition(spacing, 1f)) > 0.1f)
{
transform.position = Vector3.MoveTowards(transform.position, positionsToWalk[i].ToWorldPosition(spacing, 1f), 5 * Time.deltaTime);
yield return(new WaitForSeconds(Time.deltaTime));
Debug.Log("AQui");
}
}
position = positionsToWalk[positionsToWalk.Count - 1];
Ismoving = false;
}
public static List <Grid.Position> FindPath(Tile[,] tiles, Grid.Position fromPosition, Grid.Position toPosition)
{
var GridPosition = new Grid.Position();
var path = new List <Grid.Position>();
GridPosition == fromPosition.x;
path.Add(fromPosition);
path.Add(toPosition);
while (GridPosition < toPosition.x)
{
GridPosition++;
}
return(path);
}
public void MoveTo(Position targetPosition)
{
if (!player.Ismoving)
{
foreach (Tile tile in tiles)
{
tile.Highlight(false);
}
if (tiles[targetPosition.x, targetPosition.y].isWall)
{
Debug.Log("é uma parede");
if (!tiles[targetPosition.x - 1, targetPosition.y].isWall)
{
targetPosition = new Grid.Position {
x = targetPosition.x - 1, y = targetPosition.y
};
}
else if (!tiles[targetPosition.x + 1, targetPosition.y].isWall)
{
targetPosition = new Grid.Position {
x = targetPosition.x + 1, y = targetPosition.y
};
}
else if (!tiles[targetPosition.x, targetPosition.y + 1].isWall)
{
targetPosition = new Grid.Position {
x = targetPosition.x, y = targetPosition.y + 1
};
}
else if (!tiles[targetPosition.x, targetPosition.y - 1].isWall)
{
targetPosition = new Grid.Position {
x = targetPosition.x, y = targetPosition.y - 1
};
}
}
List <Position> path = PathFinder.FindPath(tiles, player.position, targetPosition, PathFinder.Method.Second);
foreach (Position position in path)
{
tiles[position.x, position.y].Highlight(true);
}
StartCoroutine(player.Walk(path, tileSpacing));
}
}
public static List <Grid.Position> FindPath(Tile[,] tiles, Grid.Position fromPosition, Grid.Position toPosition)
{
var path = new List <Grid.Position>();
Queue <Grid.Position> q = new Queue <Grid.Position>();
q.Enqueue(fromPosition);
Grid.Position[,] caminho = new Grid.Position[tiles.GetLength(0), tiles.GetLength(1)];
var p = q.Dequeue();
while (p.x != toPosition.x || p.y != toPosition.y)
{
if (p.x == toPosition.x && p.y == toPosition.y)
{
Debug.Log("Achei");
break;
}
else
{
if (p.x != toPosition.x)
{
if (p.x < toPosition.x)
{
p.x++;
}
else
{
p.x--;
}
}
if (p.y != toPosition.y)
{
if (p.y < toPosition.y)
{
p.y++;
}
else
{
p.y--;
}
}
path.Add(p);
}
}
return(path);
}
public static List <Grid.Position> FindPath(Tile[,] tiles, Grid.Position fromPosition, Grid.Position toPosition, Method method)
{
var path = new List <Grid.Position>();
path.Add(fromPosition);
if (method == Method.First)
{
Grid.Position position = fromPosition;
while (position.x != toPosition.x || position.y != toPosition.y)
{
if (position.x > toPosition.x)
{
position.x--;
}
else if (position.x < toPosition.x)
{
position.x++;
}
if (position.y > toPosition.y)
{
position.y--;
}
else if (position.y < toPosition.y)
{
position.y++;
}
path.Add(position);
}
}
else if (method == Method.Second)
{
return(Search(fromPosition, toPosition, tiles));
}
return(path);
}
public static List <Grid.Position> FindPath(Tile[,] tiles, Grid.Position fromPosition, Grid.Position toPosition)
{
int x = fromPosition.x;
int y = fromPosition.y;
int i;
var path = new List <Grid.Position>();
var middlePosition = new Grid.Position();
path.Add(fromPosition);
path.Add(middlePosition);
path.Add(toPosition);
for (i = 0; i <= x; i++)
{
middlePosition.x = fromPosition.x + i;
// Debug.Log("Valor do i " + i);
if (i == x)
{
i = 0;
}
}
for (i = 0; i <= y; i++)
{
middlePosition.y = fromPosition.y + i;
if (i == y)
{
i = 0;
}
}
Debug.Log("Posição inicial: " + fromPosition);
Debug.Log("Posição final: " + toPosition);
Debug.Log("Posição do meio: " + middlePosition);
return(path);
}
private static void TryEnqueueNode(Tile[,] tiles, Queue <PathNode> queue, HashSet <PathNode> nodes, PathNode currentNode, Grid.Position position)
{
int width = tiles.GetLength(0);
int height = tiles.GetLength(1);
if (position.x > width || position.x < 0 || position.y > height || position.y < 0)
{
Debug.Log("Não está na grade");
return;
}
else
{
var node = new PathNode(position, currentNode);
nodes.Add(node);
queue.Enqueue(node);
}
}
public static List <Grid.Position> FindPath(Tile[,] tiles, Grid.Position fromPosition, Grid.Position toPosition)
{
Queue <Grid.Position> queue = new Queue <Grid.Position>();
List <Grid.Position> grid = new List <Grid.Position>();
HashSet <Grid.Position> path = new HashSet <Grid.Position>();
Grid.Position[,] Tiles = new Grid.Position[tiles.GetLength(0), tiles.GetLength(1)];
queue.Enqueue(fromPosition);
Tiles[fromPosition.x, fromPosition.y] = fromPosition;
if (tiles[toPosition.x, toPosition.y].isWall)
{
return(new List <Grid.Position>());
// return Tile(tiles [toPosition.x, toPosition.y]);
}
while (queue.Count > 0)
{
Grid.Position dequeuepos = queue.Dequeue();
if (dequeuepos.Equals(toPosition))
{
grid.Add(dequeuepos);
while (dequeuepos.x != fromPosition.x || dequeuepos.y != fromPosition.y)
{
dequeuepos = Tiles[dequeuepos.x, dequeuepos.y];
grid.Add(dequeuepos);
}
grid.Reverse();
break;
}
else
{
if (Tile.InsideGrid(new Grid.Position(dequeuepos.x - 1, dequeuepos.y), tiles) && !path.Contains(new Grid.Position(dequeuepos.x - 1, dequeuepos.y)))
{
queue.Enqueue(new Grid.Position(dequeuepos.x - 1, dequeuepos.y));
path.Add(new Grid.Position(dequeuepos.x - 1, dequeuepos.y));
Tiles[dequeuepos.x - 1, dequeuepos.y] = dequeuepos;
}
if (Tile.InsideGrid(new Grid.Position(dequeuepos.x + 1, dequeuepos.y), tiles) && !path.Contains(new Grid.Position(dequeuepos.x + 1, dequeuepos.y)))
{
queue.Enqueue(new Grid.Position(dequeuepos.x + 1, dequeuepos.y));
path.Add(new Grid.Position(dequeuepos.x + 1, dequeuepos.y));
Tiles[dequeuepos.x + 1, dequeuepos.y] = dequeuepos;
}
if (Tile.InsideGrid(new Grid.Position(dequeuepos.x, dequeuepos.y + 1), tiles) && !path.Contains(new Grid.Position(dequeuepos.x, dequeuepos.y + 1)))
{
queue.Enqueue(new Grid.Position(dequeuepos.x, dequeuepos.y + 1));
path.Add(new Grid.Position(dequeuepos.x, dequeuepos.y + 1));
Tiles[dequeuepos.x, dequeuepos.y + 1] = dequeuepos;
}
if (Tile.InsideGrid(new Grid.Position(dequeuepos.x, dequeuepos.y - 1), tiles) && !path.Contains(new Grid.Position(dequeuepos.x, dequeuepos.y - 1)))
{
queue.Enqueue(new Grid.Position(dequeuepos.x, dequeuepos.y - 1));
path.Add(new Grid.Position(dequeuepos.x, dequeuepos.y - 1));
Tiles[dequeuepos.x, dequeuepos.y - 1] = dequeuepos;
}
if (Tile.InsideGrid(new Grid.Position(dequeuepos.x + 1, dequeuepos.y + 1), tiles) && !path.Contains(new Grid.Position(dequeuepos.x + 1, dequeuepos.y + 1)))
{
queue.Enqueue(new Grid.Position(dequeuepos.x + 1, dequeuepos.y + 1));
path.Add(new Grid.Position(dequeuepos.x + 1, dequeuepos.y + 1));
Tiles[dequeuepos.x + 1, dequeuepos.y + 1] = dequeuepos;
}
if (Tile.InsideGrid(new Grid.Position(dequeuepos.x - 1, dequeuepos.y + 1), tiles) && !path.Contains(new Grid.Position(dequeuepos.x - 1, dequeuepos.y + 1)))
{
queue.Enqueue(new Grid.Position(dequeuepos.x - 1, dequeuepos.y + 1));
path.Add(new Grid.Position(dequeuepos.x - 1, dequeuepos.y + 1));
Tiles[dequeuepos.x - 1, dequeuepos.y + 1] = dequeuepos;
}
if (Tile.InsideGrid(new Grid.Position(dequeuepos.x + 1, dequeuepos.y - 1), tiles) && !path.Contains(new Grid.Position(dequeuepos.x + 1, dequeuepos.y - 1)))
{
queue.Enqueue(new Grid.Position(dequeuepos.x + 1, dequeuepos.y - 1));
path.Add(new Grid.Position(dequeuepos.x + 1, dequeuepos.y - 1));
Tiles[dequeuepos.x + 1, dequeuepos.y - 1] = dequeuepos;
}
if (Tile.InsideGrid(new Grid.Position(dequeuepos.x - 1, dequeuepos.y - 1), tiles) && !path.Contains(new Grid.Position(dequeuepos.x - 1, dequeuepos.y - 1)))
{
queue.Enqueue(new Grid.Position(dequeuepos.x - 1, dequeuepos.y - 1));
Tiles[dequeuepos.x - 1, dequeuepos.y - 1] = dequeuepos;
path.Add(new Grid.Position(dequeuepos.x - 1, dequeuepos.y - 1));
}
}
}
return(grid);
}
public static List <Grid.Position> Search(Grid.Position myPosition, Grid.Position positionToFind, Tile[,] tiles)
{
int width = tiles.GetLength(0);
int heigth = tiles.GetLength(1);
Queue <Grid.Position> fila = new Queue <Grid.Position>();
List <Grid.Position> path = new List <Grid.Position>();
fila.Enqueue(myPosition);
HashSet <Grid.Position> PlacesVisited = new HashSet <Grid.Position>();
Grid.Position[,] Paths = new Grid.Position[tiles.GetLength(0), tiles.GetLength(1)];
Paths[myPosition.x, myPosition.y] = myPosition;
while (fila.Count > 0)
{
Grid.Position current = fila.Dequeue();
if (current.x == positionToFind.x && current.y == positionToFind.y)
{
path.Add(current);
while (current.x != myPosition.x || current.y != myPosition.y)
{
current = Paths[current.x, current.y];
path.Add(current);
}
path.Reverse();
break;
}
else
{
if (!PlacesVisited.Contains(new Grid.Position {
x = current.x + 1, y = current.y
}) &&
IsinTile(new Grid.Position {
x = current.x + 1, y = current.y
}, tiles))
{
fila.Enqueue(new Grid.Position {
x = current.x + 1, y = current.y
});
PlacesVisited.Add(new Grid.Position {
x = current.x + 1, y = current.y
});
Paths[current.x + 1, current.y] = current;
}
if (!PlacesVisited.Contains(new Grid.Position {
x = current.x - 1, y = current.y
}) &&
IsinTile(new Grid.Position {
x = current.x - 1, y = current.y
}, tiles))
{
fila.Enqueue(new Grid.Position {
x = current.x - 1, y = current.y
});
PlacesVisited.Add(new Grid.Position {
x = current.x - 1, y = current.y
});
Paths[current.x - 1, current.y] = current;
}
if (!PlacesVisited.Contains(new Grid.Position {
x = current.x, y = current.y + 1
}) &&
IsinTile(new Grid.Position {
x = current.x, y = current.y + 1
}, tiles))
{
fila.Enqueue(new Grid.Position {
x = current.x, y = current.y + 1
});
PlacesVisited.Add(new Grid.Position {
x = current.x, y = current.y + 1
});
Paths[current.x, current.y + 1] = current;
}
if (!PlacesVisited.Contains(new Grid.Position {
x = current.x, y = current.y - 1
}) &&
IsinTile(new Grid.Position {
x = current.x, y = current.y - 1
}, tiles))
{
fila.Enqueue(new Grid.Position {
x = current.x, y = current.y - 1
});
PlacesVisited.Add(new Grid.Position {
x = current.x, y = current.y - 1
});
Paths[current.x, current.y - 1] = current;
}
if (!PlacesVisited.Contains(new Grid.Position {
x = current.x + 1, y = current.y + 1
}) &&
IsinTile(new Grid.Position {
x = current.x + 1, y = current.y + 1
}, tiles))
{
fila.Enqueue(new Grid.Position {
x = current.x + 1, y = current.y + 1
});
PlacesVisited.Add(new Grid.Position {
x = current.x + 1, y = current.y + 1
});
Paths[current.x + 1, current.y + 1] = current;
}
if (!PlacesVisited.Contains(new Grid.Position {
x = current.x - 1, y = current.y + 1
}) &&
IsinTile(new Grid.Position {
x = current.x - 1, y = current.y + 1
}, tiles))
{
fila.Enqueue(new Grid.Position {
x = current.x - 1, y = current.y + 1
});
PlacesVisited.Add(new Grid.Position {
x = current.x - 1, y = current.y + 1
});
Paths[current.x - 1, current.y + 1] = current;
}
if (!PlacesVisited.Contains(new Grid.Position {
x = current.x + 1, y = current.y - 1
}) &&
IsinTile(new Grid.Position {
x = current.x + 1, y = current.y - 1
}, tiles))
{
fila.Enqueue(new Grid.Position {
x = current.x + 1, y = current.y - 1
});
PlacesVisited.Add(new Grid.Position {
x = current.x + 1, y = current.y - 1
});
Paths[current.x + 1, current.y - 1] = current;
}
if (!PlacesVisited.Contains(new Grid.Position {
x = current.x - 1, y = current.y - 1
}) &&
IsinTile(new Grid.Position {
x = current.x - 1, y = current.y - 1
}, tiles))
{
fila.Enqueue(new Grid.Position {
x = current.x - 1, y = current.y - 1
});
PlacesVisited.Add(new Grid.Position {
x = current.x - 1, y = current.y - 1
});
Paths[current.x - 1, current.y - 1] = current;
}
}
}
return(path);
}
public PathNode(Grid.Position position, PathNode parent)
{
this.position = position;
this.parent = parent;
}
/**
* Generate all of GameObjects from currentGrid.
*/
private void DrawTiles()
{
Grid grid = currentGrid;
tiles = new GameObject[grid.Width, grid.Length];
List <Grid.Position> waypoints = grid.Waypoints;
Grid.Position currentPos = new Grid.Position(0, 0);
bool isWaypoint = false;
Grid.TileType currentTile;
Vector3 tileScale = new Vector3(tileWidth, tileHeight, tileLength);
for (int x = 0; x < grid.Width; x++) // along x-axis in the world
{
for (int z = 0; z < grid.Length; z++) // along z-axis in the world
{
isWaypoint = false;
currentPos.UpdatePosition(x, z);
currentTile = grid.At(x, z);
// figure out if current position is a waypoint if on path
if (currentTile == Grid.TileType.path || currentTile == Grid.TileType.end)
{
foreach (Grid.Position p in waypoints)
{
if (p == currentPos)
{
isWaypoint = true;
break;
}
}
}
Vector3 worldPosition = new Vector3(x * tileWidth, 0, z * tileLength);
// Vector3 worldPosition = new Vector3(z*tileLength, 0, x*tileWidth);
GameObject tile;
switch (currentTile)
{
case Grid.TileType.terrain:
tile = GameObject.CreatePrimitive(PrimitiveType.Cube);
tile.name = "Terrain-" + x + "," + z;
tile.tag = "TerrainTile";
tile.GetComponent <Renderer>().material.mainTexture =
Resources.Load <Texture2D>(TerrainTexture);
break;
case Grid.TileType.path:
tile = GameObject.CreatePrimitive(PrimitiveType.Cube);
tile.name = "Path-" + x + "," + z;
tile.tag = "PathTile";
tile.GetComponent <Renderer>().material.mainTexture =
Resources.Load <Texture2D>(PathTexture);
break;
case Grid.TileType.start:
tile = GameObject.CreatePrimitive(PrimitiveType.Cube);
startTile = tile;
tile.name = "Start-" + x + "," + z;
tile.tag = "StartTile";
GameObject portal =
Instantiate(Resources.Load("Portal/Orbs/Prefabs/Portal")) as GameObject;
portal.name = "Portal";
portal.transform.parent = tile.transform;
portal.transform.localScale = new Vector3(2f, 2f, 2f);
portal.transform.localPosition = new Vector3(0f, 2.5f, 0f);
portal.transform.Rotate(new Vector3(0f, 0f, 90f));
tile.AddComponent <SpawnPoint>();
tile.GetComponent <SpawnPoint>().ground = this;
tile.GetComponent <SpawnPoint>().player = player;
tile.GetComponent <Renderer>().material.mainTexture =
Resources.Load <Texture2D>(PathTexture);
break;
case Grid.TileType.end:
tile = GameObject.CreatePrimitive(PrimitiveType.Cube);
endTile = tile;
tile.name = "End-" + x + "," + z;
tile.tag = "EndTile";
GameObject house =
Instantiate(Resources.Load("Baker House/Prefabs/Baker_house")) as GameObject;
house.name = "Lorham";
house.transform.parent = tile.transform;
house.transform.localScale = new Vector3(0.1f, 0.1f, 0.4f);
house.transform.localPosition = new Vector3(0f, 0.5f, 0f);
house.transform.Rotate(new Vector3(-90f, 0f, 0f));
house.AddComponent <AudioSource>();
houseAudioSource = house.GetComponent <AudioSource>();
house.SetActive(true);
tile.GetComponent <Renderer>().material.mainTexture =
Resources.Load <Texture2D>(PathTexture);
break;
case Grid.TileType.border:
tile = GameObject.CreatePrimitive(PrimitiveType.Cube);
tile.name = "Border-" + x + "," + z;
tile.tag = "BorderTile";
tile.AddComponent <Border>();
tile.GetComponent <Renderer>().material.mainTexture =
Resources.Load <Texture2D>(BorderTexture);
break;
default:
Debug.LogError("Unrecognized tile type: " + grid.At(x, z).ToString());
return;
}
// setting this as child of ground object
tile.transform.parent = transform;
// update object position in world space
tile.transform.localScale = tileScale;
tile.transform.position = worldPosition;
// add Tile component and update its internal state
tile.AddComponent <Tile>();
tile.GetComponent <Tile>().GridLocX = x;
tile.GetComponent <Tile>().GridLocY = z;
tile.GetComponent <Tile>().IsWaypoint = isWaypoint;
// add it to the tiles variable to keep track it
tiles[x, z] = tile;
}
}
// save the waypoints transformations so mobs can follow
foreach (Grid.Position w in waypoints)
{
GameObject tile = tiles[w.X, w.Y];
Debug.Assert(tile.name.Contains("Path") || tile.name.Contains("End"));
Debug.Assert(tile.GetComponent <Tile>().IsWaypoint);
waypointTransforms.Add(tile.GetComponent <Tile>().waypoint);
}
// identify neighboring tiles as buildable
for (int x = 0; x < grid.Width; x++)
{
for (int z = 0; z < grid.Length; z++)
{
currentPos.UpdatePosition(x, z);
GameObject tile = tiles[currentPos.X, currentPos.Y];
if (!tile.tag.Contains("Path"))
{
continue;
}
List <Grid.Position> neighbors = currentPos
.BuildNeighbors()
.FindAll(n => !n.OutOfBound(grid));
foreach (Grid.Position n in neighbors)
{
GameObject neighbor = tiles[n.X, n.Y];
if (neighbor.tag.Contains("Terrain"))
{
neighbor.GetComponent <Tile>().IsBuildable = true;
}
}
}
}
}
private static void TryEnqueueNode(Tile[,] tiles, Queue <PathNode> queue, HashSet <PathNode> nodes, PathNode currentNode, Grid.Position position)
{
int wBorder = tiles.GetLength(0);
int hBorder = tiles.GetLength(1);
if (position.x > wBorder || position.x < 0 || position.y > hBorder || position.y < 0)
{
return;
}
else
{
var node = new PathNode(position, currentNode);
nodes.Add(node);
queue.Enqueue(node);
}
}
public void SetPosition(Grid.Position toPosition, Vector2 spacing)
{
this.position = toPosition;
transform.localPosition = toPosition.ToWorldPosition(spacing, 1.0f);
}
public static List <Grid.Position> FindPath(Tile[,] tiles, Grid.Position fromPosition, Grid.Position toPosition)
{
var path = new List <Grid.Position>();
List <Grid.Position> lista = new List <Grid.Position> {
};
Queue <Grid.Position> Q1 = new Queue <Grid.Position>();
Q1.Enqueue(fromPosition);
while (Q1.Count > 0)
{
Grid.Position p = Q1.Dequeue();
if (p.x == toPosition.x && p.y == toPosition.y)
{
Debug.Log("Achei o cara");
break;
}
else
{
Grid.Position seeker1 = new Grid.Position {
x = p.x, y = p.y + 1
};
Grid.Position seeker2 = new Grid.Position {
x = p.x, y = p.y - 1
};
Grid.Position seeker3 = new Grid.Position {
x = p.x + 1, y = p.y
};
Grid.Position seeker4 = new Grid.Position {
x = p.x + 1, y = p.y
};
if (lista.Contains(seeker1))
{
Q1.Enqueue(seeker1);
}
if (lista.Contains(seeker2))
{
Q1.Enqueue(seeker2);
}
if (lista.Contains(seeker3))
{
Q1.Enqueue(seeker3);
}
if (lista.Contains(seeker4))
{
Q1.Enqueue(seeker4);
}
lista.Add(seeker1);
lista.Add(seeker2);
lista.Add(seeker3);
lista.Add(seeker4);
if (toPosition.x == seeker1.x && toPosition.y == seeker1.y)
{
jaVisitou();
}
if (toPosition.x == seeker2.x && toPosition.y == seeker2.y)
{
jaVisitou();
}
if (toPosition.x == seeker3.x && toPosition.y == seeker3.y)
{
jaVisitou();
}
if (toPosition.x == seeker4.x && toPosition.y == seeker4.y)
{
jaVisitou();
}
}
}
path.Add(fromPosition);
Grid.Position posi = fromPosition;
/*while(posi.x != toPosition.x || posi.y != toPosition.y)
* {
* if(posi.x < toPosition.x)
* { posi.x++; }
* else if (posi.x>toPosition.x) { posi.x--; }
*
* if (posi.y < toPosition.y)
* { posi.y++; }
* else if (posi.y> toPosition.y) { posi.y--; }
*
* path.Add(posi);
* }*/
path.Add(toPosition);
return(path);
}
