System.Collections.Generic.HashSet.Contains(Tile)

Here are the examples of the csharp api System.Collections.Generic.HashSet.Contains(Tile) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

13 Examples 7

19 Source : PathFinder.cs
with MIT License
from dbrizov

public static List<Tile> FindPath_Dijkstra(TileGrid grid, Tile start, Tile end, List<IVisualStep> outSteps)
        {
            // Visual stuff
            outSteps.Add(new MarkStartTileStep(start));
            outSteps.Add(new MarkEndTileStep(end));
            // ~Visual stuff

            foreach (var tile in grid.Tiles)
            {
                tile.Cost = int.MaxValue;
            }

            start.Cost = 0;

            HashSet<Tile> visited = new HashSet<Tile>();
            visited.Add(start);

            MinHeap<Tile> frontier = new MinHeap<Tile>((lhs, rhs) => lhs.Cost.CompareTo(rhs.Cost));
            frontier.Add(start);

            start.PrevTile = null;

            while (frontier.Count > 0)
            {
                Tile current = frontier.Remove();
                
                // Visual stuff
                if (current != start && current != end)
                {
                    outSteps.Add(new VisitTileStep(current));
                }
                // ~Visual stuff

                if (current == end)
                {
                    break;
                }

                foreach (var neighbor in grid.GetNeighbors(current))
                {
                    int newNeighborCost = current.Cost + neighbor.Weight;
                    if (newNeighborCost < neighbor.Cost)
                    {
                        neighbor.Cost = newNeighborCost;
                        neighbor.PrevTile = current;
                    }

                    if (!visited.Contains(neighbor))
                    {
                        visited.Add(neighbor);
                        frontier.Add(neighbor);

                        // Visual stuff
                        if (neighbor != end)
                        {
                            outSteps.Add(new PushTileInFrontierStep(neighbor, neighbor.Cost));
                        }
                        // ~Visual stuff
                    }
                }
            }

            List<Tile> path = BacktrackToPath(end);

            // Visual stuff
            foreach (var tile in path)
            {
                if (tile == start || tile == end)
                {
                    continue;
                }

                outSteps.Add(new MarkPathTileStep(tile));
            }
            // ~Visual stuff

            return path;
        }

19 Source : PathFinder.cs
with MIT License
from dbrizov

public static List<Tile> FindPath_AStar(TileGrid grid, Tile start, Tile end, List<IVisualStep> outSteps)
        {
            // Visual stuff
            outSteps.Add(new MarkStartTileStep(start));
            outSteps.Add(new MarkEndTileStep(end));
            // ~Visual stuff

            foreach (var tile in grid.Tiles)
            {
                tile.Cost = int.MaxValue;
            }

            start.Cost = 0;

            Comparison<Tile> heuristicComparison = (lhs, rhs) =>
            {
                float lhsCost = lhs.Cost + GetEuclideanHeuristicCost(lhs, end);
                float rhsCost = rhs.Cost + GetEuclideanHeuristicCost(rhs, end);

                return lhsCost.CompareTo(rhsCost);
            };

            MinHeap<Tile> frontier = new MinHeap<Tile>(heuristicComparison);
            frontier.Add(start);

            HashSet<Tile> visited = new HashSet<Tile>();
            visited.Add(start);

            start.PrevTile = null;

            while (frontier.Count > 0)
            {
                Tile current = frontier.Remove();

                // Visual stuff
                if (current != start && current != end)
                {
                    outSteps.Add(new VisitTileStep(current));
                }
                // ~Visual stuff

                if (current == end)
                {
                    break;
                }

                foreach (var neighbor in grid.GetNeighbors(current))
                {
                    int newNeighborCost = current.Cost + neighbor.Weight;
                    if (newNeighborCost < neighbor.Cost)
                    {
                        neighbor.Cost = newNeighborCost;
                        neighbor.PrevTile = current;
                    }

                    if (!visited.Contains(neighbor))
                    {
                        frontier.Add(neighbor);
                        visited.Add(neighbor);

                        // Visual stuff
                        if (neighbor != end)
                        {
                            outSteps.Add(new PushTileInFrontierStep(neighbor, neighbor.Cost));
                        }
                        // ~Visual stuff
                    }
                }
            }

            List<Tile> path = BacktrackToPath(end);

            // Visual stuff
            foreach (var tile in path)
            {
                if (tile == start || tile == end)
                {
                    continue;
                }

                outSteps.Add(new MarkPathTileStep(tile));
            }
            // ~Visual stuff

            return path;
        }

19 Source : PathFinder.cs
with MIT License
from dbrizov

public static List<Tile> FindPath_GreedyBestFirstSearch(TileGrid grid, Tile start, Tile end, List<IVisualStep> outSteps)
        {
            // Visual stuff
            outSteps.Add(new MarkStartTileStep(start));
            outSteps.Add(new MarkEndTileStep(end));
            // ~Visual stuff

            Comparison<Tile> heuristicComparison = (lhs, rhs) =>
            {
                float lhsCost = GetEuclideanHeuristicCost(lhs, end);
                float rhsCost = GetEuclideanHeuristicCost(rhs, end);

                return lhsCost.CompareTo(rhsCost);
            };

            MinHeap<Tile> frontier = new MinHeap<Tile>(heuristicComparison);
            frontier.Add(start);

            HashSet<Tile> visited = new HashSet<Tile>();
            visited.Add(start);

            start.PrevTile = null;

            while (frontier.Count > 0)
            {
                Tile current = frontier.Remove();

                // Visual stuff
                if (current != start && current != end)
                {
                    outSteps.Add(new VisitTileStep(current));
                }
                // ~Visual stuff

                if (current == end)
                {
                    break;
                }

                foreach (var neighbor in grid.GetNeighbors(current))
                {
                    if (!visited.Contains(neighbor))
                    {
                        frontier.Add(neighbor);
                        visited.Add(neighbor);
                        neighbor.PrevTile = current;

                        // Visual stuff
                        if (neighbor != end)
                        {
                            outSteps.Add(new PushTileInFrontierStep(neighbor, 0));
                        }
                        // ~Visual stuff
                    }
                }
            }

            List<Tile> path = BacktrackToPath(end);

            // Visual stuff
            foreach (var tile in path)
            {
                if (tile == start || tile == end)
                {
                    continue;
                }

                outSteps.Add(new MarkPathTileStep(tile));
            }
            // ~Visual stuff

            return path;
        }

19 Source : PathFinder.cs
with MIT License
from dbrizov

public static List<Tile> FindPath_BFS(TileGrid grid, Tile start, Tile end, List<IVisualStep> outSteps)
        {
            // Visual stuff
            outSteps.Add(new MarkStartTileStep(start));
            outSteps.Add(new MarkEndTileStep(end));
            // ~Visual stuff

            HashSet<Tile> visited = new HashSet<Tile>();
            visited.Add(start);

            Queue<Tile> frontier = new Queue<Tile>();
            frontier.Enqueue(start);

            start.PrevTile = null;

            while (frontier.Count > 0)
            {
                Tile current = frontier.Dequeue();

                // Visual stuff
                if (current != start && current != end)
                {
                    outSteps.Add(new VisitTileStep(current));
                }
                // ~Visual stuff

                if (current == end)
                {
                    break;
                }

                foreach (var neighbor in grid.GetNeighbors(current))
                {
                    if (!visited.Contains(neighbor))
                    {
                        visited.Add(neighbor);
                        frontier.Enqueue(neighbor);

                        neighbor.PrevTile = current;

                        // Visual stuff
                        if (neighbor != end)
                        {
                            outSteps.Add(new PushTileInFrontierStep(neighbor, 0));
                        }
                        // ~Visual stuff
                    }
                }
            }

            List<Tile> path = BacktrackToPath(end);

            // Visual stuff
            foreach (var tile in path)
            {
                if (tile == start || tile == end)
                {
                    continue;
                }

                outSteps.Add(new MarkPathTileStep(tile));
            }
            // ~Visual stuff

            return path;
        }

19 Source : TileGridController.cs
with MIT License
from kbrizov

private IEnumerator DisplayDepthFirstTraversal(Tile start)
    {
        replacedert.IsNotNull(m_grid);
        replacedert.IsNotNull(start);

        start.Color = m_startColor;

        var visitedTiles = new HashSet<Tile>();
        visitedTiles.Add(start);

        var frontier = new Stack<Tile>();
        frontier.Push(start);

        while (frontier.Count > 0)
        {
            var current = frontier.Pop();

            if (current != start)
            {
                current.Color = m_visitedTilesColor;
            }

            var neighbors = ShuffleTiles(m_grid.GetNeighbors(current).Where(tile => tile.IsPreplacedable).ToList());
            foreach (var tile in neighbors)
            {
                if (!visitedTiles.Contains(tile))
                {
                    frontier.Push(tile);
                    visitedTiles.Add(tile);

                    tile.Color = m_frontierColor;
                }
            }

            yield return new WaitForSeconds(DEFAULT_WAIT);
        }
    }

19 Source : TileGridController.cs
with MIT License
from kbrizov

private IEnumerator DisplayBreathFirstTraversal(Tile start)
    {
        replacedert.IsNotNull(m_grid);
        replacedert.IsNotNull(start);

        start.Color = m_startColor;

        var visitedTiles = new HashSet<Tile>();
        visitedTiles.Add(start);

        var frontier = new Queue<Tile>();
        frontier.Enqueue(start);

        while (frontier.Count > 0)
        {
            var current = frontier.Dequeue();
            current.Color = m_visitedTilesColor;

            var neighbors = m_grid.GetNeighbors(current);
            foreach (var tile in neighbors)
            {
                if (!visitedTiles.Contains(tile))
                {
                    frontier.Enqueue(tile);
                    visitedTiles.Add(tile);

                    tile.Color = m_frontierColor;
                }
            }

            yield return new WaitForSeconds(DEFAULT_WAIT);
        }
    }

19 Source : TileGridController.cs
with MIT License
from kbrizov

private IEnumerator DisplayDijkstraAlgorithm(Tile start)
    {
        replacedert.IsNotNull(m_grid);
        replacedert.IsNotNull(start);

        var costs = InitializePathCosts(m_grid);
        costs[start] = 0.0f;

        var visited = new HashSet<Tile>();
        visited.Add(start);

        var frontier = new PriorityQueue<Tile>((a, b) => costs[a].CompareTo(costs[b])); // Stable priority queue.
        frontier.Enqueue(start);

        start.Color = m_startColor;
        start.SetText("0");

        while (frontier.Count > 0)
        {
            var current = frontier.Dequeue();
            if (current != start)
            {
                current.Color = m_visitedTilesColor;
            }

            var neighbors = m_grid.GetNeighbors(current);
            foreach (var tile in neighbors)
            {
                var currentCost = costs[tile];
                var newCost = costs[current] + tile.Weight;

                if (newCost < currentCost)
                {
                    costs[tile] = newCost;

                    tile.SetText(newCost.ToString());
                }

                if (!visited.Contains(tile))
                {
                    frontier.Enqueue(tile);
                    visited.Add(tile);

                    tile.Color = m_frontierColor;
                }
            }

            yield return new WaitForSeconds(DEFAULT_WAIT);
        }
    }

19 Source : Room.cs
with GNU General Public License v3.0
from OrderOfThePorcupine

public void replacedignTile(Tile tile)
        {
            if (tiles.Contains(tile))
            {
                // This tile already in this room.
                return;
            }

            if (tile.Room != null)
            {
                // Belongs to some other room.
                tile.Room.tiles.Remove(tile);
            }

            tile.Room = this;
            tiles.Add(tile);
        }

19 Source : Room.cs
with GNU General Public License v3.0
from OrderOfThePorcupine

public void UnreplacedignTile(Tile tile)
        {
            if (boundaryTiles.Contains(tile))
            {
                boundaryTiles.Remove(tile);
            }

            if (tiles.Contains(tile) == false)
            {
                // This tile in not in this room.
                return;
            }

            tile.Room = null;
            tiles.Remove(tile);
        }

19 Source : WorldGenerator.cs
with GNU General Public License v3.0
from OrderOfThePorcupine

private void GrowAsteroid(Tile tile, float depth = 0)
    {
        // This generates a range of sizes around the set size, a larger degre of variance leads to less consistent looking asteroids
        int minSize = asteroidInfo.AsteroidSize - 5;
        int maxSize = asteroidInfo.AsteroidSize + 5;
        if (tile != null)
        {
            currentAsteroid.Add(tile);
            foreach (Tile neighbor in tile.GetNeighbours(false, true))
            {
                if (depth < maxSize && !currentAsteroid.Contains(neighbor) && neighbor.Furniture == null && Random.value < (float)minSize / depth)
                {
                    GrowAsteroid(neighbor, depth + 1);
                }
            }
        }
    }

19 Source : Shape.cs
with GNU General Public License v3.0
from tructv

private void DetectSelfConnection()
        {
            if (selfConnected == false)
                return;

            data.Clear();
            for (int i = 0; i < tiles.Count; i++)
                data.Add(tiles[i]);
            queue.Clear();

            Tile tile = tiles[0];
            Tile tile1;
            data.Remove(tile);
            queue.Enqueue(tile);
            int count = 1;

            while (queue.Count > 0)
            {
                tile = queue.Dequeue();
                for (int i = 0; i < Converter.absDirs.Length; i++)
                {
                    int newIndex = tile.index + Converter.absDirs[i];
                    tile1 = tileGrid[newIndex];
                    if (data.Contains(tile1) && tile.ReachedBorder(i) && tile1.ReachedBorder(3 - i))
                    {
                        data.Remove(tile1);
                        queue.Enqueue(tile1);
                        count++;
                    }
                }
            }
            selfConnected = (count == tiles.Count);
        }

19 Source : BuildingsSummary.cs
with Apache License 2.0
from Warlander

private Room ScanTileForRoom(Map map, bool[,] tilesChecked, int x, int y, int level)
        {
            if (tilesChecked[x, y])
            {
                return null;
            }
            
            HashSet<Tile> checkedTiles = new HashSet<Tile>();
            Stack<Tile> tilesToCheck = new Stack<Tile>();
            HashSet<TileSummary> tilesInRoom = new HashSet<TileSummary>();
            checkedTiles.Add(map[x, y]);
            tilesToCheck.Push(map[x, y]);
            bool noRoom = false;

            while (checkedTiles.Count <= 100 && tilesToCheck.Count > 0)
            {
                Tile checkedTile = tilesToCheck.Pop();
                tilesInRoom.Add(new TileSummary(checkedTile.X, checkedTile.Y, TilePart.Everything));
                
                if (!checkedTile.GetHorizontalHouseWall(level))
                {
                    Tile nearbyTile = map.GetRelativeTile(checkedTile, 0, -1);
                    if (!nearbyTile)
                    {
                        noRoom = true;
                        break;
                    }
                    if (!tilesChecked[nearbyTile.X, nearbyTile.Y] && !checkedTiles.Contains(nearbyTile))
                    {
                        checkedTiles.Add(nearbyTile);
                        tilesToCheck.Push(nearbyTile);
                        
                    }
                    else if (tilesChecked[nearbyTile.X, nearbyTile.Y])
                    {
                        noRoom = true;
                        break;
                    }
                }

                if (!checkedTile.GetVerticalHouseWall(level))
                {
                    Tile nearbyTile = map.GetRelativeTile(checkedTile, -1, 0);
                    if (!nearbyTile)
                    {
                        noRoom = true;
                        break;
                    }
                    if (!tilesChecked[nearbyTile.X, nearbyTile.Y] && !checkedTiles.Contains(nearbyTile))
                    {
                        checkedTiles.Add(nearbyTile);
                        tilesToCheck.Push(nearbyTile);
                    }
                    else if (tilesChecked[nearbyTile.X, nearbyTile.Y])
                    {
                        noRoom = true;
                        break;
                    }
                }

                Tile leftTile = map.GetRelativeTile(checkedTile, 0, 1);
                if (!leftTile)
                {
                    noRoom = true;
                    break;
                }
                if (!tilesChecked[leftTile.X, leftTile.Y] && !leftTile.GetHorizontalHouseWall(level) && !checkedTiles.Contains(leftTile))
                {
                    checkedTiles.Add(leftTile);
                    tilesToCheck.Push(leftTile);
                }
                else if (leftTile.GetHorizontalHouseWall(level))
                {
                    tilesInRoom.Add(new TileSummary(leftTile.X, leftTile.Y, TilePart.HorizontalWallOnly));
                }
                else if (tilesChecked[leftTile.X, leftTile.Y])
                {
                    noRoom = true;
                    break;
                }

                Tile rightTile = map.GetRelativeTile(checkedTile, 1, 0);
                if (!rightTile)
                {
                    noRoom = true;
                    break;
                }
                if (!tilesChecked[rightTile.X, rightTile.Y] && !rightTile.GetVerticalHouseWall(level) && !checkedTiles.Contains(rightTile))
                {
                    checkedTiles.Add(rightTile);
                    tilesToCheck.Push(rightTile);
                }
                else if (rightTile.GetVerticalHouseWall(level))
                {
                    tilesInRoom.Add(new TileSummary(rightTile.X, rightTile.Y, TilePart.VerticalWallOnly));
                }
                else if (tilesChecked[rightTile.X, rightTile.Y])
                {
                    noRoom = true;
                    break;
                }
            }

            if (checkedTiles.Count > 100 || tilesToCheck.Count > 0)
            {
                noRoom = true;
            }

            foreach (Tile tile in checkedTiles)
            {
                tilesChecked[tile.X, tile.Y] = true;
            }

            if (noRoom)
            {
                return null;
            }
            
            return new Room(tilesInRoom);
        }

19 Source : GroundUpdater.cs
with Apache License 2.0
from Warlander

private void FloodFill(Tile tile, GroundData data, GroundData toReplace)
        {
            if (data == toReplace)
            {
                return;
            }
            Map map = GameManager.Instance.Map;
            Stack<Tile> checkStack = new Stack<Tile>();
            checkStack.Push(tile);
            HashSet<Tile> tilesToChange = new HashSet<Tile>();

            while (checkStack.Count != 0)
            {
                Tile anchor = checkStack.Pop();
                if (anchor.Ground.Data == toReplace && !tilesToChange.Contains(anchor))
                {
                    tilesToChange.Add(anchor);
                    AddTileIfNotNull(checkStack, map[anchor.X - 1, anchor.Y]);
                    AddTileIfNotNull(checkStack, map[anchor.X + 1, anchor.Y]);
                    AddTileIfNotNull(checkStack, map[anchor.X, anchor.Y - 1]);
                    AddTileIfNotNull(checkStack, map[anchor.X, anchor.Y + 1]);
                }
            }

            foreach (Tile tileToChange in tilesToChange)
            {
                tileToChange.Ground.Data = data;
            }
        }