wPUUUii0

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