コード例 #1
0
ファイル: Dijkstras.cs プロジェクト: BenjeyBuchey/Pathfinding
    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);
    }
コード例 #2
0
    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);
    }
コード例 #3
0
        // 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);
                }
            }
        }
コード例 #4
0
    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);
    }