Botcraft/Game_2Entities_2entities_2Entity_8cpp_source.html

#include "botcraft/Game/Entities/entities/Entity.hpp"


#include "protocolCraft/Types/Item/Slot.hpp"

#include "protocolCraft/Types/Chat/Chat.hpp"

#include "protocolCraft/Types/Particles/Particle.hpp"

#if PROTOCOL_VERSION < 773 /* < 1.21.9 */

#include "protocolCraft/Types/NBT/NBT.hpp"

#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

#include "protocolCraft/Types/Components/DataComponentTypeResolvableProfile.hpp"

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

#include "botcraft/Game/Entities/VillagerData.hpp"

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

#include "botcraft/Game/Entities/GlobalPos.hpp"

#endif


#if USE_GUI

#include "botcraft/Game/AssetsManager.hpp"

#include "botcraft/Renderer/Atlas.hpp"

#endif

#include "botcraft/Utilities/Logger.hpp"


#if PROTOCOL_VERSION > 767 /* > 1.21.1 */

#include "botcraft/Game/Entities/entities/vehicle/BoatEntity.hpp"

#include "botcraft/Game/Entities/entities/vehicle/ChestBoatEntity.hpp"

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

#include "botcraft/Game/Entities/entities/animal/allay/AllayEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/AreaEffectCloudEntity.hpp"

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

#include "botcraft/Game/Entities/entities/animal/armadillo/ArmadilloEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/decoration/ArmorStandEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/ArrowEntity.hpp"

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

#include "botcraft/Game/Entities/entities/animal/axolotl/AxolotlEntity.hpp"

#endif

#if PROTOCOL_VERSION > 767 /* > 1.21.1 */

#include "botcraft/Game/Entities/entities/vehicle/ChestRaftEntity.hpp"

#include "botcraft/Game/Entities/entities/vehicle/RaftEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/ambient/BatEntity.hpp"

#if PROTOCOL_VERSION > 498 /* > 1.14.4 */

#include "botcraft/Game/Entities/entities/animal/BeeEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/monster/BlazeEntity.hpp"

#include "botcraft/Game/Entities/entities/vehicle/BoatEntity.hpp"

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

#include "botcraft/Game/Entities/entities/monster/BoggedEntity.hpp"

#endif

#if PROTOCOL_VERSION > 764 /* > 1.20.2 */

#include "botcraft/Game/Entities/entities/monster/breeze/BreezeEntity.hpp"

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

#include "botcraft/Game/Entities/entities/projectile/windcharge/BreezeWindChargeEntity.hpp"

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

#include "botcraft/Game/Entities/entities/vehicle/ChestBoatEntity.hpp"

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

#include "botcraft/Game/Entities/entities/animal/CatEntity.hpp"

#endif

#if PROTOCOL_VERSION > 760 /* > 1.19.2 */

#include "botcraft/Game/Entities/entities/animal/camel/CamelEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/monster/CaveSpiderEntity.hpp"

#include "botcraft/Game/Entities/entities/animal/ChickenEntity.hpp"


#if PROTOCOL_VERSION > 340 /* > 1.12.2 */


#include "botcraft/Game/Entities/entities/animal/CodEntity.hpp"


#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

#include "botcraft/Game/Entities/entities/animal/coppergolem/CopperGolemEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/animal/CowEntity.hpp"

#if PROTOCOL_VERSION > 767 /* > 1.21.1 */

#include "botcraft/Game/Entities/entities/monster/creaking/CreakingEntity.hpp"

#endif

#if PROTOCOL_VERSION > 767 /* > 1.21.1 */ && PROTOCOL_VERSION < 769 /* < 1.21.4 */

#include "botcraft/Game/Entities/entities/monster/creaking/CreakingTransientEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/monster/CreeperEntity.hpp"

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

#include "botcraft/Game/Entities/entities/animal/DolphinEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/animal/horse/DonkeyEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/DragonFireballEntity.hpp"

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

#include "botcraft/Game/Entities/entities/monster/DrownedEntity.hpp"

#endif

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

#include "botcraft/Game/Entities/entities/DisplayBlockDisplayEntity.hpp"

#include "botcraft/Game/Entities/entities/DisplayEntity.hpp"

#include "botcraft/Game/Entities/entities/DisplayItemDisplayEntity.hpp"

#include "botcraft/Game/Entities/entities/DisplayTextDisplayEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/monster/ElderGuardianEntity.hpp"

#include "botcraft/Game/Entities/entities/boss/enderdragon/EndCrystalEntity.hpp"

#include "botcraft/Game/Entities/entities/boss/enderdragon/EnderDragonEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/EnderManEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/EndermiteEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/EvokerEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/EvokerFangsEntity.hpp"

#include "botcraft/Game/Entities/entities/ExperienceOrbEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/EyeOfEnderEntity.hpp"

#include "botcraft/Game/Entities/entities/item/FallingBlockEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/FireworkRocketEntity.hpp"

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

#include "botcraft/Game/Entities/entities/animal/FoxEntity.hpp"

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

#include "botcraft/Game/Entities/entities/animal/frog/FrogEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/monster/GhastEntity.hpp"

#if PROTOCOL_VERSION > 770 /* > 1.21.5 */

#include "botcraft/Game/Entities/entities/animal/HappyGhastEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/monster/GiantEntity.hpp"

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

#include "botcraft/Game/Entities/entities/decoration/GlowItemFrameEntity.hpp"

#include "botcraft/Game/Entities/entities/GlowSquidEntity.hpp"

#include "botcraft/Game/Entities/entities/animal/goat/GoatEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/monster/GuardianEntity.hpp"

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

#include "botcraft/Game/Entities/entities/monster/hoglin/HoglinEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/animal/horse/HorseEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/HuskEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/IllusionerEntity.hpp"

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

#include "botcraft/Game/Entities/entities/InteractionEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/animal/IronGolemEntity.hpp"

#include "botcraft/Game/Entities/entities/item/ItemEntity.hpp"

#include "botcraft/Game/Entities/entities/decoration/ItemFrameEntity.hpp"

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

#include "botcraft/Game/Entities/entities/OminousItemSpawnerEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/projectile/LargeFireballEntity.hpp"

#include "botcraft/Game/Entities/entities/decoration/LeashFenceKnotEntity.hpp"

#include "botcraft/Game/Entities/entities/LightningBoltEntity.hpp"

#include "botcraft/Game/Entities/entities/animal/horse/LlamaEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/LlamaSpitEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/MagmaCubeEntity.hpp"

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

#include "botcraft/Game/Entities/entities/MarkerEntity.hpp"

#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

#include "botcraft/Game/Entities/entities/decoration/MannequinEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/vehicle/MinecartEntity.hpp"

#include "botcraft/Game/Entities/entities/vehicle/MinecartChestEntity.hpp"

#include "botcraft/Game/Entities/entities/vehicle/MinecartCommandBlockEntity.hpp"

#include "botcraft/Game/Entities/entities/vehicle/MinecartFurnaceEntity.hpp"

#include "botcraft/Game/Entities/entities/vehicle/MinecartHopperEntity.hpp"

#include "botcraft/Game/Entities/entities/vehicle/MinecartSpawnerEntity.hpp"

#include "botcraft/Game/Entities/entities/vehicle/MinecartTNTEntity.hpp"

#include "botcraft/Game/Entities/entities/animal/horse/MuleEntity.hpp"

#include "botcraft/Game/Entities/entities/animal/MushroomCowEntity.hpp"

#include "botcraft/Game/Entities/entities/animal/OcelotEntity.hpp"

#include "botcraft/Game/Entities/entities/decoration/PaintingEntity.hpp"

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

#include "botcraft/Game/Entities/entities/animal/PandaEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/animal/ParrotEntity.hpp"

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

#include "botcraft/Game/Entities/entities/monster/PhantomEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/animal/PigEntity.hpp"

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

#include "botcraft/Game/Entities/entities/monster/piglin/PiglinEntity.hpp"

#else

#include "botcraft/Game/Entities/entities/monster/PigZombieEntity.hpp"

#endif

#if PROTOCOL_VERSION > 736 /* > 1.16.1 */

#include "botcraft/Game/Entities/entities/monster/piglin/PiglinBruteEntity.hpp"

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

#include "botcraft/Game/Entities/entities/monster/PillagerEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/animal/PolarBearEntity.hpp"

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

#include "botcraft/Game/Entities/entities/projectile/ThrownSplashPotionEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/ThrownLingeringPotionEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/item/PrimedTntEntity.hpp"

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

#include "botcraft/Game/Entities/entities/animal/PufferfishEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/animal/RabbitEntity.hpp"

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

#include "botcraft/Game/Entities/entities/monster/RavagerEntity.hpp"

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

#include "botcraft/Game/Entities/entities/animal/SalmonEntity.hpp"

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

#include "botcraft/Game/Entities/entities/animal//sheep/SheepEntity.hpp"

#else

#include "botcraft/Game/Entities/entities/animal/SheepEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/monster/ShulkerEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/ShulkerBulletEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/SilverfishEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/SkeletonEntity.hpp"

#include "botcraft/Game/Entities/entities/animal/horse/SkeletonHorseEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/SlimeEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/SmallFireballEntity.hpp"

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

#include "botcraft/Game/Entities/entities/animal/sniffer/SnifferEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/animal/SnowGolemEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/SnowballEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/SpectralArrowEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/SpiderEntity.hpp"

#include "botcraft/Game/Entities/entities/animal/SquidEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/StrayEntity.hpp"

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

#include "botcraft/Game/Entities/entities/monster/StriderEntity.hpp"

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

#include "botcraft/Game/Entities/entities/animal/frog/TadpoleEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/projectile/ThrownEggEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/ThrownEnderpearlEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/ThrownExperienceBottleEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/ThrownPotionEntity.hpp"

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

#include "botcraft/Game/Entities/entities/projectile/ThrownTridentEntity.hpp"

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

#include "botcraft/Game/Entities/entities/animal/horse/TraderLlamaEntity.hpp"

#endif


#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

#include "botcraft/Game/Entities/entities/animal/TropicalFishEntity.hpp"

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

#include "botcraft/Game/Entities/entities/animal/TurtleEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/monster/VexEntity.hpp"

#include "botcraft/Game/Entities/entities/npc/VillagerEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/VindicatorEntity.hpp"

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

#include "botcraft/Game/Entities/entities/npc/WanderingTraderEntity.hpp"

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

#include "botcraft/Game/Entities/entities/monster/warden/WardenEntity.hpp"

#endif

#if PROTOCOL_VERSION > 764 /* > 1.20.2 */

#include "botcraft/Game/Entities/entities/projectile/windcharge/WindChargeEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/monster/WitchEntity.hpp"

#include "botcraft/Game/Entities/entities/boss/wither/WitherBossEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/WitherSkeletonEntity.hpp"


#include "botcraft/Game/Entities/entities/projectile/WitherSkullEntity.hpp"

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

#include "botcraft/Game/Entities/entities/animal/wolf/WolfEntity.hpp"

#else

#include "botcraft/Game/Entities/entities/animal/WolfEntity.hpp"

#endif

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

#include "botcraft/Game/Entities/entities/monster/ZoglinEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/monster/ZombieEntity.hpp"

#include "botcraft/Game/Entities/entities/animal/horse/ZombieHorseEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/ZombieVillagerEntity.hpp"

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

#include "botcraft/Game/Entities/entities/monster/ZombifiedPiglinEntity.hpp"

#endif

#include "botcraft/Game/Entities/entities/player/PlayerEntity.hpp"

#include "botcraft/Game/Entities/entities/projectile/FishingHookEntity.hpp"


#include <mutex>


namespace Botcraft

{

    const std::array<std::string, Entity::metadata_count> Entity::metadata_names{ {

        "data_shared_flags_id",

        "data_air_supply_id",

        "data_custom_name",

        "data_custom_name_visible",

        "data_silent",

        "data_no_gravity",

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        "data_pose",

#endif

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

        "data_ticks_frozen",

#endif

    } };


    Entity::Entity()

    {

        {

            std::scoped_lock<std::shared_mutex> lock(entity_mutex);

            // Initialize base stuff

            entity_id = 0;

            position = Vector3<double>(0.0, 0.0, 0.0);

            yaw = 0.0f;

            pitch = 0.0f;

            speed = Vector3<double>(0.0, 0.0, 0.0);

            on_ground = false;

            equipments = {

                { EquipmentSlot::MainHand, ProtocolCraft::Slot() },

                { EquipmentSlot::OffHand, ProtocolCraft::Slot() },

                { EquipmentSlot::Boots, ProtocolCraft::Slot() },

                { EquipmentSlot::Leggings, ProtocolCraft::Slot() },

                { EquipmentSlot::ChestPlate, ProtocolCraft::Slot() },

                { EquipmentSlot::Helmet, ProtocolCraft::Slot() },

#if PROTOCOL_VERSION > 766 /* > 1.20.6 */

                { EquipmentSlot::BodyAnimalArmor, ProtocolCraft::Slot() },

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

                { EquipmentSlot::Saddle, ProtocolCraft::Slot() },

#endif

            };

        }


        // Initialize all metadata with default values

        SetDataSharedFlagsId(0);

        SetDataAirSupplyId(300);

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        SetDataCustomName(std::optional<ProtocolCraft::Chat>());

#else

        SetDataCustomName("");

#endif

        SetDataCustomNameVisible(false);

        SetDataSilent(false);

        SetDataNoGravity(false);

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        SetDataPose(Pose::Standing);

#endif

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

        SetDataTicksFrozen(0);

#endif

    }


    Entity::~Entity()

    {


    }


    AABB Entity::GetCollider() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return GetColliderImpl();

    }


    double Entity::GetWidth() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return GetWidthImpl();

    }


    double Entity::GetHeight() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return GetHeightImpl();

    }


    void Entity::LoadMetadataFromRawArray(const std::vector<unsigned char>& data)

    {

        if (data.size() == 0)

        {

            return;

        }


        ProtocolCraft::ReadIterator iter = data.begin();

        size_t length = data.size();


        while (true)

        {

            const unsigned char index = ProtocolCraft::ReadData<unsigned char>(iter, length);

            if (index == 0xFF)

            {

                break;

            }


            const int type = ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length);

            std::any value;


            enum EntityMetadataTypes

            {

                Char = 0,

                Int,

#if PROTOCOL_VERSION > 760 /* > 1.19.2 */

                Long,

#endif

                Float,

                String,

                Chat,

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

                OptionalChat,

#endif

                Slot,

                Bool,

                Rotations,

                BlockPosition,

                OptionalBlockPosition,

                DirectionType,

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

                OptionalLivingEntityReference, // Fancy new name for 1.21.5, but it's still an optional UUID

#else

                OptionalUUID,

#endif

                BlockstateType,

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

                OptionalBlockstate,

#endif

#if PROTOCOL_VERSION < 773 /* < 1.21.9 */

                NBT,

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

                Particle,

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

                Particles,

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

                VillagerDataType,

                OptionalUint,

                PoseType,

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

                CatVariant,

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

                CowVariant,

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

                WolfVariant,

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

                WolfSoundVariant,

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

                FrogVariant,

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

                PigVariant,

                ChickenVariant,

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

                OptionalGlobalPos,

                PaintingVariant,

#endif

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

                SnifferState,

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

                ArmadilloState,

#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

                CopperGolemState,

                WeatheringCopperState,

#endif

                Vec3,

                Quaternion,

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

                ResolvableProfile,

#endif

#endif

            };


            switch (type)

            {

            case EntityMetadataTypes::Char:

                value = ProtocolCraft::ReadData<char>(iter, length);

                break;

            case EntityMetadataTypes::Int:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

#if PROTOCOL_VERSION > 760 /* > 1.19.2 */

            case EntityMetadataTypes::Long:

                value = static_cast<long long int>(ProtocolCraft::ReadData<ProtocolCraft::VarLong>(iter, length));

                break;

#endif

            case EntityMetadataTypes::Float:

                value = ProtocolCraft::ReadData<float>(iter, length);

                break;

            case EntityMetadataTypes::String:

                value = ProtocolCraft::ReadData<std::string>(iter, length);

                break;

            case EntityMetadataTypes::Chat:

                value = ProtocolCraft::Chat();

                std::any_cast<ProtocolCraft::Chat&>(value).Read(iter, length);

                break;

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

            case EntityMetadataTypes::OptionalChat:

                if (ProtocolCraft::ReadData<bool>(iter, length))

                {

                    value = std::optional<ProtocolCraft::Chat>(ProtocolCraft::Chat());

                    std::any_cast<std::optional<ProtocolCraft::Chat>&>(value).value().Read(iter, length);

                }

                else

                {

                    value = std::optional<ProtocolCraft::Chat>();

                }

                break;

#endif

            case EntityMetadataTypes::Slot:

                value = ProtocolCraft::Slot();

                std::any_cast<ProtocolCraft::Slot&>(value).Read(iter, length);

                break;

            case EntityMetadataTypes::Bool:

                value = ProtocolCraft::ReadData<bool>(iter, length);

                break;

            case EntityMetadataTypes::Rotations:

            {

                Vector3<float> rotation;

                for (int i = 0; i < 3; ++i)

                {

                    rotation[i] = ProtocolCraft::ReadData<float>(iter, length);

                }

                value = rotation;

                break;

            }

            case EntityMetadataTypes::BlockPosition:

            {

                ProtocolCraft::NetworkPosition position;

                position.Read(iter, length);

                value = Position(position);

                break;

            }

            case EntityMetadataTypes::OptionalBlockPosition:

                if (ProtocolCraft::ReadData<bool>(iter, length))

                {

                    ProtocolCraft::NetworkPosition position;

                    position.Read(iter, length);

                    value = std::optional<Position>(position);

                }

                else

                {

                    value = std::optional<Position>();

                }

                break;

            case EntityMetadataTypes::DirectionType:

                value = static_cast<Direction>(static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length)));

                break;

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

            case EntityMetadataTypes::OptionalLivingEntityReference:

#else

            case EntityMetadataTypes::OptionalUUID:

#endif

                if (ProtocolCraft::ReadData<bool>(iter, length))

                {

                    value = std::optional<ProtocolCraft::UUID>(ProtocolCraft::ReadData<ProtocolCraft::UUID>(iter, length));

                }

                else

                {

                    value = std::optional<ProtocolCraft::UUID>();

                }

                break;

            case EntityMetadataTypes::BlockstateType:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

            case EntityMetadataTypes::OptionalBlockstate:

                if (const int n = ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length))

                {

                    value = std::optional<int>(n);

                }

                else

                {

                    value = std::optional<int>();

                }

                break;

#endif

#if PROTOCOL_VERSION < 773 /* < 1.21.9 */

            case EntityMetadataTypes::NBT:

            {

                ProtocolCraft::NBT::UnnamedValue unnamed_value;

                unnamed_value.Read(iter, length);

                value = ProtocolCraft::NBT::Value(unnamed_value);

                break;

            }

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

            case EntityMetadataTypes::Particle:

            {

                ProtocolCraft::Particle particle;

                particle.Read(iter, length);

                value = particle;

                break;

            }

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

            case EntityMetadataTypes::Particles:

                value = ProtocolCraft::ReadData<std::vector<ProtocolCraft::Particle>>(iter, length);

                break;

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

            case EntityMetadataTypes::VillagerDataType:

                value = VillagerData{

                    ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length), // villager_type

                    ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length), // villager_profession

                    ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length) // level

                };

                break;

            case EntityMetadataTypes::OptionalUint:

            {

                const int val = ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length);

                value = val > 0 ? std::optional<int>(val - 1) : std::optional<int>();

                break;

            }

            case EntityMetadataTypes::PoseType:

                value = static_cast<Pose>(static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length)));

                break;

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

            case EntityMetadataTypes::CatVariant:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

            case EntityMetadataTypes::CowVariant:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

            case EntityMetadataTypes::WolfVariant:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

            case EntityMetadataTypes::WolfSoundVariant:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

            case EntityMetadataTypes::FrogVariant:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

            case EntityMetadataTypes::PigVariant:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

            case EntityMetadataTypes::ChickenVariant:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

            case EntityMetadataTypes::OptionalGlobalPos:

                if (ProtocolCraft::ReadData<bool>(iter, length))

                {

                    ProtocolCraft::Identifier dimension;

                    dimension.Read(iter, length);

                    ProtocolCraft::NetworkPosition pos;

                    pos.Read(iter, length);


                    value = std::optional<GlobalPos>({

                            dimension,

                            pos

                        });

                }

                else

                {

                    value = std::optional<GlobalPos>();

                }

                break;

            case EntityMetadataTypes::PaintingVariant:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

#endif

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

            case EntityMetadataTypes::SnifferState:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

            case EntityMetadataTypes::ArmadilloState:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

            case EntityMetadataTypes::CopperGolemState:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

            case EntityMetadataTypes::WeatheringCopperState:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));

                break;

#endif

            case EntityMetadataTypes::Vec3:

            {

                const float x = ProtocolCraft::ReadData<float>(iter, length);

                const float y = ProtocolCraft::ReadData<float>(iter, length);

                const float z = ProtocolCraft::ReadData<float>(iter, length);

                value = Vector3<float>(x, y, z);

            }

            break;

            case EntityMetadataTypes::Quaternion:

            {

                const float x = ProtocolCraft::ReadData<float>(iter, length);

                const float y = ProtocolCraft::ReadData<float>(iter, length);

                const float z = ProtocolCraft::ReadData<float>(iter, length);

                const float w = ProtocolCraft::ReadData<float>(iter, length);

                value = std::array<float, 4>{x, y, z, w};

            }

            break;

#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

            case EntityMetadataTypes::ResolvableProfile:

                value = ProtocolCraft::ReadData<ProtocolCraft::Components::DataComponentTypeResolvableProfile>(iter, length);

                break;

#endif

            default:

                LOG_ERROR("Unknown type in entity metadata : " << type << ".Stopping current metadata parsing.");

                return;

            }

            SetMetadataValue(index, value);

        }

    }


    void Entity::SetMetadataValue(const int index, const std::any& value)

    {

        assert(index >= 0 && index < metadata_count);

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        const std::string& metadata_name = metadata_names[index];

        metadata[metadata_name] = value;

#if USE_GUI && PROTOCOL_VERSION > 404 /* > 1.13.2 */

        if (metadata_name == "data_pose")

        {

            OnSizeUpdated();

        }

#endif

    }


    char Entity::GetDataSharedFlagsId() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return GetDataSharedFlagsIdImpl();

    }


    bool Entity::GetDataSharedFlagsId(const EntitySharedFlagsId id) const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return GetDataSharedFlagsIdImpl(id);

    }


    int Entity::GetDataAirSupplyId() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return std::any_cast<int>(metadata.at("data_air_supply_id"));

    }


#if PROTOCOL_VERSION > 340 /* > 1.12.2 */


    std::optional<ProtocolCraft::Chat> Entity::GetDataCustomName() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return std::any_cast<std::optional<ProtocolCraft::Chat>>(metadata.at("data_custom_name"));

    }


#else

    std::string Entity::GetDataCustomName() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return std::any_cast<std::string>(metadata.at("data_custom_name"));

    }

#endif


    bool Entity::GetDataCustomNameVisible() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return std::any_cast<bool>(metadata.at("data_custom_name_visible"));

    }


    bool Entity::GetDataSilent() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return std::any_cast<bool>(metadata.at("data_silent"));

    }


    bool Entity::GetDataNoGravity() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return std::any_cast<bool>(metadata.at("data_no_gravity"));

    }


#if PROTOCOL_VERSION > 404 /* > 1.13.2 */


    Pose Entity::GetDataPose() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return GetDataPoseImpl();

    }


#endif


#if PROTOCOL_VERSION > 754 /* > 1.16.5 */


    int Entity::GetDataTicksFrozen() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return std::any_cast<int>(metadata.at("data_ticks_frozen"));

    }


#endif


    void Entity::SetDataSharedFlagsId(const char data_shared_flags_id)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        SetDataSharedFlagsIdImpl(data_shared_flags_id);

    }


    void Entity::SetDataSharedFlagsId(const EntitySharedFlagsId id, const bool b)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        SetDataSharedFlagsIdImpl(id, b);

    }


    void Entity::SetDataAirSupplyId(const int data_air_supply_id)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        metadata["data_air_supply_id"] = data_air_supply_id;

    }


#if PROTOCOL_VERSION > 340 /* > 1.12.2 */


    void Entity::SetDataCustomName(const std::optional<ProtocolCraft::Chat>& data_custom_name)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        metadata["data_custom_name"] = data_custom_name;

    }


#else

    void Entity::SetDataCustomName(const std::string& data_custom_name)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        metadata["data_custom_name"] = data_custom_name;

    }

#endif


    void Entity::SetDataCustomNameVisible(const bool data_custom_name_visible)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        metadata["data_custom_name_visible"] = data_custom_name_visible;

    }


    void Entity::SetDataSilent(const bool data_silent)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        metadata["data_silent"] = data_silent;

    }


    void Entity::SetDataNoGravity(const bool data_no_gravity)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        metadata["data_no_gravity"] = data_no_gravity;

    }


#if PROTOCOL_VERSION > 404 /* > 1.13.2 */


    void Entity::SetDataPose(const Pose data_pose)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        SetDataPoseImpl(data_pose);

    }


#endif


#if PROTOCOL_VERSION > 754 /* > 1.16.5 */


    void Entity::SetDataTicksFrozen(const int data_ticks_frozen)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        metadata["data_ticks_frozen"] = data_ticks_frozen;

    }


#endif


    int Entity::GetEntityID() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return entity_id;

    }


    ProtocolCraft::UUID Entity::GetUUID() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return uuid;

    }


    Vector3<double> Entity::GetPosition() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return position;

    }


    double Entity::GetX() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return position.x;

    }


    double Entity::GetY() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return position.y;

    }


    double Entity::GetZ() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return position.z;

    }


    float Entity::GetYaw() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return yaw;

    }


    float Entity::GetPitch() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return pitch;

    }


    Vector3<double> Entity::GetSpeed() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return speed;

    }


    double Entity::GetSpeedX() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return speed.x;

    }


    double Entity::GetSpeedY() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return speed.y;

    }


    double Entity::GetSpeedZ() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return speed.z;

    }


    bool Entity::GetOnGround() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return on_ground;

    }


    std::map<EquipmentSlot, ProtocolCraft::Slot> Entity::GetEquipments() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return equipments;

    }


    ProtocolCraft::Slot Entity::GetEquipment(const EquipmentSlot slot) const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return equipments.at(slot);

    }


    std::vector<EntityEffect> Entity::GetEffects() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return effects;

    }


#if USE_GUI


    std::vector<Renderer::Face> Entity::GetFaces(const bool reset_uptodate_status)

    {

        if (faces.size() == 0)

        {

            InitializeFaces();

        }

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        if (!are_rendered_faces_up_to_date)

        {

            for (size_t i = 0; i < faces.size(); ++i)

            {

                faces[i].UpdateMatrix(face_descriptors[i].transformations, face_descriptors[i].orientation);

            }

        }

        if (reset_uptodate_status)

        {

            are_rendered_faces_up_to_date = true;

        }

        return faces;

    }


    bool Entity::GetAreRenderedFacesUpToDate() const

    {

        std::shared_lock<std::shared_mutex> lock(entity_mutex);

        return are_rendered_faces_up_to_date;

    }


#endif


    void Entity::SetEntityID(const int entity_id_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        entity_id = entity_id_;

    }


    void Entity::SetUUID(const ProtocolCraft::UUID& uuid_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        uuid = uuid_;

    }


    void Entity::SetPosition(const Vector3<double>& position_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

#if USE_GUI

        if (position_ != position)

        {

            are_rendered_faces_up_to_date = false;

            for (size_t i = 0; i < faces.size(); ++i)

            {

                std::shared_ptr<Renderer::Translation> f = std::static_pointer_cast<Renderer::Translation>(face_descriptors[i].transformations.translations.back());

                f->x = static_cast<float>(position_.x);

                f->y = static_cast<float>(position_.y);

                f->z = static_cast<float>(position_.z);

            }

        }

#endif

        position = position_;

    }


    void Entity::SetX(const double x_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

#if USE_GUI

        if (x_ != position.x)

        {

            are_rendered_faces_up_to_date = false;

            for (size_t i = 0; i < faces.size(); ++i)

            {

                std::static_pointer_cast<Renderer::Translation>(face_descriptors[i].transformations.translations.back())->x = static_cast<float>(x_);

            }

        }

#endif

        position.x = x_;

    }


    void Entity::SetY(const double y_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

#if USE_GUI

        if (y_ != position.y)

        {

            are_rendered_faces_up_to_date = false;

            for (size_t i = 0; i < faces.size(); ++i)

            {

                std::static_pointer_cast<Renderer::Translation>(face_descriptors[i].transformations.translations.back())->y = static_cast<float>(y_);

            }

        }

#endif

        position.y = y_;

    }


    void Entity::SetZ(const double z_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

#if USE_GUI

        if (z_ != position.z)

        {

            are_rendered_faces_up_to_date = false;

            for (size_t i = 0; i < faces.size(); ++i)

            {

                std::static_pointer_cast<Renderer::Translation>(face_descriptors[i].transformations.translations.back())->z = static_cast<float>(z_);

            }

        }

#endif

        position.z = z_;

    }


    void Entity::SetYaw(const float yaw_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

#if USE_GUI

        if (yaw_ != yaw)

        {

            are_rendered_faces_up_to_date = false;

            for (size_t i = 0; i < faces.size(); ++i)

            {

                std::static_pointer_cast<Renderer::Rotation>(face_descriptors[i].transformations.rotations.front())->deg_angle = yaw_;

            }

        }

#endif

        yaw = yaw_;

    }


    void Entity::SetPitch(const float pitch_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

#if USE_GUI

        if (pitch_ != pitch)

        {

            are_rendered_faces_up_to_date = false;

            for (size_t i = 0; i < faces.size(); ++i)

            {

                std::static_pointer_cast<Renderer::Rotation>(face_descriptors[i].transformations.rotations.back())->deg_angle = pitch_;

            }

        }

#endif

        pitch = pitch_;

    }


    void Entity::SetSpeed(const Vector3<double>& speed_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        speed = speed_;

    }


    void Entity::SetSpeedX(const double speed_x_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        speed.x = speed_x_;

    }


    void Entity::SetSpeedY(const double speed_y_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        speed.y = speed_y_;

    }


    void Entity::SetSpeedZ(const double speed_z_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        speed.z = speed_z_;

    }


    void Entity::SetOnGround(const bool on_ground_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        on_ground = on_ground_;

    }


    void Entity::SetEquipment(const EquipmentSlot slot, const ProtocolCraft::Slot& item)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        equipments.at(slot) = item;

    }


    void Entity::SetEffects(const std::vector<EntityEffect>& effects_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        effects = effects_;

    }


    void Entity::RemoveEffect(const EntityEffectType type)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        for (auto it = effects.begin(); it != effects.end();)

        {

            if (it->type == type)

            {

                it = effects.erase(it);

            }

            else

            {

                ++it;

            }

        }

    }


    void Entity::AddEffect(const EntityEffect& effect)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        // First, remove any instance of this type of effect on the entity

        for (auto it = effects.begin(); it != effects.end();)

        {

            if (it->type == effect.type)

            {

                it = effects.erase(it);

            }

            else

            {

                ++it;

            }

        }


        // Then add the new one

        effects.push_back(effect);

    }


#if USE_GUI


    void Entity::SetAreRenderedFacesUpToDate(const bool should_be_updated_)

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        are_rendered_faces_up_to_date = should_be_updated_;

    }


#endif


    ProtocolCraft::Json::Value Entity::Serialize() const

    {

        ProtocolCraft::Json::Value output;


        {

            std::shared_lock<std::shared_mutex> lock(entity_mutex);

            output["id"] = entity_id;

            output["position"] = position.Serialize();

            output["yaw"] = yaw;

            output["pitch"] = pitch;

            output["speed"] = speed.Serialize();

            output["on_ground"] = on_ground;

            output["equipment"] = ProtocolCraft::Json::Value();

            for (auto& p : equipments)

            {

                output["equipment"][std::to_string(static_cast<int>(p.first))] = p.second.Serialize();

            }

        }


        output["metadata"] = ProtocolCraft::Json::Value();


        output["metadata"]["data_shared_flags_id"] = GetDataSharedFlagsId();

        output["metadata"]["data_air_supply_id"] = GetDataAirSupplyId();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        output["metadata"]["data_custom_name"] = GetDataCustomName() ? GetDataCustomName().value().Serialize() : ProtocolCraft::Json::Value();

#else

        output["metadata"]["data_custom_name"] = GetDataCustomName();

#endif

        output["metadata"]["data_custom_name_visible"] = GetDataCustomNameVisible();

        output["metadata"]["data_silent"] = GetDataSilent();

        output["metadata"]["data_no_gravity"] = GetDataNoGravity();

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        output["metadata"]["data_pose"] = static_cast<int>(GetDataPose());

#endif

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

        output["metadata"]["data_ticks_frozen"] = GetDataTicksFrozen();

#endif


        return output;

    }


    bool Entity::IsLocalPlayer() const

    {

        return false;

    }


    bool Entity::IsRemotePlayer() const

    {

        return false;

    }


    bool Entity::IsLivingEntity() const

    {

        return false;

    }


    bool Entity::IsAbstractArrow() const

    {

        return false;

    }


    bool Entity::IsAnimal() const

    {

        return false;

    }


    bool Entity::IsAmbientCreature() const

    {

        return false;

    }


    bool Entity::IsMonster() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 761 /* > 1.19.3 */


    bool Entity::IsDisplay() const

    {

        return false;

    }


#endif


#if PROTOCOL_VERSION > 764 /* > 1.20.2 */


    bool Entity::IsVehicle() const

    {

        return false;

    }


#endif


    bool Entity::IsTamableAnimal() const

    {

        return false;

    }


    bool Entity::IsAbstractSchoolingFish() const

    {

        return false;

    }


    bool Entity::IsWaterAnimal() const

    {

        return false;

    }


    bool Entity::IsAbstractChestedHorse() const

    {

        return false;

    }


    bool Entity::IsAbstractHurtingProjectile() const

    {

        return false;

    }


    bool Entity::IsMob() const

    {

        return false;

    }


    bool Entity::IsSpellcasterIllager() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 578 /* > 1.15.2 */


    bool Entity::IsProjectile() const

    {

        return false;

    }


#endif


#if PROTOCOL_VERSION < 771 /* < 1.21.6 */

    bool Entity::IsFlyingMob() const

    {

        return false;

    }

#endif


    bool Entity::IsAbstractHorse() const

    {

        return false;

    }


    bool Entity::IsAbstractGolem() const

    {

        return false;

    }


    bool Entity::IsHangingEntity() const

    {

        return false;

    }


    bool Entity::IsFireball() const

    {

        return false;

    }


    bool Entity::IsAbstractMinecart() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 769 /* > 1.21.4 */


    bool Entity::IsAbstractCow() const

    {

        return false;

    }


#endif


    bool Entity::IsAbstractMinecartContainer() const

    {

        return false;

    }


    bool Entity::IsShoulderRidingEntity() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 736 /* > 1.16.1 */


    bool Entity::IsAbstractPiglin() const

    {

        return false;

    }


#endif


    bool Entity::IsAbstractIllager() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 769 /* > 1.21.4 */


    bool Entity::IsAbstractThrownPotion() const

    {

        return false;

    }


#endif


    bool Entity::IsAbstractFish() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 404 /* > 1.13.2 */


    bool Entity::IsRaider() const

    {

        return false;

    }


#endif


    bool Entity::IsAbstractSkeleton() const

    {

        return false;

    }


    bool Entity::IsThrowableItemProjectile() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 477 /* > 1.14 */


    bool Entity::IsAbstractVillager() const

    {

        return false;

    }


#endif


    bool Entity::IsAgeableMob() const

    {

        return false;

    }


    bool Entity::IsPathfinderMob() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 404 /* > 1.13.2 */


    bool Entity::IsPatrollingMonster() const

    {

        return false;

    }


#endif


    bool Entity::IsThrowableProjectile() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 765 /* > 1.20.4 */


    bool Entity::IsAbstractWindCharge() const

    {

        return false;

    }


#endif


#if PROTOCOL_VERSION > 766 /* > 1.20.6 */


    bool Entity::IsBlockAttachedEntity() const

    {

        return false;

    }


#endif


#if PROTOCOL_VERSION > 767 /* > 1.21.1 */


    bool Entity::IsAbstractBoat() const

    {

        return false;

    }


    bool Entity::IsAbstractChestBoat() const

    {

        return false;

    }


    bool Entity::IsAgeableWaterCreature() const

    {

        return false;

    }


    bool Entity::IsBoat() const

    {

        return false;

    }


    bool Entity::IsChestBoat() const

    {

        return false;

    }


    bool Entity::IsChestRaft() const

    {

        return false;

    }


    bool Entity::IsRaft() const

    {

        return false;

    }


#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */


    bool Entity::IsAvatar() const

    {

        return false;

    }


#endif


    std::shared_ptr<Entity> Entity::CreateEntity(const EntityType type)

    {

        switch (type)

        {

        case EntityType::None:

            return nullptr;

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

        case EntityType::Allay:

            return std::make_shared<AllayEntity>();

#endif

        case EntityType::AreaEffectCloud:

            return std::make_shared<AreaEffectCloudEntity>();

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

        case EntityType::Armadillo:

            return std::make_shared<ArmadilloEntity>();

#endif

        case EntityType::ArmorStand:

            return std::make_shared<ArmorStandEntity>();

        case EntityType::Arrow:

            return std::make_shared<ArrowEntity>();

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

        case EntityType::Axolotl:

            return std::make_shared<AxolotlEntity>();

#endif

        case EntityType::Bat:

            return std::make_shared<BatEntity>();

#if PROTOCOL_VERSION > 498 /* > 1.14.4 */

        case EntityType::Bee:

            return std::make_shared<BeeEntity>();

#endif

        case EntityType::Blaze:

            return std::make_shared<BlazeEntity>();

#if PROTOCOL_VERSION < 768 /* < 1.21.2 */

        case EntityType::Boat:

            return std::make_shared<BoatEntity>();

#else

        case EntityType::AcaciaBoat:

        case EntityType::BirchBoat:

        case EntityType::CherryBoat:

        case EntityType::DarkOakBoat:

        case EntityType::JungleBoat:

        case EntityType::MangroveBoat:

        case EntityType::OakBoat:

        case EntityType::PaleOakBoat:

        case EntityType::SpruceBoat:

            return std::make_shared<BoatEntity>(type);

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

        case EntityType::Bogged:

            return std::make_shared<BoggedEntity>();

#endif

#if PROTOCOL_VERSION > 764 /* > 1.20.2 */

        case EntityType::Breeze:

            return std::make_shared<BreezeEntity>();

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

        case EntityType::BreezeWindCharge:

            return std::make_shared<BreezeWindChargeEntity>();

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

#if PROTOCOL_VERSION < 768 /* < 1.21.2 */

        case EntityType::ChestBoat:

            return std::make_shared<ChestBoatEntity>();

#else

        case EntityType::AcaciaChestBoat:

        case EntityType::BirchChestBoat:

        case EntityType::CherryChestBoat:

        case EntityType::DarkOakChestBoat:

        case EntityType::JungleChestBoat:

        case EntityType::MangroveChestBoat:

        case EntityType::OakChestBoat:

        case EntityType::PaleOakChestBoat:

        case EntityType::SpruceChestBoat:

            return std::make_shared<ChestBoatEntity>(type);

#endif

#endif

#if PROTOCOL_VERSION > 767 /* > 1.21.1 */

        case EntityType::ChestRaft:

            return std::make_shared<ChestRaftEntity>(type);

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::Cat:

            return std::make_shared<CatEntity>();

#endif

#if PROTOCOL_VERSION > 760 /* > 1.19.2 */

        case EntityType::Camel:

            return std::make_shared<CamelEntity>();

#endif

        case EntityType::CaveSpider:

            return std::make_shared<CaveSpiderEntity>();

        case EntityType::Chicken:

            return std::make_shared<ChickenEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Cod:

            return std::make_shared<CodEntity>();

#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

        case EntityType::CopperGolem:

            return std::make_shared<CopperGolemEntity>();

#endif

        case EntityType::Cow:

            return std::make_shared<CowEntity>();

#if PROTOCOL_VERSION > 767 /* > 1.21.1 */

        case EntityType::Creaking:

            return std::make_shared<CreakingEntity>();

#endif

#if PROTOCOL_VERSION > 767 /* > 1.21.1 */ && PROTOCOL_VERSION < 769 /* < 1.21.4 */

        case EntityType::CreakingTransient:

            return std::make_shared<CreakingTransientEntity>();

#endif

        case EntityType::Creeper:

            return std::make_shared<CreeperEntity>();

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

        case EntityType::DisplayBlockDisplay:

            return std::make_shared<DisplayBlockDisplayEntity>();

        case EntityType::DisplayItemDisplay:

            return std::make_shared<DisplayItemDisplayEntity>();

        case EntityType::DisplayTextDisplay:

            return std::make_shared<DisplayTextDisplayEntity>();

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Dolphin:

            return std::make_shared<DolphinEntity>();

#endif

        case EntityType::Donkey:

            return std::make_shared<DonkeyEntity>();

        case EntityType::DragonFireball:

            return std::make_shared<DragonFireballEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Drowned:

            return std::make_shared<DrownedEntity>();

#endif

        case EntityType::ElderGuardian:

            return std::make_shared<ElderGuardianEntity>();

        case EntityType::EndCrystal:

            return std::make_shared<EndCrystalEntity>();

        case EntityType::EnderDragon:

            return std::make_shared<EnderDragonEntity>();

        case EntityType::EnderMan:

            return std::make_shared<EnderManEntity>();

        case EntityType::Endermite:

            return std::make_shared<EndermiteEntity>();

        case EntityType::Evoker:

            return std::make_shared<EvokerEntity>();

        case EntityType::EvokerFangs:

            return std::make_shared<EvokerFangsEntity>();

        case EntityType::ExperienceOrb:

            return std::make_shared<ExperienceOrbEntity>();

        case EntityType::EyeOfEnder:

            return std::make_shared<EyeOfEnderEntity>();

        case EntityType::FallingBlockEntity:

            return std::make_shared<FallingBlockEntity>();

        case EntityType::FireworkRocketEntity:

            return std::make_shared<FireworkRocketEntity>();

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::Fox:

            return std::make_shared<FoxEntity>();

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

        case EntityType::Frog:

            return std::make_shared<FrogEntity>();

#endif

        case EntityType::Ghast:

            return std::make_shared<GhastEntity>();

#if PROTOCOL_VERSION > 770 /* > 1.21.5 */

        case EntityType::HappyGhast:

            return std::make_shared<HappyGhastEntity>();

#endif

        case EntityType::Giant:

            return std::make_shared<GiantEntity>();

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

        case EntityType::GlowItemFrame:

            return std::make_shared<GlowItemFrameEntity>();

        case EntityType::GlowSquid:

            return std::make_shared<GlowSquidEntity>();

        case EntityType::Goat:

            return std::make_shared<GoatEntity>();

#endif

        case EntityType::Guardian:

            return std::make_shared<GuardianEntity>();

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

        case EntityType::Hoglin:

            return std::make_shared<HoglinEntity>();

#endif

        case EntityType::Horse:

            return std::make_shared<HorseEntity>();

        case EntityType::Husk:

            return std::make_shared<HuskEntity>();

        case EntityType::Illusioner:

            return std::make_shared<IllusionerEntity>();

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

        case EntityType::Interaction:

            return std::make_shared<InteractionEntity>();

#endif

        case EntityType::IronGolem:

            return std::make_shared<IronGolemEntity>();

        case EntityType::ItemEntity:

            return std::make_shared<ItemEntity>();

        case EntityType::ItemFrame:

            return std::make_shared<ItemFrameEntity>();

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

        case EntityType::OminousItemSpawner:

            return std::make_shared<OminousItemSpawnerEntity>();

#endif

        case EntityType::LargeFireball:

            return std::make_shared<LargeFireballEntity>();

        case EntityType::LeashFenceKnotEntity:

            return std::make_shared<LeashFenceKnotEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::LightningBolt:

            return std::make_shared<LightningBoltEntity>();

#endif

        case EntityType::Llama:

            return std::make_shared<LlamaEntity>();

        case EntityType::LlamaSpit:

            return std::make_shared<LlamaSpitEntity>();

        case EntityType::MagmaCube:

            return std::make_shared<MagmaCubeEntity>();

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

        case EntityType::Mannequin:

            return std::make_shared<MannequinEntity>();

#endif

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

        case EntityType::Marker:

            return std::make_shared<MarkerEntity>();

#endif

        case EntityType::Minecart:

            return std::make_shared<MinecartEntity>();

        case EntityType::MinecartChest:

            return std::make_shared<MinecartChestEntity>();

        case EntityType::MinecartCommandBlock:

            return std::make_shared<MinecartCommandBlockEntity>();

        case EntityType::MinecartFurnace:

            return std::make_shared<MinecartFurnaceEntity>();

        case EntityType::MinecartHopper:

            return std::make_shared<MinecartHopperEntity>();

        case EntityType::MinecartSpawner:

            return std::make_shared<MinecartSpawnerEntity>();

        case EntityType::MinecartTNT:

            return std::make_shared<MinecartTNTEntity>();

        case EntityType::Mule:

            return std::make_shared<MuleEntity>();

        case EntityType::MushroomCow:

            return std::make_shared<MushroomCowEntity>();

        case EntityType::Ocelot:

            return std::make_shared<OcelotEntity>();

        case EntityType::Painting:

            return std::make_shared<PaintingEntity>();

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::Panda:

            return std::make_shared<PandaEntity>();

#endif

        case EntityType::Parrot:

            return std::make_shared<ParrotEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Phantom:

            return std::make_shared<PhantomEntity>();

#endif

        case EntityType::Pig:

            return std::make_shared<PigEntity>();

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

        case EntityType::Piglin:

            return std::make_shared<PiglinEntity>();

#endif

#if PROTOCOL_VERSION > 736 /* > 1.16.1 */

        case EntityType::PiglinBrute:

            return std::make_shared<PiglinBruteEntity>();

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::Pillager:

            return std::make_shared<PillagerEntity>();

#endif

        case EntityType::PolarBear:

            return std::make_shared<PolarBearEntity>();

        case EntityType::PrimedTnt:

            return std::make_shared<PrimedTntEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Pufferfish:

            return std::make_shared<PufferfishEntity>();

#endif

        case EntityType::Rabbit:

            return std::make_shared<RabbitEntity>();

#if PROTOCOL_VERSION > 767 /* > 1.21.1 */

        case EntityType::Raft:

            return std::make_shared<RaftEntity>(type);

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::Ravager:

            return std::make_shared<RavagerEntity>();

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Salmon:

            return std::make_shared<SalmonEntity>();

#endif

        case EntityType::Sheep:

            return std::make_shared<SheepEntity>();

        case EntityType::Shulker:

            return std::make_shared<ShulkerEntity>();

        case EntityType::ShulkerBullet:

            return std::make_shared<ShulkerBulletEntity>();

        case EntityType::Silverfish:

            return std::make_shared<SilverfishEntity>();

        case EntityType::Skeleton:

            return std::make_shared<SkeletonEntity>();

        case EntityType::SkeletonHorse:

            return std::make_shared<SkeletonHorseEntity>();

        case EntityType::Slime:

            return std::make_shared<SlimeEntity>();

        case EntityType::SmallFireball:

            return std::make_shared<SmallFireballEntity>();

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

        case EntityType::Sniffer:

            return std::make_shared<SnifferEntity>();

#endif

        case EntityType::SnowGolem:

            return std::make_shared<SnowGolemEntity>();

        case EntityType::Snowball:

            return std::make_shared<SnowballEntity>();

        case EntityType::SpectralArrow:

            return std::make_shared<SpectralArrowEntity>();

        case EntityType::Spider:

            return std::make_shared<SpiderEntity>();

        case EntityType::Squid:

            return std::make_shared<SquidEntity>();

        case EntityType::Stray:

            return std::make_shared<StrayEntity>();

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

        case EntityType::Strider:

            return std::make_shared<StriderEntity>();

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

        case EntityType::Tadpole:

            return std::make_shared<TadpoleEntity>();

#endif

        case EntityType::ThrownEgg:

            return std::make_shared<ThrownEggEntity>();

        case EntityType::ThrownEnderpearl:

            return std::make_shared<ThrownEnderpearlEntity>();

        case EntityType::ThrownExperienceBottle:

            return std::make_shared<ThrownExperienceBottleEntity>();

#if PROTOCOL_VERSION < 770 /* < 1.21.5 */

        case EntityType::ThrownPotion:

            return std::make_shared<ThrownPotionEntity>();

#else

        case EntityType::ThrownSplashPotion:

            return std::make_shared<ThrownSplashPotionEntity>();

        case EntityType::ThrownLingeringPotion:

            return std::make_shared<ThrownLingeringPotionEntity>();

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::ThrownTrident:

            return std::make_shared<ThrownTridentEntity>();

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::TraderLlama:

            return std::make_shared<TraderLlamaEntity>();

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::TropicalFish:

            return std::make_shared<TropicalFishEntity>();

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Turtle:

            return std::make_shared<TurtleEntity>();

#endif

        case EntityType::Vex:

            return std::make_shared<VexEntity>();

        case EntityType::Villager:

            return std::make_shared<VillagerEntity>();

        case EntityType::Vindicator:

            return std::make_shared<VindicatorEntity>();

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::WanderingTrader:

            return std::make_shared<WanderingTraderEntity>();

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

        case EntityType::Warden:

            return std::make_shared<WardenEntity>();

#endif

#if PROTOCOL_VERSION > 764 /* > 1.20.2 */

        case EntityType::WindCharge:

            return std::make_shared<WindChargeEntity>();

#endif

        case EntityType::Witch:

            return std::make_shared<WitchEntity>();

        case EntityType::WitherBoss:

            return std::make_shared<WitherBossEntity>();

        case EntityType::WitherSkeleton:

            return std::make_shared<WitherSkeletonEntity>();

        case EntityType::WitherSkull:

            return std::make_shared<WitherSkullEntity>();

        case EntityType::Wolf:

            return std::make_shared<WolfEntity>();

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

        case EntityType::Zoglin:

            return std::make_shared<ZoglinEntity>();

#endif

        case EntityType::Zombie:

            return std::make_shared<ZombieEntity>();

        case EntityType::ZombieHorse:

            return std::make_shared<ZombieHorseEntity>();

        case EntityType::ZombieVillager:

            return std::make_shared<ZombieVillagerEntity>();

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

        case EntityType::ZombifiedPiglin:

            return std::make_shared<ZombifiedPiglinEntity>();

#else

        case EntityType::PigZombie:

            return std::make_shared<PigZombieEntity>();

#endif

        case EntityType::Player:

            return std::make_shared<PlayerEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::FishingHook:

            return std::make_shared<FishingHookEntity>();

#endif

        default:

            return nullptr;

        }

    }


#if PROTOCOL_VERSION < 458 /* < 1.14 */

    std::shared_ptr<Entity> Entity::CreateObjectEntity(const ObjectEntityType type)

    {

        switch (type)

        {

        case ObjectEntityType::None:

            return nullptr;

        case ObjectEntityType::Boat:

            return std::make_shared<BoatEntity>();

        case ObjectEntityType::ItemEntity:

            return std::make_shared<ItemEntity>();

        case ObjectEntityType::AreaEffectCloud:

            return std::make_shared<AreaEffectCloudEntity>();

        case ObjectEntityType::PrimedTnt:

            return std::make_shared<PrimedTntEntity>();

        case ObjectEntityType::EndCrystal:

            return std::make_shared<EndCrystalEntity>();

        case ObjectEntityType::Arrow:

            return std::make_shared<ArrowEntity>();

        case ObjectEntityType::Snowball:

            return std::make_shared<SnowballEntity>();

        case ObjectEntityType::ThrownEgg:

            return std::make_shared<ThrownEggEntity>();

        case ObjectEntityType::LargeFireball:

            return std::make_shared<LargeFireballEntity>();

        case ObjectEntityType::SmallFireball:

            return std::make_shared<SmallFireballEntity>();

        case ObjectEntityType::ThrownEnderpearl:

            return std::make_shared<ThrownEnderpearlEntity>();

        case ObjectEntityType::WitherSkull:

            return std::make_shared<WitherSkullEntity>();

        case ObjectEntityType::ShulkerBullet:

            return std::make_shared<ShulkerBulletEntity>();

        case ObjectEntityType::LlamaSpit:

            return std::make_shared<LlamaSpitEntity>();

        case ObjectEntityType::FallingBlockEntity:

            return std::make_shared<FallingBlockEntity>();

        case ObjectEntityType::ItemFrame:

            return std::make_shared<ItemFrameEntity>();

        case ObjectEntityType::EyeOfEnder:

            return std::make_shared<EyeOfEnderEntity>();

        case ObjectEntityType::ThrownPotion:

            return std::make_shared<ThrownPotionEntity>();

        case ObjectEntityType::ThrownExperienceBottle:

            return std::make_shared<ThrownExperienceBottleEntity>();

        case ObjectEntityType::FireworkRocketEntity:

            return std::make_shared<FireworkRocketEntity>();

        case ObjectEntityType::LeashFenceKnotEntity:

            return std::make_shared<LeashFenceKnotEntity>();

        case ObjectEntityType::ArmorStand:

            return std::make_shared<ArmorStandEntity>();

        case ObjectEntityType::EvokerFangs:

            return std::make_shared<EvokerFangsEntity>();

        case ObjectEntityType::FishingHook:

            return std::make_shared<FishingHookEntity>();

        case ObjectEntityType::SpectralArrow:

            return std::make_shared<SpectralArrowEntity>();

        case ObjectEntityType::DragonFireball:

            return std::make_shared<DragonFireballEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case ObjectEntityType::ThrownTrident:

            return std::make_shared<ThrownTridentEntity>();

#endif

        default:

            return nullptr;

        }

    }

#endif


#if USE_GUI


    void Entity::InitializeFaces()

    {

        std::scoped_lock<std::shared_mutex> lock(entity_mutex);

        const Renderer::Atlas* atlas = AssetsManager::getInstance().GetAtlas();


        // Generate default faces

        face_descriptors = std::vector<FaceDescriptor>(6);

        faces = std::vector<Renderer::Face>(6);

        const double half_height = GetHeightImpl() / 2.0;

        const double half_width = GetWidthImpl() / 2.0;

        for (int i = 0; i < 6; ++i)

        {

            face_descriptors[i].orientation = static_cast<Orientation>(i);

            face_descriptors[i].texture_names = { "" };

            face_descriptors[i].cullface_direction = Orientation::None;

            face_descriptors[i].use_tintindexes = { false };


            // Base entity scale

            face_descriptors[i].transformations.scales.push_back(std::make_shared<Renderer::Scale>(

                static_cast<float>(half_width),

                static_cast<float>(half_height),

                static_cast<float>(half_width)

            ));

            // Base translation

            face_descriptors[i].transformations.translations.push_back(std::make_shared<Renderer::Translation>(0.0f, static_cast<float>(half_height), 0.0f));

            // Entity pos translation

            face_descriptors[i].transformations.translations.push_back(std::make_shared<Renderer::Translation>(

                static_cast<float>(position.x),

                static_cast<float>(position.y),

                static_cast<float>(position.z))

            );

            // Entity yaw/pitch rotation

            face_descriptors[i].transformations.rotations.push_back(std::make_shared<Renderer::Rotation>(0.0f, 1.0f, 0.0f, yaw));

            face_descriptors[i].transformations.rotations.push_back(std::make_shared<Renderer::Rotation>(1.0f, 0.0f, 0.0f, pitch));


            face_descriptors[i].transformations.rotation = 0;


            faces[i] = Renderer::Face(face_descriptors[i].transformations, face_descriptors[i].orientation);

            faces[i].SetDisplayBackface(false);

            faces[i].SetTextureMultipliers({ 0xFFFFFFFF, 0xFFFFFFFF });


            // Extract texture info from the atlas

            std::array<unsigned short, 4> texture_pos = { 0, 0, 0, 0 };

            std::array<unsigned short, 4> texture_size = { 0, 0, 0, 0 };

            std::array<Renderer::Transparency, 2> transparencies = { Renderer::Transparency::Opaque, Renderer::Transparency::Opaque };

            std::array<Renderer::Animation, 2> animated = { Renderer::Animation::Static, Renderer::Animation::Static };


            for (int j = 0; j < std::min(2, static_cast<int>(face_descriptors[i].texture_names.size())); ++j)

            {

                const Renderer::TextureData& texture_data = atlas->GetData(face_descriptors[i].texture_names[j]);

                std::tie(texture_pos[2 * j + 0], texture_pos[2 * j + 1]) = texture_data.position;

                std::tie(texture_size[2 * j + 0], texture_size[2 * j + 1]) = texture_data.size;

                transparencies[j] = texture_data.transparency;

                animated[j] = texture_data.animation;

            }


            // Main texture coords in the atlas

            std::array<float, 4> coords = faces[i].GetTextureCoords(false);

            unsigned short height_normalizer = animated[0] == Renderer::Animation::Animated ? texture_size[0] : texture_size[1];

            coords[0] = (texture_pos[0] + coords[0] / 16.0f * texture_size[0]) / atlas->GetWidth();

            coords[1] = (texture_pos[1] + coords[1] / 16.0f * height_normalizer) / atlas->GetHeight();

            coords[2] = (texture_pos[0] + coords[2] / 16.0f * texture_size[0]) / atlas->GetWidth();

            coords[3] = (texture_pos[1] + coords[3] / 16.0f * height_normalizer) / atlas->GetHeight();

            faces[i].SetTextureCoords(coords, false);


            // Overlay texture coords in the atlas if existing

            if (face_descriptors[i].texture_names.size() > 1)

            {

                coords = faces[i].GetTextureCoords(true);

                height_normalizer = animated[1] == Renderer::Animation::Animated ? texture_size[2] : texture_size[3];

                coords[0] = (texture_pos[2] + coords[0] / 16.0f * texture_size[2]) / atlas->GetWidth();

                coords[1] = (texture_pos[3] + coords[1] / 16.0f * height_normalizer) / atlas->GetHeight();

                coords[2] = (texture_pos[2] + coords[2] / 16.0f * texture_size[2]) / atlas->GetWidth();

                coords[3] = (texture_pos[3] + coords[3] / 16.0f * height_normalizer) / atlas->GetHeight();

                faces[i].SetTextureCoords(coords, true);

            }


            faces[i].SetTransparencyData(transparencies[0]);

        }

        are_rendered_faces_up_to_date = false;

    }


    void Entity::OnSizeUpdated()

    {

        are_rendered_faces_up_to_date = false;

        const double half_width = GetWidthImpl() / 2.0;

        const double half_height = GetHeightImpl() / 2.0;

        for (size_t i = 0; i < faces.size(); ++i)

        {

            std::static_pointer_cast<Renderer::Scale>(face_descriptors[i].transformations.scales.back())->axis_x = static_cast<float>(half_width);

            std::static_pointer_cast<Renderer::Scale>(face_descriptors[i].transformations.scales.back())->axis_y = static_cast<float>(half_height);

            std::static_pointer_cast<Renderer::Scale>(face_descriptors[i].transformations.scales.back())->axis_z = static_cast<float>(half_width);

            std::static_pointer_cast<Renderer::Translation>(face_descriptors[i].transformations.translations.front())->y = static_cast<float>(half_height);

        }

    }


#endif


    char Entity::GetDataSharedFlagsIdImpl() const

    {

        return std::any_cast<char>(metadata.at("data_shared_flags_id"));

    }


    bool Entity::GetDataSharedFlagsIdImpl(const EntitySharedFlagsId id) const

    {

        return (GetDataSharedFlagsIdImpl() >> static_cast<char>(id)) & 0x01;

    }


    void Entity::SetDataSharedFlagsIdImpl(const char data_shared_flags_id)

    {

        metadata["data_shared_flags_id"] = data_shared_flags_id;

    }


    void Entity::SetDataSharedFlagsIdImpl(const EntitySharedFlagsId id, const bool b)

    {

        char current_value = GetDataSharedFlagsIdImpl();

        // Set the bit to 0

        const char mask = 0x01 << static_cast<char>(id);

        current_value &= ~mask;

        // Set the bit to b

        current_value |= b << static_cast<char>(id);

        SetDataSharedFlagsIdImpl(current_value);

    }


#if PROTOCOL_VERSION > 404 /* > 1.13.2 */


    Pose Entity::GetDataPoseImpl() const

    {

        return std::any_cast<Pose>(metadata.at("data_pose"));

    }


    void Entity::SetDataPoseImpl(const Pose data_pose)

    {

        metadata["data_pose"] = data_pose;

#if USE_GUI

        OnSizeUpdated();

#endif

    }


#endif


    AABB Entity::GetColliderImpl() const

    {

        const double half_width = GetWidthImpl() / 2.0;

        const double half_height = GetHeightImpl() / 2.0;

        return AABB(Vector3<double>(position.x, position.y + half_height, position.z), Vector3<double>(half_width, half_height, half_width));

    }


    double Entity::GetWidthImpl() const

    {

        return -1.0;

    }


    double Entity::GetHeightImpl() const

    {

        return -1.0;

    }


}


AllayEntity.hpp

AreaEffectCloudEntity.hpp

ArmadilloEntity.hpp

ArmorStandEntity.hpp

ArrowEntity.hpp

AssetsManager.hpp

Atlas.hpp

AxolotlEntity.hpp

BatEntity.hpp

BeeEntity.hpp

BlazeEntity.hpp

BoatEntity.hpp

BoggedEntity.hpp

BreezeEntity.hpp

BreezeWindChargeEntity.hpp

CamelEntity.hpp

CatEntity.hpp

CaveSpiderEntity.hpp

Chat.hpp

ChestBoatEntity.hpp

ChestRaftEntity.hpp

ChickenEntity.hpp

CodEntity.hpp

CopperGolemEntity.hpp

CowEntity.hpp

CreakingEntity.hpp

CreakingTransientEntity.hpp

CreeperEntity.hpp

DataComponentTypeResolvableProfile.hpp

DisplayBlockDisplayEntity.hpp

DisplayEntity.hpp

DisplayItemDisplayEntity.hpp

DisplayTextDisplayEntity.hpp

DolphinEntity.hpp

DonkeyEntity.hpp

DragonFireballEntity.hpp

DrownedEntity.hpp

ElderGuardianEntity.hpp

EndCrystalEntity.hpp

EnderDragonEntity.hpp

EnderManEntity.hpp

EndermiteEntity.hpp

EvokerEntity.hpp

EvokerFangsEntity.hpp

ExperienceOrbEntity.hpp

EyeOfEnderEntity.hpp

FallingBlockEntity.hpp

FireworkRocketEntity.hpp

FishingHookEntity.hpp

FoxEntity.hpp

FrogEntity.hpp

GhastEntity.hpp

GiantEntity.hpp

GlowItemFrameEntity.hpp

GlowSquidEntity.hpp

GoatEntity.hpp

GuardianEntity.hpp

HappyGhastEntity.hpp

HoglinEntity.hpp

HorseEntity.hpp

HuskEntity.hpp

IllusionerEntity.hpp

InteractionEntity.hpp

IronGolemEntity.hpp

ItemEntity.hpp

ItemFrameEntity.hpp

LargeFireballEntity.hpp

LeashFenceKnotEntity.hpp

LightningBoltEntity.hpp

LlamaEntity.hpp

LlamaSpitEntity.hpp

Logger.hpp

LOG_ERROR
#define LOG_ERROR(osstream)
Definition Logger.hpp:45

MagmaCubeEntity.hpp

MannequinEntity.hpp

MarkerEntity.hpp

MinecartChestEntity.hpp

MinecartCommandBlockEntity.hpp

MinecartEntity.hpp

MinecartFurnaceEntity.hpp

MinecartHopperEntity.hpp

MinecartSpawnerEntity.hpp

MinecartTNTEntity.hpp

MuleEntity.hpp

MushroomCowEntity.hpp

NBT.hpp

OcelotEntity.hpp

OminousItemSpawnerEntity.hpp

PaintingEntity.hpp

PandaEntity.hpp

ParrotEntity.hpp

Particle.hpp

PhantomEntity.hpp

PigEntity.hpp

PigZombieEntity.hpp

PiglinBruteEntity.hpp

PiglinEntity.hpp

PillagerEntity.hpp

PlayerEntity.hpp

PolarBearEntity.hpp

PrimedTntEntity.hpp

PufferfishEntity.hpp

RabbitEntity.hpp

RaftEntity.hpp

RavagerEntity.hpp

SalmonEntity.hpp

SheepEntity.hpp

ShulkerBulletEntity.hpp

ShulkerEntity.hpp

SilverfishEntity.hpp

SkeletonEntity.hpp

SkeletonHorseEntity.hpp

SlimeEntity.hpp

Slot.hpp

SmallFireballEntity.hpp

SnifferEntity.hpp

SnowGolemEntity.hpp

SnowballEntity.hpp

SpectralArrowEntity.hpp

SpiderEntity.hpp

SquidEntity.hpp

StrayEntity.hpp

StriderEntity.hpp

TadpoleEntity.hpp

ThrownEggEntity.hpp

ThrownEnderpearlEntity.hpp

ThrownExperienceBottleEntity.hpp

ThrownLingeringPotionEntity.hpp

ThrownPotionEntity.hpp

ThrownSplashPotionEntity.hpp

ThrownTridentEntity.hpp

TraderLlamaEntity.hpp

TropicalFishEntity.hpp

TurtleEntity.hpp

VexEntity.hpp

VillagerData.hpp

VillagerEntity.hpp

VindicatorEntity.hpp

WanderingTraderEntity.hpp

WardenEntity.hpp

WindChargeEntity.hpp

WitchEntity.hpp

WitherBossEntity.hpp

WitherSkeletonEntity.hpp

WitherSkullEntity.hpp

WolfEntity.hpp

ZoglinEntity.hpp

ZombieEntity.hpp

ZombieHorseEntity.hpp

ZombieVillagerEntity.hpp

ZombifiedPiglinEntity.hpp

GlobalPos.hpp

Botcraft::AABB
Definition AABB.hpp:8

Botcraft::AssetsManager::GetAtlas
const Renderer::Atlas * GetAtlas() const
Definition AssetsManager.cpp:240

Botcraft::AssetsManager::getInstance
static AssetsManager & getInstance()
Definition AssetsManager.cpp:21

Botcraft::Entity::GetDataTicksFrozen
int GetDataTicksFrozen() const
Definition Entity.cpp:793

Botcraft::Entity::OnSizeUpdated
void OnSizeUpdated()
Definition Entity.cpp:2074

Botcraft::Entity::GetOnGround
bool GetOnGround() const
Definition Entity.cpp:940

Botcraft::Entity::uuid
ProtocolCraft::UUID uuid
Definition Entity.hpp:267

Botcraft::Entity::GetHeightImpl
virtual double GetHeightImpl() const
Definition Entity.cpp:2142

Botcraft::Entity::SetDataSilent
void SetDataSilent(const bool data_silent)
Definition Entity.cpp:839

Botcraft::Entity::Serialize
virtual ProtocolCraft::Json::Value Serialize() const
Definition Entity.cpp:1192

Botcraft::Entity::SetDataPose
void SetDataPose(const Pose data_pose)
Definition Entity.cpp:852

Botcraft::Entity::equipments
std::map< EquipmentSlot, ProtocolCraft::Slot > equipments
Items on this entity.
Definition Entity.hpp:276

Botcraft::Entity::SetY
virtual void SetY(const double y_)
Definition Entity.cpp:1041

Botcraft::Entity::GetZ
double GetZ() const
Definition Entity.cpp:898

Botcraft::Entity::IsAbstractChestedHorse
virtual bool IsAbstractChestedHorse() const
Definition Entity.cpp:1297

Botcraft::Entity::IsWaterAnimal
virtual bool IsWaterAnimal() const
Definition Entity.cpp:1292

Botcraft::Entity::SetEffects
void SetEffects(const std::vector< EntityEffect > &effects_)
Definition Entity.cpp:1141

Botcraft::Entity::SetDataAirSupplyId
void SetDataAirSupplyId(const int data_air_supply_id)
Definition Entity.cpp:813

Botcraft::Entity::SetDataSharedFlagsIdImpl
void SetDataSharedFlagsIdImpl(const char data_shared_flags_id)
Definition Entity.cpp:2099

Botcraft::Entity::GetSpeed
Vector3< double > GetSpeed() const
Definition Entity.cpp:916

Botcraft::Entity::SetUUID
void SetUUID(const ProtocolCraft::UUID &uuid_)
Definition Entity.cpp:1000

Botcraft::Entity::GetEquipments
std::map< EquipmentSlot, ProtocolCraft::Slot > GetEquipments() const
Definition Entity.cpp:946

Botcraft::Entity::speed
Vector3< double > speed
Definition Entity.hpp:271

Botcraft::Entity::IsAbstractArrow
virtual bool IsAbstractArrow() const
Definition Entity.cpp:1248

Botcraft::Entity::IsAbstractSkeleton
virtual bool IsAbstractSkeleton() const
Definition Entity.cpp:1404

Botcraft::Entity::IsAbstractPiglin
virtual bool IsAbstractPiglin() const
Definition Entity.cpp:1374

Botcraft::Entity::GetEntityID
int GetEntityID() const
Definition Entity.cpp:868

Botcraft::Entity::IsLocalPlayer
virtual bool IsLocalPlayer() const
Definition Entity.cpp:1233

Botcraft::Entity::GetHeight
double GetHeight() const
Definition Entity.cpp:360

Botcraft::Entity::effects
std::vector< EntityEffect > effects
Definition Entity.hpp:277

Botcraft::Entity::GetDataSharedFlagsIdImpl
char GetDataSharedFlagsIdImpl() const
Definition Entity.cpp:2089

Botcraft::Entity::IsRemotePlayer
virtual bool IsRemotePlayer() const
Definition Entity.cpp:1238

Botcraft::Entity::Entity
Entity()
Definition Entity.cpp:296

Botcraft::Entity::GetDataSilent
bool GetDataSilent() const
Definition Entity.cpp:772

Botcraft::Entity::SetDataPoseImpl
void SetDataPoseImpl(const Pose data_pose)
Definition Entity.cpp:2121

Botcraft::Entity::GetSpeedX
double GetSpeedX() const
Definition Entity.cpp:922

Botcraft::Entity::IsAbstractBoat
virtual bool IsAbstractBoat() const
Definition Entity.cpp:1458

Botcraft::Entity::IsAbstractHurtingProjectile
virtual bool IsAbstractHurtingProjectile() const
Definition Entity.cpp:1302

Botcraft::Entity::pitch
float pitch
Definition Entity.hpp:270

Botcraft::Entity::GetUUID
ProtocolCraft::UUID GetUUID() const
Definition Entity.cpp:874

Botcraft::Entity::GetY
double GetY() const
Definition Entity.cpp:892

Botcraft::Entity::IsAbstractSchoolingFish
virtual bool IsAbstractSchoolingFish() const
Definition Entity.cpp:1287

Botcraft::Entity::SetSpeed
void SetSpeed(const Vector3< double > &speed_)
Definition Entity.cpp:1105

Botcraft::Entity::IsHangingEntity
virtual bool IsHangingEntity() const
Definition Entity.cpp:1341

Botcraft::Entity::GetAreRenderedFacesUpToDate
bool GetAreRenderedFacesUpToDate() const
Definition Entity.cpp:986

Botcraft::Entity::SetMetadataValue
virtual void SetMetadataValue(const int index, const std::any &value)
Definition Entity.cpp:719

Botcraft::Entity::IsSpellcasterIllager
virtual bool IsSpellcasterIllager() const
Definition Entity.cpp:1312

Botcraft::Entity::IsBlockAttachedEntity
virtual bool IsBlockAttachedEntity() const
Definition Entity.cpp:1451

Botcraft::Entity::CreateEntity
static std::shared_ptr< Entity > CreateEntity(const EntityType type)
Definition Entity.cpp:1501

Botcraft::Entity::IsAbstractThrownPotion
virtual bool IsAbstractThrownPotion() const
Definition Entity.cpp:1386

Botcraft::Entity::GetCollider
AABB GetCollider() const
Definition Entity.cpp:348

Botcraft::Entity::metadata_names
static const std::array< std::string, metadata_count > metadata_names
Definition Entity.hpp:61

Botcraft::Entity::are_rendered_faces_up_to_date
bool are_rendered_faces_up_to_date
Definition Entity.hpp:286

Botcraft::Entity::GetWidthImpl
virtual double GetWidthImpl() const
Definition Entity.cpp:2137

Botcraft::Entity::SetZ
virtual void SetZ(const double z_)
Definition Entity.cpp:1057

Botcraft::Entity::SetEquipment
void SetEquipment(const EquipmentSlot slot, const ProtocolCraft::Slot &item)
Definition Entity.cpp:1135

Botcraft::Entity::faces
std::vector< Renderer::Face > faces
Definition Entity.hpp:284

Botcraft::Entity::IsLivingEntity
virtual bool IsLivingEntity() const
Definition Entity.cpp:1243

Botcraft::Entity::IsChestBoat
virtual bool IsChestBoat() const
Definition Entity.cpp:1478

Botcraft::Entity::GetWidth
double GetWidth() const
Definition Entity.cpp:354

Botcraft::Entity::~Entity
virtual ~Entity()
Definition Entity.cpp:342

Botcraft::Entity::IsPatrollingMonster
virtual bool IsPatrollingMonster() const
Definition Entity.cpp:1432

Botcraft::Entity::IsProjectile
virtual bool IsProjectile() const
Definition Entity.cpp:1318

Botcraft::Entity::GetDataAirSupplyId
int GetDataAirSupplyId() const
Definition Entity.cpp:746

Botcraft::Entity::GetEffects
std::vector< EntityEffect > GetEffects() const
Definition Entity.cpp:958

Botcraft::Entity::IsAbstractMinecart
virtual bool IsAbstractMinecart() const
Definition Entity.cpp:1351

Botcraft::Entity::IsAvatar
virtual bool IsAvatar() const
Definition Entity.cpp:1494

Botcraft::Entity::IsDisplay
virtual bool IsDisplay() const
Definition Entity.cpp:1269

Botcraft::Entity::SetSpeedY
void SetSpeedY(const double speed_y_)
Definition Entity.cpp:1117

Botcraft::Entity::IsAbstractMinecartContainer
virtual bool IsAbstractMinecartContainer() const
Definition Entity.cpp:1363

Botcraft::Entity::SetDataCustomName
void SetDataCustomName(const std::optional< ProtocolCraft::Chat > &data_custom_name)
Definition Entity.cpp:820

Botcraft::Entity::IsAmbientCreature
virtual bool IsAmbientCreature() const
Definition Entity.cpp:1258

Botcraft::Entity::IsFireball
virtual bool IsFireball() const
Definition Entity.cpp:1346

Botcraft::Entity::GetDataPose
Pose GetDataPose() const
Definition Entity.cpp:785

Botcraft::Entity::entity_mutex
std::shared_mutex entity_mutex
Definition Entity.hpp:264

Botcraft::Entity::SetOnGround
void SetOnGround(const bool on_ground_)
Definition Entity.cpp:1129

Botcraft::Entity::IsAnimal
virtual bool IsAnimal() const
Definition Entity.cpp:1253

Botcraft::Entity::GetFaces
std::vector< Renderer::Face > GetFaces(const bool reset_uptodate_status)
Definition Entity.cpp:965

Botcraft::Entity::SetSpeedX
void SetSpeedX(const double speed_x_)
Definition Entity.cpp:1111

Botcraft::Entity::IsAbstractFish
virtual bool IsAbstractFish() const
Definition Entity.cpp:1392

Botcraft::Entity::IsAgeableMob
virtual bool IsAgeableMob() const
Definition Entity.cpp:1421

Botcraft::Entity::SetX
virtual void SetX(const double x_)
Definition Entity.cpp:1025

Botcraft::Entity::IsAbstractVillager
virtual bool IsAbstractVillager() const
Definition Entity.cpp:1415

Botcraft::Entity::InitializeFaces
virtual void InitializeFaces()
Definition Entity.cpp:1992

Botcraft::Entity::IsThrowableProjectile
virtual bool IsThrowableProjectile() const
Definition Entity.cpp:1438

Botcraft::Entity::IsAbstractWindCharge
virtual bool IsAbstractWindCharge() const
Definition Entity.cpp:1444

Botcraft::Entity::GetColliderImpl
AABB GetColliderImpl() const
Definition Entity.cpp:2130

Botcraft::Entity::SetDataSharedFlagsId
void SetDataSharedFlagsId(const char data_shared_flags_id)
Definition Entity.cpp:801

Botcraft::Entity::entity_id
int entity_id
Definition Entity.hpp:266

Botcraft::Entity::GetDataSharedFlagsId
char GetDataSharedFlagsId() const
Definition Entity.cpp:734

Botcraft::Entity::IsMob
virtual bool IsMob() const
Definition Entity.cpp:1307

Botcraft::Entity::SetYaw
virtual void SetYaw(const float yaw_)
Definition Entity.cpp:1073

Botcraft::Entity::IsPathfinderMob
virtual bool IsPathfinderMob() const
Definition Entity.cpp:1426

Botcraft::Entity::GetEquipment
ProtocolCraft::Slot GetEquipment(const EquipmentSlot slot) const
Definition Entity.cpp:952

Botcraft::Entity::SetDataCustomNameVisible
void SetDataCustomNameVisible(const bool data_custom_name_visible)
Definition Entity.cpp:833

Botcraft::Entity::IsVehicle
virtual bool IsVehicle() const
Definition Entity.cpp:1276

Botcraft::Entity::GetSpeedY
double GetSpeedY() const
Definition Entity.cpp:928

Botcraft::Entity::GetSpeedZ
double GetSpeedZ() const
Definition Entity.cpp:934

Botcraft::Entity::GetDataPoseImpl
Pose GetDataPoseImpl() const
Definition Entity.cpp:2116

Botcraft::Entity::on_ground
bool on_ground
Definition Entity.hpp:272

Botcraft::Entity::IsRaider
virtual bool IsRaider() const
Definition Entity.cpp:1398

Botcraft::Entity::SetPitch
virtual void SetPitch(const float pitch_)
Definition Entity.cpp:1089

Botcraft::Entity::IsThrowableItemProjectile
virtual bool IsThrowableItemProjectile() const
Definition Entity.cpp:1409

Botcraft::Entity::SetEntityID
void SetEntityID(const int entity_id_)
Definition Entity.cpp:994

Botcraft::Entity::IsMonster
virtual bool IsMonster() const
Definition Entity.cpp:1263

Botcraft::Entity::IsTamableAnimal
virtual bool IsTamableAnimal() const
Definition Entity.cpp:1282

Botcraft::Entity::SetDataNoGravity
void SetDataNoGravity(const bool data_no_gravity)
Definition Entity.cpp:845

Botcraft::Entity::GetDataCustomNameVisible
bool GetDataCustomNameVisible() const
Definition Entity.cpp:766

Botcraft::Entity::IsAbstractIllager
virtual bool IsAbstractIllager() const
Definition Entity.cpp:1380

Botcraft::Entity::IsAbstractHorse
virtual bool IsAbstractHorse() const
Definition Entity.cpp:1331

Botcraft::Entity::metadata
std::map< std::string, std::any > metadata
Definition Entity.hpp:279

Botcraft::Entity::position
Vector3< double > position
Definition Entity.hpp:268

Botcraft::Entity::IsAbstractCow
virtual bool IsAbstractCow() const
Definition Entity.cpp:1357

Botcraft::Entity::IsAbstractChestBoat
virtual bool IsAbstractChestBoat() const
Definition Entity.cpp:1463

Botcraft::Entity::AddEffect
void AddEffect(const EntityEffect &effect)
Definition Entity.cpp:1163

Botcraft::Entity::IsChestRaft
virtual bool IsChestRaft() const
Definition Entity.cpp:1483

Botcraft::Entity::IsAbstractGolem
virtual bool IsAbstractGolem() const
Definition Entity.cpp:1336

Botcraft::Entity::GetYaw
float GetYaw() const
Definition Entity.cpp:904

Botcraft::Entity::IsAgeableWaterCreature
virtual bool IsAgeableWaterCreature() const
Definition Entity.cpp:1468

Botcraft::Entity::GetX
double GetX() const
Definition Entity.cpp:886

Botcraft::Entity::GetDataNoGravity
bool GetDataNoGravity() const
Definition Entity.cpp:778

Botcraft::Entity::SetAreRenderedFacesUpToDate
void SetAreRenderedFacesUpToDate(const bool are_rendered_faces_up_to_date_)
Definition Entity.cpp:1184

Botcraft::Entity::GetPosition
Vector3< double > GetPosition() const
Definition Entity.cpp:880

Botcraft::Entity::SetSpeedZ
void SetSpeedZ(const double speed_z_)
Definition Entity.cpp:1123

Botcraft::Entity::metadata_count
static constexpr int metadata_count
Definition Entity.hpp:55

Botcraft::Entity::face_descriptors
std::vector< FaceDescriptor > face_descriptors
Definition Entity.hpp:283

Botcraft::Entity::GetDataCustomName
std::optional< ProtocolCraft::Chat > GetDataCustomName() const
Definition Entity.cpp:753

Botcraft::Entity::IsBoat
virtual bool IsBoat() const
Definition Entity.cpp:1473

Botcraft::Entity::LoadMetadataFromRawArray
void LoadMetadataFromRawArray(const std::vector< unsigned char > &data)
Definition Entity.cpp:367

Botcraft::Entity::IsRaft
virtual bool IsRaft() const
Definition Entity.cpp:1488

Botcraft::Entity::IsShoulderRidingEntity
virtual bool IsShoulderRidingEntity() const
Definition Entity.cpp:1368

Botcraft::Entity::GetPitch
float GetPitch() const
Definition Entity.cpp:910

Botcraft::Entity::RemoveEffect
void RemoveEffect(const EntityEffectType type)
Definition Entity.cpp:1147

Botcraft::Entity::SetPosition
virtual void SetPosition(const Vector3< double > &position_)
Definition Entity.cpp:1006

Botcraft::Entity::SetDataTicksFrozen
void SetDataTicksFrozen(const int data_ticks_frozen)
Definition Entity.cpp:860

Botcraft::Entity::yaw
float yaw
Definition Entity.hpp:269

Botcraft::Renderer::Atlas
Definition Atlas.hpp:22

Botcraft::Renderer::Atlas::GetHeight
int GetHeight() const
Definition Atlas.cpp:232

Botcraft::Renderer::Atlas::GetData
const TextureData & GetData(const std::string &name) const
Definition Atlas.cpp:237

Botcraft::Renderer::Atlas::GetWidth
int GetWidth() const
Definition Atlas.cpp:227

Botcraft::Renderer::Face
Definition Face.hpp:18

ProtocolCraft::Chat
Definition Chat.hpp:18

ProtocolCraft::Identifier
Definition Identifier.hpp:8

ProtocolCraft::Json::Value
Main class, basically a JsonVariant with extra utility functions it doesn't inherit JsonVariant direc...
Definition Json.hpp:45

ProtocolCraft::NBT::UnnamedValue
Definition NBT.hpp:12

ProtocolCraft::NBT::Value
Definition NBT.hpp:25

ProtocolCraft::NetworkPosition
Definition NetworkPosition.hpp:8

ProtocolCraft::NetworkType::Read
virtual void Read(ReadIterator &iter, size_t &length)
Definition NetworkType.hpp:18

ProtocolCraft::Particle
Definition Particle.hpp:279

ProtocolCraft::Slot
Definition Slot.hpp:13

Entity.hpp

Botcraft::Renderer::Animation::Animated
@ Animated

Botcraft::Renderer::Animation::Static
@ Static

Botcraft::Renderer::Transparency::Opaque
@ Opaque

Botcraft
Definition BaseNode.hpp:6

Botcraft::Pose
Pose
Definition Enums.hpp:250

Botcraft::Pose::Standing
@ Standing

Botcraft::Orientation
Orientation
Definition Enums.hpp:168

Botcraft::Orientation::None
@ None

Botcraft::Position
Vector3< int > Position
Definition Vector3.hpp:294

Botcraft::EquipmentSlot
EquipmentSlot
Definition Enums.hpp:276

Botcraft::EquipmentSlot::MainHand
@ MainHand

Botcraft::EquipmentSlot::ChestPlate
@ ChestPlate

Botcraft::EquipmentSlot::OffHand
@ OffHand

Botcraft::EquipmentSlot::Helmet
@ Helmet

Botcraft::EquipmentSlot::Boots
@ Boots

Botcraft::EquipmentSlot::BodyAnimalArmor
@ BodyAnimalArmor

Botcraft::EquipmentSlot::Leggings
@ Leggings

Botcraft::EquipmentSlot::Saddle
@ Saddle

Botcraft::Direction
Direction
Definition Enums.hpp:197

Botcraft::EntityEffectType
EntityEffectType
Definition Enums.hpp:321

Botcraft::EntityType
EntityType
Definition Entity.hpp:291

Botcraft::EntityType::MinecartHopper
@ MinecartHopper

Botcraft::EntityType::Marker
@ Marker

Botcraft::EntityType::Donkey
@ Donkey

Botcraft::EntityType::GlowSquid
@ GlowSquid

Botcraft::EntityType::Turtle
@ Turtle

Botcraft::EntityType::Pufferfish
@ Pufferfish

Botcraft::EntityType::ThrownTrident
@ ThrownTrident

Botcraft::EntityType::MinecartTNT
@ MinecartTNT

Botcraft::EntityType::Squid
@ Squid

Botcraft::EntityType::ChestRaft
@ ChestRaft

Botcraft::EntityType::Arrow
@ Arrow

Botcraft::EntityType::Ravager
@ Ravager

Botcraft::EntityType::SnowGolem
@ SnowGolem

Botcraft::EntityType::ZombieHorse
@ ZombieHorse

Botcraft::EntityType::Camel
@ Camel

Botcraft::EntityType::DragonFireball
@ DragonFireball

Botcraft::EntityType::Witch
@ Witch

Botcraft::EntityType::ExperienceOrb
@ ExperienceOrb

Botcraft::EntityType::Frog
@ Frog

Botcraft::EntityType::Warden
@ Warden

Botcraft::EntityType::Guardian
@ Guardian

Botcraft::EntityType::Piglin
@ Piglin

Botcraft::EntityType::Wolf
@ Wolf

Botcraft::EntityType::Painting
@ Painting

Botcraft::EntityType::LightningBolt
@ LightningBolt

Botcraft::EntityType::MangroveChestBoat
@ MangroveChestBoat

Botcraft::EntityType::Zoglin
@ Zoglin

Botcraft::EntityType::CopperGolem
@ CopperGolem

Botcraft::EntityType::Bat
@ Bat

Botcraft::EntityType::Husk
@ Husk

Botcraft::EntityType::Silverfish
@ Silverfish

Botcraft::EntityType::PrimedTnt
@ PrimedTnt

Botcraft::EntityType::Pig
@ Pig

Botcraft::EntityType::FireworkRocketEntity
@ FireworkRocketEntity

Botcraft::EntityType::Rabbit
@ Rabbit

Botcraft::EntityType::ThrownEgg
@ ThrownEgg

Botcraft::EntityType::Sniffer
@ Sniffer

Botcraft::EntityType::Horse
@ Horse

Botcraft::EntityType::Evoker
@ Evoker

Botcraft::EntityType::Tadpole
@ Tadpole

Botcraft::EntityType::TropicalFish
@ TropicalFish

Botcraft::EntityType::CherryBoat
@ CherryBoat

Botcraft::EntityType::MinecartCommandBlock
@ MinecartCommandBlock

Botcraft::EntityType::GlowItemFrame
@ GlowItemFrame

Botcraft::EntityType::BirchBoat
@ BirchBoat

Botcraft::EntityType::ItemEntity
@ ItemEntity

Botcraft::EntityType::WitherBoss
@ WitherBoss

Botcraft::EntityType::PaleOakBoat
@ PaleOakBoat

Botcraft::EntityType::FishingHook
@ FishingHook

Botcraft::EntityType::Drowned
@ Drowned

Botcraft::EntityType::MagmaCube
@ MagmaCube

Botcraft::EntityType::ElderGuardian
@ ElderGuardian

Botcraft::EntityType::MinecartSpawner
@ MinecartSpawner

Botcraft::EntityType::Mule
@ Mule

Botcraft::EntityType::WitherSkull
@ WitherSkull

Botcraft::EntityType::Pillager
@ Pillager

Botcraft::EntityType::ZombieVillager
@ ZombieVillager

Botcraft::EntityType::EnderDragon
@ EnderDragon

Botcraft::EntityType::Sheep
@ Sheep

Botcraft::EntityType::Armadillo
@ Armadillo

Botcraft::EntityType::Bogged
@ Bogged

Botcraft::EntityType::Panda
@ Panda

Botcraft::EntityType::AreaEffectCloud
@ AreaEffectCloud

Botcraft::EntityType::LargeFireball
@ LargeFireball

Botcraft::EntityType::JungleBoat
@ JungleBoat

Botcraft::EntityType::Interaction
@ Interaction

Botcraft::EntityType::Player
@ Player

Botcraft::EntityType::MinecartChest
@ MinecartChest

Botcraft::EntityType::MushroomCow
@ MushroomCow

Botcraft::EntityType::Skeleton
@ Skeleton

Botcraft::EntityType::None
@ None

Botcraft::EntityType::SpruceBoat
@ SpruceBoat

Botcraft::EntityType::LeashFenceKnotEntity
@ LeashFenceKnotEntity

Botcraft::EntityType::Giant
@ Giant

Botcraft::EntityType::BirchChestBoat
@ BirchChestBoat

Botcraft::EntityType::Hoglin
@ Hoglin

Botcraft::EntityType::JungleChestBoat
@ JungleChestBoat

Botcraft::EntityType::IronGolem
@ IronGolem

Botcraft::EntityType::Shulker
@ Shulker

Botcraft::EntityType::Dolphin
@ Dolphin

Botcraft::EntityType::PaleOakChestBoat
@ PaleOakChestBoat

Botcraft::EntityType::SpectralArrow
@ SpectralArrow

Botcraft::EntityType::Zombie
@ Zombie

Botcraft::EntityType::AcaciaChestBoat
@ AcaciaChestBoat

Botcraft::EntityType::OakBoat
@ OakBoat

Botcraft::EntityType::ThrownEnderpearl
@ ThrownEnderpearl

Botcraft::EntityType::WanderingTrader
@ WanderingTrader

Botcraft::EntityType::EvokerFangs
@ EvokerFangs

Botcraft::EntityType::Vex
@ Vex

Botcraft::EntityType::Goat
@ Goat

Botcraft::EntityType::ThrownSplashPotion
@ ThrownSplashPotion

Botcraft::EntityType::ThrownExperienceBottle
@ ThrownExperienceBottle

Botcraft::EntityType::Blaze
@ Blaze

Botcraft::EntityType::Ocelot
@ Ocelot

Botcraft::EntityType::SkeletonHorse
@ SkeletonHorse

Botcraft::EntityType::Mannequin
@ Mannequin

Botcraft::EntityType::Villager
@ Villager

Botcraft::EntityType::Cod
@ Cod

Botcraft::EntityType::DisplayItemDisplay
@ DisplayItemDisplay

Botcraft::EntityType::EndCrystal
@ EndCrystal

Botcraft::EntityType::Llama
@ Llama

Botcraft::EntityType::OminousItemSpawner
@ OminousItemSpawner

Botcraft::EntityType::ZombifiedPiglin
@ ZombifiedPiglin

Botcraft::EntityType::AcaciaBoat
@ AcaciaBoat

Botcraft::EntityType::Breeze
@ Breeze

Botcraft::EntityType::Slime
@ Slime

Botcraft::EntityType::Stray
@ Stray

Botcraft::EntityType::Chicken
@ Chicken

Botcraft::EntityType::Bee
@ Bee

Botcraft::EntityType::DarkOakChestBoat
@ DarkOakChestBoat

Botcraft::EntityType::Allay
@ Allay

Botcraft::EntityType::Spider
@ Spider

Botcraft::EntityType::MangroveBoat
@ MangroveBoat

Botcraft::EntityType::HappyGhast
@ HappyGhast

Botcraft::EntityType::MinecartFurnace
@ MinecartFurnace

Botcraft::EntityType::OakChestBoat
@ OakChestBoat

Botcraft::EntityType::Illusioner
@ Illusioner

Botcraft::EntityType::SpruceChestBoat
@ SpruceChestBoat

Botcraft::EntityType::Snowball
@ Snowball

Botcraft::EntityType::DisplayBlockDisplay
@ DisplayBlockDisplay

Botcraft::EntityType::Endermite
@ Endermite

Botcraft::EntityType::WitherSkeleton
@ WitherSkeleton

Botcraft::EntityType::CherryChestBoat
@ CherryChestBoat

Botcraft::EntityType::Raft
@ Raft

Botcraft::EntityType::TraderLlama
@ TraderLlama

Botcraft::EntityType::ShulkerBullet
@ ShulkerBullet

Botcraft::EntityType::Creaking
@ Creaking

Botcraft::EntityType::Fox
@ Fox

Botcraft::EntityType::Minecart
@ Minecart

Botcraft::EntityType::FallingBlockEntity
@ FallingBlockEntity

Botcraft::EntityType::Vindicator
@ Vindicator

Botcraft::EntityType::DarkOakBoat
@ DarkOakBoat

Botcraft::EntityType::EnderMan
@ EnderMan

Botcraft::EntityType::Salmon
@ Salmon

Botcraft::EntityType::LlamaSpit
@ LlamaSpit

Botcraft::EntityType::PolarBear
@ PolarBear

Botcraft::EntityType::PiglinBrute
@ PiglinBrute

Botcraft::EntityType::Creeper
@ Creeper

Botcraft::EntityType::Axolotl
@ Axolotl

Botcraft::EntityType::Parrot
@ Parrot

Botcraft::EntityType::Ghast
@ Ghast

Botcraft::EntityType::BreezeWindCharge
@ BreezeWindCharge

Botcraft::EntityType::Phantom
@ Phantom

Botcraft::EntityType::ItemFrame
@ ItemFrame

Botcraft::EntityType::Strider
@ Strider

Botcraft::EntityType::DisplayTextDisplay
@ DisplayTextDisplay

Botcraft::EntityType::ThrownLingeringPotion
@ ThrownLingeringPotion

Botcraft::EntityType::ArmorStand
@ ArmorStand

Botcraft::EntityType::EyeOfEnder
@ EyeOfEnder

Botcraft::EntityType::Cat
@ Cat

Botcraft::EntityType::CaveSpider
@ CaveSpider

Botcraft::EntityType::WindCharge
@ WindCharge

Botcraft::EntityType::Cow
@ Cow

Botcraft::EntityType::SmallFireball
@ SmallFireball

Botcraft::EntitySharedFlagsId
EntitySharedFlagsId
Definition Entity.hpp:40

ProtocolCraft::UUID
std::array< unsigned char, 16 > UUID
Definition BinaryReadWrite.hpp:20

ProtocolCraft::ReadIterator
std::vector< unsigned char >::const_iterator ReadIterator
Definition BinaryReadWrite.hpp:17

SheepEntity.hpp

Botcraft::EntityEffect
Definition Entity.hpp:33

Botcraft::EntityEffect::type
EntityEffectType type
Definition Entity.hpp:34

Botcraft::Renderer::TextureData
Definition Atlas.hpp:12

Botcraft::Renderer::TextureData::position
std::pair< int, int > position
<Col, Row>
Definition Atlas.hpp:16

Botcraft::Renderer::TextureData::animation
Animation animation
Definition Atlas.hpp:18

Botcraft::Renderer::TextureData::transparency
Transparency transparency
Definition Atlas.hpp:17

Botcraft::Renderer::TextureData::size
std::pair< int, int > size
<Width, Height>
Definition Atlas.hpp:14

Botcraft::Vector3
Definition Vector3.hpp:16

Botcraft::Vector3::Serialize
ProtocolCraft::Json::Value Serialize() const
Definition Vector3.hpp:279

Botcraft::Vector3::x
T x
Definition Vector3.hpp:70

Botcraft::Vector3::y
T y
Definition Vector3.hpp:71

Botcraft::Vector3::z
T z
Definition Vector3.hpp:72

Botcraft::VillagerData
Definition VillagerData.hpp:7

WolfEntity.hpp