vhepm3e5

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