AHCtHdK5

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