bool TalkAction::executeSay(Creature* creature, const std::string& words, const std::string& param)
{
//onSay(cid, words, param)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - TalkAction::executeSay] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_scriptId, m_scriptInterface);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_scriptId);
lua_pushnumber(L, creature->getID());
LuaScriptInterface::pushString(L, words);
LuaScriptInterface::pushString(L, param);
return m_scriptInterface->callFunction(3);
}
void CreatureEvent::executeOnKill(Creature* creature, Creature* target)
{
//onKill(creature, target)
if (!scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - CreatureEvent::executeOnKill] Call stack overflow" << std::endl;
return;
}
ScriptEnvironment* env = scriptInterface->getScriptEnv();
env->setScriptId(scriptId, scriptInterface);
lua_State* L = scriptInterface->getLuaState();
scriptInterface->pushFunction(scriptId);
LuaScriptInterface::pushUserdata<Creature>(L, creature);
LuaScriptInterface::setCreatureMetatable(L, -1, creature);
LuaScriptInterface::pushUserdata<Creature>(L, target);
LuaScriptInterface::setCreatureMetatable(L, -1, target);
scriptInterface->callVoidFunction(2);
}
bool CreatureEvent::executeOnThink(Creature* creature, uint32_t interval)
{
//onThink(creature, interval)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - CreatureEvent::executeOnThink] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_scriptId, m_scriptInterface);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_scriptId);
LuaScriptInterface::pushUserdata<Creature>(L, creature);
LuaScriptInterface::setCreatureMetatable(L, -1, creature);
lua_pushnumber(L, interval);
return m_scriptInterface->callFunction(2);
}
bool Weapon::executeUseWeapon(Player* player, const LuaVariant& var) const
{
//onUseWeapon(player, var)
if (!scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - Weapon::executeUseWeapon] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = scriptInterface->getScriptEnv();
env->setScriptId(scriptId, scriptInterface);
lua_State* L = scriptInterface->getLuaState();
scriptInterface->pushFunction(scriptId);
LuaScriptInterface::pushUserdata<Player>(L, player);
LuaScriptInterface::setMetatable(L, -1, "Player");
scriptInterface->pushVariant(L, var);
return scriptInterface->callFunction(2);
}
bool CreatureEvent::executeTextEdit(Player* player, Item* item, const std::string& text)
{
//onTextEdit(cid, item, text)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - CreatureEvent::executeTextEdit] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_scriptId, m_scriptInterface);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_scriptId);
LuaScriptInterface::pushNumber(L, player->getID());
LuaScriptInterface::pushThing(L, item, env->addThing(item));
LuaScriptInterface::pushString(L, text);
return m_scriptInterface->callFunction(3);
}
int32_t NpcScriptInterface::luaGetNpcParameter(lua_State* L)
{
//getNpcParameter(paramKey)
std::string paramKey = popString(L);
ScriptEnvironment* env = getScriptEnv();
Npc* npc = env->getNpc();
if (npc) {
auto it = npc->m_parameters.find(paramKey);
if (it != npc->m_parameters.end()) {
LuaScriptInterface::pushString(L, it->second);
} else {
lua_pushnil(L);
}
} else {
lua_pushnil(L);
}
return 1;
}
bool GlobalEvent::executeEvent()
{
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - GlobalEvent::executeEvent] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_scriptId, m_scriptInterface);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_scriptId);
int32_t params = 0;
if (m_eventType == GLOBALEVENT_NONE || m_eventType == GLOBALEVENT_TIMER) {
lua_pushnumber(L, m_interval);
params = 1;
}
return m_scriptInterface->callFunction(params);
}
bool ChatChannel::executeOnSpeakEvent(const Player& player, SpeakClasses& type, const std::string& message)
{
if (onSpeakEvent == -1) {
return true;
}
//onSpeak(cid, type, message)
LuaScriptInterface* m_scriptInterface = g_chat.getScriptInterface();
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - OnSpeakChannelEvent::execute] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(onSpeakEvent, m_scriptInterface);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(onSpeakEvent);
lua_pushnumber(L, player.getID());
lua_pushnumber(L, type);
LuaScriptInterface::pushString(L, message);
bool result = false;
int32_t size0 = lua_gettop(L);
int32_t ret = m_scriptInterface->protectedCall(L, 3, 1);
if (ret != 0) {
LuaScriptInterface::reportError(nullptr, LuaScriptInterface::popString(L));
} else if (lua_isboolean(L, -1)) {
result = LuaScriptInterface::popBoolean(L);
} else if (lua_gettop(L) > 0 && lua_isnumber(L, -1)) {
result = true;
type = static_cast<SpeakClasses>(LuaScriptInterface::popNumber(L));
}
if ((lua_gettop(L) + 4) != size0) {
LuaScriptInterface::reportError(nullptr, "Stack size changed!");
}
m_scriptInterface->resetScriptEnv();
return result;
}
void Monster::onCreatureAppear(Creature* creature, bool isLogin)
{
Creature::onCreatureAppear(creature, isLogin);
if (mType->info.creatureAppearEvent != -1) {
// onCreatureAppear(self, creature)
LuaScriptInterface* scriptInterface = mType->info.scriptInterface;
if (!scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - Monster::onCreatureAppear] Call stack overflow" << std::endl;
return;
}
ScriptEnvironment* env = scriptInterface->getScriptEnv();
env->setScriptId(mType->info.creatureAppearEvent, scriptInterface);
lua_State* L = scriptInterface->getLuaState();
scriptInterface->pushFunction(mType->info.creatureAppearEvent);
LuaScriptInterface::pushUserdata<Monster>(L, this);
LuaScriptInterface::setMetatable(L, -1, "Monster");
LuaScriptInterface::pushUserdata<Creature>(L, creature);
LuaScriptInterface::setCreatureMetatable(L, -1, creature);
if (scriptInterface->callFunction(2)) {
return;
}
}
if (creature == this) {
//We just spawned lets look around to see who is there.
if (isSummon()) {
isMasterInRange = canSee(getMaster()->getPosition());
}
updateTargetList();
updateIdleStatus();
} else {
onCreatureEnter(creature);
}
}
void Events::eventPlayerOnGainExperience(Player* player, Creature* source, uint64_t& exp, uint64_t rawExp)
{
// Player:onGainExperience(source, exp, rawExp)
// rawExp gives the original exp which is not multiplied
if (playerOnGainExperience == -1) {
return;
}
if (!scriptInterface.reserveScriptEnv()) {
std::cout << "[Error - Events::eventPlayerOnGainExperience] Call stack overflow" << std::endl;
return;
}
ScriptEnvironment* env = scriptInterface.getScriptEnv();
env->setScriptId(playerOnGainExperience, &scriptInterface);
lua_State* L = scriptInterface.getLuaState();
scriptInterface.pushFunction(playerOnGainExperience);
LuaScriptInterface::pushUserdata<Player>(L, player);
LuaScriptInterface::setMetatable(L, -1, "Player");
if (source) {
LuaScriptInterface::pushUserdata<Creature>(L, source);
LuaScriptInterface::setCreatureMetatable(L, -1, source);
} else {
lua_pushnil(L);
}
lua_pushnumber(L, exp);
lua_pushnumber(L, rawExp);
if (scriptInterface.protectedCall(L, 4, 1) != 0) {
LuaScriptInterface::reportError(nullptr, LuaScriptInterface::popString(L));
} else {
exp = LuaScriptInterface::getNumber<uint64_t>(L, -1);
lua_pop(L, 1);
}
scriptInterface.resetScriptEnv();
}
bool MoveEvent::executeEquip(Player* player, Item* item, slots_t slot)
{
//onEquip(cid, item, slot)
//onDeEquip(cid, item, slot)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - MoveEvent::executeEquip] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_scriptId, m_scriptInterface);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_scriptId);
lua_pushnumber(L, player->getID());
LuaScriptInterface::pushThing(L, item, env->addThing(item));
lua_pushnumber(L, slot);
return m_scriptInterface->callFunction(3);
}
bool MoveEvent::executeAddRemItem(Item* item, Item* tileItem, const Position& pos)
{
//onaddItem(moveitem, tileitem, pos)
//onRemoveItem(moveitem, tileitem, pos)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - MoveEvent::executeAddRemItem] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_scriptId, m_scriptInterface);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_scriptId);
LuaScriptInterface::pushThing(L, item);
LuaScriptInterface::pushThing(L, tileItem);
LuaScriptInterface::pushPosition(L, pos);
return m_scriptInterface->callFunction(3);
}
void NpcScript::onThink()
{
if (m_onThink == -1) {
return;
}
//onThink()
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - NpcScript::onThink] Call stack overflow" << std::endl;
return;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_onThink, m_scriptInterface);
env->setRealPos(m_npc->getPosition());
env->setNpc(m_npc);
m_scriptInterface->pushFunction(m_onThink);
m_scriptInterface->callFunction(0);
}
void NpcEventsHandler::onCreatureAppear(Creature* creature)
{
if (creatureAppearEvent == -1) {
return;
}
//onCreatureAppear(creature)
if (!scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - NpcScript::onCreatureAppear] Call stack overflow" << std::endl;
}
ScriptEnvironment* env = scriptInterface->getScriptEnv();
env->setScriptId(creatureAppearEvent, scriptInterface);
env->setNpc(npc);
lua_State* L = scriptInterface->getLuaState();
scriptInterface->pushFunction(creatureAppearEvent);
LuaScriptInterface::pushUserdata<Creature>(L, creature);
LuaScriptInterface::setCreatureMetatable(L, -1, creature);
scriptInterface->callFunction(1);
}
bool CreatureEvent::executeAdvance(Player* player, skills_t skill, uint32_t oldLevel,
uint32_t newLevel)
{
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - CreatureEvent::executeAdvance] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_scriptId, m_scriptInterface);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_scriptId);
lua_pushnumber(L, player->getID());
lua_pushnumber(L, static_cast<uint32_t>(skill));
lua_pushnumber(L, oldLevel);
lua_pushnumber(L, newLevel);
return m_scriptInterface->callFunction(4);
}
void NpcScript::onCreatureDisappear(const Creature* creature)
{
if (m_onCreatureDisappear == -1) {
return;
}
//onCreatureDisappear(id)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - NpcScript::onCreatureDisappear] Call stack overflow" << std::endl;
return;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_onCreatureDisappear, m_scriptInterface);
env->setNpc(m_npc);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_onCreatureDisappear);
lua_pushnumber(L, creature->getID());
m_scriptInterface->callFunction(1);
}
bool CreatureEvent::executeModalWindow(Player* player, uint32_t modalWindowId, uint8_t buttonId, uint8_t choiceId)
{
//onModalWindow(cid, modalWindowId, buttonId, choiceId)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - CreatureEvent::executeModalWindow] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_scriptId, m_scriptInterface);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_scriptId);
LuaScriptInterface::pushNumber(L, player->getID());
LuaScriptInterface::pushNumber(L, modalWindowId);
LuaScriptInterface::pushNumber(L, buttonId);
LuaScriptInterface::pushNumber(L, choiceId);
return m_scriptInterface->callFunction(4);
}
void NpcScript::onPlayerEndTrade(const Player* player)
{
if (m_onPlayerEndTrade == -1) {
return;
}
//onPlayerEndTrade(cid)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - NpcScript::onPlayerEndTrade] Call stack overflow" << std::endl;
return;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_onPlayerEndTrade, m_scriptInterface);
env->setNpc(m_npc);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_onPlayerEndTrade);
lua_pushnumber(L, player->getID());
m_scriptInterface->callFunction(1);
}
ReturnValue Events::eventCreatureOnTargetCombat(Creature* creature, Creature* target)
{
// Creature:onTargetCombat(target) or Creature.onTargetCombat(self, target)
if (creatureOnTargetCombat == -1) {
return RETURNVALUE_NOERROR;
}
if (!scriptInterface.reserveScriptEnv()) {
std::cout << "[Error - Events::eventCreatureOnTargetCombat] Call stack overflow" << std::endl;
return RETURNVALUE_NOTPOSSIBLE;
}
ScriptEnvironment* env = scriptInterface.getScriptEnv();
env->setScriptId(creatureOnTargetCombat, &scriptInterface);
lua_State* L = scriptInterface.getLuaState();
scriptInterface.pushFunction(creatureOnTargetCombat);
if (creature) {
LuaScriptInterface::pushUserdata<Creature>(L, creature);
LuaScriptInterface::setCreatureMetatable(L, -1, creature);
} else {
lua_pushnil(L);
}
LuaScriptInterface::pushUserdata<Creature>(L, target);
LuaScriptInterface::setCreatureMetatable(L, -1, target);
ReturnValue returnValue;
if (scriptInterface.protectedCall(L, 2, 1) != 0) {
returnValue = RETURNVALUE_NOTPOSSIBLE;
LuaScriptInterface::reportError(nullptr, LuaScriptInterface::popString(L));
} else {
returnValue = LuaScriptInterface::getNumber<ReturnValue>(L, -1);
lua_pop(L, 1);
}
scriptInterface.resetScriptEnv();
return returnValue;
}
void NpcEventsHandler::onPlayerCloseChannel(Player* player)
{
if (m_onPlayerCloseChannel == -1) {
return;
}
// onPlayerCloseChannel(player)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - NpcScript::onPlayerCloseChannel] Call stack overflow" << std::endl;
return;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_onPlayerCloseChannel, m_scriptInterface);
env->setNpc(m_npc);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_onPlayerCloseChannel);
LuaScriptInterface::pushUserdata<Player>(L, player);
LuaScriptInterface::setMetatable(L, -1, "Player");
m_scriptInterface->callFunction(1);
}
void Monster::onRemoveCreature(Creature* creature, bool isLogout)
{
Creature::onRemoveCreature(creature, isLogout);
if (mType->info.creatureDisappearEvent != -1) {
// onCreatureDisappear(self, creature)
LuaScriptInterface* scriptInterface = mType->info.scriptInterface;
if (!scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - Monster::onCreatureDisappear] Call stack overflow" << std::endl;
return;
}
ScriptEnvironment* env = scriptInterface->getScriptEnv();
env->setScriptId(mType->info.creatureDisappearEvent, scriptInterface);
lua_State* L = scriptInterface->getLuaState();
scriptInterface->pushFunction(mType->info.creatureDisappearEvent);
LuaScriptInterface::pushUserdata<Monster>(L, this);
LuaScriptInterface::setMetatable(L, -1, "Monster");
LuaScriptInterface::pushUserdata<Creature>(L, creature);
LuaScriptInterface::setCreatureMetatable(L, -1, creature);
if (scriptInterface->callFunction(2)) {
return;
}
}
if (creature == this) {
if (spawn) {
spawn->startSpawnCheck();
}
setIdle(true);
} else {
onCreatureLeave(creature);
}
}
bool CreatureEvent::executeTextEdit(Player* player, Item* item, const std::string& text)
{
//onTextEdit(player, item, text)
if (!scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - CreatureEvent::executeTextEdit] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = scriptInterface->getScriptEnv();
env->setScriptId(scriptId, scriptInterface);
lua_State* L = scriptInterface->getLuaState();
scriptInterface->pushFunction(scriptId);
LuaScriptInterface::pushUserdata(L, player);
LuaScriptInterface::setMetatable(L, -1, "Player");
LuaScriptInterface::pushThing(L, item);
LuaScriptInterface::pushString(L, text);
return scriptInterface->callFunction(3);
}
bool CombatSpell::executeCastSpell(Creature* creature, const LuaVariant& var)
{
//onCastSpell(creature, var)
if (!scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - CombatSpell::executeCastSpell] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = scriptInterface->getScriptEnv();
env->setScriptId(scriptId, scriptInterface);
lua_State* L = scriptInterface->getLuaState();
scriptInterface->pushFunction(scriptId);
LuaScriptInterface::pushUserdata<Creature>(L, creature);
LuaScriptInterface::setCreatureMetatable(L, -1, creature);
LuaScriptInterface::pushVariant(L, var);
return scriptInterface->callFunction(2);
}
bool CreatureEvent::executeOnDeath(Creature* creature, Item* corpse, Creature* killer, Creature* mostDamageKiller, bool lastHitUnjustified, bool mostDamageUnjustified)
{
//onDeath(cid, corpse, lasthitkiller, mostdamagekiller, lasthitunjustified, mostdamageunjustified)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - CreatureEvent::executeOnDeath] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_scriptId, m_scriptInterface);
uint32_t corpseid = env->addThing(corpse);
uint32_t killercid;
if (killer) {
killercid = killer->getID();
} else {
killercid = 0;
}
uint32_t mostdamagekillercid;
if (mostDamageKiller) {
mostdamagekillercid = mostDamageKiller->getID();
} else {
mostdamagekillercid = 0;
}
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_scriptId);
lua_pushnumber(L, creature->getID());
lua_pushnumber(L, corpseid);
lua_pushnumber(L, killercid);
lua_pushnumber(L, mostdamagekillercid);
lua_pushnumber(L, lastHitUnjustified);
lua_pushnumber(L, mostDamageUnjustified);
return m_scriptInterface->callFunction(6);
}
void NpcScript::onCreatureDisappear(Creature* creature)
{
if (m_onCreatureDisappear == -1) {
return;
}
//onCreatureDisappear(creature)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - NpcScript::onCreatureDisappear] Call stack overflow" << std::endl;
return;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_onCreatureDisappear, m_scriptInterface);
env->setNpc(m_npc);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_onCreatureDisappear);
LuaScriptInterface::pushUserdata<Creature>(L, creature);
LuaScriptInterface::setCreatureMetatable(L, -1, creature);
m_scriptInterface->callFunction(1);
}
bool MoveEvent::executeStep(Creature* creature, Item* item, const Position& pos)
{
//onStepIn(cid, item, pos, fromPosition)
//onStepOut(cid, item, pos, fromPosition)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - MoveEvent::executeStep] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_scriptId, m_scriptInterface);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_scriptId);
lua_pushnumber(L, creature->getID());
LuaScriptInterface::pushThing(L, item, env->addThing(item));
LuaScriptInterface::pushPosition(L, pos, 0);
LuaScriptInterface::pushPosition(L, creature->getLastPosition(), 0);
return m_scriptInterface->callFunction(4);
}
void NpcEventsHandler::onPlayerEndTrade(Player* player)
{
if (playerEndTradeEvent == -1) {
return;
}
//onPlayerEndTrade(player)
if (!scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - NpcScript::onPlayerEndTrade] Call stack overflow" << std::endl;
return;
}
ScriptEnvironment* env = scriptInterface->getScriptEnv();
env->setScriptId(playerEndTradeEvent, scriptInterface);
env->setNpc(npc);
lua_State* L = scriptInterface->getLuaState();
scriptInterface->pushFunction(playerEndTradeEvent);
LuaScriptInterface::pushUserdata<Player>(L, player);
LuaScriptInterface::setMetatable(L, -1, "Player");
scriptInterface->callFunction(1);
}
bool MoveEvent::executeEquip(Player* player, Item* item, slots_t slot)
{
//onEquip(player, item, slot)
//onDeEquip(player, item, slot)
if (!scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - MoveEvent::executeEquip] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = scriptInterface->getScriptEnv();
env->setScriptId(scriptId, scriptInterface);
lua_State* L = scriptInterface->getLuaState();
scriptInterface->pushFunction(scriptId);
LuaScriptInterface::pushUserdata<Player>(L, player);
LuaScriptInterface::setMetatable(L, -1, "Player");
LuaScriptInterface::pushThing(L, item);
lua_pushnumber(L, slot);
return scriptInterface->callFunction(3);
}
bool CreatureEvent::executeOnDeath(Creature* creature, Item* corpse, Creature* killer, Creature* mostDamageKiller, bool lastHitUnjustified, bool mostDamageUnjustified)
{
//onDeath(creature, corpse, lasthitkiller, mostdamagekiller, lasthitunjustified, mostdamageunjustified)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - CreatureEvent::executeOnDeath] Call stack overflow" << std::endl;
return false;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_scriptId, m_scriptInterface);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_scriptId);
LuaScriptInterface::pushUserdata<Creature>(L, creature);
LuaScriptInterface::setCreatureMetatable(L, -1, creature);
LuaScriptInterface::pushThing(L, corpse);
if (killer) {
LuaScriptInterface::pushUserdata<Creature>(L, killer);
LuaScriptInterface::setCreatureMetatable(L, -1, killer);
} else {
lua_pushnil(L);
}
if (mostDamageKiller) {
LuaScriptInterface::pushUserdata<Creature>(L, mostDamageKiller);
LuaScriptInterface::setCreatureMetatable(L, -1, mostDamageKiller);
} else {
lua_pushnil(L);
}
LuaScriptInterface::pushBoolean(L, lastHitUnjustified);
LuaScriptInterface::pushBoolean(L, mostDamageUnjustified);
return m_scriptInterface->callFunction(6);
}
void NpcScript::onCreatureSay(const Creature* creature, SpeakClasses type, const std::string& text, Position* pos/* = nullptr*/)
{
if (m_onCreatureSay == -1) {
return;
}
//onCreatureSay(cid, type, msg)
if (!m_scriptInterface->reserveScriptEnv()) {
std::cout << "[Error - NpcScript::onCreatureSay] Call stack overflow" << std::endl;
return;
}
ScriptEnvironment* env = m_scriptInterface->getScriptEnv();
env->setScriptId(m_onCreatureSay, m_scriptInterface);
env->setNpc(m_npc);
lua_State* L = m_scriptInterface->getLuaState();
m_scriptInterface->pushFunction(m_onCreatureSay);
lua_pushnumber(L, creature->getID());
lua_pushnumber(L, type);
LuaScriptInterface::pushString(L, text);
m_scriptInterface->callFunction(3);
}
