SimulatedPlayer.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
#include "mc/deps/core/math/Vec2.h"
#include "mc/deps/core/math/Vec3.h"
#include "mc/server/sim/LookDuration.h"
#include "mc/world/actor/player/PlayerInventory.h"
#include "mc/world/actor/provider/SynchedActorDataAccess.h"
 
// auto generated inclusion list
#include "mc/certificates/identity/PlayerAuthenticationType.h"
#include "mc/common/SubClientId.h"
#include "mc/deps/core/utility/NonOwnerPointer.h"
#include "mc/scripting/modules/minecraft/ScriptFacing.h"
#include "mc/server/ServerPlayer.h"
#include "mc/server/sim/BuildIntent.h"
#include "mc/server/sim/LookAtIntent.h"
#include "mc/server/sim/LookDuration.h"
#include "mc/server/sim/MovementIntent.h"
#include "mc/world/actor/ActorInitializationMethod.h"
#include "mc/world/actor/player/PlayerMovementSettings.h"
#include "mc/world/level/BlockPos.h"
#include "mc/world/level/GameType.h"
#include "mc/world/level/storage/PlayerSuspendLevelStorageSaveToken.h"
 
// auto generated forward declare list
// clang-format off
class Actor;
class ChunkSource;
class ChunkViewSource;
class EntityContext;
class ItemStack;
class Level;
class NavigationComponent;
class NetworkIdentifier;
class PacketSender;
class ServerNetworkHandler;
class ServerNetworkSystem;
class Vec2;
class Vec3;
struct ActorUniqueID;
struct DimensionType;
struct PlayerAuthenticationInfo;
struct VariantParameterList;
namespace ClientBlobCache::Server { class ActiveTransfersManager; }
namespace ScriptModuleGameTest { struct ScriptNavigationResult; }
namespace gametest { class BaseGameTestHelper; }
namespace mce { class UUID; }
// clang-format on
 
class SimulatedPlayer : public ::ServerPlayer {
public:
    LLAPI static optional_ref<SimulatedPlayer>
    create(std::string const& name, Vec3 const& pos, DimensionType dimId = 0, Vec2 const& rotation = {0, 0});
 
    bool simulateSneaking() {
        setSneaking(true);
        return SynchedActorDataAccess::getActorFlag(mEntityContext, ActorFlags::Sneaking);
    }
    bool simulateStopSneaking() {
        setSneaking(false);
        return !SynchedActorDataAccess::getActorFlag(mEntityContext, ActorFlags::Sneaking);
    }
    bool       simulateUseItem() { return simulateUseItemInSlot(mInventory->mSelected); }
    LLAPI bool simulateUseItem(ItemStack& item);
 
    LLAPI bool simulateDestroyBlock(BlockPos const&, ScriptModuleMinecraft::ScriptFacing);
    LLAPI bool simulateDestroyLookAt(float handLength = 5.5f);
    LLAPI void simulateStopMoving();
    LLAPI bool simulateAttack(Actor* target);
    LLAPI void simulateStartBuildInSlot(int slot);
    LLAPI void simulateStopBuild();
    LLAPI void simulateStopUsingItem();
    LLAPI bool simulateGiveItem(ItemStack& item, bool selectSlot);
    LLAPI bool simulateSetItem(ItemStack const& item, bool selectSlot, int slot);
    LLAPI bool simulateDropSelectedItem();
    LLAPI bool simulateInteract(Actor& actor);
    LLAPI void simulateStopInteracting();
    LLAPI bool isSimulatingDestroyingBlock();
    // LLAPI void simulateLookAt(Vec3 const& pos, sim::LookDuration lookType = sim::LookDuration::Instant);
    LLAPI void simulateLookAt(Actor& actor, sim::LookDuration lookType = sim::LookDuration::Instant);
    // LLAPI void simulateLookAt(BlockPos const& blockPos, sim::LookDuration lookType = sim::LookDuration::Instant);
    LLAPI void simulateDisconnect();
    LLAPI bool simulateRespawn();
    LLAPI void simulateFly();
    LLAPI void simulateStopFlying();
    LLAPI void simulateWorldMove(::Vec3 const& worldDirection, float = 1.0f);
    LLAPI void simulateLocalMove(::Vec3 const& localDirection, float = 1.0f);
    LLAPI void simulateMoveToLocation(::Vec3 const& position, float speed, bool faceTarget);
    LLAPI void simulateStopDestroyingBlock();
    LLAPI bool simulateInteract(::BlockPos const& pos, ::ScriptModuleMinecraft::ScriptFacing face);
 
    LLAPI static ::SimulatedPlayer* tryGetFromEntity(::EntityContext& entity, bool includeRemoved);
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<8, 48, ::sim::MovementIntent>                                      mSimulatedMovement;
    ::ll::TypedStorage<1, 2, ::sim::BuildIntent>                                          mBuildIntention;
    ::ll::TypedStorage<8, 40, ::sim::LookAtIntent>                                        mLookAtIntent;
    ::ll::TypedStorage<4, 16, ::std::optional<::BlockPos>>                                mDestroyingBlockPos;
    ::ll::TypedStorage<1, 2, ::std::optional<uchar>>                                      mDestroyingBlockFace;
    ::ll::TypedStorage<8, 24, ::Bedrock::NonOwnerPointer<::gametest::BaseGameTestHelper>> mGameTestHelper;
    ::ll::TypedStorage<8, 16, ::std::optional<uint64>>                                    mInputCooldownTick;
    ::ll::TypedStorage<8, 64, ::PlayerMovementSettings>                                   mMovementSettings;
    ::ll::TypedStorage<4, 4, float>                                                       mBaseInputSpeed;
    ::ll::TypedStorage<8, 32, ::std::string>                                              mXuid;
    ::ll::TypedStorage<8, 40, ::PlayerSuspendLevelStorageSaveToken const> mPlayerSuspendLevelStorageSaveToken;
    // NOLINTEND
 
public:
    // prevent constructor by default
    SimulatedPlayer();
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual void
    initializeComponents(::ActorInitializationMethod method, ::VariantParameterList const& params) /*override*/;
 
    virtual void aiStep() /*override*/;
 
    virtual bool isSimulated() const /*override*/;
 
    virtual ::std::string getXuid() const /*override*/;
 
    virtual ::PlayerMovementSettings const& getMovementSettings() const /*override*/;
 
    virtual void teleportTo(
        ::Vec3 const& pos,
        bool          shouldStopRiding,
        int           cause,
        int           sourceEntityType,
        bool          keepVelocity
    ) /*override*/;
 
    virtual int _getSpawnChunkLimit() const /*override*/;
 
    virtual ::std::shared_ptr<::ChunkViewSource> _createChunkSource(::ChunkSource& mainChunkSource) /*override*/;
 
    virtual void _updateChunkPublisherView(::Vec3 const& position, float minDistance) /*override*/;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCNAPI SimulatedPlayer(
        ::Level&                                           level,
        ::PacketSender&                                    packetSender,
        ::ServerNetworkSystem&                             network,
        ::ClientBlobCache::Server::ActiveTransfersManager& clientCacheMirror,
        ::GameType                                         playerGameType,
        ::NetworkIdentifier const&                         owner,
        ::SubClientId                                      subid,
        ::std::function<void(::ServerPlayer&)>             playerLoadedCallback,
        ::mce::UUID                                        uuid,
        ::std::string const&                               deviceId,
        ::PlayerAuthenticationType                         authType,
        ::PlayerAuthenticationInfo const&                  authInfo,
        int                                                maxChunkRadius,
        bool                                               enableItemStackNetManager,
        ::EntityContext&                                   entityContext
    );
 
    MCNAPI void _addMoveComponent();
 
    MCNAPI ::ScriptModuleGameTest::ScriptNavigationResult
    _createNavigationResult(::NavigationComponent* navigation) const;
 
    MCNAPI void _updateDestroyBlock();
 
    MCNAPI void _updateMovement();
 
    MCNAPI void _updateRidingComponents();
 
    MCNAPI void postAiStep();
 
    MCNAPI void preAiStep();
 
    MCAPI void setGameTestHelper(::Bedrock::NonOwnerPointer<::gametest::BaseGameTestHelper> gameTestHelper);
 
    MCAPI bool simulateAttack();
 
    MCAPI void simulateChat(::std::string const& message);
 
    MCAPI bool simulateInteract();
 
    MCAPI bool simulateJump();
 
    MCAPI void simulateLookAt(::BlockPos const& blockPos, ::sim::LookDuration lookType);
 
    MCAPI void simulateLookAt(::Vec3 const& pos, ::sim::LookDuration lookType = sim::LookDuration::Instant);
 
    MCAPI ::ScriptModuleGameTest::ScriptNavigationResult simulateNavigateToEntity(::Actor& actor, float speed);
 
    MCAPI ::ScriptModuleGameTest::ScriptNavigationResult
    simulateNavigateToLocation(::Vec3 const& position, float speed);
 
    MCAPI void simulateNavigateToLocations(::std::vector<::Vec3>&& positions, float speed);
 
    MCAPI void simulateSetBodyRotation(float degY);
 
    MCAPI bool simulateUseItemInSlot(int slot);
 
    MCAPI bool simulateUseItemInSlotOnBlock(
        int                                   slot,
        ::BlockPos const&                     pos,
        ::ScriptModuleMinecraft::ScriptFacing face,
        ::Vec3 const&                         facePos
    );
 
    MCAPI bool simulateUseItemOnBlock(
        ::ItemStack&                          item,
        ::BlockPos const&                     pos,
        ::ScriptModuleMinecraft::ScriptFacing face,
        ::Vec3 const&                         facePos
    );
    // NOLINTEND
 
public:
    // static functions
    // NOLINTBEGIN
    MCNAPI static ::SimulatedPlayer* create(
        ::std::string const&                                  name,
        ::Vec3 const&                                         spawnPos,
        ::DimensionType                                       dimensionId,
        ::Bedrock::NotNullNonOwnerPtr<::ServerNetworkHandler> serverNetworkHandler,
        ::std::string const&                                  xuid,
        ::std::optional<::ActorUniqueID>                      idOverride
    );
 
    MCAPI static ::SimulatedPlayer* create(
        ::std::string const&                                  name,
        ::Vec3 const&                                         spawnPos,
        ::Vec3 const&                                         spawnPosDelta,
        ::Vec2 const&                                         spawnRotation,
        bool                                                  spawnLoadedFromSave,
        ::DimensionType                                       dimensionId,
        ::Bedrock::NotNullNonOwnerPtr<::ServerNetworkHandler> serverNetworkHandler,
        ::std::string const&                                  xuid,
        ::std::optional<::ActorUniqueID>                      idOverride
    );
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCNAPI void* $ctor(
        ::Level&                                           level,
        ::PacketSender&                                    packetSender,
        ::ServerNetworkSystem&                             network,
        ::ClientBlobCache::Server::ActiveTransfersManager& clientCacheMirror,
        ::GameType                                         playerGameType,
        ::NetworkIdentifier const&                         owner,
        ::SubClientId                                      subid,
        ::std::function<void(::ServerPlayer&)>             playerLoadedCallback,
        ::mce::UUID                                        uuid,
        ::std::string const&                               deviceId,
        ::PlayerAuthenticationType                         authType,
        ::PlayerAuthenticationInfo const&                  authInfo,
        int                                                maxChunkRadius,
        bool                                               enableItemStackNetManager,
        ::EntityContext&                                   entityContext
    );
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCNAPI void $initializeComponents(::ActorInitializationMethod method, ::VariantParameterList const& params);
 
    MCNAPI void $aiStep();
 
    MCNAPI bool $isSimulated() const;
 
    MCNAPI ::std::string $getXuid() const;
 
    MCNAPI ::PlayerMovementSettings const& $getMovementSettings() const;
 
    MCAPI void
    $teleportTo(::Vec3 const& pos, bool shouldStopRiding, int cause, int sourceEntityType, bool keepVelocity);
 
    MCNAPI int $_getSpawnChunkLimit() const;
 
    MCAPI ::std::shared_ptr<::ChunkViewSource> $_createChunkSource(::ChunkSource& mainChunkSource);
 
    MCNAPI void $_updateChunkPublisherView(::Vec3 const& position, float minDistance);
 
 
    // NOLINTEND
};