1RAxBrpx

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