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
{
    typedef cSlotArea super;

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
{
    typedef cSlotAreaInventoryBase super;

public:
    cSlotAreaInventory(cWindow & a_ParentWindow) :
        cSlotAreaInventoryBase(cInventory::invInventoryCount, cInventory::invInventoryOffset, a_ParentWindow)
    {
    }
} ;





class cSlotAreaHotBar :
    public cSlotAreaInventoryBase
{
    typedef cSlotAreaInventoryBase super;

public:
    cSlotAreaHotBar(cWindow & a_ParentWindow) :
        cSlotAreaInventoryBase(cInventory::invHotbarCount, cInventory::invHotbarOffset, a_ParentWindow)
    {
    }
} ;





class cSlotAreaShield :
    public cSlotAreaInventoryBase
{
    typedef cSlotAreaInventoryBase super;

public:
    cSlotAreaShield(cWindow & a_ParentWindow) :
        cSlotAreaInventoryBase(cInventory::invShieldCount, cInventory::invShieldOffset, a_ParentWindow)
    {
    }
};





class cSlotAreaArmor :
    public cSlotAreaInventoryBase
{
public:
    cSlotAreaArmor(cWindow & a_ParentWindow) :
        cSlotAreaInventoryBase(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
{
    typedef cSlotArea super;

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
{
    typedef cSlotArea super;

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:
    typedef std::map<UInt32, std::vector<cItem> > cItemMap;  // Maps EntityID -> items

    cItemMap m_Items;

    cItem * GetPlayerSlots(cPlayer & a_Player);
} ;





class cSlotAreaCrafting :
    public cSlotAreaTemporary
{
    typedef cSlotAreaTemporary super;

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;


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
{
    typedef cSlotAreaTemporary super;

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
{
    typedef cSlotArea super;

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 :
    public cSlotAreaTemporary
{
    typedef cSlotAreaTemporary super;

public:
    cSlotAreaEnchanting(cWindow & 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 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 count of bookshelves who stand in the near of the enchanting table */
    int GetBookshelvesCount(cWorld & a_World);

protected:
    void UpdateResult(cPlayer & a_Player);

    int m_BlockX, m_BlockY, m_BlockZ;
};





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
{
    typedef cSlotArea super;

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
{
    typedef cSlotArea super;

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;
};