SAYRt324

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