Q44YRUaQ

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