public async Task <ItemStack> ReadSlotAsync()
        {
            var present = await this.ReadBooleanAsync();

            if (present)
            {
                var item = Registry.GetItem((short)await this.ReadVarIntAsync());

                var slot = new ItemStack(item.Type, await this.ReadByteAsync())
                {
                    Present = present
                };

                var reader = new NbtReader(this);

                INbtTag tag;
                while ((tag = reader.ReadNextTag()) != null)
                {
                    var itemMetaBuilder = new ItemMetaBuilder();

                    if (tag is NbtCompound root)
                    {
                        foreach (var(name, child) in root)
                        {
                            switch (name.ToLower())
                            {
                            case "enchantments":
                            {
                                var enchantments = (NbtList)child;

                                foreach (var enchant in enchantments)
                                {
                                    if (enchant is NbtCompound compound)
                                    {
                                        itemMetaBuilder.AddEnchantment(compound.GetString("id").ToEnchantType(), compound.GetShort("lvl"));
                                    }
                                }

                                break;
                            }

                            case "storedenchantments":
                            {
                                var enchantments = (NbtList)child;

                                //Globals.PacketLogger.LogDebug($"List Type: {enchantments.ListType}");

                                foreach (var enchantment in enchantments)
                                {
                                    if (enchantment is NbtCompound compound)
                                    {
                                        compound.TryGetTag("id", out var id);
                                        compound.TryGetTag("lvl", out var lvl);

                                        itemMetaBuilder.AddStoredEnchantment(compound.GetString("id").ToEnchantType(), compound.GetShort("lvl"));
                                    }
                                }
                                break;
                            }

                            case "slot":
                            {
                                var byteTag = (NbtTag <byte>)child;

                                itemMetaBuilder.WithSlot(byteTag.Value);
                                //Console.WriteLine($"Setting slot: {itemMetaBuilder.Slot}");
                                break;
                            }

                            case "damage":
                            {
                                var intTag = (NbtTag <int>)child;

                                itemMetaBuilder.WithDurability(intTag.Value);
                                //Globals.PacketLogger.LogDebug($"Setting damage: {tag.IntValue}");
                                break;
                            }

                            case "display":
                            {
                                var display = (NbtCompound)child;

                                foreach (var(displayTagName, displayTag) in display)
                                {
                                    if (displayTagName.EqualsIgnoreCase("name") && displayTag is NbtTag <string> stringTag)
                                    {
                                        var messages = stringTag.Value.FromJson <ChatMessage[]>();
                                        itemMetaBuilder.WithName(messages[0]);
                                    }
                                    else if (displayTag.Name.EqualsIgnoreCase("lore"))
                                    {
                                        var loreTag = (NbtList)displayTag;

                                        foreach (NbtTag <string> lore in loreTag)
                                        {
                                            itemMetaBuilder.AddLore(lore.Value.FromJson <ChatMessage>());
                                        }
                                    }
                                }
                                break;
                            }

                            default:
                                break;
                            }
                        }
                        //slot.ItemNbt.Slot = compound.Get<NbtByte>("Slot").Value;
                        //slot.ItemNbt.Count = compound.Get<NbtByte>("Count").Value;
                        //slot.ItemNbt.Id = compound.Get<NbtShort>("id").Value;
                        //slot.ItemNbt.Damage = compound.Get<NbtShort>("Damage").Value;
                        //slot.ItemNbt.RepairCost = compound.Get<NbtInt>("RepairCost").Value;
                    }

                    slot.ItemMeta = itemMetaBuilder.Build();
                }

                return(slot);
            }

            return(null);
        }
示例#2
0
        public void BigTest()
        {
            var fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("Obsidian.Tests.Assets.bigtest.nbt");
            var decompressedStream = new MemoryStream();

            GZip.Decompress(fs, decompressedStream, false);

            decompressedStream.Position = 0;
            var reader = new NbtReader(decompressedStream);

            var main = reader.ReadNextTag() as NbtCompound;

            //Writing out the string to read ourselves
            output.WriteLine(main.ToString());

            //Begin reading

            Assert.Equal("Level", main.Name);

            Assert.Equal(NbtTagType.Compound, main.Type);

            Assert.Equal(11, main.Count);

            var longTest = main.GetLong("longTest");

            Assert.Equal(long.MaxValue, longTest);

            var shortTest = main.GetShort("shortTest");

            Assert.Equal(short.MaxValue, shortTest);

            var stringTest = main.GetString("stringTest");

            Assert.Equal("HELLO WORLD THIS IS A TEST STRING ÅÄÖ!", stringTest);

            var floatTest = main.GetFloat("floatTest");

            Assert.Equal(0.49823147058486938, floatTest);

            var intTest = main.GetInt("intTest");

            Assert.Equal(int.MaxValue, intTest);

            var byteTest = main.GetByte("byteTest");

            Assert.Equal(127, byteTest);

            var doubleTest = main.GetDouble("doubleTest");

            Assert.Equal(0.49312871321823148, doubleTest);

            //var byteArrayTest = main.GetArr("byteArrayTest (the first 1000 values of (n*n*255+n*7)%100, starting with n=0 (0, 62, 34, 16, 8, ...))");//TODO add getting an array from a compound

            /*Assert.Equal(1000, byteArrayTest.Value.Length);
             *
             * for (int n = 0; n < 1000; n++)
             *  Assert.Equal((n * n * 255 + n * 7) % 100, byteArrayTest.Value[n]);*/

            #region nested compounds
            main.TryGetTag("nested compound test", out INbtTag compound);
            var nestedCompound = (NbtCompound)compound;

            Assert.Equal(2, nestedCompound.Count);

            nestedCompound.TryGetTag("ham", out INbtTag hamCompound);
            var ham = (NbtCompound)hamCompound;

            Assert.Equal(2, ham.Count);

            Assert.Equal("Hampus", ham.GetString("name"));
            Assert.Equal(0.75, ham.GetFloat("value"));

            nestedCompound.TryGetTag("egg", out INbtTag eggCompound);
            var egg = (NbtCompound)eggCompound;

            Assert.Equal(2, egg.Count);
            Assert.Equal("Eggbert", egg.GetString("name"));
            Assert.Equal(0.5, egg.GetFloat("value"));
            #endregion nested compounds

            #region lists
            main.TryGetTag("listTest (long)", out var longList);
            var listLongTest = (NbtList)longList;

            Assert.Equal(5, listLongTest.Count);

            var count = 11;

            foreach (var tag in listLongTest)
            {
                if (tag is NbtTag <long> item)
                {
                    Assert.Equal(count++, item.Value);
                }
            }

            main.TryGetTag("listTest (compound)", out var compoundList);
            var listCompoundTest = (NbtList)compoundList;

            Assert.Equal(2, listCompoundTest.Count);

            var compound1 = listCompoundTest[0] as NbtCompound;
            Assert.Equal("Compound tag #0", compound1.GetString("name"));
            Assert.Equal(1264099775885, compound1.GetLong("created-on"));


            var compound2 = listCompoundTest[1] as NbtCompound;
            Assert.Equal("Compound tag #1", compound2.GetString("name"));
            Assert.Equal(1264099775885, compound2.GetLong("created-on"));
            #endregion lists
        }
        public ItemStack ReadItemStack()
        {
            var present = ReadBoolean();

            if (present)
            {
                var item = Registry.GetItem((short)ReadVarInt());

                var slot = new ItemStack(item.Type, ReadUnsignedByte())
                {
                    Present = present
                };

                var reader = new NbtReader(this);

                INbtTag tag;
                while ((tag = reader.ReadNextTag()) != null)
                {
                    var itemMetaBuilder = new ItemMetaBuilder();

                    if (tag is NbtCompound root)
                    {
                        foreach (var(name, child) in root)
                        {
                            switch (name.ToUpperInvariant())
                            {
                            case "ENCHANTMENTS":
                            {
                                var enchantments = (NbtList)child;

                                foreach (var enchant in enchantments)
                                {
                                    if (enchant is NbtCompound compound)
                                    {
                                        itemMetaBuilder.AddEnchantment(compound.GetString("id").ToEnchantType(), compound.GetShort("lvl"));
                                    }
                                }

                                break;
                            }

                            case "STOREDENCHANTMENTS":
                            {
                                var enchantments = (NbtList)child;

                                //Globals.PacketLogger.LogDebug($"List Type: {enchantments.ListType}");

                                foreach (var enchantment in enchantments)
                                {
                                    if (enchantment is NbtCompound compound)
                                    {
                                        compound.TryGetTag("id", out var id);
                                        compound.TryGetTag("lvl", out var lvl);

                                        itemMetaBuilder.AddStoredEnchantment(compound.GetString("id").ToEnchantType(), compound.GetShort("lvl"));
                                    }
                                }
                                break;
                            }

                            case "SLOT":
                            {
                                var byteTag = (NbtTag <byte>)child;

                                itemMetaBuilder.WithSlot(byteTag.Value);
                                //Console.WriteLine($"Setting slot: {itemMetaBuilder.Slot}");
                                break;
                            }

                            case "DAMAGE":
                            {
                                var intTag = (NbtTag <int>)child;

                                itemMetaBuilder.WithDurability(intTag.Value);
                                //Globals.PacketLogger.LogDebug($"Setting damage: {tag.IntValue}");
                                break;
                            }

                            case "DISPLAY":
                            {
                                var display = (NbtCompound)child;

                                foreach (var(displayTagName, displayTag) in display)
                                {
                                    if (displayTagName.EqualsIgnoreCase("name") && displayTag is NbtTag <string> stringTag)
                                    {
                                        itemMetaBuilder.WithName(stringTag.Value);
                                    }
                                    else if (displayTag.Name.EqualsIgnoreCase("lore"))
                                    {
                                        var loreTag = (NbtList)displayTag;

                                        foreach (NbtTag <string> lore in loreTag)
                                        {
                                            itemMetaBuilder.AddLore(lore.Value.FromJson <ChatMessage>());
                                        }
                                    }
                                }
                                break;
                            }
                            }
                        }
                    }

                    slot.ItemMeta = itemMetaBuilder.Build();
                }

                return(slot);
            }

            return(null);
        }