private void saveChunkColumn(int planetId, Index2 index, IChunkColumn value)
{
if (!disablePersistence && value.Chunks.Any(c => c.ChangeCounter > 0))
{
persistenceManager.SaveColumn(universe.Id, planetId, value);
}
}
private IEnumerable <IChunkColumn> GenerateChunks(ChunkCoordinates center, int renderDistance)
{
var oldChunks = _loadedChunks.ToArray();
double radiusSquared = Math.Pow(renderDistance, 2);
List <ChunkCoordinates> newChunkCoordinates = new List <ChunkCoordinates>();
List <ChunkCoordinates> results = new List <ChunkCoordinates>((renderDistance * 2) * (renderDistance * 2));
for (int y = -renderDistance; y <= renderDistance; y++)
{
for (int x = -renderDistance; x <= renderDistance; x++)
{
results.Add(new ChunkCoordinates(x, y));
}
}
foreach (var cc in results.OrderBy(p =>
{
int dx = p.X;
int dy = p.Z;
return(dx * dx + dy * dy);
})
.TakeWhile(p =>
{
int dx = p.X;
int dy = p.Z;
var r = dx * dx + dy * dy;
return(r < radiusSquared);
}))
{
var acc = center + cc;
newChunkCoordinates.Add(acc);
if (!_loadedChunks.Contains(acc))
{
IChunkColumn chunk =
_generator.GenerateChunkColumn(acc);
if (chunk == null)
{
continue;
}
_loadedChunks.Add(acc);
yield return(chunk);
}
}
foreach (var chunk in oldChunks)
{
if (!newChunkCoordinates.Contains((ChunkCoordinates)chunk))
{
UnloadChunk(chunk.X, chunk.Z);
_loadedChunks.Remove(chunk);
}
}
}
private void GenerateHeightMap(IChunkColumn chunk)
{
BlockCoordinates coords;
var map = new byte[16, 16];
for (byte x = 0; x < 16; x++)
{
for (byte z = 0; z < 16; z++)
{
for (byte y = (byte)(chunk.GetHeight(x, z) + 2); y > 0; y--)
{
if (y >= 255)
{
continue;
}
coords.X = x; coords.Y = y - 1; coords.Z = z;
var provider = chunk.GetBlockState(coords.X, coords.Y, coords.Z).Block;
if (!provider.Renderable)
{
continue;
}
if (provider == null || provider.LightOpacity != 0)
{
map[x, z] = y;
break;
}
}
}
}
HeightMaps[new ChunkCoordinates(chunk.X, chunk.Z)] = map;
}
public void AddChunk(IChunkColumn chunk, ChunkCoordinates position, bool doUpdates = false)
{
var c = Chunks.AddOrUpdate(position, coordinates =>
{
return(chunk);
}, (vector3, chunk1) =>
{
if (!ReferenceEquals(chunk1, chunk))
{
chunk1.Dispose();
}
Log.Warn($"Replaced/Updated chunk at {position}");
return(chunk);
});
if (doUpdates)
{
ScheduleChunkUpdate(position, ScheduleType.Full);
ScheduleChunkUpdate(new ChunkCoordinates(position.X + 1, position.Z), ScheduleType.Border);
ScheduleChunkUpdate(new ChunkCoordinates(position.X - 1, position.Z), ScheduleType.Border);
ScheduleChunkUpdate(new ChunkCoordinates(position.X, position.Z + 1), ScheduleType.Border);
ScheduleChunkUpdate(new ChunkCoordinates(position.X, position.Z - 1), ScheduleType.Border);
}
//InitiateChunk(c, position);
}
/// <summary>
/// Lädt eine <see cref="IChunkColumn"/>.
/// </summary>
/// <param name="universeGuid">GUID des Universums.</param>
/// <param name="planet">Index des Planeten.</param>
/// <param name="columnIndex">Zu serialisierende ChunkColumn.</param>
/// <returns>Die neu geladene ChunkColumn.</returns>
public Awaiter Load(out IChunkColumn column, Guid universeGuid, IPlanet planet, Index2 columnIndex)
{
string file = Path.Combine(GetRoot(), universeGuid.ToString(), planet.Id.ToString(), string.Format(ColumnFilename, columnIndex.X, columnIndex.Y));
column = new ChunkColumn();
if (!File.Exists(file))
{
return(null);
}
try
{
using (Stream stream = File.Open(file, FileMode.Open, FileAccess.Read))
{
using (GZipStream zip = new GZipStream(stream, CompressionMode.Decompress))
{
var awaiter = new Awaiter();
awaiter.Serializable = column;
awaiter.SetResult(planet.Generator.GenerateColumn(zip, definitionManager, planet.Id, columnIndex));
return(awaiter);
}
}
}
catch (IOException)
{
try
{
File.Delete(file);
}
catch (IOException) { }
return(null);
}
}
public override void Populate(IDefinitionManager definitionManager, IPlanet planet, IChunkColumn column00, IChunkColumn column10, IChunkColumn column01, IChunkColumn column11)
{
// Tree Definitions initialisieren
if (treeDefinitions == null)
{
treeDefinitions = definitionManager.GetDefinitions<ITreeDefinition>().OrderBy(d => d.Order).ToArray();
foreach (var treeDefinition in treeDefinitions)
treeDefinition.Init(definitionManager);
}
int salt = (column00.Index.X & 0xffff) + ((column00.Index.Y & 0xffff) << 16);
Random random = new Random(planet.Seed + salt);
Index3 sample = new Index3(column00.Index.X * Chunk.CHUNKSIZE_X, column00.Index.Y * Chunk.CHUNKSIZE_Y, column00.Heights[0, 0]);
foreach (var treeDefinition in treeDefinitions)
{
int density = treeDefinition.GetDensity(planet, sample);
if (density <= 0) continue;
for (int i = 0; i < density; i++)
{
int x = random.Next(Chunk.CHUNKSIZE_X / 2, Chunk.CHUNKSIZE_X * 3 / 2);
int y = random.Next(Chunk.CHUNKSIZE_Y / 2, Chunk.CHUNKSIZE_Y * 3 / 2);
int z = LocalBuilder.GetSurfaceHeight(column00, column10, column01, column11, x, y);
LocalBuilder builder = new LocalBuilder(x, y, z + 1, column00, column10, column01, column11);
treeDefinition.PlantTree(definitionManager, planet, new Index3(x, y, z), builder, random.Next(int.MaxValue));
}
}
}
public void ChunkReceived(IChunkColumn chunkColumn, int x, int z, bool update)
{
var c = new ChunkCoordinates(x, z);
ChunkManager.AddChunk(chunkColumn, c, update);
//InitiateChunk(chunkColumn as ChunkColumn);
}
/// <summary>
/// Liefert den Chunk an der angegebenen Chunk-Koordinate zurück.
/// </summary>
/// <param name="x">X Koordinate</param>
/// <param name="y">Y Koordinate</param>
/// <param name="z">Z Koordinate</param>
/// <returns>Instanz des Chunks</returns>
public IChunk GetChunk(int x, int y, int z)
{
if (planet == null)
{
return(null);
}
if (z < 0)
{
return(null);
}
if (z >= planet.Size.Z)
{
return(null);
}
x = Index2.NormalizeAxis(x, planet.Size.X);
y = Index2.NormalizeAxis(y, planet.Size.Y);
IChunkColumn chunkColumn = chunkColumns[FlatIndex(x, y)];
if (chunkColumn != null && chunkColumn.Index.X == x && chunkColumn.Index.Y == y)
{
return(chunkColumn.Chunks[z]);
}
return(null);
}
public async ValueTask <IChunk> GetOrAddChunk(ChunkPosition position)
{
IChunkColumn chunkColumn = await GetOrAddChunkColumn(position.Column).Unchain();
IChunk chunk = await chunkColumn.GetOrAddChunk(position.Y).Unchain();
return(chunk);
}
/// <summary>
/// Erzeugt eine neue Instanz der Klasse LocalBuilder
/// </summary>
/// <param name="originX"></param>
/// <param name="originY"></param>
/// <param name="originZ"></param>
/// <param name="column00"></param>
/// <param name="column10"></param>
/// <param name="column01"></param>
/// <param name="column11"></param>
public LocalBuilder(int originX, int originY, int originZ, IChunkColumn column00, IChunkColumn column10, IChunkColumn column01, IChunkColumn column11)
{
this.originX = originX;
this.originY = originY;
this.originZ = originZ;
this.column00 = column00;
this.column01 = column01;
this.column10 = column10;
this.column11 = column11;
}
/// <summary>
///
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="z"></param>
/// <param name="block"></param>
/// <param name="meta"></param>
public void SetBlock(int x, int y, int z, ushort block, int meta = 0)
{
x += originX;
y += originY;
z += originZ;
IChunkColumn column = GetColumn(column00, column10, column01, column11, x, y);
x %= Chunk.CHUNKSIZE_X;
y %= Chunk.CHUNKSIZE_Y;
column.SetBlock(x, y, z, block, meta);
}
public LocalBuilder(int originX, int originY, int originZ, IChunkColumn column00, IChunkColumn column10, IChunkColumn column01, IChunkColumn column11)
{
this.originX = originX;
this.originY = originY;
this.originZ = originZ;
this.column00 = column00;
this.column01 = column01;
this.column10 = column10;
this.column11 = column11;
}
/// <summary>
///
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="z"></param>
/// <returns></returns>
public ushort GetBlock(int x, int y, int z)
{
x += originX;
y += originY;
z += originZ;
IChunkColumn column = GetColumn(column00, column10, column01, column11, x, y);
x %= Chunk.CHUNKSIZE_X;
y %= Chunk.CHUNKSIZE_Y;
return(column.GetBlock(x, y, z));
}
// TODO: dont allow public constructor, use a chunk manager/provider instead
public LocalChunk(IChunkColumn parent, int y, IBlockPalette blockPalette, BlockState airBlock)
{
// TODO: validate Y through a chunk manager or something
Y = y;
Column = parent ?? throw new ArgumentNullException(nameof(parent));
BlockPalette = blockPalette ?? throw new ArgumentNullException(nameof(blockPalette));
AirBlock = airBlock;
// TODO: pool storage arrays
_blocks = BitArray32.AllocateUninitialized(BlockCount, BlockPalette.BitsPerBlock);
}
private void SetUpperVoxels(IChunkColumn chunk)
{
for (int x = 0; x < 16; x++)
{
for (int z = 0; z < 16; z++)
{
for (int y = chunk.GetHeighest() + 1; y < 255; y++)
{
chunk.SetSkyLight(x, y, z, 15);
}
}
}
}
/// <summary>
/// Speichert eine <see cref="IChunkColumn"/>.
/// </summary>
/// <param name="universeGuid">GUID des Universums.</param>
/// <param name="planetId">Index des Planeten.</param>
/// <param name="column">Zu serialisierende ChunkColumn.</param>
public void SaveColumn(Guid universeGuid, int planetId, IChunkColumn column)
{
string path = Path.Combine(GetRoot(), universeGuid.ToString(), planetId.ToString());
Directory.CreateDirectory(path);
string file = path = Path.Combine(path, string.Format(ColumnFilename, column.Index.X, column.Index.Y));
using (Stream stream = File.Open(file, FileMode.Create, FileAccess.Write))
using (GZipStream zip = new GZipStream(stream, CompressionMode.Compress))
using (BinaryWriter writer = new BinaryWriter(zip))
column.Serialize(writer, definitionManager);
}
/// <summary>
/// Leert den Cache und gibt sie beim GlobalChunkCache wieder frei
/// </summary>
public void Flush()
{
for (int i = 0; i < chunkColumns.Length; i++)
{
if (chunkColumns[i] == null)
continue;
IChunkColumn chunkColumn = chunkColumns[i];
globalCache.Release(chunkColumn.Index);
chunkColumns[i] = null;
}
}
public void SendChangedChunkColumn(IChunkColumn chunkColumn)
{
//var package = new Package((ushort)OfficialCommand.SaveColumn, 0);
//using (var ms = new MemoryStream())
//using (var bw = new BinaryWriter(ms))
//{
// chunkColumn.Serialize(bw, definitionManager);
// package.Payload = ms.ToArray();
//}
//client.SendPackage(package);
}
public static IChunkColumn GetColumn(IChunkColumn column00, IChunkColumn column10, IChunkColumn column01, IChunkColumn column11, int x, int y)
{
IChunkColumn column;
if (x >= Chunk.CHUNKSIZE_X && y >= Chunk.CHUNKSIZE_Y)
column = column11;
else if (x < Chunk.CHUNKSIZE_X && y >= Chunk.CHUNKSIZE_Y)
column = column01;
else if (x >= Chunk.CHUNKSIZE_X && y < Chunk.CHUNKSIZE_Y)
column = column10;
else
column = column00;
return column;
}
/// <summary>
///
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="z"></param>
/// <param name="block"></param>
/// <param name="meta"></param>
public void SetBlock(int x, int y, int z, ushort block, int meta = 0)
{
x += originX;
y += originY;
z += originZ;
IChunkColumn column = GetColumn(column00, column10, column01, column11, x, y);
var index = z / Chunk.CHUNKSIZE_Z;
x %= Chunk.CHUNKSIZE_X;
y %= Chunk.CHUNKSIZE_Y;
z %= Chunk.CHUNKSIZE_Z;
var flatIndex = Chunk.GetFlatIndex(x, y, z);
column.Chunks[index].Blocks[flatIndex] = block;
}
/// <summary>
/// Leert den Cache und gibt sie beim GlobalChunkCache wieder frei
/// </summary>
public void Flush()
{
for (int i = 0; i < chunkColumns.Length; i++)
{
if (chunkColumns[i] == null)
{
continue;
}
IChunkColumn chunkColumn = chunkColumns[i];
globalCache.Release(chunkColumn.Planet, chunkColumn.Index, IsPassive);
chunkColumns[i] = null;
}
}
/// <summary>
/// Liefert den Chunk an der angegebenen Chunk-Koordinate zurück.
/// </summary>
/// <param name="x">X Koordinate</param>
/// <param name="y">Y Koordinate</param>
/// <param name="z">Z Koordinate</param>
/// <returns>Instanz des Chunks</returns>
public IChunk GetChunk(int x, int y, int z)
{
if (Planet == null || z < 0 || z >= Planet.Size.Z)
return null;
x = Index2.NormalizeAxis(x, Planet.Size.X);
y = Index2.NormalizeAxis(y, Planet.Size.Y);
IChunkColumn chunkColumn = chunkColumns[FlatIndex(x, y)];
if (chunkColumn != null && chunkColumn.Index.X == x && chunkColumn.Index.Y == y)
return chunkColumn.Chunks[z];
return null;
}
public void LoadChunkTest()
{
int planet = 2;
Index2 index = new Index2(6, 7);
IChunkColumn result = null;
int loadCallCounter = 0;
int saveCallCounter = 0;
GlobalChunkCache cache = new GlobalChunkCache(
(p, i) =>
{
Assert.Equals(i, index);
loadCallCounter++;
return(result = new TestChunkColumn(planet, index));
},
(i) => null,
(p, i, c) =>
{
Assert.Equals(p, planet);
Assert.Equals(i, index);
Assert.Equals(c, result);
saveCallCounter++;
});
Assert.Equals(0, cache.LoadedChunkColumns);
Assert.Equals(0, loadCallCounter);
Assert.Equals(0, saveCallCounter);
// Chunk laden
IChunkColumn x = cache.Subscribe(planet, index, false);
Assert.Equals(x, result);
Assert.Equals(x.Planet, planet);
Assert.Equals(x.Index, index);
Assert.Equals(1, loadCallCounter);
Assert.Equals(0, saveCallCounter);
Assert.Equals(1, cache.LoadedChunkColumns);
// Chunk unload
cache.Release(planet, index, false);
System.Threading.Thread.Sleep(150);//TODO: dirty fix wait till completly cleaned up
Assert.Equals(0, cache.LoadedChunkColumns);
Assert.Equals(1, loadCallCounter);
Assert.Equals(0, saveCallCounter);//Expected 0 cause chunk wasn't changed
}
public void LoadChunkTest()
{
int planet = 2;
Index2 index = new Index2(6, 7);
IChunkColumn result = null;
int loadCallCounter = 0;
int saveCallCounter = 0;
GlobalChunkCache cache = new GlobalChunkCache(
(p, i) =>
{
Assert.AreEqual(i, index);
loadCallCounter++;
return(result = new TestChunkColumn(planet, index));
},
(p, i, c) =>
{
Assert.AreEqual(p, planet);
Assert.AreEqual(i, index);
Assert.AreEqual(c, result);
saveCallCounter++;
});
Assert.AreEqual(0, cache.LoadedChunkColumns);
Assert.AreEqual(0, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Chunk laden
IChunkColumn x = cache.Subscribe(planet, index);
Assert.AreEqual(x, result);
Assert.AreEqual(x.Planet, planet);
Assert.AreEqual(x.Index, index);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
Assert.AreEqual(1, cache.LoadedChunkColumns);
// Chunk unload
cache.Release(planet, index);
Assert.AreEqual(0, cache.LoadedChunkColumns);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(1, saveCallCounter);
}
private void InitiateChunk(IChunkColumn chunkColumn, ChunkCoordinates chunkCoordinates)
{
var chunkCoords = new BlockCoordinates(chunkCoordinates.X * 16, 0, chunkCoordinates.Z * 16);
for (int x = 0; x < 16; x++)
{
for (int z = 0; z < 16; z++)
{
for (int y = 255; y > 0; y--)
{
var blockState = chunkColumn.GetBlockState(x, y, z);
if (blockState.Block is Block b)
{
b.BlockPlaced(World, blockState, chunkCoords + new BlockCoordinates(x, y, z));
}
}
}
}
}
/// <summary>
/// Lädt eine <see cref="IChunkColumn"/>.
/// </summary>
/// <param name="universeGuid">GUID des Universums.</param>
/// <param name="planet">Index des Planeten.</param>
/// <param name="columnIndex">Zu serialisierende ChunkColumn.</param>
/// <returns>Die neu geladene ChunkColumn.</returns>
public Awaiter Load(out IChunkColumn column, Guid universeGuid, IPlanet planet, Index2 columnIndex)
{
var chunkColumContext = new ChunkColumnDbContext(databaseProvider.GetDatabase <Index2Tag>(universeGuid, planet.Id, false), planet);
column = chunkColumContext.Get(columnIndex);
if (column == null)
{
return(null);
}
//var localColumn = column;
ApplyChunkDiff(column, universeGuid, planet);
var awaiter = awaiterPool.Get();
awaiter.SetResult(column);
return(awaiter);
}
/// <summary>
///
/// </summary>
/// <param name="blockInfos"></param>
public void SetBlocks(bool issueNotification, params BlockInfo[] blockInfos)
=> blockInfos
.Select(b =>
{
var x = b.Position.X + originX;
var y = b.Position.Y + originY;
var z = b.Position.Z + originZ;
IChunkColumn column = GetColumn(column00, column10, column01, column11, x, y);
var index = z / Chunk.CHUNKSIZE_Z;
x %= Chunk.CHUNKSIZE_X;
y %= Chunk.CHUNKSIZE_Y;
z %= Chunk.CHUNKSIZE_Z;
var info = new BlockInfo(x, y, z, b.Block, b.Meta);
return(new { info, index, column });
})
.GroupBy(a => a.column)
.ForEach(column => column
.GroupBy(i => i.index)
.ForEach(i => column.Key.Chunks[i.Key].SetBlocks(issueNotification, i.Select(b => b.info).ToArray())));
/// <summary>
/// Queues the initial lighting pass for a newly generated chunk.
/// </summary>
public void CalculateLighting(IChunkColumn chunk, bool skyLight = true, bool initial = false)
{
if (!chunk.SkyLightDirty)
{
return;
}
// Set voxels above max height to 0xFF
if (initial)
{
SetUpperVoxels(chunk);
}
var coords = new ChunkCoordinates(chunk.X * 16, chunk.Z * 16);
var min = new Vector3(coords.X, 0, coords.Z);
var max = new Vector3(coords.X + 16, chunk.GetHeighest() + 2, coords.Z + 16);
EnqueueOperation(new ChunkCoordinates(chunk.X, chunk.Z), new BoundingBox(min, max),
skyLight, initial);
}
public Awaiter Load(out IChunkColumn column, Guid universeGuid, IPlanet planet, Index2 columnIndex)
{
var package = new Package((ushort)OfficialCommand.LoadColumn, 0);
using (var memoryStream = new MemoryStream())
using (var binaryWriter = new BinaryWriter(memoryStream))
{
binaryWriter.Write(universeGuid.ToByteArray());
binaryWriter.Write(planet.Id);
binaryWriter.Write(columnIndex.X);
binaryWriter.Write(columnIndex.Y);
package.Payload = memoryStream.ToArray();
}
column = new ChunkColumn();
var awaiter = GetAwaiter(column, package.UId);
client.SendPackage(package);
return(awaiter);
}
public void Populate(IResourceManager resourcemanager, IPlanet planet, IChunkColumn column00, IChunkColumn column01, IChunkColumn column10, IChunkColumn column11)
{
return;
if (ispop-- <= 0)
{
return;
}
WauziEntity wauzi = new WauziEntity();
var x = r.Next(0, Chunk.CHUNKSIZE_X / 2);
var y = r.Next(0, Chunk.CHUNKSIZE_Y / 2);
PositionComponent position = new PositionComponent()
{
Position = new Coordinate(0, new Index3(x + column00.Index.X * Chunk.CHUNKSIZE_X, y + column00.Index.Y * Chunk.CHUNKSIZE_Y, 200), new Vector3(0, 0, 0))
};
wauzi.Components.AddComponent(position);
column00.Entities.Add(wauzi);
}
private async Task OnGameTick(object sender, GameTickArgs e)
{
if (e.WorldAge % 512 == 0 && e.TimeOfDay > 12000 && e.TimeOfDay < 24000)
{
EntityWorldPos playerPosition = AttachedObject.GetValue(EntityWorldPositionComponent.EntityWorldPositionProperty);
int x = random.Next(9) - 4 + (int)playerPosition.X;
int z = random.Next(9) - 4 + (int)playerPosition.Z;
BlockWorldPos monsterBlockPos = new BlockWorldPos(x, 0, z);
ChunkWorldPos monsterChunkPos = monsterBlockPos.ToChunkWorldPos();
var chunkAccessor = AttachedObject.GetComponent <ChunkAccessorComponent>();
BiomeId biomeId = await chunkAccessor.GetBlockBiome(monsterBlockPos);
IWorld world = AttachedObject.GetValue(WorldComponent.WorldProperty);
GeneratorSettings setting = await world.GetGeneratorSettings();
Biome biome = Biome.GetBiome((int)biomeId, setting);
IChunkColumn chunk = await chunkAccessor.GetChunk(monsterChunkPos);
// TODO
biome.SpawnMonster(world, GrainFactory, await chunk.GetState(), random, monsterBlockPos);
}
}
/// <summary>
///
/// </summary>
/// <param name="column00"></param>
/// <param name="column10"></param>
/// <param name="column01"></param>
/// <param name="column11"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public static IChunkColumn GetColumn(IChunkColumn column00, IChunkColumn column10, IChunkColumn column01, IChunkColumn column11, int x, int y)
{
IChunkColumn column;
if (x >= Chunk.CHUNKSIZE_X && y >= Chunk.CHUNKSIZE_Y)
{
column = column11;
}
else if (x < Chunk.CHUNKSIZE_X && y >= Chunk.CHUNKSIZE_Y)
{
column = column01;
}
else if (x >= Chunk.CHUNKSIZE_X && y < Chunk.CHUNKSIZE_Y)
{
column = column10;
}
else
{
column = column00;
}
return(column);
}
/// <summary>
/// Interne Methode, in der der zentrale Chunk gesetzt wird. Die Chunks um den Zentrumschunk werden auch nachgeladen falls nötig
/// </summary>
/// <param name="token">Token, um zu prüfen, ob die aktualisierung abgeborchen werden soll</param>
/// <param name="planet">Der Planet, auf dem die Chunks aktualisiert werden sollen</param>
/// <param name="index">Der ins Zentrum zu setzende Chunk</param>
/// <param name="successCallback">Routine die Aufgerufen werden soll, falls das setzen erfolgreich war oder nicht</param>
private void InternalSetCenter(CancellationToken token, IPlanet planet, Index2 index, Action <bool> successCallback)
{
if (planet == null)
{
successCallback?.Invoke(true);
return;
}
List <Index2> requiredChunkColumns = new List <Index2>();
for (int x = -range; x <= range; x++)
{
for (int y = -range; y <= range; y++)
{
Index2 local = new Index2(index.X + x, index.Y + y);
local.NormalizeXY(planet.Size);
requiredChunkColumns.Add(local);
}
}
// Erste Abbruchmöglichkeit
if (token.IsCancellationRequested)
{
successCallback?.Invoke(false);
return;
}
foreach (var chunkColumnIndex in requiredChunkColumns
.OrderBy(c => index.ShortestDistanceXY(c, new Index2(planet.Size))
.LengthSquared()))
{
int localX = chunkColumnIndex.X & mask;
int localY = chunkColumnIndex.Y & mask;
int flatIndex = FlatIndex(localX, localY);
IChunkColumn chunkColumn = chunkColumns[flatIndex];
// Alten Chunk entfernen, falls notwendig
if (chunkColumn != null && chunkColumn.Index != chunkColumnIndex)
{
globalCache.Release(planet.Id, chunkColumn.Index, IsPassive);
chunkColumns[flatIndex] = null;
chunkColumn = null;
}
// Zweite Abbruchmöglichkeit
if (token.IsCancellationRequested)
{
successCallback?.Invoke(false);
return;
}
// Neuen Chunk laden
if (chunkColumn == null)
{
chunkColumn = globalCache.Subscribe(planet.Id, new Index2(chunkColumnIndex), IsPassive);
chunkColumns[flatIndex] = chunkColumn;
if (chunkColumn == null)
{
successCallback?.Invoke(false);
return;
}
}
// Dritte Abbruchmöglichkeit
if (token.IsCancellationRequested)
{
successCallback?.Invoke(false);
return;
}
}
successCallback?.Invoke(true);
}
/// <summary>
/// Speichert eine <see cref="IChunkColumn"/>.
/// </summary>
/// <param name="universeGuid">GUID des Universums.</param>
/// <param name="planetId">Index des Planeten.</param>
/// <param name="column">Zu serialisierende ChunkColumn.</param>
public void SaveColumn(Guid universeGuid, int planetId, IChunkColumn column)
{
string path = Path.Combine(GetRoot(), universeGuid.ToString(), planetId.ToString());
Directory.CreateDirectory(path);
string file = path = Path.Combine(path, string.Format(ColumnFilename, column.Index.X, column.Index.Y));
using (Stream stream = File.Open(file, FileMode.Create, FileAccess.Write))
{
using (GZipStream zip = new GZipStream(stream, CompressionMode.Compress))
{
column.Serialize(zip, DefinitionManager.Instance);
}
}
}
/// <summary> /// Versieht einen Chunk mit Items /// </summary> /// <param name="definitionManager">Definition Manager</param> /// <param name="planet">Index des Planeten</param> /// <param name="column00">TODO: Kommentieren</param> /// <param name="column01">TODO: Kommentieren</param> /// <param name="column10">TODO: Kommentieren</param> /// <param name="column11">TODO: Kommentieren</param> public abstract void Populate(IDefinitionManager definitionManager, IPlanet planet, IChunkColumn column00, IChunkColumn column01, IChunkColumn column10, IChunkColumn column11);
private void saveChunkColumn(int planetId, Index2 index, IChunkColumn value)
{
if (!disablePersistence && value.Chunks.Any(c => c.ChangeCounter > 0))
{
persistenceManager.SaveColumn(universe.Id, planetId, value);
}
}
public static int GetSurfaceHeight(IChunkColumn column00, IChunkColumn column10, IChunkColumn column01, IChunkColumn column11, int x, int y)
{
IChunkColumn curColumn = GetColumn(column00, column10, column01, column11, x, y);
return curColumn.Heights[x % Chunk.CHUNKSIZE_X, y % Chunk.CHUNKSIZE_Y];
}
