1A5Tdnc4

1////////////////////////////////////////////////////////////////////////
2// OpenTibia - an opensource roleplaying game
3////////////////////////////////////////////////////////////////////////
4// This program is free software: you can redistribute it and/or modify
5// it under the terms of the GNU General Public License as published by
6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.
8//
9// This program is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12// GNU General Public License for more details.
13//
14// You should have received a copy of the GNU General Public License
15// along with this program.  If not, see <http://www.gnu.org/licenses/>.
16////////////////////////////////////////////////////////////////////////
17#include "otpch.h"
18#include "luascript.h"
19#include "scriptmanager.h"
20
21#include <boost/filesystem.hpp>
22#include <boost/any.hpp>
23#include <iostream>
24#include <iomanip>
25
26#include "player.h"
27#include "item.h"
28#include "teleport.h"
29
30#include "town.h"
31#include "house.h"
32#include "housetile.h"
33
34#include "database.h"
35#include "iologindata.h"
36#include "ioban.h"
37#include "iomapserialize.h"
38
39#include "talkaction.h"
40#include "spells.h"
41#include "combat.h"
42#include "condition.h"
43
44#include "baseevents.h"
45#include "monsters.h"
46#include "raids.h"
47
48#include "configmanager.h"
49#include "vocation.h"
50#include "status.h"
51#include "game.h"
52#include "chat.h"
53
54extern Game g_game;
55extern Monsters g_monsters;
56extern Chat g_chat;
57extern ConfigManager g_config;
58extern Spells* g_spells;
59extern TalkActions* g_talkActions;
60
61enum
62{
63	EVENT_ID_LOADING = 1,
64	EVENT_ID_USER = 1000,
65};
66
67ScriptEnviroment::AreaMap ScriptEnviroment::m_areaMap;
68uint32_t ScriptEnviroment::m_lastAreaId = 0;
69ScriptEnviroment::CombatMap ScriptEnviroment::m_combatMap;
70uint32_t ScriptEnviroment::m_lastCombatId = 0;
71ScriptEnviroment::ConditionMap ScriptEnviroment::m_conditionMap;
72uint32_t ScriptEnviroment::m_lastConditionId = 0;
73
74ScriptEnviroment::ThingMap ScriptEnviroment::m_globalMap;
75ScriptEnviroment::StorageMap ScriptEnviroment::m_storageMap;
76ScriptEnviroment::TempItemListMap ScriptEnviroment::m_tempItems;
77
78ScriptEnviroment::ScriptEnviroment()
79{
80	m_lastUID = 70000;
81	m_loaded = true;
82	reset();
83}
84
85ScriptEnviroment::~ScriptEnviroment()
86{
87	for(CombatMap::iterator it = m_combatMap.begin(); it != m_combatMap.end(); ++it)
88		delete it->second;
89
90	m_combatMap.clear();
91	for(AreaMap::iterator it = m_areaMap.begin(); it != m_areaMap.end(); ++it)
92		delete it->second;
93
94	m_areaMap.clear();
95	reset();
96}
97
98void ScriptEnviroment::reset()
99{
100	m_scriptId = m_callbackId = 0;
101	m_timerEvent = false;
102	m_realPos = Position();
103
104	m_interface = NULL;
105	for(TempItemListMap::iterator mit = m_tempItems.begin(); mit != m_tempItems.end(); ++mit)
106	{
107		ItemList itemList = mit->second;
108		for(ItemList::iterator it = itemList.begin(); it != itemList.end(); ++it)
109		{
110			if((*it)->getParent() == VirtualCylinder::virtualCylinder)
111				g_game.freeThing(*it);
112		}
113	}
114
115	m_tempItems.clear();
116	for(DBResultMap::iterator it = m_tempResults.begin(); it != m_tempResults.end(); ++it)
117	{
118		if(it->second)
119			it->second->free();
120	}
121
122	m_tempResults.clear();
123	m_localMap.clear();
124}
125
126bool ScriptEnviroment::saveGameState()
127{
128	if(!g_config.getBool(ConfigManager::SAVE_GLOBAL_STORAGE))
129		return true;
130
131	Database* db = Database::getInstance();
132	DBQuery query;
133
134	query << "DELETE FROM `global_storage` WHERE `world_id` = " << g_config.getNumber(ConfigManager::WORLD_ID) << ";";
135	if(!db->executeQuery(query.str()))
136		return false;
137
138	DBInsert query_insert(db);
139	query_insert.setQuery("INSERT INTO `global_storage` (`key`, `world_id`, `value`) VALUES ");
140	for(StorageMap::const_iterator it = m_storageMap.begin(); it != m_storageMap.end(); ++it)
141	{
142		char buffer[25 + it->second.length()];
143		sprintf(buffer, "%u, %u, %s", it->first, g_config.getNumber(ConfigManager::WORLD_ID), db->escapeString(it->second).c_str());
144		if(!query_insert.addRow(buffer))
145			return false;
146	}
147
148	return query_insert.execute();
149}
150
151bool ScriptEnviroment::loadGameState()
152{
153	Database* db = Database::getInstance();
154	DBResult* result;
155
156	DBQuery query;
157	query << "SELECT `key`, `value` FROM `global_storage` WHERE `world_id` = " << g_config.getNumber(ConfigManager::WORLD_ID) << ";";
158	if((result = db->storeQuery(query.str())))
159	{
160		do
161			m_storageMap[result->getDataInt("key")] = result->getDataString("value");
162		while(result->next());
163		result->free();
164	}
165
166	query.str("");
167	return true;
168}
169
170bool ScriptEnviroment::setCallbackId(int32_t callbackId, LuaScriptInterface* interface)
171{
172	if(!m_callbackId)
173	{
174		m_callbackId = callbackId;
175		m_interface = interface;
176		return true;
177	}
178
179	//nested callbacks are not allowed
180	if(m_interface)
181		m_interface->errorEx("Nested callbacks!");
182
183	return false;
184}
185
186void ScriptEnviroment::getInfo(int32_t& scriptId, std::string& desc, LuaScriptInterface*& interface, int32_t& callbackId, bool& timerEvent)
187{
188	scriptId = m_scriptId;
189	desc = m_eventdesc;
190	interface = m_interface;
191	callbackId = m_callbackId;
192	timerEvent = m_timerEvent;
193}
194
195void ScriptEnviroment::addUniqueThing(Thing* thing)
196{
197	Item* item = thing->getItem();
198	if(!item || !item->getUniqueId())
199		return;
200
201	if(m_globalMap[item->getUniqueId()])
202	{
203		if(item->getActionId() != 2000) //scripted quest system
204			std::cout << "Duplicate uniqueId " << item->getUniqueId() << std::endl;
205	}
206	else
207		m_globalMap[item->getUniqueId()] = thing;
208}
209
210void ScriptEnviroment::removeUniqueThing(Thing* thing)
211{
212	Item* item = thing->getItem();
213	if(!item || !item->getUniqueId())
214		return;
215
216	ThingMap::iterator it = m_globalMap.find(item->getUniqueId());
217	if(it != m_globalMap.end())
218		m_globalMap.erase(it);
219}
220
221uint32_t ScriptEnviroment::addThing(Thing* thing)
222{
223	if(!thing || thing->isRemoved())
224		return 0;
225
226	for(ThingMap::iterator it = m_localMap.begin(); it != m_localMap.end(); ++it)
227	{
228		if(it->second == thing)
229			return it->first;
230	}
231
232	if(Creature* creature = thing->getCreature())
233	{
234		m_localMap[creature->getID()] = thing;
235		return creature->getID();
236	}
237
238	if(Item* item = thing->getItem())
239	{
240		uint32_t tmp = item->getUniqueId();
241		if(tmp)
242		{
243			m_localMap[tmp] = thing;
244			return tmp;
245		}
246	}
247
248	while(m_localMap.find(m_lastUID) != m_localMap.end())
249		++m_lastUID;
250
251	m_localMap[m_lastUID] = thing;
252	return m_lastUID;
253}
254
255void ScriptEnviroment::insertThing(uint32_t uid, Thing* thing)
256{
257	if(!m_localMap[uid])
258		m_localMap[uid] = thing;
259	else
260		std::cout << "[Error - ScriptEnviroment::insertThing] Thing uid already taken" << std::endl;
261}
262
263Thing* ScriptEnviroment::getThingByUID(uint32_t uid)
264{
265	Thing* tmp = m_localMap[uid];
266	if(tmp && !tmp->isRemoved())
267		return tmp;
268
269	tmp = m_globalMap[uid];
270	if(tmp && !tmp->isRemoved())
271		return tmp;
272
273	if(uid >= 0x10000000)
274	{
275		tmp = g_game.getCreatureByID(uid);
276		if(tmp && !tmp->isRemoved())
277		{
278			m_localMap[uid] = tmp;
279			return tmp;
280		}
281	}
282
283	return NULL;
284}
285
286Item* ScriptEnviroment::getItemByUID(uint32_t uid)
287{
288	if(Thing* tmp = getThingByUID(uid))
289	{
290		if(Item* item = tmp->getItem())
291			return item;
292	}
293
294	return NULL;
295}
296
297Container* ScriptEnviroment::getContainerByUID(uint32_t uid)
298{
299	if(Item* tmp = getItemByUID(uid))
300	{
301		if(Container* container = tmp->getContainer())
302			return container;
303	}
304
305	return NULL;
306}
307
308Creature* ScriptEnviroment::getCreatureByUID(uint32_t uid)
309{
310	if(Thing* tmp = getThingByUID(uid))
311	{
312		if(Creature* creature = tmp->getCreature())
313			return creature;
314	}
315
316	return NULL;
317}
318
319Player* ScriptEnviroment::getPlayerByUID(uint32_t uid)
320{
321	if(Thing* tmp = getThingByUID(uid))
322	{
323		if(Creature* creature = tmp->getCreature())
324		{
325			if(Player* player = creature->getPlayer())
326				return player;
327		}
328	}
329
330	return NULL;
331}
332
333void ScriptEnviroment::removeThing(uint32_t uid)
334{
335	ThingMap::iterator it;
336	it = m_localMap.find(uid);
337	if(it != m_localMap.end())
338		m_localMap.erase(it);
339
340	it = m_globalMap.find(uid);
341	if(it != m_globalMap.end())
342		m_globalMap.erase(it);
343}
344
345uint32_t ScriptEnviroment::addCombatArea(CombatArea* area)
346{
347	uint32_t newAreaId = m_lastAreaId + 1;
348	m_areaMap[newAreaId] = area;
349
350	m_lastAreaId++;
351	return newAreaId;
352}
353
354CombatArea* ScriptEnviroment::getCombatArea(uint32_t areaId)
355{
356	AreaMap::const_iterator it = m_areaMap.find(areaId);
357	if(it != m_areaMap.end())
358		return it->second;
359
360	return NULL;
361}
362
363uint32_t ScriptEnviroment::addCombatObject(Combat* combat)
364{
365	uint32_t newCombatId = m_lastCombatId + 1;
366	m_combatMap[newCombatId] = combat;
367
368	m_lastCombatId++;
369	return newCombatId;
370}
371
372Combat* ScriptEnviroment::getCombatObject(uint32_t combatId)
373{
374	CombatMap::iterator it = m_combatMap.find(combatId);
375	if(it != m_combatMap.end())
376		return it->second;
377
378	return NULL;
379}
380
381uint32_t ScriptEnviroment::addConditionObject(Condition* condition)
382{
383	uint32_t newConditionId = m_lastConditionId + 1;
384	m_conditionMap[newConditionId] = condition;
385
386	m_lastConditionId++;
387	return m_lastConditionId;
388}
389
390Condition* ScriptEnviroment::getConditionObject(uint32_t conditionId)
391{
392	ConditionMap::iterator it = m_conditionMap.find(conditionId);
393	if(it != m_conditionMap.end())
394		return it->second;
395
396	return NULL;
397}
398
399void ScriptEnviroment::addTempItem(ScriptEnviroment* env, Item* item)
400{
401	m_tempItems[env].push_back(item);
402}
403
404void ScriptEnviroment::removeTempItem(ScriptEnviroment* env, Item* item)
405{
406	ItemList itemList = m_tempItems[env];
407	ItemList::iterator it = std::find(itemList.begin(), itemList.end(), item);
408	if(it != itemList.end())
409		itemList.erase(it);
410}
411
412void ScriptEnviroment::removeTempItem(Item* item)
413{
414	for(TempItemListMap::iterator mit = m_tempItems.begin(); mit != m_tempItems.end(); ++mit)
415	{
416		ItemList itemList = mit->second;
417		ItemList::iterator it = std::find(itemList.begin(), itemList.end(), item);
418		if(it != itemList.end())
419			itemList.erase(it);
420	}
421}
422
423uint32_t ScriptEnviroment::addResult(DBResult* res)
424{
425	uint32_t lastId = 0;
426	while(m_tempResults.find(lastId) != m_tempResults.end())
427		lastId++;
428
429	m_tempResults[lastId] = res;
430	return lastId;
431}
432
433bool ScriptEnviroment::removeResult(uint32_t id)
434{
435	DBResultMap::iterator it = m_tempResults.find(id);
436	if(it == m_tempResults.end())
437		return false;
438
439	if(it->second)
440		it->second->free();
441
442	m_tempResults.erase(it);
443	return true;
444}
445
446DBResult* ScriptEnviroment::getResultByID(uint32_t id)
447{
448	DBResultMap::iterator it = m_tempResults.find(id);
449	if(it != m_tempResults.end())
450		return it->second;
451
452	return NULL;
453}
454
455bool ScriptEnviroment::getStorage(const uint32_t key, std::string& value) const
456{
457	StorageMap::const_iterator it = m_storageMap.find(key);
458	if(it != m_storageMap.end())
459	{
460		value = it->second;
461		return true;
462	}
463
464	value = "-1";
465	return false;
466}
467
468void ScriptEnviroment::streamVariant(std::stringstream& stream, const std::string& local, const LuaVariant& var)
469{
470	if(!local.empty())
471		stream << "local " << local << " = {" << std::endl;
472
473	stream << "type = " << var.type;
474	switch(var.type)
475	{
476		case VARIANT_NUMBER:
477			stream << "," << std::endl << "number = " << var.number;
478			break;
479		case VARIANT_STRING:
480			stream << "," << std::endl << "string = \"" << var.text << "\"";
481			break;
482		case VARIANT_TARGETPOSITION:
483		case VARIANT_POSITION:
484		{
485			stream << "," << std::endl;
486			streamPosition(stream, "pos", var.pos);
487			break;
488		}
489		case VARIANT_NONE:
490		default:
491			break;
492	}
493
494	if(!local.empty())
495		stream << std::endl << "}" << std::endl;
496}
497
498void ScriptEnviroment::streamThing(std::stringstream& stream, const std::string& local, Thing* thing, uint32_t id/* = 0*/)
499{
500	if(!local.empty())
501		stream << "local " << local << " = {" << std::endl;
502
503	if(thing && thing->getItem())
504	{
505		const Item* item = thing->getItem();
506		if(!id)
507			id = addThing(thing);
508
509		stream << "uid = " << id << "," << std::endl;
510		stream << "itemid = " << item->getID() << "," << std::endl;
511		if(item->hasSubType())
512			stream << "type = " << item->getSubType() << "," << std::endl;
513		else
514			stream << "type = 0," << std::endl;
515
516		stream << "actionid = " << item->getActionId() << std::endl;
517	}
518	else if(thing && thing->getCreature())
519	{
520		const Creature* creature = thing->getCreature();
521		if(!id)
522			id = creature->getID();
523
524		stream << "uid = " << id << "," << std::endl;
525		stream << "itemid = 1," << std::endl;
526		if(creature->getPlayer())
527			stream << "type = 1," << std::endl;
528		else if(creature->getMonster())
529			stream << "type = 2," << std::endl;
530		else
531			stream << "type = 3," << std::endl;
532
533		if(const Player* player = creature->getPlayer())
534			stream << "actionid = " << player->getGUID() << "," << std::endl;
535		else
536			stream << "actionid = 0" << std::endl;
537	}
538	else
539	{
540		stream << "uid = 0," << std::endl;
541		stream << "itemid = 0," << std::endl;
542		stream << "type = 0," << std::endl;
543		stream << "actionid = 0" << std::endl;
544	}
545
546	if(!local.empty())
547		stream << "}" << std::endl;
548}
549
550void ScriptEnviroment::streamPosition(std::stringstream& stream, const std::string& local, const Position& position, uint32_t stackpos)
551{
552	if(!local.empty())
553		stream << "local " << local << " = {" << std::endl;
554
555	stream << "x = " << position.x << "," << std::endl;
556	stream << "y = " << position.y << "," << std::endl;
557	stream << "z = " << position.z << "," << std::endl;
558
559	stream << "stackpos = " << stackpos << std::endl;
560	if(!local.empty())
561		stream << "}" << std::endl;
562}
563
564void ScriptEnviroment::streamOutfit(std::stringstream& stream, const std::string& local, const Outfit_t& outfit)
565{
566	if(!local.empty())
567		stream << "local " << local << " = {" << std::endl;
568
569	stream << "lookType = " << outfit.lookType << "," << std::endl;
570	stream << "lookTypeEx = " << outfit.lookTypeEx << "," << std::endl;
571
572	stream << "lookHead = " << outfit.lookHead << "," << std::endl;
573	stream << "lookBody = " << outfit.lookBody << "," << std::endl;
574	stream << "lookLegs = " << outfit.lookLegs << "," << std::endl;
575	stream << "lookFeet = " << outfit.lookFeet << "," << std::endl;
576
577	stream << "lookAddons = " << outfit.lookAddons << std::endl;
578	if(!local.empty())
579		stream << "}" << std::endl;
580}
581
582std::string LuaScriptInterface::getError(ErrorCode_t code)
583{
584	switch(code)
585	{
586		case LUA_ERROR_PLAYER_NOT_FOUND:
587			return "Player not found";
588		case LUA_ERROR_MONSTER_NOT_FOUND:
589			return "Monster not found";
590		case LUA_ERROR_NPC_NOT_FOUND:
591			return "NPC not found";
592		case LUA_ERROR_CREATURE_NOT_FOUND:
593			return "Creature not found";
594		case LUA_ERROR_ITEM_NOT_FOUND:
595			return "Item not found";
596		case LUA_ERROR_THING_NOT_FOUND:
597			return "Thing not found";
598		case LUA_ERROR_TILE_NOT_FOUND:
599			return "Tile not found";
600		case LUA_ERROR_HOUSE_NOT_FOUND:
601			return "House not found";
602		case LUA_ERROR_COMBAT_NOT_FOUND:
603			return "Combat not found";
604		case LUA_ERROR_CONDITION_NOT_FOUND:
605			return "Condition not found";
606		case LUA_ERROR_AREA_NOT_FOUND:
607			return "Area not found";
608		case LUA_ERROR_CONTAINER_NOT_FOUND:
609			return "Container not found";
610		case LUA_ERROR_VARIANT_NOT_FOUND:
611			return "Variant not found";
612		case LUA_ERROR_VARIANT_UNKNOWN:
613			return "Unknown variant type";
614		case LUA_ERROR_SPELL_NOT_FOUND:
615			return "Spell not found";
616		default:
617			break;
618	}
619
620	return "Invalid error code!";
621}
622
623ScriptEnviroment LuaScriptInterface::m_scriptEnv[21];
624int32_t LuaScriptInterface::m_scriptEnvIndex = -1;
625
626LuaScriptInterface::LuaScriptInterface(std::string interfaceName)
627{
628	m_luaState = NULL;
629	m_interfaceName = interfaceName;
630	m_lastEventTimerId = 1000;
631}
632
633LuaScriptInterface::~LuaScriptInterface()
634{
635	closeState();
636}
637
638bool LuaScriptInterface::reInitState()
639{
640	closeState();
641	return initState();
642}
643
644bool LuaScriptInterface::loadBuffer(const std::string& text, Npc* npc/* = NULL*/)
645{
646	//loads buffer as a chunk at stack top
647	int32_t ret = luaL_loadbuffer(m_luaState, text.c_str(), text.length(), "loadBuffer");
648	if(ret)
649	{
650		m_lastError = popString(m_luaState);
651		error(NULL, m_lastError);
652		return false;
653	}
654
655	//check that it is loaded as a function
656	if(!lua_isfunction(m_luaState, -1))
657		return false;
658
659	m_loadingFile = "buffer";
660	reserveEnv();
661
662	ScriptEnviroment* env = getEnv();
663	env->setScriptId(EVENT_ID_LOADING, this);
664	env->setNpc(npc);
665
666	//execute it
667	ret = lua_pcall(m_luaState, 0, 0, 0);
668	if(ret)
669	{
670		error(NULL, popString(m_luaState));
671		releaseEnv();
672		return false;
673	}
674
675	releaseEnv();
676	return true;
677}
678
679bool LuaScriptInterface::loadFile(const std::string& file, Npc* npc/* = NULL*/)
680{
681	//loads file as a chunk at stack top
682	int32_t ret = luaL_loadfile(m_luaState, file.c_str());
683	if(ret)
684	{
685		m_lastError = popString(m_luaState);
686		std::cout << "[Error - LuaScriptInterface::loadFile] " << m_lastError << std::endl;
687		return false;
688	}
689
690	//check that it is loaded as a function
691	if(!lua_isfunction(m_luaState, -1))
692		return false;
693
694	m_loadingFile = file;
695	reserveEnv();
696
697	ScriptEnviroment* env = getEnv();
698	env->setScriptId(EVENT_ID_LOADING, this);
699	env->setNpc(npc);
700
701	//execute it
702	ret = lua_pcall(m_luaState, 0, 0, 0);
703	if(ret)
704	{
705		error(NULL, popString(m_luaState));
706		releaseEnv();
707		return false;
708	}
709
710	releaseEnv();
711	return true;
712}
713
714bool LuaScriptInterface::loadDirectory(const std::string& dir, Npc* npc/* = NULL*/)
715{
716	StringVec files;
717	for(boost::filesystem::directory_iterator it(dir), end; it != end; ++it)
718	{
719		std::string s = it->path().filename().string();
720		if(!boost::filesystem::is_directory(it->status()) && (s.size() > 4 ? s.substr(s.size() - 4) : "") == ".lua")
721			files.push_back(s);
722	}
723
724	std::sort(files.begin(), files.end());
725	for(StringVec::iterator it = files.begin(); it != files.end(); ++it)
726	{
727		if(!loadFile(dir + (*it), npc))
728			return false;
729	}
730
731	return true;
732}
733
734int32_t LuaScriptInterface::getEvent(const std::string& eventName)
735{
736	//get our events table
737	lua_getfield(m_luaState, LUA_REGISTRYINDEX, "EVENTS");
738	if(!lua_istable(m_luaState, -1))
739	{
740		lua_pop(m_luaState, 1);
741		return -1;
742	}
743
744	//get current event function pointer
745	lua_getglobal(m_luaState, eventName.c_str());
746	if(!lua_isfunction(m_luaState, -1))
747	{
748		lua_pop(m_luaState, 1);
749		return -1;
750	}
751
752	//save in our events table
753	lua_pushnumber(m_luaState, m_runningEventId);
754	lua_pushvalue(m_luaState, -2);
755
756	lua_rawset(m_luaState, -4);
757	lua_pop(m_luaState, 2);
758
759	//reset global value of this event
760	lua_pushnil(m_luaState);
761	lua_setglobal(m_luaState, eventName.c_str());
762
763	m_cacheFiles[m_runningEventId] = m_loadingFile + ":" + eventName;
764	++m_runningEventId;
765	return m_runningEventId - 1;
766}
767
768std::string LuaScriptInterface::getScript(int32_t scriptId)
769{
770	const static std::string tmp = "(Unknown script file)";
771	if(scriptId != EVENT_ID_LOADING)
772	{
773		ScriptsCache::iterator it = m_cacheFiles.find(scriptId);
774		if(it != m_cacheFiles.end())
775			return it->second;
776
777		return tmp;
778	}
779
780	return m_loadingFile;
781}
782
783void LuaScriptInterface::error(const char* function, const std::string& desc)
784{
785	int32_t script, callback;
786	bool timer;
787	std::string event;
788
789	LuaScriptInterface* interface;
790	getEnv()->getInfo(script, event, interface, callback, timer);
791	if(interface)
792	{
793		std::cout << std::endl << "[Error - " << interface->getName() << "] " << std::endl;
794		if(callback)
795			std::cout << "In a callback: " << interface->getScript(callback) << std::endl;
796
797		if(timer)
798			std::cout << (callback ? "from" : "In") << " a timer event called from: " << std::endl;
799
800		std::cout << interface->getScript(script) << std::endl << "Description: ";
801	}
802	else
803		std::cout << std::endl << "[Lua Error] ";
804
805	std::cout << event << std::endl;
806	if(function)
807		std::cout << "(" << function << ") ";
808
809	std::cout << desc << std::endl;
810}
811
812bool LuaScriptInterface::pushFunction(int32_t function)
813{
814	lua_getfield(m_luaState, LUA_REGISTRYINDEX, "EVENTS");
815	if(lua_istable(m_luaState, -1))
816	{
817		lua_pushnumber(m_luaState, function);
818		lua_rawget(m_luaState, -2);
819
820		lua_remove(m_luaState, -2);
821		if(lua_isfunction(m_luaState, -1))
822			return true;
823	}
824
825	return false;
826}
827
828bool LuaScriptInterface::initState()
829{
830	m_luaState = luaL_newstate();
831	if(!m_luaState)
832		return false;
833
834	luaL_openlibs(m_luaState);
835	registerFunctions();
836	if(!loadDirectory(getFilePath(FILE_TYPE_OTHER, "lib/"), NULL))
837		std::cout << "[Warning - LuaScriptInterface::initState] Cannot load " << getFilePath(FILE_TYPE_OTHER, "lib/") << std::endl;
838
839	lua_newtable(m_luaState);
840	lua_setfield(m_luaState, LUA_REGISTRYINDEX, "EVENTS");
841
842	m_runningEventId = EVENT_ID_USER;
843	return true;
844}
845
846bool LuaScriptInterface::closeState()
847{
848	if(!m_luaState)
849		return false;
850
851	m_cacheFiles.clear();
852	for(LuaTimerEvents::iterator it = m_timerEvents.begin(); it != m_timerEvents.end(); ++it)
853	{
854		for(std::list<int32_t>::iterator lt = it->second.parameters.begin(); lt != it->second.parameters.end(); ++lt)
855			luaL_unref(m_luaState, LUA_REGISTRYINDEX, *lt);
856
857		it->second.parameters.clear();
858		luaL_unref(m_luaState, LUA_REGISTRYINDEX, it->second.function);
859	}
860
861	m_timerEvents.clear();
862	lua_close(m_luaState);
863	return true;
864}
865
866void LuaScriptInterface::executeTimer(uint32_t eventIndex)
867{
868	LuaTimerEvents::iterator it = m_timerEvents.find(eventIndex);
869	if(it != m_timerEvents.end())
870	{
871		//push function
872		lua_rawgeti(m_luaState, LUA_REGISTRYINDEX, it->second.function);
873
874		//push parameters
875		for(std::list<int32_t>::reverse_iterator rt = it->second.parameters.rbegin(); rt != it->second.parameters.rend(); ++rt)
876			lua_rawgeti(m_luaState, LUA_REGISTRYINDEX, *rt);
877
878		//call the function
879		if(reserveEnv())
880		{
881			ScriptEnviroment* env = getEnv();
882			env->setTimerEvent();
883			env->setScriptId(it->second.scriptId, this);
884
885			callFunction(it->second.parameters.size());
886			releaseEnv();
887		}
888		else
889			std::cout << "[Error] Call stack overflow. LuaScriptInterface::executeTimer" << std::endl;
890
891		//free resources
892		for(std::list<int32_t>::iterator lt = it->second.parameters.begin(); lt != it->second.parameters.end(); ++lt)
893			luaL_unref(m_luaState, LUA_REGISTRYINDEX, *lt);
894
895		it->second.parameters.clear();
896		luaL_unref(m_luaState, LUA_REGISTRYINDEX, it->second.function);
897		m_timerEvents.erase(it);
898	}
899}
900
901int32_t LuaScriptInterface::handleFunction(lua_State* L)
902{
903	lua_getfield(L, LUA_GLOBALSINDEX, "debug");
904	if(!lua_istable(L, -1))
905	{
906		lua_pop(L, 1);
907		return 1;
908	}
909
910	lua_getfield(L, -1, "traceback");
911	if(!lua_isfunction(L, -1))
912	{
913		lua_pop(L, 2);
914		return 1;
915	}
916
917	lua_pushvalue(L, 1);
918	lua_pushinteger(L, 2);
919
920	lua_call(L, 2, 1);
921	return 1;
922}
923
924bool LuaScriptInterface::callFunction(uint32_t params)
925{
926	int32_t size = lua_gettop(m_luaState), handler = lua_gettop(m_luaState) - params;
927	lua_pushcfunction(m_luaState, handleFunction);
928
929	bool result = false;
930	lua_insert(m_luaState, handler);
931	if(lua_pcall(m_luaState, params, 1, handler))
932		LuaScriptInterface::error(NULL, LuaScriptInterface::popString(m_luaState));
933	else
934		result = (int32_t)LuaScriptInterface::popBoolean(m_luaState);
935
936	lua_remove(m_luaState, handler);
937	if((lua_gettop(m_luaState) + (int32_t)params + 1) != size)
938		LuaScriptInterface::error(NULL, "Stack size changed!");
939
940	return result;
941}
942
943void LuaScriptInterface::dumpStack(lua_State* L/* = NULL*/)
944{
945	if(!L)
946		L = m_luaState;
947
948	int32_t stack = lua_gettop(L);
949	if(!stack)
950		return;
951
952	std::cout << "Stack size: " << stack << std::endl;
953	for(int32_t i = 1; i <= stack ; ++i)
954		std::cout << lua_typename(m_luaState, lua_type(m_luaState, -i)) << " " << lua_topointer(m_luaState, -i) << std::endl;
955}
956
957void LuaScriptInterface::pushVariant(lua_State* L, const LuaVariant& var)
958{
959	lua_newtable(L);
960	setField(L, "type", var.type);
961	switch(var.type)
962	{
963		case VARIANT_NUMBER:
964			setField(L, "number", var.number);
965			break;
966		case VARIANT_STRING:
967			setField(L, "string", var.text);
968			break;
969		case VARIANT_TARGETPOSITION:
970		case VARIANT_POSITION:
971		{
972			lua_pushstring(L, "pos");
973			pushPosition(L, var.pos);
974			pushTable(L);
975			break;
976		}
977		case VARIANT_NONE:
978			break;
979	}
980}
981
982void LuaScriptInterface::pushThing(lua_State* L, Thing* thing, uint32_t id/* = 0*/)
983{
984	lua_newtable(L);
985	if(thing && thing->getItem())
986	{
987		const Item* item = thing->getItem();
988		if(!id)
989			id = getEnv()->addThing(thing);
990
991		setField(L, "uid", id);
992		setField(L, "itemid", item->getID());
993		if(item->hasSubType())
994			setField(L, "type", item->getSubType());
995		else
996			setField(L, "type", 0);
997
998		setField(L, "actionid", item->getActionId());
999	}
1000	else if(thing && thing->getCreature())
1001	{
1002		const Creature* creature = thing->getCreature();
1003		if(!id)
1004			id = creature->getID();
1005
1006		setField(L, "uid", id);
1007		setField(L, "itemid", 1);
1008		if(creature->getPlayer())
1009			setField(L, "type", 1);
1010		else if(creature->getMonster())
1011			setField(L, "type", 2);
1012		else
1013			setField(L, "type", 3);
1014
1015		if(const Player* player = creature->getPlayer())
1016			setField(L, "actionid", player->getGUID());
1017		else
1018			setField(L, "actionid", 0);
1019	}
1020	else
1021	{
1022		setField(L, "uid", 0);
1023		setField(L, "itemid", 0);
1024		setField(L, "type", 0);
1025		setField(L, "actionid", 0);
1026	}
1027}
1028
1029void LuaScriptInterface::pushPosition(lua_State* L, const Position& position, uint32_t stackpos)
1030{
1031	lua_newtable(L);
1032	setField(L, "x", position.x);
1033	setField(L, "y", position.y);
1034	setField(L, "z", position.z);
1035	setField(L, "stackpos", stackpos);
1036}
1037
1038void LuaScriptInterface::pushOutfit(lua_State* L, const Outfit_t& outfit)
1039{
1040	lua_newtable(L);
1041	setField(L, "lookType", outfit.lookType);
1042	setField(L, "lookTypeEx", outfit.lookTypeEx);
1043	setField(L, "lookHead", outfit.lookHead);
1044	setField(L, "lookBody", outfit.lookBody);
1045	setField(L, "lookLegs", outfit.lookLegs);
1046	setField(L, "lookFeet", outfit.lookFeet);
1047	setField(L, "lookAddons", outfit.lookAddons);
1048}
1049
1050void LuaScriptInterface::pushCallback(lua_State* L, int32_t callback)
1051{
1052	lua_rawgeti(L, LUA_REGISTRYINDEX, callback);
1053}
1054
1055LuaVariant LuaScriptInterface::popVariant(lua_State* L)
1056{
1057	LuaVariant var;
1058	var.type = (LuaVariantType_t)getField(L, "type");
1059	switch(var.type)
1060	{
1061		case VARIANT_NUMBER:
1062			var.number = getFieldUnsigned(L, "number");
1063			break;
1064		case VARIANT_STRING:
1065			var.text = getField(L, "string");
1066			break;
1067		case VARIANT_POSITION:
1068		case VARIANT_TARGETPOSITION:
1069		{
1070			lua_pushstring(L, "pos");
1071			lua_gettable(L, -2);
1072			popPosition(L, var.pos);
1073			break;
1074		}
1075		default:
1076			var.type = VARIANT_NONE;
1077			break;
1078	}
1079
1080	lua_pop(L, 1); //table
1081	return var;
1082}
1083
1084void LuaScriptInterface::popPosition(lua_State* L, PositionEx& position)
1085{
1086	if(!lua_isboolean(L, -1))
1087	{
1088		position.x = getField(L, "x");
1089		position.y = getField(L, "y");
1090		position.z = getField(L, "z");
1091		position.stackpos = getField(L, "stackpos");
1092	}
1093	else
1094		position = PositionEx();
1095
1096	lua_pop(L, 1); //table
1097}
1098
1099void LuaScriptInterface::popPosition(lua_State* L, Position& position, uint32_t& stackpos)
1100{
1101	stackpos = 0;
1102	if(!lua_isboolean(L, -1))
1103	{
1104		position.x = getField(L, "x");
1105		position.y = getField(L, "y");
1106		position.z = getField(L, "z");
1107		stackpos = getField(L, "stackpos");
1108	}
1109	else
1110		position = Position();
1111
1112	lua_pop(L, 1); //table
1113}
1114
1115bool LuaScriptInterface::popBoolean(lua_State* L)
1116{
1117	lua_pop(L, 1);
1118	return lua_toboolean(L, 0);
1119}
1120
1121int64_t LuaScriptInterface::popNumber(lua_State* L)
1122{
1123	lua_pop(L, 1);
1124	if(lua_isboolean(L, 0))
1125		return (int64_t)lua_toboolean(L, 0);
1126
1127	return (int64_t)lua_tonumber(L, 0);
1128}
1129
1130double LuaScriptInterface::popFloatNumber(lua_State* L)
1131{
1132	lua_pop(L, 1);
1133	return lua_tonumber(L, 0);
1134}
1135
1136std::string LuaScriptInterface::popString(lua_State* L)
1137{
1138	lua_pop(L, 1);
1139	const char* str = lua_tostring(L, 0);
1140	if(!str || !strlen(str))
1141		return std::string();
1142
1143	return str;
1144}
1145
1146int32_t LuaScriptInterface::popCallback(lua_State* L)
1147{
1148	return luaL_ref(L, LUA_REGISTRYINDEX);
1149}
1150
1151Outfit_t LuaScriptInterface::popOutfit(lua_State* L)
1152{
1153	Outfit_t outfit;
1154	outfit.lookAddons = getField(L, "lookAddons");
1155
1156	outfit.lookFeet = getField(L, "lookFeet");
1157	outfit.lookLegs = getField(L, "lookLegs");
1158	outfit.lookBody = getField(L, "lookBody");
1159	outfit.lookHead = getField(L, "lookHead");
1160
1161	outfit.lookTypeEx = getField(L, "lookTypeEx");
1162	outfit.lookType = getField(L, "lookType");
1163
1164	lua_pop(L, 1); //table
1165	return outfit;
1166}
1167
1168void LuaScriptInterface::setField(lua_State* L, const char* index, int32_t val)
1169{
1170	lua_pushstring(L, index);
1171	lua_pushnumber(L, val);
1172	pushTable(L);
1173}
1174
1175void LuaScriptInterface::setField(lua_State* L, const char* index, const std::string& val)
1176{
1177	lua_pushstring(L, index);
1178	lua_pushstring(L, val.c_str());
1179	pushTable(L);
1180}
1181
1182void LuaScriptInterface::setFieldBool(lua_State* L, const char* index, bool val)
1183{
1184	lua_pushstring(L, index);
1185	lua_pushboolean(L, val);
1186	pushTable(L);
1187}
1188
1189void LuaScriptInterface::setFieldFloat(lua_State* L, const char* index, double val)
1190{
1191	lua_pushstring(L, index);
1192	lua_pushnumber(L, val);
1193	pushTable(L);
1194}
1195
1196void LuaScriptInterface::createTable(lua_State* L, const char* index)
1197{
1198	lua_pushstring(L, index);
1199	lua_newtable(L);
1200}
1201
1202void LuaScriptInterface::createTable(lua_State* L, const char* index, int32_t narr, int32_t nrec)
1203{
1204	lua_pushstring(L, index);
1205	lua_createtable(L, narr, nrec);
1206}
1207
1208void LuaScriptInterface::createTable(lua_State* L, int32_t index)
1209{
1210	lua_pushnumber(L, index);
1211	lua_newtable(L);
1212}
1213
1214void LuaScriptInterface::createTable(lua_State* L, int32_t index, int32_t narr, int32_t nrec)
1215{
1216	lua_pushnumber(L, index);
1217	lua_createtable(L, narr, nrec);
1218}
1219
1220void LuaScriptInterface::pushTable(lua_State* L)
1221{
1222	lua_settable(L, -3);
1223}
1224
1225int64_t LuaScriptInterface::getField(lua_State* L, const char* key)
1226{
1227	lua_pushstring(L, key);
1228	lua_gettable(L, -2); // get table[key]
1229
1230	int64_t result = (int64_t)lua_tonumber(L, -1);
1231	lua_pop(L, 1); // remove number and key
1232	return result;
1233}
1234
1235uint64_t LuaScriptInterface::getFieldUnsigned(lua_State* L, const char* key)
1236{
1237	lua_pushstring(L, key);
1238	lua_gettable(L, -2); // get table[key]
1239
1240	uint64_t result = (uint64_t)lua_tonumber(L, -1);
1241	lua_pop(L, 1); // remove number and key
1242	return result;
1243}
1244
1245bool LuaScriptInterface::getFieldBool(lua_State* L, const char* key)
1246{
1247	lua_pushstring(L, key);
1248	lua_gettable(L, -2); // get table[key]
1249
1250	bool result = lua_toboolean(L, -1);
1251	lua_pop(L, 1); // remove number and key
1252	return result;
1253}
1254
1255std::string LuaScriptInterface::getFieldString(lua_State* L, const char* key)
1256{
1257	lua_pushstring(L, key);
1258	lua_gettable(L, -2); // get table[key]
1259
1260	std::string result = lua_tostring(L, -1);
1261	lua_pop(L, 1); // remove number and key
1262	return result;
1263}
1264
1265std::string LuaScriptInterface::getGlobalString(lua_State* L, const std::string& _identifier, const std::string& _default/* = ""*/)
1266{
1267	lua_getglobal(L, _identifier.c_str());
1268	if(!lua_isstring(L, -1))
1269	{
1270		lua_pop(L, 1);
1271		return _default;
1272	}
1273
1274	int32_t len = (int32_t)lua_strlen(L, -1);
1275	std::string ret(lua_tostring(L, -1), len);
1276
1277	lua_pop(L, 1);
1278	return ret;
1279}
1280
1281bool LuaScriptInterface::getGlobalBool(lua_State* L, const std::string& _identifier, bool _default/* = false*/)
1282{
1283	lua_getglobal(L, _identifier.c_str());
1284	if(!lua_isboolean(L, -1))
1285	{
1286		lua_pop(L, 1);
1287		return booleanString(LuaScriptInterface::getGlobalString(L, _identifier, _default ? "yes" : "no"));
1288	}
1289
1290	bool val = lua_toboolean(L, -1);
1291	lua_pop(L, 1);
1292	return val;
1293}
1294
1295int32_t LuaScriptInterface::getGlobalNumber(lua_State* L, const std::string& _identifier, const int32_t _default/* = 0*/)
1296{
1297	return (int32_t)LuaScriptInterface::getGlobalDouble(L, _identifier, _default);
1298}
1299
1300double LuaScriptInterface::getGlobalDouble(lua_State* L, const std::string& _identifier, const double _default/* = 0*/)
1301{
1302	lua_getglobal(L, _identifier.c_str());
1303	if(!lua_isnumber(L, -1))
1304	{
1305		lua_pop(L, 1);
1306		return _default;
1307	}
1308
1309	double val = lua_tonumber(L, -1);
1310	lua_pop(L, 1);
1311	return val;
1312}
1313
1314void LuaScriptInterface::getValue(const std::string& key, lua_State* L, lua_State* _L)
1315{
1316	lua_getglobal(L, key.c_str());
1317	moveValue(L, _L);
1318}
1319
1320void LuaScriptInterface::moveValue(lua_State* from, lua_State* to)
1321{
1322	switch(lua_type(from, -1))
1323	{
1324		case LUA_TNIL:
1325			lua_pushnil(to);
1326			break;
1327		case LUA_TBOOLEAN:
1328			lua_pushboolean(to, lua_toboolean(from, -1));
1329			break;
1330		case LUA_TNUMBER:
1331			lua_pushnumber(to, lua_tonumber(from, -1));
1332			break;
1333		case LUA_TSTRING:
1334		{
1335			size_t len;
1336			const char* str = lua_tolstring(from, -1, &len);
1337
1338			lua_pushlstring(to, str, len);
1339			break;
1340		}
1341		case LUA_TTABLE:
1342		{
1343			lua_newtable(to);
1344			lua_pushnil(from); // First key
1345			while(lua_next(from, -2))
1346			{
1347				// Move value to the other state
1348				moveValue(from, to); // Value is popped, key is left
1349				// Move key to the other state
1350				lua_pushvalue(from, -1); // Make a copy of the key to use for the next iteration
1351				moveValue(from, to); // Key is in other state.
1352				// We still have the key in the 'from' state ontop of the stack
1353
1354				lua_insert(to, -2); // Move key above value
1355				pushTable(to); // Set the key
1356			}
1357
1358			break;
1359		}
1360		default:
1361			break;
1362	}
1363
1364	lua_pop(from, 1); // Pop the value we just read
1365}
1366
1367void LuaScriptInterface::registerFunctions()
1368{
1369	//example(...)
1370	//lua_register(L, "name", C_function);
1371
1372	//getCreatureHealth(cid)
1373	lua_register(m_luaState, "getCreatureHealth", LuaScriptInterface::luaGetCreatureHealth);
1374
1375	//getCreatureMaxHealth(cid)
1376	lua_register(m_luaState, "getCreatureMaxHealth", LuaScriptInterface::luaGetCreatureMaxHealth);
1377
1378	//getCreatureMana(cid)
1379	lua_register(m_luaState, "getCreatureMana", LuaScriptInterface::luaGetCreatureMana);
1380
1381	//getCreatureMaxMana(cid)
1382	lua_register(m_luaState, "getCreatureMaxMana", LuaScriptInterface::luaGetCreatureMaxMana);
1383
1384	//getCreatureHideHealth(cid)
1385	lua_register(m_luaState, "getCreatureHideHealth", LuaScriptInterface::luaGetCreatureHideHealth);
1386
1387	//doCreatureSetHideHealth(cid, hide)
1388	lua_register(m_luaState, "doCreatureSetHideHealth", LuaScriptInterface::luaDoCreatureSetHideHealth);
1389
1390	//getCreatureSpeakType(cid)
1391	lua_register(m_luaState, "getCreatureSpeakType", LuaScriptInterface::luaGetCreatureSpeakType);
1392
1393	//doCreatureSetSpeakType(cid, type)
1394	lua_register(m_luaState, "doCreatureSetSpeakType", LuaScriptInterface::luaDoCreatureSetSpeakType);
1395
1396	//getCreatureLookDirection(cid)
1397	lua_register(m_luaState, "getCreatureLookDirection", LuaScriptInterface::luaGetCreatureLookDirection);
1398
1399	//getPlayerLevel(cid)
1400	lua_register(m_luaState, "getPlayerLevel", LuaScriptInterface::luaGetPlayerLevel);
1401
1402	//getPlayerExperience(cid)
1403	lua_register(m_luaState, "getPlayerExperience", LuaScriptInterface::luaGetPlayerExperience);
1404
1405	//getPlayerMagLevel(cid[, ignoreBuffs = false])
1406	lua_register(m_luaState, "getPlayerMagLevel", LuaScriptInterface::luaGetPlayerMagLevel);
1407
1408	//getPlayerSpentMana(cid)
1409	lua_register(m_luaState, "getPlayerSpentMana", LuaScriptInterface::luaGetPlayerSpentMana);
1410
1411	//getPlayerFood(cid)
1412	lua_register(m_luaState, "getPlayerFood", LuaScriptInterface::luaGetPlayerFood);
1413
1414	//getPlayerAccess(cid)
1415	lua_register(m_luaState, "getPlayerAccess", LuaScriptInterface::luaGetPlayerAccess);
1416
1417	//getPlayerGhostAccess(cid)
1418	lua_register(m_luaState, "getPlayerGhostAccess", LuaScriptInterface::luaGetPlayerGhostAccess);
1419
1420	//getPlayerSkillLevel(cid, skillid)
1421	lua_register(m_luaState, "getPlayerSkillLevel", LuaScriptInterface::luaGetPlayerSkillLevel);
1422
1423	//getPlayerSkillTries(cid, skillid)
1424	lua_register(m_luaState, "getPlayerSkillTries", LuaScriptInterface::luaGetPlayerSkillTries);
1425
1426	//getPlayerTown(cid)
1427	lua_register(m_luaState, "getPlayerTown", LuaScriptInterface::luaGetPlayerTown);
1428
1429	//getPlayerVocation(cid)
1430	lua_register(m_luaState, "getPlayerVocation", LuaScriptInterface::luaGetPlayerVocation);
1431
1432	//getPlayerIp(cid)
1433	lua_register(m_luaState, "getPlayerIp", LuaScriptInterface::luaGetPlayerIp);
1434
1435	//getPlayerRequiredMana(cid, magicLevel)
1436	lua_register(m_luaState, "getPlayerRequiredMana", LuaScriptInterface::luaGetPlayerRequiredMana);
1437
1438	//getPlayerRequiredSkillTries(cid, skillId, skillLevel)
1439	lua_register(m_luaState, "getPlayerRequiredSkillTries", LuaScriptInterface::luaGetPlayerRequiredSkillTries);
1440
1441	//getPlayerItemCount(cid, itemid[, subType = -1])
1442	lua_register(m_luaState, "getPlayerItemCount", LuaScriptInterface::luaGetPlayerItemCount);
1443
1444	//getPlayerMoney(cid)
1445	lua_register(m_luaState, "getPlayerMoney", LuaScriptInterface::luaGetPlayerMoney);
1446
1447	//getPlayerSoul(cid)
1448	lua_register(m_luaState, "getPlayerSoul", LuaScriptInterface::luaGetPlayerSoul);
1449
1450	//getPlayerFreeCap(cid)
1451	lua_register(m_luaState, "getPlayerFreeCap", LuaScriptInterface::luaGetPlayerFreeCap);
1452
1453	//getPlayerLight(cid)
1454	lua_register(m_luaState, "getPlayerLight", LuaScriptInterface::luaGetPlayerLight);
1455
1456	//getPlayerSlotItem(cid, slot)
1457	lua_register(m_luaState, "getPlayerSlotItem", LuaScriptInterface::luaGetPlayerSlotItem);
1458
1459	//getPlayerWeapon(cid[, ignoreAmmo = false])
1460	lua_register(m_luaState, "getPlayerWeapon", LuaScriptInterface::luaGetPlayerWeapon);
1461
1462	//getPlayerItemById(cid, deepSearch, itemId[, subType = -1])
1463	lua_register(m_luaState, "getPlayerItemById", LuaScriptInterface::luaGetPlayerItemById);
1464
1465	//getPlayerDepotItems(cid, depotid)
1466	lua_register(m_luaState, "getPlayerDepotItems", LuaScriptInterface::luaGetPlayerDepotItems);
1467
1468	//getPlayerGuildId(cid)
1469	lua_register(m_luaState, "getPlayerGuildId", LuaScriptInterface::luaGetPlayerGuildId);
1470
1471	//getPlayerGuildName(cid)
1472	lua_register(m_luaState, "getPlayerGuildName", LuaScriptInterface::luaGetPlayerGuildName);
1473
1474	//getPlayerGuildRankId(cid)
1475	lua_register(m_luaState, "getPlayerGuildRankId", LuaScriptInterface::luaGetPlayerGuildRankId);
1476
1477	//getPlayerGuildRank(cid)
1478	lua_register(m_luaState, "getPlayerGuildRank", LuaScriptInterface::luaGetPlayerGuildRank);
1479
1480	//getPlayerGuildNick(cid)
1481	lua_register(m_luaState, "getPlayerGuildNick", LuaScriptInterface::luaGetPlayerGuildNick);
1482
1483	//getPlayerGuildLevel(cid)
1484	lua_register(m_luaState, "getPlayerGuildLevel", LuaScriptInterface::luaGetPlayerGuildLevel);
1485
1486	//getPlayerGUID(cid)
1487	lua_register(m_luaState, "getPlayerGUID", LuaScriptInterface::luaGetPlayerGUID);
1488
1489	//getPlayerNameDescription(cid)
1490	lua_register(m_luaState, "getPlayerNameDescription", LuaScriptInterface::luaGetPlayerNameDescription);
1491
1492	//doPlayerSetNameDescription(cid, desc)
1493	lua_register(m_luaState, "doPlayerSetNameDescription", LuaScriptInterface::luaDoPlayerSetNameDescription);
1494
1495	//getPlayerSpecialDescription(cid)
1496	lua_register(m_luaState, "getPlayerSpecialDescription", LuaScriptInterface::luaGetPlayerSpecialDescription);
1497
1498	//doPlayerSetSpecialDescription(cid, desc)
1499	lua_register(m_luaState, "doPlayerSetSpecialDescription", LuaScriptInterface::luaDoPlayerSetSpecialDescription);
1500
1501	//getPlayerAccountId(cid)
1502	lua_register(m_luaState, "getPlayerAccountId", LuaScriptInterface::luaGetPlayerAccountId);
1503
1504	//getPlayerAccount(cid)
1505	lua_register(m_luaState, "getPlayerAccount", LuaScriptInterface::luaGetPlayerAccount);
1506
1507	//getPlayerFlagValue(cid, flag)
1508	lua_register(m_luaState, "getPlayerFlagValue", LuaScriptInterface::luaGetPlayerFlagValue);
1509
1510	//getPlayerCustomFlagValue(cid, flag)
1511	lua_register(m_luaState, "getPlayerCustomFlagValue", LuaScriptInterface::luaGetPlayerCustomFlagValue);
1512
1513	//getPlayerPromotionLevel(cid)
1514	lua_register(m_luaState, "getPlayerPromotionLevel", LuaScriptInterface::luaGetPlayerPromotionLevel);
1515
1516	//doPlayerSetPromotionLevel(cid, level)
1517	lua_register(m_luaState, "doPlayerSetPromotionLevel", LuaScriptInterface::luaDoPlayerSetPromotionLevel);
1518
1519	//getPlayerGroupId(cid)
1520	lua_register(m_luaState, "getPlayerGroupId", LuaScriptInterface::luaGetPlayerGroupId);
1521
1522	//doPlayerSetGroupId(cid, newGroupId)
1523	lua_register(m_luaState, "doPlayerSetGroupId", LuaScriptInterface::luaDoPlayerSetGroupId);
1524
1525	//doPlayerSendOutfitWindow(cid)
1526	lua_register(m_luaState, "doPlayerSendOutfitWindow", LuaScriptInterface::luaDoPlayerSendOutfitWindow);
1527
1528	//doPlayerLearnInstantSpell(cid, name)
1529	lua_register(m_luaState, "doPlayerLearnInstantSpell", LuaScriptInterface::luaDoPlayerLearnInstantSpell);
1530
1531	//doPlayerUnlearnInstantSpell(cid, name)
1532	lua_register(m_luaState, "doPlayerUnlearnInstantSpell", LuaScriptInterface::luaDoPlayerUnlearnInstantSpell);
1533
1534	//getPlayerLearnedInstantSpell(cid, name)
1535	lua_register(m_luaState, "getPlayerLearnedInstantSpell", LuaScriptInterface::luaGetPlayerLearnedInstantSpell);
1536
1537	//getPlayerInstantSpellCount(cid)
1538	lua_register(m_luaState, "getPlayerInstantSpellCount", LuaScriptInterface::luaGetPlayerInstantSpellCount);
1539
1540	//getPlayerInstantSpellInfo(cid, index)
1541	lua_register(m_luaState, "getPlayerInstantSpellInfo", LuaScriptInterface::luaGetPlayerInstantSpellInfo);
1542
1543	//getInstantSpellInfo(cid, name)
1544	lua_register(m_luaState, "getInstantSpellInfo", LuaScriptInterface::luaGetInstantSpellInfo);
1545
1546	//getCreatureStorage(uid, key)
1547	lua_register(m_luaState, "getCreatureStorage", LuaScriptInterface::luaGetCreatureStorage);
1548
1549	//doCreatureSetStorage(uid, key, value)
1550	lua_register(m_luaState, "doCreatureSetStorage", LuaScriptInterface::luaDoCreatureSetStorage);
1551
1552	//getStorage(key)
1553	lua_register(m_luaState, "getStorage", LuaScriptInterface::luaGetStorage);
1554
1555	//doSetStorage(key, value)
1556	lua_register(m_luaState, "doSetStorage", LuaScriptInterface::luaDoSetStorage);
1557
1558	//getChannelUsers(channelId)
1559	lua_register(m_luaState, "getChannelUsers", LuaScriptInterface::luaGetChannelUsers);
1560
1561	//getPlayersOnline()
1562	lua_register(m_luaState, "getPlayersOnline", LuaScriptInterface::luaGetPlayersOnline);
1563
1564	//getTileInfo(pos)
1565	lua_register(m_luaState, "getTileInfo", LuaScriptInterface::luaGetTileInfo);
1566
1567	//getThingFromPos(pos[, displayError = true])
1568	lua_register(m_luaState, "getThingFromPos", LuaScriptInterface::luaGetThingFromPos);
1569
1570	//getThing(uid)
1571	lua_register(m_luaState, "getThing", LuaScriptInterface::luaGetThing);
1572
1573	//doTileQueryAdd(uid, pos[, flags[, displayError = true]])
1574	lua_register(m_luaState, "doTileQueryAdd", LuaScriptInterface::luaDoTileQueryAdd);
1575
1576	//doItemRaidUnref(uid)
1577	lua_register(m_luaState, "doItemRaidUnref", LuaScriptInterface::luaDoItemRaidUnref);
1578
1579	//getThingPosition(uid)
1580	lua_register(m_luaState, "getThingPosition", LuaScriptInterface::luaGetThingPosition);
1581
1582	//getTileItemById(pos, itemId[, subType = -1])
1583	lua_register(m_luaState, "getTileItemById", LuaScriptInterface::luaGetTileItemById);
1584
1585	//getTileItemByType(pos, type)
1586	lua_register(m_luaState, "getTileItemByType", LuaScriptInterface::luaGetTileItemByType);
1587
1588	//getTileThingByPos(pos)
1589	lua_register(m_luaState, "getTileThingByPos", LuaScriptInterface::luaGetTileThingByPos);
1590
1591	//getTopCreature(pos)
1592	lua_register(m_luaState, "getTopCreature", LuaScriptInterface::luaGetTopCreature);
1593
1594	//doRemoveItem(uid[, count])
1595	lua_register(m_luaState, "doRemoveItem", LuaScriptInterface::luaDoRemoveItem);
1596
1597	//doPlayerFeed(cid, food)
1598	lua_register(m_luaState, "doPlayerFeed", LuaScriptInterface::luaDoFeedPlayer);
1599
1600	//doPlayerSendCancel(cid, text)
1601	lua_register(m_luaState, "doPlayerSendCancel", LuaScriptInterface::luaDoPlayerSendCancel);
1602
1603	//doPlayerSendDefaultCancel(cid, ReturnValue)
1604	lua_register(m_luaState, "doPlayerSendDefaultCancel", LuaScriptInterface::luaDoSendDefaultCancel);
1605
1606	//getSearchString(fromPosition, toPosition[, fromIsCreature = false[, toIsCreature = false]])
1607	lua_register(m_luaState, "getSearchString", LuaScriptInterface::luaGetSearchString);
1608
1609	//getClosestFreeTile(cid, targetpos[, extended = false[, ignoreHouse = true]])
1610	lua_register(m_luaState, "getClosestFreeTile", LuaScriptInterface::luaGetClosestFreeTile);
1611
1612	//doTeleportThing(cid, newpos[, pushmove])
1613	lua_register(m_luaState, "doTeleportThing", LuaScriptInterface::luaDoTeleportThing);
1614
1615	//doTransformItem(uid, newId[, count/subType])
1616	lua_register(m_luaState, "doTransformItem", LuaScriptInterface::luaDoTransformItem);
1617
1618	//doCreatureSay(uid, text[, type = SPEAK_SAY[, ghost = false[, cid = 0[, pos]]]])
1619	lua_register(m_luaState, "doCreatureSay", LuaScriptInterface::luaDoCreatureSay);
1620
1621	//doSendMagicEffect(pos, type[, player])
1622	lua_register(m_luaState, "doSendMagicEffect", LuaScriptInterface::luaDoSendMagicEffect);
1623
1624	//doSendDistanceShoot(fromPos, toPos, type[, player])
1625	lua_register(m_luaState, "doSendDistanceShoot", LuaScriptInterface::luaDoSendDistanceShoot);
1626
1627	//doSendAnimatedText(pos, text, color[, player])
1628	lua_register(m_luaState, "doSendAnimatedText", LuaScriptInterface::luaDoSendAnimatedText);
1629
1630	//doPlayerAddSkillTry(cid, skillid, n[, useMultiplier])
1631	lua_register(m_luaState, "doPlayerAddSkillTry", LuaScriptInterface::luaDoPlayerAddSkillTry);
1632
1633	//doCreatureAddHealth(cid, health[, hitEffect[, hitColor[, force]]])
1634	lua_register(m_luaState, "doCreatureAddHealth", LuaScriptInterface::luaDoCreatureAddHealth);
1635
1636	//doCreatureAddMana(cid, mana)
1637	lua_register(m_luaState, "doCreatureAddMana", LuaScriptInterface::luaDoCreatureAddMana);
1638
1639	//setCreatureMaxHealth(cid, health)
1640	lua_register(m_luaState, "setCreatureMaxHealth", LuaScriptInterface::luaSetCreatureMaxHealth);
1641
1642	//setCreatureMaxMana(cid, mana)
1643	lua_register(m_luaState, "setCreatureMaxMana", LuaScriptInterface::luaSetCreatureMaxMana);
1644
1645	//doPlayerSetMaxCapacity(cid, cap)
1646	lua_register(m_luaState, "doPlayerSetMaxCapacity", LuaScriptInterface::luaDoPlayerSetMaxCapacity);
1647
1648	//doPlayerAddSpentMana(cid, amount[, useMultiplier])
1649	lua_register(m_luaState, "doPlayerAddSpentMana", LuaScriptInterface::luaDoPlayerAddSpentMana);
1650
1651	//doPlayerAddSoul(cid, soul)
1652	lua_register(m_luaState, "doPlayerAddSoul", LuaScriptInterface::luaDoPlayerAddSoul);
1653
1654	//doPlayerAddItem(cid, itemid[, count/subtype[, canDropOnMap]])
1655	//doPlayerAddItem(cid, itemid[, count[, canDropOnMap[, subtype]]])
1656	//Returns uid of the created item
1657	lua_register(m_luaState, "doPlayerAddItem", LuaScriptInterface::luaDoPlayerAddItem);
1658
1659	//doPlayerAddItemEx(cid, uid[, canDropOnMap = FALSE])
1660	lua_register(m_luaState, "doPlayerAddItemEx", LuaScriptInterface::luaDoPlayerAddItemEx);
1661
1662	//doPlayerSendTextMessage(cid, MessageClasses, message)
1663	lua_register(m_luaState, "doPlayerSendTextMessage", LuaScriptInterface::luaDoPlayerSendTextMessage);
1664
1665	//doPlayerSendChannelMessage(cid, author, message, SpeakClasses, channel)
1666	lua_register(m_luaState, "doPlayerSendChannelMessage", LuaScriptInterface::luaDoPlayerSendChannelMessage);
1667
1668	//doPlayerSendToChannel(cid, targetId, SpeakClasses, message, channel[, time])
1669	lua_register(m_luaState, "doPlayerSendToChannel", LuaScriptInterface::luaDoPlayerSendToChannel);
1670
1671	//doPlayerAddMoney(cid, money)
1672	lua_register(m_luaState, "doPlayerAddMoney", LuaScriptInterface::luaDoPlayerAddMoney);
1673
1674	//doPlayerRemoveMoney(cid, money)
1675	lua_register(m_luaState, "doPlayerRemoveMoney", LuaScriptInterface::luaDoPlayerRemoveMoney);
1676
1677	//doPlayerTransferMoneyTo(cid, target, money)
1678	lua_register(m_luaState, "doPlayerTransferMoneyTo", LuaScriptInterface::luaDoPlayerTransferMoneyTo);
1679
1680	//doShowTextDialog(cid, itemid, text)
1681	lua_register(m_luaState, "doShowTextDialog", LuaScriptInterface::luaDoShowTextDialog);
1682
1683	//doDecayItem(uid)
1684	lua_register(m_luaState, "doDecayItem", LuaScriptInterface::luaDoDecayItem);
1685
1686	//doCreateItem(itemid[, type/count], pos)
1687	//Returns uid of the created item, only works on tiles.
1688	lua_register(m_luaState, "doCreateItem", LuaScriptInterface::luaDoCreateItem);
1689
1690	//doCreateItemEx(itemid[, count/subType = -1])
1691	lua_register(m_luaState, "doCreateItemEx", LuaScriptInterface::luaDoCreateItemEx);
1692
1693	//doTileAddItemEx(pos, uid)
1694	lua_register(m_luaState, "doTileAddItemEx", LuaScriptInterface::luaDoTileAddItemEx);
1695
1696	//doAddContainerItemEx(uid, virtuid)
1697	lua_register(m_luaState, "doAddContainerItemEx", LuaScriptInterface::luaDoAddContainerItemEx);
1698
1699	//doRelocate(pos, posTo[, creatures = true])
1700	//Moves all moveable objects from pos to posTo
1701	lua_register(m_luaState, "doRelocate", LuaScriptInterface::luaDoRelocate);
1702
1703	//doCleanTile(pos[, forceMapLoaded = false])
1704	lua_register(m_luaState, "doCleanTile", LuaScriptInterface::luaDoCleanTile);
1705
1706	//doCreateTeleport(itemid, topos, createpos)
1707	lua_register(m_luaState, "doCreateTeleport", LuaScriptInterface::luaDoCreateTeleport);
1708
1709	//doCreateMonster(name, pos[, displayError = true])
1710	lua_register(m_luaState, "doCreateMonster", LuaScriptInterface::luaDoCreateMonster);
1711
1712	//doCreateNpc(name, pos[, displayError = true])
1713	lua_register(m_luaState, "doCreateNpc", LuaScriptInterface::luaDoCreateNpc);
1714
1715	//doSummonMonster(cid, name)
1716	lua_register(m_luaState, "doSummonMonster", LuaScriptInterface::luaDoSummonMonster);
1717
1718	//doConvinceCreature(cid, target)
1719	lua_register(m_luaState, "doConvinceCreature", LuaScriptInterface::luaDoConvinceCreature);
1720
1721	//getMonsterTargetList(cid)
1722	lua_register(m_luaState, "getMonsterTargetList", LuaScriptInterface::luaGetMonsterTargetList);
1723
1724	//getMonsterFriendList(cid)
1725	lua_register(m_luaState, "getMonsterFriendList", LuaScriptInterface::luaGetMonsterFriendList);
1726
1727	//doMonsterSetTarget(cid, target)
1728	lua_register(m_luaState, "doMonsterSetTarget", LuaScriptInterface::luaDoMonsterSetTarget);
1729
1730	//doMonsterChangeTarget(cid)
1731	lua_register(m_luaState, "doMonsterChangeTarget", LuaScriptInterface::luaDoMonsterChangeTarget);
1732
1733	//getMonsterInfo(name)
1734	lua_register(m_luaState, "getMonsterInfo", LuaScriptInterface::luaGetMonsterInfo);
1735
1736	//doAddCondition(cid, condition)
1737	lua_register(m_luaState, "doAddCondition", LuaScriptInterface::luaDoAddCondition);
1738
1739	//doRemoveCondition(cid, type[, subId])
1740	lua_register(m_luaState, "doRemoveCondition", LuaScriptInterface::luaDoRemoveCondition);
1741
1742	//doRemoveConditions(cid[, onlyPersistent])
1743	lua_register(m_luaState, "doRemoveConditions", LuaScriptInterface::luaDoRemoveConditions);
1744
1745	//doRemoveCreature(cid[, forceLogout = true])
1746	lua_register(m_luaState, "doRemoveCreature", LuaScriptInterface::luaDoRemoveCreature);
1747
1748	//doMoveCreature(cid, direction)
1749	lua_register(m_luaState, "doMoveCreature", LuaScriptInterface::luaDoMoveCreature);
1750
1751	//doPlayerSetPzLocked(cid, locked)
1752	lua_register(m_luaState, "doPlayerSetPzLocked", LuaScriptInterface::luaDoPlayerSetPzLocked);
1753
1754	//doPlayerSetTown(cid, townid)
1755	lua_register(m_luaState, "doPlayerSetTown", LuaScriptInterface::luaDoPlayerSetTown);
1756
1757	//doPlayerSetVocation(cid,voc)
1758	lua_register(m_luaState, "doPlayerSetVocation", LuaScriptInterface::luaDoPlayerSetVocation);
1759
1760	//doPlayerRemoveItem(cid, itemid[, count[, subType]])
1761	lua_register(m_luaState, "doPlayerRemoveItem", LuaScriptInterface::luaDoPlayerRemoveItem);
1762
1763	//doPlayerAddExperience(cid, amount)
1764	lua_register(m_luaState, "doPlayerAddExperience", LuaScriptInterface::luaDoPlayerAddExperience);
1765
1766	//doPlayerSetGuildId(cid, id)
1767	lua_register(m_luaState, "doPlayerSetGuildId", LuaScriptInterface::luaDoPlayerSetGuildId);
1768
1769	//doPlayerSetGuildLevel(cid, level[, rank])
1770	lua_register(m_luaState, "doPlayerSetGuildLevel", LuaScriptInterface::luaDoPlayerSetGuildLevel);
1771
1772	//doPlayerSetGuildNick(cid, nick)
1773	lua_register(m_luaState, "doPlayerSetGuildNick", LuaScriptInterface::luaDoPlayerSetGuildNick);
1774
1775	//doPlayerAddOutfit(cid, looktype, addon)
1776	lua_register(m_luaState, "doPlayerAddOutfit", LuaScriptInterface::luaDoPlayerAddOutfit);
1777
1778	//doPlayerRemoveOutfit(cid, looktype[, addon = 0])
1779	lua_register(m_luaState, "doPlayerRemoveOutfit", LuaScriptInterface::luaDoPlayerRemoveOutfit);
1780
1781	//doPlayerAddOutfitId(cid, outfitId, addon)
1782	lua_register(m_luaState, "doPlayerAddOutfitId", LuaScriptInterface::luaDoPlayerAddOutfitId);
1783
1784	//doPlayerRemoveOutfitId(cid, outfitId[, addon = 0])
1785	lua_register(m_luaState, "doPlayerRemoveOutfitId", LuaScriptInterface::luaDoPlayerRemoveOutfitId);
1786
1787	//canPlayerWearOutfit(cid, looktype[, addon = 0])
1788	lua_register(m_luaState, "canPlayerWearOutfit", LuaScriptInterface::luaCanPlayerWearOutfit);
1789
1790	//canPlayerWearOutfitId(cid, outfitId[, addon = 0])
1791	lua_register(m_luaState, "canPlayerWearOutfitId", LuaScriptInterface::luaCanPlayerWearOutfitId);
1792
1793	//doSetCreatureLight(cid, lightLevel, lightColor, time)
1794	lua_register(m_luaState, "doSetCreatureLight", LuaScriptInterface::luaDoSetCreatureLight);
1795
1796	//getCreatureCondition(cid, condition[, subId])
1797	lua_register(m_luaState, "getCreatureCondition", LuaScriptInterface::luaGetCreatureCondition);
1798
1799	//doCreatureSetDropLoot(cid, doDrop)
1800	lua_register(m_luaState, "doCreatureSetDropLoot", LuaScriptInterface::luaDoCreatureSetDropLoot);
1801
1802	//getPlayerLossPercent(cid, lossType)
1803	lua_register(m_luaState, "getPlayerLossPercent", LuaScriptInterface::luaGetPlayerLossPercent);
1804
1805	//doPlayerSetLossPercent(cid, lossType, newPercent)
1806	lua_register(m_luaState, "doPlayerSetLossPercent", LuaScriptInterface::luaDoPlayerSetLossPercent);
1807
1808	//doPlayerSetLossSkill(cid, doLose)
1809	lua_register(m_luaState, "doPlayerSetLossSkill", LuaScriptInterface::luaDoPlayerSetLossSkill);
1810
1811	//getPlayerLossSkill(cid)
1812	lua_register(m_luaState, "getPlayerLossSkill", LuaScriptInterface::luaGetPlayerLossSkill);
1813
1814	//doPlayerSwitchSaving(cid)
1815	lua_register(m_luaState, "doPlayerSwitchSaving", LuaScriptInterface::luaDoPlayerSwitchSaving);
1816
1817	//doPlayerSave(cid[, shallow = false])
1818	lua_register(m_luaState, "doPlayerSave", LuaScriptInterface::luaDoPlayerSave);
1819
1820	//isPlayerPzLocked(cid)
1821	lua_register(m_luaState, "isPlayerPzLocked", LuaScriptInterface::luaIsPlayerPzLocked);
1822
1823	//isPlayerSaving(cid)
1824	lua_register(m_luaState, "isPlayerSaving", LuaScriptInterface::luaIsPlayerSaving);
1825
1826	//isCreature(cid)
1827	lua_register(m_luaState, "isCreature", LuaScriptInterface::luaIsCreature);
1828
1829	//isContainer(uid)
1830	lua_register(m_luaState, "isContainer", LuaScriptInterface::luaIsContainer);
1831
1832	//isMovable(uid)
1833	lua_register(m_luaState, "isMovable", LuaScriptInterface::luaIsMovable);
1834
1835	//getCreatureByName(name)
1836	lua_register(m_luaState, "getCreatureByName", LuaScriptInterface::luaGetCreatureByName);
1837
1838	//getPlayerByGUID(guid)
1839	lua_register(m_luaState, "getPlayerByGUID", LuaScriptInterface::luaGetPlayerByGUID);
1840
1841	//getPlayerByNameWildcard(name~[, ret = false])
1842	lua_register(m_luaState, "getPlayerByNameWildcard", LuaScriptInterface::luaGetPlayerByNameWildcard);
1843
1844	//getPlayerGUIDByName(name[, multiworld = false])
1845	lua_register(m_luaState, "getPlayerGUIDByName", LuaScriptInterface::luaGetPlayerGUIDByName);
1846
1847	//getPlayerNameByGUID(guid[, multiworld = false[, displayError = true]])
1848	lua_register(m_luaState, "getPlayerNameByGUID", LuaScriptInterface::luaGetPlayerNameByGUID);
1849
1850	//registerCreatureEvent(uid, eventName)
1851	lua_register(m_luaState, "registerCreatureEvent", LuaScriptInterface::luaRegisterCreatureEvent);
1852
1853	//getContainerSize(uid)
1854	lua_register(m_luaState, "getContainerSize", LuaScriptInterface::luaGetContainerSize);
1855
1856	//getContainerCap(uid)
1857	lua_register(m_luaState, "getContainerCap", LuaScriptInterface::luaGetContainerCap);
1858
1859	//getContainerItem(uid, slot)
1860	lua_register(m_luaState, "getContainerItem", LuaScriptInterface::luaGetContainerItem);
1861
1862	//doAddContainerItem(uid, itemid[, count/subType])
1863	lua_register(m_luaState, "doAddContainerItem", LuaScriptInterface::luaDoAddContainerItem);
1864
1865	//getHouseInfo(houseId)
1866	lua_register(m_luaState, "getHouseInfo", LuaScriptInterface::luaGetHouseInfo);
1867
1868	//getHouseAccessList(houseid, listId)
1869	lua_register(m_luaState, "getHouseAccessList", LuaScriptInterface::luaGetHouseAccessList);
1870
1871	//getHouseByPlayerGUID(playerGUID)
1872	lua_register(m_luaState, "getHouseByPlayerGUID", LuaScriptInterface::luaGetHouseByPlayerGUID);
1873
1874	//getHouseFromPos(pos)
1875	lua_register(m_luaState, "getHouseFromPos", LuaScriptInterface::luaGetHouseFromPos);
1876
1877	//setHouseAccessList(houseid, listid, listtext)
1878	lua_register(m_luaState, "setHouseAccessList", LuaScriptInterface::luaSetHouseAccessList);
1879
1880	//setHouseOwner(houseId, owner[, clean])
1881	lua_register(m_luaState, "setHouseOwner", LuaScriptInterface::luaSetHouseOwner);
1882
1883	//getWorldType()
1884	lua_register(m_luaState, "getWorldType", LuaScriptInterface::luaGetWorldType);
1885
1886	//setWorldType(type)
1887	lua_register(m_luaState, "setWorldType", LuaScriptInterface::luaSetWorldType);
1888
1889	//getWorldTime()
1890	lua_register(m_luaState, "getWorldTime", LuaScriptInterface::luaGetWorldTime);
1891
1892	//getWorldLight()
1893	lua_register(m_luaState, "getWorldLight", LuaScriptInterface::luaGetWorldLight);
1894
1895	//getWorldCreatures(type)
1896	//0 players, 1 monsters, 2 npcs, 3 all
1897	lua_register(m_luaState, "getWorldCreatures", LuaScriptInterface::luaGetWorldCreatures);
1898
1899	//getWorldUpTime()
1900	lua_register(m_luaState, "getWorldUpTime", LuaScriptInterface::luaGetWorldUpTime);
1901
1902	//getGuildId(guildName)
1903	lua_register(m_luaState, "getGuildId", LuaScriptInterface::luaGetGuildId);
1904
1905	//getGuildMotd(guildId)
1906	lua_register(m_luaState, "getGuildMotd", LuaScriptInterface::luaGetGuildMotd);
1907
1908	//getPlayerSex(cid[, full = false])
1909	lua_register(m_luaState, "getPlayerSex", LuaScriptInterface::luaGetPlayerSex);
1910
1911	//doPlayerSetSex(cid, newSex)
1912	lua_register(m_luaState, "doPlayerSetSex", LuaScriptInterface::luaDoPlayerSetSex);
1913
1914	//createCombatArea({area}[, {extArea}])
1915	lua_register(m_luaState, "createCombatArea", LuaScriptInterface::luaCreateCombatArea);
1916
1917	//createConditionObject(type[, ticks[, buff[, subId]]])
1918	lua_register(m_luaState, "createConditionObject", LuaScriptInterface::luaCreateConditionObject);
1919
1920	//setCombatArea(combat, area)
1921	lua_register(m_luaState, "setCombatArea", LuaScriptInterface::luaSetCombatArea);
1922
1923	//setCombatCondition(combat, condition)
1924	lua_register(m_luaState, "setCombatCondition", LuaScriptInterface::luaSetCombatCondition);
1925
1926	//setCombatParam(combat, key, value)
1927	lua_register(m_luaState, "setCombatParam", LuaScriptInterface::luaSetCombatParam);
1928
1929	//setConditionParam(condition, key, value)
1930	lua_register(m_luaState, "setConditionParam", LuaScriptInterface::luaSetConditionParam);
1931
1932	//addDamageCondition(condition, rounds, time, value)
1933	lua_register(m_luaState, "addDamageCondition", LuaScriptInterface::luaAddDamageCondition);
1934
1935	//addOutfitCondition(condition, outfit)
1936	lua_register(m_luaState, "addOutfitCondition", LuaScriptInterface::luaAddOutfitCondition);
1937
1938	//setCombatCallBack(combat, key, function_name)
1939	lua_register(m_luaState, "setCombatCallback", LuaScriptInterface::luaSetCombatCallBack);
1940
1941	//setCombatFormula(combat, type, mina, minb, maxa, maxb[, minl, maxl[, minm, maxm[, minc[, maxc]]]])
1942	lua_register(m_luaState, "setCombatFormula", LuaScriptInterface::luaSetCombatFormula);
1943
1944	//setConditionFormula(combat, mina, minb, maxa, maxb)
1945	lua_register(m_luaState, "setConditionFormula", LuaScriptInterface::luaSetConditionFormula);
1946
1947	//doCombat(cid, combat, param)
1948	lua_register(m_luaState, "doCombat", LuaScriptInterface::luaDoCombat);
1949
1950	//createCombatObject()
1951	lua_register(m_luaState, "createCombatObject", LuaScriptInterface::luaCreateCombatObject);
1952
1953	//doCombatAreaHealth(cid, type, pos, area, min, max, effect)
1954	lua_register(m_luaState, "doCombatAreaHealth", LuaScriptInterface::luaDoCombatAreaHealth);
1955
1956	//doTargetCombatHealth(cid, target, type, min, max, effect)
1957	lua_register(m_luaState, "doTargetCombatHealth", LuaScriptInterface::luaDoTargetCombatHealth);
1958
1959	//doCombatAreaMana(cid, pos, area, min, max, effect)
1960	lua_register(m_luaState, "doCombatAreaMana", LuaScriptInterface::luaDoCombatAreaMana);
1961
1962	//doTargetCombatMana(cid, target, min, max, effect)
1963	lua_register(m_luaState, "doTargetCombatMana", LuaScriptInterface::luaDoTargetCombatMana);
1964
1965	//doCombatAreaCondition(cid, pos, area, condition, effect)
1966	lua_register(m_luaState, "doCombatAreaCondition", LuaScriptInterface::luaDoCombatAreaCondition);
1967
1968	//doTargetCombatCondition(cid, target, condition, effect)
1969	lua_register(m_luaState, "doTargetCombatCondition", LuaScriptInterface::luaDoTargetCombatCondition);
1970
1971	//doCombatAreaDispel(cid, pos, area, type, effect)
1972	lua_register(m_luaState, "doCombatAreaDispel", LuaScriptInterface::luaDoCombatAreaDispel);
1973
1974	//doTargetCombatDispel(cid, target, type, effect)
1975	lua_register(m_luaState, "doTargetCombatDispel", LuaScriptInterface::luaDoTargetCombatDispel);
1976
1977	//doChallengeCreature(cid, target)
1978	lua_register(m_luaState, "doChallengeCreature", LuaScriptInterface::luaDoChallengeCreature);
1979
1980	//numberToVariant(number)
1981	lua_register(m_luaState, "numberToVariant", LuaScriptInterface::luaNumberToVariant);
1982
1983	//stringToVariant(string)
1984	lua_register(m_luaState, "stringToVariant", LuaScriptInterface::luaStringToVariant);
1985
1986	//positionToVariant(pos)
1987	lua_register(m_luaState, "positionToVariant", LuaScriptInterface::luaPositionToVariant);
1988
1989	//targetPositionToVariant(pos)
1990	lua_register(m_luaState, "targetPositionToVariant", LuaScriptInterface::luaTargetPositionToVariant);
1991
1992	//variantToNumber(var)
1993	lua_register(m_luaState, "variantToNumber", LuaScriptInterface::luaVariantToNumber);
1994
1995	//variantToString(var)
1996	lua_register(m_luaState, "variantToString", LuaScriptInterface::luaVariantToString);
1997
1998	//variantToPosition(var)
1999	lua_register(m_luaState, "variantToPosition", LuaScriptInterface::luaVariantToPosition);
2000
2001	//doChangeSpeed(cid, delta)
2002	lua_register(m_luaState, "doChangeSpeed", LuaScriptInterface::luaDoChangeSpeed);
2003
2004	//doCreatureChangeOutfit(cid, outfit)
2005	lua_register(m_luaState, "doCreatureChangeOutfit", LuaScriptInterface::luaDoCreatureChangeOutfit);
2006
2007	//doSetMonsterOutfit(cid, name, time)
2008	lua_register(m_luaState, "doSetMonsterOutfit", LuaScriptInterface::luaSetMonsterOutfit);
2009
2010	//doSetItemOutfit(cid, item, time)
2011	lua_register(m_luaState, "doSetItemOutfit", LuaScriptInterface::luaSetItemOutfit);
2012
2013	//doSetCreatureOutfit(cid, outfit, time)
2014	lua_register(m_luaState, "doSetCreatureOutfit", LuaScriptInterface::luaSetCreatureOutfit);
2015
2016	//getCreatureOutfit(cid)
2017	lua_register(m_luaState, "getCreatureOutfit", LuaScriptInterface::luaGetCreatureOutfit);
2018
2019	//getCreatureLastPosition(cid)
2020	lua_register(m_luaState, "getCreatureLastPosition", LuaScriptInterface::luaGetCreatureLastPosition);
2021
2022	//getCreatureName(cid)
2023	lua_register(m_luaState, "getCreatureName", LuaScriptInterface::luaGetCreatureName);
2024
2025	//getCreatureSpeed(cid)
2026	lua_register(m_luaState, "getCreatureSpeed", LuaScriptInterface::luaGetCreatureSpeed);
2027
2028	//getCreatureBaseSpeed(cid)
2029	lua_register(m_luaState, "getCreatureBaseSpeed", LuaScriptInterface::luaGetCreatureBaseSpeed);
2030
2031	//getCreatureTarget(cid)
2032	lua_register(m_luaState, "getCreatureTarget", LuaScriptInterface::luaGetCreatureTarget);
2033
2034	//isSightClear(fromPos, toPos, floorCheck)
2035	lua_register(m_luaState, "isSightClear", LuaScriptInterface::luaIsSightClear);
2036
2037	//isInArray(array, value[, caseSensitive = false])
2038	lua_register(m_luaState, "isInArray", LuaScriptInterface::luaIsInArray);
2039
2040	//addEvent(callback, delay, ...)
2041	lua_register(m_luaState, "addEvent", LuaScriptInterface::luaAddEvent);
2042
2043	//stopEvent(eventid)
2044	lua_register(m_luaState, "stopEvent", LuaScriptInterface::luaStopEvent);
2045
2046	//getPlayersByAccountId(accId)
2047	lua_register(m_luaState, "getPlayersByAccountId", LuaScriptInterface::luaGetPlayersByAccountId);
2048
2049	//getAccountIdByName(name)
2050	lua_register(m_luaState, "getAccountIdByName", LuaScriptInterface::luaGetAccountIdByName);
2051
2052	//getAccountByName(name)
2053	lua_register(m_luaState, "getAccountByName", LuaScriptInterface::luaGetAccountByName);
2054
2055	//getAccountIdByAccount(accName)
2056	lua_register(m_luaState, "getAccountIdByAccount", LuaScriptInterface::luaGetAccountIdByAccount);
2057
2058	//getAccountByAccountId(accId)
2059	lua_register(m_luaState, "getAccountByAccountId", LuaScriptInterface::luaGetAccountByAccountId);
2060
2061	//getIpByName(name)
2062	lua_register(m_luaState, "getIpByName", LuaScriptInterface::luaGetIpByName);
2063
2064	//getPlayersByIp(ip[, mask = 0xFFFFFFFF])
2065	lua_register(m_luaState, "getPlayersByIp", LuaScriptInterface::luaGetPlayersByIp);
2066
2067	//doPlayerPopupFYI(cid, message)
2068	lua_register(m_luaState, "doPlayerPopupFYI", LuaScriptInterface::luaDoPlayerPopupFYI);
2069
2070	//doPlayerSendTutorial(cid, id)
2071	lua_register(m_luaState, "doPlayerSendTutorial", LuaScriptInterface::luaDoPlayerSendTutorial);
2072
2073	//doPlayerSendMailByName(name, item[, town[, actor]])
2074	lua_register(m_luaState, "doPlayerSendMailByName", LuaScriptInterface::luaDoPlayerSendMailByName);
2075
2076	//doPlayerAddMapMark(cid, pos, type[, description])
2077	lua_register(m_luaState, "doPlayerAddMapMark", LuaScriptInterface::luaDoPlayerAddMapMark);
2078
2079	//doPlayerAddPremiumDays(cid, days)
2080	lua_register(m_luaState, "doPlayerAddPremiumDays", LuaScriptInterface::luaDoPlayerAddPremiumDays);
2081
2082	//getPlayerPremiumDays(cid)
2083	lua_register(m_luaState, "getPlayerPremiumDays", LuaScriptInterface::luaGetPlayerPremiumDays);
2084
2085	//doCreatureSetLookDirection(cid, dir)
2086	lua_register(m_luaState, "doCreatureSetLookDirection", LuaScriptInterface::luaDoCreatureSetLookDir);
2087
2088	//getCreatureSkullType(cid[, target])
2089	lua_register(m_luaState, "getCreatureSkullType", LuaScriptInterface::luaGetCreatureSkullType);
2090
2091	//doCreatureSetSkullType(cid, skull)
2092	lua_register(m_luaState, "doCreatureSetSkullType", LuaScriptInterface::luaDoCreatureSetSkullType);
2093
2094	//getPlayerSkullEnd(cid)
2095	lua_register(m_luaState, "getPlayerSkullEnd", LuaScriptInterface::luaGetPlayerSkullEnd);
2096
2097	//doPlayerSetSkullEnd(cid, time, type)
2098	lua_register(m_luaState, "doPlayerSetSkullEnd", LuaScriptInterface::luaDoPlayerSetSkullEnd);
2099
2100	//getPlayerBalance(cid)
2101	lua_register(m_luaState, "getPlayerBalance", LuaScriptInterface::luaGetPlayerBalance);
2102
2103	//getPlayerBlessing(cid, blessing)
2104	lua_register(m_luaState, "getPlayerBlessing", LuaScriptInterface::luaGetPlayerBlessing);
2105
2106	//doPlayerAddBlessing(cid, blessing)
2107	lua_register(m_luaState, "doPlayerAddBlessing", LuaScriptInterface::luaDoPlayerAddBlessing);
2108
2109	//getPlayerStamina(cid)
2110	lua_register(m_luaState, "getPlayerStamina", LuaScriptInterface::luaGetPlayerStamina);
2111
2112	//doPlayerSetStamina(cid, minutes)
2113	lua_register(m_luaState, "doPlayerSetStamina", LuaScriptInterface::luaDoPlayerSetStamina);
2114
2115	//doPlayerAddStamina(cid, minutes)
2116	lua_register(m_luaState, "doPlayerAddStamina", LuaScriptInterface::luaDoPlayerAddStamina);
2117
2118	//doPlayerSetBalance(cid, balance)
2119	lua_register(m_luaState, "doPlayerSetBalance", LuaScriptInterface::luaDoPlayerSetBalance);
2120
2121	//getCreatureNoMove(cid)
2122	lua_register(m_luaState, "getCreatureNoMove", LuaScriptInterface::luaGetCreatureNoMove);
2123
2124	//doCreatureSetNoMove(cid, block)
2125	lua_register(m_luaState, "doCreatureSetNoMove", LuaScriptInterface::luaDoCreatureSetNoMove);
2126
2127	//getPlayerIdleTime(cid)
2128	lua_register(m_luaState, "getPlayerIdleTime", LuaScriptInterface::luaGetPlayerIdleTime);
2129
2130	//doPlayerSetIdleTime(cid, amount)
2131	lua_register(m_luaState, "doPlayerSetIdleTime", LuaScriptInterface::luaDoPlayerSetIdleTime);
2132
2133	//getPlayerLastLoad(cid)
2134	lua_register(m_luaState, "getPlayerLastLoad", LuaScriptInterface::luaGetPlayerLastLoad);
2135
2136	//getPlayerLastLogin(cid)
2137	lua_register(m_luaState, "getPlayerLastLogin", LuaScriptInterface::luaGetPlayerLastLogin);
2138
2139	//getPlayerAccountManager(cid)
2140	lua_register(m_luaState, "getPlayerAccountManager", LuaScriptInterface::luaGetPlayerAccountManager);
2141
2142	//getPlayerRates(cid)
2143	lua_register(m_luaState, "getPlayerRates", LuaScriptInterface::luaGetPlayerRates);
2144
2145	//doPlayerSetRate(cid, type, value)
2146	lua_register(m_luaState, "doPlayerSetRate", LuaScriptInterface::luaDoPlayerSetRate);
2147
2148	//getPlayerPartner(cid)
2149	lua_register(m_luaState, "getPlayerPartner", LuaScriptInterface::luaGetPlayerPartner);
2150
2151	//doPlayerSetPartner(cid, guid)
2152	lua_register(m_luaState, "doPlayerSetPartner", LuaScriptInterface::luaDoPlayerSetPartner);
2153
2154	//getPlayerParty(cid)
2155	lua_register(m_luaState, "getPlayerParty", LuaScriptInterface::luaGetPlayerParty);
2156
2157	//doPlayerJoinParty(cid, lid)
2158	lua_register(m_luaState, "doPlayerJoinParty", LuaScriptInterface::luaDoPlayerJoinParty);
2159
2160	//getPartyMembers(lid)
2161	lua_register(m_luaState, "getPartyMembers", LuaScriptInterface::luaGetPartyMembers);
2162
2163	//getCreatureMaster(cid)
2164	lua_register(m_luaState, "getCreatureMaster", LuaScriptInterface::luaGetCreatureMaster);
2165
2166	//getCreatureSummons(cid)
2167	lua_register(m_luaState, "getCreatureSummons", LuaScriptInterface::luaGetCreatureSummons);
2168
2169	//getTownId(townName)
2170	lua_register(m_luaState, "getTownId", LuaScriptInterface::luaGetTownId);
2171
2172	//getTownName(townId)
2173	lua_register(m_luaState, "getTownName", LuaScriptInterface::luaGetTownName);
2174
2175	//getTownTemplePosition(townId[, displayError])
2176	lua_register(m_luaState, "getTownTemplePosition", LuaScriptInterface::luaGetTownTemplePosition);
2177
2178	//getTownHouses(townId)
2179	lua_register(m_luaState, "getTownHouses", LuaScriptInterface::luaGetTownHouses);
2180
2181	//getSpectators(centerPos, rangex, rangey[, multifloor = false])
2182	lua_register(m_luaState, "getSpectators", LuaScriptInterface::luaGetSpectators);
2183
2184	//getVocationInfo(id)
2185	lua_register(m_luaState, "getVocationInfo", LuaScriptInterface::luaGetVocationInfo);
2186
2187	//getGroupInfo(id)
2188	lua_register(m_luaState, "getGroupInfo", LuaScriptInterface::luaGetGroupInfo);
2189
2190	//getWaypointList()
2191	lua_register(m_luaState, "getWaypointList", LuaScriptInterface::luaGetWaypointList);
2192
2193	//getTalkActionList()
2194	lua_register(m_luaState, "getTalkActionList", LuaScriptInterface::luaGetTalkActionList);
2195
2196	//getExperienceStageList()
2197	lua_register(m_luaState, "getExperienceStageList", LuaScriptInterface::luaGetExperienceStageList);
2198
2199	//getItemIdByName(name[, displayError = true])
2200	lua_register(m_luaState, "getItemIdByName", LuaScriptInterface::luaGetItemIdByName);
2201
2202	//getItemInfo(itemid)
2203	lua_register(m_luaState, "getItemInfo", LuaScriptInterface::luaGetItemInfo);
2204
2205	//getItemAttribute(uid, key)
2206	lua_register(m_luaState, "getItemAttribute", LuaScriptInterface::luaGetItemAttribute);
2207
2208	//doItemSetAttribute(uid, key, value)
2209	lua_register(m_luaState, "doItemSetAttribute", LuaScriptInterface::luaDoItemSetAttribute);
2210
2211	//doItemEraseAttribute(uid, key)
2212	lua_register(m_luaState, "doItemEraseAttribute", LuaScriptInterface::luaDoItemEraseAttribute);
2213
2214	//getItemWeight(uid[, precise = true])
2215	lua_register(m_luaState, "getItemWeight", LuaScriptInterface::luaGetItemWeight);
2216
2217	//hasItemProperty(uid)
2218	lua_register(m_luaState, "hasItemProperty", LuaScriptInterface::luaHasItemProperty);
2219	
2220	//hasPlayerClient(cid)
2221	lua_register(m_luaState, "hasPlayerClient", LuaScriptInterface::luaHasPlayerClient);
2222
2223	//isIpBanished(ip[, mask])
2224	lua_register(m_luaState, "isIpBanished", LuaScriptInterface::luaIsIpBanished);
2225
2226	//isPlayerBanished(name/guid, type)
2227	lua_register(m_luaState, "isPlayerBanished", LuaScriptInterface::luaIsPlayerBanished);
2228
2229	//isAccountBanished(accountId[, playerId])
2230	lua_register(m_luaState, "isAccountBanished", LuaScriptInterface::luaIsAccountBanished);
2231	
2232	//luaIsWalkablefloor(...)
2233	lua_register(m_luaState, "isWalkablefloor", LuaScriptInterface::luaIsWalkablefloor);
2234
2235	//doAddIpBanishment(...)
2236	lua_register(m_luaState, "doAddIpBanishment", LuaScriptInterface::luaDoAddIpBanishment);
2237
2238	//doAddPlayerBanishment(...)
2239	lua_register(m_luaState, "doAddPlayerBanishment", LuaScriptInterface::luaDoAddPlayerBanishment);
2240
2241	//doAddAccountBanishment(...)
2242	lua_register(m_luaState, "doAddAccountBanishment", LuaScriptInterface::luaDoAddAccountBanishment);
2243
2244	//doAddNotation(...)
2245	lua_register(m_luaState, "doAddNotation", LuaScriptInterface::luaDoAddNotation);
2246
2247	//doAddStatement(...)
2248	lua_register(m_luaState, "doAddStatement", LuaScriptInterface::luaDoAddStatement);
2249
2250	//doRemoveIpBanishment(ip[, mask])
2251	lua_register(m_luaState, "doRemoveIpBanishment", LuaScriptInterface::luaDoRemoveIpBanishment);
2252
2253	//doRemovePlayerBanishment(name/guid, type)
2254	lua_register(m_luaState, "doRemovePlayerBanishment", LuaScriptInterface::luaDoRemovePlayerBanishment);
2255
2256	//doRemoveAccountBanishment(accountId[, playerId])
2257	lua_register(m_luaState, "doRemoveAccountBanishment", LuaScriptInterface::luaDoRemoveAccountBanishment);
2258
2259	//doRemoveNotations(accountId[, playerId])
2260	lua_register(m_luaState, "doRemoveNotations", LuaScriptInterface::luaDoRemoveNotations);
2261
2262	//doRemoveStatements(name/guid[, channelId])
2263	lua_register(m_luaState, "doRemoveStatements", LuaScriptInterface::luaDoRemoveStatements);
2264
2265	//getNotationsCount(accountId[, playerId])
2266	lua_register(m_luaState, "getNotationsCount", LuaScriptInterface::luaGetNotationsCount);
2267
2268	//getStatementsCount(name/guid[, channelId])
2269	lua_register(m_luaState, "getStatementsCount", LuaScriptInterface::luaGetStatementsCount);
2270
2271	//getBanData(value[, type[, param]])
2272	lua_register(m_luaState, "getBanData", LuaScriptInterface::luaGetBanData);
2273
2274	//getBanReason(id)
2275	lua_register(m_luaState, "getBanReason", LuaScriptInterface::luaGetBanReason);
2276
2277	//getBanAction(id)
2278	lua_register(m_luaState, "getBanAction", LuaScriptInterface::luaGetBanAction);
2279
2280	//getBanList(type[, value[, param]])
2281	lua_register(m_luaState, "getBanList", LuaScriptInterface::luaGetBanList);
2282
2283	//getExperienceStage(level)
2284	lua_register(m_luaState, "getExperienceStage", LuaScriptInterface::luaGetExperienceStage);
2285
2286	//getDataDir()
2287	lua_register(m_luaState, "getDataDir", LuaScriptInterface::luaGetDataDir);
2288
2289	//getLogsDir()
2290	lua_register(m_luaState, "getLogsDir", LuaScriptInterface::luaGetLogsDir);
2291
2292	//getConfigFile()
2293	lua_register(m_luaState, "getConfigFile", LuaScriptInterface::luaGetConfigFile);
2294
2295	//getConfigValue(key)
2296	lua_register(m_luaState, "getConfigValue", LuaScriptInterface::luaGetConfigValue);
2297
2298	//getModList()
2299	lua_register(m_luaState, "getModList", LuaScriptInterface::luaGetModList);
2300
2301	//getHighscoreString(skillId)
2302	lua_register(m_luaState, "getHighscoreString", LuaScriptInterface::luaGetHighscoreString);
2303
2304	//getWaypointPosition(name)
2305	lua_register(m_luaState, "getWaypointPosition", LuaScriptInterface::luaGetWaypointPosition);
2306
2307	//doWaypointAddTemporial(name, pos)
2308	lua_register(m_luaState, "doWaypointAddTemporial", LuaScriptInterface::luaDoWaypointAddTemporial);
2309
2310	//getGameState()
2311	lua_register(m_luaState, "getGameState", LuaScriptInterface::luaGetGameState);
2312
2313	//doSetGameState(id)
2314	lua_register(m_luaState, "doSetGameState", LuaScriptInterface::luaDoSetGameState);
2315
2316	//doExecuteRaid(name)
2317	lua_register(m_luaState, "doExecuteRaid", LuaScriptInterface::luaDoExecuteRaid);
2318
2319	//doCreatureExecuteTalkAction(cid, text[, ignoreAccess[, channelId]])
2320	lua_register(m_luaState, "doCreatureExecuteTalkAction", LuaScriptInterface::luaDoCreatureExecuteTalkAction);
2321
2322	//doReloadInfo(id[, cid])
2323	lua_register(m_luaState, "doReloadInfo", LuaScriptInterface::luaDoReloadInfo);
2324
2325	//doSaveServer()
2326	lua_register(m_luaState, "doSaveServer", LuaScriptInterface::luaDoSaveServer);
2327
2328	//doCleanHouse(houseId)
2329	lua_register(m_luaState, "doCleanHouse", LuaScriptInterface::luaDoCleanHouse);
2330
2331	//doCleanMap()
2332	lua_register(m_luaState, "doCleanMap", LuaScriptInterface::luaDoCleanMap);
2333
2334	//doRefreshMap()
2335	lua_register(m_luaState, "doRefreshMap", LuaScriptInterface::luaDoRefreshMap);
2336
2337	//doUpdateHouseAuctions()
2338	lua_register(m_luaState, "doUpdateHouseAuctions", LuaScriptInterface::luaDoUpdateHouseAuctions);
2339
2340	//loadmodlib(lib)
2341	lua_register(m_luaState, "loadmodlib", LuaScriptInterface::luaL_loadmodlib);
2342
2343	//domodlib(lib)
2344	lua_register(m_luaState, "domodlib", LuaScriptInterface::luaL_domodlib);
2345
2346	//dodirectory(dir)
2347	lua_register(m_luaState, "dodirectory", LuaScriptInterface::luaL_dodirectory);
2348
2349	//db table
2350	luaL_register(m_luaState, "db", LuaScriptInterface::luaDatabaseTable);
2351
2352	//result table
2353	luaL_register(m_luaState, "result", LuaScriptInterface::luaResultTable);
2354
2355	//bit table
2356	luaL_register(m_luaState, "bit", LuaScriptInterface::luaBitTable);
2357
2358	//std table
2359	luaL_register(m_luaState, "std", LuaScriptInterface::luaStdTable);
2360}
2361
2362const luaL_Reg LuaScriptInterface::luaDatabaseTable[] =
2363{
2364	//db.executeQuery(query)
2365	{"executeQuery", LuaScriptInterface::luaDatabaseExecute},
2366
2367	//db.storeQuery(query)
2368	{"storeQuery", LuaScriptInterface::luaDatabaseStoreQuery},
2369
2370	//db.escapeString(str)
2371	{"escapeString", LuaScriptInterface::luaDatabaseEscapeString},
2372
2373	//db.escapeBlob(s, length)
2374	{"escapeBlob", LuaScriptInterface::luaDatabaseEscapeBlob},
2375
2376	//db.lastInsertId()
2377	{"lastInsertId", LuaScriptInterface::luaDatabaseLastInsertId},
2378
2379	//db.stringComparison()
2380	{"stringComparison", LuaScriptInterface::luaDatabaseStringComparison},
2381
2382	//db.updateLimiter()
2383	{"updateLimiter", LuaScriptInterface::luaDatabaseUpdateLimiter},
2384
2385	{NULL,NULL}
2386};
2387
2388const luaL_Reg LuaScriptInterface::luaResultTable[] =
2389{
2390	//result.getDataInt(resId, s)
2391	{"getDataInt", LuaScriptInterface::luaResultGetDataInt},
2392
2393	//result.getDataLong(resId, s)
2394	{"getDataLong", LuaScriptInterface::luaResultGetDataLong},
2395
2396	//result.getDataString(resId, s)
2397	{"getDataString", LuaScriptInterface::luaResultGetDataString},
2398
2399	//result.getDataStream(resId, s, length)
2400	{"getDataStream", LuaScriptInterface::luaResultGetDataStream},
2401
2402	//result.next(resId)
2403	{"next", LuaScriptInterface::luaResultNext},
2404
2405	//result.free(resId)
2406	{"free", LuaScriptInterface::luaResultFree},
2407
2408	{NULL,NULL}
2409};
2410
2411const luaL_Reg LuaScriptInterface::luaBitTable[] =
2412{
2413	//{"cast", LuaScriptInterface::luaBitCast},
2414	{"bnot", LuaScriptInterface::luaBitNot},
2415	{"band", LuaScriptInterface::luaBitAnd},
2416	{"bor", LuaScriptInterface::luaBitOr},
2417	{"bxor", LuaScriptInterface::luaBitXor},
2418	{"lshift", LuaScriptInterface::luaBitLeftShift},
2419	{"rshift", LuaScriptInterface::luaBitRightShift},
2420	//{"arshift", LuaScriptInterface::luaBitArithmeticalRightShift},
2421
2422	//{"ucast", LuaScriptInterface::luaBitUCast},
2423	{"ubnot", LuaScriptInterface::luaBitUNot},
2424	{"uband", LuaScriptInterface::luaBitUAnd},
2425	{"ubor", LuaScriptInterface::luaBitUOr},
2426	{"ubxor", LuaScriptInterface::luaBitUXor},
2427	{"ulshift", LuaScriptInterface::luaBitULeftShift},
2428	{"urshift", LuaScriptInterface::luaBitURightShift},
2429	//{"uarshift", LuaScriptInterface::luaBitUArithmeticalRightShift},
2430
2431	{NULL,NULL}
2432};
2433
2434const luaL_Reg LuaScriptInterface::luaStdTable[] =
2435{
2436	{"cout", LuaScriptInterface::luaStdCout},
2437	{"cerr", LuaScriptInterface::luaStdCerr},
2438	{"clog", LuaScriptInterface::luaStdClog},
2439
2440	{"md5", LuaScriptInterface::luaStdMD5},
2441	{"sha1", LuaScriptInterface::luaStdSHA1},
2442
2443	{NULL, NULL}
2444};
2445
2446int32_t LuaScriptInterface::internalGetPlayerInfo(lua_State* L, PlayerInfo_t info)
2447{
2448	ScriptEnviroment* env = getEnv();
2449	const Player* player = env->getPlayerByUID(popNumber(L));
2450	if(!player)
2451	{
2452		std::stringstream s;
2453		s << getError(LUA_ERROR_PLAYER_NOT_FOUND) << " when requesting player info #" << info;
2454		errorEx(s.str());
2455
2456		lua_pushboolean(L, false);
2457		return 1;
2458	}
2459
2460	int64_t value = 0;
2461	Position pos;
2462	switch(info)
2463	{
2464		case PlayerInfoNameDescription:
2465			lua_pushstring(L, player->getNameDescription().c_str());
2466			return 1;
2467		case PlayerInfoSpecialDescription:
2468			lua_pushstring(L, player->getSpecialDescription().c_str());
2469			return 1;
2470		case PlayerInfoAccess:
2471			value = player->getAccess();
2472			break;
2473		case PlayerInfoGhostAccess:
2474			value = player->getGhostAccess();
2475			break;
2476		case PlayerInfoLevel:
2477			value = player->getLevel();
2478			break;
2479		case PlayerInfoExperience:
2480			value = player->getExperience();
2481			break;
2482		case PlayerInfoManaSpent:
2483			value = player->getSpentMana();
2484			break;
2485		case PlayerInfoTown:
2486			value = player->getTown();
2487			break;
2488		case PlayerInfoPromotionLevel:
2489			value = player->getPromotionLevel();
2490			break;
2491		case PlayerInfoGUID:
2492			value = player->getGUID();
2493			break;
2494		case PlayerInfoAccountId:
2495			value = player->getAccount();
2496			break;
2497		case PlayerInfoAccount:
2498			lua_pushstring(L, player->getAccountName().c_str());
2499			return 1;
2500		case PlayerInfoPremiumDays:
2501			value = player->getPremiumDays();
2502			break;
2503		case PlayerInfoFood:
2504		{
2505			if(Condition* condition = player->getCondition(CONDITION_REGENERATION, CONDITIONID_DEFAULT))
2506				value = condition->getTicks() / 1000;
2507
2508			break;
2509		}
2510		case PlayerInfoVocation:
2511			value = player->getVocationId();
2512			break;
2513		case PlayerInfoSoul:
2514			value = player->getSoul();
2515			break;
2516		case PlayerInfoFreeCap:
2517			value = (int64_t)player->getFreeCapacity();
2518			break;
2519		case PlayerInfoGuildId:
2520			value = player->getGuildId();
2521			break;
2522		case PlayerInfoGuildName:
2523			lua_pushstring(L, player->getGuildName().c_str());
2524			return 1;
2525		case PlayerInfoGuildRankId:
2526			value = player->getRankId();
2527			break;
2528		case PlayerInfoGuildRank:
2529			lua_pushstring(L, player->getRankName().c_str());
2530			return 1;
2531		case PlayerInfoGuildLevel:
2532			value = player->getGuildLevel();
2533			break;
2534		case PlayerInfoGuildNick:
2535			lua_pushstring(L, player->getGuildNick().c_str());
2536			return 1;
2537		case PlayerInfoGroupId:
2538			value = player->getGroupId();
2539			break;
2540		case PlayerInfoBalance:
2541			value = (g_config.getBool(ConfigManager::BANK_SYSTEM) ? player->balance : 0);
2542			break;
2543		case PlayerInfoStamina:
2544			value = player->getStaminaMinutes();
2545			break;
2546		case PlayerInfoLossSkill:
2547			lua_pushboolean(L, player->getLossSkill());
2548			return 1;
2549		case PlayerInfoMarriage:
2550			value = player->marriage;
2551			break;
2552		case PlayerInfoPzLock:
2553			lua_pushboolean(L, player->isPzLocked());
2554			return 1;
2555		case PlayerInfoSaving:
2556			lua_pushboolean(L, player->isSaving());
2557			return 1;
2558		case PlayerInfoIp:
2559			value = player->getIP();
2560			break;
2561		case PlayerInfoSkullEnd:
2562			value = player->getSkullEnd();
2563			break;
2564		case PlayerInfoOutfitWindow:
2565			player->sendOutfitWindow();
2566			lua_pushboolean(L, true);
2567			return 1;
2568		case PlayerInfoIdleTime:
2569			value = player->getIdleTime();
2570			break;
2571		case PlayerInfoClient:
2572			lua_pushboolean(L, player->hasClient());
2573			return 1;
2574		case PlayerInfoLastLoad:
2575			value = player->getLastLoad();
2576			break;
2577		case PlayerInfoLastLogin:
2578			value = player->getLastLogin();
2579			break;
2580		case PlayerInfoAccountManager:
2581			value = player->accountManager;
2582			break;
2583		default:
2584			errorEx("Unknown player info #" + info);
2585			value = 0;
2586			break;
2587	}
2588
2589	lua_pushnumber(L, value);
2590	return 1;
2591}
2592
2593//getPlayer[Info](uid)
2594int32_t LuaScriptInterface::luaGetPlayerNameDescription(lua_State* L)
2595{
2596	return internalGetPlayerInfo(L, PlayerInfoNameDescription);
2597}
2598
2599int32_t LuaScriptInterface::luaGetPlayerSpecialDescription(lua_State* L)
2600{
2601	return internalGetPlayerInfo(L, PlayerInfoSpecialDescription);
2602}
2603
2604int32_t LuaScriptInterface::luaGetPlayerFood(lua_State* L)
2605{
2606	return internalGetPlayerInfo(L, PlayerInfoFood);
2607}
2608
2609int32_t LuaScriptInterface::luaGetPlayerAccess(lua_State* L)
2610{
2611	return internalGetPlayerInfo(L, PlayerInfoAccess);
2612}
2613
2614int32_t LuaScriptInterface::luaGetPlayerGhostAccess(lua_State* L)
2615{
2616	return internalGetPlayerInfo(L, PlayerInfoGhostAccess);
2617}
2618
2619int32_t LuaScriptInterface::luaGetPlayerLevel(lua_State* L)
2620{
2621	return internalGetPlayerInfo(L, PlayerInfoLevel);
2622}
2623
2624int32_t LuaScriptInterface::luaGetPlayerExperience(lua_State* L)
2625{
2626	return internalGetPlayerInfo(L, PlayerInfoExperience);
2627}
2628
2629int32_t LuaScriptInterface::luaGetPlayerSpentMana(lua_State* L)
2630{
2631	return internalGetPlayerInfo(L, PlayerInfoManaSpent);
2632}
2633
2634int32_t LuaScriptInterface::luaGetPlayerVocation(lua_State* L)
2635{
2636	return internalGetPlayerInfo(L, PlayerInfoVocation);
2637}
2638
2639int32_t LuaScriptInterface::luaGetPlayerSoul(lua_State* L)
2640{
2641	return internalGetPlayerInfo(L, PlayerInfoSoul);
2642}
2643
2644int32_t LuaScriptInterface::luaGetPlayerFreeCap(lua_State* L)
2645{
2646	return internalGetPlayerInfo(L, PlayerInfoFreeCap);
2647}
2648
2649int32_t LuaScriptInterface::luaGetPlayerGuildId(lua_State* L)
2650{
2651	return internalGetPlayerInfo(L, PlayerInfoGuildId);
2652}
2653
2654int32_t LuaScriptInterface::luaGetPlayerGuildName(lua_State* L)
2655{
2656	return internalGetPlayerInfo(L, PlayerInfoGuildName);
2657}
2658
2659int32_t LuaScriptInterface::luaGetPlayerGuildRankId(lua_State* L)
2660{
2661	return internalGetPlayerInfo(L, PlayerInfoGuildRankId);
2662}
2663
2664int32_t LuaScriptInterface::luaGetPlayerGuildRank(lua_State* L)
2665{
2666	return internalGetPlayerInfo(L, PlayerInfoGuildRank);
2667}
2668
2669int32_t LuaScriptInterface::luaGetPlayerGuildLevel(lua_State* L)
2670{
2671	return internalGetPlayerInfo(L, PlayerInfoGuildLevel);
2672}
2673
2674int32_t LuaScriptInterface::luaGetPlayerGuildNick(lua_State* L)
2675{
2676	return internalGetPlayerInfo(L, PlayerInfoGuildNick);
2677}
2678
2679int32_t LuaScriptInterface::luaGetPlayerTown(lua_State* L)
2680{
2681	return internalGetPlayerInfo(L, PlayerInfoTown);
2682}
2683
2684int32_t LuaScriptInterface::luaGetPlayerPromotionLevel(lua_State* L)
2685{
2686	return internalGetPlayerInfo(L, PlayerInfoPromotionLevel);
2687}
2688
2689int32_t LuaScriptInterface::luaGetPlayerGroupId(lua_State* L)
2690{
2691	return internalGetPlayerInfo(L, PlayerInfoGroupId);
2692}
2693
2694int32_t LuaScriptInterface::luaGetPlayerGUID(lua_State* L)
2695{
2696	return internalGetPlayerInfo(L, PlayerInfoGUID);
2697}
2698
2699int32_t LuaScriptInterface::luaGetPlayerAccountId(lua_State* L)
2700{
2701	return internalGetPlayerInfo(L, PlayerInfoAccountId);
2702}
2703
2704int32_t LuaScriptInterface::luaGetPlayerAccount(lua_State* L)
2705{
2706	return internalGetPlayerInfo(L, PlayerInfoAccount);
2707}
2708
2709int32_t LuaScriptInterface::luaGetPlayerPremiumDays(lua_State* L)
2710{
2711	return internalGetPlayerInfo(L, PlayerInfoPremiumDays);
2712}
2713
2714int32_t LuaScriptInterface::luaGetPlayerBalance(lua_State* L)
2715{
2716	return internalGetPlayerInfo(L, PlayerInfoBalance);
2717}
2718
2719int32_t LuaScriptInterface::luaGetPlayerStamina(lua_State* L)
2720{
2721	return internalGetPlayerInfo(L, PlayerInfoStamina);
2722}
2723
2724int32_t LuaScriptInterface::luaGetPlayerLossSkill(lua_State* L)
2725{
2726	return internalGetPlayerInfo(L, PlayerInfoLossSkill);
2727}
2728
2729int32_t LuaScriptInterface::luaGetPlayerPartner(lua_State* L)
2730{
2731	return internalGetPlayerInfo(L, PlayerInfoMarriage);
2732}
2733
2734int32_t LuaScriptInterface::luaIsPlayerPzLocked(lua_State* L)
2735{
2736	return internalGetPlayerInfo(L, PlayerInfoPzLock);
2737}
2738
2739int32_t LuaScriptInterface::luaIsPlayerSaving(lua_State* L)
2740{
2741	return internalGetPlayerInfo(L, PlayerInfoSaving);
2742}
2743
2744int32_t LuaScriptInterface::luaGetPlayerIp(lua_State* L)
2745{
2746	return internalGetPlayerInfo(L, PlayerInfoIp);
2747}
2748
2749int32_t LuaScriptInterface::luaGetPlayerSkullEnd(lua_State* L)
2750{
2751	return internalGetPlayerInfo(L, PlayerInfoSkullEnd);
2752}
2753
2754int32_t LuaScriptInterface::luaDoPlayerSendOutfitWindow(lua_State* L)
2755{
2756	return internalGetPlayerInfo(L, PlayerInfoOutfitWindow);
2757}
2758
2759int32_t LuaScriptInterface::luaGetPlayerIdleTime(lua_State* L)
2760{
2761	return internalGetPlayerInfo(L, PlayerInfoIdleTime);
2762}
2763
2764int32_t LuaScriptInterface::luaHasPlayerClient(lua_State* L)
2765{
2766	return internalGetPlayerInfo(L, PlayerInfoClient);
2767}
2768
2769int32_t LuaScriptInterface::luaGetPlayerLastLoad(lua_State* L)
2770{
2771	return internalGetPlayerInfo(L, PlayerInfoLastLoad);
2772}
2773
2774int32_t LuaScriptInterface::luaGetPlayerLastLogin(lua_State* L)
2775{
2776	return internalGetPlayerInfo(L, PlayerInfoLastLogin);
2777}
2778
2779int32_t LuaScriptInterface::luaGetPlayerAccountManager(lua_State* L)
2780{
2781	return internalGetPlayerInfo(L, PlayerInfoAccountManager);
2782}
2783//
2784
2785int32_t LuaScriptInterface::luaGetPlayerSex(lua_State* L)
2786{
2787	//getPlayerSex(cid[, full = false])
2788	bool full = false;
2789	if(lua_gettop(L) > 1)
2790		full = popNumber(L);
2791
2792	ScriptEnviroment* env = getEnv();
2793	Player* player = env->getPlayerByUID((uint32_t)popNumber(L));
2794	if(!player)
2795	{
2796		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2797		lua_pushboolean(L, false);
2798	}
2799	else
2800		lua_pushnumber(L, player->getSex(full));
2801
2802	return 1;
2803}
2804
2805int32_t LuaScriptInterface::luaDoPlayerSetNameDescription(lua_State* L)
2806{
2807	//doPlayerSetNameDescription(cid, description)
2808	std::string description = popString(L);
2809
2810	ScriptEnviroment* env = getEnv();
2811	if(Player* player = env->getPlayerByUID(popNumber(L)))
2812	{
2813		player->nameDescription += description;
2814		lua_pushboolean(L, true);
2815	}
2816	else
2817	{
2818		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2819		lua_pushboolean(L, false);
2820	}
2821	return 1;
2822}
2823
2824int32_t LuaScriptInterface::luaDoPlayerSetSpecialDescription(lua_State* L)
2825{
2826	//doPlayerSetSpecialDescription(cid, description)
2827	std::string description = popString(L);
2828
2829	ScriptEnviroment* env = getEnv();
2830	if(Player* player = env->getPlayerByUID(popNumber(L)))
2831	{
2832		player->setSpecialDescription(description);
2833		lua_pushboolean(L, true);
2834	}
2835	else
2836	{
2837		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2838		lua_pushboolean(L, false);
2839	}
2840	return 1;
2841}
2842
2843int32_t LuaScriptInterface::luaGetPlayerMagLevel(lua_State* L)
2844{
2845	//getPlayerMagLevel(cid[, ignoreBuffs = false])
2846	bool ignoreBuffs = false;
2847	if(lua_gettop(L) > 1)
2848		ignoreBuffs = popNumber(L);
2849
2850	ScriptEnviroment* env = getEnv();
2851	if(const Player* player = env->getPlayerByUID(popNumber(L)))
2852		lua_pushnumber(L, (ignoreBuffs ? player->magLevel : player->getMagicLevel()));
2853	else
2854	{
2855		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2856		lua_pushboolean(L, false);
2857	}
2858
2859	return 1;
2860}
2861
2862int32_t LuaScriptInterface::luaGetPlayerRequiredMana(lua_State* L)
2863{
2864	//getPlayerRequiredMana(cid, magicLevel)
2865	uint32_t magLevel = popNumber(L);
2866
2867	ScriptEnviroment* env = getEnv();
2868	if(Player* player = env->getPlayerByUID(popNumber(L)))
2869		lua_pushnumber(L, player->vocation->getReqMana(magLevel));
2870	else
2871	{
2872		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2873		lua_pushboolean(L, false);
2874	}
2875
2876	return 1;
2877}
2878
2879int32_t LuaScriptInterface::luaGetPlayerRequiredSkillTries(lua_State* L)
2880{
2881	//getPlayerRequiredSkillTries(cid, skillId, skillLevel)
2882	int32_t sLevel = popNumber(L), sId = popNumber(L);
2883
2884	ScriptEnviroment* env = getEnv();
2885	if(Player* player = env->getPlayerByUID(popNumber(L)))
2886		lua_pushnumber(L, player->vocation->getReqSkillTries(sId, sLevel));
2887	else
2888	{
2889		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2890		lua_pushboolean(L, false);
2891	}
2892
2893	return 1;
2894}
2895
2896int32_t LuaScriptInterface::luaGetPlayerFlagValue(lua_State* L)
2897{
2898	//getPlayerFlagValue(cid, flag)
2899	uint32_t index = popNumber(L);
2900
2901	ScriptEnviroment* env = getEnv();
2902	if(Player* player = env->getPlayerByUID(popNumber(L)))
2903	{
2904		if(index < PlayerFlag_LastFlag)
2905			lua_pushboolean(L, player->hasFlag((PlayerFlags)index));
2906		else
2907		{
2908			std::stringstream ss;
2909			ss << index;
2910			errorEx("No valid flag index - " + ss.str());
2911			lua_pushboolean(L, false);
2912		}
2913	}
2914	else
2915	{
2916		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2917		lua_pushboolean(L, false);
2918	}
2919
2920	return 1;
2921}
2922
2923int32_t LuaScriptInterface::luaGetPlayerCustomFlagValue(lua_State* L)
2924{
2925	//getPlayerCustomFlagValue(cid, flag)
2926	uint32_t index = popNumber(L);
2927
2928	ScriptEnviroment* env = getEnv();
2929	if(Player* player = env->getPlayerByUID(popNumber(L)))
2930	{
2931		if(index < PlayerCustomFlag_LastFlag)
2932			lua_pushboolean(L, player->hasCustomFlag((PlayerCustomFlags)index));
2933		else
2934		{
2935			std::stringstream ss;
2936			ss << index;
2937			errorEx("No valid flag index - " + ss.str());
2938			lua_pushboolean(L, false);
2939		}
2940	}
2941	else
2942	{
2943		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2944		lua_pushboolean(L, false);
2945	}
2946
2947	return 1;
2948}
2949
2950int32_t LuaScriptInterface::luaDoPlayerLearnInstantSpell(lua_State* L)
2951{
2952	//doPlayerLearnInstantSpell(cid, name)
2953	std::string spellName = popString(L);
2954
2955	ScriptEnviroment* env = getEnv();
2956	Player* player = env->getPlayerByUID(popNumber(L));
2957	if(!player)
2958	{
2959		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2960		lua_pushboolean(L, false);
2961		return 1;
2962	}
2963
2964	InstantSpell* spell = g_spells->getInstantSpellByName(spellName);
2965	if(!spell)
2966	{
2967		lua_pushboolean(L, false);
2968		return 1;
2969	}
2970
2971	player->learnInstantSpell(spell->getName());
2972	lua_pushboolean(L, true);
2973	return 1;
2974}
2975
2976int32_t LuaScriptInterface::luaDoPlayerUnlearnInstantSpell(lua_State* L)
2977{
2978	//doPlayerUnlearnInstantSpell(cid, name)
2979	std::string spellName = popString(L);
2980
2981	ScriptEnviroment* env = getEnv();
2982	Player* player = env->getPlayerByUID(popNumber(L));
2983	if(!player)
2984	{
2985		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2986		lua_pushboolean(L, false);
2987		return 1;
2988	}
2989
2990	InstantSpell* spell = g_spells->getInstantSpellByName(spellName);
2991	if(!spell)
2992	{
2993		lua_pushboolean(L, false);
2994		return 1;
2995	}
2996
2997	player->unlearnInstantSpell(spell->getName());
2998	lua_pushboolean(L, true);
2999	return 1;
3000}
3001
3002int32_t LuaScriptInterface::luaGetPlayerLearnedInstantSpell(lua_State* L)
3003{
3004	//getPlayerLearnedInstantSpell(cid, name)
3005	std::string spellName = popString(L);
3006
3007	ScriptEnviroment* env = getEnv();
3008	Player* player = env->getPlayerByUID(popNumber(L));
3009	if(!player)
3010	{
3011		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3012		lua_pushboolean(L, false);
3013		return 1;
3014	}
3015
3016	InstantSpell* spell = g_spells->getInstantSpellByName(spellName);
3017	if(!spell)
3018	{
3019		lua_pushboolean(L, false);
3020		return 1;
3021	}
3022
3023	lua_pushboolean(L, player->hasLearnedInstantSpell(spellName));
3024	return 1;
3025}
3026
3027int32_t LuaScriptInterface::luaGetPlayerInstantSpellCount(lua_State* L)
3028{
3029	//getPlayerInstantSpellCount(cid)
3030	ScriptEnviroment* env = getEnv();
3031	if(Player* player = env->getPlayerByUID(popNumber(L)))
3032		lua_pushnumber(L, g_spells->getInstantSpellCount(player));
3033	else
3034	{
3035		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3036		lua_pushboolean(L, false);
3037	}
3038	return 1;
3039}
3040
3041int32_t LuaScriptInterface::luaGetPlayerInstantSpellInfo(lua_State* L)
3042{
3043	//getPlayerInstantSpellInfo(cid, index)
3044	uint32_t index = popNumber(L);
3045
3046	ScriptEnviroment* env = getEnv();
3047	Player* player = env->getPlayerByUID(popNumber(L));
3048	if(!player)
3049	{
3050		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3051		lua_pushboolean(L, false);
3052		return 1;
3053	}
3054
3055	InstantSpell* spell = g_spells->getInstantSpellByIndex(player, index);
3056	if(!spell)
3057	{
3058		errorEx(getError(LUA_ERROR_SPELL_NOT_FOUND));
3059		lua_pushboolean(L, false);
3060		return 1;
3061	}
3062
3063	lua_newtable(L);
3064	setField(L, "name", spell->getName());
3065	setField(L, "words", spell->getWords());
3066	setField(L, "level", spell->getLevel());
3067	setField(L, "mlevel", spell->getMagicLevel());
3068	setField(L, "mana", spell->getManaCost(player));
3069	setField(L, "manapercent", spell->getManaPercent());
3070	return 1;
3071}
3072
3073int32_t LuaScriptInterface::luaGetInstantSpellInfo(lua_State* L)
3074{
3075	//getInstantSpellInfo(name)
3076	InstantSpell* spell = g_spells->getInstantSpellByName(popString(L));
3077	if(!spell)
3078	{
3079		errorEx(getError(LUA_ERROR_SPELL_NOT_FOUND));
3080		lua_pushboolean(L, false);
3081		return 1;
3082	}
3083
3084	lua_newtable(L);
3085	setField(L, "name", spell->getName());
3086	setField(L, "words", spell->getWords());
3087	setField(L, "level", spell->getLevel());
3088	setField(L, "mlevel", spell->getMagicLevel());
3089	setField(L, "mana", spell->getManaCost(NULL));
3090	setField(L, "manapercent", spell->getManaPercent());
3091	return 1;
3092}
3093
3094int32_t LuaScriptInterface::luaDoRemoveItem(lua_State* L)
3095{
3096	//doRemoveItem(uid[, count])
3097	int32_t count = -1;
3098	if(lua_gettop(L) > 1)
3099		count = popNumber(L);
3100
3101	ScriptEnviroment* env = getEnv();
3102	Item* item = env->getItemByUID(popNumber(L));
3103	if(!item)
3104	{
3105		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
3106		lua_pushboolean(L, false);
3107		return 1;
3108	}
3109
3110	if(g_game.internalRemoveItem(NULL, item, count) != RET_NOERROR)
3111	{
3112		lua_pushboolean(L, false);
3113		return 1;
3114	}
3115
3116	lua_pushboolean(L, true);
3117	return 1;
3118}
3119
3120int32_t LuaScriptInterface::luaDoPlayerRemoveItem(lua_State* L)
3121{
3122	//doPlayerRemoveItem(cid, itemid, count[, subType])
3123	int32_t subType = -1;
3124	if(lua_gettop(L) > 3)
3125		subType = popNumber(L);
3126
3127	uint32_t count = popNumber(L);
3128	uint16_t itemId = (uint16_t)popNumber(L);
3129
3130	ScriptEnviroment* env = getEnv();
3131	if(Player* player = env->getPlayerByUID(popNumber(L)))
3132		lua_pushboolean(L, g_game.removeItemOfType(player, itemId, count, subType));
3133	else
3134	{
3135		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3136		lua_pushboolean(L, false);
3137	}
3138	return 1;
3139}
3140
3141int32_t LuaScriptInterface::luaDoFeedPlayer(lua_State* L)
3142{
3143	//doFeedPlayer(cid, food)
3144	int32_t food = (int32_t)popNumber(L);
3145
3146	ScriptEnviroment* env = getEnv();
3147	if(Player* player = env->getPlayerByUID(popNumber(L)))
3148	{
3149		player->addDefaultRegeneration((food * 1000) * 3);
3150		lua_pushboolean(L, true);
3151	}
3152	else
3153	{
3154		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3155		lua_pushboolean(L, false);
3156	}
3157	return 1;
3158}
3159
3160int32_t LuaScriptInterface::luaDoPlayerSendCancel(lua_State* L)
3161{
3162	//doPlayerSendCancel(cid, text)
3163	std::string text = popString(L);
3164	ScriptEnviroment* env = getEnv();
3165	if(const Player* player = env->getPlayerByUID(popNumber(L)))
3166	{
3167		player->sendCancel(text);
3168		lua_pushboolean(L, true);
3169	}
3170	else
3171	{
3172		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3173		lua_pushboolean(L, false);
3174	}
3175	return 1;
3176}
3177
3178int32_t LuaScriptInterface::luaDoSendDefaultCancel(lua_State* L)
3179{
3180	//doPlayerSendDefaultCancel(cid, ReturnValue)
3181	ReturnValue ret = (ReturnValue)popNumber(L);
3182	ScriptEnviroment* env = getEnv();
3183	if(const Player* player = env->getPlayerByUID(popNumber(L)))
3184	{
3185		player->sendCancelMessage(ret);
3186		lua_pushboolean(L, true);
3187	}
3188	else
3189	{
3190		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3191		lua_pushboolean(L, false);
3192	}
3193
3194	return 1;
3195}
3196
3197int32_t LuaScriptInterface::luaGetSearchString(lua_State* L)
3198{
3199	//getSearchString(fromPosition, toPosition[, fromIsCreature = false[, toIsCreature = false]])
3200	PositionEx toPos, fromPos;
3201	bool toIsCreature = false, fromIsCreature = false;
3202
3203	int32_t params = lua_gettop(L);
3204	if(params > 3)
3205		toIsCreature = popNumber(L);
3206
3207	if(params > 2)
3208		fromIsCreature = popNumber(L);
3209
3210	popPosition(L, toPos);
3211	popPosition(L, fromPos);
3212	if(!toPos.x || !toPos.y || !fromPos.x || !fromPos.y)
3213	{
3214		errorEx("wrong position(s) specified.");
3215		lua_pushboolean(L, false);
3216	}
3217	else
3218		lua_pushstring(L, g_game.getSearchString(fromPos, toPos, fromIsCreature, toIsCreature).c_str());
3219
3220	return 1;
3221}
3222
3223int32_t LuaScriptInterface::luaGetClosestFreeTile(lua_State* L)
3224{
3225	//getClosestFreeTile(cid, targetPos[, extended = false[, ignoreHouse = true]])
3226	uint32_t params = lua_gettop(L);
3227	bool ignoreHouse = true, extended = false;
3228	if(params > 3)
3229		ignoreHouse = popNumber(L);
3230
3231	if(params > 2)
3232		extended = popNumber(L);
3233
3234	PositionEx pos;
3235	popPosition(L, pos);
3236
3237	ScriptEnviroment* env = getEnv();
3238	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3239	{
3240		Position newPos = g_game.getClosestFreeTile(creature, pos, extended, ignoreHouse);
3241		if(newPos.x != 0)
3242			pushPosition(L, newPos, 0);
3243		else
3244			lua_pushboolean(L, false);
3245	}
3246	else
3247	{
3248		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3249		lua_pushboolean(L, false);
3250	}
3251	return 1;
3252}
3253
3254int32_t LuaScriptInterface::luaDoTeleportThing(lua_State* L)
3255{
3256	//doTeleportThing(cid, newpos[, pushmove = TRUE])
3257	bool pushMove = true;
3258	if(lua_gettop(L) > 2)
3259		pushMove = popNumber(L);
3260
3261	PositionEx pos;
3262	popPosition(L, pos);
3263
3264	ScriptEnviroment* env = getEnv();
3265	if(Thing* tmp = env->getThingByUID(popNumber(L)))
3266		lua_pushboolean(L, g_game.internalTeleport(tmp, pos, pushMove) == RET_NOERROR);
3267	else
3268	{
3269		errorEx(getError(LUA_ERROR_THING_NOT_FOUND));
3270		lua_pushboolean(L, false);
3271	}
3272	return 1;
3273}
3274
3275int32_t LuaScriptInterface::luaDoTransformItem(lua_State* L)
3276{
3277	//doTransformItem(uid, newId[, count/subType])
3278	int32_t count = -1;
3279	if(lua_gettop(L) > 2)
3280		count = popNumber(L);
3281
3282	uint16_t newId = popNumber(L);
3283	uint32_t uid = popNumber(L);
3284	ScriptEnviroment* env = getEnv();
3285
3286	Item* item = env->getItemByUID(uid);
3287	if(!item)
3288	{
3289		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
3290		lua_pushboolean(L, false);
3291		return 1;
3292	}
3293
3294	const ItemType& it = Item::items[newId];
3295	if(it.stackable && count > 100)
3296		count = 100;
3297
3298	Item* newItem = g_game.transformItem(item, newId, count);
3299	if(item->isRemoved())
3300		env->removeThing(uid);
3301
3302	if(newItem && newItem != item)
3303		env->insertThing(uid, newItem);
3304
3305	lua_pushboolean(L, true);
3306	return 1;
3307}
3308
3309int32_t LuaScriptInterface::luaDoCreatureSay(lua_State* L)
3310{
3311	//doCreatureSay(uid, text[, type = SPEAK_SAY[, ghost = false[, cid = 0[, pos]]]])
3312	uint32_t params = lua_gettop(L), cid = 0, uid = 0;
3313	PositionEx pos;
3314	if(params > 5)
3315		popPosition(L, pos);
3316
3317	if(params > 4)
3318		cid = popNumber(L);
3319
3320	bool ghost = false;
3321	if(params > 3)
3322		ghost = popNumber(L);
3323
3324	SpeakClasses type = SPEAK_SAY;
3325	if(params > 2)
3326		type = (SpeakClasses)popNumber(L);
3327
3328	std::string text = popString(L);
3329
3330	uid = popNumber(L);
3331	if(params > 5 && (!pos.x || !pos.y))
3332	{
3333		errorEx("Invalid position specified.");
3334		lua_pushboolean(L, false);
3335		return 1;
3336	}
3337
3338	ScriptEnviroment* env = getEnv();
3339	Creature* creature = env->getCreatureByUID(uid);
3340	if(!creature)
3341	{
3342		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3343		lua_pushboolean(L, false);
3344		return 1;
3345	}
3346
3347	SpectatorVec list;
3348	if(cid)
3349	{
3350		Creature* target = env->getCreatureByUID(cid);
3351		if(!target)
3352		{
3353			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3354			lua_pushboolean(L, false);
3355			return 1;
3356		}
3357
3358		list.push_back(target);
3359	}
3360
3361	if(params > 5)
3362		lua_pushboolean(L, g_game.internalCreatureSay(creature, type, text, ghost, &list, &pos));
3363	else
3364		lua_pushboolean(L, g_game.internalCreatureSay(creature, type, text, ghost, &list));
3365
3366	return 1;
3367}
3368
3369int32_t LuaScriptInterface::luaDoSendMagicEffect(lua_State* L)
3370{
3371	//doSendMagicEffect(pos, type[, player])
3372	ScriptEnviroment* env = getEnv();
3373	SpectatorVec list;
3374	if(lua_gettop(L) > 2)
3375	{
3376		if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3377			list.push_back(creature);
3378	}
3379
3380	uint32_t type = popNumber(L);
3381	PositionEx pos;
3382
3383	popPosition(L, pos);
3384	if(pos.x == 0xFFFF)
3385		pos = env->getRealPos();
3386
3387	if(!list.empty())
3388		g_game.addMagicEffect(list, pos, type);
3389	else
3390		g_game.addMagicEffect(pos, type);
3391
3392	lua_pushboolean(L, true);
3393	return 1;
3394}
3395
3396int32_t LuaScriptInterface::luaDoSendDistanceShoot(lua_State* L)
3397{
3398	//doSendDistanceShoot(fromPos, toPos, type[, player])
3399	ScriptEnviroment* env = getEnv();
3400	SpectatorVec list;
3401	if(lua_gettop(L) > 3)
3402	{
3403		if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3404			list.push_back(creature);
3405	}
3406
3407	uint32_t type = popNumber(L);
3408	PositionEx toPos, fromPos;
3409
3410	popPosition(L, toPos);
3411	popPosition(L, fromPos);
3412	if(fromPos.x == 0xFFFF)
3413		fromPos = env->getRealPos();
3414
3415	if(toPos.x == 0xFFFF)
3416		toPos = env->getRealPos();
3417
3418	if(!list.empty())
3419		g_game.addDistanceEffect(list, fromPos, toPos, type);
3420	else
3421		g_game.addDistanceEffect(fromPos, toPos, type);
3422
3423	lua_pushboolean(L, true);
3424	return 1;
3425}
3426
3427int32_t LuaScriptInterface::luaDoPlayerAddSkillTry(lua_State* L)
3428{
3429	//doPlayerAddSkillTry(uid, skillid, n[, useMultiplier])
3430	bool multiplier = true;
3431	if(lua_gettop(L) > 3)
3432		multiplier = popNumber(L);
3433
3434	uint32_t n = popNumber(L), skillid = popNumber(L);
3435	ScriptEnviroment* env = getEnv();
3436	if(Player* player = env->getPlayerByUID(popNumber(L)))
3437	{
3438		player->addSkillAdvance((skills_t)skillid, n, multiplier);
3439		lua_pushboolean(L, true);
3440	}
3441	else
3442	{
3443		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3444		lua_pushboolean(L, false);
3445	}
3446	return 1;
3447}
3448
3449int32_t LuaScriptInterface::luaGetCreatureSpeakType(lua_State* L)
3450{
3451	//getCreatureSpeakType(uid)
3452	ScriptEnviroment* env = getEnv();
3453	if(const Creature* creature = env->getCreatureByUID(popNumber(L)))
3454		lua_pushnumber(L, (SpeakClasses)creature->getSpeakType());
3455	else
3456	{
3457		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3458		lua_pushboolean(L, false);
3459	}
3460	return 1;
3461}
3462
3463int32_t LuaScriptInterface::luaDoCreatureSetSpeakType(lua_State* L)
3464{
3465	//doCreatureSetSpeakType(uid, type)
3466	SpeakClasses type = (SpeakClasses)popNumber(L);
3467
3468	ScriptEnviroment* env = getEnv();
3469	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3470	{
3471		if(type < SPEAK_CLASS_FIRST || type > SPEAK_CLASS_LAST)
3472		{
3473			errorEx("Invalid speak type!");
3474			lua_pushboolean(L, false);
3475			return 1;
3476		}
3477
3478		creature->setSpeakType(type);
3479		lua_pushboolean(L, true);
3480	}
3481	else
3482	{
3483		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3484		lua_pushboolean(L, false);
3485	}
3486	return 1;
3487}
3488
3489int32_t LuaScriptInterface::luaGetCreatureHideHealth(lua_State* L)
3490{
3491	//getCreatureHideHealth(cid)
3492	ScriptEnviroment* env = getEnv();
3493
3494	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3495		lua_pushboolean(L, creature->getHideHealth());
3496	else
3497	{
3498		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3499		lua_pushboolean(L, false);
3500	}
3501	return 1;
3502}
3503
3504int32_t LuaScriptInterface::luaDoCreatureSetHideHealth(lua_State* L)
3505{
3506	//doCreatureSetHideHealth(cid, hide)
3507	bool hide = popNumber(L);
3508
3509	ScriptEnviroment* env = getEnv();
3510	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3511	{
3512		creature->setHideHealth(hide);
3513		g_game.addCreatureHealth(creature);
3514		lua_pushboolean(L, true);
3515	}
3516	else
3517	{
3518		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3519		lua_pushboolean(L, false);
3520	}
3521	return 1;
3522}
3523
3524int32_t LuaScriptInterface::luaDoCreatureAddHealth(lua_State* L)
3525{
3526	//doCreatureAddHealth(uid, health[, hitEffect[, hitColor[, force]]])
3527	int32_t params = lua_gettop(L);
3528	bool force = false;
3529	if(params > 4)
3530		force = popNumber(L);
3531
3532	TextColor_t hitColor = TEXTCOLOR_UNKNOWN;
3533	if(params > 3)
3534		hitColor = (TextColor_t)popNumber(L);
3535
3536	MagicEffect_t hitEffect = MAGIC_EFFECT_UNKNOWN;
3537	if(params > 2)
3538		hitEffect = (MagicEffect_t)popNumber(L);
3539
3540	int32_t healthChange = popNumber(L);
3541	ScriptEnviroment* env = getEnv();
3542	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3543	{
3544		if(healthChange) //do not post with 0 value
3545			g_game.combatChangeHealth(healthChange < 1 ? COMBAT_UNDEFINEDDAMAGE : COMBAT_HEALING,
3546				NULL, creature, healthChange, hitEffect, hitColor, force);
3547
3548		lua_pushboolean(L, true);
3549	}
3550	else
3551	{
3552		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3553		lua_pushboolean(L, false);
3554	}
3555
3556	return 1;
3557}
3558
3559int32_t LuaScriptInterface::luaDoCreatureAddMana(lua_State* L)
3560{
3561	//doCreatureAddMana(uid, mana[, aggressive])
3562	bool aggressive = true;
3563	if(lua_gettop(L) > 2)
3564		aggressive = popNumber(L);
3565
3566	int32_t manaChange = popNumber(L);
3567	ScriptEnviroment* env = getEnv();
3568	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3569	{
3570		if(aggressive)
3571			g_game.combatChangeMana(NULL, creature, manaChange);
3572		else
3573			creature->changeMana(manaChange);
3574
3575		lua_pushboolean(L, true);
3576	}
3577	else
3578	{
3579		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3580		lua_pushboolean(L, false);
3581	}
3582	return 1;
3583}
3584
3585int32_t LuaScriptInterface::luaDoPlayerAddSpentMana(lua_State* L)
3586{
3587	//doPlayerAddSpentMana(cid, amount[, useMultiplier])
3588	bool multiplier = true;
3589	if(lua_gettop(L) > 2)
3590		multiplier = popNumber(L);
3591
3592	uint32_t amount = popNumber(L);
3593	ScriptEnviroment* env = getEnv();
3594	if(Player* player = env->getPlayerByUID(popNumber(L)))
3595	{
3596		player->addManaSpent(amount, multiplier);
3597		lua_pushboolean(L, true);
3598	}
3599	else
3600	{
3601		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3602		lua_pushboolean(L, false);
3603	}
3604	return 1;
3605}
3606
3607int32_t LuaScriptInterface::luaDoPlayerAddItem(lua_State* L)
3608{
3609	//doPlayerAddItem(cid, itemid[, count/subtype[, canDropOnMap]])
3610	//doPlayerAddItem(cid, itemid[, count[, canDropOnMap[, subtype]]])
3611	int32_t params = lua_gettop(L), subType = 1;
3612	if(params > 4)
3613		subType = popNumber(L);
3614
3615	bool canDropOnMap = true;
3616	if(params > 3)
3617		canDropOnMap = popNumber(L);
3618
3619	uint32_t count = 1;
3620	if(params > 2)
3621		count = popNumber(L);
3622
3623	uint32_t itemId = popNumber(L);
3624	ScriptEnviroment* env = getEnv();
3625
3626	Player* player = env->getPlayerByUID((uint32_t)popNumber(L));
3627	if(!player)
3628	{
3629		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3630		lua_pushboolean(L, false);
3631		return 1;
3632	}
3633
3634	const ItemType& it = Item::items[itemId];
3635	int32_t itemCount = 1;
3636	if(params > 4)
3637		itemCount = std::max((uint32_t)1, count);
3638	else if(it.hasSubType())
3639	{
3640		if(it.stackable)
3641			itemCount = (int32_t)std::ceil((float)count / 100);
3642
3643		subType = count;
3644	}
3645
3646	while(itemCount > 0)
3647	{
3648		int32_t stackCount = std::min(100, subType);
3649		Item* newItem = Item::CreateItem(itemId, stackCount);
3650		if(!newItem)
3651		{
3652			errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
3653			lua_pushboolean(L, false);
3654			return 1;
3655		}
3656
3657		if(it.stackable)
3658			subType -= stackCount;
3659
3660		ReturnValue ret = g_game.internalPlayerAddItem(NULL, player, newItem, canDropOnMap);
3661		if(ret != RET_NOERROR)
3662		{
3663			delete newItem;
3664			lua_pushboolean(L, false);
3665			return 1;
3666		}
3667
3668		--itemCount;
3669		if(itemCount)
3670			continue;
3671
3672		if(newItem->getParent())
3673			lua_pushnumber(L, env->addThing(newItem));
3674		else //stackable item stacked with existing object, newItem will be released
3675			lua_pushnil(L);
3676
3677		return 1;
3678	}
3679
3680	lua_pushnil(L);
3681	return 1;
3682}
3683
3684int32_t LuaScriptInterface::luaDoPlayerAddItemEx(lua_State* L)
3685{
3686	//doPlayerAddItemEx(cid, uid[, canDropOnMap = false])
3687	bool canDropOnMap = false;
3688	if(lua_gettop(L) > 2)
3689		canDropOnMap = popNumber(L);
3690
3691	uint32_t uid = (uint32_t)popNumber(L);
3692	ScriptEnviroment* env = getEnv();
3693
3694	Player* player = env->getPlayerByUID(popNumber(L));
3695	if(!player)
3696	{
3697		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3698		lua_pushboolean(L, false);
3699		return 1;
3700	}
3701
3702	Item* item = env->getItemByUID(uid);
3703	if(!item)
3704	{
3705		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
3706		lua_pushboolean(L, false);
3707		return 1;
3708	}
3709
3710	if(item->getParent() == VirtualCylinder::virtualCylinder)
3711		lua_pushnumber(L, g_game.internalPlayerAddItem(NULL, player, item, canDropOnMap));
3712	else
3713		lua_pushboolean(L, false);
3714
3715	return 1;
3716}
3717
3718int32_t LuaScriptInterface::luaDoTileAddItemEx(lua_State* L)
3719{
3720	//doTileAddItemEx(pos, uid)
3721	uint32_t uid = (uint32_t)popNumber(L);
3722	PositionEx pos;
3723	popPosition(L, pos);
3724
3725	ScriptEnviroment* env = getEnv();
3726	Tile* tile = g_game.getTile(pos.x, pos.y, pos.z);
3727	if(!tile)
3728	{
3729		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
3730		lua_pushboolean(L, false);
3731		return 1;
3732	}
3733
3734	Item* item = env->getItemByUID(uid);
3735	if(!item)
3736	{
3737		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
3738		lua_pushboolean(L, false);
3739		return 1;
3740	}
3741
3742	if(item->getParent() == VirtualCylinder::virtualCylinder)
3743		lua_pushnumber(L, g_game.internalAddItem(NULL, tile, item));
3744	else
3745		lua_pushboolean(L, false);
3746
3747	return 1;
3748}
3749
3750int32_t LuaScriptInterface::luaDoRelocate(lua_State* L)
3751{
3752	//doRelocate(pos, posTo[, creatures = true])
3753	//Moves all moveable objects from pos to posTo
3754
3755	bool creatures = true;
3756	if(lua_gettop(L) > 2)
3757		creatures = popNumber(L);
3758
3759	PositionEx toPos;
3760	popPosition(L, toPos);
3761
3762	PositionEx fromPos;
3763	popPosition(L, fromPos);
3764
3765	Tile* fromTile = g_game.getTile(fromPos.x, fromPos.y, fromPos.z);
3766	if(!fromTile)
3767	{
3768		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
3769		lua_pushboolean(L, false);
3770		return 1;
3771	}
3772
3773	Tile* toTile = g_game.getTile(toPos.x, toPos.y, toPos.z);
3774	if(!toTile)
3775	{
3776		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
3777		lua_pushboolean(L, false);
3778		return 1;
3779	}
3780
3781	if(fromTile != toTile)
3782	{
3783		for(int32_t i = fromTile->getThingCount() - 1; i >= 0; --i)
3784		{
3785			Thing* thing = fromTile->__getThing(i);
3786			if(thing)
3787			{
3788				if(Item* item = thing->getItem())
3789				{
3790					const ItemType& it = Item::items[item->getID()];
3791					if(!it.isGroundTile() && !it.alwaysOnTop && !it.isMagicField())
3792						g_game.internalTeleport(item, toPos, false, FLAG_IGNORENOTMOVEABLE);
3793				}
3794				else if(creatures)
3795				{
3796					Creature* creature = thing->getCreature();
3797					if(creature)
3798						g_game.internalTeleport(creature, toPos, true);
3799				}
3800			}
3801		}
3802	}
3803
3804	lua_pushboolean(L, true);
3805	return 1;
3806}
3807
3808int32_t LuaScriptInterface::luaDoCleanTile(lua_State* L)
3809{
3810	//doCleanTile(pos, forceMapLoaded = false)
3811	//Remove all items from tile, ignore creatures
3812	bool forceMapLoaded = false;
3813	if(lua_gettop(L) > 1)
3814		forceMapLoaded = popNumber(L);
3815
3816	PositionEx pos;
3817	popPosition(L, pos);
3818
3819	Tile* tile = g_game.getTile(pos);
3820	if(!tile)
3821	{
3822		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
3823		lua_pushboolean(L, false);
3824		return 1;
3825	}
3826
3827	for(int32_t i = tile->getThingCount() - 1; i >= 1; --i) //ignore ground
3828	{
3829		if(Thing* thing = tile->__getThing(i))
3830		{
3831			if(Item* item = thing->getItem())
3832			{
3833				if(!item->isLoadedFromMap() || forceMapLoaded)
3834					g_game.internalRemoveItem(NULL, item);
3835			}
3836		}
3837	}
3838
3839	lua_pushboolean(L, true);
3840	return 1;
3841}
3842
3843int32_t LuaScriptInterface::luaDoPlayerSendTextMessage(lua_State* L)
3844{
3845	//doPlayerSendTextMessage(cid, MessageClasses, message)
3846	std::string text = popString(L);
3847	uint32_t messageClass = popNumber(L);
3848
3849	ScriptEnviroment* env = getEnv();
3850	Player* player = env->getPlayerByUID(popNumber(L));
3851	if(!player)
3852	{
3853		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3854		lua_pushboolean(L, false);
3855		return 1;
3856	}
3857
3858	player->sendTextMessage((MessageClasses)messageClass, text);
3859	lua_pushboolean(L, true);
3860	return 1;
3861}
3862
3863int32_t LuaScriptInterface::luaDoPlayerSendChannelMessage(lua_State* L)
3864{
3865	//doPlayerSendChannelMessage(cid, author, message, SpeakClasses, channel)
3866	uint16_t channelId = popNumber(L);
3867	uint32_t speakClass = popNumber(L);
3868	std::string text = popString(L), name = popString(L);
3869
3870	ScriptEnviroment* env = getEnv();
3871	Player* player = env->getPlayerByUID(popNumber(L));
3872	if(!player)
3873	{
3874		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3875		lua_pushboolean(L, false);
3876		return 1;
3877	}
3878
3879	player->sendChannelMessage(name, text, (SpeakClasses)speakClass, channelId);
3880	lua_pushboolean(L, true);
3881	return 1;
3882}
3883
3884int32_t LuaScriptInterface::luaDoPlayerSendToChannel(lua_State* L)
3885{
3886	//doPlayerSendToChannel(cid, targetId, SpeakClasses, message, channel[, time])
3887	ScriptEnviroment* env = getEnv();
3888	uint32_t time = 0;
3889	if(lua_gettop(L) > 5)
3890		time = popNumber(L);
3891
3892	uint16_t channelId = popNumber(L);
3893	std::string text = popString(L);
3894	uint32_t speakClass = popNumber(L), targetId = popNumber(L);
3895
3896	Player* player = env->getPlayerByUID(popNumber(L));
3897	if(!player)
3898	{
3899		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3900		lua_pushboolean(L, false);
3901		return 1;
3902	}
3903
3904	Creature* creature = env->getCreatureByUID(targetId);
3905	if(!creature)
3906	{
3907		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3908		lua_pushboolean(L, false);
3909		return 1;
3910	}
3911
3912	player->sendToChannel(creature, (SpeakClasses)speakClass, text, channelId, time);
3913	lua_pushboolean(L, true);
3914	return 1;
3915}
3916
3917int32_t LuaScriptInterface::luaDoSendAnimatedText(lua_State* L)
3918{
3919	//doSendAnimatedText(pos, text, color[, player])
3920	ScriptEnviroment* env = getEnv();
3921	SpectatorVec list;
3922	if(lua_gettop(L) > 3)
3923	{
3924		if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3925			list.push_back(creature);
3926	}
3927
3928	uint32_t color = popNumber(L);
3929	std::string text = popString(L);
3930
3931	PositionEx pos;
3932	popPosition(L, pos);
3933	if(pos.x == 0xFFFF)
3934		pos = env->getRealPos();
3935
3936	if(!list.empty())
3937		g_game.addAnimatedText(list, pos, color, text);
3938	else
3939		g_game.addAnimatedText(pos, color, text);
3940
3941	lua_pushboolean(L, true);
3942	return 1;
3943}
3944
3945int32_t LuaScriptInterface::luaGetPlayerSkillLevel(lua_State* L)
3946{
3947	//getPlayerSkillLevel(cid, skillid)
3948	uint32_t skillId = popNumber(L);
3949
3950	ScriptEnviroment* env = getEnv();
3951	if(const Player* player = env->getPlayerByUID(popNumber(L)))
3952	{
3953		if(skillId <= SKILL_LAST)
3954			lua_pushnumber(L, player->skills[skillId][SKILL_LEVEL]);
3955		else
3956			lua_pushboolean(L, false);
3957	}
3958	else
3959	{
3960		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3961		lua_pushboolean(L, false);
3962	}
3963	return 1;
3964}
3965
3966int32_t LuaScriptInterface::luaGetPlayerSkillTries(lua_State* L)
3967{
3968	//getPlayerSkillTries(cid, skillid)
3969	uint32_t skillid = popNumber(L);
3970
3971	ScriptEnviroment* env = getEnv();
3972	if(const Player* player = env->getPlayerByUID(popNumber(L)))
3973	{
3974		if(skillid <= SKILL_LAST)
3975			lua_pushnumber(L, player->skills[skillid][SKILL_TRIES]);
3976		else
3977			lua_pushboolean(L, false);
3978	}
3979	else
3980	{
3981		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3982		lua_pushboolean(L, false);
3983	}
3984	return 1;
3985}
3986
3987int32_t LuaScriptInterface::luaDoCreatureSetDropLoot(lua_State* L)
3988{
3989	//doCreatureSetDropLoot(cid, doDrop)
3990	bool doDrop = popNumber(L);
3991
3992	ScriptEnviroment* env = getEnv();
3993	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3994	{
3995		creature->setDropLoot(doDrop ? LOOT_DROP_FULL : LOOT_DROP_NONE);
3996		lua_pushboolean(L, true);
3997	}
3998	else
3999	{
4000		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
4001		lua_pushboolean(L, false);
4002	}
4003
4004	return 1;
4005}
4006
4007int32_t LuaScriptInterface::luaGetPlayerLossPercent(lua_State* L)
4008{
4009	//getPlayerLossPercent(cid, lossType)
4010	uint8_t lossType = (uint8_t)popNumber(L);
4011
4012	ScriptEnviroment* env = getEnv();
4013	if(const Player* player = env->getPlayerByUID(popNumber(L)))
4014	{
4015		if(lossType <= LOSS_LAST)
4016		{
4017			uint32_t value = player->getLossPercent((lossTypes_t)lossType);
4018			lua_pushnumber(L, value);
4019		}
4020		else
4021			lua_pushboolean(L, false);
4022	}
4023	else
4024	{
4025		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4026		lua_pushboolean(L, false);
4027	}
4028	return 1;
4029}
4030
4031int32_t LuaScriptInterface::luaDoPlayerSetLossPercent(lua_State* L)
4032{
4033	//doPlayerSetLossPercent(cid, lossType, newPercent)
4034	uint32_t newPercent = popNumber(L);
4035	uint8_t lossType = (uint8_t)popNumber(L);
4036
4037	ScriptEnviroment* env = getEnv();
4038	if(Player* player = env->getPlayerByUID(popNumber(L)))
4039	{
4040		if(lossType <= LOSS_LAST)
4041		{
4042			player->setLossPercent((lossTypes_t)lossType, newPercent);
4043			lua_pushboolean(L, true);
4044		}
4045		else
4046			lua_pushboolean(L, false);
4047	}
4048	else
4049	{
4050		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4051		lua_pushboolean(L, false);
4052	}
4053	return 1;
4054}
4055
4056int32_t LuaScriptInterface::luaDoPlayerSetLossSkill(lua_State* L)
4057{
4058	//doPlayerSetLossSkill(cid, doLose)
4059	bool doLose = popNumber(L);
4060
4061	ScriptEnviroment* env = getEnv();
4062	if(Player* player = env->getPlayerByUID(popNumber(L)))
4063	{
4064		player->setLossSkill(doLose);
4065		lua_pushboolean(L, true);
4066	}
4067	else
4068	{
4069		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4070		lua_pushboolean(L, false);
4071	}
4072	return 1;
4073}
4074
4075int32_t LuaScriptInterface::luaDoShowTextDialog(lua_State* L)
4076{
4077	//doShowTextDialog(cid, itemid, text)
4078	std::string text = popString(L);
4079	uint32_t itemId = popNumber(L);
4080
4081	ScriptEnviroment* env = getEnv();
4082	if(Player* player = env->getPlayerByUID(popNumber(L)))
4083	{
4084		player->setWriteItem(NULL, 0);
4085		player->sendTextWindow(itemId, text);
4086		lua_pushboolean(L, true);
4087	}
4088	else
4089	{
4090		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4091		lua_pushboolean(L, false);
4092	}
4093	return 1;
4094}
4095
4096int32_t LuaScriptInterface::luaDoDecayItem(lua_State* L)
4097{
4098	//doDecayItem(uid)
4099	//Note: to stop decay set decayTo = 0 in items.xml
4100	ScriptEnviroment* env = getEnv();
4101	if(Item* item = env->getItemByUID(popNumber(L)))
4102	{
4103		g_game.startDecay(item);
4104		lua_pushboolean(L, true);
4105	}
4106	else
4107	{
4108		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
4109		lua_pushboolean(L, false);
4110	}
4111	return 1;
4112}
4113
4114int32_t LuaScriptInterface::luaGetThingFromPos(lua_State* L)
4115{
4116	//getThingFromPos(pos[, displayError = true])
4117	//Note:
4118	//	stackpos = 255- top thing (movable item or creature)
4119	//	stackpos = 254- magic field
4120	//	stackpos = 253- top creature
4121
4122	bool displayError = true;
4123	if(lua_gettop(L) > 1)
4124		displayError = popNumber(L);
4125
4126	PositionEx pos;
4127	popPosition(L, pos);
4128
4129	ScriptEnviroment* env = getEnv();
4130	Thing* thing = NULL;
4131	if(Tile* tile = g_game.getMap()->getTile(pos))
4132	{
4133		if(pos.stackpos == 255)
4134		{
4135			if(!(thing = tile->getTopCreature()))
4136			{
4137				Item* item = tile->getTopDownItem();
4138				if(item && item->isMoveable())
4139					thing = item;
4140			}
4141		}
4142		else if(pos.stackpos == 254)
4143			thing = tile->getFieldItem();
4144		else if(pos.stackpos == 253)
4145			thing = tile->getTopCreature();
4146		else
4147			thing = tile->__getThing(pos.stackpos);
4148
4149		if(thing)
4150			pushThing(L, thing, env->addThing(thing));
4151		else
4152			pushThing(L, NULL, 0);
4153
4154		return 1;
4155	}
4156
4157	if(displayError)
4158		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
4159
4160	pushThing(L, NULL, 0);
4161	return 1;
4162}
4163
4164int32_t LuaScriptInterface::luaGetTileItemById(lua_State* L)
4165{
4166	//getTileItemById(pos, itemId[, subType = -1])
4167	ScriptEnviroment* env = getEnv();
4168
4169	int32_t subType = -1;
4170	if(lua_gettop(L) > 2)
4171		subType = (int32_t)popNumber(L);
4172
4173	int32_t itemId = (int32_t)popNumber(L);
4174	PositionEx pos;
4175	popPosition(L, pos);
4176
4177	Tile* tile = g_game.getTile(pos);
4178	if(!tile)
4179	{
4180		pushThing(L, NULL, 0);
4181		return 1;
4182	}
4183
4184	Item* item = g_game.findItemOfType(tile, itemId, false, subType);
4185	if(!item)
4186	{
4187		pushThing(L, NULL, 0);
4188		return 1;
4189	}
4190
4191	pushThing(L, item, env->addThing(item));
4192	return 1;
4193}
4194
4195int32_t LuaScriptInterface::luaGetTileItemByType(lua_State* L)
4196{
4197	//getTileItemByType(pos, type)
4198	uint32_t rType = (uint32_t)popNumber(L);
4199	if(rType >= ITEM_TYPE_LAST)
4200	{
4201		errorEx("Not a valid item type");
4202		pushThing(L, NULL, 0);
4203		return 1;
4204	}
4205
4206	PositionEx pos;
4207	popPosition(L, pos);
4208
4209	Tile* tile = g_game.getTile(pos);
4210	if(!tile)
4211	{
4212		pushThing(L, NULL, 0);
4213		return 1;
4214	}
4215
4216	bool found = true;
4217	switch((ItemTypes_t)rType)
4218	{
4219		case ITEM_TYPE_TELEPORT:
4220		{
4221			if(!tile->hasFlag(TILESTATE_TELEPORT))
4222				found = false;
4223
4224			break;
4225		}
4226		case ITEM_TYPE_MAGICFIELD:
4227		{
4228			if(!tile->hasFlag(TILESTATE_MAGICFIELD))
4229				found = false;
4230
4231			break;
4232		}
4233		case ITEM_TYPE_MAILBOX:
4234		{
4235			if(!tile->hasFlag(TILESTATE_MAILBOX))
4236				found = false;
4237
4238			break;
4239		}
4240		case ITEM_TYPE_TRASHHOLDER:
4241		{
4242			if(!tile->hasFlag(TILESTATE_TRASHHOLDER))
4243				found = false;
4244
4245			break;
4246		}
4247		case ITEM_TYPE_BED:
4248		{
4249			if(!tile->hasFlag(TILESTATE_BED))
4250				found = false;
4251
4252			break;
4253		}
4254		default:
4255			break;
4256	}
4257
4258	if(!found)
4259	{
4260		pushThing(L, NULL, 0);
4261		return 1;
4262	}
4263
4264	ScriptEnviroment* env = getEnv();
4265	Item* item = NULL;
4266	for(uint32_t i = 0; i < tile->getThingCount(); ++i)
4267	{
4268		if(!(item = tile->__getThing(i)->getItem()))
4269			continue;
4270
4271		if(Item::items[item->getID()].type != (ItemTypes_t)rType)
4272			continue;
4273
4274		pushThing(L, item, env->addThing(item));
4275		return 1;
4276	}
4277
4278	pushThing(L, NULL, 0);
4279	return 1;
4280}
4281
4282int32_t LuaScriptInterface::luaGetTileThingByPos(lua_State* L)
4283{
4284	//getTileThingByPos(pos)
4285	PositionEx pos;
4286	popPosition(L, pos);
4287
4288	ScriptEnviroment* env = getEnv();
4289
4290	Tile* tile = g_game.getTile(pos.x, pos.y, pos.z);
4291	if(!tile)
4292	{
4293		if(pos.stackpos == -1)
4294		{
4295			lua_pushnumber(L, -1);
4296			return 1;
4297		}
4298		else
4299		{
4300			pushThing(L, NULL, 0);
4301			return 1;
4302		}
4303	}
4304
4305	if(pos.stackpos == -1)
4306	{
4307		lua_pushnumber(L, tile->getThingCount());
4308		return 1;
4309	}
4310
4311	Thing* thing = tile->__getThing(pos.stackpos);
4312	if(!thing)
4313	{
4314		pushThing(L, NULL, 0);
4315		return 1;
4316	}
4317
4318	pushThing(L, thing, env->addThing(thing));
4319	return 1;
4320}
4321
4322int32_t LuaScriptInterface::luaGetTopCreature(lua_State* L)
4323{
4324	//getTopCreature(pos)
4325	PositionEx pos;
4326	popPosition(L, pos);
4327
4328	ScriptEnviroment* env = getEnv();
4329	Tile* tile = g_game.getTile(pos);
4330	if(!tile)
4331	{
4332		pushThing(L, NULL, 0);
4333		return 1;
4334	}
4335
4336	Thing* thing = tile->getTopCreature();
4337	if(!thing || !thing->getCreature())
4338	{
4339		pushThing(L, NULL, 0);
4340		return 1;
4341	}
4342
4343	pushThing(L, thing, env->addThing(thing));
4344	return 1;
4345}
4346
4347int32_t LuaScriptInterface::luaDoCreateItem(lua_State* L)
4348{
4349	//doCreateItem(itemid[, type/count], pos)
4350	//Returns uid of the created item, only works on tiles.
4351	PositionEx pos;
4352	popPosition(L, pos);
4353
4354	uint32_t count = 1;
4355	if(lua_gettop(L) > 1)
4356		count = popNumber(L);
4357
4358	uint32_t itemId = popNumber(L);
4359	ScriptEnviroment* env = getEnv();
4360
4361	Tile* tile = g_game.getTile(pos);
4362	if(!tile)
4363	{
4364		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
4365		lua_pushboolean(L, false);
4366		return 1;
4367	}
4368
4369	const ItemType& it = Item::items[itemId];
4370	int32_t itemCount = 1, subType = 1;
4371	if(it.hasSubType())
4372	{
4373		if(it.stackable)
4374			itemCount = (int32_t)std::ceil((float)count / 100);
4375
4376		subType = count;
4377	}
4378	else
4379		itemCount = std::max((uint32_t)1, count);
4380
4381	while(itemCount > 0)
4382	{
4383		int32_t stackCount = std::min(100, subType);
4384		Item* newItem = Item::CreateItem(itemId, stackCount);
4385		if(!newItem)
4386		{
4387			errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
4388			lua_pushboolean(L, false);
4389			return 1;
4390		}
4391
4392		if(it.stackable)
4393			subType -= stackCount;
4394
4395		ReturnValue ret = g_game.internalAddItem(NULL, tile, newItem, INDEX_WHEREEVER, FLAG_NOLIMIT);
4396		if(ret != RET_NOERROR)
4397		{
4398			delete newItem;
4399			lua_pushboolean(L, false);
4400			return 1;
4401		}
4402
4403		--itemCount;
4404		if(itemCount)
4405			continue;
4406
4407		if(newItem->getParent())
4408			lua_pushnumber(L, env->addThing(newItem));
4409		else //stackable item stacked with existing object, newItem will be released
4410			lua_pushnil(L);
4411
4412		return 1;
4413	}
4414
4415	lua_pushnil(L);
4416	return 1;
4417}
4418
4419int32_t LuaScriptInterface::luaDoCreateItemEx(lua_State* L)
4420{
4421	//doCreateItemEx(itemid[, count/subType])
4422	uint32_t count = 0;
4423	if(lua_gettop(L) > 1)
4424		count = popNumber(L);
4425
4426	ScriptEnviroment* env = getEnv();
4427	const ItemType& it = Item::items[(uint32_t)popNumber(L)];
4428	if(it.stackable && count > 100)
4429		count = 100;
4430
4431	Item* newItem = Item::CreateItem(it.id, count);
4432	if(!newItem)
4433	{
4434		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
4435		lua_pushboolean(L, false);
4436		return 1;
4437	}
4438
4439	newItem->setParent(VirtualCylinder::virtualCylinder);
4440	env->addTempItem(env, newItem);
4441
4442	lua_pushnumber(L, env->addThing(newItem));
4443	return 1;
4444}
4445
4446int32_t LuaScriptInterface::luaDoCreateTeleport(lua_State* L)
4447{
4448	//doCreateTeleport(itemid, toPosition, fromPosition)
4449	PositionEx createPos;
4450	popPosition(L, createPos);
4451	PositionEx toPos;
4452	popPosition(L, toPos);
4453
4454	uint32_t itemId = (uint32_t)popNumber(L);
4455	ScriptEnviroment* env = getEnv();
4456
4457	Tile* tile = g_game.getMap()->getTile(createPos);
4458	if(!tile)
4459	{
4460		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
4461		lua_pushboolean(L, false);
4462		return 1;
4463	}
4464
4465	Item* newItem = Item::CreateItem(itemId);
4466	Teleport* newTeleport = newItem->getTeleport();
4467	if(!newTeleport)
4468	{
4469		delete newItem;
4470		lua_pushboolean(L, false);
4471		return 1;
4472	}
4473
4474	newTeleport->setDestination(toPos);
4475	if(g_game.internalAddItem(NULL, tile, newTeleport, INDEX_WHEREEVER, FLAG_NOLIMIT) != RET_NOERROR)
4476	{
4477		delete newItem;
4478		lua_pushboolean(L, false);
4479		return 1;
4480	}
4481
4482	if(newItem->getParent())
4483		lua_pushnumber(L, env->addThing(newItem));
4484	else //stackable item stacked with existing object, newItem will be released
4485		lua_pushnil(L);
4486
4487	return 1;
4488}
4489
4490int32_t LuaScriptInterface::luaGetCreatureStorage(lua_State* L)
4491{
4492	//getCreatureStorage(cid, key)
4493	uint32_t key = popNumber(L);
4494	ScriptEnviroment* env = getEnv();
4495	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
4496	{
4497		std::string strValue;
4498		if(creature->getStorage(key, strValue))
4499		{
4500			int32_t intValue = atoi(strValue.c_str());
4501			if(intValue || strValue == "0")
4502				lua_pushnumber(L, intValue);
4503			else
4504				lua_pushstring(L, strValue.c_str());
4505		}
4506		else
4507			lua_pushnumber(L, -1);
4508	}
4509	else
4510	{
4511		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
4512		lua_pushboolean(L, false);
4513	}
4514
4515	return 1;
4516}
4517
4518int32_t LuaScriptInterface::luaDoCreatureSetStorage(lua_State* L)
4519{
4520	//doCreatureSetStorage(cid, key[, value])
4521	std::string value;
4522	bool nil = true;
4523	if(lua_gettop(L) > 2)
4524	{
4525		if(!lua_isnil(L, -1))
4526		{
4527			value = popString(L);
4528			nil = false;
4529		}
4530		else
4531			lua_pop(L, 1);
4532	}
4533
4534	uint32_t key = popNumber(L);
4535	ScriptEnviroment* env = getEnv();
4536	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
4537	{
4538		if(!nil)
4539			nil = creature->setStorage(key, value);
4540		else
4541			creature->eraseStorage(key);
4542
4543		lua_pushboolean(L, nil);
4544	}
4545	else
4546	{
4547		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
4548		lua_pushboolean(L, false);
4549	}
4550
4551	return 1;
4552}
4553
4554int32_t LuaScriptInterface::luaGetTileInfo(lua_State* L)
4555{
4556	//getTileInfo(pos)
4557	PositionEx pos;
4558	popPosition(L, pos);
4559	if(Tile* tile = g_game.getMap()->getTile(pos))
4560	{
4561		ScriptEnviroment* env = getEnv();
4562		pushThing(L, tile->ground, env->addThing(tile->ground));
4563
4564		setFieldBool(L, "protection", tile->hasFlag(TILESTATE_PROTECTIONZONE));
4565		setFieldBool(L, "nopvp", tile->hasFlag(TILESTATE_NOPVPZONE));
4566		setFieldBool(L, "nologout", tile->hasFlag(TILESTATE_NOLOGOUT));
4567		setFieldBool(L, "pvp", tile->hasFlag(TILESTATE_PVPZONE));
4568		setFieldBool(L, "refresh", tile->hasFlag(TILESTATE_REFRESH));
4569		setFieldBool(L, "trashed", tile->hasFlag(TILESTATE_TRASHED));
4570		setFieldBool(L, "house", tile->hasFlag(TILESTATE_HOUSE));
4571		setFieldBool(L, "bed", tile->hasFlag(TILESTATE_BED));
4572		setFieldBool(L, "depot", tile->hasFlag(TILESTATE_DEPOT));
4573
4574		setField(L, "things", tile->getThingCount());
4575		setField(L, "creatures", tile->getCreatureCount());
4576		setField(L, "items", tile->getItemCount());
4577		setField(L, "topItems", tile->getTopItemCount());
4578		setField(L, "downItems", tile->getDownItemCount());
4579	}
4580	else
4581	{
4582		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
4583		lua_pushboolean(L, false);
4584	}
4585
4586	return 1;
4587}
4588
4589int32_t LuaScriptInterface::luaGetHouseFromPos(lua_State* L)
4590{
4591	//getHouseFromPos(pos)
4592	PositionEx pos;
4593	popPosition(L, pos);
4594
4595	Tile* tile = g_game.getMap()->getTile(pos);
4596	if(!tile)
4597	{
4598		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
4599		lua_pushboolean(L, false);
4600		return 1;
4601	}
4602
4603	HouseTile* houseTile = tile->getHouseTile();
4604	if(!houseTile)
4605	{
4606		lua_pushboolean(L, false);
4607		return 1;
4608	}
4609
4610	House* house = houseTile->getHouse();
4611	if(!house)
4612	{
4613		lua_pushboolean(L, false);
4614		return 1;
4615	}
4616
4617	lua_pushnumber(L, house->getId());
4618	return 1;
4619}
4620
4621int32_t LuaScriptInterface::luaDoCreateMonster(lua_State* L)
4622{
4623	//doCreateMonster(name, pos[, displayError = true])
4624	bool displayError = true;
4625	if(lua_gettop(L) > 2)
4626		displayError = popNumber(L);
4627
4628	PositionEx pos;
4629	popPosition(L, pos);
4630
4631	std::string name = popString(L);
4632	Monster* monster = Monster::createMonster(name.c_str());
4633	if(!monster)
4634	{
4635		if(displayError)
4636			errorEx("Monster with name '" + name + "' not found");
4637
4638		lua_pushboolean(L, false);
4639		return 1;
4640	}
4641
4642	if(!g_game.placeCreature(monster, pos))
4643	{
4644		delete monster;
4645		if(displayError)
4646			errorEx("Cannot create monster: " + name);
4647
4648		lua_pushboolean(L, true);
4649		return 1;
4650	}
4651
4652	ScriptEnviroment* env = getEnv();
4653	lua_pushnumber(L, env->addThing((Thing*)monster));
4654	return 1;
4655}
4656
4657int32_t LuaScriptInterface::luaDoCreateNpc(lua_State* L)
4658{
4659	//doCreateNpc(name, pos[, displayError = true])
4660	bool displayError = true;
4661	if(lua_gettop(L) > 2)
4662		displayError = popNumber(L);
4663
4664	PositionEx pos;
4665	popPosition(L, pos);
4666
4667	std::string name = popString(L);
4668	Npc* npc = Npc::createNpc(name.c_str());
4669	if(!npc)
4670	{
4671		if(displayError)
4672			errorEx("Npc with name '" + name + "' not found");
4673
4674		lua_pushboolean(L, false);
4675		return 1;
4676	}
4677
4678	if(!g_game.placeCreature(npc, pos))
4679	{
4680		delete npc;
4681		if(displayError)
4682			errorEx("Cannot create npc: " + name);
4683
4684		lua_pushboolean(L, true); //for scripting compatibility
4685		return 1;
4686	}
4687
4688	ScriptEnviroment* env = getEnv();
4689	lua_pushnumber(L, env->addThing((Thing*)npc));
4690	return 1;
4691}
4692
4693int32_t LuaScriptInterface::luaDoRemoveCreature(lua_State* L)
4694{
4695	//doRemoveCreature(cid[, forceLogout = true])
4696	bool forceLogout = true;
4697	if(lua_gettop(L) > 1)
4698		forceLogout = popNumber(L);
4699
4700	ScriptEnviroment* env = getEnv();
4701	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
4702	{
4703		if(Player* player = creature->getPlayer())
4704			player->kickPlayer(true, forceLogout); //Players will get kicked without restrictions
4705		else
4706			g_game.removeCreature(creature); //Monsters/NPCs will get removed
4707
4708		lua_pushboolean(L, true);
4709	}
4710	else
4711	{
4712		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
4713		lua_pushboolean(L, false);
4714	}
4715	return 1;
4716}
4717
4718int32_t LuaScriptInterface::luaDoPlayerAddMoney(lua_State* L)
4719{
4720	//doPlayerAddMoney(cid, money)
4721	uint64_t money = popNumber(L);
4722
4723	ScriptEnviroment* env = getEnv();
4724	if(Player* player = env->getPlayerByUID(popNumber(L)))
4725	{
4726		g_game.addMoney(player, money);
4727		lua_pushboolean(L, true);
4728	}
4729	else
4730	{
4731		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4732		lua_pushboolean(L, false);
4733	}
4734	return 1;
4735}
4736
4737int32_t LuaScriptInterface::luaDoPlayerRemoveMoney(lua_State* L)
4738{
4739	//doPlayerRemoveMoney(cid,money)
4740	uint64_t money = popNumber(L);
4741
4742	ScriptEnviroment* env = getEnv();
4743	if(Player* player = env->getPlayerByUID(popNumber(L)))
4744		lua_pushboolean(L, g_game.removeMoney(player, money));
4745	else
4746	{
4747		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4748		lua_pushboolean(L, false);
4749	}
4750	return 1;
4751}
4752
4753int32_t LuaScriptInterface::luaDoPlayerTransferMoneyTo(lua_State* L)
4754{
4755	//doPlayerTransferMoneyTo(cid, target, money)
4756	uint64_t money = popNumber(L);
4757	std::string target = popString(L);
4758
4759	ScriptEnviroment* env = getEnv();
4760	if(Player* player = env->getPlayerByUID(popNumber(L)))
4761		lua_pushboolean(L, player->transferMoneyTo(target, money));
4762	else
4763	{
4764		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4765		lua_pushboolean(L, false);
4766	}
4767	return 1;
4768}
4769
4770int32_t LuaScriptInterface::luaDoPlayerSetPzLocked(lua_State* L)
4771{
4772	//doPlayerSetPzLocked(cid, locked)
4773	bool locked = popNumber(L);
4774
4775	ScriptEnviroment* env = getEnv();
4776	if(Player* player = env->getPlayerByUID(popNumber(L)))
4777	{
4778		if(player->isPzLocked() != locked)
4779		{
4780			player->setPzLocked(locked);
4781			player->sendIcons();
4782		}
4783
4784		lua_pushboolean(L, true);
4785	}
4786	else
4787	{
4788		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4789		lua_pushboolean(L, false);
4790	}
4791	return 1;
4792}
4793
4794int32_t LuaScriptInterface::luaDoPlayerSetTown(lua_State* L)
4795{
4796	//doPlayerSetTown(cid, townid)
4797	uint32_t townid = (uint32_t)popNumber(L);
4798
4799	ScriptEnviroment* env = getEnv();
4800	if(Player* player = env->getPlayerByUID(popNumber(L)))
4801	{
4802		if(Town* town = Towns::getInstance()->getTown(townid))
4803		{
4804			player->setMasterPosition(town->getPosition());
4805			player->setTown(townid);
4806			lua_pushboolean(L, true);
4807		}
4808		else
4809			lua_pushboolean(L, false);
4810	}
4811	else
4812	{
4813		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4814		lua_pushboolean(L, false);
4815	}
4816	return 1;
4817}
4818
4819int32_t LuaScriptInterface::luaDoPlayerSetVocation(lua_State* L)
4820{
4821	//doPlayerSetVocation(cid, voc)
4822	uint32_t voc = popNumber(L);
4823
4824	ScriptEnviroment* env = getEnv();
4825	if(Player* player = env->getPlayerByUID(popNumber(L)))
4826	{
4827		player->setVocation(voc);
4828		lua_pushboolean(L, true);
4829	}
4830	else
4831	{
4832		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4833		lua_pushboolean(L, false);
4834	}
4835	return 1;
4836}
4837
4838int32_t LuaScriptInterface::luaDoPlayerSetSex(lua_State* L)
4839{
4840	//doPlayerSetSex(cid, sex)
4841	uint32_t newSex = popNumber(L);
4842
4843	ScriptEnviroment* env = getEnv();
4844	if(Player* player = env->getPlayerByUID(popNumber(L)))
4845	{
4846		player->setSex(newSex);
4847		lua_pushboolean(L, true);
4848	}
4849	else
4850	{
4851		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4852		lua_pushboolean(L, false);
4853	}
4854	return 1;
4855}
4856
4857int32_t LuaScriptInterface::luaDoPlayerAddSoul(lua_State* L)
4858{
4859	//doPlayerAddSoul(cid, soul)
4860	int32_t soul = popNumber(L);
4861
4862	ScriptEnviroment* env = getEnv();
4863	if(Player* player = env->getPlayerByUID(popNumber(L)))
4864	{
4865		player->changeSoul(soul);
4866		lua_pushboolean(L, true);
4867	}
4868	else
4869	{
4870		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4871		lua_pushboolean(L, false);
4872	}
4873	return 1;
4874}
4875
4876int32_t LuaScriptInterface::luaGetPlayerItemCount(lua_State* L)
4877{
4878	//getPlayerItemCount(cid, itemid[, subType = -1])
4879	int32_t subType = -1;
4880	if(lua_gettop(L) > 2)
4881		subType = popNumber(L);
4882
4883	uint32_t itemId = popNumber(L);
4884	ScriptEnviroment* env = getEnv();
4885	if(const Player* player = env->getPlayerByUID(popNumber(L)))
4886		lua_pushnumber(L, player->__getItemTypeCount(itemId, subType));
4887	else
4888	{
4889		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4890		lua_pushboolean(L, false);
4891	}
4892	return 1;
4893}
4894
4895int32_t LuaScriptInterface::luaGetPlayerMoney(lua_State* L)
4896{
4897	//getPlayerMoney(cid)
4898	ScriptEnviroment* env = getEnv();
4899	if(Player* player = env->getPlayerByUID(popNumber(L)))
4900		lua_pushnumber(L, g_game.getMoney(player));
4901	else
4902	{
4903		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4904		lua_pushboolean(L, false);
4905	}
4906	return 1;
4907}
4908
4909int32_t LuaScriptInterface::luaGetHouseInfo(lua_State* L)
4910{
4911	//getHouseInfo(houseId)
4912	bool displayError = true;
4913	if(lua_gettop(L) > 1)
4914		displayError = popNumber(L);
4915
4916	House* house = Houses::getInstance()->getHouse(popNumber(L));
4917	if(!house)
4918	{
4919		if(displayError)
4920			errorEx(getError(LUA_ERROR_HOUSE_NOT_FOUND));
4921
4922		lua_pushboolean(L, false);
4923		return 1;
4924	}
4925
4926	lua_newtable(L);
4927	setField(L, "id", house->getId());
4928	setField(L, "name", house->getName().c_str());
4929	setField(L, "owner", house->getOwner());
4930
4931	lua_pushstring(L, "entry");
4932	pushPosition(L, house->getEntry(), 0);
4933	pushTable(L);
4934
4935	setField(L, "rent", house->getRent());
4936	setField(L, "price", house->getPrice());
4937	setField(L, "town", house->getTownId());
4938	setField(L, "paidUntil", house->getPaidUntil());
4939	setField(L, "warnings", house->getRentWarnings());
4940	setField(L, "lastWarning", house->getLastWarning());
4941
4942	setFieldBool(L, "guildHall", house->isGuild());
4943	setField(L, "size", house->getSize());
4944	setField(L, "doors", house->getDoorsCount());
4945	setField(L, "beds", house->getBedsCount());
4946	setField(L, "tiles", house->getTilesCount());
4947
4948	return 1;
4949}
4950
4951int32_t LuaScriptInterface::luaGetHouseAccessList(lua_State* L)
4952{
4953	//getHouseAccessList(houseid, listid)
4954	uint32_t listid = popNumber(L);
4955	if(House* house = Houses::getInstance()->getHouse(popNumber(L)))
4956	{
4957		std::string list;
4958		if(house->getAccessList(listid, list))
4959			lua_pushstring(L, list.c_str());
4960		else
4961			lua_pushnil(L);
4962	}
4963	else
4964	{
4965		errorEx(getError(LUA_ERROR_HOUSE_NOT_FOUND));
4966		lua_pushnil(L);
4967	}
4968	return 1;
4969}
4970
4971int32_t LuaScriptInterface::luaGetHouseByPlayerGUID(lua_State* L)
4972{
4973	//getHouseByPlayerGUID(guid)
4974	if(House* house = Houses::getInstance()->getHouseByPlayerId(popNumber(L)))
4975		lua_pushnumber(L, house->getId());
4976	else
4977		lua_pushnil(L);
4978	return 1;
4979}
4980
4981int32_t LuaScriptInterface::luaSetHouseAccessList(lua_State* L)
4982{
4983	//setHouseAccessList(houseid, listid, listtext)
4984	std::string list = popString(L);
4985	uint32_t listid = popNumber(L);
4986
4987	if(House* house = Houses::getInstance()->getHouse(popNumber(L)))
4988	{
4989		house->setAccessList(listid, list);
4990		lua_pushboolean(L, true);
4991	}
4992	else
4993	{
4994		errorEx(getError(LUA_ERROR_HOUSE_NOT_FOUND));
4995		lua_pushboolean(L, false);
4996	}
4997	return 1;
4998}
4999
5000int32_t LuaScriptInterface::luaSetHouseOwner(lua_State* L)
5001{
5002	//setHouseOwner(houseId, owner[, clean])
5003	bool clean = true;
5004	if(lua_gettop(L) > 2)
5005		clean = popNumber(L);
5006
5007	uint32_t owner = popNumber(L);
5008	if(House* house = Houses::getInstance()->getHouse(popNumber(L)))
5009		lua_pushboolean(L, house->setOwnerEx(owner, clean));
5010	else
5011	{
5012		errorEx(getError(LUA_ERROR_HOUSE_NOT_FOUND));
5013		lua_pushboolean(L, false);
5014	}
5015	return 1;
5016}
5017
5018int32_t LuaScriptInterface::luaGetWorldType(lua_State* L)
5019{
5020	lua_pushnumber(L, (uint32_t)g_game.getWorldType());
5021	return 1;
5022}
5023
5024int32_t LuaScriptInterface::luaSetWorldType(lua_State* L)
5025{
5026	//setWorldType(type)
5027	WorldType_t type = (WorldType_t)popNumber(L);
5028
5029	if(type >= WORLD_TYPE_FIRST && type <= WORLD_TYPE_LAST)
5030	{
5031		g_game.setWorldType(type);
5032		lua_pushboolean(L, true);
5033	}
5034	else
5035		lua_pushboolean(L, false);
5036
5037	return 1;
5038}
5039
5040int32_t LuaScriptInterface::luaGetWorldTime(lua_State* L)
5041{
5042	//getWorldTime()
5043	lua_pushnumber(L, g_game.getLightHour());
5044	return 1;
5045}
5046
5047int32_t LuaScriptInterface::luaGetWorldLight(lua_State* L)
5048{
5049	//getWorldLight()
5050	LightInfo lightInfo;
5051	g_game.getWorldLightInfo(lightInfo);
5052	lua_pushnumber(L, lightInfo.level);
5053	lua_pushnumber(L, lightInfo.color);
5054	return 1;
5055}
5056
5057int32_t LuaScriptInterface::luaGetWorldCreatures(lua_State* L)
5058{
5059	//getWorldCreatures(type)
5060	//0 players, 1 monsters, 2 npcs, 3 all
5061	uint32_t type = popNumber(L), value;
5062	switch(type)
5063	{
5064		case 0:
5065			value = g_game.getPlayersOnline();
5066			break;
5067		case 1:
5068			value = g_game.getMonstersOnline();
5069			break;
5070		case 2:
5071			value = g_game.getNpcsOnline();
5072			break;
5073		case 3:
5074			value = g_game.getCreaturesOnline();
5075			break;
5076		default:
5077			lua_pushboolean(L, false);
5078			return 1;
5079	}
5080
5081	lua_pushnumber(L, value);
5082	return 1;
5083}
5084
5085int32_t LuaScriptInterface::luaGetWorldUpTime(lua_State* L)
5086{
5087	//getWorldUpTime()
5088	uint32_t uptime = 0;
5089	if(Status* status = Status::getInstance())
5090		uptime = status->getUptime();
5091
5092	lua_pushnumber(L, uptime);
5093	return 1;
5094}
5095
5096int32_t LuaScriptInterface::luaGetPlayerLight(lua_State* L)
5097{
5098	//getPlayerLight(cid)
5099	ScriptEnviroment* env = getEnv();
5100	if(const Player* player = env->getPlayerByUID(popNumber(L)))
5101	{
5102		LightInfo lightInfo;
5103		player->getCreatureLight(lightInfo);
5104		lua_pushnumber(L, lightInfo.level);
5105		lua_pushnumber(L, lightInfo.color);
5106	}
5107	else
5108	{
5109		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
5110		lua_pushboolean(L, false);
5111	}
5112	return 1;
5113}
5114
5115int32_t LuaScriptInterface::luaDoPlayerAddExperience(lua_State* L)
5116{
5117	//doPlayerAddExperience(cid, amount)
5118	int64_t amount = popNumber(L);
5119
5120	ScriptEnviroment* env = getEnv();
5121	if(Player* player = env->getPlayerByUID(popNumber(L)))
5122	{
5123		if(amount > 0)
5124			player->addExperience(amount);
5125		else if(amount < 0)
5126			player->removeExperience(std::abs(amount));
5127		else
5128		{
5129			lua_pushboolean(L, false);
5130			return 1;
5131		}
5132
5133		lua_pushboolean(L, true);
5134	}
5135	else
5136	{
5137		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
5138		lua_pushboolean(L, false);
5139	}
5140	return 1;
5141}
5142
5143int32_t LuaScriptInterface::luaGetPlayerSlotItem(lua_State* L)
5144{
5145	//getPlayerSlotItem(cid, slot)
5146	uint32_t slot = popNumber(L);
5147
5148	ScriptEnviroment* env = getEnv();
5149	if(const Player* player = env->getPlayerByUID(popNumber(L)))
5150	{
5151		if(Thing* thing = player->__getThing(slot))
5152			pushThing(L, thing, env->addThing(thing));
5153		else
5154			pushThing(L, NULL, 0);
5155	}
5156	else
5157	{
5158		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
5159		pushThing(L, NULL, 0);
5160	}
5161	return 1;
5162}
5163
5164int32_t LuaScriptInterface::luaGetPlayerWeapon(lua_State* L)
5165{
5166	//getPlayerWeapon(cid[, ignoreAmmo = false])
5167	bool ignoreAmmo = false;
5168	if(lua_gettop(L) > 1)
5169		ignoreAmmo = popNumber(L);
5170
5171	ScriptEnviroment* env = getEnv();
5172	if(Player* player = env->getPlayerByUID(popNumber(L)))
5173	{
5174		if(Item* weapon = player->getWeapon(ignoreAmmo))
5175			pushThing(L, weapon, env->addThing(weapon));
5176		else
5177			pushThing(L, NULL, 0);
5178	}
5179	else
5180	{
5181		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
5182		lua_pushnil(L);
5183	}
5184	return 1;
5185}
5186
5187int32_t LuaScriptInterface::luaGetPlayerItemById(lua_State* L)
5188{
5189	//getPlayerItemById(cid, deepSearch, itemId[, subType = -1])
5190	ScriptEnviroment* env = getEnv();
5191
5192	int32_t subType = -1;
5193	if(lua_gettop(L) > 3)
5194		subType = (int32_t)popNumber(L);
5195
5196	int32_t itemId = (int32_t)popNumber(L);
5197	bool deepSearch = popNumber(L);
5198
5199	Player* player = env->getPlayerByUID(popNumber(L));
5200	if(!player)
5201	{
5202		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
5203		pushThing(L, NULL, 0);
5204		return 1;
5205	}
5206
5207	Item* item = g_game.findItemOfType(player, itemId, deepSearch, subType);
5208	if(!item)
5209	{
5210		pushThing(L, NULL, 0);
5211		return 1;
5212	}
5213
5214	pushThing(L, item, env->addThing(item));
5215	return 1;
5216}
5217
5218int32_t LuaScriptInterface::luaGetThing(lua_State* L)
5219{
5220	//getThing(uid)
5221	uint32_t uid = popNumber(L);
5222
5223	ScriptEnviroment* env = getEnv();
5224	if(Thing* thing = env->getThingByUID(uid))
5225		pushThing(L, thing, uid);
5226	else
5227	{
5228		errorEx(getError(LUA_ERROR_THING_NOT_FOUND));
5229		pushThing(L, NULL, 0);
5230	}
5231	return 1;
5232}
5233
5234int32_t LuaScriptInterface::luaDoTileQueryAdd(lua_State* L)
5235{
5236	//doTileQueryAdd(uid, pos[, flags[, displayError = true]])
5237	uint32_t flags = 0, params = lua_gettop(L);
5238	bool displayError = true;
5239	if(params > 3)
5240		displayError = popNumber(L);
5241
5242	if(params > 2)
5243		flags = popNumber(L);
5244
5245	PositionEx pos;
5246	popPosition(L, pos);
5247	uint32_t uid = popNumber(L);
5248
5249	ScriptEnviroment* env = getEnv();
5250	Tile* tile = g_game.getTile(pos);
5251	if(!tile)
5252	{
5253		if(displayError)
5254			errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
5255
5256		lua_pushnumber(L, (uint32_t)RET_NOTPOSSIBLE);
5257		return 1;
5258	}
5259
5260	Thing* thing = env->getThingByUID(uid);
5261	if(!thing)
5262	{
5263		if(displayError)
5264			errorEx(getError(LUA_ERROR_THING_NOT_FOUND));
5265
5266		lua_pushnumber(L, (uint32_t)RET_NOTPOSSIBLE);
5267		return 1;
5268	}
5269
5270	lua_pushnumber(L, (uint32_t)tile->__queryAdd(0, thing, 1, flags));
5271	return 1;
5272}
5273
5274int32_t LuaScriptInterface::luaDoItemRaidUnref(lua_State* L)
5275{
5276	//doItemRaidUnref(uid)
5277	ScriptEnviroment* env = getEnv();
5278	if(Item* item = env->getItemByUID(popNumber(L)))
5279	{
5280		if(Raid* raid = item->getRaid())
5281		{
5282			raid->unRef();
5283			item->setRaid(NULL);
5284			lua_pushboolean(L, true);
5285		}
5286		else
5287			lua_pushboolean(L, false);
5288	}
5289	else
5290	{
5291		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
5292		lua_pushboolean(L, false);
5293	}
5294	return 1;
5295}
5296
5297int32_t LuaScriptInterface::luaGetThingPosition(lua_State* L)
5298{
5299	//getThingPosition(uid)
5300	ScriptEnviroment* env = getEnv();
5301	if(Thing* thing = env->getThingByUID(popNumber(L)))
5302	{
5303		Position pos = thing->getPosition();
5304		uint32_t stackpos = 0;
5305		if(Tile* tile = thing->getTile())
5306			stackpos = tile->__getIndexOfThing(thing);
5307
5308		pushPosition(L, pos, stackpos);
5309	}
5310	else
5311	{
5312		errorEx(getError(LUA_ERROR_THING_NOT_FOUND));
5313		lua_pushboolean(L, false);
5314	}
5315
5316	return 1;
5317}
5318
5319int32_t LuaScriptInterface::luaCreateCombatObject(lua_State* L)
5320{
5321	//createCombatObject()
5322	ScriptEnviroment* env = getEnv();
5323	if(env->getScriptId() != EVENT_ID_LOADING)
5324	{
5325		errorEx("This function can only be used while loading the script.");
5326		lua_pushboolean(L, false);
5327		return 1;
5328	}
5329
5330	Combat* combat = new Combat;
5331	if(!combat)
5332	{
5333		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5334		lua_pushboolean(L, false);
5335		return 1;
5336	}
5337
5338	lua_pushnumber(L, env->addCombatObject(combat));
5339	return 1;
5340}
5341
5342bool LuaScriptInterface::getArea(lua_State* L, std::list<uint32_t>& list, uint32_t& rows)
5343{
5344	rows = 0;
5345	uint32_t i = 0;
5346
5347	lua_pushnil(L);
5348	while(lua_next(L, -2))
5349	{
5350		lua_pushnil(L);
5351		while(lua_next(L, -2))
5352		{
5353			list.push_back((uint32_t)lua_tonumber(L, -1));
5354			lua_pop(L, 1); //removes value, keeps key for next iteration
5355			++i;
5356		}
5357
5358		lua_pop(L, 1); //removes value, keeps key for next iteration
5359		++rows;
5360		i = 0;
5361	}
5362
5363	lua_pop(L, 1);
5364	return rows;
5365}
5366
5367int32_t LuaScriptInterface::luaCreateCombatArea(lua_State* L)
5368{
5369	//createCombatArea( {area}[, {extArea}])
5370	ScriptEnviroment* env = getEnv();
5371	if(env->getScriptId() != EVENT_ID_LOADING)
5372	{
5373		errorEx("This function can only be used while loading the script.");
5374		lua_pushboolean(L, false);
5375		return 1;
5376	}
5377
5378	CombatArea* area = new CombatArea;
5379	if(lua_gettop(L) > 1)
5380	{
5381		//has extra parameter with diagonal area information
5382		uint32_t rowsExtArea;
5383		std::list<uint32_t> listExtArea;
5384
5385		getArea(L, listExtArea, rowsExtArea);
5386		/*setup all possible rotations*/
5387		area->setupExtArea(listExtArea, rowsExtArea);
5388	}
5389
5390	if(lua_isnoneornil(L, -1)) //prevent crash
5391	{
5392		lua_pop(L, 2);
5393		lua_pushboolean(L, false);
5394		return 1;
5395	}
5396
5397	uint32_t rowsArea = 0;
5398	std::list<uint32_t> listArea;
5399	getArea(L, listArea, rowsArea);
5400
5401	area->setupArea(listArea, rowsArea);
5402	lua_pushnumber(L, env->addCombatArea(area));
5403	return 1;
5404}
5405
5406int32_t LuaScriptInterface::luaCreateConditionObject(lua_State* L)
5407{
5408	//createConditionObject(type[, ticks[, buff[, subId]]])
5409	uint32_t params = lua_gettop(L), subId = 0;
5410	if(params > 3)
5411		subId = popNumber(L);
5412
5413	bool buff = false;
5414	if(params > 2)
5415		buff = popNumber(L);
5416
5417	int32_t ticks = 0;
5418	if(params > 1)
5419		ticks = popNumber(L);
5420
5421	ScriptEnviroment* env = getEnv();
5422	if(env->getScriptId() != EVENT_ID_LOADING)
5423	{
5424		errorEx("This function can only be used while loading the script.");
5425		lua_pushboolean(L, false);
5426		return 1;
5427	}
5428
5429	if(Condition* condition = Condition::createCondition(CONDITIONID_COMBAT, (ConditionType_t)popNumber(L), ticks, 0, buff, subId))
5430		lua_pushnumber(L, env->addConditionObject(condition));
5431	else
5432	{
5433		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
5434		lua_pushboolean(L, false);
5435	}
5436
5437	return 1;
5438}
5439
5440int32_t LuaScriptInterface::luaSetCombatArea(lua_State* L)
5441{
5442	//setCombatArea(combat, area)
5443	uint32_t areaId = popNumber(L);
5444	ScriptEnviroment* env = getEnv();
5445	if(env->getScriptId() != EVENT_ID_LOADING)
5446	{
5447		errorEx("This function can only be used while loading the script.");
5448		lua_pushboolean(L, false);
5449		return 1;
5450	}
5451
5452	Combat* combat = env->getCombatObject(popNumber(L));
5453	if(!combat)
5454	{
5455		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5456		lua_pushboolean(L, false);
5457		return 1;
5458	}
5459
5460	const CombatArea* area = env->getCombatArea(areaId);
5461	if(!area)
5462	{
5463		errorEx(getError(LUA_ERROR_AREA_NOT_FOUND));
5464		lua_pushboolean(L, false);
5465		return 1;
5466	}
5467
5468	combat->setArea(new CombatArea(*area));
5469	lua_pushboolean(L, true);
5470	return 1;
5471}
5472
5473int32_t LuaScriptInterface::luaSetCombatCondition(lua_State* L)
5474{
5475	//setCombatCondition(combat, condition)
5476	uint32_t conditionId = popNumber(L);
5477	ScriptEnviroment* env = getEnv();
5478	if(env->getScriptId() != EVENT_ID_LOADING)
5479	{
5480		errorEx("This function can only be used while loading the script.");
5481		lua_pushboolean(L, false);
5482		return 1;
5483	}
5484
5485	Combat* combat = env->getCombatObject(popNumber(L));
5486	if(!combat)
5487	{
5488		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5489		lua_pushboolean(L, false);
5490		return 1;
5491	}
5492
5493	const Condition* condition = env->getConditionObject(conditionId);
5494	if(!condition)
5495	{
5496		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
5497		lua_pushboolean(L, false);
5498		return 1;
5499	}
5500
5501	combat->setCondition(condition->clone());
5502	lua_pushboolean(L, true);
5503	return 1;
5504}
5505
5506int32_t LuaScriptInterface::luaSetCombatParam(lua_State* L)
5507{
5508	//setCombatParam(combat, key, value)
5509	uint32_t value = popNumber(L);
5510	CombatParam_t key = (CombatParam_t)popNumber(L);
5511
5512	ScriptEnviroment* env = getEnv();
5513	if(env->getScriptId() != EVENT_ID_LOADING)
5514	{
5515		errorEx("This function can only be used while loading the script.");
5516		lua_pushboolean(L, false);
5517		return 1;
5518	}
5519
5520	Combat* combat = env->getCombatObject(popNumber(L));
5521	if(!combat)
5522	{
5523		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5524		lua_pushboolean(L, false);
5525	}
5526	else
5527	{
5528		combat->setParam(key, value);
5529		lua_pushboolean(L, true);
5530	}
5531	return 1;
5532}
5533
5534int32_t LuaScriptInterface::luaSetConditionParam(lua_State* L)
5535{
5536	//setConditionParam(condition, key, value)
5537	int32_t value = (int32_t)popNumber(L);
5538	ConditionParam_t key = (ConditionParam_t)popNumber(L);
5539
5540	ScriptEnviroment* env = getEnv();
5541	if(env->getScriptId() != EVENT_ID_LOADING)
5542	{
5543		errorEx("This function can only be used while loading the script.");
5544		lua_pushboolean(L, false);
5545		return 1;
5546	}
5547
5548	if(Condition* condition = env->getConditionObject(popNumber(L)))
5549	{
5550		condition->setParam(key, value);
5551		lua_pushboolean(L, true);
5552	}
5553	else
5554	{
5555		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
5556		lua_pushboolean(L, false);
5557	}
5558
5559	return 1;
5560}
5561
5562int32_t LuaScriptInterface::luaAddDamageCondition(lua_State* L)
5563{
5564	//addDamageCondition(condition, rounds, time, value)
5565	int32_t value = popNumber(L), time = popNumber(L), rounds = popNumber(L);
5566	ScriptEnviroment* env = getEnv();
5567	if(env->getScriptId() != EVENT_ID_LOADING)
5568	{
5569		errorEx("This function can only be used while loading the script.");
5570		lua_pushboolean(L, false);
5571		return 1;
5572	}
5573
5574	if(ConditionDamage* condition = dynamic_cast<ConditionDamage*>(env->getConditionObject(popNumber(L))))
5575	{
5576		condition->addDamage(rounds, time, value);
5577		lua_pushboolean(L, true);
5578	}
5579	else
5580	{
5581		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
5582		lua_pushboolean(L, false);
5583	}
5584
5585	return 1;
5586}
5587
5588int32_t LuaScriptInterface::luaAddOutfitCondition(lua_State* L)
5589{
5590	//addOutfitCondition(condition, outfit)
5591	Outfit_t outfit = popOutfit(L);
5592	ScriptEnviroment* env = getEnv();
5593	if(env->getScriptId() != EVENT_ID_LOADING)
5594	{
5595		errorEx("This function can only be used while loading the script.");
5596		lua_pushboolean(L, false);
5597		return 1;
5598	}
5599
5600	if(ConditionOutfit* condition = dynamic_cast<ConditionOutfit*>(env->getConditionObject(popNumber(L))))
5601	{
5602		condition->addOutfit(outfit);
5603		lua_pushboolean(L, true);
5604	}
5605	else
5606	{
5607		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
5608		lua_pushboolean(L, false);
5609	}
5610
5611	return 1;
5612}
5613
5614int32_t LuaScriptInterface::luaSetCombatCallBack(lua_State* L)
5615{
5616	//setCombatCallBack(combat, key, functionName)
5617	std::string function = popString(L);
5618	CallBackParam_t key = (CallBackParam_t)popNumber(L);
5619
5620	ScriptEnviroment* env = getEnv();
5621	if(env->getScriptId() != EVENT_ID_LOADING)
5622	{
5623		errorEx("This function can only be used while loading the script.");
5624		lua_pushboolean(L, false);
5625		return 1;
5626	}
5627
5628	Combat* combat = env->getCombatObject(popNumber(L));
5629	if(!combat)
5630	{
5631		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5632		lua_pushboolean(L, false);
5633		return 1;
5634	}
5635
5636	LuaScriptInterface* interface = env->getInterface();
5637	combat->setCallback(key);
5638
5639	CallBack* callback = combat->getCallback(key);
5640	if(!callback)
5641	{
5642		std::stringstream ss;
5643		ss << key;
5644
5645		errorEx(ss.str() + " is not a valid callback key.");
5646		lua_pushboolean(L, false);
5647		return 1;
5648	}
5649
5650	if(!callback->loadCallBack(interface, function))
5651	{
5652		errorEx("Cannot load callback");
5653		lua_pushboolean(L, false);
5654	}
5655	else
5656		lua_pushboolean(L, true);
5657
5658	return 1;
5659}
5660
5661int32_t LuaScriptInterface::luaSetCombatFormula(lua_State* L)
5662{
5663	//setCombatFormula(combat, type, mina, minb, maxa, maxb[, minl, maxl[, minm, maxm[, minc[, maxc]]]])
5664	ScriptEnviroment* env = getEnv();
5665	if(env->getScriptId() != EVENT_ID_LOADING)
5666	{
5667		errorEx("This function can only be used while loading the script.");
5668		lua_pushboolean(L, false);
5669		return 1;
5670	}
5671
5672	int32_t params = lua_gettop(L), minc = 0, maxc = 0;
5673	if(params > 11)
5674		maxc = popNumber(L);
5675
5676	if(params > 10)
5677		minc = popNumber(L);
5678
5679	double minm = g_config.getDouble(ConfigManager::FORMULA_MAGIC), maxm = minm,
5680		minl = g_config.getDouble(ConfigManager::FORMULA_LEVEL), maxl = minl;
5681	if(params > 8)
5682	{
5683		maxm = popFloatNumber(L);
5684		minm = popFloatNumber(L);
5685	}
5686
5687	if(params > 6)
5688	{
5689		maxl = popFloatNumber(L);
5690		minl = popFloatNumber(L);
5691	}
5692
5693	double maxb = popFloatNumber(L), maxa = popFloatNumber(L),
5694		minb = popFloatNumber(L), mina = popFloatNumber(L);
5695	formulaType_t type = (formulaType_t)popNumber(L);
5696	if(Combat* combat = env->getCombatObject(popNumber(L)))
5697	{
5698		combat->setPlayerCombatValues(type, mina, minb, maxa, maxb, minl, maxl, minm, maxm, minc, maxc);
5699		lua_pushboolean(L, true);
5700	}
5701	else
5702	{
5703		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5704		lua_pushboolean(L, false);
5705	}
5706
5707	return 1;
5708}
5709
5710int32_t LuaScriptInterface::luaSetConditionFormula(lua_State* L)
5711{
5712	//setConditionFormula(condition, mina, minb, maxa, maxb)
5713	ScriptEnviroment* env = getEnv();
5714	if(env->getScriptId() != EVENT_ID_LOADING)
5715	{
5716		errorEx("This function can only be used while loading the script.");
5717		lua_pushboolean(L, false);
5718		return 1;
5719	}
5720
5721	double maxb = popFloatNumber(L), maxa = popFloatNumber(L),
5722		minb = popFloatNumber(L), mina = popFloatNumber(L);
5723
5724	if(ConditionSpeed* condition = dynamic_cast<ConditionSpeed*>(env->getConditionObject(popNumber(L))))
5725	{
5726		condition->setFormulaVars(mina, minb, maxa, maxb);
5727		lua_pushboolean(L, true);
5728	}
5729	else
5730	{
5731		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
5732		lua_pushboolean(L, false);
5733	}
5734
5735	return 1;
5736}
5737
5738int32_t LuaScriptInterface::luaDoCombat(lua_State* L)
5739{
5740	//doCombat(cid, combat, param)
5741	ScriptEnviroment* env = getEnv();
5742
5743	LuaVariant var = popVariant(L);
5744	uint32_t combatId = popNumber(L), cid = popNumber(L);
5745
5746	Creature* creature = NULL;
5747	if(cid != 0)
5748	{
5749		creature = env->getCreatureByUID(cid);
5750		if(!creature)
5751		{
5752			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5753			lua_pushboolean(L, false);
5754			return 1;
5755		}
5756	}
5757
5758	const Combat* combat = env->getCombatObject(combatId);
5759	if(!combat)
5760	{
5761		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5762		lua_pushboolean(L, false);
5763		return 1;
5764	}
5765
5766	if(var.type == VARIANT_NONE)
5767	{
5768		errorEx(getError(LUA_ERROR_VARIANT_NOT_FOUND));
5769		lua_pushboolean(L, false);
5770		return 1;
5771	}
5772
5773	switch(var.type)
5774	{
5775		case VARIANT_NUMBER:
5776		{
5777			Creature* target = g_game.getCreatureByID(var.number);
5778			if(!target || !creature || !creature->canSeeCreature(target))
5779			{
5780				lua_pushboolean(L, false);
5781				return 1;
5782			}
5783
5784			if(combat->hasArea())
5785				combat->doCombat(creature, target->getPosition());
5786			else
5787				combat->doCombat(creature, target);
5788
5789			break;
5790		}
5791
5792		case VARIANT_POSITION:
5793		{
5794			combat->doCombat(creature, var.pos);
5795			break;
5796		}
5797
5798		case VARIANT_TARGETPOSITION:
5799		{
5800			if(!combat->hasArea())
5801			{
5802				combat->postCombatEffects(creature, var.pos);
5803				g_game.addMagicEffect(var.pos, MAGIC_EFFECT_POFF);
5804			}
5805			else
5806				combat->doCombat(creature, var.pos);
5807
5808			break;
5809		}
5810
5811		case VARIANT_STRING:
5812		{
5813			Player* target = g_game.getPlayerByName(var.text);
5814			if(!target || !creature || !creature->canSeeCreature(target))
5815			{
5816				lua_pushboolean(L, false);
5817				return 1;
5818			}
5819
5820			combat->doCombat(creature, target);
5821			break;
5822		}
5823
5824		default:
5825		{
5826			errorEx(getError(LUA_ERROR_VARIANT_UNKNOWN));
5827			lua_pushboolean(L, false);
5828			return 1;
5829		}
5830	}
5831
5832	lua_pushboolean(L, true);
5833	return 1;
5834}
5835
5836int32_t LuaScriptInterface::luaDoCombatAreaHealth(lua_State* L)
5837{
5838	//doCombatAreaHealth(cid, type, pos, area, min, max, effect)
5839	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
5840	int32_t maxChange = (int32_t)popNumber(L), minChange = (int32_t)popNumber(L);
5841	uint32_t areaId = popNumber(L);
5842
5843	PositionEx pos;
5844	popPosition(L, pos);
5845
5846	CombatType_t combatType = (CombatType_t)popNumber(L);
5847	uint32_t cid = popNumber(L);
5848
5849	ScriptEnviroment* env = getEnv();
5850	Creature* creature = NULL;
5851	if(cid)
5852	{
5853		if(!(creature = env->getCreatureByUID(cid)))
5854		{
5855			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5856			lua_pushboolean(L, false);
5857			return 1;
5858		}
5859	}
5860
5861	const CombatArea* area = env->getCombatArea(areaId);
5862	if(area || !areaId)
5863	{
5864		CombatParams params;
5865		params.combatType = combatType;
5866		params.effects.impact = effect;
5867
5868		Combat::doCombatHealth(creature, pos, area, minChange, maxChange, params);
5869		lua_pushboolean(L, true);
5870	}
5871	else
5872	{
5873		errorEx(getError(LUA_ERROR_AREA_NOT_FOUND));
5874		lua_pushboolean(L, false);
5875	}
5876
5877	return 1;
5878}
5879
5880int32_t LuaScriptInterface::luaDoTargetCombatHealth(lua_State* L)
5881{
5882	//doTargetCombatHealth(cid, target, type, min, max, effect)
5883	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
5884	int32_t maxChange = (int32_t)popNumber(L), minChange = (int32_t)popNumber(L);
5885
5886	CombatType_t combatType = (CombatType_t)popNumber(L);
5887	uint32_t targetCid = popNumber(L), cid = popNumber(L);
5888
5889	ScriptEnviroment* env = getEnv();
5890	Creature* creature = NULL;
5891	if(cid)
5892	{
5893		if(!(creature = env->getCreatureByUID(cid)))
5894		{
5895			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5896			lua_pushboolean(L, false);
5897			return 1;
5898		}
5899	}
5900
5901	Creature* target = env->getCreatureByUID(targetCid);
5902	if(target)
5903	{
5904		CombatParams params;
5905		params.combatType = combatType;
5906		params.effects.impact = effect;
5907
5908		Combat::doCombatHealth(creature, target, minChange, maxChange, params);
5909		lua_pushboolean(L, true);
5910	}
5911	else
5912	{
5913		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5914		lua_pushboolean(L, false);
5915	}
5916
5917	return 1;
5918}
5919
5920int32_t LuaScriptInterface::luaDoCombatAreaMana(lua_State* L)
5921{
5922	//doCombatAreaMana(cid, pos, area, min, max, effect)
5923	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
5924	int32_t maxChange = (int32_t)popNumber(L), minChange = (int32_t)popNumber(L);
5925	uint32_t areaId = popNumber(L);
5926
5927	PositionEx pos;
5928	popPosition(L, pos);
5929	uint32_t cid = popNumber(L);
5930
5931	ScriptEnviroment* env = getEnv();
5932	Creature* creature = NULL;
5933	if(cid)
5934	{
5935		if(!(creature = env->getCreatureByUID(cid)))
5936		{
5937			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5938			lua_pushboolean(L, false);
5939			return 1;
5940		}
5941	}
5942
5943	const CombatArea* area = env->getCombatArea(areaId);
5944	if(area || !areaId)
5945	{
5946		CombatParams params;
5947		params.effects.impact = effect;
5948
5949		Combat::doCombatMana(creature, pos, area, minChange, maxChange, params);
5950		lua_pushboolean(L, true);
5951	}
5952	else
5953	{
5954		errorEx(getError(LUA_ERROR_AREA_NOT_FOUND));
5955		lua_pushboolean(L, false);
5956	}
5957
5958	return 1;
5959}
5960
5961int32_t LuaScriptInterface::luaDoTargetCombatMana(lua_State* L)
5962{
5963	//doTargetCombatMana(cid, target, min, max, effect)
5964	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
5965	int32_t maxChange = (int32_t)popNumber(L), minChange = (int32_t)popNumber(L);
5966	uint32_t targetCid = popNumber(L), cid = popNumber(L);
5967
5968	ScriptEnviroment* env = getEnv();
5969	Creature* creature = NULL;
5970	if(cid)
5971	{
5972		if(!(creature = env->getCreatureByUID(cid)))
5973		{
5974			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5975			lua_pushboolean(L, false);
5976			return 1;
5977		}
5978	}
5979
5980	if(Creature* target = env->getCreatureByUID(targetCid))
5981	{
5982		CombatParams params;
5983		params.effects.impact = effect;
5984
5985		Combat::doCombatMana(creature, target, minChange, maxChange, params);
5986		lua_pushboolean(L, true);
5987	}
5988	else
5989	{
5990		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5991		lua_pushboolean(L, false);
5992	}
5993
5994	return 1;
5995}
5996
5997int32_t LuaScriptInterface::luaDoCombatAreaCondition(lua_State* L)
5998{
5999	//doCombatAreaCondition(cid, pos, area, condition, effect)
6000	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
6001	uint32_t conditionId = popNumber(L), areaId = popNumber(L);
6002
6003	PositionEx pos;
6004	popPosition(L, pos);
6005	uint32_t cid = popNumber(L);
6006
6007	ScriptEnviroment* env = getEnv();
6008	Creature* creature = NULL;
6009	if(cid)
6010	{
6011		if(!(creature = env->getCreatureByUID(cid)))
6012		{
6013			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6014			lua_pushboolean(L, false);
6015			return 1;
6016		}
6017	}
6018
6019	if(const Condition* condition = env->getConditionObject(conditionId))
6020	{
6021		const CombatArea* area = env->getCombatArea(areaId);
6022		if(area || !areaId)
6023		{
6024			CombatParams params;
6025			params.effects.impact = effect;
6026			params.conditionList.push_back(condition);
6027			Combat::doCombatCondition(creature, pos, area, params);
6028
6029			lua_pushboolean(L, true);
6030		}
6031		else
6032		{
6033			errorEx(getError(LUA_ERROR_AREA_NOT_FOUND));
6034			lua_pushboolean(L, false);
6035		}
6036	}
6037	else
6038	{
6039		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
6040		lua_pushboolean(L, false);
6041	}
6042
6043	return 1;
6044}
6045
6046int32_t LuaScriptInterface::luaDoTargetCombatCondition(lua_State* L)
6047{
6048	//doTargetCombatCondition(cid, target, condition, effect)
6049	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
6050	uint32_t conditionId = popNumber(L), targetCid = popNumber(L), cid = popNumber(L);
6051
6052	ScriptEnviroment* env = getEnv();
6053	Creature* creature = NULL;
6054	if(cid)
6055	{
6056		if(!(creature = env->getCreatureByUID(cid)))
6057		{
6058			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6059			lua_pushboolean(L, false);
6060			return 1;
6061		}
6062	}
6063
6064	if(Creature* target = env->getCreatureByUID(targetCid))
6065	{
6066		if(const Condition* condition = env->getConditionObject(conditionId))
6067		{
6068			CombatParams params;
6069			params.effects.impact = effect;
6070			params.conditionList.push_back(condition);
6071
6072			Combat::doCombatCondition(creature, target, params);
6073			lua_pushboolean(L, true);
6074		}
6075		else
6076		{
6077			errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
6078			lua_pushboolean(L, false);
6079		}
6080	}
6081	else
6082	{
6083		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6084		lua_pushboolean(L, false);
6085	}
6086
6087	return 1;
6088}
6089
6090int32_t LuaScriptInterface::luaDoCombatAreaDispel(lua_State* L)
6091{
6092	//doCombatAreaDispel(cid, pos, area, type, effect)
6093	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
6094	ConditionType_t dispelType = (ConditionType_t)popNumber(L);
6095	uint32_t areaId = popNumber(L);
6096
6097	PositionEx pos;
6098	popPosition(L, pos);
6099	uint32_t cid = popNumber(L);
6100
6101	ScriptEnviroment* env = getEnv();
6102	Creature* creature = NULL;
6103	if(cid)
6104	{
6105		if(!(creature = env->getCreatureByUID(cid)))
6106		{
6107			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6108			lua_pushboolean(L, false);
6109			return 1;
6110		}
6111	}
6112
6113	const CombatArea* area = env->getCombatArea(areaId);
6114	if(area || !areaId)
6115	{
6116		CombatParams params;
6117		params.effects.impact = effect;
6118		params.dispelType = dispelType;
6119
6120		Combat::doCombatDispel(creature, pos, area, params);
6121		lua_pushboolean(L, true);
6122	}
6123	else
6124	{
6125		errorEx(getError(LUA_ERROR_AREA_NOT_FOUND));
6126		lua_pushboolean(L, false);
6127	}
6128
6129	return 1;
6130}
6131
6132int32_t LuaScriptInterface::luaDoTargetCombatDispel(lua_State* L)
6133{
6134	//doTargetCombatDispel(cid, target, type, effect)
6135	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
6136	ConditionType_t dispelType = (ConditionType_t)popNumber(L);
6137	uint32_t targetCid = popNumber(L), cid = popNumber(L);
6138
6139	ScriptEnviroment* env = getEnv();
6140	Creature* creature = NULL;
6141	if(cid)
6142	{
6143		if(!(creature = env->getCreatureByUID(cid)))
6144		{
6145			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6146			lua_pushboolean(L, false);
6147			return 1;
6148		}
6149	}
6150
6151	if(Creature* target = env->getCreatureByUID(targetCid))
6152	{
6153		CombatParams params;
6154		params.effects.impact = effect;
6155		params.dispelType = dispelType;
6156
6157		Combat::doCombatDispel(creature, target, params);
6158		lua_pushboolean(L, true);
6159	}
6160	else
6161	{
6162		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6163		lua_pushboolean(L, false);
6164	}
6165
6166	return 1;
6167}
6168
6169int32_t LuaScriptInterface::luaDoChallengeCreature(lua_State* L)
6170{
6171	//doChallengeCreature(cid, target)
6172	ScriptEnviroment* env = getEnv();
6173	uint32_t targetCid = popNumber(L);
6174
6175	Creature* creature = env->getCreatureByUID(popNumber(L));
6176	if(!creature)
6177	{
6178		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6179		lua_pushboolean(L, false);
6180		return 1;
6181	}
6182
6183	Creature* target = env->getCreatureByUID(targetCid);
6184	if(!target)
6185	{
6186		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6187		lua_pushboolean(L, false);
6188		return 1;
6189	}
6190
6191	target->challengeCreature(creature);
6192	lua_pushboolean(L, true);
6193	return 1;
6194}
6195
6196int32_t LuaScriptInterface::luaDoSummonMonster(lua_State* L)
6197{
6198	//doSummonMonster(cid, name)
6199	std::string name = popString(L);
6200
6201	ScriptEnviroment* env = getEnv();
6202	Creature* creature = env->getCreatureByUID(popNumber(L));
6203	if(!creature)
6204	{
6205		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6206		lua_pushboolean(L, false);
6207		return 1;
6208	}
6209
6210	lua_pushnumber(L, g_game.placeSummon(creature, name));
6211	return 1;
6212}
6213
6214int32_t LuaScriptInterface::luaDoConvinceCreature(lua_State* L)
6215{
6216	//doConvinceCreature(cid, target)
6217	uint32_t cid = popNumber(L);
6218
6219	ScriptEnviroment* env = getEnv();
6220	Creature* creature = env->getCreatureByUID(popNumber(L));
6221	if(!creature)
6222	{
6223		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6224		lua_pushboolean(L, false);
6225		return 1;
6226	}
6227
6228	Creature* target = env->getCreatureByUID(cid);
6229	if(!target)
6230	{
6231		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6232		lua_pushboolean(L, false);
6233		return 1;
6234	}
6235
6236	target->convinceCreature(creature);
6237	lua_pushboolean(L, true);
6238	return 1;
6239}
6240
6241int32_t LuaScriptInterface::luaGetMonsterTargetList(lua_State* L)
6242{
6243	//getMonsterTargetList(cid)
6244	ScriptEnviroment* env = getEnv();
6245	Creature* creature = env->getCreatureByUID(popNumber(L));
6246	if(!creature)
6247	{
6248		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6249		lua_pushboolean(L, false);
6250		return 1;
6251	}
6252
6253	Monster* monster = creature->getMonster();
6254	if(!monster)
6255	{
6256		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6257		lua_pushboolean(L, false);
6258		return 1;
6259	}
6260
6261	const CreatureList& targetList = monster->getTargetList();
6262	CreatureList::const_iterator it = targetList.begin();
6263
6264	lua_newtable(L);
6265	for(uint32_t i = 1; it != targetList.end(); ++it, ++i)
6266	{
6267		if(monster->isTarget(*it))
6268		{
6269			lua_pushnumber(L, i);
6270			lua_pushnumber(L, env->addThing(*it));
6271			pushTable(L);
6272		}
6273	}
6274
6275	return 1;
6276}
6277
6278int32_t LuaScriptInterface::luaGetMonsterFriendList(lua_State* L)
6279{
6280	//getMonsterFriendList(cid)
6281	ScriptEnviroment* env = getEnv();
6282	Creature* creature = env->getCreatureByUID(popNumber(L));
6283	if(!creature)
6284	{
6285		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6286		lua_pushboolean(L, false);
6287		return 1;
6288	}
6289
6290	Monster* monster = creature->getMonster();
6291	if(!monster)
6292	{
6293		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6294		lua_pushboolean(L, false);
6295		return 1;
6296	}
6297
6298	Creature* friendCreature;
6299	const CreatureList& friendList = monster->getFriendList();
6300	CreatureList::const_iterator it = friendList.begin();
6301
6302	lua_newtable(L);
6303	for(uint32_t i = 1; it != friendList.end(); ++it, ++i)
6304	{
6305		friendCreature = (*it);
6306		if(!friendCreature->isRemoved() && friendCreature->getPosition().z == monster->getPosition().z)
6307		{
6308			lua_pushnumber(L, i);
6309			lua_pushnumber(L, env->addThing(*it));
6310			pushTable(L);
6311		}
6312	}
6313
6314	return 1;
6315}
6316
6317int32_t LuaScriptInterface::luaDoMonsterSetTarget(lua_State* L)
6318{
6319	//doMonsterSetTarget(cid, target)
6320	uint32_t targetId = popNumber(L);
6321	ScriptEnviroment* env = getEnv();
6322
6323	Creature* creature = env->getCreatureByUID(popNumber(L));
6324	if(!creature)
6325	{
6326		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6327		lua_pushboolean(L, false);
6328		return 1;
6329	}
6330
6331	Monster* monster = creature->getMonster();
6332	if(!monster)
6333	{
6334		errorEx(getError(LUA_ERROR_MONSTER_NOT_FOUND));
6335		lua_pushboolean(L, false);
6336		return 1;
6337	}
6338
6339	Creature* target = env->getCreatureByUID(targetId);
6340	if(!target)
6341	{
6342		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6343		lua_pushboolean(L, false);
6344		return 1;
6345	}
6346
6347	if(!monster->isSummon())
6348		lua_pushboolean(L, monster->selectTarget(target));
6349	else
6350		lua_pushboolean(L, false);
6351
6352	return 1;
6353}
6354
6355int32_t LuaScriptInterface::luaDoMonsterChangeTarget(lua_State* L)
6356{
6357	//doMonsterChangeTarget(cid)
6358	ScriptEnviroment* env = getEnv();
6359	Creature* creature = env->getCreatureByUID(popNumber(L));
6360	if(!creature)
6361	{
6362		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6363		lua_pushboolean(L, false);
6364		return 1;
6365	}
6366
6367	Monster* monster = creature->getMonster();
6368	if(!monster)
6369	{
6370		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6371		lua_pushboolean(L, false);
6372		return 1;
6373	}
6374
6375	if(!monster->isSummon())
6376		monster->searchTarget(TARGETSEARCH_RANDOM);
6377
6378	lua_pushboolean(L, true);
6379	return 1;
6380}
6381
6382int32_t LuaScriptInterface::luaGetMonsterInfo(lua_State* L)
6383{
6384	//getMonsterInfo(name)
6385	const MonsterType* mType = g_monsters.getMonsterType(popString(L));
6386	if(!mType)
6387	{
6388		errorEx(getError(LUA_ERROR_MONSTER_NOT_FOUND));
6389		lua_pushboolean(L, false);
6390		return 1;
6391	}
6392
6393	lua_newtable(L);
6394	setField(L, "name", mType->name.c_str());
6395	setField(L, "description", mType->nameDescription.c_str());
6396	setField(L, "experience", mType->experience);
6397	setField(L, "health", mType->health);
6398	setField(L, "healthMax", mType->healthMax);
6399	setField(L, "manaCost", mType->manaCost);
6400	setField(L, "defense", mType->defense);
6401	setField(L, "armor", mType->armor);
6402	setField(L, "baseSpeed", mType->baseSpeed);
6403	setField(L, "lookCorpse", mType->lookCorpse);
6404	setField(L, "race", mType->race);
6405	setField(L, "skull", mType->skull);
6406	setField(L, "partyShield", mType->partyShield);
6407	setFieldBool(L, "summonable", mType->isSummonable);
6408	setFieldBool(L, "illusionable", mType->isIllusionable);
6409	setFieldBool(L, "convinceable", mType->isConvinceable);
6410	setFieldBool(L, "attackable", mType->isAttackable);
6411	setFieldBool(L, "hostile", mType->isHostile);
6412	createTable(L, "defenses");
6413
6414	SpellList::const_iterator it = mType->spellDefenseList.begin();
6415	for(uint32_t i = 1; it != mType->spellDefenseList.end(); ++it, ++i)
6416	{
6417		createTable(L, i);
6418		setField(L, "speed", it->speed);
6419		setField(L, "chance", it->chance);
6420		setField(L, "range", it->range);
6421
6422		setField(L, "minCombatValue", it->minCombatValue);
6423		setField(L, "maxCombatValue", it->maxCombatValue);
6424		setFieldBool(L, "isMelee", it->isMelee);
6425		pushTable(L);
6426	}
6427
6428	pushTable(L);
6429	createTable(L, "attacks");
6430
6431	it = mType->spellAttackList.begin();
6432	for(uint32_t i = 1; it != mType->spellAttackList.end(); ++it, ++i)
6433	{
6434		createTable(L, i);
6435		setField(L, "speed", it->speed);
6436		setField(L, "chance", it->chance);
6437		setField(L, "range", it->range);
6438
6439		setField(L, "minCombatValue", it->minCombatValue);
6440		setField(L, "maxCombatValue", it->maxCombatValue);
6441		setFieldBool(L, "isMelee", it->isMelee);
6442		pushTable(L);
6443	}
6444
6445	pushTable(L);
6446	createTable(L, "loot");
6447
6448	LootItems::const_iterator lit = mType->lootItems.begin();
6449	for(uint32_t i = 1; lit != mType->lootItems.end(); ++lit, ++i)
6450	{
6451		createTable(L, i);
6452		if(lit->ids.size() > 1)
6453		{
6454			createTable(L, "ids");
6455			std::vector<uint16_t>::const_iterator iit = lit->ids.begin();
6456			for(uint32_t j = 1; iit != lit->ids.end(); ++iit, ++j)
6457			{
6458				lua_pushnumber(L, j);
6459				lua_pushnumber(L, (*iit));
6460				pushTable(L);
6461			}
6462
6463			pushTable(L);
6464		}
6465		else
6466			setField(L, "id", lit->ids[0]);
6467
6468		setField(L, "count", lit->count);
6469		setField(L, "chance", lit->chance);
6470		setField(L, "subType", lit->subType);
6471		setField(L, "actionId", lit->actionId);
6472		setField(L, "uniqueId", lit->uniqueId);
6473		setField(L, "text", lit->text);
6474
6475		if(lit->childLoot.size() > 0)
6476		{
6477			createTable(L, "child");
6478			LootItems::const_iterator cit = lit->childLoot.begin();
6479			for(uint32_t j = 1; cit != lit->childLoot.end(); ++cit, ++j)
6480			{
6481				createTable(L, j);
6482				if(cit->ids.size() > 1)
6483				{
6484					createTable(L, "ids");
6485					std::vector<uint16_t>::const_iterator iit = cit->ids.begin();
6486					for(uint32_t k = 1; iit != cit->ids.end(); ++iit, ++k)
6487					{
6488						lua_pushnumber(L, k);
6489						lua_pushnumber(L, (*iit));
6490						pushTable(L);
6491					}
6492
6493					pushTable(L);
6494				}
6495				else
6496					setField(L, "id", cit->ids[0]);
6497
6498				setField(L, "count", cit->count);
6499				setField(L, "chance", cit->chance);
6500				setField(L, "subType", cit->subType);
6501				setField(L, "actionId", cit->actionId);
6502				setField(L, "uniqueId", cit->uniqueId);
6503				setField(L, "text", cit->text);
6504
6505				pushTable(L);
6506			}
6507
6508			pushTable(L);
6509		}
6510
6511		pushTable(L);
6512	}
6513
6514	pushTable(L);
6515	createTable(L, "summons");
6516
6517	SummonList::const_iterator sit = mType->summonList.begin();
6518	for(uint32_t i = 1; sit != mType->summonList.end(); ++sit, ++i)
6519	{
6520		createTable(L, i);
6521		setField(L, "name", sit->name);
6522		setField(L, "chance", sit->chance);
6523
6524		setField(L, "interval", sit->interval);
6525		setField(L, "amount", sit->amount);
6526		pushTable(L);
6527	}
6528
6529	pushTable(L);
6530	return 1;
6531}
6532
6533int32_t LuaScriptInterface::luaGetTalkActionList(lua_State* L)
6534{
6535	//getTalkactionList()
6536	TalkActionsMap::const_iterator it = g_talkActions->getFirstTalk();
6537	lua_newtable(L);
6538	for(uint32_t i = 1; it != g_talkActions->getLastTalk(); ++it, ++i)
6539	{
6540		createTable(L, i);
6541		setField(L, "words", it->first);
6542		setField(L, "access", it->second->getAccess());
6543
6544		setFieldBool(L, "log", it->second->isLogged());
6545		setFieldBool(L, "hide", it->second->isHidden());
6546
6547		setField(L, "channel", it->second->getChannel());
6548		pushTable(L);
6549	}
6550
6551	return 1;
6552}
6553
6554int32_t LuaScriptInterface::luaGetExperienceStageList(lua_State* L)
6555{
6556	//getExperienceStageList()
6557	if(!g_config.getBool(ConfigManager::EXPERIENCE_STAGES))
6558	{
6559		lua_pushboolean(L, false);
6560		return true;
6561	}
6562
6563	StageList::const_iterator it = g_game.getFirstStage();
6564	lua_newtable(L);
6565	for(uint32_t i = 1; it != g_game.getLastStage(); ++it, ++i)
6566	{
6567		createTable(L, i);
6568		setField(L, "level", it->first);
6569		setFieldFloat(L, "multiplier", it->second);
6570		pushTable(L);
6571	}
6572
6573	return 1;
6574}
6575
6576int32_t LuaScriptInterface::luaDoAddCondition(lua_State* L)
6577{
6578	//doAddCondition(cid, condition)
6579	uint32_t conditionId = popNumber(L);
6580
6581	ScriptEnviroment* env = getEnv();
6582	Creature* creature = env->getCreatureByUID(popNumber(L));
6583	if(!creature)
6584	{
6585		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6586		lua_pushboolean(L, false);
6587		return 1;
6588	}
6589
6590	Condition* condition = env->getConditionObject(conditionId);
6591	if(!condition)
6592	{
6593		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
6594		lua_pushboolean(L, false);
6595		return 1;
6596	}
6597
6598	creature->addCondition(condition->clone());
6599	lua_pushboolean(L, true);
6600	return 1;
6601}
6602
6603int32_t LuaScriptInterface::luaDoRemoveCondition(lua_State* L)
6604{
6605	//doRemoveCondition(cid, type[, subId])
6606	uint32_t subId = 0;
6607	if(lua_gettop(L) > 2)
6608		subId = popNumber(L);
6609
6610	ConditionType_t conditionType = (ConditionType_t)popNumber(L);
6611
6612	ScriptEnviroment* env = getEnv();
6613	Creature* creature = env->getCreatureByUID(popNumber(L));
6614	if(!creature)
6615	{
6616		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6617		lua_pushboolean(L, false);
6618		return 1;
6619	}
6620
6621	Condition* condition = creature->getCondition(conditionType, CONDITIONID_COMBAT, subId);
6622	if(!condition)
6623		condition = creature->getCondition(conditionType, CONDITIONID_DEFAULT, subId);
6624
6625	if(condition)
6626		creature->removeCondition(condition);
6627
6628	lua_pushboolean(L, true);
6629	return 1;
6630}
6631
6632int32_t LuaScriptInterface::luaDoRemoveConditions(lua_State* L)
6633{
6634	//doRemoveConditions(cid[, onlyPersistent])
6635	bool onlyPersistent = true;
6636	if(lua_gettop(L) > 1)
6637		onlyPersistent = popNumber(L);
6638
6639	ScriptEnviroment* env = getEnv();
6640	Creature* creature = env->getCreatureByUID(popNumber(L));
6641	if(!creature)
6642	{
6643		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6644		lua_pushboolean(L, false);
6645		return 1;
6646	}
6647
6648	creature->removeConditions(CONDITIONEND_ABORT, onlyPersistent);
6649	lua_pushboolean(L, true);
6650	return 1;
6651}
6652
6653int32_t LuaScriptInterface::luaNumberToVariant(lua_State* L)
6654{
6655	//numberToVariant(number)
6656	LuaVariant var;
6657	var.type = VARIANT_NUMBER;
6658	var.number = popNumber(L);
6659
6660	LuaScriptInterface::pushVariant(L, var);
6661	return 1;
6662}
6663
6664int32_t LuaScriptInterface::luaStringToVariant(lua_State* L)
6665{
6666	//stringToVariant(string)
6667	LuaVariant var;
6668	var.type = VARIANT_STRING;
6669	var.text = popString(L);
6670
6671	LuaScriptInterface::pushVariant(L, var);
6672	return 1;
6673}
6674
6675int32_t LuaScriptInterface::luaPositionToVariant(lua_State* L)
6676{
6677	//positionToVariant(pos)
6678	LuaVariant var;
6679	var.type = VARIANT_POSITION;
6680	popPosition(L, var.pos);
6681
6682	LuaScriptInterface::pushVariant(L, var);
6683	return 1;
6684}
6685
6686int32_t LuaScriptInterface::luaTargetPositionToVariant(lua_State* L)
6687{
6688	//targetPositionToVariant(pos)
6689	LuaVariant var;
6690	var.type = VARIANT_TARGETPOSITION;
6691	popPosition(L, var.pos);
6692
6693	LuaScriptInterface::pushVariant(L, var);
6694	return 1;
6695}
6696
6697int32_t LuaScriptInterface::luaVariantToNumber(lua_State* L)
6698{
6699	//variantToNumber(var)
6700	LuaVariant var = popVariant(L);
6701
6702	uint32_t number = 0;
6703	if(var.type == VARIANT_NUMBER)
6704		number = var.number;
6705
6706	lua_pushnumber(L, number);
6707	return 1;
6708}
6709
6710int32_t LuaScriptInterface::luaVariantToString(lua_State* L)
6711{
6712	//variantToString(var)
6713	LuaVariant var = popVariant(L);
6714
6715	std::string text = "";
6716	if(var.type == VARIANT_STRING)
6717		text = var.text;
6718
6719	lua_pushstring(L, text.c_str());
6720	return 1;
6721}
6722
6723int32_t LuaScriptInterface::luaVariantToPosition(lua_State* L)
6724{
6725	//luaVariantToPosition(var)
6726	LuaVariant var = popVariant(L);
6727
6728	PositionEx pos(0, 0, 0, 0);
6729	if(var.type == VARIANT_POSITION || var.type == VARIANT_TARGETPOSITION)
6730		pos = var.pos;
6731
6732	pushPosition(L, pos, pos.stackpos);
6733	return 1;
6734}
6735
6736int32_t LuaScriptInterface::luaDoChangeSpeed(lua_State* L)
6737{
6738	//doChangeSpeed(cid, delta)
6739	int32_t delta = (int32_t)popNumber(L);
6740
6741	ScriptEnviroment* env = getEnv();
6742	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
6743	{
6744		g_game.changeSpeed(creature, delta);
6745		lua_pushboolean(L, true);
6746	}
6747	else
6748	{
6749		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6750		lua_pushboolean(L, false);
6751	}
6752	return 1;
6753}
6754
6755int32_t LuaScriptInterface::luaSetCreatureOutfit(lua_State* L)
6756{
6757	//doSetCreatureOutfit(cid, outfit, time)
6758	int32_t time = (int32_t)popNumber(L);
6759	Outfit_t outfit = popOutfit(L);
6760
6761	ScriptEnviroment* env = getEnv();
6762	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
6763		lua_pushboolean(L, Spell::CreateIllusion(creature, outfit, time) == RET_NOERROR);
6764	else
6765	{
6766		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6767		lua_pushboolean(L, false);
6768	}
6769	return 1;
6770}
6771
6772int32_t LuaScriptInterface::luaGetCreatureOutfit(lua_State* L)
6773{
6774	//getCreatureOutfit(cid)
6775	ScriptEnviroment* env = getEnv();
6776	if(const Creature* creature = env->getCreatureByUID(popNumber(L)))
6777		pushOutfit(L, creature->getCurrentOutfit());
6778	else
6779	{
6780		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6781		lua_pushboolean(L, false);
6782	}
6783	return 1;
6784}
6785
6786int32_t LuaScriptInterface::luaSetMonsterOutfit(lua_State* L)
6787{
6788	//doSetMonsterOutfit(cid, name, time)
6789	int32_t time = (int32_t)popNumber(L);
6790	std::string name = popString(L);
6791
6792	ScriptEnviroment* env = getEnv();
6793	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
6794		lua_pushboolean(L, Spell::CreateIllusion(creature, name, time) == RET_NOERROR);
6795	else
6796	{
6797		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6798		lua_pushboolean(L, false);
6799	}
6800	return 1;
6801}
6802
6803int32_t LuaScriptInterface::luaSetItemOutfit(lua_State* L)
6804{
6805	//doSetItemOutfit(cid, item, time)
6806	int32_t time = (int32_t)popNumber(L);
6807	uint32_t item = (uint32_t)popNumber(L);
6808
6809	ScriptEnviroment* env = getEnv();
6810	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
6811		lua_pushboolean(L, Spell::CreateIllusion(creature, item, time) == RET_NOERROR);
6812	else
6813	{
6814		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6815		lua_pushboolean(L, false);
6816	}
6817	return 1;
6818}
6819
6820int32_t LuaScriptInterface::luaGetStorage(lua_State* L)
6821{
6822	//getStorage(key)
6823	ScriptEnviroment* env = getEnv();
6824	std::string strValue;
6825	if(env->getStorage(popNumber(L), strValue))
6826	{
6827		int32_t intValue = atoi(strValue.c_str());
6828		if(intValue || strValue == "0")
6829			lua_pushnumber(L, intValue);
6830		else
6831			lua_pushstring(L, strValue.c_str());
6832	}
6833	else
6834		lua_pushnumber(L, -1);
6835
6836	return 1;
6837}
6838
6839int32_t LuaScriptInterface::luaDoSetStorage(lua_State* L)
6840{
6841	//doSetStorage(value, key)
6842	std::string value;
6843	bool nil = false;
6844	if(lua_isnil(L, -1))
6845	{
6846		nil = true;
6847		lua_pop(L, 1);
6848	}
6849	else
6850		value = popString(L);
6851
6852	ScriptEnviroment* env = getEnv();
6853	if(!nil)
6854		env->setStorage(popNumber(L), value);
6855	else
6856		env->eraseStorage(popNumber(L));
6857
6858	lua_pushboolean(L, true);
6859	return 1;
6860}
6861
6862int32_t LuaScriptInterface::luaGetPlayerDepotItems(lua_State* L)
6863{
6864	//getPlayerDepotItems(cid, depotid)
6865	uint32_t depotid = popNumber(L);
6866
6867	ScriptEnviroment* env = getEnv();
6868	if(Player* player = env->getPlayerByUID(popNumber(L)))
6869	{
6870		if(const Depot* depot = player->getDepot(depotid, true))
6871			lua_pushnumber(L, depot->getItemHoldingCount());
6872		else
6873			lua_pushboolean(L, false);
6874	}
6875	else
6876	{
6877		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
6878		lua_pushboolean(L, false);
6879	}
6880	return 1;
6881}
6882
6883int32_t LuaScriptInterface::luaDoPlayerSetGuildId(lua_State* L)
6884{
6885	//doPlayerSetGuildId(cid, id)
6886	uint32_t id = popNumber(L);
6887
6888	ScriptEnviroment* env = getEnv();
6889	if(Player* player = env->getPlayerByUID(popNumber(L)))
6890	{
6891		if(player->guildId)
6892		{
6893			player->leaveGuild();
6894			if(!id)
6895				lua_pushboolean(L, true);
6896			else if(IOGuild::getInstance()->guildExists(id))
6897				lua_pushboolean(L, IOGuild::getInstance()->joinGuild(player, id));
6898			else
6899				lua_pushboolean(L, false);
6900		}
6901		else if(id && IOGuild::getInstance()->guildExists(id))
6902			lua_pushboolean(L, IOGuild::getInstance()->joinGuild(player, id));
6903		else
6904			lua_pushboolean(L, false);
6905	}
6906	else
6907	{
6908		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
6909		lua_pushboolean(L, false);
6910	}
6911	return 1;
6912}
6913
6914int32_t LuaScriptInterface::luaDoPlayerSetGuildLevel(lua_State* L)
6915{
6916	//doPlayerSetGuildLevel(cid, level[, rank])
6917	uint32_t rank = 0;
6918	if(lua_gettop(L) > 2)
6919		rank = popNumber(L);
6920
6921	GuildLevel_t level = (GuildLevel_t)popNumber(L);
6922	ScriptEnviroment* env = getEnv();
6923	if(Player* player = env->getPlayerByUID(popNumber(L)))
6924		lua_pushboolean(L, player->setGuildLevel(level, rank));
6925	else
6926	{
6927		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
6928		lua_pushboolean(L, false);
6929	}
6930
6931	return 1;
6932}
6933
6934int32_t LuaScriptInterface::luaDoPlayerSetGuildNick(lua_State* L)
6935{
6936	//doPlayerSetGuildNick(cid, nick)
6937	std::string nick = popString(L);
6938
6939	ScriptEnviroment* env = getEnv();
6940	if(Player* player = env->getPlayerByUID(popNumber(L)))
6941	{
6942		player->setGuildNick(nick);
6943		lua_pushboolean(L, true);
6944	}
6945	else
6946	{
6947		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
6948		lua_pushboolean(L, false);
6949	}
6950
6951	return 1;
6952}
6953
6954int32_t LuaScriptInterface::luaGetGuildId(lua_State* L)
6955{
6956	//getGuildId(guildName)
6957	uint32_t guildId;
6958	if(IOGuild::getInstance()->getGuildId(guildId, popString(L)))
6959		lua_pushnumber(L, guildId);
6960	else
6961		lua_pushboolean(L, false);
6962
6963	return 1;
6964}
6965
6966int32_t LuaScriptInterface::luaGetGuildMotd(lua_State* L)
6967{
6968	//getGuildMotd(guildId)
6969	uint32_t guildId = popNumber(L);
6970	if(IOGuild::getInstance()->guildExists(guildId))
6971		lua_pushstring(L, IOGuild::getInstance()->getMotd(guildId).c_str());
6972	else
6973		lua_pushboolean(L, false);
6974
6975	return 1;
6976}
6977
6978int32_t LuaScriptInterface::luaDoMoveCreature(lua_State* L)
6979{
6980	//doMoveCreature(cid, direction)
6981	uint32_t direction = popNumber(L);
6982	if(direction < NORTH || direction > NORTHEAST)
6983	{
6984		lua_pushboolean(L, false);
6985		return 1;
6986	}
6987
6988	ScriptEnviroment* env = getEnv();
6989	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
6990		lua_pushnumber(L, g_game.internalMoveCreature(creature, (Direction)direction, FLAG_NOLIMIT));
6991	else
6992	{
6993		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6994		lua_pushboolean(L, false);
6995	}
6996
6997	return 1;
6998}
6999
7000int32_t LuaScriptInterface::luaIsCreature(lua_State* L)
7001{
7002	//isCreature(cid)
7003	ScriptEnviroment* env = getEnv();
7004	lua_pushboolean(L, env->getCreatureByUID(popNumber(L)) ? true : false);
7005	return 1;
7006}
7007
7008int32_t LuaScriptInterface::luaIsContainer(lua_State* L)
7009{
7010	//isContainer(uid)
7011	ScriptEnviroment* env = getEnv();
7012	lua_pushboolean(L, env->getContainerByUID(popNumber(L)) ? true : false);
7013	return 1;
7014}
7015
7016int32_t LuaScriptInterface::luaIsMovable(lua_State* L)
7017{
7018	//isMovable(uid)
7019	ScriptEnviroment* env = getEnv();
7020	Thing* thing = env->getThingByUID(popNumber(L));
7021	if(thing && thing->isPushable())
7022		lua_pushboolean(L, true);
7023	else
7024		lua_pushboolean(L, false);
7025
7026	return 1;
7027}
7028
7029int32_t LuaScriptInterface::luaGetCreatureByName(lua_State* L)
7030{
7031	//getCreatureByName(name)
7032	ScriptEnviroment* env = getEnv();
7033	if(Creature* creature = g_game.getCreatureByName(popString(L)))
7034		lua_pushnumber(L, env->addThing(creature));
7035	else
7036		lua_pushnil(L);
7037
7038	return 1;
7039}
7040
7041int32_t LuaScriptInterface::luaGetPlayerByGUID(lua_State* L)
7042{
7043	//getPlayerByGUID(guid)
7044	ScriptEnviroment* env = getEnv();
7045	if(Player* player = g_game.getPlayerByGuid(popNumber(L)))
7046		lua_pushnumber(L, env->addThing(player));
7047	else
7048		lua_pushnil(L);
7049
7050	return 1;
7051}
7052
7053int32_t LuaScriptInterface::luaGetPlayerByNameWildcard(lua_State* L)
7054{
7055	//getPlayerByNameWildcard(name~[, ret = false])
7056	Player* player = NULL;
7057	bool pushRet = false;
7058	if(lua_gettop(L) > 1)
7059		pushRet = popNumber(L);
7060
7061	ScriptEnviroment* env = getEnv();
7062	ReturnValue ret = g_game.getPlayerByNameWildcard(popString(L), player);
7063	if(ret == RET_NOERROR)
7064		lua_pushnumber(L, env->addThing(player));
7065	else if(pushRet)
7066		lua_pushnumber(L, ret);
7067	else
7068		lua_pushnil(L);
7069
7070	return 1;
7071}
7072
7073int32_t LuaScriptInterface::luaGetPlayerGUIDByName(lua_State* L)
7074{
7075	//getPlayerGUIDByName(name[, multiworld = false])
7076	bool multiworld = false;
7077	if(lua_gettop(L) > 1)
7078		multiworld = popNumber(L);
7079
7080	std::string name = popString(L);
7081	uint32_t guid;
7082	if(Player* player = g_game.getPlayerByName(name.c_str()))
7083		lua_pushnumber(L, player->getGUID());
7084	else if(IOLoginData::getInstance()->getGuidByName(guid, name, multiworld))
7085		lua_pushnumber(L, guid);
7086	else
7087		lua_pushnil(L);
7088
7089	return 1;
7090}
7091
7092int32_t LuaScriptInterface::luaGetPlayerNameByGUID(lua_State* L)
7093{
7094	//getPlayerNameByGUID(guid[, multiworld = false[, displayError = true]])
7095	int32_t parameters = lua_gettop(L);
7096	bool multiworld = false, displayError = true;
7097
7098	if(parameters > 2)
7099		displayError = popNumber(L);
7100
7101	if(parameters > 1)
7102		multiworld = popNumber(L);
7103
7104	uint32_t guid = popNumber(L);
7105	std::string name;
7106	if(!IOLoginData::getInstance()->getNameByGuid(guid, name, multiworld))
7107	{
7108		if(displayError)
7109			errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7110
7111		lua_pushnil(L);
7112		return 1;
7113	}
7114
7115	lua_pushstring(L, name.c_str());
7116	return 1;
7117}
7118
7119int32_t LuaScriptInterface::luaGetPlayersByAccountId(lua_State* L)
7120{
7121	//getPlayersByAccountId(accId)
7122	PlayerVector players = g_game.getPlayersByAccount(popNumber(L));
7123
7124	ScriptEnviroment* env = getEnv();
7125	PlayerVector::iterator it = players.begin();
7126
7127	lua_newtable(L);
7128	for(uint32_t i = 1; it != players.end(); ++it, ++i)
7129	{
7130		lua_pushnumber(L, i);
7131		lua_pushnumber(L, env->addThing(*it));
7132		pushTable(L);
7133	}
7134
7135	return 1;
7136}
7137
7138int32_t LuaScriptInterface::luaGetIpByName(lua_State* L)
7139{
7140	//getIpByName(name)
7141	std::string name = popString(L);
7142
7143	if(Player* player = g_game.getPlayerByName(name))
7144		lua_pushnumber(L, player->getIP());
7145	else
7146		lua_pushnumber(L, IOLoginData::getInstance()->getLastIPByName(name));
7147
7148	return 1;
7149}
7150
7151int32_t LuaScriptInterface::luaGetPlayersByIp(lua_State* L)
7152{
7153	//getPlayersByIp(ip[, mask])
7154	uint32_t mask = 0xFFFFFFFF;
7155	if(lua_gettop(L) > 1)
7156		mask = (uint32_t)popNumber(L);
7157
7158	PlayerVector players = g_game.getPlayersByIP(popNumber(L), mask);
7159
7160	ScriptEnviroment* env = getEnv();
7161	PlayerVector::iterator it = players.begin();
7162
7163	lua_newtable(L);
7164	for(uint32_t i = 1; it != players.end(); ++it, ++i)
7165	{
7166		lua_pushnumber(L, i);
7167		lua_pushnumber(L, env->addThing(*it));
7168		pushTable(L);
7169	}
7170
7171	return 1;
7172}
7173
7174int32_t LuaScriptInterface::luaGetAccountIdByName(lua_State* L)
7175{
7176	//getAccountIdByName(name)
7177	std::string name = popString(L);
7178
7179	if(Player* player = g_game.getPlayerByName(name))
7180		lua_pushnumber(L, player->getAccount());
7181	else
7182		lua_pushnumber(L, IOLoginData::getInstance()->getAccountIdByName(name));
7183
7184	return 1;
7185}
7186
7187int32_t LuaScriptInterface::luaGetAccountByName(lua_State* L)
7188{
7189	//getAccountByName(name)
7190	std::string name = popString(L);
7191
7192	if(Player* player = g_game.getPlayerByName(name))
7193		lua_pushstring(L, player->getAccountName().c_str());
7194	else
7195	{
7196		std::string tmp;
7197		IOLoginData::getInstance()->getAccountName(IOLoginData::getInstance()->getAccountIdByName(name), tmp);
7198		lua_pushstring(L, tmp.c_str());
7199	}
7200
7201	return 1;
7202}
7203
7204int32_t LuaScriptInterface::luaGetAccountIdByAccount(lua_State* L)
7205{
7206	//getAccountIdByAccount(accName)
7207	uint32_t value = 0;
7208	IOLoginData::getInstance()->getAccountId(popString(L), value);
7209	lua_pushnumber(L, value);
7210	return 1;
7211}
7212
7213int32_t LuaScriptInterface::luaGetAccountByAccountId(lua_State* L)
7214{
7215	//getAccountByAccountId(accId)
7216	std::string value = 0;
7217	IOLoginData::getInstance()->getAccountName(popNumber(L), value);
7218	lua_pushstring(L, value.c_str());
7219	return 1;
7220}
7221
7222int32_t LuaScriptInterface::luaRegisterCreatureEvent(lua_State* L)
7223{
7224	//registerCreatureEvent(cid, name[, remove])
7225	bool remove = false;
7226	if(lua_gettop(L) > 2)
7227		remove = popBoolean(L);
7228
7229	std::string name = popString(L);
7230
7231	ScriptEnviroment* env = getEnv();
7232	assert(env);
7233	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7234	{
7235		if(remove)
7236			lua_pushboolean(L, creature->unregisterCreatureEvent(name));
7237		else
7238			lua_pushboolean(L, creature->registerCreatureEvent(name));
7239	}
7240	else
7241	{
7242		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7243		lua_pushboolean(L, false);
7244	}
7245
7246	return 1;
7247}
7248
7249int32_t LuaScriptInterface::luaGetContainerSize(lua_State* L)
7250{
7251	//getContainerSize(uid)
7252	ScriptEnviroment* env = getEnv();
7253	if(Container* container = env->getContainerByUID(popNumber(L)))
7254		lua_pushnumber(L, container->size());
7255	else
7256	{
7257		errorEx(getError(LUA_ERROR_CONTAINER_NOT_FOUND));
7258		lua_pushboolean(L, false);
7259	}
7260	return 1;
7261}
7262
7263int32_t LuaScriptInterface::luaGetContainerCap(lua_State* L)
7264{
7265	//getContainerCap(uid)
7266	ScriptEnviroment* env = getEnv();
7267	if(Container* container = env->getContainerByUID(popNumber(L)))
7268		lua_pushnumber(L, container->capacity());
7269	else
7270	{
7271		errorEx(getError(LUA_ERROR_CONTAINER_NOT_FOUND));
7272		lua_pushboolean(L, false);
7273	}
7274	return 1;
7275}
7276
7277int32_t LuaScriptInterface::luaGetContainerItem(lua_State* L)
7278{
7279	//getContainerItem(uid, slot)
7280	uint32_t slot = popNumber(L);
7281
7282	ScriptEnviroment* env = getEnv();
7283	if(Container* container = env->getContainerByUID(popNumber(L)))
7284	{
7285		if(Item* item = container->getItem(slot))
7286			pushThing(L, item, env->addThing(item));
7287		else
7288			pushThing(L, NULL, 0);
7289	}
7290	else
7291	{
7292		errorEx(getError(LUA_ERROR_CONTAINER_NOT_FOUND));
7293		pushThing(L, NULL, 0);
7294	}
7295	return 1;
7296
7297}
7298
7299int32_t LuaScriptInterface::luaDoAddContainerItemEx(lua_State* L)
7300{
7301	//doAddContainerItemEx(uid, virtuid)
7302	uint32_t virtuid = popNumber(L);
7303	ScriptEnviroment* env = getEnv();
7304	if(Container* container = env->getContainerByUID(popNumber(L)))
7305	{
7306		Item* item = env->getItemByUID(virtuid);
7307		if(!item)
7308		{
7309			errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
7310			lua_pushboolean(L, false);
7311			return 1;
7312		}
7313
7314		if(item->getParent() != VirtualCylinder::virtualCylinder)
7315		{
7316			lua_pushboolean(L, false);
7317			return 1;
7318		}
7319
7320		ReturnValue ret = g_game.internalAddItem(NULL, container, item);
7321		if(ret == RET_NOERROR)
7322			env->removeTempItem(item);
7323
7324		lua_pushnumber(L, ret);
7325		return 1;
7326	}
7327	else
7328	{
7329		errorEx(getError(LUA_ERROR_CONTAINER_NOT_FOUND));
7330		lua_pushboolean(L, false);
7331		return 1;
7332	}
7333}
7334
7335int32_t LuaScriptInterface::luaDoAddContainerItem(lua_State* L)
7336{
7337	//doAddContainerItem(uid, itemid[, count/subType])
7338	uint32_t count = 1;
7339	if(lua_gettop(L) > 2)
7340		count = popNumber(L);
7341
7342	uint16_t itemId = popNumber(L);
7343	ScriptEnviroment* env = getEnv();
7344
7345	Container* container = env->getContainerByUID((uint32_t)popNumber(L));
7346	if(!container)
7347	{
7348		errorEx(getError(LUA_ERROR_CONTAINER_NOT_FOUND));
7349		lua_pushboolean(L, false);
7350		return 1;
7351	}
7352
7353	const ItemType& it = Item::items[itemId];
7354	int32_t itemCount = 1, subType = 1;
7355	if(it.hasSubType())
7356	{
7357		if(it.stackable)
7358			itemCount = (int32_t)std::ceil((float)count / 100);
7359
7360		subType = count;
7361	}
7362	else
7363		itemCount = std::max((uint32_t)1, count);
7364
7365	while(itemCount > 0)
7366	{
7367		int32_t stackCount = std::min(100, subType);
7368		Item* newItem = Item::CreateItem(itemId, stackCount);
7369		if(!newItem)
7370		{
7371			errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
7372			lua_pushboolean(L, false);
7373			return 1;
7374		}
7375
7376		if(it.stackable)
7377			subType -= stackCount;
7378
7379		ReturnValue ret = g_game.internalAddItem(NULL, container, newItem);
7380		if(ret != RET_NOERROR)
7381		{
7382			delete newItem;
7383			lua_pushboolean(L, false);
7384			return 1;
7385		}
7386
7387		--itemCount;
7388		if(itemCount)
7389			continue;
7390
7391		if(newItem->getParent())
7392			lua_pushnumber(L, env->addThing(newItem));
7393		else //stackable item stacked with existing object, newItem will be released
7394			lua_pushnil(L);
7395
7396		return 1;
7397	}
7398
7399	lua_pushnil(L);
7400	return 1;
7401}
7402
7403int32_t LuaScriptInterface::luaDoPlayerAddOutfit(lua_State *L)
7404{
7405	//Consider using doPlayerAddOutfitId instead
7406	//doPlayerAddOutfit(cid, looktype, addon)
7407	uint32_t addon = popNumber(L), lookType = popNumber(L);
7408	ScriptEnviroment* env = getEnv();
7409
7410	Player* player = env->getPlayerByUID((uint32_t)popNumber(L));
7411	if(!player)
7412	{
7413		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7414		lua_pushboolean(L, false);
7415		return 1;
7416	}
7417
7418	Outfit outfit;
7419	if(Outfits::getInstance()->getOutfit(lookType, outfit))
7420	{
7421		lua_pushboolean(L, player->addOutfit(outfit.outfitId, addon));
7422		return 1;
7423	}
7424
7425	lua_pushboolean(L, false);
7426	return 1;
7427}
7428
7429int32_t LuaScriptInterface::luaDoPlayerRemoveOutfit(lua_State *L)
7430{
7431	//Consider using doPlayerRemoveOutfitId instead
7432	//doPlayerRemoveOutfit(cid, looktype[, addon = 0])
7433	uint32_t addon = 0xFF;
7434	if(lua_gettop(L) > 2)
7435		addon = popNumber(L);
7436
7437	uint32_t lookType = popNumber(L);
7438	ScriptEnviroment* env = getEnv();
7439
7440	Player* player = env->getPlayerByUID((uint32_t)popNumber(L));
7441	if(!player)
7442	{
7443		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7444		lua_pushboolean(L, false);
7445		return 1;
7446	}
7447
7448	Outfit outfit;
7449	if(Outfits::getInstance()->getOutfit(lookType, outfit))
7450	{
7451		lua_pushboolean(L, player->removeOutfit(outfit.outfitId, addon));
7452		return 1;
7453	}
7454
7455	lua_pushboolean(L, false);
7456	return 1;
7457}
7458
7459int32_t LuaScriptInterface::luaDoPlayerAddOutfitId(lua_State *L)
7460{
7461	//doPlayerAddOutfitId(cid, outfitId, addon)
7462	uint32_t addon = popNumber(L), outfitId = popNumber(L);
7463	ScriptEnviroment* env = getEnv();
7464
7465	Player* player = env->getPlayerByUID((uint32_t)popNumber(L));
7466	if(!player)
7467	{
7468		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7469		lua_pushboolean(L, false);
7470		return 1;
7471	}
7472
7473	lua_pushboolean(L, player->addOutfit(outfitId, addon));
7474	return 1;
7475}
7476
7477int32_t LuaScriptInterface::luaDoPlayerRemoveOutfitId(lua_State *L)
7478{
7479	//doPlayerRemoveOutfitId(cid, outfitId[, addon = 0])
7480	uint32_t addon = 0xFF;
7481	if(lua_gettop(L) > 2)
7482		addon = popNumber(L);
7483
7484	uint32_t outfitId = popNumber(L);
7485	ScriptEnviroment* env = getEnv();
7486
7487	Player* player = env->getPlayerByUID((uint32_t)popNumber(L));
7488	if(!player)
7489	{
7490		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7491		lua_pushboolean(L, false);
7492		return 1;
7493	}
7494
7495	lua_pushboolean(L, player->removeOutfit(outfitId, addon));
7496	return 1;
7497}
7498
7499int32_t LuaScriptInterface::luaCanPlayerWearOutfit(lua_State* L)
7500{
7501	//canPlayerWearOutfit(cid, looktype[, addon = 0])
7502	uint32_t addon = 0;
7503	if(lua_gettop(L) > 2)
7504		addon = popNumber(L);
7505
7506	uint32_t lookType = popNumber(L);
7507	ScriptEnviroment* env = getEnv();
7508
7509	Player* player = env->getPlayerByUID(popNumber(L));
7510	if(!player)
7511	{
7512		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7513		lua_pushboolean(L, false);
7514		return 1;
7515	}
7516
7517	Outfit outfit;
7518	if(Outfits::getInstance()->getOutfit(lookType, outfit))
7519	{
7520		lua_pushboolean(L, player->canWearOutfit(outfit.outfitId, addon));
7521		return 1;
7522	}
7523
7524	lua_pushboolean(L, false);
7525	return 1;
7526}
7527
7528int32_t LuaScriptInterface::luaCanPlayerWearOutfitId(lua_State* L)
7529{
7530	//canPlayerWearOutfitId(cid, outfitId[, addon = 0])
7531	uint32_t addon = 0;
7532	if(lua_gettop(L) > 2)
7533		addon = popNumber(L);
7534
7535	uint32_t outfitId = popNumber(L);
7536	ScriptEnviroment* env = getEnv();
7537
7538	Player* player = env->getPlayerByUID(popNumber(L));
7539	if(!player)
7540	{
7541		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7542		lua_pushboolean(L, false);
7543		return 1;
7544	}
7545
7546	lua_pushboolean(L, player->canWearOutfit(outfitId, addon));
7547	return 1;
7548}
7549
7550int32_t LuaScriptInterface::luaDoCreatureChangeOutfit(lua_State* L)
7551{
7552	//doCreatureChangeOutfit(cid, outfit)
7553	Outfit_t outfit = popOutfit(L);
7554	ScriptEnviroment* env = getEnv();
7555	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7556	{
7557		if(Player* player = creature->getPlayer())
7558			player->changeOutfit(outfit, false);
7559		else
7560			creature->defaultOutfit = outfit;
7561
7562		if(!creature->hasCondition(CONDITION_OUTFIT, 1))
7563			g_game.internalCreatureChangeOutfit(creature, outfit);
7564
7565		lua_pushboolean(L, true);
7566	}
7567	else
7568	{
7569		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7570		lua_pushboolean(L, false);
7571	}
7572	return 1;
7573}
7574
7575int32_t LuaScriptInterface::luaDoSetCreatureLight(lua_State* L)
7576{
7577	//doSetCreatureLight(cid, lightLevel, lightColor, time)
7578	uint32_t time = popNumber(L);
7579	uint8_t color = (uint8_t)popNumber(L), level = (uint8_t)popNumber(L);
7580
7581	ScriptEnviroment* env = getEnv();
7582	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7583	{
7584		Condition* condition = Condition::createCondition(CONDITIONID_COMBAT, CONDITION_LIGHT, time, level | (color << 8));
7585		creature->addCondition(condition);
7586		lua_pushboolean(L, true);
7587	}
7588	else
7589	{
7590		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7591		lua_pushboolean(L, false);
7592	}
7593	return 1;
7594}
7595
7596int32_t LuaScriptInterface::luaDoPlayerPopupFYI(lua_State* L)
7597{
7598	//doPlayerPopupFYI(cid, message)
7599	std::string message = popString(L);
7600
7601	ScriptEnviroment* env = getEnv();
7602	if(Player* player = env->getPlayerByUID(popNumber(L)))
7603	{
7604		player->sendFYIBox(message);
7605		lua_pushboolean(L, true);
7606	}
7607	else
7608	{
7609		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7610		lua_pushboolean(L, false);
7611	}
7612	return 1;
7613}
7614
7615int32_t LuaScriptInterface::luaDoPlayerSendTutorial(lua_State* L)
7616{
7617	//doPlayerSendTutorial(cid, id)
7618	uint8_t id = (uint8_t)popNumber(L);
7619
7620	ScriptEnviroment* env = getEnv();
7621
7622	Player* player = env->getPlayerByUID(popNumber(L));
7623	if(!player)
7624	{
7625		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7626		lua_pushboolean(L, false);
7627		return 1;
7628	}
7629
7630	player->sendTutorial(id);
7631	lua_pushboolean(L, true);
7632	return 1;
7633}
7634
7635int32_t LuaScriptInterface::luaDoPlayerSendMailByName(lua_State* L)
7636{
7637	//doPlayerSendMailByName(name, item[, town[, actor]])
7638	ScriptEnviroment* env = getEnv();
7639	int32_t params = lua_gettop(L);
7640
7641	Creature* actor = NULL;
7642	if(params > 3)
7643		actor = env->getCreatureByUID(popNumber(L));
7644
7645	uint32_t town = 0;
7646	if(params > 2)
7647		town = popNumber(L);
7648
7649	Item* item = env->getItemByUID(popNumber(L));
7650	if(!item)
7651	{
7652		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
7653		lua_pushboolean(L, false);
7654		return 1;
7655	}
7656
7657	if(item->getParent() != VirtualCylinder::virtualCylinder)
7658	{
7659		lua_pushboolean(L, false);
7660		return 1;
7661	}
7662
7663	lua_pushboolean(L, IOLoginData::getInstance()->playerMail(actor, popString(L), town, item));
7664	return 1;
7665}
7666
7667int32_t LuaScriptInterface::luaDoPlayerAddMapMark(lua_State* L)
7668{
7669	//doPlayerAddMapMark(cid, pos, type[, description])
7670	std::string description;
7671	if(lua_gettop(L) > 3)
7672		description = popString(L);
7673
7674	MapMarks_t type = (MapMarks_t)popNumber(L);
7675	PositionEx pos;
7676	popPosition(L, pos);
7677
7678	ScriptEnviroment* env = getEnv();
7679	Player* player = env->getPlayerByUID(popNumber(L));
7680	if(!player)
7681	{
7682		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7683		lua_pushboolean(L, false);
7684		return 1;
7685	}
7686
7687	player->sendAddMarker(pos, type, description);
7688	lua_pushboolean(L, true);
7689	return 1;
7690}
7691
7692int32_t LuaScriptInterface::luaDoPlayerAddPremiumDays(lua_State* L)
7693{
7694	//doPlayerAddPremiumDays(cid, days)
7695	int32_t days = popNumber(L);
7696
7697	ScriptEnviroment* env = getEnv();
7698	if(Player* player = env->getPlayerByUID(popNumber(L)))
7699	{
7700		if(player->premiumDays < 65535)
7701		{
7702			Account account = IOLoginData::getInstance()->loadAccount(player->getAccount());
7703			if(days < 0)
7704			{
7705				account.premiumDays = std::max((uint32_t)0, uint32_t(account.premiumDays + (int32_t)days));
7706				player->premiumDays = std::max((uint32_t)0, uint32_t(player->premiumDays + (int32_t)days));
7707			}
7708			else
7709			{
7710				account.premiumDays = std::min((uint32_t)65534, uint32_t(account.premiumDays + (uint32_t)days));
7711				player->premiumDays = std::min((uint32_t)65534, uint32_t(player->premiumDays + (uint32_t)days));
7712			}
7713			IOLoginData::getInstance()->saveAccount(account);
7714		}
7715		lua_pushboolean(L, true);
7716	}
7717	else
7718	{
7719		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7720		lua_pushboolean(L, false);
7721	}
7722	return 1;
7723}
7724
7725int32_t LuaScriptInterface::luaGetCreatureLastPosition(lua_State* L)
7726{
7727	//getCreatureLastPosition(cid)
7728	ScriptEnviroment* env = getEnv();
7729
7730	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7731		pushPosition(L, creature->getLastPosition(), 0);
7732	else
7733	{
7734		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7735		lua_pushboolean(L, false);
7736	}
7737	return 1;
7738}
7739
7740int32_t LuaScriptInterface::luaGetCreatureName(lua_State* L)
7741{
7742	//getCreatureName(cid)
7743	ScriptEnviroment* env = getEnv();
7744	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7745		lua_pushstring(L, creature->getName().c_str());
7746	else
7747	{
7748		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7749		lua_pushboolean(L, false);
7750	}
7751
7752	return 1;
7753}
7754
7755int32_t LuaScriptInterface::luaGetCreatureNoMove(lua_State* L)
7756{
7757	//getCreatureNoMove(cid)
7758	ScriptEnviroment* env = getEnv();
7759	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7760		lua_pushboolean(L, creature->getNoMove());
7761	else
7762	{
7763		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7764		lua_pushboolean(L, false);
7765	}
7766
7767	return 1;
7768}
7769
7770int32_t LuaScriptInterface::luaGetCreatureSkullType(lua_State* L)
7771{
7772	//getCreatureSkullType(cid[, target])
7773	uint32_t tid = 0;
7774	if(lua_gettop(L) > 1)
7775		tid = popNumber(L);
7776
7777	ScriptEnviroment* env = getEnv();
7778	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7779	{
7780		if(!tid)
7781			lua_pushnumber(L, creature->getSkull());
7782		else if(Creature* target = env->getCreatureByUID(tid))
7783			lua_pushnumber(L, creature->getSkullClient(target));
7784		else
7785		{
7786			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7787			lua_pushboolean(L, false);
7788		}
7789	}
7790	else
7791	{
7792		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7793		lua_pushboolean(L, false);
7794	}
7795
7796	return 1;
7797}
7798
7799int32_t LuaScriptInterface::luaDoCreatureSetLookDir(lua_State* L)
7800{
7801	//doCreatureSetLookDirection(cid, dir)
7802	Direction dir = (Direction)popNumber(L);
7803	ScriptEnviroment* env = getEnv();
7804	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7805	{
7806		if(dir < NORTH || dir > WEST)
7807		{
7808			lua_pushboolean(L, false);
7809			return 1;
7810		}
7811
7812		g_game.internalCreatureTurn(creature, dir);
7813		lua_pushboolean(L, true);
7814	}
7815	else
7816	{
7817		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7818		lua_pushboolean(L, false);
7819	}
7820	return 1;
7821}
7822
7823int32_t LuaScriptInterface::luaDoCreatureSetSkullType(lua_State* L)
7824{
7825	//doCreatureSetSkullType(cid, skull)
7826	Skulls_t skull = (Skulls_t)popNumber(L);
7827	ScriptEnviroment* env = getEnv();
7828	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7829	{
7830		creature->setSkull(skull);
7831		g_game.updateCreatureSkull(creature);
7832		lua_pushboolean(L, true);
7833	}
7834	else
7835	{
7836		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7837		lua_pushboolean(L, false);
7838	}
7839	return 1;
7840}
7841
7842int32_t LuaScriptInterface::luaDoPlayerSetSkullEnd(lua_State* L)
7843{
7844	//doPlayerSetSkullEnd(cid, time, type)
7845	Skulls_t _skull = (Skulls_t)popNumber(L);
7846	time_t _time = (time_t)std::max((int64_t)0, popNumber(L));
7847
7848	ScriptEnviroment* env = getEnv();
7849	if(Player* player = env->getPlayerByUID(popNumber(L)))
7850	{
7851		player->setSkullEnd(_time, false, _skull);
7852		lua_pushboolean(L, true);
7853	}
7854	else
7855	{
7856		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7857		lua_pushboolean(L, false);
7858	}
7859	return 1;
7860}
7861
7862int32_t LuaScriptInterface::luaGetCreatureSpeed(lua_State* L)
7863{
7864	//getCreatureSpeed(cid)
7865	ScriptEnviroment* env = getEnv();
7866	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7867		lua_pushnumber(L, creature->getSpeed());
7868	else
7869	{
7870		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7871		lua_pushboolean(L, false);
7872	}
7873	return 1;
7874}
7875
7876int32_t LuaScriptInterface::luaGetCreatureBaseSpeed(lua_State* L)
7877{
7878	//getCreatureBaseSpeed(cid)
7879	ScriptEnviroment* env = getEnv();
7880	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7881		lua_pushnumber(L, creature->getBaseSpeed());
7882	else
7883	{
7884		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7885		lua_pushboolean(L, false);
7886	}
7887	return 1;
7888}
7889
7890int32_t LuaScriptInterface::luaGetCreatureTarget(lua_State* L)
7891{
7892	//getCreatureTarget(cid)
7893	ScriptEnviroment* env = getEnv();
7894	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7895	{
7896		Creature* target = creature->getAttackedCreature();
7897		lua_pushnumber(L, target ? env->addThing(target) : 0);
7898	}
7899	else
7900	{
7901		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7902		lua_pushboolean(L, false);
7903	}
7904	return 1;
7905}
7906
7907int32_t LuaScriptInterface::luaIsSightClear(lua_State* L)
7908{
7909	//isSightClear(fromPos, toPos, floorCheck)
7910	PositionEx fromPos, toPos;
7911	bool floorCheck = popNumber(L);
7912
7913	popPosition(L, toPos);
7914	popPosition(L, fromPos);
7915
7916	lua_pushboolean(L, g_game.isSightClear(fromPos, toPos, floorCheck));
7917	return 1;
7918}
7919
7920int32_t LuaScriptInterface::luaIsInArray(lua_State* L)
7921{
7922	//isInArray(array, value[, caseSensitive = false])
7923	bool caseSensitive = false;
7924	if(lua_gettop(L) > 2)
7925		caseSensitive = popNumber(L);
7926
7927	boost::any value;
7928	if(lua_isnumber(L, -1))
7929		value = popFloatNumber(L);
7930	else if(lua_isboolean(L, -1))
7931		value = popBoolean(L);
7932	else if(lua_isstring(L, -1))
7933		value = popString(L);
7934	else
7935	{
7936		lua_pop(L, 1);
7937		lua_pushboolean(L, false);
7938		return 1;
7939	}
7940
7941	const std::type_info& type = value.type();
7942	if(!caseSensitive && type == typeid(std::string))
7943		value = asLowerCaseString(boost::any_cast<std::string>(value));
7944
7945	if(!lua_istable(L, -1))
7946	{
7947		boost::any data;
7948		if(lua_isnumber(L, -1))
7949			data = popFloatNumber(L);
7950		else if(lua_isboolean(L, -1))
7951			data = popBoolean(L);
7952		else if(lua_isstring(L, -1))
7953			data = popString(L);
7954		else
7955		{
7956			lua_pop(L, 1);
7957			lua_pushboolean(L, false);
7958			return 1;
7959		}
7960
7961		if(type != data.type()) // check is it even same data type before searching deeper
7962			lua_pushboolean(L, false);
7963		else if(type == typeid(bool))
7964			lua_pushboolean(L, boost::any_cast<bool>(value) == boost::any_cast<bool>(data));
7965		else if(type == typeid(double))
7966			lua_pushboolean(L, boost::any_cast<double>(value) == boost::any_cast<double>(data));
7967		else if(caseSensitive)
7968			lua_pushboolean(L, boost::any_cast<std::string>(value) == boost::any_cast<std::string>(data));
7969		else
7970			lua_pushboolean(L, boost::any_cast<std::string>(value) == asLowerCaseString(boost::any_cast<std::string>(data)));
7971
7972		return 1;
7973	}
7974
7975	lua_pushnil(L);
7976	while(lua_next(L, -2))
7977	{
7978		boost::any data;
7979		if(lua_isnumber(L, -1))
7980			data = popFloatNumber(L);
7981		else if(lua_isboolean(L, -1))
7982			data = popBoolean(L);
7983		else if(lua_isstring(L, -1))
7984			data = popString(L);
7985		else
7986		{
7987			lua_pop(L, 1);
7988			break;
7989		}
7990
7991		if(type != data.type()) // check is it same data type before searching deeper
7992			continue;
7993
7994		if(type == typeid(bool))
7995		{
7996			if(boost::any_cast<bool>(value) != boost::any_cast<bool>(data))
7997				continue;
7998
7999			lua_pushboolean(L, true);
8000			return 1;
8001		}
8002		else if(type == typeid(double))
8003		{
8004			if(boost::any_cast<double>(value) != boost::any_cast<double>(data))
8005				continue;
8006
8007			lua_pushboolean(L, true);
8008			return 1;
8009		}
8010		else if(caseSensitive)
8011		{
8012			if(boost::any_cast<std::string>(value) != boost::any_cast<std::string>(data))
8013				continue;
8014
8015			lua_pushboolean(L, true);
8016			return 1;
8017		}
8018		else if(boost::any_cast<std::string>(value) == asLowerCaseString(boost::any_cast<std::string>(data)))
8019		{
8020			lua_pushboolean(L, true);
8021			return 1;
8022		}
8023	}
8024
8025	lua_pop(L, 2);
8026	lua_pushboolean(L, false);
8027	return 1;
8028}
8029
8030int32_t LuaScriptInterface::luaAddEvent(lua_State* L)
8031{
8032	//addEvent(callback, delay, ...)
8033	ScriptEnviroment* env = getEnv();
8034	LuaScriptInterface* interface = env->getInterface();
8035	if(!interface)
8036	{
8037		errorEx("No valid script interface!");
8038		lua_pushboolean(L, false);
8039		return 1;
8040	}
8041
8042	int32_t parameters = lua_gettop(L);
8043	if(!lua_isfunction(L, -parameters)) //-parameters means the first parameter from left to right
8044	{
8045		errorEx("Callback parameter should be a function.");
8046		lua_pushboolean(L, false);
8047		return 1;
8048	}
8049
8050	std::list<int32_t> params;
8051	for(int32_t i = 0; i < parameters - 2; ++i) //-2 because addEvent needs at least two parameters
8052		params.push_back(luaL_ref(L, LUA_REGISTRYINDEX));
8053
8054	uint32_t delay = std::max((int64_t)SCHEDULER_MINTICKS, popNumber(L));
8055	LuaTimerEvent eventDesc;
8056
8057	eventDesc.parameters = params;
8058	eventDesc.function = luaL_ref(L, LUA_REGISTRYINDEX);
8059	eventDesc.scriptId = env->getScriptId();
8060
8061	interface->m_timerEvents[++interface->m_lastEventTimerId] = eventDesc;
8062	Scheduler::getInstance().addEvent(createSchedulerTask(delay, boost::bind(
8063		&LuaScriptInterface::executeTimer, interface, interface->m_lastEventTimerId)));
8064
8065	lua_pushnumber(L, interface->m_lastEventTimerId);
8066	return 1;
8067}
8068
8069int32_t LuaScriptInterface::luaStopEvent(lua_State* L)
8070{
8071	//stopEvent(eventid)
8072	uint32_t eventId = popNumber(L);
8073	ScriptEnviroment* env = getEnv();
8074
8075	LuaScriptInterface* interface = env->getInterface();
8076	if(!interface)
8077	{
8078		errorEx("No valid script interface!");
8079		lua_pushboolean(L, false);
8080		return 1;
8081	}
8082
8083	LuaTimerEvents::iterator it = interface->m_timerEvents.find(eventId);
8084	if(it != interface->m_timerEvents.end())
8085	{
8086		for(std::list<int32_t>::iterator lt = it->second.parameters.begin(); lt != it->second.parameters.end(); ++lt)
8087			luaL_unref(interface->m_luaState, LUA_REGISTRYINDEX, *lt);
8088		it->second.parameters.clear();
8089
8090		luaL_unref(interface->m_luaState, LUA_REGISTRYINDEX, it->second.function);
8091		interface->m_timerEvents.erase(it);
8092		lua_pushboolean(L, true);
8093	}
8094	else
8095		lua_pushboolean(L, false);
8096
8097	return 1;
8098}
8099
8100int32_t LuaScriptInterface::luaGetCreatureCondition(lua_State* L)
8101{
8102	//getCreatureCondition(cid, condition[, subId])
8103	uint32_t subId = 0, condition = 0;
8104	if(lua_gettop(L) > 2)
8105		subId = popNumber(L);
8106
8107	condition = popNumber(L);
8108	ScriptEnviroment* env = getEnv();
8109	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8110		lua_pushboolean(L, creature->hasCondition((ConditionType_t)condition, subId));
8111	else
8112	{
8113		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8114		lua_pushboolean(L, false);
8115	}
8116
8117	return 1;
8118}
8119
8120int32_t LuaScriptInterface::luaGetPlayerBlessing(lua_State* L)
8121{
8122	//getPlayerBlessings(cid, blessing)
8123	int16_t blessing = popNumber(L) - 1;
8124
8125	ScriptEnviroment* env = getEnv();
8126	if(Player* player = env->getPlayerByUID(popNumber(L)))
8127		lua_pushboolean(L, player->hasBlessing(blessing));
8128	else
8129	{
8130		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8131		lua_pushboolean(L, false);
8132	}
8133	return 1;
8134}
8135
8136int32_t LuaScriptInterface::luaDoPlayerAddBlessing(lua_State* L)
8137{
8138	//doPlayerAddBlessing(cid, blessing)
8139	int16_t blessing = popNumber(L) - 1;
8140	ScriptEnviroment* env = getEnv();
8141	if(Player* player = env->getPlayerByUID(popNumber(L)))
8142	{
8143		if(!player->hasBlessing(blessing))
8144		{
8145			player->addBlessing(1 << blessing);
8146			lua_pushboolean(L, true);
8147		}
8148		else
8149			lua_pushboolean(L, false);
8150	}
8151	else
8152	{
8153		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8154		lua_pushboolean(L, false);
8155	}
8156	return 1;
8157}
8158
8159int32_t LuaScriptInterface::luaDoPlayerSetPromotionLevel(lua_State* L)
8160{
8161	//doPlayerSetPromotionLevel(cid, level)
8162	uint32_t level = popNumber(L);
8163	ScriptEnviroment* env = getEnv();
8164	if(Player* player = env->getPlayerByUID(popNumber(L)))
8165	{
8166		player->setPromotionLevel(level);
8167		lua_pushboolean(L, true);
8168	}
8169	else
8170	{
8171		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8172		lua_pushboolean(L, false);
8173	}
8174	return 1;
8175}
8176
8177int32_t LuaScriptInterface::luaDoPlayerSetGroupId(lua_State* L)
8178{
8179	//doPlayerSetGroupId(cid, groupId)
8180	uint32_t groupId = popNumber(L);
8181	ScriptEnviroment* env = getEnv();
8182	if(Player* player = env->getPlayerByUID(popNumber(L)))
8183	{
8184		if(Group* group = Groups::getInstance()->getGroup(groupId))
8185		{
8186			player->setGroup(group);
8187			lua_pushboolean(L, true);
8188		}
8189		else
8190			lua_pushboolean(L, false);
8191	}
8192	else
8193	{
8194		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8195		lua_pushboolean(L, false);
8196	}
8197	return 1;
8198}
8199
8200int32_t LuaScriptInterface::luaGetCreatureMana(lua_State* L)
8201{
8202	//getCreatureMana(cid)
8203	ScriptEnviroment* env = getEnv();
8204	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8205		lua_pushnumber(L, creature->getMana());
8206	else
8207	{
8208		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8209		lua_pushboolean(L, false);
8210	}
8211	return 1;
8212}
8213
8214int32_t LuaScriptInterface::luaGetCreatureMaxMana(lua_State* L)
8215{
8216	//getCreatureMaxMana(cid)
8217	ScriptEnviroment* env = getEnv();
8218	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8219		lua_pushnumber(L, creature->getMaxMana());
8220	else
8221	{
8222		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8223		lua_pushboolean(L, false);
8224	}
8225	return 1;
8226}
8227
8228int32_t LuaScriptInterface::luaGetCreatureHealth(lua_State* L)
8229{
8230	//getCreatureHealth(cid)
8231	ScriptEnviroment* env = getEnv();
8232	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8233		lua_pushnumber(L, creature->getHealth());
8234	else
8235	{
8236		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8237		lua_pushboolean(L, false);
8238	}
8239	return 1;
8240}
8241
8242int32_t LuaScriptInterface::luaGetCreatureLookDirection(lua_State* L)
8243{
8244	//getCreatureLookDirection(cid)
8245	ScriptEnviroment* env = getEnv();
8246
8247	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8248		lua_pushnumber(L, creature->getDirection());
8249	else
8250	{
8251		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8252		lua_pushboolean(L, false);
8253	}
8254	return 1;
8255}
8256
8257int32_t LuaScriptInterface::luaGetCreatureMaxHealth(lua_State* L)
8258{
8259	//getCreatureMaxHealth(cid)
8260	ScriptEnviroment* env = getEnv();
8261	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8262		lua_pushnumber(L, creature->getMaxHealth());
8263	else
8264	{
8265		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8266		lua_pushboolean(L, false);
8267	}
8268	return 1;
8269}
8270
8271int32_t LuaScriptInterface::luaDoPlayerSetStamina(lua_State* L)
8272{
8273	//doPlayerSetStamina(cid, minutes)
8274	uint32_t minutes = popNumber(L);
8275
8276	ScriptEnviroment* env = getEnv();
8277	if(Player* player = env->getPlayerByUID(popNumber(L)))
8278	{
8279		player->setStaminaMinutes(minutes);
8280		lua_pushboolean(L, true);
8281	}
8282	else
8283	{
8284		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8285		lua_pushboolean(L, false);
8286	}
8287	return 1;
8288}
8289
8290int32_t LuaScriptInterface::luaDoPlayerAddStamina(lua_State* L)
8291{
8292	//doPlayerAddStamina(cid, minutes)
8293	int32_t minutes = popNumber(L);
8294
8295	ScriptEnviroment* env = getEnv();
8296	if(Player* player = env->getPlayerByUID(popNumber(L)))
8297	{
8298		player->setStaminaMinutes(player->getStaminaMinutes() + minutes);
8299		lua_pushboolean(L, true);
8300	}
8301	else
8302	{
8303		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8304		lua_pushboolean(L, false);
8305	}
8306	return 1;
8307}
8308
8309int32_t LuaScriptInterface::luaDoPlayerSetBalance(lua_State* L)
8310{
8311	//doPlayerSetBalance(cid, balance)
8312	uint32_t balance = popNumber(L);
8313
8314	ScriptEnviroment* env = getEnv();
8315	if(Player* player = env->getPlayerByUID(popNumber(L)))
8316	{
8317		player->balance = balance;
8318		lua_pushboolean(L, true);
8319	}
8320	else
8321	{
8322		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8323		lua_pushboolean(L, false);
8324	}
8325	return 1;
8326}
8327
8328int32_t LuaScriptInterface::luaDoPlayerSetPartner(lua_State* L)
8329{
8330	//doPlayerSetPartner(cid, guid)
8331	uint32_t guid = popNumber(L);
8332
8333	ScriptEnviroment* env = getEnv();
8334	if(Player* player = env->getPlayerByUID(popNumber(L)))
8335	{
8336		player->marriage = guid;
8337		lua_pushboolean(L, true);
8338	}
8339	else
8340	{
8341		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8342		lua_pushboolean(L, false);
8343	}
8344
8345	return 1;
8346}
8347
8348int32_t LuaScriptInterface::luaGetPlayerParty(lua_State* L)
8349{
8350	//getPlayerParty(cid)
8351	uint32_t cid = popNumber(L);
8352
8353	ScriptEnviroment* env = getEnv();
8354	if(Player* player = env->getPlayerByUID(cid))
8355	{
8356		if(Party* party = player->getParty())
8357			lua_pushnumber(L, env->addThing(party->getLeader()));
8358		else
8359			lua_pushnil(L);
8360	}
8361	else
8362	{
8363		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8364		lua_pushboolean(L, false);
8365	}
8366
8367	return 1;
8368}
8369
8370int32_t LuaScriptInterface::luaDoPlayerJoinParty(lua_State* L)
8371{
8372	//doPlayerJoinParty(cid, lid)
8373	ScriptEnviroment* env = getEnv();
8374
8375	Player* leader = env->getPlayerByUID(popNumber(L));
8376	if(!leader)
8377	{
8378		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8379		lua_pushboolean(L, false);
8380	}
8381
8382	Player* player = env->getPlayerByUID(popNumber(L));
8383	if(!player)
8384	{
8385		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8386		lua_pushboolean(L, false);
8387	}
8388
8389	g_game.playerJoinParty(player->getID(), leader->getID());
8390	lua_pushboolean(L, true);
8391	return 1;
8392}
8393
8394int32_t LuaScriptInterface::luaGetPartyMembers(lua_State* L)
8395{
8396	//getPartyMembers(cid)
8397	ScriptEnviroment* env = getEnv();
8398	if(Player* player = env->getPlayerByUID(popNumber(L)))
8399	{
8400		if(Party* party = player->getParty())
8401		{
8402			PlayerVector list = party->getMembers();
8403			list.push_back(party->getLeader());
8404
8405			PlayerVector::const_iterator it = list.begin();
8406			lua_newtable(L);
8407			for(uint32_t i = 1; it != list.end(); ++it, ++i)
8408			{
8409				lua_pushnumber(L, i);
8410				lua_pushnumber(L, (*it)->getID());
8411				pushTable(L);
8412			}
8413
8414			return 1;
8415		}
8416	}
8417
8418	lua_pushboolean(L, false);
8419	return 1;
8420}
8421
8422int32_t LuaScriptInterface::luaGetVocationInfo(lua_State* L)
8423{
8424	//getVocationInfo(id)
8425	uint32_t id = popNumber(L);
8426	Vocation* voc = Vocations::getInstance()->getVocation(id);
8427	if(!voc)
8428	{
8429		lua_pushboolean(L, false);
8430		return 1;
8431	}
8432
8433	lua_newtable(L);
8434	setField(L, "id", voc->getId());
8435	setField(L, "name", voc->getName().c_str());
8436	setField(L, "description", voc->getDescription().c_str());
8437	setField(L, "healthGain", voc->getGain(GAIN_HEALTH));
8438	setField(L, "healthGainTicks", voc->getGainTicks(GAIN_HEALTH));
8439	setField(L, "healthGainAmount", voc->getGainAmount(GAIN_HEALTH));
8440	setField(L, "manaGain", voc->getGain(GAIN_MANA));
8441	setField(L, "manaGainTicks", voc->getGainTicks(GAIN_MANA));
8442	setField(L, "manaGainAmount", voc->getGainAmount(GAIN_MANA));
8443	setField(L, "attackSpeed", voc->getAttackSpeed());
8444	setField(L, "baseSpeed", voc->getBaseSpeed());
8445	setField(L, "fromVocation", voc->getFromVocation());
8446	setField(L, "promotedVocation", Vocations::getInstance()->getPromotedVocation(id));
8447	setField(L, "soul", voc->getGain(GAIN_SOUL));
8448	setField(L, "soulAmount", voc->getGainAmount(GAIN_SOUL));
8449	setField(L, "soulTicks", voc->getGainTicks(GAIN_SOUL));
8450	setField(L, "capacity", voc->getGainCap());
8451	setFieldBool(L, "attackable", voc->isAttackable());
8452	setFieldBool(L, "needPremium", voc->isPremiumNeeded());
8453	setFieldFloat(L, "experienceMultiplier", voc->getExperienceMultiplier());
8454	return 1;
8455}
8456
8457int32_t LuaScriptInterface::luaGetGroupInfo(lua_State* L)
8458{
8459	//getGroupInfo(id[, premium])
8460	bool premium = false;
8461	if(lua_gettop(L) > 1)
8462		premium = popNumber(L);
8463
8464	Group* group = Groups::getInstance()->getGroup(popNumber(L));
8465	if(!group)
8466	{
8467		lua_pushboolean(L, false);
8468		return 1;
8469	}
8470
8471	lua_newtable(L);
8472	setField(L, "id", group->getId());
8473	setField(L, "name", group->getName().c_str());
8474	setField(L, "access", group->getAccess());
8475	setField(L, "ghostAccess", group->getGhostAccess());
8476	setField(L, "violationReasons", group->getViolationReasons());
8477	setField(L, "statementViolationFlags", group->getStatementViolationFlags());
8478	setField(L, "nameViolationFlags", group->getNameViolationFlags());
8479	setField(L, "flags", group->getFlags());
8480	setField(L, "customFlags", group->getCustomFlags());
8481	setField(L, "depotLimit", group->getDepotLimit(premium));
8482	setField(L, "maxVips", group->getMaxVips(premium));
8483	setField(L, "outfit", group->getOutfit());
8484	return 1;
8485}
8486
8487int32_t LuaScriptInterface::luaGetChannelUsers(lua_State* L)
8488{
8489	//getChannelUsers(channelId)
8490	ScriptEnviroment* env = getEnv();
8491	uint16_t channelId = popNumber(L);
8492
8493	if(ChatChannel* channel = g_chat.getChannelById(channelId))
8494	{
8495		UsersMap usersMap = channel->getUsers();
8496		UsersMap::iterator it = usersMap.begin();
8497
8498		lua_newtable(L);
8499		for(int32_t i = 1; it != usersMap.end(); ++it, ++i)
8500		{
8501			lua_pushnumber(L, i);
8502			lua_pushnumber(L, env->addThing(it->second));
8503			pushTable(L);
8504		}
8505	}
8506	else
8507		lua_pushboolean(L, false);
8508
8509	return 1;
8510}
8511
8512int32_t LuaScriptInterface::luaGetPlayersOnline(lua_State* L)
8513{
8514	//getPlayersOnline()
8515	ScriptEnviroment* env = getEnv();
8516	AutoList<Player>::iterator it = Player::autoList.begin();
8517
8518	lua_newtable(L);
8519	for(int32_t i = 1; it != Player::autoList.end(); ++it, ++i)
8520	{
8521		lua_pushnumber(L, i);
8522		lua_pushnumber(L, env->addThing(it->second));
8523		pushTable(L);
8524	}
8525	return 1;
8526}
8527
8528int32_t LuaScriptInterface::luaSetCreatureMaxHealth(lua_State* L)
8529{
8530	//setCreatureMaxHealth(uid, health)
8531	uint32_t maxHealth = (uint32_t)popNumber(L);
8532
8533	ScriptEnviroment* env = getEnv();
8534	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8535	{
8536		creature->changeMaxHealth(maxHealth);
8537		lua_pushboolean(L, true);
8538	}
8539	else
8540	{
8541		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8542		lua_pushboolean(L, false);
8543	}
8544	return 1;
8545}
8546
8547int32_t LuaScriptInterface::luaSetCreatureMaxMana(lua_State* L)
8548{
8549	//setCreatureMaxMana(uid, mana)
8550	uint32_t maxMana = (uint32_t)popNumber(L);
8551
8552	ScriptEnviroment* env = getEnv();
8553	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8554	{
8555		creature->changeMaxMana(maxMana);
8556		lua_pushboolean(L, true);
8557	}
8558	else
8559	{
8560		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8561		lua_pushboolean(L, false);
8562	}
8563	return 1;
8564}
8565
8566int32_t LuaScriptInterface::luaDoPlayerSetMaxCapacity(lua_State* L)
8567{
8568	//doPlayerSetMaxCapacity(uid, cap)
8569	double cap = popFloatNumber(L);
8570
8571	ScriptEnviroment* env = getEnv();
8572	if(Player* player = env->getPlayerByUID(popNumber(L)))
8573	{
8574		player->setCapacity(cap);
8575		lua_pushboolean(L, true);
8576	}
8577	else
8578	{
8579		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8580		lua_pushboolean(L, false);
8581	}
8582	return 1;
8583}
8584
8585int32_t LuaScriptInterface::luaGetCreatureMaster(lua_State* L)
8586{
8587	//getCreatureMaster(cid)
8588	uint32_t cid = popNumber(L);
8589
8590	ScriptEnviroment* env = getEnv();
8591
8592	Creature* creature = env->getCreatureByUID(cid);
8593	if(!creature)
8594	{
8595		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8596		lua_pushboolean(L, false);
8597		return 1;
8598	}
8599
8600	Creature* master = creature->getMaster();
8601	lua_pushnumber(L, master ? env->addThing(master) : cid);
8602	return 1;
8603}
8604
8605int32_t LuaScriptInterface::luaGetCreatureSummons(lua_State* L)
8606{
8607	//getCreatureSummons(cid)
8608	ScriptEnviroment* env = getEnv();
8609
8610	Creature* creature = env->getCreatureByUID(popNumber(L));
8611	if(!creature)
8612	{
8613		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8614		lua_pushboolean(L, false);
8615		return 1;
8616	}
8617
8618	const std::list<Creature*>& summons = creature->getSummons();
8619	CreatureList::const_iterator it = summons.begin();
8620
8621	lua_newtable(L);
8622	for(uint32_t i = 1; it != summons.end(); ++it, ++i)
8623	{
8624		lua_pushnumber(L, i);
8625		lua_pushnumber(L, env->addThing(*it));
8626		pushTable(L);
8627	}
8628
8629	return 1;
8630}
8631
8632int32_t LuaScriptInterface::luaDoPlayerSetIdleTime(lua_State* L)
8633{
8634	//doPlayerSetIdleTime(cid, amount)
8635	int64_t amount = popNumber(L);
8636	ScriptEnviroment* env = getEnv();
8637	if(Player* player = env->getPlayerByUID(popNumber(L)))
8638	{
8639		player->setIdleTime(amount);
8640		lua_pushboolean(L, true);
8641	}
8642	else
8643	{
8644		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8645		lua_pushboolean(L, false);
8646	}
8647	return 1;
8648}
8649
8650int32_t LuaScriptInterface::luaDoCreatureSetNoMove(lua_State* L)
8651{
8652	//doCreatureSetNoMove(cid, block)
8653	bool block = popNumber(L);
8654
8655	ScriptEnviroment* env = getEnv();
8656	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8657	{
8658		creature->setNoMove(block);
8659		lua_pushboolean(L, true);
8660	}
8661	else
8662	{
8663		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8664		lua_pushboolean(L, false);
8665	}
8666
8667	return 1;
8668}
8669
8670int32_t LuaScriptInterface::luaGetPlayerRates(lua_State* L)
8671{
8672	//getPlayerRates(cid)
8673	ScriptEnviroment* env = getEnv();
8674
8675	Player* player = env->getPlayerByUID(popNumber(L));
8676	if(!player)
8677	{
8678		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8679		lua_pushboolean(L, false);
8680		return 1;
8681	}
8682
8683	lua_newtable(L);
8684	for(uint32_t i = SKILL_FIRST; i <= SKILL__LAST; ++i)
8685	{
8686		lua_pushnumber(L, i);
8687		lua_pushnumber(L, player->rates[(skills_t)i]);
8688		pushTable(L);
8689	}
8690
8691	return 1;
8692}
8693
8694int32_t LuaScriptInterface::luaDoPlayerSetRate(lua_State* L)
8695{
8696	//doPlayerSetRate(cid, type, value)
8697	float value = popFloatNumber(L);
8698	uint32_t type = popNumber(L);
8699
8700	ScriptEnviroment* env = getEnv();
8701	if(Player* player = env->getPlayerByUID(popNumber(L)))
8702	{
8703		if(type <= SKILL__LAST)
8704		{
8705			player->rates[(skills_t)type] = value;
8706			lua_pushboolean(L, true);
8707		}
8708		else
8709			lua_pushboolean(L, false);
8710	}
8711	else
8712	{
8713		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8714		lua_pushboolean(L, false);
8715	}
8716
8717	return 1;
8718}
8719
8720int32_t LuaScriptInterface::luaDoPlayerSwitchSaving(lua_State* L)
8721{
8722	//doPlayerSwitchSaving(cid)
8723	ScriptEnviroment* env = getEnv();
8724	if(Player* player = env->getPlayerByUID(popNumber(L)))
8725	{
8726		player->switchSaving();
8727		lua_pushboolean(L, true);
8728	}
8729	else
8730	{
8731		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8732		lua_pushboolean(L, false);
8733	}
8734	return 1;
8735}
8736
8737int32_t LuaScriptInterface::luaDoPlayerSave(lua_State* L)
8738{
8739	//doPlayerSave(cid[, shallow = false])
8740	bool shallow = false;
8741	if(lua_gettop(L) > 1)
8742		shallow = popNumber(L);
8743
8744	ScriptEnviroment* env = getEnv();
8745	if(Player* player = env->getPlayerByUID(popNumber(L)))
8746		lua_pushboolean(L, IOLoginData::getInstance()->savePlayer(player, false, shallow));
8747	else
8748	{
8749		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8750		lua_pushboolean(L, false);
8751	}
8752	return 1;
8753}
8754
8755int32_t LuaScriptInterface::luaGetTownId(lua_State* L)
8756{
8757	//getTownId(townName)
8758	std::string townName = popString(L);
8759	if(Town* town = Towns::getInstance()->getTown(townName))
8760		lua_pushnumber(L, town->getID());
8761	else
8762		lua_pushboolean(L, false);
8763
8764	return 1;
8765}
8766
8767int32_t LuaScriptInterface::luaGetTownName(lua_State* L)
8768{
8769	//getTownName(townId)
8770	uint32_t townId = popNumber(L);
8771	if(Town* town = Towns::getInstance()->getTown(townId))
8772		lua_pushstring(L, town->getName().c_str());
8773	else
8774		lua_pushboolean(L, false);
8775
8776	return 1;
8777}
8778
8779int32_t LuaScriptInterface::luaGetTownTemplePosition(lua_State* L)
8780{
8781	//getTownTemplePosition(townId)
8782	bool displayError = true;
8783	if(lua_gettop(L) >= 2)
8784		displayError = popNumber(L);
8785
8786	uint32_t townId = popNumber(L);
8787	if(Town* town = Towns::getInstance()->getTown(townId))
8788		pushPosition(L, town->getPosition(), 255);
8789	else
8790		lua_pushboolean(L, false);
8791
8792	return 1;
8793}
8794
8795int32_t LuaScriptInterface::luaGetTownHouses(lua_State* L)
8796{
8797	//getTownHouses(townId)
8798	uint32_t townId = 0;
8799	if(lua_gettop(L) > 0)
8800		townId = popNumber(L);
8801
8802	HouseMap::iterator it = Houses::getInstance()->getHouseBegin();
8803	lua_newtable(L);
8804	for(uint32_t i = 1; it != Houses::getInstance()->getHouseEnd(); ++i, ++it)
8805	{
8806		if(townId != 0 && it->second->getTownId() != townId)
8807			continue;
8808
8809		lua_pushnumber(L, i);
8810		lua_pushnumber(L, it->second->getId());
8811		pushTable(L);
8812	}
8813
8814	return 1;
8815}
8816
8817int32_t LuaScriptInterface::luaGetSpectators(lua_State* L)
8818{
8819	//getSpectators(centerPos, rangex, rangey[, multifloor = false])
8820	bool multifloor = false;
8821	if(lua_gettop(L) > 3)
8822		multifloor = popNumber(L);
8823
8824	uint32_t rangey = popNumber(L), rangex = popNumber(L);
8825	PositionEx centerPos;
8826	popPosition(L, centerPos);
8827
8828	SpectatorVec list;
8829	g_game.getSpectators(list, centerPos, false, multifloor, rangex, rangex, rangey, rangey);
8830	if(list.empty())
8831	{
8832		lua_pushnil(L);
8833		return 1;
8834	}
8835
8836	ScriptEnviroment* env = getEnv();
8837	SpectatorVec::const_iterator it = list.begin();
8838
8839	lua_newtable(L);
8840	for(uint32_t i = 1; it != list.end(); ++it, ++i)
8841	{
8842		lua_pushnumber(L, i);
8843		lua_pushnumber(L, env->addThing(*it));
8844		pushTable(L);
8845	}
8846
8847	return 1;
8848}
8849
8850int32_t LuaScriptInterface::luaGetHighscoreString(lua_State* L)
8851{
8852	//getHighscoreString(skillId)
8853	uint16_t skillId = popNumber(L);
8854	if(skillId <= SKILL__LAST)
8855		lua_pushstring(L, g_game.getHighscoreString(skillId).c_str());
8856	else
8857		lua_pushboolean(L, false);
8858
8859	return 1;
8860}
8861
8862int32_t LuaScriptInterface::luaGetWaypointList(lua_State* L)
8863{
8864	//getWaypointList()
8865	WaypointMap waypointsMap = g_game.getMap()->waypoints.getWaypointsMap();
8866	WaypointMap::iterator it = waypointsMap.begin();
8867
8868	lua_newtable(L);
8869	for(uint32_t i = 1; it != waypointsMap.end(); ++it, ++i)
8870	{
8871		createTable(L, i);
8872		setField(L, "name", it->first);
8873		setField(L, "pos", it->second->pos.x);
8874		pushTable(L);
8875	}
8876
8877	return 1;
8878}
8879
8880int32_t LuaScriptInterface::luaGetWaypointPosition(lua_State* L)
8881{
8882	//getWaypointPosition(name)
8883	if(WaypointPtr waypoint = g_game.getMap()->waypoints.getWaypointByName(popString(L)))
8884		pushPosition(L, waypoint->pos, 0);
8885	else
8886		lua_pushboolean(L, false);
8887
8888	return 1;
8889}
8890
8891int32_t LuaScriptInterface::luaDoWaypointAddTemporial(lua_State* L)
8892{
8893	//doWaypointAddTemporial(name, pos)
8894	PositionEx pos;
8895	popPosition(L, pos);
8896
8897	g_game.getMap()->waypoints.addWaypoint(WaypointPtr(new Waypoint(popString(L), pos)));
8898	lua_pushboolean(L, true);
8899	return 1;
8900}
8901
8902int32_t LuaScriptInterface::luaGetGameState(lua_State* L)
8903{
8904	//getGameState()
8905	lua_pushnumber(L, g_game.getGameState());
8906	return 1;
8907}
8908
8909int32_t LuaScriptInterface::luaDoSetGameState(lua_State* L)
8910{
8911	//doSetGameState(id)
8912	uint32_t id = popNumber(L);
8913	if(id >= GAME_STATE_FIRST && id <= GAME_STATE_LAST)
8914	{
8915		Dispatcher::getInstance().addTask(createTask(boost::bind(&Game::setGameState, &g_game, (GameState_t)id)));
8916		lua_pushboolean(L, true);
8917	}
8918	else
8919		lua_pushboolean(L, false);
8920
8921	return 1;
8922}
8923
8924int32_t LuaScriptInterface::luaDoCreatureExecuteTalkAction(lua_State* L)
8925{
8926	//doCreatureExecuteTalkAction(cid, text[, ignoreAccess[, channelId]])
8927	uint32_t params = lua_gettop(L), channelId = CHANNEL_DEFAULT;
8928	if(params > 3)
8929		channelId = popNumber(L);
8930
8931	bool ignoreAccess = false;
8932	if(params > 2)
8933		ignoreAccess = popNumber(L);
8934
8935	std::string text = popString(L);
8936	ScriptEnviroment* env = getEnv();
8937	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8938		lua_pushboolean(L, g_talkActions->onPlayerSay(creature, channelId, text, ignoreAccess));
8939	else
8940	{
8941		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8942		lua_pushboolean(L, false);
8943	}
8944
8945	return 1;
8946}
8947
8948int32_t LuaScriptInterface::luaDoExecuteRaid(lua_State* L)
8949{
8950	//doExecuteRaid(name)
8951	std::string raidName = popString(L);
8952	if(Raids::getInstance()->getRunning())
8953	{
8954		lua_pushboolean(L, false);
8955		return 1;
8956	}
8957
8958	Raid* raid = Raids::getInstance()->getRaidByName(raidName);
8959	if(!raid || !raid->isLoaded())
8960	{
8961		errorEx("Raid with name " + raidName + " does not exists.");
8962		lua_pushboolean(L, false);
8963		return 1;
8964	}
8965
8966	lua_pushboolean(L, raid->startRaid());
8967	return 1;
8968}
8969
8970int32_t LuaScriptInterface::luaDoReloadInfo(lua_State* L)
8971{
8972	//doReloadInfo(id[, cid])
8973	uint32_t cid = 0;
8974	if(lua_gettop(L) > 1)
8975		cid = popNumber(L);
8976
8977	uint32_t id = popNumber(L);
8978	if(id >= RELOAD_FIRST && id <= RELOAD_LAST)
8979	{
8980		Scheduler::getInstance().addEvent(createSchedulerTask(SCHEDULER_MINTICKS,
8981			boost::bind(&Game::reloadInfo, &g_game, (ReloadInfo_t)id, cid)));
8982		lua_pushboolean(L, true);
8983	}
8984	else
8985		lua_pushboolean(L, false);
8986
8987	return 1;
8988}
8989
8990int32_t LuaScriptInterface::luaDoSaveServer(lua_State* L)
8991{
8992	//doSaveServer([shallow])
8993	bool shallow = false;
8994	if(lua_gettop(L) > 0)
8995		shallow = popNumber(L);
8996
8997	Dispatcher::getInstance().addTask(createTask(boost::bind(&Game::saveGameState, &g_game, shallow)));
8998	return 1;
8999}
9000
9001int32_t LuaScriptInterface::luaDoCleanHouse(lua_State* L)
9002{
9003	//doCleanHouse(houseId)
9004	uint32_t houseId = popNumber(L);
9005	if(House* house = Houses::getInstance()->getHouse(houseId))
9006	{
9007		house->clean();
9008		lua_pushboolean(L, true);
9009	}
9010	else
9011		lua_pushboolean(L, false);
9012
9013	return 1;
9014}
9015
9016int32_t LuaScriptInterface::luaDoCleanMap(lua_State* L)
9017{
9018	//doCleanMap()
9019	uint32_t count = 0;
9020	g_game.cleanMap(count);
9021	lua_pushnumber(L, count);
9022	return 1;
9023}
9024
9025int32_t LuaScriptInterface::luaDoRefreshMap(lua_State* L)
9026{
9027	//doRefreshMap()
9028	g_game.proceduralRefresh();
9029	return 1;
9030}
9031
9032int32_t LuaScriptInterface::luaDoUpdateHouseAuctions(lua_State* L)
9033{
9034	//doUpdateHouseAuctions()
9035	lua_pushboolean(L, IOMapSerialize::getInstance()->updateAuctions());
9036	return 1;
9037}
9038
9039int32_t LuaScriptInterface::luaGetItemIdByName(lua_State* L)
9040{
9041	//getItemIdByName(name[, displayError = true])
9042	bool displayError = true;
9043	if(lua_gettop(L) >= 2)
9044		displayError = popNumber(L);
9045
9046	int32_t itemId = Item::items.getItemIdByName(popString(L));
9047	if(itemId == -1)
9048	{
9049		if(displayError)
9050			errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
9051
9052		lua_pushboolean(L, false);
9053	}
9054	else
9055		lua_pushnumber(L, itemId);
9056
9057	return 1;
9058}
9059
9060int32_t LuaScriptInterface::luaGetItemInfo(lua_State* L)
9061{
9062	//getItemInfo(itemid)
9063	const ItemType* item;
9064	if(!(item = Item::items.getElement(popNumber(L))))
9065	{
9066		lua_pushboolean(L, false);
9067		return 1;
9068	}
9069
9070	lua_newtable(L);
9071	setFieldBool(L, "stopTime", item->stopTime);
9072	setFieldBool(L, "showCount", item->showCount);
9073	setFieldBool(L, "clientCharges", item->clientCharges);
9074	setFieldBool(L, "stackable", item->stackable);
9075	setFieldBool(L, "showDuration", item->showDuration);
9076	setFieldBool(L, "showCharges", item->showCharges);
9077	setFieldBool(L, "showAttributes", item->showCharges);
9078	setFieldBool(L, "distRead", item->allowDistRead);
9079	setFieldBool(L, "readable", item->canReadText);
9080	setFieldBool(L, "writable", item->canWriteText);
9081	setFieldBool(L, "forceSerialize", item->forceSerialize);
9082	setFieldBool(L, "vertical", item->isVertical);
9083	setFieldBool(L, "horizontal", item->isHorizontal);
9084	setFieldBool(L, "hangable", item->isHangable);
9085	setFieldBool(L, "usable", item->useable);
9086	setFieldBool(L, "movable", item->moveable);
9087	setFieldBool(L, "pickupable", item->pickupable);
9088	setFieldBool(L, "rotable", item->rotable);
9089	setFieldBool(L, "replacable", item->replaceable);
9090	setFieldBool(L, "hasHeight", item->hasHeight);
9091	setFieldBool(L, "blockSolid", item->blockSolid);
9092	setFieldBool(L, "blockPickupable", item->blockPickupable);
9093	setFieldBool(L, "blockProjectile", item->blockProjectile);
9094	setFieldBool(L, "blockPathing", item->blockPathFind);
9095	setFieldBool(L, "allowPickupable", item->allowPickupable);
9096	setFieldBool(L, "alwaysOnTop", item->alwaysOnTop);
9097
9098	createTable(L, "floorChange");
9099	for(int32_t i = CHANGE_FIRST; i <= CHANGE_LAST; ++i)
9100	{
9101		lua_pushnumber(L, i);
9102		lua_pushboolean(L, item->floorChange[i - 1]);
9103		pushTable(L);
9104	}
9105
9106	pushTable(L);
9107	setField(L, "magicEffect", (int32_t)item->magicEffect);
9108	setField(L, "fluidSource", (int32_t)item->fluidSource);
9109	setField(L, "weaponType", (int32_t)item->weaponType);
9110	setField(L, "bedPartnerDirection", (int32_t)item->bedPartnerDir);
9111	setField(L, "ammoAction", (int32_t)item->ammoAction);
9112	setField(L, "combatType", (int32_t)item->combatType);
9113	setField(L, "corpseType", (int32_t)item->corpseType);
9114	setField(L, "shootType", (int32_t)item->shootType);
9115	setField(L, "ammoType", (int32_t)item->ammoType);
9116
9117	createTable(L, "transformUseTo");
9118	setField(L, "female", item->transformUseTo[PLAYERSEX_FEMALE]);
9119	setField(L, "male", item->transformUseTo[PLAYERSEX_MALE]);
9120
9121	pushTable(L);
9122	setField(L, "transformToFree", item->transformToFree);
9123	setField(L, "transformEquipTo", item->transformEquipTo);
9124	setField(L, "transformDeEquipTo", item->transformDeEquipTo);
9125	setField(L, "clientId", item->clientId);
9126	setField(L, "maxItems", item->maxItems);
9127	setField(L, "slotPosition", item->slotPosition);
9128	setField(L, "wieldPosition", item->wieldPosition);
9129	setField(L, "speed", item->speed);
9130	setField(L, "maxTextLength", item->maxTextLen);
9131	setField(L, "writeOnceItemId", item->writeOnceItemId);
9132	setField(L, "attack", item->attack);
9133	setField(L, "extraAttack", item->extraAttack);
9134	setField(L, "defense", item->defense);
9135	setField(L, "extraDefense", item->extraDefense);
9136	setField(L, "armor", item->armor);
9137	setField(L, "breakChance", item->breakChance);
9138	setField(L, "hitChance", item->hitChance);
9139	setField(L, "maxHitChance", item->maxHitChance);
9140	setField(L, "runeLevel", item->runeLevel);
9141	setField(L, "runeMagicLevel", item->runeMagLevel);
9142	setField(L, "lightLevel", item->lightLevel);
9143	setField(L, "lightColor", item->lightColor);
9144	setField(L, "decayTo", item->decayTo);
9145	setField(L, "rotateTo", item->rotateTo);
9146	setField(L, "alwaysOnTopOrder", item->alwaysOnTopOrder);
9147	setField(L, "shootRange", item->shootRange);
9148	setField(L, "charges", item->charges);
9149	setField(L, "decayTime", item->decayTime);
9150	setField(L, "attackSpeed", item->attackSpeed);
9151	setField(L, "wieldInfo", item->wieldInfo);
9152	setField(L, "minRequiredLevel", item->minReqLevel);
9153	setField(L, "minRequiredMagicLevel", item->minReqMagicLevel);
9154	setField(L, "worth", item->worth);
9155	setField(L, "levelDoor", item->levelDoor);
9156	setField(L, "name", item->name.c_str());
9157	setField(L, "plural", item->pluralName.c_str());
9158	setField(L, "article", item->article.c_str());
9159	setField(L, "description", item->description.c_str());
9160	setField(L, "runeSpellName", item->runeSpellName.c_str());
9161	setField(L, "vocationString", item->vocationString.c_str());
9162
9163	createTable(L, "abilities");
9164	setFieldBool(L, "manaShield", item->abilities.manaShield);
9165	setFieldBool(L, "invisible", item->abilities.invisible);
9166	setFieldBool(L, "regeneration", item->abilities.regeneration);
9167	setFieldBool(L, "preventLoss", item->abilities.preventLoss);
9168	setFieldBool(L, "preventDrop", item->abilities.preventDrop);
9169	setField(L, "elementType", (int32_t)item->abilities.elementType);
9170	setField(L, "elementDamage", item->abilities.elementDamage);
9171	setField(L, "speed", item->abilities.speed);
9172	setField(L, "healthGain", item->abilities.healthGain);
9173	setField(L, "healthTicks", item->abilities.healthTicks);
9174	setField(L, "manaGain", item->abilities.manaGain);
9175	setField(L, "manaTicks", item->abilities.manaTicks);
9176	setField(L, "conditionSuppressions", item->abilities.conditionSuppressions);
9177
9178	//TODO: absorb, increment, reflect, skills, skillsPercent, stats, statsPercent
9179
9180	pushTable(L);
9181	setField(L, "group", (int32_t)item->group);
9182	setField(L, "type", (int32_t)item->type);
9183	setFieldFloat(L, "weight", item->weight);
9184	return 1;
9185}
9186
9187int32_t LuaScriptInterface::luaGetItemAttribute(lua_State* L)
9188{
9189	//getItemAttribute(uid, key)
9190	std::string key = popString(L);
9191	ScriptEnviroment* env = getEnv();
9192
9193	Item* item = env->getItemByUID(popNumber(L));
9194	if(!item)
9195	{
9196		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
9197		lua_pushnil(L);
9198		return 1;
9199	}
9200
9201	boost::any value = item->getAttribute(key);
9202	if(value.empty())
9203		lua_pushnil(L);
9204	else if(value.type() == typeid(std::string))
9205		lua_pushstring(L, boost::any_cast<std::string>(value).c_str());
9206	else if(value.type() == typeid(int32_t))
9207		lua_pushnumber(L, boost::any_cast<int32_t>(value));
9208	else if(value.type() == typeid(float))
9209		lua_pushnumber(L, boost::any_cast<float>(value));
9210	else if(value.type() == typeid(bool))
9211		lua_pushboolean(L, boost::any_cast<bool>(value));
9212	else
9213		lua_pushnil(L);
9214
9215	return 1;
9216}
9217
9218int32_t LuaScriptInterface::luaDoItemSetAttribute(lua_State* L)
9219{
9220	//doItemSetAttribute(uid, key, value)
9221	boost::any value;
9222	if(lua_isnumber(L, -1))
9223	{
9224		float tmp = popFloatNumber(L);
9225		if(std::floor(tmp) < tmp)
9226			value = tmp;
9227		else
9228			value = (int32_t)tmp;
9229	}
9230	else if(lua_isboolean(L, -1))
9231		value = popBoolean(L);
9232	else if(lua_isstring(L, -1))
9233		value = popString(L);
9234	else
9235	{
9236		lua_pop(L, 1);
9237		errorEx("Invalid data type");
9238
9239		lua_pushboolean(L, false);
9240		return 1;
9241	}
9242
9243	std::string key = popString(L);
9244	ScriptEnviroment* env = getEnv();
9245
9246	Item* item = env->getItemByUID(popNumber(L));
9247	if(!item)
9248	{
9249		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
9250		lua_pushboolean(L, false);
9251		return 1;
9252	}
9253
9254	if(value.type() == typeid(int32_t))
9255	{
9256		if(key == "uid")
9257		{
9258			int32_t tmp = boost::any_cast<int32_t>(value);
9259			if(tmp < 1000 || tmp > 0xFFFF)
9260			{
9261				errorEx("Value for protected key \"uid\" must be in range of 1000 to 65535");
9262				lua_pushboolean(L, false);
9263				return 1;
9264			}
9265
9266			item->setUniqueId(tmp);
9267		}		
9268		else if(key == "aid")
9269			item->setActionId(boost::any_cast<int32_t>(value));
9270		else
9271			item->setAttribute(key, boost::any_cast<int32_t>(value));
9272	}
9273	else
9274		item->setAttribute(key, value);
9275
9276	lua_pushboolean(L, true);
9277	return 1;
9278}
9279
9280int32_t LuaScriptInterface::luaDoItemEraseAttribute(lua_State* L)
9281{
9282	//doItemEraseAttribute(uid, key)
9283	std::string key = popString(L);
9284	ScriptEnviroment* env = getEnv();
9285
9286	Item* item = env->getItemByUID(popNumber(L));
9287	if(!item)
9288	{
9289		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
9290		lua_pushboolean(L, false);
9291		return 1;
9292	}
9293
9294	bool ret = true;
9295	if(key == "uid")
9296	{
9297		errorEx("Attempt to erase protected key \"uid\".");
9298		ret = false;
9299	}
9300	else if(key != "aid")
9301		item->eraseAttribute(key);
9302	else
9303		item->resetActionId();
9304
9305	lua_pushboolean(L, ret);
9306	return 1;
9307}
9308
9309int32_t LuaScriptInterface::luaGetItemWeight(lua_State* L)
9310{
9311	//getItemWeight(itemid[, precise = true])
9312	bool precise = true;
9313	if(lua_gettop(L) > 2)
9314		precise = popNumber(L);
9315
9316	ScriptEnviroment* env = getEnv();
9317	Item* item = env->getItemByUID(popNumber(L));
9318	if(!item)
9319	{
9320		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
9321		lua_pushboolean(L, false);
9322		return 1;
9323	}
9324
9325	double weight = item->getWeight();
9326	if(precise)
9327	{
9328		std::stringstream ws;
9329		ws << std::fixed << std::setprecision(2) << weight;
9330		weight = atof(ws.str().c_str());
9331	}
9332
9333	lua_pushnumber(L, weight);
9334	return 1;
9335}
9336
9337int32_t LuaScriptInterface::luaHasItemProperty(lua_State* L)
9338{
9339	//hasItemProperty(uid, prop)
9340	uint32_t prop = popNumber(L);
9341	ScriptEnviroment* env = getEnv();
9342
9343	Item* item = env->getItemByUID(popNumber(L));
9344	if(!item)
9345	{
9346		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
9347		lua_pushboolean(L, false);
9348		return 1;
9349	}
9350
9351	//Check if the item is a tile, so we can get more accurate properties
9352	bool tmp = item->hasProperty((ITEMPROPERTY)prop);
9353	if(item->getTile() && item->getTile()->ground == item)
9354		tmp = item->getTile()->hasProperty((ITEMPROPERTY)prop);
9355
9356	lua_pushboolean(L, tmp);
9357	return 1;
9358}
9359
9360int32_t LuaScriptInterface::luaIsIpBanished(lua_State* L)
9361{
9362	//isIpBanished(ip[, mask])
9363	uint32_t mask = 0xFFFFFFFF;
9364	if(lua_gettop(L) > 1)
9365		mask = popNumber(L);
9366
9367	lua_pushboolean(L, IOBan::getInstance()->isIpBanished((uint32_t)popNumber(L), mask));
9368	return 1;
9369}
9370
9371int32_t LuaScriptInterface::luaIsPlayerBanished(lua_State* L)
9372{
9373	//isPlayerBanished(name/guid, type)
9374	PlayerBan_t type = (PlayerBan_t)popNumber(L);
9375	if(lua_isnumber(L, -1))
9376		lua_pushboolean(L, IOBan::getInstance()->isPlayerBanished((uint32_t)popNumber(L), type));
9377	else
9378		lua_pushboolean(L, IOBan::getInstance()->isPlayerBanished(popString(L), type));
9379
9380	return 1;
9381}
9382
9383int32_t LuaScriptInterface::luaIsAccountBanished(lua_State* L)
9384{
9385	//isAccountBanished(accountId[, playerId])
9386	uint32_t playerId = 0;
9387	if(lua_gettop(L) > 1)
9388		playerId = popNumber(L);
9389
9390	lua_pushboolean(L, IOBan::getInstance()->isAccountBanished((uint32_t)popNumber(L), playerId));
9391	return 1;
9392}
9393
9394int32_t LuaScriptInterface::luaDoAddIpBanishment(lua_State* L)
9395{
9396	//doAddIpBanishment(ip[, mask[, length[, reason[, comment[, admin[, statement]]]]]])
9397	uint32_t admin = 0, reason = 21, mask = 0xFFFFFFFF, params = lua_gettop(L);
9398	int64_t length = time(NULL) + g_config.getNumber(ConfigManager::IPBANISHMENT_LENGTH);
9399	std::string statement, comment;
9400
9401	if(params > 6)
9402		statement = popString(L);
9403
9404	if(params > 5)
9405		admin = popNumber(L);
9406
9407	if(params > 4)
9408		comment = popString(L);
9409
9410	if(params > 3)
9411		reason = popNumber(L);
9412
9413	if(params > 2)
9414		length = popNumber(L);
9415
9416	if(params > 1)
9417		mask = popNumber(L);
9418
9419	lua_pushboolean(L, IOBan::getInstance()->addIpBanishment((uint32_t)popNumber(L),
9420		length, reason, comment, admin, mask, statement));
9421	return 1;
9422}
9423
9424int32_t LuaScriptInterface::luaDoAddPlayerBanishment(lua_State* L)
9425{
9426	//doAddPlayerBanishment(name/guid[, type[, length[, reason[, action[, comment[, admin[, statement]]]]]]])
9427	uint32_t admin = 0, reason = 21, params = lua_gettop(L);
9428	int64_t length = -1;
9429	std::string statement, comment;
9430
9431	ViolationAction_t action = ACTION_NAMELOCK;
9432	PlayerBan_t type = PLAYERBAN_LOCK;
9433	if(params > 7)
9434		statement = popString(L);
9435
9436	if(params > 6)
9437		admin = popNumber(L);
9438
9439	if(params > 5)
9440		comment = popString(L);
9441
9442	if(params > 4)
9443		action = (ViolationAction_t)popNumber(L);
9444
9445	if(params > 3)
9446		reason = popNumber(L);
9447
9448	if(params > 2)
9449		length = popNumber(L);
9450
9451	if(params > 1)
9452		type = (PlayerBan_t)popNumber(L);
9453
9454	if(lua_isnumber(L, -1))
9455		lua_pushboolean(L, IOBan::getInstance()->addPlayerBanishment((uint32_t)popNumber(L),
9456			length, reason, action, comment, admin, type, statement));
9457	else
9458		lua_pushboolean(L, IOBan::getInstance()->addPlayerBanishment(popString(L),
9459			length, reason, action, comment, admin, type, statement));
9460
9461	return 1;
9462}
9463
9464int32_t LuaScriptInterface::luaDoAddAccountBanishment(lua_State* L)
9465{
9466	//doAddAccountBanishment(accountId[, playerId[, length[, reason[, action[, comment[, admin[, statement]]]]]]])
9467	uint32_t admin = 0, reason = 21, playerId = 0, params = lua_gettop(L);
9468	int64_t length = time(NULL) + g_config.getNumber(ConfigManager::BAN_LENGTH);
9469	std::string statement, comment;
9470
9471	ViolationAction_t action = ACTION_BANISHMENT;
9472	if(params > 7)
9473		statement = popString(L);
9474
9475	if(params > 6)
9476		admin = popNumber(L);
9477
9478	if(params > 5)
9479		comment = popString(L);
9480
9481	if(params > 4)
9482		action = (ViolationAction_t)popNumber(L);
9483
9484	if(params > 3)
9485
9486		reason = popNumber(L);
9487
9488	if(params > 2)
9489		length = popNumber(L);
9490
9491	if(params > 1)
9492		playerId = popNumber(L);
9493
9494	lua_pushboolean(L, IOBan::getInstance()->addAccountBanishment((uint32_t)popNumber(L),
9495		length, reason, action, comment, admin, playerId, statement));
9496	return 1;
9497}
9498
9499int32_t LuaScriptInterface::luaDoAddNotation(lua_State* L)
9500{
9501	//doAddNotation(accountId[, playerId[, reason[, comment[, admin[, statement]]]]]])
9502	uint32_t admin = 0, reason = 21, playerId = 0, params = lua_gettop(L);
9503	std::string statement, comment;
9504
9505	if(params > 5)
9506		statement = popString(L);
9507
9508	if(params > 4)
9509		admin = popNumber(L);
9510
9511	if(params > 3)
9512		comment = popString(L);
9513
9514	if(params > 2)
9515		reason = popNumber(L);
9516
9517	if(params > 1)
9518		playerId = popNumber(L);
9519
9520	lua_pushboolean(L, IOBan::getInstance()->addNotation((uint32_t)popNumber(L),
9521		reason, comment, admin, playerId, statement));
9522	return 1;
9523}
9524
9525int32_t LuaScriptInterface::luaDoAddStatement(lua_State* L)
9526{
9527	//doAddStatement(name/guid[, channelId[, reason[, comment[, admin[, statement]]]]]])
9528	uint32_t admin = 0, reason = 21, params = lua_gettop(L);
9529	int16_t channelId = -1;
9530	std::string statement, comment;
9531
9532	if(params > 5)
9533		statement = popString(L);
9534
9535	if(params > 4)
9536		admin = popNumber(L);
9537
9538	if(params > 3)
9539		comment = popString(L);
9540
9541	if(params > 2)
9542		reason = popNumber(L);
9543
9544	if(params > 1)
9545		channelId = popNumber(L);
9546
9547	if(lua_isnumber(L, -1))
9548		lua_pushboolean(L, IOBan::getInstance()->addStatement((uint32_t)popNumber(L),
9549			reason, comment, admin, channelId, statement));
9550	else
9551		lua_pushboolean(L, IOBan::getInstance()->addStatement(popString(L),
9552			reason, comment, admin, channelId, statement));
9553
9554	return 1;
9555}
9556
9557int32_t LuaScriptInterface::luaDoRemoveIpBanishment(lua_State* L)
9558{
9559	//doRemoveIpBanishment(ip[, mask])
9560	uint32_t mask = 0xFFFFFFFF;
9561	if(lua_gettop(L) > 1)
9562		mask = popNumber(L);
9563
9564	lua_pushboolean(L, IOBan::getInstance()->removeIpBanishment(
9565		(uint32_t)popNumber(L), mask));
9566	return 1;
9567}
9568
9569int32_t LuaScriptInterface::luaDoRemovePlayerBanishment(lua_State* L)
9570{
9571	//doRemovePlayerBanishment(name/guid, type)
9572	PlayerBan_t type = (PlayerBan_t)popNumber(L);
9573	if(lua_isnumber(L, -1))
9574		lua_pushboolean(L, IOBan::getInstance()->removePlayerBanishment((uint32_t)popNumber(L), type));
9575	else
9576		lua_pushboolean(L, IOBan::getInstance()->removePlayerBanishment(popString(L), type));
9577
9578	return 1;
9579}
9580
9581int32_t LuaScriptInterface::luaDoRemoveAccountBanishment(lua_State* L)
9582{
9583	//doRemoveAccountBanishment(accountId[, playerId])
9584	uint32_t playerId = 0;
9585	if(lua_gettop(L) > 1)
9586		playerId = popNumber(L);
9587
9588	lua_pushboolean(L, IOBan::getInstance()->removeAccountBanishment((uint32_t)popNumber(L), playerId));
9589	return 1;
9590}
9591
9592int32_t LuaScriptInterface::luaDoRemoveNotations(lua_State* L)
9593{
9594	//doRemoveNotations(accountId[, playerId])
9595	uint32_t playerId = 0;
9596	if(lua_gettop(L) > 1)
9597		playerId = popNumber(L);
9598
9599	lua_pushboolean(L, IOBan::getInstance()->removeNotations((uint32_t)popNumber(L), playerId));
9600	return 1;
9601}
9602
9603int32_t LuaScriptInterface::luaDoRemoveStatements(lua_State* L)
9604{
9605	//doRemoveStatements(name/guid[, channelId])
9606	int16_t channelId = -1;
9607	if(lua_gettop(L) > 1)
9608		channelId = popNumber(L);
9609
9610	if(lua_isnumber(L, -1))
9611		lua_pushboolean(L, IOBan::getInstance()->removeStatements((uint32_t)popNumber(L), channelId));
9612	else
9613		lua_pushboolean(L, IOBan::getInstance()->removeStatements(popString(L), channelId));
9614
9615	return 1;
9616}
9617
9618int32_t LuaScriptInterface::luaGetNotationsCount(lua_State* L)
9619{
9620	//getNotationsCount(accountId[, playerId])
9621	uint32_t playerId = 0;
9622	if(lua_gettop(L) > 1)
9623		playerId = popNumber(L);
9624
9625	lua_pushnumber(L, IOBan::getInstance()->getNotationsCount((uint32_t)popNumber(L), playerId));
9626	return 1;
9627}
9628
9629int32_t LuaScriptInterface::luaGetStatementsCount(lua_State* L)
9630{
9631	//getStatementsCount(name/guid[, channelId])
9632	int16_t channelId = -1;
9633	if(lua_gettop(L) > 1)
9634		channelId = popNumber(L);
9635
9636	if(lua_isnumber(L, -1))
9637		lua_pushnumber(L, IOBan::getInstance()->getStatementsCount((uint32_t)popNumber(L), channelId));
9638	else
9639		lua_pushnumber(L, IOBan::getInstance()->getStatementsCount(popString(L), channelId));
9640
9641	return 1;
9642}
9643
9644int32_t LuaScriptInterface::luaGetBanData(lua_State* L)
9645{
9646	//getBanData(value[, type[, param]])
9647	Ban tmp;
9648	uint32_t params = lua_gettop(L);
9649	if(params > 2)
9650		tmp.param = popNumber(L);
9651
9652	if(params > 1)
9653		tmp.type = (Ban_t)popNumber(L);
9654
9655	tmp.value = popNumber(L);
9656	if(!IOBan::getInstance()->getData(tmp))
9657	{
9658		lua_pushboolean(L, false);
9659		return 1;
9660	}
9661
9662	lua_newtable(L);
9663	setField(L, "id", tmp.id);
9664	setField(L, "type", tmp.type);
9665	setField(L, "value", tmp.value);
9666	setField(L, "param", tmp.param);
9667	setField(L, "added", tmp.added);
9668	setField(L, "expires", tmp.expires);
9669	setField(L, "adminId", tmp.adminId);
9670	setField(L, "reason", tmp.reason);
9671	setField(L, "action", tmp.action);
9672	setField(L, "comment", tmp.comment);
9673	setField(L, "statement", tmp.statement);
9674	return 1;
9675}
9676
9677int32_t LuaScriptInterface::luaGetBanReason(lua_State* L)
9678{
9679	//getBanReason(id)
9680	lua_pushstring(L, getReason((ViolationAction_t)popNumber(L)).c_str());
9681	return 1;
9682}
9683
9684int32_t LuaScriptInterface::luaGetBanAction(lua_State* L)
9685{
9686	//getBanAction(id[, ipBanishment])
9687	bool ipBanishment = false;
9688	if(lua_gettop(L) > 1)
9689		ipBanishment = popNumber(L);
9690
9691	lua_pushstring(L, getAction((ViolationAction_t)popNumber(L), ipBanishment).c_str());
9692	return 1;
9693}
9694
9695int32_t LuaScriptInterface::luaGetBanList(lua_State* L)
9696{
9697	//getBanList(type[, value[, param]])
9698	int32_t param = 0, params = lua_gettop(L);
9699	if(params > 2)
9700		param = popNumber(L);
9701
9702	uint32_t value = 0;
9703	if(params > 1)
9704		value = popNumber(L);
9705
9706	BansVec bans = IOBan::getInstance()->getList((Ban_t)popNumber(L), value, param);
9707	BansVec::const_iterator it = bans.begin();
9708
9709	lua_newtable(L);
9710	for(uint32_t i = 1; it != bans.end(); ++it, ++i)
9711	{
9712		createTable(L, i);
9713		setField(L, "id", it->id);
9714		setField(L, "type", it->type);
9715		setField(L, "value", it->value);
9716		setField(L, "param", it->param);
9717		setField(L, "added", it->added);
9718		setField(L, "expires", it->expires);
9719		setField(L, "adminId", it->adminId);
9720		setField(L, "reason", it->reason);
9721		setField(L, "action", it->action);
9722		setField(L, "comment", it->comment);
9723		setField(L, "statement", it->statement);
9724		pushTable(L);
9725	}
9726
9727	return 1;
9728}
9729
9730int32_t LuaScriptInterface::luaGetExperienceStage(lua_State* L)
9731{
9732	//getExperienceStage(level[, divider])
9733	double divider = 1.0f;
9734	if(lua_gettop(L) > 1)
9735		divider = popFloatNumber(L);
9736
9737	lua_pushnumber(L, g_game.getExperienceStage(popNumber(L), divider));
9738	return 1;
9739}
9740
9741int32_t LuaScriptInterface::luaGetDataDir(lua_State* L)
9742{
9743	//getDataDir()
9744	lua_pushstring(L, getFilePath(FILE_TYPE_OTHER, "").c_str());
9745	return 1;
9746}
9747
9748int32_t LuaScriptInterface::luaGetLogsDir(lua_State* L)
9749{
9750	//getLogsDir()
9751	lua_pushstring(L, getFilePath(FILE_TYPE_LOG, "").c_str());
9752	return 1;
9753}
9754
9755int32_t LuaScriptInterface::luaGetConfigFile(lua_State* L)
9756{
9757	//getConfigFile()
9758	lua_pushstring(L, g_config.getString(ConfigManager::CONFIG_FILE).c_str());
9759	return 1;
9760}
9761
9762int32_t LuaScriptInterface::luaGetConfigValue(lua_State* L)
9763{
9764	//getConfigValue(key)
9765	g_config.getValue(popString(L), L);
9766	return 1;
9767}
9768
9769int32_t LuaScriptInterface::luaGetModList(lua_State* L)
9770{
9771	//getModList()
9772	ModMap::iterator it = ScriptingManager::getInstance()->getFirstMod();
9773	lua_newtable(L);
9774	for(uint32_t i = 1; it != ScriptingManager::getInstance()->getLastMod(); ++it, ++i)
9775	{
9776		createTable(L, i);
9777		setField(L, "name", it->first);
9778		setField(L, "description", it->second.description);
9779		setField(L, "file", it->second.file);
9780
9781		setField(L, "version", it->second.version);
9782		setField(L, "author", it->second.author);
9783		setField(L, "contact", it->second.contact);
9784
9785		setFieldBool(L, "enabled", it->second.enabled);
9786		pushTable(L);
9787	}
9788
9789	return 1;
9790}
9791
9792int32_t LuaScriptInterface::luaL_loadmodlib(lua_State* L)
9793{
9794	//loadmodlib(lib)
9795	std::string name = asLowerCaseString(popString(L));
9796	for(LibMap::iterator it = ScriptingManager::getInstance()->getFirstLib();
9797		it != ScriptingManager::getInstance()->getLastLib(); ++it)
9798	{
9799		if(asLowerCaseString(it->first) != name)
9800			continue;
9801
9802		luaL_loadstring(L, it->second.second.c_str());
9803		lua_pushvalue(L, -1);
9804		break;
9805	}
9806
9807	return 1;
9808}
9809
9810int32_t LuaScriptInterface::luaL_domodlib(lua_State* L)
9811{
9812	//domodlib(lib)
9813	std::string name = asLowerCaseString(popString(L));
9814	for(LibMap::iterator it = ScriptingManager::getInstance()->getFirstLib();
9815		it != ScriptingManager::getInstance()->getLastLib(); ++it)
9816	{
9817		if(asLowerCaseString(it->first) != name)
9818			continue;
9819
9820		bool ret = luaL_dostring(L, it->second.second.c_str());
9821		if(ret)
9822			error(NULL, popString(L));
9823
9824		lua_pushboolean(L, !ret);
9825		break;
9826	}
9827
9828	return 1;
9829}
9830
9831int32_t LuaScriptInterface::luaL_dodirectory(lua_State* L)
9832{
9833	std::string dir = popString(L);
9834	if(!getEnv()->getInterface()->loadDirectory(dir, NULL))
9835	{
9836		errorEx("Failed to load directory " + dir + ".");
9837		lua_pushboolean(L, false);
9838	}
9839	else
9840		lua_pushboolean(L, true);
9841
9842	return 1;
9843}
9844
9845#define EXPOSE_LOG(Name, Stream)\
9846	int32_t LuaScriptInterface::luaStd##Name(lua_State* L)\
9847	{\
9848		StringVec data;\
9849		for(int32_t i = 0, params = lua_gettop(L); i < params; ++i)\
9850			data.push_back(popString(L));\
9851\
9852		for(StringVec::reverse_iterator it = data.rbegin(); it != data.rend(); ++it)\
9853			Stream << (*it) << std::endl;\
9854\
9855		lua_pushnumber(L, data.size());\
9856		return 1;\
9857	}
9858
9859EXPOSE_LOG(Cout, std::cout)
9860EXPOSE_LOG(Cerr, std::cerr)
9861EXPOSE_LOG(Clog, std::clog)
9862
9863#undef EXPOSE_LOG
9864
9865int32_t LuaScriptInterface::luaStdMD5(lua_State* L)
9866{
9867	//std.md5(string[, upperCase])
9868	bool upperCase = false;
9869	if(lua_gettop(L) > 1)
9870		upperCase = popNumber(L);
9871
9872	lua_pushstring(L, transformToMD5(popString(L), upperCase).c_str());
9873	return 1;
9874}
9875
9876int32_t LuaScriptInterface::luaStdSHA1(lua_State* L)
9877{
9878	//std.sha1(string[, upperCase])
9879	bool upperCase = false;
9880	if(lua_gettop(L) > 1)
9881		upperCase = popNumber(L);
9882
9883	lua_pushstring(L, transformToSHA1(popString(L), upperCase).c_str());
9884	return 1;
9885}
9886
9887int32_t LuaScriptInterface::luaDatabaseExecute(lua_State* L)
9888{
9889	//db.executeQuery(query)
9890	DBQuery query; //lock mutex
9891	lua_pushboolean(L, Database::getInstance()->executeQuery(popString(L)));
9892	return 1;
9893}
9894
9895int32_t LuaScriptInterface::luaDatabaseStoreQuery(lua_State* L)
9896{
9897	//db.storeQuery(query)
9898	ScriptEnviroment* env = getEnv();
9899
9900	DBQuery query; //lock mutex
9901	if(DBResult* res = Database::getInstance()->storeQuery(popString(L)))
9902		lua_pushnumber(L, env->addResult(res));
9903	else
9904		lua_pushboolean(L, false);
9905
9906	return 1;
9907}
9908
9909int32_t LuaScriptInterface::luaDatabaseEscapeString(lua_State* L)
9910{
9911	//db.escapeString(str)
9912	DBQuery query; //lock mutex
9913	lua_pushstring(L, Database::getInstance()->escapeString(popString(L)).c_str());
9914	return 1;
9915}
9916
9917int32_t LuaScriptInterface::luaDatabaseEscapeBlob(lua_State* L)
9918{
9919	//db.escapeBlob(s, length)
9920	uint32_t length = popNumber(L);
9921	DBQuery query; //lock mutex
9922
9923	lua_pushstring(L, Database::getInstance()->escapeBlob(popString(L).c_str(), length).c_str());
9924	return 1;
9925}
9926
9927int32_t LuaScriptInterface::luaDatabaseLastInsertId(lua_State* L)
9928{
9929	//db.lastInsertId()
9930	DBQuery query; //lock mutex
9931	lua_pushnumber(L, Database::getInstance()->getLastInsertId());
9932	return 1;
9933}
9934
9935int32_t LuaScriptInterface::luaDatabaseStringComparison(lua_State* L)
9936{
9937	//db.stringComparison()
9938	lua_pushstring(L, Database::getInstance()->getStringComparison().c_str());
9939	return 1;
9940}
9941
9942int32_t LuaScriptInterface::luaDatabaseUpdateLimiter(lua_State* L)
9943{
9944	//db.updateLimiter()
9945	lua_pushstring(L, Database::getInstance()->getUpdateLimiter().c_str());
9946	return 1;
9947}
9948
9949int32_t LuaScriptInterface::luaIsWalkablefloor(lua_State* L)
9950{
9951	//isWalkablefloor(pos)
9952	PositionEx pos;
9953	popPosition(L, pos);
9954	if(Tile* tile = g_game.getTile(pos))
9955	{
9956		if(tile->hasProperty(BLOCKSOLID) || tile->hasProperty(BLOCKPROJECTILE) || tile->floorChange())
9957		{
9958			lua_pushboolean(L, false);
9959			return 1;
9960		}
9961		
9962		lua_pushboolean(L, true);
9963	}
9964	else
9965		lua_pushboolean(L, false);
9966		
9967	return 1;
9968}
9969
9970#define CHECK_RESULT()\
9971	if(!res)\
9972	{\
9973		lua_pushboolean(L, false);\
9974		return 1;\
9975	}
9976
9977int32_t LuaScriptInterface::luaResultGetDataInt(lua_State* L)
9978{
9979	//result.getDataInt(res, s)
9980	const std::string& s = popString(L);
9981	ScriptEnviroment* env = getEnv();
9982
9983	DBResult* res = env->getResultByID(popNumber(L));
9984	CHECK_RESULT()
9985
9986	lua_pushnumber(L, res->getDataInt(s));
9987	return 1;
9988}
9989
9990int32_t LuaScriptInterface::luaResultGetDataLong(lua_State* L)
9991{
9992	//result.getDataLong(res, s)
9993	const std::string& s = popString(L);
9994	ScriptEnviroment* env = getEnv();
9995
9996	DBResult* res = env->getResultByID(popNumber(L));
9997	CHECK_RESULT()
9998
9999	lua_pushnumber(L, res->getDataLong(s));
10000	return 1;
10001}
10002
10003int32_t LuaScriptInterface::luaResultGetDataString(lua_State* L)
10004{
10005	//result.getDataString(res, s)
10006	const std::string& s = popString(L);
10007	ScriptEnviroment* env = getEnv();
10008
10009	DBResult* res = env->getResultByID(popNumber(L));
10010	CHECK_RESULT()
10011
10012	lua_pushstring(L, res->getDataString(s).c_str());
10013	return 1;
10014}
10015
10016int32_t LuaScriptInterface::luaResultGetDataStream(lua_State* L)
10017{
10018	//result.getDataStream(res, s)
10019	const std::string s = popString(L);
10020	ScriptEnviroment* env = getEnv();
10021
10022	DBResult* res = env->getResultByID(popNumber(L));
10023	CHECK_RESULT()
10024
10025	uint64_t length = 0;
10026	lua_pushstring(L, res->getDataStream(s, length));
10027
10028	lua_pushnumber(L, length);
10029	return 1;
10030}
10031
10032int32_t LuaScriptInterface::luaResultNext(lua_State* L)
10033{
10034	//result.next(res)
10035	ScriptEnviroment* env = getEnv();
10036
10037	DBResult* res = env->getResultByID(popNumber(L));
10038	CHECK_RESULT()
10039
10040	lua_pushboolean(L, res->next());
10041	return 1;
10042}
10043
10044int32_t LuaScriptInterface::luaResultFree(lua_State* L)
10045{
10046	//result.free(res)
10047	uint32_t rid = popNumber(L);
10048	ScriptEnviroment* env = getEnv();
10049
10050	DBResult* res = env->getResultByID(rid);
10051	CHECK_RESULT()
10052
10053	lua_pushboolean(L, env->removeResult(rid));
10054	return 1;
10055}
10056
10057#undef CHECK_RESULT
10058
10059int32_t LuaScriptInterface::luaBitNot(lua_State* L)
10060{
10061	int32_t number = (int32_t)popNumber(L);
10062	lua_pushnumber(L, ~number);
10063	return 1;
10064}
10065
10066int32_t LuaScriptInterface::luaBitUNot(lua_State* L)
10067{
10068	uint32_t number = (uint32_t)popNumber(L);
10069	lua_pushnumber(L, ~number);
10070	return 1;
10071}
10072
10073#define MULTI_OPERATOR(type, name, op)\
10074	int32_t LuaScriptInterface::luaBit##name(lua_State* L)\
10075	{\
10076		int32_t params = lua_gettop(L);\
10077		type value = (type)popNumber(L);\
10078		for(int32_t i = 2; i <= params; ++i)\
10079			value op popNumber(L);\
10080\
10081		lua_pushnumber(L, value);\
10082		return 1;\
10083	}
10084
10085MULTI_OPERATOR(int32_t, And, &=)
10086MULTI_OPERATOR(int32_t, Or, |=)
10087MULTI_OPERATOR(int32_t, Xor, ^=)
10088MULTI_OPERATOR(uint32_t, UAnd, &=)
10089MULTI_OPERATOR(uint32_t, UOr, |=)
10090MULTI_OPERATOR(uint32_t, UXor, ^=)
10091
10092#undef MULTI_OPERATOR
10093
10094#define SHIFT_OPERATOR(type, name, op)\
10095	int32_t LuaScriptInterface::luaBit##name(lua_State* L)\
10096	{\
10097		type v2 = (type)popNumber(L), v1 = (type)popNumber(L);\
10098		lua_pushnumber(L, (v1 op v2));\
10099		return 1;\
10100	}
10101
10102SHIFT_OPERATOR(int32_t, LeftShift, <<)
10103SHIFT_OPERATOR(int32_t, RightShift, >>)
10104SHIFT_OPERATOR(uint32_t, ULeftShift, <<)
10105SHIFT_OPERATOR(uint32_t, URightShift, >>)
10106
10107#undef SHIFT_OPERATOR