Exemple #1
0
        /// <summary>
        /// Loads a level from the given level.dat file.
        /// </summary>
        public static Level Load(string file)
        {
            if (!Path.IsPathRooted(file))
            {
                file = Path.Combine(Directory.GetCurrentDirectory(), file);
            }
            var serializer = new NbtSerializer(typeof(Level));
            var nbtFile    = new NbtFile(file);
            var level      = (Level)serializer.Deserialize(nbtFile.RootTag["Data"]);

            level.DatFile        = file;
            level.BaseDirectory  = Path.GetDirectoryName(file);
            level.WorldGenerator = GetGenerator(level.GeneratorName);
            level.WorldGenerator.Initialize(level);
            var worlds = Directory.GetDirectories(level.BaseDirectory).Where(
                d => Directory.GetFiles(d).Any(f => f.EndsWith(".mca") || f.EndsWith(".mcr")));

            foreach (var world in worlds)
            {
                var w = World.LoadWorld(world);
                w.WorldGenerator = level.WorldGenerator;
                level.AddWorld(w);
            }
            return(level);
        }
Exemple #2
0
    private void WriteDimension(Dimension dimension, IMinecraftPacket packet)
    {
        var nbtDimension = NbtSerializer.SerializeCompound(dimension.Element, "");
        var nbtFile      = new NbtFile(nbtDimension);

        packet.WriteBytes(nbtFile.GetBuffer());
    }
Exemple #3
0
        /// <summary>
        /// Saves this level. This will not work with an in-memory world.
        /// </summary>
        public void Save()
        {
            if (DatFile == null)
            {
                throw new InvalidOperationException("This level exists only in memory. Use Save(string).");
            }
            LastPlayed = DateTime.UtcNow.Ticks;
            var serializer = new NbtSerializer(typeof(Level));
            var tag        = serializer.Serialize(this, "Data") as NbtCompound;
            var file       = new NbtFile();

            file.RootTag.Add(tag);
            file.SaveToFile(DatFile, NbtCompression.GZip);
            // Save worlds
            foreach (var world in Worlds)
            {
                if (world.BaseDirectory == null)
                {
                    world.Save(Path.Combine(BaseDirectory, world.Name));
                }
                else
                {
                    world.Save();
                }
            }
        }
Exemple #4
0
    public void SerializeComplexCompoundTest()
    {
        var faker   = new Faker();
        var element = new CustomComplexNbtElement
        {
            IntegerValue = faker.Random.Int(),
            FlatElement  = new CustomFlatNbtElement
            {
                ByteValue    = faker.Random.Byte(),
                ShortValue   = faker.Random.Short(),
                IntegerValue = faker.Random.Int(),
                FloatValue   = faker.Random.Float(),
                LongValue    = faker.Random.Long(),
                DoubleValue  = faker.Random.Double(),
                StringValue  = faker.Lorem.Sentence(),
            }
        };

        NbtCompound compound = NbtSerializer.SerializeCompound(element);

        Assert.NotNull(compound);
        AssertTag <NbtInt, int>(compound, "integer_value", element.IntegerValue, x => x.IntValue);

        NbtCompound innerCompound = compound.Get("flat_element_compound") as NbtCompound;

        Assert.NotNull(innerCompound);
        AssertTag <NbtByte, byte>(innerCompound, "byte_value", element.FlatElement.ByteValue, x => x.ByteValue);
        AssertTag <NbtShort, short>(innerCompound, "short_value", element.FlatElement.ShortValue, x => x.ShortValue);
        AssertTag <NbtInt, int>(innerCompound, "integer_value", element.FlatElement.IntegerValue, x => x.IntValue);
        AssertTag <NbtFloat, float>(innerCompound, "float_value", element.FlatElement.FloatValue, x => x.FloatValue);
        AssertTag <NbtLong, long>(innerCompound, "long_value", element.FlatElement.LongValue, x => x.LongValue);
        AssertTag <NbtDouble, double>(innerCompound, "double_value", element.FlatElement.DoubleValue, x => x.DoubleValue);
        AssertTag <NbtString, string>(innerCompound, "string_value", element.FlatElement.StringValue, x => x.StringValue);
    }
Exemple #5
0
        public static Chunk FromNbt(NbtFile nbt)
        {
            var serializer = new NbtSerializer(typeof(Chunk));
            var chunk      = (Chunk)serializer.Deserialize(nbt.RootTag["Level"]);

            return(chunk);
        }
Exemple #6
0
        private void LoadFromFile(string directory)
        {
            NbtFile file = new NbtFile();

            using (var stream = File.Open(Path.Combine(LevelDirectory, "level.dat"), FileMode.Open))
                file.LoadFromStream(stream, NbtCompression.None, null);
            var        data       = file.RootTag.Get <NbtCompound>("Data");
            var        serializer = new NbtSerializer(typeof(SavedLevel));
            SavedLevel level      = (SavedLevel)serializer.Deserialize(data);

            Name        = level.LevelName;
            Time        = level.Time;
            GameMode    = (GameMode)level.GameMode;
            MapFeatures = level.MapFeatures;
            Seed        = level.Seed;
            // Find world generator
            string generatorName = level.GeneratorName;

            WorldGenerator      = GetGenerator(generatorName);
            WorldGenerator.Seed = Seed;
            GeneratorOptions    = level.GeneratorOptions;
            WorldGenerator.Initialize(this);

            SpawnPoint = level.SpawnPoint;

            World = new World(this, WorldGenerator, Path.Combine(directory, "region"));
        }
Exemple #7
0
        private void CheckFromTag(bool fill)
        {
            var stringValue = "test_string_value_rv";
            var intValue    = 882882;

            var shadow = new EasyTestClass();

            var tag = new NbtCompound();

            tag.Add(new NbtString(nameof(shadow.EasyStringProperty), stringValue));
            tag.Add(new NbtInt(nameof(shadow.EasyIntProperty), intValue));

            EasyTestClass result = null;

            if (fill)
            {
                result = shadow;
                NbtSerializer.FillObject(result, tag);
            }
            else
            {
                result = NbtSerializer.DeserializeObject <EasyTestClass>(tag);
            }

            Assert.IsNotNull(result);

            Assert.AreEqual(stringValue, result.EasyStringProperty);
            Assert.AreEqual(intValue, result.EasyIntProperty);
        }
Exemple #8
0
        public void TestSerializer()
        {
            var serializer   = new NbtSerializer(typeof(TestType));
            var test         = new TestType();
            var serialized   = serializer.Serialize(test);
            var deserialized = (TestType)serializer.Deserialize(serialized);

            Assert.AreEqual(test, deserialized);
        }
Exemple #9
0
        public NbtFile ToNbt()
        {
            var serializer = new NbtSerializer(typeof(Chunk));
            var compound   = serializer.Serialize(this, "Level") as NbtCompound;
            var file       = new NbtFile();

            file.RootTag.Add(compound);
            return(file);
        }
Exemple #10
0
        public NbtCompound ToNbt(Vector3 position)
        {
            var serializer = new NbtSerializer(GetType());

            var entity = (NbtCompound)serializer.Serialize(this);

            entity.Add(new NbtInt("x", (int)position.X));
            entity.Add(new NbtInt("y", (int)position.Y));
            entity.Add(new NbtInt("z", (int)position.Z));

            return(entity);
        }
Exemple #11
0
        public static WorldProperties FromFile_Pre(string fileName)
        {
            if (!fileName.StartsWith(Utils.Remote))
            {
                return(null);
            }

            var stream = new MemoryStream(Utils.GetWebLevelData());
            var nbt    = new NbtSerializer().Deserialize(new GZipStream(stream, CompressionMode.Decompress));

            return(new CustomProperties(nbt, fileName.Remove(fileName.LastIndexOfAny(new[] { '\\', '/' })).Substring(Utils.Remote.Length + 1)));
        }
Exemple #12
0
        public void Save()
        {
            NbtFile file = new NbtFile();

            var serializer = new NbtSerializer(typeof(SavedLevel));
            var level      = new SavedLevel
            {
                IsRaining        = Raining,
                GeneratorVersion = 0,
                Time             = Time,
                GameMode         = (int)GameMode,
                MapFeatures      = MapFeatures,
                GeneratorName    = WorldGenerator.GeneratorName,
                Initialized      = true,
                Seed             = Seed,
                SpawnPoint       = SpawnPoint,
                SizeOnDisk       = 0,
                ThunderTime      = ThunderTime,
                RainTime         = RainTime,
                Version          = 19133,
                Thundering       = Thundering,
                LevelName        = Name,
                LastPlayed       = DateTime.UtcNow.Ticks
            };

            if (!string.IsNullOrEmpty(PlayerName))
            {
                if (File.Exists(Path.Combine(LevelDirectory, "players", PlayerName + ".dat")))
                {
                    var player = new NbtFile();
                    using (Stream stream = File.Open(Path.Combine(LevelDirectory, "players", PlayerName + ".dat"), FileMode.Open))
                        player.LoadFromStream(stream, NbtCompression.GZip, null);
                    level.Player      = player.RootTag;
                    level.Player.Name = "Player";
                }
            }
            var data = serializer.Serialize(level);

            file.RootTag = new NbtCompound("");
            file.RootTag.Add(data);
            using (var stream = File.Create(Path.Combine(LevelDirectory, "level.dat")))
                file.SaveToStream(stream, NbtCompression.GZip);
            if (World.Directory == null)
            {
                World.Save(Path.Combine(LevelDirectory, "region"));
            }
            else
            {
                World.Save();
            }
        }
        static void Main(string[] args)
        {
            NbtSerializer s = new NbtSerializer(typeof(Player));

            using (System.IO.FileStream file = new System.IO.FileStream(@"e:\Users\Stephen\Desktop\mcedit\world\players\skonves.dat", System.IO.FileMode.Open))
            {
                using (System.IO.Compression.GZipStream zip = new System.IO.Compression.GZipStream(file, System.IO.Compression.CompressionMode.Decompress))
                {
                    using (NbtReader reader = new NbtReader(zip))
                    {
                        object obj = s.Deserialize(reader);
                    }
                }
            }

            //System.IO.Compression.GZipStream
        }
Exemple #14
0
        public void Deserialize(NbtTag value)
        {
            IsModified = true;
            var compound = value as NbtCompound;
            var chunk    = (Chunk)Serializer.Deserialize(value, true);

            this._TileEntities    = chunk._TileEntities;
            this.Biomes           = chunk.Biomes;
            this.HeightMap        = chunk.HeightMap;
            this.LastUpdate       = chunk.LastUpdate;
            this.Sections         = chunk.Sections;
            this.TerrainPopulated = chunk.TerrainPopulated;
            this.X = chunk.X;
            this.Z = chunk.Z;

            // Entities
            var entities = compound["Entities"] as NbtList;

            Entities = new List <IDiskEntity>();
            for (int i = 0; i < entities.Count; i++)
            {
                var         id = entities[i]["id"].StringValue;
                IDiskEntity entity;
                if (EntityTypes.ContainsKey(id.ToUpper()))
                {
                    entity = (IDiskEntity)Activator.CreateInstance(EntityTypes[id]);
                }
                else
                {
                    entity = new UnrecognizedEntity(id);
                }
                entity.Deserialize(entities[i]);
                Entities.Add(entity);
            }
            var serializer = new NbtSerializer(typeof(Section));

            foreach (var section in compound["Sections"] as NbtList)
            {
                int index = section["Y"].IntValue;
                Sections[index] = (Section)serializer.Deserialize(section);
                Sections[index].ProcessSection();
            }
        }
Exemple #15
0
        public static TileEntity FromNbt(NbtCompound entityTag, out Vector3 position)
        {
            position = Vector3.Zero;
            var  id   = entityTag.Get <NbtString>("id").Value;
            Type type = (from e in dummyInstances where e.Id == id select e.GetType()).FirstOrDefault();

            if (type == null)
            {
                return(null);
            }

            var serializer = new NbtSerializer(type);

            var entity = (TileEntity)serializer.Deserialize(entityTag);

            position = new Vector3(
                entityTag.Get <NbtInt>("x").Value,
                entityTag.Get <NbtInt>("y").Value,
                entityTag.Get <NbtInt>("z").Value);
            return(entity);
        }
Exemple #16
0
        public void TestSignTile()
        {
            SignTileEntity entity = new SignTileEntity();

            entity.Text1 = "Test1";
            entity.Text2 = "Test2";
            entity.Text3 = "Test3";
            entity.Text4 = "Test4";

            var serializer = new NbtSerializer(typeof(SignTileEntity));

            var obj = serializer.Serialize(entity);

            var result = (SignTileEntity)serializer.Deserialize(obj);

            Assert.AreEqual(entity.Id, result.Id);
            Assert.AreEqual(entity.Text1, result.Text1);
            Assert.AreEqual(entity.Text2, result.Text2);
            Assert.AreEqual(entity.Text3, result.Text3);
            Assert.AreEqual(entity.Text4, result.Text4);
        }
Exemple #17
0
    private void WriteDimensionsAndBiomes(IEnumerable <Dimension> dimensions, IEnumerable <Biome> biomes, IMinecraftPacket packet)
    {
        IEnumerable <NbtTag> dimensionsTags = dimensions.Select(x => NbtSerializer.SerializeCompound(x));
        IEnumerable <NbtTag> biomesTags     = biomes.Select(x => NbtSerializer.SerializeCompound(x));

        var nbtCompound = new NbtCompound("")
        {
            new NbtCompound("minecraft:dimension_type")
            {
                new NbtString("type", "minecraft:dimension_type"),
                new NbtList("value", dimensionsTags, NbtTagType.Compound)
            },
            new NbtCompound("minecraft:worldgen/biome")
            {
                new NbtString("type", "minecraft:worldgen/biome"),
                new NbtList("value", biomesTags, NbtTagType.Compound)
            }
        };
        var nbtFile = new NbtFile(nbtCompound);

        packet.WriteBytes(nbtFile.GetBuffer());
    }
Exemple #18
0
        public void TypesTest()
        {
            var raw          = new TypesTestClass();
            var tag          = NbtSerializer.SerializeObject(raw);
            var deserialized = NbtSerializer.DeserializeObject <TypesTestClass>(tag);

            Assert.IsNotNull(tag);

            Assert.AreEqual(raw.BoolFalseTestProperty, deserialized.BoolFalseTestProperty);
            Assert.AreEqual(raw.BoolTrueTestProperty, deserialized.BoolTrueTestProperty);
            Assert.AreEqual(raw.ByteArrayTestProperty, deserialized.ByteArrayTestProperty);
            Assert.AreEqual(raw.IntArrayTestProperty, deserialized.IntArrayTestProperty);
            Assert.AreEqual(raw.ByteTestProperty, deserialized.ByteTestProperty);
            Assert.AreEqual(raw.SByteTestProperty, deserialized.SByteTestProperty);
            Assert.AreEqual(raw.ShortTestProperty, deserialized.ShortTestProperty);
            Assert.AreEqual(raw.UShortTestProperty, deserialized.UShortTestProperty);
            Assert.AreEqual(raw.IntTestProperty, deserialized.IntTestProperty);
            Assert.AreEqual(raw.UIntTestProperty, deserialized.UIntTestProperty);
            Assert.AreEqual(raw.LongTestProperty, deserialized.LongTestProperty);
            Assert.AreEqual(raw.ULongTestProperty, deserialized.ULongTestProperty);

            Assert.AreEqual(raw.NbtIntProperty.Value, deserialized.NbtIntProperty.Value);

            AssertTagValue <NbtByte>(tag, nameof(raw.BoolFalseTestProperty), raw.BoolFalseTestProperty, t => Convert.ToBoolean(t.Value));
            AssertTagValue <NbtByte>(tag, nameof(raw.BoolTrueTestProperty), raw.BoolTrueTestProperty, t => Convert.ToBoolean(t.Value));
            AssertTagValue <NbtByteArray>(tag, nameof(raw.ByteArrayTestProperty), raw.ByteArrayTestProperty, t => t.Value);
            AssertTagValue <NbtIntArray>(tag, nameof(raw.IntArrayTestProperty), raw.IntArrayTestProperty, t => t.Value);
            AssertTagValue <NbtByte>(tag, nameof(raw.ByteTestProperty), raw.ByteTestProperty, t => t.Value);
            AssertTagValue <NbtByte>(tag, nameof(raw.SByteTestProperty), raw.SByteTestProperty, t => (sbyte)t.Value);
            AssertTagValue <NbtShort>(tag, nameof(raw.ShortTestProperty), raw.ShortTestProperty, t => t.Value);
            AssertTagValue <NbtShort>(tag, nameof(raw.UShortTestProperty), raw.UShortTestProperty, t => (ushort)t.Value);
            AssertTagValue <NbtInt>(tag, nameof(raw.IntTestProperty), raw.IntTestProperty, t => t.Value);
            AssertTagValue <NbtInt>(tag, nameof(raw.UIntTestProperty), raw.UIntTestProperty, t => (uint)t.Value);
            AssertTagValue <NbtLong>(tag, nameof(raw.LongTestProperty), raw.LongTestProperty, t => t.Value);
            AssertTagValue <NbtLong>(tag, nameof(raw.ULongTestProperty), raw.ULongTestProperty, t => (ulong)t.Value);

            AssertTagValue <NbtInt>(tag, nameof(raw.NbtIntProperty), raw.NbtIntProperty.Value, t => t.Value);
        }
Exemple #19
0
        public void FillTest()
        {
            var valuesSet = new List <string>()
            {
                "testVal1", "test_val_2", "TestVal3", "TEST_VAL_4"
            };

            var original = new FillTestClass();

            original.GetOnlyTestStringList.AddRange(valuesSet);
            original.GetOnlyTestClassProperty.EasyIntProperty    = 321;
            original.GetOnlyTestClassProperty.EasyStringProperty = "ESP_TEST_FILL";

            var tag = NbtSerializer.SerializeObject(original);

            var result = NbtSerializer.DeserializeObject <FillTestClass>(tag);

            Assert.IsNotNull(result);

            Assert.AreEqual(original.GetOnlyTestClassProperty.EasyIntProperty, result.GetOnlyTestClassProperty.EasyIntProperty);
            Assert.AreEqual(original.GetOnlyTestClassProperty.EasyStringProperty, result.GetOnlyTestClassProperty.EasyStringProperty);
            CollectionAssert.AreEquivalent(original.GetOnlyTestStringList, result.GetOnlyTestStringList);
        }
Exemple #20
0
        public NbtTag Serialize(string tagName)
        {
            var chunk    = (NbtCompound)Serializer.Serialize(this, tagName, true);
            var entities = new NbtList("Entities", NbtTagType.Compound);

            for (int i = 0; i < Entities.Count; i++)
            {
                entities.Add(Entities[i].Serialize(string.Empty));
            }
            chunk.Add(entities);
            var sections   = new NbtList("Sections", NbtTagType.Compound);
            var serializer = new NbtSerializer(typeof(Section));

            for (int i = 0; i < Sections.Length; i++)
            {
                if (!Sections[i].IsAir)
                {
                    sections.Add(serializer.Serialize(Sections[i]));
                }
            }
            chunk.Add(sections);
            return(chunk);
        }
Exemple #21
0
        public void FieldsAndPropertiesTest()
        {
            var raw = new FieldsAndPropertiesTestClass();
            var tag = NbtSerializer.SerializeObject(raw);

            Assert.IsNotNull(tag);

            Assert.IsFalse(tag.Contains(nameof(raw.HidenTestIntFiled)));
            Assert.IsFalse(tag.Contains(nameof(raw.HidenDefaultTestIntFiled)));

            Assert.IsFalse(tag.Contains(nameof(raw.HidenTestIntProperty)));
            Assert.IsFalse(tag.Contains(nameof(raw.HidenDefaultTestIntProperty)));

            AssertTagValue <NbtInt>(tag, nameof(raw.DefaultTestIntFiled), raw.DefaultTestIntFiled, t => t.Value);
            AssertTagValue <NbtInt>(tag, nameof(raw.TestIntFiled), raw.TestIntFiled, t => t.Value);
            AssertTagValue <NbtInt>(tag, "PrivateTestIntFiled", 3, t => t.Value);
            AssertTagValue <NbtInt>(tag, FieldsAndPropertiesTestClass.NameForNamedTestIndFiled, raw.NamedTestIntFiled, t => t.Value);

            AssertTagValue <NbtInt>(tag, nameof(raw.DefaultTestIntProperty), raw.DefaultTestIntProperty, t => t.Value);
            AssertTagValue <NbtInt>(tag, nameof(raw.TestIntProperty), raw.TestIntProperty, t => t.Value);
            AssertTagValue <NbtInt>(tag, nameof(raw.OnlyGetTestIntProperty), raw.OnlyGetTestIntProperty, t => t.Value);
            AssertTagValue <NbtInt>(tag, "PrivateTestIntProperty", 8, t => t.Value);
            AssertTagValue <NbtInt>(tag, FieldsAndPropertiesTestClass.NameForNamedTestIndProperty, raw.NamedTestIntProperty, t => t.Value);
        }
Exemple #22
0
 static Chunk()
 {
     EntityTypes = new Dictionary <string, Type>();
     Serializer  = new NbtSerializer(typeof(Chunk));
 }
Exemple #23
0
 public void TestSerializer()
 {
     var serializer = new NbtSerializer(typeof(TestType));
     var test = new TestType();
     var serialized = serializer.Serialize(test);
     var deserialized = (TestType)serializer.Deserialize(serialized);
     Assert.AreEqual(test, deserialized);
 }
Exemple #24
0
 static void Main(string[] args)
 {
     TagCompound tag = NbtSerializer.Serialize(new WhatTheBlah());
     WhatTheBlah obj = NbtSerializer.Deserialize <WhatTheBlah>(tag);
 }