remove default player from headless mode

dev/tests/example.lua

@@ -1,4 +1,3 @@
-test.reconfig_packs({"base"}, {})
 test.new_world("demo", "2019", "core:default")
 assert(world.get_generator() == "core:default")
 coroutine.yield()

src/logic/EngineController.cpp

@@ -16,6 +16,7 @@
 #include "frontend/screens/MenuScreen.hpp"
 #include "graphics/ui/elements/Menu.hpp"
 #include "graphics/ui/gui_util.hpp"
+#include "objects/Players.hpp"
 #include "interfaces/Task.hpp"
 #include "util/stringutil.hpp"
 #include "world/Level.hpp"
@@ -245,6 +246,9 @@ void EngineController::createWorld(
         engine->getContent(),
         engine->getContentPacks()
     );
+    if (!engine->isHeadless()) {
+        level->players->create();
+    }
     engine->onWorldOpen(std::move(level));
 }
 

src/logic/LevelController.cpp

@@ -6,6 +6,7 @@
 #include "engine.hpp"
 #include "files/WorldFiles.hpp"
 #include "objects/Entities.hpp"
+#include "objects/Players.hpp"
 #include "physics/Hitbox.hpp"
 #include "settings.hpp"
 #include "world/Level.hpp"
@@ -23,34 +24,42 @@ LevelController::LevelController(Engine* engine, std::unique_ptr<Level> levelPtr
       )),
       chunks(std::make_unique<ChunksController>(
           *level, settings.chunks.padding.get()
-      )),
-      player(std::make_unique<PlayerController>(
-        settings, level.get(), blocks.get()
       )) {
+    if (!engine->isHeadless()) {
+        player = std::make_unique<PlayerController>(
+            settings, level.get(), level->players->get(0), blocks.get()
+        );
+    }
     scripting::on_world_load(this);
 }
 
 void LevelController::update(float delta, bool input, bool pause) {
-    glm::vec3 position = player->getPlayer()->getPosition();
+    if (player) {
-    level->loadMatrix(
+        glm::vec3 position = player->getPlayer()->getPosition();
-        position.x,
+        level->loadMatrix(
-        position.z,
+            position.x,
-        settings.chunks.loadDistance.get() + settings.chunks.padding.get() * 2
+            position.z,
-    );
+            settings.chunks.loadDistance.get() + settings.chunks.padding.get() * 2
-    chunks->update(
+        );
-        settings.chunks.loadSpeed.get(), settings.chunks.loadDistance.get(),
+        chunks->update(
-        floordiv(position.x, CHUNK_W), floordiv(position.z, CHUNK_D)
+            settings.chunks.loadSpeed.get(), settings.chunks.loadDistance.get(),
-    );
+            floordiv(position.x, CHUNK_W), floordiv(position.z, CHUNK_D)
+        );
+    }
 
     if (!pause) {
         // update all objects that needed
         blocks->update(delta);
-        player->update(delta, input, pause);
+        if (player) {
+            player->update(delta, input);
+        }
         level->entities->updatePhysics(delta);
         level->entities->update(delta);
     }
     level->entities->clean();
-    player->postUpdate(delta, input, pause);
+    if (player) {
+        player->postUpdate(delta, input, pause);
+    }
 }
 
 void LevelController::saveWorld() {

src/logic/PlayerController.cpp

@@ -190,11 +190,14 @@ void CameraControl::update(PlayerInput input, float delta, Chunks* chunks) {
 }
 
 PlayerController::PlayerController(
-    const EngineSettings& settings, Level* level,
+    const EngineSettings& settings,
+    Level* level,
+    Player* player,
     BlocksController* blocksController
 )
-    : settings(settings), level(level),
+    : settings(settings),
-      player(level->players->get(0)),
+      level(level),
+      player(player),
       camControl(player, settings.camera),
       blocksController(blocksController),
       playerTickClock(20, 3) {
@@ -242,21 +245,19 @@ void PlayerController::updateFootsteps(float delta) {
     }
 }
 
-void PlayerController::update(float delta, bool input, bool pause) {
+void PlayerController::update(float delta, bool input) {
-    if (!pause) {
+    if (input) {
-        if (input) {
+        updateKeyboard();
-            updateKeyboard();
+        player->updateSelectedEntity();
-            player->updateSelectedEntity();
+    } else {
-        } else {
+        resetKeyboard();
-            resetKeyboard();
+    }
-        }
+    updatePlayer(delta);
-        updatePlayer(delta);
 
-        if (playerTickClock.update(delta)) {
+    if (playerTickClock.update(delta)) {
-            if (player->getId() % playerTickClock.getParts() ==
+        if (player->getId() % playerTickClock.getParts() ==
-                playerTickClock.getPart()) {
+            playerTickClock.getPart()) {
-                scripting::on_player_tick(player, playerTickClock.getTickRate());
+            scripting::on_player_tick(player, playerTickClock.getTickRate());
-            }
         }
     }
 }

src/logic/PlayerController.hpp

@@ -71,9 +71,21 @@ class PlayerController {
     voxel* updateSelection(float maxDistance);
 public:
     PlayerController(
-        const EngineSettings& settings, Level* level, BlocksController* blocksController
+        const EngineSettings& settings,
+        Level* level,
+        Player* player,
+        BlocksController* blocksController
     );
-    void update(float delta, bool input, bool pause);
+
+    /// @brief Called after blocks update if not paused
+    /// @param delta delta time
+    /// @param input process user input
+    void update(float delta, bool input);
+
+    /// @brief Called after whole level update
+    /// @param delta delta time
+    /// @param input process user input
+    /// @param pause is game paused
     void postUpdate(float delta, bool input, bool pause);
     Player* getPlayer();
 };

src/objects/Players.cpp

@@ -7,7 +7,7 @@
 
 Players::Players(Level* level) : level(level) {}
 
-void Players::addPlayer(std::unique_ptr<Player> player) {
+void Players::add(std::unique_ptr<Player> player) {
     players[player->getId()] = std::move(player);
 }
 
@@ -30,7 +30,7 @@ Player* Players::create() {
         0
     );
     auto player = playerPtr.get();
-    addPlayer(std::move(playerPtr));
+    add(std::move(playerPtr));
 
     level->inventories->store(player->getInventory());
     return player;
@@ -62,7 +62,7 @@ void Players::deserialize(const dv::value& src) {
         );
         auto player = playerPtr.get();
         player->deserialize(playerMap);
-        addPlayer(std::move(playerPtr));
+        add(std::move(playerPtr));
         auto& inventory = player->getInventory();
         // invalid inventory id pre 0.25
         if (inventory->getId() == 0) {

src/objects/Players.hpp

@@ -17,7 +17,7 @@ class Players : public Serializable {
     Level* level;
     std::unordered_map<int64_t, std::unique_ptr<Player>> players;
 
-    void addPlayer(std::unique_ptr<Player> player);
+    void add(std::unique_ptr<Player> player);
 public:
     Players(Level* level);
 

src/world/World.cpp

@@ -97,9 +97,7 @@ std::unique_ptr<Level> World::create(
     );
     logger.info() << "created world '" << name << "' (" << directory.u8string() << ")";
     logger.info() << "world seed: " << seed << " generator: " << generator;
-    auto level = std::make_unique<Level>(std::move(world), content, settings);
+    return std::make_unique<Level>(std::move(world), content, settings);
-    level->players->create();
-    return level;
 }
 
 std::unique_ptr<Level> World::load(