public override void StartAlgorithm(TDTile start, TDTile end, TGMap map)
{
algoSteps.Clear();
SimplePriorityQueue <TDTile> frontier = new SimplePriorityQueue <TDTile>();
frontier.Enqueue(start, 0);
Dictionary <TDTile, TDTile> cameFrom = new Dictionary <TDTile, TDTile>();
cameFrom.Add(start, null);
Dictionary <TDTile, float> costSoFar = new Dictionary <TDTile, float>();
costSoFar.Add(start, 0);
float priority = 0.0f;
while (frontier.Count > 0)
{
TDTile currentTile = frontier.Dequeue();
if (currentTile.GetTileType() == (int)TILE_TYPE.ENDPOINT)
{
break;
}
AlgorithmStep algoStep = new AlgorithmStep(currentTile);
algoSteps.Add(algoStep);
foreach (TDTile nextTile in currentTile.neighbours)
{
if (nextTile == null || nextTile.GetTileType() == (int)TILE_TYPE.WATER || nextTile.GetTileType() == (int)TILE_TYPE.WALL)
{
continue;
}
// diagonal step check: if neighbour is diagonal but diagonal step not allowed --> we skip
if (IsDiagonalNeighbour(currentTile, nextTile) && !IsDiagonalStepAllowed())
{
continue;
}
algoTiles.Add(nextTile);
float newCost = costSoFar[currentTile] + map.GetCostByTileType(nextTile.GetTileType());
if (!costSoFar.ContainsKey(nextTile) || newCost < costSoFar[nextTile])
{
costSoFar[nextTile] = newCost;
priority = newCost;
frontier.Enqueue(nextTile, priority);
cameFrom.Add(nextTile, currentTile);
algoStep.NeighbourTiles.Add(nextTile);
}
}
}
GeneratePath(end, cameFrom);
}
public override void StartAlgorithm(TDTile start, TDTile end, TGMap map)
{
algoSteps.Clear();
SimplePriorityQueue <TDTile> frontier = new SimplePriorityQueue <TDTile>();
frontier.Enqueue(start, 0);
Dictionary <TDTile, TDTile> cameFrom = new Dictionary <TDTile, TDTile>();
cameFrom.Add(start, null);
float priority = 0.0f;
while (frontier.Count > 0)
{
TDTile currentTile = frontier.Dequeue();
Debug.Log("Dequeue Tile: " + currentTile.GetHashCode());
if (currentTile.GetTileType() == (int)TILE_TYPE.ENDPOINT)
{
break;
}
AlgorithmStep algoStep = new AlgorithmStep(currentTile);
algoSteps.Add(algoStep);
foreach (TDTile nextTile in currentTile.neighbours)
{
if (nextTile == null || nextTile.GetTileType() == (int)TILE_TYPE.WATER || nextTile.GetTileType() == (int)TILE_TYPE.WALL)
{
continue;
}
// diagonal step check: if neighbour is diagonal but diagonal step not allowed --> we skip
if (IsDiagonalNeighbour(currentTile, nextTile) && !IsDiagonalStepAllowed())
{
continue;
}
algoTiles.Add(nextTile);
if (!cameFrom.ContainsKey(nextTile))
{
priority = Heuristic(end, nextTile) + ComputeVectorCrossProduct(start, end, nextTile); // TODO: add priority field to TDTile? to debug and or display priority in game
frontier.Enqueue(nextTile, priority);
//Debug.Log("Enqueue Tile: " + nextTile.GetHashCode() + " - priority: " + priority);
cameFrom.Add(nextTile, currentTile);
algoStep.NeighbourTiles.Add(nextTile); // WRONG! WE NEED TO LOOK AT THE TILE WITH LOWEST HEURISTIC FIRST
}
}
}
GeneratePath(end, cameFrom);
}
// Creates a hive of radius `r` with cells correctly placed.
// r = 0 means a single cell.
private void createCells(uint r)
{
var c = (GameObject)GameObject.Instantiate(CellTemplate,
transform.position, transform.rotation);
c.transform.parent = transform;
if (r == 0)
{
return;
}
float celldist = c.GetComponent <SpriteRenderer>().bounds.size.x * 0.8f;
AlgorithmStep step = (j, radius) => {
float angle = j * 2 * Mathf.PI / 6f;
var pos = transform.position;
float dx = celldist * Mathf.Sin(angle + 4 * Mathf.PI / 6f),
dy = celldist * Mathf.Cos(angle + 4 * Mathf.PI / 6f);
// Step r times from center
for (uint i = 0; i < radius; ++i)
{
pos.x += celldist * Mathf.Sin(angle);
pos.y += celldist * Mathf.Cos(angle);
}
// Moving with an angle of 120° CW from this direction, create r cells
for (uint i = 0; i < radius; ++i)
{
pos.x += dx;
pos.y += dy;
var cell = (GameObject)GameObject.Instantiate(CellTemplate,
pos, transform.rotation);
cell.transform.parent = transform;
Cells.Add(cell);
}
};
for (int j = 1; j <= r; ++j)
{
for (int i = 0; i < 6; ++i)
{
step(i, j);
}
}
}
public override void StartAlgorithm(TDTile start, TDTile end, TGMap map = null)
{
algoSteps.Clear();
Queue <TDTile> frontier = new Queue <TDTile>();
frontier.Enqueue(start);
Dictionary <TDTile, TDTile> cameFrom = new Dictionary <TDTile, TDTile>();
cameFrom.Add(start, null);
while (frontier.Count > 0)
{
TDTile currentTile = frontier.Dequeue();
if (currentTile.GetTileType() == (int)TILE_TYPE.ENDPOINT)
{
break;
}
AlgorithmStep algoStep = new AlgorithmStep(currentTile);
algoSteps.Add(algoStep);
foreach (TDTile nextTile in currentTile.neighbours)
{
if (nextTile == null || nextTile.GetTileType() == (int)TILE_TYPE.WATER || nextTile.GetTileType() == (int)TILE_TYPE.WALL)
{
continue; // || == START TYLE !?
}
// diagonal step check: if neighbour is diagonal but diagonal step not allowed --> we skip
if (IsDiagonalNeighbour(currentTile, nextTile) && !IsDiagonalStepAllowed())
{
continue;
}
if (!cameFrom.ContainsKey(nextTile))
{
frontier.Enqueue(nextTile);
cameFrom.Add(nextTile, currentTile);
algoStep.NeighbourTiles.Add(nextTile);
}
}
}
GeneratePath(end, cameFrom);
}
