private ChunkCacheBitmap ProcessChunk(ChunkColumn chunk)
        {
            var items = new List <ChunkCacheBlockItem>();

            byte[] bitmapMemory = new byte[16 * 16 * 4];

            for (int z = 0; z < 16; z++)
            {
                for (int x = 0; x < 16; x++)
                {
                    //var y = chunk.GetHeight(x, z);
                    var y       = GetHeightFix(chunk, x, z);
                    var biomeId = chunk.GetBiome(x, z);

                    var i = (int)((16 * z * 4) + (4 * x));

                    var biomeColor = GetBiomeColor(biomeId);

                    //var c = SharpDX.Color.FromRgba(((255 << 24) & 0xFF) | ((y << 16) & 0xFF) | ((y << 8) & 0xFF) | (y & 0xFF));
                    var c = new SharpDX.Color(biomeColor.R, biomeColor.G, biomeColor.B, (byte)255);
                    //c = SharpDX.Color.Scale(c, ((y / 256f) * 0.6f) + 0.4f);

                    c *= (y / 255f);
                    //c = SharpDX.Color.Clamp(c, _minColor, _maxColor);

                    bitmapMemory[i]     = c.B;
                    bitmapMemory[i + 1] = c.G;
                    bitmapMemory[i + 2] = c.R;
                    bitmapMemory[i + 3] = 255;
                }
            }

            return(new ChunkCacheBitmap
            {
                X = chunk.x,
                Z = chunk.z,
                BitmapMemory = bitmapMemory
            });


            var v = items.GroupBy(ks => ks.BiomeId).Select(vs => new ChunkCacheItem()
            {
                BiomeId = vs.Key,
                Items   = vs.ToArray().ToArray(),
                X       = chunk.x,
                Z       = chunk.z
            });
        }
        private static Task GenerateHeightmap(ChunkColumn[] columns, int chunks, bool chunkHeight)
        {
            return(Task.Run(() =>
            {
                Bitmap bitmap = new Bitmap(chunks * 16, chunks * 16);
                for (int x = 0; x < chunks; x++)
                {
                    for (int z = 0; z < chunks; z++)
                    {
                        ChunkColumn column = columns[(x * chunks) + z];
                        for (int cx = 0; cx < 16; cx++)
                        {
                            var rx = (x * 16) + cx;
                            for (int cz = 0; cz < 16; cz++)
                            {
                                var rz = (z * 16) + cz;

                                //  var height = column.GetHeight(cx, cz);
                                //  var temp = (int) Math.Max((byte)0,
                                //     Math.Min((byte)255, height));

                                var height = 0;

                                if (!chunkHeight)
                                {
                                    height = column.GetHeight(cx, cz);
                                }
                                else
                                {
                                    var biome = BiomeUtils.GetBiomeById(column.GetBiome(cx, cz));
                                    height = (int)Math.Max(0,
                                                           Math.Min(255, (255 * MathUtils.ConvertRange(-2f, 2f, 0f, 1f, ((biome.MinHeight + biome.MaxHeight) / 2f)))));
                                }

                                bitmap.SetPixel(rx, rz, Color.FromArgb(height, height, height));
                            }
                        }
                    }
                }

                bitmap.Save(chunkHeight ? "chunkHeight.png" : "height.png", ImageFormat.Png);
            }));
        }
Exemple #3
0
        public ChunkDataPacket(Client client, ChunkColumn column) : base(client)
        {
            PacketId = 0x22;
            MCSerializer serializer = new MCSerializer();


            serializer.WriteInt(column.X);
            serializer.WriteInt(column.Z);
            serializer.WriteBool(true);
            serializer.WriteVarInt(column.SectionMask);
            NbtWriter  heightmapWriter  = new NbtWriter(serializer.Stream, "root");
            BitStorage heightmapStorage = new BitStorage(9, 256);

            for (int y = 0; y < 256; y++)
            {
                for (int z = 0; z < 16; z++)
                {
                    for (int x = 0; x < 16; x++)
                    {
                        if (column.GetBlock(x, y, z).StateId != 0)
                        {
                            heightmapStorage.Set(ChunkColumn.GetHeightmapIdx(x, z), y);
                        }
                    }
                }
            }

            heightmapWriter.WriteLongArray("MOTION_BLOCKING", heightmapStorage.Data);
            heightmapWriter.EndCompound();
            heightmapWriter.Finish();

            for (int y = 0; y < 256; y += 4)
            {
                for (int z = 0; z < 16; z += 4)
                {
                    for (int x = 0; x < 16; x += 4)
                    {
                        serializer.WriteInt((int)column.GetBiome(x, y, z));
                    }
                }
            }

            MCSerializer dataSerializer = new MCSerializer();
            int          primaryBitMask = column.SectionMask;

            for (int y = 0; y < 16; y++)
            {
                if ((primaryBitMask & 0b1) == 1)
                {
                    column.Sections[y].Write(dataSerializer);
                }

                primaryBitMask >>= 1;
            }

            byte[] encodedChunkData = dataSerializer.GetBytes();
            serializer.WriteVarInt(encodedChunkData.Length);
            serializer.WriteBytes(encodedChunkData);

            // TODO: Block Entities
            serializer.WriteVarInt(0);
            Data = serializer.GetBytes();
        }