Botcraft 1.21.7
Loading...
Searching...
No Matches
Entity.cpp
Go to the documentation of this file.
2
7#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
9#endif
10#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
12#endif
13
14#if USE_GUI
17#endif
19
20#if PROTOCOL_VERSION > 767 /* > 1.21.1 */
23#endif
24#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
26#endif
28#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
30#endif
33#if PROTOCOL_VERSION > 754 /* > 1.16.5 */
35#endif
36#if PROTOCOL_VERSION > 767 /* > 1.21.1 */
39#endif
41#if PROTOCOL_VERSION > 498 /* > 1.14.4 */
43#endif
46#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
48#endif
49#if PROTOCOL_VERSION > 764 /* > 1.20.2 */
51#endif
52#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
54#endif
55#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
57#endif
58#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
60#endif
61#if PROTOCOL_VERSION > 760 /* > 1.19.2 */
63#endif
66#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
68#endif
70#if PROTOCOL_VERSION > 767 /* > 1.21.1 */
72#endif
73#if PROTOCOL_VERSION > 767 /* > 1.21.1 */ && PROTOCOL_VERSION < 769 /* < 1.21.4 */
75#endif
77#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
79#endif
82#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
84#endif
85#if PROTOCOL_VERSION > 761 /* > 1.19.3 */
90#endif
102#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
104#endif
105#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
107#endif
109#if PROTOCOL_VERSION > 770 /* > 1.21.5 */
111#endif
113#if PROTOCOL_VERSION > 754 /* > 1.16.5 */
117#endif
119#if PROTOCOL_VERSION > 578 /* > 1.15.2 */
121#endif
125#if PROTOCOL_VERSION > 761 /* > 1.19.3 */
127#endif
131#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
133#endif
140#if PROTOCOL_VERSION > 754 /* > 1.16.5 */
142#endif
154#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
156#endif
158#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
160#endif
162#if PROTOCOL_VERSION > 578 /* > 1.15.2 */
164#else
166#endif
167#if PROTOCOL_VERSION > 736 /* > 1.16.1 */
169#endif
170#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
172#endif
174#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
177#endif
179#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
181#endif
183#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
185#endif
186#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
188#endif
189#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
191#else
193#endif
201#if PROTOCOL_VERSION > 761 /* > 1.19.3 */
203#endif
210#if PROTOCOL_VERSION > 578 /* > 1.15.2 */
212#endif
213#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
215#endif
220#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
222#endif
223#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
225#endif
226
227#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
229#endif
230#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
232#endif
236#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
238#endif
239#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
241#endif
242#if PROTOCOL_VERSION > 764 /* > 1.20.2 */
244#endif
249#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
251#else
253#endif
254#if PROTOCOL_VERSION > 578 /* > 1.15.2 */
256#endif
260#if PROTOCOL_VERSION > 578 /* > 1.15.2 */
262#endif
265
266#include <mutex>
267
268namespace Botcraft
269{
270 const std::array<std::string, Entity::metadata_count> Entity::metadata_names{ {
271 "data_shared_flags_id",
272 "data_air_supply_id",
273 "data_custom_name",
274 "data_custom_name_visible",
275 "data_silent",
276 "data_no_gravity",
277#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
278 "data_pose",
279#endif
280#if PROTOCOL_VERSION > 754 /* > 1.16.5 */
281 "data_ticks_frozen",
282#endif
283 } };
284
286 {
287 {
288 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
289 // Initialize base stuff
290 entity_id = 0;
291 position = Vector3<double>(0.0, 0.0, 0.0);
292 yaw = 0.0f;
293 pitch = 0.0f;
294 speed = Vector3<double>(0.0, 0.0, 0.0);
295 on_ground = false;
296 equipments = {
303#if PROTOCOL_VERSION > 766 /* > 1.20.6 */
305#endif
306 };
307 }
308
309 // Initialize all metadata with default values
312#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
313 SetDataCustomName(std::optional<ProtocolCraft::Chat>());
314#else
316#endif
318 SetDataSilent(false);
319 SetDataNoGravity(false);
320#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
322#endif
323#if PROTOCOL_VERSION > 754 /* > 1.16.5 */
325#endif
326 }
327
329 {
330
331 }
332
333
335 {
336 std::shared_lock<std::shared_mutex> lock(entity_mutex);
337 return GetColliderImpl();
338 }
339
340 double Entity::GetWidth() const
341 {
342 std::shared_lock<std::shared_mutex> lock(entity_mutex);
343 return GetWidthImpl();
344 }
345
346 double Entity::GetHeight() const
347 {
348 std::shared_lock<std::shared_mutex> lock(entity_mutex);
349 return GetHeightImpl();
350 }
351
352
353 void Entity::LoadMetadataFromRawArray(const std::vector<unsigned char>& data)
354 {
355 if (data.size() == 0)
356 {
357 return;
358 }
359
360 ProtocolCraft::ReadIterator iter = data.begin();
361 size_t length = data.size();
362
363 while (true)
364 {
365 const unsigned char index = ProtocolCraft::ReadData<unsigned char>(iter, length);
366 if (index == 0xFF)
367 {
368 break;
369 }
370
371 const int type = ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length);
372 std::any value;
373
374 enum EntityMetadataTypes
375 {
376 Char = 0,
377 Int,
378#if PROTOCOL_VERSION > 760 /* > 1.19.2 */
379 Long,
380#endif
381 Float,
382 String,
383 Chat,
384#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
385 OptionalChat,
386#endif
387 Slot,
388 Bool,
389 Rotations,
390 BlockPosition,
391 OptionalBlockPosition,
392 DirectionType,
393#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
394 OptionalLivingEntityReference, // Fancy new name for 1.21.5, but it's still an optional UUID
395#else
396 OptionalUUID,
397#endif
398 BlockstateType,
399#if PROTOCOL_VERSION > 761 /* > 1.19.3 */
400 OptionalBlockstate,
401#endif
402 NBT,
403#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
404 Particle,
405#endif
406#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
407 Particles,
408#endif
409#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
410 VillagerDataType,
411 OptionalUint,
412 PoseType,
413#endif
414#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
415 CatVariant,
416#endif
417#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
418 CowVariant,
419#endif
420#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
421 WolfVariant,
422#endif
423#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
424 WolfSoundVariant,
425#endif
426#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
427 FrogVariant,
428#endif
429#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
430 PigVariant,
431 ChickenVariant,
432#endif
433#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
434 OptionalGlobalPos,
435 PaintingVariant,
436#endif
437#if PROTOCOL_VERSION > 761 /* > 1.19.3 */
438 SnifferState,
439#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
440 ArmadilloState,
441#endif
442 Vec3,
443 Quaternion,
444#endif
445 };
446
447 switch (type)
448 {
449 case EntityMetadataTypes::Char:
450 value = ProtocolCraft::ReadData<char>(iter, length);
451 break;
452 case EntityMetadataTypes::Int:
453 value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));
454 break;
455#if PROTOCOL_VERSION > 760 /* > 1.19.2 */
456 case EntityMetadataTypes::Long:
457 value = static_cast<long long int>(ProtocolCraft::ReadData<ProtocolCraft::VarLong>(iter, length));
458 break;
459#endif
460 case EntityMetadataTypes::Float:
461 value = ProtocolCraft::ReadData<float>(iter, length);
462 break;
463 case EntityMetadataTypes::String:
464 value = ProtocolCraft::ReadData<std::string>(iter, length);
465 break;
466 case EntityMetadataTypes::Chat:
467 value = ProtocolCraft::Chat();
468 std::any_cast<ProtocolCraft::Chat&>(value).Read(iter, length);
469 break;
470#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
471 case EntityMetadataTypes::OptionalChat:
472 if (ProtocolCraft::ReadData<bool>(iter, length))
473 {
474 value = std::optional<ProtocolCraft::Chat>(ProtocolCraft::Chat());
475 std::any_cast<std::optional<ProtocolCraft::Chat>&>(value).value().Read(iter, length);
476 }
477 else
478 {
479 value = std::optional<ProtocolCraft::Chat>();
480 }
481 break;
482#endif
483 case EntityMetadataTypes::Slot:
484 value = ProtocolCraft::Slot();
485 std::any_cast<ProtocolCraft::Slot&>(value).Read(iter, length);
486 break;
487 case EntityMetadataTypes::Bool:
488 value = ProtocolCraft::ReadData<bool>(iter, length);
489 break;
490 case EntityMetadataTypes::Rotations:
491 {
492 Vector3<float> rotation;
493 for (int i = 0; i < 3; ++i)
494 {
495 rotation[i] = ProtocolCraft::ReadData<float>(iter, length);
496 }
497 value = rotation;
498 break;
499 }
500 case EntityMetadataTypes::BlockPosition:
501 {
503 position.Read(iter, length);
504 value = Position(position);
505 break;
506 }
507 case EntityMetadataTypes::OptionalBlockPosition:
508 if (ProtocolCraft::ReadData<bool>(iter, length))
509 {
511 position.Read(iter, length);
512 value = std::optional<Position>(position);
513 }
514 else
515 {
516 value = std::optional<Position>();
517 }
518 break;
519 case EntityMetadataTypes::DirectionType:
520 value = static_cast<Direction>(static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length)));
521 break;
522#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
523 case EntityMetadataTypes::OptionalLivingEntityReference:
524#else
525 case EntityMetadataTypes::OptionalUUID:
526#endif
527 if (ProtocolCraft::ReadData<bool>(iter, length))
528 {
529 value = std::optional<ProtocolCraft::UUID>(ProtocolCraft::ReadData<ProtocolCraft::UUID>(iter, length));
530 }
531 else
532 {
533 value = std::optional<ProtocolCraft::UUID>();
534 }
535 break;
536 case EntityMetadataTypes::BlockstateType:
537 value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));
538 break;
539#if PROTOCOL_VERSION > 761 /* > 1.19.3 */
540 case EntityMetadataTypes::OptionalBlockstate:
541 if (const int n = ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length))
542 {
543 value = std::optional<int>(n);
544 }
545 else
546 {
547 value = std::optional<int>();
548 }
549 break;
550#endif
551 case EntityMetadataTypes::NBT:
552 {
554 unnamed_value.Read(iter, length);
555 value = ProtocolCraft::NBT::Value(unnamed_value);
556 break;
557 }
558#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
559 case EntityMetadataTypes::Particle:
560 {
562 particle.Read(iter, length);
563 value = particle;
564 break;
565 }
566#endif
567#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
568 case EntityMetadataTypes::Particles:
569 value = ProtocolCraft::ReadData<std::vector<ProtocolCraft::Particle>>(iter, length);
570 break;
571#endif
572#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
573 case EntityMetadataTypes::VillagerDataType:
574 value = VillagerData{
575 ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length), // villager_type
576 ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length), // villager_profession
577 ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length) // level
578 };
579 break;
580 case EntityMetadataTypes::OptionalUint:
581 {
582 const int val = ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length);
583 value = val > 0 ? std::optional<int>(val - 1) : std::optional<int>();
584 break;
585 }
586 case EntityMetadataTypes::PoseType:
587 value = static_cast<Pose>(static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length)));
588 break;
589#endif
590#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
591 case EntityMetadataTypes::CatVariant:
592 value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));
593 break;
594#endif
595#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
596 case EntityMetadataTypes::CowVariant:
597 value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));
598 break;
599#endif
600#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
601 case EntityMetadataTypes::WolfVariant:
602 value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));
603 break;
604#endif
605#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
606 case EntityMetadataTypes::WolfSoundVariant:
607 value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));
608 break;
609#endif
610#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
611 case EntityMetadataTypes::FrogVariant:
612 value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));
613 break;
614#endif
615#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
616 case EntityMetadataTypes::PigVariant:
617 value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));
618 break;
619 case EntityMetadataTypes::ChickenVariant:
620 value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));
621 break;
622#endif
623#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
624 case EntityMetadataTypes::OptionalGlobalPos:
625 if (ProtocolCraft::ReadData<bool>(iter, length))
626 {
628 dimension.Read(iter, length);
630 pos.Read(iter, length);
631
632 value = std::optional<GlobalPos>({
633 dimension,
634 pos
635 });
636 }
637 else
638 {
639 value = std::optional<GlobalPos>();
640 }
641 break;
642 case EntityMetadataTypes::PaintingVariant:
643 value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));
644 break;
645#endif
646#if PROTOCOL_VERSION > 761 /* > 1.19.3 */
647 case EntityMetadataTypes::SnifferState:
648 value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));
649 break;
650#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
651 case EntityMetadataTypes::ArmadilloState:
652 value = static_cast<int>(ProtocolCraft::ReadData<ProtocolCraft::VarInt>(iter, length));
653 break;
654#endif
655 case EntityMetadataTypes::Vec3:
656 {
657 const float x = ProtocolCraft::ReadData<float>(iter, length);
658 const float y = ProtocolCraft::ReadData<float>(iter, length);
659 const float z = ProtocolCraft::ReadData<float>(iter, length);
660 value = Vector3<float>(x, y, z);
661 }
662 break;
663 case EntityMetadataTypes::Quaternion:
664 {
665 const float x = ProtocolCraft::ReadData<float>(iter, length);
666 const float y = ProtocolCraft::ReadData<float>(iter, length);
667 const float z = ProtocolCraft::ReadData<float>(iter, length);
668 const float w = ProtocolCraft::ReadData<float>(iter, length);
669 value = std::array<float, 4>{x, y, z, w};
670 }
671 break;
672#endif
673 default:
674 LOG_ERROR("Unknown type in entity metadata : " << type << ".Stopping current metadata parsing.");
675 return;
676 }
677 SetMetadataValue(index, value);
678 }
679 }
680
681 void Entity::SetMetadataValue(const int index, const std::any& value)
682 {
683 assert(index >= 0 && index < metadata_count);
684 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
685 const std::string& metadata_name = metadata_names[index];
686 metadata[metadata_name] = value;
687#if USE_GUI && PROTOCOL_VERSION > 404 /* > 1.13.2 */
688 if (metadata_name == "data_pose")
689 {
691 }
692#endif
693 }
694
695
697 {
698 std::shared_lock<std::shared_mutex> lock(entity_mutex);
700 }
701
703 {
704 std::shared_lock<std::shared_mutex> lock(entity_mutex);
705 return GetDataSharedFlagsIdImpl(id);
706 }
707
709 {
710 std::shared_lock<std::shared_mutex> lock(entity_mutex);
711 return std::any_cast<int>(metadata.at("data_air_supply_id"));
712 }
713
714#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
715 std::optional<ProtocolCraft::Chat> Entity::GetDataCustomName() const
716 {
717 std::shared_lock<std::shared_mutex> lock(entity_mutex);
718 return std::any_cast<std::optional<ProtocolCraft::Chat>>(metadata.at("data_custom_name"));
719 }
720#else
721 std::string Entity::GetDataCustomName() const
722 {
723 std::shared_lock<std::shared_mutex> lock(entity_mutex);
724 return std::any_cast<std::string>(metadata.at("data_custom_name"));
725 }
726#endif
727
729 {
730 std::shared_lock<std::shared_mutex> lock(entity_mutex);
731 return std::any_cast<bool>(metadata.at("data_custom_name_visible"));
732 }
733
735 {
736 std::shared_lock<std::shared_mutex> lock(entity_mutex);
737 return std::any_cast<bool>(metadata.at("data_silent"));
738 }
739
741 {
742 std::shared_lock<std::shared_mutex> lock(entity_mutex);
743 return std::any_cast<bool>(metadata.at("data_no_gravity"));
744 }
745
746#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
748 {
749 std::shared_lock<std::shared_mutex> lock(entity_mutex);
750 return GetDataPoseImpl();
751 }
752#endif
753
754#if PROTOCOL_VERSION > 754 /* > 1.16.5 */
756 {
757 std::shared_lock<std::shared_mutex> lock(entity_mutex);
758 return std::any_cast<int>(metadata.at("data_ticks_frozen"));
759 }
760#endif
761
762
763 void Entity::SetDataSharedFlagsId(const char data_shared_flags_id)
764 {
765 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
766 SetDataSharedFlagsIdImpl(data_shared_flags_id);
767 }
768
770 {
771 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
773 }
774
775 void Entity::SetDataAirSupplyId(const int data_air_supply_id)
776 {
777 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
778 metadata["data_air_supply_id"] = data_air_supply_id;
779 }
780
781#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
782 void Entity::SetDataCustomName(const std::optional<ProtocolCraft::Chat>& data_custom_name)
783 {
784 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
785 metadata["data_custom_name"] = data_custom_name;
786 }
787#else
788 void Entity::SetDataCustomName(const std::string& data_custom_name)
789 {
790 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
791 metadata["data_custom_name"] = data_custom_name;
792 }
793#endif
794
795 void Entity::SetDataCustomNameVisible(const bool data_custom_name_visible)
796 {
797 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
798 metadata["data_custom_name_visible"] = data_custom_name_visible;
799 }
800
801 void Entity::SetDataSilent(const bool data_silent)
802 {
803 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
804 metadata["data_silent"] = data_silent;
805 }
806
807 void Entity::SetDataNoGravity(const bool data_no_gravity)
808 {
809 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
810 metadata["data_no_gravity"] = data_no_gravity;
811 }
812
813#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
814 void Entity::SetDataPose(const Pose data_pose)
815 {
816 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
817 SetDataPoseImpl(data_pose);
818 }
819#endif
820
821#if PROTOCOL_VERSION > 754 /* > 1.16.5 */
822 void Entity::SetDataTicksFrozen(const int data_ticks_frozen)
823 {
824 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
825 metadata["data_ticks_frozen"] = data_ticks_frozen;
826 }
827#endif
828
829
831 {
832 std::shared_lock<std::shared_mutex> lock(entity_mutex);
833 return entity_id;
834 }
835
837 {
838 std::shared_lock<std::shared_mutex> lock(entity_mutex);
839 return uuid;
840 }
841
843 {
844 std::shared_lock<std::shared_mutex> lock(entity_mutex);
845 return position;
846 }
847
848 double Entity::GetX() const
849 {
850 std::shared_lock<std::shared_mutex> lock(entity_mutex);
851 return position.x;
852 }
853
854 double Entity::GetY() const
855 {
856 std::shared_lock<std::shared_mutex> lock(entity_mutex);
857 return position.y;
858 }
859
860 double Entity::GetZ() const
861 {
862 std::shared_lock<std::shared_mutex> lock(entity_mutex);
863 return position.z;
864 }
865
866 float Entity::GetYaw() const
867 {
868 std::shared_lock<std::shared_mutex> lock(entity_mutex);
869 return yaw;
870 }
871
872 float Entity::GetPitch() const
873 {
874 std::shared_lock<std::shared_mutex> lock(entity_mutex);
875 return pitch;
876 }
877
879 {
880 std::shared_lock<std::shared_mutex> lock(entity_mutex);
881 return speed;
882 }
883
884 double Entity::GetSpeedX() const
885 {
886 std::shared_lock<std::shared_mutex> lock(entity_mutex);
887 return speed.x;
888 }
889
890 double Entity::GetSpeedY() const
891 {
892 std::shared_lock<std::shared_mutex> lock(entity_mutex);
893 return speed.y;
894 }
895
896 double Entity::GetSpeedZ() const
897 {
898 std::shared_lock<std::shared_mutex> lock(entity_mutex);
899 return speed.z;
900 }
901
903 {
904 std::shared_lock<std::shared_mutex> lock(entity_mutex);
905 return on_ground;
906 }
907
908 std::map<EquipmentSlot, ProtocolCraft::Slot> Entity::GetEquipments() const
909 {
910 std::shared_lock<std::shared_mutex> lock(entity_mutex);
911 return equipments;
912 }
913
915 {
916 std::shared_lock<std::shared_mutex> lock(entity_mutex);
917 return equipments.at(slot);
918 }
919
920 std::vector<EntityEffect> Entity::GetEffects() const
921 {
922 std::shared_lock<std::shared_mutex> lock(entity_mutex);
923 return effects;
924 }
925
926#if USE_GUI
927 std::vector<Renderer::Face> Entity::GetFaces(const bool reset_uptodate_status)
928 {
929 if (faces.size() == 0)
930 {
932 }
933 std::shared_lock<std::shared_mutex> lock(entity_mutex);
935 {
936 for (size_t i = 0; i < faces.size(); ++i)
937 {
938 faces[i].UpdateMatrix(face_descriptors[i].transformations, face_descriptors[i].orientation);
939 }
940 }
941 if (reset_uptodate_status)
942 {
944 }
945 return faces;
946 }
947
949 {
950 std::shared_lock<std::shared_mutex> lock(entity_mutex);
952 }
953#endif
954
955
956 void Entity::SetEntityID(const int entity_id_)
957 {
958 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
959 entity_id = entity_id_;
960 }
961
963 {
964 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
965 uuid = uuid_;
966 }
967
969 {
970 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
971#if USE_GUI
972 if (position_ != position)
973 {
975 for (size_t i = 0; i < faces.size(); ++i)
976 {
977 std::shared_ptr<Renderer::Translation> f = std::static_pointer_cast<Renderer::Translation>(face_descriptors[i].transformations.translations.back());
978 f->x = static_cast<float>(position_.x);
979 f->y = static_cast<float>(position_.y);
980 f->z = static_cast<float>(position_.z);
981 }
982 }
983#endif
984 position = position_;
985 }
986
987 void Entity::SetX(const double x_)
988 {
989 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
990#if USE_GUI
991 if (x_ != position.x)
992 {
994 for (size_t i = 0; i < faces.size(); ++i)
995 {
996 std::static_pointer_cast<Renderer::Translation>(face_descriptors[i].transformations.translations.back())->x = static_cast<float>(x_);
997 }
998 }
999#endif
1000 position.x = x_;
1001 }
1002
1003 void Entity::SetY(const double y_)
1004 {
1005 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1006#if USE_GUI
1007 if (y_ != position.y)
1008 {
1010 for (size_t i = 0; i < faces.size(); ++i)
1011 {
1012 std::static_pointer_cast<Renderer::Translation>(face_descriptors[i].transformations.translations.back())->y = static_cast<float>(y_);
1013 }
1014 }
1015#endif
1016 position.y = y_;
1017 }
1018
1019 void Entity::SetZ(const double z_)
1020 {
1021 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1022#if USE_GUI
1023 if (z_ != position.z)
1024 {
1026 for (size_t i = 0; i < faces.size(); ++i)
1027 {
1028 std::static_pointer_cast<Renderer::Translation>(face_descriptors[i].transformations.translations.back())->z = static_cast<float>(z_);
1029 }
1030 }
1031#endif
1032 position.z = z_;
1033 }
1034
1035 void Entity::SetYaw(const float yaw_)
1036 {
1037 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1038#if USE_GUI
1039 if (yaw_ != yaw)
1040 {
1042 for (size_t i = 0; i < faces.size(); ++i)
1043 {
1044 std::static_pointer_cast<Renderer::Rotation>(face_descriptors[i].transformations.rotations.front())->deg_angle = yaw_;
1045 }
1046 }
1047#endif
1048 yaw = yaw_;
1049 }
1050
1051 void Entity::SetPitch(const float pitch_)
1052 {
1053 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1054#if USE_GUI
1055 if (pitch_ != pitch)
1056 {
1058 for (size_t i = 0; i < faces.size(); ++i)
1059 {
1060 std::static_pointer_cast<Renderer::Rotation>(face_descriptors[i].transformations.rotations.back())->deg_angle = pitch_;
1061 }
1062 }
1063#endif
1064 pitch = pitch_;
1065 }
1066
1068 {
1069 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1070 speed = speed_;
1071 }
1072
1073 void Entity::SetSpeedX(const double speed_x_)
1074 {
1075 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1076 speed.x = speed_x_;
1077 }
1078
1079 void Entity::SetSpeedY(const double speed_y_)
1080 {
1081 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1082 speed.y = speed_y_;
1083 }
1084
1085 void Entity::SetSpeedZ(const double speed_z_)
1086 {
1087 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1088 speed.z = speed_z_;
1089 }
1090
1091 void Entity::SetOnGround(const bool on_ground_)
1092 {
1093 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1094 on_ground = on_ground_;
1095 }
1096
1098 {
1099 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1100 equipments.at(slot) = item;
1101 }
1102
1103 void Entity::SetEffects(const std::vector<EntityEffect>& effects_)
1104 {
1105 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1106 effects = effects_;
1107 }
1108
1110 {
1111 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1112 for (auto it = effects.begin(); it != effects.end();)
1113 {
1114 if (it->type == type)
1115 {
1116 it = effects.erase(it);
1117 }
1118 else
1119 {
1120 ++it;
1121 }
1122 }
1123 }
1124
1126 {
1127 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1128 // First, remove any instance of this type of effect on the entity
1129 for (auto it = effects.begin(); it != effects.end();)
1130 {
1131 if (it->type == effect.type)
1132 {
1133 it = effects.erase(it);
1134 }
1135 else
1136 {
1137 ++it;
1138 }
1139 }
1140
1141 // Then add the new one
1142 effects.push_back(effect);
1143 }
1144
1145#if USE_GUI
1146 void Entity::SetAreRenderedFacesUpToDate(const bool should_be_updated_)
1147 {
1148 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1149 are_rendered_faces_up_to_date = should_be_updated_;
1150 }
1151#endif
1152
1153
1155 {
1157
1158 {
1159 std::shared_lock<std::shared_mutex> lock(entity_mutex);
1160 output["id"] = entity_id;
1161 output["position"] = position.Serialize();
1162 output["yaw"] = yaw;
1163 output["pitch"] = pitch;
1164 output["speed"] = speed.Serialize();
1165 output["on_ground"] = on_ground;
1166 output["equipment"] = ProtocolCraft::Json::Value();
1167 for (auto& p : equipments)
1168 {
1169 output["equipment"][std::to_string(static_cast<int>(p.first))] = p.second.Serialize();
1170 }
1171 }
1172
1173 output["metadata"] = ProtocolCraft::Json::Value();
1174
1175 output["metadata"]["data_shared_flags_id"] = GetDataSharedFlagsId();
1176 output["metadata"]["data_air_supply_id"] = GetDataAirSupplyId();
1177#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1178 output["metadata"]["data_custom_name"] = GetDataCustomName() ? GetDataCustomName().value().Serialize() : ProtocolCraft::Json::Value();
1179#else
1180 output["metadata"]["data_custom_name"] = GetDataCustomName();
1181#endif
1182 output["metadata"]["data_custom_name_visible"] = GetDataCustomNameVisible();
1183 output["metadata"]["data_silent"] = GetDataSilent();
1184 output["metadata"]["data_no_gravity"] = GetDataNoGravity();
1185#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
1186 output["metadata"]["data_pose"] = static_cast<int>(GetDataPose());
1187#endif
1188#if PROTOCOL_VERSION > 754 /* > 1.16.5 */
1189 output["metadata"]["data_ticks_frozen"] = GetDataTicksFrozen();
1190#endif
1191
1192 return output;
1193 }
1194
1196 {
1197 return false;
1198 }
1199
1201 {
1202 return false;
1203 }
1204
1206 {
1207 return false;
1208 }
1209
1211 {
1212 return false;
1213 }
1214
1215 bool Entity::IsAnimal() const
1216 {
1217 return false;
1218 }
1219
1221 {
1222 return false;
1223 }
1224
1226 {
1227 return false;
1228 }
1229
1230#if PROTOCOL_VERSION > 761 /* > 1.19.3 */
1232 {
1233 return false;
1234 }
1235#endif
1236
1237#if PROTOCOL_VERSION > 764 /* > 1.20.2 */
1239 {
1240 return false;
1241 }
1242#endif
1243
1245 {
1246 return false;
1247 }
1248
1250 {
1251 return false;
1252 }
1253
1255 {
1256 return false;
1257 }
1258
1260 {
1261 return false;
1262 }
1263
1265 {
1266 return false;
1267 }
1268
1269 bool Entity::IsMob() const
1270 {
1271 return false;
1272 }
1273
1275 {
1276 return false;
1277 }
1278
1279#if PROTOCOL_VERSION > 578 /* > 1.15.2 */
1281 {
1282 return false;
1283 }
1284#endif
1285
1286#if PROTOCOL_VERSION < 771 /* < 1.21.6 */
1287 bool Entity::IsFlyingMob() const
1288 {
1289 return false;
1290 }
1291#endif
1292
1294 {
1295 return false;
1296 }
1297
1299 {
1300 return false;
1301 }
1302
1304 {
1305 return false;
1306 }
1307
1309 {
1310 return false;
1311 }
1312
1314 {
1315 return false;
1316 }
1317
1318#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
1320 {
1321 return false;
1322 }
1323#endif
1324
1326 {
1327 return false;
1328 }
1329
1331 {
1332 return false;
1333 }
1334
1335#if PROTOCOL_VERSION > 736 /* > 1.16.1 */
1337 {
1338 return false;
1339 }
1340#endif
1341
1343 {
1344 return false;
1345 }
1346
1347#if PROTOCOL_VERSION > 769 /* > 1.21.4 */
1349 {
1350 return false;
1351 }
1352#endif
1353
1355 {
1356 return false;
1357 }
1358
1359#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
1360 bool Entity::IsRaider() const
1361 {
1362 return false;
1363 }
1364#endif
1365
1367 {
1368 return false;
1369 }
1370
1372 {
1373 return false;
1374 }
1375
1376#if PROTOCOL_VERSION > 477 /* > 1.14 */
1378 {
1379 return false;
1380 }
1381#endif
1382
1384 {
1385 return false;
1386 }
1387
1389 {
1390 return false;
1391 }
1392
1393#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
1395 {
1396 return false;
1397 }
1398#endif
1399
1401 {
1402 return false;
1403 }
1404
1405#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
1407 {
1408 return false;
1409 }
1410#endif
1411
1412#if PROTOCOL_VERSION > 766 /* > 1.20.6 */
1414 {
1415 return false;
1416 }
1417#endif
1418
1419#if PROTOCOL_VERSION > 767 /* > 1.21.1 */
1421 {
1422 return false;
1423 }
1424
1426 {
1427 return false;
1428 }
1429
1431 {
1432 return false;
1433 }
1434
1435 bool Entity::IsBoat() const
1436 {
1437 return false;
1438 }
1439
1441 {
1442 return false;
1443 }
1444
1446 {
1447 return false;
1448 }
1449
1450 bool Entity::IsRaft() const
1451 {
1452 return false;
1453 }
1454#endif
1455
1456
1457 std::shared_ptr<Entity> Entity::CreateEntity(const EntityType type)
1458 {
1459 switch (type)
1460 {
1461 case EntityType::None:
1462 return nullptr;
1463#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
1464 case EntityType::Allay:
1465 return std::make_shared<AllayEntity>();
1466#endif
1468 return std::make_shared<AreaEffectCloudEntity>();
1469#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
1471 return std::make_shared<ArmadilloEntity>();
1472#endif
1474 return std::make_shared<ArmorStandEntity>();
1475 case EntityType::Arrow:
1476 return std::make_shared<ArrowEntity>();
1477#if PROTOCOL_VERSION > 754 /* > 1.16.5 */
1479 return std::make_shared<AxolotlEntity>();
1480#endif
1481 case EntityType::Bat:
1482 return std::make_shared<BatEntity>();
1483#if PROTOCOL_VERSION > 498 /* > 1.14.4 */
1484 case EntityType::Bee:
1485 return std::make_shared<BeeEntity>();
1486#endif
1487 case EntityType::Blaze:
1488 return std::make_shared<BlazeEntity>();
1489#if PROTOCOL_VERSION < 768 /* < 1.21.2 */
1490 case EntityType::Boat:
1491 return std::make_shared<BoatEntity>();
1492#else
1502 return std::make_shared<BoatEntity>(type);
1503#endif
1504#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
1505 case EntityType::Bogged:
1506 return std::make_shared<BoggedEntity>();
1507#endif
1508#if PROTOCOL_VERSION > 764 /* > 1.20.2 */
1509 case EntityType::Breeze:
1510 return std::make_shared<BreezeEntity>();
1511#endif
1512#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
1514 return std::make_shared<BreezeWindChargeEntity>();
1515#endif
1516#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
1517#if PROTOCOL_VERSION < 768 /* < 1.21.2 */
1518 case EntityType::ChestBoat:
1519 return std::make_shared<ChestBoatEntity>();
1520#else
1530 return std::make_shared<ChestBoatEntity>(type);
1531#endif
1532#endif
1533#if PROTOCOL_VERSION > 767 /* > 1.21.1 */
1535 return std::make_shared<ChestRaftEntity>(type);
1536#endif
1537#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
1538 case EntityType::Cat:
1539 return std::make_shared<CatEntity>();
1540#endif
1541#if PROTOCOL_VERSION > 760 /* > 1.19.2 */
1542 case EntityType::Camel:
1543 return std::make_shared<CamelEntity>();
1544#endif
1546 return std::make_shared<CaveSpiderEntity>();
1548 return std::make_shared<ChickenEntity>();
1549#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1550 case EntityType::Cod:
1551 return std::make_shared<CodEntity>();
1552#endif
1553 case EntityType::Cow:
1554 return std::make_shared<CowEntity>();
1555#if PROTOCOL_VERSION > 767 /* > 1.21.1 */
1557 return std::make_shared<CreakingEntity>();
1558#endif
1559#if PROTOCOL_VERSION > 767 /* > 1.21.1 */ && PROTOCOL_VERSION < 769 /* < 1.21.4 */
1560 case EntityType::CreakingTransient:
1561 return std::make_shared<CreakingTransientEntity>();
1562#endif
1564 return std::make_shared<CreeperEntity>();
1565#if PROTOCOL_VERSION > 761 /* > 1.19.3 */
1567 return std::make_shared<DisplayBlockDisplayEntity>();
1569 return std::make_shared<DisplayItemDisplayEntity>();
1571 return std::make_shared<DisplayTextDisplayEntity>();
1572#endif
1573#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1575 return std::make_shared<DolphinEntity>();
1576#endif
1577 case EntityType::Donkey:
1578 return std::make_shared<DonkeyEntity>();
1580 return std::make_shared<DragonFireballEntity>();
1581#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1583 return std::make_shared<DrownedEntity>();
1584#endif
1586 return std::make_shared<ElderGuardianEntity>();
1588 return std::make_shared<EndCrystalEntity>();
1590 return std::make_shared<EnderDragonEntity>();
1592 return std::make_shared<EnderManEntity>();
1594 return std::make_shared<EndermiteEntity>();
1595 case EntityType::Evoker:
1596 return std::make_shared<EvokerEntity>();
1598 return std::make_shared<EvokerFangsEntity>();
1600 return std::make_shared<ExperienceOrbEntity>();
1602 return std::make_shared<EyeOfEnderEntity>();
1604 return std::make_shared<FallingBlockEntity>();
1606 return std::make_shared<FireworkRocketEntity>();
1607#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
1608 case EntityType::Fox:
1609 return std::make_shared<FoxEntity>();
1610#endif
1611#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
1612 case EntityType::Frog:
1613 return std::make_shared<FrogEntity>();
1614#endif
1615 case EntityType::Ghast:
1616 return std::make_shared<GhastEntity>();
1617#if PROTOCOL_VERSION > 770 /* > 1.21.5 */
1619 return std::make_shared<HappyGhastEntity>();
1620#endif
1621 case EntityType::Giant:
1622 return std::make_shared<GiantEntity>();
1623#if PROTOCOL_VERSION > 754 /* > 1.16.5 */
1625 return std::make_shared<GlowItemFrameEntity>();
1627 return std::make_shared<GlowSquidEntity>();
1628 case EntityType::Goat:
1629 return std::make_shared<GoatEntity>();
1630#endif
1632 return std::make_shared<GuardianEntity>();
1633#if PROTOCOL_VERSION > 578 /* > 1.15.2 */
1634 case EntityType::Hoglin:
1635 return std::make_shared<HoglinEntity>();
1636#endif
1637 case EntityType::Horse:
1638 return std::make_shared<HorseEntity>();
1639 case EntityType::Husk:
1640 return std::make_shared<HuskEntity>();
1642 return std::make_shared<IllusionerEntity>();
1643#if PROTOCOL_VERSION > 761 /* > 1.19.3 */
1645 return std::make_shared<InteractionEntity>();
1646#endif
1648 return std::make_shared<IronGolemEntity>();
1650 return std::make_shared<ItemEntity>();
1652 return std::make_shared<ItemFrameEntity>();
1653#if PROTOCOL_VERSION > 765 /* > 1.20.4 */
1655 return std::make_shared<OminousItemSpawnerEntity>();
1656#endif
1658 return std::make_shared<LargeFireballEntity>();
1660 return std::make_shared<LeashFenceKnotEntity>();
1661#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1663 return std::make_shared<LightningBoltEntity>();
1664#endif
1665 case EntityType::Llama:
1666 return std::make_shared<LlamaEntity>();
1668 return std::make_shared<LlamaSpitEntity>();
1670 return std::make_shared<MagmaCubeEntity>();
1671#if PROTOCOL_VERSION > 754 /* > 1.16.5 */
1672 case EntityType::Marker:
1673 return std::make_shared<MarkerEntity>();
1674#endif
1676 return std::make_shared<MinecartEntity>();
1678 return std::make_shared<MinecartChestEntity>();
1680 return std::make_shared<MinecartCommandBlockEntity>();
1682 return std::make_shared<MinecartFurnaceEntity>();
1684 return std::make_shared<MinecartHopperEntity>();
1686 return std::make_shared<MinecartSpawnerEntity>();
1688 return std::make_shared<MinecartTNTEntity>();
1689 case EntityType::Mule:
1690 return std::make_shared<MuleEntity>();
1692 return std::make_shared<MushroomCowEntity>();
1693 case EntityType::Ocelot:
1694 return std::make_shared<OcelotEntity>();
1696 return std::make_shared<PaintingEntity>();
1697#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
1698 case EntityType::Panda:
1699 return std::make_shared<PandaEntity>();
1700#endif
1701 case EntityType::Parrot:
1702 return std::make_shared<ParrotEntity>();
1703#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1705 return std::make_shared<PhantomEntity>();
1706#endif
1707 case EntityType::Pig:
1708 return std::make_shared<PigEntity>();
1709#if PROTOCOL_VERSION > 578 /* > 1.15.2 */
1710 case EntityType::Piglin:
1711 return std::make_shared<PiglinEntity>();
1712#endif
1713#if PROTOCOL_VERSION > 736 /* > 1.16.1 */
1715 return std::make_shared<PiglinBruteEntity>();
1716#endif
1717#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
1719 return std::make_shared<PillagerEntity>();
1720#endif
1722 return std::make_shared<PolarBearEntity>();
1724 return std::make_shared<PrimedTntEntity>();
1725#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1727 return std::make_shared<PufferfishEntity>();
1728#endif
1729 case EntityType::Rabbit:
1730 return std::make_shared<RabbitEntity>();
1731#if PROTOCOL_VERSION > 767 /* > 1.21.1 */
1732 case EntityType::Raft:
1733 return std::make_shared<RaftEntity>(type);
1734#endif
1735#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
1737 return std::make_shared<RavagerEntity>();
1738#endif
1739#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1740 case EntityType::Salmon:
1741 return std::make_shared<SalmonEntity>();
1742#endif
1743 case EntityType::Sheep:
1744 return std::make_shared<SheepEntity>();
1746 return std::make_shared<ShulkerEntity>();
1748 return std::make_shared<ShulkerBulletEntity>();
1750 return std::make_shared<SilverfishEntity>();
1752 return std::make_shared<SkeletonEntity>();
1754 return std::make_shared<SkeletonHorseEntity>();
1755 case EntityType::Slime:
1756 return std::make_shared<SlimeEntity>();
1758 return std::make_shared<SmallFireballEntity>();
1759#if PROTOCOL_VERSION > 761 /* > 1.19.3 */
1761 return std::make_shared<SnifferEntity>();
1762#endif
1764 return std::make_shared<SnowGolemEntity>();
1766 return std::make_shared<SnowballEntity>();
1768 return std::make_shared<SpectralArrowEntity>();
1769 case EntityType::Spider:
1770 return std::make_shared<SpiderEntity>();
1771 case EntityType::Squid:
1772 return std::make_shared<SquidEntity>();
1773 case EntityType::Stray:
1774 return std::make_shared<StrayEntity>();
1775#if PROTOCOL_VERSION > 578 /* > 1.15.2 */
1777 return std::make_shared<StriderEntity>();
1778#endif
1779#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
1781 return std::make_shared<TadpoleEntity>();
1782#endif
1784 return std::make_shared<ThrownEggEntity>();
1786 return std::make_shared<ThrownEnderpearlEntity>();
1788 return std::make_shared<ThrownExperienceBottleEntity>();
1789#if PROTOCOL_VERSION < 770 /* < 1.21.5 */
1790 case EntityType::ThrownPotion:
1791 return std::make_shared<ThrownPotionEntity>();
1792#else
1794 return std::make_shared<ThrownSplashPotionEntity>();
1796 return std::make_shared<ThrownLingeringPotionEntity>();
1797#endif
1798#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1800 return std::make_shared<ThrownTridentEntity>();
1801#endif
1802#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
1804 return std::make_shared<TraderLlamaEntity>();
1805#endif
1806#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1808 return std::make_shared<TropicalFishEntity>();
1809#endif
1810#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1811 case EntityType::Turtle:
1812 return std::make_shared<TurtleEntity>();
1813#endif
1814 case EntityType::Vex:
1815 return std::make_shared<VexEntity>();
1817 return std::make_shared<VillagerEntity>();
1819 return std::make_shared<VindicatorEntity>();
1820#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
1822 return std::make_shared<WanderingTraderEntity>();
1823#endif
1824#if PROTOCOL_VERSION > 758 /* > 1.18.2 */
1825 case EntityType::Warden:
1826 return std::make_shared<WardenEntity>();
1827#endif
1828#if PROTOCOL_VERSION > 764 /* > 1.20.2 */
1830 return std::make_shared<WindChargeEntity>();
1831#endif
1832 case EntityType::Witch:
1833 return std::make_shared<WitchEntity>();
1835 return std::make_shared<WitherBossEntity>();
1837 return std::make_shared<WitherSkeletonEntity>();
1839 return std::make_shared<WitherSkullEntity>();
1840 case EntityType::Wolf:
1841 return std::make_shared<WolfEntity>();
1842#if PROTOCOL_VERSION > 578 /* > 1.15.2 */
1843 case EntityType::Zoglin:
1844 return std::make_shared<ZoglinEntity>();
1845#endif
1846 case EntityType::Zombie:
1847 return std::make_shared<ZombieEntity>();
1849 return std::make_shared<ZombieHorseEntity>();
1851 return std::make_shared<ZombieVillagerEntity>();
1852#if PROTOCOL_VERSION > 578 /* > 1.15.2 */
1854 return std::make_shared<ZombifiedPiglinEntity>();
1855#else
1856 case EntityType::PigZombie:
1857 return std::make_shared<PigZombieEntity>();
1858#endif
1859 case EntityType::Player:
1860 return std::make_shared<PlayerEntity>();
1861#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1863 return std::make_shared<FishingHookEntity>();
1864#endif
1865 default:
1866 return nullptr;
1867 }
1868 }
1869
1870#if PROTOCOL_VERSION < 458 /* < 1.14 */
1871 std::shared_ptr<Entity> Entity::CreateObjectEntity(const ObjectEntityType type)
1872 {
1873 switch (type)
1874 {
1875 case ObjectEntityType::None:
1876 return nullptr;
1877 case ObjectEntityType::Boat:
1878 return std::make_shared<BoatEntity>();
1879 case ObjectEntityType::ItemEntity:
1880 return std::make_shared<ItemEntity>();
1881 case ObjectEntityType::AreaEffectCloud:
1882 return std::make_shared<AreaEffectCloudEntity>();
1883 case ObjectEntityType::PrimedTnt:
1884 return std::make_shared<PrimedTntEntity>();
1885 case ObjectEntityType::EndCrystal:
1886 return std::make_shared<EndCrystalEntity>();
1887 case ObjectEntityType::Arrow:
1888 return std::make_shared<ArrowEntity>();
1889 case ObjectEntityType::Snowball:
1890 return std::make_shared<SnowballEntity>();
1891 case ObjectEntityType::ThrownEgg:
1892 return std::make_shared<ThrownEggEntity>();
1893 case ObjectEntityType::LargeFireball:
1894 return std::make_shared<LargeFireballEntity>();
1895 case ObjectEntityType::SmallFireball:
1896 return std::make_shared<SmallFireballEntity>();
1897 case ObjectEntityType::ThrownEnderpearl:
1898 return std::make_shared<ThrownEnderpearlEntity>();
1899 case ObjectEntityType::WitherSkull:
1900 return std::make_shared<WitherSkullEntity>();
1901 case ObjectEntityType::ShulkerBullet:
1902 return std::make_shared<ShulkerBulletEntity>();
1903 case ObjectEntityType::LlamaSpit:
1904 return std::make_shared<LlamaSpitEntity>();
1905 case ObjectEntityType::FallingBlockEntity:
1906 return std::make_shared<FallingBlockEntity>();
1907 case ObjectEntityType::ItemFrame:
1908 return std::make_shared<ItemFrameEntity>();
1909 case ObjectEntityType::EyeOfEnder:
1910 return std::make_shared<EyeOfEnderEntity>();
1911 case ObjectEntityType::ThrownPotion:
1912 return std::make_shared<ThrownPotionEntity>();
1913 case ObjectEntityType::ThrownExperienceBottle:
1914 return std::make_shared<ThrownExperienceBottleEntity>();
1915 case ObjectEntityType::FireworkRocketEntity:
1916 return std::make_shared<FireworkRocketEntity>();
1917 case ObjectEntityType::LeashFenceKnotEntity:
1918 return std::make_shared<LeashFenceKnotEntity>();
1919 case ObjectEntityType::ArmorStand:
1920 return std::make_shared<ArmorStandEntity>();
1921 case ObjectEntityType::EvokerFangs:
1922 return std::make_shared<EvokerFangsEntity>();
1923 case ObjectEntityType::FishingHook:
1924 return std::make_shared<FishingHookEntity>();
1925 case ObjectEntityType::SpectralArrow:
1926 return std::make_shared<SpectralArrowEntity>();
1927 case ObjectEntityType::DragonFireball:
1928 return std::make_shared<DragonFireballEntity>();
1929#if PROTOCOL_VERSION > 340 /* > 1.12.2 */
1930 case ObjectEntityType::ThrownTrident:
1931 return std::make_shared<ThrownTridentEntity>();
1932#endif
1933 default:
1934 return nullptr;
1935 }
1936 }
1937#endif
1938
1939#if USE_GUI
1941 {
1942 std::scoped_lock<std::shared_mutex> lock(entity_mutex);
1944
1945 // Generate default faces
1946 face_descriptors = std::vector<FaceDescriptor>(6);
1947 faces = std::vector<Renderer::Face>(6);
1948 const double half_height = GetHeightImpl() / 2.0;
1949 const double half_width = GetWidthImpl() / 2.0;
1950 for (int i = 0; i < 6; ++i)
1951 {
1952 face_descriptors[i].orientation = static_cast<Orientation>(i);
1953 face_descriptors[i].texture_names = { "" };
1954 face_descriptors[i].cullface_direction = Orientation::None;
1955 face_descriptors[i].use_tintindexes = { false };
1956
1957 // Base entity scale
1958 face_descriptors[i].transformations.scales.push_back(std::make_shared<Renderer::Scale>(
1959 static_cast<float>(half_width),
1960 static_cast<float>(half_height),
1961 static_cast<float>(half_width)
1962 ));
1963 // Base translation
1964 face_descriptors[i].transformations.translations.push_back(std::make_shared<Renderer::Translation>(0.0f, static_cast<float>(half_height), 0.0f));
1965 // Entity pos translation
1966 face_descriptors[i].transformations.translations.push_back(std::make_shared<Renderer::Translation>(
1967 static_cast<float>(position.x),
1968 static_cast<float>(position.y),
1969 static_cast<float>(position.z))
1970 );
1971 // Entity yaw/pitch rotation
1972 face_descriptors[i].transformations.rotations.push_back(std::make_shared<Renderer::Rotation>(0.0f, 1.0f, 0.0f, yaw));
1973 face_descriptors[i].transformations.rotations.push_back(std::make_shared<Renderer::Rotation>(1.0f, 0.0f, 0.0f, pitch));
1974
1975 face_descriptors[i].transformations.rotation = 0;
1976
1977 faces[i] = Renderer::Face(face_descriptors[i].transformations, face_descriptors[i].orientation);
1978 faces[i].SetDisplayBackface(false);
1979 faces[i].SetTextureMultipliers({ 0xFFFFFFFF, 0xFFFFFFFF });
1980
1981 // Extract texture info from the atlas
1982 std::array<unsigned short, 4> texture_pos = { 0, 0, 0, 0 };
1983 std::array<unsigned short, 4> texture_size = { 0, 0, 0, 0 };
1984 std::array<Renderer::Transparency, 2> transparencies = { Renderer::Transparency::Opaque, Renderer::Transparency::Opaque };
1985 std::array<Renderer::Animation, 2> animated = { Renderer::Animation::Static, Renderer::Animation::Static };
1986
1987 for (int j = 0; j < std::min(2, static_cast<int>(face_descriptors[i].texture_names.size())); ++j)
1988 {
1989 const Renderer::TextureData& texture_data = atlas->GetData(face_descriptors[i].texture_names[j]);
1990 std::tie(texture_pos[2 * j + 0], texture_pos[2 * j + 1]) = texture_data.position;
1991 std::tie(texture_size[2 * j + 0], texture_size[2 * j + 1]) = texture_data.size;
1992 transparencies[j] = texture_data.transparency;
1993 animated[j] = texture_data.animation;
1994 }
1995
1996 // Main texture coords in the atlas
1997 std::array<float, 4> coords = faces[i].GetTextureCoords(false);
1998 unsigned short height_normalizer = animated[0] == Renderer::Animation::Animated ? texture_size[0] : texture_size[1];
1999 coords[0] = (texture_pos[0] + coords[0] / 16.0f * texture_size[0]) / atlas->GetWidth();
2000 coords[1] = (texture_pos[1] + coords[1] / 16.0f * height_normalizer) / atlas->GetHeight();
2001 coords[2] = (texture_pos[0] + coords[2] / 16.0f * texture_size[0]) / atlas->GetWidth();
2002 coords[3] = (texture_pos[1] + coords[3] / 16.0f * height_normalizer) / atlas->GetHeight();
2003 faces[i].SetTextureCoords(coords, false);
2004
2005 // Overlay texture coords in the atlas if existing
2006 if (face_descriptors[i].texture_names.size() > 1)
2007 {
2008 coords = faces[i].GetTextureCoords(true);
2009 height_normalizer = animated[1] == Renderer::Animation::Animated ? texture_size[2] : texture_size[3];
2010 coords[0] = (texture_pos[2] + coords[0] / 16.0f * texture_size[2]) / atlas->GetWidth();
2011 coords[1] = (texture_pos[3] + coords[1] / 16.0f * height_normalizer) / atlas->GetHeight();
2012 coords[2] = (texture_pos[2] + coords[2] / 16.0f * texture_size[2]) / atlas->GetWidth();
2013 coords[3] = (texture_pos[3] + coords[3] / 16.0f * height_normalizer) / atlas->GetHeight();
2014 faces[i].SetTextureCoords(coords, true);
2015 }
2016
2017 faces[i].SetTransparencyData(transparencies[0]);
2018 }
2020 }
2021
2023 {
2025 const double half_width = GetWidthImpl() / 2.0;
2026 const double half_height = GetHeightImpl() / 2.0;
2027 for (size_t i = 0; i < faces.size(); ++i)
2028 {
2029 std::static_pointer_cast<Renderer::Scale>(face_descriptors[i].transformations.scales.back())->axis_x = static_cast<float>(half_width);
2030 std::static_pointer_cast<Renderer::Scale>(face_descriptors[i].transformations.scales.back())->axis_y = static_cast<float>(half_height);
2031 std::static_pointer_cast<Renderer::Scale>(face_descriptors[i].transformations.scales.back())->axis_z = static_cast<float>(half_width);
2032 std::static_pointer_cast<Renderer::Translation>(face_descriptors[i].transformations.translations.front())->y = static_cast<float>(half_height);
2033 }
2034 }
2035#endif
2036
2038 {
2039 return std::any_cast<char>(metadata.at("data_shared_flags_id"));
2040 }
2041
2043 {
2044 return (GetDataSharedFlagsIdImpl() >> static_cast<char>(id)) & 0x01;
2045 }
2046
2047 void Entity::SetDataSharedFlagsIdImpl(const char data_shared_flags_id)
2048 {
2049 metadata["data_shared_flags_id"] = data_shared_flags_id;
2050 }
2051
2053 {
2054 char current_value = GetDataSharedFlagsIdImpl();
2055 // Set the bit to 0
2056 const char mask = 0x01 << static_cast<char>(id);
2057 current_value &= ~mask;
2058 // Set the bit to b
2059 current_value |= b << static_cast<char>(id);
2060 SetDataSharedFlagsIdImpl(current_value);
2061 }
2062
2063#if PROTOCOL_VERSION > 404 /* > 1.13.2 */
2065 {
2066 return std::any_cast<Pose>(metadata.at("data_pose"));
2067 }
2068
2069 void Entity::SetDataPoseImpl(const Pose data_pose)
2070 {
2071 metadata["data_pose"] = data_pose;
2072#if USE_GUI
2073 OnSizeUpdated();
2074#endif
2075 }
2076#endif
2077
2079 {
2080 const double half_width = GetWidthImpl() / 2.0;
2081 const double half_height = GetHeightImpl() / 2.0;
2082 return AABB(Vector3<double>(position.x, position.y + half_height, position.z), Vector3<double>(half_width, half_height, half_width));
2083 }
2084
2086 {
2087 return -1.0;
2088 }
2089
2091 {
2092 return -1.0;
2093 }
2094}
#define LOG_ERROR(osstream)
Definition Logger.hpp:45
const Renderer::Atlas * GetAtlas() const
static AssetsManager & getInstance()
int GetDataTicksFrozen() const
Definition Entity.cpp:755
void OnSizeUpdated()
Definition Entity.cpp:2022
bool GetOnGround() const
Definition Entity.cpp:902
ProtocolCraft::UUID uuid
Definition Entity.hpp:264
virtual double GetHeightImpl() const
Definition Entity.cpp:2090
void SetDataSilent(const bool data_silent)
Definition Entity.cpp:801
virtual ProtocolCraft::Json::Value Serialize() const
Definition Entity.cpp:1154
void SetDataPose(const Pose data_pose)
Definition Entity.cpp:814
std::map< EquipmentSlot, ProtocolCraft::Slot > equipments
Items on this entity.
Definition Entity.hpp:273
virtual void SetY(const double y_)
Definition Entity.cpp:1003
double GetZ() const
Definition Entity.cpp:860
virtual bool IsAbstractChestedHorse() const
Definition Entity.cpp:1259
virtual bool IsWaterAnimal() const
Definition Entity.cpp:1254
void SetEffects(const std::vector< EntityEffect > &effects_)
Definition Entity.cpp:1103
void SetDataAirSupplyId(const int data_air_supply_id)
Definition Entity.cpp:775
void SetDataSharedFlagsIdImpl(const char data_shared_flags_id)
Definition Entity.cpp:2047
Vector3< double > GetSpeed() const
Definition Entity.cpp:878
void SetUUID(const ProtocolCraft::UUID &uuid_)
Definition Entity.cpp:962
std::map< EquipmentSlot, ProtocolCraft::Slot > GetEquipments() const
Definition Entity.cpp:908
Vector3< double > speed
Definition Entity.hpp:268
virtual bool IsAbstractArrow() const
Definition Entity.cpp:1210
virtual bool IsAbstractSkeleton() const
Definition Entity.cpp:1366
virtual bool IsAbstractPiglin() const
Definition Entity.cpp:1336
int GetEntityID() const
Definition Entity.cpp:830
virtual bool IsLocalPlayer() const
Definition Entity.cpp:1195
double GetHeight() const
Definition Entity.cpp:346
std::vector< EntityEffect > effects
Definition Entity.hpp:274
char GetDataSharedFlagsIdImpl() const
Definition Entity.cpp:2037
virtual bool IsRemotePlayer() const
Definition Entity.cpp:1200
bool GetDataSilent() const
Definition Entity.cpp:734
void SetDataPoseImpl(const Pose data_pose)
Definition Entity.cpp:2069
double GetSpeedX() const
Definition Entity.cpp:884
virtual bool IsAbstractBoat() const
Definition Entity.cpp:1420
virtual bool IsAbstractHurtingProjectile() const
Definition Entity.cpp:1264
ProtocolCraft::UUID GetUUID() const
Definition Entity.cpp:836
double GetY() const
Definition Entity.cpp:854
virtual bool IsAbstractSchoolingFish() const
Definition Entity.cpp:1249
void SetSpeed(const Vector3< double > &speed_)
Definition Entity.cpp:1067
virtual bool IsHangingEntity() const
Definition Entity.cpp:1303
bool GetAreRenderedFacesUpToDate() const
Definition Entity.cpp:948
virtual void SetMetadataValue(const int index, const std::any &value)
Definition Entity.cpp:681
virtual bool IsSpellcasterIllager() const
Definition Entity.cpp:1274
virtual bool IsBlockAttachedEntity() const
Definition Entity.cpp:1413
static std::shared_ptr< Entity > CreateEntity(const EntityType type)
Definition Entity.cpp:1457
virtual bool IsAbstractThrownPotion() const
Definition Entity.cpp:1348
AABB GetCollider() const
Definition Entity.cpp:334
static const std::array< std::string, metadata_count > metadata_names
Definition Entity.hpp:61
bool are_rendered_faces_up_to_date
Definition Entity.hpp:283
virtual double GetWidthImpl() const
Definition Entity.cpp:2085
virtual void SetZ(const double z_)
Definition Entity.cpp:1019
void SetEquipment(const EquipmentSlot slot, const ProtocolCraft::Slot &item)
Definition Entity.cpp:1097
std::vector< Renderer::Face > faces
Definition Entity.hpp:281
virtual bool IsLivingEntity() const
Definition Entity.cpp:1205
virtual bool IsChestBoat() const
Definition Entity.cpp:1440
double GetWidth() const
Definition Entity.cpp:340
virtual ~Entity()
Definition Entity.cpp:328
virtual bool IsPatrollingMonster() const
Definition Entity.cpp:1394
virtual bool IsProjectile() const
Definition Entity.cpp:1280
int GetDataAirSupplyId() const
Definition Entity.cpp:708
std::vector< EntityEffect > GetEffects() const
Definition Entity.cpp:920
virtual bool IsAbstractMinecart() const
Definition Entity.cpp:1313
virtual bool IsDisplay() const
Definition Entity.cpp:1231
void SetSpeedY(const double speed_y_)
Definition Entity.cpp:1079
virtual bool IsAbstractMinecartContainer() const
Definition Entity.cpp:1325
void SetDataCustomName(const std::optional< ProtocolCraft::Chat > &data_custom_name)
Definition Entity.cpp:782
virtual bool IsAmbientCreature() const
Definition Entity.cpp:1220
virtual bool IsFireball() const
Definition Entity.cpp:1308
Pose GetDataPose() const
Definition Entity.cpp:747
std::shared_mutex entity_mutex
Definition Entity.hpp:261
void SetOnGround(const bool on_ground_)
Definition Entity.cpp:1091
virtual bool IsAnimal() const
Definition Entity.cpp:1215
std::vector< Renderer::Face > GetFaces(const bool reset_uptodate_status)
Definition Entity.cpp:927
void SetSpeedX(const double speed_x_)
Definition Entity.cpp:1073
virtual bool IsAbstractFish() const
Definition Entity.cpp:1354
virtual bool IsAgeableMob() const
Definition Entity.cpp:1383
virtual void SetX(const double x_)
Definition Entity.cpp:987
virtual bool IsAbstractVillager() const
Definition Entity.cpp:1377
virtual void InitializeFaces()
Definition Entity.cpp:1940
virtual bool IsThrowableProjectile() const
Definition Entity.cpp:1400
virtual bool IsAbstractWindCharge() const
Definition Entity.cpp:1406
AABB GetColliderImpl() const
Definition Entity.cpp:2078
void SetDataSharedFlagsId(const char data_shared_flags_id)
Definition Entity.cpp:763
char GetDataSharedFlagsId() const
Definition Entity.cpp:696
virtual bool IsMob() const
Definition Entity.cpp:1269
virtual void SetYaw(const float yaw_)
Definition Entity.cpp:1035
virtual bool IsPathfinderMob() const
Definition Entity.cpp:1388
ProtocolCraft::Slot GetEquipment(const EquipmentSlot slot) const
Definition Entity.cpp:914
void SetDataCustomNameVisible(const bool data_custom_name_visible)
Definition Entity.cpp:795
virtual bool IsVehicle() const
Definition Entity.cpp:1238
double GetSpeedY() const
Definition Entity.cpp:890
double GetSpeedZ() const
Definition Entity.cpp:896
Pose GetDataPoseImpl() const
Definition Entity.cpp:2064
virtual bool IsRaider() const
Definition Entity.cpp:1360
virtual void SetPitch(const float pitch_)
Definition Entity.cpp:1051
virtual bool IsThrowableItemProjectile() const
Definition Entity.cpp:1371
void SetEntityID(const int entity_id_)
Definition Entity.cpp:956
virtual bool IsMonster() const
Definition Entity.cpp:1225
virtual bool IsTamableAnimal() const
Definition Entity.cpp:1244
void SetDataNoGravity(const bool data_no_gravity)
Definition Entity.cpp:807
bool GetDataCustomNameVisible() const
Definition Entity.cpp:728
virtual bool IsAbstractIllager() const
Definition Entity.cpp:1342
virtual bool IsAbstractHorse() const
Definition Entity.cpp:1293
std::map< std::string, std::any > metadata
Definition Entity.hpp:276
Vector3< double > position
Definition Entity.hpp:265
virtual bool IsAbstractCow() const
Definition Entity.cpp:1319
virtual bool IsAbstractChestBoat() const
Definition Entity.cpp:1425
void AddEffect(const EntityEffect &effect)
Definition Entity.cpp:1125
virtual bool IsChestRaft() const
Definition Entity.cpp:1445
virtual bool IsAbstractGolem() const
Definition Entity.cpp:1298
float GetYaw() const
Definition Entity.cpp:866
virtual bool IsAgeableWaterCreature() const
Definition Entity.cpp:1430
double GetX() const
Definition Entity.cpp:848
bool GetDataNoGravity() const
Definition Entity.cpp:740
void SetAreRenderedFacesUpToDate(const bool are_rendered_faces_up_to_date_)
Definition Entity.cpp:1146
Vector3< double > GetPosition() const
Definition Entity.cpp:842
void SetSpeedZ(const double speed_z_)
Definition Entity.cpp:1085
static constexpr int metadata_count
Definition Entity.hpp:55
std::vector< FaceDescriptor > face_descriptors
Definition Entity.hpp:280
std::optional< ProtocolCraft::Chat > GetDataCustomName() const
Definition Entity.cpp:715
virtual bool IsBoat() const
Definition Entity.cpp:1435
void LoadMetadataFromRawArray(const std::vector< unsigned char > &data)
Definition Entity.cpp:353
virtual bool IsRaft() const
Definition Entity.cpp:1450
virtual bool IsShoulderRidingEntity() const
Definition Entity.cpp:1330
float GetPitch() const
Definition Entity.cpp:872
void RemoveEffect(const EntityEffectType type)
Definition Entity.cpp:1109
virtual void SetPosition(const Vector3< double > &position_)
Definition Entity.cpp:968
void SetDataTicksFrozen(const int data_ticks_frozen)
Definition Entity.cpp:822
const TextureData & GetData(const std::string &name) const
Definition Atlas.cpp:237
Main class, basically a JsonVariant with extra utility functions it doesn't inherit JsonVariant direc...
Definition Json.hpp:45
virtual void Read(ReadIterator &iter, size_t &length)
Vector3< int > Position
Definition Vector3.hpp:282
EquipmentSlot
Definition Enums.hpp:276
EntityEffectType
Definition Enums.hpp:315
EntitySharedFlagsId
Definition Entity.hpp:40
std::array< unsigned char, 16 > UUID
std::vector< unsigned char >::const_iterator ReadIterator
EntityEffectType type
Definition Entity.hpp:34
std::pair< int, int > position
<Col, Row>
Definition Atlas.hpp:16
std::pair< int, int > size
<Width, Height>
Definition Atlas.hpp:14
ProtocolCraft::Json::Value Serialize() const
Definition Vector3.hpp:267