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/cubemob/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/cubemob/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

#if PROTOCOL_VERSION > 775 /* > 26.1.2 */

#include "botcraft/Game/Entities/entities/monster/cubemob/SulfurCubeEntity.hpp"

#endif

#if PROTOCOL_VERSION > 776 /* > 26.2 */

#include "botcraft/Game/Entities/entities/decoration/CushionEntity.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

#if PROTOCOL_VERSION > 776 /* > 26.2 */

                DyeColor,

#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

#if PROTOCOL_VERSION > 776 /* > 26.2 */

            case EntityMetadataTypes::DyeColor:

                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


#if PROTOCOL_VERSION > 775 /* > 26.1.2 */


    bool Entity::IsAbstractCubeMob() 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 > 776 /* > 26.2 */

        case EntityType::Cushion:

            return std::make_shared<CushionEntity>();

#endif

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

#if PROTOCOL_VERSION > 776 /* > 26.2 */

        case EntityType::PoplarBoat:

            return std::make_shared<BoatEntity>(EntityType::PoplarBoat);

        case EntityType::PoplarChestBoat:

            return std::make_shared<ChestBoatEntity>(EntityType::PoplarChestBoat);

#endif

        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 > 775 /* > 26.1.2 */

        case EntityType::SulfurCube:

            return std::make_shared<SulfurCubeEntity>();

#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 float half_width = static_cast<float>(GetWidthImpl()) / 2.0f;

        const float half_height = static_cast<float>(GetHeightImpl()) / 2.0f;

        return AABB(

            Vector3<double>(position.x, position.y + half_height, position.z),

            Vector3<double>(static_cast<double>(half_width), static_cast<double>(half_height), static_cast<double>(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

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

SulfurCubeEntity.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:857

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Botcraft::Entity::IsAbstractCubeMob
virtual bool IsAbstractCubeMob() const
Definition Entity.cpp:1573

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ProtocolCraft::Slot
Definition Slot.hpp:17

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

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

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

Botcraft::EntityEffectType
EntityEffectType
Definition Enums.hpp:330

Botcraft::EntityType
EntityType
Definition Entity.hpp:297

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

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

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

Botcraft::EntityType::Bee
@ Bee

Botcraft::EntityType::DarkOakChestBoat
@ DarkOakChestBoat

Botcraft::EntityType::Allay
@ Allay

Botcraft::EntityType::Spider
@ Spider

Botcraft::EntityType::MangroveBoat
@ MangroveBoat

Botcraft::EntityType::PoplarBoat
@ PoplarBoat

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