GzNahzTB

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