ItemRegistry.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/common/SharedPtr.h"
#include "mc/common/WeakPtr.h"
#include "mc/deps/core/string/HashedString.h"
#include "mc/deps/core/utility/NonOwnerPointer.h"
#include "mc/deps/core/utility/pub_sub/Publisher.h"
#include "mc/deps/game_refs/WeakRef.h"
#include "mc/deps/resource_processing/util/MinecraftDocumentInput.h"
#include "mc/util/BaseGameVersion.h"
#include "mc/world/item/Item.h"
#include "mc/world/item/ItemTag.h"
#include "mc/world/item/registry/ItemRegistryRef.h"
 
// auto generated forward declare list
// clang-format off
class ActorInfoRegistry;
class Block;
class BlockDefinitionGroup;
class BlockType;
class CreativeItemRegistry;
class Experiments;
class IContainerRegistryAccess;
class IContainerRegistryTracker;
class IDynamicContainerSerialization;
class IMinecraftEventing;
class ItemRegistryRef;
class LevelData;
class LinkedAssetValidator;
class PackLoadContext;
class ResourcePackManager;
class SemVersion;
struct ItemData;
struct ItemIconInfo;
struct ItemParseContext;
struct ItemRegistryComplexAlias;
namespace Bedrock::PubSub::ThreadModel { struct MultiThreaded; }
namespace Bedrock::Threading { class Mutex; }
namespace Core { class Path; }
namespace cereal { struct ReflectionCtx; }
// clang-format on
 
class ItemRegistry : public ::std::enable_shared_from_this<::ItemRegistry> {
public:
    // ItemRegistry inner types declare
    // clang-format off
    struct ItemAlias;
    struct ItemHashAlias;
    struct LoadedItemAsset;
    struct ItemLoadResult;
    struct ParsedName;
    // clang-format on
 
    // ItemRegistry inner types define
    struct ItemAlias {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 48, ::HashedString>    currentName;
        ::ll::TypedStorage<8, 32, ::BaseGameVersion> sinceVersion;
        // NOLINTEND
 
    public:
        // member functions
        // NOLINTBEGIN
        MCAPI ~ItemAlias();
        // NOLINTEND
 
    public:
        // destructor thunk
        // NOLINTBEGIN
        MCAPI void $dtor();
        // NOLINTEND
    };
 
    struct ItemHashAlias {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 8, uint64>             aliasName;
        ::ll::TypedStorage<8, 32, ::BaseGameVersion> sinceVersion;
        // NOLINTEND
    };
 
    struct LoadedItemAsset {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 272, ::Bedrock::Resources::MinecraftDocumentInput> mDocumentInput;
        ::ll::TypedStorage<8, 16, ::std::shared_ptr<::PackLoadContext>>          mPackLoadContext;
        ::ll::TypedStorage<8, 32, ::std::string>                                 mLoadedPackName;
        ::ll::TypedStorage<1, 1, bool>                                           mIsComponentBased;
        // NOLINTEND
 
    public:
        // member functions
        // NOLINTBEGIN
        MCAPI ~LoadedItemAsset();
        // NOLINTEND
 
    public:
        // destructor thunk
        // NOLINTBEGIN
        MCFOLD void $dtor();
        // NOLINTEND
    };
 
    struct ItemLoadResult {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 336, ::std::optional<::ItemRegistry::LoadedItemAsset>> mLoadedItemAsset;
        ::ll::TypedStorage<8, 32, ::std::string>                                     mError;
        // NOLINTEND
 
    public:
        // member functions
        // NOLINTBEGIN
        MCAPI ~ItemLoadResult();
        // NOLINTEND
 
    public:
        // destructor thunk
        // NOLINTBEGIN
        MCAPI void $dtor();
        // NOLINTEND
    };
 
    struct ParsedName {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 16, ::std::string_view> mItemIdentifier;
        ::ll::TypedStorage<8, 32, ::std::string>      mParsedNamespace;
        ::ll::TypedStorage<8, 32, ::std::string>      mParsedName;
        ::ll::TypedStorage<4, 4, int>                 mAux;
        // NOLINTEND
 
    public:
        // member functions
        // NOLINTBEGIN
        MCAPI ~ParsedName();
        // NOLINTEND
 
    public:
        // destructor thunk
        // NOLINTBEGIN
        MCFOLD void $dtor();
        // NOLINTEND
    };
 
    using CreativeItemsServerInitCallbackSignature = void(
        ::ItemRegistryRef,
        ::BlockDefinitionGroup const&,
        ::CreativeItemRegistry*,
        ::BaseGameVersion const&,
        ::Experiments const&,
        ::ResourcePackManager const&,
        ::cereal::ReflectionCtx const&,
        ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> const,
        ::IMinecraftEventing&
    );
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<8, 8, ::gsl::not_null<::std::unique_ptr<::cereal::ReflectionCtx>>>      mCerealContext;
    ::ll::TypedStorage<8, 24, ::Bedrock::NonOwnerPointer<::LinkedAssetValidator>>              mValidator;
    ::ll::TypedStorage<8, 24, ::std::vector<::SharedPtr<::Item>>>                              mItemRegistry;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<int, ::WeakPtr<::Item>>>                    mIdToItemMap;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::HashedString, ::WeakPtr<::Item>>>         mNameToItemMap;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::HashedString, ::WeakPtr<::Item>>>         mTileNamespaceToItemMap;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::HashedString, ::WeakPtr<::Item>>>         mTileItemNameToItemMap;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::HashedString, ::ItemRegistry::ItemAlias>> mItemAliasLookupMap;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<uint64, ::ItemRegistry::ItemHashAlias>>     mReverseAliasLookupMap;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<uint64, ::ItemRegistry::ItemHashAlias>>
        mReverseFullNameAliasLookupMap;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::HashedString, ::ItemRegistryComplexAlias>> mComplexAliasLookupMap;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<short, ::HashedString>>                      mLegacyIDToNameMap;
    ::ll::TypedStorage<2, 2, short>                                                             mMaxItemID;
    ::ll::TypedStorage<8, 24, ::std::vector<::HashedString>>                                    mAttachableDefinitions;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::ItemTag, ::std::unordered_set<::Item const*>>> mTagToItemsMap;
    ::ll::TypedStorage<8, 64, ::std::unordered_set<::Item const*> const>                            mEmptyItemSet;
    ::ll::TypedStorage<1, 1, bool>                                      mServerInitializingCreativeItems;
    ::ll::TypedStorage<1, 1, bool>                                      mIsInitialized;
    ::ll::TypedStorage<8, 64, ::std::function<void(::ItemRegistryRef)>> mExtraItemInitCallback;
    ::ll::TypedStorage<
        8,
        8,
        ::std::unique_ptr<::Bedrock::PubSub::Publisher<void(), ::Bedrock::PubSub::ThreadModel::MultiThreaded, 0>>>
                                                                              mFinishedInitServerPublisher;
    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::std::atomic<int>>>          mCanUpdateTags;
    ::ll::TypedStorage<8, 24, ::std::vector<::SharedPtr<::Item>>>             mDeadItemRegistry;
    ::ll::TypedStorage<8, 32, ::BaseGameVersion>                              mWorldBaseGameVersion;
    ::ll::TypedStorage<1, 1, bool>                                            mCheckForItemWorldCompatibility;
    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::Bedrock::Threading::Mutex>> mCompatibilityCheckMutex;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::CreativeItemRegistry>>       mCreativeItemRegistry;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI ItemRegistry();
 
    MCAPI void _initServerData(
        ::std::vector<::ItemRegistry::LoadedItemAsset> const& allItemAssets,
        ::ItemParseContext&                                   parseContext,
        ::IMinecraftEventing&                                 eventing
    );
 
    MCAPI bool _shouldIgnoreEduItem(::std::string_view itemName);
 
    MCAPI ::WeakPtr<::Item> _tryCreateItem(
        ::ItemRegistry::ParsedName const& parsedName,
        ::SemVersion const&               documentVersion,
        ::PackLoadContext const&          packLoadContext,
        bool                              componentBasedItem,
        ::ItemParseContext&               parseContext
    );
 
    MCAPI ::ItemRegistryRef::LoadedItem
    _tryRegisterAndInitItem(::ItemRegistry::LoadedItemAsset const& loadedItemAsset, ::ItemParseContext& parseContext);
 
    MCAPI void alterAvailableCreativeItems(::ActorInfoRegistry* registry, ::LevelData& levelData);
 
    MCAPI void clearItemAndCreativeItemRegistry();
 
#ifdef LL_PLAT_C
    MCAPI void digestServerItemComponents(::std::vector<::ItemData> const& items);
 
    MCAPI void findAllAttachableDefinitions();
#endif
 
    MCAPI void finishedRegistration();
 
    MCAPI ::std::vector<::std::reference_wrapper<::HashedString const>> const&
    getComplexAliasSplitNames(::HashedString const& oldName) const;
 
    MCFOLD ::WeakPtr<::Item> getItem(::HashedString const& id);
 
    MCAPI ::WeakPtr<::Item> getItem(short id);
 
    MCAPI ::std::pair<::HashedString, int> getNameFromAlias(::HashedString const& name, int aux) const;
 
#ifdef LL_PLAT_C
    MCAPI void initClient(
        ::std::vector<::ItemData> const& serverItemData,
        ::Experiments const&             experiments,
        ::BaseGameVersion const&         baseGameVersion
    );
 
    MCAPI void initClientData(
        ::ResourcePackManager& resourcePackManager,
        ::Experiments const&   experiments,
        ::std::optional<::ItemIconInfo> (*iconFactory)(::std::string const&, int)
    );
#endif
 
    MCAPI void initCreativeItemsServer(
        ::BlockDefinitionGroup const&                      blockDefinitionGroup,
        ::Experiments const&                               experiments,
        ::ResourcePackManager const&                       resourcePackManager,
        ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> validator,
        ::IMinecraftEventing&                              eventing,
        ::std::function<void(
            ::ItemRegistryRef,
            ::BlockDefinitionGroup const&,
            ::CreativeItemRegistry*,
            ::BaseGameVersion const&,
            ::Experiments const&,
            ::ResourcePackManager const&,
            ::cereal::ReflectionCtx const&,
            ::Bedrock::NonOwnerPointer<::LinkedAssetValidator>,
            ::IMinecraftEventing&
        )>                                                 registerCallback
    );
 
    MCAPI void initServer(
        ::Experiments const&                               experiments,
        ::BaseGameVersion const&                           baseGameVersion,
        ::ResourcePackManager*                             rpm,
        ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> validator,
        ::IMinecraftEventing&                              eventing
    );
 
    MCAPI bool isComplexAlias(::HashedString const& oldName) const;
 
    MCAPI ::WeakPtr<::Item> lookupByName(::HashedString const& inString) const;
 
    MCAPI ::WeakPtr<::Item> lookupByName(int& inOutItemAux, ::std::string_view inString) const;
 
    MCAPI ::WeakPtr<::Item> lookupByName(int& outItemId, int& inOutItemAux, ::std::string_view inString) const;
 
    MCAPI ::WeakPtr<::Item> lookupByNameNoAlias(::std::string_view inString) const;
 
    MCAPI ::WeakPtr<::Item> lookupByNameNoParsing(int& inOutItemAux, ::HashedString const& fullName) const;
 
    MCFOLD ::WeakPtr<::Item> lookupByVanillaName(::HashedString const& inString) const;
 
#ifdef LL_PLAT_C
    MCAPI void matchServerItemIds(::std::vector<::ItemData> const& serverItemData);
#endif
 
    MCAPI void onLevelInit(
        ::WeakRef<::IDynamicContainerSerialization> containerSerialization,
        ::WeakRef<::IContainerRegistryAccess>       containerAccess,
        ::WeakRef<::IContainerRegistryTracker>      containerTracker
    );
 
    MCAPI void
    registerAlias(::HashedString const& alias, ::HashedString const& name, ::BaseGameVersion const& fromVersion);
 
    MCAPI ::WeakPtr<::Item>
    registerComplexAlias(::HashedString const& alias, ::ItemRegistryComplexAlias const& complexAlias);
 
    MCAPI void registerItem(::SharedPtr<::Item> item);
 
    MCAPI void registerLegacyID(::HashedString const& name, short id);
 
    MCAPI void registerLegacyMapping(
        ::HashedString const&    alias,
        ::HashedString const&    name,
        ::BaseGameVersion const& fromVersion
    );
 
    MCAPI void registerValidatorIdentifier(::std::string const& str);
 
    MCAPI uint64 remapToFullLegacyNameByHash(uint64 newHash);
 
    MCAPI uint64 remapToLegacyNameByHash(uint64 newHash);
 
#ifdef LL_PLAT_C
    MCAPI void setItemId(::HashedString const& itemName, short itemId, bool isComponentBased);
#endif
 
    MCAPI void shutdown();
 
    MCAPI void unregisterItem(::HashedString const& itemName);
 
    MCAPI ::std::vector<::std::string> validateServerItemComponents(::std::vector<::ItemData> const& items);
 
    MCAPI ~ItemRegistry();
    // NOLINTEND
 
public:
    // static functions
    // NOLINTBEGIN
    MCAPI static ::std::vector<::ItemRegistry::LoadedItemAsset> _loadAllItemAssets(
        ::ResourcePackManager const&                       resourcePackManager,
        ::Experiments const&                               experiments,
        ::cereal::ReflectionCtx const&                     ctx,
        ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> validator
    );
 
    MCAPI static ::ItemRegistry::ItemLoadResult _tryLoadItemAsset(
        ::std::string_view                   jsonData,
        ::std::shared_ptr<::PackLoadContext> packLoadContext,
        ::Core::Path const&                  filenameWithExtension,
        ::cereal::ReflectionCtx const&       ctx,
        ::std::string const&                 packName
    );
 
    MCAPI static ::ItemRegistry::ParsedName _tryParseItemName(
        ::rapidjson::GenericValue<
            ::rapidjson::UTF8<char>,
            ::rapidjson::MemoryPoolAllocator<::rapidjson::CrtAllocator>> const& itemData
    );
 
    MCAPI static short getBlockItemId(::Block const& block);
 
    MCAPI static short getBlockItemId(::BlockType const& block);
    // NOLINTEND
 
public:
    // static variables
    // NOLINTBEGIN
    MCAPI static ::std::string_view const& MINECRAFT_NAMESPACE();
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCAPI void* $ctor();
    // NOLINTEND
 
public:
    // destructor thunk
    // NOLINTBEGIN
    MCAPI void $dtor();
    // NOLINTEND
};