public void CalculateHeightIndexes() { for (byte x = 0; x < Chunk.WidthInBlocks; x++) { var worldPositionX = this.WorldPosition.X + x; for (byte z = 0; z < Chunk.LengthInBlocks; z++) { int worldPositionZ = this.WorldPosition.Z + z; var offset = BlockStorage.BlockIndexByWorldPosition(worldPositionX, worldPositionZ); for (int y = Chunk.MaxHeightIndexInBlocks; y >= 0; y--) { if ((y > this.HighestSolidBlockOffset) && (BlockStorage.Blocks[offset + y].Exists)) { this.HighestSolidBlockOffset = (byte)y; } else if ((this.LowestEmptyBlockOffset > y) && (!BlockStorage.Blocks[offset + y].Exists)) { this.LowestEmptyBlockOffset = (byte)y; } } } } this.LowestEmptyBlockOffset--; }
public ChunkSection(ChunkColumn owner, bool storeSkylight, int sections = 2) { Owner = owner; if (sections <= 0) { sections = 1; } //Data = new BlockStorage(); _blockStorages = new BlockStorage[sections]; for (int i = 0; i < sections; i++) { _blockStorages[i] = new BlockStorage(); } this.BlockLight = new NibbleArray(new byte[2048]); MiNET.Worlds.ChunkColumn.Fill <byte>(BlockLight.Data, 0); // if (storeSkylight) { this.SkyLight = new NibbleArray(new byte[2048]); MiNET.Worlds.ChunkColumn.Fill <byte>(SkyLight.Data, 0x00); } ScheduledUpdates = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); ScheduledSkylightUpdates = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); ScheduledBlocklightUpdates = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); }
private void TryMove(Vector3 moveVector) { // build a test move-vector slightly longer than moveVector. Vector3 testVector = moveVector; testVector.Normalize(); testVector *= moveVector.Length() + 0.3f; var footPosition = Position + new Vector3(0f, -0.5f, 0f); Vector3 testPosition = footPosition + testVector; if (BlockStorage.BlockAt(testPosition).Exists) { return; } // There should be some bounding box so his head does not enter a block above ;) /fasbat testPosition -= 2 * new Vector3(0f, -0.5f, 0f); if (BlockStorage.BlockAt(testPosition).Exists) { return; } this.Position += moveVector; }
protected virtual void GenerateBlocks(Chunk chunk, int worldPositionX, int worldPositionZ) { var rockHeight = this.GetRockHeight(worldPositionX, worldPositionZ); var dirtHeight = this.GetDirtHeight(worldPositionX, worldPositionZ, rockHeight); var offset = BlockStorage.BlockIndexByWorldPosition(worldPositionX, worldPositionZ); for (int y = Chunk.MaxHeightIndexInBlocks; y >= 0; y--) { if (y > dirtHeight) // air { BlockStorage.Blocks[offset + y] = new Block(BlockType.None); } else if (y > rockHeight) // dirt level { BlockStorage.Blocks[offset + y] = new Block(BlockType.Dirt); } else // rock level { BlockStorage.Blocks[offset + y] = new Block(BlockType.Rock); } } // apply the biome generator on x-z column. this.BiomeGenerator.ApplyBiome(chunk, dirtHeight, offset + dirtHeight, worldPositionX, worldPositionZ); }
/// <summary> /// Clears all lighting and then applies sun-lighting. /// </summary> /// <param name="chunk"></param> private static void SetInitialLighting(Chunk chunk) { byte sunValue = Chunk.MaxSunValue; for (byte x = 0; x < Chunk.WidthInBlocks; x++) { for (byte z = 0; z < Chunk.LengthInBlocks; z++) { int offset = BlockStorage.BlockIndexByRelativePosition(chunk, x, z); bool inShade = false; // if we get direct sunlight, inShade will be set to false. for (byte y = Chunk.MaxHeightIndexInBlocks; y > 0; y--) { if (!inShade && BlockStorage.Blocks[offset + y].Type != BlockType.None) // if we're under direct sunlight and just hit a solid block. { inShade = true; // set inShade to true; } BlockStorage.Blocks[offset + y].Sun = inShade ? (byte)0 : sunValue; BlockStorage.Blocks[offset + y].R = 0; BlockStorage.Blocks[offset + y].G = 0; BlockStorage.Blocks[offset + y].B = 0; } } } }
public void TestBlockStoragePersistent() { using (var ms = new MemoryStream()) { var storage = new BlockStorage(ms); using (var firstBlock = storage.CreateNew()) using (var secondBlock = storage.CreateNew()) using (var thirdBlock = storage.CreateNew()) { Assert.AreEqual(0, firstBlock.Id); Assert.AreEqual(1, secondBlock.Id); secondBlock.SetHeader(1, 100); secondBlock.SetHeader(2, 200); Assert.AreEqual(2, thirdBlock.Id); Assert.AreEqual(storage.BlockSize * 3, ms.Length); } // Test to make sure our creation persists var storage2 = new BlockStorage(ms); Assert.AreEqual(0, storage2.Find(0).Id); Assert.AreEqual(1, storage2.Find(1).Id); Assert.AreEqual(2, storage2.Find(2).Id); Assert.AreEqual(100, storage2.Find(1).GetHeader(1)); Assert.AreEqual(200, storage2.Find(1).GetHeader(2)); } }
private static void FluidFillSunLight(Chunk chunk) { for (byte x = 0; x < Chunk.WidthInBlocks; x++) { for (byte z = 0; z < Chunk.LengthInBlocks; z++) { int offset = BlockStorage.BlockIndexByRelativePosition(chunk, x, z); for (byte y = Chunk.MaxHeightIndexInBlocks; y > 0; y--) { var blockIndex = offset + y; if (BlockStorage.Blocks[blockIndex].Type != BlockType.None) // solid blocks can't propagate light. { continue; } var blockLight = BlockStorage.Blocks[blockIndex].Sun; if (blockLight <= 1) // if block's light value is too low (dark), { continue; // just skip it. } var propagatedLight = (byte)((blockLight * 9) / 10); PropagateSunLight(blockIndex + BlockStorage.XStep, propagatedLight); // propagate light to block in east. PropagateSunLight(blockIndex - BlockStorage.XStep, propagatedLight); // propagate light to block in west. PropagateSunLight(blockIndex + BlockStorage.ZStep, propagatedLight); // propagate light to block in north. PropagateSunLight(blockIndex - BlockStorage.ZStep, propagatedLight); // propagate light to block in south. // DO NOT repropagete to upper block which we don't need to do so and may cause loops! PropagateSunLight(blockIndex - 1, propagatedLight); // propagate light to block down. } } } }
public ChunkSection(bool storeSkylight, int sections = 2) { if (sections <= 0) { sections = 1; } //Data = new BlockStorage(); BlockStorages = new BlockStorage[sections]; for (int i = 0; i < sections; i++) { BlockStorages[i] = new BlockStorage(); } this.BlockLight = new NibbleArray(new byte[2048]); // if (storeSkylight) { this.SkyLight = new NibbleArray(new byte[2048]); } ResetLight(true, true); _scheduledUpdates = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); _scheduledSkylightUpdates = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); _scheduledBlocklightUpdates = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); }
public CacheContext(IStorageContext storageContext) { this._storageContext = storageContext; this._blockStorage = new BlockStorage(this); this._blockCache = new BlockCache ( cacheContext: this, maxFlushMemorySize: 10.MILLION(), maxCacheMemorySize: 1.MILLION() ); this._blockHeaderCache = new BlockHeaderCache ( cacheContext: this, maxFlushMemorySize: 10.MILLION(), maxCacheMemorySize: 1.MILLION() ); this._chainedBlockCache = new ChainedBlockCache ( cacheContext: this, maxFlushMemorySize: 1.MILLION(), maxCacheMemorySize: 100.MILLION() ); this._transactionCache = new TransactionCache ( cacheContext: this, maxCacheMemorySize: 1.MILLION() ); }
/// <summary> /// Adds game-components. /// </summary> private void AddComponents() { this.Rasterizer = new Rasterizer(); this.Game.Components.Add(new InputManager(this.Game)); this.Game.Components.Add(new AssetManager(this.Game)); #if XNA //this.Game.Components.Add(new Sky(this.Game)); #endif this.Game.Components.Add(new NewSky(this.Game)); this.Game.Components.Add(new Fogger(this.Game)); var chunkStorage = new ChunkStorage(this.Game); this.Game.Components.Add(chunkStorage); var vertexBuilder = new VertexBuilder(this.Game); this.Game.Components.Add(vertexBuilder); var chunkCache = new ChunkCache(this.Game); this.Game.Components.Add(chunkCache); var blockStorage = new BlockStorage(this.Game); this.Game.Components.Add(blockStorage); var world = new World(this.Game, chunkStorage, chunkCache); this.Game.Components.Add(world); this.Game.Components.Add(new Player(this.Game, world)); this.Game.Components.Add(new Camera(this.Game)); this.Game.Components.Add(new UserInterface(this.Game)); this.Game.Components.Add(new InGameDebugger(this.Game)); this.Game.Components.Add(new DebugBar(this.Game)); this.Game.Components.Add(new GraphManager(this.Game)); #if XNA this.Game.Components.Add(new AudioManager(this.Game)); #endif var spriteBatch = new SpriteBatch(this.Game.GraphicsDevice); Console = new GameConsole(this.Game, spriteBatch, new GameConsoleOptions { Font = Game.Content.Load <SpriteFont>(@"Fonts/Verdana"), FontColor = Color.LawnGreen, Prompt = ">", PromptColor = Color.Crimson, CursorColor = Color.OrangeRed, BackgroundColor = Color.Black * 0.8f, PastCommandOutputColor = Color.Aqua, BufferColor = Color.Gold }); }
public int getBlock(int x, int y, int z) { if (y < 0 || y > 255) { return(0); } BlockStorage var4 = this.storageArrays[y >> 4]; return(var4 != null?var4.getExtBlockID(x, y& 15, z) : 0); }
public void BlockStorageTests() { BlockStorage blockStorage = new BlockStorage(5); blockStorage.SetBlock(2, 1); blockStorage.SetBlock(4, 4); Assert.AreEqual(1, blockStorage.GetBlock(2)); Assert.AreEqual(4, blockStorage.GetBlock(4)); }
public int getBlockMetadata(int x, int y, int z) { if (y >> 4 >= this.storageArrays.Length) { return(0); } else { BlockStorage var4 = this.storageArrays[y >> 4]; return(var4 != null?var4.getExtBlockMetadata(x, y& 15, z) : 0); } }
public void TestManangingBlockInstances() { var manager = new BlockStorage(new MemoryStream()); var a = manager.CreateNew(); var b = manager.CreateNew(); Assert.AreSame(a, manager.Find(0)); Assert.AreSame(b, manager.Find(1)); Assert.AreNotSame(a, b); a.Dispose(); Assert.AreNotSame(a, manager.Find(0)); }
public ContentStorage(string basePath, BufferPool bufferPool) { var settingsPath = Path.Combine(basePath, "Settings"); var childrenPath = Path.Combine(basePath, "Children"); _bufferPool = bufferPool; _blockStorage = new BlockStorage(Path.Combine(childrenPath, nameof(ContentStorage)), _bufferPool); _contentMetadataStorage = new ContentMetadataStorage(); _settings = new SettingsDatabase(settingsPath); _checkEventScheduler = new EventScheduler(this.CheckThread); }
public Chunk() : base(6) { Blocks = new BlockStorage(); m_threadID = Globals.WorkPool.GetThreadIDFromIndex(s_id++); Pools = Globals.WorkPool.GetPool(m_threadID); m_drawCallBatcher = new DrawCallBatcher(Globals.CubeMeshBuilder, this); BBoxVertices = new List <Vector3>(); BBoxVerticesTransformed = new List <Vector3>(); Reset(); }
protected Council(Node.Node node, ChainType chainType, int chainId, uint chainIndex, short keyIndex, Key key) { ChainType = chainType; ChainId = chainId; ChainIndex = chainIndex; RequiresChainVoteKeyFlags = Block.GetRequiredChainVoteKeyFlags(ChainType); RequiresChainKeyFlags = Block.GetRequiredChainKeyFlags(ChainType); LocalKeyIndex = keyIndex; _localKey = key; _node = node; _coreChain = node.ChainManager.CoreChain; _blockStorage = node.ChainManager.GetChain(ChainType, ChainId, chainIndex).BlockStorage; }
public Chunk() { Blocks = new BlockStorage(); // Associate Chunk with a certain thread and make use of its memory pool // This is necessary in order to have lock-free caches ThreadID = Globals.WorkPool.GetThreadIDFromIndex(s_id++); Pools = Globals.WorkPool.GetPool(ThreadID); RenderGeometryBatcher = new RenderGeometryBatcher(Globals.CubeMeshGeometryBuilder, this); BBoxVertices = new List <Vector3>(); BBoxVerticesTransformed = new List <Vector3>(); StateManager = new ChunkStateManagerClient(this); }
public void Jump() { var footPosition = Position + new Vector3(0f, -1.5f, 0f); Block standingBlock = BlockStorage.BlockAt(footPosition); if (!standingBlock.Exists && this.Velocity.Y != 0) { return; } float amountBelowSurface = ((ushort)footPosition.Y) + 1 - footPosition.Y; Position += new Vector3(0, amountBelowSurface + 0.01f, 0); this.Velocity.Y = JumpVelocity; }
public void TestBlockGetSetHeader() { using (var ms = new MemoryStream()) { var storage = new BlockStorage(new MemoryStream()); var blockStart = storage.BlockSize * 22; ms.Write(new byte[blockStart], 0, blockStart); ms.Write(LittleEndianByteOrder.GetBytes(11L), 0, 8); ms.Write(LittleEndianByteOrder.GetBytes(22L), 0, 8); ms.Write(LittleEndianByteOrder.GetBytes(33L), 0, 8); ms.Write(LittleEndianByteOrder.GetBytes(44L), 0, 8); var firstSector = new byte[storage.DiskSectorSize]; ms.Position = ms.Position - 4 * 8; ms.Read(firstSector); using (var block = new Block(storage, 22, firstSector, ms)) { block.GetHeader(0); Assert.AreEqual(11L, block.GetHeader(0)); Assert.AreEqual(22L, block.GetHeader(1)); Assert.AreEqual(33L, block.GetHeader(2)); Assert.AreEqual(44L, block.GetHeader(3)); // Change header block.SetHeader(1, 33L); // Changed in memory Assert.AreEqual(33L, block.GetHeader(1)); // Should not be changed in actual stream var buffer = new byte[8]; ms.Position = blockStart + 8; ms.Read(buffer, 0, 8); Assert.AreEqual(22L, LittleEndianByteOrder.GetInt64(buffer)); } // Until we flush { var buffer = new byte[8]; ms.Position = blockStart + 8; ms.Read(buffer, 0, 8); Assert.AreEqual(33L, LittleEndianByteOrder.GetInt64(buffer)); } } }
private void ProcessPosition(GameTime gameTime) { if (FlyingEnabled) { return; } this.Velocity.Y += Gravity * (float)gameTime.ElapsedGameTime.TotalSeconds; var footPosition = Position + new Vector3(0f, -1.5f, 0f); Block standingBlock = BlockStorage.BlockAt(footPosition); if (standingBlock.Exists) { this.Velocity.Y = 0; } this.Position += Velocity * (float)gameTime.ElapsedGameTime.TotalSeconds; }
/// <summary> /// Builds vertex list for chunk. /// </summary> /// <param name="chunk"></param> private void BuildVertexList(Chunk chunk) { if (chunk.Disposed) { return; } Clear(chunk); for (byte x = 0; x < Chunk.WidthInBlocks; x++) { for (byte z = 0; z < Chunk.LenghtInBlocks; z++) { int offset = BlockStorage.BlockIndexByRelativePosition(chunk, x, z); for (byte y = chunk.LowestEmptyBlockOffset; y < chunk.HighestSolidBlockOffset; y++) { var blockIndex = offset + y; var block = BlockStorage.Blocks[blockIndex]; if (block.Type == BlockType.None) { continue; } var position = new Vector3Int(chunk.WorldPosition.X + x, y, chunk.WorldPosition.Z + z); this.BuildBlockVertices(chunk, blockIndex, position); } } } var vertices = chunk.VertexList.ToArray(); var indices = chunk.IndexList.ToArray(); if (vertices.Length == 0 || indices.Length == 0) { return; } chunk.VertexBuffer = new VertexBuffer(this.Game.GraphicsDevice, typeof(BlockVertex), vertices.Length, BufferUsage.WriteOnly); chunk.VertexBuffer.SetData(vertices); chunk.IndexBuffer = new IndexBuffer(this.Game.GraphicsDevice, IndexElementSize.SixteenBits, indices.Length, BufferUsage.WriteOnly); chunk.IndexBuffer.SetData(indices); }
static void Main(string[] args) { if (args.Length < 2) { Console.WriteLine("Usage: dotnet run <part1|part2> <puzzleInputFile>"); return; } var data = File.ReadAllText(args[1]); var block = new BlockStorage(data, new [] { " ", "\t" }); Console.WriteLine(block.ToString()); var previousBlocks = new List <BlockStorage>(); var cycles = 0; while (!previousBlocks.Where(x => x.Equals(block)).Any()) { previousBlocks.Add(block); block = block.Redistribute(); Console.WriteLine(block.ToString()); cycles++; } switch (args[0]) { case "part1": Console.WriteLine($"Redistribution matched after {cycles} cycles."); break; case "part2": var matchingBlockIndex = -1; var i = previousBlocks.Count() - 1; while (matchingBlockIndex == -1) { if (previousBlocks[i].Equals(block)) { matchingBlockIndex = i; } i--; } Console.WriteLine($"Count between matching distributions: {previousBlocks.Count() - matchingBlockIndex}."); break; } }
protected override void GenerateBlocks(Chunk chunk, int worldPositionX, int worldPositionZ) { var offset = BlockStorage.BlockIndexByWorldPosition(worldPositionX, worldPositionZ); for (int y = Chunk.MaxHeightIndexInBlocks; y >= 0; y--) { if (y >= DirtHeight) { BlockStorage.Blocks[offset + y] = new Block(BlockType.None); } else { BlockStorage.Blocks[offset + y] = new Block(BlockType.Dirt); } } // apply the biome generator on x-z column. this.BiomeGenerator.ApplyBiome(chunk, DirtHeight - 1, offset + DirtHeight - 1, worldPositionX + this.Seed, worldPositionZ); }
private void FindAimedBlock() { for (float x = 0.5f; x < 8f; x += 0.1f) { Vector3 target = this._camera.Position + (LookVector * x); var block = BlockStorage.BlockAt(target); if (!block.Exists) { this.AimedEmptyBlock = new PositionedBlock(new Vector3Int(target), block); } else { this.AimedSolidBlock = new PositionedBlock(new Vector3Int(target), block); return; } } this.AimedSolidBlock = null; }
private void PlantTree(Chunk chunk, int grassLevel, int grassOffset, int worldPositionX, int worldPositionZ) { // based on: http://techcraft.codeplex.com/SourceControl/changeset/view/5c1888588e5d#TechCraft%2fNewTake%2fNewTake%2fmodel%2fterrain%2fSimpleTerrain.cs var trunkHeight = (byte)(5 + (byte)_treePlanter.Next(10)); Console.WriteLine("tree location: {0},{1},{2}", worldPositionX, grassLevel, worldPositionZ); // trunk for (byte y = 1; y <= trunkHeight; y++) { BlockStorage.Blocks[grassOffset + y].Type = BlockType.Tree; // set the foliage. int radius = 2; Console.WriteLine("foliage: {0}-{1}, {2}, {3}", worldPositionX - radius, worldPositionX + radius, grassLevel + y, worldPositionZ); for (int x = worldPositionX - radius; x <= worldPositionX + radius; x++) { //for (int z = worldPositionZ - radius; z <= worldPositionZ + radius; z++) //{ if (!BlockStorage.BlockAt(x, grassLevel + y, worldPositionZ).Exists) { Console.Write("leave "); BlockStorage.SetBlockAt(x, grassLevel + y, worldPositionZ, new Block(BlockType.Leaves)); } else { Console.Write("solid "); } //} } Console.WriteLine(); } if (grassLevel + trunkHeight > chunk.HighestSolidBlockOffset) { chunk.HighestSolidBlockOffset = (byte)(grassLevel + trunkHeight + 1); } }
public ChunkSection(ChunkColumn owner, int y, bool storeSkylight, int sections = 2) { Owner = owner; if (sections <= 0) { sections = 1; } this._yBase = y; //Data = new BlockStorage(); _blockStorages = new BlockStorage[sections]; for (int i = 0; i < sections; i++) { _blockStorages[i] = new BlockStorage(); } this.BlockLight = new NibbleArray(new byte[2048]); MiNET.Worlds.ChunkColumn.Fill <byte>(BlockLight.Data, 0); // if (storeSkylight) { this.SkyLight = new NibbleArray(new byte[2048]); MiNET.Worlds.ChunkColumn.Fill <byte>(SkyLight.Data, (byte)(storeSkylight ? 0xff : 0x00)); } //System.Collections.BitArray a = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); TransparentBlocks = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); SolidBlocks = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); ScheduledUpdates = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); ScheduledSkylightUpdates = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); ScheduledBlocklightUpdates = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); RenderedBlocks = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]); for (int i = 0; i < TransparentBlocks.Length; i++) { TransparentBlocks[i] = true; SolidBlocks[i] = false; } }
/// <summary> /// Sets block at given relative position. /// </summary> /// <param name="x"></param> /// <param name="y"></param> /// <param name="z"></param> /// <param name="block"></param> public void FastSetBlockAt(byte x, byte y, byte z, Block block) { switch (block.Exists) { case false: if (this.LowestEmptyBlockOffset > y && y > 0) { this.LowestEmptyBlockOffset = (byte)(y - 1); } break; case true: if (y > this.HighestSolidBlockOffset && y < MaxHeightIndexInBlocks) { this.HighestSolidBlockOffset = (byte)(y + 1); } break; } BlockStorage.FastSetBlockAt(this.WorldPosition.X + x, y, this.WorldPosition.Z + z, block); this.ChunkState = ChunkState.AwaitingRelighting; }
protected override void GenerateBlocks(Chunk chunk, int worldPositionX, int worldPositionZ) { var rockHeight = this.GetRockHeight(worldPositionX, worldPositionZ); var dirtHeight = this.GetDirtHeight(worldPositionX, worldPositionZ, rockHeight); var offset = BlockStorage.BlockIndexByWorldPosition(worldPositionX, worldPositionZ); for (int y = Chunk.MaxHeightIndexInBlocks; y >= 0; y--) { if (y > dirtHeight) // air { BlockStorage.Blocks[offset + y] = new Block(BlockType.None); if (chunk.LowestEmptyBlockOffset > y) { chunk.LowestEmptyBlockOffset = (byte)y; } } else if (y > rockHeight) // dirt { var valleyNoise = this.GenerateValleyNoise(worldPositionX, worldPositionZ, y); BlockStorage.Blocks[offset + y] = new Block(valleyNoise > 0.2f ? BlockType.None : BlockType.Dirt); if (y > chunk.HighestSolidBlockOffset) { chunk.HighestSolidBlockOffset = (byte)y; } } else // rock level { BlockStorage.Blocks[offset + y] = new Block(BlockType.Rock); if (y > chunk.HighestSolidBlockOffset) { chunk.HighestSolidBlockOffset = (byte)y; } } } // apply the biome generator on x-z column. this.BiomeGenerator.ApplyBiome(chunk, dirtHeight, offset + dirtHeight, worldPositionX + this.Seed, worldPositionZ); }
public static ChunkColumn ReadColumnData(byte[] data, int chunkX, int chunkZ, bool chunksContinuous, bool hasSkyLight, int chunkMask) { using (MemoryStream memstream = new MemoryStream(data, false)) { InputBuffer input = new InputBuffer(memstream); ChunkColumn column = new ChunkColumn(chunkX, chunkZ); for (int chunkY = 0; chunkY < 16; chunkY++) { if ((chunkMask & (1 << chunkY)) != 0) { BlockStorage blocks = new BlockStorage(input); input.ReadData(2048); if (hasSkyLight) { input.ReadData(2048); } column[chunkY] = new ChunkData(blocks); } } return(column); } }
public void Init() { _game = new GameClient(); this._config = new EngineConfig(); this._engine = new Engine.Core.Engine(this._game, this._config); var cacheWidthInBlocks = ((_config.Cache.CacheRange * 2) + 1) * _config.Chunk.WidthInBlocks; var cacheLenghtInBlocks = ((_config.Cache.CacheRange * 2) + 1) * _config.Chunk.LengthInBlocks; this._cacheXStartIndex = -cacheWidthInBlocks / 2; this._cacheXEndIndex = cacheWidthInBlocks / 2; this._cacheZStartIndex = -cacheLenghtInBlocks / 2; this._cacheZEndIndex = cacheLenghtInBlocks / 2; this._directlyIndexedValidationDictionary = new Dictionary <int, BlockType>(); // set the initial values. for (var x = this._cacheXStartIndex; x < this._cacheXEndIndex; x++) { for (var z = this._cacheZStartIndex; z < this._cacheZEndIndex; z++) { var offset = BlockStorage.BlockIndexByWorldPosition(x, z); for (var y = 0; y < _config.Chunk.HeightInBlocks; y++) { var index = offset + y; var block = new Block().RandomizeType(); this._directlyIndexedValidationDictionary.Add(index, block.Type); BlockStorage.Blocks[index] = block; } } } // check if validationDictionaries item count is equal to CacheRange's volume. Assert.AreEqual(this._directlyIndexedValidationDictionary.Values.Count, _config.Cache.CacheRangeVolume); }