5 files changed, 515 insertions, 167 deletions

diff --git a/src/UI/SlotArea.cpp b/src/UI/SlotArea.cpp
index b5f84c24c..999bed989 100644
--- a/src/UI/SlotArea.cpp
+++ b/src/UI/SlotArea.cpp
@@ -5,10 +5,12 @@
 #include "Globals.h"
 #include "SlotArea.h"
 #include "../Entities/Player.h"
+#include "../BlockEntities/BeaconEntity.h"
 #include "../BlockEntities/ChestEntity.h"
 #include "../BlockEntities/DropSpenserEntity.h"
 #include "../BlockEntities/EnderChestEntity.h"
 #include "../BlockEntities/FurnaceEntity.h"
+#include "../Entities/Minecart.h"
 #include "../Items/ItemHandler.h"
 #include "Window.h"
 #include "../CraftingRecipes.h"
@@ -206,7 +208,7 @@ void cSlotArea::ShiftClicked(cPlayer & a_Player, int a_SlotNum, const cItem & a_
 	m_ParentWindow.DistributeStack(Slot, a_Player, this, true);
 	if (Slot.IsEmpty())
 	{
-		// Empty the slot completely, the cilent doesn't like left-over ItemType with zero count
+		// Empty the slot completely, the client doesn't like left-over ItemType with zero count
 		Slot.Empty();
 	}
 	SetSlot(a_SlotNum, a_Player, Slot);
@@ -1190,21 +1192,48 @@ void cSlotAreaAnvil::UpdateResult(cPlayer & a_Player)
 
 
 
-
 ////////////////////////////////////////////////////////////////////////////////
-// cSlotAreaEnchanting:
+// cSlotAreaBeacon:
 
-cSlotAreaEnchanting::cSlotAreaEnchanting(cEnchantingWindow & a_ParentWindow) :
-	cSlotAreaTemporary(1, a_ParentWindow)
+cSlotAreaBeacon::cSlotAreaBeacon(cBeaconEntity * a_Beacon, cWindow & a_ParentWindow) :
+	cSlotArea(1, a_ParentWindow),
+	m_Beacon(a_Beacon)
 {
-	a_ParentWindow.m_SlotArea = this;
+	m_Beacon->GetContents().AddListener(*this);
 }
 
 
 
 
 
-void cSlotAreaEnchanting::Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction, const cItem & a_ClickedItem)
+cSlotAreaBeacon::~cSlotAreaBeacon()
+{
+	m_Beacon->GetContents().RemoveListener(*this);
+}
+
+
+
+
+bool cSlotAreaBeacon::IsPlaceableItem(short a_ItemType)
+{
+	switch (a_ItemType)
+	{
+		case E_ITEM_EMERALD:
+		case E_ITEM_DIAMOND:
+		case E_ITEM_GOLD:
+		case E_ITEM_IRON:
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+
+void cSlotAreaBeacon::Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction, const cItem & a_ClickedItem)
 {
 	ASSERT((a_SlotNum >= 0) && (a_SlotNum < GetNumSlots()));
 
@@ -1214,7 +1243,7 @@ void cSlotAreaEnchanting::Clicked(cPlayer & a_Player, int a_SlotNum, eClickActio
 		LOGWARNING("GetSlot(%d) returned NULL! Ignoring click", a_SlotNum);
 		return;
 	}
-	
+
 	switch (a_ClickAction)
 	{
 		case caShiftLeftClick:
@@ -1223,14 +1252,28 @@ void cSlotAreaEnchanting::Clicked(cPlayer & a_Player, int a_SlotNum, eClickActio
 			ShiftClicked(a_Player, a_SlotNum, a_ClickedItem);
 			return;
 		}
-		case caDblClick:
+		case caMiddleClick:
 		{
-			DblClicked(a_Player, a_SlotNum);
+			MiddleClicked(a_Player, a_SlotNum);
 			return;
 		}
-		case caMiddleClick:
+		case caDropKey:
+		case caCtrlDropKey:
 		{
-			MiddleClicked(a_Player, a_SlotNum);
+			DropClicked(a_Player, a_SlotNum, false);
+			return;
+		}
+		case caNumber1:
+		case caNumber2:
+		case caNumber3:
+		case caNumber4:
+		case caNumber5:
+		case caNumber6:
+		case caNumber7:
+		case caNumber8:
+		case caNumber9:
+		{
+			NumberClicked(a_Player, a_SlotNum, a_ClickAction);
 			return;
 		}
 		default:
@@ -1238,7 +1281,7 @@ void cSlotAreaEnchanting::Clicked(cPlayer & a_Player, int a_SlotNum, eClickActio
 			break;
 		}
 	}
-	
+
 	cItem Slot(*GetSlot(a_SlotNum, a_Player));
 	if (!Slot.IsSameType(a_ClickedItem))
 	{
@@ -1248,106 +1291,211 @@ void cSlotAreaEnchanting::Clicked(cPlayer & a_Player, int a_SlotNum, eClickActio
 		bAsync = true;
 	}
 	cItem & DraggingItem = a_Player.GetDraggingItem();
-	switch (a_ClickAction)
+
+	if (DraggingItem.IsEmpty())
 	{
-		case caRightClick:
+		DraggingItem = Slot;
+		Slot.Empty();
+	}
+	else if (Slot.IsEmpty())
+	{
+		if (!IsPlaceableItem(DraggingItem.m_ItemType))
 		{
-			// Right-clicked
-			if (DraggingItem.IsEmpty())
-			{
-				DraggingItem = Slot.CopyOne();
-				Slot.Empty();
-				break;
-			}
-			
-			if (Slot.IsEmpty())
-			{
-				Slot = DraggingItem.CopyOne();
-				DraggingItem.m_ItemCount -= 1;
-				if (DraggingItem.m_ItemCount <= 0)
-				{
-					DraggingItem.Empty();
-				}
-			}
-			else if ((!DraggingItem.IsEqual(Slot)) && (DraggingItem.m_ItemCount == 1))
-			{
-				// Swap contents
-				cItem tmp(DraggingItem);
-				DraggingItem = Slot;
-				Slot = tmp;
-			}
-			break;
+			return;
 		}
 		
-		case caLeftClick:
+		Slot = DraggingItem.CopyOne();
+		DraggingItem.m_ItemCount -= 1;
+		if (DraggingItem.m_ItemCount <= 0)
 		{
-			// Left-clicked
-			if (DraggingItem.IsEmpty())
-			{
-				DraggingItem = Slot.CopyOne();
-				Slot.Empty();
-				break;
-			}
-			
-			if (DraggingItem.IsEqual(Slot))
-			{
-				// Do nothing
-				break;
-			}
-			
-			if (!Slot.IsEmpty())
-			{
-				if (DraggingItem.m_ItemCount == 1)
-				{
-					// Swap contents
-					cItem tmp(DraggingItem);
-					DraggingItem = Slot;
-					Slot = tmp;
-				}
-			}
-			else
-			{
-				Slot = DraggingItem.CopyOne();
-				DraggingItem.m_ItemCount -= 1;
-				if (DraggingItem.m_ItemCount <= 0)
-				{
-					DraggingItem.Empty();
-				}
-			}
-			break;
+			DraggingItem.Empty();
 		}
-		default:
+	}
+	else if (DraggingItem.m_ItemCount == 1)
+	{
+		if (!IsPlaceableItem(DraggingItem.m_ItemCount))
 		{
-			LOGWARNING("SlotArea: Unhandled click action: %d (%s)", a_ClickAction, ClickActionToString(a_ClickAction));
-			m_ParentWindow.BroadcastWholeWindow();
 			return;
 		}
-	}  // switch (a_ClickAction
-	
+
+		// Switch contents
+		cItem tmp(DraggingItem);
+		DraggingItem = Slot;
+		Slot = tmp;
+	}
+
 	SetSlot(a_SlotNum, a_Player, Slot);
 	if (bAsync)
 	{
 		m_ParentWindow.BroadcastWholeWindow();
 	}
-	UpdateResult(a_Player);
 }
 
 
 
 
 
-void cSlotAreaEnchanting::DblClicked(cPlayer & a_Player, int a_SlotNum)
+void cSlotAreaBeacon::DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_ShouldApply, bool a_KeepEmptySlots)
 {
-	cItem & Dragging = a_Player.GetDraggingItem();
-	if ((!Dragging.IsEmpty()) || (a_SlotNum != 0))
+	const cItem * Slot = GetSlot(0, a_Player);
+	if (!Slot->IsEmpty() || !IsPlaceableItem(a_ItemStack.m_ItemType) || (a_ItemStack.m_ItemCount != 1))
+	{
+		return;
+	}
+
+	if (a_ShouldApply)
+	{
+		SetSlot(0, a_Player, a_ItemStack.CopyOne());
+	}
+	a_ItemStack.Empty();
+}
+
+
+
+
+
+const cItem * cSlotAreaBeacon::GetSlot(int a_SlotNum, cPlayer & a_Player) const
+{
+	UNUSED(a_Player);
+	return &(m_Beacon->GetSlot(a_SlotNum));
+}
+
+
+
+
+
+void cSlotAreaBeacon::SetSlot(int a_SlotNum, cPlayer & a_Player, const cItem & a_Item)
+{
+	UNUSED(a_Player);
+	m_Beacon->SetSlot(a_SlotNum, a_Item);
+}
+
+
+
+
+
+void cSlotAreaBeacon::OnSlotChanged(cItemGrid * a_ItemGrid, int a_SlotNum)
+{
+	UNUSED(a_SlotNum);
+	// Something has changed in the window, broadcast the entire window to all clients
+	ASSERT(a_ItemGrid == &(m_Beacon->GetContents()));
+
+	m_ParentWindow.BroadcastWholeWindow();
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cSlotAreaEnchanting:
+
+cSlotAreaEnchanting::cSlotAreaEnchanting(cEnchantingWindow & a_ParentWindow, int a_BlockX, int a_BlockY, int a_BlockZ) :
+	cSlotAreaTemporary(1, a_ParentWindow),
+	m_BlockX(a_BlockX),
+	m_BlockY(a_BlockY),
+	m_BlockZ(a_BlockZ)
+{
+	a_ParentWindow.m_SlotArea = this;
+}
+
+
+
+
+
+void cSlotAreaEnchanting::Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction, const cItem & a_ClickedItem)
+{
+	ASSERT((a_SlotNum >= 0) && (a_SlotNum < GetNumSlots()));
+
+	bool bAsync = false;
+	if (GetSlot(a_SlotNum, a_Player) == NULL)
 	{
+		LOGWARNING("GetSlot(%d) returned NULL! Ignoring click", a_SlotNum);
 		return;
 	}
+
+	switch (a_ClickAction)
+	{
+		case caShiftLeftClick:
+		case caShiftRightClick:
+		{
+			ShiftClicked(a_Player, a_SlotNum, a_ClickedItem);
+			return;
+		}
+		case caDblClick:
+		{
+			DblClicked(a_Player, a_SlotNum);
+			return;
+		}
+		case caMiddleClick:
+		{
+			MiddleClicked(a_Player, a_SlotNum);
+			return;
+		}
+		case caDropKey:
+		case caCtrlDropKey:
+		{
+			DropClicked(a_Player, a_SlotNum, false);
+			return;
+		}
+		case caNumber1:
+		case caNumber2:
+		case caNumber3:
+		case caNumber4:
+		case caNumber5:
+		case caNumber6:
+		case caNumber7:
+		case caNumber8:
+		case caNumber9:
+		{
+			NumberClicked(a_Player, a_SlotNum, a_ClickAction);
+			return;
+		}
+		default:
+		{
+			break;
+		}
+	}
 	
-	cItem Item = *GetSlot(0, a_Player);
-	if (!m_ParentWindow.CollectItemsToHand(Item, *this, a_Player, false))
+	cItem Slot(*GetSlot(a_SlotNum, a_Player));
+	if (!Slot.IsSameType(a_ClickedItem))
+	{
+		LOGWARNING("*** Window lost sync at item %d in SlotArea with %d items ***", a_SlotNum, m_NumSlots);
+		LOGWARNING("My item:    %s", ItemToFullString(Slot).c_str());
+		LOGWARNING("Their item: %s", ItemToFullString(a_ClickedItem).c_str());
+		bAsync = true;
+	}
+	cItem & DraggingItem = a_Player.GetDraggingItem();
+
+	if (DraggingItem.IsEmpty())
+	{
+		// DraggingItem is empty -> Switch draggingitem and slot
+		if (!Slot.IsEmpty())
+		{
+			std::swap(DraggingItem, Slot);
+		}
+	}
+	else if (Slot.IsEmpty())
+	{
+		// DraggingItem isn't empty and slot is empty -> Set one dragging item in the slot
+		Slot = DraggingItem.CopyOne();
+		DraggingItem.m_ItemCount -= 1;
+
+		if (DraggingItem.m_ItemCount <= 0)
+		{
+			DraggingItem.Empty();
+		}
+	}
+	else if ((DraggingItem.m_ItemCount == 1) && !DraggingItem.IsEqual(Slot))
+	{
+		// DraggingItem and slot aren't empty -> Switch items
+		std::swap(DraggingItem, Slot);
+	}
+
+	SetSlot(a_SlotNum, a_Player, Slot);
+	if (bAsync)
 	{
-		m_ParentWindow.CollectItemsToHand(Item, *this, a_Player, true);
+		m_ParentWindow.BroadcastWholeWindow();
 	}
 }
 
@@ -1372,7 +1520,15 @@ void cSlotAreaEnchanting::DistributeStack(cItem & a_ItemStack, cPlayer & a_Playe
 	{
 		a_ItemStack.Empty();
 	}
+}
+
 
+
+
+
+void cSlotAreaEnchanting::OnPlayerAdded(cPlayer & a_Player)
+{
+	super::OnPlayerAdded(a_Player);
 	UpdateResult(a_Player);
 }
 
@@ -1392,29 +1548,33 @@ void cSlotAreaEnchanting::OnPlayerRemoved(cPlayer & a_Player)
 
 
 
+void cSlotAreaEnchanting::SetSlot(int a_SlotNum, cPlayer & a_Player, const cItem & a_Item)
+{
+	super::SetSlot(a_SlotNum, a_Player, a_Item);
+	UpdateResult(a_Player);
+}
+
+
+
+
+
 void cSlotAreaEnchanting::UpdateResult(cPlayer & a_Player)
 {
 	cItem Item = *GetSlot(0, a_Player);
 
-	if (Item.IsEmpty() || !Item.m_Enchantments.IsEmpty())
-	{
-		m_ParentWindow.SetProperty(0, 0, a_Player);
-		m_ParentWindow.SetProperty(1, 0, a_Player);
-		m_ParentWindow.SetProperty(2, 0, a_Player);
-	}
-	else if (cItem::IsEnchantable(Item.m_ItemType) || Item.m_ItemType == E_ITEM_BOOK)
+	if (cItem::IsEnchantable(Item.m_ItemType) && Item.m_Enchantments.IsEmpty())
 	{
 		int Bookshelves = std::min(GetBookshelvesCount(a_Player.GetWorld()), 15);
 
 		cFastRandom Random;
-		int base = (Random.GenerateRandomInteger(1, 8) + (int)floor((float)Bookshelves / 2) + Random.GenerateRandomInteger(0, Bookshelves));
-		int topSlot = std::max(base / 3, 1);
-		int middleSlot = (base * 2) / 3 + 1;
-		int bottomSlot = std::max(base, Bookshelves * 2);
+		int Base = (Random.GenerateRandomInteger(1, 8) + (int)floor((float)Bookshelves / 2) + Random.GenerateRandomInteger(0, Bookshelves));
+		int TopSlot = std::max(Base / 3, 1);
+		int MiddleSlot = (Base * 2) / 3 + 1;
+		int BottomSlot = std::max(Base, Bookshelves * 2);
 
-		m_ParentWindow.SetProperty(0, topSlot, a_Player);
-		m_ParentWindow.SetProperty(1, middleSlot, a_Player);
-		m_ParentWindow.SetProperty(2, bottomSlot, a_Player);
+		m_ParentWindow.SetProperty(0, TopSlot, a_Player);
+		m_ParentWindow.SetProperty(1, MiddleSlot, a_Player);
+		m_ParentWindow.SetProperty(2, BottomSlot, a_Player);
 	}
 	else
 	{
@@ -1430,12 +1590,9 @@ void cSlotAreaEnchanting::UpdateResult(cPlayer & a_Player)
 
 int cSlotAreaEnchanting::GetBookshelvesCount(cWorld * a_World)
 {
-	int PosX, PosY, PosZ;
-	((cEnchantingWindow*)&m_ParentWindow)->GetBlockPos(PosX, PosY, PosZ);
-
 	int Bookshelves = 0;
 	cBlockArea Area;
-	Area.Read(a_World, PosX - 2, PosX + 2, PosY, PosY + 1, PosZ - 2, PosZ + 2);
+	Area.Read(a_World, m_BlockX - 2, m_BlockX + 2, m_BlockY, m_BlockY + 1, m_BlockZ - 2, m_BlockZ + 2);
 
 	static const struct
 	{
@@ -1483,7 +1640,7 @@ int cSlotAreaEnchanting::GetBookshelvesCount(cWorld * a_World)
 		if (
 			(Area.GetRelBlockType(CheckCoords[i].m_AirX, CheckCoords[i].m_AirY, CheckCoords[i].m_AirZ) == E_BLOCK_AIR) &&  // There's air in the checkspot
 			(Area.GetRelBlockType(CheckCoords[i].m_BookX, CheckCoords[i].m_BookY, CheckCoords[i].m_BookZ) == E_BLOCK_BOOKCASE)  // There's bookcase in the wanted place
-			)
+		)
 		{
 			Bookshelves++;
 		}
@@ -1764,6 +1921,40 @@ void cSlotAreaFurnace::HandleSmeltItem(const cItem & a_Result, cPlayer & a_Playe
 
 
 ////////////////////////////////////////////////////////////////////////////////
+// cSlotAreaMinecartWithChest:
+
+cSlotAreaMinecartWithChest::cSlotAreaMinecartWithChest(cMinecartWithChest * a_Chest, cWindow & a_ParentWindow) :
+	cSlotArea(27, a_ParentWindow),
+	m_Chest(a_Chest)
+{
+}
+
+
+
+
+
+const cItem * cSlotAreaMinecartWithChest::GetSlot(int a_SlotNum, cPlayer & a_Player) const
+{
+	// a_SlotNum ranges from 0 to 26, use that to index the minecart chest entity's inventory directly:
+	UNUSED(a_Player);
+	return &(m_Chest->GetSlot(a_SlotNum));
+}
+
+
+
+
+
+void cSlotAreaMinecartWithChest::SetSlot(int a_SlotNum, cPlayer & a_Player, const cItem & a_Item)
+{
+	UNUSED(a_Player);
+	m_Chest->SetSlot(a_SlotNum, a_Item);
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
 // cSlotAreaInventoryBase:
 
 cSlotAreaInventoryBase::cSlotAreaInventoryBase(int a_NumSlots, int a_SlotOffset, cWindow & a_ParentWindow) :
diff --git a/src/UI/SlotArea.h b/src/UI/SlotArea.h
index fa842bb81..1eeeb9836 100644
--- a/src/UI/SlotArea.h
+++ b/src/UI/SlotArea.h
@@ -15,10 +15,12 @@
 
 class cWindow;
 class cPlayer;
+class cBeaconEntity;
 class cChestEntity;
 class cDropSpenserEntity;
 class cEnderChestEntity;
 class cFurnaceEntity;
+class cMinecartWithChest;
 class cCraftingRecipe;
 class cEnchantingWindow;
 class cWorld;
@@ -314,20 +316,49 @@ protected:
 
 
 
+class cSlotAreaBeacon :
+	public cSlotArea,
+	public cItemGrid::cListener
+{
+	typedef cSlotArea super;
+	
+public:
+	cSlotAreaBeacon(cBeaconEntity * a_Beacon, cWindow & a_ParentWindow);
+	virtual ~cSlotAreaBeacon();
+
+	bool IsPlaceableItem(short a_ItemType);
+	
+	virtual void          Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction, const cItem & a_ClickedItem) override;
+	virtual void          DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_ShouldApply, bool a_KeepEmptySlots) override;
+	virtual const cItem * GetSlot(int a_SlotNum, cPlayer & a_Player) const override;
+	virtual void          SetSlot(int a_SlotNum, cPlayer & a_Player, const cItem & a_Item) override;
+
+protected:
+	cBeaconEntity * m_Beacon;
+
+	// cItemGrid::cListener overrides:
+	virtual void OnSlotChanged(cItemGrid * a_ItemGrid, int a_SlotNum) override;
+} ;
+
+
+
+
+
 class cSlotAreaEnchanting :
 	public cSlotAreaTemporary
 {
 	typedef cSlotAreaTemporary super;
 
 public:
-	cSlotAreaEnchanting(cEnchantingWindow & a_ParentWindow);
+	cSlotAreaEnchanting(cEnchantingWindow & a_ParentWindow, int a_BlockX, int a_BlockY, int a_BlockZ);
 
 	// cSlotArea overrides:
 	virtual void Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction, const cItem & a_ClickedItem) override;
-	virtual void DblClicked(cPlayer & a_Player, int a_SlotNum) override;
 	virtual void DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_ShouldApply, bool a_KeepEmptySlots) override;
+	virtual void SetSlot(int a_SlotNum, cPlayer & a_Player, const cItem & a_Item) override;
 
 	// cSlotAreaTemporary overrides:
+	virtual void OnPlayerAdded  (cPlayer & a_Player) override;
 	virtual void OnPlayerRemoved(cPlayer & a_Player) override;
 
 	/* Get the count of bookshelves who stand in the near of the enchanting table */
@@ -336,6 +367,8 @@ public:
 protected:
 	/** Handles a click in the item slot. */
 	void UpdateResult(cPlayer & a_Player);
+
+	int m_BlockX, m_BlockY, m_BlockZ;
 };
 
 
@@ -416,10 +449,27 @@ protected:
 	// cItemGrid::cListener overrides:
 	virtual void OnSlotChanged(cItemGrid * a_ItemGrid, int a_SlotNum) override;
 
-	/// Called after an item has been smelted to handle statistics e.t.c.
+	/// Called after an item has been smelted to handle statistics etc.
 	void HandleSmeltItem(const cItem & a_Result, cPlayer & a_Player);
 } ;
 
 
 
 
+
+class cSlotAreaMinecartWithChest :
+	public cSlotArea
+{
+public:
+	cSlotAreaMinecartWithChest(cMinecartWithChest * a_ChestCart, cWindow & a_ParentWindow);
+
+	virtual const cItem * GetSlot(int a_SlotNum, cPlayer & a_Player) const override;
+	virtual void          SetSlot(int a_SlotNum, cPlayer & a_Player, const cItem & a_Item) override;
+
+protected:
+	cMinecartWithChest * m_Chest;
+};
+
+
+
+
diff --git a/src/UI/Window.cpp b/src/UI/Window.cpp
index 4731f282b..d83336f75 100644
--- a/src/UI/Window.cpp
+++ b/src/UI/Window.cpp
@@ -9,10 +9,12 @@
 #include "../Entities/Pickup.h"
 #include "../Inventory.h"
 #include "../Items/ItemHandler.h"
+#include "../BlockEntities/BeaconEntity.h"
 #include "../BlockEntities/ChestEntity.h"
 #include "../BlockEntities/DropSpenserEntity.h"
 #include "../BlockEntities/EnderChestEntity.h"
 #include "../BlockEntities/HopperEntity.h"
+#include "../Entities/Minecart.h"
 #include "../Root.h"
 #include "../Bindings/PluginManager.h"
 
@@ -56,6 +58,34 @@ cWindow::~cWindow()
 
 
 
+const AString cWindow::GetWindowTypeName(void) const
+{
+	switch (m_WindowType)
+	{
+		case wtChest:       return "minecraft:chest";
+		case wtWorkbench:   return "minecraft:crafting_table";
+		case wtFurnace:     return "minecraft:furnace";
+		case wtDropSpenser: return "minecraft:dispenser";
+		case wtEnchantment: return "minecraft:enchanting_table";
+		case wtBrewery:     return "minecraft:brewing_stand";
+		case wtNPCTrade:    return "minecraft:villager";
+		case wtBeacon:      return "minecraft:beacon";
+		case wtAnvil:       return "minecraft:anvil";
+		case wtHopper:      return "minecraft:hopper";
+		case wtDropper:     return "minecraft:dropper";
+		case wtAnimalChest: return "EntityHorse";
+		default:
+		{
+			ASSERT(!"Unknown inventory type!");
+			return "";
+		}
+	}
+}
+
+
+
+
+
 int cWindow::GetNumSlots(void) const
 {
 	int res = 0;
@@ -841,6 +871,36 @@ void cAnvilWindow::GetBlockPos(int & a_PosX, int & a_PosY, int & a_PosZ)
 
 
 ////////////////////////////////////////////////////////////////////////////////
+// cBeaconWindow:
+
+cBeaconWindow::cBeaconWindow(int a_BlockX, int a_BlockY, int a_BlockZ, cBeaconEntity * a_Beacon) :
+	cWindow(wtBeacon, "Beacon"),
+	m_Beacon(a_Beacon)
+{
+	m_ShouldDistributeToHotbarFirst = true;
+	m_SlotAreas.push_back(new cSlotAreaBeacon(m_Beacon, *this));
+	m_SlotAreas.push_back(new cSlotAreaInventory(*this));
+	m_SlotAreas.push_back(new cSlotAreaHotBar(*this));
+}
+
+
+
+
+
+void cBeaconWindow::OpenedByPlayer(cPlayer & a_Player)
+{
+	super::OpenedByPlayer(a_Player);
+
+	a_Player.GetClientHandle()->SendWindowProperty(*this, 0, m_Beacon->GetBeaconLevel());
+	a_Player.GetClientHandle()->SendWindowProperty(*this, 1, m_Beacon->GetPrimaryEffect());
+	a_Player.GetClientHandle()->SendWindowProperty(*this, 2, m_Beacon->GetSecondaryEffect());
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
 // cEnchantingWindow:
 
 cEnchantingWindow::cEnchantingWindow(int a_BlockX, int a_BlockY, int a_BlockZ) :
@@ -850,7 +910,7 @@ cEnchantingWindow::cEnchantingWindow(int a_BlockX, int a_BlockY, int a_BlockZ) :
 	m_BlockY(a_BlockY),
 	m_BlockZ(a_BlockZ)
 {
-	m_SlotAreas.push_back(new cSlotAreaEnchanting(*this));
+	m_SlotAreas.push_back(new cSlotAreaEnchanting(*this, m_BlockX, m_BlockY, m_BlockZ));
 	m_SlotAreas.push_back(new cSlotAreaInventory(*this));
 	m_SlotAreas.push_back(new cSlotAreaHotBar(*this));
 }
@@ -861,8 +921,13 @@ cEnchantingWindow::cEnchantingWindow(int a_BlockX, int a_BlockY, int a_BlockZ) :
 
 void cEnchantingWindow::SetProperty(int a_Property, int a_Value)
 {
-	m_PropertyValue[a_Property] = a_Value;
+	if ((a_Property < 0) || ((size_t)a_Property >= ARRAYCOUNT(m_PropertyValue)))
+	{
+		ASSERT(!"a_Property is invalid");
+		return;
+	}
 
+	m_PropertyValue[a_Property] = a_Value;
 	super::SetProperty(a_Property, a_Value);
 }
 
@@ -872,8 +937,13 @@ void cEnchantingWindow::SetProperty(int a_Property, int a_Value)
 
 void cEnchantingWindow::SetProperty(int a_Property, int a_Value, cPlayer & a_Player)
 {
-	m_PropertyValue[a_Property] = a_Value;
+	if ((a_Property < 0) || ((size_t)a_Property >= ARRAYCOUNT(m_PropertyValue)))
+	{
+		ASSERT(!"a_Property is invalid");
+		return;
+	}
 
+	m_PropertyValue[a_Property] = a_Value;
 	super::SetProperty(a_Property, a_Value, a_Player);
 }
 
@@ -883,18 +953,13 @@ void cEnchantingWindow::SetProperty(int a_Property, int a_Value, cPlayer & a_Pla
 
 int cEnchantingWindow::GetPropertyValue(int a_Property)
 {
-	return m_PropertyValue[a_Property];
-}
-
-
-
-
+	if ((a_Property < 0) || ((size_t)a_Property >= ARRAYCOUNT(m_PropertyValue)))
+	{
+		ASSERT(!"a_Property is invalid");
+		return 0;
+	}
 
-void cEnchantingWindow::GetBlockPos(int & a_PosX, int & a_PosY, int & a_PosZ)
-{
-	a_PosX = m_BlockX;
-	a_PosY = m_BlockY;
-	a_PosZ = m_BlockZ;
+	return m_PropertyValue[a_Property];
 }
 
 
@@ -1012,6 +1077,34 @@ cChestWindow::~cChestWindow()
 
 
 ////////////////////////////////////////////////////////////////////////////////
+// cMinecartWithChestWindow:
+
+cMinecartWithChestWindow::cMinecartWithChestWindow(cMinecartWithChest * a_ChestCart) :
+	cWindow(wtChest, "Minecart with Chest"),
+	m_ChestCart(a_ChestCart)
+{
+	m_ShouldDistributeToHotbarFirst = false;
+	m_SlotAreas.push_back(new cSlotAreaMinecartWithChest(a_ChestCart, *this));
+	m_SlotAreas.push_back(new cSlotAreaInventory(*this));
+	m_SlotAreas.push_back(new cSlotAreaHotBar(*this));
+
+	a_ChestCart->GetWorld()->BroadcastSoundEffect("random.chestopen", a_ChestCart->GetPosX(), a_ChestCart->GetPosY(), a_ChestCart->GetPosZ(), 1, 1);
+}
+
+
+
+
+
+cMinecartWithChestWindow::~cMinecartWithChestWindow()
+{
+	m_ChestCart->GetWorld()->BroadcastSoundEffect("random.chestclosed", m_ChestCart->GetPosX(), m_ChestCart->GetPosY(), m_ChestCart->GetPosZ(), 1, 1);
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
 // cDropSpenserWindow:
 
 cDropSpenserWindow::cDropSpenserWindow(int a_BlockX, int a_BlockY, int a_BlockZ, cDropSpenserEntity * a_DropSpenser) :
@@ -1037,6 +1130,7 @@ cEnderChestWindow::cEnderChestWindow(cEnderChestEntity * a_EnderChest) :
 	m_BlockY(a_EnderChest->GetPosY()),
 	m_BlockZ(a_EnderChest->GetPosZ())
 {
+	m_ShouldDistributeToHotbarFirst = false;
 	m_SlotAreas.push_back(new cSlotAreaEnderChest(a_EnderChest, *this));
 	m_SlotAreas.push_back(new cSlotAreaInventory(*this));
 	m_SlotAreas.push_back(new cSlotAreaHotBar(*this));
diff --git a/src/UI/Window.h b/src/UI/Window.h
index 97db0ca88..6b6dce346 100644
--- a/src/UI/Window.h
+++ b/src/UI/Window.h
@@ -23,6 +23,8 @@ class cDropSpenserEntity;
 class cEnderChestEntity;
 class cFurnaceEntity;
 class cHopperEntity;
+class cMinecartWithChest;
+class cBeaconEntity;
 class cSlotArea;
 class cSlotAreaAnvil;
 class cWorld;
@@ -62,7 +64,7 @@ public:
 		wtBeacon      = 7,
 		wtAnvil       = 8,
 		wtHopper      = 9,
-		// Unknown: 10
+		wtDropper     = 10,
 		wtAnimalChest = 11,
 	};
 	
@@ -75,6 +77,7 @@ public:
 
 	char GetWindowID(void) const { return m_WindowID; }  // tolua_export
 	int GetWindowType(void) const { return m_WindowType; }  // tolua_export
+	const AString GetWindowTypeName(void) const;  // tolua_export
 
 	cWindowOwner * GetOwner(void) { return m_Owner; }
 	void SetOwner( cWindowOwner * a_Owner) { m_Owner = a_Owner; }
@@ -258,6 +261,26 @@ protected:
 
 
 
+class cBeaconWindow :
+	public cWindow
+{
+	typedef cWindow super;
+public:
+	cBeaconWindow(int a_BlockX, int a_BlockY, int a_BlockZ, cBeaconEntity * a_Beacon);
+
+	cBeaconEntity * GetBeaconEntity(void) const { return m_Beacon; }
+
+	// cWindow Overrides:
+	virtual void OpenedByPlayer(cPlayer & a_Player) override;
+
+protected:
+	cBeaconEntity * m_Beacon;
+} ;
+
+
+
+
+
 class cEnchantingWindow :
 	public cWindow
 {
@@ -270,9 +293,6 @@ public:
 	/** Return the Value of a Property */
 	int GetPropertyValue(int a_Property);
 
-	/** Get the Position from the Enchantment Table */
-	void GetBlockPos(int & a_PosX, int & a_PosY, int & a_PosZ);
-
 	cSlotArea * m_SlotArea;
 
 protected:
@@ -342,6 +362,20 @@ protected:
 
 
 
+class cMinecartWithChestWindow :
+	public cWindow
+{
+public:
+	cMinecartWithChestWindow(cMinecartWithChest * a_ChestCart);
+	~cMinecartWithChestWindow();
+private:
+	cMinecartWithChest * m_ChestCart;
+};
+
+
+
+
+
 class cEnderChestWindow :
 	public cWindow
 {
diff --git a/src/UI/WindowOwner.h b/src/UI/WindowOwner.h
index 7a7941e37..6845a161b 100644
--- a/src/UI/WindowOwner.h
+++ b/src/UI/WindowOwner.h
@@ -1,4 +1,3 @@
-
 #pragma once
 
 #include "../BlockEntities/BlockEntity.h"
@@ -16,12 +15,6 @@ for entities / players in motion to close their windows when they get too far aw
 
 
 
-// class cWindow;
-
-
-
-
-
 /**
 Base class for the window owning
 */
@@ -32,16 +25,16 @@ public:
 		m_Window(NULL)
 	{
 	}
-	
+
 	virtual ~cWindowOwner()
 	{
 	}
-	
+
 	void CloseWindow(void)
 	{
 		m_Window = NULL;
 	}
-	
+
 	void OpenWindow(cWindow * a_Window)
 	{
 		m_Window = a_Window;
@@ -54,11 +47,11 @@ public:
 	}
 
 	/// Returns the block position at which the element owning the window is
-	virtual void GetBlockPos(int & a_BlockX, int & a_BlockY, int & a_BlockZ) = 0;
-	
+	virtual Vector3i GetBlockPos(void) = 0;
+
 private:
 	cWindow * m_Window;
-} ;
+};
 
 
 
@@ -71,26 +64,19 @@ class cBlockEntityWindowOwner :
 	public cWindowOwner
 {
 public:
-	cBlockEntityWindowOwner(void) :
-		m_BlockEntity(NULL)
-	{
-	}
-	
-	void SetBlockEntity(cBlockEntity * a_BlockEntity)
+	cBlockEntityWindowOwner(cBlockEntity * a_BlockEntity) :
+		m_BlockEntity(a_BlockEntity)
 	{
-		m_BlockEntity = a_BlockEntity;
 	}
-	
-	virtual void GetBlockPos(int & a_BlockX, int & a_BlockY, int & a_BlockZ) override
+
+	virtual Vector3i GetBlockPos(void) override
 	{
-		a_BlockX = m_BlockEntity->GetPosX();
-		a_BlockY = m_BlockEntity->GetPosY();
-		a_BlockZ = m_BlockEntity->GetPosZ();
+		return Vector3i(m_BlockEntity->GetPosX(), m_BlockEntity->GetPosY(), m_BlockEntity->GetPosZ());
 	}
-	
+
 private:
 	cBlockEntity * m_BlockEntity;
-} ;
+};
 
 
 
@@ -103,26 +89,19 @@ class cEntityWindowOwner :
 	public cWindowOwner
 {
 public:
-	cEntityWindowOwner(void) :
-		m_Entity(NULL)
-	{
-	}
-	
-	void SetEntity(cEntity * a_Entity)
+	cEntityWindowOwner(cEntity * a_Entity) :
+		m_Entity(a_Entity)
 	{
-		m_Entity = a_Entity;
 	}
 
-	virtual void GetBlockPos(int & a_BlockX, int & a_BlockY, int & a_BlockZ) override
+	virtual Vector3i GetBlockPos(void) override
 	{
-		a_BlockX = (int)floor(m_Entity->GetPosX() + 0.5);
-		a_BlockY = (int)floor(m_Entity->GetPosY() + 0.5);
-		a_BlockZ = (int)floor(m_Entity->GetPosZ() + 0.5);
+		return m_Entity->GetPosition().Floor();
 	}
-	
+
 private:
 	cEntity * m_Entity;
-} ;
+};