InventoryManager.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <memory>
#include <shared_mutex>
 
#include "protocolCraft/Types/Item/Slot.hpp"
#if PROTOCOL_VERSION > 451 /* > 1.13.2 */
#include "protocolCraft/Types/Item/MerchantOffer.hpp"
#endif
#include "protocolCraft/Handler.hpp"
 
#include "botcraft/Game/Enums.hpp"
 
namespace Botcraft
{
    class NetworkManager;
 
#if PROTOCOL_VERSION < 755 /* < 1.17 */
    enum class TransactionState
    {
        Waiting,
        Accepted,
        Refused
    };
#endif
 
    struct InventoryTransaction
    {
        std::shared_ptr<ProtocolCraft::ServerboundContainerClickPacket> packet;
        // In 1.21.5+, ServerboundContainerClickPacket doesn't have the components data
        // anymore, just hashed version so we need to store them somewhere
#if PROTOCOL_VERSION < 755 /* < 1.17 */ || PROTOCOL_VERSION > 769 /* > 1.21.4 */
        std::map<short, ProtocolCraft::Slot> changed_slots;
        ProtocolCraft::Slot carried_item;
#endif
    };
 
    class Window;
 
    class InventoryManager : public ProtocolCraft::Handler
    {
    public:
        InventoryManager(const std::shared_ptr<NetworkManager>& network_manager);
 
        void SetIndexHotbarSelected(const short index);
        std::shared_ptr<Window> GetWindow(const short window_id) const;
        short GetFirstOpenedWindowId() const;
        std::shared_ptr<Window> GetPlayerInventory() const;
        short GetIndexHotbarSelected() const;
        ProtocolCraft::Slot GetHotbarSelected() const;
        ProtocolCraft::Slot GetOffHand() const;
        ProtocolCraft::Slot GetCursor() const;
        void EraseInventory(const short window_id);
 
#if PROTOCOL_VERSION < 755 /* < 1.17 */
        TransactionState GetTransactionState(const short window_id, const int transaction_id) const;
#endif
 
        // Set the right transaction id, add it to the inventory manager,
        // update the next transaction id and send it to the server
        // return the id of the transaction
        int SendInventoryTransaction(const std::shared_ptr<ProtocolCraft::ServerboundContainerClickPacket>& transaction);
 
#if PROTOCOL_VERSION > 451 /* > 1.13.2 */
        std::vector<ProtocolCraft::MerchantOffer> GetAvailableMerchantOffers() const;
        void IncrementMerchantOfferUse(const int index);
#endif
 
    private:
        void SetIndexHotbarSelectedLocal(const short index);
        void SetCursor(const ProtocolCraft::Slot& c);
 
        void AddInventory(const short window_id, const InventoryType window_type);
        void SetSlot(const short window_id, const short index, const ProtocolCraft::Slot& slot);
#if PROTOCOL_VERSION > 754 /* > 1.16.5 */
        void SynchronizeContainerPlayerInventory(const short window_id);
#endif
#if PROTOCOL_VERSION > 755 /* > 1.17 */
        void SetStateId(const short window_id, const int state_id);
#endif
 
#if PROTOCOL_VERSION < 755 /* < 1.17 */
        void AddPendingTransaction(const InventoryTransaction& transaction);
#endif
        /// @brief "think" about the changes made by this transaction, filling in the necessary values in the packet
        /// @param transaction The transaction to update with the modifications
        /// @return An InventoryTransaction with various info, depending on the version
        InventoryTransaction PrepareTransaction(const std::shared_ptr<ProtocolCraft::ServerboundContainerClickPacket>& transaction);
 
        /// @brief Apply a given transaction to a container
        /// @param transaction The transaction to apply
        void ApplyTransaction(const InventoryTransaction& transaction);
 
    private:
        virtual void Handle(ProtocolCraft::ClientboundContainerSetSlotPacket& packet) override;
        virtual void Handle(ProtocolCraft::ClientboundContainerSetContentPacket& packet) override;
        virtual void Handle(ProtocolCraft::ClientboundOpenScreenPacket& packet) override;
#if PROTOCOL_VERSION < 768 /* < 1.21.2 */
        virtual void Handle(ProtocolCraft::ClientboundSetCarriedItemPacket& packet) override;
#else
        virtual void Handle(ProtocolCraft::ClientboundSetHeldSlotPacket& packet) override;
#endif
#if PROTOCOL_VERSION < 755 /* < 1.17 */
        virtual void Handle(ProtocolCraft::ClientboundContainerAckPacket& packet) override;
#endif
#if PROTOCOL_VERSION > 451 /* > 1.13.2 */
        virtual void Handle(ProtocolCraft::ClientboundMerchantOffersPacket& packet) override;
#endif
        virtual void Handle(ProtocolCraft::ClientboundContainerClosePacket& packet) override;
#if PROTOCOL_VERSION > 767 /* > 1.21.1 */
        virtual void Handle(ProtocolCraft::ClientboundSetCursorItemPacket& packet) override;
        virtual void Handle(ProtocolCraft::ClientboundSetPlayerInventoryPacket& packet) override;
#endif
 
        void ApplyTransactionImpl(const InventoryTransaction& transaction);
 
    private:
        mutable std::shared_mutex inventory_manager_mutex;
 
        std::map<short, std::shared_ptr<Window> > inventories;
        short index_hotbar_selected;
        ProtocolCraft::Slot cursor;
 
#if PROTOCOL_VERSION < 755 /* < 1.17 */
        // Storing all the transactions that have neither been accepted
        // nor refused by the server yet
        std::map<short, std::map<short, InventoryTransaction > > pending_transactions;
        // Storing the old transactions (accepted/refused) for all opened windows
        std::map<short, std::map<short, TransactionState> > transaction_states;
#endif
#if PROTOCOL_VERSION > 451 /* > 1.13.2 */
        int trading_container_id;
        std::vector<ProtocolCraft::MerchantOffer> available_trades;
#endif
 
        std::shared_ptr<NetworkManager> network_manager;
    };
} // Botcraft