estou com um problema na linha 1941 na script

.

 

a script é esta

 

////////////////////////////////////////////////////////////////////////
// OpenTibia - an opensource roleplaying game
////////////////////////////////////////////////////////////////////////
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
////////////////////////////////////////////////////////////////////////
#include "otpch.h"
#ifdef __DEBUG_LUASCRIPTS__
#include <sstream>
#endif

#include "creatureevent.h"
#include "player.h"
#include "tools.h"

CreatureEvents::CreatureEvents():
m_interface("CreatureScript Interface")
{
    m_interface.initState();
}

CreatureEvents::~CreatureEvents()
{
    CreatureEventList::iterator it;
    for(it = m_creatureEvents.begin(); it != m_creatureEvents.end(); ++it)
        delete it->second;
}

void CreatureEvents::clear()
{
    //clear creature events
    for(CreatureEventList::iterator it = m_creatureEvents.begin(); it != m_creatureEvents.end(); ++it)
        it->second->clearEvent();

    //clear lua state
    m_interface.reInitState();
}

Event* CreatureEvents::getEvent(const std::string& nodeName)
{
    std::string tmpNodeName = asLowerCaseString(nodeName);
    if(tmpNodeName == "event" || tmpNodeName == "creaturevent" || tmpNodeName == "creatureevent" || tmpNodeName == "creaturescript")
        return new CreatureEvent(&m_interface);

    return NULL;
}

bool CreatureEvents::registerEvent(Event* event, xmlNodePtr p, bool override)
{
    CreatureEvent* creatureEvent = dynamic_cast<CreatureEvent*>(event);
    if(!creatureEvent)
        return false;

    if(creatureEvent->getEventType() == CREATURE_EVENT_NONE)
    {
        std::cout << "[Error - CreatureEvents::registerEvent] Trying to register event without type!" << std::endl;
        return false;
    }

    if(CreatureEvent* oldEvent = getEventByName(creatureEvent->getName(), false))
    {
        //if there was an event with the same type that is not loaded (happens when realoading), it is reused
        if(oldEvent->getEventType() == creatureEvent->getEventType() && (!oldEvent->isLoaded() || override))
            oldEvent->copyEvent(creatureEvent);

        /*delete creatureEvent;
        return override;*/
        return false;
    }

    //if not, register it normally
    m_creatureEvents[creatureEvent->getName()] = creatureEvent;
    return true;
}

CreatureEvent* CreatureEvents::getEventByName(const std::string& name, bool forceLoaded /*= true*/)
{
    CreatureEventList::iterator it = m_creatureEvents.find(name);
    if(it != m_creatureEvents.end())
    {
        if(!forceLoaded || it->second->isLoaded())
            return it->second;
    }

    return NULL;
}

bool CreatureEvents::playerLogin(Player* player)
{
    //fire global event if is registered
    bool result = true;
    for(CreatureEventList::iterator it = m_creatureEvents.begin(); it != m_creatureEvents.end(); ++it)
    {
        if(it->second->getEventType() == CREATURE_EVENT_LOGIN &&
            !it->second->executeLogin(player) && result)
            result = false;
    }

    return result;
}

bool CreatureEvents::playerLogout(Player* player, bool forceLogout)
{
    //fire global event if is registered
    bool result = true;
    for(CreatureEventList::iterator it = m_creatureEvents.begin(); it != m_creatureEvents.end(); ++it)
    {
        if(it->second->getEventType() == CREATURE_EVENT_LOGOUT &&
            !it->second->executeLogout(player, forceLogout) && result)
            result = false;
    }

    return forceLogout || result;
}

/////////////////////////////////////

CreatureEvent::CreatureEvent(LuaScriptInterface* _interface):
Event(_interface)
{
    m_type = CREATURE_EVENT_NONE;
    m_isLoaded = false;
}

bool CreatureEvent::configureEvent(xmlNodePtr p)
{
    std::string str;
    if(!readXMLString(p, "name", str))
    {
        std::cout << "[Error - CreatureEvent::configureEvent] No name for creature event." << std::endl;
        return false;
    }

    m_eventName = str;
    if(!readXMLString(p, "type", str))
    {
        std::cout << "[Error - CreatureEvent::configureEvent] No type for creature event." << std::endl;
        return false;
    }

    std::string tmpStr = asLowerCaseString(str);
    if(tmpStr == "login")
        m_type = CREATURE_EVENT_LOGIN;
    else if(tmpStr == "logout")
        m_type = CREATURE_EVENT_LOGOUT;
    else if(tmpStr == "joinchannel")
        m_type = CREATURE_EVENT_CHANNEL_JOIN;
    else if(tmpStr == "leavechannel")
        m_type = CREATURE_EVENT_CHANNEL_LEAVE;
    else if(tmpStr == "advance")
        m_type = CREATURE_EVENT_ADVANCE;
    else if(tmpStr == "sendmail")
        m_type = CREATURE_EVENT_MAIL_SEND;
    else if(tmpStr == "receivemail")
        m_type = CREATURE_EVENT_MAIL_RECEIVE;
    else if(tmpStr == "traderequest")
        m_type = CREATURE_EVENT_TRADE_REQUEST;
    else if(tmpStr == "tradeaccept")
        m_type = CREATURE_EVENT_TRADE_ACCEPT;
    else if(tmpStr == "textedit")
        m_type = CREATURE_EVENT_TEXTEDIT;
    else if(tmpStr == "reportbug")
        m_type = CREATURE_EVENT_REPORTBUG;
    else if(tmpStr == "look")
        m_type = CREATURE_EVENT_LOOK;
    else if(tmpStr == "think")
        m_type = CREATURE_EVENT_THINK;
    else if(tmpStr == "direction")
        m_type = CREATURE_EVENT_DIRECTION;
    else if(tmpStr == "outfit")
        m_type = CREATURE_EVENT_OUTFIT;
    else if(tmpStr == "statschange")
        m_type = CREATURE_EVENT_STATSCHANGE;
    else if(tmpStr == "areacombat")
        m_type = CREATURE_EVENT_COMBAT_AREA;
    else if(tmpStr == "push")
        m_type = CREATURE_EVENT_PUSH;
    else if(tmpStr == "target")
        m_type = CREATURE_EVENT_TARGET;
    else if(tmpStr == "follow")
        m_type = CREATURE_EVENT_FOLLOW;
    else if(tmpStr == "combat")
        m_type = CREATURE_EVENT_COMBAT;
    else if(tmpStr == "attack")
        m_type = CREATURE_EVENT_ATTACK;
    else if(tmpStr == "cast")
        m_type = CREATURE_EVENT_CAST;
    else if(tmpStr == "kill")
        m_type = CREATURE_EVENT_KILL;
    else if(tmpStr == "death")
        m_type = CREATURE_EVENT_DEATH;
    else if(tmpStr == "preparedeath")
        m_type = CREATURE_EVENT_PREPAREDEATH;
    else if(tmpStr == "spawn")
        m_type = CREATURE_EVENT_SPAWN; 
    else
    {
        std::cout << "[Error - CreatureEvent::configureEvent] No valid type for creature event." << str << std::endl;
        return false;
    }

    m_isLoaded = true;
    return true;
}

std::string CreatureEvent::getScriptEventName() const
{
    switch(m_type)
    {
        case CREATURE_EVENT_LOGIN:
            return "onLogin";
        case CREATURE_EVENT_LOGOUT:
            return "onLogout";
        case CREATURE_EVENT_CHANNEL_JOIN:
            return "onJoinChannel";
        case CREATURE_EVENT_CHANNEL_LEAVE:
            return "onLeaveChannel";
        case CREATURE_EVENT_THINK:
            return "onThink";
        case CREATURE_EVENT_ADVANCE:
            return "onAdvance";
        case CREATURE_EVENT_LOOK:
            return "onLook";
        case CREATURE_EVENT_DIRECTION:
            return "onDirection";
        case CREATURE_EVENT_OUTFIT:
            return "onOutfit";
        case CREATURE_EVENT_MAIL_SEND:
            return "onSendMail";
        case CREATURE_EVENT_MAIL_RECEIVE:
            return "onReceiveMail";
        case CREATURE_EVENT_TRADE_REQUEST:
            return "onTradeRequest";
        case CREATURE_EVENT_TRADE_ACCEPT:
            return "onTradeAccept";
        case CREATURE_EVENT_TEXTEDIT:
            return "onTextEdit";
        case CREATURE_EVENT_REPORTBUG:
            return "onReportBug";
        case CREATURE_EVENT_STATSCHANGE:
            return "onStatsChange";
        case CREATURE_EVENT_COMBAT_AREA:
            return "onAreaCombat";
        case CREATURE_EVENT_PUSH:
            return "onPush";
        case CREATURE_EVENT_TARGET:
            return "onTarget";
        case CREATURE_EVENT_FOLLOW:
            return "onFollow";
        case CREATURE_EVENT_COMBAT:
            return "onCombat";
        case CREATURE_EVENT_ATTACK:
            return "onAttack";
        case CREATURE_EVENT_CAST:
            return "onCast";
        case CREATURE_EVENT_KILL:
            return "onKill";
        case CREATURE_EVENT_DEATH:
            return "onDeath";
        case CREATURE_EVENT_PREPAREDEATH:
            return "onPrepareDeath";
        case CREATURE_EVENT_SPAWN:
            return "onSpawn";
        case CREATURE_EVENT_NONE:
        default:
            break;
    }

    return "";
}

std::string CreatureEvent::getScriptEventParams() const
{
    switch(m_type)
    {
        case CREATURE_EVENT_LOGIN:
            return "cid";
        case CREATURE_EVENT_LOGOUT:
            return "cid, forceLogout";
        case CREATURE_EVENT_CHANNEL_JOIN:
        case CREATURE_EVENT_CHANNEL_LEAVE:
            return "cid, channel, users";
        case CREATURE_EVENT_ADVANCE:
            return "cid, skill, oldLevel, newLevel";
        case CREATURE_EVENT_LOOK:
            return "cid, thing, position, lookDistance";
        case CREATURE_EVENT_MAIL_SEND:
            return "cid, receiver, item, openBox";
        case CREATURE_EVENT_MAIL_RECEIVE:
            return "cid, sender, item, openBox";
        case CREATURE_EVENT_TRADE_REQUEST:
        case CREATURE_EVENT_TRADE_ACCEPT:
            return "cid, target, item";
        case CREATURE_EVENT_TEXTEDIT:
            return "cid, item, newText";
        case CREATURE_EVENT_REPORTBUG:
            return "cid, comment";
        case CREATURE_EVENT_THINK:
            return "cid, interval";
        case CREATURE_EVENT_DIRECTION:
        case CREATURE_EVENT_OUTFIT:
            return "cid, old, current";
        case CREATURE_EVENT_STATSCHANGE:
            return "cid, attacker, type, combat, value";
        case CREATURE_EVENT_COMBAT_AREA:
            return "cid, ground, position, aggressive";
        case CREATURE_EVENT_PUSH:
        case CREATURE_EVENT_TARGET:
        case CREATURE_EVENT_FOLLOW:
        case CREATURE_EVENT_COMBAT:
        case CREATURE_EVENT_ATTACK:
        case CREATURE_EVENT_CAST:
            return "cid, target";
        case CREATURE_EVENT_KILL:
            return "cid, target, lastHit";
        case CREATURE_EVENT_DEATH:
            return "cid, corpse, deathList";
        case CREATURE_EVENT_PREPAREDEATH:
            return "cid, deathList";
        case CREATURE_EVENT_SPAWN:
            return "cid";
        case CREATURE_EVENT_NONE:
        default:
            break;
    }

    return "";
}

void CreatureEvent::copyEvent(CreatureEvent* creatureEvent)
{
    m_scriptId = creatureEvent->m_scriptId;
    m_interface = creatureEvent->m_interface;
    m_scripted = creatureEvent->m_scripted;
    m_isLoaded = creatureEvent->m_isLoaded;
}

void CreatureEvent::clearEvent()
{
    m_scriptId = 0;
    m_interface = NULL;
    m_scripted = EVENT_SCRIPT_FALSE;
    m_isLoaded = false;
}

uint32_t CreatureEvent::executeLogin(Player* player)
{
    //onLogin(cid)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(player) << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", player->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);
            lua_pushnumber(L, env->addThing(player));

            bool result = m_interface->callFunction(1);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeLogin] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeLogout(Player* player, bool forceLogout)
{
    //onLogout(cid, forceLogout)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;

            scriptstream << "local cid = " << env->addThing(player) << std::endl;
            scriptstream << "local forceLogout = " << (forceLogout ? "true" : "false") << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", player->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(player));
            lua_pushboolean(L, forceLogout);

            bool result = m_interface->callFunction(2);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeLogout] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeChannelJoin(Player* player, uint16_t channelId, UsersMap usersMap)
{
    //onJoinChannel(cid, channel, users)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(player) << std::endl;

            scriptstream << "local channel = " << channelId << std::endl;
            scriptstream << "local users = {}" << std::endl;
            for(UsersMap::iterator it = usersMap.begin(); it != usersMap.end(); ++it)
                scriptstream << "users:insert(" << env->addThing(it->second) << ")" << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", player->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(player));
            lua_pushnumber(L, channelId);

            UsersMap::iterator it = usersMap.begin();
            lua_newtable(L);
            for(int32_t i = 1; it != usersMap.end(); ++it, ++i)
            {
                lua_pushnumber(L, i);
                lua_pushnumber(L, env->addThing(it->second));
                lua_settable(L, -3);
            }

            bool result = m_interface->callFunction(3);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeChannelJoin] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeChannelLeave(Player* player, uint16_t channelId, UsersMap usersMap)
{
    //onLeaveChannel(cid, channel, users)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(player) << std::endl;

            scriptstream << "local channel = " << channelId << std::endl;
            scriptstream << "local users = {}" << std::endl;
            for(UsersMap::iterator it = usersMap.begin(); it != usersMap.end(); ++it)
                scriptstream << "users:insert(" << env->addThing(it->second) << ")" << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", player->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(player));
            lua_pushnumber(L, channelId);

            UsersMap::iterator it = usersMap.begin();
            lua_newtable(L);
            for(int32_t i = 1; it != usersMap.end(); ++it, ++i)
            {
                lua_pushnumber(L, i);
                lua_pushnumber(L, env->addThing(it->second));
                lua_settable(L, -3);
            }

            bool result = m_interface->callFunction(3);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeChannelLeave] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeAdvance(Player* player, skills_t skill, uint32_t oldLevel, uint32_t newLevel)
{
    //onAdvance(cid, skill, oldLevel, newLevel)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(player) << std::endl;

            scriptstream << "local skill = " << skill << std::endl;
            scriptstream << "local oldLevel = " << oldLevel << std::endl;
            scriptstream << "local newLevel = " << newLevel << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", player->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(player));
            lua_pushnumber(L, (uint32_t)skill);

            lua_pushnumber(L, oldLevel);
            lua_pushnumber(L, newLevel);

            bool result = m_interface->callFunction(4);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeAdvance] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeMailSend(Player* player, Player* receiver, Item* item, bool openBox)
{
    //onSendMail(cid, receiver, item, openBox)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(player) << std::endl;

            scriptstream << "local receiver = " << env->addThing(receiver) << std::endl;
            env->streamThing(scriptstream, "item", item, env->addThing(item));
            scriptstream << "local openBox = " << (openBox ? "true" : "false") << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[30];
            sprintf(desc, "%s", player->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(player));
            lua_pushnumber(L, env->addThing(receiver));

            LuaScriptInterface::pushThing(L, item, env->addThing(item));
            lua_pushboolean(L, openBox);

            bool result = m_interface->callFunction(4);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeMailSend] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeMailReceive(Player* player, Player* sender, Item* item, bool openBox)
{
    //onReceiveMail(cid, sender, item, openBox)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(player) << std::endl;

            scriptstream << "local sender = " << env->addThing(sender) << std::endl;
            env->streamThing(scriptstream, "item", item, env->addThing(item));
            scriptstream << "local openBox = " << (openBox ? "true" : "false") << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[30];
            sprintf(desc, "%s", player->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(player));
            lua_pushnumber(L, env->addThing(sender));

            LuaScriptInterface::pushThing(L, item, env->addThing(item));
            lua_pushboolean(L, openBox);

            bool result = m_interface->callFunction(4);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeMailReceive] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeTradeRequest(Player* player, Player* target, Item* item)
{
    //onTradeRequest(cid, target, item)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(player) << std::endl;

            scriptstream << "local target = " << env->addThing(target) << std::endl;
            env->streamThing(scriptstream, "item", item, env->addThing(item));

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", player->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(player));
            lua_pushnumber(L, env->addThing(target));
            LuaScriptInterface::pushThing(L, item, env->addThing(item));

            bool result = m_interface->callFunction(3);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeTradeRequest] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeTradeAccept(Player* player, Player* target, Item* item, Item* targetItem)
{
    //onTradeAccept(cid, target, item, targetItem)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(player) << std::endl;

            scriptstream << "local target = " << env->addThing(target) << std::endl;
            env->streamThing(scriptstream, "item", item, env->addThing(item));

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", player->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(player));
            lua_pushnumber(L, env->addThing(target));
            LuaScriptInterface::pushThing(L, item, env->addThing(item));
            LuaScriptInterface::pushThing(L, targetItem, env->addThing(targetItem));

            bool result = m_interface->callFunction(4);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeTradeAccept] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeLook(Player* player, Thing* thing, const Position& position, int16_t stackpos, int32_t lookDistance)
{
    //onLook(cid, thing, position, lookDistance)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(player) << std::endl;

            scriptstream << "local thing = " << env->addThing(thing) << std::endl;
            env->streamPosition(scriptstream, "position", position, stackpos);
            scriptstream << "local lookDistance = " << lookDistance << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[30];
            sprintf(desc, "%s", player->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(player));
            LuaScriptInterface::pushThing(L, thing, env->addThing(thing));

            LuaScriptInterface::pushPosition(L, position, stackpos);
            lua_pushnumber(L, lookDistance);

            bool result = m_interface->callFunction(4);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeLook] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeDirection(Creature* creature, Direction old, Direction current)
{
    //onDirection(cid, old, current)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(creature) << std::endl;

            scriptstream << "local old = " << old << std::endl;
            scriptstream << "local current = " << current << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[30];
            sprintf(desc, "%s", creature->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            lua_pushnumber(L, old);
            lua_pushnumber(L, current);

            bool result = m_interface->callFunction(3);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeDirection] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeOutfit(Creature* creature, const Outfit_t& old, const Outfit_t& current)
{
    //onOutfit(cid, old, current)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(creature) << std::endl;

            env->streamOutfit(scriptstream, "old", old);
            env->streamOutfit(scriptstream, "current", current);

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[30];
            sprintf(desc, "%s", creature->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            LuaScriptInterface::pushOutfit(L, old);
            LuaScriptInterface::pushOutfit(L, current);

            bool result = m_interface->callFunction(3);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeOutfit] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeThink(Creature* creature, uint32_t interval)
{
    //onThink(cid, interval)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;

            scriptstream << "local cid = " << env->addThing(creature) << std::endl;
            scriptstream << "local interval = " << interval << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", creature->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            lua_pushnumber(L, interval);

            bool result = m_interface->callFunction(2);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeThink] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeStatsChange(Creature* creature, Creature* attacker, StatsChange_t type, CombatType_t combat, int32_t value)
{
    //onStatsChange(cid, attacker, type, combat, value)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;

            scriptstream << "local cid = " << env->addThing(creature) << std::endl;
            scriptstream << "local attacker = " << env->addThing(attacker) << std::endl;

            scriptstream << "local type = " << (uint32_t)type << std::endl;
            scriptstream << "local combat = " << (uint32_t)combat << std::endl;
            scriptstream << "local value = " << value << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", creature->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            lua_pushnumber(L, env->addThing(attacker));

            lua_pushnumber(L, (uint32_t)type);
            lua_pushnumber(L, (uint32_t)combat);
            lua_pushnumber(L, value);

            bool result = m_interface->callFunction(5);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeStatsChange] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeCombatArea(Creature* creature, Tile* tile, bool aggressive)
{
    //onAreaCombat(cid, ground, position, aggressive)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(creature) << std::endl;

            env->streamThing(scriptstream, "ground", tile->ground, env->addThing(tile->ground));
            env->streamPosition(scriptstream, "position", tile->getPosition(), 0);
            scriptstream << "local aggressive = " << (aggressive ? "true" : "false") << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            std::stringstream desc;
            desc << creature->getName();
            env->setEventDesc(desc.str());
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            LuaScriptInterface::pushThing(L, tile->ground, env->addThing(tile->ground));

            LuaScriptInterface::pushPosition(L, tile->getPosition(), 0);
            lua_pushboolean(L, aggressive);

            bool result = m_interface->callFunction(4);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeAreaCombat] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeCombat(Creature* creature, Creature* target)
{
    //onCombat(cid, target)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;

            scriptstream << "local cid = " << env->addThing(creature) << std::endl;
            scriptstream << "local target = " << env->addThing(target) << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            std::stringstream desc;
            desc << creature->getName();
            env->setEventDesc(desc.str());
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            lua_pushnumber(L, env->addThing(target));

            bool result = m_interface->callFunction(2);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeCombat] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeAttack(Creature* creature, Creature* target)
{
    //onAttack(cid, target)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;

            scriptstream << "local cid = " << env->addThing(creature) << std::endl;
            scriptstream << "local target = " << env->addThing(target) << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            std::stringstream desc;
            desc << creature->getName();
            env->setEventDesc(desc.str());
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            lua_pushnumber(L, env->addThing(target));

            bool result = m_interface->callFunction(2);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeAttack] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeCast(Creature* creature, Creature* target/* = NULL*/)
{
    //onCast(cid[, target])
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;

            scriptstream << "local cid = " << env->addThing(creature) << std::endl;
            scriptstream << "local target = ";
            if(target)
                scriptstream << env->addThing(target);
            else
                scriptstream << "nil";

            scriptstream << std::endl << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            std::stringstream desc;
            desc << creature->getName();
            env->setEventDesc(desc.str());
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            lua_pushnumber(L, env->addThing(target));

            bool result = m_interface->callFunction(2);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeCast] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeKill(Creature* creature, Creature* target, bool lastHit)
{
    //onKill(cid, target, lastHit)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(creature) << std::endl;

            scriptstream << "local target = " << env->addThing(target) << std::endl;
            scriptstream << "local lastHit = " << (lastHit ? "true" : "false") << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            std::stringstream desc;
            desc << creature->getName();
            env->setEventDesc(desc.str());
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            lua_pushnumber(L, env->addThing(target));
            lua_pushboolean(L, lastHit);

            bool result = m_interface->callFunction(3);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeKill] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeDeath(Creature* creature, Item* corpse, DeathList deathList)
{
    //onDeath(cid, corpse, deathList)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(creature) << std::endl;

            env->streamThing(scriptstream, "corpse", corpse, env->addThing(corpse));
            scriptstream << "local deathList = {}" << std::endl;
            for(DeathList::iterator it = deathList.begin(); it != deathList.end(); ++it)
            {
                scriptstream << "deathList:insert(";
            //    if(it->isCreatureKill())
            //        scriptstream << env->addThing(it->getKillerCreature());
            //    else
                    scriptstream << it->getKillerName();

                scriptstream << ")" << std::endl;
            }

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", creature->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            LuaScriptInterface::pushThing(L, corpse, env->addThing(corpse));

            lua_newtable(L);
            DeathList::iterator it = deathList.begin();
            for(int32_t i = 1; it != deathList.end(); ++it, ++i)
            {
                lua_pushnumber(L, i);
            //    if(it->isCreatureKill())
            //        lua_pushnumber(L, env->addThing(it->getKillerCreature()));
            //    else
                    lua_pushstring(L, it->getKillerName().c_str());

                lua_settable(L, -3);
            }

            bool result = m_interface->callFunction(3);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeDeath] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executePrepareDeath(Creature* creature, DeathList deathList)
{
    //onPrepareDeath(cid, deathList)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(creature) << std::endl;

            scriptstream << "local deathList = {}" << std::endl;
            for(DeathList::iterator it = deathList.begin(); it != deathList.end(); ++it)
            {
                scriptstream << "deathList:insert(";
                if(it->isCreatureKill())
                    scriptstream << env->addThing(it->getKillerCreature());
                else
                    scriptstream << it->getKillerName();

                scriptstream << ")" << std::endl;
            }

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", creature->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));

            lua_newtable(L);
            DeathList::iterator it = deathList.begin();
            for(int32_t i = 1; it != deathList.end(); ++it, ++i)
            {
                lua_pushnumber(L, i);
                if(it->isCreatureKill())
                    lua_pushnumber(L, env->addThing(it->getKillerCreature()));
                else
                    lua_pushstring(L, it->getKillerName().c_str());

                lua_settable(L, -3);
            }

            bool result = m_interface->callFunction(2);
            m_interface->releaseEnv();

            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executePrepareDeath] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeTextEdit(Player* player, Item* item, std::string newText)
{
    //onTextEdit(cid, item, newText)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;
            scriptstream << "local cid = " << env->addThing(player) << std::endl;

            env->streamThing(scriptstream, "item", item, env->addThing(item));
            scriptstream << "local newText = " << newText.c_str() << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", player->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(player));
            LuaScriptInterface::pushThing(L, item, env->addThing(item));
            lua_pushstring(L, newText.c_str());

            bool result = m_interface->callFunction(3);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeTextEdit] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeReportBug(Player* player, std::string comment)
{
    //onReportBug(cid, comment)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;

            scriptstream << "local cid = " << env->addThing(player) << std::endl;
            scriptstream << "local comment = " << comment.c_str() << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            char desc[35];
            sprintf(desc, "%s", player->getName().c_str());
            env->setEventDesc(desc);
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(player));
            lua_pushstring(L, comment.c_str());

            bool result = m_interface->callFunction(2);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeReportBug] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executePush(Player* player, Creature* target)
{
    //onPush(cid, target)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(player->getPosition());
            std::stringstream scriptstream;

            scriptstream << "local cid = " << env->addThing(player) << std::endl;
            scriptstream << "local target = " << env->addThing(target) << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            std::stringstream desc;
            desc << player->getName();
            env->setEventDesc(desc.str());
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(player->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(player));
            lua_pushnumber(L, env->addThing(target));

            bool result = m_interface->callFunction(2);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executePush] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeTarget(Creature* creature, Creature* target)
{
    //onTarget(cid, target)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;

            scriptstream << "local cid = " << env->addThing(creature) << std::endl;
            scriptstream << "local target = " << env->addThing(target) << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            std::stringstream desc;
            desc << creature->getName();
            env->setEventDesc(desc.str());
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            lua_pushnumber(L, env->addThing(target));

            bool result = m_interface->callFunction(2);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeTarget] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeFollow(Creature* creature, Creature* target)
{
    //onFollow(cid, target)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;

            scriptstream << "local cid = " << env->addThing(creature) << std::endl;
            scriptstream << "local target = " << env->addThing(target) << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            std::stringstream desc;
            desc << creature->getName();
            env->setEventDesc(desc.str());
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            lua_pushnumber(L, env->addThing(target));

            bool result = m_interface->callFunction(2);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeFollow] Call stack overflow." << std::endl;
        return 0;
    }
}
uint32_t CreatureEvent::executeOnSpawn(Creature* creature)
{

    //onSpawn(cid)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;

            scriptstream << "local cid = " << env->addThing(creature) << std::endl;

            scriptstream << m_scriptData;

            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            std::stringstream desc;
            desc << creature->getName();
            env->setEvent(desc.str());
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));

            bool result = m_interface->callFunction(1);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::clog << "[Error - CreatureEvent::executeCast] Call stack overflow." << std::endl;
        return 0;
    }
}

uint32_t CreatureEvent::executeMatou(Creature* creature, Creature* target)
{
    //onFollow(cid, target)
    if(m_interface->reserveEnv())
    {
        ScriptEnviroment* env = m_interface->getEnv();
        if(m_scripted == EVENT_SCRIPT_BUFFER)
        {
            env->setRealPos(creature->getPosition());
            std::stringstream scriptstream;

            scriptstream << "local cid = " << env->addThing(creature) << std::endl;
            scriptstream << "local target = " << env->addThing(target) << std::endl;

            scriptstream << m_scriptData;
            bool result = true;
            if(m_interface->loadBuffer(scriptstream.str()))
            {
                lua_State* L = m_interface->getState();
                result = m_interface->getGlobalBool(L, "_result", true);
            }

            m_interface->releaseEnv();
            return result;
        }
        else
        {
            #ifdef __DEBUG_LUASCRIPTS__
            std::stringstream desc;
            desc << creature->getName();
            env->setEventDesc(desc.str());
            #endif

            env->setScriptId(m_scriptId, m_interface);
            env->setRealPos(creature->getPosition());

            lua_State* L = m_interface->getState();
            m_interface->pushFunction(m_scriptId);

            lua_pushnumber(L, env->addThing(creature));
            lua_pushnumber(L, env->addThing(target));

            bool result = m_interface->callFunction(2);
            m_interface->releaseEnv();
            return result;
        }
    }
    else
    {
        std::cout << "[Error - CreatureEvent::executeMatou] Call stack overflow." << std::endl;
        return 0;
    }
}
 

@Xz Death Xz gostaria de saber qual o motivo de você estar alterando o nome das funções, em todo caso vá em creatureevents.h e mude o nome da mesma função para essa nova, e é claro, em todos os outros arquivos que utilizam essa função!

Valeu mano

consegui arrumar

hehe

REP+