public override void SetCompound(NbtCompound compound)
 {
     Line1 = GetTextValue(compound, "Text1");
     Line2 = GetTextValue(compound, "Text2");
     Line3 = GetTextValue(compound, "Text3");
     Line4 = GetTextValue(compound, "Text4");
 }

 public UpdateTileEntityPacket(Vector3 position, TileEntityAction action, NbtCompound data)
 {
     Data = new NbtFile();
     Data.RootTag = data;
     Position = position;
     Action = action;
 }

        public void ErrorTest()
        {
            var root = new NbtCompound("root");
            byte[] testData = new NbtFile(root).SaveToBuffer(NbtCompression.None);

            // creating NbtReader without a stream, or with a non-readable stream
            Assert.Throws<ArgumentNullException>(() => new NbtReader(null));
            Assert.Throws<ArgumentException>(() => new NbtReader(new NonReadableStream()));

            // corrupt the data
            testData[0] = 123;
            var reader = new NbtReader(new MemoryStream(testData));

            // attempt to use ReadValue when not at value
            Assert.Throws<InvalidOperationException>(() => reader.ReadValue());
            reader.CacheTagValues = true;
            Assert.Throws<InvalidOperationException>(() => reader.ReadValue());

            // attempt to read a corrupt stream
            Assert.Throws<NbtFormatException>(() => reader.ReadToFollowing());

            // make sure we've properly entered the error state
            Assert.IsTrue(reader.IsInErrorState);
            Assert.IsFalse(reader.HasName);
            Assert.Throws<InvalidReaderStateException>(() => reader.ReadToFollowing());
            Assert.Throws<InvalidReaderStateException>(() => reader.ReadListAsArray<int>());
            Assert.Throws<InvalidReaderStateException>(() => reader.ReadToNextSibling());
            Assert.Throws<InvalidReaderStateException>(() => reader.ReadToDescendant("derp"));
            Assert.Throws<InvalidReaderStateException>(() => reader.ReadAsTag());
            Assert.Throws<InvalidReaderStateException>(() => reader.Skip());
        }

 public override NbtCompound ToNBT()
 {
     NbtCompound c = new NbtCompound();
     Base2NBT(ref c);
     c.Tags.Add(Inventory.ToNBT());
     return c;
 }

 public static McEntity LoadEntity(NbtCompound entity)
 {
     if (entity["id"] != null && entity["id"] is NbtString)
     {
         switch (((NbtString) entity["id"]).Value.ToLower())
         {
             case "mob":
                 McEntityMob mob = new McEntityMob();
                 mob.LoadEntity(entity);
                 return mob;
             case "item":
                 McEntityItem item = new McEntityItem();
                 item.LoadEntity(entity);
                 return item;
             case "localplayer":
                 McEntityLocalPlayer player = new McEntityLocalPlayer();
                 player.LoadEntity(entity);
                 return player;
             default:
                 Console.WriteLine("Unknown Entity: {0}", ((NbtString) entity["id"]).Value);
                 break;
         }
     }
     return null;
 }

        public FurnaceBlockEntity()
            : base("Furnace")
        {
            UpdatesOnTick = true;

            Compound = new NbtCompound(string.Empty)
            {
                new NbtString("id", Id),
                new NbtList("Items", new NbtCompound()),
                new NbtInt("x", Coordinates.X),
                new NbtInt("y", Coordinates.Y),
                new NbtInt("z", Coordinates.Z)
            };

            NbtList items = (NbtList) Compound["Items"];
            for (byte i = 0; i < 3; i++)
            {
                items.Add(new NbtCompound()
                {
                    new NbtByte("Count", 0),
                    new NbtByte("Slot", i),
                    new NbtShort("id", 0),
                    new NbtByte("Damage", 0),
                });
            }
        }

 public void SkippingLists()
 {
     {
         var file = new NbtFile(TestFiles.MakeListTest());
         byte[] savedFile = file.SaveToBuffer(NbtCompression.None);
         file.LoadFromBuffer(savedFile, 0, savedFile.Length, NbtCompression.None,
                             tag => tag.TagType != NbtTagType.List);
         Assert.AreEqual(0, file.RootTag.Count);
     }
     {
         // Check list-compound interaction
         NbtCompound comp = new NbtCompound("root") {
             new NbtCompound("compOfLists") {
                 new NbtList("listOfComps") {
                     new NbtCompound {
                         new NbtList("emptyList", NbtTagType.Compound)
                     }
                 }
             }
         };
         var file = new NbtFile(comp);
         byte[] savedFile = file.SaveToBuffer(NbtCompression.None);
         file.LoadFromBuffer(savedFile, 0, savedFile.Length, NbtCompression.None,
                             tag => tag.TagType != NbtTagType.List);
         Assert.AreEqual(1, file.RootTag.Count);
     }
 }

 public override void SetCompound(NbtCompound compound)
 {
     Text1 = GetTextValue(compound, "Text1");
     Text2 = GetTextValue(compound, "Text2");
     Text3 = GetTextValue(compound, "Text3");
     Text4 = GetTextValue(compound, "Text4");
 }

 public override NbtCompound ToNBT()
 {
     NbtCompound c = new NbtCompound();
     Base2NBT(ref c,GetID());
     c.Tags.Add(new NbtByte("Tile", Tile));
     return c;
 }

        public void AddingAndRemoving()
        {
            NbtCompound test = new NbtCompound();

            NbtInt foo =  new NbtInt( "Foo" );

            test.Add( foo );

            // adding duplicate object
            Assert.Throws<ArgumentException>( () => test.Add( foo ) );

            // adding duplicate name
            Assert.Throws<ArgumentException>( () => test.Add( new NbtByte( "Foo" ) ) );

            // adding unnamed tag
            Assert.Throws<ArgumentException>( () => test.Add( new NbtInt() ) );

            // adding null
            Assert.Throws<ArgumentNullException>( () => test.Add( null ) );

            // contains existing name
            Assert.IsTrue( test.Contains( "Foo" ) );

            // contains existing object
            Assert.IsTrue( test.Contains( foo ) );

            // contains non-existent name
            Assert.IsFalse( test.Contains( "Bar" ) );

            // contains existing name / different object
            Assert.IsFalse( test.Contains( new NbtInt( "Foo" ) ) );

            // removing non-existent name
            Assert.IsFalse( test.Remove( "Bar" ) );

            // removing existing name
            Assert.IsTrue( test.Remove( "Foo" ) );

            // removing non-existent name
            Assert.IsFalse( test.Remove( "Foo" ) );

            // re-adding object
            test.Add( foo );

            // removing existing object
            Assert.IsTrue( test.Remove( foo ) );

            // clearing an empty NbtCompound
            Assert.AreEqual( test.Count, 0 );
            test.Clear();

            // re-adding after clearing
            test.Add( foo );
            Assert.AreEqual( test.Count, 1 );

            // clearing a non-empty NbtCompound
            test.Clear();
            Assert.AreEqual( test.Count, 0 );
        }

 public NbtCompound ToNBT()
 {
     NbtCompound c = new NbtCompound();
     Base2NBT(ref c,GetID());
     c.Tags.Add(new NbtByte("Tile", Tile));
     c.Tags.Add(new NbtByte("OnGround", OnGround));
     return c;
 }

 public LivingEntity(NbtCompound c)
 {
     SetBaseStuff(c);
     Health = (c["Health"] as NbtShort).Value;
     HurtTime = (c["HurtTime"] as NbtShort).Value;
     AttackTime = (c["AttackTime"] as NbtShort).Value;
     DeathTime = (c["DeathTime"] as NbtShort).Value;
 }

 public override NbtCompound ToNBT()
 {
     NbtCompound c = new NbtCompound();
     Base2NBT(ref c);
     c.Tags.Add(new NbtString("EntityId", EntityId));
     c.Tags.Add(new NbtShort("Delay", Delay));
     return c;
 }

        public NbtCompound Read(NbtCompound metadata) {
            Tags = new NbtTag[metadata.Tags.Count()];
            metadata.CopyTo(Tags, 0);

            foreach (NbtTag b in Tags) 
                metadata.Remove(b);

            return metadata;
        }

 /// <summary>
 /// Load a TileEntity's basic values (call via base() in all inheriting files)
 /// </summary>
 /// <param name="CX">Chunk X Coordinate</param>
 /// <param name="CY">Chunk Y Coordinate</param>
 /// <param name="CS">Chunk horizontal scale</param>
 /// <param name="c">TileEntity's NbtCompound.</param>
 public TileEntity(int CX,int CY,int CS,NbtCompound c)
 {
     Pos = new Vector3i(
         c.Get<NbtInt>("x").Value,
         c.Get<NbtInt>("y").Value,
         c.Get<NbtInt>("z").Value);
     ID = (c["id"] as NbtString).Value;
     orig = c;
 }

 /// <summary>
 /// Load a TileEntity's basic values (call via base() in all inheriting files)
 /// </summary>
 /// <param name="c"></param>
 public TileEntity(NbtCompound c)
 {
     orig = c;
     Pos = new Vector3i(
         c.Get<NbtInt>("x").Value,
         c.Get<NbtInt>("z").Value,
         c.Get<NbtInt>("y").Value);
     id = c.Get<NbtString>("id").Value;
 }

 public NbtCompound Write()
 {
     var Base = new NbtCompound("MCForge")
     {
         new NbtByte("perbuild", perbuild),
         new NbtByte("pervisit", pervisit)
     };
     return Base;
 }

        public void Save()
        {
            //Create nbt file
            var file = new NbtFile();
            var data = new NbtCompound() {Name = "Data"};

           
            file.RootTag.Add(data);
        }

 public override NbtCompound ToNBT()
 {
     NbtCompound c = new NbtCompound();
     Base2NBT(ref c,GetID());
     c.Tags.Add(new NbtShort("Health", Health));
     c.Tags.Add(new NbtShort("HurtTime", HurtTime));
     c.Tags.Add(new NbtShort("AttackTime", AttackTime));
     c.Tags.Add(new NbtShort("DeathTime", DeathTime));
     return c;
 }

 public Area(NbtCompound cmpd)
 {
     name = cmpd.Get<NbtString>("name").Value;
     NbtList ground = cmpd.Get<NbtList>("ground");
     foreach(NbtCompound alpha in ground) {
         int x = alpha.Get<NbtByte>("x").Value;
         int y = alpha.Get<NbtByte>("y").Value;
         platformMap.Add(new Point(x, y));
     }
     Map.portalsToProcess[this] = cmpd.Get<NbtList>("portal").ToArray<NbtCompound>().ToList<NbtCompound>();
 }