Merge branch 'main' into user-properties

src/logic/scripting/lua/libs/libblock.cpp

@@ -2,6 +2,7 @@
 #include "lighting/Lighting.hpp"
 #include "logic/BlocksController.hpp"
 #include "logic/LevelController.hpp"
+#include "objects/Players.hpp"
 #include "voxels/Block.hpp"
 #include "voxels/Chunk.hpp"
 #include "voxels/Chunks.hpp"
@@ -350,9 +351,9 @@ static int l_place(lua::State* L) {
             "there is no block with index " + std::to_string(id)
         );
     }
-    auto player = level->getObject<Player>(playerid);
+    auto player = level->players->get(playerid);
     controller->getBlocksController()->placeBlock(
-        player ? player.get() : nullptr, *def, int2blockstate(state), x, y, z
+        player, *def, int2blockstate(state), x, y, z
     );
     return 0;
 }
@@ -367,10 +368,8 @@ static int l_destruct(lua::State* L) {
         return 0;
     }
     auto& def = level->content->getIndices()->blocks.require(voxel->id);
-    auto player = level->getObject<Player>(playerid);
-    controller->getBlocksController()->breakBlock(
-        player ? player.get() : nullptr, def, x, y, z
-    );
+    auto player = level->players->get(playerid);
+    controller->getBlocksController()->breakBlock(player, def, x, y, z);
     return 0;
 }
 

src/logic/scripting/lua/libs/libcore.cpp

@@ -20,6 +20,12 @@
 
 using namespace scripting;
 
+static int l_get_version(lua::State* L) {
+    return lua::pushvec_stack(
+        L, glm::vec2(ENGINE_VERSION_MAJOR, ENGINE_VERSION_MINOR)
+    );
+}
+
 /// @brief Creating new world
 /// @param name Name world
 /// @param seed Seed world
@@ -239,6 +245,7 @@ static int l_quit(lua::State*) {
 }
 
 const luaL_Reg corelib[] = {
+    {"get_version", lua::wrap<l_get_version>},
     {"new_world", lua::wrap<l_new_world>},
     {"open_world", lua::wrap<l_open_world>},
     {"reopen_world", lua::wrap<l_reopen_world>},

src/logic/scripting/lua/libs/libfile.cpp

@@ -19,7 +19,7 @@ static fs::path resolve_path(const std::string& path) {
 
 static fs::path resolve_path_soft(const std::string& path) {
     if (path.find(':') == std::string::npos) {
-        return path;
+        return fs::u8path("");
     }
     return engine->getPaths()->resolve(path, false);
 }

src/logic/scripting/lua/libs/libplayer.cpp

@@ -4,6 +4,7 @@
 #include "items/Inventory.hpp"
 #include "objects/Entities.hpp"
 #include "objects/Player.hpp"
+#include "objects/Players.hpp"
 #include "physics/Hitbox.hpp"
 #include "window/Camera.hpp"
 #include "world/Level.hpp"
@@ -11,8 +12,8 @@
 
 using namespace scripting;
 
-inline std::shared_ptr<Player> get_player(lua::State* L, int idx) {
-    return level->getObject<Player>(lua::tointeger(L, idx));
+inline Player* get_player(lua::State* L, int idx) {
+    return level->players->get(lua::tointeger(L, idx));
 }
 
 static int l_get_pos(lua::State* L) {
@@ -235,6 +236,20 @@ static int l_set_camera(lua::State* L) {
     return 0;
 }
 
+static int l_get_name(lua::State* L) {
+    if (auto player = get_player(L, 1)) {
+        return lua::pushstring(L, player->getName());
+    }
+    return 0;
+}
+
+static int l_set_name(lua::State* L) {
+    if (auto player = get_player(L, 1)) {
+        player->setName(lua::require_string(L, 2));
+    }
+    return 0;
+}
+
 const luaL_Reg playerlib[] = {
     {"get_pos", lua::wrap<l_get_pos>},
     {"set_pos", lua::wrap<l_set_pos>},
@@ -260,5 +275,7 @@ const luaL_Reg playerlib[] = {
     {"set_entity", lua::wrap<l_set_entity>},
     {"get_camera", lua::wrap<l_get_camera>},
     {"set_camera", lua::wrap<l_set_camera>},
+    {"get_name", lua::wrap<l_get_name>},
+    {"set_name", lua::wrap<l_set_name>},
     {NULL, NULL}
 };

src/logic/scripting/lua/libs/libworld.cpp

@@ -4,7 +4,9 @@
 
 #include "assets/Assets.hpp"
 #include "assets/AssetsLoader.hpp"
+#include "coders/json.hpp"
 #include "engine.hpp"
+#include "files/files.hpp"
 #include "files/engine_paths.hpp"
 #include "world/Level.hpp"
 #include "world/World.hpp"
@@ -32,22 +34,34 @@ static int l_get_list(lua::State* L) {
     for (size_t i = 0; i < worlds.size(); i++) {
         lua::createtable(L, 0, 1);
 
-        auto name = worlds[i].filename().u8string();
+        const auto& folder = worlds[i];
+
+        auto root = json::parse(files::read_string(folder/fs::u8path("world.json")));
+        const auto& versionMap = root["version"];
+        int versionMajor = versionMap["major"].asInteger();
+        int versionMinor = versionMap["minor"].asInteger();
+
+
+        auto name = folder.filename().u8string();
         lua::pushstring(L, name);
         lua::setfield(L, "name");
 
         auto assets = engine->getAssets();
         std::string icon = "world#" + name + ".icon";
         if (!AssetsLoader::loadExternalTexture(
-                assets,
-                icon,
-                {worlds[i] / fs::path("icon.png"),
-                 worlds[i] / fs::path("preview.png")}
-            )) {
+            assets,
+            icon,
+            {worlds[i] / fs::path("icon.png"),
+                worlds[i] / fs::path("preview.png")}
+        )) {
             icon = "gui/no_world_icon";
         }
         lua::pushstring(L, icon);
         lua::setfield(L, "icon");
+
+        lua::pushvec2(L, {versionMajor, versionMinor});
+        lua::setfield(L, "version");
+
         lua::rawseti(L, i + 1);
     }
     return 1;

src/logic/scripting/scripting.cpp

@@ -68,7 +68,6 @@ void scripting::initialize(Engine* engine) {
     lua::initialize(*engine->getPaths());
 
     load_script(fs::path("stdlib.lua"), true);
-    load_script(fs::path("stdcmd.lua"), true);
     load_script(fs::path("classes.lua"), true);
 }
 
@@ -196,6 +195,7 @@ void scripting::on_content_load(Content* content) {
         lua::setfield(L, "properties");
         lua::pop(L);
     }
+    load_script(fs::path("stdcmd.lua"), true);
 }
 
 void scripting::on_world_load(LevelController* controller) {
@@ -308,6 +308,32 @@ void scripting::on_block_placed(
     }
 }
 
+void scripting::on_block_replaced(
+    Player* player, const Block& block, const glm::ivec3& pos
+) {
+    if (block.rt.funcsset.onreplaced) {
+        std::string name = block.name + ".replaced";
+        lua::emit_event(lua::get_main_state(), name, [pos, player](auto L) {
+            lua::pushivec_stack(L, pos);
+            lua::pushinteger(L, player ? player->getId() : -1);
+            return 4;
+        });
+    }
+    auto args = [&](lua::State* L) {
+        lua::pushinteger(L, block.rt.id);
+        lua::pushivec_stack(L, pos);
+        lua::pushinteger(L, player ? player->getId() : -1);
+        return 5;
+    };
+    for (auto& [packid, pack] : content->getPacks()) {
+        if (pack->worldfuncsset.onblockreplaced) {
+            lua::emit_event(
+                lua::get_main_state(), packid + ":.blockreplaced", args
+            );
+        }
+    }
+}
+
 void scripting::on_block_broken(
     Player* player, const Block& block, const glm::ivec3& pos
 ) {
@@ -725,6 +751,8 @@ void scripting::load_content_script(
         register_event(env, "on_random_update", prefix + ".randupdate");
     funcsset.onbroken = register_event(env, "on_broken", prefix + ".broken");
     funcsset.onplaced = register_event(env, "on_placed", prefix + ".placed");
+    funcsset.onreplaced =
+        register_event(env, "on_replaced", prefix + ".replaced");
     funcsset.oninteract =
         register_event(env, "on_interact", prefix + ".interact");
     funcsset.onblockstick =
@@ -776,6 +804,8 @@ void scripting::load_world_script(
         register_event(env, "on_block_placed", prefix + ":.blockplaced");
     funcsset.onblockbroken =
         register_event(env, "on_block_broken", prefix + ":.blockbroken");
+    funcsset.onblockreplaced =
+        register_event(env, "on_block_replaced", prefix + ":.blockreplaced");
     funcsset.onblockinteract =
         register_event(env, "on_block_interact", prefix + ":.blockinteract");
     funcsset.onplayertick =

src/logic/scripting/scripting.hpp

@@ -71,6 +71,9 @@ namespace scripting {
     void on_block_placed(
         Player* player, const Block& block, const glm::ivec3& pos
     );
+    void on_block_replaced(
+        Player* player, const Block& block, const glm::ivec3& pos
+    );
     void on_block_broken(
         Player* player, const Block& block, const glm::ivec3& pos
     );