Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- /**
- * The Forgotten Server - a free and open-source MMORPG server emulator
- * Copyright (C) 2016 Mark Samman <mark.samman@gmail.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
- #include "otpch.h"
- #include <boost/range/adaptor/reversed.hpp>
- #include "luascript.h"
- #include "chat.h"
- #include "player.h"
- #include "game.h"
- #include "protocolstatus.h"
- #include "spells.h"
- #include "iologindata.h"
- #include "configmanager.h"
- #include "teleport.h"
- #include "databasemanager.h"
- #include "bed.h"
- #include "monster.h"
- #include "scheduler.h"
- #include "databasetasks.h"
- #include "scriptmanager.h"
- #include "store.h"
- extern Chat* g_chat;
- extern Game g_game;
- extern Monsters g_monsters;
- extern ConfigManager g_config;
- extern Vocations g_vocations;
- extern Spells* g_spells;
- extern Store* g_store;
- enum {
- EVENT_ID_LOADING = 1,
- EVENT_ID_USER = 1000,
- };
- ScriptEnvironment::DBResultMap ScriptEnvironment::m_tempResults;
- uint32_t ScriptEnvironment::m_lastResultId = 0;
- std::multimap<ScriptEnvironment*, Item*> ScriptEnvironment::tempItems;
- LuaEnvironment g_luaEnvironment;
- ScriptEnvironment::ScriptEnvironment()
- {
- m_curNpc = nullptr;
- resetEnv();
- m_lastUID = std::numeric_limits<uint16_t>::max();
- }
- ScriptEnvironment::~ScriptEnvironment()
- {
- resetEnv();
- }
- void ScriptEnvironment::resetEnv()
- {
- m_scriptId = 0;
- m_callbackId = 0;
- m_timerEvent = false;
- m_interface = nullptr;
- localMap.clear();
- m_tempResults.clear();
- auto pair = tempItems.equal_range(this);
- auto it = pair.first;
- while (it != pair.second) {
- Item* item = it->second;
- if (item->getParent() == VirtualCylinder::virtualCylinder) {
- g_game.ReleaseItem(item);
- }
- it = tempItems.erase(it);
- }
- }
- bool ScriptEnvironment::setCallbackId(int32_t callbackId, LuaScriptInterface* scriptInterface)
- {
- if (m_callbackId != 0) {
- //nested callbacks are not allowed
- if (m_interface) {
- m_interface->reportErrorFunc("Nested callbacks!");
- }
- return false;
- }
- m_callbackId = callbackId;
- m_interface = scriptInterface;
- return true;
- }
- void ScriptEnvironment::getEventInfo(int32_t& scriptId, std::string& desc, LuaScriptInterface*& scriptInterface, int32_t& callbackId, bool& timerEvent) const
- {
- scriptId = m_scriptId;
- desc = m_eventdesc;
- scriptInterface = m_interface;
- callbackId = m_callbackId;
- timerEvent = m_timerEvent;
- }
- uint32_t ScriptEnvironment::addThing(Thing* thing)
- {
- if (!thing || thing->isRemoved()) {
- return 0;
- }
- Creature* creature = thing->getCreature();
- if (creature) {
- return creature->getID();
- }
- Item* item = thing->getItem();
- if (item && item->hasAttribute(ITEM_ATTRIBUTE_UNIQUEID)) {
- return item->getUniqueId();
- }
- for (const auto& it : localMap) {
- if (it.second == item) {
- return it.first;
- }
- }
- localMap[++m_lastUID] = item;
- return m_lastUID;
- }
- void ScriptEnvironment::insertItem(uint32_t uid, Item* item)
- {
- auto result = localMap.emplace(uid, item);
- if (!result.second) {
- std::cout << std::endl << "Lua Script Error: Thing uid already taken.";
- }
- }
- Thing* ScriptEnvironment::getThingByUID(uint32_t uid)
- {
- if (uid >= 0x10000000) {
- return g_game.getCreatureByID(uid);
- }
- if (uid <= std::numeric_limits<uint16_t>::max()) {
- Item* item = g_game.getUniqueItem(uid);
- if (item && !item->isRemoved()) {
- return item;
- }
- return nullptr;
- }
- auto it = localMap.find(uid);
- if (it != localMap.end()) {
- Item* item = it->second;
- if (!item->isRemoved()) {
- return item;
- }
- }
- return nullptr;
- }
- Item* ScriptEnvironment::getItemByUID(uint32_t uid)
- {
- Thing* thing = getThingByUID(uid);
- if (!thing) {
- return nullptr;
- }
- return thing->getItem();
- }
- Container* ScriptEnvironment::getContainerByUID(uint32_t uid)
- {
- Item* item = getItemByUID(uid);
- if (!item) {
- return nullptr;
- }
- return item->getContainer();
- }
- void ScriptEnvironment::removeItemByUID(uint32_t uid)
- {
- if (uid <= std::numeric_limits<uint16_t>::max()) {
- g_game.removeUniqueItem(uid);
- return;
- }
- auto it = localMap.find(uid);
- if (it != localMap.end()) {
- localMap.erase(it);
- }
- }
- void ScriptEnvironment::addTempItem(Item* item)
- {
- tempItems.emplace(this, item);
- }
- void ScriptEnvironment::removeTempItem(Item* item)
- {
- for (auto it = tempItems.begin(), end = tempItems.end(); it != end; ++it) {
- if (it->second == item) {
- tempItems.erase(it);
- break;
- }
- }
- }
- uint32_t ScriptEnvironment::addResult(DBResult_ptr res)
- {
- m_tempResults[++m_lastResultId] = res;
- return m_lastResultId;
- }
- bool ScriptEnvironment::removeResult(uint32_t id)
- {
- auto it = m_tempResults.find(id);
- if (it == m_tempResults.end()) {
- return false;
- }
- m_tempResults.erase(it);
- return true;
- }
- DBResult_ptr ScriptEnvironment::getResultByID(uint32_t id)
- {
- auto it = m_tempResults.find(id);
- if (it == m_tempResults.end()) {
- return nullptr;
- }
- return it->second;
- }
- std::string LuaScriptInterface::getErrorDesc(ErrorCode_t code)
- {
- switch (code) {
- case LUA_ERROR_PLAYER_NOT_FOUND: return "Player not found";
- case LUA_ERROR_CREATURE_NOT_FOUND: return "Creature not found";
- case LUA_ERROR_ITEM_NOT_FOUND: return "Item not found";
- case LUA_ERROR_THING_NOT_FOUND: return "Thing not found";
- case LUA_ERROR_TILE_NOT_FOUND: return "Tile not found";
- case LUA_ERROR_HOUSE_NOT_FOUND: return "House not found";
- case LUA_ERROR_COMBAT_NOT_FOUND: return "Combat not found";
- case LUA_ERROR_CONDITION_NOT_FOUND: return "Condition not found";
- case LUA_ERROR_AREA_NOT_FOUND: return "Area not found";
- case LUA_ERROR_CONTAINER_NOT_FOUND: return "Container not found";
- case LUA_ERROR_VARIANT_NOT_FOUND: return "Variant not found";
- case LUA_ERROR_VARIANT_UNKNOWN: return "Unknown variant type";
- case LUA_ERROR_SPELL_NOT_FOUND: return "Spell not found";
- default: return "Bad error code";
- }
- }
- ScriptEnvironment LuaScriptInterface::m_scriptEnv[16];
- int32_t LuaScriptInterface::m_scriptEnvIndex = -1;
- LuaScriptInterface::LuaScriptInterface(std::string interfaceName)
- : m_luaState(nullptr), m_interfaceName(interfaceName), m_eventTableRef(-1), m_runningEventId(EVENT_ID_USER)
- {
- if (!g_luaEnvironment.getLuaState()) {
- g_luaEnvironment.initState();
- }
- }
- LuaScriptInterface::~LuaScriptInterface()
- {
- closeState();
- }
- bool LuaScriptInterface::reInitState()
- {
- g_luaEnvironment.clearCombatObjects(this);
- g_luaEnvironment.clearAreaObjects(this);
- closeState();
- return initState();
- }
- /// Same as lua_pcall, but adds stack trace to error strings in called function.
- int LuaScriptInterface::protectedCall(lua_State* L, int nargs, int nresults)
- {
- int error_index = lua_gettop(L) - nargs;
- lua_pushcfunction(L, luaErrorHandler);
- lua_insert(L, error_index);
- int ret = lua_pcall(L, nargs, nresults, error_index);
- lua_remove(L, error_index);
- return ret;
- }
- int32_t LuaScriptInterface::loadFile(const std::string& file, Npc* npc /* = nullptr*/)
- {
- //loads file as a chunk at stack top
- int ret = luaL_loadfile(m_luaState, file.c_str());
- if (ret != 0) {
- m_lastLuaError = popString(m_luaState);
- return -1;
- }
- //check that it is loaded as a function
- if (!isFunction(m_luaState, -1)) {
- return -1;
- }
- m_loadingFile = file;
- if (!reserveScriptEnv()) {
- return -1;
- }
- ScriptEnvironment* env = getScriptEnv();
- env->setScriptId(EVENT_ID_LOADING, this);
- env->setNpc(npc);
- //execute it
- ret = protectedCall(m_luaState, 0, 0);
- if (ret != 0) {
- reportError(nullptr, popString(m_luaState));
- resetScriptEnv();
- return -1;
- }
- resetScriptEnv();
- return 0;
- }
- int32_t LuaScriptInterface::getEvent(const std::string& eventName)
- {
- //get our events table
- lua_rawgeti(m_luaState, LUA_REGISTRYINDEX, m_eventTableRef);
- if (!isTable(m_luaState, -1)) {
- lua_pop(m_luaState, 1);
- return -1;
- }
- //get current event function pointer
- lua_getglobal(m_luaState, eventName.c_str());
- if (!isFunction(m_luaState, -1)) {
- lua_pop(m_luaState, 2);
- return -1;
- }
- //save in our events table
- lua_pushvalue(m_luaState, -1);
- lua_rawseti(m_luaState, -3, m_runningEventId);
- lua_pop(m_luaState, 2);
- //reset global value of this event
- lua_pushnil(m_luaState);
- lua_setglobal(m_luaState, eventName.c_str());
- m_cacheFiles[m_runningEventId] = m_loadingFile + ":" + eventName;
- return m_runningEventId++;
- }
- int32_t LuaScriptInterface::getMetaEvent(const std::string& globalName, const std::string& eventName)
- {
- //get our events table
- lua_rawgeti(m_luaState, LUA_REGISTRYINDEX, m_eventTableRef);
- if (!isTable(m_luaState, -1)) {
- lua_pop(m_luaState, 1);
- return -1;
- }
- //get current event function pointer
- lua_getglobal(m_luaState, globalName.c_str());
- lua_getfield(m_luaState, -1, eventName.c_str());
- if (!isFunction(m_luaState, -1)) {
- lua_pop(m_luaState, 3);
- return -1;
- }
- //save in our events table
- lua_pushvalue(m_luaState, -1);
- lua_rawseti(m_luaState, -4, m_runningEventId);
- lua_pop(m_luaState, 1);
- //reset global value of this event
- lua_pushnil(m_luaState);
- lua_setfield(m_luaState, -2, eventName.c_str());
- lua_pop(m_luaState, 2);
- m_cacheFiles[m_runningEventId] = m_loadingFile + ":" + globalName + "@" + eventName;
- return m_runningEventId++;
- }
- const std::string& LuaScriptInterface::getFileById(int32_t scriptId)
- {
- if (scriptId == EVENT_ID_LOADING) {
- return m_loadingFile;
- }
- auto it = m_cacheFiles.find(scriptId);
- if (it == m_cacheFiles.end()) {
- static const std::string& unk = "(Unknown scriptfile)";
- return unk;
- }
- return it->second;
- }
- std::string LuaScriptInterface::getStackTrace(const std::string& error_desc)
- {
- lua_getglobal(m_luaState, "debug");
- if (!isTable(m_luaState, -1)) {
- lua_pop(m_luaState, 1);
- return error_desc;
- }
- lua_getfield(m_luaState, -1, "traceback");
- if (!isFunction(m_luaState, -1)) {
- lua_pop(m_luaState, 2);
- return error_desc;
- }
- lua_replace(m_luaState, -2);
- pushString(m_luaState, error_desc);
- lua_call(m_luaState, 1, 1);
- return popString(m_luaState);
- }
- void LuaScriptInterface::reportError(const char* function, const std::string& error_desc, bool stack_trace/* = false*/)
- {
- int32_t scriptId;
- int32_t callbackId;
- bool timerEvent;
- std::string event_desc;
- LuaScriptInterface* scriptInterface;
- getScriptEnv()->getEventInfo(scriptId, event_desc, scriptInterface, callbackId, timerEvent);
- std::cout << std::endl << "Lua Script Error: ";
- if (scriptInterface) {
- std::cout << '[' << scriptInterface->getInterfaceName() << "] " << std::endl;
- if (timerEvent) {
- std::cout << "in a timer event called from: " << std::endl;
- }
- if (callbackId) {
- std::cout << "in callback: " << scriptInterface->getFileById(callbackId) << std::endl;
- }
- std::cout << scriptInterface->getFileById(scriptId) << std::endl;
- }
- if (!event_desc.empty()) {
- std::cout << "Event: " << event_desc << std::endl;
- }
- if (function) {
- std::cout << function << "(). ";
- }
- if (stack_trace && scriptInterface) {
- std::cout << scriptInterface->getStackTrace(error_desc) << std::endl;
- } else {
- std::cout << error_desc << std::endl;
- }
- }
- bool LuaScriptInterface::pushFunction(int32_t functionId)
- {
- lua_rawgeti(m_luaState, LUA_REGISTRYINDEX, m_eventTableRef);
- if (!isTable(m_luaState, -1)) {
- return false;
- }
- lua_rawgeti(m_luaState, -1, functionId);
- lua_replace(m_luaState, -2);
- return isFunction(m_luaState, -1);
- }
- bool LuaScriptInterface::initState()
- {
- m_luaState = g_luaEnvironment.getLuaState();
- if (!m_luaState) {
- return false;
- }
- lua_newtable(m_luaState);
- m_eventTableRef = luaL_ref(m_luaState, LUA_REGISTRYINDEX);
- m_runningEventId = EVENT_ID_USER;
- return true;
- }
- bool LuaScriptInterface::closeState()
- {
- if (!g_luaEnvironment.getLuaState() || !m_luaState) {
- return false;
- }
- m_cacheFiles.clear();
- if (m_eventTableRef != -1) {
- luaL_unref(m_luaState, LUA_REGISTRYINDEX, m_eventTableRef);
- m_eventTableRef = -1;
- }
- m_luaState = nullptr;
- return true;
- }
- int LuaScriptInterface::luaErrorHandler(lua_State* L)
- {
- const std::string& errorMessage = popString(L);
- auto interface = getScriptEnv()->getScriptInterface();
- assert(interface); //This fires if the ScriptEnvironment hasn't been setup
- pushString(L, interface->getStackTrace(errorMessage));
- return 1;
- }
- bool LuaScriptInterface::callFunction(int params)
- {
- bool result = false;
- int size = lua_gettop(m_luaState);
- if (protectedCall(m_luaState, params, 1) != 0) {
- LuaScriptInterface::reportError(nullptr, LuaScriptInterface::getString(m_luaState, -1));
- } else {
- result = LuaScriptInterface::getBoolean(m_luaState, -1);
- }
- lua_pop(m_luaState, 1);
- if ((lua_gettop(m_luaState) + params + 1) != size) {
- LuaScriptInterface::reportError(nullptr, "Stack size changed!");
- }
- resetScriptEnv();
- return result;
- }
- void LuaScriptInterface::callVoidFunction(int params)
- {
- int size = lua_gettop(m_luaState);
- if (protectedCall(m_luaState, params, 0) != 0) {
- LuaScriptInterface::reportError(nullptr, LuaScriptInterface::popString(m_luaState));
- }
- if ((lua_gettop(m_luaState) + params + 1) != size) {
- LuaScriptInterface::reportError(nullptr, "Stack size changed!");
- }
- resetScriptEnv();
- }
- void LuaScriptInterface::pushVariant(lua_State* L, const LuaVariant& var)
- {
- lua_createtable(L, 0, 2);
- setField(L, "type", var.type);
- switch (var.type) {
- case VARIANT_NUMBER:
- setField(L, "number", var.number);
- break;
- case VARIANT_STRING:
- setField(L, "string", var.text);
- break;
- case VARIANT_TARGETPOSITION:
- case VARIANT_POSITION: {
- pushPosition(L, var.pos);
- lua_setfield(L, -2, "pos");
- break;
- }
- default:
- break;
- }
- setMetatable(L, -1, "Variant");
- }
- void LuaScriptInterface::pushThing(lua_State* L, Thing* thing)
- {
- if (!thing) {
- lua_createtable(L, 0, 4);
- setField(L, "uid", 0);
- setField(L, "itemid", 0);
- setField(L, "actionid", 0);
- setField(L, "type", 0);
- return;
- }
- if (Item* item = thing->getItem()) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- } else if (Creature* creature = thing->getCreature()) {
- pushUserdata<Creature>(L, creature);
- setCreatureMetatable(L, -1, creature);
- } else {
- lua_pushnil(L);
- }
- }
- void LuaScriptInterface::pushCylinder(lua_State* L, Cylinder* cylinder)
- {
- if (Creature* creature = cylinder->getCreature()) {
- pushUserdata<Creature>(L, creature);
- setCreatureMetatable(L, -1, creature);
- } else if (Item* parentItem = cylinder->getItem()) {
- pushUserdata<Item>(L, parentItem);
- setItemMetatable(L, -1, parentItem);
- } else if (Tile* tile = cylinder->getTile()) {
- pushUserdata<Tile>(L, tile);
- setMetatable(L, -1, "Tile");
- } else if (cylinder == VirtualCylinder::virtualCylinder) {
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- }
- void LuaScriptInterface::pushString(lua_State* L, const std::string& value)
- {
- lua_pushlstring(L, value.c_str(), value.length());
- }
- void LuaScriptInterface::pushCallback(lua_State* L, int32_t callback)
- {
- lua_rawgeti(L, LUA_REGISTRYINDEX, callback);
- }
- std::string LuaScriptInterface::popString(lua_State* L)
- {
- if (lua_gettop(L) == 0) {
- return std::string();
- }
- std::string str(getString(L, -1));
- lua_pop(L, 1);
- return str;
- }
- int32_t LuaScriptInterface::popCallback(lua_State* L)
- {
- return luaL_ref(L, LUA_REGISTRYINDEX);
- }
- // Metatables
- void LuaScriptInterface::setMetatable(lua_State* L, int32_t index, const std::string& name)
- {
- luaL_getmetatable(L, name.c_str());
- lua_setmetatable(L, index - 1);
- }
- void LuaScriptInterface::setWeakMetatable(lua_State* L, int32_t index, const std::string& name)
- {
- static std::set<std::string> weakObjectTypes;
- const std::string& weakName = name + "_weak";
- auto result = weakObjectTypes.emplace(name);
- if (result.second) {
- luaL_getmetatable(L, name.c_str());
- int childMetatable = lua_gettop(L);
- luaL_newmetatable(L, weakName.c_str());
- int metatable = lua_gettop(L);
- static const std::vector<std::string> methodKeys = {"__index", "__metatable", "__eq"};
- for (const std::string& metaKey : methodKeys) {
- lua_getfield(L, childMetatable, metaKey.c_str());
- lua_setfield(L, metatable, metaKey.c_str());
- }
- static const std::vector<int> methodIndexes = {'h', 'p', 't'};
- for (int metaIndex : methodIndexes) {
- lua_rawgeti(L, childMetatable, metaIndex);
- lua_rawseti(L, metatable, metaIndex);
- }
- lua_pushnil(L);
- lua_setfield(L, metatable, "__gc");
- lua_remove(L, childMetatable);
- } else {
- luaL_getmetatable(L, weakName.c_str());
- }
- lua_setmetatable(L, index - 1);
- }
- void LuaScriptInterface::setItemMetatable(lua_State* L, int32_t index, const Item* item)
- {
- if (item->getContainer()) {
- luaL_getmetatable(L, "Container");
- } else if (item->getTeleport()) {
- luaL_getmetatable(L, "Teleport");
- } else {
- luaL_getmetatable(L, "Item");
- }
- lua_setmetatable(L, index - 1);
- }
- void LuaScriptInterface::setCreatureMetatable(lua_State* L, int32_t index, const Creature* creature)
- {
- if (creature->getPlayer()) {
- luaL_getmetatable(L, "Player");
- } else if (creature->getMonster()) {
- luaL_getmetatable(L, "Monster");
- } else {
- luaL_getmetatable(L, "Npc");
- }
- lua_setmetatable(L, index - 1);
- }
- // Get
- std::string LuaScriptInterface::getString(lua_State* L, int32_t arg)
- {
- size_t len;
- const char* c_str = lua_tolstring(L, arg, &len);
- if (!c_str || len == 0) {
- return std::string();
- }
- return std::string(c_str, len);
- }
- Position LuaScriptInterface::getPosition(lua_State* L, int32_t arg, int32_t& stackpos)
- {
- Position position;
- position.x = getField<uint16_t>(L, arg, "x");
- position.y = getField<uint16_t>(L, arg, "y");
- position.z = getField<uint8_t>(L, arg, "z");
- lua_getfield(L, arg, "stackpos");
- if (lua_isnil(L, -1) == 1) {
- stackpos = 0;
- } else {
- stackpos = getNumber<int32_t>(L, -1);
- }
- lua_pop(L, 4);
- return position;
- }
- Position LuaScriptInterface::getPosition(lua_State* L, int32_t arg)
- {
- Position position;
- position.x = getField<uint16_t>(L, arg, "x");
- position.y = getField<uint16_t>(L, arg, "y");
- position.z = getField<uint8_t>(L, arg, "z");
- lua_pop(L, 3);
- return position;
- }
- Outfit_t LuaScriptInterface::getOutfit(lua_State* L, int32_t arg)
- {
- Outfit_t outfit;
- outfit.lookMount = getField<uint16_t>(L, arg, "lookMount");
- outfit.lookAddons = getField<uint8_t>(L, arg, "lookAddons");
- outfit.lookFeet = getField<uint8_t>(L, arg, "lookFeet");
- outfit.lookLegs = getField<uint8_t>(L, arg, "lookLegs");
- outfit.lookBody = getField<uint8_t>(L, arg, "lookBody");
- outfit.lookHead = getField<uint8_t>(L, arg, "lookHead");
- outfit.lookTypeEx = getField<uint16_t>(L, arg, "lookTypeEx");
- outfit.lookType = getField<uint16_t>(L, arg, "lookType");
- lua_pop(L, 8);
- return outfit;
- }
- LuaVariant LuaScriptInterface::getVariant(lua_State* L, int32_t arg)
- {
- LuaVariant var;
- switch (var.type = getField<LuaVariantType_t>(L, arg, "type")) {
- case VARIANT_NUMBER: {
- var.number = getField<uint32_t>(L, arg, "number");
- lua_pop(L, 2);
- break;
- }
- case VARIANT_STRING: {
- var.text = getFieldString(L, arg, "string");
- lua_pop(L, 2);
- break;
- }
- case VARIANT_POSITION:
- case VARIANT_TARGETPOSITION: {
- lua_getfield(L, arg, "pos");
- var.pos = getPosition(L, lua_gettop(L));
- lua_pop(L, 2);
- break;
- }
- default: {
- var.type = VARIANT_NONE;
- lua_pop(L, 1);
- break;
- }
- }
- return var;
- }
- Thing* LuaScriptInterface::getThing(lua_State* L, int32_t arg)
- {
- Thing* thing;
- if (lua_getmetatable(L, arg) != 0) {
- lua_rawgeti(L, -1, 't');
- switch(getNumber<uint32_t>(L, -1)) {
- case LuaData_Item:
- thing = getUserdata<Item>(L, arg);
- break;
- case LuaData_Container:
- thing = getUserdata<Container>(L, arg);
- break;
- case LuaData_Teleport:
- thing = getUserdata<Teleport>(L, arg);
- break;
- case LuaData_Player:
- thing = getUserdata<Player>(L, arg);
- break;
- case LuaData_Monster:
- thing = getUserdata<Monster>(L, arg);
- break;
- case LuaData_Npc:
- thing = getUserdata<Npc>(L, arg);
- break;
- default:
- thing = nullptr;
- break;
- }
- lua_pop(L, 2);
- } else {
- thing = getScriptEnv()->getThingByUID(getNumber<uint32_t>(L, arg));
- }
- return thing;
- }
- Creature* LuaScriptInterface::getCreature(lua_State* L, int32_t arg)
- {
- if (isUserdata(L, arg)) {
- return getUserdata<Creature>(L, arg);
- }
- return g_game.getCreatureByID(getNumber<uint32_t>(L, arg));
- }
- Player* LuaScriptInterface::getPlayer(lua_State* L, int32_t arg)
- {
- if (isUserdata(L, arg)) {
- return getUserdata<Player>(L, arg);
- }
- return g_game.getPlayerByID(getNumber<uint32_t>(L, arg));
- }
- std::string LuaScriptInterface::getFieldString(lua_State* L, int32_t arg, const std::string& key)
- {
- lua_getfield(L, arg, key.c_str());
- return getString(L, -1);
- }
- LuaDataType LuaScriptInterface::getUserdataType(lua_State* L, int32_t arg)
- {
- if (lua_getmetatable(L, arg) == 0) {
- return LuaData_Unknown;
- }
- lua_rawgeti(L, -1, 't');
- LuaDataType type = getNumber<LuaDataType>(L, -1);
- lua_pop(L, 2);
- return type;
- }
- // Push
- void LuaScriptInterface::pushBoolean(lua_State* L, bool value)
- {
- lua_pushboolean(L, value ? 1 : 0);
- }
- void LuaScriptInterface::pushPosition(lua_State* L, const Position& position, int32_t stackpos/* = 0*/)
- {
- lua_createtable(L, 0, 4);
- setField(L, "x", position.x);
- setField(L, "y", position.y);
- setField(L, "z", position.z);
- setField(L, "stackpos", stackpos);
- setMetatable(L, -1, "Position");
- }
- void LuaScriptInterface::pushOutfit(lua_State* L, const Outfit_t& outfit)
- {
- lua_createtable(L, 0, 8);
- setField(L, "lookType", outfit.lookType);
- setField(L, "lookTypeEx", outfit.lookTypeEx);
- setField(L, "lookHead", outfit.lookHead);
- setField(L, "lookBody", outfit.lookBody);
- setField(L, "lookLegs", outfit.lookLegs);
- setField(L, "lookFeet", outfit.lookFeet);
- setField(L, "lookAddons", outfit.lookAddons);
- setField(L, "lookMount", outfit.lookMount);
- }
- #define registerEnum(value) { std::string enumName = #value; registerGlobalVariable(enumName.substr(enumName.find_last_of(':') + 1), value); }
- #define registerEnumIn(tableName, value) { std::string enumName = #value; registerVariable(tableName, enumName.substr(enumName.find_last_of(':') + 1), value); }
- void LuaScriptInterface::registerFunctions()
- {
- //getPlayerFlagValue(cid, flag)
- lua_register(m_luaState, "getPlayerFlagValue", LuaScriptInterface::luaGetPlayerFlagValue);
- //getPlayerInstantSpellCount(cid)
- lua_register(m_luaState, "getPlayerInstantSpellCount", LuaScriptInterface::luaGetPlayerInstantSpellCount);
- //getPlayerInstantSpellInfo(cid, index)
- lua_register(m_luaState, "getPlayerInstantSpellInfo", LuaScriptInterface::luaGetPlayerInstantSpellInfo);
- //doPlayerAddItem(uid, itemid, <optional: default: 1> count/subtype)
- //doPlayerAddItem(cid, itemid, <optional: default: 1> count, <optional: default: 1> canDropOnMap, <optional: default: 1>subtype)
- //Returns uid of the created item
- lua_register(m_luaState, "doPlayerAddItem", LuaScriptInterface::luaDoPlayerAddItem);
- //doCreateItem(itemid, type/count, pos)
- //Returns uid of the created item, only works on tiles.
- lua_register(m_luaState, "doCreateItem", LuaScriptInterface::luaDoCreateItem);
- //doCreateItemEx(itemid, <optional> count/subtype)
- lua_register(m_luaState, "doCreateItemEx", LuaScriptInterface::luaDoCreateItemEx);
- //doTileAddItemEx(pos, uid)
- lua_register(m_luaState, "doTileAddItemEx", LuaScriptInterface::luaDoTileAddItemEx);
- //doMoveCreature(cid, direction)
- lua_register(m_luaState, "doMoveCreature", LuaScriptInterface::luaDoMoveCreature);
- //doSetCreatureLight(cid, lightLevel, lightColor, time)
- lua_register(m_luaState, "doSetCreatureLight", LuaScriptInterface::luaDoSetCreatureLight);
- //getCreatureCondition(cid, condition[, subId])
- lua_register(m_luaState, "getCreatureCondition", LuaScriptInterface::luaGetCreatureCondition);
- //isValidUID(uid)
- lua_register(m_luaState, "isValidUID", LuaScriptInterface::luaIsValidUID);
- //isDepot(uid)
- lua_register(m_luaState, "isDepot", LuaScriptInterface::luaIsDepot);
- //isMovable(uid)
- lua_register(m_luaState, "isMovable", LuaScriptInterface::luaIsMoveable);
- //doAddContainerItem(uid, itemid, <optional> count/subtype)
- lua_register(m_luaState, "doAddContainerItem", LuaScriptInterface::luaDoAddContainerItem);
- //getDepotId(uid)
- lua_register(m_luaState, "getDepotId", LuaScriptInterface::luaGetDepotId);
- //getWorldTime()
- lua_register(m_luaState, "getWorldTime", LuaScriptInterface::luaGetWorldTime);
- //getWorldLight()
- lua_register(m_luaState, "getWorldLight", LuaScriptInterface::luaGetWorldLight);
- //getWorldUpTime()
- lua_register(m_luaState, "getWorldUpTime", LuaScriptInterface::luaGetWorldUpTime);
- //createCombatArea( {area}, <optional> {extArea} )
- lua_register(m_luaState, "createCombatArea", LuaScriptInterface::luaCreateCombatArea);
- //doAreaCombatHealth(cid, type, pos, area, min, max, effect)
- lua_register(m_luaState, "doAreaCombatHealth", LuaScriptInterface::luaDoAreaCombatHealth);
- //doTargetCombatHealth(cid, target, type, min, max, effect)
- lua_register(m_luaState, "doTargetCombatHealth", LuaScriptInterface::luaDoTargetCombatHealth);
- //doAreaCombatMana(cid, pos, area, min, max, effect)
- lua_register(m_luaState, "doAreaCombatMana", LuaScriptInterface::luaDoAreaCombatMana);
- //doTargetCombatMana(cid, target, min, max, effect)
- lua_register(m_luaState, "doTargetCombatMana", LuaScriptInterface::luaDoTargetCombatMana);
- //doAreaCombatCondition(cid, pos, area, condition, effect)
- lua_register(m_luaState, "doAreaCombatCondition", LuaScriptInterface::luaDoAreaCombatCondition);
- //doTargetCombatCondition(cid, target, condition, effect)
- lua_register(m_luaState, "doTargetCombatCondition", LuaScriptInterface::luaDoTargetCombatCondition);
- //doAreaCombatDispel(cid, pos, area, type, effect)
- lua_register(m_luaState, "doAreaCombatDispel", LuaScriptInterface::luaDoAreaCombatDispel);
- //doTargetCombatDispel(cid, target, type, effect)
- lua_register(m_luaState, "doTargetCombatDispel", LuaScriptInterface::luaDoTargetCombatDispel);
- //doChallengeCreature(cid, target)
- lua_register(m_luaState, "doChallengeCreature", LuaScriptInterface::luaDoChallengeCreature);
- //doSetMonsterOutfit(cid, name, time)
- lua_register(m_luaState, "doSetMonsterOutfit", LuaScriptInterface::luaSetMonsterOutfit);
- //doSetItemOutfit(cid, item, time)
- lua_register(m_luaState, "doSetItemOutfit", LuaScriptInterface::luaSetItemOutfit);
- //doSetCreatureOutfit(cid, outfit, time)
- lua_register(m_luaState, "doSetCreatureOutfit", LuaScriptInterface::luaSetCreatureOutfit);
- //isInArray(array, value)
- lua_register(m_luaState, "isInArray", LuaScriptInterface::luaIsInArray);
- //addEvent(callback, delay, ...)
- lua_register(m_luaState, "addEvent", LuaScriptInterface::luaAddEvent);
- //stopEvent(eventid)
- lua_register(m_luaState, "stopEvent", LuaScriptInterface::luaStopEvent);
- //saveServer()
- lua_register(m_luaState, "saveServer", LuaScriptInterface::luaSaveServer);
- //cleanMap()
- lua_register(m_luaState, "cleanMap", LuaScriptInterface::luaCleanMap);
- //debugPrint(text)
- lua_register(m_luaState, "debugPrint", LuaScriptInterface::luaDebugPrint);
- //isInWar(cid, target)
- lua_register(m_luaState, "isInWar", LuaScriptInterface::luaIsInWar);
- //getWaypointPosition(name)
- lua_register(m_luaState, "getWaypointPositionByName", LuaScriptInterface::luaGetWaypointPositionByName);
- //sendChannelMessage(channelId, type, message)
- lua_register(m_luaState, "sendChannelMessage", LuaScriptInterface::luaSendChannelMessage);
- //sendGuildChannelMessage(guildId, type, message)
- lua_register(m_luaState, "sendGuildChannelMessage", LuaScriptInterface::luaSendGuildChannelMessage);
- #ifndef LUAJIT_VERSION
- //bit operations for Lua, based on bitlib project release 24
- //bit.bnot, bit.band, bit.bor, bit.bxor, bit.lshift, bit.rshift
- luaL_register(m_luaState, "bit", LuaScriptInterface::luaBitReg);
- #endif
- //configManager table
- luaL_register(m_luaState, "configManager", LuaScriptInterface::luaConfigManagerTable);
- //db table
- luaL_register(m_luaState, "db", LuaScriptInterface::luaDatabaseTable);
- //result table
- luaL_register(m_luaState, "result", LuaScriptInterface::luaResultTable);
- /* New functions */
- //registerClass(className, baseClass, newFunction)
- //registerTable(tableName)
- //registerMethod(className, functionName, function)
- //registerMetaMethod(className, functionName, function)
- //registerGlobalMethod(functionName, function)
- //registerVariable(tableName, name, value)
- //registerGlobalVariable(name, value)
- //registerEnum(value)
- //registerEnumIn(tableName, value)
- // Enums
- registerEnum(STORE_ERROR_PURCHASE)
- registerEnum(STORE_ERROR_NETWORK)
- registerEnum(STORE_ERROR_HISTORY)
- registerEnum(STORE_ERROR_TRANSFER)
- registerEnum(STORE_ERROR_INFORMATION)
- registerEnum(ACCOUNT_TYPE_NORMAL)
- registerEnum(ACCOUNT_TYPE_TUTOR)
- registerEnum(ACCOUNT_TYPE_SENIORTUTOR)
- registerEnum(ACCOUNT_TYPE_GAMEMASTER)
- registerEnum(ACCOUNT_TYPE_GOD)
- registerEnum(CALLBACK_PARAM_LEVELMAGICVALUE)
- registerEnum(CALLBACK_PARAM_SKILLVALUE)
- registerEnum(CALLBACK_PARAM_TARGETTILE)
- registerEnum(CALLBACK_PARAM_TARGETCREATURE)
- registerEnum(COMBAT_FORMULA_UNDEFINED)
- registerEnum(COMBAT_FORMULA_LEVELMAGIC)
- registerEnum(COMBAT_FORMULA_SKILL)
- registerEnum(COMBAT_FORMULA_DAMAGE)
- registerEnum(DIRECTION_NORTH)
- registerEnum(DIRECTION_EAST)
- registerEnum(DIRECTION_SOUTH)
- registerEnum(DIRECTION_WEST)
- registerEnum(DIRECTION_SOUTHWEST)
- registerEnum(DIRECTION_SOUTHEAST)
- registerEnum(DIRECTION_NORTHWEST)
- registerEnum(DIRECTION_NORTHEAST)
- registerEnum(COMBAT_NONE)
- registerEnum(COMBAT_PHYSICALDAMAGE)
- registerEnum(COMBAT_ENERGYDAMAGE)
- registerEnum(COMBAT_EARTHDAMAGE)
- registerEnum(COMBAT_FIREDAMAGE)
- registerEnum(COMBAT_UNDEFINEDDAMAGE)
- registerEnum(COMBAT_LIFEDRAIN)
- registerEnum(COMBAT_MANADRAIN)
- registerEnum(COMBAT_HEALING)
- registerEnum(COMBAT_DROWNDAMAGE)
- registerEnum(COMBAT_ICEDAMAGE)
- registerEnum(COMBAT_HOLYDAMAGE)
- registerEnum(COMBAT_DEATHDAMAGE)
- registerEnum(COMBAT_PARAM_TYPE)
- registerEnum(COMBAT_PARAM_EFFECT)
- registerEnum(COMBAT_PARAM_DISTANCEEFFECT)
- registerEnum(COMBAT_PARAM_BLOCKSHIELD)
- registerEnum(COMBAT_PARAM_BLOCKARMOR)
- registerEnum(COMBAT_PARAM_TARGETCASTERORTOPMOST)
- registerEnum(COMBAT_PARAM_CREATEITEM)
- registerEnum(COMBAT_PARAM_AGGRESSIVE)
- registerEnum(COMBAT_PARAM_DISPEL)
- registerEnum(COMBAT_PARAM_USECHARGES)
- registerEnum(CONDITION_NONE)
- registerEnum(CONDITION_POISON)
- registerEnum(CONDITION_FIRE)
- registerEnum(CONDITION_ENERGY)
- registerEnum(CONDITION_BLEEDING)
- registerEnum(CONDITION_HASTE)
- registerEnum(CONDITION_PARALYZE)
- registerEnum(CONDITION_OUTFIT)
- registerEnum(CONDITION_INVISIBLE)
- registerEnum(CONDITION_LIGHT)
- registerEnum(CONDITION_MANASHIELD)
- registerEnum(CONDITION_INFIGHT)
- registerEnum(CONDITION_DRUNK)
- registerEnum(CONDITION_EXHAUST_WEAPON)
- registerEnum(CONDITION_REGENERATION)
- registerEnum(CONDITION_SOUL)
- registerEnum(CONDITION_DROWN)
- registerEnum(CONDITION_MUTED)
- registerEnum(CONDITION_CHANNELMUTEDTICKS)
- registerEnum(CONDITION_YELLTICKS)
- registerEnum(CONDITION_ATTRIBUTES)
- registerEnum(CONDITION_FREEZING)
- registerEnum(CONDITION_DAZZLED)
- registerEnum(CONDITION_CURSED)
- registerEnum(CONDITION_EXHAUST_COMBAT)
- registerEnum(CONDITION_EXHAUST_HEAL)
- registerEnum(CONDITION_PACIFIED)
- registerEnum(CONDITION_SPELLCOOLDOWN)
- registerEnum(CONDITION_SPELLGROUPCOOLDOWN)
- registerEnum(CONDITIONID_DEFAULT)
- registerEnum(CONDITIONID_COMBAT)
- registerEnum(CONDITIONID_HEAD)
- registerEnum(CONDITIONID_NECKLACE)
- registerEnum(CONDITIONID_BACKPACK)
- registerEnum(CONDITIONID_ARMOR)
- registerEnum(CONDITIONID_RIGHT)
- registerEnum(CONDITIONID_LEFT)
- registerEnum(CONDITIONID_LEGS)
- registerEnum(CONDITIONID_FEET)
- registerEnum(CONDITIONID_RING)
- registerEnum(CONDITIONID_AMMO)
- registerEnum(CONDITION_PARAM_OWNER)
- registerEnum(CONDITION_PARAM_TICKS)
- registerEnum(CONDITION_PARAM_HEALTHGAIN)
- registerEnum(CONDITION_PARAM_HEALTHTICKS)
- registerEnum(CONDITION_PARAM_MANAGAIN)
- registerEnum(CONDITION_PARAM_MANATICKS)
- registerEnum(CONDITION_PARAM_DELAYED)
- registerEnum(CONDITION_PARAM_SPEED)
- registerEnum(CONDITION_PARAM_LIGHT_LEVEL)
- registerEnum(CONDITION_PARAM_LIGHT_COLOR)
- registerEnum(CONDITION_PARAM_SOULGAIN)
- registerEnum(CONDITION_PARAM_SOULTICKS)
- registerEnum(CONDITION_PARAM_MINVALUE)
- registerEnum(CONDITION_PARAM_MAXVALUE)
- registerEnum(CONDITION_PARAM_STARTVALUE)
- registerEnum(CONDITION_PARAM_TICKINTERVAL)
- registerEnum(CONDITION_PARAM_FORCEUPDATE)
- registerEnum(CONDITION_PARAM_SKILL_MELEE)
- registerEnum(CONDITION_PARAM_SKILL_FIST)
- registerEnum(CONDITION_PARAM_SKILL_CLUB)
- registerEnum(CONDITION_PARAM_SKILL_SWORD)
- registerEnum(CONDITION_PARAM_SKILL_AXE)
- registerEnum(CONDITION_PARAM_SKILL_DISTANCE)
- registerEnum(CONDITION_PARAM_SKILL_SHIELD)
- registerEnum(CONDITION_PARAM_SKILL_FISHING)
- registerEnum(CONDITION_PARAM_STAT_MAXHITPOINTS)
- registerEnum(CONDITION_PARAM_STAT_MAXMANAPOINTS)
- registerEnum(CONDITION_PARAM_STAT_MAGICPOINTS)
- registerEnum(CONDITION_PARAM_STAT_MAXHITPOINTSPERCENT)
- registerEnum(CONDITION_PARAM_STAT_MAXMANAPOINTSPERCENT)
- registerEnum(CONDITION_PARAM_STAT_MAGICPOINTSPERCENT)
- registerEnum(CONDITION_PARAM_PERIODICDAMAGE)
- registerEnum(CONDITION_PARAM_SKILL_MELEEPERCENT)
- registerEnum(CONDITION_PARAM_SKILL_FISTPERCENT)
- registerEnum(CONDITION_PARAM_SKILL_CLUBPERCENT)
- registerEnum(CONDITION_PARAM_SKILL_SWORDPERCENT)
- registerEnum(CONDITION_PARAM_SKILL_AXEPERCENT)
- registerEnum(CONDITION_PARAM_SKILL_DISTANCEPERCENT)
- registerEnum(CONDITION_PARAM_SKILL_SHIELDPERCENT)
- registerEnum(CONDITION_PARAM_SKILL_FISHINGPERCENT)
- registerEnum(CONDITION_PARAM_BUFF_SPELL)
- registerEnum(CONDITION_PARAM_SUBID)
- registerEnum(CONDITION_PARAM_FIELD)
- registerEnum(CONST_ME_NONE)
- registerEnum(CONST_ME_DRAWBLOOD)
- registerEnum(CONST_ME_LOSEENERGY)
- registerEnum(CONST_ME_POFF)
- registerEnum(CONST_ME_BLOCKHIT)
- registerEnum(CONST_ME_EXPLOSIONAREA)
- registerEnum(CONST_ME_EXPLOSIONHIT)
- registerEnum(CONST_ME_FIREAREA)
- registerEnum(CONST_ME_YELLOW_RINGS)
- registerEnum(CONST_ME_GREEN_RINGS)
- registerEnum(CONST_ME_HITAREA)
- registerEnum(CONST_ME_TELEPORT)
- registerEnum(CONST_ME_ENERGYHIT)
- registerEnum(CONST_ME_MAGIC_BLUE)
- registerEnum(CONST_ME_MAGIC_RED)
- registerEnum(CONST_ME_MAGIC_GREEN)
- registerEnum(CONST_ME_HITBYFIRE)
- registerEnum(CONST_ME_HITBYPOISON)
- registerEnum(CONST_ME_MORTAREA)
- registerEnum(CONST_ME_SOUND_GREEN)
- registerEnum(CONST_ME_SOUND_RED)
- registerEnum(CONST_ME_POISONAREA)
- registerEnum(CONST_ME_SOUND_YELLOW)
- registerEnum(CONST_ME_SOUND_PURPLE)
- registerEnum(CONST_ME_SOUND_BLUE)
- registerEnum(CONST_ME_SOUND_WHITE)
- registerEnum(CONST_ME_BUBBLES)
- registerEnum(CONST_ME_CRAPS)
- registerEnum(CONST_ME_GIFT_WRAPS)
- registerEnum(CONST_ME_FIREWORK_YELLOW)
- registerEnum(CONST_ME_FIREWORK_RED)
- registerEnum(CONST_ME_FIREWORK_BLUE)
- registerEnum(CONST_ME_STUN)
- registerEnum(CONST_ME_SLEEP)
- registerEnum(CONST_ME_WATERCREATURE)
- registerEnum(CONST_ME_GROUNDSHAKER)
- registerEnum(CONST_ME_HEARTS)
- registerEnum(CONST_ME_FIREATTACK)
- registerEnum(CONST_ME_ENERGYAREA)
- registerEnum(CONST_ME_SMALLCLOUDS)
- registerEnum(CONST_ME_HOLYDAMAGE)
- registerEnum(CONST_ME_BIGCLOUDS)
- registerEnum(CONST_ME_ICEAREA)
- registerEnum(CONST_ME_ICETORNADO)
- registerEnum(CONST_ME_ICEATTACK)
- registerEnum(CONST_ME_STONES)
- registerEnum(CONST_ME_SMALLPLANTS)
- registerEnum(CONST_ME_CARNIPHILA)
- registerEnum(CONST_ME_PURPLEENERGY)
- registerEnum(CONST_ME_YELLOWENERGY)
- registerEnum(CONST_ME_HOLYAREA)
- registerEnum(CONST_ME_BIGPLANTS)
- registerEnum(CONST_ME_CAKE)
- registerEnum(CONST_ME_GIANTICE)
- registerEnum(CONST_ME_WATERSPLASH)
- registerEnum(CONST_ME_PLANTATTACK)
- registerEnum(CONST_ME_TUTORIALARROW)
- registerEnum(CONST_ME_TUTORIALSQUARE)
- registerEnum(CONST_ME_MIRRORHORIZONTAL)
- registerEnum(CONST_ME_MIRRORVERTICAL)
- registerEnum(CONST_ME_SKULLHORIZONTAL)
- registerEnum(CONST_ME_SKULLVERTICAL)
- registerEnum(CONST_ME_ASSASSIN)
- registerEnum(CONST_ME_STEPSHORIZONTAL)
- registerEnum(CONST_ME_BLOODYSTEPS)
- registerEnum(CONST_ME_STEPSVERTICAL)
- registerEnum(CONST_ME_YALAHARIGHOST)
- registerEnum(CONST_ME_BATS)
- registerEnum(CONST_ME_SMOKE)
- registerEnum(CONST_ME_INSECTS)
- registerEnum(CONST_ME_DRAGONHEAD)
- registerEnum(CONST_ME_ORCSHAMAN)
- registerEnum(CONST_ME_ORCSHAMAN_FIRE)
- registerEnum(CONST_ME_THUNDER)
- registerEnum(CONST_ME_FERUMBRAS)
- registerEnum(CONST_ME_CONFETTI_HORIZONTAL)
- registerEnum(CONST_ME_CONFETTI_VERTICAL)
- registerEnum(CONST_ME_BLACKSMOKE)
- registerEnum(CONST_ME_REDSMOKE)
- registerEnum(CONST_ME_YELLOWSMOKE)
- registerEnum(CONST_ME_GREENSMOKE)
- registerEnum(CONST_ME_PURPLESMOKE)
- registerEnum(CONST_ANI_NONE)
- registerEnum(CONST_ANI_SPEAR)
- registerEnum(CONST_ANI_BOLT)
- registerEnum(CONST_ANI_ARROW)
- registerEnum(CONST_ANI_FIRE)
- registerEnum(CONST_ANI_ENERGY)
- registerEnum(CONST_ANI_POISONARROW)
- registerEnum(CONST_ANI_BURSTARROW)
- registerEnum(CONST_ANI_THROWINGSTAR)
- registerEnum(CONST_ANI_THROWINGKNIFE)
- registerEnum(CONST_ANI_SMALLSTONE)
- registerEnum(CONST_ANI_DEATH)
- registerEnum(CONST_ANI_LARGEROCK)
- registerEnum(CONST_ANI_SNOWBALL)
- registerEnum(CONST_ANI_POWERBOLT)
- registerEnum(CONST_ANI_POISON)
- registerEnum(CONST_ANI_INFERNALBOLT)
- registerEnum(CONST_ANI_HUNTINGSPEAR)
- registerEnum(CONST_ANI_ENCHANTEDSPEAR)
- registerEnum(CONST_ANI_REDSTAR)
- registerEnum(CONST_ANI_GREENSTAR)
- registerEnum(CONST_ANI_ROYALSPEAR)
- registerEnum(CONST_ANI_SNIPERARROW)
- registerEnum(CONST_ANI_ONYXARROW)
- registerEnum(CONST_ANI_PIERCINGBOLT)
- registerEnum(CONST_ANI_WHIRLWINDSWORD)
- registerEnum(CONST_ANI_WHIRLWINDAXE)
- registerEnum(CONST_ANI_WHIRLWINDCLUB)
- registerEnum(CONST_ANI_ETHEREALSPEAR)
- registerEnum(CONST_ANI_ICE)
- registerEnum(CONST_ANI_EARTH)
- registerEnum(CONST_ANI_HOLY)
- registerEnum(CONST_ANI_SUDDENDEATH)
- registerEnum(CONST_ANI_FLASHARROW)
- registerEnum(CONST_ANI_FLAMMINGARROW)
- registerEnum(CONST_ANI_SHIVERARROW)
- registerEnum(CONST_ANI_ENERGYBALL)
- registerEnum(CONST_ANI_SMALLICE)
- registerEnum(CONST_ANI_SMALLHOLY)
- registerEnum(CONST_ANI_SMALLEARTH)
- registerEnum(CONST_ANI_EARTHARROW)
- registerEnum(CONST_ANI_EXPLOSION)
- registerEnum(CONST_ANI_CAKE)
- registerEnum(CONST_ANI_TARSALARROW)
- registerEnum(CONST_ANI_VORTEXBOLT)
- registerEnum(CONST_ANI_PRISMATICBOLT)
- registerEnum(CONST_ANI_CRYSTALLINEARROW)
- registerEnum(CONST_ANI_DRILLBOLT)
- registerEnum(CONST_ANI_ENVENOMEDARROW)
- registerEnum(CONST_ANI_GLOOTHSPEAR)
- registerEnum(CONST_ANI_SIMPLEARROW)
- registerEnum(CONST_ANI_WEAPONTYPE)
- registerEnum(CONST_PROP_BLOCKSOLID)
- registerEnum(CONST_PROP_HASHEIGHT)
- registerEnum(CONST_PROP_BLOCKPROJECTILE)
- registerEnum(CONST_PROP_BLOCKPATH)
- registerEnum(CONST_PROP_ISVERTICAL)
- registerEnum(CONST_PROP_ISHORIZONTAL)
- registerEnum(CONST_PROP_MOVEABLE)
- registerEnum(CONST_PROP_IMMOVABLEBLOCKSOLID)
- registerEnum(CONST_PROP_IMMOVABLEBLOCKPATH)
- registerEnum(CONST_PROP_IMMOVABLENOFIELDBLOCKPATH)
- registerEnum(CONST_PROP_NOFIELDBLOCKPATH)
- registerEnum(CONST_PROP_SUPPORTHANGABLE)
- registerEnum(CONST_SLOT_HEAD)
- registerEnum(CONST_SLOT_NECKLACE)
- registerEnum(CONST_SLOT_BACKPACK)
- registerEnum(CONST_SLOT_ARMOR)
- registerEnum(CONST_SLOT_RIGHT)
- registerEnum(CONST_SLOT_LEFT)
- registerEnum(CONST_SLOT_LEGS)
- registerEnum(CONST_SLOT_FEET)
- registerEnum(CONST_SLOT_RING)
- registerEnum(CONST_SLOT_AMMO)
- registerEnum(GAME_STATE_STARTUP)
- registerEnum(GAME_STATE_INIT)
- registerEnum(GAME_STATE_NORMAL)
- registerEnum(GAME_STATE_CLOSED)
- registerEnum(GAME_STATE_SHUTDOWN)
- registerEnum(GAME_STATE_CLOSING)
- registerEnum(GAME_STATE_MAINTAIN)
- registerEnum(MESSAGE_STATUS_CONSOLE_BLUE)
- registerEnum(MESSAGE_STATUS_CONSOLE_RED)
- registerEnum(MESSAGE_STATUS_DEFAULT)
- registerEnum(MESSAGE_STATUS_WARNING)
- registerEnum(MESSAGE_EVENT_ADVANCE)
- registerEnum(MESSAGE_STATUS_SMALL)
- registerEnum(MESSAGE_INFO_DESCR)
- registerEnum(MESSAGE_DAMAGE_DEALT)
- registerEnum(MESSAGE_DAMAGE_RECEIVED)
- registerEnum(MESSAGE_HEALED)
- registerEnum(MESSAGE_EXPERIENCE)
- registerEnum(MESSAGE_DAMAGE_OTHERS)
- registerEnum(MESSAGE_HEALED_OTHERS)
- registerEnum(MESSAGE_EXPERIENCE_OTHERS)
- registerEnum(MESSAGE_EVENT_DEFAULT)
- registerEnum(MESSAGE_EVENT_ORANGE)
- registerEnum(MESSAGE_STATUS_CONSOLE_ORANGE)
- registerEnum(CREATURETYPE_PLAYER)
- registerEnum(CREATURETYPE_MONSTER)
- registerEnum(CREATURETYPE_NPC)
- registerEnum(CREATURETYPE_SUMMON_OWN)
- registerEnum(CREATURETYPE_SUMMON_OTHERS)
- registerEnum(CLIENTOS_LINUX)
- registerEnum(CLIENTOS_WINDOWS)
- registerEnum(CLIENTOS_FLASH)
- registerEnum(CLIENTOS_OTCLIENT_LINUX)
- registerEnum(CLIENTOS_OTCLIENT_WINDOWS)
- registerEnum(CLIENTOS_OTCLIENT_MAC)
- registerEnum(ITEM_ATTRIBUTE_NONE)
- registerEnum(ITEM_ATTRIBUTE_ACTIONID)
- registerEnum(ITEM_ATTRIBUTE_UNIQUEID)
- registerEnum(ITEM_ATTRIBUTE_DESCRIPTION)
- registerEnum(ITEM_ATTRIBUTE_TEXT)
- registerEnum(ITEM_ATTRIBUTE_DATE)
- registerEnum(ITEM_ATTRIBUTE_WRITER)
- registerEnum(ITEM_ATTRIBUTE_NAME)
- registerEnum(ITEM_ATTRIBUTE_ARTICLE)
- registerEnum(ITEM_ATTRIBUTE_PLURALNAME)
- registerEnum(ITEM_ATTRIBUTE_WEIGHT)
- registerEnum(ITEM_ATTRIBUTE_ATTACK)
- registerEnum(ITEM_ATTRIBUTE_DEFENSE)
- registerEnum(ITEM_ATTRIBUTE_EXTRADEFENSE)
- registerEnum(ITEM_ATTRIBUTE_ARMOR)
- registerEnum(ITEM_ATTRIBUTE_HITCHANCE)
- registerEnum(ITEM_ATTRIBUTE_SHOOTRANGE)
- registerEnum(ITEM_ATTRIBUTE_OWNER)
- registerEnum(ITEM_ATTRIBUTE_DURATION)
- registerEnum(ITEM_ATTRIBUTE_DECAYSTATE)
- registerEnum(ITEM_ATTRIBUTE_CORPSEOWNER)
- registerEnum(ITEM_ATTRIBUTE_CHARGES)
- registerEnum(ITEM_ATTRIBUTE_FLUIDTYPE)
- registerEnum(ITEM_ATTRIBUTE_DOORID)
- registerEnum(ITEM_TYPE_DEPOT)
- registerEnum(ITEM_TYPE_REWARDCHEST)
- registerEnum(ITEM_TYPE_MAILBOX)
- registerEnum(ITEM_TYPE_TRASHHOLDER)
- registerEnum(ITEM_TYPE_CONTAINER)
- registerEnum(ITEM_TYPE_DOOR)
- registerEnum(ITEM_TYPE_MAGICFIELD)
- registerEnum(ITEM_TYPE_TELEPORT)
- registerEnum(ITEM_TYPE_BED)
- registerEnum(ITEM_TYPE_KEY)
- registerEnum(ITEM_TYPE_RUNE)
- registerEnum(ITEM_BAG)
- registerEnum(ITEM_GOLD_COIN)
- registerEnum(ITEM_REWARD_CHEST)
- registerEnum(ITEM_REWARD_CONTAINER)
- registerEnum(ITEM_PLATINUM_COIN)
- registerEnum(ITEM_CRYSTAL_COIN)
- registerEnum(ITEM_AMULETOFLOSS)
- registerEnum(ITEM_PARCEL)
- registerEnum(ITEM_LABEL)
- registerEnum(ITEM_FIREFIELD_PVP_FULL)
- registerEnum(ITEM_FIREFIELD_PVP_MEDIUM)
- registerEnum(ITEM_FIREFIELD_PVP_SMALL)
- registerEnum(ITEM_FIREFIELD_PERSISTENT_FULL)
- registerEnum(ITEM_FIREFIELD_PERSISTENT_MEDIUM)
- registerEnum(ITEM_FIREFIELD_PERSISTENT_SMALL)
- registerEnum(ITEM_FIREFIELD_NOPVP)
- registerEnum(ITEM_POISONFIELD_PVP)
- registerEnum(ITEM_POISONFIELD_PERSISTENT)
- registerEnum(ITEM_POISONFIELD_NOPVP)
- registerEnum(ITEM_ENERGYFIELD_PVP)
- registerEnum(ITEM_ENERGYFIELD_PERSISTENT)
- registerEnum(ITEM_ENERGYFIELD_NOPVP)
- registerEnum(ITEM_MAGICWALL)
- registerEnum(ITEM_MAGICWALL_PERSISTENT)
- registerEnum(ITEM_MAGICWALL_SAFE)
- registerEnum(ITEM_WILDGROWTH)
- registerEnum(ITEM_WILDGROWTH_PERSISTENT)
- registerEnum(ITEM_WILDGROWTH_SAFE)
- registerEnum(PlayerFlag_CannotUseCombat)
- registerEnum(PlayerFlag_CannotAttackPlayer)
- registerEnum(PlayerFlag_CannotAttackMonster)
- registerEnum(PlayerFlag_CannotBeAttacked)
- registerEnum(PlayerFlag_CanConvinceAll)
- registerEnum(PlayerFlag_CanSummonAll)
- registerEnum(PlayerFlag_CanIllusionAll)
- registerEnum(PlayerFlag_CanSenseInvisibility)
- registerEnum(PlayerFlag_IgnoredByMonsters)
- registerEnum(PlayerFlag_NotGainInFight)
- registerEnum(PlayerFlag_HasInfiniteMana)
- registerEnum(PlayerFlag_HasInfiniteSoul)
- registerEnum(PlayerFlag_HasNoExhaustion)
- registerEnum(PlayerFlag_CannotUseSpells)
- registerEnum(PlayerFlag_CannotPickupItem)
- registerEnum(PlayerFlag_CanAlwaysLogin)
- registerEnum(PlayerFlag_CanBroadcast)
- registerEnum(PlayerFlag_CanEditHouses)
- registerEnum(PlayerFlag_CannotBeBanned)
- registerEnum(PlayerFlag_CannotBePushed)
- registerEnum(PlayerFlag_HasInfiniteCapacity)
- registerEnum(PlayerFlag_CanPushAllCreatures)
- registerEnum(PlayerFlag_CanTalkRedPrivate)
- registerEnum(PlayerFlag_CanTalkRedChannel)
- registerEnum(PlayerFlag_TalkOrangeHelpChannel)
- registerEnum(PlayerFlag_NotGainExperience)
- registerEnum(PlayerFlag_NotGainMana)
- registerEnum(PlayerFlag_NotGainHealth)
- registerEnum(PlayerFlag_NotGainSkill)
- registerEnum(PlayerFlag_SetMaxSpeed)
- registerEnum(PlayerFlag_SpecialVIP)
- registerEnum(PlayerFlag_NotGenerateLoot)
- registerEnum(PlayerFlag_CanTalkRedChannelAnonymous)
- registerEnum(PlayerFlag_IgnoreProtectionZone)
- registerEnum(PlayerFlag_IgnoreSpellCheck)
- registerEnum(PlayerFlag_IgnoreWeaponCheck)
- registerEnum(PlayerFlag_CannotBeMuted)
- registerEnum(PlayerFlag_IsAlwaysPremium)
- registerEnum(PLAYERSEX_FEMALE)
- registerEnum(PLAYERSEX_MALE)
- registerEnum(VOCATION_NONE)
- registerEnum(SKILL_FIST)
- registerEnum(SKILL_CLUB)
- registerEnum(SKILL_SWORD)
- registerEnum(SKILL_AXE)
- registerEnum(SKILL_DISTANCE)
- registerEnum(SKILL_SHIELD)
- registerEnum(SKILL_FISHING)
- registerEnum(SKILL_MAGLEVEL)
- registerEnum(SKILL_LEVEL)
- registerEnum(SKULL_NONE)
- registerEnum(SKULL_YELLOW)
- registerEnum(SKULL_GREEN)
- registerEnum(SKULL_WHITE)
- registerEnum(SKULL_RED)
- registerEnum(SKULL_BLACK)
- registerEnum(SKULL_ORANGE)
- registerEnum(TALKTYPE_SAY)
- registerEnum(TALKTYPE_WHISPER)
- registerEnum(TALKTYPE_YELL)
- registerEnum(TALKTYPE_PRIVATE_FROM)
- registerEnum(TALKTYPE_PRIVATE_TO)
- registerEnum(TALKTYPE_CHANNEL_Y)
- registerEnum(TALKTYPE_CHANNEL_O)
- registerEnum(TALKTYPE_PRIVATE_NP)
- registerEnum(TALKTYPE_PRIVATE_PN)
- registerEnum(TALKTYPE_BROADCAST)
- registerEnum(TALKTYPE_CHANNEL_R1)
- registerEnum(TALKTYPE_PRIVATE_RED_FROM)
- registerEnum(TALKTYPE_PRIVATE_RED_TO)
- registerEnum(TALKTYPE_MONSTER_SAY)
- registerEnum(TALKTYPE_MONSTER_YELL)
- registerEnum(TALKTYPE_CHANNEL_R2)
- registerEnum(TEXTCOLOR_BLUE)
- registerEnum(TEXTCOLOR_LIGHTGREEN)
- registerEnum(TEXTCOLOR_LIGHTBLUE)
- registerEnum(TEXTCOLOR_MAYABLUE)
- registerEnum(TEXTCOLOR_DARKRED)
- registerEnum(TEXTCOLOR_LIGHTGREY)
- registerEnum(TEXTCOLOR_SKYBLUE)
- registerEnum(TEXTCOLOR_PURPLE)
- registerEnum(TEXTCOLOR_RED)
- registerEnum(TEXTCOLOR_ORANGE)
- registerEnum(TEXTCOLOR_YELLOW)
- registerEnum(TEXTCOLOR_WHITE_EXP)
- registerEnum(TEXTCOLOR_NONE)
- registerEnum(TILESTATE_NONE)
- registerEnum(TILESTATE_PROTECTIONZONE)
- registerEnum(TILESTATE_NOPVPZONE)
- registerEnum(TILESTATE_NOLOGOUT)
- registerEnum(TILESTATE_PVPZONE)
- registerEnum(TILESTATE_FLOORCHANGE)
- registerEnum(TILESTATE_FLOORCHANGE_DOWN)
- registerEnum(TILESTATE_FLOORCHANGE_NORTH)
- registerEnum(TILESTATE_FLOORCHANGE_SOUTH)
- registerEnum(TILESTATE_FLOORCHANGE_EAST)
- registerEnum(TILESTATE_FLOORCHANGE_WEST)
- registerEnum(TILESTATE_TELEPORT)
- registerEnum(TILESTATE_MAGICFIELD)
- registerEnum(TILESTATE_MAILBOX)
- registerEnum(TILESTATE_TRASHHOLDER)
- registerEnum(TILESTATE_BED)
- registerEnum(TILESTATE_DEPOT)
- registerEnum(TILESTATE_BLOCKSOLID)
- registerEnum(TILESTATE_BLOCKPATH)
- registerEnum(TILESTATE_IMMOVABLEBLOCKSOLID)
- registerEnum(TILESTATE_IMMOVABLEBLOCKPATH)
- registerEnum(TILESTATE_IMMOVABLENOFIELDBLOCKPATH)
- registerEnum(TILESTATE_NOFIELDBLOCKPATH)
- registerEnum(TILESTATE_FLOORCHANGE_SOUTH_ALT)
- registerEnum(TILESTATE_FLOORCHANGE_EAST_ALT)
- registerEnum(TILESTATE_SUPPORTS_HANGABLE)
- registerEnum(WEAPON_NONE)
- registerEnum(WEAPON_SWORD)
- registerEnum(WEAPON_CLUB)
- registerEnum(WEAPON_AXE)
- registerEnum(WEAPON_SHIELD)
- registerEnum(WEAPON_DISTANCE)
- registerEnum(WEAPON_WAND)
- registerEnum(WEAPON_AMMO)
- registerEnum(WORLD_TYPE_NO_PVP)
- registerEnum(WORLD_TYPE_PVP)
- registerEnum(WORLD_TYPE_PVP_ENFORCED)
- // Use with container:addItem, container:addItemEx and possibly other functions.
- registerEnum(FLAG_NOLIMIT)
- registerEnum(FLAG_IGNOREBLOCKITEM)
- registerEnum(FLAG_IGNOREBLOCKCREATURE)
- registerEnum(FLAG_CHILDISOWNER)
- registerEnum(FLAG_PATHFINDING)
- registerEnum(FLAG_IGNOREFIELDDAMAGE)
- registerEnum(FLAG_IGNORENOTMOVEABLE)
- registerEnum(FLAG_IGNOREAUTOSTACK)
- // Use with itemType:getSlotPosition
- registerEnum(SLOTP_WHEREEVER)
- registerEnum(SLOTP_HEAD)
- registerEnum(SLOTP_NECKLACE)
- registerEnum(SLOTP_BACKPACK)
- registerEnum(SLOTP_ARMOR)
- registerEnum(SLOTP_RIGHT)
- registerEnum(SLOTP_LEFT)
- registerEnum(SLOTP_LEGS)
- registerEnum(SLOTP_FEET)
- registerEnum(SLOTP_RING)
- registerEnum(SLOTP_AMMO)
- registerEnum(SLOTP_DEPOT)
- registerEnum(SLOTP_TWO_HAND)
- // Use with combat functions
- registerEnum(ORIGIN_NONE)
- registerEnum(ORIGIN_CONDITION)
- registerEnum(ORIGIN_SPELL)
- registerEnum(ORIGIN_MELEE)
- registerEnum(ORIGIN_RANGED)
- // Use with house:getAccessList, house:setAccessList
- registerEnum(GUEST_LIST)
- registerEnum(SUBOWNER_LIST)
- // Use with npc:setSpeechBubble
- registerEnum(SPEECHBUBBLE_NONE)
- registerEnum(SPEECHBUBBLE_NORMAL)
- registerEnum(SPEECHBUBBLE_TRADE)
- registerEnum(SPEECHBUBBLE_QUEST)
- registerEnum(SPEECHBUBBLE_QUESTTRADER)
- // Use with player:addMapMark
- registerEnum(MAPMARK_TICK)
- registerEnum(MAPMARK_QUESTION)
- registerEnum(MAPMARK_EXCLAMATION)
- registerEnum(MAPMARK_STAR)
- registerEnum(MAPMARK_CROSS)
- registerEnum(MAPMARK_TEMPLE)
- registerEnum(MAPMARK_KISS)
- registerEnum(MAPMARK_SHOVEL)
- registerEnum(MAPMARK_SWORD)
- registerEnum(MAPMARK_FLAG)
- registerEnum(MAPMARK_LOCK)
- registerEnum(MAPMARK_BAG)
- registerEnum(MAPMARK_SKULL)
- registerEnum(MAPMARK_DOLLAR)
- registerEnum(MAPMARK_REDNORTH)
- registerEnum(MAPMARK_REDSOUTH)
- registerEnum(MAPMARK_REDEAST)
- registerEnum(MAPMARK_REDWEST)
- registerEnum(MAPMARK_GREENNORTH)
- registerEnum(MAPMARK_GREENSOUTH)
- // Use with Game.getReturnMessage
- registerEnum(RETURNVALUE_NOERROR)
- registerEnum(RETURNVALUE_NOTPOSSIBLE)
- registerEnum(RETURNVALUE_NOTENOUGHROOM)
- registerEnum(RETURNVALUE_PLAYERISPZLOCKED)
- registerEnum(RETURNVALUE_PLAYERISNOTINVITED)
- registerEnum(RETURNVALUE_CANNOTTHROW)
- registerEnum(RETURNVALUE_THEREISNOWAY)
- registerEnum(RETURNVALUE_DESTINATIONOUTOFREACH)
- registerEnum(RETURNVALUE_CREATUREBLOCK)
- registerEnum(RETURNVALUE_NOTMOVEABLE)
- registerEnum(RETURNVALUE_DROPTWOHANDEDITEM)
- registerEnum(RETURNVALUE_BOTHHANDSNEEDTOBEFREE)
- registerEnum(RETURNVALUE_CANONLYUSEONEWEAPON)
- registerEnum(RETURNVALUE_NEEDEXCHANGE)
- registerEnum(RETURNVALUE_CANNOTBEDRESSED)
- registerEnum(RETURNVALUE_PUTTHISOBJECTINYOURHAND)
- registerEnum(RETURNVALUE_PUTTHISOBJECTINBOTHHANDS)
- registerEnum(RETURNVALUE_TOOFARAWAY)
- registerEnum(RETURNVALUE_FIRSTGODOWNSTAIRS)
- registerEnum(RETURNVALUE_FIRSTGOUPSTAIRS)
- registerEnum(RETURNVALUE_CONTAINERNOTENOUGHROOM)
- registerEnum(RETURNVALUE_NOTENOUGHCAPACITY)
- registerEnum(RETURNVALUE_CANNOTPICKUP)
- registerEnum(RETURNVALUE_THISISIMPOSSIBLE)
- registerEnum(RETURNVALUE_DEPOTISFULL)
- registerEnum(RETURNVALUE_CREATUREDOESNOTEXIST)
- registerEnum(RETURNVALUE_CANNOTUSETHISOBJECT)
- registerEnum(RETURNVALUE_PLAYERWITHTHISNAMEISNOTONLINE)
- registerEnum(RETURNVALUE_NOTREQUIREDLEVELTOUSERUNE)
- registerEnum(RETURNVALUE_YOUAREALREADYTRADING)
- registerEnum(RETURNVALUE_THISPLAYERISALREADYTRADING)
- registerEnum(RETURNVALUE_YOUMAYNOTLOGOUTDURINGAFIGHT)
- registerEnum(RETURNVALUE_DIRECTPLAYERSHOOT)
- registerEnum(RETURNVALUE_NOTENOUGHLEVEL)
- registerEnum(RETURNVALUE_NOTENOUGHMAGICLEVEL)
- registerEnum(RETURNVALUE_NOTENOUGHMANA)
- registerEnum(RETURNVALUE_NOTENOUGHSOUL)
- registerEnum(RETURNVALUE_YOUAREEXHAUSTED)
- registerEnum(RETURNVALUE_PLAYERISNOTREACHABLE)
- registerEnum(RETURNVALUE_CANONLYUSETHISRUNEONCREATURES)
- registerEnum(RETURNVALUE_ACTIONNOTPERMITTEDINPROTECTIONZONE)
- registerEnum(RETURNVALUE_YOUMAYNOTATTACKTHISPLAYER)
- registerEnum(RETURNVALUE_YOUMAYNOTATTACKAPERSONINPROTECTIONZONE)
- registerEnum(RETURNVALUE_YOUMAYNOTATTACKAPERSONWHILEINPROTECTIONZONE)
- registerEnum(RETURNVALUE_YOUMAYNOTATTACKTHISCREATURE)
- registerEnum(RETURNVALUE_YOUCANONLYUSEITONCREATURES)
- registerEnum(RETURNVALUE_CREATUREISNOTREACHABLE)
- registerEnum(RETURNVALUE_TURNSECUREMODETOATTACKUNMARKEDPLAYERS)
- registerEnum(RETURNVALUE_YOUNEEDPREMIUMACCOUNT)
- registerEnum(RETURNVALUE_YOUNEEDTOLEARNTHISSPELL)
- registerEnum(RETURNVALUE_YOURVOCATIONCANNOTUSETHISSPELL)
- registerEnum(RETURNVALUE_YOUNEEDAWEAPONTOUSETHISSPELL)
- registerEnum(RETURNVALUE_PLAYERISPZLOCKEDLEAVEPVPZONE)
- registerEnum(RETURNVALUE_PLAYERISPZLOCKEDENTERPVPZONE)
- registerEnum(RETURNVALUE_ACTIONNOTPERMITTEDINANOPVPZONE)
- registerEnum(RETURNVALUE_YOUCANNOTLOGOUTHERE)
- registerEnum(RETURNVALUE_YOUNEEDAMAGICITEMTOCASTSPELL)
- registerEnum(RETURNVALUE_CANNOTCONJUREITEMHERE)
- registerEnum(RETURNVALUE_YOUNEEDTOSPLITYOURSPEARS)
- registerEnum(RETURNVALUE_NAMEISTOOAMBIGIOUS)
- registerEnum(RETURNVALUE_CANONLYUSEONESHIELD)
- registerEnum(RETURNVALUE_NOPARTYMEMBERSINRANGE)
- registerEnum(RETURNVALUE_YOUARENOTTHEOWNER)
- // _G
- registerGlobalVariable("INDEX_WHEREEVER", INDEX_WHEREEVER);
- registerGlobalBoolean("VIRTUAL_PARENT", true);
- registerGlobalMethod("isType", LuaScriptInterface::luaIsType);
- registerGlobalMethod("rawgetmetatable", LuaScriptInterface::luaRawGetMetatable);
- // configKeys
- registerTable("configKeys");
- registerEnumIn("configKeys", ConfigManager::ALLOW_CHANGEOUTFIT)
- registerEnumIn("configKeys", ConfigManager::ONE_PLAYER_ON_ACCOUNT)
- registerEnumIn("configKeys", ConfigManager::AIMBOT_HOTKEY_ENABLED)
- registerEnumIn("configKeys", ConfigManager::REMOVE_RUNE_CHARGES)
- registerEnumIn("configKeys", ConfigManager::EXPERIENCE_FROM_PLAYERS)
- registerEnumIn("configKeys", ConfigManager::FREE_PREMIUM)
- registerEnumIn("configKeys", ConfigManager::REPLACE_KICK_ON_LOGIN)
- registerEnumIn("configKeys", ConfigManager::ALLOW_CLONES)
- registerEnumIn("configKeys", ConfigManager::BIND_ONLY_GLOBAL_ADDRESS)
- registerEnumIn("configKeys", ConfigManager::OPTIMIZE_DATABASE)
- registerEnumIn("configKeys", ConfigManager::MARKET_PREMIUM)
- registerEnumIn("configKeys", ConfigManager::EMOTE_SPELLS)
- registerEnumIn("configKeys", ConfigManager::STAMINA_SYSTEM)
- registerEnumIn("configKeys", ConfigManager::WARN_UNSAFE_SCRIPTS)
- registerEnumIn("configKeys", ConfigManager::CONVERT_UNSAFE_SCRIPTS)
- registerEnumIn("configKeys", ConfigManager::CLASSIC_EQUIPMENT_SLOTS)
- registerEnumIn("configKeys", ConfigManager::MAP_NAME)
- registerEnumIn("configKeys", ConfigManager::HOUSE_RENT_PERIOD)
- registerEnumIn("configKeys", ConfigManager::SERVER_NAME)
- registerEnumIn("configKeys", ConfigManager::OWNER_NAME)
- registerEnumIn("configKeys", ConfigManager::OWNER_EMAIL)
- registerEnumIn("configKeys", ConfigManager::URL)
- registerEnumIn("configKeys", ConfigManager::LOCATION)
- registerEnumIn("configKeys", ConfigManager::IP)
- registerEnumIn("configKeys", ConfigManager::MOTD)
- registerEnumIn("configKeys", ConfigManager::WORLD_TYPE)
- registerEnumIn("configKeys", ConfigManager::MYSQL_HOST)
- registerEnumIn("configKeys", ConfigManager::MYSQL_USER)
- registerEnumIn("configKeys", ConfigManager::MYSQL_PASS)
- registerEnumIn("configKeys", ConfigManager::MYSQL_DB)
- registerEnumIn("configKeys", ConfigManager::MYSQL_SOCK)
- registerEnumIn("configKeys", ConfigManager::DEFAULT_PRIORITY)
- registerEnumIn("configKeys", ConfigManager::MAP_AUTHOR)
- registerEnumIn("configKeys", ConfigManager::SQL_PORT)
- registerEnumIn("configKeys", ConfigManager::MAX_PLAYERS)
- registerEnumIn("configKeys", ConfigManager::PZ_LOCKED)
- registerEnumIn("configKeys", ConfigManager::DEFAULT_DESPAWNRANGE)
- registerEnumIn("configKeys", ConfigManager::DEFAULT_DESPAWNRADIUS)
- registerEnumIn("configKeys", ConfigManager::RATE_EXPERIENCE)
- registerEnumIn("configKeys", ConfigManager::RATE_SKILL)
- registerEnumIn("configKeys", ConfigManager::RATE_LOOT)
- registerEnumIn("configKeys", ConfigManager::RATE_MAGIC)
- registerEnumIn("configKeys", ConfigManager::RATE_SPAWN)
- registerEnumIn("configKeys", ConfigManager::HOUSE_PRICE)
- registerEnumIn("configKeys", ConfigManager::KILLS_TO_RED)
- registerEnumIn("configKeys", ConfigManager::KILLS_TO_BLACK)
- registerEnumIn("configKeys", ConfigManager::MAX_MESSAGEBUFFER)
- registerEnumIn("configKeys", ConfigManager::ACTIONS_DELAY_INTERVAL)
- registerEnumIn("configKeys", ConfigManager::EX_ACTIONS_DELAY_INTERVAL)
- registerEnumIn("configKeys", ConfigManager::KICK_AFTER_MINUTES)
- registerEnumIn("configKeys", ConfigManager::PROTECTION_LEVEL)
- registerEnumIn("configKeys", ConfigManager::DEATH_LOSE_PERCENT)
- registerEnumIn("configKeys", ConfigManager::STATUSQUERY_TIMEOUT)
- registerEnumIn("configKeys", ConfigManager::FRAG_TIME)
- registerEnumIn("configKeys", ConfigManager::WHITE_SKULL_TIME)
- registerEnumIn("configKeys", ConfigManager::GAME_PORT)
- registerEnumIn("configKeys", ConfigManager::LOGIN_PORT)
- registerEnumIn("configKeys", ConfigManager::STATUS_PORT)
- registerEnumIn("configKeys", ConfigManager::STAIRHOP_DELAY)
- registerEnumIn("configKeys", ConfigManager::MARKET_OFFER_DURATION)
- registerEnumIn("configKeys", ConfigManager::CHECK_EXPIRED_MARKET_OFFERS_EACH_MINUTES)
- registerEnumIn("configKeys", ConfigManager::MAX_MARKET_OFFERS_AT_A_TIME_PER_PLAYER)
- registerEnumIn("configKeys", ConfigManager::EXP_FROM_PLAYERS_LEVEL_RANGE)
- registerEnumIn("configKeys", ConfigManager::MAX_PACKETS_PER_SECOND)
- // os
- registerMethod("os", "mtime", LuaScriptInterface::luaSystemTime);
- // table
- registerMethod("table", "create", LuaScriptInterface::luaTableCreate);
- // Game
- registerTable("Game");
- registerMethod("Game", "getSpectators", LuaScriptInterface::luaGameGetSpectators);
- registerMethod("Game", "getPlayers", LuaScriptInterface::luaGameGetPlayers);
- registerMethod("Game", "loadMap", LuaScriptInterface::luaGameLoadMap);
- registerMethod("Game", "getExperienceStage", LuaScriptInterface::luaGameGetExperienceStage);
- registerMethod("Game", "getMonsterCount", LuaScriptInterface::luaGameGetMonsterCount);
- registerMethod("Game", "getPlayerCount", LuaScriptInterface::luaGameGetPlayerCount);
- registerMethod("Game", "getNpcCount", LuaScriptInterface::luaGameGetNpcCount);
- registerMethod("Game", "getTowns", LuaScriptInterface::luaGameGetTowns);
- registerMethod("Game", "getHouses", LuaScriptInterface::luaGameGetHouses);
- registerMethod("Game", "getGameState", LuaScriptInterface::luaGameGetGameState);
- registerMethod("Game", "setGameState", LuaScriptInterface::luaGameSetGameState);
- registerMethod("Game", "getWorldType", LuaScriptInterface::luaGameGetWorldType);
- registerMethod("Game", "setWorldType", LuaScriptInterface::luaGameSetWorldType);
- registerMethod("Game", "getReturnMessage", LuaScriptInterface::luaGameGetReturnMessage);
- registerMethod("Game", "createItem", LuaScriptInterface::luaGameCreateItem);
- registerMethod("Game", "createContainer", LuaScriptInterface::luaGameCreateContainer);
- registerMethod("Game", "createMonster", LuaScriptInterface::luaGameCreateMonster);
- registerMethod("Game", "createNpc", LuaScriptInterface::luaGameCreateNpc);
- registerMethod("Game", "createTile", LuaScriptInterface::luaGameCreateTile);
- registerMethod("Game", "startRaid", LuaScriptInterface::luaGameStartRaid);
- // Variant
- registerClass("Variant", "", LuaScriptInterface::luaVariantCreate);
- registerMethod("Variant", "getNumber", LuaScriptInterface::luaVariantGetNumber);
- registerMethod("Variant", "getString", LuaScriptInterface::luaVariantGetString);
- registerMethod("Variant", "getPosition", LuaScriptInterface::luaVariantGetPosition);
- // Position
- registerClass("Position", "", LuaScriptInterface::luaPositionCreate);
- registerMetaMethod("Position", "__add", LuaScriptInterface::luaPositionAdd);
- registerMetaMethod("Position", "__sub", LuaScriptInterface::luaPositionSub);
- registerMetaMethod("Position", "__eq", LuaScriptInterface::luaPositionCompare);
- registerMethod("Position", "getDistance", LuaScriptInterface::luaPositionGetDistance);
- registerMethod("Position", "isSightClear", LuaScriptInterface::luaPositionIsSightClear);
- registerMethod("Position", "sendMagicEffect", LuaScriptInterface::luaPositionSendMagicEffect);
- registerMethod("Position", "sendDistanceEffect", LuaScriptInterface::luaPositionSendDistanceEffect);
- // Tile
- registerClass("Tile", "", LuaScriptInterface::luaTileCreate);
- registerMetaMethod("Tile", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Tile", "getPosition", LuaScriptInterface::luaTileGetPosition);
- registerMethod("Tile", "getGround", LuaScriptInterface::luaTileGetGround);
- registerMethod("Tile", "getThing", LuaScriptInterface::luaTileGetThing);
- registerMethod("Tile", "getThingCount", LuaScriptInterface::luaTileGetThingCount);
- registerMethod("Tile", "getTopVisibleThing", LuaScriptInterface::luaTileGetTopVisibleThing);
- registerMethod("Tile", "getTopTopItem", LuaScriptInterface::luaTileGetTopTopItem);
- registerMethod("Tile", "getTopDownItem", LuaScriptInterface::luaTileGetTopDownItem);
- registerMethod("Tile", "getFieldItem", LuaScriptInterface::luaTileGetFieldItem);
- registerMethod("Tile", "getItemById", LuaScriptInterface::luaTileGetItemById);
- registerMethod("Tile", "getItemByType", LuaScriptInterface::luaTileGetItemByType);
- registerMethod("Tile", "getItemByTopOrder", LuaScriptInterface::luaTileGetItemByTopOrder);
- registerMethod("Tile", "getItemCountById", LuaScriptInterface::luaTileGetItemCountById);
- registerMethod("Tile", "getBottomCreature", LuaScriptInterface::luaTileGetBottomCreature);
- registerMethod("Tile", "getTopCreature", LuaScriptInterface::luaTileGetTopCreature);
- registerMethod("Tile", "getBottomVisibleCreature", LuaScriptInterface::luaTileGetBottomVisibleCreature);
- registerMethod("Tile", "getTopVisibleCreature", LuaScriptInterface::luaTileGetTopVisibleCreature);
- registerMethod("Tile", "getItems", LuaScriptInterface::luaTileGetItems);
- registerMethod("Tile", "getItemCount", LuaScriptInterface::luaTileGetItemCount);
- registerMethod("Tile", "getDownItemCount", LuaScriptInterface::luaTileGetDownItemCount);
- registerMethod("Tile", "getTopItemCount", LuaScriptInterface::luaTileGetTopItemCount);
- registerMethod("Tile", "getCreatures", LuaScriptInterface::luaTileGetCreatures);
- registerMethod("Tile", "getCreatureCount", LuaScriptInterface::luaTileGetCreatureCount);
- registerMethod("Tile", "getThingIndex", LuaScriptInterface::luaTileGetThingIndex);
- registerMethod("Tile", "hasProperty", LuaScriptInterface::luaTileHasProperty);
- registerMethod("Tile", "hasFlag", LuaScriptInterface::luaTileHasFlag);
- registerMethod("Tile", "queryAdd", LuaScriptInterface::luaTileQueryAdd);
- registerMethod("Tile", "getHouse", LuaScriptInterface::luaTileGetHouse);
- // NetworkMessage
- registerClass("NetworkMessage", "", LuaScriptInterface::luaNetworkMessageCreate);
- registerMetaMethod("NetworkMessage", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMetaMethod("NetworkMessage", "__gc", LuaScriptInterface::luaNetworkMessageDelete);
- registerMethod("NetworkMessage", "delete", LuaScriptInterface::luaNetworkMessageDelete);
- registerMethod("NetworkMessage", "getByte", LuaScriptInterface::luaNetworkMessageGetByte);
- registerMethod("NetworkMessage", "getU16", LuaScriptInterface::luaNetworkMessageGetU16);
- registerMethod("NetworkMessage", "getU32", LuaScriptInterface::luaNetworkMessageGetU32);
- registerMethod("NetworkMessage", "getU64", LuaScriptInterface::luaNetworkMessageGetU64);
- registerMethod("NetworkMessage", "getString", LuaScriptInterface::luaNetworkMessageGetString);
- registerMethod("NetworkMessage", "getPosition", LuaScriptInterface::luaNetworkMessageGetPosition);
- registerMethod("NetworkMessage", "addByte", LuaScriptInterface::luaNetworkMessageAddByte);
- registerMethod("NetworkMessage", "addU16", LuaScriptInterface::luaNetworkMessageAddU16);
- registerMethod("NetworkMessage", "addU32", LuaScriptInterface::luaNetworkMessageAddU32);
- registerMethod("NetworkMessage", "addU64", LuaScriptInterface::luaNetworkMessageAddU64);
- registerMethod("NetworkMessage", "addString", LuaScriptInterface::luaNetworkMessageAddString);
- registerMethod("NetworkMessage", "addPosition", LuaScriptInterface::luaNetworkMessageAddPosition);
- registerMethod("NetworkMessage", "addDouble", LuaScriptInterface::luaNetworkMessageAddDouble);
- registerMethod("NetworkMessage", "addItem", LuaScriptInterface::luaNetworkMessageAddItem);
- registerMethod("NetworkMessage", "addItemId", LuaScriptInterface::luaNetworkMessageAddItemId);
- registerMethod("NetworkMessage", "reset", LuaScriptInterface::luaNetworkMessageReset);
- registerMethod("NetworkMessage", "skipBytes", LuaScriptInterface::luaNetworkMessageSkipBytes);
- registerMethod("NetworkMessage", "sendToPlayer", LuaScriptInterface::luaNetworkMessageSendToPlayer);
- // ModalWindow
- registerClass("ModalWindow", "", LuaScriptInterface::luaModalWindowCreate);
- registerMetaMethod("ModalWindow", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMetaMethod("ModalWindow", "__gc", LuaScriptInterface::luaModalWindowDelete);
- registerMethod("ModalWindow", "delete", LuaScriptInterface::luaModalWindowDelete);
- registerMethod("ModalWindow", "getId", LuaScriptInterface::luaModalWindowGetId);
- registerMethod("ModalWindow", "getTitle", LuaScriptInterface::luaModalWindowGetTitle);
- registerMethod("ModalWindow", "getMessage", LuaScriptInterface::luaModalWindowGetMessage);
- registerMethod("ModalWindow", "setTitle", LuaScriptInterface::luaModalWindowSetTitle);
- registerMethod("ModalWindow", "setMessage", LuaScriptInterface::luaModalWindowSetMessage);
- registerMethod("ModalWindow", "getButtonCount", LuaScriptInterface::luaModalWindowGetButtonCount);
- registerMethod("ModalWindow", "getChoiceCount", LuaScriptInterface::luaModalWindowGetChoiceCount);
- registerMethod("ModalWindow", "addButton", LuaScriptInterface::luaModalWindowAddButton);
- registerMethod("ModalWindow", "addChoice", LuaScriptInterface::luaModalWindowAddChoice);
- registerMethod("ModalWindow", "getDefaultEnterButton", LuaScriptInterface::luaModalWindowGetDefaultEnterButton);
- registerMethod("ModalWindow", "setDefaultEnterButton", LuaScriptInterface::luaModalWindowSetDefaultEnterButton);
- registerMethod("ModalWindow", "getDefaultEscapeButton", LuaScriptInterface::luaModalWindowGetDefaultEscapeButton);
- registerMethod("ModalWindow", "setDefaultEscapeButton", LuaScriptInterface::luaModalWindowSetDefaultEscapeButton);
- registerMethod("ModalWindow", "hasPriority", LuaScriptInterface::luaModalWindowHasPriority);
- registerMethod("ModalWindow", "setPriority", LuaScriptInterface::luaModalWindowSetPriority);
- registerMethod("ModalWindow", "sendToPlayer", LuaScriptInterface::luaModalWindowSendToPlayer);
- // Item
- registerClass("Item", "", LuaScriptInterface::luaItemCreate);
- registerMetaMethod("Item", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Item", "isItem", LuaScriptInterface::luaItemIsItem);
- registerMethod("Item", "getParent", LuaScriptInterface::luaItemGetParent);
- registerMethod("Item", "getTopParent", LuaScriptInterface::luaItemGetTopParent);
- registerMethod("Item", "getId", LuaScriptInterface::luaItemGetId);
- registerMethod("Item", "clone", LuaScriptInterface::luaItemClone);
- registerMethod("Item", "split", LuaScriptInterface::luaItemSplit);
- registerMethod("Item", "remove", LuaScriptInterface::luaItemRemove);
- registerMethod("Item", "getUniqueId", LuaScriptInterface::luaItemGetUniqueId);
- registerMethod("Item", "getActionId", LuaScriptInterface::luaItemGetActionId);
- registerMethod("Item", "setActionId", LuaScriptInterface::luaItemSetActionId);
- registerMethod("Item", "getCount", LuaScriptInterface::luaItemGetCount);
- registerMethod("Item", "getCharges", LuaScriptInterface::luaItemGetCharges);
- registerMethod("Item", "getFluidType", LuaScriptInterface::luaItemGetFluidType);
- registerMethod("Item", "getWeight", LuaScriptInterface::luaItemGetWeight);
- registerMethod("Item", "getSubType", LuaScriptInterface::luaItemGetSubType);
- registerMethod("Item", "getName", LuaScriptInterface::luaItemGetName);
- registerMethod("Item", "getPluralName", LuaScriptInterface::luaItemGetPluralName);
- registerMethod("Item", "getArticle", LuaScriptInterface::luaItemGetArticle);
- registerMethod("Item", "getPosition", LuaScriptInterface::luaItemGetPosition);
- registerMethod("Item", "getTile", LuaScriptInterface::luaItemGetTile);
- registerMethod("Item", "hasAttribute", LuaScriptInterface::luaItemHasAttribute);
- registerMethod("Item", "getAttribute", LuaScriptInterface::luaItemGetAttribute);
- registerMethod("Item", "setAttribute", LuaScriptInterface::luaItemSetAttribute);
- registerMethod("Item", "removeAttribute", LuaScriptInterface::luaItemRemoveAttribute);
- registerMethod("Item", "serializeAttributes", LuaScriptInterface::luaItemSerializeAttributes);
- registerMethod("Item", "moveTo", LuaScriptInterface::luaItemMoveTo);
- registerMethod("Item", "transform", LuaScriptInterface::luaItemTransform);
- registerMethod("Item", "decay", LuaScriptInterface::luaItemDecay);
- registerMethod("Item", "getDescription", LuaScriptInterface::luaItemGetDescription);
- registerMethod("Item", "hasProperty", LuaScriptInterface::luaItemHasProperty);
- // Container
- registerClass("Container", "Item", LuaScriptInterface::luaContainerCreate);
- registerMetaMethod("Container", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Container", "getSize", LuaScriptInterface::luaContainerGetSize);
- registerMethod("Container", "getCapacity", LuaScriptInterface::luaContainerGetCapacity);
- registerMethod("Container", "getEmptySlots", LuaScriptInterface::luaContainerGetEmptySlots);
- registerMethod("Container", "getItemHoldingCount", LuaScriptInterface::luaContainerGetItemHoldingCount);
- registerMethod("Container", "getItemCountById", LuaScriptInterface::luaContainerGetItemCountById);
- registerMethod("Container", "getItem", LuaScriptInterface::luaContainerGetItem);
- registerMethod("Container", "hasItem", LuaScriptInterface::luaContainerHasItem);
- registerMethod("Container", "addItem", LuaScriptInterface::luaContainerAddItem);
- registerMethod("Container", "addItemEx", LuaScriptInterface::luaContainerAddItemEx);
- // Teleport
- registerClass("Teleport", "Item", LuaScriptInterface::luaTeleportCreate);
- registerMetaMethod("Teleport", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Teleport", "getDestination", LuaScriptInterface::luaTeleportGetDestination);
- registerMethod("Teleport", "setDestination", LuaScriptInterface::luaTeleportSetDestination);
- // Creature
- registerClass("Creature", "", LuaScriptInterface::luaCreatureCreate);
- registerMetaMethod("Creature", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Creature", "registerEvent", LuaScriptInterface::luaCreatureRegisterEvent);
- registerMethod("Creature", "unregisterEvent", LuaScriptInterface::luaCreatureUnregisterEvent);
- registerMethod("Creature", "isRemoved", LuaScriptInterface::luaCreatureIsRemoved);
- registerMethod("Creature", "isCreature", LuaScriptInterface::luaCreatureIsCreature);
- registerMethod("Creature", "isInGhostMode", LuaScriptInterface::luaCreatureIsInGhostMode);
- registerMethod("Creature", "isHealthHidden", LuaScriptInterface::luaCreatureIsHealthHidden);
- registerMethod("Creature", "canSee", LuaScriptInterface::luaCreatureCanSee);
- registerMethod("Creature", "canSeeCreature", LuaScriptInterface::luaCreatureCanSeeCreature);
- registerMethod("Creature", "getParent", LuaScriptInterface::luaCreatureGetParent);
- registerMethod("Creature", "getId", LuaScriptInterface::luaCreatureGetId);
- registerMethod("Creature", "getName", LuaScriptInterface::luaCreatureGetName);
- registerMethod("Creature", "getTarget", LuaScriptInterface::luaCreatureGetTarget);
- registerMethod("Creature", "setTarget", LuaScriptInterface::luaCreatureSetTarget);
- registerMethod("Creature", "getFollowCreature", LuaScriptInterface::luaCreatureGetFollowCreature);
- registerMethod("Creature", "setFollowCreature", LuaScriptInterface::luaCreatureSetFollowCreature);
- registerMethod("Creature", "getMaster", LuaScriptInterface::luaCreatureGetMaster);
- registerMethod("Creature", "setMaster", LuaScriptInterface::luaCreatureSetMaster);
- registerMethod("Creature", "getLight", LuaScriptInterface::luaCreatureGetLight);
- registerMethod("Creature", "setLight", LuaScriptInterface::luaCreatureSetLight);
- registerMethod("Creature", "getSpeed", LuaScriptInterface::luaCreatureGetSpeed);
- registerMethod("Creature", "getBaseSpeed", LuaScriptInterface::luaCreatureGetBaseSpeed);
- registerMethod("Creature", "changeSpeed", LuaScriptInterface::luaCreatureChangeSpeed);
- registerMethod("Creature", "setDropLoot", LuaScriptInterface::luaCreatureSetDropLoot);
- registerMethod("Creature", "getPosition", LuaScriptInterface::luaCreatureGetPosition);
- registerMethod("Creature", "getTile", LuaScriptInterface::luaCreatureGetTile);
- registerMethod("Creature", "getDirection", LuaScriptInterface::luaCreatureGetDirection);
- registerMethod("Creature", "setDirection", LuaScriptInterface::luaCreatureSetDirection);
- registerMethod("Creature", "getHealth", LuaScriptInterface::luaCreatureGetHealth);
- registerMethod("Creature", "addHealth", LuaScriptInterface::luaCreatureAddHealth);
- registerMethod("Creature", "getMaxHealth", LuaScriptInterface::luaCreatureGetMaxHealth);
- registerMethod("Creature", "setMaxHealth", LuaScriptInterface::luaCreatureSetMaxHealth);
- registerMethod("Creature", "setHiddenHealth", LuaScriptInterface::luaCreatureSetHiddenHealth);
- registerMethod("Creature", "getMana", LuaScriptInterface::luaCreatureGetMana);
- registerMethod("Creature", "addMana", LuaScriptInterface::luaCreatureAddMana);
- registerMethod("Creature", "getMaxMana", LuaScriptInterface::luaCreatureGetMaxMana);
- registerMethod("Creature", "getSkull", LuaScriptInterface::luaCreatureGetSkull);
- registerMethod("Creature", "setSkull", LuaScriptInterface::luaCreatureSetSkull);
- registerMethod("Creature", "getOutfit", LuaScriptInterface::luaCreatureGetOutfit);
- registerMethod("Creature", "setOutfit", LuaScriptInterface::luaCreatureSetOutfit);
- registerMethod("Creature", "getCondition", LuaScriptInterface::luaCreatureGetCondition);
- registerMethod("Creature", "addCondition", LuaScriptInterface::luaCreatureAddCondition);
- registerMethod("Creature", "removeCondition", LuaScriptInterface::luaCreatureRemoveCondition);
- registerMethod("Creature", "remove", LuaScriptInterface::luaCreatureRemove);
- registerMethod("Creature", "teleportTo", LuaScriptInterface::luaCreatureTeleportTo);
- registerMethod("Creature", "say", LuaScriptInterface::luaCreatureSay);
- registerMethod("Creature", "getDamageMap", LuaScriptInterface::luaCreatureGetDamageMap);
- registerMethod("Creature", "getSummons", LuaScriptInterface::luaCreatureGetSummons);
- registerMethod("Creature", "getDescription", LuaScriptInterface::luaCreatureGetDescription);
- registerMethod("Creature", "getPathTo", LuaScriptInterface::luaCreatureGetPathTo);
- // Player
- registerClass("Player", "Creature", LuaScriptInterface::luaPlayerCreate);
- registerMetaMethod("Player", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Player", "isPlayer", LuaScriptInterface::luaPlayerIsPlayer);
- registerMethod("Player", "getGuid", LuaScriptInterface::luaPlayerGetGuid);
- registerMethod("Player", "getIp", LuaScriptInterface::luaPlayerGetIp);
- registerMethod("Player", "getAccountId", LuaScriptInterface::luaPlayerGetAccountId);
- registerMethod("Player", "getLastLoginSaved", LuaScriptInterface::luaPlayerGetLastLoginSaved);
- registerMethod("Player", "getLastLogout", LuaScriptInterface::luaPlayerGetLastLogout);
- registerMethod("Player", "getAccountType", LuaScriptInterface::luaPlayerGetAccountType);
- registerMethod("Player", "setAccountType", LuaScriptInterface::luaPlayerSetAccountType);
- registerMethod("Player", "getCapacity", LuaScriptInterface::luaPlayerGetCapacity);
- registerMethod("Player", "setCapacity", LuaScriptInterface::luaPlayerSetCapacity);
- registerMethod("Player", "getFreeCapacity", LuaScriptInterface::luaPlayerGetFreeCapacity);
- registerMethod("Player", "getReward", LuaScriptInterface::luaPlayerGetReward);
- registerMethod("Player", "removeReward", LuaScriptInterface::luaPlayerRemoveReward);
- registerMethod("Player", "getRewardList", LuaScriptInterface::luaPlayerGetRewardList);
- registerMethod("Player", "getDepotChest", LuaScriptInterface::luaPlayerGetDepotChest);
- registerMethod("Player", "getInbox", LuaScriptInterface::luaPlayerGetInbox);
- registerMethod("Player", "getSkullTime", LuaScriptInterface::luaPlayerGetSkullTime);
- registerMethod("Player", "setSkullTime", LuaScriptInterface::luaPlayerSetSkullTime);
- registerMethod("Player", "getDeathPenalty", LuaScriptInterface::luaPlayerGetDeathPenalty);
- registerMethod("Player", "getExperience", LuaScriptInterface::luaPlayerGetExperience);
- registerMethod("Player", "addExperience", LuaScriptInterface::luaPlayerAddExperience);
- registerMethod("Player", "removeExperience", LuaScriptInterface::luaPlayerRemoveExperience);
- registerMethod("Player", "getLevel", LuaScriptInterface::luaPlayerGetLevel);
- registerMethod("Player", "getMagicLevel", LuaScriptInterface::luaPlayerGetMagicLevel);
- registerMethod("Player", "getBaseMagicLevel", LuaScriptInterface::luaPlayerGetBaseMagicLevel);
- registerMethod("Player", "setMaxMana", LuaScriptInterface::luaPlayerSetMaxMana);
- registerMethod("Player", "getManaSpent", LuaScriptInterface::luaPlayerGetManaSpent);
- registerMethod("Player", "addManaSpent", LuaScriptInterface::luaPlayerAddManaSpent);
- registerMethod("Player", "getSkillLevel", LuaScriptInterface::luaPlayerGetSkillLevel);
- registerMethod("Player", "getEffectiveSkillLevel", LuaScriptInterface::luaPlayerGetEffectiveSkillLevel);
- registerMethod("Player", "getSkillPercent", LuaScriptInterface::luaPlayerGetSkillPercent);
- registerMethod("Player", "getSkillTries", LuaScriptInterface::luaPlayerGetSkillTries);
- registerMethod("Player", "addSkillTries", LuaScriptInterface::luaPlayerAddSkillTries);
- registerMethod("Player", "addOfflineTrainingTime", LuaScriptInterface::luaPlayerAddOfflineTrainingTime);
- registerMethod("Player", "getOfflineTrainingTime", LuaScriptInterface::luaPlayerGetOfflineTrainingTime);
- registerMethod("Player", "removeOfflineTrainingTime", LuaScriptInterface::luaPlayerRemoveOfflineTrainingTime);
- registerMethod("Player", "addOfflineTrainingTries", LuaScriptInterface::luaPlayerAddOfflineTrainingTries);
- registerMethod("Player", "getOfflineTrainingSkill", LuaScriptInterface::luaPlayerGetOfflineTrainingSkill);
- registerMethod("Player", "setOfflineTrainingSkill", LuaScriptInterface::luaPlayerSetOfflineTrainingSkill);
- registerMethod("Player", "getItemCount", LuaScriptInterface::luaPlayerGetItemCount);
- registerMethod("Player", "getItemById", LuaScriptInterface::luaPlayerGetItemById);
- registerMethod("Player", "getVocation", LuaScriptInterface::luaPlayerGetVocation);
- registerMethod("Player", "setVocation", LuaScriptInterface::luaPlayerSetVocation);
- registerMethod("Player", "getSex", LuaScriptInterface::luaPlayerGetSex);
- registerMethod("Player", "setSex", LuaScriptInterface::luaPlayerSetSex);
- registerMethod("Player", "getTown", LuaScriptInterface::luaPlayerGetTown);
- registerMethod("Player", "setTown", LuaScriptInterface::luaPlayerSetTown);
- registerMethod("Player", "getGuild", LuaScriptInterface::luaPlayerGetGuild);
- registerMethod("Player", "setGuild", LuaScriptInterface::luaPlayerSetGuild);
- registerMethod("Player", "getGuildLevel", LuaScriptInterface::luaPlayerGetGuildLevel);
- registerMethod("Player", "setGuildLevel", LuaScriptInterface::luaPlayerSetGuildLevel);
- registerMethod("Player", "getGuildNick", LuaScriptInterface::luaPlayerGetGuildNick);
- registerMethod("Player", "setGuildNick", LuaScriptInterface::luaPlayerSetGuildNick);
- registerMethod("Player", "getGroup", LuaScriptInterface::luaPlayerGetGroup);
- registerMethod("Player", "setGroup", LuaScriptInterface::luaPlayerSetGroup);
- registerMethod("Player", "getStamina", LuaScriptInterface::luaPlayerGetStamina);
- registerMethod("Player", "setStamina", LuaScriptInterface::luaPlayerSetStamina);
- registerMethod("Player", "getSoul", LuaScriptInterface::luaPlayerGetSoul);
- registerMethod("Player", "addSoul", LuaScriptInterface::luaPlayerAddSoul);
- registerMethod("Player", "getMaxSoul", LuaScriptInterface::luaPlayerGetMaxSoul);
- registerMethod("Player", "getBankBalance", LuaScriptInterface::luaPlayerGetBankBalance);
- registerMethod("Player", "setBankBalance", LuaScriptInterface::luaPlayerSetBankBalance);
- registerMethod("Player", "getStorageValue", LuaScriptInterface::luaPlayerGetStorageValue);
- registerMethod("Player", "setStorageValue", LuaScriptInterface::luaPlayerSetStorageValue);
- registerMethod("Player", "addItem", LuaScriptInterface::luaPlayerAddItem);
- registerMethod("Player", "addItemEx", LuaScriptInterface::luaPlayerAddItemEx);
- registerMethod("Player", "removeItem", LuaScriptInterface::luaPlayerRemoveItem);
- registerMethod("Player", "getMoney", LuaScriptInterface::luaPlayerGetMoney);
- registerMethod("Player", "addMoney", LuaScriptInterface::luaPlayerAddMoney);
- registerMethod("Player", "removeMoney", LuaScriptInterface::luaPlayerRemoveMoney);
- registerMethod("Player", "showTextDialog", LuaScriptInterface::luaPlayerShowTextDialog);
- registerMethod("Player", "sendTextMessage", LuaScriptInterface::luaPlayerSendTextMessage);
- registerMethod("Player", "sendChannelMessage", LuaScriptInterface::luaPlayerSendChannelMessage);
- registerMethod("Player", "sendPrivateMessage", LuaScriptInterface::luaPlayerSendPrivateMessage);
- registerMethod("Player", "channelSay", LuaScriptInterface::luaPlayerChannelSay);
- registerMethod("Player", "openChannel", LuaScriptInterface::luaPlayerOpenChannel);
- registerMethod("Player", "getSlotItem", LuaScriptInterface::luaPlayerGetSlotItem);
- registerMethod("Player", "getParty", LuaScriptInterface::luaPlayerGetParty);
- registerMethod("Player", "addOutfit", LuaScriptInterface::luaPlayerAddOutfit);
- registerMethod("Player", "addOutfitAddon", LuaScriptInterface::luaPlayerAddOutfitAddon);
- registerMethod("Player", "removeOutfit", LuaScriptInterface::luaPlayerRemoveOutfit);
- registerMethod("Player", "removeOutfitAddon", LuaScriptInterface::luaPlayerRemoveOutfitAddon);
- registerMethod("Player", "hasOutfit", LuaScriptInterface::luaPlayerHasOutfit);
- registerMethod("Player", "sendOutfitWindow", LuaScriptInterface::luaPlayerSendOutfitWindow);
- registerMethod("Player", "addMount", LuaScriptInterface::luaPlayerAddMount);
- registerMethod("Player", "removeMount", LuaScriptInterface::luaPlayerRemoveMount);
- registerMethod("Player", "hasMount", LuaScriptInterface::luaPlayerHasMount);
- registerMethod("Player", "getPremiumDays", LuaScriptInterface::luaPlayerGetPremiumDays);
- registerMethod("Player", "addPremiumDays", LuaScriptInterface::luaPlayerAddPremiumDays);
- registerMethod("Player", "removePremiumDays", LuaScriptInterface::luaPlayerRemovePremiumDays);
- registerMethod("Player", "hasBlessing", LuaScriptInterface::luaPlayerHasBlessing);
- registerMethod("Player", "addBlessing", LuaScriptInterface::luaPlayerAddBlessing);
- registerMethod("Player", "removeBlessing", LuaScriptInterface::luaPlayerRemoveBlessing);
- registerMethod("Player", "canLearnSpell", LuaScriptInterface::luaPlayerCanLearnSpell);
- registerMethod("Player", "learnSpell", LuaScriptInterface::luaPlayerLearnSpell);
- registerMethod("Player", "forgetSpell", LuaScriptInterface::luaPlayerForgetSpell);
- registerMethod("Player", "hasLearnedSpell", LuaScriptInterface::luaPlayerHasLearnedSpell);
- registerMethod("Player", "sendTutorial", LuaScriptInterface::luaPlayerSendTutorial);
- registerMethod("Player", "addMapMark", LuaScriptInterface::luaPlayerAddMapMark);
- registerMethod("Player", "save", LuaScriptInterface::luaPlayerSave);
- registerMethod("Player", "popupFYI", LuaScriptInterface::luaPlayerPopupFYI);
- registerMethod("Player", "isPzLocked", LuaScriptInterface::luaPlayerIsPzLocked);
- registerMethod("Player", "getClient", LuaScriptInterface::luaPlayerGetClient);
- registerMethod("Player", "getHouse", LuaScriptInterface::luaPlayerGetHouse);
- registerMethod("Player", "setGhostMode", LuaScriptInterface::luaPlayerSetGhostMode);
- registerMethod("Player", "getContainerId", LuaScriptInterface::luaPlayerGetContainerId);
- registerMethod("Player", "getContainerById", LuaScriptInterface::luaPlayerGetContainerById);
- registerMethod("Player", "getContainerIndex", LuaScriptInterface::luaPlayerGetContainerIndex);
- registerMethod("Player", "sendStoreError", LuaScriptInterface::luaPlayerSendStoreError);
- registerMethod("Player", "startLiveCast", LuaScriptInterface::luaPlayerStartLiveCast);
- registerMethod("Player", "stopLiveCast", LuaScriptInterface::luaPlayerStopLiveCast);
- registerMethod("Player", "isLiveCaster", LuaScriptInterface::luaPlayerIsLiveCaster);
- registerMethod("Player", "getSpectators", LuaScriptInterface::luaPlayerGetSpectators);
- // Monster
- registerClass("Monster", "Creature", LuaScriptInterface::luaMonsterCreate);
- registerMetaMethod("Monster", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Monster", "isMonster", LuaScriptInterface::luaMonsterIsMonster);
- registerMethod("Monster", "getType", LuaScriptInterface::luaMonsterGetType);
- registerMethod("Monster", "getSpawnPosition", LuaScriptInterface::luaMonsterGetSpawnPosition);
- registerMethod("Monster", "isInSpawnRange", LuaScriptInterface::luaMonsterIsInSpawnRange);
- registerMethod("Monster", "isIdle", LuaScriptInterface::luaMonsterIsIdle);
- registerMethod("Monster", "setIdle", LuaScriptInterface::luaMonsterSetIdle);
- registerMethod("Monster", "isTarget", LuaScriptInterface::luaMonsterIsTarget);
- registerMethod("Monster", "isOpponent", LuaScriptInterface::luaMonsterIsOpponent);
- registerMethod("Monster", "isFriend", LuaScriptInterface::luaMonsterIsFriend);
- registerMethod("Monster", "addFriend", LuaScriptInterface::luaMonsterAddFriend);
- registerMethod("Monster", "removeFriend", LuaScriptInterface::luaMonsterRemoveFriend);
- registerMethod("Monster", "getFriendList", LuaScriptInterface::luaMonsterGetFriendList);
- registerMethod("Monster", "getFriendCount", LuaScriptInterface::luaMonsterGetFriendCount);
- registerMethod("Monster", "addTarget", LuaScriptInterface::luaMonsterAddTarget);
- registerMethod("Monster", "removeTarget", LuaScriptInterface::luaMonsterRemoveTarget);
- registerMethod("Monster", "getTargetList", LuaScriptInterface::luaMonsterGetTargetList);
- registerMethod("Monster", "getTargetCount", LuaScriptInterface::luaMonsterGetTargetCount);
- registerMethod("Monster", "selectTarget", LuaScriptInterface::luaMonsterSelectTarget);
- registerMethod("Monster", "searchTarget", LuaScriptInterface::luaMonsterSearchTarget);
- // Npc
- registerClass("Npc", "Creature", LuaScriptInterface::luaNpcCreate);
- registerMetaMethod("Npc", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Npc", "isNpc", LuaScriptInterface::luaNpcIsNpc);
- registerMethod("Npc", "setMasterPos", LuaScriptInterface::luaNpcSetMasterPos);
- registerMethod("Npc", "getSpeechBubble", LuaScriptInterface::luaNpcGetSpeechBubble);
- registerMethod("Npc", "setSpeechBubble", LuaScriptInterface::luaNpcSetSpeechBubble);
- // Guild
- registerClass("Guild", "", LuaScriptInterface::luaGuildCreate);
- registerMetaMethod("Guild", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Guild", "getId", LuaScriptInterface::luaGuildGetId);
- registerMethod("Guild", "getName", LuaScriptInterface::luaGuildGetName);
- registerMethod("Guild", "getMembersOnline", LuaScriptInterface::luaGuildGetMembersOnline);
- registerMethod("Guild", "getBankBalance", LuaScriptInterface::luaGuildGetBankBalance);
- registerMethod("Guild", "setBankBalance", LuaScriptInterface::luaGuildSetBankBalance);
- registerMethod("Guild", "addRank", LuaScriptInterface::luaGuildAddRank);
- registerMethod("Guild", "getRankById", LuaScriptInterface::luaGuildGetRankById);
- registerMethod("Guild", "getRankByLevel", LuaScriptInterface::luaGuildGetRankByLevel);
- registerMethod("Guild", "getMotd", LuaScriptInterface::luaGuildGetMotd);
- registerMethod("Guild", "setMotd", LuaScriptInterface::luaGuildSetMotd);
- // Group
- registerClass("Group", "", LuaScriptInterface::luaGroupCreate);
- registerMetaMethod("Group", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Group", "getId", LuaScriptInterface::luaGroupGetId);
- registerMethod("Group", "getName", LuaScriptInterface::luaGroupGetName);
- registerMethod("Group", "getFlags", LuaScriptInterface::luaGroupGetFlags);
- registerMethod("Group", "getAccess", LuaScriptInterface::luaGroupGetAccess);
- registerMethod("Group", "getMaxDepotItems", LuaScriptInterface::luaGroupGetMaxDepotItems);
- registerMethod("Group", "getMaxVipEntries", LuaScriptInterface::luaGroupGetMaxVipEntries);
- // Vocation
- registerClass("Vocation", "", LuaScriptInterface::luaVocationCreate);
- registerMetaMethod("Vocation", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Vocation", "getId", LuaScriptInterface::luaVocationGetId);
- registerMethod("Vocation", "getClientId", LuaScriptInterface::luaVocationGetClientId);
- registerMethod("Vocation", "getName", LuaScriptInterface::luaVocationGetName);
- registerMethod("Vocation", "getDescription", LuaScriptInterface::luaVocationGetDescription);
- registerMethod("Vocation", "getRequiredSkillTries", LuaScriptInterface::luaVocationGetRequiredSkillTries);
- registerMethod("Vocation", "getRequiredManaSpent", LuaScriptInterface::luaVocationGetRequiredManaSpent);
- registerMethod("Vocation", "getCapacityGain", LuaScriptInterface::luaVocationGetCapacityGain);
- registerMethod("Vocation", "getHealthGain", LuaScriptInterface::luaVocationGetHealthGain);
- registerMethod("Vocation", "getHealthGainTicks", LuaScriptInterface::luaVocationGetHealthGainTicks);
- registerMethod("Vocation", "getHealthGainAmount", LuaScriptInterface::luaVocationGetHealthGainAmount);
- registerMethod("Vocation", "getManaGain", LuaScriptInterface::luaVocationGetManaGain);
- registerMethod("Vocation", "getManaGainTicks", LuaScriptInterface::luaVocationGetManaGainTicks);
- registerMethod("Vocation", "getManaGainAmount", LuaScriptInterface::luaVocationGetManaGainAmount);
- registerMethod("Vocation", "getMaxSoul", LuaScriptInterface::luaVocationGetMaxSoul);
- registerMethod("Vocation", "getSoulGainTicks", LuaScriptInterface::luaVocationGetSoulGainTicks);
- registerMethod("Vocation", "getAttackSpeed", LuaScriptInterface::luaVocationGetAttackSpeed);
- registerMethod("Vocation", "getBaseSpeed", LuaScriptInterface::luaVocationGetBaseSpeed);
- registerMethod("Vocation", "getDemotion", LuaScriptInterface::luaVocationGetDemotion);
- registerMethod("Vocation", "getPromotion", LuaScriptInterface::luaVocationGetPromotion);
- // Town
- registerClass("Town", "", LuaScriptInterface::luaTownCreate);
- registerMetaMethod("Town", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Town", "getId", LuaScriptInterface::luaTownGetId);
- registerMethod("Town", "getName", LuaScriptInterface::luaTownGetName);
- registerMethod("Town", "getTemplePosition", LuaScriptInterface::luaTownGetTemplePosition);
- // House
- registerClass("House", "", LuaScriptInterface::luaHouseCreate);
- registerMetaMethod("House", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("House", "getId", LuaScriptInterface::luaHouseGetId);
- registerMethod("House", "getName", LuaScriptInterface::luaHouseGetName);
- registerMethod("House", "getTown", LuaScriptInterface::luaHouseGetTown);
- registerMethod("House", "getExitPosition", LuaScriptInterface::luaHouseGetExitPosition);
- registerMethod("House", "getRent", LuaScriptInterface::luaHouseGetRent);
- registerMethod("House", "getOwnerGuid", LuaScriptInterface::luaHouseGetOwnerGuid);
- registerMethod("House", "setOwnerGuid", LuaScriptInterface::luaHouseSetOwnerGuid);
- registerMethod("House", "getBeds", LuaScriptInterface::luaHouseGetBeds);
- registerMethod("House", "getBedCount", LuaScriptInterface::luaHouseGetBedCount);
- registerMethod("House", "getDoors", LuaScriptInterface::luaHouseGetDoors);
- registerMethod("House", "getDoorCount", LuaScriptInterface::luaHouseGetDoorCount);
- registerMethod("House", "getTiles", LuaScriptInterface::luaHouseGetTiles);
- registerMethod("House", "getTileCount", LuaScriptInterface::luaHouseGetTileCount);
- registerMethod("House", "getAccessList", LuaScriptInterface::luaHouseGetAccessList);
- registerMethod("House", "setAccessList", LuaScriptInterface::luaHouseSetAccessList);
- // ItemType
- registerClass("ItemType", "", LuaScriptInterface::luaItemTypeCreate);
- registerMetaMethod("ItemType", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("ItemType", "isCorpse", LuaScriptInterface::luaItemTypeIsCorpse);
- registerMethod("ItemType", "isDoor", LuaScriptInterface::luaItemTypeIsDoor);
- registerMethod("ItemType", "isContainer", LuaScriptInterface::luaItemTypeIsContainer);
- registerMethod("ItemType", "isFluidContainer", LuaScriptInterface::luaItemTypeIsFluidContainer);
- registerMethod("ItemType", "isMovable", LuaScriptInterface::luaItemTypeIsMovable);
- registerMethod("ItemType", "isRune", LuaScriptInterface::luaItemTypeIsRune);
- registerMethod("ItemType", "isStackable", LuaScriptInterface::luaItemTypeIsStackable);
- registerMethod("ItemType", "isReadable", LuaScriptInterface::luaItemTypeIsReadable);
- registerMethod("ItemType", "isWritable", LuaScriptInterface::luaItemTypeIsWritable);
- registerMethod("ItemType", "getType", LuaScriptInterface::luaItemTypeGetType);
- registerMethod("ItemType", "getId", LuaScriptInterface::luaItemTypeGetId);
- registerMethod("ItemType", "getClientId", LuaScriptInterface::luaItemTypeGetClientId);
- registerMethod("ItemType", "getName", LuaScriptInterface::luaItemTypeGetName);
- registerMethod("ItemType", "getPluralName", LuaScriptInterface::luaItemTypeGetPluralName);
- registerMethod("ItemType", "getArticle", LuaScriptInterface::luaItemTypeGetArticle);
- registerMethod("ItemType", "getDescription", LuaScriptInterface::luaItemTypeGetDescription);
- registerMethod("ItemType", "getSlotPosition", LuaScriptInterface::luaItemTypeGetSlotPosition);
- registerMethod("ItemType", "getCharges", LuaScriptInterface::luaItemTypeGetCharges);
- registerMethod("ItemType", "getFluidSource", LuaScriptInterface::luaItemTypeGetFluidSource);
- registerMethod("ItemType", "getCapacity", LuaScriptInterface::luaItemTypeGetCapacity);
- registerMethod("ItemType", "getWeight", LuaScriptInterface::luaItemTypeGetWeight);
- registerMethod("ItemType", "getHitChance", LuaScriptInterface::luaItemTypeGetHitChance);
- registerMethod("ItemType", "getShootRange", LuaScriptInterface::luaItemTypeGetShootRange);
- registerMethod("ItemType", "getAttack", LuaScriptInterface::luaItemTypeGetAttack);
- registerMethod("ItemType", "getDefense", LuaScriptInterface::luaItemTypeGetDefense);
- registerMethod("ItemType", "getExtraDefense", LuaScriptInterface::luaItemTypeGetExtraDefense);
- registerMethod("ItemType", "getArmor", LuaScriptInterface::luaItemTypeGetArmor);
- registerMethod("ItemType", "getWeaponType", LuaScriptInterface::luaItemTypeGetWeaponType);
- registerMethod("ItemType", "getElementType", LuaScriptInterface::luaItemTypeGetElementType);
- registerMethod("ItemType", "getElementDamage", LuaScriptInterface::luaItemTypeGetElementDamage);
- registerMethod("ItemType", "getTransformEquipId", LuaScriptInterface::luaItemTypeGetTransformEquipId);
- registerMethod("ItemType", "getTransformDeEquipId", LuaScriptInterface::luaItemTypeGetTransformDeEquipId);
- registerMethod("ItemType", "getDestroyId", LuaScriptInterface::luaItemTypeGetDestroyId);
- registerMethod("ItemType", "getDecayId", LuaScriptInterface::luaItemTypeGetDecayId);
- registerMethod("ItemType", "getRequiredLevel", LuaScriptInterface::luaItemTypeGetRequiredLevel);
- registerMethod("ItemType", "hasSubType", LuaScriptInterface::luaItemTypeHasSubType);
- // Combat
- registerClass("Combat", "", LuaScriptInterface::luaCombatCreate);
- registerMetaMethod("Combat", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Combat", "setParameter", LuaScriptInterface::luaCombatSetParameter);
- registerMethod("Combat", "setFormula", LuaScriptInterface::luaCombatSetFormula);
- registerMethod("Combat", "setArea", LuaScriptInterface::luaCombatSetArea);
- registerMethod("Combat", "setCondition", LuaScriptInterface::luaCombatSetCondition);
- registerMethod("Combat", "setCallback", LuaScriptInterface::luaCombatSetCallback);
- registerMethod("Combat", "setOrigin", LuaScriptInterface::luaCombatSetOrigin);
- registerMethod("Combat", "execute", LuaScriptInterface::luaCombatExecute);
- // Condition
- registerClass("Condition", "", LuaScriptInterface::luaConditionCreate);
- registerMetaMethod("Condition", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMetaMethod("Condition", "__gc", LuaScriptInterface::luaConditionDelete);
- registerMethod("Condition", "delete", LuaScriptInterface::luaConditionDelete);
- registerMethod("Condition", "getId", LuaScriptInterface::luaConditionGetId);
- registerMethod("Condition", "getSubId", LuaScriptInterface::luaConditionGetSubId);
- registerMethod("Condition", "getType", LuaScriptInterface::luaConditionGetType);
- registerMethod("Condition", "getIcons", LuaScriptInterface::luaConditionGetIcons);
- registerMethod("Condition", "getEndTime", LuaScriptInterface::luaConditionGetEndTime);
- registerMethod("Condition", "clone", LuaScriptInterface::luaConditionClone);
- registerMethod("Condition", "getTicks", LuaScriptInterface::luaConditionGetTicks);
- registerMethod("Condition", "setTicks", LuaScriptInterface::luaConditionSetTicks);
- registerMethod("Condition", "setParameter", LuaScriptInterface::luaConditionSetParameter);
- registerMethod("Condition", "setFormula", LuaScriptInterface::luaConditionSetFormula);
- registerMethod("Condition", "setOutfit", LuaScriptInterface::luaConditionSetOutfit);
- registerMethod("Condition", "addDamage", LuaScriptInterface::luaConditionAddDamage);
- // MonsterType
- registerClass("MonsterType", "", LuaScriptInterface::luaMonsterTypeCreate);
- registerMetaMethod("MonsterType", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("MonsterType", "isAttackable", LuaScriptInterface::luaMonsterTypeIsAttackable);
- registerMethod("MonsterType", "isConvinceable", LuaScriptInterface::luaMonsterTypeIsConvinceable);
- registerMethod("MonsterType", "isSummonable", LuaScriptInterface::luaMonsterTypeIsSummonable);
- registerMethod("MonsterType", "isIllusionable", LuaScriptInterface::luaMonsterTypeIsIllusionable);
- registerMethod("MonsterType", "isHostile", LuaScriptInterface::luaMonsterTypeIsHostile);
- registerMethod("MonsterType", "isPushable", LuaScriptInterface::luaMonsterTypeIsPushable);
- registerMethod("MonsterType", "isHealthShown", LuaScriptInterface::luaMonsterTypeIsHealthShown);
- registerMethod("MonsterType", "isRewardBoss", LuaScriptInterface::luaMonsterTypeIsRewardBoss);
- registerMethod("MonsterType", "canPushItems", LuaScriptInterface::luaMonsterTypeCanPushItems);
- registerMethod("MonsterType", "canPushCreatures", LuaScriptInterface::luaMonsterTypeCanPushCreatures);
- registerMethod("MonsterType", "getName", LuaScriptInterface::luaMonsterTypeGetName);
- registerMethod("MonsterType", "getNameDescription", LuaScriptInterface::luaMonsterTypeGetNameDescription);
- registerMethod("MonsterType", "getHealth", LuaScriptInterface::luaMonsterTypeGetHealth);
- registerMethod("MonsterType", "getMaxHealth", LuaScriptInterface::luaMonsterTypeGetMaxHealth);
- registerMethod("MonsterType", "getRunHealth", LuaScriptInterface::luaMonsterTypeGetRunHealth);
- registerMethod("MonsterType", "getExperience", LuaScriptInterface::luaMonsterTypeGetExperience);
- registerMethod("MonsterType", "getCombatImmunities", LuaScriptInterface::luaMonsterTypeGetCombatImmunities);
- registerMethod("MonsterType", "getConditionImmunities", LuaScriptInterface::luaMonsterTypeGetConditionImmunities);
- registerMethod("MonsterType", "getAttackList", LuaScriptInterface::luaMonsterTypeGetAttackList);
- registerMethod("MonsterType", "getDefenseList", LuaScriptInterface::luaMonsterTypeGetDefenseList);
- registerMethod("MonsterType", "getElementList", LuaScriptInterface::luaMonsterTypeGetElementList);
- registerMethod("MonsterType", "getVoices", LuaScriptInterface::luaMonsterTypeGetVoices);
- registerMethod("MonsterType", "getLoot", LuaScriptInterface::luaMonsterTypeGetLoot);
- registerMethod("MonsterType", "getCreatureEvents", LuaScriptInterface::luaMonsterTypeGetCreatureEvents);
- registerMethod("MonsterType", "getSummonList", LuaScriptInterface::luaMonsterTypeGetSummonList);
- registerMethod("MonsterType", "getMaxSummons", LuaScriptInterface::luaMonsterTypeGetMaxSummons);
- registerMethod("MonsterType", "getArmor", LuaScriptInterface::luaMonsterTypeGetArmor);
- registerMethod("MonsterType", "getDefense", LuaScriptInterface::luaMonsterTypeGetDefense);
- registerMethod("MonsterType", "getOutfit", LuaScriptInterface::luaMonsterTypeGetOutfit);
- registerMethod("MonsterType", "getRace", LuaScriptInterface::luaMonsterTypeGetRace);
- registerMethod("MonsterType", "getCorpseId", LuaScriptInterface::luaMonsterTypeGetCorpseId);
- registerMethod("MonsterType", "getManaCost", LuaScriptInterface::luaMonsterTypeGetManaCost);
- registerMethod("MonsterType", "getBaseSpeed", LuaScriptInterface::luaMonsterTypeGetBaseSpeed);
- registerMethod("MonsterType", "getLight", LuaScriptInterface::luaMonsterTypeGetLight);
- registerMethod("MonsterType", "getStaticAttackChance", LuaScriptInterface::luaMonsterTypeGetStaticAttackChance);
- registerMethod("MonsterType", "getTargetDistance", LuaScriptInterface::luaMonsterTypeGetTargetDistance);
- registerMethod("MonsterType", "getYellChance", LuaScriptInterface::luaMonsterTypeGetYellChance);
- registerMethod("MonsterType", "getYellSpeedTicks", LuaScriptInterface::luaMonsterTypeGetYellSpeedTicks);
- registerMethod("MonsterType", "getChangeTargetChance", LuaScriptInterface::luaMonsterTypeGetChangeTargetChance);
- registerMethod("MonsterType", "getChangeTargetSpeed", LuaScriptInterface::luaMonsterTypeGetChangeTargetSpeed);
- // Party
- registerClass("Party", "", nullptr);
- registerMetaMethod("Party", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("Party", "disband", LuaScriptInterface::luaPartyDisband);
- registerMethod("Party", "getLeader", LuaScriptInterface::luaPartyGetLeader);
- registerMethod("Party", "setLeader", LuaScriptInterface::luaPartySetLeader);
- registerMethod("Party", "getMembers", LuaScriptInterface::luaPartyGetMembers);
- registerMethod("Party", "getMemberCount", LuaScriptInterface::luaPartyGetMemberCount);
- registerMethod("Party", "getInvitees", LuaScriptInterface::luaPartyGetInvitees);
- registerMethod("Party", "getInviteeCount", LuaScriptInterface::luaPartyGetInviteeCount);
- registerMethod("Party", "addInvite", LuaScriptInterface::luaPartyAddInvite);
- registerMethod("Party", "removeInvite", LuaScriptInterface::luaPartyRemoveInvite);
- registerMethod("Party", "addMember", LuaScriptInterface::luaPartyAddMember);
- registerMethod("Party", "removeMember", LuaScriptInterface::luaPartyRemoveMember);
- registerMethod("Party", "isSharedExperienceActive", LuaScriptInterface::luaPartyIsSharedExperienceActive);
- registerMethod("Party", "isSharedExperienceEnabled", LuaScriptInterface::luaPartyIsSharedExperienceEnabled);
- registerMethod("Party", "shareExperience", LuaScriptInterface::luaPartyShareExperience);
- registerMethod("Party", "setSharedExperience", LuaScriptInterface::luaPartySetSharedExperience);
- // StoreOffer
- registerClass("StoreOffer", "", LuaScriptInterface::luaStoreOfferCreate);
- registerMetaMethod("StoreOffer", "__eq", LuaScriptInterface::luaUserdataCompare);
- registerMethod("StoreOffer", "getId", LuaScriptInterface::luaStoreOfferGetId);
- registerMethod("StoreOffer", "getName", LuaScriptInterface::luaStoreOfferGetName);
- }
- #undef registerEnum
- #undef registerEnumIn
- void LuaScriptInterface::registerClass(const std::string& className, const std::string& baseClass, lua_CFunction newFunction/* = nullptr*/)
- {
- // className = {}
- lua_newtable(m_luaState);
- lua_pushvalue(m_luaState, -1);
- lua_setglobal(m_luaState, className.c_str());
- int methods = lua_gettop(m_luaState);
- // methodsTable = {}
- lua_newtable(m_luaState);
- int methodsTable = lua_gettop(m_luaState);
- if (newFunction) {
- // className.__call = newFunction
- lua_pushcfunction(m_luaState, newFunction);
- lua_setfield(m_luaState, methodsTable, "__call");
- }
- uint32_t parents = 0;
- if (!baseClass.empty()) {
- lua_getglobal(m_luaState, baseClass.c_str());
- lua_rawgeti(m_luaState, -1, 'p');
- parents = getNumber<uint32_t>(m_luaState, -1) + 1;
- lua_pop(m_luaState, 1);
- lua_setfield(m_luaState, methodsTable, "__index");
- }
- // setmetatable(className, methodsTable)
- lua_setmetatable(m_luaState, methods);
- // className.metatable = {}
- luaL_newmetatable(m_luaState, className.c_str());
- int metatable = lua_gettop(m_luaState);
- // className.metatable.__metatable = className
- lua_pushvalue(m_luaState, methods);
- lua_setfield(m_luaState, metatable, "__metatable");
- // className.metatable.__index = className
- lua_pushvalue(m_luaState, methods);
- lua_setfield(m_luaState, metatable, "__index");
- // className.metatable['h'] = hash
- lua_pushnumber(m_luaState, std::hash<std::string>()(className));
- lua_rawseti(m_luaState, metatable, 'h');
- // className.metatable['p'] = parents
- lua_pushnumber(m_luaState, parents);
- lua_rawseti(m_luaState, metatable, 'p');
- // className.metatable['t'] = type
- if (className == "Item") {
- lua_pushnumber(m_luaState, LuaData_Item);
- } else if (className == "Container") {
- lua_pushnumber(m_luaState, LuaData_Container);
- } else if (className == "Teleport") {
- lua_pushnumber(m_luaState, LuaData_Teleport);
- } else if (className == "Player") {
- lua_pushnumber(m_luaState, LuaData_Player);
- } else if (className == "Monster") {
- lua_pushnumber(m_luaState, LuaData_Monster);
- } else if (className == "Npc") {
- lua_pushnumber(m_luaState, LuaData_Npc);
- } else if (className == "Tile") {
- lua_pushnumber(m_luaState, LuaData_Tile);
- } else {
- lua_pushnumber(m_luaState, LuaData_Unknown);
- }
- lua_rawseti(m_luaState, metatable, 't');
- // pop className, className.metatable
- lua_pop(m_luaState, 2);
- }
- void LuaScriptInterface::registerTable(const std::string& tableName)
- {
- // _G[tableName] = {}
- lua_newtable(m_luaState);
- lua_setglobal(m_luaState, tableName.c_str());
- }
- void LuaScriptInterface::registerMethod(const std::string& globalName, const std::string& methodName, lua_CFunction func)
- {
- // globalName.methodName = func
- lua_getglobal(m_luaState, globalName.c_str());
- lua_pushcfunction(m_luaState, func);
- lua_setfield(m_luaState, -2, methodName.c_str());
- // pop globalName
- lua_pop(m_luaState, 1);
- }
- void LuaScriptInterface::registerMetaMethod(const std::string& className, const std::string& methodName, lua_CFunction func)
- {
- // className.metatable.methodName = func
- luaL_getmetatable(m_luaState, className.c_str());
- lua_pushcfunction(m_luaState, func);
- lua_setfield(m_luaState, -2, methodName.c_str());
- // pop className.metatable
- lua_pop(m_luaState, 1);
- }
- void LuaScriptInterface::registerGlobalMethod(const std::string& functionName, lua_CFunction func)
- {
- // _G[functionName] = func
- lua_pushcfunction(m_luaState, func);
- lua_setglobal(m_luaState, functionName.c_str());
- }
- void LuaScriptInterface::registerVariable(const std::string& tableName, const std::string& name, lua_Number value)
- {
- // tableName.name = value
- lua_getglobal(m_luaState, tableName.c_str());
- setField(m_luaState, name.c_str(), value);
- // pop tableName
- lua_pop(m_luaState, 1);
- }
- void LuaScriptInterface::registerGlobalVariable(const std::string& name, lua_Number value)
- {
- // _G[name] = value
- lua_pushnumber(m_luaState, value);
- lua_setglobal(m_luaState, name.c_str());
- }
- void LuaScriptInterface::registerGlobalBoolean(const std::string& name, bool value)
- {
- // _G[name] = value
- pushBoolean(m_luaState, value);
- lua_setglobal(m_luaState, name.c_str());
- }
- int LuaScriptInterface::luaGetPlayerFlagValue(lua_State* L)
- {
- //getPlayerFlagValue(cid, flag)
- Player* player = getPlayer(L, 1);
- if (player) {
- PlayerFlags flag = getNumber<PlayerFlags>(L, 2);
- pushBoolean(L, player->hasFlag(flag));
- } else {
- reportErrorFunc(getErrorDesc(LUA_ERROR_PLAYER_NOT_FOUND));
- pushBoolean(L, false);
- }
- return 1;
- }
- int LuaScriptInterface::luaGetPlayerInstantSpellCount(lua_State* L)
- {
- //getPlayerInstantSpellCount(cid)
- Player* player = getPlayer(L, 1);
- if (player) {
- lua_pushnumber(L, g_spells->getInstantSpellCount(player));
- } else {
- reportErrorFunc(getErrorDesc(LUA_ERROR_PLAYER_NOT_FOUND));
- pushBoolean(L, false);
- }
- return 1;
- }
- int LuaScriptInterface::luaGetPlayerInstantSpellInfo(lua_State* L)
- {
- //getPlayerInstantSpellInfo(cid, index)
- Player* player = getPlayer(L, 1);
- if (!player) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_PLAYER_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- uint32_t index = getNumber<uint32_t>(L, 2);
- InstantSpell* spell = g_spells->getInstantSpellByIndex(player, index);
- if (!spell) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_SPELL_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- lua_createtable(L, 0, 6);
- setField(L, "name", spell->getName());
- setField(L, "words", spell->getWords());
- setField(L, "level", spell->getLevel());
- setField(L, "mlevel", spell->getMagicLevel());
- setField(L, "mana", spell->getManaCost(player));
- setField(L, "manapercent", spell->getManaPercent());
- return 1;
- }
- int LuaScriptInterface::luaDoPlayerAddItem(lua_State* L)
- {
- //doPlayerAddItem(cid, itemid, <optional: default: 1> count/subtype, <optional: default: 1> canDropOnMap)
- //doPlayerAddItem(cid, itemid, <optional: default: 1> count, <optional: default: 1> canDropOnMap, <optional: default: 1>subtype)
- Player* player = getPlayer(L, 1);
- if (!player) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_PLAYER_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- uint16_t itemId = getNumber<uint16_t>(L, 2);
- int32_t count = getNumber<int32_t>(L, 3, 1);
- bool canDropOnMap = getBoolean(L, 4, true);
- uint16_t subType = getNumber<uint16_t>(L, 5, 1);
- const ItemType& it = Item::items[itemId];
- int32_t itemCount;
- auto parameters = lua_gettop(L);
- if (parameters > 4) {
- //subtype already supplied, count then is the amount
- itemCount = std::max<int32_t>(1, count);
- } else if (it.hasSubType()) {
- if (it.stackable) {
- itemCount = static_cast<int32_t>(std::ceil(static_cast<float>(count) / 100));
- } else {
- itemCount = 1;
- }
- subType = count;
- } else {
- itemCount = std::max<int32_t>(1, count);
- }
- while (itemCount > 0) {
- uint16_t stackCount = subType;
- if (it.stackable && stackCount > 100) {
- stackCount = 100;
- }
- Item* newItem = Item::CreateItem(itemId, stackCount);
- if (!newItem) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_ITEM_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- if (it.stackable) {
- subType -= stackCount;
- }
- ReturnValue ret = g_game.internalPlayerAddItem(player, newItem, canDropOnMap);
- if (ret != RETURNVALUE_NOERROR) {
- delete newItem;
- pushBoolean(L, false);
- return 1;
- }
- if (--itemCount == 0) {
- if (newItem->getParent()) {
- uint32_t uid = getScriptEnv()->addThing(newItem);
- lua_pushnumber(L, uid);
- return 1;
- } else {
- //stackable item stacked with existing object, newItem will be released
- pushBoolean(L, false);
- return 1;
- }
- }
- }
- pushBoolean(L, false);
- return 1;
- }
- int LuaScriptInterface::luaDoTileAddItemEx(lua_State* L)
- {
- //doTileAddItemEx(pos, uid)
- const Position& pos = getPosition(L, 1);
- Tile* tile = g_game.map.getTile(pos);
- if (!tile) {
- std::ostringstream ss;
- ss << pos << ' ' << getErrorDesc(LUA_ERROR_TILE_NOT_FOUND);
- reportErrorFunc(ss.str());
- pushBoolean(L, false);
- return 1;
- }
- uint32_t uid = getNumber<uint32_t>(L, 2);
- Item* item = getScriptEnv()->getItemByUID(uid);
- if (!item) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_ITEM_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- if (item->getParent() != VirtualCylinder::virtualCylinder) {
- reportErrorFunc("Item already has a parent");
- pushBoolean(L, false);
- return 1;
- }
- lua_pushnumber(L, g_game.internalAddItem(tile, item));
- return 1;
- }
- int LuaScriptInterface::luaDoCreateItem(lua_State* L)
- {
- //doCreateItem(itemid, <optional> type/count, pos)
- //Returns uid of the created item, only works on tiles.
- const Position& pos = getPosition(L, 3);
- Tile* tile = g_game.map.getTile(pos);
- if (!tile) {
- std::ostringstream ss;
- ss << pos << ' ' << getErrorDesc(LUA_ERROR_TILE_NOT_FOUND);
- reportErrorFunc(ss.str());
- pushBoolean(L, false);
- return 1;
- }
- ScriptEnvironment* env = getScriptEnv();
- int32_t itemCount = 1;
- int32_t subType = 1;
- uint16_t itemId = getNumber<uint16_t>(L, 1);
- uint32_t count = getNumber<uint32_t>(L, 2, 1);
- const ItemType& it = Item::items[itemId];
- if (it.hasSubType()) {
- if (it.stackable) {
- itemCount = static_cast<int32_t>(std::ceil(static_cast<float>(count) / 100));
- }
- subType = count;
- } else {
- itemCount = std::max<int32_t>(1, count);
- }
- while (itemCount > 0) {
- int32_t stackCount = std::min<int32_t>(100, subType);
- Item* newItem = Item::CreateItem(itemId, stackCount);
- if (!newItem) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_ITEM_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- if (it.stackable) {
- subType -= stackCount;
- }
- ReturnValue ret = g_game.internalAddItem(tile, newItem, INDEX_WHEREEVER, FLAG_NOLIMIT);
- if (ret != RETURNVALUE_NOERROR) {
- delete newItem;
- pushBoolean(L, false);
- return 1;
- }
- if (--itemCount == 0) {
- if (newItem->getParent()) {
- uint32_t uid = env->addThing(newItem);
- lua_pushnumber(L, uid);
- return 1;
- } else {
- //stackable item stacked with existing object, newItem will be released
- pushBoolean(L, false);
- return 1;
- }
- }
- }
- pushBoolean(L, false);
- return 1;
- }
- int LuaScriptInterface::luaDoCreateItemEx(lua_State* L)
- {
- //doCreateItemEx(itemid, <optional> count/subtype)
- //Returns uid of the created item
- uint16_t itemId = getNumber<uint16_t>(L, 1);
- uint32_t count = getNumber<uint32_t>(L, 2, 1);
- const ItemType& it = Item::items[itemId];
- if (it.stackable && count > 100) {
- reportErrorFunc("Stack count cannot be higher than 100.");
- count = 100;
- }
- Item* newItem = Item::CreateItem(itemId, count);
- if (!newItem) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_ITEM_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- newItem->setParent(VirtualCylinder::virtualCylinder);
- ScriptEnvironment* env = getScriptEnv();
- env->addTempItem(newItem);
- uint32_t uid = env->addThing(newItem);
- lua_pushnumber(L, uid);
- return 1;
- }
- int LuaScriptInterface::luaDebugPrint(lua_State* L)
- {
- //debugPrint(text)
- reportErrorFunc(getString(L, -1));
- return 0;
- }
- int LuaScriptInterface::luaGetWorldTime(lua_State* L)
- {
- //getWorldTime()
- uint32_t time = g_game.getLightHour();
- lua_pushnumber(L, time);
- return 1;
- }
- int LuaScriptInterface::luaGetWorldLight(lua_State* L)
- {
- //getWorldLight()
- LightInfo lightInfo;
- g_game.getWorldLightInfo(lightInfo);
- lua_pushnumber(L, lightInfo.level);
- lua_pushnumber(L, lightInfo.color);
- return 2;
- }
- int LuaScriptInterface::luaGetWorldUpTime(lua_State* L)
- {
- //getWorldUpTime()
- uint64_t uptime = (OTSYS_TIME() - ProtocolStatus::start) / 1000;
- lua_pushnumber(L, uptime);
- return 1;
- }
- bool LuaScriptInterface::getArea(lua_State* L, std::list<uint32_t>& list, uint32_t& rows)
- {
- lua_pushnil(L);
- for (rows = 0; lua_next(L, -2) != 0; ++rows) {
- if (!isTable(L, -1)) {
- return false;
- }
- lua_pushnil(L);
- while (lua_next(L, -2) != 0) {
- if (!isNumber(L, -1)) {
- return false;
- }
- list.push_back(getNumber<uint32_t>(L, -1));
- lua_pop(L, 1);
- }
- lua_pop(L, 1);
- }
- lua_pop(L, 1);
- return (rows != 0);
- }
- int LuaScriptInterface::luaCreateCombatArea(lua_State* L)
- {
- //createCombatArea( {area}, <optional> {extArea} )
- ScriptEnvironment* env = getScriptEnv();
- if (env->getScriptId() != EVENT_ID_LOADING) {
- reportErrorFunc("This function can only be used while loading the script.");
- pushBoolean(L, false);
- return 1;
- }
- uint32_t areaId = g_luaEnvironment.createAreaObject(env->getScriptInterface());
- AreaCombat* area = g_luaEnvironment.getAreaObject(areaId);
- int parameters = lua_gettop(L);
- if (parameters >= 2) {
- uint32_t rowsExtArea;
- std::list<uint32_t> listExtArea;
- if (!getArea(L, listExtArea, rowsExtArea)) {
- reportErrorFunc("Invalid extended area table.");
- pushBoolean(L, false);
- return 1;
- }
- area->setupExtArea(listExtArea, rowsExtArea);
- }
- uint32_t rowsArea = 0;
- std::list<uint32_t> listArea;
- if (!getArea(L, listArea, rowsArea)) {
- reportErrorFunc("Invalid area table.");
- pushBoolean(L, false);
- return 1;
- }
- area->setupArea(listArea, rowsArea);
- lua_pushnumber(L, areaId);
- return 1;
- }
- int LuaScriptInterface::luaDoAreaCombatHealth(lua_State* L)
- {
- //doAreaCombatHealth(cid, type, pos, area, min, max, effect[, origin = ORIGIN_SPELL])
- Creature* creature = getCreature(L, 1);
- if (!creature && (!isNumber(L, 1) || getNumber<uint32_t>(L, 1) != 0)) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- uint32_t areaId = getNumber<uint32_t>(L, 4);
- const AreaCombat* area = g_luaEnvironment.getAreaObject(areaId);
- if (area || areaId == 0) {
- CombatType_t combatType = getNumber<CombatType_t>(L, 2);
- CombatParams params;
- params.combatType = combatType;
- params.impactEffect = getNumber<uint8_t>(L, 7);
- CombatDamage damage;
- damage.origin = getNumber<CombatOrigin>(L, 8, ORIGIN_SPELL);
- damage.primary.type = combatType;
- damage.primary.value = normal_random(getNumber<int32_t>(L, 6), getNumber<int32_t>(L, 5));
- Combat::doCombatHealth(creature, getPosition(L, 3), area, damage, params);
- pushBoolean(L, true);
- } else {
- reportErrorFunc(getErrorDesc(LUA_ERROR_AREA_NOT_FOUND));
- pushBoolean(L, false);
- }
- return 1;
- }
- int LuaScriptInterface::luaDoTargetCombatHealth(lua_State* L)
- {
- //doTargetCombatHealth(cid, target, type, min, max, effect[, origin = ORIGIN_SPELL])
- Creature* creature = getCreature(L, 1);
- if (!creature && (!isNumber(L, 1) || getNumber<uint32_t>(L, 1) != 0)) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- Creature* target = getCreature(L, 2);
- if (!target) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- CombatType_t combatType = getNumber<CombatType_t>(L, 3);
- CombatParams params;
- params.combatType = combatType;
- params.impactEffect = getNumber<uint8_t>(L, 6);
- CombatDamage damage;
- damage.origin = getNumber<CombatOrigin>(L, 7, ORIGIN_SPELL);
- damage.primary.type = combatType;
- damage.primary.value = normal_random(getNumber<int32_t>(L, 4), getNumber<int32_t>(L, 5));
- Combat::doCombatHealth(creature, target, damage, params);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaDoAreaCombatMana(lua_State* L)
- {
- //doAreaCombatMana(cid, pos, area, min, max, effect[, origin = ORIGIN_SPELL])
- Creature* creature = getCreature(L, 1);
- if (!creature && (!isNumber(L, 1) || getNumber<uint32_t>(L, 1) != 0)) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- uint32_t areaId = getNumber<uint32_t>(L, 3);
- const AreaCombat* area = g_luaEnvironment.getAreaObject(areaId);
- if (area || areaId == 0) {
- CombatParams params;
- params.impactEffect = getNumber<uint8_t>(L, 6);
- CombatDamage damage;
- damage.origin = getNumber<CombatOrigin>(L, 7, ORIGIN_SPELL);
- damage.primary.type = COMBAT_MANADRAIN;
- damage.primary.value = normal_random(getNumber<int32_t>(L, 4), getNumber<int32_t>(L, 5));
- Position pos = getPosition(L, 2);
- Combat::doCombatMana(creature, pos, area, damage, params);
- pushBoolean(L, true);
- } else {
- reportErrorFunc(getErrorDesc(LUA_ERROR_AREA_NOT_FOUND));
- pushBoolean(L, false);
- }
- return 1;
- }
- int LuaScriptInterface::luaDoTargetCombatMana(lua_State* L)
- {
- //doTargetCombatMana(cid, target, min, max, effect[, origin = ORIGIN_SPELL)
- Creature* creature = getCreature(L, 1);
- if (!creature && (!isNumber(L, 1) || getNumber<uint32_t>(L, 1) != 0)) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- Creature* target = getCreature(L, 2);
- if (!target) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- CombatParams params;
- params.impactEffect = getNumber<uint8_t>(L, 5);
- CombatDamage damage;
- damage.origin = getNumber<CombatOrigin>(L, 6, ORIGIN_SPELL);
- damage.primary.type = COMBAT_MANADRAIN;
- damage.primary.value = normal_random(getNumber<int32_t>(L, 3), getNumber<int32_t>(L, 4));
- Combat::doCombatMana(creature, target, damage, params);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaDoAreaCombatCondition(lua_State* L)
- {
- //doAreaCombatCondition(cid, pos, area, condition, effect)
- Creature* creature = getCreature(L, 1);
- if (!creature && (!isNumber(L, 1) || getNumber<uint32_t>(L, 1) != 0)) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- const Condition* condition = getUserdata<Condition>(L, 4);
- if (!condition) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CONDITION_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- uint32_t areaId = getNumber<uint32_t>(L, 3);
- const AreaCombat* area = g_luaEnvironment.getAreaObject(areaId);
- if (area || areaId == 0) {
- CombatParams params;
- params.impactEffect = getNumber<uint8_t>(L, 5);
- params.conditionList.emplace_front(condition);
- Combat::doCombatCondition(creature, getPosition(L, 2), area, params);
- pushBoolean(L, true);
- } else {
- reportErrorFunc(getErrorDesc(LUA_ERROR_AREA_NOT_FOUND));
- pushBoolean(L, false);
- }
- return 1;
- }
- int LuaScriptInterface::luaDoTargetCombatCondition(lua_State* L)
- {
- //doTargetCombatCondition(cid, target, condition, effect)
- Creature* creature = getCreature(L, 1);
- if (!creature && (!isNumber(L, 1) || getNumber<uint32_t>(L, 1) != 0)) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- Creature* target = getCreature(L, 2);
- if (!target) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- const Condition* condition = getUserdata<Condition>(L, 3);
- if (!condition) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CONDITION_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- CombatParams params;
- params.impactEffect = getNumber<uint8_t>(L, 4);
- params.conditionList.emplace_front(condition);
- Combat::doCombatCondition(creature, target, params);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaDoAreaCombatDispel(lua_State* L)
- {
- //doAreaCombatDispel(cid, pos, area, type, effect)
- Creature* creature = getCreature(L, 1);
- if (!creature && (!isNumber(L, 1) || getNumber<uint32_t>(L, 1) != 0)) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- uint32_t areaId = getNumber<uint32_t>(L, 3);
- const AreaCombat* area = g_luaEnvironment.getAreaObject(areaId);
- if (area || areaId == 0) {
- CombatParams params;
- params.impactEffect = getNumber<uint8_t>(L, 5);
- params.dispelType = getNumber<ConditionType_t>(L, 4);
- Combat::doCombatDispel(creature, getPosition(L, 2), area, params);
- pushBoolean(L, true);
- } else {
- reportErrorFunc(getErrorDesc(LUA_ERROR_AREA_NOT_FOUND));
- pushBoolean(L, false);
- }
- return 1;
- }
- int LuaScriptInterface::luaDoTargetCombatDispel(lua_State* L)
- {
- //doTargetCombatDispel(cid, target, type, effect)
- Creature* creature = getCreature(L, 1);
- if (!creature && (!isNumber(L, 1) || getNumber<uint32_t>(L, 1) != 0)) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- Creature* target = getCreature(L, 2);
- if (!target) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- CombatParams params;
- params.dispelType = getNumber<ConditionType_t>(L, 3);
- params.impactEffect = getNumber<uint8_t>(L, 4);
- Combat::doCombatDispel(creature, target, params);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaDoChallengeCreature(lua_State* L)
- {
- //doChallengeCreature(cid, target)
- Creature* creature = getCreature(L, 1);
- if (!creature) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- Creature* target = getCreature(L, 2);
- if (!target) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- target->challengeCreature(creature);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaSetCreatureOutfit(lua_State* L)
- {
- //doSetCreatureOutfit(cid, outfit, time)
- Creature* creature = getCreature(L, 1);
- if (!creature) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- Outfit_t outfit = getOutfit(L, 2);
- int32_t time = getNumber<int32_t>(L, 3);
- pushBoolean(L, Spell::CreateIllusion(creature, outfit, time) == RETURNVALUE_NOERROR);
- return 1;
- }
- int LuaScriptInterface::luaSetMonsterOutfit(lua_State* L)
- {
- //doSetMonsterOutfit(cid, name, time)
- Creature* creature = getCreature(L, 1);
- if (!creature) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- std::string name = getString(L, 2);
- int32_t time = getNumber<int32_t>(L, 3);
- pushBoolean(L, Spell::CreateIllusion(creature, name, time) == RETURNVALUE_NOERROR);
- return 1;
- }
- int LuaScriptInterface::luaSetItemOutfit(lua_State* L)
- {
- //doSetItemOutfit(cid, item, time)
- Creature* creature = getCreature(L, 1);
- if (!creature) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- uint32_t item = getNumber<uint32_t>(L, 2);
- int32_t time = getNumber<int32_t>(L, 3);
- pushBoolean(L, Spell::CreateIllusion(creature, item, time) == RETURNVALUE_NOERROR);
- return 1;
- }
- int LuaScriptInterface::luaDoMoveCreature(lua_State* L)
- {
- //doMoveCreature(cid, direction)
- Creature* creature = getCreature(L, 1);
- if (!creature) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- Direction direction = getNumber<Direction>(L, 2);
- if (direction > DIRECTION_LAST) {
- reportErrorFunc("No valid direction");
- pushBoolean(L, false);
- return 1;
- }
- ReturnValue ret = g_game.internalMoveCreature(creature, direction, FLAG_NOLIMIT);
- lua_pushnumber(L, ret);
- return 1;
- }
- int LuaScriptInterface::luaIsValidUID(lua_State* L)
- {
- //isValidUID(uid)
- pushBoolean(L, getScriptEnv()->getThingByUID(getNumber<uint32_t>(L, -1)) != nullptr);
- return 1;
- }
- int LuaScriptInterface::luaIsDepot(lua_State* L)
- {
- //isDepot(uid)
- Container* container = getScriptEnv()->getContainerByUID(getNumber<uint32_t>(L, -1));
- pushBoolean(L, container && container->getDepotLocker());
- return 1;
- }
- int LuaScriptInterface::luaIsMoveable(lua_State* L)
- {
- //isMoveable(uid)
- //isMovable(uid)
- Thing* thing = getScriptEnv()->getThingByUID(getNumber<uint32_t>(L, -1));
- pushBoolean(L, thing && thing->isPushable());
- return 1;
- }
- int LuaScriptInterface::luaDoAddContainerItem(lua_State* L)
- {
- //doAddContainerItem(uid, itemid, <optional> count/subtype)
- uint32_t uid = getNumber<uint32_t>(L, 1);
- ScriptEnvironment* env = getScriptEnv();
- Container* container = env->getContainerByUID(uid);
- if (!container) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CONTAINER_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- uint16_t itemId = getNumber<uint16_t>(L, 2);
- const ItemType& it = Item::items[itemId];
- int32_t itemCount = 1;
- int32_t subType = 1;
- uint32_t count = getNumber<uint32_t>(L, 3, 1);
- if (it.hasSubType()) {
- if (it.stackable) {
- itemCount = static_cast<int32_t>(std::ceil(static_cast<float>(count) / 100));
- }
- subType = count;
- } else {
- itemCount = std::max<int32_t>(1, count);
- }
- while (itemCount > 0) {
- int32_t stackCount = std::min<int32_t>(100, subType);
- Item* newItem = Item::CreateItem(itemId, stackCount);
- if (!newItem) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_ITEM_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- if (it.stackable) {
- subType -= stackCount;
- }
- ReturnValue ret = g_game.internalAddItem(container, newItem);
- if (ret != RETURNVALUE_NOERROR) {
- delete newItem;
- pushBoolean(L, false);
- return 1;
- }
- if (--itemCount == 0) {
- if (newItem->getParent()) {
- lua_pushnumber(L, env->addThing(newItem));
- } else {
- //stackable item stacked with existing object, newItem will be released
- pushBoolean(L, false);
- }
- return 1;
- }
- }
- pushBoolean(L, false);
- return 1;
- }
- int LuaScriptInterface::luaGetDepotId(lua_State* L)
- {
- //getDepotId(uid)
- uint32_t uid = getNumber<uint32_t>(L, -1);
- Container* container = getScriptEnv()->getContainerByUID(uid);
- if (!container) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CONTAINER_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- DepotLocker* depotLocker = container->getDepotLocker();
- if (!depotLocker) {
- reportErrorFunc("Depot not found");
- pushBoolean(L, false);
- return 1;
- }
- lua_pushnumber(L, depotLocker->getDepotId());
- return 1;
- }
- int LuaScriptInterface::luaIsInArray(lua_State* L)
- {
- //isInArray(array, value)
- if (!isTable(L, 1)) {
- pushBoolean(L, false);
- return 1;
- }
- lua_pushnil(L);
- while (lua_next(L, 1)) {
- if (lua_equal(L, 2, -1) != 0) {
- pushBoolean(L, true);
- return 1;
- }
- lua_pop(L, 1);
- }
- pushBoolean(L, false);
- return 1;
- }
- int LuaScriptInterface::luaDoSetCreatureLight(lua_State* L)
- {
- //doSetCreatureLight(cid, lightLevel, lightColor, time)
- Creature* creature = getCreature(L, 1);
- if (!creature) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_PLAYER_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- uint16_t level = getNumber<uint16_t>(L, 2);
- uint16_t color = getNumber<uint16_t>(L, 3);
- uint32_t time = getNumber<uint32_t>(L, 4);
- Condition* condition = Condition::createCondition(CONDITIONID_COMBAT, CONDITION_LIGHT, time, level | (color << 8));
- creature->addCondition(condition);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaAddEvent(lua_State* L)
- {
- //addEvent(callback, delay, ...)
- lua_State* globalState = g_luaEnvironment.getLuaState();
- if (!globalState) {
- reportErrorFunc("No valid script interface!");
- pushBoolean(L, false);
- return 1;
- } else if (globalState != L) {
- lua_xmove(L, globalState, lua_gettop(L));
- }
- int parameters = lua_gettop(globalState);
- if (!isFunction(globalState, -parameters)) { //-parameters means the first parameter from left to right
- reportErrorFunc("callback parameter should be a function.");
- pushBoolean(L, false);
- return 1;
- }
- if (g_config.getBoolean(ConfigManager::WARN_UNSAFE_SCRIPTS) || g_config.getBoolean(ConfigManager::CONVERT_UNSAFE_SCRIPTS)) {
- std::vector<std::pair<int32_t, LuaDataType>> indexes;
- for (int i = 3; i <= parameters; ++i) {
- if (lua_getmetatable(globalState, i) == 0) {
- continue;
- }
- lua_rawgeti(L, -1, 't');
- LuaDataType type = getNumber<LuaDataType>(L, -1);
- if (type != LuaData_Unknown && type != LuaData_Tile) {
- indexes.push_back({i, type});
- }
- lua_pop(globalState, 2);
- }
- if (!indexes.empty()) {
- if (g_config.getBoolean(ConfigManager::WARN_UNSAFE_SCRIPTS)) {
- bool plural = indexes.size() > 1;
- std::string warningString = "Argument";
- if (plural) {
- warningString += 's';
- }
- for (const auto& entry : indexes) {
- if (entry == indexes.front()) {
- warningString += ' ';
- } else if (entry == indexes.back()) {
- warningString += " and ";
- } else {
- warningString += ", ";
- }
- warningString += '#';
- warningString += std::to_string(entry.first);
- }
- if (plural) {
- warningString += " are unsafe";
- } else {
- warningString += " is unsafe";
- }
- reportErrorFunc(warningString);
- }
- if (g_config.getBoolean(ConfigManager::CONVERT_UNSAFE_SCRIPTS)) {
- for (const auto& entry : indexes) {
- switch (entry.second) {
- case LuaData_Item:
- case LuaData_Container:
- case LuaData_Teleport: {
- lua_getglobal(globalState, "Item");
- lua_getfield(globalState, -1, "getUniqueId");
- break;
- }
- case LuaData_Player:
- case LuaData_Monster:
- case LuaData_Npc: {
- lua_getglobal(globalState, "Creature");
- lua_getfield(globalState, -1, "getId");
- break;
- }
- default:
- break;
- }
- lua_replace(globalState, -2);
- lua_pushvalue(globalState, entry.first);
- lua_call(globalState, 1, 1);
- lua_replace(globalState, entry.first);
- }
- }
- }
- }
- LuaTimerEventDesc eventDesc;
- for (int i = 0; i < parameters - 2; ++i) { //-2 because addEvent needs at least two parameters
- eventDesc.parameters.push_back(luaL_ref(globalState, LUA_REGISTRYINDEX));
- }
- uint32_t delay = std::max<uint32_t>(100, getNumber<uint32_t>(globalState, 2));
- lua_pop(globalState, 1);
- eventDesc.function = luaL_ref(globalState, LUA_REGISTRYINDEX);
- eventDesc.scriptId = getScriptEnv()->getScriptId();
- auto& lastTimerEventId = g_luaEnvironment.m_lastEventTimerId;
- eventDesc.eventId = g_scheduler.addEvent(createSchedulerTask(
- delay, std::bind(&LuaEnvironment::executeTimerEvent, &g_luaEnvironment, lastTimerEventId)
- ));
- g_luaEnvironment.m_timerEvents.emplace(lastTimerEventId, std::move(eventDesc));
- lua_pushnumber(L, lastTimerEventId++);
- return 1;
- }
- int LuaScriptInterface::luaStopEvent(lua_State* L)
- {
- //stopEvent(eventid)
- lua_State* globalState = g_luaEnvironment.getLuaState();
- if (!globalState) {
- reportErrorFunc("No valid script interface!");
- pushBoolean(L, false);
- return 1;
- }
- uint32_t eventId = getNumber<uint32_t>(L, 1);
- auto& timerEvents = g_luaEnvironment.m_timerEvents;
- auto it = timerEvents.find(eventId);
- if (it == timerEvents.end()) {
- pushBoolean(L, false);
- return 1;
- }
- LuaTimerEventDesc timerEventDesc = std::move(it->second);
- timerEvents.erase(it);
- g_scheduler.stopEvent(timerEventDesc.eventId);
- luaL_unref(globalState, LUA_REGISTRYINDEX, timerEventDesc.function);
- for (auto parameter : timerEventDesc.parameters) {
- luaL_unref(globalState, LUA_REGISTRYINDEX, parameter);
- }
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaGetCreatureCondition(lua_State* L)
- {
- Creature* creature = getCreature(L, 1);
- if (!creature) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- ConditionType_t condition = getNumber<ConditionType_t>(L, 2);
- uint32_t subId = getNumber<uint32_t>(L, 3, 0);
- pushBoolean(L, creature->hasCondition(condition, subId));
- return 1;
- }
- int LuaScriptInterface::luaSaveServer(lua_State* L)
- {
- g_game.saveGameState();
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaCleanMap(lua_State* L)
- {
- lua_pushnumber(L, g_game.map.clean());
- return 1;
- }
- int LuaScriptInterface::luaIsInWar(lua_State* L)
- {
- //isInWar(cid, target)
- Player* player = getPlayer(L, 1);
- if (!player) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_PLAYER_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- Player* targetPlayer = getPlayer(L, 2);
- if (!targetPlayer) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_PLAYER_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- pushBoolean(L, player->isInWar(targetPlayer));
- return 1;
- }
- int LuaScriptInterface::luaGetWaypointPositionByName(lua_State* L)
- {
- //getWaypointPositionByName(name)
- auto& waypoints = g_game.map.waypoints;
- auto it = waypoints.find(getString(L, -1));
- if (it != waypoints.end()) {
- pushPosition(L, it->second);
- } else {
- pushBoolean(L, false);
- }
- return 1;
- }
- int LuaScriptInterface::luaSendChannelMessage(lua_State* L)
- {
- //sendChannelMessage(channelId, type, message)
- uint32_t channelId = getNumber<uint32_t>(L, 1);
- ChatChannel* channel = g_chat->getChannelById(channelId);
- if (!channel) {
- pushBoolean(L, false);
- return 1;
- }
- SpeakClasses type = getNumber<SpeakClasses>(L, 2);
- std::string message = getString(L, 3);
- channel->sendToAll(message, type);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaSendGuildChannelMessage(lua_State* L)
- {
- //sendGuildChannelMessage(guildId, type, message)
- uint32_t guildId = getNumber<uint32_t>(L, 1);
- ChatChannel* channel = g_chat->getGuildChannelById(guildId);
- if (!channel) {
- pushBoolean(L, false);
- return 1;
- }
- SpeakClasses type = getNumber<SpeakClasses>(L, 2);
- std::string message = getString(L, 3);
- channel->sendToAll(message, type);
- pushBoolean(L, true);
- return 1;
- }
- std::string LuaScriptInterface::escapeString(const std::string& string)
- {
- std::string s = string;
- replaceString(s, "\\", "\\\\");
- replaceString(s, "\"", "\\\"");
- replaceString(s, "'", "\\'");
- replaceString(s, "[[", "\\[[");
- return s;
- }
- #ifndef LUAJIT_VERSION
- const luaL_Reg LuaScriptInterface::luaBitReg[] = {
- //{"tobit", LuaScriptInterface::luaBitToBit},
- {"bnot", LuaScriptInterface::luaBitNot},
- {"band", LuaScriptInterface::luaBitAnd},
- {"bor", LuaScriptInterface::luaBitOr},
- {"bxor", LuaScriptInterface::luaBitXor},
- {"lshift", LuaScriptInterface::luaBitLeftShift},
- {"rshift", LuaScriptInterface::luaBitRightShift},
- //{"arshift", LuaScriptInterface::luaBitArithmeticalRightShift},
- //{"rol", LuaScriptInterface::luaBitRotateLeft},
- //{"ror", LuaScriptInterface::luaBitRotateRight},
- //{"bswap", LuaScriptInterface::luaBitSwapEndian},
- //{"tohex", LuaScriptInterface::luaBitToHex},
- {nullptr, nullptr}
- };
- int LuaScriptInterface::luaBitNot(lua_State* L)
- {
- lua_pushnumber(L, ~getNumber<uint32_t>(L, -1));
- return 1;
- }
- #define MULTIOP(name, op) \
- int LuaScriptInterface::luaBit##name(lua_State* L) \
- { \
- int n = lua_gettop(L); \
- uint32_t w = getNumber<uint32_t>(L, -1); \
- for (int i = 1; i < n; ++i) \
- w op getNumber<uint32_t>(L, i); \
- lua_pushnumber(L, w); \
- return 1; \
- }
- MULTIOP(And, &= )
- MULTIOP(Or, |= )
- MULTIOP(Xor, ^= )
- #define SHIFTOP(name, op) \
- int LuaScriptInterface::luaBit##name(lua_State* L) \
- { \
- uint32_t n1 = getNumber<uint32_t>(L, 1), n2 = getNumber<uint32_t>(L, 2); \
- lua_pushnumber(L, (n1 op n2)); \
- return 1; \
- }
- SHIFTOP(LeftShift, << )
- SHIFTOP(RightShift, >> )
- #endif
- const luaL_Reg LuaScriptInterface::luaConfigManagerTable[] = {
- {"getString", LuaScriptInterface::luaConfigManagerGetString},
- {"getNumber", LuaScriptInterface::luaConfigManagerGetNumber},
- {"getBoolean", LuaScriptInterface::luaConfigManagerGetBoolean},
- {nullptr, nullptr}
- };
- int LuaScriptInterface::luaConfigManagerGetString(lua_State* L)
- {
- pushString(L, g_config.getString(getNumber<ConfigManager::string_config_t>(L, -1)));
- return 1;
- }
- int LuaScriptInterface::luaConfigManagerGetNumber(lua_State* L)
- {
- lua_pushnumber(L, g_config.getNumber(getNumber<ConfigManager::integer_config_t>(L, -1)));
- return 1;
- }
- int LuaScriptInterface::luaConfigManagerGetBoolean(lua_State* L)
- {
- pushBoolean(L, g_config.getBoolean(getNumber<ConfigManager::boolean_config_t>(L, -1)));
- return 1;
- }
- const luaL_Reg LuaScriptInterface::luaDatabaseTable[] = {
- {"query", LuaScriptInterface::luaDatabaseExecute},
- {"asyncQuery", LuaScriptInterface::luaDatabaseAsyncExecute},
- {"storeQuery", LuaScriptInterface::luaDatabaseStoreQuery},
- {"asyncStoreQuery", LuaScriptInterface::luaDatabaseAsyncStoreQuery},
- {"escapeString", LuaScriptInterface::luaDatabaseEscapeString},
- {"escapeBlob", LuaScriptInterface::luaDatabaseEscapeBlob},
- {"lastInsertId", LuaScriptInterface::luaDatabaseLastInsertId},
- {"tableExists", LuaScriptInterface::luaDatabaseTableExists},
- {nullptr, nullptr}
- };
- int LuaScriptInterface::luaDatabaseExecute(lua_State* L)
- {
- pushBoolean(L, Database::getInstance()->executeQuery(getString(L, -1)));
- return 1;
- }
- int LuaScriptInterface::luaDatabaseAsyncExecute(lua_State* L)
- {
- std::function<void(DBResult_ptr, bool)> callback;
- if (lua_gettop(L) > 1) {
- int32_t ref = luaL_ref(L, LUA_REGISTRYINDEX);
- auto scriptId = getScriptEnv()->getScriptId();
- callback = [ref, scriptId](DBResult_ptr, bool success) {
- lua_State* luaState = g_luaEnvironment.getLuaState();
- if (!luaState) {
- return;
- }
- if (!LuaScriptInterface::reserveScriptEnv()) {
- luaL_unref(luaState, LUA_REGISTRYINDEX, ref);
- return;
- }
- lua_rawgeti(luaState, LUA_REGISTRYINDEX, ref);
- pushBoolean(luaState, success);
- auto env = getScriptEnv();
- env->setScriptId(scriptId, &g_luaEnvironment);
- g_luaEnvironment.callFunction(1);
- luaL_unref(luaState, LUA_REGISTRYINDEX, ref);
- };
- }
- g_databaseTasks.addTask(getString(L, -1), callback);
- return 0;
- }
- int LuaScriptInterface::luaDatabaseStoreQuery(lua_State* L)
- {
- if (DBResult_ptr res = Database::getInstance()->storeQuery(getString(L, -1))) {
- lua_pushnumber(L, ScriptEnvironment::addResult(res));
- } else {
- pushBoolean(L, false);
- }
- return 1;
- }
- int LuaScriptInterface::luaDatabaseAsyncStoreQuery(lua_State* L)
- {
- std::function<void(DBResult_ptr, bool)> callback;
- if (lua_gettop(L) > 1) {
- int32_t ref = luaL_ref(L, LUA_REGISTRYINDEX);
- auto scriptId = getScriptEnv()->getScriptId();
- callback = [ref, scriptId](DBResult_ptr result, bool) {
- lua_State* luaState = g_luaEnvironment.getLuaState();
- if (!luaState) {
- return;
- }
- if (!LuaScriptInterface::reserveScriptEnv()) {
- luaL_unref(luaState, LUA_REGISTRYINDEX, ref);
- return;
- }
- lua_rawgeti(luaState, LUA_REGISTRYINDEX, ref);
- if (result) {
- lua_pushnumber(luaState, ScriptEnvironment::addResult(result));
- } else {
- pushBoolean(luaState, false);
- }
- auto env = getScriptEnv();
- env->setScriptId(scriptId, &g_luaEnvironment);
- g_luaEnvironment.callFunction(1);
- luaL_unref(luaState, LUA_REGISTRYINDEX, ref);
- };
- }
- g_databaseTasks.addTask(getString(L, -1), callback, true);
- return 0;
- }
- int LuaScriptInterface::luaDatabaseEscapeString(lua_State* L)
- {
- pushString(L, Database::getInstance()->escapeString(getString(L, -1)));
- return 1;
- }
- int LuaScriptInterface::luaDatabaseEscapeBlob(lua_State* L)
- {
- uint32_t length = getNumber<uint32_t>(L, 2);
- pushString(L, Database::getInstance()->escapeBlob(getString(L, 1).c_str(), length));
- return 1;
- }
- int LuaScriptInterface::luaDatabaseLastInsertId(lua_State* L)
- {
- lua_pushnumber(L, Database::getInstance()->getLastInsertId());
- return 1;
- }
- int LuaScriptInterface::luaDatabaseTableExists(lua_State* L)
- {
- pushBoolean(L, DatabaseManager::tableExists(getString(L, -1)));
- return 1;
- }
- const luaL_Reg LuaScriptInterface::luaResultTable[] = {
- {"getNumber", LuaScriptInterface::luaResultGetNumber},
- {"getString", LuaScriptInterface::luaResultGetString},
- {"getStream", LuaScriptInterface::luaResultGetStream},
- {"next", LuaScriptInterface::luaResultNext},
- {"free", LuaScriptInterface::luaResultFree},
- {nullptr, nullptr}
- };
- int LuaScriptInterface::luaResultGetNumber(lua_State* L)
- {
- DBResult_ptr res = ScriptEnvironment::getResultByID(getNumber<uint32_t>(L, 1));
- if (!res) {
- pushBoolean(L, false);
- return 1;
- }
- const std::string& s = getString(L, 2);
- lua_pushnumber(L, res->getNumber<int64_t>(s));
- return 1;
- }
- int LuaScriptInterface::luaResultGetString(lua_State* L)
- {
- DBResult_ptr res = ScriptEnvironment::getResultByID(getNumber<uint32_t>(L, 1));
- if (!res) {
- pushBoolean(L, false);
- return 1;
- }
- const std::string& s = getString(L, 2);
- pushString(L, res->getString(s));
- return 1;
- }
- int LuaScriptInterface::luaResultGetStream(lua_State* L)
- {
- DBResult_ptr res = ScriptEnvironment::getResultByID(getNumber<uint32_t>(L, 1));
- if (!res) {
- pushBoolean(L, false);
- return 1;
- }
- unsigned long length;
- const char* stream = res->getStream(getString(L, 2), length);
- lua_pushlstring(L, stream, length);
- lua_pushnumber(L, length);
- return 2;
- }
- int LuaScriptInterface::luaResultNext(lua_State* L)
- {
- DBResult_ptr res = ScriptEnvironment::getResultByID(getNumber<uint32_t>(L, -1));
- if (!res) {
- pushBoolean(L, false);
- return 1;
- }
- pushBoolean(L, res->next());
- return 1;
- }
- int LuaScriptInterface::luaResultFree(lua_State* L)
- {
- pushBoolean(L, ScriptEnvironment::removeResult(getNumber<uint32_t>(L, -1)));
- return 1;
- }
- // Userdata
- int LuaScriptInterface::luaUserdataCompare(lua_State* L)
- {
- // userdataA == userdataB
- pushBoolean(L, getUserdata<void>(L, 1) == getUserdata<void>(L, 2));
- return 1;
- }
- // _G
- int LuaScriptInterface::luaIsType(lua_State* L)
- {
- // isType(derived, base)
- lua_getmetatable(L, -2);
- lua_getmetatable(L, -2);
- lua_rawgeti(L, -2, 'p');
- uint_fast8_t parentsB = getNumber<uint_fast8_t>(L, 1);
- lua_rawgeti(L, -3, 'h');
- size_t hashB = getNumber<size_t>(L, 1);
- lua_rawgeti(L, -3, 'p');
- uint_fast8_t parentsA = getNumber<uint_fast8_t>(L, 1);
- for (uint_fast8_t i = parentsA; i < parentsB; ++i) {
- lua_getfield(L, -3, "__index");
- lua_replace(L, -4);
- }
- lua_rawgeti(L, -4, 'h');
- size_t hashA = getNumber<size_t>(L, 1);
- pushBoolean(L, hashA == hashB);
- return 1;
- }
- int LuaScriptInterface::luaRawGetMetatable(lua_State* L)
- {
- // rawgetmetatable(metatableName)
- luaL_getmetatable(L, getString(L, 1).c_str());
- return 1;
- }
- // os
- int LuaScriptInterface::luaSystemTime(lua_State* L)
- {
- // os.mtime()
- lua_pushnumber(L, OTSYS_TIME());
- return 1;
- }
- // table
- int LuaScriptInterface::luaTableCreate(lua_State* L)
- {
- // table.create(arrayLength, keyLength)
- lua_createtable(L, getNumber<int32_t>(L, 1), getNumber<int32_t>(L, 2));
- return 1;
- }
- // Game
- int LuaScriptInterface::luaGameGetSpectators(lua_State* L)
- {
- // Game.getSpectators(position[, multifloor = false[, onlyPlayer = false[, minRangeX = 0[, maxRangeX = 0[, minRangeY = 0[, maxRangeY = 0]]]]]])
- const Position& position = getPosition(L, 1);
- bool multifloor = getBoolean(L, 2, false);
- bool onlyPlayers = getBoolean(L, 3, false);
- int32_t minRangeX = getNumber<int32_t>(L, 4, 0);
- int32_t maxRangeX = getNumber<int32_t>(L, 5, 0);
- int32_t minRangeY = getNumber<int32_t>(L, 6, 0);
- int32_t maxRangeY = getNumber<int32_t>(L, 7, 0);
- SpectatorVec spectators;
- g_game.map.getSpectators(spectators, position, multifloor, onlyPlayers, minRangeX, maxRangeX, minRangeY, maxRangeY);
- lua_createtable(L, spectators.size(), 0);
- int index = 0;
- for (Creature* creature : spectators) {
- pushUserdata<Creature>(L, creature);
- setCreatureMetatable(L, -1, creature);
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaGameGetPlayers(lua_State* L)
- {
- // Game.getPlayers()
- lua_createtable(L, g_game.getPlayersOnline(), 0);
- int index = 0;
- for (const auto& playerEntry : g_game.getPlayers()) {
- pushUserdata<Player>(L, playerEntry.second);
- setMetatable(L, -1, "Player");
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaGameLoadMap(lua_State* L)
- {
- // Game.loadMap(path)
- const std::string& path = getString(L, 1);
- g_dispatcher.addTask(createTask(std::bind(&Game::loadMap, &g_game, path)));
- return 0;
- }
- int LuaScriptInterface::luaGameGetExperienceStage(lua_State* L)
- {
- // Game.getExperienceStage(level)
- uint32_t level = getNumber<uint32_t>(L, 1);
- lua_pushnumber(L, g_game.getExperienceStage(level));
- return 1;
- }
- int LuaScriptInterface::luaGameGetMonsterCount(lua_State* L)
- {
- // Game.getMonsterCount()
- lua_pushnumber(L, g_game.getMonstersOnline());
- return 1;
- }
- int LuaScriptInterface::luaGameGetPlayerCount(lua_State* L)
- {
- // Game.getPlayerCount()
- lua_pushnumber(L, g_game.getPlayersOnline());
- return 1;
- }
- int LuaScriptInterface::luaGameGetNpcCount(lua_State* L)
- {
- // Game.getNpcCount()
- lua_pushnumber(L, g_game.getNpcsOnline());
- return 1;
- }
- int LuaScriptInterface::luaGameGetTowns(lua_State* L)
- {
- // Game.getTowns()
- const auto& towns = g_game.map.towns.getTowns();
- lua_createtable(L, towns.size(), 0);
- int index = 0;
- for (auto townEntry : towns) {
- pushUserdata<Town>(L, townEntry.second);
- setMetatable(L, -1, "Town");
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaGameGetHouses(lua_State* L)
- {
- // Game.getHouses()
- const auto& houses = g_game.map.houses.getHouses();
- lua_createtable(L, houses.size(), 0);
- int index = 0;
- for (auto houseEntry : houses) {
- pushUserdata<House>(L, houseEntry.second);
- setMetatable(L, -1, "House");
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaGameGetGameState(lua_State* L)
- {
- // Game.getGameState()
- lua_pushnumber(L, g_game.getGameState());
- return 1;
- }
- int LuaScriptInterface::luaGameSetGameState(lua_State* L)
- {
- // Game.setGameState(state)
- GameState_t state = getNumber<GameState_t>(L, 1);
- g_game.setGameState(state);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaGameGetWorldType(lua_State* L)
- {
- // Game.getWorldType()
- lua_pushnumber(L, g_game.getWorldType());
- return 1;
- }
- int LuaScriptInterface::luaGameSetWorldType(lua_State* L)
- {
- // Game.setWorldType(type)
- WorldType_t type = getNumber<WorldType_t>(L, 1);
- g_game.setWorldType(type);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaGameGetReturnMessage(lua_State* L)
- {
- // Game.getReturnMessage(value)
- ReturnValue value = getNumber<ReturnValue>(L, 1);
- pushString(L, getReturnMessage(value));
- return 1;
- }
- int LuaScriptInterface::luaGameCreateItem(lua_State* L)
- {
- // Game.createItem(itemId[, count[, position]])
- uint16_t count = getNumber<uint16_t>(L, 2, 1);
- uint16_t id;
- if (isNumber(L, 1)) {
- id = getNumber<uint16_t>(L, 1);
- } else {
- id = Item::items.getItemIdByName(getString(L, 1));
- if (id == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- const ItemType& it = Item::items[id];
- if (it.stackable) {
- count = std::min<uint16_t>(count, 100);
- }
- Item* item = Item::CreateItem(id, count);
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- if (lua_gettop(L) >= 3) {
- const Position& position = getPosition(L, 3);
- Tile* tile = g_game.map.getTile(position);
- if (!tile) {
- delete item;
- lua_pushnil(L);
- return 1;
- }
- g_game.internalAddItem(tile, item, INDEX_WHEREEVER, FLAG_NOLIMIT);
- } else {
- getScriptEnv()->addTempItem(item);
- item->setParent(VirtualCylinder::virtualCylinder);
- }
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- return 1;
- }
- int LuaScriptInterface::luaGameCreateContainer(lua_State* L)
- {
- // Game.createContainer(itemId, size[, position])
- uint16_t size = getNumber<uint16_t>(L, 2);
- uint16_t id;
- if (isNumber(L, 1)) {
- id = getNumber<uint16_t>(L, 1);
- } else {
- id = Item::items.getItemIdByName(getString(L, 1));
- if (id == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- Container* container = Item::CreateItemAsContainer(id, size);
- if (!container) {
- lua_pushnil(L);
- return 1;
- }
- if (lua_gettop(L) >= 3) {
- const Position& position = getPosition(L, 3);
- Tile* tile = g_game.map.getTile(position);
- if (!tile) {
- delete container;
- lua_pushnil(L);
- return 1;
- }
- g_game.internalAddItem(tile, container, INDEX_WHEREEVER, FLAG_NOLIMIT);
- } else {
- getScriptEnv()->addTempItem(container);
- container->setParent(VirtualCylinder::virtualCylinder);
- }
- pushUserdata<Container>(L, container);
- setMetatable(L, -1, "Container");
- return 1;
- }
- int LuaScriptInterface::luaGameCreateMonster(lua_State* L)
- {
- // Game.createMonster(monsterName, position[, extended = false[, force = false]])
- Monster* monster = Monster::createMonster(getString(L, 1));
- if (!monster) {
- lua_pushnil(L);
- return 1;
- }
- const Position& position = getPosition(L, 2);
- bool extended = getBoolean(L, 3, false);
- bool force = getBoolean(L, 4, false);
- if (g_game.placeCreature(monster, position, extended, force)) {
- pushUserdata<Monster>(L, monster);
- setMetatable(L, -1, "Monster");
- } else {
- delete monster;
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGameCreateNpc(lua_State* L)
- {
- // Game.createNpc(npcName, position[, extended = false[, force = false]])
- Npc* npc = Npc::createNpc(getString(L, 1));
- if (!npc) {
- lua_pushnil(L);
- return 1;
- }
- const Position& position = getPosition(L, 2);
- bool extended = getBoolean(L, 3, false);
- bool force = getBoolean(L, 4, false);
- if (g_game.placeCreature(npc, position, extended, force)) {
- pushUserdata<Npc>(L, npc);
- setMetatable(L, -1, "Npc");
- } else {
- delete npc;
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGameCreateTile(lua_State* L)
- {
- // Game.createTile(x, y, z[, isDynamic = false])
- // Game.createTile(position[, isDynamic = false])
- Position position;
- bool isDynamic;
- if (isTable(L, 1)) {
- position = getPosition(L, 1);
- isDynamic = getBoolean(L, 2, false);
- } else {
- position.x = getNumber<uint16_t>(L, 1);
- position.y = getNumber<uint16_t>(L, 2);
- position.z = getNumber<uint16_t>(L, 3);
- isDynamic = getBoolean(L, 4, false);
- }
- Tile* tile = g_game.map.getTile(position);
- if (!tile) {
- if (isDynamic) {
- tile = new DynamicTile(position.x, position.y, position.z);
- } else {
- tile = new StaticTile(position.x, position.y, position.z);
- }
- g_game.map.setTile(position, tile);
- }
- pushUserdata(L, tile);
- setMetatable(L, -1, "Tile");
- return 1;
- }
- int LuaScriptInterface::luaGameStartRaid(lua_State* L)
- {
- // Game.startRaid(raidName)
- const std::string& raidName = getString(L, 1);
- Raid* raid = g_game.raids.getRaidByName(raidName);
- if (raid) {
- raid->startRaid();
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // Variant
- int LuaScriptInterface::luaVariantCreate(lua_State* L)
- {
- // Variant(number or string or position or thing)
- LuaVariant variant;
- if (isUserdata(L, 2)) {
- if (Thing* thing = getThing(L, 2)) {
- variant.type = VARIANT_TARGETPOSITION;
- variant.pos = thing->getPosition();
- }
- } else if (isTable(L, 2)) {
- variant.type = VARIANT_POSITION;
- variant.pos = getPosition(L, 2);
- } else if (isNumber(L, 2)) {
- variant.type = VARIANT_NUMBER;
- variant.number = getNumber<uint32_t>(L, 2);
- } else if (isString(L, 2)) {
- variant.type = VARIANT_STRING;
- variant.text = getString(L, 2);
- }
- pushVariant(L, variant);
- return 1;
- }
- int LuaScriptInterface::luaVariantGetNumber(lua_State* L)
- {
- // Variant:getNumber()
- const LuaVariant& variant = getVariant(L, 1);
- if (variant.type == VARIANT_NUMBER) {
- lua_pushnumber(L, variant.number);
- } else {
- lua_pushnumber(L, 0);
- }
- return 1;
- }
- int LuaScriptInterface::luaVariantGetString(lua_State* L)
- {
- // Variant:getString()
- const LuaVariant& variant = getVariant(L, 1);
- if (variant.type == VARIANT_STRING) {
- pushString(L, variant.text);
- } else {
- pushString(L, std::string());
- }
- return 1;
- }
- int LuaScriptInterface::luaVariantGetPosition(lua_State* L)
- {
- // Variant:getPosition()
- const LuaVariant& variant = getVariant(L, 1);
- if (variant.type == VARIANT_POSITION || variant.type == VARIANT_TARGETPOSITION) {
- pushPosition(L, variant.pos);
- } else {
- pushPosition(L, Position());
- }
- return 1;
- }
- // Position
- int LuaScriptInterface::luaPositionCreate(lua_State* L)
- {
- // Position([x = 0[, y = 0[, z = 0[, stackpos = 0]]]])
- // Position([position])
- if (lua_gettop(L) <= 1) {
- pushPosition(L, Position());
- return 1;
- }
- int32_t stackpos;
- if (isTable(L, 2)) {
- const Position& position = getPosition(L, 2, stackpos);
- pushPosition(L, position, stackpos);
- } else {
- uint16_t x = getNumber<uint16_t>(L, 2, 0);
- uint16_t y = getNumber<uint16_t>(L, 3, 0);
- uint8_t z = getNumber<uint8_t>(L, 4, 0);
- stackpos = getNumber<int32_t>(L, 5, 0);
- pushPosition(L, Position(x, y, z), stackpos);
- }
- return 1;
- }
- int LuaScriptInterface::luaPositionAdd(lua_State* L)
- {
- // positionValue = position + positionEx
- int32_t stackpos;
- const Position& position = getPosition(L, 1, stackpos);
- Position positionEx;
- if (stackpos == 0) {
- positionEx = getPosition(L, 2, stackpos);
- } else {
- positionEx = getPosition(L, 2);
- }
- pushPosition(L, position + positionEx, stackpos);
- return 1;
- }
- int LuaScriptInterface::luaPositionSub(lua_State* L)
- {
- // positionValue = position - positionEx
- int32_t stackpos;
- const Position& position = getPosition(L, 1, stackpos);
- Position positionEx;
- if (stackpos == 0) {
- positionEx = getPosition(L, 2, stackpos);
- } else {
- positionEx = getPosition(L, 2);
- }
- pushPosition(L, position - positionEx, stackpos);
- return 1;
- }
- int LuaScriptInterface::luaPositionCompare(lua_State* L)
- {
- // position == positionEx
- const Position& positionEx = getPosition(L, 2);
- const Position& position = getPosition(L, 1);
- pushBoolean(L, position == positionEx);
- return 1;
- }
- int LuaScriptInterface::luaPositionGetDistance(lua_State* L)
- {
- // position:getDistance(positionEx)
- const Position& positionEx = getPosition(L, 2);
- const Position& position = getPosition(L, 1);
- lua_pushnumber(L, std::max<int32_t>(
- std::max<int32_t>(
- std::abs(Position::getDistanceX(position, positionEx)),
- std::abs(Position::getDistanceY(position, positionEx))
- ),
- std::abs(Position::getDistanceZ(position, positionEx))
- ));
- return 1;
- }
- int LuaScriptInterface::luaPositionIsSightClear(lua_State* L)
- {
- // position:isSightClear(positionEx[, sameFloor = true])
- bool sameFloor = getBoolean(L, 3, true);
- const Position& positionEx = getPosition(L, 2);
- const Position& position = getPosition(L, 1);
- pushBoolean(L, g_game.isSightClear(position, positionEx, sameFloor));
- return 1;
- }
- int LuaScriptInterface::luaPositionSendMagicEffect(lua_State* L)
- {
- // position:sendMagicEffect(magicEffect[, player = nullptr])
- SpectatorVec list;
- if (lua_gettop(L) >= 3) {
- Player* player = getPlayer(L, 3);
- if (player) {
- list.insert(player);
- }
- }
- MagicEffectClasses magicEffect = getNumber<MagicEffectClasses>(L, 2);
- const Position& position = getPosition(L, 1);
- if (!list.empty()) {
- Game::addMagicEffect(list, position, magicEffect);
- } else {
- g_game.addMagicEffect(position, magicEffect);
- }
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaPositionSendDistanceEffect(lua_State* L)
- {
- // position:sendDistanceEffect(positionEx, distanceEffect[, player = nullptr])
- SpectatorVec list;
- if (lua_gettop(L) >= 4) {
- Player* player = getPlayer(L, 4);
- if (player) {
- list.insert(player);
- }
- }
- ShootType_t distanceEffect = getNumber<ShootType_t>(L, 3);
- const Position& positionEx = getPosition(L, 2);
- const Position& position = getPosition(L, 1);
- if (!list.empty()) {
- Game::addDistanceEffect(list, position, positionEx, distanceEffect);
- } else {
- g_game.addDistanceEffect(position, positionEx, distanceEffect);
- }
- pushBoolean(L, true);
- return 1;
- }
- // Tile
- int LuaScriptInterface::luaTileCreate(lua_State* L)
- {
- // Tile(x, y, z)
- // Tile(position)
- Tile* tile;
- if (isTable(L, 2)) {
- tile = g_game.map.getTile(getPosition(L, 2));
- } else {
- uint8_t z = getNumber<uint8_t>(L, 4);
- uint16_t y = getNumber<uint16_t>(L, 3);
- uint16_t x = getNumber<uint16_t>(L, 2);
- tile = g_game.map.getTile(x, y, z);
- }
- if (tile) {
- pushUserdata<Tile>(L, tile);
- setMetatable(L, -1, "Tile");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetPosition(lua_State* L)
- {
- // tile:getPosition()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (tile) {
- pushPosition(L, tile->getPosition());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetGround(lua_State* L)
- {
- // tile:getGround()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (tile && tile->getGround()) {
- pushUserdata<Item>(L, tile->getGround());
- setItemMetatable(L, -1, tile->getGround());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetThing(lua_State* L)
- {
- // tile:getThing(index)
- int32_t index = getNumber<int32_t>(L, 2);
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- Thing* thing = tile->getThing(index);
- if (!thing) {
- lua_pushnil(L);
- return 1;
- }
- if (Creature* creature = thing->getCreature()) {
- pushUserdata<Creature>(L, creature);
- setCreatureMetatable(L, -1, creature);
- } else if (Item* item = thing->getItem()) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetThingCount(lua_State* L)
- {
- // tile:getThingCount()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (tile) {
- lua_pushnumber(L, tile->getThingCount());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetTopVisibleThing(lua_State* L)
- {
- // tile:getTopVisibleThing(creature)
- Creature* creature = getCreature(L, 2);
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- Thing* thing = tile->getTopVisibleThing(creature);
- if (!thing) {
- lua_pushnil(L);
- return 1;
- }
- if (Creature* visibleCreature = thing->getCreature()) {
- pushUserdata<Creature>(L, visibleCreature);
- setCreatureMetatable(L, -1, visibleCreature);
- } else if (Item* visibleItem = thing->getItem()) {
- pushUserdata<Item>(L, visibleItem);
- setItemMetatable(L, -1, visibleItem);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetTopTopItem(lua_State* L)
- {
- // tile:getTopTopItem()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- Item* item = tile->getTopTopItem();
- if (item) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetTopDownItem(lua_State* L)
- {
- // tile:getTopDownItem()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- Item* item = tile->getTopDownItem();
- if (item) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetFieldItem(lua_State* L)
- {
- // tile:getFieldItem()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- Item* item = tile->getFieldItem();
- if (item) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetItemById(lua_State* L)
- {
- // tile:getItemById(itemId[, subType = -1])
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- uint16_t itemId;
- if (isNumber(L, 2)) {
- itemId = getNumber<uint16_t>(L, 2);
- } else {
- itemId = Item::items.getItemIdByName(getString(L, 2));
- if (itemId == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- int32_t subType = getNumber<int32_t>(L, 3, -1);
- Item* item = g_game.findItemOfType(tile, itemId, false, subType);
- if (item) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetItemByType(lua_State* L)
- {
- // tile:getItemByType(itemType)
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- bool found;
- ItemTypes_t itemType = getNumber<ItemTypes_t>(L, 2);
- switch (itemType) {
- case ITEM_TYPE_TELEPORT:
- found = tile->hasFlag(TILESTATE_TELEPORT);
- break;
- case ITEM_TYPE_MAGICFIELD:
- found = tile->hasFlag(TILESTATE_MAGICFIELD);
- break;
- case ITEM_TYPE_MAILBOX:
- found = tile->hasFlag(TILESTATE_MAILBOX);
- break;
- case ITEM_TYPE_TRASHHOLDER:
- found = tile->hasFlag(TILESTATE_TRASHHOLDER);
- break;
- case ITEM_TYPE_BED:
- found = tile->hasFlag(TILESTATE_BED);
- break;
- case ITEM_TYPE_DEPOT:
- found = tile->hasFlag(TILESTATE_DEPOT);
- break;
- default:
- found = true;
- break;
- }
- if (!found) {
- lua_pushnil(L);
- return 1;
- }
- if (Item* item = tile->getGround()) {
- const ItemType& it = Item::items[item->getID()];
- if (it.type == itemType) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- return 1;
- }
- }
- if (const TileItemVector* items = tile->getItemList()) {
- for (Item* item : *items) {
- const ItemType& it = Item::items[item->getID()];
- if (it.type == itemType) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- return 1;
- }
- }
- }
- lua_pushnil(L);
- return 1;
- }
- int LuaScriptInterface::luaTileGetItemByTopOrder(lua_State* L)
- {
- // tile:getItemByTopOrder(topOrder)
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- int32_t topOrder = getNumber<int32_t>(L, 2);
- Item* item = tile->getItemByTopOrder(topOrder);
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- return 1;
- }
- int LuaScriptInterface::luaTileGetItemCountById(lua_State* L)
- {
- // tile:getItemCountById(itemId[, subType = -1])
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- int32_t subType = getNumber<int32_t>(L, 3, -1);
- uint16_t itemId;
- if (isNumber(L, 2)) {
- itemId = getNumber<uint16_t>(L, 2);
- } else {
- itemId = Item::items.getItemIdByName(getString(L, 2));
- if (itemId == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- lua_pushnumber(L, tile->getItemTypeCount(itemId, subType));
- return 1;
- }
- int LuaScriptInterface::luaTileGetBottomCreature(lua_State* L)
- {
- // tile:getBottomCreature()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- const Creature* creature = tile->getBottomCreature();
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- pushUserdata<const Creature>(L, creature);
- setCreatureMetatable(L, -1, creature);
- return 1;
- }
- int LuaScriptInterface::luaTileGetTopCreature(lua_State* L)
- {
- // tile:getTopCreature()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- Creature* creature = tile->getTopCreature();
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- pushUserdata<Creature>(L, creature);
- setCreatureMetatable(L, -1, creature);
- return 1;
- }
- int LuaScriptInterface::luaTileGetBottomVisibleCreature(lua_State* L)
- {
- // tile:getBottomVisibleCreature(creature)
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- Creature* creature = getCreature(L, 2);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- const Creature* visibleCreature = tile->getBottomVisibleCreature(creature);
- if (visibleCreature) {
- pushUserdata<const Creature>(L, visibleCreature);
- setCreatureMetatable(L, -1, visibleCreature);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetTopVisibleCreature(lua_State* L)
- {
- // tile:getTopVisibleCreature(creature)
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- Creature* creature = getCreature(L, 2);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- Creature* visibleCreature = tile->getTopVisibleCreature(creature);
- if (visibleCreature) {
- pushUserdata<Creature>(L, visibleCreature);
- setCreatureMetatable(L, -1, visibleCreature);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetItems(lua_State* L)
- {
- // tile:getItems()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- TileItemVector* itemVector = tile->getItemList();
- if (!itemVector) {
- lua_pushnil(L);
- return 1;
- }
- lua_createtable(L, itemVector->size(), 0);
- int index = 0;
- for (Item* item : *itemVector) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetItemCount(lua_State* L)
- {
- // tile:getItemCount()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- lua_pushnumber(L, tile->getItemCount());
- return 1;
- }
- int LuaScriptInterface::luaTileGetDownItemCount(lua_State* L)
- {
- // tile:getDownItemCount()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (tile) {
- lua_pushnumber(L, tile->getDownItemCount());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetTopItemCount(lua_State* L)
- {
- // tile:getTopItemCount()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- lua_pushnumber(L, tile->getTopItemCount());
- return 1;
- }
- int LuaScriptInterface::luaTileGetCreatures(lua_State* L)
- {
- // tile:getCreatures()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- CreatureVector* creatureVector = tile->getCreatures();
- if (!creatureVector) {
- lua_pushnil(L);
- return 1;
- }
- lua_createtable(L, creatureVector->size(), 0);
- int index = 0;
- for (Creature* creature : *creatureVector) {
- pushUserdata<Creature>(L, creature);
- setCreatureMetatable(L, -1, creature);
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetCreatureCount(lua_State* L)
- {
- // tile:getCreatureCount()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- lua_pushnumber(L, tile->getCreatureCount());
- return 1;
- }
- int LuaScriptInterface::luaTileHasProperty(lua_State* L)
- {
- // tile:hasProperty(property[, item])
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- Item* item;
- if (lua_gettop(L) >= 3) {
- item = getUserdata<Item>(L, 3);
- } else {
- item = nullptr;
- }
- ITEMPROPERTY property = getNumber<ITEMPROPERTY>(L, 2);
- if (item) {
- pushBoolean(L, tile->hasProperty(item, property));
- } else {
- pushBoolean(L, tile->hasProperty(property));
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetThingIndex(lua_State* L)
- {
- // tile:getThingIndex(thing)
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- Thing* thing = getThing(L, 2);
- if (thing) {
- lua_pushnumber(L, tile->getThingIndex(thing));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileHasFlag(lua_State* L)
- {
- // tile:hasFlag(flag)
- Tile* tile = getUserdata<Tile>(L, 1);
- if (tile) {
- tileflags_t flag = getNumber<tileflags_t>(L, 2);
- pushBoolean(L, tile->hasFlag(flag));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileQueryAdd(lua_State* L)
- {
- // tile:queryAdd(thing[, flags])
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- Thing* thing = getThing(L, 2);
- if (thing) {
- uint32_t flags = getNumber<uint32_t>(L, 3, 0);
- lua_pushnumber(L, tile->queryAdd(0, *thing, 1, flags));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTileGetHouse(lua_State* L)
- {
- // tile:getHouse()
- Tile* tile = getUserdata<Tile>(L, 1);
- if (!tile) {
- lua_pushnil(L);
- return 1;
- }
- if (HouseTile* houseTile = dynamic_cast<HouseTile*>(tile)) {
- pushUserdata<House>(L, houseTile->getHouse());
- setMetatable(L, -1, "House");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // NetworkMessage
- int LuaScriptInterface::luaNetworkMessageCreate(lua_State* L)
- {
- // NetworkMessage()
- pushUserdata<NetworkMessage>(L, new NetworkMessage);
- setMetatable(L, -1, "NetworkMessage");
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageDelete(lua_State* L)
- {
- NetworkMessage** messagePtr = getRawUserdata<NetworkMessage>(L, 1);
- if (messagePtr && *messagePtr) {
- delete *messagePtr;
- *messagePtr = nullptr;
- }
- return 0;
- }
- int LuaScriptInterface::luaNetworkMessageGetByte(lua_State* L)
- {
- // networkMessage:getByte()
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- lua_pushnumber(L, message->getByte());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageGetU16(lua_State* L)
- {
- // networkMessage:getU16()
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- lua_pushnumber(L, message->get<uint16_t>());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageGetU32(lua_State* L)
- {
- // networkMessage:getU32()
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- lua_pushnumber(L, message->get<uint32_t>());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageGetU64(lua_State* L)
- {
- // networkMessage:getU64()
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- lua_pushnumber(L, message->get<uint64_t>());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageGetString(lua_State* L)
- {
- // networkMessage:getString()
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- pushString(L, message->getString());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageGetPosition(lua_State* L)
- {
- // networkMessage:getPosition()
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- pushPosition(L, message->getPosition());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageAddByte(lua_State* L)
- {
- // networkMessage:addByte(number)
- uint8_t number = getNumber<uint8_t>(L, 2);
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- message->addByte(number);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageAddU16(lua_State* L)
- {
- // networkMessage:addU16(number)
- uint16_t number = getNumber<uint16_t>(L, 2);
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- message->add<uint16_t>(number);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageAddU32(lua_State* L)
- {
- // networkMessage:addU32(number)
- uint32_t number = getNumber<uint32_t>(L, 2);
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- message->add<uint32_t>(number);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageAddU64(lua_State* L)
- {
- // networkMessage:addU64(number)
- uint64_t number = getNumber<uint64_t>(L, 2);
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- message->add<uint64_t>(number);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageAddString(lua_State* L)
- {
- // networkMessage:addString(string)
- const std::string& string = getString(L, 2);
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- message->addString(string);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageAddPosition(lua_State* L)
- {
- // networkMessage:addPosition(position)
- const Position& position = getPosition(L, 2);
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- message->addPosition(position);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageAddDouble(lua_State* L)
- {
- // networkMessage:addDouble(number)
- double number = getNumber<double>(L, 2);
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- message->addDouble(number);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageAddItem(lua_State* L)
- {
- // networkMessage:addItem(item)
- Item* item = getUserdata<Item>(L, 2);
- if (!item) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_ITEM_NOT_FOUND));
- lua_pushnil(L);
- return 1;
- }
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- message->addItem(item);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageAddItemId(lua_State* L)
- {
- // networkMessage:addItemId(itemId)
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (!message) {
- lua_pushnil(L);
- return 1;
- }
- uint16_t itemId;
- if (isNumber(L, 2)) {
- itemId = getNumber<uint16_t>(L, 2);
- } else {
- itemId = Item::items.getItemIdByName(getString(L, 2));
- if (itemId == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- message->addItemId(itemId);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageReset(lua_State* L)
- {
- // networkMessage:reset()
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- message->reset();
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageSkipBytes(lua_State* L)
- {
- // networkMessage:skipBytes(number)
- int16_t number = getNumber<int16_t>(L, 2);
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (message) {
- message->skipBytes(number);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNetworkMessageSendToPlayer(lua_State* L)
- {
- // networkMessage:sendToPlayer(player[, broadcast])
- NetworkMessage* message = getUserdata<NetworkMessage>(L, 1);
- if (!message) {
- lua_pushnil(L);
- return 1;
- }
- Player* player = getPlayer(L, 2);
- if (player) {
- bool broadcast = getBoolean(L, 3, true);
- player->sendNetworkMessage(*message, broadcast);
- pushBoolean(L, true);
- } else {
- reportErrorFunc(getErrorDesc(LUA_ERROR_PLAYER_NOT_FOUND));
- lua_pushnil(L);
- }
- return 1;
- }
- // ModalWindow
- int LuaScriptInterface::luaModalWindowCreate(lua_State* L)
- {
- // ModalWindow(id, title, message)
- const std::string& message = getString(L, 4);
- const std::string& title = getString(L, 3);
- uint32_t id = getNumber<uint32_t>(L, 2);
- pushUserdata<ModalWindow>(L, new ModalWindow(id, title, message));
- setMetatable(L, -1, "ModalWindow");
- return 1;
- }
- int LuaScriptInterface::luaModalWindowDelete(lua_State* L)
- {
- ModalWindow** windowPtr = getRawUserdata<ModalWindow>(L, 1);
- if (windowPtr && *windowPtr) {
- delete *windowPtr;
- *windowPtr = nullptr;
- }
- return 0;
- }
- int LuaScriptInterface::luaModalWindowGetId(lua_State* L)
- {
- // modalWindow:getId()
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- lua_pushnumber(L, window->id);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowGetTitle(lua_State* L)
- {
- // modalWindow:getTitle()
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- pushString(L, window->title);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowGetMessage(lua_State* L)
- {
- // modalWindow:getMessage()
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- pushString(L, window->message);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowSetTitle(lua_State* L)
- {
- // modalWindow:setTitle(text)
- const std::string& text = getString(L, 2);
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- window->title = text;
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowSetMessage(lua_State* L)
- {
- // modalWindow:setMessage(text)
- const std::string& text = getString(L, 2);
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- window->message = text;
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowGetButtonCount(lua_State* L)
- {
- // modalWindow:getButtonCount()
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- lua_pushnumber(L, window->buttons.size());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowGetChoiceCount(lua_State* L)
- {
- // modalWindow:getChoiceCount()
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- lua_pushnumber(L, window->choices.size());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowAddButton(lua_State* L)
- {
- // modalWindow:addButton(id, text)
- const std::string& text = getString(L, 3);
- uint8_t id = getNumber<uint8_t>(L, 2);
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- window->buttons.emplace_back(text, id);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowAddChoice(lua_State* L)
- {
- // modalWindow:addChoice(id, text)
- const std::string& text = getString(L, 3);
- uint8_t id = getNumber<uint8_t>(L, 2);
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- window->choices.emplace_back(text, id);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowGetDefaultEnterButton(lua_State* L)
- {
- // modalWindow:getDefaultEnterButton()
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- lua_pushnumber(L, window->defaultEnterButton);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowSetDefaultEnterButton(lua_State* L)
- {
- // modalWindow:setDefaultEnterButton(buttonId)
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- window->defaultEnterButton = getNumber<uint8_t>(L, 2);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowGetDefaultEscapeButton(lua_State* L)
- {
- // modalWindow:getDefaultEscapeButton()
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- lua_pushnumber(L, window->defaultEscapeButton);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowSetDefaultEscapeButton(lua_State* L)
- {
- // modalWindow:setDefaultEscapeButton(buttonId)
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- window->defaultEscapeButton = getNumber<uint8_t>(L, 2);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowHasPriority(lua_State* L)
- {
- // modalWindow:hasPriority()
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- pushBoolean(L, window->priority);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowSetPriority(lua_State* L)
- {
- // modalWindow:setPriority(priority)
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- window->priority = getBoolean(L, 2);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaModalWindowSendToPlayer(lua_State* L)
- {
- // modalWindow:sendToPlayer(player)
- Player* player = getPlayer(L, 2);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- ModalWindow* window = getUserdata<ModalWindow>(L, 1);
- if (window) {
- if (!player->hasModalWindowOpen(window->id)) {
- player->sendModalWindow(*window);
- }
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // Item
- int LuaScriptInterface::luaItemCreate(lua_State* L)
- {
- // Item(uid)
- uint32_t id = getNumber<uint32_t>(L, 2);
- Item* item = getScriptEnv()->getItemByUID(id);
- if (item) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemIsItem(lua_State* L)
- {
- // item:isItem()
- pushBoolean(L, getUserdata<const Item>(L, 1) != nullptr);
- return 1;
- }
- int LuaScriptInterface::luaItemGetParent(lua_State* L)
- {
- // item:getParent()
- Item* item = getUserdata<Item>(L, 1);
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- Cylinder* parent = item->getParent();
- if (!parent) {
- lua_pushnil(L);
- return 1;
- }
- pushCylinder(L, parent);
- return 1;
- }
- int LuaScriptInterface::luaItemGetTopParent(lua_State* L)
- {
- // item:getTopParent()
- Item* item = getUserdata<Item>(L, 1);
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- Cylinder* topParent = item->getTopParent();
- if (!topParent) {
- lua_pushnil(L);
- return 1;
- }
- pushCylinder(L, topParent);
- return 1;
- }
- int LuaScriptInterface::luaItemGetId(lua_State* L)
- {
- // item:getId()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- lua_pushnumber(L, item->getID());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemClone(lua_State* L)
- {
- // item:clone()
- Item* item = getUserdata<Item>(L, 1);
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- Item* clone = item->clone();
- if (!clone) {
- lua_pushnil(L);
- return 1;
- }
- getScriptEnv()->addTempItem(clone);
- clone->setParent(VirtualCylinder::virtualCylinder);
- pushUserdata<Item>(L, clone);
- setItemMetatable(L, -1, clone);
- return 1;
- }
- int LuaScriptInterface::luaItemSplit(lua_State* L)
- {
- // item:split([count = 1])
- Item** itemPtr = getRawUserdata<Item>(L, 1);
- if (!itemPtr) {
- lua_pushnil(L);
- return 1;
- }
- Item* item = *itemPtr;
- if (!item || !item->isStackable()) {
- lua_pushnil(L);
- return 1;
- }
- uint16_t count = std::min<uint16_t>(getNumber<uint16_t>(L, 2, 1), item->getItemCount());
- uint16_t diff = item->getItemCount() - count;
- Item* splitItem = item->clone();
- if (!splitItem) {
- lua_pushnil(L);
- return 1;
- }
- ScriptEnvironment* env = getScriptEnv();
- uint32_t uid = env->addThing(item);
- Item* newItem = g_game.transformItem(item, item->getID(), diff);
- if (item->isRemoved()) {
- env->removeItemByUID(uid);
- }
- if (newItem && newItem != item) {
- env->insertItem(uid, newItem);
- }
- *itemPtr = newItem;
- splitItem->setParent(VirtualCylinder::virtualCylinder);
- env->addTempItem(splitItem);
- pushUserdata<Item>(L, splitItem);
- setItemMetatable(L, -1, splitItem);
- return 1;
- }
- int LuaScriptInterface::luaItemRemove(lua_State* L)
- {
- // item:remove([count = -1])
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- int32_t count = getNumber<int32_t>(L, 2, -1);
- pushBoolean(L, g_game.internalRemoveItem(item, count) == RETURNVALUE_NOERROR);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetUniqueId(lua_State* L)
- {
- // item:getUniqueId()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- uint32_t uniqueId = item->getUniqueId();
- if (uniqueId == 0) {
- uniqueId = getScriptEnv()->addThing(item);
- }
- lua_pushnumber(L, uniqueId);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetActionId(lua_State* L)
- {
- // item:getActionId()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- lua_pushnumber(L, item->getActionId());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemSetActionId(lua_State* L)
- {
- // item:setActionId(actionId)
- uint16_t actionId = getNumber<uint16_t>(L, 2);
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- item->setActionId(actionId);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetCount(lua_State* L)
- {
- // item:getCount()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- lua_pushnumber(L, item->getItemCount());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetCharges(lua_State* L)
- {
- // item:getCharges()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- lua_pushnumber(L, item->getCharges());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetFluidType(lua_State* L)
- {
- // item:getFluidType()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- lua_pushnumber(L, item->getFluidType());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetWeight(lua_State* L)
- {
- // item:getWeight()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- lua_pushnumber(L, item->getWeight());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetSubType(lua_State* L)
- {
- // item:getSubType()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- lua_pushnumber(L, item->getSubType());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetName(lua_State* L)
- {
- // item:getName()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- pushString(L, item->getName());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetPluralName(lua_State* L)
- {
- // item:getPluralName()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- pushString(L, item->getPluralName());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetArticle(lua_State* L)
- {
- // item:getArticle()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- pushString(L, item->getArticle());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetPosition(lua_State* L)
- {
- // item:getPosition()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- pushPosition(L, item->getPosition());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetTile(lua_State* L)
- {
- // item:getTile()
- Item* item = getUserdata<Item>(L, 1);
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- Tile* tile = item->getTile();
- if (tile) {
- pushUserdata<Tile>(L, tile);
- setMetatable(L, -1, "Tile");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemHasAttribute(lua_State* L)
- {
- // item:hasAttribute(key)
- Item* item = getUserdata<Item>(L, 1);
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- itemAttrTypes attribute;
- if (isNumber(L, 2)) {
- attribute = getNumber<itemAttrTypes>(L, 2);
- } else if (isString(L, 2)) {
- attribute = stringToItemAttribute(getString(L, 2));
- } else {
- attribute = ITEM_ATTRIBUTE_NONE;
- }
- pushBoolean(L, item->hasAttribute(attribute));
- return 1;
- }
- int LuaScriptInterface::luaItemGetAttribute(lua_State* L)
- {
- // item:getAttribute(key)
- Item* item = getUserdata<Item>(L, 1);
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- itemAttrTypes attribute;
- if (isNumber(L, 2)) {
- attribute = getNumber<itemAttrTypes>(L, 2);
- } else if (isString(L, 2)) {
- attribute = stringToItemAttribute(getString(L, 2));
- } else {
- attribute = ITEM_ATTRIBUTE_NONE;
- }
- if (ItemAttributes::isIntAttrType(attribute)) {
- lua_pushnumber(L, item->getIntAttr(attribute));
- } else if (ItemAttributes::isStrAttrType(attribute)) {
- pushString(L, item->getStrAttr(attribute));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemSetAttribute(lua_State* L)
- {
- // item:setAttribute(key, value)
- Item* item = getUserdata<Item>(L, 1);
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- itemAttrTypes attribute;
- if (isNumber(L, 2)) {
- attribute = getNumber<itemAttrTypes>(L, 2);
- } else if (isString(L, 2)) {
- attribute = stringToItemAttribute(getString(L, 2));
- } else {
- attribute = ITEM_ATTRIBUTE_NONE;
- }
- if (ItemAttributes::isIntAttrType(attribute)) {
- if (attribute == ITEM_ATTRIBUTE_UNIQUEID) {
- reportErrorFunc("Attempt to set protected key \"uid\"");
- pushBoolean(L, false);
- return 1;
- }
- item->setIntAttr(attribute, getNumber<int32_t>(L, 3));
- pushBoolean(L, true);
- } else if (ItemAttributes::isStrAttrType(attribute)) {
- item->setStrAttr(attribute, getString(L, 3));
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemRemoveAttribute(lua_State* L)
- {
- // item:removeAttribute(key)
- Item* item = getUserdata<Item>(L, 1);
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- itemAttrTypes attribute;
- if (isNumber(L, 2)) {
- attribute = getNumber<itemAttrTypes>(L, 2);
- } else if (isString(L, 2)) {
- attribute = stringToItemAttribute(getString(L, 2));
- } else {
- attribute = ITEM_ATTRIBUTE_NONE;
- }
- bool ret = attribute != ITEM_ATTRIBUTE_UNIQUEID;
- if (ret) {
- item->removeAttribute(attribute);
- } else {
- reportErrorFunc("Attempt to erase protected key \"uid\"");
- }
- pushBoolean(L, ret);
- return 1;
- }
- int LuaScriptInterface::luaItemSerializeAttributes(lua_State* L)
- {
- // item:serializeAttributes()
- Item* item = getUserdata<Item>(L, 1);
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- PropWriteStream propWriteStream;
- item->serializeAttr(propWriteStream);
- size_t attributesSize;
- const char* attributes = propWriteStream.getStream(attributesSize);
- lua_pushlstring(L, attributes, attributesSize);
- return 1;
- }
- int LuaScriptInterface::luaItemMoveTo(lua_State* L)
- {
- // item:moveTo(position or cylinder)
- Item** itemPtr = getRawUserdata<Item>(L, 1);
- if (!itemPtr) {
- lua_pushnil(L);
- return 1;
- }
- Item* item = *itemPtr;
- if (!item || item->isRemoved()) {
- lua_pushnil(L);
- return 1;
- }
- Cylinder* toCylinder;
- if (isUserdata(L, 2)) {
- const LuaDataType type = getUserdataType(L, 2);
- switch (type) {
- case LuaData_Container:
- toCylinder = getUserdata<Container>(L, 2);
- break;
- case LuaData_Player:
- toCylinder = getUserdata<Player>(L, 2);
- break;
- case LuaData_Tile:
- toCylinder = getUserdata<Tile>(L, 2);
- break;
- default:
- toCylinder = nullptr;
- break;
- }
- } else {
- toCylinder = g_game.map.getTile(getPosition(L, 2));
- }
- if (!toCylinder) {
- lua_pushnil(L);
- return 1;
- }
- if (item->getParent() == toCylinder) {
- pushBoolean(L, true);
- return 1;
- }
- if (item->getParent() == VirtualCylinder::virtualCylinder) {
- pushBoolean(L, g_game.internalAddItem(toCylinder, item) == RETURNVALUE_NOERROR);
- } else {
- Item* moveItem = nullptr;
- ReturnValue ret = g_game.internalMoveItem(item->getParent(), toCylinder, INDEX_WHEREEVER, item, item->getItemCount(), &moveItem, FLAG_NOLIMIT | FLAG_IGNOREBLOCKITEM | FLAG_IGNOREBLOCKCREATURE | FLAG_IGNORENOTMOVEABLE);
- if (moveItem) {
- *itemPtr = moveItem;
- }
- pushBoolean(L, ret == RETURNVALUE_NOERROR);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTransform(lua_State* L)
- {
- // item:transform(itemId[, count/subType = -1])
- Item** itemPtr = getRawUserdata<Item>(L, 1);
- if (!itemPtr) {
- lua_pushnil(L);
- return 1;
- }
- Item*& item = *itemPtr;
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- uint16_t itemId;
- if (isNumber(L, 2)) {
- itemId = getNumber<uint16_t>(L, 2);
- } else {
- itemId = Item::items.getItemIdByName(getString(L, 2));
- if (itemId == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- int32_t subType = getNumber<int32_t>(L, 3, -1);
- if (item->getID() == itemId && (subType == -1 || subType == item->getSubType())) {
- pushBoolean(L, true);
- return 1;
- }
- const ItemType& it = Item::items[itemId];
- if (it.stackable) {
- subType = std::min<int32_t>(subType, 100);
- }
- ScriptEnvironment* env = getScriptEnv();
- uint32_t uid = env->addThing(item);
- Item* newItem = g_game.transformItem(item, itemId, subType);
- if (item->isRemoved()) {
- env->removeItemByUID(uid);
- }
- if (newItem && newItem != item) {
- env->insertItem(uid, newItem);
- }
- item = newItem;
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaItemDecay(lua_State* L)
- {
- // item:decay()
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- g_game.startDecay(item);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemGetDescription(lua_State* L)
- {
- // item:getDescription(distance)
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- int32_t distance = getNumber<int32_t>(L, 2);
- pushString(L, item->getDescription(distance));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemHasProperty(lua_State* L)
- {
- // item:hasProperty(property)
- Item* item = getUserdata<Item>(L, 1);
- if (item) {
- ITEMPROPERTY property = getNumber<ITEMPROPERTY>(L, 2);
- pushBoolean(L, item->hasProperty(property));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // Container
- int LuaScriptInterface::luaContainerCreate(lua_State* L)
- {
- // Container(uid)
- uint32_t id = getNumber<uint32_t>(L, 2);
- Container* container = getScriptEnv()->getContainerByUID(id);
- if (container) {
- pushUserdata(L, container);
- setMetatable(L, -1, "Container");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaContainerGetSize(lua_State* L)
- {
- // container:getSize()
- Container* container = getUserdata<Container>(L, 1);
- if (container) {
- lua_pushnumber(L, container->size());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaContainerGetCapacity(lua_State* L)
- {
- // container:getCapacity()
- Container* container = getUserdata<Container>(L, 1);
- if (container) {
- lua_pushnumber(L, container->capacity());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaContainerGetEmptySlots(lua_State* L)
- {
- // container:getEmptySlots([recursive = false])
- Container* container = getUserdata<Container>(L, 1);
- if (!container) {
- lua_pushnil(L);
- return 1;
- }
- uint32_t slots = container->capacity() - container->size();
- bool recursive = getBoolean(L, 2, false);
- if (recursive) {
- for (ContainerIterator it = container->iterator(); it.hasNext(); it.advance()) {
- if (Container* tmpContainer = (*it)->getContainer()) {
- slots += tmpContainer->capacity() - tmpContainer->size();
- }
- }
- }
- lua_pushnumber(L, slots);
- return 1;
- }
- int LuaScriptInterface::luaContainerGetItemHoldingCount(lua_State* L)
- {
- // container:getItemHoldingCount()
- Container* container = getUserdata<Container>(L, 1);
- if (container) {
- lua_pushnumber(L, container->getItemHoldingCount());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaContainerGetItem(lua_State* L)
- {
- // container:getItem(index)
- Container* container = getUserdata<Container>(L, 1);
- if (!container) {
- lua_pushnil(L);
- return 1;
- }
- uint32_t index = getNumber<uint32_t>(L, 2);
- Item* item = container->getItemByIndex(index);
- if (item) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaContainerHasItem(lua_State* L)
- {
- // container:hasItem(item)
- Item* item = getUserdata<Item>(L, 2);
- Container* container = getUserdata<Container>(L, 1);
- if (container) {
- pushBoolean(L, container->isHoldingItem(item));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaContainerAddItem(lua_State* L)
- {
- // container:addItem(itemId[, count/subType = 1[, index = INDEX_WHEREEVER[, flags = 0]]])
- Container* container = getUserdata<Container>(L, 1);
- if (!container) {
- lua_pushnil(L);
- return 1;
- }
- uint16_t itemId;
- if (isNumber(L, 2)) {
- itemId = getNumber<uint16_t>(L, 2);
- } else {
- itemId = Item::items.getItemIdByName(getString(L, 2));
- if (itemId == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- uint32_t subType = getNumber<uint32_t>(L, 3, 1);
- Item* item = Item::CreateItem(itemId, std::min<uint32_t>(subType, 100));
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- int32_t index = getNumber<int32_t>(L, 4, INDEX_WHEREEVER);
- uint32_t flags = getNumber<uint32_t>(L, 5, 0);
- ReturnValue ret = g_game.internalAddItem(container, item, index, flags);
- if (ret == RETURNVALUE_NOERROR) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- } else {
- delete item;
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaContainerAddItemEx(lua_State* L)
- {
- // container:addItemEx(item[, index = INDEX_WHEREEVER[, flags = 0]])
- Item* item = getUserdata<Item>(L, 2);
- if (!item) {
- lua_pushnil(L);
- return 1;
- }
- Container* container = getUserdata<Container>(L, 1);
- if (!container) {
- lua_pushnil(L);
- return 1;
- }
- if (item->getParent() != VirtualCylinder::virtualCylinder) {
- reportErrorFunc("Item already has a parent");
- lua_pushnil(L);
- return 1;
- }
- int32_t index = getNumber<int32_t>(L, 3, INDEX_WHEREEVER);
- uint32_t flags = getNumber<uint32_t>(L, 4, 0);
- ReturnValue ret = g_game.internalAddItem(container, item, index, flags);
- if (ret == RETURNVALUE_NOERROR) {
- ScriptEnvironment::removeTempItem(item);
- }
- lua_pushnumber(L, ret);
- return 1;
- }
- int LuaScriptInterface::luaContainerGetItemCountById(lua_State* L)
- {
- // container:getItemCountById(itemId[, subType = -1])
- Container* container = getUserdata<Container>(L, 1);
- if (!container) {
- lua_pushnil(L);
- return 1;
- }
- uint16_t itemId;
- if (isNumber(L, 2)) {
- itemId = getNumber<uint16_t>(L, 2);
- } else {
- itemId = Item::items.getItemIdByName(getString(L, 2));
- if (itemId == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- int32_t subType = getNumber<int32_t>(L, 3, -1);
- lua_pushnumber(L, container->getItemTypeCount(itemId, subType));
- return 1;
- }
- // Teleport
- int LuaScriptInterface::luaTeleportCreate(lua_State* L)
- {
- // Teleport(uid)
- uint32_t id = getNumber<uint32_t>(L, 2);
- Item* item = getScriptEnv()->getItemByUID(id);
- if (item && item->getTeleport()) {
- pushUserdata(L, item);
- setMetatable(L, -1, "Teleport");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTeleportGetDestination(lua_State* L)
- {
- // teleport:getDestination()
- Teleport* teleport = getUserdata<Teleport>(L, 1);
- if (teleport) {
- pushPosition(L, teleport->getDestPos());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTeleportSetDestination(lua_State* L)
- {
- // teleport:setDestination(position)
- Teleport* teleport = getUserdata<Teleport>(L, 1);
- if (teleport) {
- teleport->setDestPos(getPosition(L, 2));
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // Creature
- int LuaScriptInterface::luaCreatureCreate(lua_State* L)
- {
- // Creature(id or name or userdata)
- Creature* creature;
- if (isNumber(L, 2)) {
- creature = g_game.getCreatureByID(getNumber<uint32_t>(L, 2));
- } else if (isString(L, 2)) {
- creature = g_game.getCreatureByName(getString(L, 2));
- } else if (isUserdata(L, 2)) {
- LuaDataType type = getUserdataType(L, 2);
- if (type != LuaData_Player && type != LuaData_Monster && type != LuaData_Npc) {
- lua_pushnil(L);
- return 1;
- }
- creature = getUserdata<Creature>(L, 2);
- } else {
- creature = nullptr;
- }
- if (creature) {
- pushUserdata<Creature>(L, creature);
- setCreatureMetatable(L, -1, creature);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureRegisterEvent(lua_State* L)
- {
- // creature:registerEvent(name)
- Creature* creature = getUserdata<Creature>(L, 1);
- if (creature) {
- const std::string& name = getString(L, 2);
- pushBoolean(L, creature->registerCreatureEvent(name));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureUnregisterEvent(lua_State* L)
- {
- // creature:unregisterEvent(name)
- const std::string& name = getString(L, 2);
- Creature* creature = getUserdata<Creature>(L, 1);
- if (creature) {
- pushBoolean(L, creature->unregisterCreatureEvent(name));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureIsRemoved(lua_State* L)
- {
- // creature:isRemoved()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- pushBoolean(L, creature->isRemoved());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureIsCreature(lua_State* L)
- {
- // creature:isCreature()
- pushBoolean(L, getUserdata<const Creature>(L, 1) != nullptr);
- return 1;
- }
- int LuaScriptInterface::luaCreatureIsInGhostMode(lua_State* L)
- {
- // creature:isInGhostMode()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- pushBoolean(L, creature->isInGhostMode());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureIsHealthHidden(lua_State* L)
- {
- // creature:isHealthHidden()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- pushBoolean(L, creature->isHealthHidden());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureCanSee(lua_State* L)
- {
- // creature:canSee(position)
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- const Position& position = getPosition(L, 2);
- pushBoolean(L, creature->canSee(position));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureCanSeeCreature(lua_State* L)
- {
- // creature:canSeeCreature(creature)
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- const Creature* otherCreature = getCreature(L, 2);
- pushBoolean(L, creature->canSeeCreature(otherCreature));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetParent(lua_State* L)
- {
- // creature:getParent()
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- Cylinder* parent = creature->getParent();
- if (!parent) {
- lua_pushnil(L);
- return 1;
- }
- pushCylinder(L, parent);
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetId(lua_State* L)
- {
- // creature:getId()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- lua_pushnumber(L, creature->getID());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetName(lua_State* L)
- {
- // creature:getName()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- pushString(L, creature->getName());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetTarget(lua_State* L)
- {
- // creature:getTarget()
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- Creature* target = creature->getAttackedCreature();
- if (target) {
- pushUserdata<Creature>(L, target);
- setCreatureMetatable(L, -1, target);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureSetTarget(lua_State* L)
- {
- // creature:setTarget(target)
- Creature* creature = getUserdata<Creature>(L, 1);
- if (creature) {
- Creature* target = getCreature(L, 2);
- pushBoolean(L, creature->setAttackedCreature(target));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetFollowCreature(lua_State* L)
- {
- // creature:getFollowCreature()
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- Creature* followCreature = creature->getFollowCreature();
- if (followCreature) {
- pushUserdata<Creature>(L, followCreature);
- setCreatureMetatable(L, -1, followCreature);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureSetFollowCreature(lua_State* L)
- {
- // creature:setFollowCreature(followedCreature)
- Creature* creature = getUserdata<Creature>(L, 1);
- if (creature) {
- Creature* followCreature = getCreature(L, 2);
- pushBoolean(L, creature->setFollowCreature(followCreature));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetMaster(lua_State* L)
- {
- // creature:getMaster()
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- Creature* master = creature->getMaster();
- if (!master) {
- lua_pushnil(L);
- return 1;
- }
- pushUserdata<Creature>(L, master);
- setCreatureMetatable(L, -1, master);
- return 1;
- }
- int LuaScriptInterface::luaCreatureSetMaster(lua_State* L)
- {
- // creature:setMaster(master)
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- Creature* master = getCreature(L, 2);
- if (master) {
- pushBoolean(L, creature->convinceCreature(master));
- } else {
- master = creature->getMaster();
- if (master) {
- master->removeSummon(creature);
- creature->incrementReferenceCounter();
- creature->setDropLoot(true);
- }
- pushBoolean(L, true);
- }
- g_game.updateCreatureType(creature);
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetLight(lua_State* L)
- {
- // creature:getLight()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- LightInfo light;
- creature->getCreatureLight(light);
- lua_pushnumber(L, light.level);
- lua_pushnumber(L, light.color);
- return 2;
- }
- int LuaScriptInterface::luaCreatureSetLight(lua_State* L)
- {
- // creature:setLight(color, level)
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- LightInfo light;
- light.color = getNumber<uint8_t>(L, 2);
- light.level = getNumber<uint8_t>(L, 3);
- creature->setCreatureLight(light);
- g_game.changeLight(creature);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetSpeed(lua_State* L)
- {
- // creature:getSpeed()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- lua_pushnumber(L, creature->getSpeed());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetBaseSpeed(lua_State* L)
- {
- // creature:getBaseSpeed()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- lua_pushnumber(L, creature->getBaseSpeed());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureChangeSpeed(lua_State* L)
- {
- // creature:changeSpeed(delta)
- Creature* creature = getCreature(L, 1);
- if (!creature) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_CREATURE_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- int32_t delta = getNumber<int32_t>(L, 2);
- g_game.changeSpeed(creature, delta);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaCreatureSetDropLoot(lua_State* L)
- {
- // creature:setDropLoot(doDrop)
- Creature* creature = getUserdata<Creature>(L, 1);
- if (creature) {
- creature->setDropLoot(getBoolean(L, 2));
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetPosition(lua_State* L)
- {
- // creature:getPosition()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- pushPosition(L, creature->getPosition());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetTile(lua_State* L)
- {
- // creature:getTile()
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- Tile* tile = creature->getTile();
- if (tile) {
- pushUserdata<Tile>(L, tile);
- setMetatable(L, -1, "Tile");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetDirection(lua_State* L)
- {
- // creature:getDirection()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- lua_pushnumber(L, creature->getDirection());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureSetDirection(lua_State* L)
- {
- // creature:setDirection(direction)
- Creature* creature = getUserdata<Creature>(L, 1);
- if (creature) {
- pushBoolean(L, g_game.internalCreatureTurn(creature, getNumber<Direction>(L, 2)));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetHealth(lua_State* L)
- {
- // creature:getHealth()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- lua_pushnumber(L, creature->getHealth());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureAddHealth(lua_State* L)
- {
- // creature:addHealth(healthChange)
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- CombatDamage damage;
- damage.primary.value = getNumber<int32_t>(L, 2);
- if (damage.primary.value >= 0) {
- damage.primary.type = COMBAT_HEALING;
- } else {
- damage.primary.type = COMBAT_UNDEFINEDDAMAGE;
- }
- pushBoolean(L, g_game.combatChangeHealth(nullptr, creature, damage));
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetMaxHealth(lua_State* L)
- {
- // creature:getMaxHealth()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- lua_pushnumber(L, creature->getMaxHealth());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureSetMaxHealth(lua_State* L)
- {
- // creature:setMaxHealth(maxHealth)
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- creature->healthMax = getNumber<uint32_t>(L, 2);
- creature->health = std::min<int32_t>(creature->health, creature->healthMax);
- g_game.addCreatureHealth(creature);
- Player* player = creature->getPlayer();
- if (player) {
- player->sendStats();
- }
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaCreatureSetHiddenHealth(lua_State* L)
- {
- // creature:setHiddenHealth(hide)
- Creature* creature = getUserdata<Creature>(L, 1);
- if (creature) {
- creature->setHiddenHealth(getBoolean(L, 2));
- g_game.addCreatureHealth(creature);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetMana(lua_State* L)
- {
- // creature:getMana()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- lua_pushnumber(L, creature->getMana());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureAddMana(lua_State* L)
- {
- // creature:addMana(manaChange[, animationOnLoss = false])
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- int32_t manaChange = getNumber<int32_t>(L, 2);
- bool animationOnLoss = getBoolean(L, 3, false);
- if (!animationOnLoss && manaChange < 0) {
- creature->changeMana(manaChange);
- } else {
- g_game.combatChangeMana(nullptr, creature, manaChange, ORIGIN_NONE);
- }
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetMaxMana(lua_State* L)
- {
- // creature:getMaxMana()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- lua_pushnumber(L, creature->getMaxMana());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetSkull(lua_State* L)
- {
- // creature:getSkull()
- Creature* creature = getUserdata<Creature>(L, 1);
- if (creature) {
- lua_pushnumber(L, creature->getSkull());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureSetSkull(lua_State* L)
- {
- // creature:setSkull(skull)
- Creature* creature = getUserdata<Creature>(L, 1);
- if (creature) {
- creature->setSkull(getNumber<Skulls_t>(L, 2));
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetOutfit(lua_State* L)
- {
- // creature:getOutfit()
- const Creature* creature = getUserdata<const Creature>(L, 1);
- if (creature) {
- pushOutfit(L, creature->getCurrentOutfit());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureSetOutfit(lua_State* L)
- {
- // creature:setOutfit(outfit)
- Creature* creature = getUserdata<Creature>(L, 1);
- if (creature) {
- creature->defaultOutfit = getOutfit(L, 2);
- g_game.internalCreatureChangeOutfit(creature, creature->defaultOutfit);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetCondition(lua_State* L)
- {
- // creature:getCondition(conditionType[, conditionId = CONDITIONID_COMBAT[, subId = 0]])
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- ConditionType_t conditionType = getNumber<ConditionType_t>(L, 2);
- ConditionId_t conditionId = getNumber<ConditionId_t>(L, 3, CONDITIONID_COMBAT);
- uint32_t subId = getNumber<uint32_t>(L, 4, 0);
- Condition* condition = creature->getCondition(conditionType, conditionId, subId);
- if (condition) {
- pushUserdata<Condition>(L, condition);
- setWeakMetatable(L, -1, "Condition");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureAddCondition(lua_State* L)
- {
- // creature:addCondition(condition[, force = false])
- Creature* creature = getUserdata<Creature>(L, 1);
- Condition* condition = getUserdata<Condition>(L, 2);
- if (creature && condition) {
- bool force = getBoolean(L, 3, false);
- pushBoolean(L, creature->addCondition(condition->clone(), force));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureRemoveCondition(lua_State* L)
- {
- // creature:removeCondition(conditionType[, conditionId = CONDITIONID_COMBAT[, subId = 0[, force = false]]])
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- ConditionType_t conditionType = getNumber<ConditionType_t>(L, 2);
- ConditionId_t conditionId = getNumber<ConditionId_t>(L, 3, CONDITIONID_COMBAT);
- uint32_t subId = getNumber<uint32_t>(L, 4, 0);
- Condition* condition = creature->getCondition(conditionType, conditionId, subId);
- if (condition) {
- bool force = getBoolean(L, 5, false);
- creature->removeCondition(condition, force);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureRemove(lua_State* L)
- {
- // creature:remove()
- Creature** creaturePtr = getRawUserdata<Creature>(L, 1);
- if (!creaturePtr) {
- lua_pushnil(L);
- return 1;
- }
- Creature* creature = *creaturePtr;
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- Player* player = creature->getPlayer();
- if (player) {
- player->kickPlayer(true);
- } else {
- g_game.removeCreature(creature);
- }
- *creaturePtr = nullptr;
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaCreatureTeleportTo(lua_State* L)
- {
- // creature:teleportTo(position[, pushMovement = false])
- bool pushMovement = getBoolean(L, 3, false);
- const Position& position = getPosition(L, 2);
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- const Position oldPosition = creature->getPosition();
- if (g_game.internalTeleport(creature, position, pushMovement) != RETURNVALUE_NOERROR) {
- pushBoolean(L, false);
- return 1;
- }
- if (!pushMovement) {
- if (oldPosition.x == position.x) {
- if (oldPosition.y < position.y) {
- g_game.internalCreatureTurn(creature, DIRECTION_SOUTH);
- } else {
- g_game.internalCreatureTurn(creature, DIRECTION_NORTH);
- }
- } else if (oldPosition.x > position.x) {
- g_game.internalCreatureTurn(creature, DIRECTION_WEST);
- } else if (oldPosition.x < position.x) {
- g_game.internalCreatureTurn(creature, DIRECTION_EAST);
- }
- }
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaCreatureSay(lua_State* L)
- {
- // creature:say(text, type[, ghost = false[, target = nullptr[, position]]])
- int parameters = lua_gettop(L);
- Position position;
- if (parameters >= 6) {
- position = getPosition(L, 6);
- if (!position.x || !position.y) {
- reportErrorFunc("Invalid position specified.");
- pushBoolean(L, false);
- return 1;
- }
- }
- Creature* target = nullptr;
- if (parameters >= 5) {
- target = getCreature(L, 5);
- }
- bool ghost = getBoolean(L, 4, false);
- SpeakClasses type = getNumber<SpeakClasses>(L, 3);
- const std::string& text = getString(L, 2);
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- SpectatorVec list;
- if (target) {
- list.insert(target);
- }
- if (position.x != 0) {
- pushBoolean(L, g_game.internalCreatureSay(creature, type, text, ghost, &list, &position));
- } else {
- pushBoolean(L, g_game.internalCreatureSay(creature, type, text, ghost, &list));
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetDamageMap(lua_State* L)
- {
- // creature:getDamageMap()
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- lua_createtable(L, creature->damageMap.size(), 0);
- for (auto damageEntry : creature->damageMap) {
- lua_createtable(L, 0, 2);
- setField(L, "total", damageEntry.second.total);
- setField(L, "ticks", damageEntry.second.ticks);
- lua_rawseti(L, -2, damageEntry.first);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetSummons(lua_State* L)
- {
- // creature:getSummons()
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- lua_createtable(L, creature->getSummonCount(), 0);
- int index = 0;
- for (Creature* summon : creature->getSummons()) {
- pushUserdata<Creature>(L, summon);
- setCreatureMetatable(L, -1, summon);
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetDescription(lua_State* L)
- {
- // creature:getDescription(distance)
- int32_t distance = getNumber<int32_t>(L, 2);
- Creature* creature = getUserdata<Creature>(L, 1);
- if (creature) {
- pushString(L, creature->getDescription(distance));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCreatureGetPathTo(lua_State* L)
- {
- // creature:getPathTo(pos[, minTargetDist = 0[, maxTargetDist = 1[, fullPathSearch = true[, clearSight = true[, maxSearchDist = 0]]]]])
- Creature* creature = getUserdata<Creature>(L, 1);
- if (!creature) {
- lua_pushnil(L);
- return 1;
- }
- const Position& position = getPosition(L, 2);
- FindPathParams fpp;
- fpp.minTargetDist = getNumber<int32_t>(L, 3, 0);
- fpp.maxTargetDist = getNumber<int32_t>(L, 4, 1);
- fpp.fullPathSearch = getBoolean(L, 5, fpp.fullPathSearch);
- fpp.clearSight = getBoolean(L, 6, fpp.clearSight);
- fpp.maxSearchDist = getNumber<int32_t>(L, 7, fpp.maxSearchDist);
- std::forward_list<Direction> dirList;
- if (creature->getPathTo(position, dirList, fpp)) {
- lua_newtable(L);
- int index = 0;
- for (Direction dir : dirList) {
- lua_pushnumber(L, dir);
- lua_rawseti(L, -2, ++index);
- }
- } else {
- pushBoolean(L, false);
- }
- return 1;
- }
- // Player
- int LuaScriptInterface::luaPlayerCreate(lua_State* L)
- {
- // Player(id or name or userdata)
- Player* player;
- if (isNumber(L, 2)) {
- player = g_game.getPlayerByID(getNumber<uint32_t>(L, 2));
- } else if (isString(L, 2)) {
- ReturnValue ret = g_game.getPlayerByNameWildcard(getString(L, 2), player);
- if (ret != RETURNVALUE_NOERROR) {
- lua_pushnil(L);
- lua_pushnumber(L, ret);
- return 2;
- }
- } else if (isUserdata(L, 2)) {
- if (getUserdataType(L, 2) != LuaData_Player) {
- lua_pushnil(L);
- return 1;
- }
- player = getUserdata<Player>(L, 2);
- } else {
- player = nullptr;
- }
- if (player) {
- pushUserdata<Player>(L, player);
- setMetatable(L, -1, "Player");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerIsPlayer(lua_State* L)
- {
- // player:isPlayer()
- pushBoolean(L, getUserdata<const Player>(L, 1) != nullptr);
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetGuid(lua_State* L)
- {
- // player:getGuid()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getGUID());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetIp(lua_State* L)
- {
- // player:getIp()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getIP());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetAccountId(lua_State* L)
- {
- // player:getAccountId()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getAccount());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetLastLoginSaved(lua_State* L)
- {
- // player:getLastLoginSaved()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getLastLoginSaved());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetLastLogout(lua_State* L)
- {
- // player:getLastLogout()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getLastLogout());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetAccountType(lua_State* L)
- {
- // player:getAccountType()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getAccountType());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetAccountType(lua_State* L)
- {
- // player:setAccountType(accountType)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->accountType = getNumber<AccountType_t>(L, 2);
- IOLoginData::setAccountType(player->getAccount(), player->accountType);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetCapacity(lua_State* L)
- {
- // player:getCapacity()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getCapacity());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetCapacity(lua_State* L)
- {
- // player:setCapacity(capacity)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->capacity = getNumber<uint32_t>(L, 2);
- player->sendStats();
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetFreeCapacity(lua_State* L)
- {
- // player:getFreeCapacity()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getFreeCapacity());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetReward(lua_State* L)
- {
- // player:getReward(rewardId[, autoCreate = false])
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- uint32_t rewardId = getNumber<uint32_t>(L, 2);
- bool autoCreate = getBoolean(L, 3, false);
- if (Reward* reward = player->getReward(rewardId, autoCreate)) {
- pushUserdata<Item>(L, reward);
- setItemMetatable(L, -1, reward);
- } else {
- pushBoolean(L, false);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerRemoveReward(lua_State* L)
- {
- // player:removeReward(rewardId)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- uint32_t rewardId = getNumber<uint32_t>(L, 2);
- player->removeReward(rewardId);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetRewardList(lua_State* L)
- {
- // player:getRewardList(rewardId)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- auto rewardVec = player->getRewardList();
- lua_createtable(L, rewardVec.size(), 0);
- int index = 0;
- for (const auto& rewardId : rewardVec) {
- lua_pushnumber(L, rewardId);
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetDepotChest(lua_State* L)
- {
- // player:getDepotChest(depotId[, autoCreate = false])
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- uint32_t depotId = getNumber<uint32_t>(L, 2);
- bool autoCreate = getBoolean(L, 3, false);
- DepotChest* depotChest = player->getDepotChest(depotId, autoCreate);
- if (depotChest) {
- pushUserdata<Item>(L, depotChest);
- setItemMetatable(L, -1, depotChest);
- } else {
- pushBoolean(L, false);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetInbox(lua_State* L)
- {
- // player:getInbox()
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- Inbox* inbox = player->getInbox();
- if (inbox) {
- pushUserdata<Item>(L, inbox);
- setItemMetatable(L, -1, inbox);
- } else {
- pushBoolean(L, false);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetSkullTime(lua_State* L)
- {
- // player:getSkullTime()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getSkullTicks());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetSkullTime(lua_State* L)
- {
- // player:setSkullTime(skullTime)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->setSkullTicks(getNumber<int64_t>(L, 2));
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetDeathPenalty(lua_State* L)
- {
- // player:getDeathPenalty()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, static_cast<uint32_t>(player->getLostPercent() * 100));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetExperience(lua_State* L)
- {
- // player:getExperience()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getExperience());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddExperience(lua_State* L)
- {
- // player:addExperience(experience[, sendText = false])
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- int64_t experience = getNumber<int64_t>(L, 2);
- bool sendText = getBoolean(L, 3, false);
- player->addExperience(nullptr, experience, sendText);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerRemoveExperience(lua_State* L)
- {
- // player:removeExperience(experience[, sendText = false])
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- int64_t experience = getNumber<int64_t>(L, 2);
- bool sendText = getBoolean(L, 3, false);
- player->removeExperience(experience, sendText);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetLevel(lua_State* L)
- {
- // player:getLevel()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getLevel());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetMagicLevel(lua_State* L)
- {
- // player:getMagicLevel()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getMagicLevel());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetBaseMagicLevel(lua_State* L)
- {
- // player:getBaseMagicLevel()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getBaseMagicLevel());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetMaxMana(lua_State* L)
- {
- // player:setMaxMana(maxMana)
- Player* player = getPlayer(L, 1);
- if (player) {
- player->manaMax = getNumber<int32_t>(L, 2);
- player->mana = std::min<int32_t>(player->mana, player->manaMax);
- player->sendStats();
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetManaSpent(lua_State* L)
- {
- // player:getManaSpent()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getSpentMana());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddManaSpent(lua_State* L)
- {
- // player:addManaSpent(amount)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->addManaSpent(getNumber<uint64_t>(L, 2));
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetSkillLevel(lua_State* L)
- {
- // player:getSkillLevel(skillType)
- skills_t skillType = getNumber<skills_t>(L, 2);
- Player* player = getUserdata<Player>(L, 1);
- if (player && skillType <= SKILL_LAST) {
- lua_pushnumber(L, player->skills[skillType].level);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetEffectiveSkillLevel(lua_State* L)
- {
- // player:getEffectiveSkillLevel(skillType)
- skills_t skillType = getNumber<skills_t>(L, 2);
- Player* player = getUserdata<Player>(L, 1);
- if (player && skillType <= SKILL_LAST) {
- lua_pushnumber(L, player->getSkillLevel(skillType));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetSkillPercent(lua_State* L)
- {
- // player:getSkillPercent(skillType)
- skills_t skillType = getNumber<skills_t>(L, 2);
- Player* player = getUserdata<Player>(L, 1);
- if (player && skillType <= SKILL_LAST) {
- lua_pushnumber(L, player->skills[skillType].percent);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetSkillTries(lua_State* L)
- {
- // player:getSkillTries(skillType)
- skills_t skillType = getNumber<skills_t>(L, 2);
- Player* player = getUserdata<Player>(L, 1);
- if (player && skillType <= SKILL_LAST) {
- lua_pushnumber(L, player->skills[skillType].tries);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddSkillTries(lua_State* L)
- {
- // player:addSkillTries(skillType, tries)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- skills_t skillType = getNumber<skills_t>(L, 2);
- uint64_t tries = getNumber<uint64_t>(L, 3);
- player->addSkillAdvance(skillType, tries);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddOfflineTrainingTime(lua_State* L)
- {
- // player:addOfflineTrainingTime(time)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- int32_t time = getNumber<int32_t>(L, 2);
- player->addOfflineTrainingTime(time);
- player->sendStats();
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetOfflineTrainingTime(lua_State* L)
- {
- // player:getOfflineTrainingTime()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getOfflineTrainingTime());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerRemoveOfflineTrainingTime(lua_State* L)
- {
- // player:removeOfflineTrainingTime(time)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- int32_t time = getNumber<int32_t>(L, 2);
- player->removeOfflineTrainingTime(time);
- player->sendStats();
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddOfflineTrainingTries(lua_State* L)
- {
- // player:addOfflineTrainingTries(skillType, tries)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- skills_t skillType = getNumber<skills_t>(L, 2);
- uint64_t tries = getNumber<uint64_t>(L, 3);
- pushBoolean(L, player->addOfflineTrainingTries(skillType, tries));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetOfflineTrainingSkill(lua_State* L)
- {
- // player:getOfflineTrainingSkill()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getOfflineTrainingSkill());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetOfflineTrainingSkill(lua_State* L)
- {
- // player:setOfflineTrainingSkill(skillId)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- uint32_t skillId = getNumber<uint32_t>(L, 2);
- player->setOfflineTrainingSkill(skillId);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetItemCount(lua_State* L)
- {
- // player:getItemCount(itemId[, subType = -1])
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- uint16_t itemId;
- if (isNumber(L, 2)) {
- itemId = getNumber<uint16_t>(L, 2);
- } else {
- itemId = Item::items.getItemIdByName(getString(L, 2));
- if (itemId == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- int32_t subType = getNumber<int32_t>(L, 3, -1);
- lua_pushnumber(L, player->getItemTypeCount(itemId, subType));
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetItemById(lua_State* L)
- {
- // player:getItemById(itemId, deepSearch[, subType = -1])
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- uint16_t itemId;
- if (isNumber(L, 2)) {
- itemId = getNumber<uint16_t>(L, 2);
- } else {
- itemId = Item::items.getItemIdByName(getString(L, 2));
- if (itemId == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- bool deepSearch = getBoolean(L, 3);
- int32_t subType = getNumber<int32_t>(L, 4, -1);
- Item* item = g_game.findItemOfType(player, itemId, deepSearch, subType);
- if (item) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetVocation(lua_State* L)
- {
- // player:getVocation()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- pushUserdata<Vocation>(L, player->getVocation());
- setMetatable(L, -1, "Vocation");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetVocation(lua_State* L)
- {
- // player:setVocation(id or name or userdata)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- Vocation* vocation;
- if (isNumber(L, 2)) {
- vocation = g_vocations.getVocation(getNumber<uint16_t>(L, 2));
- } else if (isString(L, 2)) {
- vocation = g_vocations.getVocation(g_vocations.getVocationId(getString(L, 2)));
- } else if (isUserdata(L, 2)) {
- vocation = getUserdata<Vocation>(L, 2);
- } else {
- vocation = nullptr;
- }
- if (!vocation) {
- pushBoolean(L, false);
- return 1;
- }
- player->setVocation(vocation->getId());
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetSex(lua_State* L)
- {
- // player:getSex()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getSex());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetSex(lua_State* L)
- {
- // player:setSex(newSex)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- PlayerSex_t newSex = getNumber<PlayerSex_t>(L, 2);
- player->setSex(newSex);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetTown(lua_State* L)
- {
- // player:getTown()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- pushUserdata<Town>(L, player->getTown());
- setMetatable(L, -1, "Town");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetTown(lua_State* L)
- {
- // player:setTown(town)
- Town* town = getUserdata<Town>(L, 2);
- if (!town) {
- pushBoolean(L, false);
- return 1;
- }
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->setTown(town);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetGuild(lua_State* L)
- {
- // player:getGuild()
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- Guild* guild = player->getGuild();
- if (!guild) {
- lua_pushnil(L);
- return 1;
- }
- pushUserdata<Guild>(L, guild);
- setMetatable(L, -1, "Guild");
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetGuild(lua_State* L)
- {
- // player:setGuild(guild)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- player->setGuild(getUserdata<Guild>(L, 2));
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetGuildLevel(lua_State* L)
- {
- // player:getGuildLevel()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getGuildLevel());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetGuildLevel(lua_State* L)
- {
- // player:setGuildLevel(level)
- uint8_t level = getNumber<uint8_t>(L, 2);
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->setGuildLevel(level);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetGuildNick(lua_State* L)
- {
- // player:getGuildNick()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- pushString(L, player->getGuildNick());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetGuildNick(lua_State* L)
- {
- // player:setGuildNick(nick)
- const std::string& nick = getString(L, 2);
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->setGuildNick(nick);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetGroup(lua_State* L)
- {
- // player:getGroup()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- pushUserdata<Group>(L, player->getGroup());
- setMetatable(L, -1, "Group");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetGroup(lua_State* L)
- {
- // player:setGroup(group)
- Group* group = getUserdata<Group>(L, 2);
- if (!group) {
- pushBoolean(L, false);
- return 1;
- }
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->setGroup(group);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetStamina(lua_State* L)
- {
- // player:getStamina()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getStaminaMinutes());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetStamina(lua_State* L)
- {
- // player:setStamina(stamina)
- uint16_t stamina = getNumber<uint16_t>(L, 2);
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->staminaMinutes = std::min<uint16_t>(2520, stamina);
- player->sendStats();
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetSoul(lua_State* L)
- {
- // player:getSoul()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getSoul());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddSoul(lua_State* L)
- {
- // player:addSoul(soulChange)
- int32_t soulChange = getNumber<int32_t>(L, 2);
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->changeSoul(soulChange);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetMaxSoul(lua_State* L)
- {
- // player:getMaxSoul()
- Player* player = getUserdata<Player>(L, 1);
- if (player && player->vocation) {
- lua_pushnumber(L, player->vocation->getSoulMax());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetBankBalance(lua_State* L)
- {
- // player:getBankBalance()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getBankBalance());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetBankBalance(lua_State* L)
- {
- // player:setBankBalance(bankBalance)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->setBankBalance(getNumber<uint64_t>(L, 2));
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetStorageValue(lua_State* L)
- {
- // player:getStorageValue(key)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- uint32_t key = getNumber<uint32_t>(L, 2);
- int32_t value;
- if (player->getStorageValue(key, value)) {
- lua_pushnumber(L, value);
- } else {
- lua_pushnumber(L, -1);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetStorageValue(lua_State* L)
- {
- // player:setStorageValue(key, value)
- int32_t value = getNumber<int32_t>(L, 3);
- uint32_t key = getNumber<uint32_t>(L, 2);
- Player* player = getUserdata<Player>(L, 1);
- if (IS_IN_KEYRANGE(key, RESERVED_RANGE)) {
- std::ostringstream ss;
- ss << "Accessing reserved range: " << key;
- reportErrorFunc(ss.str());
- pushBoolean(L, false);
- return 1;
- }
- if (player) {
- player->addStorageValue(key, value);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddItem(lua_State* L)
- {
- // player:addItem(itemId[, count = 1[, canDropOnMap = true[, subType = 1[, slot = CONST_SLOT_WHEREEVER]]]])
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- pushBoolean(L, false);
- return 1;
- }
- uint16_t itemId;
- if (isNumber(L, 2)) {
- itemId = getNumber<uint16_t>(L, 2);
- } else {
- itemId = Item::items.getItemIdByName(getString(L, 2));
- if (itemId == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- int32_t count = getNumber<int32_t>(L, 3, 1);
- int32_t subType = getNumber<int32_t>(L, 5, 1);
- const ItemType& it = Item::items[itemId];
- int32_t itemCount = 1;
- int parameters = lua_gettop(L);
- if (parameters >= 4) {
- itemCount = std::max<int32_t>(1, count);
- } else if (it.hasSubType()) {
- if (it.stackable) {
- itemCount = std::ceil(count / 100.f);
- }
- subType = count;
- } else {
- itemCount = std::max<int32_t>(1, count);
- }
- bool hasTable = itemCount > 1;
- if (hasTable) {
- lua_newtable(L);
- } else if (itemCount == 0) {
- lua_pushnil(L);
- return 1;
- }
- bool canDropOnMap = getBoolean(L, 4, true);
- slots_t slot = getNumber<slots_t>(L, 6, CONST_SLOT_WHEREEVER);
- for (int32_t i = 1; i <= itemCount; ++i) {
- int32_t stackCount = subType;
- if (it.stackable) {
- stackCount = std::min<int32_t>(stackCount, 100);
- subType -= stackCount;
- }
- Item* item = Item::CreateItem(itemId, stackCount);
- if (!item) {
- if (!hasTable) {
- lua_pushnil(L);
- }
- return 1;
- }
- ReturnValue ret = g_game.internalPlayerAddItem(player, item, canDropOnMap, slot);
- if (ret != RETURNVALUE_NOERROR) {
- delete item;
- if (!hasTable) {
- lua_pushnil(L);
- }
- return 1;
- }
- if (hasTable) {
- lua_pushnumber(L, i);
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- lua_settable(L, -3);
- } else {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- }
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddItemEx(lua_State* L)
- {
- // player:addItemEx(item[, canDropOnMap = false[, index = INDEX_WHEREEVER[, flags = 0]]])
- // player:addItemEx(item[, canDropOnMap = true[, slot = CONST_SLOT_WHEREEVER]])
- Item* item = getUserdata<Item>(L, 2);
- if (!item) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_ITEM_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- if (item->getParent() != VirtualCylinder::virtualCylinder) {
- reportErrorFunc("Item already has a parent");
- pushBoolean(L, false);
- return 1;
- }
- bool canDropOnMap = getBoolean(L, 3, false);
- ReturnValue returnValue;
- if (canDropOnMap) {
- slots_t slot = getNumber<slots_t>(L, 4, CONST_SLOT_WHEREEVER);
- returnValue = g_game.internalPlayerAddItem(player, item, true, slot);
- } else {
- int32_t index = getNumber<int32_t>(L, 4, INDEX_WHEREEVER);
- uint32_t flags = getNumber<uint32_t>(L, 5, 0);
- returnValue = g_game.internalAddItem(player, item, index, flags);
- }
- if (returnValue == RETURNVALUE_NOERROR) {
- ScriptEnvironment::removeTempItem(item);
- }
- lua_pushnumber(L, returnValue);
- return 1;
- }
- int LuaScriptInterface::luaPlayerRemoveItem(lua_State* L)
- {
- // player:removeItem(itemId, count[, subType = -1[, ignoreEquipped = false]])
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- uint16_t itemId;
- if (isNumber(L, 2)) {
- itemId = getNumber<uint16_t>(L, 2);
- } else {
- itemId = Item::items.getItemIdByName(getString(L, 2));
- if (itemId == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- uint32_t count = getNumber<uint32_t>(L, 3);
- int32_t subType = getNumber<int32_t>(L, 4, -1);
- bool ignoreEquipped = getBoolean(L, 5, false);
- pushBoolean(L, player->removeItemOfType(itemId, count, subType, ignoreEquipped));
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetMoney(lua_State* L)
- {
- // player:getMoney()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getMoney());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddMoney(lua_State* L)
- {
- // player:addMoney(money)
- uint64_t money = getNumber<uint64_t>(L, 2);
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- g_game.addMoney(player, money);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerRemoveMoney(lua_State* L)
- {
- // player:removeMoney(money)mon
- Player* player = getUserdata<Player>(L, 1);
- bool success = false;
- if (player) {
- uint64_t money = getNumber<uint64_t>(L, 2);
- if (!g_game.removeMoney(player, money))
- {
- uint64_t playerTotal = player->getMoney() + player->getBankBalance();
- if (playerTotal >= money)
- {
- money -= player->getMoney(); //discount player money
- if (money < 0) money = 0;
- g_game.removeMoney(player, player->getMoney()); //1
- if (player->getMoney() < 0) money = 0;
- // player money is 0, and its value is discounted. Now remove from balance the rest
- playerTotal = player->getBankBalance() - money;
- if (playerTotal < 0) playerTotal = 0;
- player->setBankBalance(playerTotal);
- std::ostringstream ss;
- ss << "Paid " << money << " gold from bank account. Your account balance is now " << player->getBankBalance() << " gold.";
- player->sendTextMessage(MESSAGE_INFO_DESCR, ss.str());
- success = true;
- }
- }
- else
- {
- success = true;
- }
- pushBoolean(L, success);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerShowTextDialog(lua_State* L)
- {
- // player:showTextDialog(itemId[, text[, canWrite[, length]]])
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- int32_t length = getNumber<int32_t>(L, 5, -1);
- bool canWrite = getBoolean(L, 4, false);
- std::string text;
- int parameters = lua_gettop(L);
- if (parameters >= 3) {
- text = getString(L, 3);
- }
- uint16_t itemId;
- if (isNumber(L, 2)) {
- itemId = getNumber<uint16_t>(L, 2);
- } else {
- itemId = Item::items.getItemIdByName(getString(L, 2));
- if (itemId == 0) {
- lua_pushnil(L);
- return 1;
- }
- }
- Item* item = Item::CreateItem(itemId);
- if (!item) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_ITEM_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- if (length < 0) {
- length = Item::items[item->getID()].maxTextLen;
- }
- if (!text.empty()) {
- item->setText(text);
- length = std::max<int32_t>(text.size(), length);
- }
- item->setParent(player);
- player->setWriteItem(item, length);
- player->sendTextWindow(item, length, canWrite);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaPlayerSendTextMessage(lua_State* L)
- {
- // player:sendTextMessage(type, text[, position, primaryValue = 0, primaryColor = TEXTCOLOR_NONE[, secondaryValue = 0, secondaryColor = TEXTCOLOR_NONE]])
- int parameters = lua_gettop(L);
- TextMessage message(getNumber<MessageClasses>(L, 2), getString(L, 3));
- if (parameters >= 6) {
- message.position = getPosition(L, 4);
- message.primary.value = getNumber<int32_t>(L, 5);
- message.primary.color = getNumber<TextColor_t>(L, 6);
- }
- if (parameters >= 8) {
- message.secondary.value = getNumber<int32_t>(L, 7);
- message.secondary.color = getNumber<TextColor_t>(L, 8);
- }
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->sendTextMessage(message);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSendChannelMessage(lua_State* L)
- {
- // player:sendChannelMessage(author, text, type, channelId)
- uint16_t channelId = getNumber<uint16_t>(L, 5);
- SpeakClasses type = getNumber<SpeakClasses>(L, 4);
- const std::string& text = getString(L, 3);
- const std::string& author = getString(L, 2);
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->sendChannelMessage(author, text, type, channelId);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSendPrivateMessage(lua_State* L)
- {
- // player:sendPrivateMessage(speaker, text[, type])
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- const Player* speaker = getUserdata<const Player>(L, 2);
- const std::string& text = getString(L, 3);
- SpeakClasses type = getNumber<SpeakClasses>(L, 4, TALKTYPE_PRIVATE_FROM);
- player->sendPrivateMessage(speaker, type, text);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaPlayerChannelSay(lua_State* L)
- {
- // player:channelSay(speaker, type, text, channelId)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- Creature* speaker = getCreature(L, 2);
- SpeakClasses type = getNumber<SpeakClasses>(L, 3);
- const std::string& text = getString(L, 4);
- uint16_t channelId = getNumber<uint16_t>(L, 5);
- player->sendToChannel(speaker, type, text, channelId);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaPlayerOpenChannel(lua_State* L)
- {
- // player:openChannel(channelId)
- uint16_t channelId = getNumber<uint16_t>(L, 2);
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- g_game.playerOpenChannel(player->getID(), channelId);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetSlotItem(lua_State* L)
- {
- // player:getSlotItem(slot)
- const Player* player = getUserdata<const Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- uint32_t slot = getNumber<uint32_t>(L, 2);
- Thing* thing = player->getThing(slot);
- if (!thing) {
- lua_pushnil(L);
- return 1;
- }
- Item* item = thing->getItem();
- if (item) {
- pushUserdata<Item>(L, item);
- setItemMetatable(L, -1, item);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetParty(lua_State* L)
- {
- // player:getParty()
- const Player* player = getUserdata<const Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- Party* party = player->getParty();
- if (party) {
- pushUserdata<Party>(L, party);
- setMetatable(L, -1, "Party");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddOutfit(lua_State* L)
- {
- // player:addOutfit(lookType)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->addOutfit(getNumber<uint16_t>(L, 2), 0);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddOutfitAddon(lua_State* L)
- {
- // player:addOutfitAddon(lookType, addon)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- uint16_t lookType = getNumber<uint16_t>(L, 2);
- uint8_t addon = getNumber<uint8_t>(L, 3);
- player->addOutfit(lookType, addon);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerRemoveOutfit(lua_State* L)
- {
- // player:removeOutfit(lookType)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- uint16_t lookType = getNumber<uint16_t>(L, 2);
- pushBoolean(L, player->removeOutfit(lookType));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerRemoveOutfitAddon(lua_State* L)
- {
- // player:removeOutfitAddon(lookType, addon)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- uint16_t lookType = getNumber<uint16_t>(L, 2);
- uint8_t addon = getNumber<uint8_t>(L, 3);
- pushBoolean(L, player->removeOutfitAddon(lookType, addon));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerHasOutfit(lua_State* L)
- {
- // player:hasOutfit(lookType[, addon = 0])
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- uint16_t lookType = getNumber<uint16_t>(L, 2);
- uint8_t addon = getNumber<uint8_t>(L, 3, 0);
- pushBoolean(L, player->canWear(lookType, addon));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSendOutfitWindow(lua_State* L)
- {
- // player:sendOutfitWindow()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->sendOutfitWindow();
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddMount(lua_State* L)
- {
- // player:addMount(mountId or mountName)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- uint8_t mountId;
- if (isNumber(L, 2)) {
- mountId = getNumber<uint8_t>(L, 2);
- pushBoolean(L, player->tameMount(mountId));
- } else if (isString(L, 2)) {
- Mount* mount = g_game.mounts.getMountByName(getString(L, 2));
- if (!mount) {
- lua_pushnil(L);
- return 1;
- }
- mountId = mount->id;
- pushBoolean(L, player->tameMount(mountId));
- }
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerRemoveMount(lua_State* L)
- {
- // player:removeMount(mountId or mountName)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- uint8_t mountId;
- if (isNumber(L, 2)) {
- mountId = getNumber<uint8_t>(L, 2);
- pushBoolean(L, player->untameMount(mountId));
- } else if (isString(L, 2)) {
- Mount* mount = g_game.mounts.getMountByName(getString(L, 2));
- if (!mount) {
- lua_pushnil(L);
- return 1;
- }
- mountId = mount->id;
- pushBoolean(L, player->untameMount(mountId));
- }
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerHasMount(lua_State* L)
- {
- // player:hasMount(mountId or mountName)
- const Player* player = getUserdata<const Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- Mount* mount = nullptr;
- if (isNumber(L, 2)) {
- mount = g_game.mounts.getMountByID(getNumber<uint8_t>(L, 2));
- } else if (isString(L, 2)) {
- mount = g_game.mounts.getMountByName(getString(L, 2));
- }
- if (mount) {
- pushBoolean(L, player->hasMount(mount));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetPremiumDays(lua_State* L)
- {
- // player:getPremiumDays()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->premiumDays);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddPremiumDays(lua_State* L)
- {
- // player:addPremiumDays(days)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- if (player->premiumDays != std::numeric_limits<uint16_t>::max()) {
- uint16_t days = getNumber<uint16_t>(L, 2);
- int32_t addDays = std::min<int32_t>(0xFFFE - player->premiumDays, days);
- if (addDays > 0) {
- player->setPremiumDays(player->premiumDays + addDays);
- IOLoginData::addPremiumDays(player->getAccount(), addDays);
- }
- }
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaPlayerRemovePremiumDays(lua_State* L)
- {
- // player:removePremiumDays(days)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- if (player->premiumDays != std::numeric_limits<uint16_t>::max()) {
- uint16_t days = getNumber<uint16_t>(L, 2);
- int32_t removeDays = std::min<int32_t>(player->premiumDays, days);
- if (removeDays > 0) {
- player->setPremiumDays(player->premiumDays - removeDays);
- IOLoginData::removePremiumDays(player->getAccount(), removeDays);
- }
- }
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaPlayerHasBlessing(lua_State* L)
- {
- // player:hasBlessing(blessing)
- uint8_t blessing = getNumber<uint8_t>(L, 2) - 1;
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- pushBoolean(L, player->hasBlessing(blessing));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddBlessing(lua_State* L)
- {
- // player:addBlessing(blessing)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- uint8_t blessing = getNumber<uint8_t>(L, 2) - 1;
- if (player->hasBlessing(blessing)) {
- pushBoolean(L, false);
- return 1;
- }
- player->addBlessing(1 << blessing);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaPlayerRemoveBlessing(lua_State* L)
- {
- // player:removeBlessing(blessing)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- uint8_t blessing = getNumber<uint8_t>(L, 2) - 1;
- if (!player->hasBlessing(blessing)) {
- pushBoolean(L, false);
- return 1;
- }
- player->removeBlessing(1 << blessing);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaPlayerCanLearnSpell(lua_State* L)
- {
- // player:canLearnSpell(spellName)
- const Player* player = getUserdata<const Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- const std::string& spellName = getString(L, 2);
- InstantSpell* spell = g_spells->getInstantSpellByName(spellName);
- if (!spell) {
- reportErrorFunc("Spell \"" + spellName + "\" not found");
- pushBoolean(L, false);
- return 1;
- }
- if (player->hasFlag(PlayerFlag_IgnoreSpellCheck)) {
- pushBoolean(L, true);
- return 1;
- }
- const auto& vocMap = spell->getVocMap();
- if (vocMap.count(player->getVocationId()) == 0) {
- pushBoolean(L, false);
- } else if (player->getLevel() < spell->getLevel()) {
- pushBoolean(L, false);
- } else if (player->getMagicLevel() < spell->getMagicLevel()) {
- pushBoolean(L, false);
- } else {
- pushBoolean(L, true);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerLearnSpell(lua_State* L)
- {
- // player:learnSpell(spellName)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- const std::string& spellName = getString(L, 2);
- player->learnInstantSpell(spellName);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerForgetSpell(lua_State* L)
- {
- // player:forgetSpell(spellName)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- const std::string& spellName = getString(L, 2);
- player->forgetInstantSpell(spellName);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerHasLearnedSpell(lua_State* L)
- {
- // player:hasLearnedSpell(spellName)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- const std::string& spellName = getString(L, 2);
- pushBoolean(L, player->hasLearnedInstantSpell(spellName));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSendTutorial(lua_State* L)
- {
- // player:sendTutorial(tutorialId)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- uint8_t tutorialId = getNumber<uint8_t>(L, 2);
- player->sendTutorial(tutorialId);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerAddMapMark(lua_State* L)
- {
- // player:addMapMark(position, type, description)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- const Position& position = getPosition(L, 2);
- uint8_t type = getNumber<uint8_t>(L, 3);
- const std::string& description = getString(L, 4);
- player->sendAddMarker(position, type, description);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSave(lua_State* L)
- {
- // player:save()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- player->loginPosition = player->getPosition();
- pushBoolean(L, IOLoginData::savePlayer(player));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerPopupFYI(lua_State* L)
- {
- // player:popupFYI(message)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- const std::string& message = getString(L, 2);
- player->sendFYIBox(message);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerIsPzLocked(lua_State* L)
- {
- // player:isPzLocked()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- pushBoolean(L, player->isPzLocked());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetClient(lua_State* L)
- {
- // player:getClient()
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_createtable(L, 0, 2);
- setField(L, "version", player->getProtocolVersion());
- setField(L, "os", player->getOperatingSystem());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetHouse(lua_State* L)
- {
- // player:getHouse()
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- House* house = g_game.map.houses.getHouseByPlayerId(player->getGUID());
- if (house) {
- pushUserdata<House>(L, house);
- setMetatable(L, -1, "House");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSetGhostMode(lua_State* L)
- {
- // player:setGhostMode(enabled)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- bool enabled = getBoolean(L, 2);
- if (player->isInGhostMode() == enabled) {
- pushBoolean(L, true);
- return 1;
- }
- player->switchGhostMode();
- Tile* tile = player->getTile();
- const Position& position = player->getPosition();
- SpectatorVec list;
- g_game.map.getSpectators(list, position, true, true);
- for (Creature* spectator : list) {
- Player* tmpPlayer = spectator->getPlayer();
- if (tmpPlayer != player && !tmpPlayer->isAccessPlayer()) {
- if (enabled) {
- tmpPlayer->sendRemoveTileThing(position, tile->getStackposOfCreature(tmpPlayer, player));
- } else {
- tmpPlayer->sendCreatureAppear(player, position, true);
- }
- } else {
- tmpPlayer->sendCreatureChangeVisible(player, !enabled);
- }
- }
- if (player->isInGhostMode()) {
- for (const auto& it : g_game.getPlayers()) {
- if (!it.second->isAccessPlayer()) {
- it.second->notifyStatusChange(player, VIPSTATUS_OFFLINE);
- }
- }
- IOLoginData::updateOnlineStatus(player->getGUID(), false);
- } else {
- for (const auto& it : g_game.getPlayers()) {
- if (!it.second->isAccessPlayer()) {
- it.second->notifyStatusChange(player, VIPSTATUS_ONLINE);
- }
- }
- IOLoginData::updateOnlineStatus(player->getGUID(), true);
- }
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetContainerId(lua_State* L)
- {
- // player:getContainerId(container)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- Container* container = getUserdata<Container>(L, 2);
- if (container) {
- lua_pushnumber(L, player->getContainerID(container));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetContainerById(lua_State* L)
- {
- // player:getContainerById(id)
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- Container* container = player->getContainerByID(getNumber<uint8_t>(L, 2));
- if (container) {
- pushUserdata<Container>(L, container);
- setMetatable(L, -1, "Container");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerGetContainerIndex(lua_State* L)
- {
- // player:getContainerIndex(id)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- lua_pushnumber(L, player->getContainerIndex(getNumber<uint8_t>(L, 2)));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPlayerSendStoreError(lua_State* L)
- {
- // player::sendStoreError(errorType, message)
- Player* player = getUserdata<Player>(L, 1);
- if (player) {
- StoreError_t errorType = static_cast<StoreError_t>(getNumber<uint8_t>(L, 2));
- if (isString(L, 3)) {
- player->sendStoreError(errorType, getString(L, 3));
- pushBoolean(L, true);
- return 1;
- }
- }
- lua_pushnil(L);
- return 1;
- }
- int32_t LuaScriptInterface::luaPlayerStartLiveCast(lua_State* L)
- {
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- std::string password;
- if (lua_gettop(L) == 2) {
- password = getString(L, 2);
- }
- lua_pushboolean(L, player->startLiveCast(password));
- return 1;
- }
- int32_t LuaScriptInterface::luaPlayerStopLiveCast(lua_State* L)
- {
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- lua_pushboolean(L, player->stopLiveCast());
- return 1;
- }
- int32_t LuaScriptInterface::luaPlayerIsLiveCaster(lua_State* L)
- {
- Player* player = getUserdata<Player>(L, 1);
- if (!player) {
- lua_pushnil(L);
- return 1;
- }
- lua_pushboolean(L, player->isLiveCaster());
- return 1;
- }
- int32_t LuaScriptInterface::luaPlayerGetSpectators(lua_State* L)
- {
- Player* player = getUserdata<Player>(L, 1);
- if (!player || !player->isLiveCaster()) {
- lua_pushnil(L);
- return 1;
- }
- std::lock_guard<std::mutex> lock(player->client->liveCastLock);
- std::vector<ProtocolSpectator_ptr> spectators;
- player->getSpectators(spectators);
- lua_createtable(L, spectators.size(), 0);
- int idx = 0, anonymous = 0;
- for (const auto spectator : spectators) {
- std::string specName = spectator->getName();
- if (specName.empty()) {
- anonymous += 1;
- } else {
- pushString(L, specName);
- lua_rawseti(L, -2, ++idx);
- }
- }
- lua_pushnumber(L, anonymous);
- return 2;
- }
- // Monster
- int LuaScriptInterface::luaMonsterCreate(lua_State* L)
- {
- // Monster(id or userdata)
- Monster* monster;
- if (isNumber(L, 2)) {
- monster = g_game.getMonsterByID(getNumber<uint32_t>(L, 2));
- } else if (isUserdata(L, 2)) {
- if (getUserdataType(L, 2) != LuaData_Monster) {
- lua_pushnil(L);
- return 1;
- }
- monster = getUserdata<Monster>(L, 2);
- } else {
- monster = nullptr;
- }
- if (monster) {
- pushUserdata<Monster>(L, monster);
- setMetatable(L, -1, "Monster");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterIsMonster(lua_State* L)
- {
- // monster:isMonster()
- pushBoolean(L, getUserdata<const Monster>(L, 1) != nullptr);
- return 1;
- }
- int LuaScriptInterface::luaMonsterGetType(lua_State* L)
- {
- // monster:getType()
- const Monster* monster = getUserdata<const Monster>(L, 1);
- if (monster) {
- pushUserdata<MonsterType>(L, monster->mType);
- setMetatable(L, -1, "MonsterType");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterGetSpawnPosition(lua_State* L)
- {
- // monster:getSpawnPosition()
- const Monster* monster = getUserdata<const Monster>(L, 1);
- if (monster) {
- pushPosition(L, monster->getMasterPos());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterIsInSpawnRange(lua_State* L)
- {
- // monster:isInSpawnRange([position])
- Monster* monster = getUserdata<Monster>(L, 1);
- if (monster) {
- pushBoolean(L, monster->isInSpawnRange(lua_gettop(L) >= 2 ? getPosition(L, 2) : monster->getPosition()));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterIsIdle(lua_State* L)
- {
- // monster:isIdle()
- Monster* monster = getUserdata<Monster>(L, 1);
- if (monster) {
- pushBoolean(L, monster->getIdleStatus());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterSetIdle(lua_State* L)
- {
- // monster:setIdle(idle)
- Monster* monster = getUserdata<Monster>(L, 1);
- if (!monster) {
- lua_pushnil(L);
- return 1;
- }
- monster->setIdle(getBoolean(L, 2));
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaMonsterIsTarget(lua_State* L)
- {
- // monster:isTarget(creature)
- Monster* monster = getUserdata<Monster>(L, 1);
- if (monster) {
- const Creature* creature = getCreature(L, 2);
- pushBoolean(L, monster->isTarget(creature));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterIsOpponent(lua_State* L)
- {
- // monster:isOpponent(creature)
- Monster* monster = getUserdata<Monster>(L, 1);
- if (monster) {
- const Creature* creature = getCreature(L, 2);
- pushBoolean(L, monster->isOpponent(creature));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterIsFriend(lua_State* L)
- {
- // monster:isFriend(creature)
- Monster* monster = getUserdata<Monster>(L, 1);
- if (monster) {
- const Creature* creature = getCreature(L, 2);
- pushBoolean(L, monster->isFriend(creature));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterAddFriend(lua_State* L)
- {
- // monster:addFriend(creature)
- Monster* monster = getUserdata<Monster>(L, 1);
- if (monster) {
- Creature* creature = getCreature(L, 2);
- monster->addFriend(creature);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterRemoveFriend(lua_State* L)
- {
- // monster:removeFriend(creature)
- Monster* monster = getUserdata<Monster>(L, 1);
- if (monster) {
- Creature* creature = getCreature(L, 2);
- monster->removeFriend(creature);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterGetFriendList(lua_State* L)
- {
- // monster:getFriendList()
- Monster* monster = getUserdata<Monster>(L, 1);
- if (!monster) {
- lua_pushnil(L);
- return 1;
- }
- const auto& friendList = monster->getFriendList();
- lua_createtable(L, friendList.size(), 0);
- int index = 0;
- for (Creature* creature : friendList) {
- pushUserdata<Creature>(L, creature);
- setCreatureMetatable(L, -1, creature);
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterGetFriendCount(lua_State* L)
- {
- // monster:getFriendCount()
- Monster* monster = getUserdata<Monster>(L, 1);
- if (monster) {
- lua_pushnumber(L, monster->getFriendList().size());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterAddTarget(lua_State* L)
- {
- // monster:addTarget(creature[, pushFront = false])
- Monster* monster = getUserdata<Monster>(L, 1);
- if (!monster) {
- lua_pushnil(L);
- return 1;
- }
- Creature* creature = getCreature(L, 2);
- bool pushFront = getBoolean(L, 3, false);
- monster->addTarget(creature, pushFront);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaMonsterRemoveTarget(lua_State* L)
- {
- // monster:removeTarget(creature)
- Monster* monster = getUserdata<Monster>(L, 1);
- if (!monster) {
- lua_pushnil(L);
- return 1;
- }
- monster->removeTarget(getCreature(L, 2));
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaMonsterGetTargetList(lua_State* L)
- {
- // monster:getTargetList()
- Monster* monster = getUserdata<Monster>(L, 1);
- if (!monster) {
- lua_pushnil(L);
- return 1;
- }
- const auto& targetList = monster->getTargetList();
- lua_createtable(L, targetList.size(), 0);
- int index = 0;
- for (Creature* creature : targetList) {
- pushUserdata<Creature>(L, creature);
- setCreatureMetatable(L, -1, creature);
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterGetTargetCount(lua_State* L)
- {
- // monster:getTargetCount()
- Monster* monster = getUserdata<Monster>(L, 1);
- if (monster) {
- lua_pushnumber(L, monster->getTargetList().size());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterSelectTarget(lua_State* L)
- {
- // monster:selectTarget(creature)
- Monster* monster = getUserdata<Monster>(L, 1);
- if (monster) {
- Creature* creature = getCreature(L, 2);
- pushBoolean(L, monster->selectTarget(creature));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterSearchTarget(lua_State* L)
- {
- // monster:searchTarget([searchType = TARGETSEARCH_DEFAULT])
- Monster* monster = getUserdata<Monster>(L, 1);
- if (monster) {
- TargetSearchType_t searchType = getNumber<TargetSearchType_t>(L, 2, TARGETSEARCH_DEFAULT);
- pushBoolean(L, monster->searchTarget(searchType));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // Npc
- int LuaScriptInterface::luaNpcCreate(lua_State* L)
- {
- // Npc([id or name or userdata])
- Npc* npc;
- if (lua_gettop(L) >= 2) {
- if (isNumber(L, 2)) {
- npc = g_game.getNpcByID(getNumber<uint32_t>(L, 2));
- } else if (isString(L, 2)) {
- npc = g_game.getNpcByName(getString(L, 2));
- } else if (isUserdata(L, 2)) {
- if (getUserdataType(L, 2) != LuaData_Npc) {
- lua_pushnil(L);
- return 1;
- }
- npc = getUserdata<Npc>(L, 2);
- } else {
- npc = nullptr;
- }
- } else {
- npc = getScriptEnv()->getNpc();
- }
- if (npc) {
- pushUserdata<Npc>(L, npc);
- setMetatable(L, -1, "Npc");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNpcIsNpc(lua_State* L)
- {
- // npc:isNpc()
- pushBoolean(L, getUserdata<const Npc>(L, 1) != nullptr);
- return 1;
- }
- int LuaScriptInterface::luaNpcSetMasterPos(lua_State* L)
- {
- // npc:setMasterPos(pos[, radius])
- Npc* npc = getUserdata<Npc>(L, 1);
- if (!npc) {
- lua_pushnil(L);
- return 1;
- }
- const Position& pos = getPosition(L, 2);
- int32_t radius = getNumber<int32_t>(L, 3, 1);
- npc->setMasterPos(pos, radius);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaNpcGetSpeechBubble(lua_State* L)
- {
- // npc:getSpeechBubble()
- Npc* npc = getUserdata<Npc>(L, 1);
- if (npc) {
- lua_pushnumber(L, npc->getSpeechBubble());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaNpcSetSpeechBubble(lua_State* L)
- {
- // npc:setSpeechBubble(speechBubble)
- Npc* npc = getUserdata<Npc>(L, 1);
- if (npc) {
- npc->setSpeechBubble(getNumber<uint8_t>(L, 2));
- }
- return 0;
- }
- // Guild
- int LuaScriptInterface::luaGuildCreate(lua_State* L)
- {
- // Guild(id)
- uint32_t id = getNumber<uint32_t>(L, 2);
- Guild* guild = g_game.getGuild(id);
- if (guild) {
- pushUserdata<Guild>(L, guild);
- setMetatable(L, -1, "Guild");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGuildGetId(lua_State* L)
- {
- // guild:getId()
- Guild* guild = getUserdata<Guild>(L, 1);
- if (guild) {
- lua_pushnumber(L, guild->getId());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGuildGetName(lua_State* L)
- {
- // guild:getName()
- Guild* guild = getUserdata<Guild>(L, 1);
- if (guild) {
- pushString(L, guild->getName());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGuildGetMembersOnline(lua_State* L)
- {
- // guild:getMembersOnline()
- const Guild* guild = getUserdata<const Guild>(L, 1);
- if (!guild) {
- lua_pushnil(L);
- return 1;
- }
- const auto& members = guild->getMembersOnline();
- lua_createtable(L, members.size(), 0);
- int index = 0;
- for (Player* player : members) {
- pushUserdata<Player>(L, player);
- setMetatable(L, -1, "Player");
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaGuildGetBankBalance(lua_State* L)
- {
- // guild:getBankBalance()
- Guild* guild = getUserdata<Guild>(L, 1);
- if (!guild) {
- lua_pushnil(L);
- return 1;
- }
- lua_pushnumber(L, guild->getBankBalance());
- return 1;
- }
- int LuaScriptInterface::luaGuildSetBankBalance(lua_State* L)
- {
- // guild:setBankBalance(balance)
- Guild* guild = getUserdata<Guild>(L, 1);
- if (!guild) {
- lua_pushnil(L);
- return 1;
- }
- auto balance = getNumber<uint32_t>(L, 2);
- guild->setBankBalance(balance);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaGuildAddRank(lua_State* L)
- {
- // guild:addRank(id, name, level)
- Guild* guild = getUserdata<Guild>(L, 1);
- if (guild) {
- uint32_t id = getNumber<uint32_t>(L, 2);
- const std::string& name = getString(L, 3);
- uint8_t level = getNumber<uint8_t>(L, 4);
- guild->addRank(id, name, level);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGuildGetRankById(lua_State* L)
- {
- // guild:getRankById(id)
- Guild* guild = getUserdata<Guild>(L, 1);
- if (!guild) {
- lua_pushnil(L);
- return 1;
- }
- uint32_t id = getNumber<uint32_t>(L, 2);
- GuildRank* rank = guild->getRankById(id);
- if (rank) {
- lua_createtable(L, 0, 3);
- setField(L, "id", rank->id);
- setField(L, "name", rank->name);
- setField(L, "level", rank->level);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGuildGetRankByLevel(lua_State* L)
- {
- // guild:getRankByLevel(level)
- const Guild* guild = getUserdata<const Guild>(L, 1);
- if (!guild) {
- lua_pushnil(L);
- return 1;
- }
- uint8_t level = getNumber<uint8_t>(L, 2);
- const GuildRank* rank = guild->getRankByLevel(level);
- if (rank) {
- lua_createtable(L, 0, 3);
- setField(L, "id", rank->id);
- setField(L, "name", rank->name);
- setField(L, "level", rank->level);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGuildGetMotd(lua_State* L)
- {
- // guild:getMotd()
- Guild* guild = getUserdata<Guild>(L, 1);
- if (guild) {
- pushString(L, guild->getMotd());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGuildSetMotd(lua_State* L)
- {
- // guild:setMotd(motd)
- const std::string& motd = getString(L, 2);
- Guild* guild = getUserdata<Guild>(L, 1);
- if (guild) {
- guild->setMotd(motd);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // Group
- int LuaScriptInterface::luaGroupCreate(lua_State* L)
- {
- // Group(id)
- uint32_t id = getNumber<uint32_t>(L, 2);
- Group* group = g_game.groups.getGroup(id);
- if (group) {
- pushUserdata<Group>(L, group);
- setMetatable(L, -1, "Group");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGroupGetId(lua_State* L)
- {
- // group:getId()
- Group* group = getUserdata<Group>(L, 1);
- if (group) {
- lua_pushnumber(L, group->id);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGroupGetName(lua_State* L)
- {
- // group:getName()
- Group* group = getUserdata<Group>(L, 1);
- if (group) {
- pushString(L, group->name);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGroupGetFlags(lua_State* L)
- {
- // group:getFlags()
- Group* group = getUserdata<Group>(L, 1);
- if (group) {
- lua_pushnumber(L, group->flags);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGroupGetAccess(lua_State* L)
- {
- // group:getAccess()
- Group* group = getUserdata<Group>(L, 1);
- if (group) {
- pushBoolean(L, group->access);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGroupGetMaxDepotItems(lua_State* L)
- {
- // group:getMaxDepotItems()
- Group* group = getUserdata<Group>(L, 1);
- if (group) {
- lua_pushnumber(L, group->maxDepotItems);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaGroupGetMaxVipEntries(lua_State* L)
- {
- // group:getMaxVipEntries()
- Group* group = getUserdata<Group>(L, 1);
- if (group) {
- lua_pushnumber(L, group->maxVipEntries);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // Vocation
- int LuaScriptInterface::luaVocationCreate(lua_State* L)
- {
- // Vocation(id or name)
- uint32_t id;
- if (isNumber(L, 2)) {
- id = getNumber<uint32_t>(L, 2);
- } else {
- id = g_vocations.getVocationId(getString(L, 2));
- }
- Vocation* vocation = g_vocations.getVocation(id);
- if (vocation) {
- pushUserdata<Vocation>(L, vocation);
- setMetatable(L, -1, "Vocation");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetId(lua_State* L)
- {
- // vocation:getId()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getId());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetClientId(lua_State* L)
- {
- // vocation:getClientId()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getClientId());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetName(lua_State* L)
- {
- // vocation:getName()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- pushString(L, vocation->getVocName());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetDescription(lua_State* L)
- {
- // vocation:getDescription()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- pushString(L, vocation->getVocDescription());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetRequiredSkillTries(lua_State* L)
- {
- // vocation:getRequiredSkillTries(skillType, skillLevel)
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- skills_t skillType = getNumber<skills_t>(L, 2);
- uint16_t skillLevel = getNumber<uint16_t>(L, 3);
- lua_pushnumber(L, vocation->getReqSkillTries(skillType, skillLevel));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetRequiredManaSpent(lua_State* L)
- {
- // vocation:getRequiredManaSpent(magicLevel)
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- uint32_t magicLevel = getNumber<uint32_t>(L, 2);
- lua_pushnumber(L, vocation->getReqMana(magicLevel));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetCapacityGain(lua_State* L)
- {
- // vocation:getCapacityGain()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getCapGain());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetHealthGain(lua_State* L)
- {
- // vocation:getHealthGain()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getHPGain());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetHealthGainTicks(lua_State* L)
- {
- // vocation:getHealthGainTicks()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getHealthGainTicks());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetHealthGainAmount(lua_State* L)
- {
- // vocation:getHealthGainAmount()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getHealthGainAmount());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetManaGain(lua_State* L)
- {
- // vocation:getManaGain()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getManaGain());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetManaGainTicks(lua_State* L)
- {
- // vocation:getManaGainTicks()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getManaGainTicks());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetManaGainAmount(lua_State* L)
- {
- // vocation:getManaGainAmount()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getManaGainAmount());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetMaxSoul(lua_State* L)
- {
- // vocation:getMaxSoul()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getSoulMax());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetSoulGainTicks(lua_State* L)
- {
- // vocation:getSoulGainTicks()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getSoulGainTicks());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetAttackSpeed(lua_State* L)
- {
- // vocation:getAttackSpeed()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getAttackSpeed());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetBaseSpeed(lua_State* L)
- {
- // vocation:getBaseSpeed()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (vocation) {
- lua_pushnumber(L, vocation->getBaseSpeed());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetDemotion(lua_State* L)
- {
- // vocation:getDemotion()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (!vocation) {
- lua_pushnil(L);
- return 1;
- }
- uint16_t fromId = vocation->getFromVocation();
- if (fromId == VOCATION_NONE) {
- lua_pushnil(L);
- return 1;
- }
- Vocation* demotedVocation = g_vocations.getVocation(fromId);
- if (demotedVocation && demotedVocation != vocation) {
- pushUserdata<Vocation>(L, demotedVocation);
- setMetatable(L, -1, "Vocation");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaVocationGetPromotion(lua_State* L)
- {
- // vocation:getPromotion()
- Vocation* vocation = getUserdata<Vocation>(L, 1);
- if (!vocation) {
- lua_pushnil(L);
- return 1;
- }
- uint16_t promotedId = g_vocations.getPromotedVocation(vocation->getId());
- if (promotedId == VOCATION_NONE) {
- lua_pushnil(L);
- return 1;
- }
- Vocation* promotedVocation = g_vocations.getVocation(promotedId);
- if (promotedVocation && promotedVocation != vocation) {
- pushUserdata<Vocation>(L, promotedVocation);
- setMetatable(L, -1, "Vocation");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // Town
- int LuaScriptInterface::luaTownCreate(lua_State* L)
- {
- // Town(id or name)
- Town* town;
- if (isNumber(L, 2)) {
- town = g_game.map.towns.getTown(getNumber<uint32_t>(L, 2));
- } else if (isString(L, 2)) {
- town = g_game.map.towns.getTown(getString(L, 2));
- } else {
- town = nullptr;
- }
- if (town) {
- pushUserdata<Town>(L, town);
- setMetatable(L, -1, "Town");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTownGetId(lua_State* L)
- {
- // town:getId()
- Town* town = getUserdata<Town>(L, 1);
- if (town) {
- lua_pushnumber(L, town->getID());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTownGetName(lua_State* L)
- {
- // town:getName()
- Town* town = getUserdata<Town>(L, 1);
- if (town) {
- pushString(L, town->getName());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaTownGetTemplePosition(lua_State* L)
- {
- // town:getTemplePosition()
- Town* town = getUserdata<Town>(L, 1);
- if (town) {
- pushPosition(L, town->getTemplePosition());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // House
- int LuaScriptInterface::luaHouseCreate(lua_State* L)
- {
- // House(id)
- House* house = g_game.map.houses.getHouse(getNumber<uint32_t>(L, 2));
- if (house) {
- pushUserdata<House>(L, house);
- setMetatable(L, -1, "House");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetId(lua_State* L)
- {
- // house:getId()
- House* house = getUserdata<House>(L, 1);
- if (house) {
- lua_pushnumber(L, house->getId());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetName(lua_State* L)
- {
- // house:getName()
- House* house = getUserdata<House>(L, 1);
- if (house) {
- pushString(L, house->getName());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetTown(lua_State* L)
- {
- // house:getTown()
- House* house = getUserdata<House>(L, 1);
- if (!house) {
- lua_pushnil(L);
- return 1;
- }
- Town* town = g_game.map.towns.getTown(house->getTownId());
- if (town) {
- pushUserdata<Town>(L, town);
- setMetatable(L, -1, "Town");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetExitPosition(lua_State* L)
- {
- // house:getExitPosition()
- House* house = getUserdata<House>(L, 1);
- if (house) {
- pushPosition(L, house->getEntryPosition());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetRent(lua_State* L)
- {
- // house:getRent()
- House* house = getUserdata<House>(L, 1);
- if (house) {
- lua_pushnumber(L, house->getRent());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetOwnerGuid(lua_State* L)
- {
- // house:getOwnerGuid()
- House* house = getUserdata<House>(L, 1);
- if (house) {
- lua_pushnumber(L, house->getOwner());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseSetOwnerGuid(lua_State* L)
- {
- // house:setOwnerGuid(guid[, updateDatabase = true])
- House* house = getUserdata<House>(L, 1);
- if (house) {
- uint32_t guid = getNumber<uint32_t>(L, 2);
- bool updateDatabase = getBoolean(L, 3, true);
- house->setOwner(guid, updateDatabase);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetBeds(lua_State* L)
- {
- // house:getBeds()
- House* house = getUserdata<House>(L, 1);
- if (!house) {
- lua_pushnil(L);
- return 1;
- }
- const auto& beds = house->getBeds();
- lua_createtable(L, beds.size(), 0);
- int index = 0;
- for (BedItem* bedItem : beds) {
- pushUserdata<Item>(L, bedItem);
- setItemMetatable(L, -1, bedItem);
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetBedCount(lua_State* L)
- {
- // house:getBedCount()
- House* house = getUserdata<House>(L, 1);
- if (house) {
- lua_pushnumber(L, house->getBedCount());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetDoors(lua_State* L)
- {
- // house:getDoors()
- House* house = getUserdata<House>(L, 1);
- if (!house) {
- lua_pushnil(L);
- return 1;
- }
- const auto& doors = house->getDoors();
- lua_createtable(L, doors.size(), 0);
- int index = 0;
- for (Door* door : doors) {
- pushUserdata<Item>(L, door);
- setItemMetatable(L, -1, door);
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetDoorCount(lua_State* L)
- {
- // house:getDoorCount()
- House* house = getUserdata<House>(L, 1);
- if (house) {
- lua_pushnumber(L, house->getDoors().size());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetTiles(lua_State* L)
- {
- // house:getTiles()
- House* house = getUserdata<House>(L, 1);
- if (!house) {
- lua_pushnil(L);
- return 1;
- }
- const auto& tiles = house->getTiles();
- lua_createtable(L, tiles.size(), 0);
- int index = 0;
- for (Tile* tile : tiles) {
- pushUserdata<Tile>(L, tile);
- setMetatable(L, -1, "Tile");
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetTileCount(lua_State* L)
- {
- // house:getTileCount()
- House* house = getUserdata<House>(L, 1);
- if (house) {
- lua_pushnumber(L, house->getTiles().size());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseGetAccessList(lua_State* L)
- {
- // house:getAccessList(listId)
- House* house = getUserdata<House>(L, 1);
- if (!house) {
- lua_pushnil(L);
- return 1;
- }
- std::string list;
- uint32_t listId = getNumber<uint32_t>(L, 2);
- if (house->getAccessList(listId, list)) {
- pushString(L, list);
- } else {
- pushBoolean(L, false);
- }
- return 1;
- }
- int LuaScriptInterface::luaHouseSetAccessList(lua_State* L)
- {
- // house:setAccessList(listId, list)
- House* house = getUserdata<House>(L, 1);
- if (!house) {
- lua_pushnil(L);
- return 1;
- }
- uint32_t listId = getNumber<uint32_t>(L, 2);
- const std::string& list = getString(L, 3);
- house->setAccessList(listId, list);
- pushBoolean(L, true);
- return 1;
- }
- // ItemType
- int LuaScriptInterface::luaItemTypeCreate(lua_State* L)
- {
- // ItemType(id or name)
- uint32_t id;
- if (isNumber(L, 2)) {
- id = getNumber<uint32_t>(L, 2);
- } else {
- id = Item::items.getItemIdByName(getString(L, 2));
- }
- const ItemType& itemType = Item::items[id];
- pushUserdata<const ItemType>(L, &itemType);
- setMetatable(L, -1, "ItemType");
- return 1;
- }
- int LuaScriptInterface::luaItemTypeIsCorpse(lua_State* L)
- {
- // itemType:isCorpse()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushBoolean(L, itemType->corpseType != RACE_NONE);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeIsDoor(lua_State* L)
- {
- // itemType:isDoor()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushBoolean(L, itemType->isDoor());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeIsContainer(lua_State* L)
- {
- // itemType:isContainer()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushBoolean(L, itemType->isContainer());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeIsFluidContainer(lua_State* L)
- {
- // itemType:isFluidContainer()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushBoolean(L, itemType->isFluidContainer());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeIsMovable(lua_State* L)
- {
- // itemType:isMovable()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushBoolean(L, itemType->moveable);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeIsRune(lua_State* L)
- {
- // itemType:isRune()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushBoolean(L, itemType->isRune());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeIsStackable(lua_State* L)
- {
- // itemType:isStackable()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushBoolean(L, itemType->stackable);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeIsReadable(lua_State* L)
- {
- // itemType:isReadable()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushBoolean(L, itemType->canReadText);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeIsWritable(lua_State* L)
- {
- // itemType:isWritable()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushBoolean(L, itemType->canWriteText);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetType(lua_State* L)
- {
- // itemType:getType()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->type);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetId(lua_State* L)
- {
- // itemType:getId()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->id);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetClientId(lua_State* L)
- {
- // itemType:getClientId()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->clientId);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetName(lua_State* L)
- {
- // itemType:getName()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushString(L, itemType->name);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetPluralName(lua_State* L)
- {
- // itemType:getPluralName()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushString(L, itemType->getPluralName());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetArticle(lua_State* L)
- {
- // itemType:getArticle()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushString(L, itemType->article);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetDescription(lua_State* L)
- {
- // itemType:getDescription()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushString(L, itemType->description);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetSlotPosition(lua_State *L)
- {
- // itemType:getSlotPosition()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->slotPosition);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetCharges(lua_State* L)
- {
- // itemType:getCharges()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->charges);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetFluidSource(lua_State* L)
- {
- // itemType:getFluidSource()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->fluidSource);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetCapacity(lua_State* L)
- {
- // itemType:getCapacity()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->maxItems);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetWeight(lua_State* L)
- {
- // itemType:getWeight([count = 1])
- uint16_t count = getNumber<uint16_t>(L, 2, 1);
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (!itemType) {
- lua_pushnil(L);
- return 1;
- }
- uint64_t weight = static_cast<uint64_t>(itemType->weight) * std::max<int32_t>(1, count);
- lua_pushnumber(L, weight);
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetHitChance(lua_State* L)
- {
- // itemType:getHitChance()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->hitChance);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetShootRange(lua_State* L)
- {
- // itemType:getShootRange()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->shootRange);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetAttack(lua_State* L)
- {
- // itemType:getAttack()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->attack);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetDefense(lua_State* L)
- {
- // itemType:getDefense()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->defense);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetExtraDefense(lua_State* L)
- {
- // itemType:getExtraDefense()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->extraDefense);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetArmor(lua_State* L)
- {
- // itemType:getArmor()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->armor);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetWeaponType(lua_State* L)
- {
- // itemType:getWeaponType()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->weaponType);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetElementType(lua_State* L)
- {
- // itemType:getElementType()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (!itemType) {
- lua_pushnil(L);
- return 1;
- }
- auto& abilities = itemType->abilities;
- if (abilities) {
- lua_pushnumber(L, abilities->elementType);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetElementDamage(lua_State* L)
- {
- // itemType:getElementDamage()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (!itemType) {
- lua_pushnil(L);
- return 1;
- }
- auto& abilities = itemType->abilities;
- if (abilities) {
- lua_pushnumber(L, abilities->elementDamage);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetTransformEquipId(lua_State* L)
- {
- // itemType:getTransformEquipId()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->transformEquipTo);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetTransformDeEquipId(lua_State* L)
- {
- // itemType:getTransformDeEquipId()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->transformDeEquipTo);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetDestroyId(lua_State* L)
- {
- // itemType:getDestroyId()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->destroyTo);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetDecayId(lua_State* L)
- {
- // itemType:getDecayId()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->decayTo);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeGetRequiredLevel(lua_State* L)
- {
- // itemType:getRequiredLevel()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- lua_pushnumber(L, itemType->minReqLevel);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaItemTypeHasSubType(lua_State* L)
- {
- // itemType:hasSubType()
- const ItemType* itemType = getUserdata<const ItemType>(L, 1);
- if (itemType) {
- pushBoolean(L, itemType->hasSubType());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // Combat
- int LuaScriptInterface::luaCombatCreate(lua_State* L)
- {
- // Combat()
- pushUserdata<Combat>(L, g_luaEnvironment.createCombatObject(getScriptEnv()->getScriptInterface()));
- setMetatable(L, -1, "Combat");
- return 1;
- }
- int LuaScriptInterface::luaCombatSetParameter(lua_State* L)
- {
- // combat:setParameter(key, value)
- Combat* combat = getUserdata<Combat>(L, 1);
- if (!combat) {
- lua_pushnil(L);
- return 1;
- }
- CombatParam_t key = getNumber<CombatParam_t>(L, 2);
- uint32_t value;
- if (isBoolean(L, 3)) {
- value = getBoolean(L, 3) ? 1 : 0;
- } else {
- value = getNumber<uint32_t>(L, 3);
- }
- combat->setParam(key, value);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaCombatSetFormula(lua_State* L)
- {
- // combat:setFormula(type, mina, minb, maxa, maxb)
- Combat* combat = getUserdata<Combat>(L, 1);
- if (!combat) {
- lua_pushnil(L);
- return 1;
- }
- formulaType_t type = getNumber<formulaType_t>(L, 2);
- double mina = getNumber<double>(L, 3);
- double minb = getNumber<double>(L, 4);
- double maxa = getNumber<double>(L, 5);
- double maxb = getNumber<double>(L, 6);
- combat->setPlayerCombatValues(type, mina, minb, maxa, maxb);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaCombatSetArea(lua_State* L)
- {
- // combat:setArea(area)
- if (getScriptEnv()->getScriptId() != EVENT_ID_LOADING) {
- reportErrorFunc("This function can only be used while loading the script.");
- lua_pushnil(L);
- return 1;
- }
- const AreaCombat* area = g_luaEnvironment.getAreaObject(getNumber<uint32_t>(L, 2));
- if (!area) {
- reportErrorFunc(getErrorDesc(LUA_ERROR_AREA_NOT_FOUND));
- lua_pushnil(L);
- return 1;
- }
- Combat* combat = getUserdata<Combat>(L, 1);
- if (combat) {
- combat->setArea(new AreaCombat(*area));
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCombatSetCondition(lua_State* L)
- {
- // combat:setCondition(condition)
- Condition* condition = getUserdata<Condition>(L, 2);
- Combat* combat = getUserdata<Combat>(L, 1);
- if (combat && condition) {
- combat->setCondition(condition->clone());
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCombatSetCallback(lua_State* L)
- {
- // combat:setCallback(key, function)
- Combat* combat = getUserdata<Combat>(L, 1);
- if (!combat) {
- lua_pushnil(L);
- return 1;
- }
- CallBackParam_t key = getNumber<CallBackParam_t>(L, 2);
- if (!combat->setCallback(key)) {
- lua_pushnil(L);
- return 1;
- }
- CallBack* callback = combat->getCallback(key);
- if (!callback) {
- lua_pushnil(L);
- return 1;
- }
- const std::string& function = getString(L, 3);
- pushBoolean(L, callback->loadCallBack(getScriptEnv()->getScriptInterface(), function));
- return 1;
- }
- int LuaScriptInterface::luaCombatSetOrigin(lua_State* L)
- {
- // combat:setOrigin(origin)
- Combat* combat = getUserdata<Combat>(L, 1);
- if (combat) {
- combat->setOrigin(getNumber<CombatOrigin>(L, 2));
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaCombatExecute(lua_State* L)
- {
- // combat:execute(creature, variant)
- Combat* combat = getUserdata<Combat>(L, 1);
- if (!combat) {
- pushBoolean(L, false);
- return 1;
- }
- Creature* creature = getCreature(L, 2);
- const LuaVariant& variant = getVariant(L, 3);
- switch (variant.type) {
- case VARIANT_NUMBER: {
- Creature* target = g_game.getCreatureByID(variant.number);
- if (!target) {
- pushBoolean(L, false);
- return 1;
- }
- if (combat->hasArea()) {
- combat->doCombat(creature, target->getPosition());
- } else {
- combat->doCombat(creature, target);
- }
- break;
- }
- case VARIANT_POSITION: {
- combat->doCombat(creature, variant.pos);
- break;
- }
- case VARIANT_TARGETPOSITION: {
- if (combat->hasArea()) {
- combat->doCombat(creature, variant.pos);
- } else {
- combat->postCombatEffects(creature, variant.pos);
- g_game.addMagicEffect(variant.pos, CONST_ME_POFF);
- }
- break;
- }
- case VARIANT_STRING: {
- Player* target = g_game.getPlayerByName(variant.text);
- if (!target) {
- pushBoolean(L, false);
- return 1;
- }
- combat->doCombat(creature, target);
- break;
- }
- case VARIANT_NONE: {
- reportErrorFunc(getErrorDesc(LUA_ERROR_VARIANT_NOT_FOUND));
- pushBoolean(L, false);
- return 1;
- }
- default: {
- break;
- }
- }
- pushBoolean(L, true);
- return 1;
- }
- // Condition
- int LuaScriptInterface::luaConditionCreate(lua_State* L)
- {
- // Condition(conditionType[, conditionId = CONDITIONID_COMBAT])
- ConditionType_t conditionType = getNumber<ConditionType_t>(L, 2);
- ConditionId_t conditionId = getNumber<ConditionId_t>(L, 3, CONDITIONID_COMBAT);
- Condition* condition = Condition::createCondition(conditionId, conditionType, 0, 0);
- if (condition) {
- pushUserdata<Condition>(L, condition);
- setMetatable(L, -1, "Condition");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaConditionDelete(lua_State* L)
- {
- // condition:delete()
- Condition** conditionPtr = getRawUserdata<Condition>(L, 1);
- if (conditionPtr && *conditionPtr) {
- delete *conditionPtr;
- *conditionPtr = nullptr;
- }
- return 0;
- }
- int LuaScriptInterface::luaConditionGetId(lua_State* L)
- {
- // condition:getId()
- Condition* condition = getUserdata<Condition>(L, 1);
- if (condition) {
- lua_pushnumber(L, condition->getId());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaConditionGetSubId(lua_State* L)
- {
- // condition:getSubId()
- Condition* condition = getUserdata<Condition>(L, 1);
- if (condition) {
- lua_pushnumber(L, condition->getSubId());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaConditionGetType(lua_State* L)
- {
- // condition:getType()
- Condition* condition = getUserdata<Condition>(L, 1);
- if (condition) {
- lua_pushnumber(L, condition->getType());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaConditionGetIcons(lua_State* L)
- {
- // condition:getIcons()
- Condition* condition = getUserdata<Condition>(L, 1);
- if (condition) {
- lua_pushnumber(L, condition->getIcons());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaConditionGetEndTime(lua_State* L)
- {
- // condition:getEndTime()
- Condition* condition = getUserdata<Condition>(L, 1);
- if (condition) {
- lua_pushnumber(L, condition->getEndTime());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaConditionClone(lua_State* L)
- {
- // condition:clone()
- Condition* condition = getUserdata<Condition>(L, 1);
- if (condition) {
- pushUserdata<Condition>(L, condition->clone());
- setMetatable(L, -1, "Condition");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaConditionGetTicks(lua_State* L)
- {
- // condition:getTicks()
- Condition* condition = getUserdata<Condition>(L, 1);
- if (condition) {
- lua_pushnumber(L, condition->getTicks());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaConditionSetTicks(lua_State* L)
- {
- // condition:setTicks(ticks)
- int32_t ticks = getNumber<int32_t>(L, 2);
- Condition* condition = getUserdata<Condition>(L, 1);
- if (condition) {
- condition->setTicks(ticks);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaConditionSetParameter(lua_State* L)
- {
- // condition:setParameter(key, value)
- Condition* condition = getUserdata<Condition>(L, 1);
- if (!condition) {
- lua_pushnil(L);
- return 1;
- }
- ConditionParam_t key = getNumber<ConditionParam_t>(L, 2);
- int32_t value;
- if (isBoolean(L, 3)) {
- value = getBoolean(L, 3) ? 1 : 0;
- } else {
- value = getNumber<int32_t>(L, 3);
- }
- condition->setParam(key, value);
- pushBoolean(L, true);
- return 1;
- }
- int LuaScriptInterface::luaConditionSetFormula(lua_State* L)
- {
- // condition:setFormula(mina, minb, maxa, maxb)
- double maxb = getNumber<double>(L, 5);
- double maxa = getNumber<double>(L, 4);
- double minb = getNumber<double>(L, 3);
- double mina = getNumber<double>(L, 2);
- ConditionSpeed* condition = dynamic_cast<ConditionSpeed*>(getUserdata<Condition>(L, 1));
- if (condition) {
- condition->setFormulaVars(mina, minb, maxa, maxb);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaConditionSetOutfit(lua_State* L)
- {
- // condition:setOutfit(outfit)
- // condition:setOutfit(lookTypeEx, lookType, lookHead, lookBody, lookLegs, lookFeet[, lookAddons[, lookMount]])
- Outfit_t outfit;
- if (isTable(L, 2)) {
- outfit = getOutfit(L, 2);
- } else {
- outfit.lookMount = getNumber<uint16_t>(L, 9, outfit.lookMount);
- outfit.lookAddons = getNumber<uint8_t>(L, 8, outfit.lookAddons);
- outfit.lookFeet = getNumber<uint8_t>(L, 7);
- outfit.lookLegs = getNumber<uint8_t>(L, 6);
- outfit.lookBody = getNumber<uint8_t>(L, 5);
- outfit.lookHead = getNumber<uint8_t>(L, 4);
- outfit.lookType = getNumber<uint16_t>(L, 3);
- outfit.lookTypeEx = getNumber<uint16_t>(L, 2);
- }
- ConditionOutfit* condition = dynamic_cast<ConditionOutfit*>(getUserdata<Condition>(L, 1));
- if (condition) {
- condition->setOutfit(outfit);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaConditionAddDamage(lua_State* L)
- {
- // condition:addDamage(rounds, time, value)
- int32_t value = getNumber<int32_t>(L, 4);
- int32_t time = getNumber<int32_t>(L, 3);
- int32_t rounds = getNumber<int32_t>(L, 2);
- ConditionDamage* condition = dynamic_cast<ConditionDamage*>(getUserdata<Condition>(L, 1));
- if (condition) {
- pushBoolean(L, condition->addDamage(rounds, time, value));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // MonsterType
- int LuaScriptInterface::luaMonsterTypeCreate(lua_State* L)
- {
- // MonsterType(name)
- MonsterType* monsterType = g_monsters.getMonsterType(getString(L, 2));
- if (monsterType) {
- pushUserdata<MonsterType>(L, monsterType);
- setMetatable(L, -1, "MonsterType");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeIsAttackable(lua_State* L)
- {
- // monsterType:isAttackable()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushBoolean(L, monsterType->isAttackable);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeIsConvinceable(lua_State* L)
- {
- // monsterType:isConvinceable()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushBoolean(L, monsterType->isConvinceable);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeIsSummonable(lua_State* L)
- {
- // monsterType:isSummonable()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushBoolean(L, monsterType->isSummonable);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeIsIllusionable(lua_State* L)
- {
- // monsterType:isIllusionable()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushBoolean(L, monsterType->isIllusionable);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeIsHostile(lua_State* L)
- {
- // monsterType:isHostile()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushBoolean(L, monsterType->isHostile);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeIsPushable(lua_State* L)
- {
- // monsterType:isPushable()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushBoolean(L, monsterType->pushable);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeIsHealthShown(lua_State* L)
- {
- // monsterType:isHealthShown()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushBoolean(L, !monsterType->hiddenHealth);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeIsRewardBoss(lua_State* L)
- {
- // monsterType:isRewardBoss()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushBoolean(L, monsterType->isRewardBoss);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeCanPushItems(lua_State* L)
- {
- // monsterType:canPushItems()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushBoolean(L, monsterType->canPushItems);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeCanPushCreatures(lua_State* L)
- {
- // monsterType:canPushCreatures()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushBoolean(L, monsterType->canPushCreatures);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetName(lua_State* L)
- {
- // monsterType:getName()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushString(L, monsterType->name);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetNameDescription(lua_State* L)
- {
- // monsterType:getNameDescription()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushString(L, monsterType->nameDescription);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetHealth(lua_State* L)
- {
- // monsterType:getHealth()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->health);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetMaxHealth(lua_State* L)
- {
- // monsterType:getMaxHealth()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->healthMax);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetRunHealth(lua_State* L)
- {
- // monsterType:getRunHealth()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->runAwayHealth);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetExperience(lua_State* L)
- {
- // monsterType:getExperience()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->experience);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetCombatImmunities(lua_State* L)
- {
- // monsterType:getCombatImmunities()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->damageImmunities);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetConditionImmunities(lua_State* L)
- {
- // monsterType:getConditionImmunities()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->conditionImmunities);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetAttackList(lua_State* L)
- {
- // monsterType:getAttackList()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (!monsterType) {
- lua_pushnil(L);
- return 1;
- }
- lua_createtable(L, monsterType->attackSpells.size(), 0);
- int index = 0;
- for (const auto& spellBlock : monsterType->attackSpells) {
- lua_createtable(L, 0, 8);
- setField(L, "chance", spellBlock.chance);
- setField(L, "isCombatSpell", spellBlock.combatSpell ? 1 : 0);
- setField(L, "isMelee", spellBlock.isMelee ? 1 : 0);
- setField(L, "minCombatValue", spellBlock.minCombatValue);
- setField(L, "maxCombatValue", spellBlock.maxCombatValue);
- setField(L, "range", spellBlock.range);
- setField(L, "speed", spellBlock.speed);
- pushUserdata<CombatSpell>(L, static_cast<CombatSpell*>(spellBlock.spell));
- lua_setfield(L, -2, "spell");
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetDefenseList(lua_State* L)
- {
- // monsterType:getDefenseList()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (!monsterType) {
- lua_pushnil(L);
- return 1;
- }
- lua_createtable(L, monsterType->defenseSpells.size(), 0);
- int index = 0;
- for (const auto& spellBlock : monsterType->defenseSpells) {
- lua_createtable(L, 0, 8);
- setField(L, "chance", spellBlock.chance);
- setField(L, "isCombatSpell", spellBlock.combatSpell ? 1 : 0);
- setField(L, "isMelee", spellBlock.isMelee ? 1 : 0);
- setField(L, "minCombatValue", spellBlock.minCombatValue);
- setField(L, "maxCombatValue", spellBlock.maxCombatValue);
- setField(L, "range", spellBlock.range);
- setField(L, "speed", spellBlock.speed);
- pushUserdata<CombatSpell>(L, static_cast<CombatSpell*>(spellBlock.spell));
- lua_setfield(L, -2, "spell");
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetElementList(lua_State* L)
- {
- // monsterType:getElementList()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (!monsterType) {
- lua_pushnil(L);
- return 1;
- }
- lua_createtable(L, monsterType->elementMap.size(), 0);
- for (const auto& elementEntry : monsterType->elementMap) {
- lua_pushnumber(L, elementEntry.second);
- lua_rawseti(L, -2, elementEntry.first);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetVoices(lua_State* L)
- {
- // monsterType:getVoices()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (!monsterType) {
- lua_pushnil(L);
- return 1;
- }
- int index = 0;
- lua_createtable(L, monsterType->voiceVector.size(), 0);
- for (const auto& voiceBlock : monsterType->voiceVector) {
- lua_createtable(L, 0, 2);
- setField(L, "text", voiceBlock.text);
- setField(L, "yellText", voiceBlock.yellText);
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetLoot(lua_State* L)
- {
- // monsterType:getLoot()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (!monsterType) {
- lua_pushnil(L);
- return 1;
- }
- static const std::function<void(const std::vector<LootBlock>&)> parseLoot = [&](const std::vector<LootBlock>& lootList) {
- lua_createtable(L, lootList.size(), 0);
- int index = 0;
- for (const auto& lootBlock : lootList) {
- lua_createtable(L, 0, 8);
- setField(L, "itemId", lootBlock.id);
- setField(L, "chance", lootBlock.chance);
- setField(L, "subType", lootBlock.subType);
- setField(L, "maxCount", lootBlock.countmax);
- setField(L, "actionId", lootBlock.actionId);
- setField(L, "text", lootBlock.text);
- pushBoolean(L, lootBlock.unique);
- lua_setfield(L, -2, "unique");
- parseLoot(lootBlock.childLoot);
- lua_setfield(L, -2, "childLoot");
- lua_rawseti(L, -2, ++index);
- }
- };
- parseLoot(monsterType->lootItems);
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetCreatureEvents(lua_State* L)
- {
- // monsterType:getCreatureEvents()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (!monsterType) {
- lua_pushnil(L);
- return 1;
- }
- int index = 0;
- lua_createtable(L, monsterType->scripts.size(), 0);
- for (const std::string& creatureEvent : monsterType->scripts) {
- pushString(L, creatureEvent);
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetSummonList(lua_State* L)
- {
- // monsterType:getSummonList()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (!monsterType) {
- lua_pushnil(L);
- return 1;
- }
- int index = 0;
- lua_createtable(L, monsterType->summons.size(), 0);
- for (const auto& summonBlock : monsterType->summons) {
- lua_createtable(L, 0, 3);
- setField(L, "name", summonBlock.name);
- setField(L, "speed", summonBlock.speed);
- setField(L, "chance", summonBlock.chance);
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetMaxSummons(lua_State* L)
- {
- // monsterType:getMaxSummons()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->maxSummons);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetArmor(lua_State* L)
- {
- // monsterType:getArmor()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->armor);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetDefense(lua_State* L)
- {
- // monsterType:getDefense()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->defense);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetOutfit(lua_State* L)
- {
- // monsterType:getOutfit()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- pushOutfit(L, monsterType->outfit);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetRace(lua_State* L)
- {
- // monsterType:getRace()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->race);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetCorpseId(lua_State* L)
- {
- // monsterType:getCorpseId()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->lookcorpse);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetManaCost(lua_State* L)
- {
- // monsterType:getManaCost()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->manaCost);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetBaseSpeed(lua_State* L)
- {
- // monsterType:getBaseSpeed()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->baseSpeed);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetLight(lua_State* L)
- {
- // monsterType:getLight()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (!monsterType) {
- lua_pushnil(L);
- return 1;
- }
- lua_pushnumber(L, monsterType->lightLevel);
- lua_pushnumber(L, monsterType->lightColor);
- return 2;
- }
- int LuaScriptInterface::luaMonsterTypeGetStaticAttackChance(lua_State* L)
- {
- // monsterType:getStaticAttackChance()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->staticAttackChance);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetTargetDistance(lua_State* L)
- {
- // monsterType:getTargetDistance()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->targetDistance);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetYellChance(lua_State* L)
- {
- // monsterType:getYellChance()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->yellChance);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetYellSpeedTicks(lua_State* L)
- {
- // monsterType:getYellSpeedTicks()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->yellSpeedTicks);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetChangeTargetChance(lua_State* L)
- {
- // monsterType:getChangeTargetChance()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->changeTargetChance);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaMonsterTypeGetChangeTargetSpeed(lua_State* L)
- {
- // monsterType:getChangeTargetSpeed()
- MonsterType* monsterType = getUserdata<MonsterType>(L, 1);
- if (monsterType) {
- lua_pushnumber(L, monsterType->changeTargetSpeed);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- // Party
- int LuaScriptInterface::luaPartyDisband(lua_State* L)
- {
- // party:disband()
- Party** partyPtr = getRawUserdata<Party>(L, 1);
- if (partyPtr && *partyPtr) {
- Party*& party = *partyPtr;
- party->disband();
- party = nullptr;
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartyGetLeader(lua_State* L)
- {
- // party:getLeader()
- Party* party = getUserdata<Party>(L, 1);
- if (!party) {
- lua_pushnil(L);
- return 1;
- }
- Player* leader = party->getLeader();
- if (leader) {
- pushUserdata<Player>(L, leader);
- setMetatable(L, -1, "Player");
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartySetLeader(lua_State* L)
- {
- // party:setLeader(player)
- Player* player = getPlayer(L, 2);
- Party* party = getUserdata<Party>(L, 1);
- if (party && player) {
- pushBoolean(L, party->passPartyLeadership(player));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartyGetMembers(lua_State* L)
- {
- // party:getMembers()
- Party* party = getUserdata<Party>(L, 1);
- if (!party) {
- lua_pushnil(L);
- return 1;
- }
- int index = 0;
- lua_createtable(L, party->getMemberCount(), 0);
- for (Player* player : party->getMembers()) {
- pushUserdata<Player>(L, player);
- setMetatable(L, -1, "Player");
- lua_rawseti(L, -2, ++index);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartyGetMemberCount(lua_State* L)
- {
- // party:getMemberCount()
- Party* party = getUserdata<Party>(L, 1);
- if (party) {
- lua_pushnumber(L, party->getMemberCount());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartyGetInvitees(lua_State* L)
- {
- // party:getInvitees()
- Party* party = getUserdata<Party>(L, 1);
- if (party) {
- lua_createtable(L, party->getInvitationCount(), 0);
- int index = 0;
- for (Player* player : party->getInvitees()) {
- pushUserdata<Player>(L, player);
- setMetatable(L, -1, "Player");
- lua_rawseti(L, -2, ++index);
- }
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartyGetInviteeCount(lua_State* L)
- {
- // party:getInviteeCount()
- Party* party = getUserdata<Party>(L, 1);
- if (party) {
- lua_pushnumber(L, party->getInvitationCount());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartyAddInvite(lua_State* L)
- {
- // party:addInvite(player)
- Player* player = getPlayer(L, 2);
- Party* party = getUserdata<Party>(L, 1);
- if (party && player) {
- pushBoolean(L, party->invitePlayer(*player));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartyRemoveInvite(lua_State* L)
- {
- // party:removeInvite(player)
- Player* player = getPlayer(L, 2);
- Party* party = getUserdata<Party>(L, 1);
- if (party && player) {
- pushBoolean(L, party->removeInvite(*player));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartyAddMember(lua_State* L)
- {
- // party:addMember(player)
- Player* player = getPlayer(L, 2);
- Party* party = getUserdata<Party>(L, 1);
- if (party && player) {
- pushBoolean(L, party->joinParty(*player));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartyRemoveMember(lua_State* L)
- {
- // party:removeMember(player)
- Player* player = getPlayer(L, 2);
- Party* party = getUserdata<Party>(L, 1);
- if (party && player) {
- pushBoolean(L, party->leaveParty(player));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartyIsSharedExperienceActive(lua_State* L)
- {
- // party:isSharedExperienceActive()
- Party* party = getUserdata<Party>(L, 1);
- if (party) {
- pushBoolean(L, party->isSharedExperienceActive());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartyIsSharedExperienceEnabled(lua_State* L)
- {
- // party:isSharedExperienceEnabled()
- Party* party = getUserdata<Party>(L, 1);
- if (party) {
- pushBoolean(L, party->isSharedExperienceEnabled());
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartyShareExperience(lua_State* L)
- {
- // party:shareExperience(experience)
- uint64_t experience = getNumber<uint64_t>(L, 2);
- Party* party = getUserdata<Party>(L, 1);
- if (party) {
- party->shareExperience(experience);
- pushBoolean(L, true);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaPartySetSharedExperience(lua_State* L)
- {
- // party:setSharedExperience(active)
- bool active = getBoolean(L, 2);
- Party* party = getUserdata<Party>(L, 1);
- if (party) {
- pushBoolean(L, party->setSharedExperience(party->getLeader(), active));
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaStoreOfferCreate(lua_State* L)
- {
- // StoreOffer(id)
- if (isNumber(L, 2)) {
- auto offer = g_store->getOfferById(getNumber<uint32_t>(L, 2));
- if (offer) {
- pushUserdata<StoreOffer>(L, &(*offer));
- setMetatable(L, -1, "StoreOffer");
- return 1;
- }
- }
- lua_pushnil(L);
- return 1;
- }
- int LuaScriptInterface::luaStoreOfferGetId(lua_State* L)
- {
- StoreOffer* offer = getUserdata<StoreOffer>(L, 1);
- if (offer) {
- lua_pushnumber(L, offer->id);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- int LuaScriptInterface::luaStoreOfferGetName(lua_State* L)
- {
- // storeOffer:getName()
- StoreOffer* offer = getUserdata<StoreOffer>(L, 1);
- if (offer) {
- pushString(L, offer->name);
- } else {
- lua_pushnil(L);
- }
- return 1;
- }
- //
- LuaEnvironment::LuaEnvironment() :
- LuaScriptInterface("Main Interface"), m_testInterface(nullptr),
- m_lastEventTimerId(1), m_lastCombatId(0), m_lastAreaId(0)
- {
- //
- }
- LuaEnvironment::~LuaEnvironment()
- {
- delete m_testInterface;
- closeState();
- }
- bool LuaEnvironment::initState()
- {
- m_luaState = luaL_newstate();
- if (!m_luaState) {
- return false;
- }
- luaL_openlibs(m_luaState);
- registerFunctions();
- m_runningEventId = EVENT_ID_USER;
- return true;
- }
- bool LuaEnvironment::reInitState()
- {
- // TODO: get children, reload children
- closeState();
- return initState();
- }
- bool LuaEnvironment::closeState()
- {
- if (!m_luaState) {
- return false;
- }
- for (const auto& combatEntry : m_combatIdMap) {
- clearCombatObjects(combatEntry.first);
- }
- for (const auto& areaEntry : m_areaIdMap) {
- clearAreaObjects(areaEntry.first);
- }
- for (auto& timerEntry : m_timerEvents) {
- LuaTimerEventDesc timerEventDesc = std::move(timerEntry.second);
- for (int32_t parameter : timerEventDesc.parameters) {
- luaL_unref(m_luaState, LUA_REGISTRYINDEX, parameter);
- }
- luaL_unref(m_luaState, LUA_REGISTRYINDEX, timerEventDesc.function);
- }
- m_combatIdMap.clear();
- m_areaIdMap.clear();
- m_timerEvents.clear();
- m_cacheFiles.clear();
- lua_close(m_luaState);
- m_luaState = nullptr;
- return true;
- }
- LuaScriptInterface* LuaEnvironment::getTestInterface()
- {
- if (!m_testInterface) {
- m_testInterface = new LuaScriptInterface("Test Interface");
- m_testInterface->initState();
- }
- return m_testInterface;
- }
- Combat* LuaEnvironment::getCombatObject(uint32_t id) const
- {
- auto it = m_combatMap.find(id);
- if (it == m_combatMap.end()) {
- return nullptr;
- }
- return it->second;
- }
- Combat* LuaEnvironment::createCombatObject(LuaScriptInterface* interface)
- {
- Combat* combat = new Combat;
- m_combatMap[++m_lastCombatId] = combat;
- m_combatIdMap[interface].push_back(m_lastCombatId);
- return combat;
- }
- void LuaEnvironment::clearCombatObjects(LuaScriptInterface* interface)
- {
- auto it = m_combatIdMap.find(interface);
- if (it == m_combatIdMap.end()) {
- return;
- }
- for (uint32_t id : it->second) {
- auto itt = m_combatMap.find(id);
- if (itt != m_combatMap.end()) {
- delete itt->second;
- m_combatMap.erase(itt);
- }
- }
- it->second.clear();
- }
- AreaCombat* LuaEnvironment::getAreaObject(uint32_t id) const
- {
- auto it = m_areaMap.find(id);
- if (it == m_areaMap.end()) {
- return nullptr;
- }
- return it->second;
- }
- uint32_t LuaEnvironment::createAreaObject(LuaScriptInterface* interface)
- {
- m_areaMap[++m_lastAreaId] = new AreaCombat;
- m_areaIdMap[interface].push_back(m_lastAreaId);
- return m_lastAreaId;
- }
- void LuaEnvironment::clearAreaObjects(LuaScriptInterface* interface)
- {
- auto it = m_areaIdMap.find(interface);
- if (it == m_areaIdMap.end()) {
- return;
- }
- for (uint32_t id : it->second) {
- auto itt = m_areaMap.find(id);
- if (itt != m_areaMap.end()) {
- delete itt->second;
- m_areaMap.erase(itt);
- }
- }
- it->second.clear();
- }
- void LuaEnvironment::executeTimerEvent(uint32_t eventIndex)
- {
- auto it = m_timerEvents.find(eventIndex);
- if (it == m_timerEvents.end()) {
- return;
- }
- LuaTimerEventDesc timerEventDesc = std::move(it->second);
- m_timerEvents.erase(it);
- //push function
- lua_rawgeti(m_luaState, LUA_REGISTRYINDEX, timerEventDesc.function);
- //push parameters
- for (auto parameter : boost::adaptors::reverse(timerEventDesc.parameters)) {
- lua_rawgeti(m_luaState, LUA_REGISTRYINDEX, parameter);
- }
- //call the function
- if (reserveScriptEnv()) {
- ScriptEnvironment* env = getScriptEnv();
- env->setTimerEvent();
- env->setScriptId(timerEventDesc.scriptId, this);
- callFunction(timerEventDesc.parameters.size());
- } else {
- std::cout << "[Error - LuaScriptInterface::executeTimerEvent] Call stack overflow" << std::endl;
- }
- //free resources
- luaL_unref(m_luaState, LUA_REGISTRYINDEX, timerEventDesc.function);
- for (auto parameter : timerEventDesc.parameters) {
- luaL_unref(m_luaState, LUA_REGISTRYINDEX, parameter);
- }
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement