Exemple #1
0
 public ChunkLightUpdate(Chunk chunk, int x, int y, int z)
 {
     _X = x;
     _Y = y;
     _Z = z;
     _Chunk = chunk;
 }
Exemple #2
0
 public ChunkLightUpdate(Chunk chunk)
 {
     _X = -1;
     _Y = -1;
     _Z = -1;
     _Chunk = chunk;
 }
Exemple #3
0
        public Chunk ProvideChunk(int x, int z, WorldManager world)
        {
            Chunk chunk = new Chunk(world, UniversalCoords.FromChunk(x, z));
            InitGen();

            byte[] data = new byte[32768];
            #if PROFILE
            Stopwatch watch = new Stopwatch();
            watch.Start();
            #endif
            GenerateTerrain(chunk, data, x, z);
            GenerateFlora(chunk, data, x, z);
            chunk.SetAllBlocks(data);

            chunk.RecalculateHeight();
            chunk.LightToRecalculate = true;
            #if PROFILE
            watch.Stop();

            _World.Logger.Log(Logger.LogLevel.Info, "Chunk {0} {1}, {2}", false, x, z, watch.ElapsedMilliseconds);
            #endif

            _World.AddChunk(chunk);
            chunk.MarkToSave();

            return chunk;
        }
Exemple #4
0
 internal void SendChunk(Chunk chunk)
 {
     MapChunkPacket packet = new MapChunkPacket
     {
         Chunk = chunk
     };
     PacketHandler.SendPacket(packet);
 }
Exemple #5
0
        public static MapChunkData GetMapChunkData(Chunk chunk, bool firstInit)
        {
            MapChunkData chunkData = new MapChunkData();

            ushort mask = 1;

            Queue<Section> sectionsToBeSent = new Queue<Section>();
            for (int i = 0; i < 16; ++i)
            {
                Section currentSection = chunk.Sections[i];
                if (currentSection != null && (firstInit || (chunk.SectionsToBeUpdated & 1) << i != 0))
                {
                    sectionsToBeSent.Enqueue(currentSection);
                }
            }

            int dataDim = sectionsToBeSent.Count * (Section.BYTESIZE + Section.SIZE);

            if (firstInit)
                dataDim += 256;

            chunkData.Data = new byte[dataDim];

            int halfSize = sectionsToBeSent.Count * Section.HALFSIZE;
            int offsetData = sectionsToBeSent.Count * Section.SIZE;
            int offsetLight = offsetData + halfSize;
            int offsetSkyLight = offsetLight + halfSize;

            int sectionIndex = 0;
            while(sectionsToBeSent.Count > 0)
            {
                Section section = sectionsToBeSent.Dequeue();

                Buffer.BlockCopy(section.Types, 0, chunkData.Data, sectionIndex * Section.SIZE, Section.SIZE);
                Buffer.BlockCopy(section.Data.Data, 0, chunkData.Data, offsetData + (sectionIndex * Section.HALFSIZE),
                                    Section.HALFSIZE);

                Buffer.BlockCopy(chunk.Light.Data, section.SectionId * Section.HALFSIZE, chunkData.Data, offsetLight + (sectionIndex * Section.HALFSIZE),
                                    Section.HALFSIZE);
                Buffer.BlockCopy(chunk.SkyLight.Data, section.SectionId * Section.HALFSIZE, chunkData.Data, offsetSkyLight + (sectionIndex * Section.HALFSIZE),
                                    Section.HALFSIZE);


                chunkData.PrimaryBitMask |= mask << section.SectionId;
                ++sectionIndex;
                // TODO: we leave add array and biome array to 0 (ocean), we need to change the chunk generator accordingly
            }

            return chunkData;
        }
Exemple #6
0
        public static void LoadContainersFromDisk(Chunk chunk)
        {
            string containerPath = Path.Combine(chunk.World.Folder, ChraftConfig.ContainersFolder, "x" + chunk.Coords.ChunkX + "z" + chunk.Coords.ChunkZ);
            if (!Directory.Exists(containerPath))
                return;
            
            string[] files = Directory.GetFiles(containerPath);

            PersistentContainer container;
            UniversalCoords containerCoords;
            BlockData.Blocks containerType;
            string id;
            int x, y, z, startPos, endPos;
            string coordStr;
            foreach (var file in files)
            {
                coordStr = file.Substring(file.LastIndexOf(Path.DirectorySeparatorChar) + 1);
                startPos = coordStr.IndexOf("x") + 1;
                endPos = coordStr.IndexOf("y");
                if (!Int32.TryParse(coordStr.Substring(startPos, endPos - startPos), out x))
                    continue;
                startPos = endPos + 1;
                endPos = coordStr.IndexOf("z");
                if (!Int32.TryParse(coordStr.Substring(startPos, endPos - startPos), out y))
                    continue;
                startPos = endPos + 1;
                endPos = coordStr.IndexOf(".");
                if (!Int32.TryParse(coordStr.Substring(startPos, endPos - startPos), out z))
                    continue;
                containerCoords = UniversalCoords.FromWorld(x, y, z);
                containerType = chunk.GetType(containerCoords);
                switch (containerType)
                {
                    case BlockData.Blocks.Dispenser:
                        container = new DispenserContainer();
                        container.Initialize(chunk.World, containerCoords);
                        break;
                    case BlockData.Blocks.Furnace:
                    case BlockData.Blocks.Burning_Furnace:
                        container = new FurnaceContainer();
                        container.Initialize(chunk.World, containerCoords);
                        (container as FurnaceContainer).StartBurning();
                        break;
                    default:
                        continue;
                }
                chunk.Containers.TryAdd(containerCoords.BlockPackedCoords, container);
            }
        }
Exemple #7
0
        public override void Read(PacketReader stream)
        {
            int posX = stream.ReadInt();
            short posY = stream.ReadShort();
            int posZ = stream.ReadInt();
            byte sizeX = (byte)(stream.ReadByte() + 1);
            byte sizeY = (byte)(stream.ReadByte() + 1);
            byte sizeZ = (byte)(stream.ReadByte() + 1);

            int o = sizeX * sizeY * sizeZ;
            Chunk = new Chunk(null, UniversalCoords.FromWorld(posX, posY, posZ));

            int len = stream.ReadInt();
            stream.ReadBytes(len);
        }
        public override void Read(PacketReader stream)
        {
            int posX = stream.ReadInt();
            short posY = stream.ReadShort();
            int posZ = stream.ReadInt();
            byte sizeX = (byte)(stream.ReadByte() + 1);
            byte sizeY = (byte)(stream.ReadByte() + 1);
            byte sizeZ = (byte)(stream.ReadByte() + 1);

            int o = sizeX * sizeY * sizeZ;
            Chunk = new Chunk(null, posX << 4, posZ << 4);

            int len = stream.ReadInt();
            byte[] data = new byte[o * 5 / 2];
            byte[] comp = stream.ReadBytes(len);
        }
Exemple #9
0
        public override void Read(BigEndianStream stream)
        {
            int posX = stream.ReadInt();
            short posY = stream.ReadShort();
            int posZ = stream.ReadInt();
            byte sizeX = (byte)(stream.ReadByte() + 1);
            byte sizeY = (byte)(stream.ReadByte() + 1);
            byte sizeZ = (byte)(stream.ReadByte() + 1);

            int o = sizeX * sizeY * sizeZ;
            Chunk = new Chunk(null, posX, posZ);

            int len = stream.ReadInt();
            byte[] comp = new byte[len];
            byte[] data = new byte[o * 5 / 2];
            len = stream.Read(comp, 0, len);
        }
Exemple #10
0
        public void ProvideChunk(int x, int z, Chunk chunk, bool recalculate)
        {
            InitGen();

            byte[] data = new byte[32768];
            Stopwatch watch = new Stopwatch();
            watch.Start();
            GenerateTerrain(chunk, data, x, z);
            GenerateFlora(chunk, data, x, z);
            chunk.SetAllBlocks(data);
            watch.Stop();
            if(recalculate)
                chunk.Recalculate();

            Console.WriteLine("Chunk {0} {1}, {2}", x, z, watch.ElapsedMilliseconds);

            //chunk.Save();
            _World.AddChunk(chunk);
            chunk.MarkToSave();
        }
Exemple #11
0
        public Chunk ProvideChunk(int x, int z, Chunk chunk, bool recalculate)
        {
            InitGen();

            byte[] data = new byte[32768];
            Stopwatch watch = new Stopwatch();
            watch.Start();
            GenerateTerrain(chunk, data, x, z);
            GenerateFlora(chunk, data, x, z);
            chunk.SetAllBlocks(data);
            if(recalculate)
                chunk.Recalculate();
            watch.Stop();

            Console.WriteLine("Chunk {0} {1}", x, z);

            //chunk.Save();
            _World.AddChunk(chunk);

            return chunk;
        }
Exemple #12
0
        private void GenerateOuterLayer(int x, int y, int z, int firstBlockHeight, BIOME_TYPE type, Chunk c, byte[] data)
        {
            double heightPercentage = (firstBlockHeight - y) / 128.0;
            short currentIndex = (short)(x << 11 | z << 7 | y);

            switch (type)
            {
                case BIOME_TYPE.PLAINS:
                case BIOME_TYPE.MOUNTAINS:
                    // Beach
                    if (y >= 60 && y <= 66)
                    {
                        data[currentIndex] = (byte)BlockData.Blocks.Sand;
                        break;
                    }

                    if (heightPercentage == 0.0 && y > 66)
                    {
                        // Grass on top
                        data[currentIndex] = (byte)BlockData.Blocks.Grass;
                    }
                    else if (heightPercentage > 0.2)
                    {
                        // Stone
                        data[currentIndex] = (byte)BlockData.Blocks.Stone;
                    }
                    else
                    {
                        // Dirt
                        data[currentIndex] = (byte)BlockData.Blocks.Dirt;
                    }

                    GenerateRiver(c, x, y, z, heightPercentage, type, data);
                    break;

                case BIOME_TYPE.SNOW:

                    if (heightPercentage == 0.0 && y > 65)
                    {
                        // Snow on top
                        data[currentIndex] = (byte)BlockData.Blocks.Snow;
                        // Grass under the snow
                        data[x << 11 | z << 7 | y - 1] = (byte)BlockData.Blocks.Grass;
                    }

                    else if (heightPercentage > 0.2)
                    {
                        // Stone
                        data[currentIndex] = (byte)BlockData.Blocks.Stone;
                    }
                    else if (data[x << 11 | z << 7 | (y + 1)] == (byte)BlockData.Blocks.Air)
                    {
                        // Grass under the snow
                        data[currentIndex] = (byte)BlockData.Blocks.Grass;
                        data[x << 11 | z << 7 | (y + 1)] = (byte)BlockData.Blocks.Snow;
                    }
                    else
                    {
                        // Dirt
                        data[currentIndex] = (byte)BlockData.Blocks.Dirt;
                    }

                    GenerateRiver(c, x, y, z, heightPercentage, type, data);
                    break;

                case BIOME_TYPE.DESERT:
                    /*if (heightPercentage > 0.6 && y < 75)
                    {
                        // Stone
                        data[x << 11 | z << 7 | y] = (byte)BlockData.Blocks.Stone;
                    }
                    else*/
                    if (y < 80)
                    {
                        data[currentIndex] = (byte)BlockData.Blocks.Sand;
                    }

                    break;

            }
        }
Exemple #13
0
        private void GenerateTerrain(Chunk c, byte[] data, int x, int z)
        {
            double[, ,] density = new double[17, 129, 17];

            // Build the density map with lower resolution, 4*4*16 instead of 16*16*128
            for (int bx = 0; bx <= 16; bx += 4)
            {
                int worldX = bx + (x * 16);
                for (int bz = 0; bz <= 16; bz += 4)
                {
                    BIOME_TYPE type = CalcBiomeType(x, z);
                    int worldZ = bz + (z * 16);
                    for (int by = 0; by <= 128; by += 8)
                    {
                        density[bx, by, bz] = CalcDensity(worldX, by, worldZ, type);
                    }
                }
            }

            triLerpDensityMap(density);

            for (int bx = 0; bx < 16; bx++)
            {
                int worldX = bx + (x * 16);
                for (int bz = 0; bz < 16; bz++)
                {
                    int worldZ = bz + (z * 16);
                    int firstBlockHeight = -1;

                    BIOME_TYPE type = CalcBiomeType(worldX, worldZ);
                    for (int by = 127; by >= 0; --by)
                    {
                        int index = bx << 11 | bz << 7 | by;
                        if (by == 0) // First bedrock Layer
                        {
                            data[index] = (byte)BlockData.Blocks.Bedrock;
                            continue;
                        }
                        else if (by > 0 && by < 5 && _FastRandom.randomDouble() > 0.3) // Randomly put blocks of the remaining 4 layers of bedrock
                        {
                            data[index] = (byte)BlockData.Blocks.Bedrock;
                            continue;
                        }
                        else if (by <= 55)
                            data[index] = (byte)BlockData.Blocks.Stone;
                        else
                        {
                            if (by > 55 && by < 64)
                            {
                                data[index] = (byte)BlockData.Blocks.Still_Water;
                                if (by == 63 && type == BIOME_TYPE.SNOW)
                                {
                                    data[index] = (byte)BlockData.Blocks.Ice;
                                }
                            }

                            double dens = density[bx, by, bz];

                            if (dens >= 0.009 && dens <= 0.02)
                            {
                                // Some block was set...
                                if (firstBlockHeight == -1)
                                    firstBlockHeight = by;

                                GenerateOuterLayer(bx, by, bz, firstBlockHeight, type, c, data);
                            }
                            else if (dens > 0.02)
                            {
                                // Some block was set...
                                if (firstBlockHeight == -1)
                                    firstBlockHeight = by;

                                if (CalcCaveDensity(worldX, by, worldZ) > -0.6)
                                    GenerateInnerLayer(bx, by, bz, type, data);
                            }
                            else
                                firstBlockHeight = -1;
                        }

                        if (data[index] == (byte)BlockData.Blocks.Stone)
                            GenerateResource(bx, by, bz, data);
                    }
                }
            }
        }
Exemple #14
0
        protected void GenerateRiver(Chunk c, int x, int y, int z, double heightPercentage, BIOME_TYPE type, byte[] data)
        {
            // Rivers under water? Nope.
            if (y <= 63)
                return;

            double lakeIntens = CalcLakeIntensity(x + c.Coords.ChunkX * 16, z + c.Coords.ChunkZ * 16);
            short currentIndex = (short)(x << 11 | z << 7 | y);

            if (lakeIntens < 0.2 )
            {
                if (heightPercentage < 0.001)
                    data[currentIndex] = (byte)BlockData.Blocks.Air;
                else if (heightPercentage < 0.02)
                {
                    if (type == BIOME_TYPE.SNOW)
                    {
                        // To be sure that there's no snow above us
                        data[x << 11 | z << 7 | y + 1] = (byte)BlockData.Blocks.Air;
                        data[currentIndex] = (byte)BlockData.Blocks.Ice;
                    }
                    else
                    {
                        data[currentIndex] = (byte)BlockData.Blocks.Still_Water;
                    }
                }
            }
        }
Exemple #15
0
        private void GenerateFlora(Chunk c, byte[] data, int x, int z)
        {
            BIOME_TYPE biome = CalcBiomeType(x, z);
            for (int bx = 0; bx < 16; ++bx)
            {
                int worldX = bx + x * 16;
                for (int bz = 0; bz < 16; ++bz)
                {
                    int worldZ = bz + z * 16;
                    for (int by = 64; by < 128; ++by)
                    {
                        int worldY = by;
                        int index = bx << 11 | bz << 7 | by + 1;

                        if (data[bx << 11 | bz << 7 | by] == (byte)BlockData.Blocks.Grass && data[index] == (byte)BlockData.Blocks.Air)
                        {
                            double grassDens = CalcGrassDensity(worldX, worldZ);
                            if (grassDens > 0.0)
                            {
                                // Generate high grass.
                                double rand = _FastRandom.standNormalDistrDouble();
                                if (rand > -0.2 && rand < 0.2)
                                {
                                    data[index] = (byte)BlockData.Blocks.TallGrass;
                                    c.Data.setNibble(bx, by + 1, bz, 1);
                                }

                                //Generate flowers.
                                if (_FastRandom.standNormalDistrDouble() < -2)
                                {
                                    if (_FastRandom.randomBoolean())
                                        data[index] = (byte)BlockData.Blocks.Rose;
                                    else
                                        data[index] = (byte)BlockData.Blocks.Yellow_Flower;
                                }
                            }

                            if (by < 110 && bx % 4 == 0 && bz % 4 == 0)
                            {
                                double forestDens = CalcForestDensity(worldX, worldZ);

                                if (forestDens > 0.005)
                                {
                                    int randX = bx + _FastRandom.randomInt() % 12 + 4;
                                    int randZ = bz + _FastRandom.randomInt() % 12 + 4;

                                    if (randX < 3)
                                        randX = 3;
                                    else if (randX > 12)
                                        randX = 12;

                                    if (randZ < 3)
                                        randZ = 3;
                                    else if (randZ > 15)
                                        randZ = 12;

                                    if (data[randX << 11 | randZ << 7 | by] == (byte)BlockData.Blocks.Grass)
                                    {
                                        GenerateTree(c, randX, by, randZ, data);
                                    }
                                    else if (biome == BIOME_TYPE.DESERT && data[randX << 11 | randZ << 7 | by] == (byte)BlockData.Blocks.Sand)
                                    {
                                        GenerateCactus(randX, by, randZ, data);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #16
0
 public Section(Chunk parent)
 {
     _Parent = parent;
     _NonAirBlocks = 0;
 }
Exemple #17
0
        internal void SendSignTexts(Chunk chunk)
        {
            foreach (var signKVP in chunk.SignsText)
            {
                int blockX = signKVP.Key >> 11;
                int blockY = (signKVP.Key & 0xFF) % 128;
                int blockZ = (signKVP.Key >> 7) & 0xF;

                UniversalCoords coords = UniversalCoords.FromBlock(chunk.Coords.ChunkX, chunk.Coords.ChunkZ, blockX, blockY, blockZ);

                string[] lines = new string[4];

                int length = signKVP.Value.Length;

                for (int i = 0; i < 4; ++i, length -= 15)
                {
                    int currentLength = length;
                    if (currentLength > 15)
                        currentLength = 15;

                    if (length > 0)
                        lines[i] = signKVP.Value.Substring(i * 15, currentLength);
                    else
                        lines[i] = "";
                }

                SendPacket(new UpdateSignPacket { X = coords.WorldX, Y = coords.WorldY, Z = coords.WorldZ, Lines = lines });
            }
        }
Exemple #18
0
 public static bool IsDoubleChest(Chunk chunk, UniversalCoords coords)
 {
     if (chunk == null)
         return false;
     return chunk.IsNSEWTo(coords,(byte) BlockData.Blocks.Chest);
 }
Exemple #19
0
 public Section(Chunk parent, int sectionId)
 {
     _Parent = parent;
     _NonAirBlocks = 0;
     SectionId = sectionId;
 }
Exemple #20
0
        public static MapChunkData GetMapChunkData(Chunk chunk)
        {
            MapChunkData chunkData = new MapChunkData();

            ushort mask = 1;
            int sectionIndex = 0;

            int sectionsSent = 0;

            for (int i = 0; i < 16; ++i )
            {
                Section currentSection = chunk.Sections[i];
                if (currentSection != null)
                    ++sectionsSent;
            }

            int dataDim = (sectionsSent * Section.BYTESIZE) + 256; // (Number of sections * (Section dimension + Add array) + Biome array

            chunkData.Data = new byte[dataDim];

            int halfSize = sectionsSent * Section.HALFSIZE;
            int offsetData = sectionsSent * Section.SIZE;
            int offsetLight = offsetData + halfSize;
            int offsetSkyLight = offsetLight + halfSize;

            for (int i = 0; i < 16; ++i)
            {
                Section currentSection = chunk.Sections[i];

                if (currentSection != null)
                {
                    Buffer.BlockCopy(currentSection.Types, 0, chunkData.Data, sectionIndex * Section.SIZE, Section.SIZE);
                    Buffer.BlockCopy(currentSection.Data.Data, 0, chunkData.Data, offsetData + (sectionIndex * Section.HALFSIZE),
                                        Section.HALFSIZE);

                    Buffer.BlockCopy(chunk.Light.Data, i * Section.HALFSIZE, chunkData.Data, offsetLight + (sectionIndex * Section.HALFSIZE),
                                        Section.HALFSIZE);
                    Buffer.BlockCopy(chunk.SkyLight.Data, i * Section.HALFSIZE, chunkData.Data, offsetSkyLight + (sectionIndex * Section.HALFSIZE),
                                        Section.HALFSIZE);

                    chunkData.PrimaryBitMask |= mask << i;
                    ++sectionIndex;
                }

                // TODO: we leave add array and biome array to 0 (ocean), we need to change the chunk generator accordingly
            }

            return chunkData;
        }
Exemple #21
0
 public static void UnloadContainers(Chunk chunk)
 {
     foreach (var container in chunk.Containers)
     {
         container.Value.Save();
         if (container.Value is FurnaceContainer)
             (container.Value as FurnaceContainer).Unload();
     }
     chunk.Containers.Clear();
 }
Exemple #22
0
 internal bool Remove(Chunk chunk)
 {
     chunk.Deleted = true;
     return Remove(chunk.Coords);
 }
Exemple #23
0
 private Chunk LoadChunk(int x, int z)
 {
     lock (ChunkGenLock)
     {
         Chunk chunk = new Chunk(this, x << 4, z << 4);
         if (chunk.Load())
             Chunks.Add(chunk);
         else
             chunk = Generator.ProvideChunk(x, z);
         return chunk;
     }
 }
Exemple #24
0
        private Chunk LoadChunk(UniversalCoords coords, bool create, bool recalculate)
        {
            lock (ChunkGenLock)
            {
                // We should check again since two threads can enter here, one after the other, with the same chunk to load
                Chunk chunk;
                if ((chunk = Chunks[coords]) != null)
                    return chunk;

                chunk = new Chunk(this, coords);
                if (chunk.Load())
                    AddChunk(chunk);
                else if (create)
                    _generator.ProvideChunk(coords.ChunkX, coords.ChunkZ, chunk, recalculate);
                else
                    chunk = null;

                if(chunk != null)
                    chunk.InitGrowableCache();

                return chunk;
            }
        }
Exemple #25
0
        private void GenerateTree(Chunk c, int x, int y, int z, byte[] data)
        {
            // Trees should only be placed in direct sunlight
            if (!CanSeeTheSky(x, y + 1, z, data))
                return;

            double r2 = _FastRandom.standNormalDistrDouble();
            /*if (r2 > -2 && r2 < -1)
            {*/
            // Standard tree

            for (int by = y + 4; by < y + 6; by++)
                for (int bx = x - 2; bx <= x + 2; bx++)
                    for (int bz = z - 2; bz <= z + 2; bz++)
                    {
                        data[bx << 11 | bz << 7 | by] = (byte)BlockData.Blocks.Leaves;
                        c.Data.setNibble(bx, by, bz, 0);
                    }

            for (int bx = x - 1; bx <= x + 1; bx++)
                for (int bz = z - 1; bz <= z + 1; bz++)
                {
                    data[bx << 11 | bz << 7 | y + 6] = (byte)BlockData.Blocks.Leaves;
                    c.Data.setNibble(bx, y + 6, bz, 0);
                }

            for (int by = y + 1; by < y + 6; by++)
            {
                data[x << 11 | z << 7 | by] = (byte)BlockData.Blocks.Log;
                c.Data.setNibble(x, by, z, 0);
            }
            //}
            // TODO: other tree types
            /*else if (r2 > 1 && r2 < 2)
            {
                c.setBlock(x, y + 1, z, (byte)0x0);
                c.getParent().getObjectGenerator("firTree").generate(c.getBlockWorldPosX(x), y + 1, c.getBlockWorldPosZ(z), false);
            }
            else
            {
                c.setBlock(x, y + 1, z, (byte)0x0);
                c.getParent().getObjectGenerator("tree").generate(c.getBlockWorldPosX(x), y + 1, c.getBlockWorldPosZ(z), false);
            }*/
        }
Exemple #26
0
 public void Add(Chunk chunk)
 {
     this[chunk.Coords] = chunk;
     Interlocked.Increment(ref Changes);
 }
Exemple #27
0
 public void AddChunk(Chunk c)
 {
     c.CreationDate = DateTime.Now;
     Chunks.Add(c);
 }
Exemple #28
0
 internal void SendChunk(Chunk chunk, bool sync)
 {
     MapChunkPacket packet = new MapChunkPacket
     {
         Chunk = chunk,
         Async = !sync
     };
     SendPacket(packet);
 }
Exemple #29
0
        public static Chunk Load(UniversalCoords coords, WorldManager world)
        {
            string path = world.Folder + "/x" + coords.ChunkX + "_z" + coords.ChunkZ + ".gz";

            if (!CanLoad(path))
                return null;

            Stream zip = null;

            Chunk chunk = new Chunk(world, coords);

            try
            {
                zip = new DeflateStream(File.Open(path, FileMode.Open), CompressionMode.Decompress);

                int version = zip.ReadByte();

                switch(version)
                {
                    /* When there's a new mod you do:
                    case 1:
                    {
                     * dosomething
                     * goto case 0;
                    }*/
                    case 0:
                    {
                        chunk.LightToRecalculate = Convert.ToBoolean(zip.ReadByte());
                        chunk.HeightMap = new byte[16,16];
                        int height;
                        chunk.MaxHeight = 0;
                        for (int x = 0; x < 16; ++x)
                        {
                            for (int z = 0; z < 16; ++z)
                            {
                                height = chunk.HeightMap[x, z] = (byte) zip.ReadByte();

                                if (chunk.MaxHeight < height)
                                    chunk.MaxHeight = height;
                            }
                        }
                        chunk.LoadAllBlocks(zip);
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                world.Logger.Log(ex);
                return null;
            }
            if (zip != null)
                zip.Dispose();

            (BlockHelper.Instance((byte) BlockData.Blocks.Sign_Post) as BlockSignBase).LoadSignsFromDisk(chunk, world.SignsFolder);

            return chunk;
        }
Exemple #30
0
 public void RemoveChunk(Chunk c)
 {
     Chunks.Remove(c);
 }