BymcyHaT

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	//doAddIpBanishment(...)
2233	lua_register(m_luaState, "doAddIpBanishment", LuaScriptInterface::luaDoAddIpBanishment);
2234
2235	//doAddPlayerBanishment(...)
2236	lua_register(m_luaState, "doAddPlayerBanishment", LuaScriptInterface::luaDoAddPlayerBanishment);
2237
2238	//doAddAccountBanishment(...)
2239	lua_register(m_luaState, "doAddAccountBanishment", LuaScriptInterface::luaDoAddAccountBanishment);
2240
2241	//doAddNotation(...)
2242	lua_register(m_luaState, "doAddNotation", LuaScriptInterface::luaDoAddNotation);
2243
2244	//doAddStatement(...)
2245	lua_register(m_luaState, "doAddStatement", LuaScriptInterface::luaDoAddStatement);
2246
2247	//doRemoveIpBanishment(ip[, mask])
2248	lua_register(m_luaState, "doRemoveIpBanishment", LuaScriptInterface::luaDoRemoveIpBanishment);
2249
2250	//doRemovePlayerBanishment(name/guid, type)
2251	lua_register(m_luaState, "doRemovePlayerBanishment", LuaScriptInterface::luaDoRemovePlayerBanishment);
2252
2253	//doRemoveAccountBanishment(accountId[, playerId])
2254	lua_register(m_luaState, "doRemoveAccountBanishment", LuaScriptInterface::luaDoRemoveAccountBanishment);
2255
2256	//doRemoveNotations(accountId[, playerId])
2257	lua_register(m_luaState, "doRemoveNotations", LuaScriptInterface::luaDoRemoveNotations);
2258
2259	//doRemoveStatements(name/guid[, channelId])
2260	lua_register(m_luaState, "doRemoveStatements", LuaScriptInterface::luaDoRemoveStatements);
2261
2262	//getNotationsCount(accountId[, playerId])
2263	lua_register(m_luaState, "getNotationsCount", LuaScriptInterface::luaGetNotationsCount);
2264
2265	//getStatementsCount(name/guid[, channelId])
2266	lua_register(m_luaState, "getStatementsCount", LuaScriptInterface::luaGetStatementsCount);
2267
2268	//getBanData(value[, type[, param]])
2269	lua_register(m_luaState, "getBanData", LuaScriptInterface::luaGetBanData);
2270
2271	//getBanReason(id)
2272	lua_register(m_luaState, "getBanReason", LuaScriptInterface::luaGetBanReason);
2273
2274	//getBanAction(id)
2275	lua_register(m_luaState, "getBanAction", LuaScriptInterface::luaGetBanAction);
2276
2277	//getBanList(type[, value[, param]])
2278	lua_register(m_luaState, "getBanList", LuaScriptInterface::luaGetBanList);
2279
2280	//getExperienceStage(level)
2281	lua_register(m_luaState, "getExperienceStage", LuaScriptInterface::luaGetExperienceStage);
2282
2283	//getDataDir()
2284	lua_register(m_luaState, "getDataDir", LuaScriptInterface::luaGetDataDir);
2285
2286	//getLogsDir()
2287	lua_register(m_luaState, "getLogsDir", LuaScriptInterface::luaGetLogsDir);
2288
2289	//getConfigFile()
2290	lua_register(m_luaState, "getConfigFile", LuaScriptInterface::luaGetConfigFile);
2291
2292	//getConfigValue(key)
2293	lua_register(m_luaState, "getConfigValue", LuaScriptInterface::luaGetConfigValue);
2294
2295	//getModList()
2296	lua_register(m_luaState, "getModList", LuaScriptInterface::luaGetModList);
2297
2298	//getHighscoreString(skillId)
2299	lua_register(m_luaState, "getHighscoreString", LuaScriptInterface::luaGetHighscoreString);
2300
2301	//getWaypointPosition(name)
2302	lua_register(m_luaState, "getWaypointPosition", LuaScriptInterface::luaGetWaypointPosition);
2303
2304	//doWaypointAddTemporial(name, pos)
2305	lua_register(m_luaState, "doWaypointAddTemporial", LuaScriptInterface::luaDoWaypointAddTemporial);
2306
2307	//getGameState()
2308	lua_register(m_luaState, "getGameState", LuaScriptInterface::luaGetGameState);
2309
2310	//doSetGameState(id)
2311	lua_register(m_luaState, "doSetGameState", LuaScriptInterface::luaDoSetGameState);
2312
2313	//doExecuteRaid(name)
2314	lua_register(m_luaState, "doExecuteRaid", LuaScriptInterface::luaDoExecuteRaid);
2315
2316	//doCreatureExecuteTalkAction(cid, text[, ignoreAccess[, channelId]])
2317	lua_register(m_luaState, "doCreatureExecuteTalkAction", LuaScriptInterface::luaDoCreatureExecuteTalkAction);
2318
2319	//doReloadInfo(id[, cid])
2320	lua_register(m_luaState, "doReloadInfo", LuaScriptInterface::luaDoReloadInfo);
2321
2322	//doSaveServer()
2323	lua_register(m_luaState, "doSaveServer", LuaScriptInterface::luaDoSaveServer);
2324
2325	//doCleanHouse(houseId)
2326	lua_register(m_luaState, "doCleanHouse", LuaScriptInterface::luaDoCleanHouse);
2327
2328	//doCleanMap()
2329	lua_register(m_luaState, "doCleanMap", LuaScriptInterface::luaDoCleanMap);
2330
2331	//doRefreshMap()
2332	lua_register(m_luaState, "doRefreshMap", LuaScriptInterface::luaDoRefreshMap);
2333
2334	//doUpdateHouseAuctions()
2335	lua_register(m_luaState, "doUpdateHouseAuctions", LuaScriptInterface::luaDoUpdateHouseAuctions);
2336
2337	//loadmodlib(lib)
2338	lua_register(m_luaState, "loadmodlib", LuaScriptInterface::luaL_loadmodlib);
2339
2340	//domodlib(lib)
2341	lua_register(m_luaState, "domodlib", LuaScriptInterface::luaL_domodlib);
2342
2343	//dodirectory(dir)
2344	lua_register(m_luaState, "dodirectory", LuaScriptInterface::luaL_dodirectory);
2345
2346	//db table
2347	luaL_register(m_luaState, "db", LuaScriptInterface::luaDatabaseTable);
2348
2349	//result table
2350	luaL_register(m_luaState, "result", LuaScriptInterface::luaResultTable);
2351
2352	//bit table
2353	luaL_register(m_luaState, "bit", LuaScriptInterface::luaBitTable);
2354
2355	//std table
2356	luaL_register(m_luaState, "std", LuaScriptInterface::luaStdTable);
2357}
2358
2359const luaL_Reg LuaScriptInterface::luaDatabaseTable[] =
2360{
2361	//db.executeQuery(query)
2362	{"executeQuery", LuaScriptInterface::luaDatabaseExecute},
2363
2364	//db.storeQuery(query)
2365	{"storeQuery", LuaScriptInterface::luaDatabaseStoreQuery},
2366
2367	//db.escapeString(str)
2368	{"escapeString", LuaScriptInterface::luaDatabaseEscapeString},
2369
2370	//db.escapeBlob(s, length)
2371	{"escapeBlob", LuaScriptInterface::luaDatabaseEscapeBlob},
2372
2373	//db.lastInsertId()
2374	{"lastInsertId", LuaScriptInterface::luaDatabaseLastInsertId},
2375
2376	//db.stringComparison()
2377	{"stringComparison", LuaScriptInterface::luaDatabaseStringComparison},
2378
2379	//db.updateLimiter()
2380	{"updateLimiter", LuaScriptInterface::luaDatabaseUpdateLimiter},
2381
2382	{NULL,NULL}
2383};
2384
2385const luaL_Reg LuaScriptInterface::luaResultTable[] =
2386{
2387	//result.getDataInt(resId, s)
2388	{"getDataInt", LuaScriptInterface::luaResultGetDataInt},
2389
2390	//result.getDataLong(resId, s)
2391	{"getDataLong", LuaScriptInterface::luaResultGetDataLong},
2392
2393	//result.getDataString(resId, s)
2394	{"getDataString", LuaScriptInterface::luaResultGetDataString},
2395
2396	//result.getDataStream(resId, s, length)
2397	{"getDataStream", LuaScriptInterface::luaResultGetDataStream},
2398
2399	//result.next(resId)
2400	{"next", LuaScriptInterface::luaResultNext},
2401
2402	//result.free(resId)
2403	{"free", LuaScriptInterface::luaResultFree},
2404
2405	{NULL,NULL}
2406};
2407
2408const luaL_Reg LuaScriptInterface::luaBitTable[] =
2409{
2410	//{"cast", LuaScriptInterface::luaBitCast},
2411	{"bnot", LuaScriptInterface::luaBitNot},
2412	{"band", LuaScriptInterface::luaBitAnd},
2413	{"bor", LuaScriptInterface::luaBitOr},
2414	{"bxor", LuaScriptInterface::luaBitXor},
2415	{"lshift", LuaScriptInterface::luaBitLeftShift},
2416	{"rshift", LuaScriptInterface::luaBitRightShift},
2417	//{"arshift", LuaScriptInterface::luaBitArithmeticalRightShift},
2418
2419	//{"ucast", LuaScriptInterface::luaBitUCast},
2420	{"ubnot", LuaScriptInterface::luaBitUNot},
2421	{"uband", LuaScriptInterface::luaBitUAnd},
2422	{"ubor", LuaScriptInterface::luaBitUOr},
2423	{"ubxor", LuaScriptInterface::luaBitUXor},
2424	{"ulshift", LuaScriptInterface::luaBitULeftShift},
2425	{"urshift", LuaScriptInterface::luaBitURightShift},
2426	//{"uarshift", LuaScriptInterface::luaBitUArithmeticalRightShift},
2427
2428	{NULL,NULL}
2429};
2430
2431const luaL_Reg LuaScriptInterface::luaStdTable[] =
2432{
2433	{"cout", LuaScriptInterface::luaStdCout},
2434	{"cerr", LuaScriptInterface::luaStdCerr},
2435	{"clog", LuaScriptInterface::luaStdClog},
2436
2437	{"md5", LuaScriptInterface::luaStdMD5},
2438	{"sha1", LuaScriptInterface::luaStdSHA1},
2439
2440	{NULL, NULL}
2441};
2442
2443int32_t LuaScriptInterface::internalGetPlayerInfo(lua_State* L, PlayerInfo_t info)
2444{
2445	ScriptEnviroment* env = getEnv();
2446	const Player* player = env->getPlayerByUID(popNumber(L));
2447	if(!player)
2448	{
2449		std::stringstream s;
2450		s << getError(LUA_ERROR_PLAYER_NOT_FOUND) << " when requesting player info #" << info;
2451		errorEx(s.str());
2452
2453		lua_pushboolean(L, false);
2454		return 1;
2455	}
2456
2457	int64_t value = 0;
2458	Position pos;
2459	switch(info)
2460	{
2461		case PlayerInfoNameDescription:
2462			lua_pushstring(L, player->getNameDescription().c_str());
2463			return 1;
2464		case PlayerInfoSpecialDescription:
2465			lua_pushstring(L, player->getSpecialDescription().c_str());
2466			return 1;
2467		case PlayerInfoAccess:
2468			value = player->getAccess();
2469			break;
2470		case PlayerInfoGhostAccess:
2471			value = player->getGhostAccess();
2472			break;
2473		case PlayerInfoLevel:
2474			value = player->getLevel();
2475			break;
2476		case PlayerInfoExperience:
2477			value = player->getExperience();
2478			break;
2479		case PlayerInfoManaSpent:
2480			value = player->getSpentMana();
2481			break;
2482		case PlayerInfoTown:
2483			value = player->getTown();
2484			break;
2485		case PlayerInfoPromotionLevel:
2486			value = player->getPromotionLevel();
2487			break;
2488		case PlayerInfoGUID:
2489			value = player->getGUID();
2490			break;
2491		case PlayerInfoAccountId:
2492			value = player->getAccount();
2493			break;
2494		case PlayerInfoAccount:
2495			lua_pushstring(L, player->getAccountName().c_str());
2496			return 1;
2497		case PlayerInfoPremiumDays:
2498			value = player->getPremiumDays();
2499			break;
2500		case PlayerInfoFood:
2501		{
2502			if(Condition* condition = player->getCondition(CONDITION_REGENERATION, CONDITIONID_DEFAULT))
2503				value = condition->getTicks() / 1000;
2504
2505			break;
2506		}
2507		case PlayerInfoVocation:
2508			value = player->getVocationId();
2509			break;
2510		case PlayerInfoSoul:
2511			value = player->getSoul();
2512			break;
2513		case PlayerInfoFreeCap:
2514			value = (int64_t)player->getFreeCapacity();
2515			break;
2516		case PlayerInfoGuildId:
2517			value = player->getGuildId();
2518			break;
2519		case PlayerInfoGuildName:
2520			lua_pushstring(L, player->getGuildName().c_str());
2521			return 1;
2522		case PlayerInfoGuildRankId:
2523			value = player->getRankId();
2524			break;
2525		case PlayerInfoGuildRank:
2526			lua_pushstring(L, player->getRankName().c_str());
2527			return 1;
2528		case PlayerInfoGuildLevel:
2529			value = player->getGuildLevel();
2530			break;
2531		case PlayerInfoGuildNick:
2532			lua_pushstring(L, player->getGuildNick().c_str());
2533			return 1;
2534		case PlayerInfoGroupId:
2535			value = player->getGroupId();
2536			break;
2537		case PlayerInfoBalance:
2538			value = (g_config.getBool(ConfigManager::BANK_SYSTEM) ? player->balance : 0);
2539			break;
2540		case PlayerInfoStamina:
2541			value = player->getStaminaMinutes();
2542			break;
2543		case PlayerInfoLossSkill:
2544			lua_pushboolean(L, player->getLossSkill());
2545			return 1;
2546		case PlayerInfoMarriage:
2547			value = player->marriage;
2548			break;
2549		case PlayerInfoPzLock:
2550			lua_pushboolean(L, player->isPzLocked());
2551			return 1;
2552		case PlayerInfoSaving:
2553			lua_pushboolean(L, player->isSaving());
2554			return 1;
2555		case PlayerInfoIp:
2556			value = player->getIP();
2557			break;
2558		case PlayerInfoSkullEnd:
2559			value = player->getSkullEnd();
2560			break;
2561		case PlayerInfoOutfitWindow:
2562			player->sendOutfitWindow();
2563			lua_pushboolean(L, true);
2564			return 1;
2565		case PlayerInfoIdleTime:
2566			value = player->getIdleTime();
2567			break;
2568		case PlayerInfoClient:
2569			lua_pushboolean(L, player->hasClient());
2570			return 1;
2571		case PlayerInfoLastLoad:
2572			value = player->getLastLoad();
2573			break;
2574		case PlayerInfoLastLogin:
2575			value = player->getLastLogin();
2576			break;
2577		case PlayerInfoAccountManager:
2578			value = player->accountManager;
2579			break;
2580		default:
2581			errorEx("Unknown player info #" + info);
2582			value = 0;
2583			break;
2584	}
2585
2586	lua_pushnumber(L, value);
2587	return 1;
2588}
2589
2590//getPlayer[Info](uid)
2591int32_t LuaScriptInterface::luaGetPlayerNameDescription(lua_State* L)
2592{
2593	return internalGetPlayerInfo(L, PlayerInfoNameDescription);
2594}
2595
2596int32_t LuaScriptInterface::luaGetPlayerSpecialDescription(lua_State* L)
2597{
2598	return internalGetPlayerInfo(L, PlayerInfoSpecialDescription);
2599}
2600
2601int32_t LuaScriptInterface::luaGetPlayerFood(lua_State* L)
2602{
2603	return internalGetPlayerInfo(L, PlayerInfoFood);
2604}
2605
2606int32_t LuaScriptInterface::luaGetPlayerAccess(lua_State* L)
2607{
2608	return internalGetPlayerInfo(L, PlayerInfoAccess);
2609}
2610
2611int32_t LuaScriptInterface::luaGetPlayerGhostAccess(lua_State* L)
2612{
2613	return internalGetPlayerInfo(L, PlayerInfoGhostAccess);
2614}
2615
2616int32_t LuaScriptInterface::luaGetPlayerLevel(lua_State* L)
2617{
2618	return internalGetPlayerInfo(L, PlayerInfoLevel);
2619}
2620
2621int32_t LuaScriptInterface::luaGetPlayerExperience(lua_State* L)
2622{
2623	return internalGetPlayerInfo(L, PlayerInfoExperience);
2624}
2625
2626int32_t LuaScriptInterface::luaGetPlayerSpentMana(lua_State* L)
2627{
2628	return internalGetPlayerInfo(L, PlayerInfoManaSpent);
2629}
2630
2631int32_t LuaScriptInterface::luaGetPlayerVocation(lua_State* L)
2632{
2633	return internalGetPlayerInfo(L, PlayerInfoVocation);
2634}
2635
2636int32_t LuaScriptInterface::luaGetPlayerSoul(lua_State* L)
2637{
2638	return internalGetPlayerInfo(L, PlayerInfoSoul);
2639}
2640
2641int32_t LuaScriptInterface::luaGetPlayerFreeCap(lua_State* L)
2642{
2643	return internalGetPlayerInfo(L, PlayerInfoFreeCap);
2644}
2645
2646int32_t LuaScriptInterface::luaGetPlayerGuildId(lua_State* L)
2647{
2648	return internalGetPlayerInfo(L, PlayerInfoGuildId);
2649}
2650
2651int32_t LuaScriptInterface::luaGetPlayerGuildName(lua_State* L)
2652{
2653	return internalGetPlayerInfo(L, PlayerInfoGuildName);
2654}
2655
2656int32_t LuaScriptInterface::luaGetPlayerGuildRankId(lua_State* L)
2657{
2658	return internalGetPlayerInfo(L, PlayerInfoGuildRankId);
2659}
2660
2661int32_t LuaScriptInterface::luaGetPlayerGuildRank(lua_State* L)
2662{
2663	return internalGetPlayerInfo(L, PlayerInfoGuildRank);
2664}
2665
2666int32_t LuaScriptInterface::luaGetPlayerGuildLevel(lua_State* L)
2667{
2668	return internalGetPlayerInfo(L, PlayerInfoGuildLevel);
2669}
2670
2671int32_t LuaScriptInterface::luaGetPlayerGuildNick(lua_State* L)
2672{
2673	return internalGetPlayerInfo(L, PlayerInfoGuildNick);
2674}
2675
2676int32_t LuaScriptInterface::luaGetPlayerTown(lua_State* L)
2677{
2678	return internalGetPlayerInfo(L, PlayerInfoTown);
2679}
2680
2681int32_t LuaScriptInterface::luaGetPlayerPromotionLevel(lua_State* L)
2682{
2683	return internalGetPlayerInfo(L, PlayerInfoPromotionLevel);
2684}
2685
2686int32_t LuaScriptInterface::luaGetPlayerGroupId(lua_State* L)
2687{
2688	return internalGetPlayerInfo(L, PlayerInfoGroupId);
2689}
2690
2691int32_t LuaScriptInterface::luaGetPlayerGUID(lua_State* L)
2692{
2693	return internalGetPlayerInfo(L, PlayerInfoGUID);
2694}
2695
2696int32_t LuaScriptInterface::luaGetPlayerAccountId(lua_State* L)
2697{
2698	return internalGetPlayerInfo(L, PlayerInfoAccountId);
2699}
2700
2701int32_t LuaScriptInterface::luaGetPlayerAccount(lua_State* L)
2702{
2703	return internalGetPlayerInfo(L, PlayerInfoAccount);
2704}
2705
2706int32_t LuaScriptInterface::luaGetPlayerPremiumDays(lua_State* L)
2707{
2708	return internalGetPlayerInfo(L, PlayerInfoPremiumDays);
2709}
2710
2711int32_t LuaScriptInterface::luaGetPlayerBalance(lua_State* L)
2712{
2713	return internalGetPlayerInfo(L, PlayerInfoBalance);
2714}
2715
2716int32_t LuaScriptInterface::luaGetPlayerStamina(lua_State* L)
2717{
2718	return internalGetPlayerInfo(L, PlayerInfoStamina);
2719}
2720
2721int32_t LuaScriptInterface::luaGetPlayerLossSkill(lua_State* L)
2722{
2723	return internalGetPlayerInfo(L, PlayerInfoLossSkill);
2724}
2725
2726int32_t LuaScriptInterface::luaGetPlayerPartner(lua_State* L)
2727{
2728	return internalGetPlayerInfo(L, PlayerInfoMarriage);
2729}
2730
2731int32_t LuaScriptInterface::luaIsPlayerPzLocked(lua_State* L)
2732{
2733	return internalGetPlayerInfo(L, PlayerInfoPzLock);
2734}
2735
2736int32_t LuaScriptInterface::luaIsPlayerSaving(lua_State* L)
2737{
2738	return internalGetPlayerInfo(L, PlayerInfoSaving);
2739}
2740
2741int32_t LuaScriptInterface::luaGetPlayerIp(lua_State* L)
2742{
2743	return internalGetPlayerInfo(L, PlayerInfoIp);
2744}
2745
2746int32_t LuaScriptInterface::luaGetPlayerSkullEnd(lua_State* L)
2747{
2748	return internalGetPlayerInfo(L, PlayerInfoSkullEnd);
2749}
2750
2751int32_t LuaScriptInterface::luaDoPlayerSendOutfitWindow(lua_State* L)
2752{
2753	return internalGetPlayerInfo(L, PlayerInfoOutfitWindow);
2754}
2755
2756int32_t LuaScriptInterface::luaGetPlayerIdleTime(lua_State* L)
2757{
2758	return internalGetPlayerInfo(L, PlayerInfoIdleTime);
2759}
2760
2761int32_t LuaScriptInterface::luaHasPlayerClient(lua_State* L)
2762{
2763	return internalGetPlayerInfo(L, PlayerInfoClient);
2764}
2765
2766int32_t LuaScriptInterface::luaGetPlayerLastLoad(lua_State* L)
2767{
2768	return internalGetPlayerInfo(L, PlayerInfoLastLoad);
2769}
2770
2771int32_t LuaScriptInterface::luaGetPlayerLastLogin(lua_State* L)
2772{
2773	return internalGetPlayerInfo(L, PlayerInfoLastLogin);
2774}
2775
2776int32_t LuaScriptInterface::luaGetPlayerAccountManager(lua_State* L)
2777{
2778	return internalGetPlayerInfo(L, PlayerInfoAccountManager);
2779}
2780//
2781
2782int32_t LuaScriptInterface::luaGetPlayerSex(lua_State* L)
2783{
2784	//getPlayerSex(cid[, full = false])
2785	bool full = false;
2786	if(lua_gettop(L) > 1)
2787		full = popNumber(L);
2788
2789	ScriptEnviroment* env = getEnv();
2790	Player* player = env->getPlayerByUID((uint32_t)popNumber(L));
2791	if(!player)
2792	{
2793		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2794		lua_pushboolean(L, false);
2795	}
2796	else
2797		lua_pushnumber(L, player->getSex(full));
2798
2799	return 1;
2800}
2801
2802int32_t LuaScriptInterface::luaDoPlayerSetNameDescription(lua_State* L)
2803{
2804	//doPlayerSetNameDescription(cid, description)
2805	std::string description = popString(L);
2806
2807	ScriptEnviroment* env = getEnv();
2808	if(Player* player = env->getPlayerByUID(popNumber(L)))
2809	{
2810		player->nameDescription += description;
2811		lua_pushboolean(L, true);
2812	}
2813	else
2814	{
2815		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2816		lua_pushboolean(L, false);
2817	}
2818	return 1;
2819}
2820
2821int32_t LuaScriptInterface::luaDoPlayerSetSpecialDescription(lua_State* L)
2822{
2823	//doPlayerSetSpecialDescription(cid, description)
2824	std::string description = popString(L);
2825
2826	ScriptEnviroment* env = getEnv();
2827	if(Player* player = env->getPlayerByUID(popNumber(L)))
2828	{
2829		player->setSpecialDescription(description);
2830		lua_pushboolean(L, true);
2831	}
2832	else
2833	{
2834		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2835		lua_pushboolean(L, false);
2836	}
2837	return 1;
2838}
2839
2840int32_t LuaScriptInterface::luaGetPlayerMagLevel(lua_State* L)
2841{
2842	//getPlayerMagLevel(cid[, ignoreBuffs = false])
2843	bool ignoreBuffs = false;
2844	if(lua_gettop(L) > 1)
2845		ignoreBuffs = popNumber(L);
2846
2847	ScriptEnviroment* env = getEnv();
2848	if(const Player* player = env->getPlayerByUID(popNumber(L)))
2849		lua_pushnumber(L, (ignoreBuffs ? player->magLevel : player->getMagicLevel()));
2850	else
2851	{
2852		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2853		lua_pushboolean(L, false);
2854	}
2855
2856	return 1;
2857}
2858
2859int32_t LuaScriptInterface::luaGetPlayerRequiredMana(lua_State* L)
2860{
2861	//getPlayerRequiredMana(cid, magicLevel)
2862	uint32_t magLevel = popNumber(L);
2863
2864	ScriptEnviroment* env = getEnv();
2865	if(Player* player = env->getPlayerByUID(popNumber(L)))
2866		lua_pushnumber(L, player->vocation->getReqMana(magLevel));
2867	else
2868	{
2869		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2870		lua_pushboolean(L, false);
2871	}
2872
2873	return 1;
2874}
2875
2876int32_t LuaScriptInterface::luaGetPlayerRequiredSkillTries(lua_State* L)
2877{
2878	//getPlayerRequiredSkillTries(cid, skillId, skillLevel)
2879	int32_t sLevel = popNumber(L), sId = popNumber(L);
2880
2881	ScriptEnviroment* env = getEnv();
2882	if(Player* player = env->getPlayerByUID(popNumber(L)))
2883		lua_pushnumber(L, player->vocation->getReqSkillTries(sId, sLevel));
2884	else
2885	{
2886		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2887		lua_pushboolean(L, false);
2888	}
2889
2890	return 1;
2891}
2892
2893int32_t LuaScriptInterface::luaGetPlayerFlagValue(lua_State* L)
2894{
2895	//getPlayerFlagValue(cid, flag)
2896	uint32_t index = popNumber(L);
2897
2898	ScriptEnviroment* env = getEnv();
2899	if(Player* player = env->getPlayerByUID(popNumber(L)))
2900	{
2901		if(index < PlayerFlag_LastFlag)
2902			lua_pushboolean(L, player->hasFlag((PlayerFlags)index));
2903		else
2904		{
2905			std::stringstream ss;
2906			ss << index;
2907			errorEx("No valid flag index - " + ss.str());
2908			lua_pushboolean(L, false);
2909		}
2910	}
2911	else
2912	{
2913		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2914		lua_pushboolean(L, false);
2915	}
2916
2917	return 1;
2918}
2919
2920int32_t LuaScriptInterface::luaGetPlayerCustomFlagValue(lua_State* L)
2921{
2922	//getPlayerCustomFlagValue(cid, flag)
2923	uint32_t index = popNumber(L);
2924
2925	ScriptEnviroment* env = getEnv();
2926	if(Player* player = env->getPlayerByUID(popNumber(L)))
2927	{
2928		if(index < PlayerCustomFlag_LastFlag)
2929			lua_pushboolean(L, player->hasCustomFlag((PlayerCustomFlags)index));
2930		else
2931		{
2932			std::stringstream ss;
2933			ss << index;
2934			errorEx("No valid flag index - " + ss.str());
2935			lua_pushboolean(L, false);
2936		}
2937	}
2938	else
2939	{
2940		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2941		lua_pushboolean(L, false);
2942	}
2943
2944	return 1;
2945}
2946
2947int32_t LuaScriptInterface::luaDoPlayerLearnInstantSpell(lua_State* L)
2948{
2949	//doPlayerLearnInstantSpell(cid, name)
2950	std::string spellName = popString(L);
2951
2952	ScriptEnviroment* env = getEnv();
2953	Player* player = env->getPlayerByUID(popNumber(L));
2954	if(!player)
2955	{
2956		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2957		lua_pushboolean(L, false);
2958		return 1;
2959	}
2960
2961	InstantSpell* spell = g_spells->getInstantSpellByName(spellName);
2962	if(!spell)
2963	{
2964		lua_pushboolean(L, false);
2965		return 1;
2966	}
2967
2968	player->learnInstantSpell(spell->getName());
2969	lua_pushboolean(L, true);
2970	return 1;
2971}
2972
2973int32_t LuaScriptInterface::luaDoPlayerUnlearnInstantSpell(lua_State* L)
2974{
2975	//doPlayerUnlearnInstantSpell(cid, name)
2976	std::string spellName = popString(L);
2977
2978	ScriptEnviroment* env = getEnv();
2979	Player* player = env->getPlayerByUID(popNumber(L));
2980	if(!player)
2981	{
2982		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
2983		lua_pushboolean(L, false);
2984		return 1;
2985	}
2986
2987	InstantSpell* spell = g_spells->getInstantSpellByName(spellName);
2988	if(!spell)
2989	{
2990		lua_pushboolean(L, false);
2991		return 1;
2992	}
2993
2994	player->unlearnInstantSpell(spell->getName());
2995	lua_pushboolean(L, true);
2996	return 1;
2997}
2998
2999int32_t LuaScriptInterface::luaGetPlayerLearnedInstantSpell(lua_State* L)
3000{
3001	//getPlayerLearnedInstantSpell(cid, name)
3002	std::string spellName = popString(L);
3003
3004	ScriptEnviroment* env = getEnv();
3005	Player* player = env->getPlayerByUID(popNumber(L));
3006	if(!player)
3007	{
3008		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3009		lua_pushboolean(L, false);
3010		return 1;
3011	}
3012
3013	InstantSpell* spell = g_spells->getInstantSpellByName(spellName);
3014	if(!spell)
3015	{
3016		lua_pushboolean(L, false);
3017		return 1;
3018	}
3019
3020	lua_pushboolean(L, player->hasLearnedInstantSpell(spellName));
3021	return 1;
3022}
3023
3024int32_t LuaScriptInterface::luaGetPlayerInstantSpellCount(lua_State* L)
3025{
3026	//getPlayerInstantSpellCount(cid)
3027	ScriptEnviroment* env = getEnv();
3028	if(Player* player = env->getPlayerByUID(popNumber(L)))
3029		lua_pushnumber(L, g_spells->getInstantSpellCount(player));
3030	else
3031	{
3032		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3033		lua_pushboolean(L, false);
3034	}
3035	return 1;
3036}
3037
3038int32_t LuaScriptInterface::luaGetPlayerInstantSpellInfo(lua_State* L)
3039{
3040	//getPlayerInstantSpellInfo(cid, index)
3041	uint32_t index = popNumber(L);
3042
3043	ScriptEnviroment* env = getEnv();
3044	Player* player = env->getPlayerByUID(popNumber(L));
3045	if(!player)
3046	{
3047		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3048		lua_pushboolean(L, false);
3049		return 1;
3050	}
3051
3052	InstantSpell* spell = g_spells->getInstantSpellByIndex(player, index);
3053	if(!spell)
3054	{
3055		errorEx(getError(LUA_ERROR_SPELL_NOT_FOUND));
3056		lua_pushboolean(L, false);
3057		return 1;
3058	}
3059
3060	lua_newtable(L);
3061	setField(L, "name", spell->getName());
3062	setField(L, "words", spell->getWords());
3063	setField(L, "level", spell->getLevel());
3064	setField(L, "mlevel", spell->getMagicLevel());
3065	setField(L, "mana", spell->getManaCost(player));
3066	setField(L, "manapercent", spell->getManaPercent());
3067	return 1;
3068}
3069
3070int32_t LuaScriptInterface::luaGetInstantSpellInfo(lua_State* L)
3071{
3072	//getInstantSpellInfo(name)
3073	InstantSpell* spell = g_spells->getInstantSpellByName(popString(L));
3074	if(!spell)
3075	{
3076		errorEx(getError(LUA_ERROR_SPELL_NOT_FOUND));
3077		lua_pushboolean(L, false);
3078		return 1;
3079	}
3080
3081	lua_newtable(L);
3082	setField(L, "name", spell->getName());
3083	setField(L, "words", spell->getWords());
3084	setField(L, "level", spell->getLevel());
3085	setField(L, "mlevel", spell->getMagicLevel());
3086	setField(L, "mana", spell->getManaCost(NULL));
3087	setField(L, "manapercent", spell->getManaPercent());
3088	return 1;
3089}
3090
3091int32_t LuaScriptInterface::luaDoRemoveItem(lua_State* L)
3092{
3093	//doRemoveItem(uid[, count])
3094	int32_t count = -1;
3095	if(lua_gettop(L) > 1)
3096		count = popNumber(L);
3097
3098	ScriptEnviroment* env = getEnv();
3099	Item* item = env->getItemByUID(popNumber(L));
3100	if(!item)
3101	{
3102		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
3103		lua_pushboolean(L, false);
3104		return 1;
3105	}
3106
3107	if(g_game.internalRemoveItem(NULL, item, count) != RET_NOERROR)
3108	{
3109		lua_pushboolean(L, false);
3110		return 1;
3111	}
3112
3113	lua_pushboolean(L, true);
3114	return 1;
3115}
3116
3117int32_t LuaScriptInterface::luaDoPlayerRemoveItem(lua_State* L)
3118{
3119	//doPlayerRemoveItem(cid, itemid, count[, subType])
3120	int32_t subType = -1;
3121	if(lua_gettop(L) > 3)
3122		subType = popNumber(L);
3123
3124	uint32_t count = popNumber(L);
3125	uint16_t itemId = (uint16_t)popNumber(L);
3126
3127	ScriptEnviroment* env = getEnv();
3128	if(Player* player = env->getPlayerByUID(popNumber(L)))
3129		lua_pushboolean(L, g_game.removeItemOfType(player, itemId, count, subType));
3130	else
3131	{
3132		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3133		lua_pushboolean(L, false);
3134	}
3135	return 1;
3136}
3137
3138int32_t LuaScriptInterface::luaDoFeedPlayer(lua_State* L)
3139{
3140	//doFeedPlayer(cid, food)
3141	int32_t food = (int32_t)popNumber(L);
3142
3143	ScriptEnviroment* env = getEnv();
3144	if(Player* player = env->getPlayerByUID(popNumber(L)))
3145	{
3146		player->addDefaultRegeneration((food * 1000) * 3);
3147		lua_pushboolean(L, true);
3148	}
3149	else
3150	{
3151		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3152		lua_pushboolean(L, false);
3153	}
3154	return 1;
3155}
3156
3157int32_t LuaScriptInterface::luaDoPlayerSendCancel(lua_State* L)
3158{
3159	//doPlayerSendCancel(cid, text)
3160	std::string text = popString(L);
3161	ScriptEnviroment* env = getEnv();
3162	if(const Player* player = env->getPlayerByUID(popNumber(L)))
3163	{
3164		player->sendCancel(text);
3165		lua_pushboolean(L, true);
3166	}
3167	else
3168	{
3169		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3170		lua_pushboolean(L, false);
3171	}
3172	return 1;
3173}
3174
3175int32_t LuaScriptInterface::luaDoSendDefaultCancel(lua_State* L)
3176{
3177	//doPlayerSendDefaultCancel(cid, ReturnValue)
3178	ReturnValue ret = (ReturnValue)popNumber(L);
3179	ScriptEnviroment* env = getEnv();
3180	if(const Player* player = env->getPlayerByUID(popNumber(L)))
3181	{
3182		player->sendCancelMessage(ret);
3183		lua_pushboolean(L, true);
3184	}
3185	else
3186	{
3187		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3188		lua_pushboolean(L, false);
3189	}
3190
3191	return 1;
3192}
3193
3194int32_t LuaScriptInterface::luaGetSearchString(lua_State* L)
3195{
3196	//getSearchString(fromPosition, toPosition[, fromIsCreature = false[, toIsCreature = false]])
3197	PositionEx toPos, fromPos;
3198	bool toIsCreature = false, fromIsCreature = false;
3199
3200	int32_t params = lua_gettop(L);
3201	if(params > 3)
3202		toIsCreature = popNumber(L);
3203
3204	if(params > 2)
3205		fromIsCreature = popNumber(L);
3206
3207	popPosition(L, toPos);
3208	popPosition(L, fromPos);
3209	if(!toPos.x || !toPos.y || !fromPos.x || !fromPos.y)
3210	{
3211		errorEx("wrong position(s) specified.");
3212		lua_pushboolean(L, false);
3213	}
3214	else
3215		lua_pushstring(L, g_game.getSearchString(fromPos, toPos, fromIsCreature, toIsCreature).c_str());
3216
3217	return 1;
3218}
3219
3220int32_t LuaScriptInterface::luaGetClosestFreeTile(lua_State* L)
3221{
3222	//getClosestFreeTile(cid, targetPos[, extended = false[, ignoreHouse = true]])
3223	uint32_t params = lua_gettop(L);
3224	bool ignoreHouse = true, extended = false;
3225	if(params > 3)
3226		ignoreHouse = popNumber(L);
3227
3228	if(params > 2)
3229		extended = popNumber(L);
3230
3231	PositionEx pos;
3232	popPosition(L, pos);
3233
3234	ScriptEnviroment* env = getEnv();
3235	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3236	{
3237		Position newPos = g_game.getClosestFreeTile(creature, pos, extended, ignoreHouse);
3238		if(newPos.x != 0)
3239			pushPosition(L, newPos, 0);
3240		else
3241			lua_pushboolean(L, false);
3242	}
3243	else
3244	{
3245		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3246		lua_pushboolean(L, false);
3247	}
3248	return 1;
3249}
3250
3251int32_t LuaScriptInterface::luaDoTeleportThing(lua_State* L)
3252{
3253	//doTeleportThing(cid, newpos[, pushmove = TRUE])
3254	bool pushMove = true;
3255	if(lua_gettop(L) > 2)
3256		pushMove = popNumber(L);
3257
3258	PositionEx pos;
3259	popPosition(L, pos);
3260
3261	ScriptEnviroment* env = getEnv();
3262	if(Thing* tmp = env->getThingByUID(popNumber(L)))
3263		lua_pushboolean(L, g_game.internalTeleport(tmp, pos, pushMove) == RET_NOERROR);
3264	else
3265	{
3266		errorEx(getError(LUA_ERROR_THING_NOT_FOUND));
3267		lua_pushboolean(L, false);
3268	}
3269	return 1;
3270}
3271
3272int32_t LuaScriptInterface::luaDoTransformItem(lua_State* L)
3273{
3274	//doTransformItem(uid, newId[, count/subType])
3275	int32_t count = -1;
3276	if(lua_gettop(L) > 2)
3277		count = popNumber(L);
3278
3279	uint16_t newId = popNumber(L);
3280	uint32_t uid = popNumber(L);
3281	ScriptEnviroment* env = getEnv();
3282
3283	Item* item = env->getItemByUID(uid);
3284	if(!item)
3285	{
3286		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
3287		lua_pushboolean(L, false);
3288		return 1;
3289	}
3290
3291	const ItemType& it = Item::items[newId];
3292	if(it.stackable && count > 100)
3293		count = 100;
3294
3295	Item* newItem = g_game.transformItem(item, newId, count);
3296	if(item->isRemoved())
3297		env->removeThing(uid);
3298
3299	if(newItem && newItem != item)
3300		env->insertThing(uid, newItem);
3301
3302	lua_pushboolean(L, true);
3303	return 1;
3304}
3305
3306int32_t LuaScriptInterface::luaDoCreatureSay(lua_State* L)
3307{
3308	//doCreatureSay(uid, text[, type = SPEAK_SAY[, ghost = false[, cid = 0[, pos]]]])
3309	uint32_t params = lua_gettop(L), cid = 0, uid = 0;
3310	PositionEx pos;
3311	if(params > 5)
3312		popPosition(L, pos);
3313
3314	if(params > 4)
3315		cid = popNumber(L);
3316
3317	bool ghost = false;
3318	if(params > 3)
3319		ghost = popNumber(L);
3320
3321	SpeakClasses type = SPEAK_SAY;
3322	if(params > 2)
3323		type = (SpeakClasses)popNumber(L);
3324
3325	std::string text = popString(L);
3326
3327	uid = popNumber(L);
3328	if(params > 5 && (!pos.x || !pos.y))
3329	{
3330		errorEx("Invalid position specified.");
3331		lua_pushboolean(L, false);
3332		return 1;
3333	}
3334
3335	ScriptEnviroment* env = getEnv();
3336	Creature* creature = env->getCreatureByUID(uid);
3337	if(!creature)
3338	{
3339		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3340		lua_pushboolean(L, false);
3341		return 1;
3342	}
3343
3344	SpectatorVec list;
3345	if(cid)
3346	{
3347		Creature* target = env->getCreatureByUID(cid);
3348		if(!target)
3349		{
3350			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3351			lua_pushboolean(L, false);
3352			return 1;
3353		}
3354
3355		list.push_back(target);
3356	}
3357
3358	if(params > 5)
3359		lua_pushboolean(L, g_game.internalCreatureSay(creature, type, text, ghost, &list, &pos));
3360	else
3361		lua_pushboolean(L, g_game.internalCreatureSay(creature, type, text, ghost, &list));
3362
3363	return 1;
3364}
3365
3366int32_t LuaScriptInterface::luaDoSendMagicEffect(lua_State* L)
3367{
3368	//doSendMagicEffect(pos, type[, creature[, player]])
3369	ScriptEnviroment* env = getEnv();
3370	SpectatorVec list;
3371	if(lua_gettop(L) > 3)
3372	{
3373		if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3374			list.push_back(creature);
3375	}
3376	
3377	Creature* creature = NULL;
3378	if(lua_gettop(L) > 2)
3379		creature = env->getCreatureByUID(popNumber(L));
3380
3381	uint32_t type = popNumber(L);
3382	PositionEx pos;
3383
3384	popPosition(L, pos);
3385	if(pos.x == 0xFFFF)
3386		pos = env->getRealPos();
3387
3388	if(creature && pos.x > 0xFF && pos.y > 0xFF)
3389	{
3390		pos.x = 0;
3391		pos.y = 0;
3392	}
3393
3394	if(!list.empty())
3395		g_game.addMagicEffect(list, pos, type, false, creature);
3396	else
3397		g_game.addMagicEffect(pos, type, false, creature);
3398
3399	lua_pushboolean(L, true);
3400	return 1;
3401}
3402
3403int32_t LuaScriptInterface::luaDoSendDistanceShoot(lua_State* L)
3404{
3405	//doSendDistanceShoot(fromPos, toPos, type[, player])
3406	ScriptEnviroment* env = getEnv();
3407	SpectatorVec list;
3408	if(lua_gettop(L) > 3)
3409	{
3410		if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3411			list.push_back(creature);
3412	}
3413
3414	uint32_t type = popNumber(L);
3415	PositionEx toPos, fromPos;
3416
3417	popPosition(L, toPos);
3418	popPosition(L, fromPos);
3419	if(fromPos.x == 0xFFFF)
3420		fromPos = env->getRealPos();
3421
3422	if(toPos.x == 0xFFFF)
3423		toPos = env->getRealPos();
3424
3425	if(!list.empty())
3426		g_game.addDistanceEffect(list, fromPos, toPos, type);
3427	else
3428		g_game.addDistanceEffect(fromPos, toPos, type);
3429
3430	lua_pushboolean(L, true);
3431	return 1;
3432}
3433
3434int32_t LuaScriptInterface::luaDoPlayerAddSkillTry(lua_State* L)
3435{
3436	//doPlayerAddSkillTry(uid, skillid, n[, useMultiplier])
3437	bool multiplier = true;
3438	if(lua_gettop(L) > 3)
3439		multiplier = popNumber(L);
3440
3441	uint32_t n = popNumber(L), skillid = popNumber(L);
3442	ScriptEnviroment* env = getEnv();
3443	if(Player* player = env->getPlayerByUID(popNumber(L)))
3444	{
3445		player->addSkillAdvance((skills_t)skillid, n, multiplier);
3446		lua_pushboolean(L, true);
3447	}
3448	else
3449	{
3450		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3451		lua_pushboolean(L, false);
3452	}
3453	return 1;
3454}
3455
3456int32_t LuaScriptInterface::luaGetCreatureSpeakType(lua_State* L)
3457{
3458	//getCreatureSpeakType(uid)
3459	ScriptEnviroment* env = getEnv();
3460	if(const Creature* creature = env->getCreatureByUID(popNumber(L)))
3461		lua_pushnumber(L, (SpeakClasses)creature->getSpeakType());
3462	else
3463	{
3464		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3465		lua_pushboolean(L, false);
3466	}
3467	return 1;
3468}
3469
3470int32_t LuaScriptInterface::luaDoCreatureSetSpeakType(lua_State* L)
3471{
3472	//doCreatureSetSpeakType(uid, type)
3473	SpeakClasses type = (SpeakClasses)popNumber(L);
3474
3475	ScriptEnviroment* env = getEnv();
3476	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3477	{
3478		if(type < SPEAK_CLASS_FIRST || type > SPEAK_CLASS_LAST)
3479		{
3480			errorEx("Invalid speak type!");
3481			lua_pushboolean(L, false);
3482			return 1;
3483		}
3484
3485		creature->setSpeakType(type);
3486		lua_pushboolean(L, true);
3487	}
3488	else
3489	{
3490		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3491		lua_pushboolean(L, false);
3492	}
3493	return 1;
3494}
3495
3496int32_t LuaScriptInterface::luaGetCreatureHideHealth(lua_State* L)
3497{
3498	//getCreatureHideHealth(cid)
3499	ScriptEnviroment* env = getEnv();
3500
3501	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3502		lua_pushboolean(L, creature->getHideHealth());
3503	else
3504	{
3505		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3506		lua_pushboolean(L, false);
3507	}
3508	return 1;
3509}
3510
3511int32_t LuaScriptInterface::luaDoCreatureSetHideHealth(lua_State* L)
3512{
3513	//doCreatureSetHideHealth(cid, hide)
3514	bool hide = popNumber(L);
3515
3516	ScriptEnviroment* env = getEnv();
3517	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3518	{
3519		creature->setHideHealth(hide);
3520		g_game.addCreatureHealth(creature);
3521		lua_pushboolean(L, true);
3522	}
3523	else
3524	{
3525		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3526		lua_pushboolean(L, false);
3527	}
3528	return 1;
3529}
3530
3531int32_t LuaScriptInterface::luaDoCreatureAddHealth(lua_State* L)
3532{
3533	//doCreatureAddHealth(uid, health[, hitEffect[, hitColor[, force]]])
3534	int32_t params = lua_gettop(L);
3535	bool force = false;
3536	if(params > 4)
3537		force = popNumber(L);
3538
3539	TextColor_t hitColor = TEXTCOLOR_UNKNOWN;
3540	if(params > 3)
3541		hitColor = (TextColor_t)popNumber(L);
3542
3543	MagicEffect_t hitEffect = MAGIC_EFFECT_UNKNOWN;
3544	if(params > 2)
3545		hitEffect = (MagicEffect_t)popNumber(L);
3546
3547	int32_t healthChange = popNumber(L);
3548	ScriptEnviroment* env = getEnv();
3549	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3550	{
3551		if(healthChange) //do not post with 0 value
3552			g_game.combatChangeHealth(healthChange < 1 ? COMBAT_UNDEFINEDDAMAGE : COMBAT_HEALING,
3553				NULL, creature, healthChange, hitEffect, hitColor, force);
3554
3555		lua_pushboolean(L, true);
3556	}
3557	else
3558	{
3559		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3560		lua_pushboolean(L, false);
3561	}
3562
3563	return 1;
3564}
3565
3566int32_t LuaScriptInterface::luaDoCreatureAddMana(lua_State* L)
3567{
3568	//doCreatureAddMana(uid, mana[, aggressive])
3569	bool aggressive = true;
3570	if(lua_gettop(L) > 2)
3571		aggressive = popNumber(L);
3572
3573	int32_t manaChange = popNumber(L);
3574	ScriptEnviroment* env = getEnv();
3575	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3576	{
3577		if(aggressive)
3578			g_game.combatChangeMana(NULL, creature, manaChange);
3579		else
3580			creature->changeMana(manaChange);
3581
3582		lua_pushboolean(L, true);
3583	}
3584	else
3585	{
3586		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3587		lua_pushboolean(L, false);
3588	}
3589	return 1;
3590}
3591
3592int32_t LuaScriptInterface::luaDoPlayerAddSpentMana(lua_State* L)
3593{
3594	//doPlayerAddSpentMana(cid, amount[, useMultiplier])
3595	bool multiplier = true;
3596	if(lua_gettop(L) > 2)
3597		multiplier = popNumber(L);
3598
3599	uint32_t amount = popNumber(L);
3600	ScriptEnviroment* env = getEnv();
3601	if(Player* player = env->getPlayerByUID(popNumber(L)))
3602	{
3603		player->addManaSpent(amount, multiplier);
3604		lua_pushboolean(L, true);
3605	}
3606	else
3607	{
3608		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3609		lua_pushboolean(L, false);
3610	}
3611	return 1;
3612}
3613
3614int32_t LuaScriptInterface::luaDoPlayerAddItem(lua_State* L)
3615{
3616	//doPlayerAddItem(cid, itemid[, count/subtype[, canDropOnMap]])
3617	//doPlayerAddItem(cid, itemid[, count[, canDropOnMap[, subtype]]])
3618	int32_t params = lua_gettop(L), subType = 1;
3619	if(params > 4)
3620		subType = popNumber(L);
3621
3622	bool canDropOnMap = true;
3623	if(params > 3)
3624		canDropOnMap = popNumber(L);
3625
3626	uint32_t count = 1;
3627	if(params > 2)
3628		count = popNumber(L);
3629
3630	uint32_t itemId = popNumber(L);
3631	ScriptEnviroment* env = getEnv();
3632
3633	Player* player = env->getPlayerByUID((uint32_t)popNumber(L));
3634	if(!player)
3635	{
3636		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3637		lua_pushboolean(L, false);
3638		return 1;
3639	}
3640
3641	const ItemType& it = Item::items[itemId];
3642	int32_t itemCount = 1;
3643	if(params > 4)
3644		itemCount = std::max((uint32_t)1, count);
3645	else if(it.hasSubType())
3646	{
3647		if(it.stackable)
3648			itemCount = (int32_t)std::ceil((float)count / 100);
3649
3650		subType = count;
3651	}
3652
3653	while(itemCount > 0)
3654	{
3655		int32_t stackCount = std::min(100, subType);
3656		Item* newItem = Item::CreateItem(itemId, stackCount);
3657		if(!newItem)
3658		{
3659			errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
3660			lua_pushboolean(L, false);
3661			return 1;
3662		}
3663
3664		if(it.stackable)
3665			subType -= stackCount;
3666
3667		ReturnValue ret = g_game.internalPlayerAddItem(NULL, player, newItem, canDropOnMap);
3668		if(ret != RET_NOERROR)
3669		{
3670			delete newItem;
3671			lua_pushboolean(L, false);
3672			return 1;
3673		}
3674
3675		--itemCount;
3676		if(itemCount)
3677			continue;
3678
3679		if(newItem->getParent())
3680			lua_pushnumber(L, env->addThing(newItem));
3681		else //stackable item stacked with existing object, newItem will be released
3682			lua_pushnil(L);
3683
3684		return 1;
3685	}
3686
3687	lua_pushnil(L);
3688	return 1;
3689}
3690
3691int32_t LuaScriptInterface::luaDoPlayerAddItemEx(lua_State* L)
3692{
3693	//doPlayerAddItemEx(cid, uid[, canDropOnMap = false])
3694	bool canDropOnMap = false;
3695	if(lua_gettop(L) > 2)
3696		canDropOnMap = popNumber(L);
3697
3698	uint32_t uid = (uint32_t)popNumber(L);
3699	ScriptEnviroment* env = getEnv();
3700
3701	Player* player = env->getPlayerByUID(popNumber(L));
3702	if(!player)
3703	{
3704		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3705		lua_pushboolean(L, false);
3706		return 1;
3707	}
3708
3709	Item* item = env->getItemByUID(uid);
3710	if(!item)
3711	{
3712		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
3713		lua_pushboolean(L, false);
3714		return 1;
3715	}
3716
3717	if(item->getParent() == VirtualCylinder::virtualCylinder)
3718		lua_pushnumber(L, g_game.internalPlayerAddItem(NULL, player, item, canDropOnMap));
3719	else
3720		lua_pushboolean(L, false);
3721
3722	return 1;
3723}
3724
3725int32_t LuaScriptInterface::luaDoTileAddItemEx(lua_State* L)
3726{
3727	//doTileAddItemEx(pos, uid)
3728	uint32_t uid = (uint32_t)popNumber(L);
3729	PositionEx pos;
3730	popPosition(L, pos);
3731
3732	ScriptEnviroment* env = getEnv();
3733	Tile* tile = g_game.getTile(pos.x, pos.y, pos.z);
3734	if(!tile)
3735	{
3736		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
3737		lua_pushboolean(L, false);
3738		return 1;
3739	}
3740
3741	Item* item = env->getItemByUID(uid);
3742	if(!item)
3743	{
3744		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
3745		lua_pushboolean(L, false);
3746		return 1;
3747	}
3748
3749	if(item->getParent() == VirtualCylinder::virtualCylinder)
3750		lua_pushnumber(L, g_game.internalAddItem(NULL, tile, item));
3751	else
3752		lua_pushboolean(L, false);
3753
3754	return 1;
3755}
3756
3757int32_t LuaScriptInterface::luaDoRelocate(lua_State* L)
3758{
3759	//doRelocate(pos, posTo[, creatures = true])
3760	//Moves all moveable objects from pos to posTo
3761
3762	bool creatures = true;
3763	if(lua_gettop(L) > 2)
3764		creatures = popNumber(L);
3765
3766	PositionEx toPos;
3767	popPosition(L, toPos);
3768
3769	PositionEx fromPos;
3770	popPosition(L, fromPos);
3771
3772	Tile* fromTile = g_game.getTile(fromPos.x, fromPos.y, fromPos.z);
3773	if(!fromTile)
3774	{
3775		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
3776		lua_pushboolean(L, false);
3777		return 1;
3778	}
3779
3780	Tile* toTile = g_game.getTile(toPos.x, toPos.y, toPos.z);
3781	if(!toTile)
3782	{
3783		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
3784		lua_pushboolean(L, false);
3785		return 1;
3786	}
3787
3788	if(fromTile != toTile)
3789	{
3790		for(int32_t i = fromTile->getThingCount() - 1; i >= 0; --i)
3791		{
3792			Thing* thing = fromTile->__getThing(i);
3793			if(thing)
3794			{
3795				if(Item* item = thing->getItem())
3796				{
3797					const ItemType& it = Item::items[item->getID()];
3798					if(!it.isGroundTile() && !it.alwaysOnTop && !it.isMagicField())
3799						g_game.internalTeleport(item, toPos, false, FLAG_IGNORENOTMOVEABLE);
3800				}
3801				else if(creatures)
3802				{
3803					Creature* creature = thing->getCreature();
3804					if(creature)
3805						g_game.internalTeleport(creature, toPos, true);
3806				}
3807			}
3808		}
3809	}
3810
3811	lua_pushboolean(L, true);
3812	return 1;
3813}
3814
3815int32_t LuaScriptInterface::luaDoCleanTile(lua_State* L)
3816{
3817	//doCleanTile(pos, forceMapLoaded = false)
3818	//Remove all items from tile, ignore creatures
3819	bool forceMapLoaded = false;
3820	if(lua_gettop(L) > 1)
3821		forceMapLoaded = popNumber(L);
3822
3823	PositionEx pos;
3824	popPosition(L, pos);
3825
3826	Tile* tile = g_game.getTile(pos);
3827	if(!tile)
3828	{
3829		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
3830		lua_pushboolean(L, false);
3831		return 1;
3832	}
3833
3834	for(int32_t i = tile->getThingCount() - 1; i >= 1; --i) //ignore ground
3835	{
3836		if(Thing* thing = tile->__getThing(i))
3837		{
3838			if(Item* item = thing->getItem())
3839			{
3840				if(!item->isLoadedFromMap() || forceMapLoaded)
3841					g_game.internalRemoveItem(NULL, item);
3842			}
3843		}
3844	}
3845
3846	lua_pushboolean(L, true);
3847	return 1;
3848}
3849
3850int32_t LuaScriptInterface::luaDoPlayerSendTextMessage(lua_State* L)
3851{
3852	//doPlayerSendTextMessage(cid, MessageClasses, message)
3853	std::string text = popString(L);
3854	uint32_t messageClass = popNumber(L);
3855
3856	ScriptEnviroment* env = getEnv();
3857	Player* player = env->getPlayerByUID(popNumber(L));
3858	if(!player)
3859	{
3860		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3861		lua_pushboolean(L, false);
3862		return 1;
3863	}
3864
3865	player->sendTextMessage((MessageClasses)messageClass, text);
3866	lua_pushboolean(L, true);
3867	return 1;
3868}
3869
3870int32_t LuaScriptInterface::luaDoPlayerSendChannelMessage(lua_State* L)
3871{
3872	//doPlayerSendChannelMessage(cid, author, message, SpeakClasses, channel)
3873	uint16_t channelId = popNumber(L);
3874	uint32_t speakClass = popNumber(L);
3875	std::string text = popString(L), name = popString(L);
3876
3877	ScriptEnviroment* env = getEnv();
3878	Player* player = env->getPlayerByUID(popNumber(L));
3879	if(!player)
3880	{
3881		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3882		lua_pushboolean(L, false);
3883		return 1;
3884	}
3885
3886	player->sendChannelMessage(name, text, (SpeakClasses)speakClass, channelId);
3887	lua_pushboolean(L, true);
3888	return 1;
3889}
3890
3891int32_t LuaScriptInterface::luaDoPlayerSendToChannel(lua_State* L)
3892{
3893	//doPlayerSendToChannel(cid, targetId, SpeakClasses, message, channel[, time])
3894	ScriptEnviroment* env = getEnv();
3895	uint32_t time = 0;
3896	if(lua_gettop(L) > 5)
3897		time = popNumber(L);
3898
3899	uint16_t channelId = popNumber(L);
3900	std::string text = popString(L);
3901	uint32_t speakClass = popNumber(L), targetId = popNumber(L);
3902
3903	Player* player = env->getPlayerByUID(popNumber(L));
3904	if(!player)
3905	{
3906		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3907		lua_pushboolean(L, false);
3908		return 1;
3909	}
3910
3911	Creature* creature = env->getCreatureByUID(targetId);
3912	if(!creature)
3913	{
3914		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
3915		lua_pushboolean(L, false);
3916		return 1;
3917	}
3918
3919	player->sendToChannel(creature, (SpeakClasses)speakClass, text, channelId, time);
3920	lua_pushboolean(L, true);
3921	return 1;
3922}
3923
3924int32_t LuaScriptInterface::luaDoSendAnimatedText(lua_State* L)
3925{
3926	//doSendAnimatedText(pos, text, color[, player])
3927	ScriptEnviroment* env = getEnv();
3928	SpectatorVec list;
3929	if(lua_gettop(L) > 3)
3930	{
3931		if(Creature* creature = env->getCreatureByUID(popNumber(L)))
3932			list.push_back(creature);
3933	}
3934
3935	uint32_t color = popNumber(L);
3936	std::string text = popString(L);
3937
3938	PositionEx pos;
3939	popPosition(L, pos);
3940	if(pos.x == 0xFFFF)
3941		pos = env->getRealPos();
3942
3943	if(!list.empty())
3944		g_game.addAnimatedText(list, pos, color, text);
3945	else
3946		g_game.addAnimatedText(pos, color, text);
3947
3948	lua_pushboolean(L, true);
3949	return 1;
3950}
3951
3952int32_t LuaScriptInterface::luaGetPlayerSkillLevel(lua_State* L)
3953{
3954	//getPlayerSkillLevel(cid, skillid)
3955	uint32_t skillId = popNumber(L);
3956
3957	ScriptEnviroment* env = getEnv();
3958	if(const Player* player = env->getPlayerByUID(popNumber(L)))
3959	{
3960		if(skillId <= SKILL_LAST)
3961			lua_pushnumber(L, player->skills[skillId][SKILL_LEVEL]);
3962		else
3963			lua_pushboolean(L, false);
3964	}
3965	else
3966	{
3967		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3968		lua_pushboolean(L, false);
3969	}
3970	return 1;
3971}
3972
3973int32_t LuaScriptInterface::luaGetPlayerSkillTries(lua_State* L)
3974{
3975	//getPlayerSkillTries(cid, skillid)
3976	uint32_t skillid = popNumber(L);
3977
3978	ScriptEnviroment* env = getEnv();
3979	if(const Player* player = env->getPlayerByUID(popNumber(L)))
3980	{
3981		if(skillid <= SKILL_LAST)
3982			lua_pushnumber(L, player->skills[skillid][SKILL_TRIES]);
3983		else
3984			lua_pushboolean(L, false);
3985	}
3986	else
3987	{
3988		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
3989		lua_pushboolean(L, false);
3990	}
3991	return 1;
3992}
3993
3994int32_t LuaScriptInterface::luaDoCreatureSetDropLoot(lua_State* L)
3995{
3996	//doCreatureSetDropLoot(cid, doDrop)
3997	bool doDrop = popNumber(L);
3998
3999	ScriptEnviroment* env = getEnv();
4000	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
4001	{
4002		creature->setDropLoot(doDrop ? LOOT_DROP_FULL : LOOT_DROP_NONE);
4003		lua_pushboolean(L, true);
4004	}
4005	else
4006	{
4007		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
4008		lua_pushboolean(L, false);
4009	}
4010
4011	return 1;
4012}
4013
4014int32_t LuaScriptInterface::luaGetPlayerLossPercent(lua_State* L)
4015{
4016	//getPlayerLossPercent(cid, lossType)
4017	uint8_t lossType = (uint8_t)popNumber(L);
4018
4019	ScriptEnviroment* env = getEnv();
4020	if(const Player* player = env->getPlayerByUID(popNumber(L)))
4021	{
4022		if(lossType <= LOSS_LAST)
4023		{
4024			uint32_t value = player->getLossPercent((lossTypes_t)lossType);
4025			lua_pushnumber(L, value);
4026		}
4027		else
4028			lua_pushboolean(L, false);
4029	}
4030	else
4031	{
4032		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4033		lua_pushboolean(L, false);
4034	}
4035	return 1;
4036}
4037
4038int32_t LuaScriptInterface::luaDoPlayerSetLossPercent(lua_State* L)
4039{
4040	//doPlayerSetLossPercent(cid, lossType, newPercent)
4041	uint32_t newPercent = popNumber(L);
4042	uint8_t lossType = (uint8_t)popNumber(L);
4043
4044	ScriptEnviroment* env = getEnv();
4045	if(Player* player = env->getPlayerByUID(popNumber(L)))
4046	{
4047		if(lossType <= LOSS_LAST)
4048		{
4049			player->setLossPercent((lossTypes_t)lossType, newPercent);
4050			lua_pushboolean(L, true);
4051		}
4052		else
4053			lua_pushboolean(L, false);
4054	}
4055	else
4056	{
4057		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4058		lua_pushboolean(L, false);
4059	}
4060	return 1;
4061}
4062
4063int32_t LuaScriptInterface::luaDoPlayerSetLossSkill(lua_State* L)
4064{
4065	//doPlayerSetLossSkill(cid, doLose)
4066	bool doLose = popNumber(L);
4067
4068	ScriptEnviroment* env = getEnv();
4069	if(Player* player = env->getPlayerByUID(popNumber(L)))
4070	{
4071		player->setLossSkill(doLose);
4072		lua_pushboolean(L, true);
4073	}
4074	else
4075	{
4076		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4077		lua_pushboolean(L, false);
4078	}
4079	return 1;
4080}
4081
4082int32_t LuaScriptInterface::luaDoShowTextDialog(lua_State* L)
4083{
4084	//doShowTextDialog(cid, itemid, text)
4085	std::string text = popString(L);
4086	uint32_t itemId = popNumber(L);
4087
4088	ScriptEnviroment* env = getEnv();
4089	if(Player* player = env->getPlayerByUID(popNumber(L)))
4090	{
4091		player->setWriteItem(NULL, 0);
4092		player->sendTextWindow(itemId, text);
4093		lua_pushboolean(L, true);
4094	}
4095	else
4096	{
4097		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4098		lua_pushboolean(L, false);
4099	}
4100	return 1;
4101}
4102
4103int32_t LuaScriptInterface::luaDoDecayItem(lua_State* L)
4104{
4105	//doDecayItem(uid)
4106	//Note: to stop decay set decayTo = 0 in items.xml
4107	ScriptEnviroment* env = getEnv();
4108	if(Item* item = env->getItemByUID(popNumber(L)))
4109	{
4110		g_game.startDecay(item);
4111		lua_pushboolean(L, true);
4112	}
4113	else
4114	{
4115		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
4116		lua_pushboolean(L, false);
4117	}
4118	return 1;
4119}
4120
4121int32_t LuaScriptInterface::luaGetThingFromPos(lua_State* L)
4122{
4123	//getThingFromPos(pos[, displayError = true])
4124	//Note:
4125	//	stackpos = 255- top thing (movable item or creature)
4126	//	stackpos = 254- magic field
4127	//	stackpos = 253- top creature
4128
4129	bool displayError = true;
4130	if(lua_gettop(L) > 1)
4131		displayError = popNumber(L);
4132
4133	PositionEx pos;
4134	popPosition(L, pos);
4135
4136	ScriptEnviroment* env = getEnv();
4137	Thing* thing = NULL;
4138	if(Tile* tile = g_game.getMap()->getTile(pos))
4139	{
4140		if(pos.stackpos == 255)
4141		{
4142			if(!(thing = tile->getTopCreature()))
4143			{
4144				Item* item = tile->getTopDownItem();
4145				if(item && item->isMoveable())
4146					thing = item;
4147			}
4148		}
4149		else if(pos.stackpos == 254)
4150			thing = tile->getFieldItem();
4151		else if(pos.stackpos == 253)
4152			thing = tile->getTopCreature();
4153		else
4154			thing = tile->__getThing(pos.stackpos);
4155
4156		if(thing)
4157			pushThing(L, thing, env->addThing(thing));
4158		else
4159			pushThing(L, NULL, 0);
4160
4161		return 1;
4162	}
4163
4164	if(displayError)
4165		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
4166
4167	pushThing(L, NULL, 0);
4168	return 1;
4169}
4170
4171int32_t LuaScriptInterface::luaGetTileItemById(lua_State* L)
4172{
4173	//getTileItemById(pos, itemId[, subType = -1])
4174	ScriptEnviroment* env = getEnv();
4175
4176	int32_t subType = -1;
4177	if(lua_gettop(L) > 2)
4178		subType = (int32_t)popNumber(L);
4179
4180	int32_t itemId = (int32_t)popNumber(L);
4181	PositionEx pos;
4182	popPosition(L, pos);
4183
4184	Tile* tile = g_game.getTile(pos);
4185	if(!tile)
4186	{
4187		pushThing(L, NULL, 0);
4188		return 1;
4189	}
4190
4191	Item* item = g_game.findItemOfType(tile, itemId, false, subType);
4192	if(!item)
4193	{
4194		pushThing(L, NULL, 0);
4195		return 1;
4196	}
4197
4198	pushThing(L, item, env->addThing(item));
4199	return 1;
4200}
4201
4202int32_t LuaScriptInterface::luaGetTileItemByType(lua_State* L)
4203{
4204	//getTileItemByType(pos, type)
4205	uint32_t rType = (uint32_t)popNumber(L);
4206	if(rType >= ITEM_TYPE_LAST)
4207	{
4208		errorEx("Not a valid item type");
4209		pushThing(L, NULL, 0);
4210		return 1;
4211	}
4212
4213	PositionEx pos;
4214	popPosition(L, pos);
4215
4216	Tile* tile = g_game.getTile(pos);
4217	if(!tile)
4218	{
4219		pushThing(L, NULL, 0);
4220		return 1;
4221	}
4222
4223	bool found = true;
4224	switch((ItemTypes_t)rType)
4225	{
4226		case ITEM_TYPE_TELEPORT:
4227		{
4228			if(!tile->hasFlag(TILESTATE_TELEPORT))
4229				found = false;
4230
4231			break;
4232		}
4233		case ITEM_TYPE_MAGICFIELD:
4234		{
4235			if(!tile->hasFlag(TILESTATE_MAGICFIELD))
4236				found = false;
4237
4238			break;
4239		}
4240		case ITEM_TYPE_MAILBOX:
4241		{
4242			if(!tile->hasFlag(TILESTATE_MAILBOX))
4243				found = false;
4244
4245			break;
4246		}
4247		case ITEM_TYPE_TRASHHOLDER:
4248		{
4249			if(!tile->hasFlag(TILESTATE_TRASHHOLDER))
4250				found = false;
4251
4252			break;
4253		}
4254		case ITEM_TYPE_BED:
4255		{
4256			if(!tile->hasFlag(TILESTATE_BED))
4257				found = false;
4258
4259			break;
4260		}
4261		default:
4262			break;
4263	}
4264
4265	if(!found)
4266	{
4267		pushThing(L, NULL, 0);
4268		return 1;
4269	}
4270
4271	ScriptEnviroment* env = getEnv();
4272	Item* item = NULL;
4273	for(uint32_t i = 0; i < tile->getThingCount(); ++i)
4274	{
4275		if(!(item = tile->__getThing(i)->getItem()))
4276			continue;
4277
4278		if(Item::items[item->getID()].type != (ItemTypes_t)rType)
4279			continue;
4280
4281		pushThing(L, item, env->addThing(item));
4282		return 1;
4283	}
4284
4285	pushThing(L, NULL, 0);
4286	return 1;
4287}
4288
4289int32_t LuaScriptInterface::luaGetTileThingByPos(lua_State* L)
4290{
4291	//getTileThingByPos(pos)
4292	PositionEx pos;
4293	popPosition(L, pos);
4294
4295	ScriptEnviroment* env = getEnv();
4296
4297	Tile* tile = g_game.getTile(pos.x, pos.y, pos.z);
4298	if(!tile)
4299	{
4300		if(pos.stackpos == -1)
4301		{
4302			lua_pushnumber(L, -1);
4303			return 1;
4304		}
4305		else
4306		{
4307			pushThing(L, NULL, 0);
4308			return 1;
4309		}
4310	}
4311
4312	if(pos.stackpos == -1)
4313	{
4314		lua_pushnumber(L, tile->getThingCount());
4315		return 1;
4316	}
4317
4318	Thing* thing = tile->__getThing(pos.stackpos);
4319	if(!thing)
4320	{
4321		pushThing(L, NULL, 0);
4322		return 1;
4323	}
4324
4325	pushThing(L, thing, env->addThing(thing));
4326	return 1;
4327}
4328
4329int32_t LuaScriptInterface::luaGetTopCreature(lua_State* L)
4330{
4331	//getTopCreature(pos)
4332	PositionEx pos;
4333	popPosition(L, pos);
4334
4335	ScriptEnviroment* env = getEnv();
4336	Tile* tile = g_game.getTile(pos);
4337	if(!tile)
4338	{
4339		pushThing(L, NULL, 0);
4340		return 1;
4341	}
4342
4343	Thing* thing = tile->getTopCreature();
4344	if(!thing || !thing->getCreature())
4345	{
4346		pushThing(L, NULL, 0);
4347		return 1;
4348	}
4349
4350	pushThing(L, thing, env->addThing(thing));
4351	return 1;
4352}
4353
4354int32_t LuaScriptInterface::luaDoCreateItem(lua_State* L)
4355{
4356	//doCreateItem(itemid[, type/count], pos)
4357	//Returns uid of the created item, only works on tiles.
4358	PositionEx pos;
4359	popPosition(L, pos);
4360
4361	uint32_t count = 1;
4362	if(lua_gettop(L) > 1)
4363		count = popNumber(L);
4364
4365	uint32_t itemId = popNumber(L);
4366	ScriptEnviroment* env = getEnv();
4367
4368	Tile* tile = g_game.getTile(pos);
4369	if(!tile)
4370	{
4371		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
4372		lua_pushboolean(L, false);
4373		return 1;
4374	}
4375
4376	const ItemType& it = Item::items[itemId];
4377	int32_t itemCount = 1, subType = 1;
4378	if(it.hasSubType())
4379	{
4380		if(it.stackable)
4381			itemCount = (int32_t)std::ceil((float)count / 100);
4382
4383		subType = count;
4384	}
4385	else
4386		itemCount = std::max((uint32_t)1, count);
4387
4388	while(itemCount > 0)
4389	{
4390		int32_t stackCount = std::min(100, subType);
4391		Item* newItem = Item::CreateItem(itemId, stackCount);
4392		if(!newItem)
4393		{
4394			errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
4395			lua_pushboolean(L, false);
4396			return 1;
4397		}
4398
4399		if(it.stackable)
4400			subType -= stackCount;
4401
4402		ReturnValue ret = g_game.internalAddItem(NULL, tile, newItem, INDEX_WHEREEVER, FLAG_NOLIMIT);
4403		if(ret != RET_NOERROR)
4404		{
4405			delete newItem;
4406			lua_pushboolean(L, false);
4407			return 1;
4408		}
4409
4410		--itemCount;
4411		if(itemCount)
4412			continue;
4413
4414		if(newItem->getParent())
4415			lua_pushnumber(L, env->addThing(newItem));
4416		else //stackable item stacked with existing object, newItem will be released
4417			lua_pushnil(L);
4418
4419		return 1;
4420	}
4421
4422	lua_pushnil(L);
4423	return 1;
4424}
4425
4426int32_t LuaScriptInterface::luaDoCreateItemEx(lua_State* L)
4427{
4428	//doCreateItemEx(itemid[, count/subType])
4429	uint32_t count = 0;
4430	if(lua_gettop(L) > 1)
4431		count = popNumber(L);
4432
4433	ScriptEnviroment* env = getEnv();
4434	const ItemType& it = Item::items[(uint32_t)popNumber(L)];
4435	if(it.stackable && count > 100)
4436		count = 100;
4437
4438	Item* newItem = Item::CreateItem(it.id, count);
4439	if(!newItem)
4440	{
4441		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
4442		lua_pushboolean(L, false);
4443		return 1;
4444	}
4445
4446	newItem->setParent(VirtualCylinder::virtualCylinder);
4447	env->addTempItem(env, newItem);
4448
4449	lua_pushnumber(L, env->addThing(newItem));
4450	return 1;
4451}
4452
4453int32_t LuaScriptInterface::luaDoCreateTeleport(lua_State* L)
4454{
4455	//doCreateTeleport(itemid, toPosition, fromPosition)
4456	PositionEx createPos;
4457	popPosition(L, createPos);
4458	PositionEx toPos;
4459	popPosition(L, toPos);
4460
4461	uint32_t itemId = (uint32_t)popNumber(L);
4462	ScriptEnviroment* env = getEnv();
4463
4464	Tile* tile = g_game.getMap()->getTile(createPos);
4465	if(!tile)
4466	{
4467		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
4468		lua_pushboolean(L, false);
4469		return 1;
4470	}
4471
4472	Item* newItem = Item::CreateItem(itemId);
4473	Teleport* newTeleport = newItem->getTeleport();
4474	if(!newTeleport)
4475	{
4476		delete newItem;
4477		lua_pushboolean(L, false);
4478		return 1;
4479	}
4480
4481	newTeleport->setDestination(toPos);
4482	if(g_game.internalAddItem(NULL, tile, newTeleport, INDEX_WHEREEVER, FLAG_NOLIMIT) != RET_NOERROR)
4483	{
4484		delete newItem;
4485		lua_pushboolean(L, false);
4486		return 1;
4487	}
4488
4489	if(newItem->getParent())
4490		lua_pushnumber(L, env->addThing(newItem));
4491	else //stackable item stacked with existing object, newItem will be released
4492		lua_pushnil(L);
4493
4494	return 1;
4495}
4496
4497int32_t LuaScriptInterface::luaGetCreatureStorage(lua_State* L)
4498{
4499	//getCreatureStorage(cid, key)
4500	uint32_t key = popNumber(L);
4501	ScriptEnviroment* env = getEnv();
4502	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
4503	{
4504		std::string strValue;
4505		if(creature->getStorage(key, strValue))
4506		{
4507			int32_t intValue = atoi(strValue.c_str());
4508			if(intValue || strValue == "0")
4509				lua_pushnumber(L, intValue);
4510			else
4511				lua_pushstring(L, strValue.c_str());
4512		}
4513		else
4514			lua_pushnumber(L, -1);
4515	}
4516	else
4517	{
4518		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
4519		lua_pushboolean(L, false);
4520	}
4521
4522	return 1;
4523}
4524
4525int32_t LuaScriptInterface::luaDoCreatureSetStorage(lua_State* L)
4526{
4527	//doCreatureSetStorage(cid, key[, value])
4528	std::string value;
4529	bool nil = true;
4530	if(lua_gettop(L) > 2)
4531	{
4532		if(!lua_isnil(L, -1))
4533		{
4534			value = popString(L);
4535			nil = false;
4536		}
4537		else
4538			lua_pop(L, 1);
4539	}
4540
4541	uint32_t key = popNumber(L);
4542	ScriptEnviroment* env = getEnv();
4543	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
4544	{
4545		if(!nil)
4546			nil = creature->setStorage(key, value);
4547		else
4548			creature->eraseStorage(key);
4549
4550		lua_pushboolean(L, nil);
4551	}
4552	else
4553	{
4554		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
4555		lua_pushboolean(L, false);
4556	}
4557
4558	return 1;
4559}
4560
4561int32_t LuaScriptInterface::luaGetTileInfo(lua_State* L)
4562{
4563	//getTileInfo(pos)
4564	PositionEx pos;
4565	popPosition(L, pos);
4566	if(Tile* tile = g_game.getMap()->getTile(pos))
4567	{
4568		ScriptEnviroment* env = getEnv();
4569		pushThing(L, tile->ground, env->addThing(tile->ground));
4570
4571		setFieldBool(L, "protection", tile->hasFlag(TILESTATE_PROTECTIONZONE));
4572		setFieldBool(L, "nopvp", tile->hasFlag(TILESTATE_NOPVPZONE));
4573		setFieldBool(L, "nologout", tile->hasFlag(TILESTATE_NOLOGOUT));
4574		setFieldBool(L, "pvp", tile->hasFlag(TILESTATE_PVPZONE));
4575		setFieldBool(L, "refresh", tile->hasFlag(TILESTATE_REFRESH));
4576		setFieldBool(L, "trashed", tile->hasFlag(TILESTATE_TRASHED));
4577		setFieldBool(L, "house", tile->hasFlag(TILESTATE_HOUSE));
4578		setFieldBool(L, "bed", tile->hasFlag(TILESTATE_BED));
4579		setFieldBool(L, "depot", tile->hasFlag(TILESTATE_DEPOT));
4580
4581		setField(L, "things", tile->getThingCount());
4582		setField(L, "creatures", tile->getCreatureCount());
4583		setField(L, "items", tile->getItemCount());
4584		setField(L, "topItems", tile->getTopItemCount());
4585		setField(L, "downItems", tile->getDownItemCount());
4586	}
4587	else
4588	{
4589		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
4590		lua_pushboolean(L, false);
4591	}
4592
4593	return 1;
4594}
4595
4596int32_t LuaScriptInterface::luaGetHouseFromPos(lua_State* L)
4597{
4598	//getHouseFromPos(pos)
4599	PositionEx pos;
4600	popPosition(L, pos);
4601
4602	Tile* tile = g_game.getMap()->getTile(pos);
4603	if(!tile)
4604	{
4605		errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
4606		lua_pushboolean(L, false);
4607		return 1;
4608	}
4609
4610	HouseTile* houseTile = tile->getHouseTile();
4611	if(!houseTile)
4612	{
4613		lua_pushboolean(L, false);
4614		return 1;
4615	}
4616
4617	House* house = houseTile->getHouse();
4618	if(!house)
4619	{
4620		lua_pushboolean(L, false);
4621		return 1;
4622	}
4623
4624	lua_pushnumber(L, house->getId());
4625	return 1;
4626}
4627
4628int32_t LuaScriptInterface::luaDoCreateMonster(lua_State* L)
4629{
4630	//doCreateMonster(name, pos[, displayError = true])
4631	bool displayError = true;
4632	if(lua_gettop(L) > 2)
4633		displayError = popNumber(L);
4634
4635	PositionEx pos;
4636	popPosition(L, pos);
4637
4638	std::string name = popString(L);
4639	Monster* monster = Monster::createMonster(name.c_str());
4640	if(!monster)
4641	{
4642		if(displayError)
4643			errorEx("Monster with name '" + name + "' not found");
4644
4645		lua_pushboolean(L, false);
4646		return 1;
4647	}
4648
4649	if(!g_game.placeCreature(monster, pos))
4650	{
4651		delete monster;
4652		if(displayError)
4653			errorEx("Cannot create monster: " + name);
4654
4655		lua_pushboolean(L, true);
4656		return 1;
4657	}
4658
4659	ScriptEnviroment* env = getEnv();
4660	lua_pushnumber(L, env->addThing((Thing*)monster));
4661	return 1;
4662}
4663
4664int32_t LuaScriptInterface::luaDoCreateNpc(lua_State* L)
4665{
4666	//doCreateNpc(name, pos[, displayError = true])
4667	bool displayError = true;
4668	if(lua_gettop(L) > 2)
4669		displayError = popNumber(L);
4670
4671	PositionEx pos;
4672	popPosition(L, pos);
4673
4674	std::string name = popString(L);
4675	Npc* npc = Npc::createNpc(name.c_str());
4676	if(!npc)
4677	{
4678		if(displayError)
4679			errorEx("Npc with name '" + name + "' not found");
4680
4681		lua_pushboolean(L, false);
4682		return 1;
4683	}
4684
4685	if(!g_game.placeCreature(npc, pos))
4686	{
4687		delete npc;
4688		if(displayError)
4689			errorEx("Cannot create npc: " + name);
4690
4691		lua_pushboolean(L, true); //for scripting compatibility
4692		return 1;
4693	}
4694
4695	ScriptEnviroment* env = getEnv();
4696	lua_pushnumber(L, env->addThing((Thing*)npc));
4697	return 1;
4698}
4699
4700int32_t LuaScriptInterface::luaDoRemoveCreature(lua_State* L)
4701{
4702	//doRemoveCreature(cid[, forceLogout = true])
4703	bool forceLogout = true;
4704	if(lua_gettop(L) > 1)
4705		forceLogout = popNumber(L);
4706
4707	ScriptEnviroment* env = getEnv();
4708	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
4709	{
4710		if(Player* player = creature->getPlayer())
4711			player->kickPlayer(true, forceLogout); //Players will get kicked without restrictions
4712		else
4713			g_game.removeCreature(creature); //Monsters/NPCs will get removed
4714
4715		lua_pushboolean(L, true);
4716	}
4717	else
4718	{
4719		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
4720		lua_pushboolean(L, false);
4721	}
4722	return 1;
4723}
4724
4725int32_t LuaScriptInterface::luaDoPlayerAddMoney(lua_State* L)
4726{
4727	//doPlayerAddMoney(cid, money)
4728	uint64_t money = popNumber(L);
4729
4730	ScriptEnviroment* env = getEnv();
4731	if(Player* player = env->getPlayerByUID(popNumber(L)))
4732	{
4733		g_game.addMoney(player, money);
4734		lua_pushboolean(L, true);
4735	}
4736	else
4737	{
4738		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4739		lua_pushboolean(L, false);
4740	}
4741	return 1;
4742}
4743
4744int32_t LuaScriptInterface::luaDoPlayerRemoveMoney(lua_State* L)
4745{
4746	//doPlayerRemoveMoney(cid,money)
4747	uint64_t money = popNumber(L);
4748
4749	ScriptEnviroment* env = getEnv();
4750	if(Player* player = env->getPlayerByUID(popNumber(L)))
4751		lua_pushboolean(L, g_game.removeMoney(player, money));
4752	else
4753	{
4754		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4755		lua_pushboolean(L, false);
4756	}
4757	return 1;
4758}
4759
4760int32_t LuaScriptInterface::luaDoPlayerTransferMoneyTo(lua_State* L)
4761{
4762	//doPlayerTransferMoneyTo(cid, target, money)
4763	uint64_t money = popNumber(L);
4764	std::string target = popString(L);
4765
4766	ScriptEnviroment* env = getEnv();
4767	if(Player* player = env->getPlayerByUID(popNumber(L)))
4768		lua_pushboolean(L, player->transferMoneyTo(target, money));
4769	else
4770	{
4771		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4772		lua_pushboolean(L, false);
4773	}
4774	return 1;
4775}
4776
4777int32_t LuaScriptInterface::luaDoPlayerSetPzLocked(lua_State* L)
4778{
4779	//doPlayerSetPzLocked(cid, locked)
4780	bool locked = popNumber(L);
4781
4782	ScriptEnviroment* env = getEnv();
4783	if(Player* player = env->getPlayerByUID(popNumber(L)))
4784	{
4785		if(player->isPzLocked() != locked)
4786		{
4787			player->setPzLocked(locked);
4788			player->sendIcons();
4789		}
4790
4791		lua_pushboolean(L, true);
4792	}
4793	else
4794	{
4795		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4796		lua_pushboolean(L, false);
4797	}
4798	return 1;
4799}
4800
4801int32_t LuaScriptInterface::luaDoPlayerSetTown(lua_State* L)
4802{
4803	//doPlayerSetTown(cid, townid)
4804	uint32_t townid = (uint32_t)popNumber(L);
4805
4806	ScriptEnviroment* env = getEnv();
4807	if(Player* player = env->getPlayerByUID(popNumber(L)))
4808	{
4809		if(Town* town = Towns::getInstance()->getTown(townid))
4810		{
4811			player->setMasterPosition(town->getPosition());
4812			player->setTown(townid);
4813			lua_pushboolean(L, true);
4814		}
4815		else
4816			lua_pushboolean(L, false);
4817	}
4818	else
4819	{
4820		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4821		lua_pushboolean(L, false);
4822	}
4823	return 1;
4824}
4825
4826int32_t LuaScriptInterface::luaDoPlayerSetVocation(lua_State* L)
4827{
4828	//doPlayerSetVocation(cid, voc)
4829	uint32_t voc = popNumber(L);
4830
4831	ScriptEnviroment* env = getEnv();
4832	if(Player* player = env->getPlayerByUID(popNumber(L)))
4833	{
4834		player->setVocation(voc);
4835		lua_pushboolean(L, true);
4836	}
4837	else
4838	{
4839		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4840		lua_pushboolean(L, false);
4841	}
4842	return 1;
4843}
4844
4845int32_t LuaScriptInterface::luaDoPlayerSetSex(lua_State* L)
4846{
4847	//doPlayerSetSex(cid, sex)
4848	uint32_t newSex = popNumber(L);
4849
4850	ScriptEnviroment* env = getEnv();
4851	if(Player* player = env->getPlayerByUID(popNumber(L)))
4852	{
4853		player->setSex(newSex);
4854		lua_pushboolean(L, true);
4855	}
4856	else
4857	{
4858		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4859		lua_pushboolean(L, false);
4860	}
4861	return 1;
4862}
4863
4864int32_t LuaScriptInterface::luaDoPlayerAddSoul(lua_State* L)
4865{
4866	//doPlayerAddSoul(cid, soul)
4867	int32_t soul = popNumber(L);
4868
4869	ScriptEnviroment* env = getEnv();
4870	if(Player* player = env->getPlayerByUID(popNumber(L)))
4871	{
4872		player->changeSoul(soul);
4873		lua_pushboolean(L, true);
4874	}
4875	else
4876	{
4877		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4878		lua_pushboolean(L, false);
4879	}
4880	return 1;
4881}
4882
4883int32_t LuaScriptInterface::luaGetPlayerItemCount(lua_State* L)
4884{
4885	//getPlayerItemCount(cid, itemid[, subType = -1])
4886	int32_t subType = -1;
4887	if(lua_gettop(L) > 2)
4888		subType = popNumber(L);
4889
4890	uint32_t itemId = popNumber(L);
4891	ScriptEnviroment* env = getEnv();
4892	if(const Player* player = env->getPlayerByUID(popNumber(L)))
4893		lua_pushnumber(L, player->__getItemTypeCount(itemId, subType));
4894	else
4895	{
4896		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4897		lua_pushboolean(L, false);
4898	}
4899	return 1;
4900}
4901
4902int32_t LuaScriptInterface::luaGetPlayerMoney(lua_State* L)
4903{
4904	//getPlayerMoney(cid)
4905	ScriptEnviroment* env = getEnv();
4906	if(Player* player = env->getPlayerByUID(popNumber(L)))
4907		lua_pushnumber(L, g_game.getMoney(player));
4908	else
4909	{
4910		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
4911		lua_pushboolean(L, false);
4912	}
4913	return 1;
4914}
4915
4916int32_t LuaScriptInterface::luaGetHouseInfo(lua_State* L)
4917{
4918	//getHouseInfo(houseId)
4919	bool displayError = true;
4920	if(lua_gettop(L) > 1)
4921		displayError = popNumber(L);
4922
4923	House* house = Houses::getInstance()->getHouse(popNumber(L));
4924	if(!house)
4925	{
4926		if(displayError)
4927			errorEx(getError(LUA_ERROR_HOUSE_NOT_FOUND));
4928
4929		lua_pushboolean(L, false);
4930		return 1;
4931	}
4932
4933	lua_newtable(L);
4934	setField(L, "id", house->getId());
4935	setField(L, "name", house->getName().c_str());
4936	setField(L, "owner", house->getOwner());
4937
4938	lua_pushstring(L, "entry");
4939	pushPosition(L, house->getEntry(), 0);
4940	pushTable(L);
4941
4942	setField(L, "rent", house->getRent());
4943	setField(L, "price", house->getPrice());
4944	setField(L, "town", house->getTownId());
4945	setField(L, "paidUntil", house->getPaidUntil());
4946	setField(L, "warnings", house->getRentWarnings());
4947	setField(L, "lastWarning", house->getLastWarning());
4948
4949	setFieldBool(L, "guildHall", house->isGuild());
4950	setField(L, "size", house->getSize());
4951	setField(L, "doors", house->getDoorsCount());
4952	setField(L, "beds", house->getBedsCount());
4953	setField(L, "tiles", house->getTilesCount());
4954
4955	return 1;
4956}
4957
4958int32_t LuaScriptInterface::luaGetHouseAccessList(lua_State* L)
4959{
4960	//getHouseAccessList(houseid, listid)
4961	uint32_t listid = popNumber(L);
4962	if(House* house = Houses::getInstance()->getHouse(popNumber(L)))
4963	{
4964		std::string list;
4965		if(house->getAccessList(listid, list))
4966			lua_pushstring(L, list.c_str());
4967		else
4968			lua_pushnil(L);
4969	}
4970	else
4971	{
4972		errorEx(getError(LUA_ERROR_HOUSE_NOT_FOUND));
4973		lua_pushnil(L);
4974	}
4975	return 1;
4976}
4977
4978int32_t LuaScriptInterface::luaGetHouseByPlayerGUID(lua_State* L)
4979{
4980	//getHouseByPlayerGUID(guid)
4981	if(House* house = Houses::getInstance()->getHouseByPlayerId(popNumber(L)))
4982		lua_pushnumber(L, house->getId());
4983	else
4984		lua_pushnil(L);
4985	return 1;
4986}
4987
4988int32_t LuaScriptInterface::luaSetHouseAccessList(lua_State* L)
4989{
4990	//setHouseAccessList(houseid, listid, listtext)
4991	std::string list = popString(L);
4992	uint32_t listid = popNumber(L);
4993
4994	if(House* house = Houses::getInstance()->getHouse(popNumber(L)))
4995	{
4996		house->setAccessList(listid, list);
4997		lua_pushboolean(L, true);
4998	}
4999	else
5000	{
5001		errorEx(getError(LUA_ERROR_HOUSE_NOT_FOUND));
5002		lua_pushboolean(L, false);
5003	}
5004	return 1;
5005}
5006
5007int32_t LuaScriptInterface::luaSetHouseOwner(lua_State* L)
5008{
5009	//setHouseOwner(houseId, owner[, clean])
5010	bool clean = true;
5011	if(lua_gettop(L) > 2)
5012		clean = popNumber(L);
5013
5014	uint32_t owner = popNumber(L);
5015	if(House* house = Houses::getInstance()->getHouse(popNumber(L)))
5016		lua_pushboolean(L, house->setOwnerEx(owner, clean));
5017	else
5018	{
5019		errorEx(getError(LUA_ERROR_HOUSE_NOT_FOUND));
5020		lua_pushboolean(L, false);
5021	}
5022	return 1;
5023}
5024
5025int32_t LuaScriptInterface::luaGetWorldType(lua_State* L)
5026{
5027	lua_pushnumber(L, (uint32_t)g_game.getWorldType());
5028	return 1;
5029}
5030
5031int32_t LuaScriptInterface::luaSetWorldType(lua_State* L)
5032{
5033	//setWorldType(type)
5034	WorldType_t type = (WorldType_t)popNumber(L);
5035
5036	if(type >= WORLD_TYPE_FIRST && type <= WORLD_TYPE_LAST)
5037	{
5038		g_game.setWorldType(type);
5039		lua_pushboolean(L, true);
5040	}
5041	else
5042		lua_pushboolean(L, false);
5043
5044	return 1;
5045}
5046
5047int32_t LuaScriptInterface::luaGetWorldTime(lua_State* L)
5048{
5049	//getWorldTime()
5050	lua_pushnumber(L, g_game.getLightHour());
5051	return 1;
5052}
5053
5054int32_t LuaScriptInterface::luaGetWorldLight(lua_State* L)
5055{
5056	//getWorldLight()
5057	LightInfo lightInfo;
5058	g_game.getWorldLightInfo(lightInfo);
5059	lua_pushnumber(L, lightInfo.level);
5060	lua_pushnumber(L, lightInfo.color);
5061	return 1;
5062}
5063
5064int32_t LuaScriptInterface::luaGetWorldCreatures(lua_State* L)
5065{
5066	//getWorldCreatures(type)
5067	//0 players, 1 monsters, 2 npcs, 3 all
5068	uint32_t type = popNumber(L), value;
5069	switch(type)
5070	{
5071		case 0:
5072			value = g_game.getPlayersOnline();
5073			break;
5074		case 1:
5075			value = g_game.getMonstersOnline();
5076			break;
5077		case 2:
5078			value = g_game.getNpcsOnline();
5079			break;
5080		case 3:
5081			value = g_game.getCreaturesOnline();
5082			break;
5083		default:
5084			lua_pushboolean(L, false);
5085			return 1;
5086	}
5087
5088	lua_pushnumber(L, value);
5089	return 1;
5090}
5091
5092int32_t LuaScriptInterface::luaGetWorldUpTime(lua_State* L)
5093{
5094	//getWorldUpTime()
5095	uint32_t uptime = 0;
5096	if(Status* status = Status::getInstance())
5097		uptime = status->getUptime();
5098
5099	lua_pushnumber(L, uptime);
5100	return 1;
5101}
5102
5103int32_t LuaScriptInterface::luaGetPlayerLight(lua_State* L)
5104{
5105	//getPlayerLight(cid)
5106	ScriptEnviroment* env = getEnv();
5107	if(const Player* player = env->getPlayerByUID(popNumber(L)))
5108	{
5109		LightInfo lightInfo;
5110		player->getCreatureLight(lightInfo);
5111		lua_pushnumber(L, lightInfo.level);
5112		lua_pushnumber(L, lightInfo.color);
5113	}
5114	else
5115	{
5116		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
5117		lua_pushboolean(L, false);
5118	}
5119	return 1;
5120}
5121
5122int32_t LuaScriptInterface::luaDoPlayerAddExperience(lua_State* L)
5123{
5124	//doPlayerAddExperience(cid, amount)
5125	int64_t amount = popNumber(L);
5126
5127	ScriptEnviroment* env = getEnv();
5128	if(Player* player = env->getPlayerByUID(popNumber(L)))
5129	{
5130		if(amount > 0)
5131			player->addExperience(amount);
5132		else if(amount < 0)
5133			player->removeExperience(std::abs(amount));
5134		else
5135		{
5136			lua_pushboolean(L, false);
5137			return 1;
5138		}
5139
5140		lua_pushboolean(L, true);
5141	}
5142	else
5143	{
5144		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
5145		lua_pushboolean(L, false);
5146	}
5147	return 1;
5148}
5149
5150int32_t LuaScriptInterface::luaGetPlayerSlotItem(lua_State* L)
5151{
5152	//getPlayerSlotItem(cid, slot)
5153	uint32_t slot = popNumber(L);
5154
5155	ScriptEnviroment* env = getEnv();
5156	if(const Player* player = env->getPlayerByUID(popNumber(L)))
5157	{
5158		if(Thing* thing = player->__getThing(slot))
5159			pushThing(L, thing, env->addThing(thing));
5160		else
5161			pushThing(L, NULL, 0);
5162	}
5163	else
5164	{
5165		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
5166		pushThing(L, NULL, 0);
5167	}
5168	return 1;
5169}
5170
5171int32_t LuaScriptInterface::luaGetPlayerWeapon(lua_State* L)
5172{
5173	//getPlayerWeapon(cid[, ignoreAmmo = false])
5174	bool ignoreAmmo = false;
5175	if(lua_gettop(L) > 1)
5176		ignoreAmmo = popNumber(L);
5177
5178	ScriptEnviroment* env = getEnv();
5179	if(Player* player = env->getPlayerByUID(popNumber(L)))
5180	{
5181		if(Item* weapon = player->getWeapon(ignoreAmmo))
5182			pushThing(L, weapon, env->addThing(weapon));
5183		else
5184			pushThing(L, NULL, 0);
5185	}
5186	else
5187	{
5188		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
5189		lua_pushnil(L);
5190	}
5191	return 1;
5192}
5193
5194int32_t LuaScriptInterface::luaGetPlayerItemById(lua_State* L)
5195{
5196	//getPlayerItemById(cid, deepSearch, itemId[, subType = -1])
5197	ScriptEnviroment* env = getEnv();
5198
5199	int32_t subType = -1;
5200	if(lua_gettop(L) > 3)
5201		subType = (int32_t)popNumber(L);
5202
5203	int32_t itemId = (int32_t)popNumber(L);
5204	bool deepSearch = popNumber(L);
5205
5206	Player* player = env->getPlayerByUID(popNumber(L));
5207	if(!player)
5208	{
5209		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
5210		pushThing(L, NULL, 0);
5211		return 1;
5212	}
5213
5214	Item* item = g_game.findItemOfType(player, itemId, deepSearch, subType);
5215	if(!item)
5216	{
5217		pushThing(L, NULL, 0);
5218		return 1;
5219	}
5220
5221	pushThing(L, item, env->addThing(item));
5222	return 1;
5223}
5224
5225int32_t LuaScriptInterface::luaGetThing(lua_State* L)
5226{
5227	//getThing(uid)
5228	uint32_t uid = popNumber(L);
5229
5230	ScriptEnviroment* env = getEnv();
5231	if(Thing* thing = env->getThingByUID(uid))
5232		pushThing(L, thing, uid);
5233	else
5234	{
5235		errorEx(getError(LUA_ERROR_THING_NOT_FOUND));
5236		pushThing(L, NULL, 0);
5237	}
5238	return 1;
5239}
5240
5241int32_t LuaScriptInterface::luaDoTileQueryAdd(lua_State* L)
5242{
5243	//doTileQueryAdd(uid, pos[, flags[, displayError = true]])
5244	uint32_t flags = 0, params = lua_gettop(L);
5245	bool displayError = true;
5246	if(params > 3)
5247		displayError = popNumber(L);
5248
5249	if(params > 2)
5250		flags = popNumber(L);
5251
5252	PositionEx pos;
5253	popPosition(L, pos);
5254	uint32_t uid = popNumber(L);
5255
5256	ScriptEnviroment* env = getEnv();
5257	Tile* tile = g_game.getTile(pos);
5258	if(!tile)
5259	{
5260		if(displayError)
5261			errorEx(getError(LUA_ERROR_TILE_NOT_FOUND));
5262
5263		lua_pushnumber(L, (uint32_t)RET_NOTPOSSIBLE);
5264		return 1;
5265	}
5266
5267	Thing* thing = env->getThingByUID(uid);
5268	if(!thing)
5269	{
5270		if(displayError)
5271			errorEx(getError(LUA_ERROR_THING_NOT_FOUND));
5272
5273		lua_pushnumber(L, (uint32_t)RET_NOTPOSSIBLE);
5274		return 1;
5275	}
5276
5277	lua_pushnumber(L, (uint32_t)tile->__queryAdd(0, thing, 1, flags));
5278	return 1;
5279}
5280
5281int32_t LuaScriptInterface::luaDoItemRaidUnref(lua_State* L)
5282{
5283	//doItemRaidUnref(uid)
5284	ScriptEnviroment* env = getEnv();
5285	if(Item* item = env->getItemByUID(popNumber(L)))
5286	{
5287		if(Raid* raid = item->getRaid())
5288		{
5289			raid->unRef();
5290			item->setRaid(NULL);
5291			lua_pushboolean(L, true);
5292		}
5293		else
5294			lua_pushboolean(L, false);
5295	}
5296	else
5297	{
5298		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
5299		lua_pushboolean(L, false);
5300	}
5301	return 1;
5302}
5303
5304int32_t LuaScriptInterface::luaGetThingPosition(lua_State* L)
5305{
5306	//getThingPosition(uid)
5307	ScriptEnviroment* env = getEnv();
5308	if(Thing* thing = env->getThingByUID(popNumber(L)))
5309	{
5310		Position pos = thing->getPosition();
5311		uint32_t stackpos = 0;
5312		if(Tile* tile = thing->getTile())
5313			stackpos = tile->__getIndexOfThing(thing);
5314
5315		pushPosition(L, pos, stackpos);
5316	}
5317	else
5318	{
5319		errorEx(getError(LUA_ERROR_THING_NOT_FOUND));
5320		lua_pushboolean(L, false);
5321	}
5322
5323	return 1;
5324}
5325
5326int32_t LuaScriptInterface::luaCreateCombatObject(lua_State* L)
5327{
5328	//createCombatObject()
5329	ScriptEnviroment* env = getEnv();
5330	if(env->getScriptId() != EVENT_ID_LOADING)
5331	{
5332		errorEx("This function can only be used while loading the script.");
5333		lua_pushboolean(L, false);
5334		return 1;
5335	}
5336
5337	Combat* combat = new Combat;
5338	if(!combat)
5339	{
5340		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5341		lua_pushboolean(L, false);
5342		return 1;
5343	}
5344
5345	lua_pushnumber(L, env->addCombatObject(combat));
5346	return 1;
5347}
5348
5349bool LuaScriptInterface::getArea(lua_State* L, std::list<uint32_t>& list, uint32_t& rows)
5350{
5351	rows = 0;
5352	uint32_t i = 0;
5353
5354	lua_pushnil(L);
5355	while(lua_next(L, -2))
5356	{
5357		lua_pushnil(L);
5358		while(lua_next(L, -2))
5359		{
5360			list.push_back((uint32_t)lua_tonumber(L, -1));
5361			lua_pop(L, 1); //removes value, keeps key for next iteration
5362			++i;
5363		}
5364
5365		lua_pop(L, 1); //removes value, keeps key for next iteration
5366		++rows;
5367		i = 0;
5368	}
5369
5370	lua_pop(L, 1);
5371	return rows;
5372}
5373
5374int32_t LuaScriptInterface::luaCreateCombatArea(lua_State* L)
5375{
5376	//createCombatArea( {area}[, {extArea}])
5377	ScriptEnviroment* env = getEnv();
5378	if(env->getScriptId() != EVENT_ID_LOADING)
5379	{
5380		errorEx("This function can only be used while loading the script.");
5381		lua_pushboolean(L, false);
5382		return 1;
5383	}
5384
5385	CombatArea* area = new CombatArea;
5386	if(lua_gettop(L) > 1)
5387	{
5388		//has extra parameter with diagonal area information
5389		uint32_t rowsExtArea;
5390		std::list<uint32_t> listExtArea;
5391
5392		getArea(L, listExtArea, rowsExtArea);
5393		/*setup all possible rotations*/
5394		area->setupExtArea(listExtArea, rowsExtArea);
5395	}
5396
5397	if(lua_isnoneornil(L, -1)) //prevent crash
5398	{
5399		lua_pop(L, 2);
5400		lua_pushboolean(L, false);
5401		return 1;
5402	}
5403
5404	uint32_t rowsArea = 0;
5405	std::list<uint32_t> listArea;
5406	getArea(L, listArea, rowsArea);
5407
5408	area->setupArea(listArea, rowsArea);
5409	lua_pushnumber(L, env->addCombatArea(area));
5410	return 1;
5411}
5412
5413int32_t LuaScriptInterface::luaCreateConditionObject(lua_State* L)
5414{
5415	//createConditionObject(type[, ticks[, buff[, subId]]])
5416	uint32_t params = lua_gettop(L), subId = 0;
5417	if(params > 3)
5418		subId = popNumber(L);
5419
5420	bool buff = false;
5421	if(params > 2)
5422		buff = popNumber(L);
5423
5424	int32_t ticks = 0;
5425	if(params > 1)
5426		ticks = popNumber(L);
5427
5428	ScriptEnviroment* env = getEnv();
5429	if(env->getScriptId() != EVENT_ID_LOADING)
5430	{
5431		errorEx("This function can only be used while loading the script.");
5432		lua_pushboolean(L, false);
5433		return 1;
5434	}
5435
5436	if(Condition* condition = Condition::createCondition(CONDITIONID_COMBAT, (ConditionType_t)popNumber(L), ticks, 0, buff, subId))
5437		lua_pushnumber(L, env->addConditionObject(condition));
5438	else
5439	{
5440		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
5441		lua_pushboolean(L, false);
5442	}
5443
5444	return 1;
5445}
5446
5447int32_t LuaScriptInterface::luaSetCombatArea(lua_State* L)
5448{
5449	//setCombatArea(combat, area)
5450	uint32_t areaId = popNumber(L);
5451	ScriptEnviroment* env = getEnv();
5452	if(env->getScriptId() != EVENT_ID_LOADING)
5453	{
5454		errorEx("This function can only be used while loading the script.");
5455		lua_pushboolean(L, false);
5456		return 1;
5457	}
5458
5459	Combat* combat = env->getCombatObject(popNumber(L));
5460	if(!combat)
5461	{
5462		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5463		lua_pushboolean(L, false);
5464		return 1;
5465	}
5466
5467	const CombatArea* area = env->getCombatArea(areaId);
5468	if(!area)
5469	{
5470		errorEx(getError(LUA_ERROR_AREA_NOT_FOUND));
5471		lua_pushboolean(L, false);
5472		return 1;
5473	}
5474
5475	combat->setArea(new CombatArea(*area));
5476	lua_pushboolean(L, true);
5477	return 1;
5478}
5479
5480int32_t LuaScriptInterface::luaSetCombatCondition(lua_State* L)
5481{
5482	//setCombatCondition(combat, condition)
5483	uint32_t conditionId = popNumber(L);
5484	ScriptEnviroment* env = getEnv();
5485	if(env->getScriptId() != EVENT_ID_LOADING)
5486	{
5487		errorEx("This function can only be used while loading the script.");
5488		lua_pushboolean(L, false);
5489		return 1;
5490	}
5491
5492	Combat* combat = env->getCombatObject(popNumber(L));
5493	if(!combat)
5494	{
5495		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5496		lua_pushboolean(L, false);
5497		return 1;
5498	}
5499
5500	const Condition* condition = env->getConditionObject(conditionId);
5501	if(!condition)
5502	{
5503		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
5504		lua_pushboolean(L, false);
5505		return 1;
5506	}
5507
5508	combat->setCondition(condition->clone());
5509	lua_pushboolean(L, true);
5510	return 1;
5511}
5512
5513int32_t LuaScriptInterface::luaSetCombatParam(lua_State* L)
5514{
5515	//setCombatParam(combat, key, value)
5516	uint32_t value = popNumber(L);
5517	CombatParam_t key = (CombatParam_t)popNumber(L);
5518
5519	ScriptEnviroment* env = getEnv();
5520	if(env->getScriptId() != EVENT_ID_LOADING)
5521	{
5522		errorEx("This function can only be used while loading the script.");
5523		lua_pushboolean(L, false);
5524		return 1;
5525	}
5526
5527	Combat* combat = env->getCombatObject(popNumber(L));
5528	if(!combat)
5529	{
5530		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5531		lua_pushboolean(L, false);
5532	}
5533	else
5534	{
5535		combat->setParam(key, value);
5536		lua_pushboolean(L, true);
5537	}
5538	return 1;
5539}
5540
5541int32_t LuaScriptInterface::luaSetConditionParam(lua_State* L)
5542{
5543	//setConditionParam(condition, key, value)
5544	int32_t value = (int32_t)popNumber(L);
5545	ConditionParam_t key = (ConditionParam_t)popNumber(L);
5546
5547	ScriptEnviroment* env = getEnv();
5548	if(env->getScriptId() != EVENT_ID_LOADING)
5549	{
5550		errorEx("This function can only be used while loading the script.");
5551		lua_pushboolean(L, false);
5552		return 1;
5553	}
5554
5555	if(Condition* condition = env->getConditionObject(popNumber(L)))
5556	{
5557		condition->setParam(key, value);
5558		lua_pushboolean(L, true);
5559	}
5560	else
5561	{
5562		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
5563		lua_pushboolean(L, false);
5564	}
5565
5566	return 1;
5567}
5568
5569int32_t LuaScriptInterface::luaAddDamageCondition(lua_State* L)
5570{
5571	//addDamageCondition(condition, rounds, time, value)
5572	int32_t value = popNumber(L), time = popNumber(L), rounds = popNumber(L);
5573	ScriptEnviroment* env = getEnv();
5574	if(env->getScriptId() != EVENT_ID_LOADING)
5575	{
5576		errorEx("This function can only be used while loading the script.");
5577		lua_pushboolean(L, false);
5578		return 1;
5579	}
5580
5581	if(ConditionDamage* condition = dynamic_cast<ConditionDamage*>(env->getConditionObject(popNumber(L))))
5582	{
5583		condition->addDamage(rounds, time, value);
5584		lua_pushboolean(L, true);
5585	}
5586	else
5587	{
5588		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
5589		lua_pushboolean(L, false);
5590	}
5591
5592	return 1;
5593}
5594
5595int32_t LuaScriptInterface::luaAddOutfitCondition(lua_State* L)
5596{
5597	//addOutfitCondition(condition, outfit)
5598	Outfit_t outfit = popOutfit(L);
5599	ScriptEnviroment* env = getEnv();
5600	if(env->getScriptId() != EVENT_ID_LOADING)
5601	{
5602		errorEx("This function can only be used while loading the script.");
5603		lua_pushboolean(L, false);
5604		return 1;
5605	}
5606
5607	if(ConditionOutfit* condition = dynamic_cast<ConditionOutfit*>(env->getConditionObject(popNumber(L))))
5608	{
5609		condition->addOutfit(outfit);
5610		lua_pushboolean(L, true);
5611	}
5612	else
5613	{
5614		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
5615		lua_pushboolean(L, false);
5616	}
5617
5618	return 1;
5619}
5620
5621int32_t LuaScriptInterface::luaSetCombatCallBack(lua_State* L)
5622{
5623	//setCombatCallBack(combat, key, functionName)
5624	std::string function = popString(L);
5625	CallBackParam_t key = (CallBackParam_t)popNumber(L);
5626
5627	ScriptEnviroment* env = getEnv();
5628	if(env->getScriptId() != EVENT_ID_LOADING)
5629	{
5630		errorEx("This function can only be used while loading the script.");
5631		lua_pushboolean(L, false);
5632		return 1;
5633	}
5634
5635	Combat* combat = env->getCombatObject(popNumber(L));
5636	if(!combat)
5637	{
5638		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5639		lua_pushboolean(L, false);
5640		return 1;
5641	}
5642
5643	LuaScriptInterface* interface = env->getInterface();
5644	combat->setCallback(key);
5645
5646	CallBack* callback = combat->getCallback(key);
5647	if(!callback)
5648	{
5649		std::stringstream ss;
5650		ss << key;
5651
5652		errorEx(ss.str() + " is not a valid callback key.");
5653		lua_pushboolean(L, false);
5654		return 1;
5655	}
5656
5657	if(!callback->loadCallBack(interface, function))
5658	{
5659		errorEx("Cannot load callback");
5660		lua_pushboolean(L, false);
5661	}
5662	else
5663		lua_pushboolean(L, true);
5664
5665	return 1;
5666}
5667
5668int32_t LuaScriptInterface::luaSetCombatFormula(lua_State* L)
5669{
5670	//setCombatFormula(combat, type, mina, minb, maxa, maxb[, minl, maxl[, minm, maxm[, minc[, maxc]]]])
5671	ScriptEnviroment* env = getEnv();
5672	if(env->getScriptId() != EVENT_ID_LOADING)
5673	{
5674		errorEx("This function can only be used while loading the script.");
5675		lua_pushboolean(L, false);
5676		return 1;
5677	}
5678
5679	int32_t params = lua_gettop(L), minc = 0, maxc = 0;
5680	if(params > 11)
5681		maxc = popNumber(L);
5682
5683	if(params > 10)
5684		minc = popNumber(L);
5685
5686	double minm = g_config.getDouble(ConfigManager::FORMULA_MAGIC), maxm = minm,
5687		minl = g_config.getDouble(ConfigManager::FORMULA_LEVEL), maxl = minl;
5688	if(params > 8)
5689	{
5690		maxm = popFloatNumber(L);
5691		minm = popFloatNumber(L);
5692	}
5693
5694	if(params > 6)
5695	{
5696		maxl = popFloatNumber(L);
5697		minl = popFloatNumber(L);
5698	}
5699
5700	double maxb = popFloatNumber(L), maxa = popFloatNumber(L),
5701		minb = popFloatNumber(L), mina = popFloatNumber(L);
5702	formulaType_t type = (formulaType_t)popNumber(L);
5703	if(Combat* combat = env->getCombatObject(popNumber(L)))
5704	{
5705		combat->setPlayerCombatValues(type, mina, minb, maxa, maxb, minl, maxl, minm, maxm, minc, maxc);
5706		lua_pushboolean(L, true);
5707	}
5708	else
5709	{
5710		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5711		lua_pushboolean(L, false);
5712	}
5713
5714	return 1;
5715}
5716
5717int32_t LuaScriptInterface::luaSetConditionFormula(lua_State* L)
5718{
5719	//setConditionFormula(condition, mina, minb, maxa, maxb)
5720	ScriptEnviroment* env = getEnv();
5721	if(env->getScriptId() != EVENT_ID_LOADING)
5722	{
5723		errorEx("This function can only be used while loading the script.");
5724		lua_pushboolean(L, false);
5725		return 1;
5726	}
5727
5728	double maxb = popFloatNumber(L), maxa = popFloatNumber(L),
5729		minb = popFloatNumber(L), mina = popFloatNumber(L);
5730
5731	if(ConditionSpeed* condition = dynamic_cast<ConditionSpeed*>(env->getConditionObject(popNumber(L))))
5732	{
5733		condition->setFormulaVars(mina, minb, maxa, maxb);
5734		lua_pushboolean(L, true);
5735	}
5736	else
5737	{
5738		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
5739		lua_pushboolean(L, false);
5740	}
5741
5742	return 1;
5743}
5744
5745int32_t LuaScriptInterface::luaDoCombat(lua_State* L)
5746{
5747	//doCombat(cid, combat, param)
5748	ScriptEnviroment* env = getEnv();
5749
5750	LuaVariant var = popVariant(L);
5751	uint32_t combatId = popNumber(L), cid = popNumber(L);
5752
5753	Creature* creature = NULL;
5754	if(cid != 0)
5755	{
5756		creature = env->getCreatureByUID(cid);
5757		if(!creature)
5758		{
5759			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5760			lua_pushboolean(L, false);
5761			return 1;
5762		}
5763	}
5764
5765	const Combat* combat = env->getCombatObject(combatId);
5766	if(!combat)
5767	{
5768		errorEx(getError(LUA_ERROR_COMBAT_NOT_FOUND));
5769		lua_pushboolean(L, false);
5770		return 1;
5771	}
5772
5773	if(var.type == VARIANT_NONE)
5774	{
5775		errorEx(getError(LUA_ERROR_VARIANT_NOT_FOUND));
5776		lua_pushboolean(L, false);
5777		return 1;
5778	}
5779
5780	switch(var.type)
5781	{
5782		case VARIANT_NUMBER:
5783		{
5784			Creature* target = g_game.getCreatureByID(var.number);
5785			if(!target || !creature || !creature->canSeeCreature(target))
5786			{
5787				lua_pushboolean(L, false);
5788				return 1;
5789			}
5790
5791			if(combat->hasArea())
5792				combat->doCombat(creature, target->getPosition());
5793			else
5794				combat->doCombat(creature, target);
5795
5796			break;
5797		}
5798
5799		case VARIANT_POSITION:
5800		{
5801			combat->doCombat(creature, var.pos);
5802			break;
5803		}
5804
5805		case VARIANT_TARGETPOSITION:
5806		{
5807			if(!combat->hasArea())
5808			{
5809				combat->postCombatEffects(creature, var.pos);
5810				g_game.addMagicEffect(var.pos, MAGIC_EFFECT_POFF);
5811			}
5812			else
5813				combat->doCombat(creature, var.pos);
5814
5815			break;
5816		}
5817
5818		case VARIANT_STRING:
5819		{
5820			Player* target = g_game.getPlayerByName(var.text);
5821			if(!target || !creature || !creature->canSeeCreature(target))
5822			{
5823				lua_pushboolean(L, false);
5824				return 1;
5825			}
5826
5827			combat->doCombat(creature, target);
5828			break;
5829		}
5830
5831		default:
5832		{
5833			errorEx(getError(LUA_ERROR_VARIANT_UNKNOWN));
5834			lua_pushboolean(L, false);
5835			return 1;
5836		}
5837	}
5838
5839	lua_pushboolean(L, true);
5840	return 1;
5841}
5842
5843int32_t LuaScriptInterface::luaDoCombatAreaHealth(lua_State* L)
5844{
5845	//doCombatAreaHealth(cid, type, pos, area, min, max, effect)
5846	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
5847	int32_t maxChange = (int32_t)popNumber(L), minChange = (int32_t)popNumber(L);
5848	uint32_t areaId = popNumber(L);
5849
5850	PositionEx pos;
5851	popPosition(L, pos);
5852
5853	CombatType_t combatType = (CombatType_t)popNumber(L);
5854	uint32_t cid = popNumber(L);
5855
5856	ScriptEnviroment* env = getEnv();
5857	Creature* creature = NULL;
5858	if(cid)
5859	{
5860		if(!(creature = env->getCreatureByUID(cid)))
5861		{
5862			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5863			lua_pushboolean(L, false);
5864			return 1;
5865		}
5866	}
5867
5868	const CombatArea* area = env->getCombatArea(areaId);
5869	if(area || !areaId)
5870	{
5871		CombatParams params;
5872		params.combatType = combatType;
5873		params.effects.impact = effect;
5874
5875		Combat::doCombatHealth(creature, pos, area, minChange, maxChange, params);
5876		lua_pushboolean(L, true);
5877	}
5878	else
5879	{
5880		errorEx(getError(LUA_ERROR_AREA_NOT_FOUND));
5881		lua_pushboolean(L, false);
5882	}
5883
5884	return 1;
5885}
5886
5887int32_t LuaScriptInterface::luaDoTargetCombatHealth(lua_State* L)
5888{
5889	//doTargetCombatHealth(cid, target, type, min, max, effect)
5890	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
5891	int32_t maxChange = (int32_t)popNumber(L), minChange = (int32_t)popNumber(L);
5892
5893	CombatType_t combatType = (CombatType_t)popNumber(L);
5894	uint32_t targetCid = popNumber(L), cid = popNumber(L);
5895
5896	ScriptEnviroment* env = getEnv();
5897	Creature* creature = NULL;
5898	if(cid)
5899	{
5900		if(!(creature = env->getCreatureByUID(cid)))
5901		{
5902			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5903			lua_pushboolean(L, false);
5904			return 1;
5905		}
5906	}
5907
5908	Creature* target = env->getCreatureByUID(targetCid);
5909	if(target)
5910	{
5911		CombatParams params;
5912		params.combatType = combatType;
5913		params.effects.impact = effect;
5914
5915		Combat::doCombatHealth(creature, target, minChange, maxChange, params);
5916		lua_pushboolean(L, true);
5917	}
5918	else
5919	{
5920		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5921		lua_pushboolean(L, false);
5922	}
5923
5924	return 1;
5925}
5926
5927int32_t LuaScriptInterface::luaDoCombatAreaMana(lua_State* L)
5928{
5929	//doCombatAreaMana(cid, pos, area, min, max, effect)
5930	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
5931	int32_t maxChange = (int32_t)popNumber(L), minChange = (int32_t)popNumber(L);
5932	uint32_t areaId = popNumber(L);
5933
5934	PositionEx pos;
5935	popPosition(L, pos);
5936	uint32_t cid = popNumber(L);
5937
5938	ScriptEnviroment* env = getEnv();
5939	Creature* creature = NULL;
5940	if(cid)
5941	{
5942		if(!(creature = env->getCreatureByUID(cid)))
5943		{
5944			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5945			lua_pushboolean(L, false);
5946			return 1;
5947		}
5948	}
5949
5950	const CombatArea* area = env->getCombatArea(areaId);
5951	if(area || !areaId)
5952	{
5953		CombatParams params;
5954		params.effects.impact = effect;
5955
5956		Combat::doCombatMana(creature, pos, area, minChange, maxChange, params);
5957		lua_pushboolean(L, true);
5958	}
5959	else
5960	{
5961		errorEx(getError(LUA_ERROR_AREA_NOT_FOUND));
5962		lua_pushboolean(L, false);
5963	}
5964
5965	return 1;
5966}
5967
5968int32_t LuaScriptInterface::luaDoTargetCombatMana(lua_State* L)
5969{
5970	//doTargetCombatMana(cid, target, min, max, effect)
5971	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
5972	int32_t maxChange = (int32_t)popNumber(L), minChange = (int32_t)popNumber(L);
5973	uint32_t targetCid = popNumber(L), cid = popNumber(L);
5974
5975	ScriptEnviroment* env = getEnv();
5976	Creature* creature = NULL;
5977	if(cid)
5978	{
5979		if(!(creature = env->getCreatureByUID(cid)))
5980		{
5981			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5982			lua_pushboolean(L, false);
5983			return 1;
5984		}
5985	}
5986
5987	if(Creature* target = env->getCreatureByUID(targetCid))
5988	{
5989		CombatParams params;
5990		params.effects.impact = effect;
5991
5992		Combat::doCombatMana(creature, target, minChange, maxChange, params);
5993		lua_pushboolean(L, true);
5994	}
5995	else
5996	{
5997		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
5998		lua_pushboolean(L, false);
5999	}
6000
6001	return 1;
6002}
6003
6004int32_t LuaScriptInterface::luaDoCombatAreaCondition(lua_State* L)
6005{
6006	//doCombatAreaCondition(cid, pos, area, condition, effect)
6007	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
6008	uint32_t conditionId = popNumber(L), areaId = popNumber(L);
6009
6010	PositionEx pos;
6011	popPosition(L, pos);
6012	uint32_t cid = popNumber(L);
6013
6014	ScriptEnviroment* env = getEnv();
6015	Creature* creature = NULL;
6016	if(cid)
6017	{
6018		if(!(creature = env->getCreatureByUID(cid)))
6019		{
6020			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6021			lua_pushboolean(L, false);
6022			return 1;
6023		}
6024	}
6025
6026	if(const Condition* condition = env->getConditionObject(conditionId))
6027	{
6028		const CombatArea* area = env->getCombatArea(areaId);
6029		if(area || !areaId)
6030		{
6031			CombatParams params;
6032			params.effects.impact = effect;
6033			params.conditionList.push_back(condition);
6034			Combat::doCombatCondition(creature, pos, area, params);
6035
6036			lua_pushboolean(L, true);
6037		}
6038		else
6039		{
6040			errorEx(getError(LUA_ERROR_AREA_NOT_FOUND));
6041			lua_pushboolean(L, false);
6042		}
6043	}
6044	else
6045	{
6046		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
6047		lua_pushboolean(L, false);
6048	}
6049
6050	return 1;
6051}
6052
6053int32_t LuaScriptInterface::luaDoTargetCombatCondition(lua_State* L)
6054{
6055	//doTargetCombatCondition(cid, target, condition, effect)
6056	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
6057	uint32_t conditionId = popNumber(L), targetCid = popNumber(L), cid = popNumber(L);
6058
6059	ScriptEnviroment* env = getEnv();
6060	Creature* creature = NULL;
6061	if(cid)
6062	{
6063		if(!(creature = env->getCreatureByUID(cid)))
6064		{
6065			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6066			lua_pushboolean(L, false);
6067			return 1;
6068		}
6069	}
6070
6071	if(Creature* target = env->getCreatureByUID(targetCid))
6072	{
6073		if(const Condition* condition = env->getConditionObject(conditionId))
6074		{
6075			CombatParams params;
6076			params.effects.impact = effect;
6077			params.conditionList.push_back(condition);
6078
6079			Combat::doCombatCondition(creature, target, params);
6080			lua_pushboolean(L, true);
6081		}
6082		else
6083		{
6084			errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
6085			lua_pushboolean(L, false);
6086		}
6087	}
6088	else
6089	{
6090		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6091		lua_pushboolean(L, false);
6092	}
6093
6094	return 1;
6095}
6096
6097int32_t LuaScriptInterface::luaDoCombatAreaDispel(lua_State* L)
6098{
6099	//doCombatAreaDispel(cid, pos, area, type, effect)
6100	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
6101	ConditionType_t dispelType = (ConditionType_t)popNumber(L);
6102	uint32_t areaId = popNumber(L);
6103
6104	PositionEx pos;
6105	popPosition(L, pos);
6106	uint32_t cid = popNumber(L);
6107
6108	ScriptEnviroment* env = getEnv();
6109	Creature* creature = NULL;
6110	if(cid)
6111	{
6112		if(!(creature = env->getCreatureByUID(cid)))
6113		{
6114			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6115			lua_pushboolean(L, false);
6116			return 1;
6117		}
6118	}
6119
6120	const CombatArea* area = env->getCombatArea(areaId);
6121	if(area || !areaId)
6122	{
6123		CombatParams params;
6124		params.effects.impact = effect;
6125		params.dispelType = dispelType;
6126
6127		Combat::doCombatDispel(creature, pos, area, params);
6128		lua_pushboolean(L, true);
6129	}
6130	else
6131	{
6132		errorEx(getError(LUA_ERROR_AREA_NOT_FOUND));
6133		lua_pushboolean(L, false);
6134	}
6135
6136	return 1;
6137}
6138
6139int32_t LuaScriptInterface::luaDoTargetCombatDispel(lua_State* L)
6140{
6141	//doTargetCombatDispel(cid, target, type, effect)
6142	MagicEffect_t effect = (MagicEffect_t)popNumber(L);
6143	ConditionType_t dispelType = (ConditionType_t)popNumber(L);
6144	uint32_t targetCid = popNumber(L), cid = popNumber(L);
6145
6146	ScriptEnviroment* env = getEnv();
6147	Creature* creature = NULL;
6148	if(cid)
6149	{
6150		if(!(creature = env->getCreatureByUID(cid)))
6151		{
6152			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6153			lua_pushboolean(L, false);
6154			return 1;
6155		}
6156	}
6157
6158	if(Creature* target = env->getCreatureByUID(targetCid))
6159	{
6160		CombatParams params;
6161		params.effects.impact = effect;
6162		params.dispelType = dispelType;
6163
6164		Combat::doCombatDispel(creature, target, params);
6165		lua_pushboolean(L, true);
6166	}
6167	else
6168	{
6169		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6170		lua_pushboolean(L, false);
6171	}
6172
6173	return 1;
6174}
6175
6176int32_t LuaScriptInterface::luaDoChallengeCreature(lua_State* L)
6177{
6178	//doChallengeCreature(cid, target)
6179	ScriptEnviroment* env = getEnv();
6180	uint32_t targetCid = popNumber(L);
6181
6182	Creature* creature = env->getCreatureByUID(popNumber(L));
6183	if(!creature)
6184	{
6185		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6186		lua_pushboolean(L, false);
6187		return 1;
6188	}
6189
6190	Creature* target = env->getCreatureByUID(targetCid);
6191	if(!target)
6192	{
6193		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6194		lua_pushboolean(L, false);
6195		return 1;
6196	}
6197
6198	target->challengeCreature(creature);
6199	lua_pushboolean(L, true);
6200	return 1;
6201}
6202
6203int32_t LuaScriptInterface::luaDoSummonMonster(lua_State* L)
6204{
6205	//doSummonMonster(cid, name)
6206	std::string name = popString(L);
6207
6208	ScriptEnviroment* env = getEnv();
6209	Creature* creature = env->getCreatureByUID(popNumber(L));
6210	if(!creature)
6211	{
6212		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6213		lua_pushboolean(L, false);
6214		return 1;
6215	}
6216
6217	lua_pushnumber(L, g_game.placeSummon(creature, name));
6218	return 1;
6219}
6220
6221int32_t LuaScriptInterface::luaDoConvinceCreature(lua_State* L)
6222{
6223	//doConvinceCreature(cid, target)
6224	uint32_t cid = popNumber(L);
6225
6226	ScriptEnviroment* env = getEnv();
6227	Creature* creature = env->getCreatureByUID(popNumber(L));
6228	if(!creature)
6229	{
6230		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6231		lua_pushboolean(L, false);
6232		return 1;
6233	}
6234
6235	Creature* target = env->getCreatureByUID(cid);
6236	if(!target)
6237	{
6238		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6239		lua_pushboolean(L, false);
6240		return 1;
6241	}
6242
6243	target->convinceCreature(creature);
6244	lua_pushboolean(L, true);
6245	return 1;
6246}
6247
6248int32_t LuaScriptInterface::luaGetMonsterTargetList(lua_State* L)
6249{
6250	//getMonsterTargetList(cid)
6251	ScriptEnviroment* env = getEnv();
6252	Creature* creature = env->getCreatureByUID(popNumber(L));
6253	if(!creature)
6254	{
6255		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6256		lua_pushboolean(L, false);
6257		return 1;
6258	}
6259
6260	Monster* monster = creature->getMonster();
6261	if(!monster)
6262	{
6263		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6264		lua_pushboolean(L, false);
6265		return 1;
6266	}
6267
6268	const CreatureList& targetList = monster->getTargetList();
6269	CreatureList::const_iterator it = targetList.begin();
6270
6271	lua_newtable(L);
6272	for(uint32_t i = 1; it != targetList.end(); ++it, ++i)
6273	{
6274		if(monster->isTarget(*it))
6275		{
6276			lua_pushnumber(L, i);
6277			lua_pushnumber(L, env->addThing(*it));
6278			pushTable(L);
6279		}
6280	}
6281
6282	return 1;
6283}
6284
6285int32_t LuaScriptInterface::luaGetMonsterFriendList(lua_State* L)
6286{
6287	//getMonsterFriendList(cid)
6288	ScriptEnviroment* env = getEnv();
6289	Creature* creature = env->getCreatureByUID(popNumber(L));
6290	if(!creature)
6291	{
6292		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6293		lua_pushboolean(L, false);
6294		return 1;
6295	}
6296
6297	Monster* monster = creature->getMonster();
6298	if(!monster)
6299	{
6300		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6301		lua_pushboolean(L, false);
6302		return 1;
6303	}
6304
6305	Creature* friendCreature;
6306	const CreatureList& friendList = monster->getFriendList();
6307	CreatureList::const_iterator it = friendList.begin();
6308
6309	lua_newtable(L);
6310	for(uint32_t i = 1; it != friendList.end(); ++it, ++i)
6311	{
6312		friendCreature = (*it);
6313		if(!friendCreature->isRemoved() && friendCreature->getPosition().z == monster->getPosition().z)
6314		{
6315			lua_pushnumber(L, i);
6316			lua_pushnumber(L, env->addThing(*it));
6317			pushTable(L);
6318		}
6319	}
6320
6321	return 1;
6322}
6323
6324int32_t LuaScriptInterface::luaDoMonsterSetTarget(lua_State* L)
6325{
6326	//doMonsterSetTarget(cid, target)
6327	uint32_t targetId = popNumber(L);
6328	ScriptEnviroment* env = getEnv();
6329
6330	Creature* creature = env->getCreatureByUID(popNumber(L));
6331	if(!creature)
6332	{
6333		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6334		lua_pushboolean(L, false);
6335		return 1;
6336	}
6337
6338	Monster* monster = creature->getMonster();
6339	if(!monster)
6340	{
6341		errorEx(getError(LUA_ERROR_MONSTER_NOT_FOUND));
6342		lua_pushboolean(L, false);
6343		return 1;
6344	}
6345
6346	Creature* target = env->getCreatureByUID(targetId);
6347	if(!target)
6348	{
6349		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6350		lua_pushboolean(L, false);
6351		return 1;
6352	}
6353
6354	if(!monster->isSummon())
6355		lua_pushboolean(L, monster->selectTarget(target));
6356	else
6357		lua_pushboolean(L, false);
6358
6359	return 1;
6360}
6361
6362int32_t LuaScriptInterface::luaDoMonsterChangeTarget(lua_State* L)
6363{
6364	//doMonsterChangeTarget(cid)
6365	ScriptEnviroment* env = getEnv();
6366	Creature* creature = env->getCreatureByUID(popNumber(L));
6367	if(!creature)
6368	{
6369		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6370		lua_pushboolean(L, false);
6371		return 1;
6372	}
6373
6374	Monster* monster = creature->getMonster();
6375	if(!monster)
6376	{
6377		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6378		lua_pushboolean(L, false);
6379		return 1;
6380	}
6381
6382	if(!monster->isSummon())
6383		monster->searchTarget(TARGETSEARCH_RANDOM);
6384
6385	lua_pushboolean(L, true);
6386	return 1;
6387}
6388
6389int32_t LuaScriptInterface::luaGetMonsterInfo(lua_State* L)
6390{
6391	//getMonsterInfo(name)
6392	const MonsterType* mType = g_monsters.getMonsterType(popString(L));
6393	if(!mType)
6394	{
6395		errorEx(getError(LUA_ERROR_MONSTER_NOT_FOUND));
6396		lua_pushboolean(L, false);
6397		return 1;
6398	}
6399
6400	lua_newtable(L);
6401	setField(L, "name", mType->name.c_str());
6402	setField(L, "description", mType->nameDescription.c_str());
6403	setField(L, "experience", mType->experience);
6404	setField(L, "health", mType->health);
6405	setField(L, "healthMax", mType->healthMax);
6406	setField(L, "manaCost", mType->manaCost);
6407	setField(L, "defense", mType->defense);
6408	setField(L, "armor", mType->armor);
6409	setField(L, "baseSpeed", mType->baseSpeed);
6410	setField(L, "lookCorpse", mType->lookCorpse);
6411	setField(L, "race", mType->race);
6412	setField(L, "skull", mType->skull);
6413	setField(L, "partyShield", mType->partyShield);
6414	setFieldBool(L, "summonable", mType->isSummonable);
6415	setFieldBool(L, "illusionable", mType->isIllusionable);
6416	setFieldBool(L, "convinceable", mType->isConvinceable);
6417	setFieldBool(L, "attackable", mType->isAttackable);
6418	setFieldBool(L, "hostile", mType->isHostile);
6419	createTable(L, "defenses");
6420
6421	SpellList::const_iterator it = mType->spellDefenseList.begin();
6422	for(uint32_t i = 1; it != mType->spellDefenseList.end(); ++it, ++i)
6423	{
6424		createTable(L, i);
6425		setField(L, "speed", it->speed);
6426		setField(L, "chance", it->chance);
6427		setField(L, "range", it->range);
6428
6429		setField(L, "minCombatValue", it->minCombatValue);
6430		setField(L, "maxCombatValue", it->maxCombatValue);
6431		setFieldBool(L, "isMelee", it->isMelee);
6432		pushTable(L);
6433	}
6434
6435	pushTable(L);
6436	createTable(L, "attacks");
6437
6438	it = mType->spellAttackList.begin();
6439	for(uint32_t i = 1; it != mType->spellAttackList.end(); ++it, ++i)
6440	{
6441		createTable(L, i);
6442		setField(L, "speed", it->speed);
6443		setField(L, "chance", it->chance);
6444		setField(L, "range", it->range);
6445
6446		setField(L, "minCombatValue", it->minCombatValue);
6447		setField(L, "maxCombatValue", it->maxCombatValue);
6448		setFieldBool(L, "isMelee", it->isMelee);
6449		pushTable(L);
6450	}
6451
6452	pushTable(L);
6453	createTable(L, "loot");
6454
6455	LootItems::const_iterator lit = mType->lootItems.begin();
6456	for(uint32_t i = 1; lit != mType->lootItems.end(); ++lit, ++i)
6457	{
6458		createTable(L, i);
6459		if(lit->ids.size() > 1)
6460		{
6461			createTable(L, "ids");
6462			std::vector<uint16_t>::const_iterator iit = lit->ids.begin();
6463			for(uint32_t j = 1; iit != lit->ids.end(); ++iit, ++j)
6464			{
6465				lua_pushnumber(L, j);
6466				lua_pushnumber(L, (*iit));
6467				pushTable(L);
6468			}
6469
6470			pushTable(L);
6471		}
6472		else
6473			setField(L, "id", lit->ids[0]);
6474
6475		setField(L, "count", lit->count);
6476		setField(L, "chance", lit->chance);
6477		setField(L, "subType", lit->subType);
6478		setField(L, "actionId", lit->actionId);
6479		setField(L, "uniqueId", lit->uniqueId);
6480		setField(L, "text", lit->text);
6481
6482		if(lit->childLoot.size() > 0)
6483		{
6484			createTable(L, "child");
6485			LootItems::const_iterator cit = lit->childLoot.begin();
6486			for(uint32_t j = 1; cit != lit->childLoot.end(); ++cit, ++j)
6487			{
6488				createTable(L, j);
6489				if(cit->ids.size() > 1)
6490				{
6491					createTable(L, "ids");
6492					std::vector<uint16_t>::const_iterator iit = cit->ids.begin();
6493					for(uint32_t k = 1; iit != cit->ids.end(); ++iit, ++k)
6494					{
6495						lua_pushnumber(L, k);
6496						lua_pushnumber(L, (*iit));
6497						pushTable(L);
6498					}
6499
6500					pushTable(L);
6501				}
6502				else
6503					setField(L, "id", cit->ids[0]);
6504
6505				setField(L, "count", cit->count);
6506				setField(L, "chance", cit->chance);
6507				setField(L, "subType", cit->subType);
6508				setField(L, "actionId", cit->actionId);
6509				setField(L, "uniqueId", cit->uniqueId);
6510				setField(L, "text", cit->text);
6511
6512				pushTable(L);
6513			}
6514
6515			pushTable(L);
6516		}
6517
6518		pushTable(L);
6519	}
6520
6521	pushTable(L);
6522	createTable(L, "summons");
6523
6524	SummonList::const_iterator sit = mType->summonList.begin();
6525	for(uint32_t i = 1; sit != mType->summonList.end(); ++sit, ++i)
6526	{
6527		createTable(L, i);
6528		setField(L, "name", sit->name);
6529		setField(L, "chance", sit->chance);
6530
6531		setField(L, "interval", sit->interval);
6532		setField(L, "amount", sit->amount);
6533		pushTable(L);
6534	}
6535
6536	pushTable(L);
6537	return 1;
6538}
6539
6540int32_t LuaScriptInterface::luaGetTalkActionList(lua_State* L)
6541{
6542	//getTalkactionList()
6543	TalkActionsMap::const_iterator it = g_talkActions->getFirstTalk();
6544	lua_newtable(L);
6545	for(uint32_t i = 1; it != g_talkActions->getLastTalk(); ++it, ++i)
6546	{
6547		createTable(L, i);
6548		setField(L, "words", it->first);
6549		setField(L, "access", it->second->getAccess());
6550
6551		setFieldBool(L, "log", it->second->isLogged());
6552		setFieldBool(L, "hide", it->second->isHidden());
6553
6554		setField(L, "channel", it->second->getChannel());
6555		pushTable(L);
6556	}
6557
6558	return 1;
6559}
6560
6561int32_t LuaScriptInterface::luaGetExperienceStageList(lua_State* L)
6562{
6563	//getExperienceStageList()
6564	if(!g_config.getBool(ConfigManager::EXPERIENCE_STAGES))
6565	{
6566		lua_pushboolean(L, false);
6567		return true;
6568	}
6569
6570	StageList::const_iterator it = g_game.getFirstStage();
6571	lua_newtable(L);
6572	for(uint32_t i = 1; it != g_game.getLastStage(); ++it, ++i)
6573	{
6574		createTable(L, i);
6575		setField(L, "level", it->first);
6576		setFieldFloat(L, "multiplier", it->second);
6577		pushTable(L);
6578	}
6579
6580	return 1;
6581}
6582
6583int32_t LuaScriptInterface::luaDoAddCondition(lua_State* L)
6584{
6585	//doAddCondition(cid, condition)
6586	uint32_t conditionId = popNumber(L);
6587
6588	ScriptEnviroment* env = getEnv();
6589	Creature* creature = env->getCreatureByUID(popNumber(L));
6590	if(!creature)
6591	{
6592		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6593		lua_pushboolean(L, false);
6594		return 1;
6595	}
6596
6597	Condition* condition = env->getConditionObject(conditionId);
6598	if(!condition)
6599	{
6600		errorEx(getError(LUA_ERROR_CONDITION_NOT_FOUND));
6601		lua_pushboolean(L, false);
6602		return 1;
6603	}
6604
6605	creature->addCondition(condition->clone());
6606	lua_pushboolean(L, true);
6607	return 1;
6608}
6609
6610int32_t LuaScriptInterface::luaDoRemoveCondition(lua_State* L)
6611{
6612	//doRemoveCondition(cid, type[, subId])
6613	uint32_t subId = 0;
6614	if(lua_gettop(L) > 2)
6615		subId = popNumber(L);
6616
6617	ConditionType_t conditionType = (ConditionType_t)popNumber(L);
6618
6619	ScriptEnviroment* env = getEnv();
6620	Creature* creature = env->getCreatureByUID(popNumber(L));
6621	if(!creature)
6622	{
6623		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6624		lua_pushboolean(L, false);
6625		return 1;
6626	}
6627
6628	Condition* condition = creature->getCondition(conditionType, CONDITIONID_COMBAT, subId);
6629	if(!condition)
6630		condition = creature->getCondition(conditionType, CONDITIONID_DEFAULT, subId);
6631
6632	if(condition)
6633		creature->removeCondition(condition);
6634
6635	lua_pushboolean(L, true);
6636	return 1;
6637}
6638
6639int32_t LuaScriptInterface::luaDoRemoveConditions(lua_State* L)
6640{
6641	//doRemoveConditions(cid[, onlyPersistent])
6642	bool onlyPersistent = true;
6643	if(lua_gettop(L) > 1)
6644		onlyPersistent = popNumber(L);
6645
6646	ScriptEnviroment* env = getEnv();
6647	Creature* creature = env->getCreatureByUID(popNumber(L));
6648	if(!creature)
6649	{
6650		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6651		lua_pushboolean(L, false);
6652		return 1;
6653	}
6654
6655	creature->removeConditions(CONDITIONEND_ABORT, onlyPersistent);
6656	lua_pushboolean(L, true);
6657	return 1;
6658}
6659
6660int32_t LuaScriptInterface::luaNumberToVariant(lua_State* L)
6661{
6662	//numberToVariant(number)
6663	LuaVariant var;
6664	var.type = VARIANT_NUMBER;
6665	var.number = popNumber(L);
6666
6667	LuaScriptInterface::pushVariant(L, var);
6668	return 1;
6669}
6670
6671int32_t LuaScriptInterface::luaStringToVariant(lua_State* L)
6672{
6673	//stringToVariant(string)
6674	LuaVariant var;
6675	var.type = VARIANT_STRING;
6676	var.text = popString(L);
6677
6678	LuaScriptInterface::pushVariant(L, var);
6679	return 1;
6680}
6681
6682int32_t LuaScriptInterface::luaPositionToVariant(lua_State* L)
6683{
6684	//positionToVariant(pos)
6685	LuaVariant var;
6686	var.type = VARIANT_POSITION;
6687	popPosition(L, var.pos);
6688
6689	LuaScriptInterface::pushVariant(L, var);
6690	return 1;
6691}
6692
6693int32_t LuaScriptInterface::luaTargetPositionToVariant(lua_State* L)
6694{
6695	//targetPositionToVariant(pos)
6696	LuaVariant var;
6697	var.type = VARIANT_TARGETPOSITION;
6698	popPosition(L, var.pos);
6699
6700	LuaScriptInterface::pushVariant(L, var);
6701	return 1;
6702}
6703
6704int32_t LuaScriptInterface::luaVariantToNumber(lua_State* L)
6705{
6706	//variantToNumber(var)
6707	LuaVariant var = popVariant(L);
6708
6709	uint32_t number = 0;
6710	if(var.type == VARIANT_NUMBER)
6711		number = var.number;
6712
6713	lua_pushnumber(L, number);
6714	return 1;
6715}
6716
6717int32_t LuaScriptInterface::luaVariantToString(lua_State* L)
6718{
6719	//variantToString(var)
6720	LuaVariant var = popVariant(L);
6721
6722	std::string text = "";
6723	if(var.type == VARIANT_STRING)
6724		text = var.text;
6725
6726	lua_pushstring(L, text.c_str());
6727	return 1;
6728}
6729
6730int32_t LuaScriptInterface::luaVariantToPosition(lua_State* L)
6731{
6732	//luaVariantToPosition(var)
6733	LuaVariant var = popVariant(L);
6734
6735	PositionEx pos(0, 0, 0, 0);
6736	if(var.type == VARIANT_POSITION || var.type == VARIANT_TARGETPOSITION)
6737		pos = var.pos;
6738
6739	pushPosition(L, pos, pos.stackpos);
6740	return 1;
6741}
6742
6743int32_t LuaScriptInterface::luaDoChangeSpeed(lua_State* L)
6744{
6745	//doChangeSpeed(cid, delta)
6746	int32_t delta = (int32_t)popNumber(L);
6747
6748	ScriptEnviroment* env = getEnv();
6749	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
6750	{
6751		g_game.changeSpeed(creature, delta);
6752		lua_pushboolean(L, true);
6753	}
6754	else
6755	{
6756		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6757		lua_pushboolean(L, false);
6758	}
6759	return 1;
6760}
6761
6762int32_t LuaScriptInterface::luaSetCreatureOutfit(lua_State* L)
6763{
6764	//doSetCreatureOutfit(cid, outfit, time)
6765	int32_t time = (int32_t)popNumber(L);
6766	Outfit_t outfit = popOutfit(L);
6767
6768	ScriptEnviroment* env = getEnv();
6769	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
6770		lua_pushboolean(L, Spell::CreateIllusion(creature, outfit, time) == RET_NOERROR);
6771	else
6772	{
6773		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6774		lua_pushboolean(L, false);
6775	}
6776	return 1;
6777}
6778
6779int32_t LuaScriptInterface::luaGetCreatureOutfit(lua_State* L)
6780{
6781	//getCreatureOutfit(cid)
6782	ScriptEnviroment* env = getEnv();
6783	if(const Creature* creature = env->getCreatureByUID(popNumber(L)))
6784		pushOutfit(L, creature->getCurrentOutfit());
6785	else
6786	{
6787		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6788		lua_pushboolean(L, false);
6789	}
6790	return 1;
6791}
6792
6793int32_t LuaScriptInterface::luaSetMonsterOutfit(lua_State* L)
6794{
6795	//doSetMonsterOutfit(cid, name, time)
6796	int32_t time = (int32_t)popNumber(L);
6797	std::string name = popString(L);
6798
6799	ScriptEnviroment* env = getEnv();
6800	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
6801		lua_pushboolean(L, Spell::CreateIllusion(creature, name, time) == RET_NOERROR);
6802	else
6803	{
6804		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6805		lua_pushboolean(L, false);
6806	}
6807	return 1;
6808}
6809
6810int32_t LuaScriptInterface::luaSetItemOutfit(lua_State* L)
6811{
6812	//doSetItemOutfit(cid, item, time)
6813	int32_t time = (int32_t)popNumber(L);
6814	uint32_t item = (uint32_t)popNumber(L);
6815
6816	ScriptEnviroment* env = getEnv();
6817	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
6818		lua_pushboolean(L, Spell::CreateIllusion(creature, item, time) == RET_NOERROR);
6819	else
6820	{
6821		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
6822		lua_pushboolean(L, false);
6823	}
6824	return 1;
6825}
6826
6827int32_t LuaScriptInterface::luaGetStorage(lua_State* L)
6828{
6829	//getStorage(key)
6830	ScriptEnviroment* env = getEnv();
6831	std::string strValue;
6832	if(env->getStorage(popNumber(L), strValue))
6833	{
6834		int32_t intValue = atoi(strValue.c_str());
6835		if(intValue || strValue == "0")
6836			lua_pushnumber(L, intValue);
6837		else
6838			lua_pushstring(L, strValue.c_str());
6839	}
6840	else
6841		lua_pushnumber(L, -1);
6842
6843	return 1;
6844}
6845
6846int32_t LuaScriptInterface::luaDoSetStorage(lua_State* L)
6847{
6848	//doSetStorage(value, key)
6849	std::string value;
6850	bool nil = false;
6851	if(lua_isnil(L, -1))
6852	{
6853		nil = true;
6854		lua_pop(L, 1);
6855	}
6856	else
6857		value = popString(L);
6858
6859	ScriptEnviroment* env = getEnv();
6860	if(!nil)
6861		env->setStorage(popNumber(L), value);
6862	else
6863		env->eraseStorage(popNumber(L));
6864
6865	lua_pushboolean(L, true);
6866	return 1;
6867}
6868
6869int32_t LuaScriptInterface::luaGetPlayerDepotItems(lua_State* L)
6870{
6871	//getPlayerDepotItems(cid, depotid)
6872	uint32_t depotid = popNumber(L);
6873
6874	ScriptEnviroment* env = getEnv();
6875	if(Player* player = env->getPlayerByUID(popNumber(L)))
6876	{
6877		if(const Depot* depot = player->getDepot(depotid, true))
6878			lua_pushnumber(L, depot->getItemHoldingCount());
6879		else
6880			lua_pushboolean(L, false);
6881	}
6882	else
6883	{
6884		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
6885		lua_pushboolean(L, false);
6886	}
6887	return 1;
6888}
6889
6890int32_t LuaScriptInterface::luaDoPlayerSetGuildId(lua_State* L)
6891{
6892	//doPlayerSetGuildId(cid, id)
6893	uint32_t id = popNumber(L);
6894
6895	ScriptEnviroment* env = getEnv();
6896	if(Player* player = env->getPlayerByUID(popNumber(L)))
6897	{
6898		if(player->guildId)
6899		{
6900			player->leaveGuild();
6901			if(!id)
6902				lua_pushboolean(L, true);
6903			else if(IOGuild::getInstance()->guildExists(id))
6904				lua_pushboolean(L, IOGuild::getInstance()->joinGuild(player, id));
6905			else
6906				lua_pushboolean(L, false);
6907		}
6908		else if(id && IOGuild::getInstance()->guildExists(id))
6909			lua_pushboolean(L, IOGuild::getInstance()->joinGuild(player, id));
6910		else
6911			lua_pushboolean(L, false);
6912	}
6913	else
6914	{
6915		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
6916		lua_pushboolean(L, false);
6917	}
6918	return 1;
6919}
6920
6921int32_t LuaScriptInterface::luaDoPlayerSetGuildLevel(lua_State* L)
6922{
6923	//doPlayerSetGuildLevel(cid, level[, rank])
6924	uint32_t rank = 0;
6925	if(lua_gettop(L) > 2)
6926		rank = popNumber(L);
6927
6928	GuildLevel_t level = (GuildLevel_t)popNumber(L);
6929	ScriptEnviroment* env = getEnv();
6930	if(Player* player = env->getPlayerByUID(popNumber(L)))
6931		lua_pushboolean(L, player->setGuildLevel(level, rank));
6932	else
6933	{
6934		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
6935		lua_pushboolean(L, false);
6936	}
6937
6938	return 1;
6939}
6940
6941int32_t LuaScriptInterface::luaDoPlayerSetGuildNick(lua_State* L)
6942{
6943	//doPlayerSetGuildNick(cid, nick)
6944	std::string nick = popString(L);
6945
6946	ScriptEnviroment* env = getEnv();
6947	if(Player* player = env->getPlayerByUID(popNumber(L)))
6948	{
6949		player->setGuildNick(nick);
6950		lua_pushboolean(L, true);
6951	}
6952	else
6953	{
6954		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
6955		lua_pushboolean(L, false);
6956	}
6957
6958	return 1;
6959}
6960
6961int32_t LuaScriptInterface::luaGetGuildId(lua_State* L)
6962{
6963	//getGuildId(guildName)
6964	uint32_t guildId;
6965	if(IOGuild::getInstance()->getGuildId(guildId, popString(L)))
6966		lua_pushnumber(L, guildId);
6967	else
6968		lua_pushboolean(L, false);
6969
6970	return 1;
6971}
6972
6973int32_t LuaScriptInterface::luaGetGuildMotd(lua_State* L)
6974{
6975	//getGuildMotd(guildId)
6976	uint32_t guildId = popNumber(L);
6977	if(IOGuild::getInstance()->guildExists(guildId))
6978		lua_pushstring(L, IOGuild::getInstance()->getMotd(guildId).c_str());
6979	else
6980		lua_pushboolean(L, false);
6981
6982	return 1;
6983}
6984
6985int32_t LuaScriptInterface::luaDoMoveCreature(lua_State* L)
6986{
6987	//doMoveCreature(cid, direction)
6988	uint32_t direction = popNumber(L);
6989	if(direction < NORTH || direction > NORTHEAST)
6990	{
6991		lua_pushboolean(L, false);
6992		return 1;
6993	}
6994
6995	ScriptEnviroment* env = getEnv();
6996	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
6997		lua_pushnumber(L, g_game.internalMoveCreature(creature, (Direction)direction, FLAG_NOLIMIT));
6998	else
6999	{
7000		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7001		lua_pushboolean(L, false);
7002	}
7003
7004	return 1;
7005}
7006
7007int32_t LuaScriptInterface::luaIsCreature(lua_State* L)
7008{
7009	//isCreature(cid)
7010	ScriptEnviroment* env = getEnv();
7011	lua_pushboolean(L, env->getCreatureByUID(popNumber(L)) ? true : false);
7012	return 1;
7013}
7014
7015int32_t LuaScriptInterface::luaIsContainer(lua_State* L)
7016{
7017	//isContainer(uid)
7018	ScriptEnviroment* env = getEnv();
7019	lua_pushboolean(L, env->getContainerByUID(popNumber(L)) ? true : false);
7020	return 1;
7021}
7022
7023int32_t LuaScriptInterface::luaIsMovable(lua_State* L)
7024{
7025	//isMovable(uid)
7026	ScriptEnviroment* env = getEnv();
7027	Thing* thing = env->getThingByUID(popNumber(L));
7028	if(thing && thing->isPushable())
7029		lua_pushboolean(L, true);
7030	else
7031		lua_pushboolean(L, false);
7032
7033	return 1;
7034}
7035
7036int32_t LuaScriptInterface::luaGetCreatureByName(lua_State* L)
7037{
7038	//getCreatureByName(name)
7039	ScriptEnviroment* env = getEnv();
7040	if(Creature* creature = g_game.getCreatureByName(popString(L)))
7041		lua_pushnumber(L, env->addThing(creature));
7042	else
7043		lua_pushnil(L);
7044
7045	return 1;
7046}
7047
7048int32_t LuaScriptInterface::luaGetPlayerByGUID(lua_State* L)
7049{
7050	//getPlayerByGUID(guid)
7051	ScriptEnviroment* env = getEnv();
7052	if(Player* player = g_game.getPlayerByGuid(popNumber(L)))
7053		lua_pushnumber(L, env->addThing(player));
7054	else
7055		lua_pushnil(L);
7056
7057	return 1;
7058}
7059
7060int32_t LuaScriptInterface::luaGetPlayerByNameWildcard(lua_State* L)
7061{
7062	//getPlayerByNameWildcard(name~[, ret = false])
7063	Player* player = NULL;
7064	bool pushRet = false;
7065	if(lua_gettop(L) > 1)
7066		pushRet = popNumber(L);
7067
7068	ScriptEnviroment* env = getEnv();
7069	ReturnValue ret = g_game.getPlayerByNameWildcard(popString(L), player);
7070	if(ret == RET_NOERROR)
7071		lua_pushnumber(L, env->addThing(player));
7072	else if(pushRet)
7073		lua_pushnumber(L, ret);
7074	else
7075		lua_pushnil(L);
7076
7077	return 1;
7078}
7079
7080int32_t LuaScriptInterface::luaGetPlayerGUIDByName(lua_State* L)
7081{
7082	//getPlayerGUIDByName(name[, multiworld = false])
7083	bool multiworld = false;
7084	if(lua_gettop(L) > 1)
7085		multiworld = popNumber(L);
7086
7087	std::string name = popString(L);
7088	uint32_t guid;
7089	if(Player* player = g_game.getPlayerByName(name.c_str()))
7090		lua_pushnumber(L, player->getGUID());
7091	else if(IOLoginData::getInstance()->getGuidByName(guid, name, multiworld))
7092		lua_pushnumber(L, guid);
7093	else
7094		lua_pushnil(L);
7095
7096	return 1;
7097}
7098
7099int32_t LuaScriptInterface::luaGetPlayerNameByGUID(lua_State* L)
7100{
7101	//getPlayerNameByGUID(guid[, multiworld = false[, displayError = true]])
7102	int32_t parameters = lua_gettop(L);
7103	bool multiworld = false, displayError = true;
7104
7105	if(parameters > 2)
7106		displayError = popNumber(L);
7107
7108	if(parameters > 1)
7109		multiworld = popNumber(L);
7110
7111	uint32_t guid = popNumber(L);
7112	std::string name;
7113	if(!IOLoginData::getInstance()->getNameByGuid(guid, name, multiworld))
7114	{
7115		if(displayError)
7116			errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7117
7118		lua_pushnil(L);
7119		return 1;
7120	}
7121
7122	lua_pushstring(L, name.c_str());
7123	return 1;
7124}
7125
7126int32_t LuaScriptInterface::luaGetPlayersByAccountId(lua_State* L)
7127{
7128	//getPlayersByAccountId(accId)
7129	PlayerVector players = g_game.getPlayersByAccount(popNumber(L));
7130
7131	ScriptEnviroment* env = getEnv();
7132	PlayerVector::iterator it = players.begin();
7133
7134	lua_newtable(L);
7135	for(uint32_t i = 1; it != players.end(); ++it, ++i)
7136	{
7137		lua_pushnumber(L, i);
7138		lua_pushnumber(L, env->addThing(*it));
7139		pushTable(L);
7140	}
7141
7142	return 1;
7143}
7144
7145int32_t LuaScriptInterface::luaGetIpByName(lua_State* L)
7146{
7147	//getIpByName(name)
7148	std::string name = popString(L);
7149
7150	if(Player* player = g_game.getPlayerByName(name))
7151		lua_pushnumber(L, player->getIP());
7152	else
7153		lua_pushnumber(L, IOLoginData::getInstance()->getLastIPByName(name));
7154
7155	return 1;
7156}
7157
7158int32_t LuaScriptInterface::luaGetPlayersByIp(lua_State* L)
7159{
7160	//getPlayersByIp(ip[, mask])
7161	uint32_t mask = 0xFFFFFFFF;
7162	if(lua_gettop(L) > 1)
7163		mask = (uint32_t)popNumber(L);
7164
7165	PlayerVector players = g_game.getPlayersByIP(popNumber(L), mask);
7166
7167	ScriptEnviroment* env = getEnv();
7168	PlayerVector::iterator it = players.begin();
7169
7170	lua_newtable(L);
7171	for(uint32_t i = 1; it != players.end(); ++it, ++i)
7172	{
7173		lua_pushnumber(L, i);
7174		lua_pushnumber(L, env->addThing(*it));
7175		pushTable(L);
7176	}
7177
7178	return 1;
7179}
7180
7181int32_t LuaScriptInterface::luaGetAccountIdByName(lua_State* L)
7182{
7183	//getAccountIdByName(name)
7184	std::string name = popString(L);
7185
7186	if(Player* player = g_game.getPlayerByName(name))
7187		lua_pushnumber(L, player->getAccount());
7188	else
7189		lua_pushnumber(L, IOLoginData::getInstance()->getAccountIdByName(name));
7190
7191	return 1;
7192}
7193
7194int32_t LuaScriptInterface::luaGetAccountByName(lua_State* L)
7195{
7196	//getAccountByName(name)
7197	std::string name = popString(L);
7198
7199	if(Player* player = g_game.getPlayerByName(name))
7200		lua_pushstring(L, player->getAccountName().c_str());
7201	else
7202	{
7203		std::string tmp;
7204		IOLoginData::getInstance()->getAccountName(IOLoginData::getInstance()->getAccountIdByName(name), tmp);
7205		lua_pushstring(L, tmp.c_str());
7206	}
7207
7208	return 1;
7209}
7210
7211int32_t LuaScriptInterface::luaGetAccountIdByAccount(lua_State* L)
7212{
7213	//getAccountIdByAccount(accName)
7214	uint32_t value = 0;
7215	IOLoginData::getInstance()->getAccountId(popString(L), value);
7216	lua_pushnumber(L, value);
7217	return 1;
7218}
7219
7220int32_t LuaScriptInterface::luaGetAccountByAccountId(lua_State* L)
7221{
7222	//getAccountByAccountId(accId)
7223	std::string value = 0;
7224	IOLoginData::getInstance()->getAccountName(popNumber(L), value);
7225	lua_pushstring(L, value.c_str());
7226	return 1;
7227}
7228
7229int32_t LuaScriptInterface::luaRegisterCreatureEvent(lua_State* L)
7230{
7231	//registerCreatureEvent(cid, name)
7232	std::string name = popString(L);
7233
7234	ScriptEnviroment* env = getEnv();
7235	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7236		lua_pushboolean(L, creature->registerCreatureEvent(name));
7237	else
7238	{
7239		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7240		lua_pushboolean(L, false);
7241	}
7242
7243	return 1;
7244}
7245
7246int32_t LuaScriptInterface::luaGetContainerSize(lua_State* L)
7247{
7248	//getContainerSize(uid)
7249	ScriptEnviroment* env = getEnv();
7250	if(Container* container = env->getContainerByUID(popNumber(L)))
7251		lua_pushnumber(L, container->size());
7252	else
7253	{
7254		errorEx(getError(LUA_ERROR_CONTAINER_NOT_FOUND));
7255		lua_pushboolean(L, false);
7256	}
7257	return 1;
7258}
7259
7260int32_t LuaScriptInterface::luaGetContainerCap(lua_State* L)
7261{
7262	//getContainerCap(uid)
7263	ScriptEnviroment* env = getEnv();
7264	if(Container* container = env->getContainerByUID(popNumber(L)))
7265		lua_pushnumber(L, container->capacity());
7266	else
7267	{
7268		errorEx(getError(LUA_ERROR_CONTAINER_NOT_FOUND));
7269		lua_pushboolean(L, false);
7270	}
7271	return 1;
7272}
7273
7274int32_t LuaScriptInterface::luaGetContainerItem(lua_State* L)
7275{
7276	//getContainerItem(uid, slot)
7277	uint32_t slot = popNumber(L);
7278
7279	ScriptEnviroment* env = getEnv();
7280	if(Container* container = env->getContainerByUID(popNumber(L)))
7281	{
7282		if(Item* item = container->getItem(slot))
7283			pushThing(L, item, env->addThing(item));
7284		else
7285			pushThing(L, NULL, 0);
7286	}
7287	else
7288	{
7289		errorEx(getError(LUA_ERROR_CONTAINER_NOT_FOUND));
7290		pushThing(L, NULL, 0);
7291	}
7292	return 1;
7293
7294}
7295
7296int32_t LuaScriptInterface::luaDoAddContainerItemEx(lua_State* L)
7297{
7298	//doAddContainerItemEx(uid, virtuid)
7299	uint32_t virtuid = popNumber(L);
7300	ScriptEnviroment* env = getEnv();
7301	if(Container* container = env->getContainerByUID(popNumber(L)))
7302	{
7303		Item* item = env->getItemByUID(virtuid);
7304		if(!item)
7305		{
7306			errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
7307			lua_pushboolean(L, false);
7308			return 1;
7309		}
7310
7311		if(item->getParent() != VirtualCylinder::virtualCylinder)
7312		{
7313			lua_pushboolean(L, false);
7314			return 1;
7315		}
7316
7317		ReturnValue ret = g_game.internalAddItem(NULL, container, item);
7318		if(ret == RET_NOERROR)
7319			env->removeTempItem(item);
7320
7321		lua_pushnumber(L, ret);
7322		return 1;
7323	}
7324	else
7325	{
7326		errorEx(getError(LUA_ERROR_CONTAINER_NOT_FOUND));
7327		lua_pushboolean(L, false);
7328		return 1;
7329	}
7330}
7331
7332int32_t LuaScriptInterface::luaDoAddContainerItem(lua_State* L)
7333{
7334	//doAddContainerItem(uid, itemid[, count/subType])
7335	uint32_t count = 1;
7336	if(lua_gettop(L) > 2)
7337		count = popNumber(L);
7338
7339	uint16_t itemId = popNumber(L);
7340	ScriptEnviroment* env = getEnv();
7341
7342	Container* container = env->getContainerByUID((uint32_t)popNumber(L));
7343	if(!container)
7344	{
7345		errorEx(getError(LUA_ERROR_CONTAINER_NOT_FOUND));
7346		lua_pushboolean(L, false);
7347		return 1;
7348	}
7349
7350	const ItemType& it = Item::items[itemId];
7351	int32_t itemCount = 1, subType = 1;
7352	if(it.hasSubType())
7353	{
7354		if(it.stackable)
7355			itemCount = (int32_t)std::ceil((float)count / 100);
7356
7357		subType = count;
7358	}
7359	else
7360		itemCount = std::max((uint32_t)1, count);
7361
7362	while(itemCount > 0)
7363	{
7364		int32_t stackCount = std::min(100, subType);
7365		Item* newItem = Item::CreateItem(itemId, stackCount);
7366		if(!newItem)
7367		{
7368			errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
7369			lua_pushboolean(L, false);
7370			return 1;
7371		}
7372
7373		if(it.stackable)
7374			subType -= stackCount;
7375
7376		ReturnValue ret = g_game.internalAddItem(NULL, container, newItem);
7377		if(ret != RET_NOERROR)
7378		{
7379			delete newItem;
7380			lua_pushboolean(L, false);
7381			return 1;
7382		}
7383
7384		--itemCount;
7385		if(itemCount)
7386			continue;
7387
7388		if(newItem->getParent())
7389			lua_pushnumber(L, env->addThing(newItem));
7390		else //stackable item stacked with existing object, newItem will be released
7391			lua_pushnil(L);
7392
7393		return 1;
7394	}
7395
7396	lua_pushnil(L);
7397	return 1;
7398}
7399
7400int32_t LuaScriptInterface::luaDoPlayerAddOutfit(lua_State *L)
7401{
7402	//Consider using doPlayerAddOutfitId instead
7403	//doPlayerAddOutfit(cid, looktype, addon)
7404	uint32_t addon = popNumber(L), lookType = popNumber(L);
7405	ScriptEnviroment* env = getEnv();
7406
7407	Player* player = env->getPlayerByUID((uint32_t)popNumber(L));
7408	if(!player)
7409	{
7410		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7411		lua_pushboolean(L, false);
7412		return 1;
7413	}
7414
7415	Outfit outfit;
7416	if(Outfits::getInstance()->getOutfit(lookType, outfit))
7417	{
7418		lua_pushboolean(L, player->addOutfit(outfit.outfitId, addon));
7419		return 1;
7420	}
7421
7422	lua_pushboolean(L, false);
7423	return 1;
7424}
7425
7426int32_t LuaScriptInterface::luaDoPlayerRemoveOutfit(lua_State *L)
7427{
7428	//Consider using doPlayerRemoveOutfitId instead
7429	//doPlayerRemoveOutfit(cid, looktype[, addon = 0])
7430	uint32_t addon = 0xFF;
7431	if(lua_gettop(L) > 2)
7432		addon = popNumber(L);
7433
7434	uint32_t lookType = popNumber(L);
7435	ScriptEnviroment* env = getEnv();
7436
7437	Player* player = env->getPlayerByUID((uint32_t)popNumber(L));
7438	if(!player)
7439	{
7440		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7441		lua_pushboolean(L, false);
7442		return 1;
7443	}
7444
7445	Outfit outfit;
7446	if(Outfits::getInstance()->getOutfit(lookType, outfit))
7447	{
7448		lua_pushboolean(L, player->removeOutfit(outfit.outfitId, addon));
7449		return 1;
7450	}
7451
7452	lua_pushboolean(L, false);
7453	return 1;
7454}
7455
7456int32_t LuaScriptInterface::luaDoPlayerAddOutfitId(lua_State *L)
7457{
7458	//doPlayerAddOutfitId(cid, outfitId, addon)
7459	uint32_t addon = popNumber(L), outfitId = popNumber(L);
7460	ScriptEnviroment* env = getEnv();
7461
7462	Player* player = env->getPlayerByUID((uint32_t)popNumber(L));
7463	if(!player)
7464	{
7465		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7466		lua_pushboolean(L, false);
7467		return 1;
7468	}
7469
7470	lua_pushboolean(L, player->addOutfit(outfitId, addon));
7471	return 1;
7472}
7473
7474int32_t LuaScriptInterface::luaDoPlayerRemoveOutfitId(lua_State *L)
7475{
7476	//doPlayerRemoveOutfitId(cid, outfitId[, addon = 0])
7477	uint32_t addon = 0xFF;
7478	if(lua_gettop(L) > 2)
7479		addon = popNumber(L);
7480
7481	uint32_t outfitId = popNumber(L);
7482	ScriptEnviroment* env = getEnv();
7483
7484	Player* player = env->getPlayerByUID((uint32_t)popNumber(L));
7485	if(!player)
7486	{
7487		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7488		lua_pushboolean(L, false);
7489		return 1;
7490	}
7491
7492	lua_pushboolean(L, player->removeOutfit(outfitId, addon));
7493	return 1;
7494}
7495
7496int32_t LuaScriptInterface::luaCanPlayerWearOutfit(lua_State* L)
7497{
7498	//canPlayerWearOutfit(cid, looktype[, addon = 0])
7499	uint32_t addon = 0;
7500	if(lua_gettop(L) > 2)
7501		addon = popNumber(L);
7502
7503	uint32_t lookType = popNumber(L);
7504	ScriptEnviroment* env = getEnv();
7505
7506	Player* player = env->getPlayerByUID(popNumber(L));
7507	if(!player)
7508	{
7509		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7510		lua_pushboolean(L, false);
7511		return 1;
7512	}
7513
7514	Outfit outfit;
7515	if(Outfits::getInstance()->getOutfit(lookType, outfit))
7516	{
7517		lua_pushboolean(L, player->canWearOutfit(outfit.outfitId, addon));
7518		return 1;
7519	}
7520
7521	lua_pushboolean(L, false);
7522	return 1;
7523}
7524
7525int32_t LuaScriptInterface::luaCanPlayerWearOutfitId(lua_State* L)
7526{
7527	//canPlayerWearOutfitId(cid, outfitId[, addon = 0])
7528	uint32_t addon = 0;
7529	if(lua_gettop(L) > 2)
7530		addon = popNumber(L);
7531
7532	uint32_t outfitId = popNumber(L);
7533	ScriptEnviroment* env = getEnv();
7534
7535	Player* player = env->getPlayerByUID(popNumber(L));
7536	if(!player)
7537	{
7538		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7539		lua_pushboolean(L, false);
7540		return 1;
7541	}
7542
7543	lua_pushboolean(L, player->canWearOutfit(outfitId, addon));
7544	return 1;
7545}
7546
7547int32_t LuaScriptInterface::luaDoCreatureChangeOutfit(lua_State* L)
7548{
7549	//doCreatureChangeOutfit(cid, outfit)
7550	Outfit_t outfit = popOutfit(L);
7551	ScriptEnviroment* env = getEnv();
7552	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7553	{
7554		if(Player* player = creature->getPlayer())
7555			player->changeOutfit(outfit, false);
7556		else
7557			creature->defaultOutfit = outfit;
7558
7559		if(!creature->hasCondition(CONDITION_OUTFIT, 1))
7560			g_game.internalCreatureChangeOutfit(creature, outfit);
7561
7562		lua_pushboolean(L, true);
7563	}
7564	else
7565	{
7566		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7567		lua_pushboolean(L, false);
7568	}
7569	return 1;
7570}
7571
7572int32_t LuaScriptInterface::luaDoSetCreatureLight(lua_State* L)
7573{
7574	//doSetCreatureLight(cid, lightLevel, lightColor, time)
7575	uint32_t time = popNumber(L);
7576	uint8_t color = (uint8_t)popNumber(L), level = (uint8_t)popNumber(L);
7577
7578	ScriptEnviroment* env = getEnv();
7579	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7580	{
7581		Condition* condition = Condition::createCondition(CONDITIONID_COMBAT, CONDITION_LIGHT, time, level | (color << 8));
7582		creature->addCondition(condition);
7583		lua_pushboolean(L, true);
7584	}
7585	else
7586	{
7587		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7588		lua_pushboolean(L, false);
7589	}
7590	return 1;
7591}
7592
7593int32_t LuaScriptInterface::luaDoPlayerPopupFYI(lua_State* L)
7594{
7595	//doPlayerPopupFYI(cid, message)
7596	std::string message = popString(L);
7597
7598	ScriptEnviroment* env = getEnv();
7599	if(Player* player = env->getPlayerByUID(popNumber(L)))
7600	{
7601		player->sendFYIBox(message);
7602		lua_pushboolean(L, true);
7603	}
7604	else
7605	{
7606		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7607		lua_pushboolean(L, false);
7608	}
7609	return 1;
7610}
7611
7612int32_t LuaScriptInterface::luaDoPlayerSendTutorial(lua_State* L)
7613{
7614	//doPlayerSendTutorial(cid, id)
7615	uint8_t id = (uint8_t)popNumber(L);
7616
7617	ScriptEnviroment* env = getEnv();
7618
7619	Player* player = env->getPlayerByUID(popNumber(L));
7620	if(!player)
7621	{
7622		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7623		lua_pushboolean(L, false);
7624		return 1;
7625	}
7626
7627	player->sendTutorial(id);
7628	lua_pushboolean(L, true);
7629	return 1;
7630}
7631
7632int32_t LuaScriptInterface::luaDoPlayerSendMailByName(lua_State* L)
7633{
7634	//doPlayerSendMailByName(name, item[, town[, actor]])
7635	ScriptEnviroment* env = getEnv();
7636	int32_t params = lua_gettop(L);
7637
7638	Creature* actor = NULL;
7639	if(params > 3)
7640		actor = env->getCreatureByUID(popNumber(L));
7641
7642	uint32_t town = 0;
7643	if(params > 2)
7644		town = popNumber(L);
7645
7646	Item* item = env->getItemByUID(popNumber(L));
7647	if(!item)
7648	{
7649		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
7650		lua_pushboolean(L, false);
7651		return 1;
7652	}
7653
7654	if(item->getParent() != VirtualCylinder::virtualCylinder)
7655	{
7656		lua_pushboolean(L, false);
7657		return 1;
7658	}
7659
7660	lua_pushboolean(L, IOLoginData::getInstance()->playerMail(actor, popString(L), town, item));
7661	return 1;
7662}
7663
7664int32_t LuaScriptInterface::luaDoPlayerAddMapMark(lua_State* L)
7665{
7666	//doPlayerAddMapMark(cid, pos, type[, description])
7667	std::string description;
7668	if(lua_gettop(L) > 3)
7669		description = popString(L);
7670
7671	MapMarks_t type = (MapMarks_t)popNumber(L);
7672	PositionEx pos;
7673	popPosition(L, pos);
7674
7675	ScriptEnviroment* env = getEnv();
7676	Player* player = env->getPlayerByUID(popNumber(L));
7677	if(!player)
7678	{
7679		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7680		lua_pushboolean(L, false);
7681		return 1;
7682	}
7683
7684	player->sendAddMarker(pos, type, description);
7685	lua_pushboolean(L, true);
7686	return 1;
7687}
7688
7689int32_t LuaScriptInterface::luaDoPlayerAddPremiumDays(lua_State* L)
7690{
7691	//doPlayerAddPremiumDays(cid, days)
7692	int32_t days = popNumber(L);
7693
7694	ScriptEnviroment* env = getEnv();
7695	if(Player* player = env->getPlayerByUID(popNumber(L)))
7696	{
7697		if(player->premiumDays < 65535)
7698		{
7699			Account account = IOLoginData::getInstance()->loadAccount(player->getAccount());
7700			if(days < 0)
7701			{
7702				account.premiumDays = std::max((uint32_t)0, uint32_t(account.premiumDays + (int32_t)days));
7703				player->premiumDays = std::max((uint32_t)0, uint32_t(player->premiumDays + (int32_t)days));
7704			}
7705			else
7706			{
7707				account.premiumDays = std::min((uint32_t)65534, uint32_t(account.premiumDays + (uint32_t)days));
7708				player->premiumDays = std::min((uint32_t)65534, uint32_t(player->premiumDays + (uint32_t)days));
7709			}
7710			IOLoginData::getInstance()->saveAccount(account);
7711		}
7712		lua_pushboolean(L, true);
7713	}
7714	else
7715	{
7716		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7717		lua_pushboolean(L, false);
7718	}
7719	return 1;
7720}
7721
7722int32_t LuaScriptInterface::luaGetCreatureLastPosition(lua_State* L)
7723{
7724	//getCreatureLastPosition(cid)
7725	ScriptEnviroment* env = getEnv();
7726
7727	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7728		pushPosition(L, creature->getLastPosition(), 0);
7729	else
7730	{
7731		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7732		lua_pushboolean(L, false);
7733	}
7734	return 1;
7735}
7736
7737int32_t LuaScriptInterface::luaGetCreatureName(lua_State* L)
7738{
7739	//getCreatureName(cid)
7740	ScriptEnviroment* env = getEnv();
7741	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7742		lua_pushstring(L, creature->getName().c_str());
7743	else
7744	{
7745		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7746		lua_pushboolean(L, false);
7747	}
7748
7749	return 1;
7750}
7751
7752int32_t LuaScriptInterface::luaGetCreatureNoMove(lua_State* L)
7753{
7754	//getCreatureNoMove(cid)
7755	ScriptEnviroment* env = getEnv();
7756	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7757		lua_pushboolean(L, creature->getNoMove());
7758	else
7759	{
7760		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7761		lua_pushboolean(L, false);
7762	}
7763
7764	return 1;
7765}
7766
7767int32_t LuaScriptInterface::luaGetCreatureSkullType(lua_State* L)
7768{
7769	//getCreatureSkullType(cid[, target])
7770	uint32_t tid = 0;
7771	if(lua_gettop(L) > 1)
7772		tid = popNumber(L);
7773
7774	ScriptEnviroment* env = getEnv();
7775	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7776	{
7777		if(!tid)
7778			lua_pushnumber(L, creature->getSkull());
7779		else if(Creature* target = env->getCreatureByUID(tid))
7780			lua_pushnumber(L, creature->getSkullClient(target));
7781		else
7782		{
7783			errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7784			lua_pushboolean(L, false);
7785		}
7786	}
7787	else
7788	{
7789		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7790		lua_pushboolean(L, false);
7791	}
7792
7793	return 1;
7794}
7795
7796int32_t LuaScriptInterface::luaDoCreatureSetLookDir(lua_State* L)
7797{
7798	//doCreatureSetLookDirection(cid, dir)
7799	Direction dir = (Direction)popNumber(L);
7800	ScriptEnviroment* env = getEnv();
7801	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7802	{
7803		if(dir < NORTH || dir > WEST)
7804		{
7805			lua_pushboolean(L, false);
7806			return 1;
7807		}
7808
7809		g_game.internalCreatureTurn(creature, dir);
7810		lua_pushboolean(L, true);
7811	}
7812	else
7813	{
7814		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7815		lua_pushboolean(L, false);
7816	}
7817	return 1;
7818}
7819
7820int32_t LuaScriptInterface::luaDoCreatureSetSkullType(lua_State* L)
7821{
7822	//doCreatureSetSkullType(cid, skull)
7823	Skulls_t skull = (Skulls_t)popNumber(L);
7824	ScriptEnviroment* env = getEnv();
7825	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7826	{
7827		creature->setSkull(skull);
7828		g_game.updateCreatureSkull(creature);
7829		lua_pushboolean(L, true);
7830	}
7831	else
7832	{
7833		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7834		lua_pushboolean(L, false);
7835	}
7836	return 1;
7837}
7838
7839int32_t LuaScriptInterface::luaDoPlayerSetSkullEnd(lua_State* L)
7840{
7841	//doPlayerSetSkullEnd(cid, time, type)
7842	Skulls_t _skull = (Skulls_t)popNumber(L);
7843	time_t _time = (time_t)std::max((int64_t)0, popNumber(L));
7844
7845	ScriptEnviroment* env = getEnv();
7846	if(Player* player = env->getPlayerByUID(popNumber(L)))
7847	{
7848		player->setSkullEnd(_time, false, _skull);
7849		lua_pushboolean(L, true);
7850	}
7851	else
7852	{
7853		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
7854		lua_pushboolean(L, false);
7855	}
7856	return 1;
7857}
7858
7859int32_t LuaScriptInterface::luaGetCreatureSpeed(lua_State* L)
7860{
7861	//getCreatureSpeed(cid)
7862	ScriptEnviroment* env = getEnv();
7863	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7864		lua_pushnumber(L, creature->getSpeed());
7865	else
7866	{
7867		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7868		lua_pushboolean(L, false);
7869	}
7870	return 1;
7871}
7872
7873int32_t LuaScriptInterface::luaGetCreatureBaseSpeed(lua_State* L)
7874{
7875	//getCreatureBaseSpeed(cid)
7876	ScriptEnviroment* env = getEnv();
7877	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7878		lua_pushnumber(L, creature->getBaseSpeed());
7879	else
7880	{
7881		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7882		lua_pushboolean(L, false);
7883	}
7884	return 1;
7885}
7886
7887int32_t LuaScriptInterface::luaGetCreatureTarget(lua_State* L)
7888{
7889	//getCreatureTarget(cid)
7890	ScriptEnviroment* env = getEnv();
7891	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
7892	{
7893		Creature* target = creature->getAttackedCreature();
7894		lua_pushnumber(L, target ? env->addThing(target) : 0);
7895	}
7896	else
7897	{
7898		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
7899		lua_pushboolean(L, false);
7900	}
7901	return 1;
7902}
7903
7904int32_t LuaScriptInterface::luaIsSightClear(lua_State* L)
7905{
7906	//isSightClear(fromPos, toPos, floorCheck)
7907	PositionEx fromPos, toPos;
7908	bool floorCheck = popNumber(L);
7909
7910	popPosition(L, toPos);
7911	popPosition(L, fromPos);
7912
7913	lua_pushboolean(L, g_game.isSightClear(fromPos, toPos, floorCheck));
7914	return 1;
7915}
7916
7917int32_t LuaScriptInterface::luaIsInArray(lua_State* L)
7918{
7919	//isInArray(array, value[, caseSensitive = false])
7920	bool caseSensitive = false;
7921	if(lua_gettop(L) > 2)
7922		caseSensitive = popNumber(L);
7923
7924	boost::any value;
7925	if(lua_isnumber(L, -1))
7926		value = popFloatNumber(L);
7927	else if(lua_isboolean(L, -1))
7928		value = popBoolean(L);
7929	else if(lua_isstring(L, -1))
7930		value = popString(L);
7931	else
7932	{
7933		lua_pop(L, 1);
7934		lua_pushboolean(L, false);
7935		return 1;
7936	}
7937
7938	const std::type_info& type = value.type();
7939	if(!caseSensitive && type == typeid(std::string))
7940		value = asLowerCaseString(boost::any_cast<std::string>(value));
7941
7942	if(!lua_istable(L, -1))
7943	{
7944		boost::any data;
7945		if(lua_isnumber(L, -1))
7946			data = popFloatNumber(L);
7947		else if(lua_isboolean(L, -1))
7948			data = popBoolean(L);
7949		else if(lua_isstring(L, -1))
7950			data = popString(L);
7951		else
7952		{
7953			lua_pop(L, 1);
7954			lua_pushboolean(L, false);
7955			return 1;
7956		}
7957
7958		if(type != data.type()) // check is it even same data type before searching deeper
7959			lua_pushboolean(L, false);
7960		else if(type == typeid(bool))
7961			lua_pushboolean(L, boost::any_cast<bool>(value) == boost::any_cast<bool>(data));
7962		else if(type == typeid(double))
7963			lua_pushboolean(L, boost::any_cast<double>(value) == boost::any_cast<double>(data));
7964		else if(caseSensitive)
7965			lua_pushboolean(L, boost::any_cast<std::string>(value) == boost::any_cast<std::string>(data));
7966		else
7967			lua_pushboolean(L, boost::any_cast<std::string>(value) == asLowerCaseString(boost::any_cast<std::string>(data)));
7968
7969		return 1;
7970	}
7971
7972	lua_pushnil(L);
7973	while(lua_next(L, -2))
7974	{
7975		boost::any data;
7976		if(lua_isnumber(L, -1))
7977			data = popFloatNumber(L);
7978		else if(lua_isboolean(L, -1))
7979			data = popBoolean(L);
7980		else if(lua_isstring(L, -1))
7981			data = popString(L);
7982		else
7983		{
7984			lua_pop(L, 1);
7985			break;
7986		}
7987
7988		if(type != data.type()) // check is it same data type before searching deeper
7989			continue;
7990
7991		if(type == typeid(bool))
7992		{
7993			if(boost::any_cast<bool>(value) != boost::any_cast<bool>(data))
7994				continue;
7995
7996			lua_pushboolean(L, true);
7997			return 1;
7998		}
7999		else if(type == typeid(double))
8000		{
8001			if(boost::any_cast<double>(value) != boost::any_cast<double>(data))
8002				continue;
8003
8004			lua_pushboolean(L, true);
8005			return 1;
8006		}
8007		else if(caseSensitive)
8008		{
8009			if(boost::any_cast<std::string>(value) != boost::any_cast<std::string>(data))
8010				continue;
8011
8012			lua_pushboolean(L, true);
8013			return 1;
8014		}
8015		else if(boost::any_cast<std::string>(value) == asLowerCaseString(boost::any_cast<std::string>(data)))
8016		{
8017			lua_pushboolean(L, true);
8018			return 1;
8019		}
8020	}
8021
8022	lua_pop(L, 2);
8023	lua_pushboolean(L, false);
8024	return 1;
8025}
8026
8027int32_t LuaScriptInterface::luaAddEvent(lua_State* L)
8028{
8029	//addEvent(callback, delay, ...)
8030	ScriptEnviroment* env = getEnv();
8031	LuaScriptInterface* interface = env->getInterface();
8032	if(!interface)
8033	{
8034		errorEx("No valid script interface!");
8035		lua_pushboolean(L, false);
8036		return 1;
8037	}
8038
8039	int32_t parameters = lua_gettop(L);
8040	if(!lua_isfunction(L, -parameters)) //-parameters means the first parameter from left to right
8041	{
8042		errorEx("Callback parameter should be a function.");
8043		lua_pushboolean(L, false);
8044		return 1;
8045	}
8046
8047	std::list<int32_t> params;
8048	for(int32_t i = 0; i < parameters - 2; ++i) //-2 because addEvent needs at least two parameters
8049		params.push_back(luaL_ref(L, LUA_REGISTRYINDEX));
8050
8051	uint32_t delay = std::max((int64_t)SCHEDULER_MINTICKS, popNumber(L));
8052	LuaTimerEvent eventDesc;
8053
8054	eventDesc.parameters = params;
8055	eventDesc.function = luaL_ref(L, LUA_REGISTRYINDEX);
8056	eventDesc.scriptId = env->getScriptId();
8057
8058	interface->m_timerEvents[++interface->m_lastEventTimerId] = eventDesc;
8059	Scheduler::getInstance().addEvent(createSchedulerTask(delay, boost::bind(
8060		&LuaScriptInterface::executeTimer, interface, interface->m_lastEventTimerId)));
8061
8062	lua_pushnumber(L, interface->m_lastEventTimerId);
8063	return 1;
8064}
8065
8066int32_t LuaScriptInterface::luaStopEvent(lua_State* L)
8067{
8068	//stopEvent(eventid)
8069	uint32_t eventId = popNumber(L);
8070	ScriptEnviroment* env = getEnv();
8071
8072	LuaScriptInterface* interface = env->getInterface();
8073	if(!interface)
8074	{
8075		errorEx("No valid script interface!");
8076		lua_pushboolean(L, false);
8077		return 1;
8078	}
8079
8080	LuaTimerEvents::iterator it = interface->m_timerEvents.find(eventId);
8081	if(it != interface->m_timerEvents.end())
8082	{
8083		for(std::list<int32_t>::iterator lt = it->second.parameters.begin(); lt != it->second.parameters.end(); ++lt)
8084			luaL_unref(interface->m_luaState, LUA_REGISTRYINDEX, *lt);
8085		it->second.parameters.clear();
8086
8087		luaL_unref(interface->m_luaState, LUA_REGISTRYINDEX, it->second.function);
8088		interface->m_timerEvents.erase(it);
8089		lua_pushboolean(L, true);
8090	}
8091	else
8092		lua_pushboolean(L, false);
8093
8094	return 1;
8095}
8096
8097int32_t LuaScriptInterface::luaGetCreatureCondition(lua_State* L)
8098{
8099	//getCreatureCondition(cid, condition[, subId])
8100	uint32_t subId = 0, condition = 0;
8101	if(lua_gettop(L) > 2)
8102		subId = popNumber(L);
8103
8104	condition = popNumber(L);
8105	ScriptEnviroment* env = getEnv();
8106	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8107		lua_pushboolean(L, creature->hasCondition((ConditionType_t)condition, subId));
8108	else
8109	{
8110		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8111		lua_pushboolean(L, false);
8112	}
8113
8114	return 1;
8115}
8116
8117int32_t LuaScriptInterface::luaGetPlayerBlessing(lua_State* L)
8118{
8119	//getPlayerBlessings(cid, blessing)
8120	int16_t blessing = popNumber(L) - 1;
8121
8122	ScriptEnviroment* env = getEnv();
8123	if(Player* player = env->getPlayerByUID(popNumber(L)))
8124		lua_pushboolean(L, player->hasBlessing(blessing));
8125	else
8126	{
8127		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8128		lua_pushboolean(L, false);
8129	}
8130	return 1;
8131}
8132
8133int32_t LuaScriptInterface::luaDoPlayerAddBlessing(lua_State* L)
8134{
8135	//doPlayerAddBlessing(cid, blessing)
8136	int16_t blessing = popNumber(L) - 1;
8137	ScriptEnviroment* env = getEnv();
8138	if(Player* player = env->getPlayerByUID(popNumber(L)))
8139	{
8140		if(!player->hasBlessing(blessing))
8141		{
8142			player->addBlessing(1 << blessing);
8143			lua_pushboolean(L, true);
8144		}
8145		else
8146			lua_pushboolean(L, false);
8147	}
8148	else
8149	{
8150		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8151		lua_pushboolean(L, false);
8152	}
8153	return 1;
8154}
8155
8156int32_t LuaScriptInterface::luaDoPlayerSetPromotionLevel(lua_State* L)
8157{
8158	//doPlayerSetPromotionLevel(cid, level)
8159	uint32_t level = popNumber(L);
8160	ScriptEnviroment* env = getEnv();
8161	if(Player* player = env->getPlayerByUID(popNumber(L)))
8162	{
8163		player->setPromotionLevel(level);
8164		lua_pushboolean(L, true);
8165	}
8166	else
8167	{
8168		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8169		lua_pushboolean(L, false);
8170	}
8171	return 1;
8172}
8173
8174int32_t LuaScriptInterface::luaDoPlayerSetGroupId(lua_State* L)
8175{
8176	//doPlayerSetGroupId(cid, groupId)
8177	uint32_t groupId = popNumber(L);
8178	ScriptEnviroment* env = getEnv();
8179	if(Player* player = env->getPlayerByUID(popNumber(L)))
8180	{
8181		if(Group* group = Groups::getInstance()->getGroup(groupId))
8182		{
8183			player->setGroup(group);
8184			lua_pushboolean(L, true);
8185		}
8186		else
8187			lua_pushboolean(L, false);
8188	}
8189	else
8190	{
8191		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8192		lua_pushboolean(L, false);
8193	}
8194	return 1;
8195}
8196
8197int32_t LuaScriptInterface::luaGetCreatureMana(lua_State* L)
8198{
8199	//getCreatureMana(cid)
8200	ScriptEnviroment* env = getEnv();
8201	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8202		lua_pushnumber(L, creature->getMana());
8203	else
8204	{
8205		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8206		lua_pushboolean(L, false);
8207	}
8208	return 1;
8209}
8210
8211int32_t LuaScriptInterface::luaGetCreatureMaxMana(lua_State* L)
8212{
8213	//getCreatureMaxMana(cid)
8214	ScriptEnviroment* env = getEnv();
8215	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8216		lua_pushnumber(L, creature->getMaxMana());
8217	else
8218	{
8219		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8220		lua_pushboolean(L, false);
8221	}
8222	return 1;
8223}
8224
8225int32_t LuaScriptInterface::luaGetCreatureHealth(lua_State* L)
8226{
8227	//getCreatureHealth(cid)
8228	ScriptEnviroment* env = getEnv();
8229	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8230		lua_pushnumber(L, creature->getHealth());
8231	else
8232	{
8233		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8234		lua_pushboolean(L, false);
8235	}
8236	return 1;
8237}
8238
8239int32_t LuaScriptInterface::luaGetCreatureLookDirection(lua_State* L)
8240{
8241	//getCreatureLookDirection(cid)
8242	ScriptEnviroment* env = getEnv();
8243
8244	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8245		lua_pushnumber(L, creature->getDirection());
8246	else
8247	{
8248		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8249		lua_pushboolean(L, false);
8250	}
8251	return 1;
8252}
8253
8254int32_t LuaScriptInterface::luaGetCreatureMaxHealth(lua_State* L)
8255{
8256	//getCreatureMaxHealth(cid)
8257	ScriptEnviroment* env = getEnv();
8258	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8259		lua_pushnumber(L, creature->getMaxHealth());
8260	else
8261	{
8262		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8263		lua_pushboolean(L, false);
8264	}
8265	return 1;
8266}
8267
8268int32_t LuaScriptInterface::luaDoPlayerSetStamina(lua_State* L)
8269{
8270	//doPlayerSetStamina(cid, minutes)
8271	uint32_t minutes = popNumber(L);
8272
8273	ScriptEnviroment* env = getEnv();
8274	if(Player* player = env->getPlayerByUID(popNumber(L)))
8275	{
8276		player->setStaminaMinutes(minutes);
8277		lua_pushboolean(L, true);
8278	}
8279	else
8280	{
8281		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8282		lua_pushboolean(L, false);
8283	}
8284	return 1;
8285}
8286
8287int32_t LuaScriptInterface::luaDoPlayerAddStamina(lua_State* L)
8288{
8289	//doPlayerAddStamina(cid, minutes)
8290	int32_t minutes = popNumber(L);
8291
8292	ScriptEnviroment* env = getEnv();
8293	if(Player* player = env->getPlayerByUID(popNumber(L)))
8294	{
8295		player->setStaminaMinutes(player->getStaminaMinutes() + minutes);
8296		lua_pushboolean(L, true);
8297	}
8298	else
8299	{
8300		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8301		lua_pushboolean(L, false);
8302	}
8303	return 1;
8304}
8305
8306int32_t LuaScriptInterface::luaDoPlayerSetBalance(lua_State* L)
8307{
8308	//doPlayerSetBalance(cid, balance)
8309	uint32_t balance = popNumber(L);
8310
8311	ScriptEnviroment* env = getEnv();
8312	if(Player* player = env->getPlayerByUID(popNumber(L)))
8313	{
8314		player->balance = balance;
8315		lua_pushboolean(L, true);
8316	}
8317	else
8318	{
8319		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8320		lua_pushboolean(L, false);
8321	}
8322	return 1;
8323}
8324
8325int32_t LuaScriptInterface::luaDoPlayerSetPartner(lua_State* L)
8326{
8327	//doPlayerSetPartner(cid, guid)
8328	uint32_t guid = popNumber(L);
8329
8330	ScriptEnviroment* env = getEnv();
8331	if(Player* player = env->getPlayerByUID(popNumber(L)))
8332	{
8333		player->marriage = guid;
8334		lua_pushboolean(L, true);
8335	}
8336	else
8337	{
8338		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8339		lua_pushboolean(L, false);
8340	}
8341
8342	return 1;
8343}
8344
8345int32_t LuaScriptInterface::luaGetPlayerParty(lua_State* L)
8346{
8347	//getPlayerParty(cid)
8348	uint32_t cid = popNumber(L);
8349
8350	ScriptEnviroment* env = getEnv();
8351	if(Player* player = env->getPlayerByUID(cid))
8352	{
8353		if(Party* party = player->getParty())
8354			lua_pushnumber(L, env->addThing(party->getLeader()));
8355		else
8356			lua_pushnil(L);
8357	}
8358	else
8359	{
8360		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8361		lua_pushboolean(L, false);
8362	}
8363
8364	return 1;
8365}
8366
8367int32_t LuaScriptInterface::luaDoPlayerJoinParty(lua_State* L)
8368{
8369	//doPlayerJoinParty(cid, lid)
8370	ScriptEnviroment* env = getEnv();
8371
8372	Player* leader = env->getPlayerByUID(popNumber(L));
8373	if(!leader)
8374	{
8375		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8376		lua_pushboolean(L, false);
8377	}
8378
8379	Player* player = env->getPlayerByUID(popNumber(L));
8380	if(!player)
8381	{
8382		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8383		lua_pushboolean(L, false);
8384	}
8385
8386	g_game.playerJoinParty(player->getID(), leader->getID());
8387	lua_pushboolean(L, true);
8388	return 1;
8389}
8390
8391int32_t LuaScriptInterface::luaGetPartyMembers(lua_State* L)
8392{
8393	//getPartyMembers(cid)
8394	ScriptEnviroment* env = getEnv();
8395	if(Player* player = env->getPlayerByUID(popNumber(L)))
8396	{
8397		if(Party* party = player->getParty())
8398		{
8399			PlayerVector list = party->getMembers();
8400			list.push_back(party->getLeader());
8401
8402			PlayerVector::const_iterator it = list.begin();
8403			lua_newtable(L);
8404			for(uint32_t i = 1; it != list.end(); ++it, ++i)
8405			{
8406				lua_pushnumber(L, i);
8407				lua_pushnumber(L, (*it)->getID());
8408				pushTable(L);
8409			}
8410
8411			return 1;
8412		}
8413	}
8414
8415	lua_pushboolean(L, false);
8416	return 1;
8417}
8418
8419int32_t LuaScriptInterface::luaGetVocationInfo(lua_State* L)
8420{
8421	//getVocationInfo(id)
8422	uint32_t id = popNumber(L);
8423	Vocation* voc = Vocations::getInstance()->getVocation(id);
8424	if(!voc)
8425	{
8426		lua_pushboolean(L, false);
8427		return 1;
8428	}
8429
8430	lua_newtable(L);
8431	setField(L, "id", voc->getId());
8432	setField(L, "name", voc->getName().c_str());
8433	setField(L, "description", voc->getDescription().c_str());
8434	setField(L, "healthGain", voc->getGain(GAIN_HEALTH));
8435	setField(L, "healthGainTicks", voc->getGainTicks(GAIN_HEALTH));
8436	setField(L, "healthGainAmount", voc->getGainAmount(GAIN_HEALTH));
8437	setField(L, "manaGain", voc->getGain(GAIN_MANA));
8438	setField(L, "manaGainTicks", voc->getGainTicks(GAIN_MANA));
8439	setField(L, "manaGainAmount", voc->getGainAmount(GAIN_MANA));
8440	setField(L, "attackSpeed", voc->getAttackSpeed());
8441	setField(L, "baseSpeed", voc->getBaseSpeed());
8442	setField(L, "fromVocation", voc->getFromVocation());
8443	setField(L, "promotedVocation", Vocations::getInstance()->getPromotedVocation(id));
8444	setField(L, "soul", voc->getGain(GAIN_SOUL));
8445	setField(L, "soulAmount", voc->getGainAmount(GAIN_SOUL));
8446	setField(L, "soulTicks", voc->getGainTicks(GAIN_SOUL));
8447	setField(L, "capacity", voc->getGainCap());
8448	setFieldBool(L, "attackable", voc->isAttackable());
8449	setFieldBool(L, "needPremium", voc->isPremiumNeeded());
8450	setFieldFloat(L, "experienceMultiplier", voc->getExperienceMultiplier());
8451	return 1;
8452}
8453
8454int32_t LuaScriptInterface::luaGetGroupInfo(lua_State* L)
8455{
8456	//getGroupInfo(id[, premium])
8457	bool premium = false;
8458	if(lua_gettop(L) > 1)
8459		premium = popNumber(L);
8460
8461	Group* group = Groups::getInstance()->getGroup(popNumber(L));
8462	if(!group)
8463	{
8464		lua_pushboolean(L, false);
8465		return 1;
8466	}
8467
8468	lua_newtable(L);
8469	setField(L, "id", group->getId());
8470	setField(L, "name", group->getName().c_str());
8471	setField(L, "access", group->getAccess());
8472	setField(L, "ghostAccess", group->getGhostAccess());
8473	setField(L, "violationReasons", group->getViolationReasons());
8474	setField(L, "statementViolationFlags", group->getStatementViolationFlags());
8475	setField(L, "nameViolationFlags", group->getNameViolationFlags());
8476	setField(L, "flags", group->getFlags());
8477	setField(L, "customFlags", group->getCustomFlags());
8478	setField(L, "depotLimit", group->getDepotLimit(premium));
8479	setField(L, "maxVips", group->getMaxVips(premium));
8480	setField(L, "outfit", group->getOutfit());
8481	return 1;
8482}
8483
8484int32_t LuaScriptInterface::luaGetChannelUsers(lua_State* L)
8485{
8486	//getChannelUsers(channelId)
8487	ScriptEnviroment* env = getEnv();
8488	uint16_t channelId = popNumber(L);
8489
8490	if(ChatChannel* channel = g_chat.getChannelById(channelId))
8491	{
8492		UsersMap usersMap = channel->getUsers();
8493		UsersMap::iterator it = usersMap.begin();
8494
8495		lua_newtable(L);
8496		for(int32_t i = 1; it != usersMap.end(); ++it, ++i)
8497		{
8498			lua_pushnumber(L, i);
8499			lua_pushnumber(L, env->addThing(it->second));
8500			pushTable(L);
8501		}
8502	}
8503	else
8504		lua_pushboolean(L, false);
8505
8506	return 1;
8507}
8508
8509int32_t LuaScriptInterface::luaGetPlayersOnline(lua_State* L)
8510{
8511	//getPlayersOnline()
8512	ScriptEnviroment* env = getEnv();
8513	AutoList<Player>::iterator it = Player::autoList.begin();
8514
8515	lua_newtable(L);
8516	for(int32_t i = 1; it != Player::autoList.end(); ++it, ++i)
8517	{
8518		lua_pushnumber(L, i);
8519		lua_pushnumber(L, env->addThing(it->second));
8520		pushTable(L);
8521	}
8522	return 1;
8523}
8524
8525int32_t LuaScriptInterface::luaSetCreatureMaxHealth(lua_State* L)
8526{
8527	//setCreatureMaxHealth(uid, health)
8528	uint32_t maxHealth = (uint32_t)popNumber(L);
8529
8530	ScriptEnviroment* env = getEnv();
8531	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8532	{
8533		creature->changeMaxHealth(maxHealth);
8534		lua_pushboolean(L, true);
8535	}
8536	else
8537	{
8538		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8539		lua_pushboolean(L, false);
8540	}
8541	return 1;
8542}
8543
8544int32_t LuaScriptInterface::luaSetCreatureMaxMana(lua_State* L)
8545{
8546	//setCreatureMaxMana(uid, mana)
8547	uint32_t maxMana = (uint32_t)popNumber(L);
8548
8549	ScriptEnviroment* env = getEnv();
8550	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8551	{
8552		creature->changeMaxMana(maxMana);
8553		lua_pushboolean(L, true);
8554	}
8555	else
8556	{
8557		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8558		lua_pushboolean(L, false);
8559	}
8560	return 1;
8561}
8562
8563int32_t LuaScriptInterface::luaDoPlayerSetMaxCapacity(lua_State* L)
8564{
8565	//doPlayerSetMaxCapacity(uid, cap)
8566	double cap = popFloatNumber(L);
8567
8568	ScriptEnviroment* env = getEnv();
8569	if(Player* player = env->getPlayerByUID(popNumber(L)))
8570	{
8571		player->setCapacity(cap);
8572		lua_pushboolean(L, true);
8573	}
8574	else
8575	{
8576		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8577		lua_pushboolean(L, false);
8578	}
8579	return 1;
8580}
8581
8582int32_t LuaScriptInterface::luaGetCreatureMaster(lua_State* L)
8583{
8584	//getCreatureMaster(cid)
8585	uint32_t cid = popNumber(L);
8586
8587	ScriptEnviroment* env = getEnv();
8588
8589	Creature* creature = env->getCreatureByUID(cid);
8590	if(!creature)
8591	{
8592		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8593		lua_pushboolean(L, false);
8594		return 1;
8595	}
8596
8597	Creature* master = creature->getMaster();
8598	lua_pushnumber(L, master ? env->addThing(master) : cid);
8599	return 1;
8600}
8601
8602int32_t LuaScriptInterface::luaGetCreatureSummons(lua_State* L)
8603{
8604	//getCreatureSummons(cid)
8605	ScriptEnviroment* env = getEnv();
8606
8607	Creature* creature = env->getCreatureByUID(popNumber(L));
8608	if(!creature)
8609	{
8610		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8611		lua_pushboolean(L, false);
8612		return 1;
8613	}
8614
8615	const std::list<Creature*>& summons = creature->getSummons();
8616	CreatureList::const_iterator it = summons.begin();
8617
8618	lua_newtable(L);
8619	for(uint32_t i = 1; it != summons.end(); ++it, ++i)
8620	{
8621		lua_pushnumber(L, i);
8622		lua_pushnumber(L, env->addThing(*it));
8623		pushTable(L);
8624	}
8625
8626	return 1;
8627}
8628
8629int32_t LuaScriptInterface::luaDoPlayerSetIdleTime(lua_State* L)
8630{
8631	//doPlayerSetIdleTime(cid, amount)
8632	int64_t amount = popNumber(L);
8633	ScriptEnviroment* env = getEnv();
8634	if(Player* player = env->getPlayerByUID(popNumber(L)))
8635	{
8636		player->setIdleTime(amount);
8637		lua_pushboolean(L, true);
8638	}
8639	else
8640	{
8641		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8642		lua_pushboolean(L, false);
8643	}
8644	return 1;
8645}
8646
8647int32_t LuaScriptInterface::luaDoCreatureSetNoMove(lua_State* L)
8648{
8649	//doCreatureSetNoMove(cid, block)
8650	bool block = popNumber(L);
8651
8652	ScriptEnviroment* env = getEnv();
8653	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8654	{
8655		creature->setNoMove(block);
8656		lua_pushboolean(L, true);
8657	}
8658	else
8659	{
8660		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8661		lua_pushboolean(L, false);
8662	}
8663
8664	return 1;
8665}
8666
8667int32_t LuaScriptInterface::luaGetPlayerRates(lua_State* L)
8668{
8669	//getPlayerRates(cid)
8670	ScriptEnviroment* env = getEnv();
8671
8672	Player* player = env->getPlayerByUID(popNumber(L));
8673	if(!player)
8674	{
8675		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8676		lua_pushboolean(L, false);
8677		return 1;
8678	}
8679
8680	lua_newtable(L);
8681	for(uint32_t i = SKILL_FIRST; i <= SKILL__LAST; ++i)
8682	{
8683		lua_pushnumber(L, i);
8684		lua_pushnumber(L, player->rates[(skills_t)i]);
8685		pushTable(L);
8686	}
8687
8688	return 1;
8689}
8690
8691int32_t LuaScriptInterface::luaDoPlayerSetRate(lua_State* L)
8692{
8693	//doPlayerSetRate(cid, type, value)
8694	float value = popFloatNumber(L);
8695	uint32_t type = popNumber(L);
8696
8697	ScriptEnviroment* env = getEnv();
8698	if(Player* player = env->getPlayerByUID(popNumber(L)))
8699	{
8700		if(type <= SKILL__LAST)
8701		{
8702			player->rates[(skills_t)type] = value;
8703			lua_pushboolean(L, true);
8704		}
8705		else
8706			lua_pushboolean(L, false);
8707	}
8708	else
8709	{
8710		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8711		lua_pushboolean(L, false);
8712	}
8713
8714	return 1;
8715}
8716
8717int32_t LuaScriptInterface::luaDoPlayerSwitchSaving(lua_State* L)
8718{
8719	//doPlayerSwitchSaving(cid)
8720	ScriptEnviroment* env = getEnv();
8721	if(Player* player = env->getPlayerByUID(popNumber(L)))
8722	{
8723		player->switchSaving();
8724		lua_pushboolean(L, true);
8725	}
8726	else
8727	{
8728		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8729		lua_pushboolean(L, false);
8730	}
8731	return 1;
8732}
8733
8734int32_t LuaScriptInterface::luaDoPlayerSave(lua_State* L)
8735{
8736	//doPlayerSave(cid[, shallow = false])
8737	bool shallow = false;
8738	if(lua_gettop(L) > 1)
8739		shallow = popNumber(L);
8740
8741	ScriptEnviroment* env = getEnv();
8742	if(Player* player = env->getPlayerByUID(popNumber(L)))
8743		lua_pushboolean(L, IOLoginData::getInstance()->savePlayer(player, false, shallow));
8744	else
8745	{
8746		errorEx(getError(LUA_ERROR_PLAYER_NOT_FOUND));
8747		lua_pushboolean(L, false);
8748	}
8749	return 1;
8750}
8751
8752int32_t LuaScriptInterface::luaGetTownId(lua_State* L)
8753{
8754	//getTownId(townName)
8755	std::string townName = popString(L);
8756	if(Town* town = Towns::getInstance()->getTown(townName))
8757		lua_pushnumber(L, town->getID());
8758	else
8759		lua_pushboolean(L, false);
8760
8761	return 1;
8762}
8763
8764int32_t LuaScriptInterface::luaGetTownName(lua_State* L)
8765{
8766	//getTownName(townId)
8767	uint32_t townId = popNumber(L);
8768	if(Town* town = Towns::getInstance()->getTown(townId))
8769		lua_pushstring(L, town->getName().c_str());
8770	else
8771		lua_pushboolean(L, false);
8772
8773	return 1;
8774}
8775
8776int32_t LuaScriptInterface::luaGetTownTemplePosition(lua_State* L)
8777{
8778	//getTownTemplePosition(townId)
8779	bool displayError = true;
8780	if(lua_gettop(L) >= 2)
8781		displayError = popNumber(L);
8782
8783	uint32_t townId = popNumber(L);
8784	if(Town* town = Towns::getInstance()->getTown(townId))
8785		pushPosition(L, town->getPosition(), 255);
8786	else
8787		lua_pushboolean(L, false);
8788
8789	return 1;
8790}
8791
8792int32_t LuaScriptInterface::luaGetTownHouses(lua_State* L)
8793{
8794	//getTownHouses(townId)
8795	uint32_t townId = 0;
8796	if(lua_gettop(L) > 0)
8797		townId = popNumber(L);
8798
8799	HouseMap::iterator it = Houses::getInstance()->getHouseBegin();
8800	lua_newtable(L);
8801	for(uint32_t i = 1; it != Houses::getInstance()->getHouseEnd(); ++i, ++it)
8802	{
8803		if(townId != 0 && it->second->getTownId() != townId)
8804			continue;
8805
8806		lua_pushnumber(L, i);
8807		lua_pushnumber(L, it->second->getId());
8808		pushTable(L);
8809	}
8810
8811	return 1;
8812}
8813
8814int32_t LuaScriptInterface::luaGetSpectators(lua_State* L)
8815{
8816	//getSpectators(centerPos, rangex, rangey[, multifloor = false])
8817	bool multifloor = false;
8818	if(lua_gettop(L) > 3)
8819		multifloor = popNumber(L);
8820
8821	uint32_t rangey = popNumber(L), rangex = popNumber(L);
8822	PositionEx centerPos;
8823	popPosition(L, centerPos);
8824
8825	SpectatorVec list;
8826	g_game.getSpectators(list, centerPos, false, multifloor, rangex, rangex, rangey, rangey);
8827	if(list.empty())
8828	{
8829		lua_pushnil(L);
8830		return 1;
8831	}
8832
8833	ScriptEnviroment* env = getEnv();
8834	SpectatorVec::const_iterator it = list.begin();
8835
8836	lua_newtable(L);
8837	for(uint32_t i = 1; it != list.end(); ++it, ++i)
8838	{
8839		lua_pushnumber(L, i);
8840		lua_pushnumber(L, env->addThing(*it));
8841		pushTable(L);
8842	}
8843
8844	return 1;
8845}
8846
8847int32_t LuaScriptInterface::luaGetHighscoreString(lua_State* L)
8848{
8849	//getHighscoreString(skillId)
8850	uint16_t skillId = popNumber(L);
8851	if(skillId <= SKILL__LAST)
8852		lua_pushstring(L, g_game.getHighscoreString(skillId).c_str());
8853	else
8854		lua_pushboolean(L, false);
8855
8856	return 1;
8857}
8858
8859int32_t LuaScriptInterface::luaGetWaypointList(lua_State* L)
8860{
8861	//getWaypointList()
8862	WaypointMap waypointsMap = g_game.getMap()->waypoints.getWaypointsMap();
8863	WaypointMap::iterator it = waypointsMap.begin();
8864
8865	lua_newtable(L);
8866	for(uint32_t i = 1; it != waypointsMap.end(); ++it, ++i)
8867	{
8868		createTable(L, i);
8869		setField(L, "name", it->first);
8870		setField(L, "pos", it->second->pos.x);
8871		pushTable(L);
8872	}
8873
8874	return 1;
8875}
8876
8877int32_t LuaScriptInterface::luaGetWaypointPosition(lua_State* L)
8878{
8879	//getWaypointPosition(name)
8880	if(WaypointPtr waypoint = g_game.getMap()->waypoints.getWaypointByName(popString(L)))
8881		pushPosition(L, waypoint->pos, 0);
8882	else
8883		lua_pushboolean(L, false);
8884
8885	return 1;
8886}
8887
8888int32_t LuaScriptInterface::luaDoWaypointAddTemporial(lua_State* L)
8889{
8890	//doWaypointAddTemporial(name, pos)
8891	PositionEx pos;
8892	popPosition(L, pos);
8893
8894	g_game.getMap()->waypoints.addWaypoint(WaypointPtr(new Waypoint(popString(L), pos)));
8895	lua_pushboolean(L, true);
8896	return 1;
8897}
8898
8899int32_t LuaScriptInterface::luaGetGameState(lua_State* L)
8900{
8901	//getGameState()
8902	lua_pushnumber(L, g_game.getGameState());
8903	return 1;
8904}
8905
8906int32_t LuaScriptInterface::luaDoSetGameState(lua_State* L)
8907{
8908	//doSetGameState(id)
8909	uint32_t id = popNumber(L);
8910	if(id >= GAME_STATE_FIRST && id <= GAME_STATE_LAST)
8911	{
8912		Dispatcher::getInstance().addTask(createTask(boost::bind(&Game::setGameState, &g_game, (GameState_t)id)));
8913		lua_pushboolean(L, true);
8914	}
8915	else
8916		lua_pushboolean(L, false);
8917
8918	return 1;
8919}
8920
8921int32_t LuaScriptInterface::luaDoCreatureExecuteTalkAction(lua_State* L)
8922{
8923	//doCreatureExecuteTalkAction(cid, text[, ignoreAccess[, channelId]])
8924	uint32_t params = lua_gettop(L), channelId = CHANNEL_DEFAULT;
8925	if(params > 3)
8926		channelId = popNumber(L);
8927
8928	bool ignoreAccess = false;
8929	if(params > 2)
8930		ignoreAccess = popNumber(L);
8931
8932	std::string text = popString(L);
8933	ScriptEnviroment* env = getEnv();
8934	if(Creature* creature = env->getCreatureByUID(popNumber(L)))
8935		lua_pushboolean(L, g_talkActions->onPlayerSay(creature, channelId, text, ignoreAccess));
8936	else
8937	{
8938		errorEx(getError(LUA_ERROR_CREATURE_NOT_FOUND));
8939		lua_pushboolean(L, false);
8940	}
8941
8942	return 1;
8943}
8944
8945int32_t LuaScriptInterface::luaDoExecuteRaid(lua_State* L)
8946{
8947	//doExecuteRaid(name)
8948	std::string raidName = popString(L);
8949	if(Raids::getInstance()->getRunning())
8950	{
8951		lua_pushboolean(L, false);
8952		return 1;
8953	}
8954
8955	Raid* raid = Raids::getInstance()->getRaidByName(raidName);
8956	if(!raid || !raid->isLoaded())
8957	{
8958		errorEx("Raid with name " + raidName + " does not exists.");
8959		lua_pushboolean(L, false);
8960		return 1;
8961	}
8962
8963	lua_pushboolean(L, raid->startRaid());
8964	return 1;
8965}
8966
8967int32_t LuaScriptInterface::luaDoReloadInfo(lua_State* L)
8968{
8969	//doReloadInfo(id[, cid])
8970	uint32_t cid = 0;
8971	if(lua_gettop(L) > 1)
8972		cid = popNumber(L);
8973
8974	uint32_t id = popNumber(L);
8975	if(id >= RELOAD_FIRST && id <= RELOAD_LAST)
8976	{
8977		Scheduler::getInstance().addEvent(createSchedulerTask(SCHEDULER_MINTICKS,
8978			boost::bind(&Game::reloadInfo, &g_game, (ReloadInfo_t)id, cid)));
8979		lua_pushboolean(L, true);
8980	}
8981	else
8982		lua_pushboolean(L, false);
8983
8984	return 1;
8985}
8986
8987int32_t LuaScriptInterface::luaDoSaveServer(lua_State* L)
8988{
8989	//doSaveServer([shallow])
8990	bool shallow = false;
8991	if(lua_gettop(L) > 0)
8992		shallow = popNumber(L);
8993
8994	Dispatcher::getInstance().addTask(createTask(boost::bind(&Game::saveGameState, &g_game, shallow)));
8995	return 1;
8996}
8997
8998int32_t LuaScriptInterface::luaDoCleanHouse(lua_State* L)
8999{
9000	//doCleanHouse(houseId)
9001	uint32_t houseId = popNumber(L);
9002	if(House* house = Houses::getInstance()->getHouse(houseId))
9003	{
9004		house->clean();
9005		lua_pushboolean(L, true);
9006	}
9007	else
9008		lua_pushboolean(L, false);
9009
9010	return 1;
9011}
9012
9013int32_t LuaScriptInterface::luaDoCleanMap(lua_State* L)
9014{
9015	//doCleanMap()
9016	uint32_t count = 0;
9017	g_game.cleanMap(count);
9018	lua_pushnumber(L, count);
9019	return 1;
9020}
9021
9022int32_t LuaScriptInterface::luaDoRefreshMap(lua_State* L)
9023{
9024	//doRefreshMap()
9025	g_game.proceduralRefresh();
9026	return 1;
9027}
9028
9029int32_t LuaScriptInterface::luaDoUpdateHouseAuctions(lua_State* L)
9030{
9031	//doUpdateHouseAuctions()
9032	lua_pushboolean(L, IOMapSerialize::getInstance()->updateAuctions());
9033	return 1;
9034}
9035
9036int32_t LuaScriptInterface::luaGetItemIdByName(lua_State* L)
9037{
9038	//getItemIdByName(name[, displayError = true])
9039	bool displayError = true;
9040	if(lua_gettop(L) >= 2)
9041		displayError = popNumber(L);
9042
9043	int32_t itemId = Item::items.getItemIdByName(popString(L));
9044	if(itemId == -1)
9045	{
9046		if(displayError)
9047			errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
9048
9049		lua_pushboolean(L, false);
9050	}
9051	else
9052		lua_pushnumber(L, itemId);
9053
9054	return 1;
9055}
9056
9057int32_t LuaScriptInterface::luaGetItemInfo(lua_State* L)
9058{
9059	//getItemInfo(itemid)
9060	const ItemType* item;
9061	if(!(item = Item::items.getElement(popNumber(L))))
9062	{
9063		lua_pushboolean(L, false);
9064		return 1;
9065	}
9066
9067	lua_newtable(L);
9068	setFieldBool(L, "stopTime", item->stopTime);
9069	setFieldBool(L, "showCount", item->showCount);
9070	setFieldBool(L, "clientCharges", item->clientCharges);
9071	setFieldBool(L, "stackable", item->stackable);
9072	setFieldBool(L, "showDuration", item->showDuration);
9073	setFieldBool(L, "showCharges", item->showCharges);
9074	setFieldBool(L, "showAttributes", item->showCharges);
9075	setFieldBool(L, "distRead", item->allowDistRead);
9076	setFieldBool(L, "readable", item->canReadText);
9077	setFieldBool(L, "writable", item->canWriteText);
9078	setFieldBool(L, "forceSerialize", item->forceSerialize);
9079	setFieldBool(L, "vertical", item->isVertical);
9080	setFieldBool(L, "horizontal", item->isHorizontal);
9081	setFieldBool(L, "hangable", item->isHangable);
9082	setFieldBool(L, "usable", item->useable);
9083	setFieldBool(L, "movable", item->moveable);
9084	setFieldBool(L, "pickupable", item->pickupable);
9085	setFieldBool(L, "rotable", item->rotable);
9086	setFieldBool(L, "replacable", item->replaceable);
9087	setFieldBool(L, "hasHeight", item->hasHeight);
9088	setFieldBool(L, "blockSolid", item->blockSolid);
9089	setFieldBool(L, "blockPickupable", item->blockPickupable);
9090	setFieldBool(L, "blockProjectile", item->blockProjectile);
9091	setFieldBool(L, "blockPathing", item->blockPathFind);
9092	setFieldBool(L, "allowPickupable", item->allowPickupable);
9093	setFieldBool(L, "alwaysOnTop", item->alwaysOnTop);
9094
9095	createTable(L, "floorChange");
9096	for(int32_t i = CHANGE_FIRST; i <= CHANGE_LAST; ++i)
9097	{
9098		lua_pushnumber(L, i);
9099		lua_pushboolean(L, item->floorChange[i - 1]);
9100		pushTable(L);
9101	}
9102
9103	pushTable(L);
9104	setField(L, "magicEffect", (int32_t)item->magicEffect);
9105	setField(L, "fluidSource", (int32_t)item->fluidSource);
9106	setField(L, "weaponType", (int32_t)item->weaponType);
9107	setField(L, "bedPartnerDirection", (int32_t)item->bedPartnerDir);
9108	setField(L, "ammoAction", (int32_t)item->ammoAction);
9109	setField(L, "combatType", (int32_t)item->combatType);
9110	setField(L, "corpseType", (int32_t)item->corpseType);
9111	setField(L, "shootType", (int32_t)item->shootType);
9112	setField(L, "ammoType", (int32_t)item->ammoType);
9113
9114	createTable(L, "transformUseTo");
9115	setField(L, "female", item->transformUseTo[PLAYERSEX_FEMALE]);
9116	setField(L, "male", item->transformUseTo[PLAYERSEX_MALE]);
9117
9118	pushTable(L);
9119	setField(L, "transformToFree", item->transformToFree);
9120	setField(L, "transformEquipTo", item->transformEquipTo);
9121	setField(L, "transformDeEquipTo", item->transformDeEquipTo);
9122	setField(L, "clientId", item->clientId);
9123	setField(L, "maxItems", item->maxItems);
9124	setField(L, "slotPosition", item->slotPosition);
9125	setField(L, "wieldPosition", item->wieldPosition);
9126	setField(L, "speed", item->speed);
9127	setField(L, "maxTextLength", item->maxTextLen);
9128	setField(L, "writeOnceItemId", item->writeOnceItemId);
9129	setField(L, "attack", item->attack);
9130	setField(L, "extraAttack", item->extraAttack);
9131	setField(L, "defense", item->defense);
9132	setField(L, "extraDefense", item->extraDefense);
9133	setField(L, "armor", item->armor);
9134	setField(L, "breakChance", item->breakChance);
9135	setField(L, "hitChance", item->hitChance);
9136	setField(L, "maxHitChance", item->maxHitChance);
9137	setField(L, "runeLevel", item->runeLevel);
9138	setField(L, "runeMagicLevel", item->runeMagLevel);
9139	setField(L, "lightLevel", item->lightLevel);
9140	setField(L, "lightColor", item->lightColor);
9141	setField(L, "decayTo", item->decayTo);
9142	setField(L, "rotateTo", item->rotateTo);
9143	setField(L, "alwaysOnTopOrder", item->alwaysOnTopOrder);
9144	setField(L, "shootRange", item->shootRange);
9145	setField(L, "charges", item->charges);
9146	setField(L, "decayTime", item->decayTime);
9147	setField(L, "attackSpeed", item->attackSpeed);
9148	setField(L, "wieldInfo", item->wieldInfo);
9149	setField(L, "minRequiredLevel", item->minReqLevel);
9150	setField(L, "minRequiredMagicLevel", item->minReqMagicLevel);
9151	setField(L, "worth", item->worth);
9152	setField(L, "levelDoor", item->levelDoor);
9153	setField(L, "name", item->name.c_str());
9154	setField(L, "plural", item->pluralName.c_str());
9155	setField(L, "article", item->article.c_str());
9156	setField(L, "description", item->description.c_str());
9157	setField(L, "runeSpellName", item->runeSpellName.c_str());
9158	setField(L, "vocationString", item->vocationString.c_str());
9159
9160	createTable(L, "abilities");
9161	setFieldBool(L, "manaShield", item->abilities.manaShield);
9162	setFieldBool(L, "invisible", item->abilities.invisible);
9163	setFieldBool(L, "regeneration", item->abilities.regeneration);
9164	setFieldBool(L, "preventLoss", item->abilities.preventLoss);
9165	setFieldBool(L, "preventDrop", item->abilities.preventDrop);
9166	setField(L, "elementType", (int32_t)item->abilities.elementType);
9167	setField(L, "elementDamage", item->abilities.elementDamage);
9168	setField(L, "speed", item->abilities.speed);
9169	setField(L, "healthGain", item->abilities.healthGain);
9170	setField(L, "healthTicks", item->abilities.healthTicks);
9171	setField(L, "manaGain", item->abilities.manaGain);
9172	setField(L, "manaTicks", item->abilities.manaTicks);
9173	setField(L, "conditionSuppressions", item->abilities.conditionSuppressions);
9174
9175	//TODO: absorb, increment, reflect, skills, skillsPercent, stats, statsPercent
9176
9177	pushTable(L);
9178	setField(L, "group", (int32_t)item->group);
9179	setField(L, "type", (int32_t)item->type);
9180	setFieldFloat(L, "weight", item->weight);
9181	return 1;
9182}
9183
9184int32_t LuaScriptInterface::luaGetItemAttribute(lua_State* L)
9185{
9186	//getItemAttribute(uid, key)
9187	std::string key = popString(L);
9188	ScriptEnviroment* env = getEnv();
9189
9190	Item* item = env->getItemByUID(popNumber(L));
9191	if(!item)
9192	{
9193		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
9194		lua_pushnil(L);
9195		return 1;
9196	}
9197
9198	boost::any value = item->getAttribute(key);
9199	if(value.empty())
9200		lua_pushnil(L);
9201	else if(value.type() == typeid(std::string))
9202		lua_pushstring(L, boost::any_cast<std::string>(value).c_str());
9203	else if(value.type() == typeid(int32_t))
9204		lua_pushnumber(L, boost::any_cast<int32_t>(value));
9205	else if(value.type() == typeid(float))
9206		lua_pushnumber(L, boost::any_cast<float>(value));
9207	else if(value.type() == typeid(bool))
9208		lua_pushboolean(L, boost::any_cast<bool>(value));
9209	else
9210		lua_pushnil(L);
9211
9212	return 1;
9213}
9214
9215int32_t LuaScriptInterface::luaDoItemSetAttribute(lua_State* L)
9216{
9217	//doItemSetAttribute(uid, key, value)
9218	boost::any value;
9219	if(lua_isnumber(L, -1))
9220	{
9221		float tmp = popFloatNumber(L);
9222		if(std::floor(tmp) < tmp)
9223			value = tmp;
9224		else
9225			value = (int32_t)tmp;
9226	}
9227	else if(lua_isboolean(L, -1))
9228		value = popBoolean(L);
9229	else if(lua_isstring(L, -1))
9230		value = popString(L);
9231	else
9232	{
9233		lua_pop(L, 1);
9234		errorEx("Invalid data type");
9235
9236		lua_pushboolean(L, false);
9237		return 1;
9238	}
9239
9240	std::string key = popString(L);
9241	ScriptEnviroment* env = getEnv();
9242
9243	Item* item = env->getItemByUID(popNumber(L));
9244	if(!item)
9245	{
9246		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
9247		lua_pushboolean(L, false);
9248		return 1;
9249	}
9250
9251	if(value.type() == typeid(int32_t))
9252	{
9253		if(key == "uid")
9254		{
9255			int32_t tmp = boost::any_cast<int32_t>(value);
9256			if(tmp < 1000 || tmp > 0xFFFF)
9257			{
9258				errorEx("Value for protected key \"uid\" must be in range of 1000 to 65535");
9259				lua_pushboolean(L, false);
9260				return 1;
9261			}
9262
9263			item->setUniqueId(tmp);
9264		}		
9265		else if(key == "aid")
9266			item->setActionId(boost::any_cast<int32_t>(value));
9267		else
9268			item->setAttribute(key, boost::any_cast<int32_t>(value));
9269	}
9270	else
9271		item->setAttribute(key, value);
9272
9273	lua_pushboolean(L, true);
9274	return 1;
9275}
9276
9277int32_t LuaScriptInterface::luaDoItemEraseAttribute(lua_State* L)
9278{
9279	//doItemEraseAttribute(uid, key)
9280	std::string key = popString(L);
9281	ScriptEnviroment* env = getEnv();
9282
9283	Item* item = env->getItemByUID(popNumber(L));
9284	if(!item)
9285	{
9286		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
9287		lua_pushboolean(L, false);
9288		return 1;
9289	}
9290
9291	bool ret = true;
9292	if(key == "uid")
9293	{
9294		errorEx("Attempt to erase protected key \"uid\".");
9295		ret = false;
9296	}
9297	else if(key != "aid")
9298		item->eraseAttribute(key);
9299	else
9300		item->resetActionId();
9301
9302	lua_pushboolean(L, ret);
9303	return 1;
9304}
9305
9306int32_t LuaScriptInterface::luaGetItemWeight(lua_State* L)
9307{
9308	//getItemWeight(itemid[, precise = true])
9309	bool precise = true;
9310	if(lua_gettop(L) > 2)
9311		precise = popNumber(L);
9312
9313	ScriptEnviroment* env = getEnv();
9314	Item* item = env->getItemByUID(popNumber(L));
9315	if(!item)
9316	{
9317		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
9318		lua_pushboolean(L, false);
9319		return 1;
9320	}
9321
9322	double weight = item->getWeight();
9323	if(precise)
9324	{
9325		std::stringstream ws;
9326		ws << std::fixed << std::setprecision(2) << weight;
9327		weight = atof(ws.str().c_str());
9328	}
9329
9330	lua_pushnumber(L, weight);
9331	return 1;
9332}
9333
9334int32_t LuaScriptInterface::luaHasItemProperty(lua_State* L)
9335{
9336	//hasItemProperty(uid, prop)
9337	uint32_t prop = popNumber(L);
9338	ScriptEnviroment* env = getEnv();
9339
9340	Item* item = env->getItemByUID(popNumber(L));
9341	if(!item)
9342	{
9343		errorEx(getError(LUA_ERROR_ITEM_NOT_FOUND));
9344		lua_pushboolean(L, false);
9345		return 1;
9346	}
9347
9348	//Check if the item is a tile, so we can get more accurate properties
9349	bool tmp = item->hasProperty((ITEMPROPERTY)prop);
9350	if(item->getTile() && item->getTile()->ground == item)
9351		tmp = item->getTile()->hasProperty((ITEMPROPERTY)prop);
9352
9353	lua_pushboolean(L, tmp);
9354	return 1;
9355}
9356
9357int32_t LuaScriptInterface::luaIsIpBanished(lua_State* L)
9358{
9359	//isIpBanished(ip[, mask])
9360	uint32_t mask = 0xFFFFFFFF;
9361	if(lua_gettop(L) > 1)
9362		mask = popNumber(L);
9363
9364	lua_pushboolean(L, IOBan::getInstance()->isIpBanished((uint32_t)popNumber(L), mask));
9365	return 1;
9366}
9367
9368int32_t LuaScriptInterface::luaIsPlayerBanished(lua_State* L)
9369{
9370	//isPlayerBanished(name/guid, type)
9371	PlayerBan_t type = (PlayerBan_t)popNumber(L);
9372	if(lua_isnumber(L, -1))
9373		lua_pushboolean(L, IOBan::getInstance()->isPlayerBanished((uint32_t)popNumber(L), type));
9374	else
9375		lua_pushboolean(L, IOBan::getInstance()->isPlayerBanished(popString(L), type));
9376
9377	return 1;
9378}
9379
9380int32_t LuaScriptInterface::luaIsAccountBanished(lua_State* L)
9381{
9382	//isAccountBanished(accountId[, playerId])
9383	uint32_t playerId = 0;
9384	if(lua_gettop(L) > 1)
9385		playerId = popNumber(L);
9386
9387	lua_pushboolean(L, IOBan::getInstance()->isAccountBanished((uint32_t)popNumber(L), playerId));
9388	return 1;
9389}
9390
9391int32_t LuaScriptInterface::luaDoAddIpBanishment(lua_State* L)
9392{
9393	//doAddIpBanishment(ip[, mask[, length[, reason[, comment[, admin[, statement]]]]]])
9394	uint32_t admin = 0, reason = 21, mask = 0xFFFFFFFF, params = lua_gettop(L);
9395	int64_t length = time(NULL) + g_config.getNumber(ConfigManager::IPBANISHMENT_LENGTH);
9396	std::string statement, comment;
9397
9398	if(params > 6)
9399		statement = popString(L);
9400
9401	if(params > 5)
9402		admin = popNumber(L);
9403
9404	if(params > 4)
9405		comment = popString(L);
9406
9407	if(params > 3)
9408		reason = popNumber(L);
9409
9410	if(params > 2)
9411		length = popNumber(L);
9412
9413	if(params > 1)
9414		mask = popNumber(L);
9415
9416	lua_pushboolean(L, IOBan::getInstance()->addIpBanishment((uint32_t)popNumber(L),
9417		length, reason, comment, admin, mask, statement));
9418	return 1;
9419}
9420
9421int32_t LuaScriptInterface::luaDoAddPlayerBanishment(lua_State* L)
9422{
9423	//doAddPlayerBanishment(name/guid[, type[, length[, reason[, action[, comment[, admin[, statement]]]]]]])
9424	uint32_t admin = 0, reason = 21, params = lua_gettop(L);
9425	int64_t length = -1;
9426	std::string statement, comment;
9427
9428	ViolationAction_t action = ACTION_NAMELOCK;
9429	PlayerBan_t type = PLAYERBAN_LOCK;
9430	if(params > 7)
9431		statement = popString(L);
9432
9433	if(params > 6)
9434		admin = popNumber(L);
9435
9436	if(params > 5)
9437		comment = popString(L);
9438
9439	if(params > 4)
9440		action = (ViolationAction_t)popNumber(L);
9441
9442	if(params > 3)
9443		reason = popNumber(L);
9444
9445	if(params > 2)
9446		length = popNumber(L);
9447
9448	if(params > 1)
9449		type = (PlayerBan_t)popNumber(L);
9450
9451	if(lua_isnumber(L, -1))
9452		lua_pushboolean(L, IOBan::getInstance()->addPlayerBanishment((uint32_t)popNumber(L),
9453			length, reason, action, comment, admin, type, statement));
9454	else
9455		lua_pushboolean(L, IOBan::getInstance()->addPlayerBanishment(popString(L),
9456			length, reason, action, comment, admin, type, statement));
9457
9458	return 1;
9459}
9460
9461int32_t LuaScriptInterface::luaDoAddAccountBanishment(lua_State* L)
9462{
9463	//doAddAccountBanishment(accountId[, playerId[, length[, reason[, action[, comment[, admin[, statement]]]]]]])
9464	uint32_t admin = 0, reason = 21, playerId = 0, params = lua_gettop(L);
9465	int64_t length = time(NULL) + g_config.getNumber(ConfigManager::BAN_LENGTH);
9466	std::string statement, comment;
9467
9468	ViolationAction_t action = ACTION_BANISHMENT;
9469	if(params > 7)
9470		statement = popString(L);
9471
9472	if(params > 6)
9473		admin = popNumber(L);
9474
9475	if(params > 5)
9476		comment = popString(L);
9477
9478	if(params > 4)
9479		action = (ViolationAction_t)popNumber(L);
9480
9481	if(params > 3)
9482
9483		reason = popNumber(L);
9484
9485	if(params > 2)
9486		length = popNumber(L);
9487
9488	if(params > 1)
9489		playerId = popNumber(L);
9490
9491	lua_pushboolean(L, IOBan::getInstance()->addAccountBanishment((uint32_t)popNumber(L),
9492		length, reason, action, comment, admin, playerId, statement));
9493	return 1;
9494}
9495
9496int32_t LuaScriptInterface::luaDoAddNotation(lua_State* L)
9497{
9498	//doAddNotation(accountId[, playerId[, reason[, comment[, admin[, statement]]]]]])
9499	uint32_t admin = 0, reason = 21, playerId = 0, params = lua_gettop(L);
9500	std::string statement, comment;
9501
9502	if(params > 5)
9503		statement = popString(L);
9504
9505	if(params > 4)
9506		admin = popNumber(L);
9507
9508	if(params > 3)
9509		comment = popString(L);
9510
9511	if(params > 2)
9512		reason = popNumber(L);
9513
9514	if(params > 1)
9515		playerId = popNumber(L);
9516
9517	lua_pushboolean(L, IOBan::getInstance()->addNotation((uint32_t)popNumber(L),
9518		reason, comment, admin, playerId, statement));
9519	return 1;
9520}
9521
9522int32_t LuaScriptInterface::luaDoAddStatement(lua_State* L)
9523{
9524	//doAddStatement(name/guid[, channelId[, reason[, comment[, admin[, statement]]]]]])
9525	uint32_t admin = 0, reason = 21, params = lua_gettop(L);
9526	int16_t channelId = -1;
9527	std::string statement, comment;
9528
9529	if(params > 5)
9530		statement = popString(L);
9531
9532	if(params > 4)
9533		admin = popNumber(L);
9534
9535	if(params > 3)
9536		comment = popString(L);
9537
9538	if(params > 2)
9539		reason = popNumber(L);
9540
9541	if(params > 1)
9542		channelId = popNumber(L);
9543
9544	if(lua_isnumber(L, -1))
9545		lua_pushboolean(L, IOBan::getInstance()->addStatement((uint32_t)popNumber(L),
9546			reason, comment, admin, channelId, statement));
9547	else
9548		lua_pushboolean(L, IOBan::getInstance()->addStatement(popString(L),
9549			reason, comment, admin, channelId, statement));
9550
9551	return 1;
9552}
9553
9554int32_t LuaScriptInterface::luaDoRemoveIpBanishment(lua_State* L)
9555{
9556	//doRemoveIpBanishment(ip[, mask])
9557	uint32_t mask = 0xFFFFFFFF;
9558	if(lua_gettop(L) > 1)
9559		mask = popNumber(L);
9560
9561	lua_pushboolean(L, IOBan::getInstance()->removeIpBanishment(
9562		(uint32_t)popNumber(L), mask));
9563	return 1;
9564}
9565
9566int32_t LuaScriptInterface::luaDoRemovePlayerBanishment(lua_State* L)
9567{
9568	//doRemovePlayerBanishment(name/guid, type)
9569	PlayerBan_t type = (PlayerBan_t)popNumber(L);
9570	if(lua_isnumber(L, -1))
9571		lua_pushboolean(L, IOBan::getInstance()->removePlayerBanishment((uint32_t)popNumber(L), type));
9572	else
9573		lua_pushboolean(L, IOBan::getInstance()->removePlayerBanishment(popString(L), type));
9574
9575	return 1;
9576}
9577
9578int32_t LuaScriptInterface::luaDoRemoveAccountBanishment(lua_State* L)
9579{
9580	//doRemoveAccountBanishment(accountId[, playerId])
9581	uint32_t playerId = 0;
9582	if(lua_gettop(L) > 1)
9583		playerId = popNumber(L);
9584
9585	lua_pushboolean(L, IOBan::getInstance()->removeAccountBanishment((uint32_t)popNumber(L), playerId));
9586	return 1;
9587}
9588
9589int32_t LuaScriptInterface::luaDoRemoveNotations(lua_State* L)
9590{
9591	//doRemoveNotations(accountId[, playerId])
9592	uint32_t playerId = 0;
9593	if(lua_gettop(L) > 1)
9594		playerId = popNumber(L);
9595
9596	lua_pushboolean(L, IOBan::getInstance()->removeNotations((uint32_t)popNumber(L), playerId));
9597	return 1;
9598}
9599
9600int32_t LuaScriptInterface::luaDoRemoveStatements(lua_State* L)
9601{
9602	//doRemoveStatements(name/guid[, channelId])
9603	int16_t channelId = -1;
9604	if(lua_gettop(L) > 1)
9605		channelId = popNumber(L);
9606
9607	if(lua_isnumber(L, -1))
9608		lua_pushboolean(L, IOBan::getInstance()->removeStatements((uint32_t)popNumber(L), channelId));
9609	else
9610		lua_pushboolean(L, IOBan::getInstance()->removeStatements(popString(L), channelId));
9611
9612	return 1;
9613}
9614
9615int32_t LuaScriptInterface::luaGetNotationsCount(lua_State* L)
9616{
9617	//getNotationsCount(accountId[, playerId])
9618	uint32_t playerId = 0;
9619	if(lua_gettop(L) > 1)
9620		playerId = popNumber(L);
9621
9622	lua_pushnumber(L, IOBan::getInstance()->getNotationsCount((uint32_t)popNumber(L), playerId));
9623	return 1;
9624}
9625
9626int32_t LuaScriptInterface::luaGetStatementsCount(lua_State* L)
9627{
9628	//getStatementsCount(name/guid[, channelId])
9629	int16_t channelId = -1;
9630	if(lua_gettop(L) > 1)
9631		channelId = popNumber(L);
9632
9633	if(lua_isnumber(L, -1))
9634		lua_pushnumber(L, IOBan::getInstance()->getStatementsCount((uint32_t)popNumber(L), channelId));
9635	else
9636		lua_pushnumber(L, IOBan::getInstance()->getStatementsCount(popString(L), channelId));
9637
9638	return 1;
9639}
9640
9641int32_t LuaScriptInterface::luaGetBanData(lua_State* L)
9642{
9643	//getBanData(value[, type[, param]])
9644	Ban tmp;
9645	uint32_t params = lua_gettop(L);
9646	if(params > 2)
9647		tmp.param = popNumber(L);
9648
9649	if(params > 1)
9650		tmp.type = (Ban_t)popNumber(L);
9651
9652	tmp.value = popNumber(L);
9653	if(!IOBan::getInstance()->getData(tmp))
9654	{
9655		lua_pushboolean(L, false);
9656		return 1;
9657	}
9658
9659	lua_newtable(L);
9660	setField(L, "id", tmp.id);
9661	setField(L, "type", tmp.type);
9662	setField(L, "value", tmp.value);
9663	setField(L, "param", tmp.param);
9664	setField(L, "added", tmp.added);
9665	setField(L, "expires", tmp.expires);
9666	setField(L, "adminId", tmp.adminId);
9667	setField(L, "reason", tmp.reason);
9668	setField(L, "action", tmp.action);
9669	setField(L, "comment", tmp.comment);
9670	setField(L, "statement", tmp.statement);
9671	return 1;
9672}
9673
9674int32_t LuaScriptInterface::luaGetBanReason(lua_State* L)
9675{
9676	//getBanReason(id)
9677	lua_pushstring(L, getReason((ViolationAction_t)popNumber(L)).c_str());
9678	return 1;
9679}
9680
9681int32_t LuaScriptInterface::luaGetBanAction(lua_State* L)
9682{
9683	//getBanAction(id[, ipBanishment])
9684	bool ipBanishment = false;
9685	if(lua_gettop(L) > 1)
9686		ipBanishment = popNumber(L);
9687
9688	lua_pushstring(L, getAction((ViolationAction_t)popNumber(L), ipBanishment).c_str());
9689	return 1;
9690}
9691
9692int32_t LuaScriptInterface::luaGetBanList(lua_State* L)
9693{
9694	//getBanList(type[, value[, param]])
9695	int32_t param = 0, params = lua_gettop(L);
9696	if(params > 2)
9697		param = popNumber(L);
9698
9699	uint32_t value = 0;
9700	if(params > 1)
9701		value = popNumber(L);
9702
9703	BansVec bans = IOBan::getInstance()->getList((Ban_t)popNumber(L), value, param);
9704	BansVec::const_iterator it = bans.begin();
9705
9706	lua_newtable(L);
9707	for(uint32_t i = 1; it != bans.end(); ++it, ++i)
9708	{
9709		createTable(L, i);
9710		setField(L, "id", it->id);
9711		setField(L, "type", it->type);
9712		setField(L, "value", it->value);
9713		setField(L, "param", it->param);
9714		setField(L, "added", it->added);
9715		setField(L, "expires", it->expires);
9716		setField(L, "adminId", it->adminId);
9717		setField(L, "reason", it->reason);
9718		setField(L, "action", it->action);
9719		setField(L, "comment", it->comment);
9720		setField(L, "statement", it->statement);
9721		pushTable(L);
9722	}
9723
9724	return 1;
9725}
9726
9727int32_t LuaScriptInterface::luaGetExperienceStage(lua_State* L)
9728{
9729	//getExperienceStage(level[, divider])
9730	double divider = 1.0f;
9731	if(lua_gettop(L) > 1)
9732		divider = popFloatNumber(L);
9733
9734	lua_pushnumber(L, g_game.getExperienceStage(popNumber(L), divider));
9735	return 1;
9736}
9737
9738int32_t LuaScriptInterface::luaGetDataDir(lua_State* L)
9739{
9740	//getDataDir()
9741	lua_pushstring(L, getFilePath(FILE_TYPE_OTHER, "").c_str());
9742	return 1;
9743}
9744
9745int32_t LuaScriptInterface::luaGetLogsDir(lua_State* L)
9746{
9747	//getLogsDir()
9748	lua_pushstring(L, getFilePath(FILE_TYPE_LOG, "").c_str());
9749	return 1;
9750}
9751
9752int32_t LuaScriptInterface::luaGetConfigFile(lua_State* L)
9753{
9754	//getConfigFile()
9755	lua_pushstring(L, g_config.getString(ConfigManager::CONFIG_FILE).c_str());
9756	return 1;
9757}
9758
9759int32_t LuaScriptInterface::luaGetConfigValue(lua_State* L)
9760{
9761	//getConfigValue(key)
9762	g_config.getValue(popString(L), L);
9763	return 1;
9764}
9765
9766int32_t LuaScriptInterface::luaGetModList(lua_State* L)
9767{
9768	//getModList()
9769	ModMap::iterator it = ScriptingManager::getInstance()->getFirstMod();
9770	lua_newtable(L);
9771	for(uint32_t i = 1; it != ScriptingManager::getInstance()->getLastMod(); ++it, ++i)
9772	{
9773		createTable(L, i);
9774		setField(L, "name", it->first);
9775		setField(L, "description", it->second.description);
9776		setField(L, "file", it->second.file);
9777
9778		setField(L, "version", it->second.version);
9779		setField(L, "author", it->second.author);
9780		setField(L, "contact", it->second.contact);
9781
9782		setFieldBool(L, "enabled", it->second.enabled);
9783		pushTable(L);
9784	}
9785
9786	return 1;
9787}
9788
9789int32_t LuaScriptInterface::luaL_loadmodlib(lua_State* L)
9790{
9791	//loadmodlib(lib)
9792	std::string name = asLowerCaseString(popString(L));
9793	for(LibMap::iterator it = ScriptingManager::getInstance()->getFirstLib();
9794		it != ScriptingManager::getInstance()->getLastLib(); ++it)
9795	{
9796		if(asLowerCaseString(it->first) != name)
9797			continue;
9798
9799		luaL_loadstring(L, it->second.second.c_str());
9800		lua_pushvalue(L, -1);
9801		break;
9802	}
9803
9804	return 1;
9805}
9806
9807int32_t LuaScriptInterface::luaL_domodlib(lua_State* L)
9808{
9809	//domodlib(lib)
9810	std::string name = asLowerCaseString(popString(L));
9811	for(LibMap::iterator it = ScriptingManager::getInstance()->getFirstLib();
9812		it != ScriptingManager::getInstance()->getLastLib(); ++it)
9813	{
9814		if(asLowerCaseString(it->first) != name)
9815			continue;
9816
9817		bool ret = luaL_dostring(L, it->second.second.c_str());
9818		if(ret)
9819			error(NULL, popString(L));
9820
9821		lua_pushboolean(L, !ret);
9822		break;
9823	}
9824
9825	return 1;
9826}
9827
9828int32_t LuaScriptInterface::luaL_dodirectory(lua_State* L)
9829{
9830	std::string dir = popString(L);
9831	if(!getEnv()->getInterface()->loadDirectory(dir, NULL))
9832	{
9833		errorEx("Failed to load directory " + dir + ".");
9834		lua_pushboolean(L, false);
9835	}
9836	else
9837		lua_pushboolean(L, true);
9838
9839	return 1;
9840}
9841
9842#define EXPOSE_LOG(Name, Stream)\
9843	int32_t LuaScriptInterface::luaStd##Name(lua_State* L)\
9844	{\
9845		StringVec data;\
9846		for(int32_t i = 0, params = lua_gettop(L); i < params; ++i)\
9847			data.push_back(popString(L));\
9848\
9849		for(StringVec::reverse_iterator it = data.rbegin(); it != data.rend(); ++it)\
9850			Stream << (*it) << std::endl;\
9851\
9852		lua_pushnumber(L, data.size());\
9853		return 1;\
9854	}
9855
9856EXPOSE_LOG(Cout, std::cout)
9857EXPOSE_LOG(Cerr, std::cerr)
9858EXPOSE_LOG(Clog, std::clog)
9859
9860#undef EXPOSE_LOG
9861
9862int32_t LuaScriptInterface::luaStdMD5(lua_State* L)
9863{
9864	//std.md5(string[, upperCase])
9865	bool upperCase = false;
9866	if(lua_gettop(L) > 1)
9867		upperCase = popNumber(L);
9868
9869	lua_pushstring(L, transformToMD5(popString(L), upperCase).c_str());
9870	return 1;
9871}
9872
9873int32_t LuaScriptInterface::luaStdSHA1(lua_State* L)
9874{
9875	//std.sha1(string[, upperCase])
9876	bool upperCase = false;
9877	if(lua_gettop(L) > 1)
9878		upperCase = popNumber(L);
9879
9880	lua_pushstring(L, transformToSHA1(popString(L), upperCase).c_str());
9881	return 1;
9882}
9883
9884int32_t LuaScriptInterface::luaDatabaseExecute(lua_State* L)
9885{
9886	//db.executeQuery(query)
9887	DBQuery query; //lock mutex
9888	lua_pushboolean(L, Database::getInstance()->executeQuery(popString(L)));
9889	return 1;
9890}
9891
9892int32_t LuaScriptInterface::luaDatabaseStoreQuery(lua_State* L)
9893{
9894	//db.storeQuery(query)
9895	ScriptEnviroment* env = getEnv();
9896
9897	DBQuery query; //lock mutex
9898	if(DBResult* res = Database::getInstance()->storeQuery(popString(L)))
9899		lua_pushnumber(L, env->addResult(res));
9900	else
9901		lua_pushboolean(L, false);
9902
9903	return 1;
9904}
9905
9906int32_t LuaScriptInterface::luaDatabaseEscapeString(lua_State* L)
9907{
9908	//db.escapeString(str)
9909	DBQuery query; //lock mutex
9910	lua_pushstring(L, Database::getInstance()->escapeString(popString(L)).c_str());
9911	return 1;
9912}
9913
9914int32_t LuaScriptInterface::luaDatabaseEscapeBlob(lua_State* L)
9915{
9916	//db.escapeBlob(s, length)
9917	uint32_t length = popNumber(L);
9918	DBQuery query; //lock mutex
9919
9920	lua_pushstring(L, Database::getInstance()->escapeBlob(popString(L).c_str(), length).c_str());
9921	return 1;
9922}
9923
9924int32_t LuaScriptInterface::luaDatabaseLastInsertId(lua_State* L)
9925{
9926	//db.lastInsertId()
9927	DBQuery query; //lock mutex
9928	lua_pushnumber(L, Database::getInstance()->getLastInsertId());
9929	return 1;
9930}
9931
9932int32_t LuaScriptInterface::luaDatabaseStringComparison(lua_State* L)
9933{
9934	//db.stringComparison()
9935	lua_pushstring(L, Database::getInstance()->getStringComparison().c_str());
9936	return 1;
9937}
9938
9939int32_t LuaScriptInterface::luaDatabaseUpdateLimiter(lua_State* L)
9940{
9941	//db.updateLimiter()
9942	lua_pushstring(L, Database::getInstance()->getUpdateLimiter().c_str());
9943	return 1;
9944}
9945
9946#define CHECK_RESULT()\
9947	if(!res)\
9948	{\
9949		lua_pushboolean(L, false);\
9950		return 1;\
9951	}
9952
9953int32_t LuaScriptInterface::luaResultGetDataInt(lua_State* L)
9954{
9955	//result.getDataInt(res, s)
9956	const std::string& s = popString(L);
9957	ScriptEnviroment* env = getEnv();
9958
9959	DBResult* res = env->getResultByID(popNumber(L));
9960	CHECK_RESULT()
9961
9962	lua_pushnumber(L, res->getDataInt(s));
9963	return 1;
9964}
9965
9966int32_t LuaScriptInterface::luaResultGetDataLong(lua_State* L)
9967{
9968	//result.getDataLong(res, s)
9969	const std::string& s = popString(L);
9970	ScriptEnviroment* env = getEnv();
9971
9972	DBResult* res = env->getResultByID(popNumber(L));
9973	CHECK_RESULT()
9974
9975	lua_pushnumber(L, res->getDataLong(s));
9976	return 1;
9977}
9978
9979int32_t LuaScriptInterface::luaResultGetDataString(lua_State* L)
9980{
9981	//result.getDataString(res, s)
9982	const std::string& s = popString(L);
9983	ScriptEnviroment* env = getEnv();
9984
9985	DBResult* res = env->getResultByID(popNumber(L));
9986	CHECK_RESULT()
9987
9988	lua_pushstring(L, res->getDataString(s).c_str());
9989	return 1;
9990}
9991
9992int32_t LuaScriptInterface::luaResultGetDataStream(lua_State* L)
9993{
9994	//result.getDataStream(res, s)
9995	const std::string s = popString(L);
9996	ScriptEnviroment* env = getEnv();
9997
9998	DBResult* res = env->getResultByID(popNumber(L));
9999	CHECK_RESULT()
10000
10001	uint64_t length = 0;
10002	lua_pushstring(L, res->getDataStream(s, length));
10003
10004	lua_pushnumber(L, length);
10005	return 1;
10006}
10007
10008int32_t LuaScriptInterface::luaResultNext(lua_State* L)
10009{
10010	//result.next(res)
10011	ScriptEnviroment* env = getEnv();
10012
10013	DBResult* res = env->getResultByID(popNumber(L));
10014	CHECK_RESULT()
10015
10016	lua_pushboolean(L, res->next());
10017	return 1;
10018}
10019
10020int32_t LuaScriptInterface::luaResultFree(lua_State* L)
10021{
10022	//result.free(res)
10023	uint32_t rid = popNumber(L);
10024	ScriptEnviroment* env = getEnv();
10025
10026	DBResult* res = env->getResultByID(rid);
10027	CHECK_RESULT()
10028
10029	lua_pushboolean(L, env->removeResult(rid));
10030	return 1;
10031}
10032
10033#undef CHECK_RESULT
10034
10035int32_t LuaScriptInterface::luaBitNot(lua_State* L)
10036{
10037	int32_t number = (int32_t)popNumber(L);
10038	lua_pushnumber(L, ~number);
10039	return 1;
10040}
10041
10042int32_t LuaScriptInterface::luaBitUNot(lua_State* L)
10043{
10044	uint32_t number = (uint32_t)popNumber(L);
10045	lua_pushnumber(L, ~number);
10046	return 1;
10047}
10048
10049#define MULTI_OPERATOR(type, name, op)\
10050	int32_t LuaScriptInterface::luaBit##name(lua_State* L)\
10051	{\
10052		int32_t params = lua_gettop(L);\
10053		type value = (type)popNumber(L);\
10054		for(int32_t i = 2; i <= params; ++i)\
10055			value op popNumber(L);\
10056\
10057		lua_pushnumber(L, value);\
10058		return 1;\
10059	}
10060
10061MULTI_OPERATOR(int32_t, And, &=)
10062MULTI_OPERATOR(int32_t, Or, |=)
10063MULTI_OPERATOR(int32_t, Xor, ^=)
10064MULTI_OPERATOR(uint32_t, UAnd, &=)
10065MULTI_OPERATOR(uint32_t, UOr, |=)
10066MULTI_OPERATOR(uint32_t, UXor, ^=)
10067
10068#undef MULTI_OPERATOR
10069
10070#define SHIFT_OPERATOR(type, name, op)\
10071	int32_t LuaScriptInterface::luaBit##name(lua_State* L)\
10072	{\
10073		type v2 = (type)popNumber(L), v1 = (type)popNumber(L);\
10074		lua_pushnumber(L, (v1 op v2));\
10075		return 1;\
10076	}
10077
10078SHIFT_OPERATOR(int32_t, LeftShift, <<)
10079SHIFT_OPERATOR(int32_t, RightShift, >>)
10080SHIFT_OPERATOR(uint32_t, ULeftShift, <<)
10081SHIFT_OPERATOR(uint32_t, URightShift, >>)
10082
10083#undef SHIFT_OPERATOR