API tools faq
paste
Advertisement
Guest User

creatureevent.cpp

a guest
Nov 17th, 2019
121
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 58.57 KB | None | 0 0
raw download clone embed print report
  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. #ifdef __DEBUG_LUASCRIPTS__
  19. #include <sstream>
  20. #endif
  21.  
  22. #include "creatureevent.h"
  23. #include "tools.h"
  24.  
  25. #include "monster.h"
  26. #include "player.h"
  27.  
  28. extern CreatureEvents* g_creatureEvents;
  29.  
  30. CreatureEvents::CreatureEvents():
  31.     m_interface("CreatureScript Interface")
  32. {
  33.     m_interface.initState();
  34. }
  35.  
  36. CreatureEvents::~CreatureEvents()
  37. {
  38.     for(CreatureEventList::iterator it = m_creatureEvents.begin(); it != m_creatureEvents.end(); ++it)
  39.         delete (*it);
  40.  
  41.     m_creatureEvents.clear();
  42. }
  43.  
  44. void CreatureEvents::clear()
  45. {
  46.     //clear creature events
  47.     for(CreatureEventList::iterator it = m_creatureEvents.begin(); it != m_creatureEvents.end(); ++it)
  48.         (*it)->clearEvent();
  49.  
  50.     //clear lua state
  51.     m_interface.reInitState();
  52. }
  53.  
  54. Event* CreatureEvents::getEvent(const std::string& nodeName)
  55. {
  56.     std::string tmpNodeName = asLowerCaseString(nodeName);
  57.     if(tmpNodeName == "event" || tmpNodeName == "creaturevent" || tmpNodeName == "creatureevent" || tmpNodeName == "creaturescript")
  58.         return new CreatureEvent(&m_interface);
  59.  
  60.     return NULL;
  61. }
  62.  
  63. bool CreatureEvents::registerEvent(Event* event, xmlNodePtr, bool override)
  64. {
  65.     CreatureEvent* creatureEvent = dynamic_cast<CreatureEvent*>(event);
  66.     if(!creatureEvent)
  67.         return false;
  68.  
  69.     if(creatureEvent->getEventType() == CREATURE_EVENT_NONE)
  70.     {
  71.         std::clog << "[Error - CreatureEvents::registerEvent] Trying to register event without type!" << std::endl;
  72.         return false;
  73.     }
  74.  
  75.     if(CreatureEvent* oldEvent = getEventByName(creatureEvent->getName()))
  76.     {
  77.         //if there was an event with the same type that is not loaded (happens when realoading), it is reused
  78.         if(oldEvent->getEventType() == creatureEvent->getEventType())
  79.         {
  80.             if(!oldEvent->isLoaded() || override)
  81.                 oldEvent->copyEvent(creatureEvent);
  82.  
  83.             return override;
  84.         }
  85.     }
  86.  
  87.     //if not, register it normally
  88.     m_creatureEvents.push_back(creatureEvent);
  89.     return true;
  90. }
  91.  
  92. CreatureEvent* CreatureEvents::getEventByName(const std::string& name)
  93. {
  94.     for(CreatureEventList::iterator it = m_creatureEvents.begin(); it != m_creatureEvents.end(); ++it)
  95.     {
  96.         if((*it)->getName() == name)
  97.             return (*it);
  98.     }
  99.  
  100.     return NULL;
  101. }
  102.  
  103. bool CreatureEvents::playerLogin(Player* player)
  104. {
  105.     //fire global event if is registered
  106.     bool result = true;
  107.     for(CreatureEventList::iterator it = m_creatureEvents.begin(); it != m_creatureEvents.end(); ++it)
  108.     {
  109.         if((*it)->getEventType() == CREATURE_EVENT_LOGIN &&
  110.             (*it)->isLoaded() && !(*it)->executePlayer(player) && result)
  111.             result = false;
  112.     }
  113.  
  114.     return result;
  115. }
  116.  
  117. bool CreatureEvents::playerLogout(Player* player, bool forceLogout)
  118. {
  119.     //fire global event if is registered
  120.     bool result = true;
  121.     for(CreatureEventList::iterator it = m_creatureEvents.begin(); it != m_creatureEvents.end(); ++it)
  122.     {
  123.         if((*it)->getEventType() == CREATURE_EVENT_LOGOUT && (*it)->isLoaded()
  124.             && !(*it)->executeLogout(player, forceLogout) && result)
  125.             result = false;
  126.     }
  127.  
  128.     return result;
  129. }
  130.  
  131. bool CreatureEvents::monsterSpawn(Monster* monster)
  132. {
  133.     //fire global event if is registered
  134.     bool result = true;
  135.     for(CreatureEventList::iterator it = m_creatureEvents.begin(); it != m_creatureEvents.end(); ++it)
  136.     {
  137.         if((*it)->getEventType() == CREATURE_EVENT_SPAWN_GLOBAL &&
  138.             (*it)->isLoaded() && !(*it)->executeSpawn(monster) && result)
  139.             result = false;
  140.     }
  141.  
  142.     return result;
  143. }
  144.  
  145. CreatureEventType_t CreatureEvents::getType(const std::string& type)
  146. {
  147.     CreatureEventType_t _type = CREATURE_EVENT_NONE;
  148.     if(type == "login")
  149.         _type = CREATURE_EVENT_LOGIN;
  150.     else if(type == "logout")
  151.         _type = CREATURE_EVENT_LOGOUT;
  152.     else if(type == "channeljoin")
  153.         _type = CREATURE_EVENT_CHANNEL_JOIN;
  154.     else if(type == "channelleave")
  155.         _type = CREATURE_EVENT_CHANNEL_LEAVE;
  156.     else if(type == "channelrequest")
  157.         _type = CREATURE_EVENT_CHANNEL_REQUEST;
  158.     else if(type == "advance")
  159.         _type = CREATURE_EVENT_ADVANCE;
  160.     else if(type == "mailsend")
  161.         _type = CREATURE_EVENT_MAIL_SEND;
  162.     else if(type == "mailreceive")
  163.         _type = CREATURE_EVENT_MAIL_RECEIVE;
  164.     else if(type == "traderequest")
  165.         _type = CREATURE_EVENT_TRADE_REQUEST;
  166.     else if(type == "tradeaccept")
  167.         _type = CREATURE_EVENT_TRADE_ACCEPT;
  168.     else if(type == "textedit")
  169.         _type = CREATURE_EVENT_TEXTEDIT;
  170.     else if(type == "houseedit")
  171.         _type = CREATURE_EVENT_HOUSEEDIT;
  172.     else if(type == "reportbug")
  173.         _type = CREATURE_EVENT_REPORTBUG;
  174.     else if(type == "reportviolation")
  175.         _type = CREATURE_EVENT_REPORTVIOLATION;
  176.     else if(type == "look")
  177.         _type = CREATURE_EVENT_LOOK;
  178.     else if(type == "spawn" || type == "spawn-single")
  179.         _type = CREATURE_EVENT_SPAWN_SINGLE;
  180.     else if(type == "spawnall" || type == "spawn-global")
  181.         _type = CREATURE_EVENT_SPAWN_GLOBAL;
  182.     else if(type == "think")
  183.         _type = CREATURE_EVENT_THINK;
  184.     else if(type == "direction")
  185.         _type = CREATURE_EVENT_DIRECTION;
  186.     else if(type == "outfit")
  187.         _type = CREATURE_EVENT_OUTFIT;
  188.     else if(type == "statschange")
  189.         _type = CREATURE_EVENT_STATSCHANGE;
  190.     else if(type == "areacombat")
  191.         _type = CREATURE_EVENT_COMBAT_AREA;
  192.     else if(type == "throw")
  193.         _type = CREATURE_EVENT_THROW;
  194.     else if(type == "push")
  195.         _type = CREATURE_EVENT_PUSH;
  196.     else if(type == "target")
  197.         _type = CREATURE_EVENT_TARGET;
  198.     else if(type == "follow")
  199.         _type = CREATURE_EVENT_FOLLOW;
  200.     else if(type == "combat")
  201.         _type = CREATURE_EVENT_COMBAT;
  202.     else if(type == "attack")
  203.         _type = CREATURE_EVENT_ATTACK;
  204.     else if(type == "cast")
  205.         _type = CREATURE_EVENT_CAST;
  206.     else if(type == "kill")
  207.         _type = CREATURE_EVENT_KILL;
  208.     else if(type == "death")
  209.         _type = CREATURE_EVENT_DEATH;
  210.     else if(type == "preparedeath")
  211.         _type = CREATURE_EVENT_PREPAREDEATH;
  212.     else if(type == "extendedopcode")
  213.         _type = CREATURE_EVENT_EXTENDED_OPCODE;
  214.  
  215.     return _type;
  216. }
  217.  
  218. CreatureEvent::CreatureEvent(LuaInterface* _interface):
  219. Event(_interface)
  220. {
  221.     m_type = CREATURE_EVENT_NONE;
  222.     m_loaded = false;
  223. }
  224.  
  225. CreatureEvent::CreatureEvent(const CreatureEvent* copy):
  226. Event(copy)
  227. {
  228.     m_type = copy->m_type;
  229.     m_loaded = copy->m_loaded;
  230.     m_scriptId = copy->m_scriptId;
  231.     m_interface = copy->m_interface;
  232.     m_scripted = copy->m_scripted;
  233.     m_loaded = copy->m_loaded;
  234.     m_scriptData = copy->m_scriptData;
  235. }
  236.  
  237. bool CreatureEvent::configureEvent(xmlNodePtr p)
  238. {
  239.     std::string strValue;
  240.     if(!readXMLString(p, "name", strValue))
  241.     {
  242.         std::clog << "[Error - CreatureEvent::configureEvent] No name for creature event." << std::endl;
  243.         return false;
  244.     }
  245.  
  246.     m_eventName = strValue;
  247.     if(!readXMLString(p, "type", strValue))
  248.     {
  249.         std::clog << "[Error - CreatureEvent::configureEvent] No type for creature event." << std::endl;
  250.         return false;
  251.     }
  252.  
  253.     m_type = g_creatureEvents->getType(asLowerCaseString(strValue));
  254.     if(m_type == CREATURE_EVENT_NONE)
  255.     {
  256.         std::clog << "[Error - CreatureEvent::configureEvent] No valid type for creature event: " << strValue << "." << std::endl;
  257.         return false;
  258.     }
  259.  
  260.     m_loaded = true;
  261.     return true;
  262. }
  263.  
  264. std::string CreatureEvent::getScriptEventName() const
  265. {
  266.     switch(m_type)
  267.     {
  268.         case CREATURE_EVENT_LOGIN:
  269.             return "onLogin";
  270.         case CREATURE_EVENT_LOGOUT:
  271.             return "onLogout";
  272.         case CREATURE_EVENT_SPAWN_SINGLE:
  273.         case CREATURE_EVENT_SPAWN_GLOBAL:
  274.             return "onSpawn";
  275.         case CREATURE_EVENT_CHANNEL_JOIN:
  276.             return "onChannelJoin";
  277.         case CREATURE_EVENT_CHANNEL_LEAVE:
  278.             return "onChannelLeave";
  279.         case CREATURE_EVENT_CHANNEL_REQUEST:
  280.             return "onChannelRequest";
  281.         case CREATURE_EVENT_THINK:
  282.             return "onThink";
  283.         case CREATURE_EVENT_ADVANCE:
  284.             return "onAdvance";
  285.         case CREATURE_EVENT_LOOK:
  286.             return "onLook";
  287.         case CREATURE_EVENT_DIRECTION:
  288.             return "onDirection";
  289.         case CREATURE_EVENT_OUTFIT:
  290.             return "onOutfit";
  291.         case CREATURE_EVENT_MAIL_SEND:
  292.             return "onMailSend";
  293.         case CREATURE_EVENT_MAIL_RECEIVE:
  294.             return "onMailReceive";
  295.         case CREATURE_EVENT_TRADE_REQUEST:
  296.             return "onTradeRequest";
  297.         case CREATURE_EVENT_TRADE_ACCEPT:
  298.             return "onTradeAccept";
  299.         case CREATURE_EVENT_TEXTEDIT:
  300.             return "onTextEdit";
  301.         case CREATURE_EVENT_HOUSEEDIT:
  302.             return "onHouseEdit";
  303.         case CREATURE_EVENT_REPORTBUG:
  304.             return "onReportBug";
  305.         case CREATURE_EVENT_REPORTVIOLATION:
  306.             return "onReportViolation";
  307.         case CREATURE_EVENT_STATSCHANGE:
  308.             return "onStatsChange";
  309.         case CREATURE_EVENT_COMBAT_AREA:
  310.             return "onAreaCombat";
  311.         case CREATURE_EVENT_THROW:
  312.             return "onThrow";
  313.         case CREATURE_EVENT_PUSH:
  314.             return "onPush";
  315.         case CREATURE_EVENT_TARGET:
  316.             return "onTarget";
  317.         case CREATURE_EVENT_FOLLOW:
  318.             return "onFollow";
  319.         case CREATURE_EVENT_COMBAT:
  320.             return "onCombat";
  321.         case CREATURE_EVENT_ATTACK:
  322.             return "onAttack";
  323.         case CREATURE_EVENT_CAST:
  324.             return "onCast";
  325.         case CREATURE_EVENT_KILL:
  326.             return "onKill";
  327.         case CREATURE_EVENT_DEATH:
  328.             return "onDeath";
  329.         case CREATURE_EVENT_PREPAREDEATH:
  330.             return "onPrepareDeath";
  331.         case CREATURE_EVENT_EXTENDED_OPCODE:
  332.             return "onExtendedOpcode";
  333.         case CREATURE_EVENT_NONE:
  334.         default:
  335.             break;
  336.     }
  337.  
  338.     return "";
  339. }
  340.  
  341. std::string CreatureEvent::getScriptEventParams() const
  342. {
  343.     switch(m_type)
  344.     {
  345.         case CREATURE_EVENT_LOGIN:
  346.         case CREATURE_EVENT_SPAWN_SINGLE:
  347.         case CREATURE_EVENT_SPAWN_GLOBAL:
  348.             return "cid";
  349.         case CREATURE_EVENT_LOGOUT:
  350.             return "cid, forceLogout";
  351.         case CREATURE_EVENT_CHANNEL_JOIN:
  352.         case CREATURE_EVENT_CHANNEL_LEAVE:
  353.             return "cid, channel, users";
  354.         case CREATURE_EVENT_CHANNEL_REQUEST:
  355.             return "cid, channel, custom";
  356.         case CREATURE_EVENT_ADVANCE:
  357.             return "cid, skill, oldLevel, newLevel";
  358.         case CREATURE_EVENT_LOOK:
  359.             return "cid, thing, position, lookDistance";
  360.         case CREATURE_EVENT_MAIL_SEND:
  361.             return "cid, target, item, openBox";
  362.         case CREATURE_EVENT_MAIL_RECEIVE:
  363.             return "cid, target, item, openBox";
  364.         case CREATURE_EVENT_TRADE_REQUEST:
  365.             return "cid, target, item";
  366.         case CREATURE_EVENT_TRADE_ACCEPT:
  367.             return "cid, target, item, targetItem";
  368.         case CREATURE_EVENT_TEXTEDIT:
  369.             return "cid, item, newText";
  370.         case CREATURE_EVENT_HOUSEEDIT:
  371.             return "cid, house, list, text";
  372.         case CREATURE_EVENT_REPORTBUG:
  373.             return "cid, comment";
  374.         case CREATURE_EVENT_REPORTVIOLATION:
  375.             return "cid, type, reason, name, comment, translation, statementId";
  376.         case CREATURE_EVENT_THINK:
  377.             return "cid, interval";
  378.         case CREATURE_EVENT_DIRECTION:
  379.         case CREATURE_EVENT_OUTFIT:
  380.             return "cid, old, current";
  381.         case CREATURE_EVENT_STATSCHANGE:
  382.             return "cid, attacker, type, combat, value";
  383.         case CREATURE_EVENT_COMBAT_AREA:
  384.             return "cid, ground, position, aggressive";
  385.         case CREATURE_EVENT_THROW:
  386.             return "cid, item, fromPosition, toPosition";
  387.         case CREATURE_EVENT_PUSH:
  388.             return "cid, target, ground, position";
  389.         case CREATURE_EVENT_COMBAT:
  390.             return "cid, target, aggressive";
  391.         case CREATURE_EVENT_TARGET:
  392.         case CREATURE_EVENT_FOLLOW:
  393.         case CREATURE_EVENT_ATTACK:
  394.         case CREATURE_EVENT_CAST:
  395.             return "cid, target";
  396.         case CREATURE_EVENT_KILL:
  397.             return "cid, target, damage, flags, war";
  398.         case CREATURE_EVENT_DEATH:
  399.             return "cid, corpse, deathList";
  400.         case CREATURE_EVENT_PREPAREDEATH:
  401.             return "cid, deathList";
  402.         case CREATURE_EVENT_EXTENDED_OPCODE:
  403.             return "cid, opcode, buffer";
  404.         case CREATURE_EVENT_NONE:
  405.         default:
  406.             break;
  407.     }
  408.  
  409.     return "";
  410. }
  411.  
  412. void CreatureEvent::copyEvent(CreatureEvent* creatureEvent)
  413. {
  414.     m_scriptId = creatureEvent->m_scriptId;
  415.     m_interface = creatureEvent->m_interface;
  416.     m_scripted = creatureEvent->m_scripted;
  417.  
  418.     std::string* oldScript = m_scriptData;
  419.     m_scriptData = creatureEvent->m_scriptData;
  420.  
  421.     m_loaded = creatureEvent->m_loaded;
  422.     if(oldScript)
  423.         delete oldScript;
  424. }
  425.  
  426. void CreatureEvent::clearEvent()
  427. {
  428.     m_scriptId = 0;
  429.     m_interface = NULL;
  430.     m_scripted = EVENT_SCRIPT_FALSE;
  431.     m_loaded = false;
  432. }
  433.  
  434. uint32_t CreatureEvent::executePlayer(Player* player)
  435. {
  436.     //onLogin(cid)
  437.     if(m_interface->reserveEnv())
  438.     {
  439.         ScriptEnviroment* env = m_interface->getEnv();
  440.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  441.         {
  442.             env->setRealPos(player->getPosition());
  443.             std::stringstream scriptstream;
  444.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  445.  
  446.             if(m_scriptData)
  447.                 scriptstream << *m_scriptData;
  448.  
  449.             bool result = true;
  450.             if(m_interface->loadBuffer(scriptstream.str()))
  451.             {
  452.                 lua_State* L = m_interface->getState();
  453.                 result = m_interface->getGlobalBool(L, "_result", true);
  454.             }
  455.  
  456.             m_interface->releaseEnv();
  457.             return result;
  458.         }
  459.         else
  460.         {
  461.             #ifdef __DEBUG_LUASCRIPTS__
  462.             char desc[35];
  463.             sprintf(desc, "%s", player->getName().c_str());
  464.             env->setEvent(desc);
  465.             #endif
  466.  
  467.             env->setScriptId(m_scriptId, m_interface);
  468.             env->setRealPos(player->getPosition());
  469.  
  470.             lua_State* L = m_interface->getState();
  471.             m_interface->pushFunction(m_scriptId);
  472.             lua_pushnumber(L, env->addThing(player));
  473.  
  474.             bool result = m_interface->callFunction(1);
  475.             m_interface->releaseEnv();
  476.             return result;
  477.         }
  478.     }
  479.     else
  480.     {
  481.         std::clog << "[Error - CreatureEvent::executePlayer] Call stack overflow." << std::endl;
  482.         return 0;
  483.     }
  484. }
  485.  
  486. uint32_t CreatureEvent::executeLogout(Player* player, bool forceLogout)
  487. {
  488.     //onLogout(cid, forceLogout)
  489.     if(m_interface->reserveEnv())
  490.     {
  491.         ScriptEnviroment* env = m_interface->getEnv();
  492.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  493.         {
  494.             env->setRealPos(player->getPosition());
  495.             std::stringstream scriptstream;
  496.  
  497.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  498.             scriptstream << "local forceLogout = " << (forceLogout ? "true" : "false") << std::endl;
  499.  
  500.             if(m_scriptData)
  501.                 scriptstream << *m_scriptData;
  502.  
  503.             bool result = true;
  504.             if(m_interface->loadBuffer(scriptstream.str()))
  505.             {
  506.                 lua_State* L = m_interface->getState();
  507.                 result = m_interface->getGlobalBool(L, "_result", true);
  508.             }
  509.  
  510.             m_interface->releaseEnv();
  511.             return result;
  512.         }
  513.         else
  514.         {
  515.             #ifdef __DEBUG_LUASCRIPTS__
  516.             char desc[35];
  517.             sprintf(desc, "%s", player->getName().c_str());
  518.             env->setEvent(desc);
  519.             #endif
  520.  
  521.             env->setScriptId(m_scriptId, m_interface);
  522.             env->setRealPos(player->getPosition());
  523.  
  524.             lua_State* L = m_interface->getState();
  525.             m_interface->pushFunction(m_scriptId);
  526.  
  527.             lua_pushnumber(L, env->addThing(player));
  528.             lua_pushboolean(L, forceLogout);
  529.  
  530.             bool result = m_interface->callFunction(2);
  531.             m_interface->releaseEnv();
  532.             return result;
  533.         }
  534.     }
  535.     else
  536.     {
  537.         std::clog << "[Error - CreatureEvent::executeLogout] Call stack overflow." << std::endl;
  538.         return 0;
  539.     }
  540. }
  541.  
  542. uint32_t CreatureEvent::executeChannel(Player* player, uint16_t channelId, UsersMap usersMap)
  543. {
  544.     //onChannel[Join/Leave](cid, channel, users)
  545.     if(m_interface->reserveEnv())
  546.     {
  547.         ScriptEnviroment* env = m_interface->getEnv();
  548.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  549.         {
  550.             env->setRealPos(player->getPosition());
  551.             std::stringstream scriptstream;
  552.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  553.  
  554.             scriptstream << "local channel = " << channelId << std::endl;
  555.             scriptstream << "local users = {}" << std::endl;
  556.             for(UsersMap::iterator it = usersMap.begin(); it != usersMap.end(); ++it)
  557.                 scriptstream << "users:insert(" << env->addThing(it->second) << ")" << std::endl;
  558.  
  559.             if(m_scriptData)
  560.                 scriptstream << *m_scriptData;
  561.  
  562.             bool result = true;
  563.             if(m_interface->loadBuffer(scriptstream.str()))
  564.             {
  565.                 lua_State* L = m_interface->getState();
  566.                 result = m_interface->getGlobalBool(L, "_result", true);
  567.             }
  568.  
  569.             m_interface->releaseEnv();
  570.             return result;
  571.         }
  572.         else
  573.         {
  574.             #ifdef __DEBUG_LUASCRIPTS__
  575.             char desc[35];
  576.             sprintf(desc, "%s", player->getName().c_str());
  577.             env->setEvent(desc);
  578.             #endif
  579.  
  580.             env->setScriptId(m_scriptId, m_interface);
  581.             env->setRealPos(player->getPosition());
  582.  
  583.             lua_State* L = m_interface->getState();
  584.             m_interface->pushFunction(m_scriptId);
  585.  
  586.             lua_pushnumber(L, env->addThing(player));
  587.             lua_pushnumber(L, channelId);
  588.  
  589.             UsersMap::iterator it = usersMap.begin();
  590.             lua_newtable(L);
  591.             for(int32_t i = 1; it != usersMap.end(); ++it, ++i)
  592.             {
  593.                 lua_pushnumber(L, i);
  594.                 lua_pushnumber(L, env->addThing(it->second));
  595.                 lua_settable(L, -3);
  596.             }
  597.  
  598.             bool result = m_interface->callFunction(3);
  599.             m_interface->releaseEnv();
  600.             return result;
  601.         }
  602.     }
  603.     else
  604.     {
  605.         std::clog << "[Error - CreatureEvent::executeChannel] Call stack overflow." << std::endl;
  606.         return 0;
  607.     }
  608. }
  609.  
  610. uint32_t CreatureEvent::executeAdvance(Player* player, skills_t skill, uint32_t oldLevel, uint32_t newLevel)
  611. {
  612.     //onAdvance(cid, skill, oldLevel, newLevel)
  613.     if(m_interface->reserveEnv())
  614.     {
  615.         ScriptEnviroment* env = m_interface->getEnv();
  616.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  617.         {
  618.             env->setRealPos(player->getPosition());
  619.             std::stringstream scriptstream;
  620.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  621.  
  622.             scriptstream << "local skill = " << skill << std::endl;
  623.             scriptstream << "local oldLevel = " << oldLevel << std::endl;
  624.             scriptstream << "local newLevel = " << newLevel << std::endl;
  625.  
  626.             if(m_scriptData)
  627.                 scriptstream << *m_scriptData;
  628.  
  629.             bool result = true;
  630.             if(m_interface->loadBuffer(scriptstream.str()))
  631.             {
  632.                 lua_State* L = m_interface->getState();
  633.                 result = m_interface->getGlobalBool(L, "_result", true);
  634.             }
  635.  
  636.             m_interface->releaseEnv();
  637.             return result;
  638.         }
  639.         else
  640.         {
  641.             #ifdef __DEBUG_LUASCRIPTS__
  642.             char desc[35];
  643.             sprintf(desc, "%s", player->getName().c_str());
  644.             env->setEvent(desc);
  645.             #endif
  646.  
  647.             env->setScriptId(m_scriptId, m_interface);
  648.             env->setRealPos(player->getPosition());
  649.  
  650.             lua_State* L = m_interface->getState();
  651.             m_interface->pushFunction(m_scriptId);
  652.  
  653.             lua_pushnumber(L, env->addThing(player));
  654.             lua_pushnumber(L, (uint32_t)skill);
  655.  
  656.             lua_pushnumber(L, oldLevel);
  657.             lua_pushnumber(L, newLevel);
  658.  
  659.             bool result = m_interface->callFunction(4);
  660.             m_interface->releaseEnv();
  661.             return result;
  662.         }
  663.     }
  664.     else
  665.     {
  666.         std::clog << "[Error - CreatureEvent::executeAdvance] Call stack overflow." << std::endl;
  667.         return 0;
  668.     }
  669. }
  670.  
  671. uint32_t CreatureEvent::executeMail(Player* player, Player* target, Item* item, bool openBox)
  672. {
  673.     //onMail[Send/Receive](cid, target, item, openBox)
  674.     if(m_interface->reserveEnv())
  675.     {
  676.         ScriptEnviroment* env = m_interface->getEnv();
  677.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  678.         {
  679.             env->setRealPos(player->getPosition());
  680.             std::stringstream scriptstream;
  681.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  682.             scriptstream << "local target = " << env->addThing(target) << std::endl;
  683.  
  684.             env->streamThing(scriptstream, "item", item, env->addThing(item));
  685.             scriptstream << "local openBox = " << (openBox ? "true" : "false") << std::endl;
  686.  
  687.             if(m_scriptData)
  688.                 scriptstream << *m_scriptData;
  689.  
  690.             bool result = true;
  691.             if(m_interface->loadBuffer(scriptstream.str()))
  692.             {
  693.                 lua_State* L = m_interface->getState();
  694.                 result = m_interface->getGlobalBool(L, "_result", true);
  695.             }
  696.  
  697.             m_interface->releaseEnv();
  698.             return result;
  699.         }
  700.         else
  701.         {
  702.             #ifdef __DEBUG_LUASCRIPTS__
  703.             char desc[30];
  704.             sprintf(desc, "%s", player->getName().c_str());
  705.             env->setEvent(desc);
  706.             #endif
  707.  
  708.             env->setScriptId(m_scriptId, m_interface);
  709.             env->setRealPos(player->getPosition());
  710.  
  711.             lua_State* L = m_interface->getState();
  712.             m_interface->pushFunction(m_scriptId);
  713.  
  714.             lua_pushnumber(L, env->addThing(player));
  715.             lua_pushnumber(L, env->addThing(target));
  716.  
  717.             LuaInterface::pushThing(L, item, env->addThing(item));
  718.             lua_pushboolean(L, openBox);
  719.  
  720.             bool result = m_interface->callFunction(4);
  721.             m_interface->releaseEnv();
  722.             return result;
  723.         }
  724.     }
  725.     else
  726.     {
  727.         std::clog << "[Error - CreatureEvent::executeMail] Call stack overflow." << std::endl;
  728.         return 0;
  729.     }
  730. }
  731.  
  732. uint32_t CreatureEvent::executeTradeRequest(Player* player, Player* target, Item* item)
  733. {
  734.     //onTradeRequest(cid, target, item)
  735.     if(m_interface->reserveEnv())
  736.     {
  737.         ScriptEnviroment* env = m_interface->getEnv();
  738.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  739.         {
  740.             env->setRealPos(player->getPosition());
  741.             std::stringstream scriptstream;
  742.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  743.  
  744.             scriptstream << "local target = " << env->addThing(target) << std::endl;
  745.             env->streamThing(scriptstream, "item", item, env->addThing(item));
  746.  
  747.             if(m_scriptData)
  748.                 scriptstream << *m_scriptData;
  749.  
  750.             bool result = true;
  751.             if(m_interface->loadBuffer(scriptstream.str()))
  752.             {
  753.                 lua_State* L = m_interface->getState();
  754.                 result = m_interface->getGlobalBool(L, "_result", true);
  755.             }
  756.  
  757.             m_interface->releaseEnv();
  758.             return result;
  759.         }
  760.         else
  761.         {
  762.             #ifdef __DEBUG_LUASCRIPTS__
  763.             char desc[35];
  764.             sprintf(desc, "%s", player->getName().c_str());
  765.             env->setEvent(desc);
  766.             #endif
  767.  
  768.             env->setScriptId(m_scriptId, m_interface);
  769.             env->setRealPos(player->getPosition());
  770.  
  771.             lua_State* L = m_interface->getState();
  772.             m_interface->pushFunction(m_scriptId);
  773.  
  774.             lua_pushnumber(L, env->addThing(player));
  775.             lua_pushnumber(L, env->addThing(target));
  776.             LuaInterface::pushThing(L, item, env->addThing(item));
  777.  
  778.             bool result = m_interface->callFunction(3);
  779.             m_interface->releaseEnv();
  780.             return result;
  781.         }
  782.     }
  783.     else
  784.     {
  785.         std::clog << "[Error - CreatureEvent::executeTradeRequest] Call stack overflow." << std::endl;
  786.         return 0;
  787.     }
  788. }
  789.  
  790. uint32_t CreatureEvent::executeTradeAccept(Player* player, Player* target, Item* item, Item* targetItem)
  791. {
  792.     //onTradeAccept(cid, target, item, targetItem)
  793.     if(m_interface->reserveEnv())
  794.     {
  795.         ScriptEnviroment* env = m_interface->getEnv();
  796.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  797.         {
  798.             env->setRealPos(player->getPosition());
  799.             std::stringstream scriptstream;
  800.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  801.  
  802.             scriptstream << "local target = " << env->addThing(target) << std::endl;
  803.             env->streamThing(scriptstream, "item", item, env->addThing(item));
  804.  
  805.             if(m_scriptData)
  806.                 scriptstream << *m_scriptData;
  807.  
  808.             bool result = true;
  809.             if(m_interface->loadBuffer(scriptstream.str()))
  810.             {
  811.                 lua_State* L = m_interface->getState();
  812.                 result = m_interface->getGlobalBool(L, "_result", true);
  813.             }
  814.  
  815.             m_interface->releaseEnv();
  816.             return result;
  817.         }
  818.         else
  819.         {
  820.             #ifdef __DEBUG_LUASCRIPTS__
  821.             char desc[35];
  822.             sprintf(desc, "%s", player->getName().c_str());
  823.             env->setEvent(desc);
  824.             #endif
  825.  
  826.             env->setScriptId(m_scriptId, m_interface);
  827.             env->setRealPos(player->getPosition());
  828.  
  829.             lua_State* L = m_interface->getState();
  830.             m_interface->pushFunction(m_scriptId);
  831.  
  832.             lua_pushnumber(L, env->addThing(player));
  833.             lua_pushnumber(L, env->addThing(target));
  834.             LuaInterface::pushThing(L, item, env->addThing(item));
  835.             LuaInterface::pushThing(L, targetItem, env->addThing(targetItem));
  836.  
  837.             bool result = m_interface->callFunction(4);
  838.             m_interface->releaseEnv();
  839.             return result;
  840.         }
  841.     }
  842.     else
  843.     {
  844.         std::clog << "[Error - CreatureEvent::executeTradeAccept] Call stack overflow." << std::endl;
  845.         return 0;
  846.     }
  847. }
  848.  
  849. uint32_t CreatureEvent::executeLook(Player* player, Thing* thing, const Position& position, int16_t stackpos, int32_t lookDistance)
  850. {
  851.     //onLook(cid, thing, position, lookDistance)
  852.     if(m_interface->reserveEnv())
  853.     {
  854.         ScriptEnviroment* env = m_interface->getEnv();
  855.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  856.         {
  857.             env->setRealPos(player->getPosition());
  858.             std::stringstream scriptstream;
  859.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  860.  
  861.             scriptstream << "local thing = " << env->addThing(thing) << std::endl;
  862.             env->streamPosition(scriptstream, "position", position, stackpos);
  863.             scriptstream << "local lookDistance = " << lookDistance << std::endl;
  864.  
  865.             if(m_scriptData)
  866.                 scriptstream << *m_scriptData;
  867.  
  868.             bool result = true;
  869.             if(m_interface->loadBuffer(scriptstream.str()))
  870.             {
  871.                 lua_State* L = m_interface->getState();
  872.                 result = m_interface->getGlobalBool(L, "_result", true);
  873.             }
  874.  
  875.             m_interface->releaseEnv();
  876.             return result;
  877.         }
  878.         else
  879.         {
  880.             #ifdef __DEBUG_LUASCRIPTS__
  881.             char desc[30];
  882.             sprintf(desc, "%s", player->getName().c_str());
  883.             env->setEvent(desc);
  884.             #endif
  885.  
  886.             env->setScriptId(m_scriptId, m_interface);
  887.             env->setRealPos(player->getPosition());
  888.  
  889.             lua_State* L = m_interface->getState();
  890.             m_interface->pushFunction(m_scriptId);
  891.  
  892.             lua_pushnumber(L, env->addThing(player));
  893.             LuaInterface::pushThing(L, thing, env->addThing(thing));
  894.  
  895.             LuaInterface::pushPosition(L, position, stackpos);
  896.             lua_pushnumber(L, lookDistance);
  897.  
  898.             bool result = m_interface->callFunction(4);
  899.             m_interface->releaseEnv();
  900.             return result;
  901.         }
  902.     }
  903.     else
  904.     {
  905.         std::clog << "[Error - CreatureEvent::executeLook] Call stack overflow." << std::endl;
  906.         return 0;
  907.     }
  908. }
  909.  
  910. uint32_t CreatureEvent::executeSpawn(Monster* monster)
  911. {
  912.     //onSpawn(cid)
  913.     if(m_interface->reserveEnv())
  914.     {
  915.         ScriptEnviroment* env = m_interface->getEnv();
  916.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  917.         {
  918.             env->setRealPos(monster->getPosition());
  919.             std::stringstream scriptstream;
  920.             scriptstream << "local cid = " << env->addThing(monster) << std::endl;
  921.  
  922.             if(m_scriptData)
  923.                 scriptstream << *m_scriptData;
  924.  
  925.             bool result = true;
  926.             if(m_interface->loadBuffer(scriptstream.str()))
  927.             {
  928.                 lua_State* L = m_interface->getState();
  929.                 result = m_interface->getGlobalBool(L, "_result", true);
  930.             }
  931.  
  932.             m_interface->releaseEnv();
  933.             return result;
  934.         }
  935.         else
  936.         {
  937.             #ifdef __DEBUG_LUASCRIPTS__
  938.             char desc[35];
  939.             sprintf(desc, "%s", monster->getName().c_str());
  940.             env->setEvent(desc);
  941.             #endif
  942.  
  943.             env->setScriptId(m_scriptId, m_interface);
  944.             env->setRealPos(monster->getPosition());
  945.  
  946.             lua_State* L = m_interface->getState();
  947.             m_interface->pushFunction(m_scriptId);
  948.             lua_pushnumber(L, env->addThing(monster));
  949.  
  950.             bool result = m_interface->callFunction(1);
  951.             m_interface->releaseEnv();
  952.             return result;
  953.         }
  954.     }
  955.     else
  956.     {
  957.         std::clog << "[Error - CreatureEvent::executeSpawn] Call stack overflow." << std::endl;
  958.         return 0;
  959.     }
  960. }
  961.  
  962. uint32_t CreatureEvent::executeDirection(Creature* creature, Direction old, Direction current)
  963. {
  964.     //onDirection(cid, old, current)
  965.     if(m_interface->reserveEnv())
  966.     {
  967.         ScriptEnviroment* env = m_interface->getEnv();
  968.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  969.         {
  970.             env->setRealPos(creature->getPosition());
  971.             std::stringstream scriptstream;
  972.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  973.  
  974.             scriptstream << "local old = " << old << std::endl;
  975.             scriptstream << "local current = " << current << std::endl;
  976.  
  977.             if(m_scriptData)
  978.                 scriptstream << *m_scriptData;
  979.  
  980.             bool result = true;
  981.             if(m_interface->loadBuffer(scriptstream.str()))
  982.             {
  983.                 lua_State* L = m_interface->getState();
  984.                 result = m_interface->getGlobalBool(L, "_result", true);
  985.             }
  986.  
  987.             m_interface->releaseEnv();
  988.             return result;
  989.         }
  990.         else
  991.         {
  992.             #ifdef __DEBUG_LUASCRIPTS__
  993.             char desc[30];
  994.             sprintf(desc, "%s", creature->getName().c_str());
  995.             env->setEvent(desc);
  996.             #endif
  997.  
  998.             env->setScriptId(m_scriptId, m_interface);
  999.             env->setRealPos(creature->getPosition());
  1000.  
  1001.             lua_State* L = m_interface->getState();
  1002.             m_interface->pushFunction(m_scriptId);
  1003.  
  1004.             lua_pushnumber(L, env->addThing(creature));
  1005.             lua_pushnumber(L, old);
  1006.             lua_pushnumber(L, current);
  1007.  
  1008.             bool result = m_interface->callFunction(3);
  1009.             m_interface->releaseEnv();
  1010.             return result;
  1011.         }
  1012.     }
  1013.     else
  1014.     {
  1015.         std::clog << "[Error - CreatureEvent::executeDirection] Call stack overflow." << std::endl;
  1016.         return 0;
  1017.     }
  1018. }
  1019.  
  1020. uint32_t CreatureEvent::executeOutfit(Creature* creature, const Outfit_t& old, const Outfit_t& current)
  1021. {
  1022.     //onOutfit(cid, old, current)
  1023.     if(m_interface->reserveEnv())
  1024.     {
  1025.         ScriptEnviroment* env = m_interface->getEnv();
  1026.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1027.         {
  1028.             env->setRealPos(creature->getPosition());
  1029.             std::stringstream scriptstream;
  1030.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  1031.  
  1032.             env->streamOutfit(scriptstream, "old", old);
  1033.             env->streamOutfit(scriptstream, "current", current);
  1034.  
  1035.             if(m_scriptData)
  1036.                 scriptstream << *m_scriptData;
  1037.  
  1038.             bool result = true;
  1039.             if(m_interface->loadBuffer(scriptstream.str()))
  1040.             {
  1041.                 lua_State* L = m_interface->getState();
  1042.                 result = m_interface->getGlobalBool(L, "_result", true);
  1043.             }
  1044.  
  1045.             m_interface->releaseEnv();
  1046.             return result;
  1047.         }
  1048.         else
  1049.         {
  1050.             #ifdef __DEBUG_LUASCRIPTS__
  1051.             char desc[30];
  1052.             sprintf(desc, "%s", creature->getName().c_str());
  1053.             env->setEvent(desc);
  1054.             #endif
  1055.  
  1056.             env->setScriptId(m_scriptId, m_interface);
  1057.             env->setRealPos(creature->getPosition());
  1058.  
  1059.             lua_State* L = m_interface->getState();
  1060.             m_interface->pushFunction(m_scriptId);
  1061.  
  1062.             lua_pushnumber(L, env->addThing(creature));
  1063.             LuaInterface::pushOutfit(L, old);
  1064.             LuaInterface::pushOutfit(L, current);
  1065.  
  1066.             bool result = m_interface->callFunction(3);
  1067.             m_interface->releaseEnv();
  1068.             return result;
  1069.         }
  1070.     }
  1071.     else
  1072.     {
  1073.         std::clog << "[Error - CreatureEvent::executeOutfit] Call stack overflow." << std::endl;
  1074.         return 0;
  1075.     }
  1076. }
  1077.  
  1078. uint32_t CreatureEvent::executeThink(Creature* creature, uint32_t interval)
  1079. {
  1080.     //onThink(cid, interval)
  1081.     if(m_interface->reserveEnv())
  1082.     {
  1083.         ScriptEnviroment* env = m_interface->getEnv();
  1084.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1085.         {
  1086.             env->setRealPos(creature->getPosition());
  1087.             std::stringstream scriptstream;
  1088.  
  1089.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  1090.             scriptstream << "local interval = " << interval << std::endl;
  1091.  
  1092.             if(m_scriptData)
  1093.                 scriptstream << *m_scriptData;
  1094.  
  1095.             bool result = true;
  1096.             if(m_interface->loadBuffer(scriptstream.str()))
  1097.             {
  1098.                 lua_State* L = m_interface->getState();
  1099.                 result = m_interface->getGlobalBool(L, "_result", true);
  1100.             }
  1101.  
  1102.             m_interface->releaseEnv();
  1103.             return result;
  1104.         }
  1105.         else
  1106.         {
  1107.             #ifdef __DEBUG_LUASCRIPTS__
  1108.             char desc[35];
  1109.             sprintf(desc, "%s", creature->getName().c_str());
  1110.             env->setEvent(desc);
  1111.             #endif
  1112.  
  1113.             env->setScriptId(m_scriptId, m_interface);
  1114.             env->setRealPos(creature->getPosition());
  1115.  
  1116.             lua_State* L = m_interface->getState();
  1117.             m_interface->pushFunction(m_scriptId);
  1118.  
  1119.             lua_pushnumber(L, env->addThing(creature));
  1120.             lua_pushnumber(L, interval);
  1121.  
  1122.             bool result = m_interface->callFunction(2);
  1123.             m_interface->releaseEnv();
  1124.             return result;
  1125.         }
  1126.     }
  1127.     else
  1128.     {
  1129.         std::clog << "[Error - CreatureEvent::executeThink] Call stack overflow." << std::endl;
  1130.         return 0;
  1131.     }
  1132. }
  1133.  
  1134. uint32_t CreatureEvent::executeStatsChange(Creature* creature, Creature* attacker, StatsChange_t type, CombatType_t combat, int32_t value)
  1135. {
  1136.     //onStatsChange(cid, attacker, type, combat, value)
  1137.     if(m_interface->reserveEnv())
  1138.     {
  1139.         ScriptEnviroment* env = m_interface->getEnv();
  1140.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1141.         {
  1142.             env->setRealPos(creature->getPosition());
  1143.             std::stringstream scriptstream;
  1144.  
  1145.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  1146.             scriptstream << "local attacker = " << env->addThing(attacker) << std::endl;
  1147.  
  1148.             scriptstream << "local type = " << (uint32_t)type << std::endl;
  1149.             scriptstream << "local combat = " << (uint32_t)combat << std::endl;
  1150.             scriptstream << "local value = " << value << std::endl;
  1151.  
  1152.             if(m_scriptData)
  1153.                 scriptstream << *m_scriptData;
  1154.  
  1155.             bool result = true;
  1156.             if(m_interface->loadBuffer(scriptstream.str()))
  1157.             {
  1158.                 lua_State* L = m_interface->getState();
  1159.                 result = m_interface->getGlobalBool(L, "_result", true);
  1160.             }
  1161.  
  1162.             m_interface->releaseEnv();
  1163.             return result;
  1164.         }
  1165.         else
  1166.         {
  1167.             #ifdef __DEBUG_LUASCRIPTS__
  1168.             char desc[35];
  1169.             sprintf(desc, "%s", creature->getName().c_str());
  1170.             env->setEvent(desc);
  1171.             #endif
  1172.  
  1173.             env->setScriptId(m_scriptId, m_interface);
  1174.             env->setRealPos(creature->getPosition());
  1175.  
  1176.             lua_State* L = m_interface->getState();
  1177.             m_interface->pushFunction(m_scriptId);
  1178.  
  1179.             lua_pushnumber(L, env->addThing(creature));
  1180.             lua_pushnumber(L, env->addThing(attacker));
  1181.  
  1182.             lua_pushnumber(L, (uint32_t)type);
  1183.             lua_pushnumber(L, (uint32_t)combat);
  1184.             lua_pushnumber(L, value);
  1185.  
  1186.             bool result = m_interface->callFunction(5);
  1187.             m_interface->releaseEnv();
  1188.             return result;
  1189.         }
  1190.     }
  1191.     else
  1192.     {
  1193.         std::clog << "[Error - CreatureEvent::executeStatsChange] Call stack overflow." << std::endl;
  1194.         return 0;
  1195.     }
  1196. }
  1197.  
  1198. uint32_t CreatureEvent::executeCombatArea(Creature* creature, Tile* tile, bool aggressive)
  1199. {
  1200.     //onAreaCombat(cid, ground, position, aggressive)
  1201.     if(m_interface->reserveEnv())
  1202.     {
  1203.         ScriptEnviroment* env = m_interface->getEnv();
  1204.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1205.         {
  1206.             env->setRealPos(creature->getPosition());
  1207.             std::stringstream scriptstream;
  1208.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  1209.  
  1210.             env->streamThing(scriptstream, "ground", tile->ground, env->addThing(tile->ground));
  1211.             env->streamPosition(scriptstream, "position", tile->getPosition(), 0);
  1212.             scriptstream << "local aggressive = " << (aggressive ? "true" : "false") << std::endl;
  1213.  
  1214.             if(m_scriptData)
  1215.                 scriptstream << *m_scriptData;
  1216.  
  1217.             bool result = true;
  1218.             if(m_interface->loadBuffer(scriptstream.str()))
  1219.             {
  1220.                 lua_State* L = m_interface->getState();
  1221.                 result = m_interface->getGlobalBool(L, "_result", true);
  1222.             }
  1223.  
  1224.             m_interface->releaseEnv();
  1225.             return result;
  1226.         }
  1227.         else
  1228.         {
  1229.             #ifdef __DEBUG_LUASCRIPTS__
  1230.             std::stringstream desc;
  1231.             desc << creature->getName();
  1232.             env->setEvent(desc.str());
  1233.             #endif
  1234.  
  1235.             env->setScriptId(m_scriptId, m_interface);
  1236.             env->setRealPos(creature->getPosition());
  1237.  
  1238.             lua_State* L = m_interface->getState();
  1239.             m_interface->pushFunction(m_scriptId);
  1240.  
  1241.             lua_pushnumber(L, env->addThing(creature));
  1242.             LuaInterface::pushThing(L, tile->ground, env->addThing(tile->ground));
  1243.  
  1244.             LuaInterface::pushPosition(L, tile->getPosition(), 0);
  1245.             lua_pushboolean(L, aggressive);
  1246.  
  1247.             bool result = m_interface->callFunction(4);
  1248.             m_interface->releaseEnv();
  1249.             return result;
  1250.         }
  1251.     }
  1252.     else
  1253.     {
  1254.         std::clog << "[Error - CreatureEvent::executeAreaCombat] Call stack overflow." << std::endl;
  1255.         return 0;
  1256.     }
  1257. }
  1258.  
  1259. uint32_t CreatureEvent::executeCombat(Creature* creature, Creature* target, bool aggressive)
  1260. {
  1261.     //onCombat(cid, target, aggressive)
  1262.     if(m_interface->reserveEnv())
  1263.     {
  1264.         ScriptEnviroment* env = m_interface->getEnv();
  1265.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1266.         {
  1267.             env->setRealPos(creature->getPosition());
  1268.             std::stringstream scriptstream;
  1269.  
  1270.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  1271.             scriptstream << "local target = " << env->addThing(target) << std::endl;
  1272.             scriptstream << "local aggressive = " << (aggressive ? "true" : "false") << std::endl;
  1273.  
  1274.             if(m_scriptData)
  1275.                 scriptstream << *m_scriptData;
  1276.  
  1277.             bool result = true;
  1278.             if(m_interface->loadBuffer(scriptstream.str()))
  1279.             {
  1280.                 lua_State* L = m_interface->getState();
  1281.                 result = m_interface->getGlobalBool(L, "_result", true);
  1282.             }
  1283.  
  1284.             m_interface->releaseEnv();
  1285.             return result;
  1286.         }
  1287.         else
  1288.         {
  1289.             #ifdef __DEBUG_LUASCRIPTS__
  1290.             std::stringstream desc;
  1291.             desc << creature->getName();
  1292.             env->setEvent(desc.str());
  1293.             #endif
  1294.  
  1295.             env->setScriptId(m_scriptId, m_interface);
  1296.             env->setRealPos(creature->getPosition());
  1297.  
  1298.             lua_State* L = m_interface->getState();
  1299.             m_interface->pushFunction(m_scriptId);
  1300.  
  1301.             lua_pushnumber(L, env->addThing(creature));
  1302.             lua_pushnumber(L, env->addThing(target));
  1303.             lua_pushboolean(L, aggressive);
  1304.  
  1305.             bool result = m_interface->callFunction(3);
  1306.             m_interface->releaseEnv();
  1307.             return result;
  1308.         }
  1309.     }
  1310.     else
  1311.     {
  1312.         std::clog << "[Error - CreatureEvent::executeCombat] Call stack overflow." << std::endl;
  1313.         return 0;
  1314.     }
  1315. }
  1316.  
  1317. uint32_t CreatureEvent::executeCast(Creature* creature, Creature* target/* = NULL*/)
  1318. {
  1319.     //onCast(cid[, target])
  1320.     if(m_interface->reserveEnv())
  1321.     {
  1322.         ScriptEnviroment* env = m_interface->getEnv();
  1323.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1324.         {
  1325.             env->setRealPos(creature->getPosition());
  1326.             std::stringstream scriptstream;
  1327.  
  1328.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  1329.             scriptstream << "local target = ";
  1330.             if(target)
  1331.                 scriptstream << env->addThing(target);
  1332.             else
  1333.                 scriptstream << "nil";
  1334.  
  1335.             if(m_scriptData)
  1336.                 scriptstream << *m_scriptData;
  1337.  
  1338.             bool result = true;
  1339.             if(m_interface->loadBuffer(scriptstream.str()))
  1340.             {
  1341.                 lua_State* L = m_interface->getState();
  1342.                 result = m_interface->getGlobalBool(L, "_result", true);
  1343.             }
  1344.  
  1345.             m_interface->releaseEnv();
  1346.             return result;
  1347.         }
  1348.         else
  1349.         {
  1350.             #ifdef __DEBUG_LUASCRIPTS__
  1351.             std::stringstream desc;
  1352.             desc << creature->getName();
  1353.             env->setEvent(desc.str());
  1354.             #endif
  1355.  
  1356.             env->setScriptId(m_scriptId, m_interface);
  1357.             env->setRealPos(creature->getPosition());
  1358.  
  1359.             lua_State* L = m_interface->getState();
  1360.             m_interface->pushFunction(m_scriptId);
  1361.  
  1362.             lua_pushnumber(L, env->addThing(creature));
  1363.             lua_pushnumber(L, env->addThing(target));
  1364.  
  1365.             bool result = m_interface->callFunction(2);
  1366.             m_interface->releaseEnv();
  1367.             return result;
  1368.         }
  1369.     }
  1370.     else
  1371.     {
  1372.         std::clog << "[Error - CreatureEvent::executeCast] Call stack overflow." << std::endl;
  1373.         return 0;
  1374.     }
  1375. }
  1376.  
  1377. uint32_t CreatureEvent::executeKill(Creature* creature, Creature* target, const DeathEntry& entry)
  1378. {
  1379.     //onKill(cid, target, damage, flags)
  1380.     if(m_interface->reserveEnv())
  1381.     {
  1382.         uint32_t flags = 0;
  1383.         if(entry.isLast())
  1384.             flags |= 1;
  1385.  
  1386.         if(entry.isJustify())
  1387.             flags |= 2;
  1388.  
  1389.         if(entry.isUnjustified())
  1390.             flags |= 4;
  1391.  
  1392.         ScriptEnviroment* env = m_interface->getEnv();
  1393.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1394.         {
  1395.             env->setRealPos(creature->getPosition());
  1396.             std::stringstream scriptstream;
  1397.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  1398.  
  1399.             scriptstream << "local target = " << env->addThing(target) << std::endl;
  1400.             scriptstream << "local damage = " << entry.getDamage() << std::endl;
  1401.             scriptstream << "local flags = " << flags << std::endl;
  1402.             scriptstream << "local war = " << entry.getWar().war << std::endl;
  1403.  
  1404.             if(m_scriptData)
  1405.                 scriptstream << *m_scriptData;
  1406.  
  1407.             bool result = true;
  1408.             if(m_interface->loadBuffer(scriptstream.str()))
  1409.             {
  1410.                 lua_State* L = m_interface->getState();
  1411.                 result = m_interface->getGlobalBool(L, "_result", true);
  1412.             }
  1413.  
  1414.             m_interface->releaseEnv();
  1415.             return result;
  1416.         }
  1417.         else
  1418.         {
  1419.             #ifdef __DEBUG_LUASCRIPTS__
  1420.             std::stringstream desc;
  1421.             desc << creature->getName();
  1422.             env->setEvent(desc.str());
  1423.             #endif
  1424.  
  1425.             env->setScriptId(m_scriptId, m_interface);
  1426.             env->setRealPos(creature->getPosition());
  1427.  
  1428.             lua_State* L = m_interface->getState();
  1429.             m_interface->pushFunction(m_scriptId);
  1430.  
  1431.             lua_pushnumber(L, env->addThing(creature));
  1432.             lua_pushnumber(L, env->addThing(target));
  1433.  
  1434.             lua_pushnumber(L, entry.getDamage());
  1435.             lua_pushnumber(L, flags);
  1436.             lua_pushnumber(L, entry.getWar().war);
  1437.  
  1438.             bool result = m_interface->callFunction(5);
  1439.             m_interface->releaseEnv();
  1440.             return result;
  1441.         }
  1442.     }
  1443.     else
  1444.     {
  1445.         std::clog << "[Error - CreatureEvent::executeKill] Call stack overflow." << std::endl;
  1446.         return 0;
  1447.     }
  1448. }
  1449.  
  1450. uint32_t CreatureEvent::executeDeath(Creature* creature, Item* corpse, DeathList deathList)
  1451. {
  1452.     //onDeath(cid, corpse, deathList)
  1453.     if(m_interface->reserveEnv())
  1454.     {
  1455.         ScriptEnviroment* env = m_interface->getEnv();
  1456.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1457.         {
  1458.             env->setRealPos(creature->getPosition());
  1459.             std::stringstream scriptstream;
  1460.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  1461.  
  1462.             env->streamThing(scriptstream, "corpse", corpse, env->addThing(corpse));
  1463.             scriptstream << "local deathList = {}" << std::endl;
  1464.             for(DeathList::iterator it = deathList.begin(); it != deathList.end(); ++it)
  1465.             {
  1466.                 scriptstream << "deathList:insert(";
  1467.                 if(it->isCreatureKill())
  1468.                     scriptstream << env->addThing(it->getKillerCreature());
  1469.                 else
  1470.                     scriptstream << it->getKillerName();
  1471.  
  1472.                 scriptstream << ")" << std::endl;
  1473.             }
  1474.  
  1475.             if(m_scriptData)
  1476.                 scriptstream << *m_scriptData;
  1477.  
  1478.             bool result = true;
  1479.             if(m_interface->loadBuffer(scriptstream.str()))
  1480.             {
  1481.                 lua_State* L = m_interface->getState();
  1482.                 result = m_interface->getGlobalBool(L, "_result", true);
  1483.             }
  1484.  
  1485.             m_interface->releaseEnv();
  1486.             return result;
  1487.         }
  1488.         else
  1489.         {
  1490.             #ifdef __DEBUG_LUASCRIPTS__
  1491.             char desc[35];
  1492.             sprintf(desc, "%s", creature->getName().c_str());
  1493.             env->setEvent(desc);
  1494.             #endif
  1495.  
  1496.             env->setScriptId(m_scriptId, m_interface);
  1497.             env->setRealPos(creature->getPosition());
  1498.  
  1499.             lua_State* L = m_interface->getState();
  1500.             m_interface->pushFunction(m_scriptId);
  1501.  
  1502.             lua_pushnumber(L, env->addThing(creature));
  1503.             LuaInterface::pushThing(L, corpse, env->addThing(corpse));
  1504.  
  1505.             lua_newtable(L);
  1506.             DeathList::iterator it = deathList.begin();
  1507.             for(int32_t i = 1; it != deathList.end(); ++it, ++i)
  1508.             {
  1509.                 lua_pushnumber(L, i);
  1510.                 if(it->isCreatureKill())
  1511.                     lua_pushnumber(L, env->addThing(it->getKillerCreature()));
  1512.                 else
  1513.                     lua_pushstring(L, it->getKillerName().c_str());
  1514.  
  1515.                 lua_settable(L, -3);
  1516.             }
  1517.  
  1518.             bool result = m_interface->callFunction(3);
  1519.             m_interface->releaseEnv();
  1520.             return result;
  1521.         }
  1522.     }
  1523.     else
  1524.     {
  1525.         std::clog << "[Error - CreatureEvent::executeDeath] Call stack overflow." << std::endl;
  1526.         return 0;
  1527.     }
  1528. }
  1529.  
  1530. uint32_t CreatureEvent::executePrepareDeath(Creature* creature, DeathList deathList)
  1531. {
  1532.     //onPrepareDeath(cid, deathList)
  1533.     if(m_interface->reserveEnv())
  1534.     {
  1535.         ScriptEnviroment* env = m_interface->getEnv();
  1536.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1537.         {
  1538.             env->setRealPos(creature->getPosition());
  1539.             std::stringstream scriptstream;
  1540.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  1541.  
  1542.             scriptstream << "local deathList = {}" << std::endl;
  1543.             for(DeathList::iterator it = deathList.begin(); it != deathList.end(); ++it)
  1544.             {
  1545.                 scriptstream << "deathList:insert(";
  1546.                 if(it->isCreatureKill())
  1547.                     scriptstream << env->addThing(it->getKillerCreature());
  1548.                 else
  1549.                     scriptstream << it->getKillerName();
  1550.  
  1551.                 scriptstream << ")" << std::endl;
  1552.             }
  1553.  
  1554.             if(m_scriptData)
  1555.                 scriptstream << *m_scriptData;
  1556.  
  1557.             bool result = true;
  1558.             if(m_interface->loadBuffer(scriptstream.str()))
  1559.             {
  1560.                 lua_State* L = m_interface->getState();
  1561.                 result = m_interface->getGlobalBool(L, "_result", true);
  1562.             }
  1563.  
  1564.             m_interface->releaseEnv();
  1565.             return result;
  1566.         }
  1567.         else
  1568.         {
  1569.             #ifdef __DEBUG_LUASCRIPTS__
  1570.             char desc[35];
  1571.             sprintf(desc, "%s", creature->getName().c_str());
  1572.             env->setEvent(desc);
  1573.             #endif
  1574.  
  1575.             env->setScriptId(m_scriptId, m_interface);
  1576.             env->setRealPos(creature->getPosition());
  1577.  
  1578.             lua_State* L = m_interface->getState();
  1579.             m_interface->pushFunction(m_scriptId);
  1580.  
  1581.             lua_pushnumber(L, env->addThing(creature));
  1582.  
  1583.             lua_newtable(L);
  1584.             DeathList::iterator it = deathList.begin();
  1585.             for(int32_t i = 1; it != deathList.end(); ++it, ++i)
  1586.             {
  1587.                 lua_pushnumber(L, i);
  1588.                 if(it->isCreatureKill())
  1589.                     lua_pushnumber(L, env->addThing(it->getKillerCreature()));
  1590.                 else
  1591.                     lua_pushstring(L, it->getKillerName().c_str());
  1592.  
  1593.                 lua_settable(L, -3);
  1594.             }
  1595.  
  1596.             bool result = m_interface->callFunction(2);
  1597.             m_interface->releaseEnv();
  1598.  
  1599.             return result;
  1600.         }
  1601.     }
  1602.     else
  1603.     {
  1604.         std::clog << "[Error - CreatureEvent::executePrepareDeath] Call stack overflow." << std::endl;
  1605.         return 0;
  1606.     }
  1607. }
  1608.  
  1609. uint32_t CreatureEvent::executeTextEdit(Player* player, Item* item, const std::string& newText)
  1610. {
  1611.     //onTextEdit(cid, item, newText)
  1612.     if(m_interface->reserveEnv())
  1613.     {
  1614.         ScriptEnviroment* env = m_interface->getEnv();
  1615.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1616.         {
  1617.             env->setRealPos(player->getPosition());
  1618.             std::stringstream scriptstream;
  1619.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  1620.  
  1621.             env->streamThing(scriptstream, "item", item, env->addThing(item));
  1622.             scriptstream << "local newText = " << newText << std::endl;
  1623.  
  1624.             if(m_scriptData)
  1625.                 scriptstream << *m_scriptData;
  1626.  
  1627.             bool result = true;
  1628.             if(m_interface->loadBuffer(scriptstream.str()))
  1629.             {
  1630.                 lua_State* L = m_interface->getState();
  1631.                 result = m_interface->getGlobalBool(L, "_result", true);
  1632.             }
  1633.  
  1634.             m_interface->releaseEnv();
  1635.             return result;
  1636.         }
  1637.         else
  1638.         {
  1639.             #ifdef __DEBUG_LUASCRIPTS__
  1640.             char desc[35];
  1641.             sprintf(desc, "%s", player->getName().c_str());
  1642.             env->setEvent(desc);
  1643.             #endif
  1644.  
  1645.             env->setScriptId(m_scriptId, m_interface);
  1646.             env->setRealPos(player->getPosition());
  1647.  
  1648.             lua_State* L = m_interface->getState();
  1649.             m_interface->pushFunction(m_scriptId);
  1650.  
  1651.             lua_pushnumber(L, env->addThing(player));
  1652.             LuaInterface::pushThing(L, item, env->addThing(item));
  1653.             lua_pushstring(L, newText.c_str());
  1654.  
  1655.             bool result = m_interface->callFunction(3);
  1656.             m_interface->releaseEnv();
  1657.             return result;
  1658.         }
  1659.     }
  1660.     else
  1661.     {
  1662.         std::clog << "[Error - CreatureEvent::executeTextEdit] Call stack overflow." << std::endl;
  1663.         return 0;
  1664.     }
  1665. }
  1666.  
  1667. uint32_t CreatureEvent::executeHouseEdit(Player* player, uint32_t houseId, uint32_t listId, const std::string& text)
  1668. {
  1669.     //onHouseEdit(cid, houseId, listId, text)
  1670.     if(m_interface->reserveEnv())
  1671.     {
  1672.         ScriptEnviroment* env = m_interface->getEnv();
  1673.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1674.         {
  1675.             env->setRealPos(player->getPosition());
  1676.             std::stringstream scriptstream;
  1677.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  1678.             scriptstream << "local house = " << houseId << std::endl;
  1679.  
  1680.             scriptstream << "local list = " << listId << std::endl;
  1681.             scriptstream << "local text = " << text << std::endl;
  1682.             if(m_scriptData)
  1683.                 scriptstream << *m_scriptData;
  1684.  
  1685.             bool result = true;
  1686.             if(m_interface->loadBuffer(scriptstream.str()))
  1687.             {
  1688.                 lua_State* L = m_interface->getState();
  1689.                 result = m_interface->getGlobalBool(L, "_result", true);
  1690.             }
  1691.  
  1692.             m_interface->releaseEnv();
  1693.             return result;
  1694.         }
  1695.         else
  1696.         {
  1697.             #ifdef __DEBUG_LUASCRIPTS__
  1698.             char desc[35];
  1699.             sprintf(desc, "%s", player->getName().c_str());
  1700.             env->setEvent(desc);
  1701.             #endif
  1702.  
  1703.             env->setScriptId(m_scriptId, m_interface);
  1704.             env->setRealPos(player->getPosition());
  1705.  
  1706.             lua_State* L = m_interface->getState();
  1707.             m_interface->pushFunction(m_scriptId);
  1708.  
  1709.             lua_pushnumber(L, env->addThing(player));
  1710.             lua_pushnumber(L, houseId);
  1711.             lua_pushnumber(L, listId);
  1712.             lua_pushstring(L, text.c_str());
  1713.  
  1714.             bool result = m_interface->callFunction(4);
  1715.             m_interface->releaseEnv();
  1716.             return result;
  1717.         }
  1718.     }
  1719.     else
  1720.     {
  1721.         std::clog << "[Error - CreatureEvent::executeHouseEdit] Call stack overflow." << std::endl;
  1722.         return 0;
  1723.     }
  1724. }
  1725.  
  1726. uint32_t CreatureEvent::executeReportBug(Player* player, const std::string& comment)
  1727. {
  1728.     //onReportBug(cid, comment)
  1729.     if(m_interface->reserveEnv())
  1730.     {
  1731.         ScriptEnviroment* env = m_interface->getEnv();
  1732.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1733.         {
  1734.             env->setRealPos(player->getPosition());
  1735.             std::stringstream scriptstream;
  1736.  
  1737.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  1738.             scriptstream << "local comment = " << comment << std::endl;
  1739.  
  1740.             if(m_scriptData)
  1741.                 scriptstream << *m_scriptData;
  1742.  
  1743.             bool result = true;
  1744.             if(m_interface->loadBuffer(scriptstream.str()))
  1745.             {
  1746.                 lua_State* L = m_interface->getState();
  1747.                 result = m_interface->getGlobalBool(L, "_result", true);
  1748.             }
  1749.  
  1750.             m_interface->releaseEnv();
  1751.             return result;
  1752.         }
  1753.         else
  1754.         {
  1755.             #ifdef __DEBUG_LUASCRIPTS__
  1756.             char desc[35];
  1757.             sprintf(desc, "%s", player->getName().c_str());
  1758.             env->setEvent(desc);
  1759.             #endif
  1760.  
  1761.             env->setScriptId(m_scriptId, m_interface);
  1762.             env->setRealPos(player->getPosition());
  1763.  
  1764.             lua_State* L = m_interface->getState();
  1765.             m_interface->pushFunction(m_scriptId);
  1766.  
  1767.             lua_pushnumber(L, env->addThing(player));
  1768.             lua_pushstring(L, comment.c_str());
  1769.  
  1770.             bool result = m_interface->callFunction(2);
  1771.             m_interface->releaseEnv();
  1772.             return result;
  1773.         }
  1774.     }
  1775.     else
  1776.     {
  1777.         std::clog << "[Error - CreatureEvent::executeReportBug] Call stack overflow." << std::endl;
  1778.         return 0;
  1779.     }
  1780. }
  1781.  
  1782. uint32_t CreatureEvent::executeReportViolation(Player* player, ReportType_t type, uint8_t reason,
  1783.     const std::string& name, const std::string& comment, const std::string& translation, uint32_t statementId)
  1784. {
  1785.     //onReportViolation(cid, type, reason, name, comment, translation, statementId)
  1786.     if(m_interface->reserveEnv())
  1787.     {
  1788.         ScriptEnviroment* env = m_interface->getEnv();
  1789.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1790.         {
  1791.             env->setRealPos(player->getPosition());
  1792.             std::stringstream scriptstream;
  1793.  
  1794.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  1795.             scriptstream << "local type = " << type << std::endl;
  1796.             scriptstream << "local reason = " << (uint16_t)reason << std::endl;
  1797.  
  1798.             scriptstream << "local name = " << name << std::endl;
  1799.             scriptstream << "local comment = " << comment << std::endl;
  1800.             scriptstream << "local translation = " << translation << std::endl;
  1801.  
  1802.             scriptstream << "local statementId = " << statementId << std::endl;
  1803.             if(m_scriptData)
  1804.                 scriptstream << *m_scriptData;
  1805.  
  1806.             bool result = true;
  1807.             if(m_interface->loadBuffer(scriptstream.str()))
  1808.             {
  1809.                 lua_State* L = m_interface->getState();
  1810.                 result = m_interface->getGlobalBool(L, "_result", true);
  1811.             }
  1812.  
  1813.             m_interface->releaseEnv();
  1814.             return result;
  1815.         }
  1816.         else
  1817.         {
  1818.             #ifdef __DEBUG_LUASCRIPTS__
  1819.             char desc[35];
  1820.             sprintf(desc, "%s", player->getName().c_str());
  1821.             env->setEvent(desc);
  1822.             #endif
  1823.  
  1824.             env->setScriptId(m_scriptId, m_interface);
  1825.             env->setRealPos(player->getPosition());
  1826.  
  1827.             lua_State* L = m_interface->getState();
  1828.             m_interface->pushFunction(m_scriptId);
  1829.  
  1830.             lua_pushnumber(L, env->addThing(player));
  1831.             lua_pushnumber(L, type);
  1832.             lua_pushnumber(L, reason);
  1833.  
  1834.             lua_pushstring(L, name.c_str());
  1835.             lua_pushstring(L, comment.c_str());
  1836.             lua_pushstring(L, translation.c_str());
  1837.             lua_pushnumber(L, statementId);
  1838.  
  1839.             bool result = m_interface->callFunction(7);
  1840.             m_interface->releaseEnv();
  1841.             return result;
  1842.         }
  1843.     }
  1844.     else
  1845.     {
  1846.         std::clog << "[Error - CreatureEvent::executeReportViolation] Call stack overflow." << std::endl;
  1847.         return 0;
  1848.     }
  1849. }
  1850.  
  1851. uint32_t CreatureEvent::executeChannelRequest(Player* player, const std::string& channel, bool isPrivate, bool custom)
  1852. {
  1853.     //onChannelRequest(cid, channel, custom)
  1854.     if(m_interface->reserveEnv())
  1855.     {
  1856.         ScriptEnviroment* env = m_interface->getEnv();
  1857.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1858.         {
  1859.             env->setRealPos(player->getPosition());
  1860.             std::stringstream scriptstream;
  1861.  
  1862.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  1863.             if(!isPrivate)
  1864.                 scriptstream << "local channel = " << atoi(channel.c_str()) << std::endl;
  1865.             else
  1866.                 scriptstream << "local channel = " << channel << std::endl;
  1867.  
  1868.             scriptstream << "local custom = " << (custom ? "true" : "false") << std::endl;
  1869.             if(m_scriptData)
  1870.                 scriptstream << *m_scriptData;
  1871.  
  1872.             bool result = true;
  1873.             if(m_interface->loadBuffer(scriptstream.str()))
  1874.             {
  1875.                 lua_State* L = m_interface->getState();
  1876.                 result = m_interface->getGlobalBool(L, "_result", true);
  1877.             }
  1878.  
  1879.             m_interface->releaseEnv();
  1880.             return result;
  1881.         }
  1882.         else
  1883.         {
  1884.             #ifdef __DEBUG_LUASCRIPTS__
  1885.             char desc[35];
  1886.             sprintf(desc, "%s", player->getName().c_str());
  1887.             env->setEvent(desc);
  1888.             #endif
  1889.  
  1890.             env->setScriptId(m_scriptId, m_interface);
  1891.             env->setRealPos(player->getPosition());
  1892.  
  1893.             lua_State* L = m_interface->getState();
  1894.             m_interface->pushFunction(m_scriptId);
  1895.  
  1896.             lua_pushnumber(L, env->addThing(player));
  1897.             if(!isPrivate)
  1898.                 lua_pushnumber(L, atoi(channel.c_str()));
  1899.             else
  1900.                 lua_pushstring(L, channel.c_str());
  1901.  
  1902.             lua_pushboolean(L, custom);
  1903.             bool result = m_interface->callFunction(3);
  1904.             m_interface->releaseEnv();
  1905.             return result;
  1906.         }
  1907.     }
  1908.     else
  1909.     {
  1910.         std::clog << "[Error - CreatureEvent::executeChannelRequest] Call stack overflow." << std::endl;
  1911.         return 0;
  1912.     }
  1913. }
  1914.  
  1915. uint32_t CreatureEvent::executePush(Player* player, Creature* target, Tile* tile)
  1916. {
  1917.     //onPush(cid, target, ground, position)
  1918.     if(m_interface->reserveEnv())
  1919.     {
  1920.         ScriptEnviroment* env = m_interface->getEnv();
  1921.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1922.         {
  1923.             env->setRealPos(player->getPosition());
  1924.             std::stringstream scriptstream;
  1925.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  1926.  
  1927.             scriptstream << "local target = " << env->addThing(target) << std::endl;
  1928.             env->streamThing(scriptstream, "ground", tile->ground, env->addThing(tile->ground));
  1929.             env->streamPosition(scriptstream, "position", tile->getPosition(), 0);
  1930.  
  1931.             if(m_scriptData)
  1932.                 scriptstream << *m_scriptData;
  1933.  
  1934.             bool result = true;
  1935.             if(m_interface->loadBuffer(scriptstream.str()))
  1936.             {
  1937.                 lua_State* L = m_interface->getState();
  1938.                 result = m_interface->getGlobalBool(L, "_result", true);
  1939.             }
  1940.  
  1941.             m_interface->releaseEnv();
  1942.             return result;
  1943.         }
  1944.         else
  1945.         {
  1946.             #ifdef __DEBUG_LUASCRIPTS__
  1947.             std::stringstream desc;
  1948.             desc << player->getName();
  1949.             env->setEvent(desc.str());
  1950.             #endif
  1951.  
  1952.             env->setScriptId(m_scriptId, m_interface);
  1953.             env->setRealPos(player->getPosition());
  1954.  
  1955.             lua_State* L = m_interface->getState();
  1956.             m_interface->pushFunction(m_scriptId);
  1957.  
  1958.             lua_pushnumber(L, env->addThing(player));
  1959.             lua_pushnumber(L, env->addThing(target));
  1960.  
  1961.             LuaInterface::pushThing(L, tile->ground, env->addThing(tile->ground));
  1962.             LuaInterface::pushPosition(L, tile->getPosition(), 0);
  1963.  
  1964.             bool result = m_interface->callFunction(4);
  1965.             m_interface->releaseEnv();
  1966.             return result;
  1967.         }
  1968.     }
  1969.     else
  1970.     {
  1971.         std::clog << "[Error - CreatureEvent::executePush] Call stack overflow." << std::endl;
  1972.         return 0;
  1973.     }
  1974. }
  1975.  
  1976. uint32_t CreatureEvent::executeThrow(Player* player, Item* item, const Position& fromPosition, const Position& toPosition)
  1977. {
  1978.     //onThrow(cid, item, fromPosition, toPosition)
  1979.     if(m_interface->reserveEnv())
  1980.     {
  1981.         ScriptEnviroment* env = m_interface->getEnv();
  1982.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1983.         {
  1984.             env->setRealPos(player->getPosition());
  1985.             std::stringstream scriptstream;
  1986.             scriptstream << "local cid = " << env->addThing(player) << std::endl;
  1987.  
  1988.             env->streamThing(scriptstream, "item", item, env->addThing(item));
  1989.             env->streamPosition(scriptstream, "fromPosition", fromPosition, 0);
  1990.             env->streamPosition(scriptstream, "toPosition", toPosition, 0);
  1991.  
  1992.             if(m_scriptData)
  1993.                 scriptstream << *m_scriptData;
  1994.  
  1995.             bool result = true;
  1996.             if(m_interface->loadBuffer(scriptstream.str()))
  1997.             {
  1998.                 lua_State* L = m_interface->getState();
  1999.                 result = m_interface->getGlobalBool(L, "_result", true);
  2000.             }
  2001.  
  2002.             m_interface->releaseEnv();
  2003.             return result;
  2004.         }
  2005.         else
  2006.         {
  2007.             #ifdef __DEBUG_LUASCRIPTS__
  2008.             std::stringstream desc;
  2009.             desc << player->getName();
  2010.             env->setEvent(desc.str());
  2011.             #endif
  2012.  
  2013.             env->setScriptId(m_scriptId, m_interface);
  2014.             env->setRealPos(player->getPosition());
  2015.  
  2016.             lua_State* L = m_interface->getState();
  2017.             m_interface->pushFunction(m_scriptId);
  2018.  
  2019.             lua_pushnumber(L, env->addThing(player));
  2020.             LuaInterface::pushThing(L, item, env->addThing(item));
  2021.  
  2022.             LuaInterface::pushPosition(L, fromPosition, 0);
  2023.             LuaInterface::pushPosition(L, toPosition, 0);
  2024.  
  2025.             bool result = m_interface->callFunction(4);
  2026.             m_interface->releaseEnv();
  2027.             return result;
  2028.         }
  2029.     }
  2030.     else
  2031.     {
  2032.         std::clog << "[Error - CreatureEvent::executeThrow] Call stack overflow." << std::endl;
  2033.         return 0;
  2034.     }
  2035. }
  2036.  
  2037. uint32_t CreatureEvent::executeAction(Creature* creature, Creature* target)
  2038. {
  2039.     //on[Target/Follow/Attack](cid, target)
  2040.     if(m_interface->reserveEnv())
  2041.     {
  2042.         ScriptEnviroment* env = m_interface->getEnv();
  2043.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  2044.         {
  2045.             env->setRealPos(creature->getPosition());
  2046.             std::stringstream scriptstream;
  2047.  
  2048.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  2049.             scriptstream << "local target = " << env->addThing(target) << std::endl;
  2050.  
  2051.             if(m_scriptData)
  2052.                 scriptstream << *m_scriptData;
  2053.  
  2054.             bool result = true;
  2055.             if(m_interface->loadBuffer(scriptstream.str()))
  2056.             {
  2057.                 lua_State* L = m_interface->getState();
  2058.                 result = m_interface->getGlobalBool(L, "_result", true);
  2059.             }
  2060.  
  2061.             m_interface->releaseEnv();
  2062.             return result;
  2063.         }
  2064.         else
  2065.         {
  2066.             #ifdef __DEBUG_LUASCRIPTS__
  2067.             std::stringstream desc;
  2068.             desc << creature->getName();
  2069.             env->setEvent(desc.str());
  2070.             #endif
  2071.  
  2072.             env->setScriptId(m_scriptId, m_interface);
  2073.             env->setRealPos(creature->getPosition());
  2074.  
  2075.             lua_State* L = m_interface->getState();
  2076.             m_interface->pushFunction(m_scriptId);
  2077.  
  2078.             lua_pushnumber(L, env->addThing(creature));
  2079.             lua_pushnumber(L, env->addThing(target));
  2080.  
  2081.             bool result = m_interface->callFunction(2);
  2082.             m_interface->releaseEnv();
  2083.             return result;
  2084.         }
  2085.     }
  2086.     else
  2087.     {
  2088.         std::clog << "[Error - CreatureEvent::executeAction] Call stack overflow." << std::endl;
  2089.         return 0;
  2090.     }
  2091. }
  2092.  
  2093. uint32_t CreatureEvent::executeExtendedOpcode(Creature* creature, uint8_t opcode, const std::string& buffer)
  2094. {
  2095.     //onExtendedOpcode(cid, opcode, buffer)
  2096.     if(m_interface->reserveEnv())
  2097.     {
  2098.         ScriptEnviroment* env = m_interface->getEnv();
  2099.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  2100.         {
  2101.             env->setRealPos(creature->getPosition());
  2102.             std::stringstream scriptstream;
  2103.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  2104.             scriptstream << "local opcode = " << (int)opcode << std::endl;
  2105.             scriptstream << "local buffer = " << buffer.c_str() << std::endl;
  2106.  
  2107.             scriptstream << m_scriptData;
  2108.             bool result = true;
  2109.             if(m_interface->loadBuffer(scriptstream.str()))
  2110.             {
  2111.                 lua_State* L = m_interface->getState();
  2112.                 result = m_interface->getGlobalBool(L, "_result", true);
  2113.             }
  2114.  
  2115.             m_interface->releaseEnv();
  2116.             return result;
  2117.         }
  2118.         else
  2119.         {
  2120.             #ifdef __DEBUG_LUASCRIPTS__
  2121.             char desc[35];
  2122.             sprintf(desc, "%s", creature->getName().c_str());
  2123.             env->setEvent(desc);
  2124.             #endif
  2125.  
  2126.             env->setScriptId(m_scriptId, m_interface);
  2127.             env->setRealPos(creature->getPosition());
  2128.  
  2129.             lua_State* L = m_interface->getState();
  2130.             m_interface->pushFunction(m_scriptId);
  2131.             lua_pushnumber(L, env->addThing(creature));
  2132.             lua_pushnumber(L, opcode);
  2133.             lua_pushlstring(L, buffer.c_str(), buffer.length());
  2134.  
  2135.             bool result = m_interface->callFunction(3);
  2136.             m_interface->releaseEnv();
  2137.             return result;
  2138.         }
  2139.     }
  2140.     else
  2141.     {
  2142.         std::cout << "[Error - CreatureEvent::executeRemoved] Call stack overflow." << std::endl;
  2143.         return 0;
  2144.     }
  2145. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!