e2whPP35

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