Fix crash caused by the entity vector being invalidated

cubic-server/Client.cpp

@@ -351,7 +351,7 @@ void Client::_onStatusRequest()
         return;
     }
 
-    json["version"]["name"] = MC_VERSION;
+    json["version"]["name"] = MC_VERSION_BRANDING;
     json["version"]["protocol"] = MC_PROTOCOL;
     json["players"]["max"] = conf["max-players"].as<int32_t>();
     {

cubic-server/Dimension.cpp

@@ -4,6 +4,7 @@
 #include "Server.hpp"
 #include "World.hpp"
 #include "entities/Entity.hpp"
+#include "entities/EntityType.hpp"
 #include "logging/logging.hpp"
 #include "math/Vector3.hpp"
 #include "protocol/ClientPackets.hpp"
@@ -24,9 +25,11 @@ Dimension::Dimension(std::shared_ptr<World> world, world_storage::DimensionType
 
 void Dimension::tick()
 {
-    std::lock_guard _(_entitiesMutex);
-    for (auto ent : _entities) {
-        ent->tick();
+    {
+        std::lock_guard _(_entitiesMutex);
+        for (auto ent : _entities) {
+            ent->tick();
+        }
     }
     uint32_t rts = CONFIG["randomtickspeed"].as<uint32_t>();
     if (rts != 0) {
@@ -37,6 +40,16 @@ void Dimension::tick()
             chunk.processRandomTick(rts);
         }
     }
+    {
+        std::unique_lock a(_entitiesMutex, std::defer_lock);
+        std::unique_lock b(_newEntitiesMutex, std::defer_lock);
+        std::lock(a, b);
+
+        if (_newEntities.size() != 0) {
+            _entities.insert(_entities.end(), _newEntities.begin(), _newEntities.end());
+            _newEntities.clear();
+        }
+    }
 }
 
 void Dimension::stop()
@@ -115,8 +128,8 @@ void Dimension::removePlayer(int32_t entity_id)
 
 void Dimension::addEntity(std::shared_ptr<Entity> entity)
 {
-    std::lock_guard _(_entitiesMutex);
-    _entities.emplace_back(entity);
+    std::lock_guard _(_newEntitiesMutex);
+    _newEntities.emplace_back(entity);
 }
 
 void Dimension::addPlayer(std::shared_ptr<Player> entity)
@@ -220,24 +233,37 @@ const world_storage::ChunkColumn &Dimension::getChunk(const Position2D &pos) con
 void Dimension::spawnPlayer(Player &current)
 {
     auto current_id = current.getId();
-    std::lock_guard _(_playersMutex);
-    for (auto player : _players) {
-        LDEBUG("player is: {}", player->getUsername());
-        LDEBUG("current is: {}", current.getUsername());
-        // if (current->getPos().distance(player->getPos()) <= 12) {
-        if (player->getId() != current_id) {
-            player->sendSpawnPlayer(
-                {current_id, current.getUuid(), current.getPosition().x, current.getPosition().y, current.getPosition().z, current.getRotation().x, current.getRotation().z}
-            );
-            LDEBUG("send spawn player to {}", player->getUsername());
-            current.sendSpawnPlayer(
-                {player->getId(), player->getUuid(), player->getPosition().x, player->getPosition().y, player->getPosition().z, player->getRotation().x, player->getRotation().z}
-            );
-            LDEBUG("send spawn player to {}", current.getUsername());
-            //}
+    {
+
+        std::lock_guard _(_playersMutex);
+        for (auto player : _players) {
+            LDEBUG("player is: {}", player->getUsername());
+            LDEBUG("current is: {}", current.getUsername());
+            // if (current->getPos().distance(player->getPos()) <= 12) {
+            if (player->getId() != current_id) {
+                player->sendSpawnPlayer(
+                    {current_id, current.getUuid(), current.getPosition().x, current.getPosition().y, current.getPosition().z, current.getRotation().x, current.getRotation().z}
+                );
+                LDEBUG("send spawn player to {}", player->getUsername());
+                current.sendSpawnPlayer(
+                    {player->getId(), player->getUuid(), player->getPosition().x, player->getPosition().y, player->getPosition().z, player->getRotation().x,
+                     player->getRotation().z}
+                );
+                LDEBUG("send spawn player to {}", current.getUsername());
+                //}
+            }
+            player->sendEntityMetadata(current);
+            current.sendEntityMetadata(*player);
+        }
+    }
+    {
+        std::lock_guard _(_entitiesMutex);
+        for (auto ent : _entities) {
+            if (ent->getType() == EntityType::Player)
+                continue;
+            current.sendSpawnEntity(*ent);
+            current.sendEntityMetadata(*ent);
         }
-        player->sendEntityMetadata(current);
-        current.sendEntityMetadata(*player);
     }
 }
 

cubic-server/Dimension.hpp

@@ -149,11 +149,13 @@ class Dimension : public std::enable_shared_from_this<Dimension> {
 public:
     mutable std::recursive_mutex _playersMutex;
     mutable std::recursive_mutex _entitiesMutex;
+    mutable std::recursive_mutex _newEntitiesMutex;
     mutable std::mutex _loadingChunksMutex;
 
 protected:
     std::counting_semaphore<SEMAPHORE_MAX> _dimensionLock;
     std::vector<std::shared_ptr<Entity>> _entities;
+    std::vector<std::shared_ptr<Entity>> _newEntities;
     std::vector<std::shared_ptr<Player>> _players;
     std::shared_ptr<World> _world;
     std::mutex _processingMutex;

cubic-server/Player.cpp

@@ -309,6 +309,29 @@ void Player::sendSpawnEntity(const protocol::SpawnEntity &data)
     N_LDEBUG("Sent a Spawn Entity packet");
 }
 
+void Player::sendSpawnEntity(const Entity &data)
+{
+    GET_CLIENT();
+    auto pck = protocol::createSpawnEntity({
+        data.getId(), // Entity ID
+        data.getUuid(), // Entity UUID
+        data.getType(), // Entity Type
+        data.getPosition().x, // Entity Position X
+        data.getPosition().y, // Entity Position Y
+        data.getPosition().z, // Entity Position Z
+        0, // Entity Pitch
+        0, // Entity Yaw
+        0, // Entity Head Yaw
+        0, // Entity data
+        0, // Entity Velocity X
+        0, // Entity Velocity Y
+        0 // Entity Velocity Z
+    });
+    client->doWrite(std::move(pck));
+
+    N_LDEBUG("Sent a Spawn Entity packet");
+}
+
 void Player::sendSpawnPlayer(const protocol::SpawnPlayer &data)
 {
     GET_CLIENT();

cubic-server/Player.hpp

@@ -102,6 +102,7 @@ class Player : public LivingEntity {
     void sendPlayerInfoUpdate(const protocol::PlayerInfoUpdate &data);
     void sendPlayerInfoRemove(const protocol::PlayerInfoRemove &data);
     void sendSpawnEntity(const protocol::SpawnEntity &data);
+    void sendSpawnEntity(const Entity &data);
     void sendSpawnPlayer(const protocol::SpawnPlayer &data);
     void sendEntityVelocity(const protocol::EntityVelocity &data);
     void sendHealth(void);

cubic-server/Server.hpp

@@ -44,6 +44,7 @@
 #include "registry/MasterRegistry.hpp"
 
 constexpr char MC_VERSION[] = "1.19.3";
+constexpr char MC_VERSION_BRANDING[] = "CubicServer 1.19.3";
 constexpr uint16_t MC_PROTOCOL = 761;
 constexpr uint16_t MS_PER_TICK = 50;
 

cubic-server/allCommands.hpp

@@ -10,4 +10,5 @@
 #include "command_parser/commands/Scoreboard.hpp"
 #include "command_parser/commands/Seed.hpp"
 #include "command_parser/commands/Stop.hpp"
+#include "command_parser/commands/Teleport.hpp"
 #include "command_parser/commands/Time.hpp"

cubic-server/entities/Chicken.cpp

@@ -25,7 +25,7 @@ void Chicken::layEgg()
     auto time = utility::PseudoRandomGenerator::getInstance()->generateNumber(6000, 12000);
     LDEBUG("Chicken will drop egg in {} ticks", time);
     _layEgg.setTickRate(time);
-    _dim->makeEntity<Item>(protocol::Slot {true, ITEM_CONVERTER.fromItemToProtocolId("minecraft:egg"), 1})->dropItem({_pos.x, _pos.y + 1, _pos.z});
+    _dim->makeEntity<Item>(protocol::Slot {true, ITEM_CONVERTER.fromItemToProtocolId("minecraft:egg"), 1})->dropItem({_pos.x, _pos.y + 1, _pos.z}, false);
     LDEBUG("Chicken dropped egg at x: {}, y: {}, z: {}", _pos.x, _pos.y + 1, _pos.z);
 }