/// <summary>
/// Changes to level to a given map
/// </summary>
/// <param name="map">New streamed tile map</param>
/// <param name="disposeCurrentMap">Disposes the current level when true</param>
public void Changelevel(StreamedTileMap map, bool disposeCurrentMap)
{
if (!disposeCurrentMap && currentLevel != null)
{
maps.Add(currentLevel);
}
currentLevel = map;
GridChanged?.Invoke(this, new GridEventArgs(currentLevel.GridRow, currentLevel.GridColumn, -1, -1, false));
}
/// <summary>
/// Changes to level to map that will be generated based on the current position
/// </summary>
/// <param name="tileColumn">Tile column index</param>
/// <param name="tileRow">Tile row index</param>
/// <param name="disposeCurrentMap">Disposes the current level when true</param>
public void Changelevel(int tileColumn, int tileRow, bool disposeCurrentMap)
{
if (!disposeCurrentMap && currentLevel != null)
{
maps.Add(CurrentLevel);
}
UnSub();
currentLevel = generator.GenerateMap(tileColumn, tileRow);
Sub();
GridChanged?.Invoke(this, new GridEventArgs(currentLevel.GridRow, currentLevel.GridColumn, -1, -1, false));
}
/// <summary>
/// Changes to level to map that will be generated based on the current position
/// </summary>
/// <param name="settings">Setting to generate the new map</param>
/// <param name="tileColumn">Tile column index</param>
/// <param name="tileRow">Tile row index</param>
/// <param name="disposeCurrentMap">Disposes the current level when true</param>
public void Changelevel(GeneratorSettings settings, int tileColumn, int tileRow, bool disposeCurrentMap)
{
this.settings = settings;
if (!disposeCurrentMap && currentLevel != null)
{
maps.Add(CurrentLevel);
}
generator = new TileMapGenerator();
UnSub();
currentLevel = generator.GenerateMap(settings, spreads, tileColumn, tileRow);
Sub();
GridChanged?.Invoke(this, new GridEventArgs(currentLevel.GridRow, currentLevel.GridColumn, -1, -1, false));
}
/// <summary>
/// Starts new map generation
/// </summary>
/// <param name="currentTileRow">Tile row index</param>
/// <param name="currentTileColumn">tile column index</param>
private void Resize(int currentTileRow, int currentTileColumn)
{
if (generator != null)
{
if (newMap != null)
{
newMapAvalible = true;
if (TryMapUpdate(gridRow, gridColumn))
{
return;
}
}
newMapAvalible = false;
newMapRequested = true;
new Thread(() =>
{
newMap = generator.GenerateMap(currentTileColumn, currentTileRow);
newMapAvalible = true;
}).Start();
}
}
/// <summary>
/// Create the StreamedTileMap from the generated grids
/// </summary>
/// <param name="maps">Current grid with all it's surrounding grids</param>
/// <param name="suroundingGrids">Ids of all surrounding grids</param>
/// <param name="gridsPerRow">Number grids per row</param>
/// <param name="streamedTileMap">A reference to a streamedTileMap</param>
private void CreateTileMapParts(Tile[][] maps, List <ObjectTile>[] objectTiles, int[] suroundingGrids, int gridsPerRow, StreamedTileMap streamedTileMap)
{
//create TileMapPart
for (int i = 0; i < maps.Length; i++)
{
int gridId = suroundingGrids[i];
int gridRow;
int gridColumn;
TileMathHelper.ToPosition(gridId, gridsPerRow, out gridRow, out gridColumn);
gridRow = TileMathHelper.FixTileIndex(gridRow, gridsPerRow);
gridColumn = TileMathHelper.FixTileIndex(gridColumn, gridsPerRow);
TileMapPart part = new TileMapPart(gridId, maps[i], null, objectTiles[i].ToArray(), gridColumn, gridRow);
streamedTileMap.Add(part);
}
}
/// <summary>
/// Generates a map based on the given tile location, generator settings and area spreads
/// </summary>
/// <param name="settings">Generator settings to modify the generation process</param>
/// <param name="areas">Areas that should be placed on the map</param>
/// <param name="tileColumn">Tile column index</param>
/// <param name="tileRow">Tile row index</param>
/// <returns>Returns a StreamedTileMap</returns>
public StreamedTileMap GenerateMap(GeneratorSettings settings, AreaSpread[] areas, int tileColumn, int tileRow)
{
if (settings.Seed > 0)
{
random = new Random(settings.Seed);
}
else if (random == null)
{
throw new ArgumentOutOfRangeException();
}
this.settings = settings;
spreads = areas;
double tilesPerGrid = Math.Round(settings.MeterPerGrid / settings.MeterPerTile);
int tilesPerColumn = (int)tilesPerGrid;
int size = tilesPerColumn * tilesPerColumn;
int gridsPerRow = (int)Math.Ceiling(GetMapSize(settings) / tilesPerGrid);
int gridColumn = (int)Math.Floor(tileColumn / tilesPerGrid);
int gridRow = (int)Math.Floor(tileRow / tilesPerGrid);
Tile[][] edgeOverrides = new Tile[9][];
Tile[][] maps = new Tile[9][];
List <ObjectTile>[] objectTiles = new List <ObjectTile> [9];
for (int i = 0; i < maps.Length; i++)
{
edgeOverrides[i] = new Tile[size];
maps[i] = new Tile[size];
objectTiles[i] = new List <ObjectTile>();
}
int[] suroundingGrids = CreateSuroundings(maps.Length, gridColumn, gridRow, gridsPerRow);
StreamedTileMap streamedTileMap = new StreamedTileMap(this, tileRow, tileColumn, gridsPerRow, gridsPerRow, tilesPerColumn, tilesPerColumn, settings.TileSize);
//Create Map
foreach (LayerType currentLayerType in Enum.GetValues(typeof(LayerType)).Cast <LayerType>().OrderBy(k => (int)k))
{
for (int i = 0; i < suroundingGrids.Length; i++)
{
AreaSpread[] layerAreas = areas.Where(a => a.Layer == currentLayerType).ToArray();
random = new Random(suroundingGrids[i] * settings.Seed);
for (int j = 0; j < layerAreas.Length; j++)
{
switch (layerAreas[j].Layer)
{
case LayerType.Height:
{
if (layerAreas[j].MaxSizeInMeter <= settings.MeterPerGrid / 2f)
{
CreateLayerOne(i, maps, edgeOverrides, (int)tilesPerGrid, (int)tilesPerGrid, settings.TileSize, settings.MeterPerTile, layerAreas[j], settings.RadiusOfCylinder);
}
else
{
throw new Exception("AreaSpread MaxSize must be smaller then (MetersPerGrid / 2)!");
}
break;
}
case LayerType.Biome:
CreateBiomeLayer(i, maps, layerAreas[j]);
break;
case LayerType.Paths:
CreateLayerFour();
break;
case LayerType.PointsOfInterest:
{
objectTiles[i].AddRange(CreateObjectLayer(maps[i], layerAreas[j], tilesPerColumn, tilesPerColumn));
}
break;
}
}
}
if (currentLayerType == LayerType.Height)
{
//DefragementMap and add edgenoise
DefragmentMaps(maps, areas, suroundingGrids, (int)tilesPerGrid, (int)tilesPerGrid);
//Merge edgeOverrides
for (int k = 0; k < maps.Length; k++)
{
maps[k] = TileMathHelper.MergeMaps(maps[k], edgeOverrides[k]);
}
}
}
CreateTileMapParts(maps, objectTiles, suroundingGrids, gridsPerRow, streamedTileMap);
return(streamedTileMap);
}
/// <summary>
/// Changes the map to a new streamed tile map (Tile map will be updated on the next update)
/// </summary>
/// <param name="map">New streamed tile map</param>
public void ChangeMap(StreamedTileMap map)
{
newMap = map;
newMapAvalible = true;
}
