d6/de6/Mob_8h_source.html

#pragma once


#include "mc/_HeaderOutputPredefine.h"


// auto generated inclusion list

#include "mc/deps/shared_types/legacy/EquipmentSlot.h"

#include "mc/deps/shared_types/legacy/LevelSoundEvent.h"

#include "mc/deps/shared_types/legacy/actor/ActorDamageCause.h"

#include "mc/deps/shared_types/legacy/actor/ArmorSlot.h"

#include "mc/legacy/ActorUniqueID.h"

#include "mc/world/actor/Actor.h"

#include "mc/world/actor/ActorEvent.h"

#include "mc/world/actor/ActorInitializationMethod.h"

#include "mc/world/actor/ActorSwingSource.h"

#include "mc/world/actor/ArmorMaterialType.h"

#include "mc/world/actor/BuiltInMobComponents.h"

#include "mc/world/actor/MobSpawnMethod.h"

#include "mc/world/actor/TravelType.h"

#include "mc/world/item/ClockSpriteCalculator.h"

#include "mc/world/item/CompassSpriteCalculator.h"

#include "mc/world/item/HandSlot.h"

#include "mc/world/level/BlockPos.h"


// auto generated forward declare list

// clang-format off

class AABB;

class ActorDamageSource;

class ActorDefinitionGroup;

class ActorHurtResult;

class BaseAttributeMap;

class Block;

class BodyControl;

class CompoundTag;

class DataLoadHelper;

class EntityContext;

class HashedString;

class ILevel;

class ItemStack;

class ListTag;

class Player;

class SaveContext;

class SynchedActorDataWriter;

class Vec3;

struct ActorDefinitionIdentifier;

struct CalculateAttackDamageSettings;

struct DimensionType;

struct HurtEffectsSettings;

struct HurtParameters;

struct InterpolationPair;

struct JumpPreventionResult;

struct KnockbackParameters;

struct LegacyGoalDefinition;

struct VariantParameterList;

namespace mce { class UUID; }

class IOptionsReader;

// clang-format on


class Mob : public ::Actor {

public:

    LLAPI void refreshInventory();


    LLAPI static ::Mob* tryGetFromEntity(::EntityContext& entity, bool includeRemoved);


    LLNDAPI ItemStack const& getItemSlot(::SharedTypes::Legacy::EquipmentSlot slot) const;


public:

    // member variables

    // NOLINTBEGIN

    ::ll::TypedStorage<4, 4, float>                       mHurtDir;

    ::ll::TypedStorage<4, 4, float>                       mOTilt;

    ::ll::TypedStorage<4, 4, float>                       mTilt;

    ::ll::TypedStorage<8, 32, ::CompassSpriteCalculator>  mCompassSpriteCalc;

    ::ll::TypedStorage<8, 32, ::CompassSpriteCalculator>  mRecoveryCompassSpriteCalc;

    ::ll::TypedStorage<4, 12, ::ClockSpriteCalculator>    mClockSpriteCalc;

    ::ll::TypedStorage<4, 4, float>                       mAttackAnim;

    ::ll::TypedStorage<4, 4, int>                         mSwingTime;

    ::ll::TypedStorage<8, 32, ::BuiltInMobComponents>     mBuiltInMobComponents;

    ::ll::TypedStorage<4, 4, float>                       mMovementComponentCurrentSpeed;

    ::ll::TypedStorage<1, 2, ::std::optional<::HandSlot>> mSwingingHand;

    ::ll::TypedStorage<1, 1, bool>                        mSurfaceMob;

    ::ll::TypedStorage<1, 1, bool>                        mNaturallySpawned;

    ::ll::TypedStorage<1, 1, bool>                        mWantsToBeJockey;

    ::ll::TypedStorage<1, 1, bool>                        mHasBoundOrigin;

    ::ll::TypedStorage<1, 1, ::MobSpawnMethod>            mSpawnMethod;

    ::ll::TypedStorage<1, 1, bool>                        mCreateAiOnReload;

    ::ll::TypedStorage<8, 8, ::ActorUniqueID>             mCaravanHead;

    ::ll::TypedStorage<8, 8, ::ActorUniqueID>             mCaravanTail;

    ::ll::TypedStorage<4, 4, float>                       mOAttackAnim;

    ::ll::TypedStorage<4, 12, ::BlockPos>                 mBoundOrigin;

    ::ll::TypedStorage<8, 8, ::ActorUniqueID>             mTargetCaptainId;

    // NOLINTEND


public:

    // prevent constructor by default

    Mob();


public:

    // virtual functions

    // NOLINTBEGIN

    virtual void

    initializeComponents(::ActorInitializationMethod method, ::VariantParameterList const& params) /*override*/;


    virtual void reloadHardcodedClient(::ActorInitializationMethod method) /*override*/;


    virtual void reloadHardcoded(::ActorInitializationMethod method, ::VariantParameterList const& params) /*override*/;


    virtual ~Mob() /*override*/;


    virtual void knockback(::Actor* source, float damage, float xd, float zd, ::KnockbackParameters const& parameters);


    virtual void kill() /*override*/;


    virtual void die(::ActorDamageSource const& source) /*override*/;


    virtual bool shouldDropDeathLoot() const /*override*/;


    virtual void spawnAnim();


    virtual bool isAlive() const /*override*/;


    virtual bool isSleeping() const /*override*/;


    virtual void setSleeping(bool val) /*override*/;


    virtual bool isBlocking() const /*override*/;


    virtual void setSprinting(bool shouldSprint);


    virtual bool canBePulledIntoVehicle() const /*override*/;


    virtual float getSpeed() const;


    virtual void setSpeed(float speed);


    virtual float getYawSpeedInDegreesPerSecond() const /*override*/;


    virtual void normalTick() /*override*/;


    virtual void baseTick() /*override*/;


    virtual void hurtEffects(::ActorDamageSource const& source, float damage, ::HurtEffectsSettings const& settings);


    virtual void damageCarriedItemOnAttack(::Actor& target, float damageDealtToTarget);


    virtual ::ActorHurtResult doFireHurt(int amount) /*override*/;


    virtual void aiStep();


    virtual void pushActors();


    virtual bool checkSpawnRules(bool fromSpawner);


    virtual bool checkSpawnObstruction() const;


    virtual void addPassenger(::Actor& newPassenger) /*override*/;


    virtual bool startRiding(::Actor& vehicle, bool forceRiding) /*override*/;


    virtual void handleEntityEvent(::ActorEvent id, int data) /*override*/;


    virtual int getItemUseDuration() const;


    virtual float getItemUseStartupProgress() const;


    virtual float getItemUseIntervalProgress() const;


    virtual bool swing(::ActorSwingSource swingSource, ::HandSlot handSlot) /*override*/;


    virtual float getMaxHeadXRot();


    virtual bool isImmobile() const /*override*/;


    virtual void blockedByShield(::ActorDamageSource const& source, ::Actor& blocker) /*override*/;


    virtual void setTarget(::Actor* target) /*override*/;


    virtual ::ActorHurtResult

    attack(::Actor& target, ::SharedTypes::Legacy::ActorDamageCause const& cause) /*override*/;


    virtual bool isAlliedTo(::Mob* other);


    virtual ::ActorHurtResult doHurtTarget(::Actor* target, ::SharedTypes::Legacy::ActorDamageCause const& cause);


    virtual ::SharedTypes::Legacy::ActorDamageCause getBlockDamageCause(::Block const& block) const /*override*/;


    virtual bool inCaravan() const /*override*/;


    virtual int getArmorValue() const;


    virtual void hurtArmorSlots(::ActorDamageSource const& source, int damage, ::std::bitset<5> const hurtSlots);


    virtual void setDamagedArmor(::SharedTypes::Legacy::ArmorSlot slot, ::ItemStack const& item);


    virtual void sendArmorDamage(::std::bitset<5> const damagedSlots);


    virtual void sendArmor(::std::bitset<5> const armorSlots);


    virtual ::ArmorMaterialType getArmorMaterialTypeInSlot(::SharedTypes::Legacy::ArmorSlot slot) const /*override*/;


    virtual int getArmorTextureIndexInSlot(::SharedTypes::Legacy::ArmorSlot slot) const /*override*/;


    virtual float getArmorColorInSlot(::SharedTypes::Legacy::ArmorSlot slot, int channelRGBA) const /*override*/;


    virtual ::std::vector<::ItemStack const*> getAllHandEquipment() const;


    virtual ::std::vector<::ItemStack const*> getAllEquipment() const;


    virtual int getDeathTime() const /*override*/;


    virtual void dropEquipmentOnDeath(::ActorDamageSource const& source);


    virtual void dropEquipmentOnDeath();


    virtual void clearVanishEnchantedItemsOnDeath();


    virtual void sendInventory(bool shouldSelectSlot);


    virtual void buildDebugInfo(::std::string& out) const /*override*/;


    virtual float getInterpolatedBodyRot(float a) const /*override*/;


    virtual float getInterpolatedHeadRot(float a) const /*override*/;


    virtual float getInterpolatedBodyYaw(float a) const /*override*/;


    virtual bool isSurfaceMob() const /*override*/;


    virtual float getDamageAfterEnchantReduction(::ActorDamageSource const& source, float damage) const;


    virtual bool createAIGoals();


    virtual void onBorn(::Actor&, ::Actor&);


    virtual bool setItemSlot(::SharedTypes::Legacy::EquipmentSlot slot, ::ItemStack const& item);


    virtual void setTransitioningSitting(bool value);


    virtual bool hasComponent(::HashedString const& name) const /*override*/;


    virtual bool canChangeDimensionsUsingPortal() const /*override*/;


    virtual void teleportTo(

        ::Vec3 const& pos,

        bool          shouldStopRiding,

        int           cause,

        int           sourceEntityType,

        bool          keepVelocity

    ) /*override*/;


    virtual float _getWalkTargetValue(::BlockPos const& pos);


    virtual bool canExistWhenDisallowMob() const;


    virtual bool canPowerJump() const /*override*/;


    virtual void setEquippedSlot(::SharedTypes::Legacy::EquipmentSlot slot, ::ItemStack const& item) /*override*/;


    virtual void renderDebugServerState(::IOptionsReader const& options) /*override*/;


    virtual void addAdditionalSaveData(::CompoundTag& entityTag) const /*override*/;


    virtual void readAdditionalSaveData(::CompoundTag const& tag, ::DataLoadHelper& dataLoadHelper) /*override*/;


    virtual ::std::unique_ptr<::BodyControl> initBodyControl();


    virtual float causeFallDamageToActor(float distance, float multiplier, ::ActorDamageSource source) /*override*/;


    virtual void outOfWorld() /*override*/;


    virtual ::ActorHurtResult

    _hurt(::ActorDamageSource const& source, float damage, ::HurtParameters const& hurtParameters) /*override*/;


    virtual void newServerAiStep();


    virtual void _doInitialMove() /*override*/;


    virtual ::AABB _getAdjustedAABBForSpawnCheck(::AABB const& aabb, ::Vec3 const& mobPos) const;

    // NOLINTEND


public:

    // member functions

    // NOLINTBEGIN

    MCNAPI Mob(::ILevel& level, ::EntityContext& entityContext);


    MCNAPI

    Mob(::ActorDefinitionGroup*            definitions,

        ::ActorDefinitionIdentifier const& definitionName,

        ::EntityContext&                   entityContext);


    MCNAPI ::BuiltInMobComponents _addBuiltInMobComponents();


    MCNAPI void _doSoulSpeedParticleEffect();


    MCNAPI void _doSprintParticleEffect();


    MCNAPI bool _initHardCodedComponents(bool isClientSide);


    MCNAPI void _initialize(::EntityContext& entityContext, bool isClientSide);


    MCNAPI bool _isDoingMaceSmashAttack() const;


    MCNAPI void _processSoulSpeed();


    MCNAPI void _updateSprintingState();


    MCAPI void

    addSpeedModifier(::mce::UUID const& attributeID, ::std::string const& attributeName, float speedModifier);


    MCNAPI float calcMoveRelativeSpeed(::TravelType travelType);


    MCAPI float calculateAttackDamage(::Actor const& target, ::CalculateAttackDamageSettings const& settings) const;


    MCAPI ::std::optional<float> checkTotemDeathProtection(::ActorDamageSource const& killingDamage);


    MCAPI void clearMainHandSlot();


    MCNAPI void containerChanged(int iSlot);


    MCNAPI void createAI(::std::vector<::LegacyGoalDefinition> goals);


    MCNAPI void dropContainer();


    MCNAPI void emitJumpPreventedEvent(::BlockPos const& pos);


#ifdef LL_PLAT_C

    MCNAPI ::std::vector<int> getAllArmorID() const;

#endif


    MCNAPI int getArmorTypeHash();


    MCNAPI int getCarriedItemKnockbackBonus() const;


    MCAPI float getDamageAfterArmorReduction(::ActorDamageSource const& source, float damage) const;


    MCNAPI float getDamageAfterDamageSensorComponentAdjustments(::ActorDamageSource const& source, float damage);


    MCNAPI float getJumpEffectAmplifierValue();


    MCNAPI float getJumpMultiplier();


    MCNAPI ::JumpPreventionResult getJumpPrevention();


    MCNAPI int getModifiedSwingDuration(::HandSlot handSlot) const;


    MCNAPI int getNoActionTime() const;


#ifdef LL_PLAT_C

    MCNAPI float getPassengerLockedBodyRot() const;


    MCNAPI float getPassengerRotLimit() const;

#endif


    MCNAPI ::SharedTypes::Legacy::LevelSoundEvent getSpawnSound() const;


#ifdef LL_PLAT_C

    MCNAPI float getSwimSpeedMultiplier() const;

#endif


    MCNAPI int getToughnessValue() const;


    MCNAPI ::TravelType getTravelType();


    MCAPI float getYBodyRotation() const;


#ifdef LL_PLAT_C

    MCNAPI ::InterpolationPair getYBodyRotationsNewOld() const;

#endif


    MCAPI void hurtArmor(::ActorDamageSource const& source, int damage);


    MCNAPI bool isAbleToMove() const;


    MCNAPI bool isTransitioningSitting() const;


    MCNAPI void joinCaravan(::Mob* head);


    MCAPI void jumpFromGround();


    MCNAPI void leaveCaravan();


    MCAPI void lookAt(::Actor* lookAt, float yMax, float xMax);


    MCNAPI void onPlayerDimensionChanged(::Player* player, ::DimensionType fromDimension, ::DimensionType toDimension);


    MCAPI void resetAttributes();


    MCNAPI void resetNoActionTime();


    MCNAPI ::std::unique_ptr<::ListTag> saveOffhand(::SaveContext const& saveContext) const;


    MCNAPI void setJumpTicks(int ticks);


    MCAPI void setSpeedModifier(float speed);


    MCAPI void setYBodyRotation(float rotation);


    MCAPI void setYBodyRotations(float rotation, float oldRotation);


    MCNAPI bool shouldApplyWaterGravity();


    MCNAPI void snapToYBodyRot(float yBodyRot);


    MCNAPI void tickMobEffectsVisuals();


    MCAPI void updateEquipment();


    MCNAPI void updateGlidingDurability();

    // NOLINTEND


public:

    // static functions

    // NOLINTBEGIN

    MCNAPI static void _registerMobAttributes(::BaseAttributeMap& attributes);


#ifdef LL_PLAT_C

    MCNAPI static void setSprinting(::BaseAttributeMap& attributes, ::SynchedActorDataWriter data, bool shouldSprint);

#endif

    // NOLINTEND


public:

    // constructor thunks

    // NOLINTBEGIN

    MCNAPI void* $ctor(::ILevel& level, ::EntityContext& entityContext);


    MCNAPI void* $ctor(

        ::ActorDefinitionGroup*            definitions,

        ::ActorDefinitionIdentifier const& definitionName,

        ::EntityContext&                   entityContext

    );

    // NOLINTEND


public:

    // destructor thunk

    // NOLINTBEGIN

    MCNAPI void $dtor();

    // NOLINTEND


public:

    // virtual function thunks

    // NOLINTBEGIN

    MCAPI void $initializeComponents(::ActorInitializationMethod method, ::VariantParameterList const& params);


    MCNAPI void $reloadHardcodedClient(::ActorInitializationMethod method);


    MCNAPI void $reloadHardcoded(::ActorInitializationMethod method, ::VariantParameterList const& params);


    MCAPI void $knockback(::Actor* source, float damage, float xd, float zd, ::KnockbackParameters const& parameters);


    MCNAPI void $kill();


    MCAPI void $die(::ActorDamageSource const& source);


    MCNAPI bool $shouldDropDeathLoot() const;


    MCNAPI void $spawnAnim();


    MCNAPI bool $isAlive() const;


    MCNAPI bool $isSleeping() const;


    MCNAPI void $setSleeping(bool val);


    MCNAPI bool $isBlocking() const;


    MCAPI void $setSprinting(bool shouldSprint);


    MCNAPI bool $canBePulledIntoVehicle() const;


    MCNAPI float $getSpeed() const;


    MCNAPI void $setSpeed(float speed);


    MCNAPI float $getYawSpeedInDegreesPerSecond() const;


    MCAPI void $normalTick();


    MCAPI void $baseTick();


    MCNAPI void $hurtEffects(::ActorDamageSource const& source, float damage, ::HurtEffectsSettings const& settings);


    MCNAPI void $damageCarriedItemOnAttack(::Actor& target, float damageDealtToTarget);


    MCNAPI ::ActorHurtResult $doFireHurt(int amount);


    MCAPI void $aiStep();


    MCAPI void $pushActors();


    MCAPI bool $checkSpawnRules(bool fromSpawner);


    MCAPI bool $checkSpawnObstruction() const;


    MCAPI void $addPassenger(::Actor& newPassenger);


    MCAPI bool $startRiding(::Actor& vehicle, bool forceRiding);


    MCNAPI void $handleEntityEvent(::ActorEvent id, int data);


    MCNAPI int $getItemUseDuration() const;


    MCNAPI float $getItemUseStartupProgress() const;


    MCNAPI float $getItemUseIntervalProgress() const;


    MCNAPI bool $swing(::ActorSwingSource swingSource, ::HandSlot handSlot);


    MCNAPI float $getMaxHeadXRot();


    MCNAPI bool $isImmobile() const;


    MCNAPI void $blockedByShield(::ActorDamageSource const& source, ::Actor& blocker);


    MCAPI void $setTarget(::Actor* target);


    MCAPI ::ActorHurtResult $attack(::Actor& target, ::SharedTypes::Legacy::ActorDamageCause const& cause);


    MCNAPI bool $isAlliedTo(::Mob* other);


    MCAPI ::ActorHurtResult $doHurtTarget(::Actor* target, ::SharedTypes::Legacy::ActorDamageCause const& cause);


    MCNAPI ::SharedTypes::Legacy::ActorDamageCause $getBlockDamageCause(::Block const& block) const;


    MCNAPI bool $inCaravan() const;


    MCNAPI int $getArmorValue() const;


    MCNAPI void $hurtArmorSlots(::ActorDamageSource const& source, int damage, ::std::bitset<5> const hurtSlots);


    MCNAPI void $setDamagedArmor(::SharedTypes::Legacy::ArmorSlot slot, ::ItemStack const& item);


    MCNAPI void $sendArmorDamage(::std::bitset<5> const damagedSlots);


    MCNAPI void $sendArmor(::std::bitset<5> const armorSlots);


    MCNAPI ::ArmorMaterialType $getArmorMaterialTypeInSlot(::SharedTypes::Legacy::ArmorSlot slot) const;


    MCNAPI int $getArmorTextureIndexInSlot(::SharedTypes::Legacy::ArmorSlot slot) const;


    MCNAPI float $getArmorColorInSlot(::SharedTypes::Legacy::ArmorSlot slot, int channelRGBA) const;


    MCNAPI ::std::vector<::ItemStack const*> $getAllHandEquipment() const;


    MCNAPI ::std::vector<::ItemStack const*> $getAllEquipment() const;


    MCNAPI int $getDeathTime() const;


    MCAPI void $dropEquipmentOnDeath(::ActorDamageSource const& source);


    MCAPI void $dropEquipmentOnDeath();


    MCNAPI void $clearVanishEnchantedItemsOnDeath();


    MCNAPI void $sendInventory(bool shouldSelectSlot);


    MCNAPI void $buildDebugInfo(::std::string& out) const;


    MCNAPI float $getInterpolatedBodyRot(float a) const;


    MCNAPI float $getInterpolatedHeadRot(float a) const;


    MCNAPI float $getInterpolatedBodyYaw(float a) const;


    MCNAPI bool $isSurfaceMob() const;


    MCAPI float $getDamageAfterEnchantReduction(::ActorDamageSource const& source, float damage) const;


    MCNAPI bool $createAIGoals();


    MCFOLD void $onBorn(::Actor&, ::Actor&);


    MCAPI bool $setItemSlot(::SharedTypes::Legacy::EquipmentSlot slot, ::ItemStack const& item);


    MCNAPI void $setTransitioningSitting(bool value);


    MCNAPI bool $hasComponent(::HashedString const& name) const;


    MCAPI bool $canChangeDimensionsUsingPortal() const;


    MCAPI void

    $teleportTo(::Vec3 const& pos, bool shouldStopRiding, int cause, int sourceEntityType, bool keepVelocity);


    MCNAPI float $_getWalkTargetValue(::BlockPos const& pos);


    MCNAPI bool $canExistWhenDisallowMob() const;


    MCNAPI bool $canPowerJump() const;


    MCAPI void $setEquippedSlot(::SharedTypes::Legacy::EquipmentSlot slot, ::ItemStack const& item);


    MCNAPI void $renderDebugServerState(::IOptionsReader const& options);


    MCNAPI void $addAdditionalSaveData(::CompoundTag& entityTag) const;


    MCNAPI void $readAdditionalSaveData(::CompoundTag const& tag, ::DataLoadHelper& dataLoadHelper);


    MCNAPI ::std::unique_ptr<::BodyControl> $initBodyControl();


    MCAPI float $causeFallDamageToActor(float distance, float multiplier, ::ActorDamageSource source);


    MCNAPI void $outOfWorld();


    MCAPI ::ActorHurtResult

    $_hurt(::ActorDamageSource const& source, float damage, ::HurtParameters const& hurtParameters);


    MCNAPI void $newServerAiStep();


    MCNAPI void $_doInitialMove();


    MCNAPI ::AABB $_getAdjustedAABBForSpawnCheck(::AABB const& aabb, ::Vec3 const& mobPos) const;


    // NOLINTEND


public:

    // vftables

    // NOLINTBEGIN

    MCNAPI static void** $vftable();

    // NOLINTEND

};


AABB
Definition AABB.h:18

ActorDamageSource
Definition ActorDamageSource.h:18

ActorDefinitionGroup
Definition ActorDefinitionGroup.h:26

ActorHurtResult
Definition ActorHurtResult.h:5

Actor::$canChangeDimensionsUsingPortal
MCAPI bool $canChangeDimensionsUsingPortal() const

BaseAttributeMap
Definition BaseAttributeMap.h:21

BlockPos
Definition BlockPos.h:14

Block
Definition Block.h:42

BodyControl
Definition BodyControl.h:13

CompoundTag
Definition CompoundTag.h:18

DataLoadHelper
Definition DataLoadHelper.h:20

EntityContext
Definition EntityContext.h:15

HashedString
Definition HashedString.h:5

ILevel
Definition ILevel.h:223

IOptionsReader
Definition IOptionsReader.h:5

ItemStack
Definition ItemStack.h:26

ListTag
Definition ListTag.h:19

Mob::$setTransitioningSitting
MCAPI void $setTransitioningSitting(bool value)

Mob::$doFireHurt
MCAPI::ActorHurtResult $doFireHurt(int amount)

Mob::getCarriedItemKnockbackBonus
MCAPI int getCarriedItemKnockbackBonus() const

Mob::$damageCarriedItemOnAttack
MCAPI void $damageCarriedItemOnAttack(::Actor &target, float damageDealtToTarget)

Mob::$createAIGoals
MCAPI bool $createAIGoals()

Mob::$getArmorColorInSlot
MCAPI float $getArmorColorInSlot(::SharedTypes::Legacy::ArmorSlot slot, int channelRGBA) const

Mob::$getItemUseStartupProgress
MCAPI float $getItemUseStartupProgress() const

Mob::updateGlidingDurability
MCAPI void updateGlidingDurability()

Mob::$isSleeping
MCAPI bool $isSleeping() const

Mob::$getInterpolatedBodyRot
MCAPI float $getInterpolatedBodyRot(float a) const

Mob::$_getAdjustedAABBForSpawnCheck
MCAPI::AABB $_getAdjustedAABBForSpawnCheck(::AABB const &aabb, ::Vec3 const &mobPos) const

Mob::$canExistWhenDisallowMob
MCAPI bool $canExistWhenDisallowMob() const

Mob::$canBePulledIntoVehicle
MCAPI bool $canBePulledIntoVehicle() const

Mob::$initBodyControl
MCAPI ::std::unique_ptr<::BodyControl > $initBodyControl()

Mob::$ctor
MCAPI void * $ctor(::ILevel &level, ::EntityContext &entityContext)

Mob::_updateSprintingState
MCAPI void _updateSprintingState()

Mob::$isImmobile
MCAPI bool $isImmobile() const

Mob::$reloadHardcodedClient
MCAPI void $reloadHardcodedClient(::ActorInitializationMethod method)

Mob::_doSprintParticleEffect
MCAPI void _doSprintParticleEffect()

Mob::$sendArmorDamage
MCAPI void $sendArmorDamage(::std::bitset< 5 > const damagedSlots)

Mob::Mob
MCAPI Mob(::ActorDefinitionGroup *definitions, ::ActorDefinitionIdentifier const &definitionName, ::EntityContext &entityContext)

Mob::$ctor
MCAPI void * $ctor(::ActorDefinitionGroup *definitions, ::ActorDefinitionIdentifier const &definitionName, ::EntityContext &entityContext)

Mob::$outOfWorld
MCAPI void $outOfWorld()

Mob::getToughnessValue
MCAPI int getToughnessValue() const

Mob::$getYawSpeedInDegreesPerSecond
MCAPI float $getYawSpeedInDegreesPerSecond() const

Mob::snapToYBodyRot
MCAPI void snapToYBodyRot(float yBodyRot)

Mob::getNoActionTime
MCAPI int getNoActionTime() const

Mob::$sendArmor
MCAPI void $sendArmor(::std::bitset< 5 > const armorSlots)

Mob::onPlayerDimensionChanged
MCAPI void onPlayerDimensionChanged(::Player *player, ::DimensionType fromDimension, ::DimensionType toDimension)

Mob::$kill
MCAPI void $kill()

Mob::getArmorTypeHash
MCAPI int getArmorTypeHash()

Mob::createAI
MCAPI void createAI(::std::vector<::LegacyGoalDefinition > goals)

Mob::$readAdditionalSaveData
MCAPI void $readAdditionalSaveData(::CompoundTag const &tag, ::DataLoadHelper &dataLoadHelper)

Mob::$buildDebugInfo
MCAPI void $buildDebugInfo(::std::string &out) const

Mob::$shouldDropDeathLoot
MCAPI bool $shouldDropDeathLoot() const

Mob::$canPowerJump
MCAPI bool $canPowerJump() const

Mob::containerChanged
MCAPI void containerChanged(int iSlot)

Mob::getTravelType
MCAPI::TravelType getTravelType()

Mob::$setDamagedArmor
MCAPI void $setDamagedArmor(::SharedTypes::Legacy::ArmorSlot slot, ::ItemStack const &item)

Mob::$setSleeping
MCAPI void $setSleeping(bool val)

Mob::isAbleToMove
MCAPI bool isAbleToMove() const

Mob::$swing
MCAPI bool $swing(::ActorSwingSource swingSource, ::HandSlot handSlot)

Mob::isTransitioningSitting
MCAPI bool isTransitioningSitting() const

Mob::$isBlocking
MCAPI bool $isBlocking() const

Mob::$getArmorMaterialTypeInSlot
MCAPI::ArmorMaterialType $getArmorMaterialTypeInSlot(::SharedTypes::Legacy::ArmorSlot slot) const

Mob::$handleEntityEvent
MCAPI void $handleEntityEvent(::ActorEvent id, int data)

Mob::$getItemUseIntervalProgress
MCAPI float $getItemUseIntervalProgress() const

Mob::$sendInventory
MCAPI void $sendInventory(bool shouldSelectSlot)

Mob::$hurtArmorSlots
MCAPI void $hurtArmorSlots(::ActorDamageSource const &source, int damage, ::std::bitset< 5 > const hurtSlots)

Mob::Mob
MCAPI Mob(::ILevel &level, ::EntityContext &entityContext)

Mob::$reloadHardcoded
MCAPI void $reloadHardcoded(::ActorInitializationMethod method, ::VariantParameterList const &params)

Mob::$getMaxHeadXRot
MCAPI float $getMaxHeadXRot()

Mob::_isDoingMaceSmashAttack
MCAPI bool _isDoingMaceSmashAttack() const

Mob::$getSpeed
MCAPI float $getSpeed() const

Mob::$getItemUseDuration
MCAPI int $getItemUseDuration() const

Mob::$getAllHandEquipment
MCAPI ::std::vector<::ItemStack const * > $getAllHandEquipment() const

Mob::getJumpMultiplier
MCAPI float getJumpMultiplier()

Mob::$isAlliedTo
MCAPI bool $isAlliedTo(::Mob *other)

Mob::$addAdditionalSaveData
MCAPI void $addAdditionalSaveData(::CompoundTag &entityTag) const

Mob::setJumpTicks
MCAPI void setJumpTicks(int ticks)

Mob::getSpawnSound
MCAPI::SharedTypes::Legacy::LevelSoundEvent getSpawnSound() const

Mob::_initialize
MCAPI void _initialize(::EntityContext &entityContext, bool isClientSide)

Mob::shouldApplyWaterGravity
MCAPI bool shouldApplyWaterGravity()

Mob::getModifiedSwingDuration
MCAPI int getModifiedSwingDuration(::HandSlot handSlot) const

Mob::joinCaravan
MCAPI void joinCaravan(::Mob *head)

Mob::$isSurfaceMob
MCAPI bool $isSurfaceMob() const

Mob::getJumpEffectAmplifierValue
MCAPI float getJumpEffectAmplifierValue()

Mob::$hasComponent
MCAPI bool $hasComponent(::HashedString const &name) const

Mob::$getAllEquipment
MCAPI ::std::vector<::ItemStack const * > $getAllEquipment() const

Mob::resetNoActionTime
MCAPI void resetNoActionTime()

Mob::_initHardCodedComponents
MCAPI bool _initHardCodedComponents(bool isClientSide)

Mob::_doSoulSpeedParticleEffect
MCAPI void _doSoulSpeedParticleEffect()

Mob::$inCaravan
MCAPI bool $inCaravan() const

Mob::emitJumpPreventedEvent
MCAPI void emitJumpPreventedEvent(::BlockPos const &pos)

Mob::_addBuiltInMobComponents
MCAPI::BuiltInMobComponents _addBuiltInMobComponents()

Mob::dropContainer
MCAPI void dropContainer()

Mob::$_getWalkTargetValue
MCAPI float $_getWalkTargetValue(::BlockPos const &pos)

Mob::saveOffhand
MCAPI ::std::unique_ptr<::ListTag > saveOffhand(::SaveContext const &saveContext) const

Mob::$renderDebugServerState
MCAPI void $renderDebugServerState(::IOptionsReader const &options)

Mob::_registerMobAttributes
static MCAPI void _registerMobAttributes(::BaseAttributeMap &attributes)

Mob::$getBlockDamageCause
MCAPI::SharedTypes::Legacy::ActorDamageCause $getBlockDamageCause(::Block const &block) const

Mob::_processSoulSpeed
MCAPI void _processSoulSpeed()

Mob::getJumpPrevention
MCAPI::JumpPreventionResult getJumpPrevention()

Mob::$spawnAnim
MCAPI void $spawnAnim()

Mob::tickMobEffectsVisuals
MCAPI void tickMobEffectsVisuals()

Mob::$getArmorTextureIndexInSlot
MCAPI int $getArmorTextureIndexInSlot(::SharedTypes::Legacy::ArmorSlot slot) const

Mob::$getArmorValue
MCAPI int $getArmorValue() const

Mob::$vftable
static MCAPI void ** $vftable()

Mob::$getInterpolatedBodyYaw
MCAPI float $getInterpolatedBodyYaw(float a) const

Mob::$getInterpolatedHeadRot
MCAPI float $getInterpolatedHeadRot(float a) const

Mob::$_doInitialMove
MCAPI void $_doInitialMove()

Mob::$dtor
MCAPI void $dtor()

Mob::$clearVanishEnchantedItemsOnDeath
MCAPI void $clearVanishEnchantedItemsOnDeath()

Mob::$getDeathTime
MCAPI int $getDeathTime() const

Mob::$isAlive
MCAPI bool $isAlive() const

Mob::getDamageAfterDamageSensorComponentAdjustments
MCAPI float getDamageAfterDamageSensorComponentAdjustments(::ActorDamageSource const &source, float damage)

Mob::leaveCaravan
MCAPI void leaveCaravan()

Mob::$blockedByShield
MCAPI void $blockedByShield(::ActorDamageSource const &source, ::Actor &blocker)

Mob::$newServerAiStep
MCAPI void $newServerAiStep()

Mob::$setSpeed
MCAPI void $setSpeed(float speed)

Mob::$hurtEffects
MCAPI void $hurtEffects(::ActorDamageSource const &source, float damage, ::HurtEffectsSettings const &settings)

Mob::calcMoveRelativeSpeed
MCAPI float calcMoveRelativeSpeed(::TravelType travelType)

Player
Definition Player.h:131

SaveContext
Definition SaveContext.h:5

SynchedActorDataWriter
Definition SynchedActorDataWriter.h:12

Vec3
Definition Vec3.h:10

mce::UUID
Definition UUID.h:8

ActorDefinitionIdentifier
Definition ActorDefinitionIdentifier.h:15

CalculateAttackDamageSettings
Definition CalculateAttackDamageSettings.h:5

DimensionType
Definition DimensionType.h:5

HurtEffectsSettings
Definition HurtEffectsSettings.h:8

HurtParameters
Definition HurtParameters.h:8

InterpolationPair
Definition InterpolationPair.h:5

JumpPreventionResult
Definition JumpPreventionResult.h:8

KnockbackParameters
Definition KnockbackParameters.h:5

LegacyGoalDefinition
Definition LegacyGoalDefinition.h:32

VariantParameterList
Definition VariantParameterList.h:17