voxelcoreprojects/voxelcore
1
0
Fork 0
mirror of https://github.com/MihailRis/voxelcore.git synced 2026-10-09 04:51:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

Merge pull request #837 from MihailRis/dev

Browse source 
move development to main
This commit is contained in:
MihailRis 2026-05-05 01:03:01 +03:00 • committed by GitHub
commit c4d5812b4f
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
46 changed files with 754 additions and 342 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/constants.hpp
View file

@ -6,7 +6,7 @@
#include <string>
inline constexpr int ENGINE_VERSION_MAJOR = 0;
inline constexpr int ENGINE_VERSION_MINOR = 31;
inline constexpr int ENGINE_VERSION_MINOR = 32;
#ifdef NDEBUG
inline constexpr bool ENGINE_DEBUG_BUILD = false;
@ -14,7 +14,7 @@ inline constexpr bool ENGINE_DEBUG_BUILD = false;
inline constexpr bool ENGINE_DEBUG_BUILD = true;
#endif // NDEBUG
inline const std::string ENGINE_VERSION_STRING = "0.31";
inline const std::string ENGINE_VERSION_STRING = "0.32";
/// @brief world regions format version
inline constexpr uint REGION_FORMAT_VERSION = 3;

20
src/content/ContentLoader.cpp
View file

@ -334,6 +334,8 @@ void ContentLoader::load() {
fixPackIndices();
loadContentScript(*runtime);
auto folder = pack->folder;
builder.defaults = paths.readCombinedObject(
@ -462,6 +464,20 @@ void ContentLoader::reloadScript(const Content& content, ItemDef& item) {
load_script(content, item);
}
void ContentLoader::loadContentScript(ContentPackRuntime& runtime) {
const auto& pack = runtime.getInfo();
const auto& folder = pack.folder;
io::path scriptFile = folder / "scripts/content.lua";
if (io::is_regular_file(scriptFile)) {
scripting::load_content_script(
runtime.getEnvironment(),
pack.id,
scriptFile,
pack.id + ":scripts/content.lua"
);
}
}
void ContentLoader::loadWorldScript(ContentPackRuntime& runtime) {
const auto& pack = runtime.getInfo();
const auto& folder = pack.folder;
@ -478,6 +494,7 @@ void ContentLoader::loadWorldScript(ContentPackRuntime& runtime) {
}
void ContentLoader::loadScripts(Content& content) {
scripting::on_scripts_loading();
load_scripts(content, content.blocks);
load_scripts(content, content.items);
@ -486,7 +503,6 @@ void ContentLoader::loadScripts(Content& content) {
const auto& pack = runtime->getInfo();
const auto& folder = pack.folder;
// Load main world script
loadWorldScript(*runtime);
// Load entity components
@ -501,6 +517,8 @@ void ContentLoader::loadScripts(Content& content) {
);
});
}
scripting::on_content_loaded();
}
void ContentLoader::loadResources(ResourceType type, const dv::value& list) {

1
src/content/ContentLoader.hpp
View file

@ -58,6 +58,7 @@ public:
void load();
static void loadScripts(Content& content);
static void loadContentScript(ContentPackRuntime& pack);
static void loadWorldScript(ContentPackRuntime& pack);
static void reloadScript(const Content& content, Block& block);
static void reloadScript(const Content& content, ItemDef& item);

161
src/content/ContentPack.cpp
View file

@ -47,10 +47,6 @@ io::path ContentPack::getContentFile() const {
return folder / CONTENT_FILENAME;
}
bool ContentPack::is_pack(const io::path& folder) {
return io::is_regular_file(folder / PACKAGE_FILENAME);
}
std::optional<ContentPackStats> ContentPack::loadStats() const {
auto contentFile = getContentFile();
if (!io::exists(contentFile)) {
@ -85,6 +81,9 @@ static void checkContentPackId(const std::string& id, const io::path& folder) {
);
}
}
if (id == "none") {
throw contentpack_error(id, folder, "content-pack id is not specified");
}
if (std::find(
ContentPack::RESERVED_NAMES.begin(),
ContentPack::RESERVED_NAMES.end(),
@ -94,10 +93,71 @@ static void checkContentPackId(const std::string& id, const io::path& folder) {
}
}
static DependencyPack parse_dependency(std::string depName) {
auto level = DependencyLevel::REQUIRED;
switch (depName.at(0)) {
case '!':
depName = depName.substr(1);
break;
case '?':
depName = depName.substr(1);
level = DependencyLevel::OPTIONAL;
break;
case '~':
depName = depName.substr(1);
level = DependencyLevel::WEAK;
break;
}
std::string depVer = "*";
std::string depVerOperator = "=";
size_t versionPos = depName.rfind("@");
if (versionPos != std::string::npos) {
depVer = depName.substr(versionPos + 1);
depName = depName.substr(0, versionPos);
if (depVer.size() >= 2) {
std::string op = depVer.substr(0, 2);
std::uint8_t op_size = 0;
// Two symbol operators
if (op == ">=" || op == "<=") {
op_size = 2;
depVerOperator = op;
}
// One symbol operators
else {
op = depVer.substr(0, 1);
if (op == ">" || op == "<") {
op_size = 1;
depVerOperator = op;
}
}
depVer = depVer.substr(op_size);
} else {
if (depVer == ">" || depVer == "<"){
depVer = "*";
}
}
}
VersionOperator versionOperator;
if (VersionOperatorMeta.getItem(depVerOperator, versionOperator)) {
return DependencyPack{level, depName, depVer, versionOperator};
} else {
throw std::runtime_error("invalid version operator");
}
}
ContentPack ContentPack::read(const io::path& folder) {
auto root = io::read_json(folder / PACKAGE_FILENAME);
ContentPack pack;
root.at("id").get(pack.id);
checkContentPackId(pack.id, folder);
root.at("title").get(pack.title);
root.at("version").get(pack.version);
if (root.has("creators")) {
@ -115,81 +175,26 @@ ContentPack ContentPack::read(const io::path& folder) {
root.at("source").get(pack.source);
pack.folder = folder;
auto dependenciesList = root.at("dependencies");
if (!dependenciesList) {
return pack;
}
if (auto found = root.at("dependencies")) {
const auto& dependencies = *found;
for (const auto& elem : dependencies) {
std::string depName = elem.asString();
auto level = DependencyLevel::REQUIRED;
switch (depName.at(0)) {
case '!':
depName = depName.substr(1);
break;
case '?':
depName = depName.substr(1);
level = DependencyLevel::OPTIONAL;
break;
case '~':
depName = depName.substr(1);
level = DependencyLevel::WEAK;
break;
}
std::string depVer = "*";
std::string depVerOperator = "=";
size_t versionPos = depName.rfind("@");
if (versionPos != std::string::npos) {
depVer = depName.substr(versionPos + 1);
depName = depName.substr(0, versionPos);
if (depVer.size() >= 2) {
std::string op = depVer.substr(0, 2);
std::uint8_t op_size = 0;
// Two symbol operators
if (op == ">=" || op == "<=") {
op_size = 2;
depVerOperator = op;
}
// One symbol operators
else {
op = depVer.substr(0, 1);
if (op == ">" || op == "<") {
op_size = 1;
depVerOperator = op;
}
}
depVer = depVer.substr(op_size);
} else {
if (depVer == ">" || depVer == "<"){
depVer = "*";
}
}
}
VersionOperator versionOperator;
if (VersionOperatorMeta.getItem(depVerOperator, versionOperator)) {
pack.dependencies.push_back(
{level, depName, depVer, versionOperator}
);
} else {
try {
pack.dependencies.push_back(parse_dependency(std::move(depName)));
} catch (const std::runtime_error& err) {
throw contentpack_error(
pack.id, folder, "invalid version operator"
pack.id,
folder,
"dependency parsing error: " + std::string(err.what())
);
}
}
}
if (pack.id == "none") {
throw contentpack_error(
pack.id, folder, "content-pack id is not specified"
);
}
checkContentPackId(pack.id, folder);
return pack;
}
@ -200,15 +205,21 @@ void ContentPack::scanFolder(
return;
}
for (const auto& packFolder : io::directory_iterator(folder)) {
if (!io::is_directory(packFolder)) continue;
if (!is_pack(packFolder)) continue;
if (!io::is_directory(packFolder)) {
continue;
}
auto packageFile = packFolder / PACKAGE_FILENAME;
if (!io::is_regular_file(packageFile)) {
continue;
}
try {
packs.push_back(read(packFolder));
} catch (const contentpack_error& err) {
std::cerr << "package.json error at " << err.getFolder().string();
std::cerr << ": " << err.what() << std::endl;
logger.warning() << "package.json error at "
<< err.getFolder().string() << ": " << err.what();
} catch (const std::runtime_error& err) {
std::cerr << err.what() << std::endl;
logger.error() << "reading " << packageFile.string()
<< " error: " << err.what();
}
}
}

11
src/content/ContentPack.hpp
View file

@ -85,7 +85,6 @@ struct ContentPack {
static inline const io::path GENERATORS_FOLDER = "generators";
static const std::vector<std::string> RESERVED_NAMES;
static bool is_pack(const io::path& folder);
static ContentPack read(const io::path& folder);
static void scanFolder(
@ -114,6 +113,14 @@ struct ContentPack {
default: return "";
}
}
static std::string_view getPrefix(std::string_view path) {
size_t pos = path.find(':');
if (pos == std::string::npos) {
return "";
}
return path.substr(0, pos);
}
};
struct WorldFuncsSet {
@ -127,6 +134,8 @@ struct WorldFuncsSet {
bool onchunkremove;
bool oninventoryopen;
bool oninventoryclosed;
bool onentityspawn;
bool onentitydespawn;
};
class ContentPackRuntime {

8
src/graphics/render/TextNote.cpp
View file

@ -10,6 +10,14 @@ void TextNote::setText(std::wstring_view text) {
this->text = text;
}
void TextNote::setEntity(entityid_t eid) {
this->entity = eid;
}
entityid_t TextNote::getEntity() const {
return entity;
}
const std::wstring& TextNote::getText() const {
return text;
}

4
src/graphics/render/TextNote.hpp
View file

@ -1,5 +1,6 @@
#pragma once
#include "constants.hpp"
#include "presets/NotePreset.hpp"
/// @brief 3D text instance
@ -7,6 +8,7 @@ class TextNote {
std::wstring text;
NotePreset preset;
glm::vec3 position;
entityid_t entity = ENTITY_NONE;
glm::vec3 xAxis {1, 0, 0};
glm::vec3 yAxis {0, 1, 0};
@ -14,6 +16,8 @@ public:
TextNote(std::wstring text, NotePreset preset, glm::vec3 position);
void setText(std::wstring_view text);
void setEntity(entityid_t eid);
entityid_t getEntity() const;
const std::wstring& getText() const;

17
src/graphics/render/TextsRenderer.cpp
View file

@ -10,12 +10,18 @@
#include "graphics/core/Shader.hpp"
#include "graphics/core/DrawContext.hpp"
#include "presets/NotePreset.hpp"
#include "world/Level.hpp"
#include "objects/Entities.hpp"
#include "objects/Entity.hpp"
#include "constants.hpp"
TextsRenderer::TextsRenderer(
Batch3D& batch, const Assets& assets, const Frustum& frustum
const Level& level,
Batch3D& batch,
const Assets& assets,
const Frustum& frustum
)
: batch(batch), assets(assets), frustum(frustum) {
: level(level), batch(batch), assets(assets), frustum(frustum) {
}
void TextsRenderer::renderNote(
@ -31,6 +37,13 @@ void TextsRenderer::renderNote(
const auto& preset = note.getPreset();
auto pos = note.getPosition();
entityid_t eid = note.getEntity();
if (eid != ENTITY_NONE) {
if (auto entity = level.entities->get(eid)) {
pos += entity->getTransform().displayPos;
}
}
if (util::distance2(pos, camera.position) >
util::sqr(preset.renderDistance / camera.zoom)) {
return;

9
src/graphics/render/TextsRenderer.hpp
View file

@ -12,8 +12,10 @@ class Batch3D;
class Frustum;
class TextNote;
struct EngineSettings;
class Level;
class TextsRenderer {
const Level& level;
Batch3D& batch;
const Assets& assets;
const Frustum& frustum;
@ -31,7 +33,12 @@ class TextsRenderer {
bool projected
);
public:
TextsRenderer(Batch3D& batch, const Assets& assets, const Frustum& frustum);
TextsRenderer(
const Level& level,
Batch3D& batch,
const Assets& assets,
const Frustum& frustum
);
void render(
const DrawContext& context,

6
src/graphics/render/WorldRenderer.cpp
View file

@ -91,9 +91,11 @@ WorldRenderer::WorldRenderer(
assets, level, *player.chunks, &engine.getSettings().graphics
)),
particles(std::make_unique<ParticlesRenderer>(
assets, level, *player.chunks, engine.getSettings().graphics
assets, level, *player.chunks, engine.getSettings().graphics
)),
texts(std::make_unique<TextsRenderer>(
level, *batch3d, assets, *frustumCulling
)),
texts(std::make_unique<TextsRenderer>(*batch3d, assets, *frustumCulling)),
blockWraps(std::make_unique<BlockWrapsRenderer>(
assets, level.content, *player.chunks
)) {

6
src/logic/scripting/lua/libs/libapp.cpp
View file

@ -350,6 +350,7 @@ static int l_start_debug_instance(lua::State* L) {
}
}
auto projectPath = lua::isstring(L, 2) ? lua::require_lstring(L, 2) : "";
auto outputPath = lua::isstring(L, 3) ? lua::require_lstring(L, 3) : "";
const auto& paths = engine->getPaths();
std::vector<std::string> args {
@ -362,7 +363,10 @@ static int l_start_debug_instance(lua::State* L) {
args.emplace_back(io::resolve(std::string(projectPath)).string());
}
platform::new_engine_instance(std::move(args));
platform::new_engine_instance(
std::move(args),
outputPath.empty() ? "" : io::resolve(std::string(outputPath))
);
return lua::pushinteger(L, port);
}

5
src/logic/scripting/lua/libs/libgui.cpp
View file

@ -1011,8 +1011,9 @@ static int l_gui_get_env(lua::State* L) {
"document '" + std::string(name) + "' not found"
);
}
lua::getglobal(L, lua::env_name(*doc->getEnvironment()));
return 1;
return lua::getregistry(
L, lua::ENVS_TABLE, lua::env_name(*doc->getEnvironment())
);
}
static int l_gui_str(lua::State* L) {

2
src/logic/scripting/lua/libs/libposteffects.cpp
View file

@ -65,7 +65,7 @@ static int l_set_params(lua::State* L) {
static int l_set_array(lua::State* L) {
size_t index = static_cast<size_t>(lua::tointeger(L, 1));
auto key = lua::require_string(L, 2);
auto data = lua::require_lstring(L, 3);
auto data = lua::bytearray_as_string(L, 3);
auto effect = post_processing->getEffect(index);
if (effect == nullptr) {
return 0;

16
src/logic/scripting/lua/libs/libtext3d.cpp
View file

@ -95,6 +95,20 @@ static int l_set_rotation(lua::State* L) {
return 0;
}
static int l_get_entity(lua::State* L) {
if (auto note = renderer->texts->get(lua::tointeger(L, 1))) {
return lua::pushinteger(L, note->getEntity());
}
return 0;
}
static int l_set_entity(lua::State* L) {
if (auto note = renderer->texts->get(lua::tointeger(L, 1))) {
note->setEntity(lua::touinteger(L, 2));
}
return 0;
}
const luaL_Reg text3dlib[] = {
{"show", wrap_hud<l_show>},
{"hide", wrap_hud<l_hide>},
@ -108,5 +122,7 @@ const luaL_Reg text3dlib[] = {
{"set_axis_y", wrap_hud<l_set_axis_y>},
{"set_rotation", wrap_hud<l_set_rotation>},
{"update_settings", wrap_hud<l_update_settings>},
{"get_entity", wrap_hud<l_get_entity>},
{"set_entity", wrap_hud<l_set_entity>},
{nullptr, nullptr}
};

42
src/logic/scripting/lua/lua_engine.cpp
View file

@ -64,12 +64,13 @@ static void create_libs(State* L, StateType stateType) {
openlib(L, "vec4", vec4lib);
openlib(L, "yaml", yamllib);
openlib(L, "__vc_app", applib);
lua::getglobal(L, "__vc_app");
lua::setregistry(L, "app");
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);
lua::getregistry(L, "app");
lua::setglobal(L, "app");
}
if (stateType == StateType::BASE || stateType == StateType::SCRIPT) {
openlib(L, "assets", assetslib);
@ -95,10 +96,18 @@ static void create_libs(State* L, StateType stateType) {
}
addfunc(L, "print", lua::wrap<l_print>);
addfunc(L, "_crc32", lua::wrap<l_crc32>);
addfunc(L, "crc32", lua::wrap<l_crc32>);
}
static int l_panic_handler(lua::State* L) {
logger.error() << "PANIC: unprotected error in call to Lua API: " << lua::tostring(L, -1);
logger.flush();
abort();
}
void lua::init_state(State* L, StateType stateType) {
lua_atpanic(L, l_panic_handler);
// Allowed standard libraries
luaL_openlibs(L);
@ -112,21 +121,25 @@ void lua::init_state(State* L, StateType stateType) {
setglobal(L, "io");
createtable(L, 0, 0);
pushvalue(L, -1);
setglobal(L, "__vc__pack_envs");
setregistry(L, lua::PACK_ENVS_TABLE);
const char* removed_os[] {
"execute", "exit", "remove", "rename", "setlocale", "tmpname", nullptr};
remove_lib_funcs(L, "os", removed_os);
create_libs(L, stateType);
createtable(L, 0, 0);
setregistry(L, LAMBDAS_TABLE);
createtable(L, 0, 0);
setregistry(L, CHUNKS_TABLE);
createtable(L, 0, 0);
pushglobals(L);
setglobal(L, env_name(0));
createtable(L, 0, 0);
setglobal(L, LAMBDAS_TABLE);
createtable(L, 0, 0);
setglobal(L, CHUNKS_TABLE);
setfield(L, env_name(0));
setregistry(L, ENVS_TABLE);
initialize_libs_extends(L);
@ -144,6 +157,9 @@ void lua::initialize(const EnginePaths& paths, const CoreParameters& params) {
);
lua::pushstring(main_thread, params.scriptFile.stem().u8string());
lua::setglobal(main_thread, "__VC_SCRIPT_NAME");
lua::pushboolean(main_thread, params.headless);
lua::setglobal(main_thread, "__VC_HEADLESS");
}
void lua::finalize() {

48
src/logic/scripting/lua/lua_util.cpp
View file

@ -8,7 +8,7 @@
using namespace lua;
static int nextEnvironment = 1;
static int next_environment = 1;
std::unordered_map<std::type_index, std::string> lua::usertypeNames;
@ -20,7 +20,7 @@ int lua::userdata_destructor(lua::State* L) {
}
std::string lua::env_name(int env) {
return "_ENV" + util::mangleid(env);
return std::to_string(env);
}
int lua::pushvalue(State* L, const dv::value& value) {
@ -220,7 +220,7 @@ void lua::dump_stack(State* L) {
static std::shared_ptr<std::string> create_lambda_handler(State* L) {
auto ptr = reinterpret_cast<ptrdiff_t>(topointer(L, -1));
auto name = util::mangleid(ptr);
requireglobal(L, LAMBDAS_TABLE);
requireregistry(L, LAMBDAS_TABLE);
pushvalue(L, -2);
setfield(L, name);
pop(L, 2);
@ -229,7 +229,7 @@ static std::shared_ptr<std::string> create_lambda_handler(State* L) {
new std::string(name),
[=](std::string* name) {
auto L = lua::get_main_state();
requireglobal(L, LAMBDAS_TABLE);
requireregistry(L, LAMBDAS_TABLE);
pushnil(L);
setfield(L, *name);
pop(L);
@ -242,8 +242,9 @@ runnable lua::create_runnable(State* L) {
auto funcptr = create_lambda_handler(L);
return [=]() {
auto L = lua::get_main_state();
if (!get_from(L, LAMBDAS_TABLE, *funcptr, false))
if (!get_from_registry(L, LAMBDAS_TABLE, *funcptr, false)) {
return;
}
call_nothrow(L, 0, 0);
pop(L);
};
@ -252,8 +253,9 @@ runnable lua::create_runnable(State* L) {
KeyCallback lua::create_simple_handler(State* L) {
auto funcptr = create_lambda_handler(L);
return [=]() -> bool {
if (!get_from(L, LAMBDAS_TABLE, *funcptr, false))
if (!get_from_registry(L, LAMBDAS_TABLE, *funcptr, false)) {
return false;
}
int top = gettop(L) - 1;
if (call_nothrow(L, 0)) {
int nres = gettop(L) - top;
@ -271,8 +273,9 @@ KeyCallback lua::create_simple_handler(State* L) {
scripting::common_func lua::create_lambda(State* L) {
auto funcptr = create_lambda_handler(L);
return [=](const std::vector<dv::value>& args) -> dv::value {
if (!get_from(L, LAMBDAS_TABLE, *funcptr, false))
if (!get_from_registry(L, LAMBDAS_TABLE, *funcptr, false)) {
return nullptr;
}
int top = gettop(L) - 1;
for (const auto& arg : args) {
pushvalue(L, arg);
@ -294,8 +297,9 @@ scripting::common_func lua::create_lambda(State* L) {
scripting::common_func lua::create_lambda_nothrow(State* L) {
auto funcptr = create_lambda_handler(L);
return [=](const std::vector<dv::value>& args) -> dv::value {
if (!get_from(L, LAMBDAS_TABLE, *funcptr, false))
if (!get_from_registry(L, LAMBDAS_TABLE, *funcptr, false)) {
return nullptr;
}
int top = gettop(L) - 1;
for (const auto& arg : args) {
pushvalue(L, arg);
@ -313,8 +317,16 @@ scripting::common_func lua::create_lambda_nothrow(State* L) {
};
}
static void store_env(lua::State* L, int id) {
requireregistry(L, ENVS_TABLE);
pushvalue(L, -2);
lua_remove(L, -3);
setfield(L, env_name(id));
pop(L);
}
int lua::create_environment(State* L, int parent) {
int id = nextEnvironment++;
int id = next_environment++;
// local env = {}
createtable(L, 0, 1);
@ -331,24 +343,22 @@ int lua::create_environment(State* L, int parent) {
setfield(L, "__index");
setmetatable(L);
// envname = env
setglobal(L, env_name(id));
store_env(L, id);
return id;
}
int lua::restore_pack_environment(lua::State* L, const std::string& packid) {
if(!lua::getglobal(L, "__vc__pack_envs")) {
if(!requireregistry(L, PACK_ENVS_TABLE)) {
return -1;
}
int id = nextEnvironment++;
int id = next_environment++;
if (lua::getfield(L, packid)) {
// envname = env
setglobal(L, env_name(id));
lua::pop(L);
if (getfield(L, packid)) {
store_env(L, id);
pop(L);
return id;
}
lua::pop(L);
pop(L);
return -1;
}
@ -357,5 +367,5 @@ void lua::remove_environment(State* L, int id) {
return;
}
pushnil(L);
setglobal(L, env_name(id));
store_env(L, id);
}

160
src/logic/scripting/lua/lua_util.hpp
View file

@ -14,21 +14,35 @@
namespace lua {
inline std::string LAMBDAS_TABLE = "$L"; // lambdas storage
inline std::string CHUNKS_TABLE = "$C"; // precompiled lua chunks
inline std::string PACK_ENVS_TABLE = "$P";
inline std::string ENVS_TABLE = "$E";
extern std::unordered_map<std::type_index, std::string> usertypeNames;
int userdata_destructor(lua::State* L);
std::string env_name(int env);
void dump_stack(lua::State*);
inline bool getglobal(lua::State* L, const std::string& name) {
lua_getglobal(L, name.c_str());
if (isnil(L, -1)) {
inline bool isnoneornil(lua::State* L, int idx) {
return lua_isnoneornil(L, idx);
}
inline bool getfield(lua::State* L, const std::string& name, int idx = -1) {
lua_getfield(L, idx, name.c_str());
if (isnoneornil(L, -1)) {
pop(L);
return false;
}
return true;
}
inline bool getglobal(lua::State* L, const std::string& name) {
return getfield(L, name, LUA_GLOBALSINDEX);
}
inline bool getregistry(lua::State* L, const std::string& name) {
return getfield(L, name, LUA_REGISTRYINDEX);
}
inline int requireglobal(lua::State* L, const std::string& name) {
if (getglobal(L, name)) {
return 1;
@ -37,6 +51,24 @@ namespace lua {
}
}
inline int requireregistry(lua::State* L, const std::string& name) {
if (getregistry(L, name)) {
return 1;
} else {
throw std::runtime_error("registry entry " + name + " not found");
}
}
inline bool getregistry(lua::State* L, const std::string& name, const std::string& key) {
requireregistry(L, name);
if (getfield(L, key)) {
lua_remove(L, -2);
return true;
}
pop(L);
return false;
}
inline bool hasglobal(lua::State* L, const std::string& name) {
lua_getglobal(L, name.c_str());
if (isnil(L, -1)) {
@ -203,9 +235,6 @@ namespace lua {
inline int pushglobals(lua::State* L) {
return pushvalue(L, LUA_GLOBALSINDEX);
}
inline bool isnoneornil(lua::State* L, int idx) {
return lua_isnoneornil(L, idx);
}
inline bool isboolean(lua::State* L, int idx) {
return lua_isboolean(L, idx);
}
@ -267,6 +296,9 @@ namespace lua {
inline void setglobal(lua::State* L, const std::string& name) {
lua_setglobal(L, name.c_str());
}
inline void setregistry(lua::State* L, const std::string& key) {
lua_setfield(L, LUA_REGISTRYINDEX, key.c_str());
}
template <class T>
inline T* touserdata(lua::State* L, int idx) {
if (void* rawptr = lua_touserdata(L, idx)) {
@ -461,15 +493,6 @@ namespace lua {
[[nodiscard]] dv::value tovalue(lua::State*, int idx);
inline bool getfield(lua::State* L, const std::string& name, int idx = -1) {
lua_getfield(L, idx, name.c_str());
if (isnoneornil(L, -1)) {
pop(L);
return false;
}
return true;
}
inline int requirefield(
lua::State* L, const std::string& name, int idx = -1
) {
@ -538,7 +561,7 @@ namespace lua {
if (luaL_loadbuffer(L, src.c_str(), src.length(), file.c_str())) {
throw luaerror(tostring(L, -1));
}
if (env && getglobal(L, env_name(env))) {
if (env && getregistry(L, ENVS_TABLE, env_name(env))) {
lua_setfenv(L, -2);
}
}
@ -551,7 +574,46 @@ namespace lua {
setfield(L, name);
pop(L, 2);
} else {
throw std::runtime_error("table " + tableName + " not found");
throw std::runtime_error("global table " + tableName + " not found");
}
}
inline void store_in_registry(
lua::State* L, const std::string& tableName, const std::string& name
) {
if (getregistry(L, tableName)) {
pushvalue(L, -2);
setfield(L, name);
pop(L, 2);
} else {
throw std::runtime_error("table " + tableName + " not found in registry");
}
}
inline int get_from(
lua::State* L,
const std::string& tableName,
const std::string& name,
bool required,
int idx,
std::string_view context
) {
if (getfield(L, tableName, idx)) {
if (getfield(L, name)) {
return 1;
} else if (required) {
pop(L);
throw std::runtime_error(
std::string(context) + " table " + tableName +
" has no member " + name
);
}
pop(L);
return 0;
} else {
throw std::runtime_error(
std::string(context) + " table " + tableName + " not found"
);
}
}
@ -561,20 +623,20 @@ namespace lua {
const std::string& name,
bool required = false
) {
if (getglobal(L, tableName)) {
if (getfield(L, name)) {
return 1;
} else if (required) {
pop(L);
throw std::runtime_error(
"table " + tableName + " has no member " + name
);
}
pop(L);
return 0;
} else {
throw std::runtime_error("table " + tableName + " not found");
}
return get_from(
L, tableName, name, required, LUA_GLOBALSINDEX, "global"
);
}
inline int get_from_registry(
lua::State* L,
const std::string& tableName,
const std::string& name,
bool required = false
) {
return get_from(
L, tableName, name, required, LUA_REGISTRYINDEX, "registry"
);
}
int call(lua::State*, int argc, int nresults = -1);
@ -607,10 +669,7 @@ namespace lua {
scripting::common_func create_lambda_nothrow(lua::State*);
inline int pushenv(lua::State* L, int env) {
if (getglobal(L, env_name(env))) {
return 1;
}
return 0;
return getregistry(L, ENVS_TABLE, env_name(env));
}
int create_environment(lua::State*, int parent);
int restore_pack_environment(lua::State*, const std::string& packid);
@ -739,14 +798,14 @@ namespace lua {
inline void read_bytes_from_table(
lua::State* L, int tableIndex, std::vector<ubyte>& bytes
) {
if (!lua::istable(L, tableIndex)) {
if (!istable(L, tableIndex)) {
throw std::runtime_error("table expected");
} else {
size_t size = lua::objlen(L, tableIndex);
size_t size = objlen(L, tableIndex);
for (size_t i = 0; i < size; i++) {
lua::rawgeti(L, i + 1, tableIndex);
const int byte = lua::tointeger(L, -1);
lua::pop(L);
rawgeti(L, i + 1, tableIndex);
const int byte = tointeger(L, -1);
pop(L);
if (byte < 0 || byte > 255) {
throw std::runtime_error(
"invalid byte '" + std::to_string(byte) + "'"
@ -758,11 +817,11 @@ namespace lua {
}
inline int create_bytearray(lua::State* L, const void* bytes, size_t size) {
lua::requireglobal(L, "Bytearray_construct");
lua::pushlstring(
requireglobal(L, "Bytearray_construct");
pushlstring(
L, std::string_view(reinterpret_cast<const char*>(bytes), size)
);
return lua::call(L, 1, 1);
return call(L, 1, 1);
}
inline int create_bytearray(lua::State* L, const std::vector<ubyte>& bytes) {
@ -770,12 +829,15 @@ namespace lua {
}
inline std::string_view bytearray_as_string(lua::State* L, int idx) {
lua::pushvalue(L, idx);
lua::requireglobal(L, "Bytearray_as_string");
lua::pushvalue(L, -2);
lua::call(L, 1, 1);
auto view = lua::tolstring(L, -1);
lua::pop(L, 2);
if (type(L, idx) == LUA_TSTRING) {
return tolstring(L, idx);
}
pushvalue(L, idx);
requireglobal(L, "Bytearray_as_string");
pushvalue(L, -2);
call(L, 1, 1);
auto view = tolstring(L, -1);
pop(L, 2);
return view;
}
}

47
src/logic/scripting/scripting.cpp
View file

@ -188,11 +188,7 @@ std::unique_ptr<Process> scripting::start_app_script(const io::path& script) {
lua::pushstring(L, pack.id);
lua::setfield(L, "PACK_ID");
if(!lua::getglobal(L, "__vc__pack_envs")) {
lua::createtable(L, 0, 0);
lua::setglobal(L, "__vc__pack_envs");
lua::pushvalue(L, -1);
}
lua::requireregistry(L, lua::PACK_ENVS_TABLE);
lua::pushenv(L, id);
lua::setfield(L, pack.id);
lua::pop(L);
@ -248,7 +244,7 @@ std::unique_ptr<Process> scripting::start_app_script(const io::path& script) {
void scripting::process_post_runnables() {
auto L = lua::get_main_state();
if (lua::getglobal(L, "__process_post_runnables")) {
if (lua::getglobal(L, "__vc__process_post_runnables")) {
lua::call_nothrow(L, 0, 0);
}
}
@ -627,6 +623,26 @@ void scripting::on_ui_close(UiDocument* layout, Inventory* inventory) {
});
}
void scripting::on_scripts_loading() {
auto L = lua::get_main_state();
for (auto& pack : content_control->getAllContentPacks()) {
lua::emit_event(L, pack.id + ":.onscriptsloading", [](auto L) {
return 0;
});
}
}
void scripting::on_content_loaded() {
auto L = lua::get_main_state();
for (auto& pack : content_control->getAllContentPacks()) {
lua::emit_event(L, pack.id + ":.oncontentloaded", [](auto L) {
return 0;
});
}
}
bool scripting::register_event(
int env, const std::string& name, const std::string& id
) {
@ -722,7 +738,7 @@ void scripting::load_entity_component(
std::string src = io::read_string(file);
logger.info() << "script (component) " << file.string();
lua::loadbuffer(L, *env, src, fileName);
lua::store_in(L, lua::CHUNKS_TABLE, name);
lua::store_in_registry(L, lua::CHUNKS_TABLE, name);
}
void scripting::load_world_script(
@ -761,6 +777,23 @@ void scripting::load_world_script(
register_event(env, "on_inventory_open", prefix + ":.inventoryopen");
funcsset.oninventoryclosed =
register_event(env, "on_inventory_closed", prefix + ":.inventoryclosed");
funcsset.onentityspawn =
register_event(env, "on_entity_spawn", prefix + ":.entityspawn");
funcsset.onentitydespawn =
register_event(env, "on_entity_despawn", prefix + ":.entitydespawn");
}
void scripting::load_content_script(
const scriptenv& senv,
const std::string& prefix,
const io::path& file,
const std::string& fileName
) {
int env = *senv;
lua::pop(lua::get_main_state(), load_script(env, "content", file, fileName));
register_event(env, "on_scripts_loading", prefix + ":.onscriptsloading");
register_event(env, "on_content_loaded", prefix + ":.oncontentloaded");
}
void scripting::load_layout_script(

13
src/logic/scripting/scripting.hpp
View file

@ -160,6 +160,12 @@ namespace scripting {
/// @brief Called on UI view close
void on_ui_close(UiDocument* layout, Inventory* inventory);
/// @brief Called on Content loading
void on_scripts_loading();
/// @brief Called on Content loading finish
void on_content_loaded();
/// @brief Load script associated with a Block
/// @param env environment
/// @param prefix pack id
@ -221,6 +227,13 @@ namespace scripting {
WorldFuncsSet& funcsset
);
void load_content_script(
const scriptenv& env,
const std::string& packid,
const io::path& file,
const std::string& fileName
);
/// @brief Load script associated with an UiDocument
/// @param env environment
/// @param prefix pack id

73
src/logic/scripting/scripting_entities.cpp
View file

@ -1,14 +1,18 @@
#include "scripting.hpp"
#include "debug/Logger.hpp"
#include "lua/lua_engine.hpp"
#include "objects/Entities.hpp"
#include "objects/EntityDef.hpp"
#include "objects/Entity.hpp"
#include "objects/Player.hpp"
#include "util/stringutil.hpp"
#include "content/Content.hpp"
#include "content/ContentPack.hpp"
using namespace scripting;
static debug::Logger logger("scripting-entities");
static inline const std::string STDCOMP = "stdcomp";
[[nodiscard]] static scriptenv create_component_environment(
@ -52,6 +56,24 @@ dv::value scripting::get_component_value(
return nullptr;
}
static void init_component_events(
lua::State* L, const scriptenv& env, UserComponent& component
) {
lua::pushenv(L, *env);
auto& funcsset = component.funcsset;
funcsset.on_grounded = lua::hasfield(L, "on_grounded");
funcsset.on_fall = lua::hasfield(L, "on_fall");
funcsset.on_despawn = lua::hasfield(L, "on_despawn");
funcsset.on_sensor_enter = lua::hasfield(L, "on_sensor_enter");
funcsset.on_sensor_exit = lua::hasfield(L, "on_sensor_exit");
funcsset.on_save = lua::hasfield(L, "on_save");
funcsset.on_aim_on = lua::hasfield(L, "on_aim_on");
funcsset.on_aim_off = lua::hasfield(L, "on_aim_off");
funcsset.on_attacked = lua::hasfield(L, "on_attacked");
funcsset.on_used = lua::hasfield(L, "on_used");
lua::pop(L);
}
static void create_component(
lua::State* L,
int entityIdx,
@ -59,11 +81,20 @@ static void create_component(
const dv::value& args,
const dv::value& saved
) {
auto parentEnv = get_root_environment();
auto prefix = ContentPack::getPrefix(component.name);
const auto& content = *scripting::content;
if (auto runtime = content.getPackRuntime(std::string(prefix))) {
parentEnv = runtime->getEnvironment();
} else {
logger.warning() << "pack environment is not available for "
<< component.name;
}
lua::pushvalue(L, entityIdx);
auto compenv = create_component_environment(
get_root_environment(), -1, component.name
std::move(parentEnv), -1, component.name
);
lua::get_from(L, lua::CHUNKS_TABLE, component.name, true);
lua::get_from_registry(L, lua::CHUNKS_TABLE, component.name, true);
lua::pushenv(L, *compenv);
if (args != nullptr) {
@ -95,19 +126,8 @@ static void create_component(
lua::setfenv(L);
lua::call_nothrow(L, 0, 0);
lua::pushenv(L, *compenv);
auto& funcsset = component.funcsset;
funcsset.on_grounded = lua::hasfield(L, "on_grounded");
funcsset.on_fall = lua::hasfield(L, "on_fall");
funcsset.on_despawn = lua::hasfield(L, "on_despawn");
funcsset.on_sensor_enter = lua::hasfield(L, "on_sensor_enter");
funcsset.on_sensor_exit = lua::hasfield(L, "on_sensor_exit");
funcsset.on_save = lua::hasfield(L, "on_save");
funcsset.on_aim_on = lua::hasfield(L, "on_aim_on");
funcsset.on_aim_off = lua::hasfield(L, "on_aim_off");
funcsset.on_attacked = lua::hasfield(L, "on_attacked");
funcsset.on_used = lua::hasfield(L, "on_used");
lua::pop(L, 2);
init_component_events(L, compenv, component);
lua::pop(L);
component.env = compenv;
}
@ -129,6 +149,15 @@ void scripting::on_entity_spawn(
for (auto& component : components) {
create_component(L, -1, *component, args, saved);
}
for (auto& [packid, pack] : content->getPacks()) {
if (pack->worldfuncsset.onentityspawn) {
lua::emit_event(L, packid + ":.entityspawn", [&](lua::State* L) {
lua::pushinteger(L, eid);
return 1;
});
}
}
}
static void process_entity_callback(
@ -170,9 +199,21 @@ void scripting::on_entity_despawn(const Entity& entity) {
process_entity_callback(
entity, "on_despawn", &EntityFuncsSet::on_despawn, nullptr
);
auto L = lua::get_main_state();
entityid_t uid = entity.getUID();
for (auto& [packid, pack] : content->getPacks()) {
if (pack->worldfuncsset.onentitydespawn) {
lua::emit_event(L, packid + ":.entitydespawn", [&](lua::State* L) {
lua::pushinteger(L, uid);
return 1;
});
}
}
lua::get_from(L, "stdcomp", "remove_Entity", true);
lua::pushinteger(L, entity.getUID());
lua::pushinteger(L, uid);
lua::call(L, 1, 0);
}

4
src/main.cpp
View file

@ -15,7 +15,9 @@ static void sigterm_handler(int signum) {
int main(int argc, char** argv) {
#ifdef VC_BUILD_NAME
logger.info() << "build: " << VC_BUILD_NAME;
if constexpr (VC_BUILD_NAME[0]) {
logger.info() << "build: " << VC_BUILD_NAME;
}
#endif
CoreParameters coreParameters;

30
src/util/platform.cpp
View file

@ -215,7 +215,9 @@ std::filesystem::path platform::get_executable_path() {
#endif
}
void platform::new_engine_instance(const std::vector<std::string>& args) {
void platform::new_engine_instance(
const std::vector<std::string>& args, std::filesystem::path outputFile
) {
auto executable = get_executable_path();
#ifdef _WIN32
@ -250,6 +252,24 @@ void platform::new_engine_instance(const std::vector<std::string>& args) {
auto commandString = toWString(ss.str());
STARTUPINFOW si = { sizeof(si) };
if (!outputFile.empty()) {
si.dwFlags |= STARTF_USESTDHANDLES;
si.hStdOutput = CreateFileW(
toWString(outputFile.u8string()).data(),
GENERIC_WRITE,
FILE_SHARE_WRITE | FILE_SHARE_READ,
nullptr,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
nullptr
);
if (si.hStdOutput == INVALID_HANDLE_VALUE) {
throw std::runtime_error(
"CreateFileW failed with code: " +
std::to_string(GetLastError())
);
}
}
PROCESS_INFORMATION pi = { 0 };
DWORD flags = CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS;
// | CREATE_NO_WINDOW;
@ -280,7 +300,11 @@ void platform::new_engine_instance(const std::vector<std::string>& args) {
for (int i = 0; i < args.size(); i++) {
ss << " " << util::quote(args[i]);
}
ss << " >/dev/null &";
if (outputFile.empty()) {
ss << " >/dev/null &";
} else {
ss << " >" << util::quote(outputFile.u8string()) << " &";
}
auto command = ss.str();
logger.info() << command;
@ -302,4 +326,4 @@ bool platform::stdin_has_data() {
fds.events = POLLIN;
return poll(&fds, 1, 0) == 1;
#endif
}
}

4
src/util/platform.hpp
View file

@ -18,7 +18,9 @@ namespace platform {
/// @brief Get current process running executable path
std::filesystem::path get_executable_path();
/// @brief Run a separate engine instance with specified arguments
void new_engine_instance(const std::vector<std::string>& args);
void new_engine_instance(
const std::vector<std::string>& args, std::filesystem::path outputFile
);
/// @brief Open URL in web browser
bool open_url(const std::string& url);
/// @brief Check if stdin has input