public void LoadChunkWithMultipleReferencesTest()
{
PlanetIndex3 index = new PlanetIndex3(4, new Index3(5, 6, 7));
IChunk result = null;
int loadCallCounter = 0;
int saveCallCounter = 0;
GlobalChunkCache cache = new GlobalChunkCache(
(i) =>
{
loadCallCounter++;
Assert.AreEqual(i, index);
return result = new TestChunk(index);
},
(i, c) =>
{
saveCallCounter++;
Assert.AreEqual(i, index);
Assert.AreEqual(c, result);
});
// Load 1
Assert.AreEqual(0, cache.LoadedChunks);
Assert.AreEqual(0, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
IChunk x1 = cache.Subscribe(index, true);
Assert.AreEqual(x1, result);
Assert.AreEqual(x1.Planet, index.Planet);
Assert.AreEqual(x1.Index, index.ChunkIndex);
Assert.AreEqual(1, cache.LoadedChunks);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Load 2
IChunk x2 = cache.Subscribe(index, true);
Assert.AreEqual(x2, result);
Assert.AreEqual(x2.Planet, index.Planet);
Assert.AreEqual(x2.Index, index.ChunkIndex);
Assert.AreEqual(x1, x2);
Assert.AreEqual(1, cache.LoadedChunks);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Unload 1
cache.Release(index, true);
Assert.AreEqual(1, cache.LoadedChunks);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Unload 2
cache.Release(index, true);
Assert.AreEqual(0, cache.LoadedChunks);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(1, saveCallCounter);
}
/// <summary>
/// Überprüft, ob der gegebene PlanetIndex3 den gleichen Wert aufweist, wie das gegebene Objekt.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
if (!(obj is PlanetIndex3))
{
return(false);
}
PlanetIndex3 other = (PlanetIndex3)obj;
return(
other.Planet == Planet &&
other.ChunkIndex.X == ChunkIndex.X &&
other.ChunkIndex.Y == ChunkIndex.Y &&
other.ChunkIndex.Z == ChunkIndex.Z);
}
public IChunk Deserialize(Stream stream, PlanetIndex3 position)
{
Chunk chunk = new Chunk(position.ChunkIndex, position.Planet);
using (BinaryReader br = new BinaryReader(stream))
{
List <IBlockDefinition> types = new List <IBlockDefinition>();
Dictionary <ushort, ushort> map = new Dictionary <ushort, ushort>();
bool longIndex = br.ReadByte() > 0;
int typecount = longIndex ? br.ReadUInt16() : br.ReadByte();
// Im Falle eines Luftchunks
if (typecount == 0)
{
return(chunk);
}
for (int i = 0; i < typecount; i++)
{
string typeName = br.ReadString();
IBlockDefinition[] definitions = DefinitionManager.GetBlockDefinitions().ToArray();
var blockDefinition = definitions.FirstOrDefault(d => d.GetType().FullName == typeName);
types.Add(blockDefinition);
map.Add((ushort)types.Count, (ushort)(Array.IndexOf(definitions, blockDefinition) + 1));
}
for (int i = 0; i < chunk.Blocks.Length; i++)
{
ushort typeIndex = longIndex ? br.ReadUInt16() : br.ReadByte();
chunk.MetaData[i] = 0;
if (typeIndex > 0)
{
chunk.Blocks[i] = map[typeIndex];
var definition = DefinitionManager.GetBlockDefinitionByIndex(map[typeIndex]);
if (definition.HasMetaData)
{
chunk.MetaData[i] = br.ReadInt32();
}
}
}
}
return(chunk);
}
public IChunk Deserialize(Stream stream, PlanetIndex3 position)
{
Chunk chunk = new Chunk(position.ChunkIndex, position.Planet);
using (BinaryReader br = new BinaryReader(stream))
{
List<IBlockDefinition> types = new List<IBlockDefinition>();
Dictionary<ushort, ushort> map = new Dictionary<ushort, ushort>();
bool longIndex = br.ReadByte() > 0;
int typecount = longIndex ? br.ReadUInt16() : br.ReadByte();
// Im Falle eines Luftchunks
if (typecount == 0)
return chunk;
for (int i = 0; i < typecount; i++)
{
string typeName = br.ReadString();
IBlockDefinition[] definitions = BlockDefinitionManager.GetBlockDefinitions().ToArray();
var blockDefinition = definitions.FirstOrDefault(d => d.GetType().FullName == typeName);
types.Add(blockDefinition);
map.Add((ushort)types.Count, (ushort)(Array.IndexOf(definitions, blockDefinition) + 1));
}
for (int i = 0; i < chunk.Blocks.Length; i++)
{
ushort typeIndex = longIndex ? br.ReadUInt16() : br.ReadByte();
chunk.MetaData[i] = 0;
if (typeIndex > 0)
{
chunk.Blocks[i] = map[typeIndex];
var definition = BlockDefinitionManager.GetForType(map[typeIndex]);
if (definition.HasMetaData)
chunk.MetaData[i] = br.ReadInt32();
}
}
}
return chunk;
}
public void LoadChunkTest()
{
PlanetIndex3 index = new PlanetIndex3(4, new Index3(5, 6, 7));
IChunk result = null;
int loadCallCounter = 0;
int saveCallCounter = 0;
GlobalChunkCache cache = new GlobalChunkCache(
(i) =>
{
Assert.AreEqual(i, index);
loadCallCounter++;
return(result = new TestChunk(index));
},
(i, c) =>
{
Assert.AreEqual(i, index);
Assert.AreEqual(c, result);
saveCallCounter++;
});
Assert.AreEqual(0, cache.LoadedChunks);
Assert.AreEqual(0, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Chunk laden
IChunk x = cache.Subscribe(index, true);
Assert.AreEqual(x, result);
Assert.AreEqual(x.Planet, index.Planet);
Assert.AreEqual(x.Index, index.ChunkIndex);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
Assert.AreEqual(1, cache.LoadedChunks);
// Chunk unload
cache.Release(index, true);
Assert.AreEqual(0, cache.LoadedChunks);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(1, saveCallCounter);
}
public void LoadChunkTest()
{
PlanetIndex3 index = new PlanetIndex3(4, new Index3(5, 6, 7));
IChunk result = null;
int loadCallCounter = 0;
int saveCallCounter = 0;
GlobalChunkCache cache = new GlobalChunkCache(
(i) =>
{
Assert.AreEqual(i, index);
loadCallCounter++;
return result = new TestChunk(index);
},
(i, c) =>
{
Assert.AreEqual(i, index);
Assert.AreEqual(c, result);
saveCallCounter++;
});
Assert.AreEqual(0, cache.LoadedChunks);
Assert.AreEqual(0, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Chunk laden
IChunk x = cache.Subscribe(index, true);
Assert.AreEqual(x, result);
Assert.AreEqual(x.Planet, index.Planet);
Assert.AreEqual(x.Index, index.ChunkIndex);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
Assert.AreEqual(1, cache.LoadedChunks);
// Chunk unload
cache.Release(index, true);
Assert.AreEqual(0, cache.LoadedChunks);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(1, saveCallCounter);
}
public TestChunk(PlanetIndex3 index)
{
this.planet = index.Planet;
this.index = index.ChunkIndex;
}
public void SetChunk(PlanetIndex3? index)
{
ChunkPosition = index;
chunkLoaded = false;
chunk = null;
if (index != null)
_manager = ResourceManager.Instance.GetManagerForPlanet(index.Value.Planet);
else
_manager = null;
}
public void LoadMultipleChunksTest()
{
PlanetIndex3 index1 = new PlanetIndex3(4, new Index3(5, 6, 7));
PlanetIndex3 index2 = new PlanetIndex3(12, new Index3(15, 16, 17));
IChunk result1 = null;
IChunk result2 = null;
int loadCallCounter = 0;
int saveCallCounter = 0;
GlobalChunkCache cache = new GlobalChunkCache(
(i) =>
{
loadCallCounter++;
if (i.Planet == 4)
{
Assert.AreEqual(i, index1);
return result1 = new TestChunk(index1);
}
else if (i.Planet == 12)
{
Assert.AreEqual(i, index2);
return result2 = new TestChunk(index2);
}
throw new NotSupportedException();
},
(i, c) =>
{
saveCallCounter++;
if (i.Planet == 4)
{
Assert.AreEqual(i, index1);
Assert.AreEqual(c, result1);
return;
}
else if (i.Planet == 12)
{
Assert.AreEqual(i, index2);
Assert.AreEqual(c, result2);
return;
}
throw new NotSupportedException();
});
// Load 1
Assert.AreEqual(0, cache.LoadedChunks);
Assert.AreEqual(0, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
IChunk x1 = cache.Subscribe(index1, true);
Assert.AreEqual(x1, result1);
Assert.AreEqual(x1.Planet, index1.Planet);
Assert.AreEqual(x1.Index, index1.ChunkIndex);
Assert.AreEqual(1, cache.LoadedChunks);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Load 2
IChunk x2 = cache.Subscribe(index2, true);
Assert.AreEqual(x2, result2);
Assert.AreEqual(x2.Planet, index2.Planet);
Assert.AreEqual(x2.Index, index2.ChunkIndex);
Assert.AreEqual(2, cache.LoadedChunks);
Assert.AreEqual(2, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Unload 1
cache.Release(index1, true);
Assert.AreEqual(1, cache.LoadedChunks);
Assert.AreEqual(2, loadCallCounter);
Assert.AreEqual(1, saveCallCounter);
// Unload 2
cache.Release(index2, true);
Assert.AreEqual(0, cache.LoadedChunks);
Assert.AreEqual(2, loadCallCounter);
Assert.AreEqual(2, saveCallCounter);
}
public void LoadMultipleChunksTest()
{
PlanetIndex3 index1 = new PlanetIndex3(4, new Index3(5, 6, 7));
PlanetIndex3 index2 = new PlanetIndex3(12, new Index3(15, 16, 17));
IChunk result1 = null;
IChunk result2 = null;
int loadCallCounter = 0;
int saveCallCounter = 0;
GlobalChunkCache cache = new GlobalChunkCache(
(i) =>
{
loadCallCounter++;
if (i.Planet == 4)
{
Assert.AreEqual(i, index1);
return(result1 = new TestChunk(index1));
}
else if (i.Planet == 12)
{
Assert.AreEqual(i, index2);
return(result2 = new TestChunk(index2));
}
throw new NotSupportedException();
},
(i, c) =>
{
saveCallCounter++;
if (i.Planet == 4)
{
Assert.AreEqual(i, index1);
Assert.AreEqual(c, result1);
return;
}
else if (i.Planet == 12)
{
Assert.AreEqual(i, index2);
Assert.AreEqual(c, result2);
return;
}
throw new NotSupportedException();
});
// Load 1
Assert.AreEqual(0, cache.LoadedChunks);
Assert.AreEqual(0, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
IChunk x1 = cache.Subscribe(index1, true);
Assert.AreEqual(x1, result1);
Assert.AreEqual(x1.Planet, index1.Planet);
Assert.AreEqual(x1.Index, index1.ChunkIndex);
Assert.AreEqual(1, cache.LoadedChunks);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Load 2
IChunk x2 = cache.Subscribe(index2, true);
Assert.AreEqual(x2, result2);
Assert.AreEqual(x2.Planet, index2.Planet);
Assert.AreEqual(x2.Index, index2.ChunkIndex);
Assert.AreEqual(2, cache.LoadedChunks);
Assert.AreEqual(2, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Unload 1
cache.Release(index1, true);
Assert.AreEqual(1, cache.LoadedChunks);
Assert.AreEqual(2, loadCallCounter);
Assert.AreEqual(1, saveCallCounter);
// Unload 2
cache.Release(index2, true);
Assert.AreEqual(0, cache.LoadedChunks);
Assert.AreEqual(2, loadCallCounter);
Assert.AreEqual(2, saveCallCounter);
}
public void SetChunk(PlanetIndex3? index)
{
ChunkPosition = index;
chunkLoaded = false;
chunk = null;
}
public void LoadChunkWithMultipleReferencesTest()
{
PlanetIndex3 index = new PlanetIndex3(4, new Index3(5, 6, 7));
IChunk result = null;
int loadCallCounter = 0;
int saveCallCounter = 0;
GlobalChunkCache cache = new GlobalChunkCache(
(i) =>
{
loadCallCounter++;
Assert.AreEqual(i, index);
return(result = new TestChunk(index));
},
(i, c) =>
{
saveCallCounter++;
Assert.AreEqual(i, index);
Assert.AreEqual(c, result);
});
// Load 1
Assert.AreEqual(0, cache.LoadedChunks);
Assert.AreEqual(0, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
IChunk x1 = cache.Subscribe(index, true);
Assert.AreEqual(x1, result);
Assert.AreEqual(x1.Planet, index.Planet);
Assert.AreEqual(x1.Index, index.ChunkIndex);
Assert.AreEqual(1, cache.LoadedChunks);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Load 2
IChunk x2 = cache.Subscribe(index, true);
Assert.AreEqual(x2, result);
Assert.AreEqual(x2.Planet, index.Planet);
Assert.AreEqual(x2.Index, index.ChunkIndex);
Assert.AreEqual(x1, x2);
Assert.AreEqual(1, cache.LoadedChunks);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Unload 1
cache.Release(index, true);
Assert.AreEqual(1, cache.LoadedChunks);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(0, saveCallCounter);
// Unload 2
cache.Release(index, true);
Assert.AreEqual(0, cache.LoadedChunks);
Assert.AreEqual(1, loadCallCounter);
Assert.AreEqual(1, saveCallCounter);
}
public void Release(PlanetIndex3 position, bool writable = true)
{
SaveCounter++;
}
public IChunk Subscribe(PlanetIndex3 position, bool writable = true)
{
LoadCounter++;
return(new TestChunk(position));
}
public IChunk Subscribe(PlanetIndex3 position, bool writable = true)
{
LoadCounter++;
return new TestChunk(position);
}
public TestChunk(PlanetIndex3 index)
{
this.planet = index.Planet;
this.index = index.ChunkIndex;
}
private void saveChunk(PlanetIndex3 index, IChunk value)
{
IUniverse universe = GetUniverse(0);
if (!disablePersistence && value.ChangeCounter > 0)
{
chunkPersistence.Save(universe.Id, index.Planet, value);
value.ChangeCounter = 0;
}
}
private IChunk loadChunk(PlanetIndex3 index)
{
IUniverse universe = GetUniverse(0);
IPlanet planet = GetPlanet(index.Planet);
// Load from disk
IChunk first = chunkPersistence.Load(universe.Id, index.Planet, index.ChunkIndex);
if (first != null)
return first;
IChunk[] result = mapGenerator.GenerateChunk(planet, new Index2(index.ChunkIndex.X, index.ChunkIndex.Y));
if (result != null && result.Length > index.ChunkIndex.Z)
{
result[index.ChunkIndex.Z].ChangeCounter = 0;
return result[index.ChunkIndex.Z];
}
return null;
}
private bool FillChunkRenderer()
{
Index3 destinationChunk = player.Player.Position.ChunkIndex;
IPlanet planet = ResourceManager.Instance.GetPlanet(player.Player.Position.Planet);
destinationChunk.Z = Math.Max(VIEWHEIGHT, Math.Min(planet.Size.Z - VIEWHEIGHT, destinationChunk.Z));
// Nur ausführen wenn der Spieler den Chunk gewechselt hat
if (destinationChunk != currentChunk)
{
#region Shift durchführen
Index3 shift = currentChunk.ShortestDistanceXY(
destinationChunk, new Index2(planet.Size.X, planet.Size.Y));
for (int i = activeChunkRenderer.Count - 1; i >= 0; i--)
{
ChunkRenderer renderer = activeChunkRenderer[i];
Index3 absoluteIndex = renderer.ChunkPosition.Value.ChunkIndex;
Index3 relativeIndex = destinationChunk.ShortestDistanceXY(
absoluteIndex, new Index2(
planet.Size.X,
planet.Size.Y));
if (!renderer.ChunkPosition.HasValue ||
relativeIndex.X < -VIEWRANGE || relativeIndex.X > VIEWRANGE ||
relativeIndex.Y < -VIEWRANGE || relativeIndex.Y > VIEWRANGE ||
relativeIndex.Z < -VIEWHEIGHT || relativeIndex.Z > VIEWHEIGHT)
{
renderer.SetChunk(null);
freeChunkRenderer.Enqueue(renderer);
activeChunkRenderer.Remove(renderer);
}
}
#endregion
#region Ungenutzte Chunks auffüllen
foreach (var distance in distances)
{
Index3 chunkIndex = destinationChunk + distance;
chunkIndex.NormalizeXY(planet.Size);
PlanetIndex3 chunkPosition = new PlanetIndex3(
player.Player.Position.Planet, chunkIndex);
if (!activeChunkRenderer.Any(c => c.ChunkPosition == chunkPosition))
{
ChunkRenderer renderer = freeChunkRenderer.Dequeue();
renderer.SetChunk(chunkPosition);
activeChunkRenderer.Add(renderer);
}
}
#endregion
currentChunk = destinationChunk;
}
#region Chunkrenderer updaten
int shortestDistance = int.MaxValue;
ChunkRenderer updatableRenderer = null;
foreach (var renderer in activeChunkRenderer)
{
if (!renderer.NeedUpdate())
continue;
Index3 absoluteIndex = renderer.ChunkPosition.Value.ChunkIndex;
Index3 relativeIndex = destinationChunk.ShortestDistanceXY(
absoluteIndex, new Index2(
planet.Size.X,
planet.Size.Y));
int distance = relativeIndex.LengthSquared();
if (distance < shortestDistance)
{
updatableRenderer = renderer;
shortestDistance = distance;
}
}
if (updatableRenderer != null)
updatableRenderer.RegenerateVertexBuffer();
#endregion
return updatableRenderer != null;
}
public void Release(PlanetIndex3 position, bool writable = true)
{
SaveCounter++;
}
