7 files changed, 406 insertions, 5 deletions

diff --git a/src/WorldStorage/FastNBT.h b/src/WorldStorage/FastNBT.h
index 01a9ad274..1b8b09c21 100644
--- a/src/WorldStorage/FastNBT.h
+++ b/src/WorldStorage/FastNBT.h
@@ -309,7 +309,7 @@ protected:
 		eTagType m_ItemType;  // for TAG_List, the element type
 	} ;
 	
-	static const int MAX_STACK = 50;  // Highliy doubtful that an NBT would be constructed this many levels deep
+	static const int MAX_STACK = 50;  // Highly doubtful that an NBT would be constructed this many levels deep
 	
 	// These two fields emulate a stack. A raw array is used due to speed issues - no reallocations are allowed.
 	sParent m_Stack[MAX_STACK];
diff --git a/src/WorldStorage/FireworksSerializer.cpp b/src/WorldStorage/FireworksSerializer.cpp
new file mode 100644
index 000000000..1f05b470d
--- /dev/null
+++ b/src/WorldStorage/FireworksSerializer.cpp
@@ -0,0 +1,252 @@
+
+#include "Globals.h"
+#include "FireworksSerializer.h"
+#include "WorldStorage/FastNBT.h"
+
+
+
+
+
+void cFireworkItem::WriteToNBTCompound(const cFireworkItem & a_FireworkItem, cFastNBTWriter & a_Writer, const ENUM_ITEM_ID a_Type)
+{
+	switch (a_Type)
+	{
+		case E_ITEM_FIREWORK_ROCKET:
+		{
+			a_Writer.BeginCompound("Fireworks");
+			a_Writer.AddByte("Flight", a_FireworkItem.m_FlightTimeInTicks / 20);
+			a_Writer.BeginList("Explosions", TAG_Compound);
+			a_Writer.BeginCompound("");
+			a_Writer.AddByte("Flicker", a_FireworkItem.m_HasFlicker);
+			a_Writer.AddByte("Trail", a_FireworkItem.m_HasTrail);
+			a_Writer.AddByte("Type", a_FireworkItem.m_Type);
+			a_Writer.AddIntArray("Colors", &(a_FireworkItem.m_Colours[0]), a_FireworkItem.m_Colours.size());
+			a_Writer.AddIntArray("FadeColors", &(a_FireworkItem.m_FadeColours[0]), a_FireworkItem.m_FadeColours.size());
+			a_Writer.EndCompound();
+			a_Writer.EndList();
+			a_Writer.EndCompound();
+			break;
+		}
+		case E_ITEM_FIREWORK_STAR:
+		{
+			a_Writer.BeginCompound("Explosion");
+			a_Writer.AddByte("Flicker", a_FireworkItem.m_HasFlicker);
+			a_Writer.AddByte("Trail", a_FireworkItem.m_HasTrail);
+			a_Writer.AddByte("Type", a_FireworkItem.m_Type);
+			if (!a_FireworkItem.m_Colours.empty())
+			{
+				a_Writer.AddIntArray("Colors", &(a_FireworkItem.m_Colours[0]), a_FireworkItem.m_Colours.size());
+			}
+			if (!a_FireworkItem.m_FadeColours.empty())
+			{
+				a_Writer.AddIntArray("FadeColors", &(a_FireworkItem.m_FadeColours[0]), a_FireworkItem.m_FadeColours.size());
+			}
+			a_Writer.EndCompound();
+			break;
+		}
+		default: ASSERT(!"Unhandled firework item!"); break;
+	}
+}
+
+
+
+
+
+void cFireworkItem::ParseFromNBT(cFireworkItem & a_FireworkItem, const cParsedNBT & a_NBT, int a_TagIdx, const ENUM_ITEM_ID a_Type)
+{
+	if (a_TagIdx < 0)
+	{
+		return;
+	}
+
+	switch (a_Type)
+	{
+		case E_ITEM_FIREWORK_STAR:
+		{
+			for (int explosiontag = a_NBT.GetFirstChild(a_TagIdx); explosiontag >= 0; explosiontag = a_NBT.GetNextSibling(explosiontag))
+			{
+				eTagType TagType = a_NBT.GetType(explosiontag);
+				if (TagType == TAG_Byte) // Custon name tag
+				{
+					AString ExplosionName = a_NBT.GetName(explosiontag);
+
+					if (ExplosionName == "Flicker")
+					{
+						a_FireworkItem.m_HasFlicker = (a_NBT.GetByte(explosiontag) == 1);
+					}
+					else if (ExplosionName == "Trail")
+					{
+						a_FireworkItem.m_HasTrail = (a_NBT.GetByte(explosiontag) == 1);
+					}
+					else if (ExplosionName == "Type")
+					{
+						a_FireworkItem.m_Type = a_NBT.GetByte(explosiontag);
+					}
+				}
+				else if (TagType == TAG_IntArray)
+				{
+					AString ExplosionName = a_NBT.GetName(explosiontag);
+
+					if (ExplosionName == "Colors")
+					{
+						// Divide by four as data length returned in bytes
+						int DataLength = a_NBT.GetDataLength(explosiontag) / 4;
+						if (DataLength == 0)
+						{
+							continue;
+						}
+
+						const int * ColourData = (const int *)(a_NBT.GetData(explosiontag));
+						for (int i = 0; i < DataLength; i++)
+						{
+							a_FireworkItem.m_Colours.push_back(ntohl(ColourData[i]));
+						}
+					}
+					else if (ExplosionName == "FadeColors")
+					{
+						int DataLength = a_NBT.GetDataLength(explosiontag) / 4;
+						if (DataLength == 0)
+						{
+							continue;
+						}
+
+						const int * FadeColourData = (const int *)(a_NBT.GetData(explosiontag));
+						for (int i = 0; i < DataLength; i++)
+						{
+							a_FireworkItem.m_FadeColours.push_back(ntohl(FadeColourData[i]));
+						}
+					}
+				}
+			}
+			break;
+		}
+		case E_ITEM_FIREWORK_ROCKET:
+		{
+			for (int fireworkstag = a_NBT.GetFirstChild(a_TagIdx); fireworkstag >= 0; fireworkstag = a_NBT.GetNextSibling(fireworkstag))
+			{
+				eTagType TagType = a_NBT.GetType(fireworkstag);
+				if (TagType == TAG_Byte) // Custon name tag
+				{
+					if (a_NBT.GetName(fireworkstag) == "Flight")
+					{
+						a_FireworkItem.m_FlightTimeInTicks = a_NBT.GetByte(fireworkstag) * 20;
+					}
+				}
+				else if ((TagType == TAG_List) && (a_NBT.GetName(fireworkstag) == "Explosions"))
+				{
+					int ExplosionsChild = a_NBT.GetFirstChild(fireworkstag);
+					if ((a_NBT.GetType(ExplosionsChild) == TAG_Compound) && (a_NBT.GetName(ExplosionsChild).empty()))
+					{
+						ParseFromNBT(a_FireworkItem, a_NBT, ExplosionsChild, E_ITEM_FIREWORK_STAR);
+					}
+				}
+			}
+			break;
+		}
+		default: ASSERT(!"Unhandled firework item!"); break;
+	}
+}
+
+
+
+
+
+AString cFireworkItem::ColoursToString(const cFireworkItem & a_FireworkItem)
+{
+	AString Result;
+
+	for (std::vector<int>::const_iterator itr = a_FireworkItem.m_Colours.begin(); itr != a_FireworkItem.m_Colours.end(); ++itr)
+	{
+		AppendPrintf(Result, "%i;", *itr);
+	}
+
+	return Result;
+}
+
+
+
+
+
+void cFireworkItem::ColoursFromString(const AString & a_String, cFireworkItem & a_FireworkItem)
+{
+	AStringVector Split = StringSplit(a_String, ";");
+
+	for (size_t itr = 0; itr < Split.size(); ++itr)
+	{
+		if (Split[itr].empty())
+		{
+			continue;
+		}
+
+		a_FireworkItem.m_Colours.push_back(atoi(Split[itr].c_str()));
+	}
+}
+
+
+
+
+
+AString cFireworkItem::FadeColoursToString(const cFireworkItem & a_FireworkItem)
+{
+	AString Result;
+
+	for (std::vector<int>::const_iterator itr = a_FireworkItem.m_FadeColours.begin(); itr != a_FireworkItem.m_FadeColours.end(); ++itr)
+	{
+		AppendPrintf(Result, "%i;", *itr);
+	}
+
+	return Result;
+}
+
+
+
+
+
+void cFireworkItem::FadeColoursFromString(const AString & a_String, cFireworkItem & a_FireworkItem)
+{
+	AStringVector Split = StringSplit(a_String, ";");
+
+	for (size_t itr = 0; itr < Split.size(); ++itr)
+	{
+		if (Split[itr].empty())
+		{
+			continue;
+		}
+
+		a_FireworkItem.m_FadeColours.push_back(atoi(Split[itr].c_str()));
+	}
+}
+
+
+
+
+
+int cFireworkItem::GetVanillaColourCodeFromDye(short a_DyeMeta)
+{
+	/*
+	Colours are supposed to be calculated via: R << 16 + G << 8 + B
+	However, the RGB values fireworks use aren't the same as the ones for dyes (the ones listed in the MC Wiki)
+	Therefore, here is a list of numbers gotten via the Protocol Proxy
+	*/
+
+	switch (a_DyeMeta)
+	{
+		case E_META_DYE_BLACK: return 0x1E1B1B;
+		case E_META_DYE_RED: return 0xB3312C;
+		case E_META_DYE_GREEN: return 0x3B511A;
+		case E_META_DYE_BROWN:  return 0x51301A;
+		case E_META_DYE_BLUE: return 0x253192;
+		case E_META_DYE_PURPLE: return 0x7B2FBE;
+		case E_META_DYE_CYAN: return 0x287697;
+		case E_META_DYE_LIGHTGRAY: return 0xABABAB;
+		case E_META_DYE_GRAY: return 0x434343;
+		case E_META_DYE_PINK: return 0xD88198;
+		case E_META_DYE_LIGHTGREEN: return 0x41CD34;
+		case E_META_DYE_YELLOW: return 0xDECF2A;
+		case E_META_DYE_LIGHTBLUE: return 0x6689D3;
+		case E_META_DYE_MAGENTA: return 0xC354CD;
+		case E_META_DYE_ORANGE: return 0xEB8844;
+		case E_META_DYE_WHITE: return 0xF0F0F0;
+		default: ASSERT(!"Unhandled dye meta whilst trying to get colour code for fireworks!"); return 0;
+	}
+}
diff --git a/src/WorldStorage/FireworksSerializer.h b/src/WorldStorage/FireworksSerializer.h
new file mode 100644
index 000000000..5b87bafdb
--- /dev/null
+++ b/src/WorldStorage/FireworksSerializer.h
@@ -0,0 +1,92 @@
+
+// FireworksSerializer.h
+
+// Declares the cFireworkItem class representing a firework or firework star
+
+
+
+
+
+#pragma once
+
+#include "Defines.h"
+
+class cFastNBTWriter;
+class cParsedNBT;
+
+
+
+
+
+class cFireworkItem
+{
+public:
+	cFireworkItem(void) :
+		m_HasFlicker(false),
+		m_HasTrail(false),
+		m_Type(0),
+		m_FlightTimeInTicks(0)
+	{
+	}
+
+	inline void CopyFrom(const cFireworkItem & a_Item)
+	{
+		m_FlightTimeInTicks = a_Item.m_FlightTimeInTicks;
+		m_HasFlicker = a_Item.m_HasFlicker;
+		m_HasTrail = a_Item.m_HasTrail;
+		m_Type = a_Item.m_Type;
+		m_Colours = a_Item.m_Colours;
+		m_FadeColours = a_Item.m_FadeColours;
+	}
+
+	inline void EmptyData(void)
+	{
+		m_FlightTimeInTicks = 0;
+		m_HasFlicker = false;
+		m_Type = 0;
+		m_HasTrail = false;
+		m_Colours.clear();
+		m_FadeColours.clear();
+	}
+
+	inline bool IsEqualTo(const cFireworkItem & a_Item) const
+	{
+		return
+			(
+			(m_FlightTimeInTicks == a_Item.m_FlightTimeInTicks) &&
+			(m_HasFlicker == a_Item.m_HasFlicker) &&
+			(m_HasTrail == a_Item.m_HasTrail) &&
+			(m_Type == a_Item.m_Type) &&
+			(m_Colours == a_Item.m_Colours) &&
+			(m_FadeColours == a_Item.m_FadeColours)
+			);
+	}
+
+	/** Writes firework NBT data to a Writer object */
+	static void WriteToNBTCompound(const cFireworkItem & a_FireworkItem, cFastNBTWriter & a_Writer, const ENUM_ITEM_ID a_Type);
+
+	/** Reads NBT data from a NBT object and populates a FireworkItem with it */
+	static void ParseFromNBT(cFireworkItem & a_FireworkItem, const cParsedNBT & a_NBT, int a_TagIdx, const ENUM_ITEM_ID a_Type);
+
+	/** Converts the firework's vector of colours into a string of values separated by a semicolon */
+	static AString ColoursToString(const cFireworkItem & a_FireworkItem);
+
+	/** Parses a string containing encoded firework colours and populates a FireworkItem with it */
+	static void ColoursFromString(const AString & a_String, cFireworkItem & a_FireworkItem);
+
+	/** Converts the firework's vector of fade colours into a string of values separated by a semicolon */
+	static AString FadeColoursToString(const cFireworkItem & a_FireworkItem);
+
+	/** Parses a string containing encoded firework fade colours and populates a FireworkItem with it */
+	static void FadeColoursFromString(const AString & a_String, cFireworkItem & a_FireworkItem);
+
+	/** Returns a colour code for fireworks used by the network code */
+	static int GetVanillaColourCodeFromDye(short a_DyeMeta);
+
+	bool m_HasFlicker;
+	bool m_HasTrail;
+	NIBBLETYPE m_Type;
+	short m_FlightTimeInTicks;
+	std::vector<int> m_Colours;
+	std::vector<int> m_FadeColours;
+};
\ No newline at end of file
diff --git a/src/WorldStorage/NBTChunkSerializer.cpp b/src/WorldStorage/NBTChunkSerializer.cpp
index 6d0e29958..4cf3c62d7 100644
--- a/src/WorldStorage/NBTChunkSerializer.cpp
+++ b/src/WorldStorage/NBTChunkSerializer.cpp
@@ -28,6 +28,7 @@
 #include "../Entities/Minecart.h"
 #include "../Entities/Pickup.h"
 #include "../Entities/ProjectileEntity.h"
+#include "../Entities/TNTEntity.h"
 
 #include "../Mobs/Monster.h"
 #include "../Mobs/Bat.h"
@@ -91,11 +92,19 @@ void cNBTChunkSerializer::AddItem(const cItem & a_Item, int a_Slot, const AStrin
 	}
 	
 	// Write the enchantments:
-	if (!a_Item.m_Enchantments.IsEmpty())
+	if (!a_Item.m_Enchantments.IsEmpty() || ((a_Item.m_ItemType == E_ITEM_FIREWORK_ROCKET) || (a_Item.m_ItemType == E_ITEM_FIREWORK_STAR)))
 	{
-		const char * TagName = (a_Item.m_ItemType == E_ITEM_BOOK) ? "StoredEnchantments" : "ench";
 		m_Writer.BeginCompound("tag");
-			EnchantmentSerializer::WriteToNBTCompound(a_Item.m_Enchantments, m_Writer, TagName);
+			if ((a_Item.m_ItemType == E_ITEM_FIREWORK_ROCKET) || (a_Item.m_ItemType == E_ITEM_FIREWORK_STAR))
+			{
+				cFireworkItem::WriteToNBTCompound(a_Item.m_FireworkItem, m_Writer, (ENUM_ITEM_ID)a_Item.m_ItemType);
+			}
+			
+			if (!a_Item.m_Enchantments.IsEmpty())
+			{
+				const char * TagName = (a_Item.m_ItemType == E_ITEM_BOOK) ? "StoredEnchantments" : "ench";
+				EnchantmentSerializer::WriteToNBTCompound(a_Item.m_Enchantments, m_Writer, TagName);
+			}
 		m_Writer.EndCompound();
 	}
 	
@@ -583,6 +592,18 @@ void cNBTChunkSerializer::AddProjectileEntity(cProjectileEntity * a_Projectile)
 
 
 
+void cNBTChunkSerializer::AddTNTEntity(cTNTEntity * a_TNT)
+{
+	m_Writer.BeginCompound("");
+		AddBasicEntity(a_TNT, "PrimedTnt");
+		m_Writer.AddByte("Fuse", (unsigned char)a_TNT->GetFuseTicks());
+	m_Writer.EndCompound();
+}
+
+
+
+
+
 void cNBTChunkSerializer::AddMinecartChestContents(cMinecartWithChest * a_Minecart)
 {
 	m_Writer.BeginList("Items", TAG_Compound);
@@ -662,7 +683,7 @@ void cNBTChunkSerializer::Entity(cEntity * a_Entity)
 		case cEntity::etMonster:      AddMonsterEntity     ((cMonster *)         a_Entity); break;
 		case cEntity::etPickup:       AddPickupEntity      ((cPickup *)          a_Entity); break;
 		case cEntity::etProjectile:   AddProjectileEntity  ((cProjectileEntity *)a_Entity); break;
-		case cEntity::etTNT: /* TODO */ break;
+		case cEntity::etTNT:          AddTNTEntity         ((cTNTEntity *)       a_Entity); break;
 		case cEntity::etExpOrb: /* TODO */ break;
 		case cEntity::etItemFrame: /* TODO */ break;
 		case cEntity::etPainting: /* TODO */ break;
diff --git a/src/WorldStorage/NBTChunkSerializer.h b/src/WorldStorage/NBTChunkSerializer.h
index 8a9e18413..3b486d2bc 100644
--- a/src/WorldStorage/NBTChunkSerializer.h
+++ b/src/WorldStorage/NBTChunkSerializer.h
@@ -41,6 +41,7 @@ class cMonster;
 class cPickup;
 class cItemGrid;
 class cProjectileEntity;
+class cTNTEntity;
 
 
 
@@ -107,6 +108,7 @@ protected:
 	void AddMonsterEntity     (cMonster * a_Monster);
 	void AddPickupEntity      (cPickup * a_Pickup);
 	void AddProjectileEntity  (cProjectileEntity * a_Projectile);
+	void AddTNTEntity         (cTNTEntity * a_TNT);
 	
 	void AddMinecartChestContents(cMinecartWithChest * a_Minecart);
 	
diff --git a/src/WorldStorage/WSSAnvil.cpp b/src/WorldStorage/WSSAnvil.cpp
index 680f2458f..eb159f28d 100644
--- a/src/WorldStorage/WSSAnvil.cpp
+++ b/src/WorldStorage/WSSAnvil.cpp
@@ -36,6 +36,7 @@
 #include "../Entities/Minecart.h"
 #include "../Entities/Pickup.h"
 #include "../Entities/ProjectileEntity.h"
+#include "../Entities/TNTEntity.h"
 
 
 
@@ -663,6 +664,12 @@ bool cWSSAnvil::LoadItemFromNBT(cItem & a_Item, const cParsedNBT & a_NBT, int a_
 	{
 		EnchantmentSerializer::ParseFromNBT(a_Item.m_Enchantments, a_NBT, EnchTag);
 	}
+
+	int FireworksTag = a_NBT.FindChildByName(TagTag, ((a_Item.m_ItemType == E_ITEM_FIREWORK_STAR) ? "Fireworks" : "Explosion"));
+	if (EnchTag > 0)
+	{
+		cFireworkItem::ParseFromNBT(a_Item.m_FireworkItem, a_NBT, FireworksTag, (ENUM_ITEM_ID)a_Item.m_ItemType);
+	}
 	
 	return true;
 }
@@ -1231,6 +1238,10 @@ void cWSSAnvil::LoadEntityFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		LoadPigZombieFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
 	}
+	else if (strncmp(a_IDTag, "PrimedTnt", a_IDTagLength) == 0)
+	{
+		LoadTNTFromNBT(a_Entities, a_NBT, a_EntityTagIdx);
+	}
 	// TODO: other entities
 }
 
@@ -2167,6 +2178,28 @@ void cWSSAnvil::LoadPigZombieFromNBT(cEntityList & a_Entities, const cParsedNBT
 
 
 
+void cWSSAnvil::LoadTNTFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
+{
+	std::auto_ptr<cTNTEntity> TNT(new cTNTEntity(0.0, 0.0, 0.0, 0));
+	if (!LoadEntityBaseFromNBT(*TNT.get(), a_NBT, a_TagIdx))
+	{
+		return;
+	}
+	
+	// Load Fuse Ticks:
+	int FuseTicks = a_NBT.FindChildByName(a_TagIdx, "Fuse");
+	if (FuseTicks > 0)
+	{
+		TNT->SetFuseTicks((int) a_NBT.GetByte(FuseTicks));
+	}
+	
+	a_Entities.push_back(TNT.release());
+}
+
+
+
+
+
 bool cWSSAnvil::LoadEntityBaseFromNBT(cEntity & a_Entity, const cParsedNBT & a_NBT, int a_TagIdx)
 {
 	double Pos[3];
diff --git a/src/WorldStorage/WSSAnvil.h b/src/WorldStorage/WSSAnvil.h
index b26345b13..fe93d16c3 100644
--- a/src/WorldStorage/WSSAnvil.h
+++ b/src/WorldStorage/WSSAnvil.h
@@ -192,6 +192,7 @@ protected:
 	void LoadWolfFromNBT            (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadZombieFromNBT          (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadPigZombieFromNBT       (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadTNTFromNBT             (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	
 	/// Loads entity common data from the NBT compound; returns true if successful
 	bool LoadEntityBaseFromNBT(cEntity & a_Entity, const cParsedNBT & a_NBT, int a_TagIdx);