FWXcL4eG

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