PulseStudio/VoxelEngine
PulseStudio/VoxelEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Merge branch 'main' into lua_audio

Browse Source
This commit is contained in:
MihailRis 2024-03-05 22:23:14 +03:00
commit 454a354941
4 changed files with 291 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/items/ItemDef.h
View File

@ -7,7 +7,8 @@
#include "../typedefs.h" #include "../typedefs.h"
struct item_funcs_set { struct item_funcs_set {
bool init: 1; bool init: 1;
bool on_use: 1;
bool on_use_on_block: 1; bool on_use_on_block: 1;
bool on_block_break_by: 1; bool on_block_break_by: 1;
}; };

460
src/logic/PlayerController.cpp
View File

@ -32,103 +32,103 @@ const float CROUCH_SHIFT_Y = -0.2f;
CameraControl::CameraControl(std::shared_ptr<Player> player, const CameraSettings& settings) CameraControl::CameraControl(std::shared_ptr<Player> player, const CameraSettings& settings)
: player(player), : player(player),
camera(player->camera), camera(player->camera),
currentViewCamera(player->currentCamera), currentViewCamera(player->currentCamera),
settings(settings), settings(settings),
offset(0.0f, 0.7f, 0.0f) { offset(0.0f, 0.7f, 0.0f) {
} }
void CameraControl::refresh() { void CameraControl::refresh() {
camera->position = player->hitbox->position + offset; camera->position = player->hitbox->position + offset;
} }
void CameraControl::updateMouse(PlayerInput& input) { void CameraControl::updateMouse(PlayerInput& input) {
glm::vec2& cam = player->cam; glm::vec2& cam = player->cam;
float sensitivity = (input.zoom ? settings.sensitivity / 4.f : settings.sensitivity); float sensitivity = (input.zoom ? settings.sensitivity / 4.f : settings.sensitivity);
cam -= glm::degrees(Events::delta / (float)Window::height * sensitivity); cam -= glm::degrees(Events::delta / (float)Window::height * sensitivity);
if (cam.y < -89.9f) { if (cam.y < -89.9f) {
cam.y = -89.9f; cam.y = -89.9f;
} }
else if (cam.y > 89.9f) { else if (cam.y > 89.9f) {
cam.y = 89.9f; cam.y = 89.9f;
} }
if (cam.x > 180.f) { if (cam.x > 180.f) {
cam.x -= 360.f; cam.x -= 360.f;
} }
else if (cam.x < -180.f) { else if (cam.x < -180.f) {
cam.x += 360.f; cam.x += 360.f;
} }
camera->rotation = glm::mat4(1.0f); camera->rotation = glm::mat4(1.0f);
camera->rotate(glm::radians(cam.y), glm::radians(cam.x), 0); camera->rotate(glm::radians(cam.y), glm::radians(cam.x), 0);
} }
void CameraControl::update(PlayerInput& input, float delta, Chunks* chunks) { void CameraControl::update(PlayerInput& input, float delta, Chunks* chunks) {
Hitbox* hitbox = player->hitbox.get(); Hitbox* hitbox = player->hitbox.get();
offset = glm::vec3(0.0f, 0.7f, 0.0f); offset = glm::vec3(0.0f, 0.7f, 0.0f);
if (settings.shaking && !input.cheat) { if (settings.shaking && !input.cheat) {
const float k = CAM_SHAKE_DELTA_K; const float k = CAM_SHAKE_DELTA_K;
const float oh = CAM_SHAKE_OFFSET; const float oh = CAM_SHAKE_OFFSET;
const float ov = CAM_SHAKE_OFFSET_Y; const float ov = CAM_SHAKE_OFFSET_Y;
const glm::vec3& vel = hitbox->velocity; const glm::vec3& vel = hitbox->velocity;
interpVel = interpVel * (1.0f - delta * 5) + vel * delta * 0.1f; interpVel = interpVel * (1.0f - delta * 5) + vel * delta * 0.1f;
if (hitbox->grounded && interpVel.y < 0.0f){ if (hitbox->grounded && interpVel.y < 0.0f){
interpVel.y *= -30.0f; interpVel.y *= -30.0f;
} }
shake = shake * (1.0f - delta * k); shake = shake * (1.0f - delta * k);
if (hitbox->grounded) { if (hitbox->grounded) {
float f = glm::length(glm::vec2(vel.x, vel.z)); float f = glm::length(glm::vec2(vel.x, vel.z));
shakeTimer += delta * f * CAM_SHAKE_SPEED; shakeTimer += delta * f * CAM_SHAKE_SPEED;
shake += f * delta * k; shake += f * delta * k;
} }
offset += camera->right * glm::sin(shakeTimer) * oh * shake; offset += camera->right * glm::sin(shakeTimer) * oh * shake;
offset += camera->up * glm::abs(glm::cos(shakeTimer)) * ov * shake; offset += camera->up * glm::abs(glm::cos(shakeTimer)) * ov * shake;
offset -= glm::min(interpVel * 0.05f, 1.0f); offset -= glm::min(interpVel * 0.05f, 1.0f);
} }
if (settings.fovEvents){ if (settings.fovEvents){
bool crouch = input.shift && hitbox->grounded && !input.sprint; bool crouch = input.shift && hitbox->grounded && !input.sprint;
float dt = fmin(1.0f, delta * ZOOM_SPEED); float dt = fmin(1.0f, delta * ZOOM_SPEED);
float zoomValue = 1.0f; float zoomValue = 1.0f;
if (crouch){ if (crouch){
offset += glm::vec3(0.f, CROUCH_SHIFT_Y, 0.f); offset += glm::vec3(0.f, CROUCH_SHIFT_Y, 0.f);
zoomValue = CROUCH_ZOOM; zoomValue = CROUCH_ZOOM;
} else if (input.sprint){ } else if (input.sprint){
zoomValue = RUN_ZOOM; zoomValue = RUN_ZOOM;
} }
if (input.zoom) if (input.zoom)
zoomValue *= C_ZOOM; zoomValue *= C_ZOOM;
camera->zoom = zoomValue * dt + camera->zoom * (1.0f - dt); camera->zoom = zoomValue * dt + camera->zoom * (1.0f - dt);
} }
auto spCamera = player->spCamera; auto spCamera = player->spCamera;
auto tpCamera = player->tpCamera; auto tpCamera = player->tpCamera;
if (input.cameraMode) { //ugly but effective if (input.cameraMode) { //ugly but effective
if (player->currentCamera == camera) if (player->currentCamera == camera)
player->currentCamera = tpCamera; player->currentCamera = tpCamera;
else if (player->currentCamera == spCamera) else if (player->currentCamera == spCamera)
player->currentCamera = camera; player->currentCamera = camera;
else if (player->currentCamera == tpCamera) else if (player->currentCamera == tpCamera)
player->currentCamera = spCamera; player->currentCamera = spCamera;
} }
if (player->currentCamera == spCamera) { if (player->currentCamera == spCamera) {
spCamera->position = chunks->rayCastToObstacle(camera->position, camera->front, 3.0f) - 0.2f*(camera->front); spCamera->position = chunks->rayCastToObstacle(camera->position, camera->front, 3.0f) - 0.2f*(camera->front);
spCamera->dir = -camera->dir; spCamera->dir = -camera->dir;
spCamera->front = -camera->front; spCamera->front = -camera->front;
} }
else if (player->currentCamera == tpCamera) { else if (player->currentCamera == tpCamera) {
tpCamera->position = chunks->rayCastToObstacle(camera->position, -camera->front, 3.0f) + 0.2f * (camera->front); tpCamera->position = chunks->rayCastToObstacle(camera->position, -camera->front, 3.0f) + 0.2f * (camera->front);
tpCamera->dir = camera->dir; tpCamera->dir = camera->dir;
tpCamera->front = camera->front; tpCamera->front = camera->front;
} }
} }
glm::vec3 PlayerController::selectedBlockPosition; glm::vec3 PlayerController::selectedBlockPosition;
@ -141,167 +141,194 @@ PlayerController::PlayerController(
Level* level, Level* level,
const EngineSettings& settings, const EngineSettings& settings,
BlocksController* blocksController) BlocksController* blocksController)
: level(level), : level(level),
player(level->getObject<Player>(0)), player(level->getObject<Player>(0)),
camControl(player, settings.camera), camControl(player, settings.camera),
blocksController(blocksController) { blocksController(blocksController) {
} }
void PlayerController::update(float delta, bool input, bool pause) { void PlayerController::update(float delta, bool input, bool pause) {
if (!pause) { if (!pause) {
if (input) { if (input) {
updateKeyboard(); updateKeyboard();
} else { } else {
resetKeyboard(); resetKeyboard();
} }
updateCamera(delta, input); updateCamera(delta, input);
updateControls(delta); updateControls(delta);
} }
camControl.refresh(); camControl.refresh();
if (input) { if (input) {
updateInteraction(); updateInteraction();
} else { } else {
selectedBlockId = -1; selectedBlockId = -1;
selectedBlockStates = 0; selectedBlockStates = 0;
} }
} }
void PlayerController::updateKeyboard() { void PlayerController::updateKeyboard() {
input.moveForward = Events::active(BIND_MOVE_FORWARD); input.moveForward = Events::active(BIND_MOVE_FORWARD);
input.moveBack = Events::active(BIND_MOVE_BACK); input.moveBack = Events::active(BIND_MOVE_BACK);
input.moveLeft = Events::active(BIND_MOVE_LEFT); input.moveLeft = Events::active(BIND_MOVE_LEFT);
input.moveRight = Events::active(BIND_MOVE_RIGHT); input.moveRight = Events::active(BIND_MOVE_RIGHT);
input.sprint = Events::active(BIND_MOVE_SPRINT); input.sprint = Events::active(BIND_MOVE_SPRINT);
input.shift = Events::active(BIND_MOVE_CROUCH); input.shift = Events::active(BIND_MOVE_CROUCH);
input.cheat = Events::active(BIND_MOVE_CHEAT); input.cheat = Events::active(BIND_MOVE_CHEAT);
input.jump = Events::active(BIND_MOVE_JUMP); input.jump = Events::active(BIND_MOVE_JUMP);
input.zoom = Events::active(BIND_CAM_ZOOM); input.zoom = Events::active(BIND_CAM_ZOOM);
input.cameraMode = Events::jactive(BIND_CAM_MODE); input.cameraMode = Events::jactive(BIND_CAM_MODE);
input.noclip = Events::jactive(BIND_PLAYER_NOCLIP); input.noclip = Events::jactive(BIND_PLAYER_NOCLIP);
input.flight = Events::jactive(BIND_PLAYER_FLIGHT); input.flight = Events::jactive(BIND_PLAYER_FLIGHT);
} }
void PlayerController::updateCamera(float delta, bool movement) { void PlayerController::updateCamera(float delta, bool movement) {
if (movement) { if (movement) {
camControl.updateMouse(input); camControl.updateMouse(input);
} }
camControl.update(input, delta, level->chunks.get()); camControl.update(input, delta, level->chunks.get());
} }
void PlayerController::resetKeyboard() { void PlayerController::resetKeyboard() {
input.zoom = false; input.zoom = false;
input.moveForward = false; input.moveForward = false;
input.moveBack = false; input.moveBack = false;
input.moveLeft = false; input.moveLeft = false;
input.moveRight = false; input.moveRight = false;
input.sprint = false; input.sprint = false;
input.shift = false; input.shift = false;
input.cheat = false; input.cheat = false;
input.jump = false; input.jump = false;
} }
void PlayerController::updateControls(float delta){ void PlayerController::updateControls(float delta){
player->updateInput(level, input, delta); player->updateInput(level, input, delta);
}
static int determine_rotation(Block* def, glm::ivec3& norm, glm::vec3& camDir) {
if (def && def->rotatable){
const std::string& name = def->rotations.name;
if (name == "pipe") {
if (norm.x < 0.0f) return BLOCK_DIR_WEST;
else if (norm.x > 0.0f) return BLOCK_DIR_EAST;
else if (norm.y > 0.0f) return BLOCK_DIR_UP;
else if (norm.y < 0.0f) return BLOCK_DIR_DOWN;
else if (norm.z > 0.0f) return BLOCK_DIR_NORTH;
else if (norm.z < 0.0f) return BLOCK_DIR_SOUTH;
}
else if (name == "pane") {
if (abs(camDir.x) > abs(camDir.z)){
if (camDir.x > 0.0f) return BLOCK_DIR_EAST;
if (camDir.x < 0.0f) return BLOCK_DIR_WEST;
}
if (abs(camDir.x) < abs(camDir.z)){
if (camDir.z > 0.0f) return BLOCK_DIR_SOUTH;
if (camDir.z < 0.0f) return BLOCK_DIR_NORTH;
}
}
}
return 0;
}
static void pick_block(ContentIndices* indices, Chunks* chunks, Player* player, int x, int y, int z) {
Block* block = indices->getBlockDef(chunks->get(x,y,z)->id);
itemid_t id = block->rt.pickingItem;
auto inventory = player->getInventory();
size_t slotid = inventory->findSlotByItem(id, 0, 10);
if (slotid == Inventory::npos) {
slotid = player->getChosenSlot();
} else {
player->setChosenSlot(slotid);
}
ItemStack& stack = inventory->getSlot(slotid);
if (stack.getItemId() != id) {
stack.set(ItemStack(id, 1));
}
} }
void PlayerController::updateInteraction(){ void PlayerController::updateInteraction(){
auto indices = level->content->getIndices(); auto indices = level->content->getIndices();
Chunks* chunks = level->chunks.get(); Chunks* chunks = level->chunks.get();
Lighting* lighting = level->lighting.get(); Lighting* lighting = level->lighting.get();
Camera* camera = player->camera.get(); Camera* camera = player->camera.get();
glm::vec3 end;
glm::ivec3 iend;
glm::ivec3 norm;
bool xkey = Events::pressed(keycode::X); bool xkey = Events::pressed(keycode::X);
bool lclick = Events::jactive(BIND_PLAYER_ATTACK) || bool lclick = Events::jactive(BIND_PLAYER_ATTACK) ||
(xkey && Events::active(BIND_PLAYER_ATTACK)); (xkey && Events::active(BIND_PLAYER_ATTACK));
bool rclick = Events::jactive(BIND_PLAYER_BUILD) || bool rclick = Events::jactive(BIND_PLAYER_BUILD) ||
(xkey && Events::active(BIND_PLAYER_BUILD)); (xkey && Events::active(BIND_PLAYER_BUILD));
float maxDistance = 10.0f; float maxDistance = 10.0f;
if (xkey) { if (xkey) {
maxDistance *= 20.0f; maxDistance *= 20.0f;
} }
auto inventory = player->getInventory();
ItemStack& stack = inventory->getSlot(player->getChosenSlot());
ItemDef* item = indices->getItemDef(stack.getItemId());
voxel* vox = chunks->rayCast(camera->position, glm::vec3 end;
camera->front, glm::ivec3 iend;
maxDistance, glm::ivec3 norm;
end, norm, iend); voxel* vox = chunks->rayCast(
if (vox != nullptr){ camera->position,
player->selectedVoxel = *vox; camera->front,
selectedBlockId = vox->id; maxDistance,
selectedBlockStates = vox->states; end, norm, iend
selectedBlockPosition = iend; );
selectedPointPosition = end; if (vox != nullptr){
selectedBlockNormal = norm; player->selectedVoxel = *vox;
int x = iend.x; selectedBlockId = vox->id;
int y = iend.y; selectedBlockStates = vox->states;
int z = iend.z; selectedBlockPosition = iend;
uint8_t states = 0; selectedPointPosition = end;
selectedBlockNormal = norm;
int x = iend.x;
int y = iend.y;
int z = iend.z;
auto inventory = player->getInventory(); Block* def = indices->getBlockDef(item->rt.placingBlock);
ItemStack& stack = inventory->getSlot(player->getChosenSlot()); uint8_t states = determine_rotation(def, norm, camera->dir);
ItemDef* item = indices->getItemDef(stack.getItemId());
Block* def = indices->getBlockDef(item->rt.placingBlock);
if (def && def->rotatable){
const std::string& name = def->rotations.name;
if (name == "pipe") {
if (norm.x < 0.0f) states = BLOCK_DIR_WEST;
else if (norm.x > 0.0f) states = BLOCK_DIR_EAST;
else if (norm.y > 0.0f) states = BLOCK_DIR_UP;
else if (norm.y < 0.0f) states = BLOCK_DIR_DOWN;
else if (norm.z > 0.0f) states = BLOCK_DIR_NORTH;
else if (norm.z < 0.0f) states = BLOCK_DIR_SOUTH;
} else if (name == "pane") {
glm::vec3 vec = camera->dir;
if (abs(vec.x) > abs(vec.z)){
if (vec.x > 0.0f) states = BLOCK_DIR_EAST;
if (vec.x < 0.0f) states = BLOCK_DIR_WEST;
}
if (abs(vec.x) < abs(vec.z)){
if (vec.z > 0.0f) states = BLOCK_DIR_SOUTH;
if (vec.z < 0.0f) states = BLOCK_DIR_NORTH;
}
}
}
if (lclick) { if (lclick && !input.shift && item->rt.funcsset.on_block_break_by) {
if (!input.shift && item->rt.funcsset.on_block_break_by) { if (scripting::on_item_break_block(player.get(), item, x, y, z))
if (scripting::on_item_break_block(player.get(), item, x, y, z)) return;
return;
}
} }
Block* target = indices->getBlockDef(vox->id); Block* target = indices->getBlockDef(vox->id);
if (lclick && target->breakable){ if (lclick && target->breakable){
blocksController->breakBlock(player.get(), target, x, y, z); blocksController->breakBlock(player.get(), target, x, y, z);
} }
if (rclick) { if (rclick && !input.shift) {
if (!input.shift && item->rt.funcsset.on_use_on_block) { bool preventDefault = false;
if (scripting::on_item_use_on_block(player.get(), item, x, y, z))
return; if (item->rt.funcsset.on_use) {
preventDefault |= scripting::on_item_use(player.get(), item);
}
if (item->rt.funcsset.on_use_on_block) {
preventDefault |= scripting::on_item_use_on_block(player.get(), item, x, y, z);
}
if (preventDefault) {
return;
} }
} }
if (def && rclick){ if (def && rclick){
if (!input.shift && target->rt.funcsset.oninteract) { if (!input.shift && target->rt.funcsset.oninteract) {
if (scripting::on_block_interact(player.get(), target, x, y, z)) if (scripting::on_block_interact(player.get(), target, x, y, z))
return; return;
} }
if (!target->replaceable){ if (!target->replaceable){
x = (iend.x)+(norm.x); x = (iend.x)+(norm.x);
y = (iend.y)+(norm.y); y = (iend.y)+(norm.y);
z = (iend.z)+(norm.z); z = (iend.z)+(norm.z);
} else { } else {
if (def->rotations.name == "pipe") { if (def->rotations.name == "pipe") {
states = BLOCK_DIR_UP; states = BLOCK_DIR_UP;
} }
} }
vox = chunks->get(x, y, z); vox = chunks->get(x, y, z);
blockid_t chosenBlock = def->rt.id; blockid_t chosenBlock = def->rt.id;
if (vox && (target = indices->getBlockDef(vox->id))->replaceable) { if (vox && (target = indices->getBlockDef(vox->id))->replaceable) {
if (!level->physics->isBlockInside(x,y,z, player->hitbox.get()) if (!level->physics->isBlockInside(x,y,z, player->hitbox.get())
|| !def->obstacle){ || !def->obstacle){
if (def->grounded && !chunks->isSolidBlock(x, y-1, z)) { if (def->grounded && !chunks->isSolidBlock(x, y-1, z)) {
chosenBlock = 0; chosenBlock = 0;
} }
@ -313,28 +340,21 @@ void PlayerController::updateInteraction(){
} }
blocksController->updateSides(x, y, z); blocksController->updateSides(x, y, z);
} }
} }
} }
} }
if (Events::jactive(BIND_PLAYER_PICK)){ if (Events::jactive(BIND_PLAYER_PICK)) {
Block* block = indices->getBlockDef(chunks->get(x,y,z)->id); pick_block(indices, chunks, player.get(), x, y, z);
itemid_t id = block->rt.pickingItem; }
auto inventory = player->getInventory(); } else {
size_t slotid = inventory->findSlotByItem(id, 0, 10); selectedBlockId = -1;
if (slotid == Inventory::npos) { selectedBlockStates = 0;
slotid = player->getChosenSlot(); }
} else { if (rclick) {
player->setChosenSlot(slotid); if (item->rt.funcsset.on_use) {
} scripting::on_item_use(player.get(), item);
ItemStack& stack = inventory->getSlot(slotid); }
if (stack.getItemId() != id) { }
stack.set(ItemStack(id, 1));
}
}
} else {
selectedBlockId = -1;
selectedBlockStates = 0;
}
} }
Player* PlayerController::getPlayer() { Player* PlayerController::getPlayer() {

12
src/logic/scripting/scripting.cpp
View File

@ -187,6 +187,17 @@ bool scripting::on_block_interact(Player* player, const Block* block, int x, int
return false; return false;
} }
bool scripting::on_item_use(Player* player, const ItemDef* item) {
std::string name = item->name+".use";
if (state->getglobal(name)) {
state->pushinteger(player->getId());
if (state->callNoThrow(4)) {
return state->toboolean(-1);
}
}
return false;
}
bool scripting::on_item_use_on_block(Player* player, const ItemDef* item, int x, int y, int z) { bool scripting::on_item_use_on_block(Player* player, const ItemDef* item, int x, int y, int z) {
std::string name = item->name+".useon"; std::string name = item->name+".useon";
if (state->getglobal(name)) { if (state->getglobal(name)) {
@ -263,6 +274,7 @@ void scripting::load_item_script(int env, std::string prefix, fs::path file, ite
state->execute(env, src, file.u8string()); state->execute(env, src, file.u8string());
funcsset.init = register_event(env, "init", prefix+".init"); funcsset.init = register_event(env, "init", prefix+".init");
funcsset.on_use = register_event(env, "on_use", prefix+".use");
funcsset.on_use_on_block = register_event(env, "on_use_on_block", prefix+".useon"); funcsset.on_use_on_block = register_event(env, "on_use_on_block", prefix+".useon");
funcsset.on_block_break_by = register_event(env, "on_block_break_by", prefix+".blockbreakby"); funcsset.on_block_break_by = register_event(env, "on_block_break_by", prefix+".blockbreakby");
} }

51
src/logic/scripting/scripting.h
View File

@ -30,7 +30,7 @@ namespace scripting {
extern Level* level; extern Level* level;
extern BlocksController* blocks; extern BlocksController* blocks;
/* Lua environment wrapper for automatic deletion */ /// @brief Lua environment wrapper for automatic deletion
class Environment { class Environment {
int env; int env;
public: public:
@ -58,34 +58,51 @@ namespace scripting {
void on_block_broken(Player* player, const Block* block, int x, int y, int z); void on_block_broken(Player* player, const Block* block, int x, int y, int z);
bool on_block_interact(Player* player, const Block* block, int x, int y, int z); bool on_block_interact(Player* player, const Block* block, int x, int y, int z);
/** Called on RMB click on block with the item selected /// @brief Called on RMB click with the item selected
@return true if prevents default action */ /// @return true if prevents default action
bool on_item_use(Player* player, const ItemDef* item);
/// @brief Called on RMB click on block with the item selected
/// @return true if prevents default action
bool on_item_use_on_block(Player* player, const ItemDef* item, int x, int y, int z); bool on_item_use_on_block(Player* player, const ItemDef* item, int x, int y, int z);
/** Called on LMB click on block with the item selected
@return true if prevents default action */ /// @brief Called on LMB click on block with the item selected
/// @return true if prevents default action
bool on_item_break_block(Player* player, const ItemDef* item, int x, int y, int z); bool on_item_break_block(Player* player, const ItemDef* item, int x, int y, int z);
/** Called on UI view show */ /// @brief Called on UI view show
void on_ui_open(UiDocument* layout, Inventory* inventory, glm::ivec3 blockcoord); void on_ui_open(UiDocument* layout, Inventory* inventory, glm::ivec3 blockcoord);
/** Called on UI view close*/
/// @brief Called on UI view close
void on_ui_close(UiDocument* layout, Inventory* inventory); void on_ui_close(UiDocument* layout, Inventory* inventory);
/** Load script associated with a Block */ /// @brief Load script associated with a Block
/// @param env environment id
/// @param prefix pack id
/// @param file item script file
/// @param funcsset block callbacks set
void load_block_script(int env, std::string prefix, fs::path file, block_funcs_set& funcsset); void load_block_script(int env, std::string prefix, fs::path file, block_funcs_set& funcsset);
/** Load script associated with an Item */
/// @brief Load script associated with an Item
/// @param env environment id
/// @param prefix pack id
/// @param file item script file
/// @param funcsset item callbacks set
void load_item_script(int env, std::string prefix, fs::path file, item_funcs_set& funcsset); void load_item_script(int env, std::string prefix, fs::path file, item_funcs_set& funcsset);
/** /// @brief Load package-specific world script
* Load package-specific world script /// @param env environment id
* @param env environment id /// @param packid content-pack id
* @param packid content-pack id /// @param file script file path
* @param file script file path
*/
void load_world_script(int env, std::string packid, fs::path file); void load_world_script(int env, std::string packid, fs::path file);
/** Load script associated with an UiDocument */ /// @brief Load script associated with an UiDocument
/// @param env environment id
/// @param prefix pack id
/// @param file item script file
/// @param script document script info
void load_layout_script(int env, std::string prefix, fs::path file, uidocscript& script); void load_layout_script(int env, std::string prefix, fs::path file, uidocscript& script);
/** Finalize lua state. Using scripting after will lead to Lua panic */ /// @brief Finalize lua state. Using scripting after will lead to Lua panic
void close(); void close();
} }