Exemplo n.º 1
0
        protected void GenerateCircle(ChunkColumn chunk, Vector3 location, int radius, Block block)
        {
            for (var I = -radius; I <= radius; I = (I + 1))
            {
                for (var j = -radius; j <= radius; j = (j + 1))
                {
                    var max = (int) Math.Sqrt((I*I) + (j*j));
                    if (max <= radius)
                    {
                        var X = location.X + I;
                        var Z = location.Z + j;

                        if (X < 0 || X >= 16 || Z < 0 || Z >= 256)
                            continue;

                        var x = (int) X;
                        var y = (int) location.Y;
                        var z = (int) Z;
                        if (chunk.GetBlock(x, y, z).Equals(0))
                        {
                            chunk.SetBlock(x, y, z, block);
                        }
                    }
                }
            }
        }
Exemplo n.º 2
0
        public override void Decorate(ChunkColumn chunk, BiomeBase biome)
        {
            /*	var trees = ExperimentalV2Generator.GetRandomNumber(3, 8);
            var treeBasePositions = new int[trees, 2];

            for (var t = 0; t < trees; t++)
            {
                var x = ExperimentalV2Generator.GetRandomNumber(1, 16);
                var z = ExperimentalV2Generator.GetRandomNumber(1, 16);
                treeBasePositions[t, 0] = x;
                treeBasePositions[t, 1] = z;
            }
            for (int y = ExperimentalV2Generator.WaterLevel; y < 256; y++)
            {
                for (var pos = 0; pos < trees; pos++)
                {
                    if (chunk.GetBlock(treeBasePositions[pos, 0], y, treeBasePositions[pos, 1]) == biome.TopBlock.Id)
                    {
                            var meta = ExperimentalV2Generator.GetRandomNumber(0, 8);
                            chunk.SetBlock(treeBasePositions[pos, 0], y + 1, treeBasePositions[pos, 1],
                                new Block(38) {Metadata = (ushort) meta});
                    }
                }
            }*/
        }
Exemplo n.º 3
0
 public override void Decorate(ChunkColumn chunk, BiomeBase biome)
 {
     for (var x = 0; x < 16; x++)
     {
         for (var z = 0; z < 16; z++)
         {
             //Check for temperature.
             for (var y = 0; y < StandardWorldProvider.WaterLevel; y++)
             {
                 //Lake generation
                 if (y < StandardWorldProvider.WaterLevel)
                 {
                     if (chunk.GetBlock(x, y, z) == 2 || chunk.GetBlock(x, y, z) == 3) //Grass or Dirt?
                     {
                         if (StandardWorldProvider.GetRandomNumber(1, 40) == 1 && y < StandardWorldProvider.WaterLevel - 4)
                             chunk.SetBlock(x, y, z, BlockFactory.GetBlockById(82)); //Clay
                         else
                         {
                             chunk.SetBlock(x, y, z, new BlockSand()); //Sand
                             chunk.BiomeId[x*16 + z] = 16; //Beach
                         }
                     }
                     if (chunk.GetBlock(x, y + 1, z) == 0)
                     {
                         if (y < StandardWorldProvider.WaterLevel - 3)
                         {
                             chunk.SetBlock(x, y + 1, z, new BlockFlowingWater()); //Water
                             chunk.BiomeId[x*16 + z] = 0; //Ocean
                         }
                     }
                 }
             }
         }
     }
 }
Exemplo n.º 4
0
		public static ChunkColumn DecocedChunkColumn(byte[] buffer)
		{
			return null;
			MemoryStream stream = new MemoryStream(buffer);
			{
				NbtBinaryReader defStream = new NbtBinaryReader(stream, true);
				ChunkColumn chunk = new ChunkColumn();

				chunk.x = IPAddress.NetworkToHostOrder(defStream.ReadInt32());
				chunk.z = IPAddress.NetworkToHostOrder(defStream.ReadInt32());

				int chunkSize = 16*16*128;
				defStream.Read(chunk.blocks, 0, chunkSize);
				defStream.Read(chunk.metadata.Data, 0, chunkSize/2);
				defStream.Read(chunk.skylight.Data, 0, chunkSize/2);
				defStream.Read(chunk.blocklight.Data, 0, chunkSize/2);

				defStream.Read(chunk.height, 0, 256);

				byte[] ints = new byte[256*4];
				defStream.Read(ints, 0, ints.Length);
				int j = 0;
				for (int i = 0; i < ints.Length; i = i + 4)
				{
					chunk.biomeColor[j++] = BitConverter.ToInt32(new[] {ints[i], ints[i + 1], ints[i + 2], ints[i + 3]}, 0);
				}

				return chunk;
			}
		}
Exemplo n.º 5
0
        private void DecorateTrees(ChunkColumn chunk, BiomeBase biome)
        {
            var trees = StandardWorldProvider.GetRandomNumber(biome.MinTrees, biome.MaxTrees);
            var treeBasePositions = new int[trees, 2];

            for (var t = 0; t < trees; t++)
            {
                var x = new Random().Next(1, 16);
                var z = new Random().Next(1, 16);
                treeBasePositions[t, 0] = x;
                treeBasePositions[t, 1] = z;
            }

            for (var y = StandardWorldProvider.WaterLevel + 2; y < 256; y++)
            {
                for (var pos = 0; pos < trees; pos++)
                {
                    if (treeBasePositions[pos, 0] < 14 && treeBasePositions[pos, 0] > 4 && treeBasePositions[pos, 1] < 14 &&
                        treeBasePositions[pos, 1] > 4)
                    {
                        if (chunk.GetBlock(treeBasePositions[pos, 0], y + 1, treeBasePositions[pos, 1]) == biome.TopBlock.Id)
                        {
                            GenerateTree(chunk, treeBasePositions[pos, 0], y + 1, treeBasePositions[pos, 1], biome);
                        }
                    }
                }
            }
        }
Exemplo n.º 6
0
 private void GenerateTree(ChunkColumn chunk, int x, int treebase, int z, BiomeBase biome)
 {
     if (biome.TreeStructures.Length > 0)
     {
         var value = StandardWorldProvider.GetRandomNumber(0, biome.TreeStructures.Length);
         biome.TreeStructures[value].Create(chunk, x, treebase, z);
     }
 }
Exemplo n.º 7
0
 public virtual void Create(ChunkColumn chunk, int x, int y, int z)
 {
     if (chunk.GetBlock(x, y + Height, z) == 0)
     {
         foreach (var b in Blocks)
         {
             chunk.SetBlock(x + (int) b.Coordinates.X, y + (int) b.Coordinates.Y, z + (int) b.Coordinates.Z, b);
         }
     }
 }
Exemplo n.º 8
0
 public override void Decorate(ChunkColumn chunk, BiomeBase biome, int x, int z)
 {
     for (var y = 1; y < 6; y++)
     {
         if (StandardWorldProvider.GetRandomNumber(0, 5) == 1)
         {
             chunk.SetBlock(x, y, z, BlockFactory.GetBlockById(7));
         }
     }
 }
Exemplo n.º 9
0
 public static void GenerateColumn(ChunkColumn chunk, Vector3 location, int height, Block block)
 {
     for (var o = 0; o < height; o++)
     {
         var x = (int) location.X;
         var y = (int) location.Y + o;
         var z = (int) location.Z;
         chunk.SetBlock(x, y, z, block);
     }
 }
Exemplo n.º 10
0
		public void Create(ChunkColumn chunk, int x, int y, int z)
		{
			if (chunk.GetBlock(x, y + MaxHeight, z) == (byte) Material.Air)
			{
				foreach (Block b in Blocks)
				{
					chunk.SetBlock(x + b.Coordinates.X, y + b.Coordinates.Y, z + b.Coordinates.Z, b.Id);
					chunk.SetMetadata(x + b.Coordinates.X, y + b.Coordinates.Y, z + b.Coordinates.Z, b.Metadata);
				}
			}
		}
Exemplo n.º 11
0
 public override void Decorate(ChunkColumn chunk, BiomeBase biome, int x, int z)
 {
     for (var y = StandardWorldProvider.WaterLevel; y < 256; y++)
     {
         if (StandardWorldProvider.GetRandomNumber(0, 10) == 5)
         {
             if (chunk.GetBlock(x, y, z) == biome.TopBlock.Id)
             {
                 chunk.SetBlock(x, y + 1, z, new Block(31) {Metadata = 1});
             }
         }
     }
 }
Exemplo n.º 12
0
        public ChunkColumn GenerateChunkColumn(ChunkCoordinates chunkCoordinates)
        {
            ChunkColumn cachedChunk;
            if (_chunkCache.TryGetValue(chunkCoordinates, out cachedChunk)) return cachedChunk;

            ChunkColumn chunk = new ChunkColumn();
            chunk.x = chunkCoordinates.X;
            chunk.z = chunkCoordinates.Z;

            PopulateChunk(chunk);

            _chunkCache[chunkCoordinates] = chunk;

            return chunk;
        }
Exemplo n.º 13
0
 public override void Decorate(ChunkColumn chunk, BiomeBase biome, int x, int z)
 {
     if (x < 15 && x > 3 && z < 15 && z > 3)
     {
         for (var y = StandardWorldProvider.WaterLevel; y < 256; y++)
         {
             if (StandardWorldProvider.GetRandomNumber(0, 30) == 5)
             {
                 if (chunk.GetBlock(x, y + 1, z) == biome.TopBlock.Id)
                 {
                     GenerateTree(chunk, x, y + 1, z, biome);
                 }
             }
         }
     }
 }
Exemplo n.º 14
0
 public void GenerateCave(ChunkColumn chunk)
 {
     _gcRandom = new GcRandom(chunk, _seedi);
     for (var x = 0; x < 16; x++)
     {
         for (var z = 0; z < 16; z++)
         {
             for (var y = 50; y >= 6; y--)
             {
                 if (_gcRandom.IsInCave(x, y, z))
                 {
                     chunk.SetBlock(x, y, z, new BlockAir());
                 }
             }
         }
     }
 }
Exemplo n.º 15
0
        public override void Decorate(ChunkColumn chunk, BiomeBase biome, int x, int z)
        {
            _chunke = chunk;
            for (var y = 1 /*No need to check first layer :p*/; y < 128 /*Nothing above this*/; y++)
            {
                if (chunk.GetBlock(x, y, z) == 1)
                {
                    if (y < 128)
                    {
                        GenerateCoal(x, y, z);
                    }

                    if (y < 64)
                    {
                        GenerateIron(x, y, z);
                    }

                    if (y < 29)
                    {
                        GenerateGold(x, y, z);
                    }

                    if (y < 23)
                    {
                        GenerateLapis(x, y, z);
                    }

                    if (y < 16)
                    {
                        if (y > 12)
                        {
                            if (StandardWorldProvider.GetRandomNumber(0, 3) == 2)
                            {
                                GenerateDiamond(x, y, z);
                            }
                        }
                        else
                        {
                            GenerateDiamond(x, y, z);
                        }
                    }
                }
            }
        }
Exemplo n.º 16
0
        public override void Create(ChunkColumn chunk, int x, int y, int z)
        {
            var location = new Vector3(x, y, z);
            if (!ValidLocation(new Vector3(x, y, z))) return;

            var r = new Random();
            var height = r.Next(7, 8);
            GenerateColumn(chunk, location, height, new Block(17) {Metadata = 1});
            for (var Y = 1; Y < height; Y++)
            {
                if (Y%2 == 0)
                {
                    GenerateVanillaCircle(chunk, location + new Vector3(0, Y + 1, 0), _leafRadius - 1, new Block(18) {Metadata = 1});
                    continue;
                }
                GenerateVanillaCircle(chunk, location + new Vector3(0, Y + 1, 0), _leafRadius, new Block(18) {Metadata = 1});
            }

            GenerateTopper(chunk, location + new Vector3(0, height, 0), 0x1);
        }
Exemplo n.º 17
0
        internal GcRandom(ChunkColumn chunki, int seed)
        {
            Chunk = chunki;
            _subtractForLessThanCutoff = _amplitude1 - _cutOff;
            _f1Xz = 1.0/_sxz;
            _f1Y = 1.0/_sy;

            if (_maxCaveHeight - _minCaveHeight > 128)
            {
                _caveBandBuffer = 32;
            }
            else
            {
                _caveBandBuffer = 16;
            }

            _noiseGen1 = new SimplexPerlin(seed, NoiseQuality.Fast);
            _noiseGen2 = new SimplexPerlin((int) _noiseGen1.GetValue(Chunk.X, Chunk.Z), NoiseQuality.Fast);
            _noiseGen3 = new SimplexPerlin((int) _noiseGen1.GetValue(Chunk.X, Chunk.Z), NoiseQuality.Fast);
        }
Exemplo n.º 18
0
 public override void Decorate(ChunkColumn chunk, BiomeBase biome)
 {
     for (var x = 0; x < 16; x++)
     {
         for (var z = 0; z < 16; z++)
         {
             for (var y = 0; y < LavaLevel; y++)
             {
                 //Lake generation
                 if (y < LavaLevel)
                 {
                     if (chunk.GetBlock(x, y + 1, z) == 0)
                     {
                         chunk.SetBlock(x, y + 1, z, BlockFactory.GetBlockById(10)); //Lava
                     }
                 }
             }
         }
     }
 }
Exemplo n.º 19
0
        public void Calculate(ChunkColumn chunk, ChunkCoordinates chunkCoordinates)
        {
            var cx = (chunkCoordinates.X << 4);
            var cz = (chunkCoordinates.Z << 4);

            for (int x = 0; x < 16; x++)
            {
                var rx = cx + x;
                for (int z = 0; z < 16; z++)
                {
                    var rz     = cz + z;
                    int height = chunk.GetHeight(x, z);

                    for (int y = height; y < 255; y++)
                    {
                        Process(chunk, rx, height, rz);
                        //Process(chunk, x, y, z);
                    }
                }
            }
        }
        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);
        }
Exemplo n.º 21
0
 private bool IsValidSugarCaneLocation(ChunkColumn chunk, int x, int y, int z)
 {
     if (y - 1 <= 0)
     {
         return(false);
     }
     if (x - 1 >= 0 && x + 1 < 16)
     {
         if (z - 1 >= 0 && z + 1 < 16)
         {
             if (chunk.GetBlock(x + 1, y, z) == 8 ||
                 chunk.GetBlock(x - 1, y, z) == 8 ||
                 chunk.GetBlock(x, y, z + 1) == 8 ||
                 chunk.GetBlock(x, y, z - 1) == 8)
             {
                 return(true);
             }
         }
     }
     return(false);
 }
Exemplo n.º 22
0
        public override ChunkColumn LoadChunk(int x, int z)
        {
            var u      = Globals.Decompress(File.ReadAllBytes(Folder + "/" + x + "." + z + ".cfile"));
            var reader = new MSGBuffer(u);

            var blockLength = reader.ReadInt();
            var block       = reader.ReadUShortLocal(blockLength);

            var metalength = reader.ReadInt();
            var blockmeta  = reader.ReadShortLocal(metalength);

            //var blockies = new Block[block.Length];
            //for (var i = 0; i < block.Length; i++)
            //{
            //	blockies[i] = new Block(block[i]) { Metadata = (byte) blockmeta[i] };
            //}

            var skyLength = reader.ReadInt();
            var skylight  = reader.Read(skyLength);

            var lightLength = reader.ReadInt();
            var blocklight  = reader.Read(lightLength);

            var biomeIdLength = reader.ReadInt();
            var biomeId       = reader.Read(biomeIdLength);

            var cc = new ChunkColumn
            {
                Blocks     = block,
                Metadata   = blockmeta,
                Blocklight = { Data = blocklight },
                Skylight   = { Data = skylight },
                BiomeId    = biomeId,
                X          = x,
                Z          = z
            };

            Debug.WriteLine("We should have loaded " + x + ", " + z);
            return(cc);
        }
Exemplo n.º 23
0
        public IChunkColumn GenerateColumn(IEnumerable <IBlockDefinition> blockDefinitions, IPlanet planet, Index2 index)
        {
            IBlockDefinition sandDefinition = blockDefinitions.FirstOrDefault(d => typeof(SandBlockDefinition) == d.GetType());
            ushort           sandIndex      = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), sandDefinition) + 1);

            IChunk[] result = new IChunk[planet.Size.Z];

            ChunkColumn column = new ChunkColumn(result, planet.Id, index);


            for (int layer = 0; layer < planet.Size.Z; layer++)
            {
                result[layer] = new Chunk(new Index3(index.X, index.Y, layer), planet.Id);
            }

            int part = (planet.Size.Z * Chunk.CHUNKSIZE_Z) / 4;

            for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
            {
                float heightY = (float)Math.Sin((float)(y * Math.PI) / 15f);
                for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
                {
                    float heightX = (float)Math.Sin((float)(x * Math.PI) / 18f);

                    float height = ((heightX + heightY + 2) / 4) * (2 * part);
                    for (int z = 0; z < planet.Size.Z * Chunk.CHUNKSIZE_Z; z++)
                    {
                        if (z < (int)(height + part))
                        {
                            int block = z % (Chunk.CHUNKSIZE_Z);
                            int layer = (int)(z / Chunk.CHUNKSIZE_Z);
                            result[layer].SetBlock(x, y, block, sandIndex);
                        }
                    }
                }
            }

            column.CalculateHeights();
            return(column);
        }
Exemplo n.º 24
0
 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);
     }
 }
Exemplo n.º 25
0
    private void NotifyNeighbours()
    {
        for (int x = -1; x <= 1; x++)
        {
            for (int z = -1; z <= 1; z++)
            {
                // Current chunk
                if (x == 0 && z == 0)
                {
                    continue;
                }

                ChunkColumn aNeighbourChunk = World.GetColumn(colCoord.GetRelativePos(x, z));

                // If we find a chunk without data, we don't generate
                if (aNeighbourChunk != null)
                {
                    aNeighbourChunk.IncrementNeighbourDataCount();
                }
            }
        }
    }
Exemplo n.º 26
0
        protected void GenerateVanillaLeaves(ChunkColumn chunk, Vector3 location, int radius, byte id, byte meta)
        {
            if (location.X > 16 || location.X < 0 || location.Z > 16 || location.Z < 0)
            {
                return;
            }
            var radiusOffset = radius;

            for (var yOffset = -radius; yOffset <= radius; yOffset = (yOffset + 1))
            {
                var y = location.Y + yOffset;
                if (y > 255)
                {
                    continue;
                }
                GenerateVanillaCircle(chunk, new Vector3(location.X, y, location.Z), radiusOffset, id, meta);
                if (yOffset != -radius && yOffset % 2 == 0)
                {
                    radiusOffset--;
                }
            }
        }
Exemplo n.º 27
0
        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(ArrayPool <byte> .Shared.Rent(2048));
            MiNET.Worlds.ChunkColumn.Fill <byte>(BlockLight.Data, 0);

            if (storeSkylight)
            {
                this.SkyLight = new NibbleArray(ArrayPool <byte> .Shared.Rent(2048));
                MiNET.Worlds.ChunkColumn.Fill <byte>(SkyLight.Data, 0xff);
            }
//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;
            }
        }
Exemplo n.º 28
0
    public static byte GetBlock(int x, int y, int z)
    {
        ColumnCoord colCoord = GetColumnCoord(x, z);

        try
        {
            ChunkColumn chunkCol = null;
            if (columns.TryGetValue(colCoord, out chunkCol))
            {
                if (chunkCol.hasMapData)
                {
                    return(chunkCol.GetBlock(x - colCoord.x * ChunkColumn.chunkSize, y, z - colCoord.z * ChunkColumn.chunkSize));
                }
            }
        }
        catch (Exception e)
        {
            Debug.Log("Chunk error!! " + e);
        }

        return(0);
    }
Exemplo n.º 29
0
        protected void GenerateVanillaCircle(ChunkColumn chunk, Vector3 location, int radius, byte id, byte meta,
                                             double corner = 0)
        {
            for (var I = -radius; I <= radius; I = (I + 1))
            {
                for (var j = -radius; j <= radius; j = (j + 1))
                {
                    var max = (int)Math.Sqrt((I * I) + (j * j));
                    if (max <= radius)
                    {
                        if (I.Equals(-radius) && j.Equals(-radius) || I.Equals(-radius) && j.Equals(radius) ||
                            I.Equals(radius) && j.Equals(-radius) || I.Equals(radius) && j.Equals(radius))
                        {
                            if (corner + radius * 0.2 < 0.4 || corner + radius * 0.2 > 0.7 || corner.Equals(0))
                            {
                                continue;
                            }
                        }
                        var x = location.X + I;
                        var z = location.Z + j;
                        if (x < 0 || z > 16)
                        {
                            continue;
                        }
                        if (z < 0 || z > 16)
                        {
                            continue;
                        }

                        if (chunk.GetBlock((int)x, (int)location.Y, (int)z) == 0)
                        {
                            chunk.SetBlock((int)x, (int)location.Y, (int)z, id);
                            chunk.SetMetadata((int)x, (int)location.Y, (int)z, meta);
                        }
                    }
                }
            }
        }
Exemplo n.º 30
0
        public override void Create(ChunkColumn chunk, int x, int y, int z)
        {
            var block = chunk.GetBlock(x, y - 1, z);

            if (block != 2 && block != 3)
            {
                return;
            }

            var location = new Vector3(x, y, z);

            if (!ValidLocation(location, LeafRadius))
            {
                return;
            }

            int height = Rnd.Next(4, MaxHeight);

            GenerateColumn(chunk, location, height, 17, 2);
            Vector3 leafLocation = location + new Vector3(0, height, 0);

            GenerateVanillaLeaves(chunk, leafLocation, LeafRadius, 18, 2);
        }
Exemplo n.º 31
0
 private void DecorateTrees(ChunkColumn chunk, BiomeBase biome)
 {
     for (var x = 0; x < 16; x++)
     {
         for (var z = 0; z < 16; z++)
         {
             for (var y = StandardWorldProvider.WaterLevel; y < 256; y++)
             {
                 if (StandardWorldProvider.GetRandomNumber(0, 13) == 5)
                 {
                     //The if is so we don't have 'f****d up' trees xD
                     if (x < 15 && x > 3 && z < 15 && z > 3)
                     {
                         if (chunk.GetBlock(x, y + 1, z) == biome.TopBlock.Id)
                         {
                             GenerateTree(chunk, x, y + 1, z, biome);
                         }
                     }
                 }
             }
         }
     }
 }
Exemplo n.º 32
0
        private void SetBiomeBlocks(ChunkColumn chunk, ChunkLandscape landscape)
        {
            int worldX = chunk.X * 16;
            int worldZ = chunk.Z * 16;

            var coords = new BlockCoordinates(worldX, 0, worldZ);

            for (int x = 0; x < 16; x++)
            {
                coords.X = worldX + x;
                for (int z = 0; z < 16; z++)
                {
                    coords.Z = worldZ + z;

                    var index = NoiseMap.GetIndex(x, z);
                    var river = landscape.River[index];
                    int depth = -1;

                    landscape.Biome[index].Replace(chunk, coords, x, z, depth, this, landscape.Noise, river, landscape.Biome);
                    chunk.biomeId[index] = (byte)landscape.Biome[index].Id;
                }
            }
        }
Exemplo n.º 33
0
 private void DecorateTrees(ChunkColumn chunk, BiomeBase biome)
 {
     for (var x = 0; x < 16; x++)
     {
         for (var z = 0; z < 16; z++)
         {
             for (var y = StandardWorldProvider.WaterLevel; y < 256; y++)
             {
                 if (StandardWorldProvider.GetRandomNumber(0, 13) == 5)
                 {
                     //The if is so we don't have 'f****d up' trees xD
                     if (x < 15 && x > 3 && z < 15 && z > 3)
                     {
                         if (chunk.GetBlock(x, y + 1, z) == biome.TopBlock.Id)
                         {
                             GenerateTree(chunk, x, y + 1, z, biome);
                         }
                     }
                 }
             }
         }
     }
 }
Exemplo n.º 34
0
 public override void Decorate(ChunkColumn chunk, BiomeBase biome)
 {
     for (var x = 0; x < 16; x++)
     {
         for (var z = 0; z < 16; z++)
         {
             //Check for temperature.
             for (var y = 0; y < StandardWorldProvider.WaterLevel; y++)
             {
                 //Lake generation
                 if (y < StandardWorldProvider.WaterLevel)
                 {
                     if (chunk.GetBlock(x, y, z) == 2 || chunk.GetBlock(x, y, z) == 3)                             //Grass or Dirt?
                     {
                         if (StandardWorldProvider.GetRandomNumber(1, 40) == 1 && y < StandardWorldProvider.WaterLevel - 4)
                         {
                             chunk.SetBlock(x, y, z, BlockFactory.GetBlockById(82));                                     //Clay
                         }
                         else
                         {
                             chunk.SetBlock(x, y, z, new BlockSand());                         //Sand
                             chunk.BiomeId[x * 16 + z] = 16;                                   //Beach
                         }
                     }
                     if (chunk.GetBlock(x, y + 1, z) == 0)
                     {
                         if (y < StandardWorldProvider.WaterLevel - 3)
                         {
                             chunk.SetBlock(x, y + 1, z, new BlockFlowingWater());            //Water
                             chunk.BiomeId[x * 16 + z] = 0;                                   //Ocean
                         }
                     }
                 }
             }
         }
     }
 }
Exemplo n.º 35
0
        public bool RecalcSkyLight(ChunkColumn chunk, World level)
        {
            if (chunk == null)
            {
                return(false);
            }

            for (int x = 0; x < 16; x++)
            {
                for (int z = 0; z < 16; z++)
                {
                    if (chunk.isAllAir && !IsOnChunkBorder(x, z))
                    {
                        continue;
                    }

                    int height = GetHigestSurrounding(x, z, chunk, level);
                    if (height == 0)
                    {
                        continue;
                    }

                    //var skyLight = chunk.GetSkyLight(x, height, z);
                    //if (skyLight == 15)
                    {
                        Block block = level.GetConvertedBlock(new BlockCoordinates(x + (chunk.x * 16), height, z + (chunk.z * 16)));
                        Calculate(level, block);
                    }
                    //else
                    //{
                    //	Log.Error($"Block with wrong light level. Expected 15 but was {skyLight}");
                    //}
                }
            }

            return(true);
        }
Exemplo n.º 36
0
        public IChunkColumn GenerateColumn(IEnumerable<IBlockDefinition> blockDefinitions, IPlanet planet, Index2 index)
        {
            IBlockDefinition sandDefinition = blockDefinitions.FirstOrDefault(d => typeof(SandBlockDefinition) == d.GetType());
            ushort sandIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), sandDefinition) + 1);

            IChunk[] result = new IChunk[planet.Size.Z];

            ChunkColumn column = new ChunkColumn(result, planet.Id, index);

            for (int layer = 0; layer < planet.Size.Z; layer++)
                result[layer] = new Chunk(new Index3(index.X, index.Y, layer), planet.Id);

            int part = (planet.Size.Z * Chunk.CHUNKSIZE_Z) / 4;

            for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
            {
                float heightY = (float)Math.Sin((float)(y * Math.PI) / 15f);
                for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
                {
                    float heightX = (float)Math.Sin((float)(x * Math.PI) / 18f);

                    float height = ((heightX + heightY + 2) / 4) * (2 * part);
                    for (int z = 0; z < planet.Size.Z * Chunk.CHUNKSIZE_Z; z++)
                    {
                        if (z < (int)(height + part))
                        {
                            int block = z % (Chunk.CHUNKSIZE_Z);
                            int layer = (int)(z / Chunk.CHUNKSIZE_Z);
                            result[layer].SetBlock(x, y, block, sandIndex);
                        }
                    }
                }
            }

            column.CalculateHeights();
            return column;
        }
Exemplo n.º 37
0
        public override void OnPacket(ChunkDataPacket chunkData)
        {
            byte[]      data    = chunkData.Data;
            var         chunkId = new Int2(chunkData.ChunkX, chunkData.ChunkZ);
            ChunkColumn chunkColumn;

            if (chunkData.Fullchunk)
            {
                chunkColumn = new ChunkColumn();
            }
            else
            {
                chunkColumn = world.Chunks[chunkId];
            }
            try
            {
                chunkColumn.Parse(ref data, chunkData.PrimaryBitMask);
            }
            catch (Exception e)
            {
                var guid = Guid.NewGuid();
                Console.WriteLine($"Error: Chunk column read error on chunk {guid}) with {e.StackTrace}");
                File.WriteAllText($"{guid}.txt", Convert.ToBase64String(chunkData.Data));
            }

            lock (chunkData)
            {
                if (chunkData.Fullchunk)
                {
                    if (world.Chunks.ContainsKey(chunkId))
                    {
                        world.Chunks.Remove(chunkId);
                    }
                    world.Chunks.Add(chunkId, chunkColumn);
                }
            }
        }
Exemplo n.º 38
0
        public ChunkColumn GenerateChunkColumn(ChunkCoordinates chunkCoordinates)
        {
            return(_cache.GetOrAdd(
                       chunkCoordinates, (cc) =>
            {
                ChunkColumn chunk = new ChunkColumn()
                {
                    X = chunkCoordinates.X,
                    Z = chunkCoordinates.Z
                };

                for (int x = 0; x < 16; x++)
                {
                    for (int z = 0; z < 16; z++)
                    {
                        int rx = (chunkCoordinates.X * 16) + x;
                        int rz = (chunkCoordinates.Z * 16) + z;

                        BlockState iblockstate = GetBlockStateFor(rx, rz);

                        if (iblockstate != null)
                        {
                            chunk.SetBlockState(x, 1, z, iblockstate);
                            //chunk.Height[((z << 4) + (x))] = 70;
                        }

                        // chunk.SetSkyLight(x, 70, z, 15);
                        //  chunk.SetSkyLight(x, 71, z, 15);
                        //  chunk.SetSkyLight(x, 69, z, 15);
                    }
                }

                //chunk.CalculateHeight();
                return chunk;
            }));
        }
Exemplo n.º 39
0
        private BlockColumnMeta GetColumnMeta(ChunkColumn chunk, int x, int z)
        {
            var pos = new BlockPosition((chunk.x << 4) + x, (chunk.z << 4) + z);

            var y = chunk.GetHeight(x, z);
            //var highestBlock = Level.GetBlock(pos.X, y, pos.Z);
            var highestBlock = GetHighestBlock(pos.X, pos.Z);

            if (highestBlock == null)
            {
                return(new BlockColumnMeta()
                {
                    Position = pos,
                    Height = 0,
                    BiomeId = 0,
                    BlockId = 0,
                    LightLevel = 0
                });
            }

            //_skyLightCalculations.Calculate(Level, highestBlock);

            //if (highestBlock.LightLevel > 0)
            //{
            //    BlockLightCalculations.Calculate(Level, highestBlock);
            //}

            return(new BlockColumnMeta()
            {
                Position = pos,
                Height = (byte)highestBlock.Coordinates.Y,
                BiomeId = highestBlock.BiomeId,
                BlockId = highestBlock.Id,
                LightLevel = chunk.GetSkylight(x, y, z)
            });
        }
Exemplo n.º 40
0
 public override void Decorate(ChunkColumn chunk, BiomeBase biome)
 {
     for (var x = 0; x < 16; x++)
     {
         for (var z = 0; z < 16; z++)
         {
             //Check for temperature.
             for (var y = 0; y < NetherWorldProvider.WaterLevel; y++)
             {
                 //Lake generation
                 if (y < NetherWorldProvider.WaterLevel)
                 {
                     if (chunk.GetBlock(x, y + 1, z) == 0)
                     {
                         if (y < NetherWorldProvider.WaterLevel - 3)
                         {
                             chunk.SetBlock(x, y + 1, z, new BlockStationaryLava());                                     //Water
                         }
                     }
                 }
             }
         }
     }
 }
Exemplo n.º 41
0
 public override void Decorate(ChunkColumn chunk, BiomeBase biome)
 {
     for (var x = 0; x < 16; x++)
     {
         for (var z = 0; z < 16; z++)
         {
             //Check for temperature.
             for (var y = 0; y < NetherWorldProvider.WaterLevel; y++)
             {
                 //Lake generation
                 if (y < NetherWorldProvider.WaterLevel)
                 {
                     if (chunk.GetBlock(x, y + 1, z) == 0)
                     {
                         if (y < NetherWorldProvider.WaterLevel - 3)
                         {
                             chunk.SetBlock(x, y + 1, z, new BlockStationaryLava()); //Water
                         }
                     }
                 }
             }
         }
     }
 }
Exemplo n.º 42
0
        public override void HandleMcpeLevelChunk(McpeLevelChunk message)
        {
            if (!Client._chunks.ContainsKey(new Tuple <int, int>(message.chunkX, message.chunkZ)))
            {
                //Log.Debug($"Chunk X={message.chunkX}, Z={message.chunkZ}, size={message.chunkData.Length}, Count={Client._chunks.Count}");

                try
                {
                    ChunkColumn chunk = ClientUtils.DecodeChunkColumn((int)message.subChunkCount, message.chunkData, _blockPallet, _internalStates);
                    if (chunk != null)
                    {
                        chunk.x = message.chunkX;
                        chunk.z = message.chunkZ;
                        chunk.RecalcHeight();
                        Client._chunks.TryAdd(new Tuple <int, int>(message.chunkX, message.chunkZ), chunk);
                        //Log.Debug($"Added parsed bedrock chunk X={chunk.x}, Z={chunk.z}");
                    }
                }
                catch (Exception e)
                {
                    Log.Error("Reading chunk", e);
                }
            }
        }
Exemplo n.º 43
0
        public override void HandleMcpeLevelChunk(McpeLevelChunk message)
        {
            // TODO doesn't work anymore I guess
            if (Client.IsEmulator)
            {
                return;
            }

            Client.Chunks.GetOrAdd(new ChunkCoordinates(message.chunkX, message.chunkZ), coordinates =>
            {
                Log.Debug($"Chunk X={message.chunkX}, Z={message.chunkZ}, size={message.chunkData.Length}, Count={Client.Chunks.Count}");

                ChunkColumn chunk = null;
                try
                {
                    chunk = ClientUtils.DecodeChunkColumn((int)message.subChunkCount, message.chunkData);
                    if (chunk != null)
                    {
                        chunk.X = coordinates.X;
                        chunk.Z = coordinates.Z;
                        chunk.RecalcHeight();
                        Log.DebugFormat("Chunk X={0}, Z={1}", chunk.X, chunk.Z);
                        foreach (KeyValuePair <BlockCoordinates, NbtCompound> blockEntity in chunk.BlockEntities)
                        {
                            Log.Debug($"Blockentity: {blockEntity.Value}");
                        }
                    }
                }
                catch (Exception e)
                {
                    Log.Error("Reading chunk", e);
                }

                return(chunk);
            });
        }
Exemplo n.º 44
0
 private void GenerateTree(ChunkColumn chunk, int x, int treebase, int z, WoodType woodType)
 {
     new OakTree().Create(chunk, x, treebase, z);
 }
Exemplo n.º 45
0
        private void GenerateTree(ChunkColumn chunk, int x, int treebase, int z)
        {
            int treeheight = GetRandomNumber(4, 5);

            chunk.SetBlock(x, treebase + treeheight + 2, z, 18); //Top leave

            chunk.SetBlock(x, treebase + treeheight + 1, z + 1, 18);
            chunk.SetBlock(x, treebase + treeheight + 1, z - 1, 18);
            chunk.SetBlock(x + 1, treebase + treeheight + 1, z, 18);
            chunk.SetBlock(x - 1, treebase + treeheight + 1, z, 18);

            chunk.SetBlock(x, treebase + treeheight, z + 1, 18);
            chunk.SetBlock(x, treebase + treeheight, z - 1, 18);
            chunk.SetBlock(x + 1, treebase + treeheight, z, 18);
            chunk.SetBlock(x - 1, treebase + treeheight, z, 18);

            chunk.SetBlock(x + 1, treebase + treeheight, z + 1, 18);
            chunk.SetBlock(x - 1, treebase + treeheight, z - 1, 18);
            chunk.SetBlock(x + 1, treebase + treeheight, z - 1, 18);
            chunk.SetBlock(x - 1, treebase + treeheight, z + 1, 18);

            for (int i = 0; i <= treeheight; i++)
            {
                chunk.SetBlock(x, treebase + i, z, 17);
            }
        }
Exemplo n.º 46
0
 private bool SaveChunk(ChunkColumn chunk)
 {
     File.WriteAllBytes(_folder + "/" + chunk.X + "." + chunk.Z + ".cfile", Globals.Compress(chunk.Export()));
     return(true);
 }
Exemplo n.º 47
0
        public ChunkColumn GetChunk(int X, int Z)
        {
            var width = 32;
            var depth = 32;

            var rx = X >> 5;
            var rz = Z >> 5;

            var filePath = Path.Combine(_basePath, string.Format(@"region\r.{0}.{1}.mca", rx, rz));

            if (!File.Exists(filePath))
            {
                return(_backEndGenerator.GenerateChunkColumn(new Vector2(X, Z)));
            }

            using (var regionFile = File.OpenRead(filePath))
            {
                var buffer = new byte[8192];

                regionFile.Read(buffer, 0, 8192);

                var xi = (X % width);
                if (xi < 0)
                {
                    xi += 32;
                }
                var zi = (Z % depth);
                if (zi < 0)
                {
                    zi += 32;
                }
                var tableOffset = (xi + zi * width) * 4;

                regionFile.Seek(tableOffset, SeekOrigin.Begin);

                var offsetBuffer = new byte[4];
                regionFile.Read(offsetBuffer, 0, 3);
                Array.Reverse(offsetBuffer);
                var offset = BitConverter.ToInt32(offsetBuffer, 0) << 4;

                var length = regionFile.ReadByte();

                //if (offset == 0 || length == 0) return _backEndGenerator.GenerateChunkColumn(new Vector2(X, Z));

                if (offset == 0 || length == 0)
                {
                    return(_backEndGenerator.GenerateChunkColumn(new Vector2(X, Z)));
                }

                regionFile.Seek(offset, SeekOrigin.Begin);
                var waste = new byte[4];
                regionFile.Read(waste, 0, 4);
                var compressionMode = regionFile.ReadByte();

                var nbt = new NbtFile();
                nbt.LoadFromStream(regionFile, NbtCompression.ZLib);

                var dataTag = nbt.RootTag["Level"];

                var sections = dataTag["Sections"] as NbtList;

                var chunk = new ChunkColumn
                {
                    X       = X,
                    Z       = Z,
                    BiomeId = dataTag["Biomes"].ByteArrayValue
                };

                for (var i = 0; i < chunk.BiomeId.Length; i++)
                {
                    if (chunk.BiomeId[i] > 22)
                    {
                        chunk.BiomeId[i] = 0;
                    }
                }
                if (chunk.BiomeId.Length > 256)
                {
                    throw new Exception();
                }

                // This will turn into a full chunk column
                foreach (var sectionTag in sections)
                {
                    var sy      = sectionTag["Y"].ByteValue * 16;
                    var blocks  = sectionTag["Blocks"].ByteArrayValue;
                    var data    = sectionTag["Data"].ByteArrayValue;
                    var addTag  = sectionTag["Add"];
                    var adddata = new byte[2048];
                    if (addTag != null)
                    {
                        adddata = addTag.ByteArrayValue;
                    }
                    var blockLight = sectionTag["BlockLight"].ByteArrayValue;
                    var skyLight   = sectionTag["SkyLight"].ByteArrayValue;

                    for (var x = 0; x < 16; x++)
                    {
                        for (var z = 0; z < 16; z++)
                        {
                            for (var y = 0; y < 16; y++)
                            {
                                var yi = sy + y - _waterOffsetY;
                                if (yi < 0 || yi >= 256)
                                {
                                    continue;
                                }

                                var anvilIndex = y * 16 * 16 + z * 16 + x;
                                var blockId    = blocks[anvilIndex] + (Nibble4(adddata, anvilIndex) << 8);


                                var b = BlockFactory.GetBlockById((ushort)blockId);
                                b.Metadata = Nibble4(data, anvilIndex);
                                chunk.SetBlock(x, yi, z, b);
                                chunk.SetBlocklight(x, yi, z, Nibble4(blockLight, anvilIndex));
                                chunk.SetSkylight(x, yi, z, Nibble4(skyLight, anvilIndex));
                            }
                        }
                    }
                }

                var entities     = dataTag["Entities"] as NbtList;
                var tileEntities = dataTag["TileEntities"] as NbtList;

                if (tileEntities != null)
                {
                    foreach (var nbtTag in tileEntities)
                    {
                        var    blockEntityTag = (NbtCompound)nbtTag;
                        string entityId       = blockEntityTag["id"].StringValue;
                        int    x = blockEntityTag["x"].IntValue;
                        int    y = blockEntityTag["y"].IntValue - _waterOffsetY;
                        int    z = blockEntityTag["z"].IntValue;
                        blockEntityTag["y"] = new NbtInt("y", y);

                        TileEntity blockEntity = TileEntityFactory.GetBlockEntityById(entityId);
                        if (blockEntity != null)
                        {
                            blockEntityTag.Name = string.Empty;
                            chunk.SetBlockEntity(new Vector3(x, y, z), blockEntityTag);
                        }
                    }
                }

                var tileTicks = dataTag["TileTicks"] as NbtList;

                chunk.IsDirty = false;
                return(chunk);
            }
        }
Exemplo n.º 48
0
        private void PopulateChunk(ChunkColumn chunk)
        {
            int trees = new Random().Next(0, 10);
            int[,] treeBasePositions = new int[trees, 2];

            for (int t = 0; t < trees; t++)
            {
                int x = new Random().Next(1, 16);
                int z = new Random().Next(1, 16);
                treeBasePositions[t, 0] = x;
                treeBasePositions[t, 1] = z;
            }

            var bottom = new SimplexOctaveGenerator(_seed.GetHashCode(), 8);
            var overhang = new SimplexOctaveGenerator(_seed.GetHashCode(), 8);
            overhang.SetScale(1/64.0);
            bottom.SetScale(1/128.0);

            double overhangsMagnitude = 16;
            double bottomsMagnitude = 32;

            for (int x = 0; x < 16; x++)
            {
                for (int z = 0; z < 16; z++)
                {
                    float ox = x + chunk.x*16;
                    float oz = z + chunk.z*16;

                    int bottomHeight = (int)((bottom.Noise(ox, oz, 0.5, 0.5)*bottomsMagnitude) + 64.0);
                    int maxHeight = (int)((overhang.Noise(ox, oz, 0.5, 0.5)*overhangsMagnitude) + bottomHeight + 32.0);

                    double threshold = 0.0;

                    maxHeight = Math.Max(1, maxHeight);

                    for (int y = 0; y < maxHeight && y < 128; y++)
                    {
                        if (y <= 1)
                        {
                            chunk.SetBlock(x, y, z, 7);
                            continue;
                        }

                        if (y > bottomHeight)
                        {
                            //part where we do the overhangs
                            double density = overhang.Noise(ox, y, oz, 0.5, 0.5);
                            if (density > threshold) chunk.SetBlock(x, y, z, (byte)Material.Stone);
                        }
                        else
                        {
                            chunk.SetBlock(x, y, z, (byte)Material.Stone);
                        }
                    }

                    //turn the tops into grass
                    chunk.SetBlock(x, bottomHeight, z, (byte)Material.Grass); //the top of the base hills
                    chunk.SetBlock(x, bottomHeight - 1, z, (byte)Material.Dirt);
                    chunk.SetBlock(x, bottomHeight - 2, z, (byte)Material.Dirt);

                    for (int y = bottomHeight + 1; y > bottomHeight && y < maxHeight && y < 127; y++)
                    {
                        //the overhang
                        byte thisblock = chunk.GetBlock(x, y, z);
                        byte blockabove = chunk.GetBlock(x, y + 1, z);

                        if (thisblock != (decimal)Material.Air && blockabove == (decimal)Material.Air)
                        {
                            if (chunk.GetBlock(x, y, z) == (byte)Material.Dirt || chunk.GetBlock(x, y, z) == (byte)Material.Air || chunk.GetBlock(x, y, z) == (byte)Material.Stone) chunk.SetBlock(x, y, z, (byte)Material.Grass);
                            if (chunk.GetBlock(x, y - 1, z) != (decimal)Material.Air)
                                chunk.SetBlock(x, y - 1, z, (byte)Material.Dirt);
                            if (chunk.GetBlock(x, y - 2, z) != (decimal)Material.Air)
                                chunk.SetBlock(x, y - 2, z, (byte)Material.Dirt);
                        }
                    }

                    for (int y = 0; y < WaterLevel; y++)
                    {
                        //Lake generation
                        if (y < WaterLevel)
                        {
                            if (chunk.GetBlock(x, y, z) == (decimal)Material.Grass || chunk.GetBlock(x, y, z) == (decimal)Material.Dirt) //Grass or Dirt?
                            {
                                if (GetRandomNumber(1, 40) == 1 && y < WaterLevel - 4)
                                    chunk.SetBlock(x, y, z, 82); //Clay
                                else
                                    chunk.SetBlock(x, y, z, 12); //Sand
                            }
                            if (chunk.GetBlock(x, y + 1, z) == (decimal)Material.Air)
                            {
                                if (y < WaterLevel - 3)
                                    chunk.SetBlock(x, y + 1, z, 8); //FlowingWater
                            }
                        }
                    }

                    for (int y = 0; y < 127; y++)
                    {
                        byte thisblock = chunk.GetBlock(x, y, z);
                        byte blockabove = chunk.GetBlock(x, y + 1, z);
                        if (thisblock == (decimal)Material.Grass && blockabove == (decimal)Material.Air && y > WaterLevel)
                        {
                            //Grass
                            if (GetRandomNumber(0, 5) == 1)
                            {
                                chunk.SetBlock(x, y + 1, z, 31);
                                chunk.SetMetadata(x, y + 1, z, 1);
                            }

                            //Flowers
                            if (GetRandomNumber(0, 65) == 1)
                            {
                                int meta = GetRandomNumber(0, 8);
                                chunk.SetBlock(x, y + 1, z, 38);
                                chunk.SetMetadata(x, y + 1, z, (byte)meta);
                            }

                            //Trees
                            for (int pos = 0; pos < trees; pos++)
                            {
                                if (treeBasePositions[pos, 0] < 14 && treeBasePositions[pos, 0] > 4 && treeBasePositions[pos, 1] < 14 &&
                                    treeBasePositions[pos, 1] > 4)
                                {
                                    if (chunk.GetBlock(treeBasePositions[pos, 0], y + 1, treeBasePositions[pos, 1]) == 2)
                                    {
                                        if (y >= bottomHeight)
                                            GenerateTree(chunk, treeBasePositions[pos, 0], y + 1, treeBasePositions[pos, 1], WoodType.Oak);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Exemplo n.º 49
0
 private bool SaveChunk(ChunkColumn chunk)
 {
     File.WriteAllBytes(_folder + "/" + chunk.X + "." + chunk.Z + ".cfile", Globals.Compress(chunk.Export()));
     return true;
 }
Exemplo n.º 50
0
        private void PopulateChunk(ChunkColumn chunk)
        {
            var bottom = new SimplexOctaveGenerator(ServerSettings.Seed.GetHashCode(), 8);
            var overhang = new SimplexOctaveGenerator(ServerSettings.Seed.GetHashCode(), 8);
            overhang.SetScale(1/OverhangScale);
            bottom.SetScale(1/Groundscale);

            for (var x = 0; x < 16; x++)
            {
                for (var z = 0; z < 16; z++)
                {
                    float ox = x + chunk.X*16;
                    float oz = z + chunk.Z*16;

                    var cBiome = _biomeManager.GetBiome((int) ox, (int) oz);
                    chunk.BiomeId[x*16 + z] = cBiome.MinecraftBiomeId;

                    var bottomHeight =
                        (int)
                            ((bottom.Noise(ox, oz, BottomsFrequency, BottomsAmplitude)*BottomsMagnitude) + BottomOffset + cBiome.BaseHeight);

                    var maxHeight =
                        (int)
                            ((overhang.Noise(ox, oz, OverhangFrequency, OverhangAmplitude)*OverhangsMagnitude) + bottomHeight +
                             OverhangOffset);
                    maxHeight = Math.Max(1, maxHeight);

                    for (var y = 0; y < maxHeight && y < 256; y++)
                    {
                        if (y == 0)
                        {
                            chunk.SetBlock(x, y, z, BlockFactory.GetBlockById(7));
                            continue;
                        }

                        if (y > bottomHeight)
                        {
                            //part where we do the overhangs
                            if (EnableOverhang)
                            {
                                var density = overhang.Noise(ox, y, oz, OverhangFrequency, OverhangAmplitude);
                                if (density > Threshold) chunk.SetBlock(x, y, z, BlockFactory.GetBlockById(1));
                            }
                        }
                        else
                        {
                            chunk.SetBlock(x, y, z, BlockFactory.GetBlockById(1));
                        }
                    }

                    //Turn the blocks ontop into the correct material
                    for (var y = 0; y < 256; y++)
                    {
                        if (chunk.GetBlock(x, y + 1, z) == 0 && chunk.GetBlock(x, y, z) == 1)
                        {
                            chunk.SetBlock(x, y, z, cBiome.TopBlock);

                            chunk.SetBlock(x, y - 1, z, cBiome.Filling);
                            chunk.SetBlock(x, y - 2, z, cBiome.Filling);
                        }
                    }

                    foreach (var decorator in cBiome.Decorators)
                    {
                        decorator.Decorate(chunk, cBiome, x, z);
                    }
                    new OreDecorator().Decorate(chunk, cBiome, x, z); //Ores :)
                    new BedrockDecorator().Decorate(chunk, cBiome, x, z); //Random bedrock :)
                }
            }

            new WaterDecorator().Decorate(chunk, new PlainsBiome()); //For now, ALWAYS use the water decorator on all chunks...
            _cavegen.GenerateCave(chunk);
            new LavaDecorator().Decorate(chunk, new PlainsBiome());
        }
Exemplo n.º 51
0
        public override ChunkColumn LoadChunk(int x, int z)
        {
            var u = Globals.Decompress(File.ReadAllBytes(_folder + "/" + x + "." + z + ".cfile"));
            var reader = new DataBuffer(u);

            var blockLength = reader.ReadInt();
            var block = reader.ReadUShortLocal(blockLength);

            var metalength = reader.ReadInt();
            var blockmeta = reader.ReadUShortLocal(metalength);

            var skyLength = reader.ReadInt();
            var skylight = reader.Read(skyLength);

            var lightLength = reader.ReadInt();
            var blocklight = reader.Read(lightLength);

            var biomeIdLength = reader.ReadInt();
            var biomeId = reader.Read(biomeIdLength);

            var cc = new ChunkColumn
            {
                Blocks = block,
                Metadata = blockmeta,
                Blocklight = {Data = blocklight},
                Skylight = {Data = skylight},
                BiomeId = biomeId,
                X = x,
                Z = z
            };
            Debug.WriteLine("We should have loaded " + x + ", " + z);
            return cc;
        }
Exemplo n.º 52
0
        public override ChunkColumn GenerateChunkColumn(Vector2 chunkCoordinates)
        {
            ChunkColumn c;
            if (ChunkCache.TryGetValue(new Tuple<int, int>(chunkCoordinates.X, chunkCoordinates.Z), out c)) return c;

            if (File.Exists((_folder + "/" + chunkCoordinates.X + "." + chunkCoordinates.Z + ".cfile")))
            {
                var cd = LoadChunk(chunkCoordinates.X, chunkCoordinates.Z);
                lock (ChunkCache)
                {
                    if (!ChunkCache.ContainsKey(new Tuple<int, int>(cd.X, cd.Z)))
                        ChunkCache.Add(new Tuple<int, int>(cd.X, cd.Z), cd);
                }
                return cd;
            }

            var chunk = new ChunkColumn {X = chunkCoordinates.X, Z = chunkCoordinates.Z};
            PopulateChunk(chunk);

            if (!ChunkCache.ContainsKey(new Tuple<int, int>(chunkCoordinates.X, chunkCoordinates.Z)))
                ChunkCache.Add(new Tuple<int, int>(chunkCoordinates.X, chunkCoordinates.Z), chunk);

            return chunk;
        }
Exemplo n.º 53
0
        private void PopulateChunk(ChunkColumn chunk)
        {
            int trees = new Random().Next(0, 10);
            int[,] treeBasePositions = new int[trees, 2];

            for (int t = 0; t < trees; t++)
            {
                int x = new Random().Next(1, 16);
                int z = new Random().Next(1, 16);
                treeBasePositions[t, 0] = x;
                treeBasePositions[t, 1] = z;
            }

            for (int x = 0; x < 16; x++)
            {
                for (int z = 0; z < 16; z++)
                {
                    int stoneHeight = (int) Math.Floor(stoneBaseHeight);
                    stoneHeight += GetNoise(chunk.x*16 + x, chunk.z*16 + z, stoneMountainFrequency, (int) Math.Floor(stoneMountainHeight));

                    if (stoneHeight < stoneMinHeight)
                        stoneHeight = (int) Math.Floor(stoneMinHeight);

                    stoneHeight += GetNoise(chunk.x*16 + x, chunk.z*16 + z, stoneBaseNoise, (int) Math.Floor(stoneBaseNoiseHeight));

                    int dirtHeight = stoneHeight + (int) Math.Floor(dirtBaseHeight);
                    dirtHeight += GetNoise(chunk.x*16 + x, chunk.z*16 + z, dirtNoise, (int) Math.Floor(dirtNoiseHeight));

                    for (int y = 0; y < 256; y++)
                    {
                        //float y2 = Get3DNoise(chunk.X*16, y, chunk.Z*16, stoneBaseNoise, (int) Math.Floor(stoneBaseNoiseHeight));
                        if (y <= stoneHeight)
                        {
                            chunk.SetBlock(x, y, z, 1);

                            //Diamond ore
                            if (GetRandomNumber(0, 2500) < 5)
                            {
                                chunk.SetBlock(x, y, z, 56);
                            }

                            //Coal Ore
                            if (GetRandomNumber(0, 1500) < 50)
                            {
                                chunk.SetBlock(x, y, z, 16);
                            }

                            //Iron Ore
                            if (GetRandomNumber(0, 2500) < 30)
                            {
                                chunk.SetBlock(x, y, z, 15);
                            }

                            //Gold Ore
                            if (GetRandomNumber(0, 2500) < 20)
                            {
                                chunk.SetBlock(x, y, z, 14);
                            }
                        }

                        if (y < waterLevel) //FlowingWater :)
                        {
                            if (chunk.GetBlock(x, y, z) == 2 || chunk.GetBlock(x, y, z) == 3) //Grass or Dirt?
                            {
                                if (GetRandomNumber(1, 40) == 5 && y < waterLevel - 4)
                                    chunk.SetBlock(x, y, z, 82); //Clay
                                else
                                    chunk.SetBlock(x, y, z, 12); //Sand
                            }
                            if (y < waterLevel - 3)
                                chunk.SetBlock(x, y + 1, z, 8); //FlowingWater
                        }

                        if (y <= dirtHeight && y >= stoneHeight)
                        {
                            chunk.SetBlock(x, y, z, 3); //Dirt
                            chunk.SetBlock(x, y + 1, z, 2); //Grass Block
                            if (y > waterLevel)
                            {
                                //Grass
                                if (GetRandomNumber(0, 5) == 2)
                                {
                                    chunk.SetBlock(x, y + 2, z, 31);
                                    chunk.SetMetadata(x, y + 2, z, 1);
                                }

                                //flower
                                if (GetRandomNumber(0, 65) == 8)
                                {
                                    int meta = GetRandomNumber(0, 8);
                                    chunk.SetBlock(x, y + 2, z, 38);
                                    chunk.SetMetadata(x, y + 2, z, (byte) meta);
                                }

                                for (int pos = 0; pos < trees; pos++)
                                {
                                    if (treeBasePositions[pos, 0] < 14 && treeBasePositions[pos, 0] > 4 && treeBasePositions[pos, 1] < 14 &&
                                        treeBasePositions[pos, 1] > 4)
                                    {
                                        if (y < waterLevel + 2)
                                            break;
                                        if (chunk.GetBlock(treeBasePositions[pos, 0], y + 1, treeBasePositions[pos, 1]) == 2)
                                        {
                                            if (y == dirtHeight)
                                                GenerateTree(chunk, treeBasePositions[pos, 0], y + 1, treeBasePositions[pos, 1]);
                                        }
                                    }
                                }
                            }
                        }

                        if (y == 0)
                        {
                            chunk.SetBlock(x, y, z, 7);
                        }
                    }
                }
            }
        }
Exemplo n.º 54
0
        public static void SaveChunk(ChunkColumn chunk, string basePath, int yoffset)
        {
            var coordinates = new ChunkCoordinates(chunk.X, chunk.Z);

            var width = 32;
            var depth = 32;

            var rx = coordinates.X >> 5;
            var rz = coordinates.Z >> 5;

            var filePath = Path.Combine(basePath, string.Format(@"region\r.{0}.{1}.mca", rx, rz));

            if (!File.Exists(filePath))
            {
                // Make sure directory exist
                Directory.CreateDirectory(Path.Combine(basePath, "region"));

                // Create empty region file
                using (var regionFile = File.Open(filePath, FileMode.CreateNew))
                {
                    var buffer = new byte[8192];
                    regionFile.Write(buffer, 0, buffer.Length);
                }

                return;
            }

            using (var regionFile = File.Open(filePath, FileMode.Open))
            {
                var buffer = new byte[8192];
                regionFile.Read(buffer, 0, buffer.Length);

                var xi = (coordinates.X % width);
                if (xi < 0)
                {
                    xi += 32;
                }
                var zi = (coordinates.Z % depth);
                if (zi < 0)
                {
                    zi += 32;
                }
                var tableOffset = (xi + zi * width) * 4;

                regionFile.Seek(tableOffset, SeekOrigin.Begin);

                var offsetBuffer = new byte[4];
                regionFile.Read(offsetBuffer, 0, 3);
                Array.Reverse(offsetBuffer);
                var offset = BitConverter.ToInt32(offsetBuffer, 0) << 4;

                var length = regionFile.ReadByte();

                if (offset == 0 || length == 0)
                {
                    regionFile.Seek(0, SeekOrigin.End);
                    offset = (int)regionFile.Position;

                    regionFile.Seek(tableOffset, SeekOrigin.Begin);

                    var bytes = BitConverter.GetBytes(offset >> 4);
                    Array.Reverse(bytes);
                    regionFile.Write(bytes, 0, 3);
                    regionFile.WriteByte(1);
                }

                regionFile.Seek(offset, SeekOrigin.Begin);
                var waste = new byte[4];
                regionFile.Write(waste, 0, 4);              // Lenght
                regionFile.WriteByte(0x02);                 // Compression mode

                // Write NBT
                var nbt    = CreateNbtFromChunkColumn(chunk, yoffset);
                var nbtBuf = nbt.SaveToBuffer(NbtCompression.ZLib);
                regionFile.Write(nbtBuf, 0, nbtBuf.Length);

                var lenght = nbtBuf.Length + 5;
                int reminder;
                Math.DivRem(lenght, 4096, out reminder);

                var padding = new byte[4096 - reminder];
                if (padding.Length > 0)
                {
                    regionFile.Write(padding, 0, padding.Length);
                }
            }
        }
Exemplo n.º 55
0
        private static NbtFile CreateNbtFromChunkColumn(ChunkColumn chunk, int yoffset)
        {
            var nbt = new NbtFile();

            var levelTag = new NbtCompound("Level");

            nbt.RootTag.Add(levelTag);

            levelTag.Add(new NbtInt("xPos", chunk.X));
            levelTag.Add(new NbtInt("zPos", chunk.Z));
            levelTag.Add(new NbtByteArray("Biomes", chunk.BiomeId));

            var sectionsTag = new NbtList("Sections");

            levelTag.Add(sectionsTag);

            for (var i = 0; i < 8; i++)
            {
                var sectionTag = new NbtCompound();
                sectionsTag.Add(sectionTag);
                sectionTag.Add(new NbtByte("Y", (byte)i));
                var sy = i * 16;

                var blocks     = new byte[4096];
                var data       = new byte[2048];
                var blockLight = new byte[2048];
                var skyLight   = new byte[2048];

                for (var x = 0; x < 16; x++)
                {
                    for (var z = 0; z < 16; z++)
                    {
                        for (var y = 0; y < 16; y++)
                        {
                            var yi = sy + y;
                            if (yi < 0 || yi >= 256)
                            {
                                continue;                                                  // ?
                            }
                            var anvilIndex = (y + yoffset) * 16 * 16 + z * 16 + x;
                            var blockId    = chunk.GetBlock(x, yi, z);

                            blocks[anvilIndex] = (byte)blockId;
                            SetNibble4(data, anvilIndex, chunk.GetMetadata(x, yi, z));
                            SetNibble4(blockLight, anvilIndex, chunk.GetBlocklight(x, yi, z));
                            SetNibble4(skyLight, anvilIndex, chunk.GetSkylight(x, yi, z));
                        }
                    }
                }

                sectionTag.Add(new NbtByteArray("Blocks", blocks));
                sectionTag.Add(new NbtByteArray("Data", data));
                sectionTag.Add(new NbtByteArray("BlockLight", blockLight));
                sectionTag.Add(new NbtByteArray("SkyLight", skyLight));
            }

            levelTag.Add(new NbtList("Entities", NbtTagType.Compound));
            levelTag.Add(new NbtList("TileEntities", NbtTagType.Compound));
            levelTag.Add(new NbtList("TileTicks", NbtTagType.Compound));

            return(nbt);
        }
Exemplo n.º 56
0
 public static void SaveChunkToAnvil(ChunkColumn chunk)
 {
     AnvilWorldProvider.SaveChunk(chunk, _basePath, 0);
 }
Exemplo n.º 57
0
    public ChunkMeshData[] GenerateChunkMeshData(ChunkColumn chunkCol, int yIndex)
    {
        ChunkMeshData[] chunkMeshData = new ChunkMeshData[2];

        // Initializing mesh data's
        for (int i = 0; i < chunkMeshData.Length; i++)
        {
            chunkMeshData[i] = new ChunkMeshData();
        }

        int yOffset = yIndex * ChunkColumn.chunkSize;

        Color32 currentColor;
        int     currentFaceCount;
        int     meshBufferIndex;

        for (int z = 0; z < ChunkColumn.chunkSize; z++)
        {
            for (int y = 0; y < ChunkColumn.chunkSize; y++)
            {
                for (int x = 0; x < ChunkColumn.chunkSize; x++)
                {
                    byte currentBlockID = chunkCol.GetBlock(x, y + yOffset, z);
                    if (currentBlockID == 0)
                    {
                        // Block is air, don't generate a mesh
                        continue;
                    }

                    // Block is not air, generate a mesh
                    currentFaceCount = 0;

                    // Assume block is solid
                    meshBufferIndex = 0;

                    // Compare ID to transparent blockID's
                    if (IsTransparentBlock(currentBlockID))
                    {
                        // It's a transparent block, use transparent mesh buffer
                        meshBufferIndex = 1;
                    }

                    // Block above
                    if (ShouldDrawFace(currentBlockID, chunkCol.GetBlock(x, y + yOffset + 1, z), meshBufferIndex))
                    {
                        chunkMeshData[meshBufferIndex].AddCubeFace(x, y, z, Faces.Top);
                        currentFaceCount++;
                    }

                    // North block
                    if (ShouldDrawFace(currentBlockID, chunkCol.GetBlock(x, y + yOffset, z + 1), meshBufferIndex))
                    {
                        chunkMeshData[meshBufferIndex].AddCubeFace(x, y, z, Faces.North);
                        currentFaceCount++;
                    }

                    // East block
                    if (ShouldDrawFace(currentBlockID, chunkCol.GetBlock(x + 1, y + yOffset, z), meshBufferIndex))
                    {
                        chunkMeshData[meshBufferIndex].AddCubeFace(x, y, z, Faces.East);
                        currentFaceCount++;
                    }

                    // South block
                    if (ShouldDrawFace(currentBlockID, chunkCol.GetBlock(x, y + yOffset, z - 1), meshBufferIndex))
                    {
                        chunkMeshData[meshBufferIndex].AddCubeFace(x, y, z, Faces.South);
                        currentFaceCount++;
                    }

                    // West block
                    if (ShouldDrawFace(currentBlockID, chunkCol.GetBlock(x - 1, y + yOffset, z), meshBufferIndex))
                    {
                        chunkMeshData[meshBufferIndex].AddCubeFace(x, y, z, Faces.West);
                        currentFaceCount++;
                    }

                    // Bottom block
                    if (ShouldDrawFace(currentBlockID, chunkCol.GetBlock(x, y + yOffset - 1, z), meshBufferIndex))
                    {
                        chunkMeshData[meshBufferIndex].AddCubeFace(x, y, z, Faces.Bottom);
                        currentFaceCount++;
                    }

                    if (currentFaceCount > 0)
                    {
                        // Block is visible (has faces)
                        currentColor = EvaluateColor(chunkCol.colCoord.x * ChunkColumn.chunkSize + x,
                                                     yIndex * ChunkColumn.chunkSize + y,
                                                     chunkCol.colCoord.z * ChunkColumn.chunkSize + z,
                                                     currentBlockID);

                        chunkMeshData[meshBufferIndex].AddColor(currentColor, currentFaceCount);
                    }
                }
            }
        }


        return(chunkMeshData);
    }
Exemplo n.º 58
0
        private static NbtFile CreateNbtFromChunkColumn(ChunkColumn chunk)
        {
            var nbt = new NbtFile();

            NbtCompound levelTag = new NbtCompound("Level");

            nbt.RootTag.Add(levelTag);

            levelTag.Add(new NbtInt("xPos", chunk.x));
            levelTag.Add(new NbtInt("zPos", chunk.z));
            levelTag.Add(new NbtByteArray("Biomes", chunk.biomeId));

            NbtList sectionsTag = new NbtList("Sections");

            levelTag.Add(sectionsTag);

            for (int i = 0; i < 8; i++)
            {
                NbtCompound sectionTag = new NbtCompound();
                sectionsTag.Add(sectionTag);
                sectionTag.Add(new NbtByte("Y", (byte)i));
                int sy = i * 16;

                byte[] blocks     = new byte[4096];
                byte[] data       = new byte[2048];
                byte[] blockLight = new byte[2048];
                byte[] skyLight   = new byte[2048];

                for (int x = 0; x < 16; x++)
                {
                    for (int z = 0; z < 16; z++)
                    {
                        for (int y = 0; y < 16; y++)
                        {
                            int yi = sy + y;
                            if (yi < 0 || yi >= 256)
                            {
                                continue;                                                  // ?
                            }
                            int  anvilIndex = (y + _waterOffsetY) * 16 * 16 + z * 16 + x;
                            byte blockId    = chunk.GetBlock(x, yi, z);

                            // PE to Anvil friendly converstion
                            if (blockId == 5)
                            {
                                blockId = 125;
                            }
                            else if (blockId == 158)
                            {
                                blockId = 126;
                            }
                            else if (blockId == 50)
                            {
                                blockId = 75;
                            }
                            else if (blockId == 50)
                            {
                                blockId = 76;
                            }
                            else if (blockId == 89)
                            {
                                blockId = 123;
                            }
                            else if (blockId == 89)
                            {
                                blockId = 124;
                            }
                            else if (blockId == 73)
                            {
                                blockId = 152;
                            }

                            blocks[anvilIndex] = blockId;
                            SetNibble4(data, anvilIndex, chunk.GetMetadata(x, yi, z));
                            SetNibble4(blockLight, anvilIndex, chunk.GetBlocklight(x, yi, z));
                            SetNibble4(skyLight, anvilIndex, chunk.GetSkylight(x, yi, z));
                        }
                    }
                }

                sectionTag.Add(new NbtByteArray("Blocks", blocks));
                sectionTag.Add(new NbtByteArray("Data", data));
                sectionTag.Add(new NbtByteArray("BlockLight", blockLight));
                sectionTag.Add(new NbtByteArray("SkyLight", skyLight));
            }

            levelTag.Add(new NbtList("Entities", NbtTagType.Compound));
            levelTag.Add(new NbtList("TileEntities", NbtTagType.Compound));
            levelTag.Add(new NbtList("TileTicks", NbtTagType.Compound));

            return(nbt);
        }
Exemplo n.º 59
0
        private void PopulateChunk(ChunkColumn chunk)
        {
            var bottom   = new SimplexOctaveGenerator(ServerSettings.Seed.GetHashCode(), 8);
            var overhang = new SimplexOctaveGenerator(ServerSettings.Seed.GetHashCode(), 8);

            overhang.SetScale(1 / OverhangScale);
            bottom.SetScale(1 / Groundscale);


            for (var x = 0; x < 16; x++)
            {
                for (var z = 0; z < 16; z++)
                {
                    float ox = x + chunk.X * 16;
                    float oz = z + chunk.Z * 16;

                    var cBiome = _biomeManager.GetBiome((int)ox, (int)oz);
                    chunk.BiomeId[x * 16 + z] = cBiome.MinecraftBiomeId;

                    var bottomHeight =
                        (int)
                        ((bottom.Noise(ox, oz, BottomsFrequency, BottomsAmplitude) * BottomsMagnitude) + BottomOffset + cBiome.BaseHeight);

                    var maxHeight =
                        (int)
                        ((overhang.Noise(ox, oz, OverhangFrequency, OverhangAmplitude) * OverhangsMagnitude) + bottomHeight +
                         OverhangOffset);
                    maxHeight = Math.Max(1, maxHeight);

                    for (var y = 0; y < maxHeight && y < 256; y++)
                    {
                        if (y == 0)
                        {
                            chunk.SetBlock(x, y, z, BlockFactory.GetBlockById(7));
                            continue;
                        }

                        if (y > bottomHeight)
                        {
                            //part where we do the overhangs
                            if (EnableOverhang)
                            {
                                var density = overhang.Noise(ox, y, oz, OverhangFrequency, OverhangAmplitude);
                                if (density > Threshold)
                                {
                                    chunk.SetBlock(x, y, z, BlockFactory.GetBlockById(1));
                                }
                            }
                        }
                        else
                        {
                            chunk.SetBlock(x, y, z, BlockFactory.GetBlockById(1));
                        }
                    }

                    //Turn the blocks ontop into the correct material
                    for (var y = 0; y < 256; y++)
                    {
                        if (chunk.GetBlock(x, y + 1, z) == 0 && chunk.GetBlock(x, y, z) == 1)
                        {
                            chunk.SetBlock(x, y, z, cBiome.TopBlock);

                            chunk.SetBlock(x, y - 1, z, cBiome.Filling);
                            chunk.SetBlock(x, y - 2, z, cBiome.Filling);
                        }
                    }

                    foreach (var decorator in cBiome.Decorators)
                    {
                        decorator.Decorate(chunk, cBiome, x, z);
                    }
                    new OreDecorator().Decorate(chunk, cBiome, x, z);                     //Ores :)
                    new BedrockDecorator().Decorate(chunk, cBiome, x, z);                 //Random bedrock :)
                }
            }

            new WaterDecorator().Decorate(chunk, new PlainsBiome());             //For now, ALWAYS use the water decorator on all chunks...
            _cavegen.GenerateCave(chunk);
            new LavaDecorator().Decorate(chunk, new PlainsBiome());
        }
Exemplo n.º 60
0
 public override void Decorate(ChunkColumn chunk, BiomeBase biome)
 {
 }