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++; }