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
19
Source : PathFinder.cs
with MIT License
from dbrizov
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
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
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
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
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
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
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
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
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
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
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
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
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;
}
}