void load_float_setting(LuaEnvironment& env)
{
env.load_module_function("FloatSetting", "value", float_setting_value);
env.load_module_function("FloatSetting", "synopsis", float_setting_synopsis);
env.load_module_function("FloatSetting", "min", float_setting_min);
env.load_module_function("FloatSetting", "max", float_setting_max);
env.load_module_function("FloatSetting", "update", float_setting_update);
}
void load_touch(LuaEnvironment& env)
{
env.load_module_function("Touch", "pointer_down", touch_pointer_down);
env.load_module_function("Touch", "pointer_up", touch_pointer_up);
env.load_module_function("Touch", "any_down", touch_any_down);
env.load_module_function("Touch", "any_up", touch_any_up);
env.load_module_function("Touch", "pointer_xy", touch_pointer_xy);
}
//-----------------------------------------------------------------------------
void load_quaternionbox(LuaEnvironment& env)
{
env.load_module_function("QuaternionBox", "new", quaternionbox_new);
env.load_module_function("QuaternionBox", "store", quaternionbox_store);
env.load_module_function("QuaternionBox", "unbox", quaternionbox_unbox);
env.load_module_function("QuaternionBox", "__tostring", quaternionbox_tostring);
env.load_module_constructor("QuaternionBox", quaternionbox_ctor);
}
//-----------------------------------------------------------------------------
void load_sprite(LuaEnvironment& env)
{
env.load_module_function("Sprite", "local_position", sprite_local_position);
env.load_module_function("Sprite", "local_rotation", sprite_local_rotation);
env.load_module_function("Sprite", "local_pose", sprite_local_pose);
env.load_module_function("Sprite", "set_local_position", sprite_set_local_position);
env.load_module_function("Sprite", "set_local_rotation", sprite_set_local_rotation);
env.load_module_function("Sprite", "set_local_pose", sprite_set_local_pose);
env.load_module_function("Sprite", "set_frame", sprite_set_frame);
}
void load_vector2box(LuaEnvironment& env)
{
env.load_module_function("Vector2Box", "new", vector2box_new);
env.load_module_function("Vector2Box", "store", vector2box_store);
env.load_module_function("Vector2Box", "unbox", vector2box_unbox);
env.load_module_function("Vector2Box", "__index", vector2box_get_value);
env.load_module_function("Vector2Box", "__newindex", vector2box_set_value);
env.load_module_function("Vector2Box", "__tostring", vector2box_tostring);
env.load_module_constructor("Vector2Box", vector2box_ctor);
}
int LuaEnv_Engine::GetTotalEntityCount(LuaEnvironment &env)
{
// First arg is self
//Engine* engine = LuaEnvironment::convertUserdata<Engine>(state, 1, "jl.Engine");
if(env.readGlobal("SAUROBYTE_GAME"))
{
Engine *engine = env.readStack<Engine*>("Saurobyte_Engine");
env.pushArgs(engine->getEntityPool().getEntityCount());
}
//lua_pushnumber(state, engine->getEntityPool().getEntityCount());
return 1;
}
int LuaEnv_Audio::PlayStream(LuaEnvironment &env)
{
// First arg is name of sound
std::string soundName = env.readArg<std::string>();
AudioHandle sound = AudioDevice::playStream(soundName);
if(sound->isValid())
env.pushArgs(true);
else
env.pushArgs(false);
return 1;
}
int LuaEnv_Engine::GetWindowWidth(LuaEnvironment &env)
{
// First arg is self
//Engine* engine = LuaEnvironment::convertUserdata<Engine>(state, 1, "jl.Engine");
if(env.readGlobal("SAUROBYTE_GAME"))
{
Engine *engine = env.readStack<Engine*>("Saurobyte_Engine");
env.pushArgs(engine->getWindow().getSize().x);
}
//lua_pushnumber(state, engine->getWindow().getSize().x);
return 1;
}
bool Event::checkScript(const std::string& basePath, const std::string& scriptsName, const std::string& scriptFile)
{
LuaScriptInterface* testInterface = g_luaEnvironment.getTestInterface();
testInterface->reInitState();
if (testInterface->loadFile(std::string(basePath + "lib/" + scriptsName + ".lua")) == -1) {
std::cout << "[Warning - Event::checkScript] Can not load " << scriptsName << " lib/" << scriptsName << ".lua" << std::endl;
}
if (m_scriptId != 0) {
std::cout << "[Failure - Event::checkScript] scriptid = " << m_scriptId << std::endl;
return false;
}
if (testInterface->loadFile(basePath + scriptFile) == -1) {
std::cout << "[Warning - Event::checkScript] Can not load script: " << scriptFile << std::endl;
std::cout << testInterface->getLastLuaError() << std::endl;
return false;
}
const std::string& eventName = getScriptEventName();
int32_t id = testInterface->getEvent(eventName);
if (id == -1) {
std::cout << "[Warning - Event::checkScript] Event " << eventName << " not found. " << scriptFile << std::endl;
return false;
}
return true;
}
// Get component name
int LuaEnv_Component::GetComponentName(LuaEnvironment &env)
{
// First argument is self
BaseComponent *comp = env.readArg<BaseComponent*>("Saurobyte_Component");
env.pushArgs(comp->getName());
return 1;
}
bool ScriptingManager::loadScriptSystems()
{
if (g_luaEnvironment.loadFile("data/global.lua") == -1) {
std::cout << "[Warning - ScriptingManager::loadScriptSystems] Can not load data/global.lua" << std::endl;
}
g_weapons = new Weapons();
if (!g_weapons->loadFromXml()) {
std::cout << "> ERROR: Unable to load weapons!" << std::endl;
return false;
}
g_weapons->loadDefaults();
g_spells = new Spells();
if (!g_spells->loadFromXml()) {
std::cout << "> ERROR: Unable to load spells!" << std::endl;
return false;
}
g_actions = new Actions();
if (!g_actions->loadFromXml()) {
std::cout << "> ERROR: Unable to load actions!" << std::endl;
return false;
}
g_talkActions = new TalkActions();
if (!g_talkActions->loadFromXml()) {
std::cout << "> ERROR: Unable to load talk actions!" << std::endl;
return false;
}
g_moveEvents = new MoveEvents();
if (!g_moveEvents->loadFromXml()) {
std::cout << "> ERROR: Unable to load move events!" << std::endl;
return false;
}
g_creatureEvents = new CreatureEvents();
if (!g_creatureEvents->loadFromXml()) {
std::cout << "> ERROR: Unable to load creature events!" << std::endl;
return false;
}
g_globalEvents = new GlobalEvents();
if (!g_globalEvents->loadFromXml()) {
std::cout << "> ERROR: Unable to load global events!" << std::endl;
return false;
}
g_events = new Events();
if (!g_events->load()) {
std::cout << "> ERROR: Unable to load events!" << std::endl;
return false;
}
return true;
}
//-----------------------------------------------------------------------------
void load_window(LuaEnvironment& env)
{
env.load_module_function("Window", "show", window_show);
env.load_module_function("Window", "hide", window_hide);
env.load_module_function("Window", "get_size", window_get_size);
env.load_module_function("Window", "get_position", window_get_position);
env.load_module_function("Window", "resize", window_resize);
env.load_module_function("Window", "move", window_move);
env.load_module_function("Window", "show_cursor", window_show_cursor);
env.load_module_function("Window", "hide_cursor", window_hide_cursor);
env.load_module_function("Window", "get_cursor_xy", window_get_cursor_xy);
env.load_module_function("Window", "set_cursor_xy", window_set_cursor_xy);
env.load_module_function("Window", "title", window_title);
env.load_module_function("Window", "set_title", window_set_title);
}
void load_debug_line(LuaEnvironment& env)
{
env.load_module_function("DebugLine", "add_line", debug_line_add_line);
env.load_module_function("DebugLine", "add_sphere", debug_line_add_sphere);
env.load_module_function("DebugLine", "add_obb", debug_line_add_obb);
env.load_module_function("DebugLine", "clear", debug_line_clear);
env.load_module_function("DebugLine", "commit", debug_line_commit);
env.load_module_function("DebugLine", "__index", "DebugLine");
env.load_module_function("DebugLine", "__tostring", debug_line_tostring);
}
bool NpcScriptInterface::initState()
{
luaState = g_luaEnvironment.getLuaState();
if (!luaState) {
return false;
}
registerFunctions();
lua_newtable(luaState);
eventTableRef = luaL_ref(luaState, LUA_REGISTRYINDEX);
runningEventId = EVENT_ID_USER;
return true;
}
int LuaEnv_Engine::GetActiveScene(LuaEnvironment &env)
{
// First arg is self
if(env.readGlobal("SAUROBYTE_GAME"))
{
Engine *engine = env.readStack<Engine*>("Saurobyte_Engine");
Scene *activeScene = engine->getScenePool().getActiveScene();
if(activeScene == nullptr)
env.pushNil();
else
env.pushObject<Scene*>(activeScene, "Saurobyte_Scene");
}
//Engine* engine = LuaEnvironment::convertUserdata<Engine>(state, 1, "jl.Engine");
//Scene *activeScene = engine->getScenePool().getActiveScene();
return 1;
}
//-----------------------------------------------------------------------------
void load_resource_package(LuaEnvironment& env)
{
env.load_module_function("ResourcePackage", "load", resource_package_load);
env.load_module_function("ResourcePackage", "unload", resource_package_unload);
env.load_module_function("ResourcePackage", "flush", resource_package_flush);
env.load_module_function("ResourcePackage", "has_loaded", resource_package_has_loaded);
env.load_module_function("ResourcePackage", "__index", "ResourcePackage");
env.load_module_function("ResourcePackage", "__tostring", resource_package_tostring);
}
//-----------------------------------------------------------------------------
void load_mouse(LuaEnvironment& env)
{
env.load_module_function("Mouse", "button_pressed", mouse_button_pressed);
env.load_module_function("Mouse", "button_released", mouse_button_released);
env.load_module_function("Mouse", "cursor_xy", mouse_cursor_xy);
env.load_module_function("Mouse", "set_cursor_xy", mouse_set_cursor_xy);
env.load_module_function("Mouse", "cursor_relative_xy", mouse_cursor_relative_xy);
env.load_module_function("Mouse", "set_cursor_relative_xy", mouse_set_cursor_relative_xy);
}
int LuaEnv_Engine::ChangeScene(LuaEnvironment &env)
{
// First arg is self
if(env.readGlobal("SAUROBYTE_GAME"))
{
Engine *engine = env.readStack<Engine*>("Saurobyte_Engine");
std::string sceneName = env.readArg<std::string>();
engine->changeScene(sceneName.c_str());
}
//Engine* engine = env.toObject<Engine*>(state, 1, "jl.Engine");
// Second argument is scene name
//std::string sceneName = luaL_checkstring(state, 2);
return 0;
}
int LuaEnv_Engine::DeleteScene(LuaEnvironment &env)
{
// First arg is self
if(env.readGlobal("SAUROBYTE_GAME"))
{
Engine *engine = env.readStack<Engine*>("Saurobyte_Engine");
std::string sceneName = env.readArg<std::string>();
engine->getScenePool().deleteScene(sceneName.c_str());
}
//Engine* engine = LuaEnvironment::convertUserdata<Engine>(state, 1, "jl.Engine");
/// Second argument is scene name
//std::string sceneName = luaL_checkstring(state, 2);
//lua_settop(state, 0);
return 0;
}
int LuaEnv_Engine::MoveCamera(LuaEnvironment &env)
{
// First arg is self
//Engine* engine = LuaEnvironment::convertUserdata<Engine>(state, 1, "jl.Engine");
if(env.readGlobal("SAUROBYTE_GAME"))
{
Engine *engine = env.readStack<Engine*>("Saurobyte_Engine");
// 2nd arg is X offset, 3rd arg is Y offset, 4th arg is Z offset
float xOff = env.readArg<float>();
float yOff = env.readArg<float>();
float zOff = env.readArg<float>();
}
//engine->getScenePool().getActiveScene()->getCamera().move(glm::vec3(xOff, yOff, zOff));
return 0;
}
void load_string_setting(LuaEnvironment& env)
{
env.load_module_function("StringSetting", "value", string_setting_value);
env.load_module_function("StringSetting", "synopsis", string_setting_synopsis);
env.load_module_function("StringSetting", "update", string_setting_update);
}
void load_mouse(LuaEnvironment& env)
{
env.load_module_function("Mouse", "button_pressed", mouse_button_pressed);
env.load_module_function("Mouse", "button_released", mouse_button_released);
env.load_module_function("Mouse", "any_pressed", mouse_any_pressed);
env.load_module_function("Mouse", "any_released", mouse_any_released);
env.load_module_function("Mouse", "cursor_xy", mouse_cursor_xy);
env.load_module_function("Mouse", "set_cursor_xy", mouse_set_cursor_xy);
env.load_module_function("Mouse", "cursor_relative_xy", mouse_cursor_relative_xy);
env.load_module_function("Mouse", "set_cursor_relative_xy", mouse_set_cursor_relative_xy);
env.load_module_function("Mouse", "wheel", mouse_wheel);
env.load_module_enum("Mouse", "LEFT", MouseButton::LEFT);
env.load_module_enum("Mouse", "MIDDLE", MouseButton::MIDDLE);
env.load_module_enum("Mouse", "RIGHT", MouseButton::RIGHT);
}
void Commands::reloadInfo(Player& player, const std::string& param)
{
std::string tmpParam = asLowerCaseString(param);
if (tmpParam == "action" || tmpParam == "actions") {
g_actions->reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded actions.");
} else if (tmpParam == "config" || tmpParam == "configuration") {
g_config.reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded config.");
} else if (tmpParam == "command" || tmpParam == "commands") {
reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded commands.");
} else if (tmpParam == "creaturescript" || tmpParam == "creaturescripts") {
g_creatureEvents->reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded creature scripts.");
} else if (tmpParam == "monster" || tmpParam == "monsters") {
g_monsters.reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded monsters.");
} else if (tmpParam == "move" || tmpParam == "movement" || tmpParam == "movements"
|| tmpParam == "moveevents" || tmpParam == "moveevent") {
g_moveEvents->reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded movements.");
} else if (tmpParam == "npc" || tmpParam == "npcs") {
Npcs::reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded npcs.");
} else if (tmpParam == "raid" || tmpParam == "raids") {
Raids::getInstance()->reload();
Raids::getInstance()->startup();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded raids.");
} else if (tmpParam == "spell" || tmpParam == "spells") {
g_spells->reload();
g_monsters.reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded spells.");
} else if (tmpParam == "talk" || tmpParam == "talkaction" || tmpParam == "talkactions") {
g_talkActions->reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded talk actions.");
} else if (tmpParam == "items") {
Item::items.reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded items.");
} else if (tmpParam == "weapon" || tmpParam == "weapons") {
g_weapons->reload();
g_weapons->loadDefaults();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded weapons.");
} else if (tmpParam == "quest" || tmpParam == "quests") {
Quests::getInstance()->reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded quests.");
} else if (tmpParam == "mount" || tmpParam == "mounts") {
Mounts::getInstance()->reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded mounts.");
} else if (tmpParam == "globalevents" || tmpParam == "globalevent") {
g_globalEvents->reload();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded globalevents.");
} else if (tmpParam == "events") {
g_events->load();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded events.");
} else if (tmpParam == "chat" || tmpParam == "channel" || tmpParam == "chatchannels") {
g_chat.load();
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded chatchannels.");
} else if (tmpParam == "global") {
g_luaEnvironment.loadFile("data/global.lua");
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reloaded global.lua.");
} else {
player.sendTextMessage(MESSAGE_STATUS_CONSOLE_BLUE, "Reload type not found.");
}
}
//-----------------------------------------------------------------------------
void load_actor(LuaEnvironment& env)
{
env.load_module_function("Actor", "world_position", actor_world_position);
env.load_module_function("Actor", "world_rotation", actor_world_rotation);
env.load_module_function("Actor", "world_pose", actor_world_pose);
env.load_module_function("Actor", "teleport_world_position", actor_teleport_world_position);
env.load_module_function("Actor", "teleport_world_rotation", actor_teleport_world_rotation);
env.load_module_function("Actor", "teleport_world_pose", actor_teleport_world_pose);
env.load_module_function("Actor", "center_of_mass", actor_center_of_mass);
env.load_module_function("Actor", "enable_gravity", actor_enable_gravity);
env.load_module_function("Actor", "disable_gravity", actor_disable_gravity);
env.load_module_function("Actor", "enable_collision", actor_enable_collision);
env.load_module_function("Actor", "set_collision_filter", actor_set_collision_filter);
env.load_module_function("Actor", "disable_collision", actor_disable_collision);
env.load_module_function("Actor", "set_kinematic", actor_set_kinematic);
env.load_module_function("Actor", "move", actor_move);
env.load_module_function("Actor", "is_static", actor_is_static);
env.load_module_function("Actor", "is_dynamic", actor_is_dynamic);
env.load_module_function("Actor", "is_kinematic", actor_is_kinematic);
env.load_module_function("Actor", "is_nonkinematic", actor_is_nonkinematic);
env.load_module_function("Actor", "linear_damping", actor_linear_damping);
env.load_module_function("Actor", "set_linear_damping", actor_set_linear_damping);
env.load_module_function("Actor", "angular_damping", actor_angular_damping);
env.load_module_function("Actor", "set_angular_damping", actor_set_angular_damping);
env.load_module_function("Actor", "linear_velocity", actor_linear_velocity);
env.load_module_function("Actor", "set_linear_velocity", actor_set_linear_velocity);
env.load_module_function("Actor", "angular_velocity", actor_angular_velocity);
env.load_module_function("Actor", "set_angular_velocity", actor_set_angular_velocity);
env.load_module_function("Actor", "add_impulse", actor_add_impulse);
env.load_module_function("Actor", "add_impulse_at", actor_add_impulse_at);
env.load_module_function("Actor", "add_torque_impulse", actor_add_torque_impulse);
env.load_module_function("Actor", "push", actor_push);
env.load_module_function("Actor", "push_at", actor_push_at);
env.load_module_function("Actor", "is_sleeping", actor_is_sleeping);
env.load_module_function("Actor", "wake_up", actor_wake_up);
env.load_module_function("Actor", "unit", actor_unit);
}
void load_vector3(LuaEnvironment& env)
{
env.load_module_function("Vector3", "new", vector3_new);
env.load_module_function("Vector3", "x", vector3_x);
env.load_module_function("Vector3", "y", vector3_y);
env.load_module_function("Vector3", "z", vector3_z);
env.load_module_function("Vector3", "set_x", vector3_set_x);
env.load_module_function("Vector3", "set_y", vector3_set_y);
env.load_module_function("Vector3", "set_z", vector3_set_z);
env.load_module_function("Vector3", "values", vector3_values);
env.load_module_function("Vector3", "add", vector3_add);
env.load_module_function("Vector3", "subtract", vector3_subtract);
env.load_module_function("Vector3", "multiply", vector3_multiply);
env.load_module_function("Vector3", "divide", vector3_divide);
env.load_module_function("Vector3", "dot", vector3_dot);
env.load_module_function("Vector3", "cross", vector3_cross);
env.load_module_function("Vector3", "equal", vector3_equal);
env.load_module_function("Vector3", "length", vector3_length);
env.load_module_function("Vector3", "squared_length", vector3_squared_length);
env.load_module_function("Vector3", "set_length", vector3_set_length);
env.load_module_function("Vector3", "normalize", vector3_normalize);
env.load_module_function("Vector3", "distance", vector3_distance);
env.load_module_function("Vector3", "angle", vector3_angle);
env.load_module_function("Vector3", "forward", vector3_forward);
env.load_module_function("Vector3", "backward", vector3_backward);
env.load_module_function("Vector3", "left", vector3_left);
env.load_module_function("Vector3", "right", vector3_right);
env.load_module_function("Vector3", "up", vector3_up);
env.load_module_function("Vector3", "down", vector3_down);
env.load_module_constructor("Vector3", vector3_ctor);
env.load_module_function("Vector2", "new", vector2_new);
env.load_module_constructor("Vector2", vector2_ctor);
env.load_module_function("Vector3Box", "new", vector3box_new);
env.load_module_function("Vector3Box", "store", vector3box_store);
env.load_module_function("Vector3Box", "unbox", vector3box_unbox);
env.load_module_function("Vector3Box", "__index", vector3box_get_value);
env.load_module_function("Vector3Box", "__newindex", vector3box_set_value);
env.load_module_function("Vector3Box", "__tostring", vector3box_tostring);
env.load_module_constructor("Vector3Box", vector3box_ctor);
}
bool CombatSpell::loadScriptCombat()
{
combat = g_luaEnvironment.getCombatObject(g_luaEnvironment.lastCombatId);
return combat != nullptr;
}
void load_quaternion(LuaEnvironment& env)
{
env.load_module_function("Quaternion", "new", quaternion_new);
env.load_module_function("Quaternion", "negate", quaternion_negate);
env.load_module_function("Quaternion", "identity", quaternion_identity);
env.load_module_function("Quaternion", "multiply", quaternion_multiply);
env.load_module_function("Quaternion", "multiply_by_scalar", quaternion_multiply_by_scalar);
env.load_module_function("Quaternion", "length", quaternion_length);
env.load_module_function("Quaternion", "normalize", quaternion_normalize);
env.load_module_function("Quaternion", "conjugate", quaternion_conjugate);
env.load_module_function("Quaternion", "inverse", quaternion_inverse);
env.load_module_function("Quaternion", "power", quaternion_power);
env.load_module_function("Quaternion", "elements", quaternion_elements);
env.load_module_constructor("Quaternion", quaternion_ctor);
env.load_module_function("QuaternionBox", "new", quaternionbox_new);
env.load_module_function("QuaternionBox", "store", quaternionbox_store);
env.load_module_function("QuaternionBox", "unbox", quaternionbox_unbox);
env.load_module_function("QuaternionBox", "__tostring", quaternionbox_tostring);
env.load_module_constructor("QuaternionBox", quaternionbox_ctor);
}
void LuaStack::check_temporary(int i, const Vector3* p)
{
LuaEnvironment* env = device()->lua_environment();
if (!is_pointer(i) || !env->is_vector3(p))
luaL_typerror(L, i, "Vector3");
}
void LuaStack::check_temporary(int i, const Quaternion* p)
{
LuaEnvironment* env = device()->lua_environment();
if (!is_pointer(i) || !env->is_quaternion(p))
luaL_typerror(L, i, "Quaternion");
}
void LuaStack::check_temporary(int i, const Matrix4x4* p)
{
LuaEnvironment* env = device()->lua_environment();
if (!is_pointer(i) || !env->is_matrix4x4(p))
luaL_typerror(L, i, "Matrix4x4");
}
