SlotArea.h

Go to the documentation of this file.

 
// SlotArea.h
 
// Interfaces to the cSlotArea class representing a contiguous area of slots in a UI window
 
 
 
 
#pragma once
 
#include "../Inventory.h"
 
 
 
 
 
class cHorse;
class cWindow;
class cPlayer;
class cBeaconEntity;
class cBrewingstandEntity;
class cChestEntity;
class cEnderChestEntity;
class cFurnaceEntity;
class cMinecartWithChest;
class cCraftingRecipe;
class cWorld;
 
 
 
 
 
class cSlotArea
{
public:
    cSlotArea(int a_NumSlots, cWindow & a_ParentWindow);
    virtual ~cSlotArea() {}  // force a virtual destructor in all subclasses
 
    int GetNumSlots(void) const { return m_NumSlots; }
 
    virtual const cItem * GetSlot(int a_SlotNum, cPlayer & a_Player) const = 0;
 
    virtual void SetSlot(int a_SlotNum, cPlayer & a_Player, const cItem & a_Item) = 0;
 
    virtual void Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction, const cItem & a_ClickedItem);
 
    virtual void ShiftClicked(cPlayer & a_Player, int a_SlotNum, const cItem & a_ClickedItem);
 
    virtual void DblClicked(cPlayer & a_Player, int a_SlotNum);
 
    virtual void MiddleClicked(cPlayer & a_Player, int a_SlotNum);
 
    virtual void DropClicked(cPlayer & a_Player, int a_SlotNum, bool a_DropStack);
 
    virtual void NumberClicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction);
 
    virtual void OnPlayerAdded(cPlayer & a_Player);
 
    virtual void OnPlayerRemoved(cPlayer & a_Player);
 
    virtual void DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_ShouldApply, bool a_KeepEmptySlots, bool a_BackFill);
 
    virtual bool CollectItemsToHand(cItem & a_Dragging, cPlayer & a_Player, bool a_CollectFullStacks);
 
protected:
    int       m_NumSlots;
    cWindow & m_ParentWindow;
} ;
 
 
 
 
 
class cSlotAreaInventoryBase:
    public cSlotArea
{
    using Super = cSlotArea;
 
public:
 
    cSlotAreaInventoryBase(int a_NumSlots, int a_SlotOffset, cWindow & a_ParentWindow);
 
    // Creative inventory's click handling is somewhat different from survival inventory's, handle that here:
    virtual void Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction, const cItem & a_ClickedItem) 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:
    int m_SlotOffset;  // Index that this area's slot 0 has in the underlying cInventory
} ;
 
 
 
 
 
class cSlotAreaInventory:
    public cSlotAreaInventoryBase
{
    using Super = cSlotAreaInventoryBase;
 
public:
 
    cSlotAreaInventory(cWindow & a_ParentWindow):
        Super(cInventory::invInventoryCount, cInventory::invInventoryOffset, a_ParentWindow)
    {
    }
} ;
 
 
 
 
 
class cSlotAreaHotBar:
    public cSlotAreaInventoryBase
{
    using Super = cSlotAreaInventoryBase;
 
public:
    cSlotAreaHotBar(cWindow & a_ParentWindow):
        Super(cInventory::invHotbarCount, cInventory::invHotbarOffset, a_ParentWindow)
    {
    }
} ;
 
 
 
 
 
class cSlotAreaShield:
    public cSlotAreaInventoryBase
{
    using Super = cSlotAreaInventoryBase;
 
public:
 
    cSlotAreaShield(cWindow & a_ParentWindow):
        Super(cInventory::invShieldCount, cInventory::invShieldOffset, a_ParentWindow)
    {
    }
};
 
 
 
 
 
class cSlotAreaArmor:
    public cSlotAreaInventoryBase
{
    using Super = cSlotAreaInventoryBase;
 
public:
 
    cSlotAreaArmor(cWindow & a_ParentWindow):
        Super(cInventory::invArmorCount, cInventory::invArmorOffset, a_ParentWindow)
    {
    }
 
    virtual void DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_ShouldApply, bool a_KeepEmptySlots, bool a_BackFill) override;
 
    virtual void Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction, const cItem & a_ClickedItem) override;
 
    static bool CanPlaceArmorInSlot(int a_SlotNum, const cItem & a_Item);
} ;
 
 
 
 
 
class cSlotAreaItemGrid:
    public cSlotArea,
    public cItemGrid::cListener
{
    using Super = cSlotArea;
 
public:
 
    cSlotAreaItemGrid(cItemGrid & a_ItemGrid, cWindow & a_ParentWindow);
 
    virtual ~cSlotAreaItemGrid() 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:
    cItemGrid & m_ItemGrid;
 
    // cItemGrid::cListener overrides:
    virtual void OnSlotChanged(cItemGrid * a_ItemGrid, int a_SlotNum) override;
} ;
 
 
 
 
 
class cSlotAreaTemporary:
    public cSlotArea
{
    using Super = cSlotArea;
 
public:
 
    cSlotAreaTemporary(int a_NumSlots, cWindow & a_ParentWindow);
 
    // cSlotArea overrides:
    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;
    virtual void          OnPlayerAdded  (cPlayer & a_Player) override;
    virtual void          OnPlayerRemoved(cPlayer & a_Player) override;
 
    void TossItems(cPlayer & a_Player, int a_Begin, int a_End);
 
protected:
    using cItemMap = std::map<UInt32, std::vector<cItem> >;  // Maps EntityID -> items
 
    cItemMap m_Items;
 
    cItem * GetPlayerSlots(cPlayer & a_Player);
} ;
 
 
 
 
 
class cSlotAreaCrafting:
    public cSlotAreaTemporary
{
    using Super = cSlotAreaTemporary;
 
public:
 
    cSlotAreaCrafting(int a_GridSize, cWindow & a_ParentWindow);
 
    // cSlotAreaTemporary 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 OnPlayerRemoved(cPlayer & a_Player) override;
    virtual void SetSlot        (int a_SlotNum, cPlayer & a_Player, const cItem & a_Item) override;
 
    // Distributing items into this area is completely disabled
    virtual void DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_ShouldApply, bool a_KeepEmptySlots, bool a_BackFill) override;
 
    void ClearCraftingGrid(cPlayer & a_Player);
 
    void LoadRecipe(cPlayer & a_Player, UInt32 a_RecipeId);
 
protected:
    typedef std::list<std::pair<UInt32, cCraftingRecipe> > cRecipeMap;
 
    int        m_GridSize;
    cRecipeMap m_Recipes;
 
    void ClickedResult(cPlayer & a_Player);
 
    void ShiftClickedResult(cPlayer & a_Player);
 
    void DropClickedResult(cPlayer & a_Player);
 
    void UpdateRecipe(cPlayer & a_Player);
 
    cCraftingRecipe & GetRecipeForPlayer(cPlayer & a_Player);
 
    void HandleCraftItem(const cItem & a_Result, cPlayer & a_Player);
} ;
 
 
 
 
 
class cSlotAreaAnvil:
    public cSlotAreaTemporary
{
    using Super = cSlotAreaTemporary;
 
public:
 
    cSlotAreaAnvil(cWindow & a_ParentWindow);
 
    // cSlotArea overrides:
    virtual void Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction, const cItem & a_ClickedItem) override;
    virtual void ShiftClicked(cPlayer & a_Player, int a_SlotNum, const cItem & a_ClickedItem) override;
    virtual void DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_ShouldApply, bool a_KeepEmptySlots, bool a_BackFill) override;
 
    // cSlotAreaTemporary overrides:
    virtual void OnPlayerRemoved(cPlayer & a_Player) override;
 
    bool CanTakeResultItem(cPlayer & a_Player);
 
    void OnTakeResult(cPlayer & a_Player);
 
    void UpdateResult(cPlayer & a_Player);
 
protected:
    int m_MaximumCost;
 
    char m_StackSizeToBeUsedInRepair;
} ;
 
 
 
 
 
class cSlotAreaBeacon:
    public cSlotArea,
    public cItemGrid::cListener
{
    using Super = cSlotArea;
 
public:
 
    cSlotAreaBeacon(cBeaconEntity * a_Beacon, cWindow & a_ParentWindow);
    virtual ~cSlotAreaBeacon() override;
 
    static 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, bool a_BackFill) 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 final :
    public cSlotAreaTemporary
{
    using Super = cSlotAreaTemporary;
 
public:
 
    cSlotAreaEnchanting(cWindow & a_ParentWindow, Vector3i a_BlockPos);
 
    // cSlotArea overrides:
    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, bool a_BackFill) 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 number of bookshelves which are near the enchanting table */
    unsigned GetBookshelvesCount(cWorld & a_World);
 
    /* Return the enchanted item matching the chosen option (0, 1, 2)
    Ownership of the cItem is transferred to the caller. */
    cItem SelectEnchantedOption(size_t a_EnchantOption);
 
protected:
 
    void UpdateResult(cPlayer & a_Player);
 
    Vector3i m_BlockPos;
    std::array<cItem, 3> m_EnchantedItemOptions;
};
 
 
 
 
 
class cSlotAreaChest :
    public cSlotArea
{
public:
    cSlotAreaChest(cChestEntity * a_Chest, 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:
    cChestEntity * m_Chest;
} ;
 
 
 
 
 
class cSlotAreaDoubleChest :
    public cSlotArea
{
public:
    cSlotAreaDoubleChest(cChestEntity * a_TopChest, cChestEntity * a_BottomChest, 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:
    cChestEntity * m_TopChest;
    cChestEntity * m_BottomChest;
} ;
 
 
 
 
 
class cSlotAreaEnderChest :
    public cSlotArea
{
public:
    cSlotAreaEnderChest(cEnderChestEntity * a_EnderChest, 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:
    cEnderChestEntity * m_EnderChest;
};
 
 
 
 
 
class cSlotAreaFurnace:
    public cSlotArea,
    public cItemGrid::cListener
{
    using Super = cSlotArea;
 
public:
 
    cSlotAreaFurnace(cFurnaceEntity * a_Furnace, cWindow & a_ParentWindow);
 
    virtual ~cSlotAreaFurnace() override;
 
    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, bool a_BackFill) 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:
    cFurnaceEntity * m_Furnace;
 
    // cItemGrid::cListener overrides:
    virtual void OnSlotChanged(cItemGrid * a_ItemGrid, int a_SlotNum) override;
 
    void HandleSmeltItem(const cItem & a_Result, cPlayer & a_Player);
} ;
 
 
 
 
 
class cSlotAreaBrewingstand:
    public cSlotArea,
    public cItemGrid::cListener
{
    using Super = cSlotArea;
 
public:
 
    cSlotAreaBrewingstand(cBrewingstandEntity * a_Brewingstand, cWindow & a_ParentWindow);
 
    virtual ~cSlotAreaBrewingstand() override;
 
    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, bool a_BackFill) 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:
    cBrewingstandEntity * m_Brewingstand;
 
    // cItemGrid::cListener overrides:
    virtual void OnSlotChanged(cItemGrid * a_ItemGrid, int a_SlotNum) override;
 
    void HandleBrewedItem(cPlayer & a_Player, const cItem & a_ClickedItem);
} ;
 
 
 
 
 
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;
};
 
 
 
 
 
class cSlotAreaHorse:
    public cSlotArea
{
public:
    enum
    {
        SaddleSlot,
        ArmorSlot
    };
 
    cSlotAreaHorse(cHorse & a_Horse, cWindow & a_ParentWindow);
    virtual void Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction, const cItem & a_ClickedItem) 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;
    virtual void DistributeStack(cItem & a_ItemStack, cPlayer & a_Player, bool a_ShouldApply, bool a_KeepEmptySlots, bool a_BackFill) override;
private:
    cHorse & m_Horse;
};