Merge pull request #768 from MihailRis/projects-related

projects-related

res/layouts/pages/content.xml

@@ -15,7 +15,7 @@
         <textbox id='search_textbox' multiline='false' size='440,25' sub-consumer='function(x) refresh_search() end'></textbox>  
     </panel>  
   
-    <image onclick='core.open_folder("user:content")' interactive='true' src='gui/folder_icon'   
+    <image onclick='app.open_folder("user:content")' interactive='true' src='gui/folder_icon'   
         size='32' margin='0,0,18,66' gravity='bottom-right'  
         color='#FFFFFF50' hover-color='#FFFFFF10'/>  
   

res/layouts/pages/content_menu.xml

@@ -9,7 +9,7 @@
         <textbox id='search_textbox' multiline='false' size='440,25' sub-consumer='function(x) refresh_search() end'></textbox>
     </panel>
 
-    <image onclick='core.open_folder("user:content")' interactive='true' src='gui/folder_icon' 
+    <image onclick='app.open_folder("user:content")' interactive='true' src='gui/folder_icon' 
         size='32' margin='0,0,10,15' gravity='bottom-right'
         color='#FFFFFF50' hover-color='#FFFFFF10'/>
 

res/layouts/pages/main.xml

@@ -3,5 +3,5 @@
     <button onclick='menu.page="scripts"'>@Scripts</button>
     <button onclick='menu.page="settings"'>@Settings</button>
     <button onclick='menu.page="content_menu"'>@Content</button>
-    <button onclick='core.quit()'>@Quit</button>
+    <button onclick='app.quit(true)'>@Quit</button>
 </panel>

res/layouts/pages/new_world.xml.lua

@@ -21,7 +21,7 @@ function create_world()
     local seed = document.seed_box.text
     local generator = settings.generator
     session.reset_entry('new_world')
-    core.new_world(name, seed, generator)
+    app.new_world(name, seed, generator)
 end
 
 function world_name_placeholder()

res/layouts/pages/pause.xml

@@ -2,7 +2,7 @@
     <button onclick='menu:reset()'>@Continue</button>
     <button onclick='menu.page="content?mode=world"'>@Content</button>
     <button onclick='menu.page="settings"'>@Settings</button>
-    <button onclick='core.close_world(true)'>
+    <button onclick='app.close_world(true)'>
         @Save and Quit to Menu
     </button>
 </panel>

res/layouts/pages/settings.xml

@@ -10,7 +10,7 @@
 
     <panel margin='6' gravity='bottom-left' size='250' color='0' interval='1'>
         <button onclick='menu.page="languages"' id='langs_btn'>-</button>
-        <button onclick='core.open_folder("user:")'>@Open data folder</button>
+        <button onclick='app.open_folder("user:")'>@Open data folder</button>
 		<button id='s_rst' onclick='sections:set("reset")'>@Reset settings</button>
         <button onclick='menu:back()'>@Back</button>
     </panel>

res/layouts/pages/settings.xml.lua

@@ -1,7 +1,7 @@
 function on_open()
     document.langs_btn.text = string.format(
         "%s: %s", gui.str("Language", "settings"),
-        gui.get_locales_info()[core.get_setting("ui.language")].name
+        gui.get_locales_info()[app.get_setting("ui.language")].name
     )
     sections = RadioGroup({
         audio=document.s_aud,

res/layouts/pages/settings_audio.xml.lua

@@ -1,25 +1,25 @@
 function create_setting(id, name, step, postfix)
-    local info = core.get_setting_info(id)
+    local info = app.get_setting_info(id)
     postfix = postfix or ""
     document.root:add(gui.template("track_setting", {
         id=id,
         name=gui.str(name, "settings"),
-        value=core.get_setting(id),
+        value=app.get_setting(id),
         min=info.min,
         max=info.max,
         step=step,
         postfix=postfix
     }))
-    update_setting(core.get_setting(id), id, name, postfix)
+    update_setting(app.get_setting(id), id, name, postfix)
 end
 
 function update_setting(x, id, name, postfix)
-    core.set_setting(id, x)
+    app.set_setting(id, x)
     -- updating label
     document[id..".L"].text = string.format(
         "%s: %s%s", 
         gui.str(name, "settings"),
-        core.str_setting(id),
+        app.str_setting(id),
         postfix
     )
 end
@@ -54,7 +54,7 @@ function on_open()
     create_setting("audio.volume-music", "Music", 0.01)
     document.root:add("<label context='settings'>@Microphone</label>")
     document.root:add("<select id='input_device_select' "..
-        "onselect='function(opt) core.set_setting(\"audio.input-device\", opt) end'/>")
+        "onselect='function(opt) app.set_setting(\"audio.input-device\", opt) end'/>")
     document.root:add("<container id='input_volume_outer' color='#000000' size='4'>"
                         .."<container id='input_volume_inner' color='#00FF00FF' pos='1' size='2'/>"
                     .."</container>")

res/layouts/pages/settings_controls.xml.lua

@@ -40,12 +40,12 @@ function refresh_sensitivity()
     document.sensitivity_label.text = string.format(
         "%s: %s", 
         gui.str("Mouse Sensitivity", "settings"),
-        core.str_setting("camera.sensitivity")
+        app.str_setting("camera.sensitivity")
     )
 end
 
 function change_sensitivity(val)
-    core.set_setting("camera.sensitivity", val)
+    app.set_setting("camera.sensitivity", val)
     refresh_sensitivity()
 end
 
@@ -93,7 +93,7 @@ function refresh_binding_marks()
 end
 
 function on_open()
-    document.sensitivity_track.value = core.get_setting("camera.sensitivity")
+    document.sensitivity_track.value = app.get_setting("camera.sensitivity")
     refresh_sensitivity()
 
     local panel = document.bindings_panel

res/layouts/pages/settings_display.xml.lua

@@ -10,14 +10,14 @@ tostring_overrides["display.framerate"] = function(x)
 end
 
 function create_setting(id, name, step, postfix, tooltip, changeonrelease)
-    local info = core.get_setting_info(id)
+    local info = app.get_setting_info(id)
     postfix = postfix or ""
     tooltip = tooltip or ""
     changeonrelease = changeonrelease or ""
     document.root:add(gui.template("track_setting", {
         id=id,
         name=gui.str(name, "settings"),
-        value=core.get_setting(id),
+        value=app.get_setting(id),
         min=info.min,
         max=info.max,
         step=step,
@@ -25,7 +25,7 @@ function create_setting(id, name, step, postfix, tooltip, changeonrelease)
         tooltip=tooltip,
         changeonrelease=changeonrelease
     }))
-    update_setting(core.get_setting(id), id, name, postfix)
+    update_setting(app.get_setting(id), id, name, postfix)
 end
 
 function update_setting(x, id, name, postfix)
@@ -34,7 +34,7 @@ function update_setting(x, id, name, postfix)
     if func then
         str = func(x)
     else
-        str = core.str_setting(id)
+        str = app.str_setting(id)
     end
     -- updating label
     document[id..".L"].text = string.format(
@@ -48,8 +48,8 @@ end
 function create_checkbox(id, name, tooltip)
     tooltip = tooltip or ''
     document.root:add(string.format(
-        "<checkbox consumer='function(x) core.set_setting(\"%s\", x) end' checked='%s' tooltip='%s'>%s</checkbox>", 
+        "<checkbox consumer='function(x) app.set_setting(\"%s\", x) end' checked='%s' tooltip='%s'>%s</checkbox>",
-        id, core.str_setting(id), gui.str(tooltip, "settings"), gui.str(name, "settings")
+        id, app.str_setting(id), gui.str(tooltip, "settings"), gui.str(name, "settings")
     ))
 end
 
@@ -59,11 +59,11 @@ function on_open()
     create_setting("display.framerate", "Framerate", 1, "", "", true)
 
     document.root:add(string.format(
-        "<select context='settings' onselect='function(opt) core.set_setting(\"display.window-mode\", tonumber(opt)) end' selected='%s'>"..
+        "<select context='settings' onselect='function(opt) app.set_setting(\"display.window-mode\", tonumber(opt)) end' selected='%s'>"..
             "<option value='0'>@Windowed</option>"..
             "<option value='1'>@Fullscreen</option>"..
             "<option value='2'>@Borderless</option>"..
-        "</select>", core.get_setting("display.window-mode"))
+        "</select>", app.get_setting("display.window-mode"))
     )
 
     create_checkbox("camera.shaking", "Camera Shaking")

res/layouts/pages/settings_graphics.xml.lua

@@ -1,12 +1,12 @@
 function create_setting(id, name, step, postfix, tooltip, changeonrelease)
-    local info = core.get_setting_info(id)
+    local info = app.get_setting_info(id)
     postfix = postfix or ""
     tooltip = tooltip or ""
     changeonrelease = changeonrelease or ""
     document.root:add(gui.template("track_setting", {
         id=id,
         name=gui.str(name, "settings"),
-        value=core.get_setting(id),
+        value=app.get_setting(id),
         min=info.min,
         max=info.max,
         step=step,
@@ -14,7 +14,7 @@ function create_setting(id, name, step, postfix, tooltip, changeonrelease)
         tooltip=tooltip,
         changeonrelease=changeonrelease
     }))
-    update_setting(core.get_setting(id), id, name, postfix)
+    update_setting(app.get_setting(id), id, name, postfix)
 end
 
 function update_setting(x, id, name, postfix)
@@ -22,7 +22,7 @@ function update_setting(x, id, name, postfix)
     document[id..".L"].text = string.format(
         "%s: %s%s",
         gui.str(name, "settings"),
-        core.str_setting(id), 
+        app.str_setting(id),
         postfix
     )
 end
@@ -30,8 +30,8 @@ end
 function create_checkbox(id, name, tooltip)
     tooltip = tooltip or ''
     document.root:add(string.format(
-        "<checkbox consumer='function(x) core.set_setting(\"%s\", x) end' checked='%s' tooltip='%s'>%s</checkbox>", 
+        "<checkbox consumer='function(x) app.set_setting(\"%s\", x) end' checked='%s' tooltip='%s'>%s</checkbox>",
-        id, core.str_setting(id), gui.str(tooltip, "settings"), gui.str(name, "settings")
+        id, app.str_setting(id), gui.str(tooltip, "settings"), gui.str(name, "settings")
     ))
 end
 

res/layouts/pages/settings_reset.xml.lua

@@ -11,7 +11,7 @@ function reset(category)
 end
 
 function reset_setting(name)
-	core.set_setting(name, core.get_setting_info(name).def)
+	app.set_setting(name, app.get_setting_info(name).def)
 end
 
 function reset_audio()

res/layouts/pages/worlds.xml

@@ -3,6 +3,6 @@
     
     <panel id='worlds' size='390,1' padding='5' color='#FFFFFF11' max-length='400'>
     </panel>
-    <button pos='485,525' size='500,40' onclick='core.open_folder("user:worlds")'>@Open worlds folder</button>
+    <button pos='485,525' size='500,40' onclick='app.open_folder("user:worlds")'>@Open worlds folder</button>
     <button onclick='menu:back()'>@Back</button>
 </panel>

res/layouts/pages/worlds.xml.lua

@@ -1,7 +1,7 @@
 function on_open()
     local worlds = world.get_list()
     for _, info in ipairs(worlds) do
-        local major, minor = core.get_version()
+        local major, minor = app.get_version()
         if info.version[1] > major or info.version[2] > minor then
             info.versionColor = "#A02010"
         else

res/layouts/templates/language.xml

@@ -1,4 +1,4 @@
 <button 
-    onclick='core.set_setting("ui.language", "%{id}") menu:back()'>
+    onclick='app.set_setting("ui.language", "%{id}") menu:back()'>
     %{name}
 </button>

res/layouts/templates/track_setting.xml

@@ -2,6 +2,6 @@
     <label id='%{id}.L' margin='0,3,0,0'>%{name}: %{value}%{postfix}</label>
     <trackbar 
         value='%{value}' min='%{min}' max='%{max}' step='%{step}' tooltip='%{tooltip}'
-        consumer='function(x) core.set_setting("%{id}", x) end' change-on-release='%{changeonrelease}'
+        consumer='function(x) app.set_setting("%{id}", x) end' change-on-release='%{changeonrelease}'
         sub-consumer='function(x) update_setting(x, "%{id}", "%{name}", "%{postfix}") end'/>
 </panel>

res/layouts/templates/world.xml

@@ -2,7 +2,7 @@
     size='380,66'
     color='#0F1E2DB2'
     hover-color='#162B3399'
-    onclick='core.open_world("%{name}")'
+    onclick='app.open_world("%{name}")'
 >
     <image pos='1' src='%{icon}' size='96,64'></image>
     <label pos='104,8'>%{name}</label>
@@ -11,7 +11,7 @@
             color='#00000000'
             hover-color='#FFFFFF2B'
             padding='0'
-            onclick='core.delete_world("%{name}")'>
+            onclick='app.delete_world("%{name}")'>
         <image src='gui/delete_icon' size='32,32' color='#FFFFFF50'/>
     </button>
     <label color='%{versionColor}' pos='317,44'>%{versionString}</label>

res/modules/internal/gui_util.lua

@@ -34,7 +34,7 @@ function gui_util.load_page(query)
     local filename = file.find(string.format("layouts/pages/%s.xml", name))
     if filename then
         name = file.prefix(filename)..":pages/"..name
-        gui.load_document(filename, name, args)
+        gui.load_document(filename, name, args, { app = __vc_app })
         return name
     end
 end
@@ -52,19 +52,21 @@ end
 
 -- class designed for simple UI-nodes access via properties syntax
 local Element = {}
+local __gui_getattr = gui.getattr
+local __gui_setattr = gui.setattr
 function Element.new(docname, name)
     return setmetatable({docname=docname, name=name}, {
         __index=function(self, k)
-            return gui.getattr(self.docname, self.name, k)
+            return __gui_getattr(self.docname, self.name, k)
         end,
         __newindex=function(self, k, v)
-            gui.setattr(self.docname, self.name, k, v)
+            __gui_setattr(self.docname, self.name, k, v)
         end,
         __ipairs=function(self)
             local i = 0
             return function()
                 i = i + 1
-                local elem = gui.getattr(self.docname, self.name, i)
+                local elem = __gui_getattr(self.docname, self.name, i)
                 if elem == nil then
                     return
                 end
@@ -161,7 +163,7 @@ function gui.show_input_dialog(text, actual_callback, validator, confirm_text)
         callback=callback,
         validator=validator or function() return #text > 0 end
     })
-    input.add_callback("key:escape", callback, gui.root[id])
+    input.add_callback("key:escape", function() gui.root[id]:destruct() end, gui.root[id])
     input.add_callback("key:enter", callback, gui.root[id])
     gui.root[id.."_input"].focused = true
 end

res/scripts/hud.lua

@@ -29,7 +29,7 @@ local function configure_SSAO()
     end
     events.on("core:setting.graphics.ssao.set", update_ssao_quality)
 
-    update_ssao_quality(core.get_setting("graphics.ssao"))
+    update_ssao_quality(__vc_app.get_setting("graphics.ssao"))
 end
 
 local function update_hand()

res/scripts/stdlib.lua

@@ -1,4 +1,4 @@
-local enable_experimental = core.get_setting("debug.enable-experimental")
+local enable_experimental = __vc_app.get_setting("debug.enable-experimental")
 
 ------------------------------------------------
 ------ Extended kit of standard functions ------
@@ -24,36 +24,43 @@ function tb_frame_tostring(frame)
     return s
 end
 
-local core_set_setting = core.set_setting
+local __vc__app_script_coroutine
-function core.set_setting(name, value, ...)
-    core_set_setting(name, value, ...)
-    events.emit("core:setting."..name..".set", value)
-end
 
 local function complete_app_lib(app)
+    local __app_load_content = app.load_content
+    local __app_reset_content = app.reset_content
+    local __app_reconfig_packs = app.reconfig_packs
+    local __app_tick = coroutine.yield
+    local __app_set_setting = app.set_setting
+    local __app_quit = app.quit
+
     app.sleep = sleep
     app.script = __VC_SCRIPT_NAME
-    app.new_world = core.new_world
+
-    app.open_world = core.open_world
+    app.set_setting = function(name, value, ...)
-    app.save_world = core.save_world
+        __app_set_setting(name, value, ...)
-    app.close_world = core.close_world
+        events.emit("core:setting."..name..".set", value)
-    app.reopen_world = core.reopen_world
-    app.delete_world = core.delete_world
-    app.reconfig_packs = core.reconfig_packs
-    app.get_setting = core.get_setting
-    app.set_setting = core.set_setting
-    app.tick = function()
-        coroutine.yield()
     end
-    app.get_version = core.get_version
+    app.tick = __app_tick
-    app.get_setting_info = core.get_setting_info
+
-    app.load_content = function()
+    local function call_in_app_script_co(func, ...)
-        core.load_content()
+        local running = coroutine.running()
-        app.tick()
+        if not running or running ~= __vc__app_script_coroutine then
+            error("content must be reload in application script coroutine")
+        end
+        func(...)
+        __app_tick()
+    end
+
+    app.reconfig_packs = function(...)
+        call_in_app_script_co(__app_reconfig_packs, ...)
+    end
+    app.load_content = function(...)
+        call_in_app_script_co(__app_load_content, ...)
+    end
+    app.reset_content = function(...)
+        call_in_app_script_co(__app_reset_content, ...)
     end
-    app.reset_content = core.reset_content
-    app.is_content_loaded = core.is_content_loaded
-    app.set_title = core.set_title
 
     function app.config_packs(packs_list)
         -- Check if packs are valid and add dependencies to the configuration
@@ -75,15 +82,16 @@ local function complete_app_lib(app)
         app.reconfig_packs(toadd, toremove)
     end
 
-    function app.quit()
+    function app.quit(silent)
-        local tb = debug.get_traceback(1)
+        if not silent then
-        local s = "app.quit() traceback:"
+            local tb = debug.get_traceback(1)
-        for i, frame in ipairs(tb) do
+            local s = "app.quit() traceback:"
-            s = s .. "\n\t"..tb_frame_tostring(frame)
+            for i, frame in ipairs(tb) do
+                s = s .. "\n\t"..tb_frame_tostring(frame)
+            end
+            debug.log(s)
         end
-        debug.log(s)
+        __app_quit()
-        core.quit()
-        coroutine.yield()
     end
 
     function app.sleep_until(predicate, max_ticks, max_time)
@@ -123,6 +131,66 @@ function pack.unload(prefix)
     events.remove_by_prefix(prefix)
 end
 
+local __vc_coroutines = {}
+local __vc_named_coroutines = {}
+local __vc_next_coroutine = 1
+
+function __vc_start_coroutine(chunk)
+    local co = coroutine.create(chunk)
+    local id = __vc_next_coroutine
+    __vc_next_coroutine = __vc_next_coroutine + 1
+    __vc_coroutines[id] = co
+    return id
+end
+
+function __vc_resume_coroutine(id)
+    local co = __vc_coroutines[id]
+    if co then
+        local success, err = coroutine.resume(co)
+        if not success then
+            debug.error(err)
+            error(err)
+        end
+        return coroutine.status(co) ~= "dead"
+    end
+    return false
+end
+
+function __vc_stop_coroutine(id)
+    local co = __vc_coroutines[id]
+    if co then
+        if coroutine.close then
+            coroutine.close(co)
+        end
+        __vc_coroutines[id] = nil
+    end
+end
+
+function start_coroutine(chunk, name)
+    local co = coroutine.create(function()
+        local status, error = xpcall(chunk, function(err)
+            local fullmsg = "error: "..string.match(err, ": (.+)").."\n"..debug.traceback()
+            
+            if hud then
+                gui.alert(fullmsg, function()
+                    if world.is_open() then
+                        __vc_app.close_world()
+                    else
+                        __vc_app.reset_content()
+                        menu:reset()
+                        menu.page = "main"
+                    end
+                end)
+            end
+            return fullmsg
+        end)
+        if not status then
+            debug.error(error)
+        end
+    end)
+    __vc_named_coroutines[name] = co
+end
+
 function __vc_start_app_script(path, name)
     debug.log("starting application script "..path)
 
@@ -134,9 +202,13 @@ function __vc_start_app_script(path, name)
     local script_env = setmetatable({app = app or __vc_app}, {__index=_G})
     chunk = setfenv(chunk, script_env)
     if name then
-        return start_coroutine(chunk, name)
+        start_coroutine(chunk, name)
+        __vc__app_script_coroutine = __vc_named_coroutines[name]
+        return
     else
-        return __vc_start_coroutine(chunk)
+        local id = __vc_start_coroutine(chunk)
+        __vc__app_script_coroutine = __vc_coroutines[id]
+        return id
     end
 end
 
@@ -435,66 +507,6 @@ function __vc_on_world_quit()
     file.__close_all_descriptors()
 end
 
-local __vc_coroutines = {}
-local __vc_named_coroutines = {}
-local __vc_next_coroutine = 1
-
-function __vc_start_coroutine(chunk)
-    local co = coroutine.create(chunk)
-    local id = __vc_next_coroutine
-    __vc_next_coroutine = __vc_next_coroutine + 1
-    __vc_coroutines[id] = co
-    return id
-end
-
-function __vc_resume_coroutine(id)
-    local co = __vc_coroutines[id]
-    if co then
-        local success, err = coroutine.resume(co)
-        if not success then
-            debug.error(err)
-            error(err)
-        end
-        return coroutine.status(co) ~= "dead"
-    end
-    return false
-end
-
-function __vc_stop_coroutine(id)
-    local co = __vc_coroutines[id]
-    if co then
-        if coroutine.close then
-            coroutine.close(co)
-        end
-        __vc_coroutines[id] = nil
-    end
-end
-
-function start_coroutine(chunk, name)
-    local co = coroutine.create(function()
-        local status, error = xpcall(chunk, function(err)
-            local fullmsg = "error: "..string.match(err, ": (.+)").."\n"..debug.traceback()
-            
-            if hud then
-                gui.alert(fullmsg, function()
-                    if world.is_open() then
-                        __vc_app.close_world()
-                    else
-                        __vc_app.reset_content()
-                        menu:reset()
-                        menu.page = "main"
-                    end
-                end)
-            end
-            return fullmsg
-        end)
-        if not status then
-            debug.error(error)
-        end
-    end)
-    __vc_named_coroutines[name] = co
-end
-
 local __post_runnables = {}
 
 local fn_audio_reset_fetch_buffer = audio.__reset_fetch_buffer

src/engine/Engine.cpp

@@ -139,7 +139,8 @@ void Engine::initialize(CoreParameters coreParameters) {
     editor = std::make_unique<devtools::Editor>(*this);
     cmd = std::make_unique<cmd::CommandsInterpreter>();
 
-    if (project->permissions.has(Permissions::NETWORK)) {
+    if (project->permissions.has(Permissions::NETWORK) ||
+        !params.debugServerString.empty()) {
         network = network::Network::create(settings.network);
     }
 
@@ -177,7 +178,7 @@ void Engine::initialize(CoreParameters coreParameters) {
     scripting::initialize(this);
 
     if (!isHeadless()) {
-        gui->setPageLoader(scripting::create_page_loader());
+        gui->getMenu()->setPageLoader(scripting::create_page_loader());
     }
     keepAlive(settings.ui.language.observe([this](auto lang) {
         langs::setup(lang, paths->resPaths.collectRoots());

src/graphics/ui/GUI.cpp

@@ -67,15 +67,6 @@ GUI::GUI(Engine& engine)
 
 GUI::~GUI() = default;
 
-void GUI::setPageLoader(PageLoaderFunc pageLoader) {
-    this->pagesLoader = std::move(pageLoader);
-    menu->setPageLoader(this->pagesLoader);
-}
-
-PageLoaderFunc GUI::getPagesLoader() {
-    return pagesLoader;
-}
-
 std::shared_ptr<Menu> GUI::getMenu() {
     return menu;
 }

src/graphics/ui/GUI.hpp

@@ -62,8 +62,6 @@ namespace gui {
     class Container;
     class Menu;
 
-    using PageLoaderFunc = std::function<std::shared_ptr<UINode>(const std::string&)>;
-
     /// @brief The main UI controller
     class GUI {
         Engine& engine;
@@ -83,8 +81,6 @@ namespace gui {
         std::queue<runnable> postRunnables;
         std::vector<std::weak_ptr<UINode>> mouseOver;
 
-        PageLoaderFunc pagesLoader;
-
         float tooltipTimer = 0.0f;
         float doubleClickTimer = 0.0f;
         float doubleClickDelay = 0.5f;
@@ -101,10 +97,6 @@ namespace gui {
         GUI(Engine& engine);
         ~GUI();
 
-        void setPageLoader(PageLoaderFunc pageLoader);
-        
-        PageLoaderFunc getPagesLoader();
-
         /// @brief Get the main menu (Menu) node
         std::shared_ptr<Menu> getMenu();
 

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

@@ -1,18 +1,338 @@
 #include "api_lua.hpp"
 
-#include "io/io.hpp"
-#include "io/devices/MemoryDevice.hpp"
-#include "logic/scripting/scripting.hpp"
 #include "content/ContentControl.hpp"
+#include "devtools/Project.hpp"
 #include "engine/Engine.hpp"
 #include "engine/EnginePaths.hpp"
-#include "devtools/Project.hpp"
+#include "frontend/locale.hpp"
+#include "graphics/ui/elements/Menu.hpp"
+#include "graphics/ui/gui_util.hpp"
+#include "graphics/ui/GUI.hpp"
+#include "io/devices/MemoryDevice.hpp"
+#include "io/io.hpp"
+#include "io/settings_io.hpp"
+#include "logic/EngineController.hpp"
+#include "logic/LevelController.hpp"
+#include "logic/scripting/scripting.hpp"
 #include "network/Network.hpp"
 #include "util/platform.hpp"
+#include "util/stringutil.hpp"
 #include "window/Window.hpp"
+#include "world/Level.hpp"
 
 using namespace scripting;
 
+/// @brief Check if content is loaded
+static int l_is_content_loaded(lua::State* L) {
+    return lua::pushboolean(L, content != nullptr);
+}
+
+/// @brief Load content
+static int l_load_content(lua::State* L) {
+    content_control->loadContent();
+    return 0;
+}
+
+/// @brief Reset content, excluding specified packs modules
+static int l_reset_content(lua::State* L) {
+    if (level != nullptr) {
+        throw std::runtime_error("world must be closed before");
+    }
+    std::vector<std::string> nonResetPacks;
+    if (lua::istable(L, 1)) {
+        int len = lua::objlen(L, 1);
+        for (int i = 0; i < len; i++) {
+            lua::rawgeti(L, i + 1, 1);
+            nonResetPacks.emplace_back(lua::require_lstring(L, -1));
+            lua::pop(L);
+        }
+    }
+    content_control->resetContent(std::move(nonResetPacks));
+    return 0;
+}
+
+/// @brief Reconfigure packs
+/// @param addPacks An array of packs to add
+/// @param remPacks An array of packs to remove
+static int l_reconfig_packs(lua::State* L) {
+    if (!lua::istable(L, 1)) {
+        throw std::runtime_error("strings array expected as the first argument");
+    }
+    if (!lua::istable(L, 2)) {
+        throw std::runtime_error("strings array expected as the second argument");
+    }
+    std::vector<std::string> addPacks;
+    int addLen = lua::objlen(L, 1);
+    for (int i = 0; i < addLen; i++) {
+        lua::rawgeti(L, i + 1, 1);
+        addPacks.emplace_back(lua::require_lstring(L, -1));
+        lua::pop(L);
+    }
+    std::vector<std::string> remPacks;
+    int remLen = lua::objlen(L, 2);
+    for (int i = 0; i < remLen; i++) {
+        lua::rawgeti(L, i + 1, 2);
+        remPacks.emplace_back(lua::require_lstring(L, -1));
+        lua::pop(L);
+    }
+    auto engineController = engine->getController();
+    try {
+        engineController->reconfigPacks(controller, addPacks, remPacks);
+    } catch (const contentpack_error& err) {
+        throw std::runtime_error(
+            std::string(err.what()) + " [" + err.getPackId() + " ]"
+        );
+    }
+    return 0;
+}
+
+/// @brief Get content sources list
+static int l_get_content_sources(lua::State* L) {
+    const auto& sources = engine->getContentControl().getContentSources();
+    lua::createtable(L, static_cast<int>(sources.size()), 0);
+    for (size_t i = 0; i < sources.size(); i++) {
+        lua::pushlstring(L, sources[i].string());
+        lua::rawseti(L, static_cast<int>(i + 1));
+    }
+    return 1;
+}
+
+/// @brief Set content sources list
+static int l_set_content_sources(lua::State* L) {
+    if (!lua::istable(L, 1)) {
+        throw std::runtime_error("table expected as argument 1");
+    }
+    int len = lua::objlen(L, 1);
+    std::vector<io::path> sources;
+    for (int i = 0; i < len; i++) {
+        lua::rawgeti(L, i + 1);
+        sources.emplace_back(std::string(lua::require_lstring(L, -1)));
+        lua::pop(L);
+    }
+    engine->getContentControl().setContentSources(std::move(sources));
+    return 0;
+}
+
+/// @brief Reset content sources to defaults
+static int l_reset_content_sources(lua::State* L) {
+    engine->getContentControl().resetContentSources();
+    return 0;
+}
+
+/// @brief Get a setting value
+/// @param name The name of the setting
+/// @return The value of the setting
+static int l_get_setting(lua::State* L) {
+    auto name = lua::require_string(L, 1);
+    const auto value = engine->getSettingsHandler().getValue(name);
+    return lua::pushvalue(L, value);
+}
+
+/// @brief Set a setting value
+/// @param name The name of the setting
+/// @param value The new value for the setting
+static int l_set_setting(lua::State* L) {
+    auto name = lua::require_string(L, 1);
+    const auto value = lua::tovalue(L, 2);
+    engine->getSettingsHandler().setValue(name, value);
+    return 0;
+}
+
+/// @brief Convert a setting value to a string
+/// @param name The name of the setting
+/// @return The string representation of the setting value
+static int l_str_setting(lua::State* L) {
+    auto name = lua::require_string(L, 1);
+    const auto string = engine->getSettingsHandler().toString(name);
+    return lua::pushstring(L, string);
+}
+
+/// @brief Get information about a setting
+/// @param name The name of the setting
+/// @return A table with information about the setting
+static int l_get_setting_info(lua::State* L) {
+    auto name = lua::require_string(L, 1);
+    auto setting = engine->getSettingsHandler().getSetting(name);
+    lua::createtable(L, 0, 1);
+    if (auto number = dynamic_cast<NumberSetting*>(setting)) {
+        lua::pushnumber(L, number->getMin());
+        lua::setfield(L, "min");
+        lua::pushnumber(L, number->getMax());
+        lua::setfield(L, "max");
+        lua::pushnumber(L, number->getDefault());
+        lua::setfield(L, "def");
+        return 1;
+    }
+    if (auto integer = dynamic_cast<IntegerSetting*>(setting)) {
+        lua::pushinteger(L, integer->getMin());
+        lua::setfield(L, "min");
+        lua::pushinteger(L, integer->getMax());
+        lua::setfield(L, "max");
+        lua::pushinteger(L, integer->getDefault());
+        lua::setfield(L, "def");
+        return 1;
+    }
+    if (auto boolean = dynamic_cast<FlagSetting*>(setting)) {
+        lua::pushboolean(L, boolean->getDefault());
+        lua::setfield(L, "def");
+        return 1;
+    }
+    if (auto string = dynamic_cast<StringSetting*>(setting)) {
+        lua::pushstring(L, string->getDefault());
+        lua::setfield(L, "def");
+        return 1;
+    }
+    lua::pop(L);
+    throw std::runtime_error("unsupported setting type");
+}
+
+/// @brief Open folder in file explorer
+static int l_open_folder(lua::State* L) {
+    platform::open_folder(io::resolve(lua::require_string(L, 1)));
+    return 0;
+}
+
+/// @brief Open URL in default browser with confirmation dialog
+static int l_open_url(lua::State* L) {
+    auto url = lua::require_string(L, 1);
+
+    std::wstring msg = langs::get(L"Are you sure you want to open the link:") +
+                       L"\n" + util::str2wstr_utf8(url) +
+                       std::wstring(L"?");
+
+    auto menu = engine->getGUI().getMenu();
+
+    guiutil::confirm(*engine, msg, [url, menu]() {
+        platform::open_url(url);
+        if (!menu->back()) {
+            menu->reset();
+        }
+    });
+    return 0;
+}
+
+
+/// @brief Bring application window to focus
+static int l_focus(lua::State* L) {
+    engine->getWindow().focus();
+    return 0;
+}
+
+/// @brief Set window title 
+static int l_set_title(lua::State* L) {
+    auto title = lua::require_string(L, 1);
+    engine->getWindow().setTitle(title);
+    return 0;
+}
+
+/// @brief Quit the game
+static int l_quit(lua::State*) {
+    engine->quit();
+    return 0;
+}
+
+/// @brief Creating new world
+/// @param name Name world
+/// @param seed Seed world
+/// @param generator Type of generation
+static int l_new_world(lua::State* L) {
+    auto name = lua::require_string(L, 1);
+    auto seed = lua::require_string(L, 2);
+    auto generator = lua::require_string(L, 3);
+    int64_t localPlayer = 0;
+    if (lua::gettop(L) >= 4) {
+        localPlayer = lua::tointeger(L, 4);
+    }
+    if (level != nullptr) {
+        throw std::runtime_error("world must be closed before");
+    }
+    auto controller = engine->getController();
+    controller->setLocalPlayer(localPlayer);
+    controller->createWorld(name, seed, generator);
+    return 0;
+}
+
+/// @brief Open world
+/// @param name Name world
+static int l_open_world(lua::State* L) {
+    auto name = lua::require_string(L, 1);
+    if (level != nullptr) {
+        throw std::runtime_error("world must be closed before");
+    }
+    auto controller = engine->getController();
+    controller->setLocalPlayer(0);
+    controller->openWorld(name, false);
+    return 0;
+}
+
+/// @brief Reopen world
+static int l_reopen_world(lua::State*) {
+    auto controller = engine->getController();
+    if (level == nullptr) {
+        throw std::runtime_error("no world open");
+    }
+    controller->reopenWorld(level->getWorld());
+    return 0;
+}
+
+/// @brief Save world
+static int l_save_world(lua::State* L) {
+    if (controller == nullptr) {
+        throw std::runtime_error("no world open");
+    }
+    controller->saveWorld();
+    return 0;
+}
+
+/// @brief Close world
+/// @param flag Save world (bool)
+static int l_close_world(lua::State* L) {
+    if (controller == nullptr) {
+        throw std::runtime_error("no world open");
+    }
+    controller->processBeforeQuit();
+    bool save_world = lua::toboolean(L, 1);
+    if (save_world) {
+        controller->saveWorld();
+    }
+    engine->onWorldClosed();
+    return 0;
+}
+
+/// @brief Delete world
+/// @param name Name world
+static int l_delete_world(lua::State* L) {
+    auto name = lua::require_string(L, 1);
+    auto controller = engine->getController();
+    controller->deleteWorld(name);
+    return 0;
+}
+
+/// @brief Get engine version
+/// @return major, minor 
+static int l_get_version(lua::State* L) {
+    return lua::pushvec_stack(
+        L, glm::vec2(ENGINE_VERSION_MAJOR, ENGINE_VERSION_MINOR)
+    );
+}
+
+/// @brief Create in-memory named IO device
+static int l_create_memory_device(lua::State* L) {
+    std::string name = lua::require_string(L, 1);
+    if (io::get_device(name)) {
+        throw std::runtime_error(
+            "entry-point '" + name + "' is already used"
+        );
+    }
+    if (name.find(':') != std::string::npos) {
+        throw std::runtime_error("invalid entry point name");
+    }
+    
+    io::set_device(name, std::make_unique<io::MemoryDevice>());
+    return 0;
+}
+
+/// @brief Start a new engine instance with debugging server
 static int l_start_debug_instance(lua::State* L) {
     if (!engine->getProject().permissions.has(Permissions::DEBUGGING)) {
         throw std::runtime_error("project has no debugging permission");
@@ -29,6 +349,7 @@ static int l_start_debug_instance(lua::State* L) {
             throw std::runtime_error("could not find free port");
         }
     }
+    auto projectPath = lua::isstring(L, 2) ? lua::require_lstring(L, 2) : "";
     const auto& paths = engine->getPaths();
 
     std::vector<std::string> args {
@@ -36,67 +357,46 @@ static int l_start_debug_instance(lua::State* L) {
         "--dir", paths.getUserFilesFolder().u8string(),
         "--dbg-server",  "tcp:" + std::to_string(port),
     };
+    if (!projectPath.empty()) {
+        args.emplace_back("--project");
+        args.emplace_back(io::resolve(std::string(projectPath)).string());
+    }
+
     platform::new_engine_instance(std::move(args));
     return lua::pushinteger(L, port);
 }
 
-static int l_focus(lua::State* L) {
-    engine->getWindow().focus();
-    return 0;
-}
-
-static int l_create_memory_device(lua::State* L) {
-    std::string name = lua::require_string(L, 1);
-    if (io::get_device(name)) {
-        throw std::runtime_error(
-            "entry-point '" + name + "' is already used"
-        );
-    }
-    if (name.find(':') != std::string::npos) {
-        throw std::runtime_error("invalid entry point name");
-    }
-    
-    io::set_device(name, std::make_unique<io::MemoryDevice>());
-    return 0;
-}
-
-static int l_get_content_sources(lua::State* L) {
-    const auto& sources = engine->getContentControl().getContentSources();
-    lua::createtable(L, static_cast<int>(sources.size()), 0);
-    for (size_t i = 0; i < sources.size(); i++) {
-        lua::pushlstring(L, sources[i].string());
-        lua::rawseti(L, static_cast<int>(i + 1));
-    }
-    return 1;
-}
-
-static int l_set_content_sources(lua::State* L) {
-    if (!lua::istable(L, 1)) {
-        throw std::runtime_error("table expected as argument 1");
-    }
-    int len = lua::objlen(L, 1);
-    std::vector<io::path> sources;
-    for (int i = 0; i < len; i++) {
-        lua::rawgeti(L, i + 1);
-        sources.emplace_back(std::string(lua::require_lstring(L, -1)));
-        lua::pop(L);
-    }
-    engine->getContentControl().setContentSources(std::move(sources));
-    return 0;
-}
-
-static int l_reset_content_sources(lua::State* L) {
-    engine->getContentControl().resetContentSources();
-    return 0;
-}
-
 const luaL_Reg applib[] = {
-    {"start_debug_instance", lua::wrap<l_start_debug_instance>},
+    /// content
-    {"focus", lua::wrap<l_focus>},
+    {"is_content_loaded", lua::wrap<l_is_content_loaded>},
-    {"create_memory_device", lua::wrap<l_create_memory_device>},
+    {"load_content", lua::wrap<l_load_content>},
+    {"reset_content", lua::wrap<l_reset_content>},
+    {"reconfig_packs", lua::wrap<l_reconfig_packs>},
     {"get_content_sources", lua::wrap<l_get_content_sources>},
     {"set_content_sources", lua::wrap<l_set_content_sources>},
     {"reset_content_sources", lua::wrap<l_reset_content_sources>},
-    // for other functions see libcore.cpp and stdlib.lua
+    /// settings
+    {"get_setting", lua::wrap<l_get_setting>},
+    {"set_setting", lua::wrap<l_set_setting>},
+    {"str_setting", lua::wrap<l_str_setting>},
+    {"get_setting_info", lua::wrap<l_get_setting_info>},
+    /// system applications
+    {"open_folder", lua::wrap<l_open_folder>},
+    {"open_url", lua::wrap<l_open_url>},
+    /// window
+    {"focus", lua::wrap<l_focus>},
+    {"set_title", lua::wrap<l_set_title>},
+    {"quit", lua::wrap<l_quit>},
+    /// world
+    {"new_world", lua::wrap<l_new_world>},
+    {"open_world", lua::wrap<l_open_world>},
+    {"reopen_world", lua::wrap<l_reopen_world>},
+    {"save_world", lua::wrap<l_save_world>},
+    {"close_world", lua::wrap<l_close_world>},
+    {"delete_world", lua::wrap<l_delete_world>},
+    /// other
+    {"get_version", lua::wrap<l_get_version>},
+    {"create_memory_device", lua::wrap<l_create_memory_device>},
+    {"start_debug_instance", lua::wrap<l_start_debug_instance>},
     {nullptr, nullptr}
 };

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

@@ -1,274 +1,9 @@
-#include <memory>
+#include "api_lua.hpp"
-#include <vector>
+
 #include <sstream>
 
-#include "api_lua.hpp"
-#include "constants.hpp"
-#include "assets/Assets.hpp"
-#include "content/Content.hpp"
-#include "content/ContentControl.hpp"
-#include "engine/Engine.hpp"
-#include "engine/EnginePaths.hpp"
-#include "io/io.hpp"
-#include "io/settings_io.hpp"
-#include "frontend/menu.hpp"
-#include "frontend/screens/MenuScreen.hpp"
-#include "graphics/core/Texture.hpp"
-#include "logic/EngineController.hpp"
-#include "logic/LevelController.hpp"
-#include "util/listutil.hpp"
-#include "util/platform.hpp"
-#include "world/Level.hpp"
-#include "world/generator/WorldGenerator.hpp"
-#include "util/platform.hpp"
-#include "frontend/locale.hpp"
-#include "graphics/ui/gui_util.hpp"
-#include "graphics/ui/GUI.hpp"
-#include "graphics/ui/elements/Menu.hpp"
-#include "window/Window.hpp"
-
 using namespace scripting;
 
-static int l_get_version(lua::State* L) {
-    return lua::pushvec_stack(
-        L, glm::vec2(ENGINE_VERSION_MAJOR, ENGINE_VERSION_MINOR)
-    );
-}
-
-static int l_load_content(lua::State* L) {
-    content_control->loadContent();
-    return 0;
-}
-
-static int l_reset_content(lua::State* L) {
-    if (level != nullptr) {
-        throw std::runtime_error("world must be closed before");
-    }
-    std::vector<std::string> nonResetPacks;
-    if (lua::istable(L, 1)) {
-        int len = lua::objlen(L, 1);
-        for (int i = 0; i < len; i++) {
-            lua::rawgeti(L, i + 1, 1);
-            nonResetPacks.emplace_back(lua::require_lstring(L, -1));
-            lua::pop(L);
-        }
-    }
-    content_control->resetContent(std::move(nonResetPacks));
-    return 0;
-}
-
-static int l_is_content_loaded(lua::State* L) {
-    return lua::pushboolean(L, content != nullptr);
-}
-
-/// @brief Creating new world
-/// @param name Name world
-/// @param seed Seed world
-/// @param generator Type of generation
-static int l_new_world(lua::State* L) {
-    auto name = lua::require_string(L, 1);
-    auto seed = lua::require_string(L, 2);
-    auto generator = lua::require_string(L, 3);
-    int64_t localPlayer = 0;
-    if (lua::gettop(L) >= 4) {
-        localPlayer = lua::tointeger(L, 4);
-    }
-    if (level != nullptr) {
-        throw std::runtime_error("world must be closed before");
-    }
-    auto controller = engine->getController();
-    controller->setLocalPlayer(localPlayer);
-    controller->createWorld(name, seed, generator);
-    return 0;
-}
-
-/// @brief Open world
-/// @param name Name world
-static int l_open_world(lua::State* L) {
-    auto name = lua::require_string(L, 1);
-    if (level != nullptr) {
-        throw std::runtime_error("world must be closed before");
-    }
-    auto controller = engine->getController();
-    controller->setLocalPlayer(0);
-    controller->openWorld(name, false);
-    return 0;
-}
-
-/// @brief Reopen world
-static int l_reopen_world(lua::State*) {
-    auto controller = engine->getController();
-    if (level == nullptr) {
-        throw std::runtime_error("no world open");
-    }
-    controller->reopenWorld(level->getWorld());
-    return 0;
-}
-
-/// @brief Save world
-static int l_save_world(lua::State* L) {
-    if (controller == nullptr) {
-        throw std::runtime_error("no world open");
-    }
-    controller->saveWorld();
-    return 0;
-}
-
-/// @brief Close world
-/// @param flag Save world (bool)
-static int l_close_world(lua::State* L) {
-    if (controller == nullptr) {
-        throw std::runtime_error("no world open");
-    }
-    controller->processBeforeQuit();
-    bool save_world = lua::toboolean(L, 1);
-    if (save_world) {
-        controller->saveWorld();
-    }
-    engine->onWorldClosed();
-    return 0;
-}
-
-/// @brief Delete world
-/// @param name Name world
-static int l_delete_world(lua::State* L) {
-    auto name = lua::require_string(L, 1);
-    auto controller = engine->getController();
-    controller->deleteWorld(name);
-    return 0;
-}
-
-/// @brief Reconfigure packs
-/// @param addPacks An array of packs to add
-/// @param remPacks An array of packs to remove
-static int l_reconfig_packs(lua::State* L) {
-    if (!lua::istable(L, 1)) {
-        throw std::runtime_error("strings array expected as the first argument");
-    }
-    if (!lua::istable(L, 2)) {
-        throw std::runtime_error("strings array expected as the second argument");
-    }
-    std::vector<std::string> addPacks;
-    int addLen = lua::objlen(L, 1);
-    for (int i = 0; i < addLen; i++) {
-        lua::rawgeti(L, i + 1, 1);
-        addPacks.emplace_back(lua::require_lstring(L, -1));
-        lua::pop(L);
-    }
-    std::vector<std::string> remPacks;
-    int remLen = lua::objlen(L, 2);
-    for (int i = 0; i < remLen; i++) {
-        lua::rawgeti(L, i + 1, 2);
-        remPacks.emplace_back(lua::require_lstring(L, -1));
-        lua::pop(L);
-    }
-    auto engineController = engine->getController();
-    try {
-        engineController->reconfigPacks(controller, addPacks, remPacks);
-    } catch (const contentpack_error& err) {
-        throw std::runtime_error(
-            std::string(err.what()) + " [" + err.getPackId() + " ]"
-        );
-    }
-    return 0;
-}
-
-/// @brief Get a setting value
-/// @param name The name of the setting
-/// @return The value of the setting
-static int l_get_setting(lua::State* L) {
-    auto name = lua::require_string(L, 1);
-    const auto value = engine->getSettingsHandler().getValue(name);
-    return lua::pushvalue(L, value);
-}
-
-/// @brief Set a setting value
-/// @param name The name of the setting
-/// @param value The new value for the setting
-static int l_set_setting(lua::State* L) {
-    auto name = lua::require_string(L, 1);
-    const auto value = lua::tovalue(L, 2);
-    engine->getSettingsHandler().setValue(name, value);
-    return 0;
-}
-
-/// @brief Convert a setting value to a string
-/// @param name The name of the setting
-/// @return The string representation of the setting value
-static int l_str_setting(lua::State* L) {
-    auto name = lua::require_string(L, 1);
-    const auto string = engine->getSettingsHandler().toString(name);
-    return lua::pushstring(L, string);
-}
-
-/// @brief Get information about a setting
-/// @param name The name of the setting
-/// @return A table with information about the setting
-static int l_get_setting_info(lua::State* L) {
-    auto name = lua::require_string(L, 1);
-    auto setting = engine->getSettingsHandler().getSetting(name);
-    lua::createtable(L, 0, 1);
-    if (auto number = dynamic_cast<NumberSetting*>(setting)) {
-        lua::pushnumber(L, number->getMin());
-        lua::setfield(L, "min");
-        lua::pushnumber(L, number->getMax());
-        lua::setfield(L, "max");
-        lua::pushnumber(L, number->getDefault());
-        lua::setfield(L, "def");
-        return 1;
-    }
-    if (auto integer = dynamic_cast<IntegerSetting*>(setting)) {
-        lua::pushinteger(L, integer->getMin());
-        lua::setfield(L, "min");
-        lua::pushinteger(L, integer->getMax());
-        lua::setfield(L, "max");
-        lua::pushinteger(L, integer->getDefault());
-        lua::setfield(L, "def");
-        return 1;
-    }
-    if (auto boolean = dynamic_cast<FlagSetting*>(setting)) {
-        lua::pushboolean(L, boolean->getDefault());
-        lua::setfield(L, "def");
-        return 1;
-    }
-    if (auto string = dynamic_cast<StringSetting*>(setting)) {
-        lua::pushstring(L, string->getDefault());
-        lua::setfield(L, "def");
-        return 1;
-    }
-    lua::pop(L);
-    throw std::runtime_error("unsupported setting type");
-}
-
-static int l_open_folder(lua::State* L) {
-    platform::open_folder(io::resolve(lua::require_string(L, 1)));
-    return 0;
-}
-
-static int l_open_url(lua::State* L) {
-    auto url = lua::require_string(L, 1);
-
-    std::wstring msg = langs::get(L"Are you sure you want to open the link:") +
-                       L"\n" + util::str2wstr_utf8(url) +
-                       std::wstring(L"?");
-
-    auto menu = engine->getGUI().getMenu();
-
-    guiutil::confirm(*engine, msg, [url, menu]() {
-        platform::open_url(url);
-        if (!menu->back()) {
-            menu->reset();
-        }
-    });
-    return 0;
-}
-
-/// @brief Quit the game
-static int l_quit(lua::State*) {
-    engine->quit();
-    return 0;
-}
-
 static int l_blank(lua::State*) {
     return 0;
 }
@@ -300,33 +35,8 @@ static int l_capture_output(lua::State* L) {
     return 1;
 }
 
-static int l_set_title(lua::State* L) {
-    auto title = lua::require_string(L, 1);
-    engine->getWindow().setTitle(title);
-    return 0;
-}
-
 const luaL_Reg corelib[] = {
     {"blank", lua::wrap<l_blank>},
-    {"get_version", lua::wrap<l_get_version>},
-    {"load_content", lua::wrap<l_load_content>},
-    {"reset_content", lua::wrap<l_reset_content>},
-    {"is_content_loaded", lua::wrap<l_is_content_loaded>},
-    {"new_world", lua::wrap<l_new_world>},
-    {"open_world", lua::wrap<l_open_world>},
-    {"reopen_world", lua::wrap<l_reopen_world>},
-    {"save_world", lua::wrap<l_save_world>},
-    {"close_world", lua::wrap<l_close_world>},
-    {"delete_world", lua::wrap<l_delete_world>},
-    {"reconfig_packs", lua::wrap<l_reconfig_packs>},
-    {"get_setting", lua::wrap<l_get_setting>},
-    {"set_setting", lua::wrap<l_set_setting>},
-    {"str_setting", lua::wrap<l_str_setting>},
-    {"get_setting_info", lua::wrap<l_get_setting_info>},
-    {"open_folder", lua::wrap<l_open_folder>},
-    {"open_url", lua::wrap<l_open_url>},
-    {"quit", lua::wrap<l_quit>},
     {"capture_output", lua::wrap<l_capture_output>},
-    {"set_title", lua::wrap<l_set_title>},
     {nullptr, nullptr}
 };

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

@@ -1111,6 +1111,16 @@ static int l_gui_load_document(lua::State* L) {
     );
     auto document = documentPtr.get();
     engine->getAssets()->store(std::move(documentPtr), alias);
+
+    // namespace extension
+    if (lua::istable(L, 4)) {
+        if (lua::get_from(L, "table", "merge")) {
+            lua::pushenv(L, *document->getEnvironment());
+            lua::pushvalue(L, 4);
+            lua::call(L, 2, 0);
+            lua::pop(L);
+        }
+    }
     scripting::on_ui_open(document, {args});
     return 0;
 }

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

@@ -2,6 +2,7 @@
 #include "coders/json.hpp"
 #include "engine/Engine.hpp"
 #include "network/Network.hpp"
+#include "devtools/Project.hpp"
 
 #include <variant>
 #include <utility>
@@ -439,7 +440,7 @@ static int l_is_nodelay(lua::State* L, network::Network& network) {
     return lua::pushboolean(L, false);
 }
 
-static int l_pull_events(lua::State* L, network::Network& network) {
+static int l_pull_events(lua::State* L) {
     std::vector<NetworkEvent> local_queue;
     {
         std::lock_guard lock(events_queue_mutex);
@@ -528,7 +529,8 @@ int wrap(lua_State* L) {
     int result = 0;
     try {
         auto network = engine->getNetwork();
-        if (network == nullptr) {
+        const auto& permissions = engine->getProject().permissions;
+        if (network == nullptr || !permissions.has(Permissions::NETWORK)) {
             throw std::runtime_error(
                 "network subsystem is not available in the project"
             );
@@ -554,7 +556,7 @@ const luaL_Reg networklib[] = {
     {"get_total_download", wrap<l_get_total_download>},
     {"find_free_port", wrap<l_find_free_port>},
     {"is_available", lua::wrap<l_is_available>},
-    {"__pull_events", wrap<l_pull_events>},
+    {"__pull_events", lua::wrap<l_pull_events>},
     {"__open_tcp", wrap<l_open_tcp>},
     {"__open_udp", wrap<l_open_udp>},
     {"__closeserver", wrap<l_closeserver>},

src/logic/scripting/lua/lua_engine.cpp

@@ -66,6 +66,8 @@ static void create_libs(State* L, StateType stateType) {
 
     if (stateType == StateType::SCRIPT) {
         openlib(L, "app", applib);
+        lua::getglobal(L, "app");
+        lua::setglobal(L, "__vc_app");
     } else if (stateType == StateType::BASE) {
         openlib(L, "__vc_app", applib);
     }

src/util/platform.cpp

@@ -281,6 +281,7 @@ void platform::new_engine_instance(const std::vector<std::string>& args) {
     ss << " >/dev/null &";
     
     auto command = ss.str();
+    logger.info() << command;
     if (int res = system(command.c_str())) {
         throw std::runtime_error(
             "starting an engine instance failed with code: " +