public void Write(int x, int z, NbtNode node)
        {
            lock (this)
            {
                NbtWriter    writer = new NbtWriter();
                MemoryStream stream = new MemoryStream();
                writer.WriteFile(stream, node);
                byte[] buffer      = Compress(stream.ToArray());
                int    usedSectors = ((buffer.Length + 5) % 4096) == 0
                                      ? (buffer.Length + 5) / 4096
                                      : (buffer.Length + 5) / 4096 + 1;
                MoveToHeaderPosition(x, z);
                _filePointer.Write(0);

                int sectorPostion = FindFreeSector(usedSectors);
                Console.WriteLine("Saving chunk {0},{1} at position {2}.", x, z, sectorPostion);
                int sector = (sectorPostion << 8) | usedSectors;

                MoveToHeaderPosition(x, z);

                _filePointer.Write(sector);

                _filePointer.Seek(sectorPostion * 4096, SeekOrigin.Begin);
                _filePointer.Write(buffer.Length);
                _filePointer.Write((byte)1);  //GZip Compression
                _filePointer.Write(buffer);
                _filePointer.Flush();
            }
        }
Example #2
0
        public void WriteFile(Stream decompressStream, NbtNode node)
        {
            BigEndianStream stream;

            WriteNode(stream = new BigEndianStream(decompressStream), node);
            //stream.Flush();
        }
Example #3
0
        public void AddNode <T>(string name, T value)
        {
            NbtNode node = null;

            if (typeof(T) == typeof(string))
            {
                node = new NbtString {
                    Value = (string)(object)value
                }
            }
            ;
            if (typeof(T) == typeof(byte))
            {
                node = new NbtByte {
                    Value = (byte)(object)value
                }
            }
            ;
            if (typeof(T) == typeof(int))
            {
                node = new NbtInt {
                    Value = (int)(object)value
                }
            }
            ;
            if (typeof(T) == typeof(byte[]))
            {
                node = new NbtBytes {
                    Value = (byte[])(object)value
                }
            }
            ;
            if (typeof(T) == typeof(double))
            {
                node = new NbtDouble {
                    Value = (double)(object)value
                }
            }
            ;
            if (typeof(T) == typeof(float))
            {
                node = new NbtFloat {
                    Value = (float)(object)value
                }
            }
            ;
            if (typeof(T) == typeof(int[]))
            {
                node = new NbtInts {
                    Value = (int[])(object)value
                }
            }
            ;
            if (typeof(T) == typeof(long))
            {
                node = new NbtLong {
                    Value = (long)(object)value
                }
            }
            ;
            if (typeof(T) == typeof(short))
            {
                node = new NbtShort {
                    Value = (short)(object)value
                }
            }
            ;
            if (typeof(T) == typeof(NbtList))
            {
                node = (NbtNode)(object)value;
            }
            if (typeof(T) == typeof(NbtCompound))
            {
                node = (NbtNode)(object)value;
            }
            if (node == null)
            {
                throw new Exception("Wrong Typ: " + typeof(T));
            }
            node.Name = name;
            Childs.Add(node);
        }
    }
Example #4
0
        private void WriteNode(BigEndianStream zipped, NbtNode node)
        {
            zipped.Write(node.Type);
            if (node.Type == 0)
            {
                return;
            }
            zipped.Write8(node.Name);
            switch (node.Type)
            {
            case 1:
                zipped.Write(((NbtByte)node).Value);
                break;

            case 2:
                zipped.Write(((NbtShort)node).Value);
                break;

            case 3:
                zipped.Write(((NbtInt)node).Value);
                break;

            case 4:
                zipped.Write(((NbtLong)node).Value);
                break;

            case 5:
                zipped.Write(((NbtFloat)node).Value);
                break;

            case 6:
                zipped.Write(((NbtDouble)node).Value);
                break;

            case 7:
                zipped.Write(((NbtBytes)node).Value.Length);
                zipped.Write(((NbtBytes)node).Value);
                break;

            case 8:
                zipped.Write8(((NbtString)node).Value);
                break;

            case 9:
                var list = (NbtList)node;
                zipped.Write(list.TagId);
                zipped.Write(list.Childs.Count);
                foreach (var child in list.Childs)
                {
                    WriteRaw(zipped, list.TagId, child);
                }
                break;

            case 10:
                var compount = (NbtCompound)node;
                foreach (var item in compount.Childs)
                {
                    WriteNode(zipped, item);
                }
                WriteNode(zipped, new NbtStop());
                break;

            case 11:
                zipped.Write(((NbtInts)node).Value.Length);
                zipped.Write(IntToByteArray(((NbtInts)node).Value));
                break;
            }
        }
        private NbtNode ReadNode(BigEndianStream zipped)
        {
            byte    type = (byte)zipped.ReadByte();
            NbtNode node = null;

            switch (type)
            {
            case 0:
                return(new NbtStop());

            case 1:
                node = new NbtByte
                {
                    Name  = zipped.ReadString8(),
                    Value = zipped.ReadByte()
                };
                break;

            case 2:
                node = new NbtShort
                {
                    Name  = zipped.ReadString8(),
                    Value = zipped.ReadInt16()
                };
                break;

            case 3:
                node = new NbtInt
                {
                    Name  = zipped.ReadString8(),
                    Value = zipped.ReadInt32()
                };
                break;

            case 4:
                node = new NbtLong
                {
                    Name  = zipped.ReadString8(),
                    Value = zipped.ReadInt64()
                };
                break;

            case 5:
                node = new NbtFloat
                {
                    Name  = zipped.ReadString8(),
                    Value = zipped.ReadSingle()
                };
                break;

            case 6:
                node = new NbtDouble
                {
                    Name  = zipped.ReadString8(),
                    Value = zipped.ReadDouble()
                };
                break;

            case 7:
                node = new NbtBytes
                {
                    Name  = zipped.ReadString8(),
                    Value = zipped.ReadBytes(zipped.ReadInt32())
                };
                break;

            case 8:
                node = new NbtString
                {
                    Name  = zipped.ReadString8(),
                    Value = zipped.ReadString8()
                };
                break;

            case 9:
                node = new NbtList();
                ((NbtList)node).Name   = zipped.ReadString8();
                ((NbtList)node).Childs = new List <object>();
                byte tagId = zipped.ReadByte();
                ((NbtList)node).TagId = tagId;
                int length = zipped.ReadInt32();

                for (int i = 0; i < length; i++)
                {
                    ((NbtList)node).Childs.Add(ReadRaw(zipped, tagId));
                }
                break;

            case 10:
                node = new NbtCompound();
                ((NbtCompound)node).Name   = zipped.ReadString8();
                ((NbtCompound)node).Childs = new List <NbtNode>();
                NbtNode subNode;
                while ((subNode = ReadNode(zipped)).Type != 0)
                {
                    ((NbtCompound)node).Childs.Add(subNode);
                }
                break;

            case 11:
                node = new NbtInts
                {
                    Name  = zipped.ReadString8(),
                    Value = ByteToIntArray(zipped.ReadBytes(zipped.ReadInt32() * sizeof(int)))
                };
                break;
            }
            //string str = zipped.ReadString8(100);
            if (node == null)
            {
                throw new Exception();
            }
            return(node);
        }