v2RjJ4iD

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