Exemplo n.º 1
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.º 2
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;
            }

            var height = Rnd.Next(7, 8);

            GenerateColumn(chunk, location, height, 17, 1);
            for (var Y = 1; Y < height; Y++)
            {
                if (Y % 2 == 0)
                {
                    GenerateVanillaCircle(chunk, location + new Vector3(0, Y + 1, 0), _leafRadius - 1, 18, 1);
                    continue;
                }
                GenerateVanillaCircle(chunk, location + new Vector3(0, Y + 1, 0), _leafRadius, 18, 1);
            }

            GenerateTopper(chunk, location + new Vector3(0, height, 0), 0x1);
        }
Exemplo n.º 3
0
 protected void GenerateVanillaCircle(ChunkColumn chunk, Vector3 location, int radius, Block block, 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 (chunk.GetBlock((int)X, (int)location.Y, (int)Z).Equals(0))
                 {
                     chunk.SetBlock((int)X, (int)location.Y, (int)Z, block);
                 }
             }
         }
     }
 }
Exemplo n.º 4
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.º 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
 public override void Decorate(ChunkColumn chunk, BiomeBase biome)
 {
     for (var x = 0; x < 16; x++)
     {
         for (var z = 0; z < 16; z++)
         {
             //var blockbiome = chunk.BiomeId[x*16 + z];
             //if (BiomeManager.GetBiomeById(blockbiome).Temperature < 2.0f) //If the temperature is below 2.0F create lakes.
             //{
             //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.º 7
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.º 8
0
 protected void GenerateVanillaCircle(ChunkColumn chunk, Vector3 location, int radius, Block block, 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 (chunk.GetBlock((int)x, (int)location.Y, (int)z).Equals(0))
                 {
                     chunk.SetBlock((int)x, (int)location.Y, (int)z, block);
                 }
             }
         }
     }
 }
Exemplo n.º 9
0
        public Block GetConvertedBlock(BlockCoordinates blockCoordinates)
        {
            ChunkColumn chunk = GetChunk(blockCoordinates);

            if (chunk == null)
            {
                return new Air()
                       {
                           Coordinates = blockCoordinates, SkyLight = 15
                       }
            }
            ;

            byte bid        = chunk.GetBlock(blockCoordinates.X & 0x0f, blockCoordinates.Y & 0xff, blockCoordinates.Z & 0x0f);
            byte metadata   = chunk.GetMetadata(blockCoordinates.X & 0x0f, blockCoordinates.Y & 0xff, blockCoordinates.Z & 0x0f);
            byte blockLight = chunk.GetBlocklight(blockCoordinates.X & 0x0f, blockCoordinates.Y & 0xff, blockCoordinates.Z & 0x0f);
            byte skyLight   = chunk.GetSkylight(blockCoordinates.X & 0x0f, blockCoordinates.Y & 0xff, blockCoordinates.Z & 0x0f);



            Block block = PCPEConvert.ConvertBlock(bid, metadata);

            block.Coordinates = blockCoordinates;
            block.BlockLight  = blockLight;
            block.SkyLight    = skyLight;

            return(block);
        }
Exemplo n.º 10
0
        protected void GenerateLeaves(ChunkColumn world, int x, int y, int z, float size, float width, byte leafBlockId, byte leafMeta, byte woodId, byte woodMeta)
        {
            float dist;
            int   i, j, k, s = (int)(size - 1f), w = (int)((size - 1f) * width);

            for (i = -w; i <= w; i++)
            {
                for (j = -s; j <= s; j++)
                {
                    for (k = -w; k <= w; k++)
                    {
                        dist = Math.Abs((float)i / width) + (float)Math.Abs(j) + Math.Abs((float)k / width);
                        if (dist <= size - 0.5f || (dist <= size && Rnd.NextDouble() < 0.5))
                        {
                            if (dist < 0.6f)
                            {
                                world.SetBlock(x + i, y + j, z + k, woodId);
                                world.SetMetadata(x + i, y + j, z + k, woodMeta);
                            }
                            if (world.GetBlock(x + i, y + j, z + k) == 0)
                            {
                                world.SetBlock(x + i, y + j, z + k, leafBlockId);
                                world.SetMetadata(x + i, y + j, z + k, leafMeta);
                            }
                        }
                    }
                }
            }
        }
Exemplo n.º 11
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;
            }

            BaseSize = 3 + Rnd.Next(2);
            if (Roots > 0f)
            {
                for (int k = 0; k < 3; k++)
                {
                    GenerateBranch(chunk, x, y + Roots, z, (120 * k) - 40 + Rnd.Next(80), 1.6f + (float)Rnd.NextDouble() * 0.1f, Roots * 1.7f, 1f, 17, 3);
                }
            }

            for (int i = y + Roots; i < y + BaseSize; i++)
            {
                chunk.SetBlock(x, i, z, 17);
                chunk.SetMetadata(x, i, z, 3);
            }

            float horDir, verDir;
            int   eX, eY, eZ;

            for (int j = 0; j < Branches; j++)
            {
                horDir = (120 * j) - 60 + Rnd.Next(120);
                verDir = VerticalStart + (float)Rnd.NextDouble() * VerticalRand;

                eX = x + (int)(Math.Cos(horDir * Math.PI / 180D) * verDir * BranchLength);
                eZ = z + (int)(Math.Sin(horDir * Math.PI / 180D) * verDir * BranchLength);
                eY = y + BaseSize + (int)((1f - verDir) * BranchLength);

                if (CanGenerateBranch(x, y + BaseSize, z, horDir, verDir, BranchLength, 1f, 4f, 1.5f) && CanGenerateLeaves(eX, eY, eZ, 4f, 1.5f))
                {
                    GenerateBranch(chunk, x, y + BaseSize, z, horDir, verDir, BranchLength, 1f, 17, 3);

                    for (int m = 0; m < 1; m++)
                    {
                        GenerateLeaves(chunk, eX, eY, eZ, 4f, 1.5f, 18, 3, 17, 3);
                    }
                }
            }

            /*var location = new Vector3(x, y, z);
             * if (!ValidLocation(location, 2)) return;
             *
             * int height = Math.Max(4, Rnd.Next(MaxHeight));
             *
             * GenerateColumn(chunk, location, height, 17, 3);
             * Vector3 leafLocation = location + new Vector3(0, height, 0);
             * GenerateVanillaLeaves(chunk, leafLocation, 2, 18, 3);
             */
            //	base.Create(chunk, x, y, z);
        }
Exemplo n.º 12
0
        public override void Create(ChunkColumn chunk, int x, int y, int z)
        {
            if (x < 6 || x > 10 || z < 6 || z > 10)
            {
                return;
            }

            var block = chunk.GetBlock(x, y - 1, z);

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

            BaseSize = 9 + Rnd.Next(5);

            if (Roots > 0f)
            {
                for (int k = 0; k < 3; k++)
                {
                    GenerateBranch(chunk, x, y + Roots, z, (120 * k) - 40 + Rnd.Next(80), 1.6f + (float)Rnd.NextDouble() * 0.1f, Roots * 1.7f, 1f,
                                   17, 3);              //17 = Wood, 3 = Jungle Type
                }
            }

            for (int i = y + Roots; i < y + BaseSize; i++)
            {
                chunk.SetBlock(x, i, z, 17);
                chunk.SetMetadata(x, i, z, 3);
            }

            float horDir, verDir;
            int   eX, eY, eZ;

            for (int j = 0; j < Branches; j++)
            {
                horDir = (120 * j) - 60 + Rnd.Next(120);
                verDir = VerticalStart + (float)Rnd.NextDouble() * VerticalRand;

                eX = x + (int)(Math.Cos(horDir * Math.PI / 180D) * verDir * BranchLength);
                eZ = z + (int)(Math.Sin(horDir * Math.PI / 180D) * verDir * BranchLength);
                eY = y + BaseSize + (int)((1f - verDir) * BranchLength);

                if (CanGenerateBranch(x, y + BaseSize, z, horDir, verDir, BranchLength, 1f, 4f, 1.5f) && CanGenerateLeaves(eX, eY, eZ, 4f, 1.5f))
                {
                    GenerateBranch(chunk, x, y + BaseSize, z, horDir, verDir, BranchLength, 1f,
                                   17, 3);              //17 = Wood, 3 = Jungle Type

                    for (int m = 0; m < 1; m++)
                    {
                        GenerateLeaves(chunk, eX, eY, eZ, 4f, 1.5f,
                                       18, 3,                  //18 = Leaves, 3 = Jungle Type
                                       17, 3);                 //17 = Wood, 3 = Jungle Type
                    }
                }
            }
        }
Exemplo n.º 13
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.º 14
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.º 15
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.º 16
0
 private static byte GetHeightFix(ChunkColumn chunk, int x, int z)
 {
     for (byte y = 255; y > 0; y--)
     {
         if (chunk.GetBlock(x, y, z) > 0)
         {
             return(y);
         }
     }
     return(1);
 }
Exemplo n.º 17
0
 private byte GetHeightFix(ChunkColumn column, int x, int z)
 {
     for (byte y = 255; y > 0; y--)
     {
         if (column.GetBlock(x, y, z) > 0)
         {
             return(y);
         }
     }
     return(0);
 }
Exemplo n.º 18
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;
            }

            base.Create(chunk, x, y, z);
        }
Exemplo n.º 19
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.º 20
0
        private void DecorateChunk(ChunkColumn chunk, float[] heightMap, float[] thresholdMap, Biome[] biomes,
                                   ChunkDecorator[] decorators)
        {
            for (int x = 0; x < Width; x++)
            {
                for (int z = 0; z < Depth; z++)
                {
                    var height = chunk.height[(x << 4) + z];
                    var biome  = biomes[(x << 4) + z];

                    for (int y = 0; y < Height; y++)
                    {
                        bool isSurface = false;
                        if (y <= height)
                        {
                            if (y < 255 && chunk.GetBlock(x, y, z) == 1 && chunk.GetBlock(x, y + 1, z) == 0)
                            {
                                isSurface = true;
                            }

                            if (isSurface)
                            {
                                if (y >= WaterLevel)
                                {
                                    chunk.SetBlock(x, y, z, biome.SurfaceBlock);
                                    chunk.SetMetadata(x, y, z, biome.SurfaceMetadata);

                                    chunk.SetBlock(x, y - 1, z, biome.SoilBlock);
                                    chunk.SetMetadata(x, y - 1, z, biome.SoilMetadata);
                                }
                            }
                        }

                        for (int i = 0; i < decorators.Length; i++)
                        {
                            decorators[i].Decorate(chunk, biome, thresholdMap, x, y, z, isSurface, y < height - 1);
                        }
                    }
                }
            }
        }
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
        private bool CheckSafe(ChunkColumn chunk, int x, int y, int z)
        {
            if (chunk.GetBlock(x - 1, y, z) != 0)
            {
                return(false);
            }
            if (chunk.GetBlock(x + 1, y, z) != 0)
            {
                return(false);
            }
            if (chunk.GetBlock(x, y, z - 1) != 0)
            {
                return(false);
            }
            if (chunk.GetBlock(x, y, z + 1) != 0)
            {
                return(false);
            }

            return(true);
        }
Exemplo n.º 23
0
        public bool IsAir(BlockCoordinates blockCoordinates)
        {
            ChunkColumn chunk = GetChunk(blockCoordinates);

            if (chunk == null)
            {
                return(true);
            }

            byte bid = chunk.GetBlock(blockCoordinates.X & 0x0f, blockCoordinates.Y & 0xff, blockCoordinates.Z & 0x0f);

            return(bid == 0);
        }
Exemplo n.º 24
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.º 25
0
        public bool IsTransparent(BlockCoordinates blockCoordinates)
        {
            ChunkColumn chunk = GetChunk(blockCoordinates);

            if (chunk == null)
            {
                return(true);
            }

            byte bid = chunk.GetBlock(blockCoordinates.X & 0x0f, blockCoordinates.Y & 0xff, blockCoordinates.Z & 0x0f);

            return(PCPEConvert.UnconvertedTransparentBlocks.Contains(bid));
        }
Exemplo n.º 26
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.º 27
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.º 28
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, 13) == 5)
             {
                 if (chunk.GetBlock(x, y + 1, z) == biome.TopBlock.Id)
                 {
                     GenerateTree(chunk, x, y + 1, z, biome);
                 }
             }
         }
     }
 }
Exemplo n.º 29
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.º 30
0
        public override void Decorate(ChunkColumn column, Biome biome, float[] thresholdMap, int x, int y, int z, bool surface, bool isBelowMaxHeight)
        {
            if (y > OverworldGenerator.WaterLevel && y > 32)
            {
                return;
            }

            //var density = thresholdMap[x + 16*(y + 256*z)];

            /*var bid = column.GetBlock(x, y, z);
             * if (bid == 0 /* || density < 0) //If this block is supposed to be air.
             * {
             *      if (surface && biome.Temperature <= 0f)
             *      {
             *              column.SetBlock(x, y, z, 79);
             *      }
             *      else
             *      {
             *              column.SetBlock(x, y, z, 8);
             *      }
             * }
             * else if (surface)
             * {
             *      column.SetBlock(x,y,z, 12);
             * }*/

            //	if (y >= SurvivalWorldProvider.WaterLevel) return;

            var block = column.GetBlock(x, y, z);

            if (surface)
            {
                column.SetBlock(x, y, z, 12);                 //Sand
            }
            else if (y <= OverworldGenerator.WaterLevel && block == 0)
            {
                if (biome.Temperature <= 0f && y == OverworldGenerator.WaterLevel - 1)
                {
                    column.SetBlock(x, y, z, 79);                     //Ice
                }
                else
                {
                    column.SetBlock(x, y, z, 8);                     //Water
                }
            }
        }
Exemplo n.º 31
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.º 32
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.º 33
0
        public override void Create(ChunkColumn chunk, int x, int y, int z)
        {
            if (chunk.GetBlock(x, y - 1, z) != 12)
            {
                return;                                                //Not sand, do not generate.
            }
            var growth = Rnd.Next(0x1, 0x15);

            for (int modifiedY = y; modifiedY < y + _height; modifiedY++)
            {
                if (!CheckSafe(chunk, x, modifiedY, z))
                {
                    break;
                }

                chunk.SetBlock(x, modifiedY, z, 81);                 //Cactus block
                chunk.SetMetadata(x, modifiedY, z, (byte)growth);
            }
        }
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++)
         {
             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.º 35
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.º 36
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, 15) == 5)
         {
             if (chunk.GetBlock(x, y, z) == biome.TopBlock.Id)
             {
                 //var meta = ExperimentalV2Generator.GetRandomNumber(0, 8);
                 chunk.SetBlock(x, y + 1, z, new Block(175)
                 {
                     Metadata = 0
                 });
                 chunk.SetBlock(x, y + 2, z, new Block(175)
                 {
                     Metadata = 1
                 });
             }
         }
     }
 }
Exemplo n.º 37
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.º 38
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.º 39
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.º 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
        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.º 42
0
 protected void GenerateVanillaCircle(ChunkColumn chunk, Vector3 location, int radius, Block block, 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 (chunk.GetBlock((int) x, (int) location.Y, (int) z).Equals(0))
                 {
                     chunk.SetBlock((int) x, (int) location.Y, (int) z, block);
                 }
             }
         }
     }
 }
Exemplo n.º 43
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.º 44
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.º 45
0
        private void PopulateChunk(ChunkColumn chunk)
        {
            var bottom = new SimplexOctaveGenerator(ServerSettings.Seed.GetHashCode(), 8);
            var top = new SimplexOctaveGenerator(ServerSettings.Seed.GetHashCode(), 8);
            bottom.SetScale(1/Groundscale);
            top.SetScale(1/Topscale);

            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 bottomHeight =
                        (int) ((bottom.Noise(ox, oz, BottomsFrequency, BottomsAmplitude)*BottomsMagnitude) + BottomOffset);
                    var topHeight = (int) ((top.Noise(ox, oz, TopFrequency, TopAmplitude)*TopMagnitude) + TopOffset);

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

                        if (y < bottomHeight)
                        {
                            chunk.SetBlock(x, y, z, new BlockNetherrack());
                        }

                        if (y < topHeight)
                        {
                            chunk.SetBlock(x, 256 - y, z, new BlockNetherrack());
                            if (GetRandomNumber(1, 50) == 25)
                            {
                                chunk.SetBlock(x, 256 - (y + 1), z, new Block(89));
                            }
                        }
                    }

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

                            chunk.SetBlock(x, y - 1, z, new BlockNetherrack());
                            chunk.SetBlock(x, y - 2, z, new BlockNetherrack());
                        }
                    }
                }
            }

            new NetherLavaDecorator().Decorate(chunk, new PlainsBiome());
        }
Exemplo n.º 46
0
        private static NbtFile CreateNbtFromChunkColumn(ChunkColumn chunk, int yoffset)
        {
            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 + yoffset)*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));
            }

            // TODO: Save entities
            NbtList entitiesTag = new NbtList("Entities", NbtTagType.Compound);
            levelTag.Add(entitiesTag);

            NbtList blockEntitiesTag = new NbtList("TileEntities", NbtTagType.Compound);
            levelTag.Add(blockEntitiesTag);
            foreach (NbtCompound blockEntityNbt in chunk.BlockEntities.Values)
            {
                NbtCompound nbtClone = (NbtCompound) blockEntityNbt.Clone();
                nbtClone.Name = null;
                blockEntitiesTag.Add(nbtClone);
            }

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

            return nbt;
        }
Exemplo n.º 47
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.º 48
0
        public ChunkColumn GenerateChunkColumn(ChunkCoordinates chunkCoordinates)
        {
            lock (_chunkCache)
            {
                ChunkColumn cachedChunk;
                if (_chunkCache.TryGetValue(chunkCoordinates, out cachedChunk))
                {
                    return cachedChunk;
                }

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

                int h = PopulateChunk(chunk);

                chunk.SetBlock(0, h + 1, 0, 7);
                chunk.SetBlock(1, h + 1, 0, 41);
                chunk.SetBlock(2, h + 1, 0, 41);
                chunk.SetBlock(3, h + 1, 0, 41);
                chunk.SetBlock(3, h + 1, 0, 41);

                //chunk.SetBlock(6, h + 1, 6, 57);

                chunk.SetBlock(6, h, 9, 63);
                chunk.SetMetadata(6, h, 9, 12);
                var blockEntity = GetBlockEntity((chunkCoordinates.X*16) + 6, h, (chunkCoordinates.Z*16) + 9);
                chunk.SetBlockEntity(blockEntity.Coordinates, blockEntity.GetCompound());

                if (chunkCoordinates.X == 1 && chunkCoordinates.Z == 1)
                {
                    for (int x = 0; x < 10; x++)
                    {
                        for (int z = 0; z < 10; z++)
                        {
                            for (int y = h - 2; y < h; y++)
                            {
                                chunk.SetBlock(x, y, z, 8);
                            }
                        }
                    }
                }

                if (chunkCoordinates.X == 3 && chunkCoordinates.Z == 1)
                {
                    for (int x = 0; x < 10; x++)
                    {
                        for (int z = 0; z < 10; z++)
                        {
                            for (int y = h - 1; y < h; y++)
                            {
                                chunk.SetBlock(x, y, z, 10);
                            }
                        }
                    }
                }

                for (int x = 0; x < 16; x++)
                {
                    for (int z = 0; z < 16; z++)
                    {
                        for (int y = 127; y != 0; y--)
                        {
                            if (chunk.GetBlock(x, y, z) == 0x00)
                            {
                                chunk.SetSkylight(x, y, z, 0xff);
                            }
                            else
                            {
                                chunk.SetSkylight(x, y, z, 0x00);
                            }
                        }
                    }
                }

                _chunkCache[chunkCoordinates] = chunk;

                return chunk;
            }
        }
Exemplo n.º 49
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;
        }