ActorFactory.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/deps/core/utility/NonOwnerPointer.h"
#include "mc/deps/game_refs/OwnerPtr.h"
#include "mc/world/actor/ActorType.h"
 
// auto generated forward declare list
// clang-format off
class Actor;
class ActorComponentFactory;
class ActorDefinitionGroup;
class ActorGoalFactory;
class ActorMigratedDefinitionFactory;
class BlockPos;
class BlockSource;
class CompoundTag;
class DataLoadHelper;
class DimensionHeightRange;
class EntityContext;
class Experiments;
class IEntityInitializer;
class Level;
class LevelChunk;
class Vec2;
class Vec3;
struct ActorDefinitionIdentifier;
struct ActorFactoryData;
struct ActorInfo;
// clang-format on
 
class ActorFactory {
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::Level>>                  mLevel;
    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::IEntityInitializer>>                 mEntityInitializer;
    ::ll::TypedStorage<8, 24, ::Bedrock::NonOwnerPointer<::ActorDefinitionGroup>>      mDefinitions;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::std::string, ::ActorFactoryData>> mFactoryFunctions;
    ::ll::TypedStorage<8, 16, ::std::set<::std::string>>                               mExperimentalEntities;
    ::ll::TypedStorage<8, 24, ::std::vector<::ActorFactoryData>>                       mVanillaActors;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ActorComponentFactory>>               mComponentFactory;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ActorGoalFactory>>                    mGoalFactory;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ActorMigratedDefinitionFactory>>      mActorMigratedFactory;
    // NOLINTEND
 
public:
    // prevent constructor by default
    ActorFactory();
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ~ActorFactory();
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI ActorFactory(::Bedrock::NotNullNonOwnerPtr<::Level> level, ::Experiments const& experiments);
 
    MCAPI void _buildSummonableActorList(
        ::Experiments const&                                                   experiments,
        ::std::function<void(::std::string const&, ::ActorFactoryData const&)> callback
    ) const;
 
    MCAPI ::OwnerPtr<::EntityContext> _constructActor(
        ::ActorDefinitionIdentifier const&  identifier,
        ::Vec3 const&                       position,
        ::Vec2 const&                       rotation,
        ::std::vector<::std::string> const* previousDefinitions
    ) const;
 
    MCAPI void _loadDefinitionGroups(::ActorDefinitionGroup* group);
 
    MCAPI void _loadDefinitionsHelper();
 
    MCAPI bool _validateActorData(
        ::CompoundTag&               tag,
        ::ActorDefinitionIdentifier& outDefinition,
        ::Vec3&                      outPosition,
        ::LevelChunk const*          levelChunk
    ) const;
 
    MCAPI void applyEntityInitializer(::std::unique_ptr<::Actor> actor, ::EntityContext& entity) const;
 
    MCAPI ::std::vector<::std::pair<::std::string, ::ActorDefinitionIdentifier const*>>
    buildSummonEntityTypeEnum(::Experiments const& experiments) const;
 
    MCAPI void clearDefinitionGroup();
 
    MCAPI ::OwnerPtr<::EntityContext> clientCreateDisplayActor(
        ::ActorDefinitionIdentifier const& identifier,
        ::Actor*                           spawner,
        ::Vec3 const&                      position,
        ::Vec2 const&                      rotation
    );
 
    MCAPI ::OwnerPtr<::EntityContext> createActor(
        ::std::string const&               method,
        ::ActorDefinitionIdentifier const& identifier,
        ::Actor*                           spawner,
        ::Vec3 const&                      position,
        ::Vec2 const&                      rotation
    );
 
    MCAPI ::OwnerPtr<::EntityContext> createBornActor(::ActorDefinitionIdentifier const& identifier, ::Actor* parent);
 
    MCAPI ::OwnerPtr<::EntityContext>
    createBornActor(::ActorDefinitionIdentifier const& identifier, ::BlockPos const& pos);
 
    MCAPI ::OwnerPtr<::EntityContext> createSpawnedActor(
        ::ActorDefinitionIdentifier const& identifier,
        ::Actor*                           spawner,
        ::Vec3 const&                      position,
        ::Vec2 const&                      rotation
    );
 
    MCAPI ::OwnerPtr<::EntityContext>
    createSummonedActor(::ActorDefinitionIdentifier const& identifier, ::Actor* spawner, ::Vec3 const& position);
 
    MCAPI ::OwnerPtr<::EntityContext>
    createTransformedActor(::ActorDefinitionIdentifier const& identifier, ::Actor* from);
 
#ifdef LL_PLAT_C
    MCAPI void digestIdentifierListFromServer(::std::vector<::ActorInfo> const& identifierList);
 
    MCAPI ::std::vector<::std::string> generateActorIdentifierList() const;
#endif
 
    MCFOLD ::ActorGoalFactory& getGoalFactory();
 
    MCFOLD ::ActorMigratedDefinitionFactory& getMigratedDefinitionFactory();
 
    MCAPI void init(::Experiments const& experiments);
 
    MCAPI ::OwnerPtr<::EntityContext> loadActor(::CompoundTag* tag, ::DataLoadHelper& dataLoadHelper);
 
    MCAPI ::OwnerPtr<::EntityContext>
    loadActor(::CompoundTag* tag, ::DataLoadHelper& dataLoadHelper, ::DimensionHeightRange const& heightRange);
 
    MCAPI ::OwnerPtr<::EntityContext> loadActor(
        ::CompoundTag*                tag,
        ::DataLoadHelper&             dataLoadHelper,
        ::DimensionHeightRange const& heightRange,
        ::LevelChunk const*           levelChunk
    );
 
    MCAPI ::ActorType lookupEntityType(::ActorDefinitionIdentifier const& identifier) const;
 
    MCAPI void setDefinitionGroup(::ActorDefinitionGroup* group);
 
    MCFOLD void setEntityInitializer(::std::shared_ptr<::IEntityInitializer> entityInitializer);
 
    MCAPI void setVanillaActors(::std::vector<::ActorFactoryData> vanillaActors);
    // NOLINTEND
 
public:
    // static functions
    // NOLINTBEGIN
    MCAPI static void fillFactoryData(
        ::ActorDefinitionIdentifier const&                             identifier,
        ::ActorDefinitionIdentifier const&                             baseIdentifier,
        ::std::unordered_map<::std::string, ::ActorFactoryData> const& factoryFunctions,
        ::ActorFactoryData&                                            data
    );
 
    MCAPI static ::Actor* fixLegacyEntity(::BlockSource& region, ::CompoundTag const* tag);
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCAPI void* $ctor(::Bedrock::NotNullNonOwnerPtr<::Level> level, ::Experiments const& experiments);
    // NOLINTEND
 
public:
    // destructor thunk
    // NOLINTBEGIN
    MCAPI void $dtor();
    // NOLINTEND
 
public:
    // vftables
    // NOLINTBEGIN
    MCNAPI static void** $vftable();
    // NOLINTEND
};