private static void WrapFloorWithWallTiles(TileMap <TileType> result)
{
int2[] directions = new int2[]
{
new int2(0, 1),
new int2(1, 1),
new int2(1, 0),
new int2(1, -1),
new int2(0, -1),
new int2(-1, -1),
new int2(-1, 0),
new int2(-1, 1)
};
int2[] floorTiles = result.GetPresentTiles();
for (int i = 0; i < floorTiles.Length; i++)
{
for (int j = 0; j < directions.Length; j++)
{
int2 targetTile = floorTiles[i] + directions[j];
if (result[targetTile] != TileType.Floor)
{
Zone zone = result.Layout.FindZoneByPosition(targetTile);
if (zone != null)
{
zone.tiles.Add(targetTile);
result.Add(targetTile, TileType.Wall);
}
}
}
}
}
public void PassTileMapWithTiles()
{
TileMap <TileType> originalMap = new TileMap <TileType>();
Zone zoneA = new Zone();
zoneA.tiles.Add(new int2(0, 0));
zoneA.tiles.Add(new int2(9, 7));
zoneA.tiles.Add(new int2(34, 58));
originalMap.Layout.Add(zoneA);
originalMap.Add(new int2(0, 0), TileType.Floor);
originalMap.Add(new int2(9, 7), TileType.Wall);
originalMap.Add(new int2(34, 58), TileType.Floor);
TileMap <TileType> passedMap = PassValueToScript(originalMap);
Assert.IsTrue(passedMap[0, 0] == TileType.Floor);
Assert.IsTrue(passedMap[9, 7] == TileType.Wall);
Assert.IsTrue(passedMap[34, 58] == TileType.Floor);
}
private void GenerateMapColumn(int x, int startZ, int count, List <TileTypes> tileList)
{
for (int i = 0; i < count; i++)
{
HexCoords hexCoords = new HexCoords(x, startZ);
int chosenTileIdx = random.Next(tileList.Count);
TileMap.Add(hexCoords, tileList[chosenTileIdx]);
//delete the chosen tile from the list so we don't use it again
tileList.RemoveAt(chosenTileIdx);
startZ++;
}
}
// #### TileMap Helpers
private static void AddFloorTiles(TileMap <TileType> result)
{
var zoneEnumerator = result.Layout.Zones.Nodes.GetEnumerator();
while (zoneEnumerator.MoveNext())
{
Zone zone = zoneEnumerator.Current.Value;
var tileEnumerator = zone.GetEnumerator();
while (tileEnumerator.MoveNext())
{
result.Add(tileEnumerator.Current, TileType.Floor);
}
}
}
public static void AddOrUpdate(TileData[] tilesAddOrUpdate, ObjectData[] objAddOrUpdate, int[] removedObjects)
{
Task.Factory.StartNew(() =>
{
foreach (var i in removedObjects)
{
Objects.Remove(i);
}
foreach (var i in tilesAddOrUpdate)
{
var pos = new Point(i.X, i.Y);
var tile = new Tile(pos.X, pos.Y, i.Id);
if (TileMap.ContainsKey(pos))
{
TileMap[pos] = tile;
}
else
{
TileMap.Add(pos, tile);
}
}
foreach (var i in objAddOrUpdate)
{
if (Objects.ContainsKey(i.ObjectId))
{
Objects[i.ObjectId].SetDistination(i.X, i.Y);
Objects[i.ObjectId].ImportStat(i.Stats);
if (i.LastDirection != -1)
{
if (Objects[i.ObjectId] is Player)
{
((Player)Objects[i.ObjectId]).CurrentDirection = (Direction)i.LastDirection;
}
else
{
((Entity)Objects[i.ObjectId]).CurrentDirection = (Direction)i.LastDirection;
}
}
}
else
{
if (i.IsPlayer)
{
HandlePlayer(i);
}
else if (i.IsEntity)
{
HandleEntity(i);
}
else
{
HandleObject(i);
}
}
}
});
}
public static TileMap <T> Convert <U, T>(this TileMap <U> map, Func <U, T> conversionFunction)
{
TileMap <T> result = new TileMap <T>();
Layout resultLayout = new Layout();
result.Layout = resultLayout;
// Add zones & tiles
Graph <Zone> mapGraph = map.Layout.Zones;
Zone zone;
for (int i = 0; i < mapGraph.Count; i++)
{
zone = mapGraph.Nodes[i].Value;
RectangleInt bounds = zone.bounds;
Zone newZone = new Zone(bounds.x, bounds.y, bounds.width, bounds.height);
var enumerator = zone.GetEnumerator();
int2 tile;
while (enumerator.MoveNext())
{
tile = enumerator.Current;
newZone.tiles.Add(tile);
result.Add(tile, conversionFunction(map[tile.x, tile.y]));
}
resultLayout.Add(newZone);
}
// Link layout Zones
Zone resultZone;
for (int i = 0; i < mapGraph.Count; i++)
{
zone = mapGraph.Nodes[i].Value;
GraphNode <Zone> mapZoneNode = mapGraph.Nodes.FindByValue(zone) as GraphNode <Zone>;
resultZone = resultLayout.FindZoneByPosition(zone.bounds.Position);
var linkEnumerator = mapZoneNode.Neighbors.GetEnumerator();
while (linkEnumerator.MoveNext())
{
Zone mapConnectionZone = linkEnumerator.Current.Value;
Zone resultConnectionZone = resultLayout.FindZoneByPosition(mapConnectionZone.bounds.Position);
GraphNode <Zone> resultZoneNode = resultLayout.Zones.Nodes.FindByValue(resultZone) as GraphNode <Zone>;
if (CountOccurrences(resultZoneNode.Neighbors, resultConnectionZone) < CountOccurrences(mapZoneNode.Neighbors, mapConnectionZone))
{
resultLayout.ConnectZones(resultZone, resultConnectionZone);
}
}
}
// Connect zones
for (int i = 0; i < mapGraph.Count; i++)
{
zone = mapGraph.Nodes[i].Value;
resultZone = resultLayout.FindZoneByPosition(zone.bounds.Position);
int2 connectionPoint;
Zone connectionZone;
var connectionsEnumerator = zone.connections.GetEnumerator();
while (connectionsEnumerator.MoveNext())
{
int2 currentMapPoint = connectionsEnumerator.Current.Key;
Zone currentMapZoneConnection = connectionsEnumerator.Current.Value;
connectionPoint = new int2(currentMapPoint.x, currentMapPoint.y);
connectionZone = resultLayout.FindZoneByPosition(currentMapZoneConnection.bounds.Position);
resultZone.AddConnectionPoint(connectionPoint, connectionZone);
}
}
// Set Initial & Final zones
resultLayout.InitialZone = resultLayout.FindZoneByPosition(map.Layout.InitialZone.bounds.Position);
resultLayout.FinalZone = resultLayout.FindZoneByPosition(map.Layout.FinalZone.bounds.Position);
// Set Spawn & Exit zones
result.SpawnPoint = map.SpawnPoint;
result.ExitPoint = map.ExitPoint;
return(result);
}
