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 > 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/arrow/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/boat/ChestRaftEntity.hpp"

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

#endif

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

#if PROTOCOL_VERSION > 498 /* > 1.14.4 */

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

#endif

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

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

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

#include "botcraft/Game/Entities/entities/monster/skeleton/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/hurtingprojectile/windcharge/BreezeWindChargeEntity.hpp"

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

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

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

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

#endif

#if PROTOCOL_VERSION > 760 /* > 1.19.2 */

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

#endif

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

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

#endif

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

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

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */


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


#endif


#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

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

#endif

#include "botcraft/Game/Entities/entities/animal/cow/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/dolphin/DolphinEntity.hpp"

#endif

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

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

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

#include "botcraft/Game/Entities/entities/monster/zombie/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/illager/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/fox/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/happyghast/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/animal/squid/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/equine/HorseEntity.hpp"

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

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

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

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

#endif

#include "botcraft/Game/Entities/entities/animal/golem/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/hurtingprojectile/LargeFireballEntity.hpp"

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

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

#include "botcraft/Game/Entities/entities/animal/equine/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/minecart/MinecartEntity.hpp"

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

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

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

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

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

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

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

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

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

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

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

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

#endif

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

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

#include "botcraft/Game/Entities/entities/animal/pig/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/zombie/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/illager/PillagerEntity.hpp"

#endif

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

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

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

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

#endif

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

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

#include "botcraft/Game/Entities/entities/animal/rabbit/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/fish/SalmonEntity.hpp"

#endif

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

#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/skeleton/SkeletonEntity.hpp"

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

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

#include "botcraft/Game/Entities/entities/projectile/hurtingprojectile/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/golem/SnowGolemEntity.hpp"

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

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

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

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

#include "botcraft/Game/Entities/entities/monster/skeleton/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/throwableitemprojectile/ThrownEggEntity.hpp"

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

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

#if PROTOCOL_VERSION < 770 /* < 1.21.5 */

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

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

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

#endif


#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

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

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

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

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

#include "botcraft/Game/Entities/entities/npc/wanderingtrader/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/hurtingprojectile/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/skeleton/WitherSkeletonEntity.hpp"

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

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

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

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

#endif

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


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

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

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

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

#endif

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

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

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

#include "botcraft/Game/Entities/entities/animal/nautilus/NautilusEntity.hpp"

#include "botcraft/Game/Entities/entities/animal/nautilus/ZombieNautilusEntity.hpp"

#include "botcraft/Game/Entities/entities/monster/skeleton/ParchedEntity.hpp"

#endif


#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 > 774 /* > 1.21.11 */

                CatSoundVariant,

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

                CowVariant,

#endif

#if PROTOCOL_VERSION > 774 /* > 1.21.11 */

                CowSoundVariant,

#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,

#endif

#if PROTOCOL_VERSION > 774 /* > 1.21.11 */

                PigSoundVariant,

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

                ChickenVariant,

#endif

#if PROTOCOL_VERSION > 774 /* > 1.21.11 */

                ChickenSoundVariant,

#endif

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

                ZombieNautilusVariant,

#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

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

                HumanoidArm,

#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 > 774 /* > 1.21.11 */

            case EntityMetadataTypes::CatSoundVariant:

                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 > 774 /* > 1.21.11 */

            case EntityMetadataTypes::CowSoundVariant:

                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;

#endif

#if PROTOCOL_VERSION > 774 /* > 1.21.11 */

            case EntityMetadataTypes::PigSoundVariant:

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

                break;

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

            case EntityMetadataTypes::ChickenVariant:

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

                break;

#endif

#if PROTOCOL_VERSION > 774 /* > 1.21.11 */

            case EntityMetadataTypes::ChickenSoundVariant:

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

                break;

#endif

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

            case EntityMetadataTypes::ZombieNautilusVariant:

                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

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

            case EntityMetadataTypes::HumanoidArm:

                value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(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


#if PROTOCOL_VERSION > 773 /* > 1.21.10 */


    bool Entity::IsAbstractNautilus() 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

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

        case EntityType::CamelHusk:

            return std::make_shared<CamelHuskEntity>();

#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>();

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

        case EntityType::Nautilus:

            return std::make_shared<NautilusEntity>();

#endif

        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

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

        case EntityType::Parched:

            return std::make_shared<ParchedEntity>();

#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>();

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

        case EntityType::ZombieNautilus:

            return std::make_shared<ZombieNautilusEntity>();

#endif

        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

CamelHuskEntity.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

NautilusEntity.hpp

OcelotEntity.hpp

OminousItemSpawnerEntity.hpp

PaintingEntity.hpp

PandaEntity.hpp

ParchedEntity.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

ZombieNautilusEntity.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:843

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Botcraft::Entity::IsAbstractNautilus
virtual bool IsAbstractNautilus() const
Definition Entity.cpp:1552

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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:289

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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:286

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

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

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

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

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

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

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

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

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

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

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:283

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:256

Botcraft::Pose::Standing
@ Standing

Botcraft::Orientation
Orientation
Definition Enums.hpp:171

Botcraft::Orientation::None
@ None

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

Botcraft::EquipmentSlot
EquipmentSlot
Definition Enums.hpp:282

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:203

Botcraft::EntityEffectType
EntityEffectType
Definition Enums.hpp:327

Botcraft::EntityType
EntityType
Definition Entity.hpp:294

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::ZombieNautilus
@ ZombieNautilus

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::Parched
@ Parched

Botcraft::EntityType::ThrownEnderpearl
@ ThrownEnderpearl

Botcraft::EntityType::WanderingTrader
@ WanderingTrader

Botcraft::EntityType::EvokerFangs
@ EvokerFangs

Botcraft::EntityType::CamelHusk
@ CamelHusk

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::Nautilus
@ Nautilus

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

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