Botcraft/Game_2Entities_2entities_2Entity_8cpp_source.html

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


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

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

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

#if PROTOCOL_VERSION < 773 /* < 1.21.9 */

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

#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

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

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

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

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

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

#endif


#if USE_GUI

#include "botcraft/Game/AssetsManager.hpp"

#include "botcraft/Renderer/Atlas.hpp"

#endif

#include "botcraft/Utilities/Logger.hpp"


#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

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

#endif

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

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

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

#endif

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

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

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

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

#endif

#if PROTOCOL_VERSION > 767 /* > 1.21.1 */

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

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

#endif

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

#if PROTOCOL_VERSION > 498 /* > 1.14.4 */

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

#endif

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

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

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

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

#endif

#if PROTOCOL_VERSION > 764 /* > 1.20.2 */

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

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

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

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

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

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

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

#endif

#if PROTOCOL_VERSION > 760 /* > 1.19.2 */

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

#endif

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

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

#endif

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

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

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */


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


#endif


#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

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

#endif

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

#if PROTOCOL_VERSION > 767 /* > 1.21.1 */

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

#endif

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

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

#endif

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

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

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

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

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

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

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

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

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

#endif

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

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

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

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

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

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

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

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

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

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

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

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

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

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

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

#endif

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

#if PROTOCOL_VERSION > 770 /* > 1.21.5 */

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

#endif

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

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

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

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

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

#endif

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

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

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

#endif

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

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

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

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

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

#endif

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

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

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

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

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

#endif

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

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

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

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

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

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

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

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

#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

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

#endif

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

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

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

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

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

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

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

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

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

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

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

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

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

#endif

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

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

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

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

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

#else

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

#endif

#if PROTOCOL_VERSION > 736 /* > 1.16.1 */

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

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

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

#endif

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

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

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

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

#endif

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

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

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

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

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

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

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

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

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

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

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

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

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

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

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

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

#endif

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

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

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

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

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

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

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

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

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

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

#endif

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

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

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

#if PROTOCOL_VERSION < 770 /* < 1.21.5 */

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

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

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

#endif


#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#endif

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

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

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

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

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

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

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

#endif

#if PROTOCOL_VERSION > 764 /* > 1.20.2 */

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

#endif

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

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

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

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

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

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

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

#endif

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


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

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

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

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

#endif

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

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

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

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

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

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

#endif


#include <mutex>


namespace Botcraft

{

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

        "data_shared_flags_id",

        "data_air_supply_id",

        "data_custom_name",

        "data_custom_name_visible",

        "data_silent",

        "data_no_gravity",

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        "data_pose",

#endif

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

        "data_ticks_frozen",

#endif

    } };


    Entity::Entity()

    {

        {

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

            // Initialize base stuff

            entity_id = 0;

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

            yaw = 0.0f;

            pitch = 0.0f;

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

            on_ground = false;

            equipments = {

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

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

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

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

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

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

#if PROTOCOL_VERSION > 766 /* > 1.20.6 */

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

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

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

#endif

            };

        }


        // Initialize all metadata with default values

        SetDataSharedFlagsId(0);

        SetDataAirSupplyId(300);

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#else

        SetDataCustomName("");

#endif

        SetDataCustomNameVisible(false);

        SetDataSilent(false);

        SetDataNoGravity(false);

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        SetDataPose(Pose::Standing);

#endif

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

        SetDataTicksFrozen(0);

#endif

    }


    Entity::~Entity()

    {


    }


    AABB Entity::GetCollider() const

    {

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

        return GetColliderImpl();

    }


    double Entity::GetWidth() const

    {

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

        return GetWidthImpl();

    }


    double Entity::GetHeight() const

    {

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

        return GetHeightImpl();

    }


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

    {

        if (data.size() == 0)

        {

            return;

        }


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

        size_t length = data.size();


        while (true)

        {

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

            if (index == 0xFF)

            {

                break;

            }


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

            std::any value;


            enum EntityMetadataTypes

            {

                Char = 0,

                Int,

#if PROTOCOL_VERSION > 760 /* > 1.19.2 */

                Long,

#endif

                Float,

                String,

                Chat,

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

                OptionalChat,

#endif

                Slot,

                Bool,

                Rotations,

                BlockPosition,

                OptionalBlockPosition,

                DirectionType,

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

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

#else

                OptionalUUID,

#endif

                BlockstateType,

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

                OptionalBlockstate,

#endif

#if PROTOCOL_VERSION < 773 /* < 1.21.9 */

                NBT,

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

                Particle,

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

                Particles,

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

                VillagerDataType,

                OptionalUint,

                PoseType,

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

                CatVariant,

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

                CowVariant,

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

                WolfVariant,

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

                WolfSoundVariant,

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

                FrogVariant,

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

                PigVariant,

                ChickenVariant,

#endif

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

                ZombieNautilusVariant,

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

                OptionalGlobalPos,

                PaintingVariant,

#endif

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

                SnifferState,

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

                ArmadilloState,

#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

                CopperGolemState,

                WeatheringCopperState,

#endif

                Vec3,

                Quaternion,

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

                ResolvableProfile,

#endif

#endif

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

                HumanoidArm,

#endif

            };


            switch (type)

            {

            case EntityMetadataTypes::Char:

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

                break;

            case EntityMetadataTypes::Int:

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

                break;

#if PROTOCOL_VERSION > 760 /* > 1.19.2 */

            case EntityMetadataTypes::Long:

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

                break;

#endif

            case EntityMetadataTypes::Float:

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

                break;

            case EntityMetadataTypes::String:

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

                break;

            case EntityMetadataTypes::Chat:

                value = ProtocolCraft::Chat();

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

                break;

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

            case EntityMetadataTypes::OptionalChat:

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

                {

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

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

                }

                else

                {

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

                }

                break;

#endif

            case EntityMetadataTypes::Slot:

                value = ProtocolCraft::Slot();

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

                break;

            case EntityMetadataTypes::Bool:

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

                break;

            case EntityMetadataTypes::Rotations:

            {

                Vector3<float> rotation;

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

                {

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

                }

                value = rotation;

                break;

            }

            case EntityMetadataTypes::BlockPosition:

            {

                ProtocolCraft::NetworkPosition position;

                position.Read(iter, length);

                value = Position(position);

                break;

            }

            case EntityMetadataTypes::OptionalBlockPosition:

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

                {

                    ProtocolCraft::NetworkPosition position;

                    position.Read(iter, length);

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

                }

                else

                {

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

                }

                break;

            case EntityMetadataTypes::DirectionType:

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

                break;

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

            case EntityMetadataTypes::OptionalLivingEntityReference:

#else

            case EntityMetadataTypes::OptionalUUID:

#endif

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

                {

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

                }

                else

                {

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

                }

                break;

            case EntityMetadataTypes::BlockstateType:

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

                break;

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

            case EntityMetadataTypes::OptionalBlockstate:

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

                {

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

                }

                else

                {

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

                }

                break;

#endif

#if PROTOCOL_VERSION < 773 /* < 1.21.9 */

            case EntityMetadataTypes::NBT:

            {

                ProtocolCraft::NBT::UnnamedValue unnamed_value;

                unnamed_value.Read(iter, length);

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

                break;

            }

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

            case EntityMetadataTypes::Particle:

            {

                ProtocolCraft::Particle particle;

                particle.Read(iter, length);

                value = particle;

                break;

            }

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

            case EntityMetadataTypes::Particles:

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

                break;

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

            case EntityMetadataTypes::VillagerDataType:

                value = VillagerData{

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

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

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

                };

                break;

            case EntityMetadataTypes::OptionalUint:

            {

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

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

                break;

            }

            case EntityMetadataTypes::PoseType:

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

                break;

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

            case EntityMetadataTypes::CatVariant:

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

                break;

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

            case EntityMetadataTypes::CowVariant:

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

                break;

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

            case EntityMetadataTypes::WolfVariant:

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

                break;

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

            case EntityMetadataTypes::WolfSoundVariant:

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

                break;

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

            case EntityMetadataTypes::FrogVariant:

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

                break;

#endif

#if PROTOCOL_VERSION > 769 /* > 1.21.4 */

            case EntityMetadataTypes::PigVariant:

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

                break;

            case EntityMetadataTypes::ChickenVariant:

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

                break;

#endif

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

            case EntityMetadataTypes::ZombieNautilusVariant:

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

                break;

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

            case EntityMetadataTypes::OptionalGlobalPos:

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

                {

                    ProtocolCraft::Identifier dimension;

                    dimension.Read(iter, length);

                    ProtocolCraft::NetworkPosition pos;

                    pos.Read(iter, length);


                    value = std::optional<GlobalPos>({

                            dimension,

                            pos

                        });

                }

                else

                {

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

                }

                break;

            case EntityMetadataTypes::PaintingVariant:

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

                break;

#endif

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

            case EntityMetadataTypes::SnifferState:

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

                break;

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

            case EntityMetadataTypes::ArmadilloState:

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

                break;

#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

            case EntityMetadataTypes::CopperGolemState:

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

                break;

            case EntityMetadataTypes::WeatheringCopperState:

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

                break;

#endif

            case EntityMetadataTypes::Vec3:

            {

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

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

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

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

            }

            break;

            case EntityMetadataTypes::Quaternion:

            {

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

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

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

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

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

            }

            break;

#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

            case EntityMetadataTypes::ResolvableProfile:

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

                break;

#endif

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

            case EntityMetadataTypes::HumanoidArm:

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

                break;

#endif

            default:

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

                return;

            }

            SetMetadataValue(index, value);

        }

    }


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

    {

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

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

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

        metadata[metadata_name] = value;

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

        if (metadata_name == "data_pose")

        {

            OnSizeUpdated();

        }

#endif

    }


    char Entity::GetDataSharedFlagsId() const

    {

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

        return GetDataSharedFlagsIdImpl();

    }


    bool Entity::GetDataSharedFlagsId(const EntitySharedFlagsId id) const

    {

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

        return GetDataSharedFlagsIdImpl(id);

    }


    int Entity::GetDataAirSupplyId() const

    {

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

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

    }


#if PROTOCOL_VERSION > 340 /* > 1.12.2 */


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

    {

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

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

    }


#else

    std::string Entity::GetDataCustomName() const

    {

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

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

    }

#endif


    bool Entity::GetDataCustomNameVisible() const

    {

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

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

    }


    bool Entity::GetDataSilent() const

    {

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

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

    }


    bool Entity::GetDataNoGravity() const

    {

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

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

    }


#if PROTOCOL_VERSION > 404 /* > 1.13.2 */


    Pose Entity::GetDataPose() const

    {

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

        return GetDataPoseImpl();

    }


#endif


#if PROTOCOL_VERSION > 754 /* > 1.16.5 */


    int Entity::GetDataTicksFrozen() const

    {

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

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

    }


#endif


    void Entity::SetDataSharedFlagsId(const char data_shared_flags_id)

    {

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

        SetDataSharedFlagsIdImpl(data_shared_flags_id);

    }


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

    {

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

        SetDataSharedFlagsIdImpl(id, b);

    }


    void Entity::SetDataAirSupplyId(const int data_air_supply_id)

    {

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

        metadata["data_air_supply_id"] = data_air_supply_id;

    }


#if PROTOCOL_VERSION > 340 /* > 1.12.2 */


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

    {

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

        metadata["data_custom_name"] = data_custom_name;

    }


#else

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

    {

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

        metadata["data_custom_name"] = data_custom_name;

    }

#endif


    void Entity::SetDataCustomNameVisible(const bool data_custom_name_visible)

    {

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

        metadata["data_custom_name_visible"] = data_custom_name_visible;

    }


    void Entity::SetDataSilent(const bool data_silent)

    {

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

        metadata["data_silent"] = data_silent;

    }


    void Entity::SetDataNoGravity(const bool data_no_gravity)

    {

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

        metadata["data_no_gravity"] = data_no_gravity;

    }


#if PROTOCOL_VERSION > 404 /* > 1.13.2 */


    void Entity::SetDataPose(const Pose data_pose)

    {

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

        SetDataPoseImpl(data_pose);

    }


#endif


#if PROTOCOL_VERSION > 754 /* > 1.16.5 */


    void Entity::SetDataTicksFrozen(const int data_ticks_frozen)

    {

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

        metadata["data_ticks_frozen"] = data_ticks_frozen;

    }


#endif


    int Entity::GetEntityID() const

    {

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

        return entity_id;

    }


    ProtocolCraft::UUID Entity::GetUUID() const

    {

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

        return uuid;

    }


    Vector3<double> Entity::GetPosition() const

    {

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

        return position;

    }


    double Entity::GetX() const

    {

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

        return position.x;

    }


    double Entity::GetY() const

    {

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

        return position.y;

    }


    double Entity::GetZ() const

    {

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

        return position.z;

    }


    float Entity::GetYaw() const

    {

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

        return yaw;

    }


    float Entity::GetPitch() const

    {

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

        return pitch;

    }


    Vector3<double> Entity::GetSpeed() const

    {

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

        return speed;

    }


    double Entity::GetSpeedX() const

    {

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

        return speed.x;

    }


    double Entity::GetSpeedY() const

    {

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

        return speed.y;

    }


    double Entity::GetSpeedZ() const

    {

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

        return speed.z;

    }


    bool Entity::GetOnGround() const

    {

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

        return on_ground;

    }


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

    {

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

        return equipments;

    }


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

    {

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

        return equipments.at(slot);

    }


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

    {

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

        return effects;

    }


#if USE_GUI


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

    {

        if (faces.size() == 0)

        {

            InitializeFaces();

        }

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

        if (!are_rendered_faces_up_to_date)

        {

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

            {

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

            }

        }

        if (reset_uptodate_status)

        {

            are_rendered_faces_up_to_date = true;

        }

        return faces;

    }


    bool Entity::GetAreRenderedFacesUpToDate() const

    {

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

        return are_rendered_faces_up_to_date;

    }


#endif


    void Entity::SetEntityID(const int entity_id_)

    {

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

        entity_id = entity_id_;

    }


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

    {

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

        uuid = uuid_;

    }


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

    {

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

#if USE_GUI

        if (position_ != position)

        {

            are_rendered_faces_up_to_date = false;

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

            {

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

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

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

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

            }

        }

#endif

        position = position_;

    }


    void Entity::SetX(const double x_)

    {

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

#if USE_GUI

        if (x_ != position.x)

        {

            are_rendered_faces_up_to_date = false;

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

            {

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

            }

        }

#endif

        position.x = x_;

    }


    void Entity::SetY(const double y_)

    {

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

#if USE_GUI

        if (y_ != position.y)

        {

            are_rendered_faces_up_to_date = false;

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

            {

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

            }

        }

#endif

        position.y = y_;

    }


    void Entity::SetZ(const double z_)

    {

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

#if USE_GUI

        if (z_ != position.z)

        {

            are_rendered_faces_up_to_date = false;

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

            {

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

            }

        }

#endif

        position.z = z_;

    }


    void Entity::SetYaw(const float yaw_)

    {

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

#if USE_GUI

        if (yaw_ != yaw)

        {

            are_rendered_faces_up_to_date = false;

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

            {

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

            }

        }

#endif

        yaw = yaw_;

    }


    void Entity::SetPitch(const float pitch_)

    {

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

#if USE_GUI

        if (pitch_ != pitch)

        {

            are_rendered_faces_up_to_date = false;

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

            {

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

            }

        }

#endif

        pitch = pitch_;

    }


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

    {

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

        speed = speed_;

    }


    void Entity::SetSpeedX(const double speed_x_)

    {

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

        speed.x = speed_x_;

    }


    void Entity::SetSpeedY(const double speed_y_)

    {

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

        speed.y = speed_y_;

    }


    void Entity::SetSpeedZ(const double speed_z_)

    {

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

        speed.z = speed_z_;

    }


    void Entity::SetOnGround(const bool on_ground_)

    {

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

        on_ground = on_ground_;

    }


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

    {

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

        equipments.at(slot) = item;

    }


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

    {

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

        effects = effects_;

    }


    void Entity::RemoveEffect(const EntityEffectType type)

    {

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

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

        {

            if (it->type == type)

            {

                it = effects.erase(it);

            }

            else

            {

                ++it;

            }

        }

    }


    void Entity::AddEffect(const EntityEffect& effect)

    {

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

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

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

        {

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

            {

                it = effects.erase(it);

            }

            else

            {

                ++it;

            }

        }


        // Then add the new one

        effects.push_back(effect);

    }


#if USE_GUI


    void Entity::SetAreRenderedFacesUpToDate(const bool should_be_updated_)

    {

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

        are_rendered_faces_up_to_date = should_be_updated_;

    }


#endif


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

    {

        ProtocolCraft::Json::Value output;


        {

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

            output["id"] = entity_id;

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

            output["yaw"] = yaw;

            output["pitch"] = pitch;

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

            output["on_ground"] = on_ground;

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

            for (auto& p : equipments)

            {

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

            }

        }


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


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

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

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

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

#else

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

#endif

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

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

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

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

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

#endif

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

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

#endif


        return output;

    }


    bool Entity::IsLocalPlayer() const

    {

        return false;

    }


    bool Entity::IsRemotePlayer() const

    {

        return false;

    }


    bool Entity::IsLivingEntity() const

    {

        return false;

    }


    bool Entity::IsAbstractArrow() const

    {

        return false;

    }


    bool Entity::IsAnimal() const

    {

        return false;

    }


    bool Entity::IsAmbientCreature() const

    {

        return false;

    }


    bool Entity::IsMonster() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 761 /* > 1.19.3 */


    bool Entity::IsDisplay() const

    {

        return false;

    }


#endif


#if PROTOCOL_VERSION > 764 /* > 1.20.2 */


    bool Entity::IsVehicle() const

    {

        return false;

    }


#endif


    bool Entity::IsTamableAnimal() const

    {

        return false;

    }


    bool Entity::IsAbstractSchoolingFish() const

    {

        return false;

    }


    bool Entity::IsWaterAnimal() const

    {

        return false;

    }


    bool Entity::IsAbstractChestedHorse() const

    {

        return false;

    }


    bool Entity::IsAbstractHurtingProjectile() const

    {

        return false;

    }


    bool Entity::IsMob() const

    {

        return false;

    }


    bool Entity::IsSpellcasterIllager() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 578 /* > 1.15.2 */


    bool Entity::IsProjectile() const

    {

        return false;

    }


#endif


#if PROTOCOL_VERSION < 771 /* < 1.21.6 */

    bool Entity::IsFlyingMob() const

    {

        return false;

    }

#endif


    bool Entity::IsAbstractHorse() const

    {

        return false;

    }


    bool Entity::IsAbstractGolem() const

    {

        return false;

    }


    bool Entity::IsHangingEntity() const

    {

        return false;

    }


    bool Entity::IsFireball() const

    {

        return false;

    }


    bool Entity::IsAbstractMinecart() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 769 /* > 1.21.4 */


    bool Entity::IsAbstractCow() const

    {

        return false;

    }


#endif


    bool Entity::IsAbstractMinecartContainer() const

    {

        return false;

    }


    bool Entity::IsShoulderRidingEntity() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 736 /* > 1.16.1 */


    bool Entity::IsAbstractPiglin() const

    {

        return false;

    }


#endif


    bool Entity::IsAbstractIllager() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 769 /* > 1.21.4 */


    bool Entity::IsAbstractThrownPotion() const

    {

        return false;

    }


#endif


    bool Entity::IsAbstractFish() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 404 /* > 1.13.2 */


    bool Entity::IsRaider() const

    {

        return false;

    }


#endif


    bool Entity::IsAbstractSkeleton() const

    {

        return false;

    }


    bool Entity::IsThrowableItemProjectile() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 477 /* > 1.14 */


    bool Entity::IsAbstractVillager() const

    {

        return false;

    }


#endif


    bool Entity::IsAgeableMob() const

    {

        return false;

    }


    bool Entity::IsPathfinderMob() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 404 /* > 1.13.2 */


    bool Entity::IsPatrollingMonster() const

    {

        return false;

    }


#endif


    bool Entity::IsThrowableProjectile() const

    {

        return false;

    }


#if PROTOCOL_VERSION > 765 /* > 1.20.4 */


    bool Entity::IsAbstractWindCharge() const

    {

        return false;

    }


#endif


#if PROTOCOL_VERSION > 766 /* > 1.20.6 */


    bool Entity::IsBlockAttachedEntity() const

    {

        return false;

    }


#endif


#if PROTOCOL_VERSION > 767 /* > 1.21.1 */


    bool Entity::IsAbstractBoat() const

    {

        return false;

    }


    bool Entity::IsAbstractChestBoat() const

    {

        return false;

    }


    bool Entity::IsAgeableWaterCreature() const

    {

        return false;

    }


    bool Entity::IsBoat() const

    {

        return false;

    }


    bool Entity::IsChestBoat() const

    {

        return false;

    }


    bool Entity::IsChestRaft() const

    {

        return false;

    }


    bool Entity::IsRaft() const

    {

        return false;

    }


#endif


#if PROTOCOL_VERSION > 772 /* > 1.21.8 */


    bool Entity::IsAvatar() const

    {

        return false;

    }


#endif


#if PROTOCOL_VERSION > 773 /* > 1.21.10 */


    bool Entity::IsAbstractNautilus() const

    {

        return false;

    }


#endif


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

    {

        switch (type)

        {

        case EntityType::None:

            return nullptr;

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

        case EntityType::Allay:

            return std::make_shared<AllayEntity>();

#endif

        case EntityType::AreaEffectCloud:

            return std::make_shared<AreaEffectCloudEntity>();

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

        case EntityType::Armadillo:

            return std::make_shared<ArmadilloEntity>();

#endif

        case EntityType::ArmorStand:

            return std::make_shared<ArmorStandEntity>();

        case EntityType::Arrow:

            return std::make_shared<ArrowEntity>();

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

        case EntityType::Axolotl:

            return std::make_shared<AxolotlEntity>();

#endif

        case EntityType::Bat:

            return std::make_shared<BatEntity>();

#if PROTOCOL_VERSION > 498 /* > 1.14.4 */

        case EntityType::Bee:

            return std::make_shared<BeeEntity>();

#endif

        case EntityType::Blaze:

            return std::make_shared<BlazeEntity>();

#if PROTOCOL_VERSION < 768 /* < 1.21.2 */

        case EntityType::Boat:

            return std::make_shared<BoatEntity>();

#else

        case EntityType::AcaciaBoat:

        case EntityType::BirchBoat:

        case EntityType::CherryBoat:

        case EntityType::DarkOakBoat:

        case EntityType::JungleBoat:

        case EntityType::MangroveBoat:

        case EntityType::OakBoat:

        case EntityType::PaleOakBoat:

        case EntityType::SpruceBoat:

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

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

        case EntityType::Bogged:

            return std::make_shared<BoggedEntity>();

#endif

#if PROTOCOL_VERSION > 764 /* > 1.20.2 */

        case EntityType::Breeze:

            return std::make_shared<BreezeEntity>();

#endif

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

        case EntityType::BreezeWindCharge:

            return std::make_shared<BreezeWindChargeEntity>();

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

#if PROTOCOL_VERSION < 768 /* < 1.21.2 */

        case EntityType::ChestBoat:

            return std::make_shared<ChestBoatEntity>();

#else

        case EntityType::AcaciaChestBoat:

        case EntityType::BirchChestBoat:

        case EntityType::CherryChestBoat:

        case EntityType::DarkOakChestBoat:

        case EntityType::JungleChestBoat:

        case EntityType::MangroveChestBoat:

        case EntityType::OakChestBoat:

        case EntityType::PaleOakChestBoat:

        case EntityType::SpruceChestBoat:

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

#endif

#endif

#if PROTOCOL_VERSION > 767 /* > 1.21.1 */

        case EntityType::ChestRaft:

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

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::Cat:

            return std::make_shared<CatEntity>();

#endif

#if PROTOCOL_VERSION > 760 /* > 1.19.2 */

        case EntityType::Camel:

            return std::make_shared<CamelEntity>();

#endif

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

        case EntityType::CamelHusk:

            return std::make_shared<CamelHuskEntity>();

#endif

        case EntityType::CaveSpider:

            return std::make_shared<CaveSpiderEntity>();

        case EntityType::Chicken:

            return std::make_shared<ChickenEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Cod:

            return std::make_shared<CodEntity>();

#endif

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

        case EntityType::CopperGolem:

            return std::make_shared<CopperGolemEntity>();

#endif

        case EntityType::Cow:

            return std::make_shared<CowEntity>();

#if PROTOCOL_VERSION > 767 /* > 1.21.1 */

        case EntityType::Creaking:

            return std::make_shared<CreakingEntity>();

#endif

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

        case EntityType::CreakingTransient:

            return std::make_shared<CreakingTransientEntity>();

#endif

        case EntityType::Creeper:

            return std::make_shared<CreeperEntity>();

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

        case EntityType::DisplayBlockDisplay:

            return std::make_shared<DisplayBlockDisplayEntity>();

        case EntityType::DisplayItemDisplay:

            return std::make_shared<DisplayItemDisplayEntity>();

        case EntityType::DisplayTextDisplay:

            return std::make_shared<DisplayTextDisplayEntity>();

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Dolphin:

            return std::make_shared<DolphinEntity>();

#endif

        case EntityType::Donkey:

            return std::make_shared<DonkeyEntity>();

        case EntityType::DragonFireball:

            return std::make_shared<DragonFireballEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Drowned:

            return std::make_shared<DrownedEntity>();

#endif

        case EntityType::ElderGuardian:

            return std::make_shared<ElderGuardianEntity>();

        case EntityType::EndCrystal:

            return std::make_shared<EndCrystalEntity>();

        case EntityType::EnderDragon:

            return std::make_shared<EnderDragonEntity>();

        case EntityType::EnderMan:

            return std::make_shared<EnderManEntity>();

        case EntityType::Endermite:

            return std::make_shared<EndermiteEntity>();

        case EntityType::Evoker:

            return std::make_shared<EvokerEntity>();

        case EntityType::EvokerFangs:

            return std::make_shared<EvokerFangsEntity>();

        case EntityType::ExperienceOrb:

            return std::make_shared<ExperienceOrbEntity>();

        case EntityType::EyeOfEnder:

            return std::make_shared<EyeOfEnderEntity>();

        case EntityType::FallingBlockEntity:

            return std::make_shared<FallingBlockEntity>();

        case EntityType::FireworkRocketEntity:

            return std::make_shared<FireworkRocketEntity>();

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::Fox:

            return std::make_shared<FoxEntity>();

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

        case EntityType::Frog:

            return std::make_shared<FrogEntity>();

#endif

        case EntityType::Ghast:

            return std::make_shared<GhastEntity>();

#if PROTOCOL_VERSION > 770 /* > 1.21.5 */

        case EntityType::HappyGhast:

            return std::make_shared<HappyGhastEntity>();

#endif

        case EntityType::Giant:

            return std::make_shared<GiantEntity>();

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

        case EntityType::GlowItemFrame:

            return std::make_shared<GlowItemFrameEntity>();

        case EntityType::GlowSquid:

            return std::make_shared<GlowSquidEntity>();

        case EntityType::Goat:

            return std::make_shared<GoatEntity>();

#endif

        case EntityType::Guardian:

            return std::make_shared<GuardianEntity>();

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

        case EntityType::Hoglin:

            return std::make_shared<HoglinEntity>();

#endif

        case EntityType::Horse:

            return std::make_shared<HorseEntity>();

        case EntityType::Husk:

            return std::make_shared<HuskEntity>();

        case EntityType::Illusioner:

            return std::make_shared<IllusionerEntity>();

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

        case EntityType::Interaction:

            return std::make_shared<InteractionEntity>();

#endif

        case EntityType::IronGolem:

            return std::make_shared<IronGolemEntity>();

        case EntityType::ItemEntity:

            return std::make_shared<ItemEntity>();

        case EntityType::ItemFrame:

            return std::make_shared<ItemFrameEntity>();

#if PROTOCOL_VERSION > 765 /* > 1.20.4 */

        case EntityType::OminousItemSpawner:

            return std::make_shared<OminousItemSpawnerEntity>();

#endif

        case EntityType::LargeFireball:

            return std::make_shared<LargeFireballEntity>();

        case EntityType::LeashFenceKnotEntity:

            return std::make_shared<LeashFenceKnotEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::LightningBolt:

            return std::make_shared<LightningBoltEntity>();

#endif

        case EntityType::Llama:

            return std::make_shared<LlamaEntity>();

        case EntityType::LlamaSpit:

            return std::make_shared<LlamaSpitEntity>();

        case EntityType::MagmaCube:

            return std::make_shared<MagmaCubeEntity>();

#if PROTOCOL_VERSION > 772 /* > 1.21.8 */

        case EntityType::Mannequin:

            return std::make_shared<MannequinEntity>();

#endif

#if PROTOCOL_VERSION > 754 /* > 1.16.5 */

        case EntityType::Marker:

            return std::make_shared<MarkerEntity>();

#endif

        case EntityType::Minecart:

            return std::make_shared<MinecartEntity>();

        case EntityType::MinecartChest:

            return std::make_shared<MinecartChestEntity>();

        case EntityType::MinecartCommandBlock:

            return std::make_shared<MinecartCommandBlockEntity>();

        case EntityType::MinecartFurnace:

            return std::make_shared<MinecartFurnaceEntity>();

        case EntityType::MinecartHopper:

            return std::make_shared<MinecartHopperEntity>();

        case EntityType::MinecartSpawner:

            return std::make_shared<MinecartSpawnerEntity>();

        case EntityType::MinecartTNT:

            return std::make_shared<MinecartTNTEntity>();

        case EntityType::Mule:

            return std::make_shared<MuleEntity>();

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

        case EntityType::Nautilus:

            return std::make_shared<NautilusEntity>();

#endif

        case EntityType::MushroomCow:

            return std::make_shared<MushroomCowEntity>();

        case EntityType::Ocelot:

            return std::make_shared<OcelotEntity>();

        case EntityType::Painting:

            return std::make_shared<PaintingEntity>();

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::Panda:

            return std::make_shared<PandaEntity>();

#endif

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

        case EntityType::Parched:

            return std::make_shared<ParchedEntity>();

#endif

        case EntityType::Parrot:

            return std::make_shared<ParrotEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Phantom:

            return std::make_shared<PhantomEntity>();

#endif

        case EntityType::Pig:

            return std::make_shared<PigEntity>();

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

        case EntityType::Piglin:

            return std::make_shared<PiglinEntity>();

#endif

#if PROTOCOL_VERSION > 736 /* > 1.16.1 */

        case EntityType::PiglinBrute:

            return std::make_shared<PiglinBruteEntity>();

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::Pillager:

            return std::make_shared<PillagerEntity>();

#endif

        case EntityType::PolarBear:

            return std::make_shared<PolarBearEntity>();

        case EntityType::PrimedTnt:

            return std::make_shared<PrimedTntEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Pufferfish:

            return std::make_shared<PufferfishEntity>();

#endif

        case EntityType::Rabbit:

            return std::make_shared<RabbitEntity>();

#if PROTOCOL_VERSION > 767 /* > 1.21.1 */

        case EntityType::Raft:

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

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::Ravager:

            return std::make_shared<RavagerEntity>();

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Salmon:

            return std::make_shared<SalmonEntity>();

#endif

        case EntityType::Sheep:

            return std::make_shared<SheepEntity>();

        case EntityType::Shulker:

            return std::make_shared<ShulkerEntity>();

        case EntityType::ShulkerBullet:

            return std::make_shared<ShulkerBulletEntity>();

        case EntityType::Silverfish:

            return std::make_shared<SilverfishEntity>();

        case EntityType::Skeleton:

            return std::make_shared<SkeletonEntity>();

        case EntityType::SkeletonHorse:

            return std::make_shared<SkeletonHorseEntity>();

        case EntityType::Slime:

            return std::make_shared<SlimeEntity>();

        case EntityType::SmallFireball:

            return std::make_shared<SmallFireballEntity>();

#if PROTOCOL_VERSION > 761 /* > 1.19.3 */

        case EntityType::Sniffer:

            return std::make_shared<SnifferEntity>();

#endif

        case EntityType::SnowGolem:

            return std::make_shared<SnowGolemEntity>();

        case EntityType::Snowball:

            return std::make_shared<SnowballEntity>();

        case EntityType::SpectralArrow:

            return std::make_shared<SpectralArrowEntity>();

        case EntityType::Spider:

            return std::make_shared<SpiderEntity>();

        case EntityType::Squid:

            return std::make_shared<SquidEntity>();

        case EntityType::Stray:

            return std::make_shared<StrayEntity>();

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

        case EntityType::Strider:

            return std::make_shared<StriderEntity>();

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

        case EntityType::Tadpole:

            return std::make_shared<TadpoleEntity>();

#endif

        case EntityType::ThrownEgg:

            return std::make_shared<ThrownEggEntity>();

        case EntityType::ThrownEnderpearl:

            return std::make_shared<ThrownEnderpearlEntity>();

        case EntityType::ThrownExperienceBottle:

            return std::make_shared<ThrownExperienceBottleEntity>();

#if PROTOCOL_VERSION < 770 /* < 1.21.5 */

        case EntityType::ThrownPotion:

            return std::make_shared<ThrownPotionEntity>();

#else

        case EntityType::ThrownSplashPotion:

            return std::make_shared<ThrownSplashPotionEntity>();

        case EntityType::ThrownLingeringPotion:

            return std::make_shared<ThrownLingeringPotionEntity>();

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::ThrownTrident:

            return std::make_shared<ThrownTridentEntity>();

#endif

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::TraderLlama:

            return std::make_shared<TraderLlamaEntity>();

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::TropicalFish:

            return std::make_shared<TropicalFishEntity>();

#endif

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::Turtle:

            return std::make_shared<TurtleEntity>();

#endif

        case EntityType::Vex:

            return std::make_shared<VexEntity>();

        case EntityType::Villager:

            return std::make_shared<VillagerEntity>();

        case EntityType::Vindicator:

            return std::make_shared<VindicatorEntity>();

#if PROTOCOL_VERSION > 404 /* > 1.13.2 */

        case EntityType::WanderingTrader:

            return std::make_shared<WanderingTraderEntity>();

#endif

#if PROTOCOL_VERSION > 758 /* > 1.18.2 */

        case EntityType::Warden:

            return std::make_shared<WardenEntity>();

#endif

#if PROTOCOL_VERSION > 764 /* > 1.20.2 */

        case EntityType::WindCharge:

            return std::make_shared<WindChargeEntity>();

#endif

        case EntityType::Witch:

            return std::make_shared<WitchEntity>();

        case EntityType::WitherBoss:

            return std::make_shared<WitherBossEntity>();

        case EntityType::WitherSkeleton:

            return std::make_shared<WitherSkeletonEntity>();

        case EntityType::WitherSkull:

            return std::make_shared<WitherSkullEntity>();

        case EntityType::Wolf:

            return std::make_shared<WolfEntity>();

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

        case EntityType::Zoglin:

            return std::make_shared<ZoglinEntity>();

#endif

        case EntityType::Zombie:

            return std::make_shared<ZombieEntity>();

        case EntityType::ZombieHorse:

            return std::make_shared<ZombieHorseEntity>();

#if PROTOCOL_VERSION > 773 /* > 1.21.10 */

        case EntityType::ZombieNautilus:

            return std::make_shared<ZombieNautilusEntity>();

#endif

        case EntityType::ZombieVillager:

            return std::make_shared<ZombieVillagerEntity>();

#if PROTOCOL_VERSION > 578 /* > 1.15.2 */

        case EntityType::ZombifiedPiglin:

            return std::make_shared<ZombifiedPiglinEntity>();

#else

        case EntityType::PigZombie:

            return std::make_shared<PigZombieEntity>();

#endif

        case EntityType::Player:

            return std::make_shared<PlayerEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case EntityType::FishingHook:

            return std::make_shared<FishingHookEntity>();

#endif

        default:

            return nullptr;

        }

    }


#if PROTOCOL_VERSION < 458 /* < 1.14 */

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

    {

        switch (type)

        {

        case ObjectEntityType::None:

            return nullptr;

        case ObjectEntityType::Boat:

            return std::make_shared<BoatEntity>();

        case ObjectEntityType::ItemEntity:

            return std::make_shared<ItemEntity>();

        case ObjectEntityType::AreaEffectCloud:

            return std::make_shared<AreaEffectCloudEntity>();

        case ObjectEntityType::PrimedTnt:

            return std::make_shared<PrimedTntEntity>();

        case ObjectEntityType::EndCrystal:

            return std::make_shared<EndCrystalEntity>();

        case ObjectEntityType::Arrow:

            return std::make_shared<ArrowEntity>();

        case ObjectEntityType::Snowball:

            return std::make_shared<SnowballEntity>();

        case ObjectEntityType::ThrownEgg:

            return std::make_shared<ThrownEggEntity>();

        case ObjectEntityType::LargeFireball:

            return std::make_shared<LargeFireballEntity>();

        case ObjectEntityType::SmallFireball:

            return std::make_shared<SmallFireballEntity>();

        case ObjectEntityType::ThrownEnderpearl:

            return std::make_shared<ThrownEnderpearlEntity>();

        case ObjectEntityType::WitherSkull:

            return std::make_shared<WitherSkullEntity>();

        case ObjectEntityType::ShulkerBullet:

            return std::make_shared<ShulkerBulletEntity>();

        case ObjectEntityType::LlamaSpit:

            return std::make_shared<LlamaSpitEntity>();

        case ObjectEntityType::FallingBlockEntity:

            return std::make_shared<FallingBlockEntity>();

        case ObjectEntityType::ItemFrame:

            return std::make_shared<ItemFrameEntity>();

        case ObjectEntityType::EyeOfEnder:

            return std::make_shared<EyeOfEnderEntity>();

        case ObjectEntityType::ThrownPotion:

            return std::make_shared<ThrownPotionEntity>();

        case ObjectEntityType::ThrownExperienceBottle:

            return std::make_shared<ThrownExperienceBottleEntity>();

        case ObjectEntityType::FireworkRocketEntity:

            return std::make_shared<FireworkRocketEntity>();

        case ObjectEntityType::LeashFenceKnotEntity:

            return std::make_shared<LeashFenceKnotEntity>();

        case ObjectEntityType::ArmorStand:

            return std::make_shared<ArmorStandEntity>();

        case ObjectEntityType::EvokerFangs:

            return std::make_shared<EvokerFangsEntity>();

        case ObjectEntityType::FishingHook:

            return std::make_shared<FishingHookEntity>();

        case ObjectEntityType::SpectralArrow:

            return std::make_shared<SpectralArrowEntity>();

        case ObjectEntityType::DragonFireball:

            return std::make_shared<DragonFireballEntity>();

#if PROTOCOL_VERSION > 340 /* > 1.12.2 */

        case ObjectEntityType::ThrownTrident:

            return std::make_shared<ThrownTridentEntity>();

#endif

        default:

            return nullptr;

        }

    }

#endif


#if USE_GUI


    void Entity::InitializeFaces()

    {

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

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


        // Generate default faces

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

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

        const double half_height = GetHeightImpl() / 2.0;

        const double half_width = GetWidthImpl() / 2.0;

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

        {

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

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

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

            face_descriptors[i].use_tintindexes = { false };


            // Base entity scale

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

                static_cast<float>(half_width),

                static_cast<float>(half_height),

                static_cast<float>(half_width)

            ));

            // Base translation

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

            // Entity pos translation

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

                static_cast<float>(position.x),

                static_cast<float>(position.y),

                static_cast<float>(position.z))

            );

            // Entity yaw/pitch rotation

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

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


            face_descriptors[i].transformations.rotation = 0;


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

            faces[i].SetDisplayBackface(false);

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


            // Extract texture info from the atlas

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

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

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

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


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

            {

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

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

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

                transparencies[j] = texture_data.transparency;

                animated[j] = texture_data.animation;

            }


            // Main texture coords in the atlas

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

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

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

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

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

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

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


            // Overlay texture coords in the atlas if existing

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

            {

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

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

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

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

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

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

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

            }


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

        }

        are_rendered_faces_up_to_date = false;

    }


    void Entity::OnSizeUpdated()

    {

        are_rendered_faces_up_to_date = false;

        const double half_width = GetWidthImpl() / 2.0;

        const double half_height = GetHeightImpl() / 2.0;

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

        {

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

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

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

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

        }

    }


#endif


    char Entity::GetDataSharedFlagsIdImpl() const

    {

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

    }


    bool Entity::GetDataSharedFlagsIdImpl(const EntitySharedFlagsId id) const

    {

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

    }


    void Entity::SetDataSharedFlagsIdImpl(const char data_shared_flags_id)

    {

        metadata["data_shared_flags_id"] = data_shared_flags_id;

    }


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

    {

        char current_value = GetDataSharedFlagsIdImpl();

        // Set the bit to 0

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

        current_value &= ~mask;

        // Set the bit to b

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

        SetDataSharedFlagsIdImpl(current_value);

    }


#if PROTOCOL_VERSION > 404 /* > 1.13.2 */


    Pose Entity::GetDataPoseImpl() const

    {

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

    }


    void Entity::SetDataPoseImpl(const Pose data_pose)

    {

        metadata["data_pose"] = data_pose;

#if USE_GUI

        OnSizeUpdated();

#endif

    }


#endif


    AABB Entity::GetColliderImpl() const

    {

        const double half_width = GetWidthImpl() / 2.0;

        const double half_height = GetHeightImpl() / 2.0;

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

    }


    double Entity::GetWidthImpl() const

    {

        return -1.0;

    }


    double Entity::GetHeightImpl() const

    {

        return -1.0;

    }


}


AllayEntity.hpp

AreaEffectCloudEntity.hpp

ArmadilloEntity.hpp

ArmorStandEntity.hpp

ArrowEntity.hpp

AssetsManager.hpp

Atlas.hpp

AxolotlEntity.hpp

BatEntity.hpp

BeeEntity.hpp

BlazeEntity.hpp

BoatEntity.hpp

BoggedEntity.hpp

BreezeEntity.hpp

BreezeWindChargeEntity.hpp

CamelEntity.hpp

CamelHuskEntity.hpp

CatEntity.hpp

CaveSpiderEntity.hpp

Chat.hpp

ChestBoatEntity.hpp

ChestRaftEntity.hpp

ChickenEntity.hpp

CodEntity.hpp

CopperGolemEntity.hpp

CowEntity.hpp

CreakingEntity.hpp

CreakingTransientEntity.hpp

CreeperEntity.hpp

DataComponentTypeResolvableProfile.hpp

DisplayBlockDisplayEntity.hpp

DisplayEntity.hpp

DisplayItemDisplayEntity.hpp

DisplayTextDisplayEntity.hpp

DolphinEntity.hpp

DonkeyEntity.hpp

DragonFireballEntity.hpp

DrownedEntity.hpp

ElderGuardianEntity.hpp

EndCrystalEntity.hpp

EnderDragonEntity.hpp

EnderManEntity.hpp

EndermiteEntity.hpp

EvokerEntity.hpp

EvokerFangsEntity.hpp

ExperienceOrbEntity.hpp

EyeOfEnderEntity.hpp

FallingBlockEntity.hpp

FireworkRocketEntity.hpp

FishingHookEntity.hpp

FoxEntity.hpp

FrogEntity.hpp

GhastEntity.hpp

GiantEntity.hpp

GlowItemFrameEntity.hpp

GlowSquidEntity.hpp

GoatEntity.hpp

GuardianEntity.hpp

HappyGhastEntity.hpp

HoglinEntity.hpp

HorseEntity.hpp

HuskEntity.hpp

IllusionerEntity.hpp

InteractionEntity.hpp

IronGolemEntity.hpp

ItemEntity.hpp

ItemFrameEntity.hpp

LargeFireballEntity.hpp

LeashFenceKnotEntity.hpp

LightningBoltEntity.hpp

LlamaEntity.hpp

LlamaSpitEntity.hpp

Logger.hpp

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

MagmaCubeEntity.hpp

MannequinEntity.hpp

MarkerEntity.hpp

MinecartChestEntity.hpp

MinecartCommandBlockEntity.hpp

MinecartEntity.hpp

MinecartFurnaceEntity.hpp

MinecartHopperEntity.hpp

MinecartSpawnerEntity.hpp

MinecartTNTEntity.hpp

MuleEntity.hpp

MushroomCowEntity.hpp

NBT.hpp

NautilusEntity.hpp

OcelotEntity.hpp

OminousItemSpawnerEntity.hpp

PaintingEntity.hpp

PandaEntity.hpp

ParchedEntity.hpp

ParrotEntity.hpp

Particle.hpp

PhantomEntity.hpp

PigEntity.hpp

PigZombieEntity.hpp

PiglinBruteEntity.hpp

PiglinEntity.hpp

PillagerEntity.hpp

PlayerEntity.hpp

PolarBearEntity.hpp

PrimedTntEntity.hpp

PufferfishEntity.hpp

RabbitEntity.hpp

RaftEntity.hpp

RavagerEntity.hpp

SalmonEntity.hpp

SheepEntity.hpp

ShulkerBulletEntity.hpp

ShulkerEntity.hpp

SilverfishEntity.hpp

SkeletonEntity.hpp

SkeletonHorseEntity.hpp

SlimeEntity.hpp

Slot.hpp

SmallFireballEntity.hpp

SnifferEntity.hpp

SnowGolemEntity.hpp

SnowballEntity.hpp

SpectralArrowEntity.hpp

SpiderEntity.hpp

SquidEntity.hpp

StrayEntity.hpp

StriderEntity.hpp

TadpoleEntity.hpp

ThrownEggEntity.hpp

ThrownEnderpearlEntity.hpp

ThrownExperienceBottleEntity.hpp

ThrownLingeringPotionEntity.hpp

ThrownPotionEntity.hpp

ThrownSplashPotionEntity.hpp

ThrownTridentEntity.hpp

TraderLlamaEntity.hpp

TropicalFishEntity.hpp

TurtleEntity.hpp

VexEntity.hpp

VillagerData.hpp

VillagerEntity.hpp

VindicatorEntity.hpp

WanderingTraderEntity.hpp

WardenEntity.hpp

WindChargeEntity.hpp

WitchEntity.hpp

WitherBossEntity.hpp

WitherSkeletonEntity.hpp

WitherSkullEntity.hpp

WolfEntity.hpp

ZoglinEntity.hpp

ZombieEntity.hpp

ZombieHorseEntity.hpp

ZombieNautilusEntity.hpp

ZombieVillagerEntity.hpp

ZombifiedPiglinEntity.hpp

GlobalPos.hpp

Botcraft::AABB
Definition AABB.hpp:8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ProtocolCraft::Chat
Definition Chat.hpp:18

ProtocolCraft::Identifier
Definition Identifier.hpp:8

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

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

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

ProtocolCraft::NetworkPosition
Definition NetworkPosition.hpp:8

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

ProtocolCraft::Particle
Definition Particle.hpp:279

ProtocolCraft::Slot
Definition Slot.hpp:13

Entity.hpp

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

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

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

Botcraft
Definition BaseNode.hpp:6

Botcraft::Pose
Pose
Definition Enums.hpp:256

Botcraft::Pose::Standing
@ Standing

Botcraft::Orientation
Orientation
Definition Enums.hpp:171

Botcraft::Orientation::None
@ None

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

Botcraft::EquipmentSlot
EquipmentSlot
Definition Enums.hpp:282

Botcraft::EquipmentSlot::MainHand
@ MainHand

Botcraft::EquipmentSlot::ChestPlate
@ ChestPlate

Botcraft::EquipmentSlot::OffHand
@ OffHand

Botcraft::EquipmentSlot::Helmet
@ Helmet

Botcraft::EquipmentSlot::Boots
@ Boots

Botcraft::EquipmentSlot::BodyAnimalArmor
@ BodyAnimalArmor

Botcraft::EquipmentSlot::Leggings
@ Leggings

Botcraft::EquipmentSlot::Saddle
@ Saddle

Botcraft::Direction
Direction
Definition Enums.hpp:203

Botcraft::EntityEffectType
EntityEffectType
Definition Enums.hpp:327

Botcraft::EntityType
EntityType
Definition Entity.hpp:294

Botcraft::EntityType::MinecartHopper
@ MinecartHopper

Botcraft::EntityType::Marker
@ Marker

Botcraft::EntityType::Donkey
@ Donkey

Botcraft::EntityType::GlowSquid
@ GlowSquid

Botcraft::EntityType::Turtle
@ Turtle

Botcraft::EntityType::Pufferfish
@ Pufferfish

Botcraft::EntityType::ThrownTrident
@ ThrownTrident

Botcraft::EntityType::MinecartTNT
@ MinecartTNT

Botcraft::EntityType::Squid
@ Squid

Botcraft::EntityType::ChestRaft
@ ChestRaft

Botcraft::EntityType::Arrow
@ Arrow

Botcraft::EntityType::Ravager
@ Ravager

Botcraft::EntityType::SnowGolem
@ SnowGolem

Botcraft::EntityType::ZombieHorse
@ ZombieHorse

Botcraft::EntityType::Camel
@ Camel

Botcraft::EntityType::DragonFireball
@ DragonFireball

Botcraft::EntityType::Witch
@ Witch

Botcraft::EntityType::ExperienceOrb
@ ExperienceOrb

Botcraft::EntityType::Frog
@ Frog

Botcraft::EntityType::Warden
@ Warden

Botcraft::EntityType::ZombieNautilus
@ ZombieNautilus

Botcraft::EntityType::Guardian
@ Guardian

Botcraft::EntityType::Piglin
@ Piglin

Botcraft::EntityType::Wolf
@ Wolf

Botcraft::EntityType::Painting
@ Painting

Botcraft::EntityType::LightningBolt
@ LightningBolt

Botcraft::EntityType::MangroveChestBoat
@ MangroveChestBoat

Botcraft::EntityType::Zoglin
@ Zoglin

Botcraft::EntityType::CopperGolem
@ CopperGolem

Botcraft::EntityType::Bat
@ Bat

Botcraft::EntityType::Husk
@ Husk

Botcraft::EntityType::Silverfish
@ Silverfish

Botcraft::EntityType::PrimedTnt
@ PrimedTnt

Botcraft::EntityType::Pig
@ Pig

Botcraft::EntityType::FireworkRocketEntity
@ FireworkRocketEntity

Botcraft::EntityType::Rabbit
@ Rabbit

Botcraft::EntityType::ThrownEgg
@ ThrownEgg

Botcraft::EntityType::Sniffer
@ Sniffer

Botcraft::EntityType::Horse
@ Horse

Botcraft::EntityType::Evoker
@ Evoker

Botcraft::EntityType::Tadpole
@ Tadpole

Botcraft::EntityType::TropicalFish
@ TropicalFish

Botcraft::EntityType::CherryBoat
@ CherryBoat

Botcraft::EntityType::MinecartCommandBlock
@ MinecartCommandBlock

Botcraft::EntityType::GlowItemFrame
@ GlowItemFrame

Botcraft::EntityType::BirchBoat
@ BirchBoat

Botcraft::EntityType::ItemEntity
@ ItemEntity

Botcraft::EntityType::WitherBoss
@ WitherBoss

Botcraft::EntityType::PaleOakBoat
@ PaleOakBoat

Botcraft::EntityType::FishingHook
@ FishingHook

Botcraft::EntityType::Drowned
@ Drowned

Botcraft::EntityType::MagmaCube
@ MagmaCube

Botcraft::EntityType::ElderGuardian
@ ElderGuardian

Botcraft::EntityType::MinecartSpawner
@ MinecartSpawner

Botcraft::EntityType::Mule
@ Mule

Botcraft::EntityType::WitherSkull
@ WitherSkull

Botcraft::EntityType::Pillager
@ Pillager

Botcraft::EntityType::ZombieVillager
@ ZombieVillager

Botcraft::EntityType::EnderDragon
@ EnderDragon

Botcraft::EntityType::Sheep
@ Sheep

Botcraft::EntityType::Armadillo
@ Armadillo

Botcraft::EntityType::Bogged
@ Bogged

Botcraft::EntityType::Panda
@ Panda

Botcraft::EntityType::AreaEffectCloud
@ AreaEffectCloud

Botcraft::EntityType::LargeFireball
@ LargeFireball

Botcraft::EntityType::JungleBoat
@ JungleBoat

Botcraft::EntityType::Interaction
@ Interaction

Botcraft::EntityType::Player
@ Player

Botcraft::EntityType::MinecartChest
@ MinecartChest

Botcraft::EntityType::MushroomCow
@ MushroomCow

Botcraft::EntityType::Skeleton
@ Skeleton

Botcraft::EntityType::None
@ None

Botcraft::EntityType::SpruceBoat
@ SpruceBoat

Botcraft::EntityType::LeashFenceKnotEntity
@ LeashFenceKnotEntity

Botcraft::EntityType::Giant
@ Giant

Botcraft::EntityType::BirchChestBoat
@ BirchChestBoat

Botcraft::EntityType::Hoglin
@ Hoglin

Botcraft::EntityType::JungleChestBoat
@ JungleChestBoat

Botcraft::EntityType::IronGolem
@ IronGolem

Botcraft::EntityType::Shulker
@ Shulker

Botcraft::EntityType::Dolphin
@ Dolphin

Botcraft::EntityType::PaleOakChestBoat
@ PaleOakChestBoat

Botcraft::EntityType::SpectralArrow
@ SpectralArrow

Botcraft::EntityType::Zombie
@ Zombie

Botcraft::EntityType::AcaciaChestBoat
@ AcaciaChestBoat

Botcraft::EntityType::OakBoat
@ OakBoat

Botcraft::EntityType::Parched
@ Parched

Botcraft::EntityType::ThrownEnderpearl
@ ThrownEnderpearl

Botcraft::EntityType::WanderingTrader
@ WanderingTrader

Botcraft::EntityType::EvokerFangs
@ EvokerFangs

Botcraft::EntityType::CamelHusk
@ CamelHusk

Botcraft::EntityType::Vex
@ Vex

Botcraft::EntityType::Goat
@ Goat

Botcraft::EntityType::ThrownSplashPotion
@ ThrownSplashPotion

Botcraft::EntityType::ThrownExperienceBottle
@ ThrownExperienceBottle

Botcraft::EntityType::Blaze
@ Blaze

Botcraft::EntityType::Ocelot
@ Ocelot

Botcraft::EntityType::SkeletonHorse
@ SkeletonHorse

Botcraft::EntityType::Mannequin
@ Mannequin

Botcraft::EntityType::Villager
@ Villager

Botcraft::EntityType::Cod
@ Cod

Botcraft::EntityType::DisplayItemDisplay
@ DisplayItemDisplay

Botcraft::EntityType::EndCrystal
@ EndCrystal

Botcraft::EntityType::Nautilus
@ Nautilus

Botcraft::EntityType::Llama
@ Llama

Botcraft::EntityType::OminousItemSpawner
@ OminousItemSpawner

Botcraft::EntityType::ZombifiedPiglin
@ ZombifiedPiglin

Botcraft::EntityType::AcaciaBoat
@ AcaciaBoat

Botcraft::EntityType::Breeze
@ Breeze

Botcraft::EntityType::Slime
@ Slime

Botcraft::EntityType::Stray
@ Stray

Botcraft::EntityType::Chicken
@ Chicken

Botcraft::EntityType::Bee
@ Bee

Botcraft::EntityType::DarkOakChestBoat
@ DarkOakChestBoat

Botcraft::EntityType::Allay
@ Allay

Botcraft::EntityType::Spider
@ Spider

Botcraft::EntityType::MangroveBoat
@ MangroveBoat

Botcraft::EntityType::HappyGhast
@ HappyGhast

Botcraft::EntityType::MinecartFurnace
@ MinecartFurnace

Botcraft::EntityType::OakChestBoat
@ OakChestBoat

Botcraft::EntityType::Illusioner
@ Illusioner

Botcraft::EntityType::SpruceChestBoat
@ SpruceChestBoat

Botcraft::EntityType::Snowball
@ Snowball

Botcraft::EntityType::DisplayBlockDisplay
@ DisplayBlockDisplay

Botcraft::EntityType::Endermite
@ Endermite

Botcraft::EntityType::WitherSkeleton
@ WitherSkeleton

Botcraft::EntityType::CherryChestBoat
@ CherryChestBoat

Botcraft::EntityType::Raft
@ Raft

Botcraft::EntityType::TraderLlama
@ TraderLlama

Botcraft::EntityType::ShulkerBullet
@ ShulkerBullet

Botcraft::EntityType::Creaking
@ Creaking

Botcraft::EntityType::Fox
@ Fox

Botcraft::EntityType::Minecart
@ Minecart

Botcraft::EntityType::FallingBlockEntity
@ FallingBlockEntity

Botcraft::EntityType::Vindicator
@ Vindicator

Botcraft::EntityType::DarkOakBoat
@ DarkOakBoat

Botcraft::EntityType::EnderMan
@ EnderMan

Botcraft::EntityType::Salmon
@ Salmon

Botcraft::EntityType::LlamaSpit
@ LlamaSpit

Botcraft::EntityType::PolarBear
@ PolarBear

Botcraft::EntityType::PiglinBrute
@ PiglinBrute

Botcraft::EntityType::Creeper
@ Creeper

Botcraft::EntityType::Axolotl
@ Axolotl

Botcraft::EntityType::Parrot
@ Parrot

Botcraft::EntityType::Ghast
@ Ghast

Botcraft::EntityType::BreezeWindCharge
@ BreezeWindCharge

Botcraft::EntityType::Phantom
@ Phantom

Botcraft::EntityType::ItemFrame
@ ItemFrame

Botcraft::EntityType::Strider
@ Strider

Botcraft::EntityType::DisplayTextDisplay
@ DisplayTextDisplay

Botcraft::EntityType::ThrownLingeringPotion
@ ThrownLingeringPotion

Botcraft::EntityType::ArmorStand
@ ArmorStand

Botcraft::EntityType::EyeOfEnder
@ EyeOfEnder

Botcraft::EntityType::Cat
@ Cat

Botcraft::EntityType::CaveSpider
@ CaveSpider

Botcraft::EntityType::WindCharge
@ WindCharge

Botcraft::EntityType::Cow
@ Cow

Botcraft::EntityType::SmallFireball
@ SmallFireball

Botcraft::EntitySharedFlagsId
EntitySharedFlagsId
Definition Entity.hpp:40

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

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

Botcraft::EntityEffect
Definition Entity.hpp:33

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

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

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

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

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

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

Botcraft::Vector3
Definition Vector3.hpp:16

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

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

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

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

Botcraft::VillagerData
Definition VillagerData.hpp:7