public IChunk GenerateChunk(IWorld world, Coordinates2D position)
 {
     var chunk = new Chunk(position);
     int y = 0;
     for (int i = 0; i < Layers.Count; i++)
     {
         int height = y + Layers[i].Height;
         while (y < height)
         {
             for (int x = 0; x < 16; x++)
             {
                 for (int z = 0; z < 16; z++)
                 {
                     chunk.SetBlockID(new Coordinates3D(x, y, z), Layers[i].BlockId);
                     chunk.SetMetadata(new Coordinates3D(x, y, z), Layers[i].Metadata);
                 }
             }
             y++;
         }
     }
     for (int i = 0; i < chunk.Biomes.Length; i++)
         chunk.Biomes[i] = (byte)Biome;
     chunk.TerrainPopulated = true;
     chunk.UpdateHeightMap();
     return chunk;
 }

        private static void AddChunk(MinecraftClient client, int x, int z, ushort primaryBitMap, ushort addBitMap, bool lightIncluded, bool groundUp, byte[] data)
        {
            var coordinates = new Coordinates2D(x, z);
            var relativePosition = GetRelativeChunkPosition(coordinates);
            var chunk = new Chunk(relativePosition);
            var sectionCount = GetSectionCount(primaryBitMap);

            // Run through the sections
            // TODO: Support block IDs >255
            for (int y = 0; y < 16; y++)
            {
                if ((primaryBitMap & (1 << y)) > 0)
                {
                    // Blocks
                    Array.Copy(data, y * BlockDataLength, chunk.Sections[y].Blocks, 0, BlockDataLength);
                    // Metadata
                    Array.Copy(data, (BlockDataLength * sectionCount) + (y * NibbleDataLength),
                        chunk.Sections[y].Metadata.Data, 0, NibbleDataLength);
                    // Light
                    Array.Copy(data, ((BlockDataLength + NibbleDataLength) * sectionCount) + (y * NibbleDataLength),
                        chunk.Sections[y].BlockLight.Data, 0, NibbleDataLength);
                    // Sky light
                    if (lightIncluded)
                    {
                        Array.Copy(data, ((BlockDataLength + NibbleDataLength + NibbleDataLength) * sectionCount) + (y * NibbleDataLength),
                            chunk.Sections[y].SkyLight.Data, 0, NibbleDataLength);
                    }
                }
            }
            if (groundUp)
                Array.Copy(data, data.Length - chunk.Biomes.Length, chunk.Biomes, 0, chunk.Biomes.Length);
            client.World.SetChunk(coordinates, chunk);
            //client.OnChunkRecieved(new ChunkRecievedEventArgs(position, new ReadOnlyChunk(chunk)));
        }

        public IPacket ReadPacket(IMinecraftDataReader reader)
        {
            Coordinates = Coordinates2D.FromReaderInt(reader);
            RecordList = RecordList.FromReader(reader);

            return this;
        }

 public static bool IsCuboidCorner(Coordinates2D location, Coordinates3D start, Vector3 size)
 {
     return location.X.Equals(start.X) && location.Z.Equals(start.Z)
         || location.X.Equals(start.X) && location.Z.Equals(start.Z + (int)size.Z - 1)
         || location.X.Equals(start.X + (int)size.X - 1) && location.Z.Equals(start.Z)
         || location.X.Equals(start.X + (int)size.X - 1) && location.Z.Equals(start.Z + (int)size.Z - 1);
 }

 public Model(Coordinates2D min, Coordinates2D max, int wolfCount, int preyCount)
 {
     this.min = min;
     this.max = max;
     this.wolfCount = wolfCount;
     this.preyCount = preyCount;
 }

 public byte GenerateBiome(int seed, IBiomeRepository biomes, Coordinates2D location)
 {
     double temp = Math.Abs(TempNoise.Value2D(location.X, location.Z));
     double rainfall = Math.Abs(RainNoise.Value2D(location.X, location.Z));
     byte ID = biomes.GetBiome(temp, rainfall).ID;
     return ID;
 }

        public void GenerateChunk(Coordinates2D coordinates)
        {
            int regionX = coordinates.X / Region.Width - ((coordinates.X < 0) ? 1 : 0);
            int regionZ = coordinates.Z / Region.Depth - ((coordinates.Z < 0) ? 1 : 0);

            var region = LoadOrGenerateRegion(new Coordinates2D(regionX, regionZ));
            region.GenerateChunk(new Coordinates2D(coordinates.X - regionX * 32, coordinates.Z - regionZ * 32));
        }

 public void FindIntersectionVector_LeftBorder()
 {
     Coordinates2D intersection = new Coordinates2D(XMIN, 200);
     Vector2D vector = new Vector2D(-140, -20);
     Vector2D actualVector = _testAsset.FindIntersectionVector(vector, intersection);
     Vector2D expectedVector = new Vector2D(140 * RICOCHE, -20 * RICOCHE);
     Assert.AreEqual(expectedVector.X, actualVector.X);
     Assert.AreEqual(expectedVector.Y, actualVector.Y);
 }

 public void FindIntersectionVector_UpperBorder()
 {
     Coordinates2D intersection = new Coordinates2D(500, YMAX);
     Vector2D vector = new Vector2D(-100,50);
     Vector2D actualVector = _testAsset.FindIntersectionVector(vector, intersection);
     Vector2D expectedVector = new Vector2D(-100 * RICOCHE, -50 * RICOCHE);
     Assert.AreEqual(expectedVector.X, actualVector.X);
     Assert.AreEqual(expectedVector.Y, actualVector.Y);
 }

 public void FindIntersectionVector_ButtomBorder()
 {
     Coordinates2D intersection = new Coordinates2D(750, YMIN);
     Vector2D vector = new Vector2D(50, -300);
     Vector2D actualVector = _testAsset.FindIntersectionVector(vector, intersection);
     Vector2D expectedVector = new Vector2D(50 * RICOCHE, 300 * RICOCHE);
     Assert.AreEqual(expectedVector.X, actualVector.X);
     Assert.AreEqual(expectedVector.Y, actualVector.Y);
 }

 /// <summary>
 /// Retrieves the requested chunk from the region, or
 /// generates it if a world generator is provided.
 /// </summary>
 /// <param name="position">The position of the requested local chunk coordinates.</param>
 public IChunk GetChunk(Coordinates2D position, bool generate = true)
 {
     // TODO: This could use some refactoring
     lock (Chunks)
     {
         if (!Chunks.ContainsKey(position))
         {
             if (regionFile != null)
             {
                 // Search the stream for that region
                 lock (regionFile)
                 {
                     var chunkData = GetChunkFromTable(position);
                     if (chunkData == null)
                     {
                         if (World.ChunkProvider == null)
                             throw new ArgumentException("The requested chunk is not loaded.", "position");
                         if (generate)
                             GenerateChunk(position);
                         else
                             return null;
                         return Chunks[position];
                     }
                     regionFile.Seek(chunkData.Item1, SeekOrigin.Begin);
                     /*int length = */
                     new MinecraftStream(regionFile).ReadInt32(); // TODO: Avoid making new objects here, and in the WriteInt32
                     int compressionMode = regionFile.ReadByte();
                     switch (compressionMode)
                     {
                         case 1: // gzip
                             throw new NotImplementedException("gzipped chunks are not implemented");
                         case 2: // zlib
                             var nbt = new NbtFile();
                             nbt.LoadFromStream(regionFile, NbtCompression.ZLib, null);
                             var chunk = Chunk.FromNbt(nbt);
                             Chunks.Add(position, chunk);
                             World.OnChunkLoaded(new ChunkLoadedEventArgs(chunk));
                             break;
                         default:
                             throw new InvalidDataException("Invalid compression scheme provided by region file.");
                     }
                 }
             }
             else if (World.ChunkProvider == null)
                 throw new ArgumentException("The requested chunk is not loaded.", "position");
             else
             {
                 if (generate)
                     GenerateChunk(position);
                 else
                     return null;
             }
         }
         return Chunks[position];
     }
 }

        public Chunk GetChunkWithoutGeneration(Coordinates2D coordinates)
        {
            int regionX = coordinates.X / Region.Width - ((coordinates.X < 0) ? 1 : 0);
            int regionZ = coordinates.Z / Region.Depth - ((coordinates.Z < 0) ? 1 : 0);

            var regionPosition = new Coordinates2D(regionX, regionZ);
            if (!Regions.ContainsKey(regionPosition)) return null;
            return Regions[regionPosition].GetChunkWithoutGeneration(
                new Coordinates2D(coordinates.X - regionX * 32, coordinates.Z - regionZ * 32));
        }

        public int GetChunkIndex(Coordinates2D coordinates)
        {
            foreach (var chunk in Chunks)
            {
                if (chunk.Coordinates == coordinates)
                    return Chunks.IndexOf(chunk);
            }

            return -1;
        }

 /// <summary>
 /// Creates a region from the given region file.
 /// </summary>
 public Region(Coordinates2D position, World world, string file) : this(position, world)
 {
     if (File.Exists(file))
         regionFile = File.Open(file, FileMode.OpenOrCreate);
     else
     {
         regionFile = File.Open(file, FileMode.OpenOrCreate);
         CreateRegionHeader();
     }
 }

 internal IChunk FindChunk(Coordinates2D coordinates)
 {
     try
     {
         return World.FindChunk(new Coordinates3D(coordinates.X, 0, coordinates.Z));
     }
     catch
     {
         return null;
     }
 }

 public Chunk(Coordinates2D coordinates)
     : this()
 {
     X = coordinates.X;
     Z = coordinates.Z;
     const int size = Width * Height * Depth;
     Blocks = new byte[size];
     Metadata = new NibbleArray(size);
     BlockLight = new NibbleArray(size);
     SkyLight = new NibbleArray(size);
 }

 protected override IEnumerable<Coordinates2D> GetNeighbours(Coordinates2D coord)
 {
     if(coord.x > TopLeft.x)
         yield return new Coordinates2D(coord.x - 1, coord.y);
     if(coord.x < BottomRight.x)
         yield return new Coordinates2D(coord.x + 1, coord.y);
     if(coord.y > TopLeft.y)
         yield return new Coordinates2D(coord.x, coord.y - 1);
     if(coord.y < BottomRight.y)
         yield return new Coordinates2D(coord.x, coord.y + 1);
 }

        public void SetChunk(Coordinates2D coordinates, Chunk chunk)
        {
            int regionX = coordinates.X / Region.Width - ((coordinates.X < 0) ? 1 : 0);
            int regionZ = coordinates.Z / Region.Depth - ((coordinates.Z < 0) ? 1 : 0);

            var region = LoadOrGenerateRegion(new Coordinates2D(regionX, regionZ));
            lock (region)
            {
                chunk.IsModified = true;
                region.SetChunk(new Coordinates2D(coordinates.X - regionX * 32, coordinates.Z - regionZ * 32), chunk);
            }
        }

 /*
  * The distance to the closest biome cell point to the specified location(uses the Chebyshev distance function).
  */
 public double ClosestCellPoint(Coordinates2D location)
 {
     var distance = double.MaxValue;
     foreach (BiomeCell C in BiomeCells)
     {
         var _distance = Distance(location, C.CellPoint);
         if (_distance < distance)
         {
             distance = _distance;
         }
     }
     return distance;
 }

 protected void InitializeWorld(Coordinates2D min, Coordinates2D max)
 {
     ILogManager logManager;
     world = SystemBuilder
         .Create<Coordinates2D, EmptyData, EmptyData>()
         .WithDefaultLog(out logManager)
         .WithTopology(new FourConnectedSurfaceTopology(min, max))
         .WithSurfaceMap()
         .WithEmptyNodeData()
         .WithEmptyEdgeData()
         .Build();
     journal = logManager.Journal;
     world = runner.World;
     runner = new Runner<Coordinates2D, EmptyData, EmptyData>(world);
 }