API tools faq
paste
Advertisement
Guest User

spells.cpp

a guest
Jan 3rd, 2013
90
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Lua 52.80 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. #include "const.h"
  19. #include <libxml/xmlmemory.h>
  20. #include <libxml/parser.h>
  21.  
  22. #include "spells.h"
  23. #include "tools.h"
  24.  
  25. #include "house.h"
  26. #include "housetile.h"
  27. #include "combat.h"
  28.  
  29. #include "monsters.h"
  30. #include "configmanager.h"
  31. #include "game.h"
  32.  
  33. extern Game g_game;
  34. extern Spells* g_spells;
  35. extern Monsters g_monsters;
  36. extern ConfigManager g_config;
  37.  
  38. Spells::Spells():
  39. m_interface("Spell Interface")
  40. {
  41.     m_interface.initState();
  42. }
  43.  
  44. ReturnValue Spells::onPlayerSay(Player* player, const std::string& words)
  45. {
  46.     std::string reWords = words;
  47.     trimString(reWords);
  48.  
  49.     InstantSpell* instantSpell = getInstantSpell(reWords);
  50.     if(!instantSpell)
  51.         return RET_NOTPOSSIBLE;
  52.  
  53.     size_t size = instantSpell->getWords().length();
  54.     std::string param = reWords.substr(size, reWords.length() - size), reParam = "";
  55.     if(instantSpell->getHasParam() && !param.empty() && param[0] == ' ')
  56.     {
  57.         size_t quote = param.find('"', 1);
  58.         if(quote != std::string::npos)
  59.         {
  60.             size_t tmp = param.find('"', quote + 1);
  61.             if(tmp == std::string::npos)
  62.                 tmp = param.length();
  63.  
  64.             reParam = param.substr(quote + 1, tmp - quote - 1);
  65.         }
  66.         else if(param.find(' ', 1) == std::string::npos)
  67.             reParam = param.substr(1, param.length());
  68.  
  69.         trimString(reParam);
  70.     }
  71.  
  72.     Position pos = player->getPosition();
  73.     if(!instantSpell->castInstant(player, reParam))
  74.         return RET_NEEDEXCHANGE;
  75.  
  76.     SpeakClasses type = SPEAK_SAY;
  77.     if(g_config.getBool(ConfigManager::EMOTE_SPELLS))
  78.         type = SPEAK_MONSTER_SAY;
  79.  
  80.     if(!g_config.getBool(ConfigManager::SPELL_NAME_INSTEAD_WORDS))
  81.     {
  82.         if(g_config.getBool(ConfigManager::UNIFIED_SPELLS))
  83.         {
  84.             reWords = instantSpell->getWords();
  85.             if(instantSpell->getHasParam())
  86.                 reWords += " \"" + reParam + "\"";
  87.         }
  88.  
  89.         return g_game.internalCreatureSay(player, type, reWords, player->isGhost()) ?
  90.             RET_NOERROR : RET_NOTPOSSIBLE;
  91.     }
  92.  
  93.     std::string ret = instantSpell->getName();
  94.     if(param.length())
  95.     {
  96.         trimString(param);
  97.         size_t tmp = 0, rtmp = param.length();
  98.         if(param[0] == '"')
  99.             tmp = 1;
  100.  
  101.         if(param[rtmp] == '"')
  102.             rtmp -= 1;
  103.  
  104.         ret += ": " + param.substr(tmp, rtmp);
  105.     }
  106.  
  107.     return g_game.internalCreatureSay(player, type, ret, player->isGhost(),
  108.         NULL, &pos) ? RET_NOERROR : RET_NOTPOSSIBLE;
  109. }
  110.  
  111. void Spells::clear()
  112. {
  113.     for(RunesMap::iterator rit = runes.begin(); rit != runes.end(); ++rit)
  114.         delete rit->second;
  115.  
  116.     runes.clear();
  117.     for(InstantsMap::iterator it = instants.begin(); it != instants.end(); ++it)
  118.         delete it->second;
  119.  
  120.     instants.clear();
  121.     m_interface.reInitState();
  122. }
  123.  
  124. Event* Spells::getEvent(const std::string& nodeName)
  125. {
  126.     std::string tmpNodeName = asLowerCaseString(nodeName);
  127.     if(tmpNodeName == "rune")
  128.         return new RuneSpell(&m_interface);
  129.  
  130.     if(tmpNodeName == "instant")
  131.         return new InstantSpell(&m_interface);
  132.  
  133.     if(tmpNodeName == "conjure")
  134.         return new ConjureSpell(&m_interface);
  135.  
  136.     return NULL;
  137. }
  138.  
  139. bool Spells::registerEvent(Event* event, xmlNodePtr, bool override)
  140. {
  141.     if(InstantSpell* instant = dynamic_cast<InstantSpell*>(event))
  142.     {
  143.         InstantsMap::iterator it = instants.find(instant->getWords());
  144.         if(it == instants.end())
  145.         {
  146.             instants[instant->getWords()] = instant;
  147.             return true;
  148.         }
  149.  
  150.         if(override)
  151.         {
  152.             delete it->second;
  153.             it->second = instant;
  154.             return true;
  155.         }
  156.  
  157.         std::clog << "[Warning - Spells::registerEvent] Duplicate registered instant spell with words: " << instant->getWords() << std::endl;
  158.         return false;
  159.     }
  160.  
  161.     if(RuneSpell* rune = dynamic_cast<RuneSpell*>(event))
  162.     {
  163.         RunesMap::iterator it = runes.find(rune->getRuneItemId());
  164.         if(it == runes.end())
  165.         {
  166.             runes[rune->getRuneItemId()] = rune;
  167.             return true;
  168.         }
  169.  
  170.         if(override)
  171.         {
  172.             delete it->second;
  173.             it->second = rune;
  174.             return true;
  175.         }
  176.  
  177.         std::clog << "[Warning - Spells::registerEvent] Duplicate registered rune with id: " << rune->getRuneItemId() << std::endl;
  178.         return false;
  179.     }
  180.  
  181.     return false;
  182. }
  183.  
  184. Spell* Spells::getSpellByName(const std::string& name)
  185. {
  186.     Spell* spell;
  187.     if((spell = getRuneSpellByName(name)) || (spell = getInstantSpellByName(name)))
  188.         return spell;
  189.  
  190.     return NULL;
  191. }
  192.  
  193. RuneSpell* Spells::getRuneSpell(uint32_t id)
  194. {
  195.     RunesMap::iterator it = runes.find(id);
  196.     if(it != runes.end())
  197.         return it->second;
  198.  
  199.     return NULL;
  200. }
  201.  
  202. RuneSpell* Spells::getRuneSpellByName(const std::string& name)
  203. {
  204.     for(RunesMap::iterator it = runes.begin(); it != runes.end(); ++it)
  205.     {
  206.         if(boost::algorithm::iequals(it->second->getName(), name))
  207.             return it->second;
  208.     }
  209.  
  210.     return NULL;
  211. }
  212.  
  213. InstantSpell* Spells::getInstantSpell(const std::string& words)
  214. {
  215.     InstantSpell* result = NULL;
  216.     for(InstantsMap::iterator it = instants.begin(); it != instants.end(); ++it)
  217.     {
  218.         InstantSpell* instantSpell = it->second;
  219.         if(!asLowerCaseString(words).compare(0, instantSpell->getWords().length(),
  220.             asLowerCaseString(instantSpell->getWords())))
  221.         {
  222.             if(!result || instantSpell->getWords().length() > result->getWords().length())
  223.                 result = instantSpell;
  224.         }
  225.     }
  226.  
  227.     if(result && words.length() > result->getWords().length())
  228.     {
  229.         std::string param = words.substr(result->getWords().length(), words.length());
  230.         if(param[0] != ' ' || (param.length() > 1 && (!result->getHasParam() || param.find(' ', 1) != std::string::npos) && param[1] != '"'))
  231.             return NULL;
  232.     }
  233.  
  234.     return result;
  235. }
  236.  
  237. uint32_t Spells::getInstantSpellCount(const Player* player)
  238. {
  239.     uint32_t count = 0;
  240.     for(InstantsMap::iterator it = instants.begin(); it != instants.end(); ++it)
  241.     {
  242.         if(it->second->canCast(player))
  243.             ++count;
  244.     }
  245.  
  246.     return count;
  247. }
  248.  
  249. InstantSpell* Spells::getInstantSpellByIndex(const Player* player, uint32_t index)
  250. {
  251.     uint32_t count = 0;
  252.     for(InstantsMap::iterator it = instants.begin(); it != instants.end(); ++it)
  253.     {
  254.         InstantSpell* instantSpell = it->second;
  255.         if(!instantSpell->canCast(player))
  256.             continue;
  257.  
  258.         if(count == index)
  259.             return instantSpell;
  260.  
  261.         ++count;
  262.     }
  263.  
  264.     return NULL;
  265. }
  266.  
  267. InstantSpell* Spells::getInstantSpellByName(const std::string& name)
  268. {
  269.     std::string tmpName = asLowerCaseString(name);
  270.     for(InstantsMap::iterator it = instants.begin(); it != instants.end(); ++it)
  271.     {
  272.         if(tmpName == asLowerCaseString(it->second->getName()))
  273.             return it->second;
  274.     }
  275.  
  276.     return NULL;
  277. }
  278.  
  279. Position Spells::getCasterPosition(Creature* creature, Direction dir)
  280. {
  281.     return getNextPosition(dir, creature->getPosition());
  282. }
  283.  
  284. bool BaseSpell::castSpell(Creature* creature)
  285. {
  286.     if(!creature)
  287.         return false;
  288.  
  289.     bool success = true;
  290.     CreatureEventList castEvents = creature->getCreatureEvents(CREATURE_EVENT_CAST);
  291.     for(CreatureEventList::iterator it = castEvents.begin(); it != castEvents.end(); ++it)
  292.     {
  293.         if(!(*it)->executeCast(creature) && success)
  294.             success = false;
  295.     }
  296.  
  297.     return success;
  298. }
  299.  
  300. bool BaseSpell::castSpell(Creature* creature, Creature* target)
  301. {
  302.     if(!creature || !target)
  303.         return false;
  304.  
  305.     bool success = true;
  306.     CreatureEventList castEvents = creature->getCreatureEvents(CREATURE_EVENT_CAST);
  307.     for(CreatureEventList::iterator it = castEvents.begin(); it != castEvents.end(); ++it)
  308.     {
  309.         if(!(*it)->executeCast(creature, target) && success)
  310.             success = false;
  311.     }
  312.  
  313.     return success;
  314. }
  315.  
  316. CombatSpell::CombatSpell(Combat* _combat, bool _needTarget, bool _needDirection) :
  317.     Event(&g_spells->getInterface())
  318. {
  319.     combat =_combat;
  320.     needTarget = _needTarget;
  321.     needDirection = _needDirection;
  322. }
  323.  
  324. CombatSpell::~CombatSpell()
  325. {
  326.     delete combat;
  327. }
  328.  
  329. bool CombatSpell::loadScriptCombat()
  330. {
  331.     if(m_interface->reserveEnv())
  332.     {
  333.         ScriptEnviroment* env = m_interface->getEnv();
  334.         combat = env->getCombatObject(env->getLastCombatId());
  335.  
  336.         env->resetCallback();
  337.         m_interface->releaseEnv();
  338.     }
  339.  
  340.     return combat != NULL;
  341. }
  342.  
  343. bool CombatSpell::castSpell(Creature* creature)
  344. {
  345.     if(!BaseSpell::castSpell(creature))
  346.         return false;
  347.  
  348.     if(isScripted())
  349.     {
  350.         LuaVariant var;
  351.         var.type = VARIANT_POSITION;
  352.         if(needDirection)
  353.             var.pos = Spells::getCasterPosition(creature, creature->getDirection());
  354.         else
  355.             var.pos = creature->getPosition();
  356.  
  357.         return executeCastSpell(creature, var);
  358.     }
  359.  
  360.     Position pos;
  361.     if(needDirection)
  362.         pos = Spells::getCasterPosition(creature, creature->getDirection());
  363.     else
  364.         pos = creature->getPosition();
  365.  
  366.     combat->doCombat(creature, pos);
  367.     return true;
  368. }
  369.  
  370. bool CombatSpell::castSpell(Creature* creature, Creature* target)
  371. {
  372.     if(!BaseSpell::castSpell(creature, target))
  373.         return false;
  374.  
  375.     if(isScripted())
  376.     {
  377.         LuaVariant var;
  378.         if(combat->hasArea())
  379.         {
  380.             var.type = VARIANT_POSITION;
  381.             if(needTarget)
  382.                 var.pos = target->getPosition();
  383.             else if(needDirection)
  384.                 var.pos = Spells::getCasterPosition(creature, creature->getDirection());
  385.             else
  386.                 var.pos = creature->getPosition();
  387.         }
  388.         else
  389.         {
  390.             var.type = VARIANT_NUMBER;
  391.             var.number = target->getID();
  392.         }
  393.  
  394.         return executeCastSpell(creature, var);
  395.     }
  396.  
  397.     if(combat->hasArea())
  398.     {
  399.         if(!needTarget)
  400.             return castSpell(creature);
  401.  
  402.         combat->doCombat(creature, target->getPosition());
  403.     }
  404.     else
  405.         combat->doCombat(creature, target);
  406.  
  407.     return true;
  408. }
  409.  
  410. bool CombatSpell::executeCastSpell(Creature* creature, const LuaVariant& var)
  411. {
  412.     //onCastSpell(cid, var)
  413.     if(m_interface->reserveEnv())
  414.     {
  415.         ScriptEnviroment* env = m_interface->getEnv();
  416.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  417.         {
  418.             env->setRealPos(creature->getPosition());
  419.             std::stringstream scriptstream;
  420.  
  421.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  422.             env->streamVariant(scriptstream, "var", var);
  423.  
  424.             scriptstream << m_scriptData;
  425.             bool result = true;
  426.             if(m_interface->loadBuffer(scriptstream.str()))
  427.             {
  428.                 lua_State* L = m_interface->getState();
  429.                 result = m_interface->getGlobalBool(L, "_result", true);
  430.             }
  431.  
  432.             m_interface->releaseEnv();
  433.             return result;
  434.         }
  435.         else
  436.         {
  437.             #ifdef __DEBUG_LUASCRIPTS__
  438.             char desc[60];
  439.             sprintf(desc, "onCastSpell - %s", creature->getName().c_str());
  440.             env->setEvent(desc);
  441.             #endif
  442.  
  443.             env->setScriptId(m_scriptId, m_interface);
  444.             env->setRealPos(creature->getPosition());
  445.             lua_State* L = m_interface->getState();
  446.  
  447.             m_interface->pushFunction(m_scriptId);
  448.             lua_pushnumber(L, env->addThing(creature));
  449.             m_interface->pushVariant(L, var);
  450.  
  451.             bool result = m_interface->callFunction(2);
  452.             m_interface->releaseEnv();
  453.             return result;
  454.         }
  455.     }
  456.     else
  457.     {
  458.         std::clog << "[Error - CombatSpell::executeCastSpell] Call stack overflow." << std::endl;
  459.         return false;
  460.     }
  461. }
  462.  
  463. Spell::Spell()
  464. {
  465.     level = 0;
  466.     magLevel = 0;
  467.     mana = 0;
  468.     manaPercent = 0;
  469.     soul = 0;
  470.     range = -1;
  471.     exhaustion = 1000;
  472.     needTarget = false;
  473.     needWeapon = false;
  474.     selfTarget = false;
  475.     blockingSolid = false;
  476.     blockingCreature = false;
  477.     enabled = true;
  478.     premium = false;
  479.     isAggressive = true;
  480.     learnable = false;
  481.  
  482.     for(int32_t i = SKILL_FIRST; i <= SKILL_LAST; ++i)
  483.         skills[i] = 10;
  484. }
  485.  
  486. bool Spell::configureSpell(xmlNodePtr p)
  487. {
  488.     int32_t intValue;
  489.     std::string strValue;
  490.     if(readXMLString(p, "name", strValue))
  491.     {
  492.         name = strValue;
  493.         const char* reservedList[] =
  494.         {
  495.             "melee", "physical", "poison", "earth", "fire", "ice", "freeze", "energy", "drown", "death", "curse", "holy",
  496.             "lifedrain", "manadrain", "healing", "speed", "outfit", "invisible", "drunk", "firefield", "poisonfield",
  497.             "energyfield", "firecondition", "poisoncondition", "energycondition", "drowncondition", "freezecondition",
  498.             "cursecondition"
  499.         };
  500.  
  501.         for(uint32_t i = 0; i < sizeof(reservedList) / sizeof(const char*); ++i)
  502.         {
  503.             if(boost::algorithm::iequals(reservedList[i], name.c_str()))
  504.             {
  505.                 std::clog << "[Error - Spell::configureSpell] Spell is using a reserved name: " << reservedList[i] << std::endl;
  506.                 return false;
  507.             }
  508.         }
  509.     }
  510.     else
  511.     {
  512.         std::clog << "[Error - Spell::configureSpell] Spell without name." << std::endl;
  513.         return false;
  514.     }
  515.  
  516.     if(readXMLInteger(p, "lvl", intValue) || readXMLInteger(p, "level", intValue))
  517.         level = intValue;
  518.  
  519.     if(readXMLInteger(p, "maglv", intValue) || readXMLInteger(p, "magiclevel", intValue))
  520.         magLevel = intValue;
  521.  
  522.     if(readXMLString(p, "skill", strValue) || readXMLString(p, "skills", strValue) || readXMLInteger(p, "skillpoints", intValue))
  523.     {
  524.         std::vector<std::string> strVector = explodeString(strValue, ";"), tmpVector;
  525.         for(std::vector<std::string>::iterator it = strVector.begin(); it != strVector.end(); ++it)
  526.         {
  527.             tmpVector = explodeString(*it, ",");
  528.             if(tmpVector.size() > 1)
  529.             {
  530.                 intValue = atoi(tmpVector[0].c_str());
  531.                 if(!intValue)
  532.                     skills[getSkillId(tmpVector[0])] = atoi(tmpVector[1].c_str());
  533.                 else
  534.                     skills[intValue] = atoi(tmpVector[1].c_str());
  535.             }
  536.         }
  537.     }
  538.  
  539.     if(readXMLInteger(p, "mana", intValue))
  540.         mana = intValue;
  541.  
  542.     if(readXMLInteger(p, "manapercent", intValue))
  543.         manaPercent = intValue;
  544.  
  545.     if(readXMLInteger(p, "soul", intValue))
  546.         soul = intValue;
  547.  
  548.     if(readXMLInteger(p, "exhaustion", intValue))
  549.         exhaustion = intValue;
  550.  
  551.     if(readXMLString(p, "enabled", strValue))
  552.         enabled = booleanString(strValue);
  553.  
  554.     if(readXMLString(p, "prem", strValue) || readXMLString(p, "premium", strValue))
  555.         premium = booleanString(strValue);
  556.  
  557.     if(readXMLString(p, "needtarget", strValue))
  558.         needTarget = booleanString(strValue);
  559.  
  560.     if(readXMLString(p, "needweapon", strValue))
  561.         needWeapon = booleanString(strValue);
  562.  
  563.     if(readXMLString(p, "selftarget", strValue))
  564.         selfTarget = booleanString(strValue);
  565.  
  566.     if(readXMLString(p, "needlearn", strValue))
  567.         learnable = booleanString(strValue);
  568.  
  569.     if(readXMLInteger(p, "range", intValue))
  570.         range = intValue;
  571.  
  572.     if(readXMLString(p, "blocktype", strValue))
  573.     {
  574.         std::string tmpStrValue = asLowerCaseString(strValue);
  575.         if(tmpStrValue == "all")
  576.             blockingCreature = blockingSolid = true;
  577.         else if(tmpStrValue == "solid")
  578.             blockingSolid = true;
  579.         else if(tmpStrValue == "creature")
  580.             blockingCreature = true;
  581.         else
  582.             std::clog << "[Warning - Spell::configureSpell] Blocktype \"" <<strValue << "\" does not exist." << std::endl;
  583.     }
  584.     else if(readXMLString(p, "blocking", strValue))
  585.         blockingCreature = blockingSolid = booleanString(strValue);
  586.  
  587.     if(readXMLString(p, "aggressive", strValue))
  588.         isAggressive = booleanString(strValue);
  589.  
  590.     std::string error;
  591.     for(xmlNodePtr vocationNode = p->children; vocationNode; vocationNode = vocationNode->next)
  592.     {
  593.         if(!parseVocationNode(vocationNode, vocSpellMap, vocStringVec, error))
  594.             std::clog << "[Warning - Spell::configureSpell] Spell: " << name << ", " << error << std::endl;
  595.     }
  596.  
  597.     return true;
  598. }
  599.  
  600. bool Spell::checkSpell(Player* player) const
  601. {
  602.     if(player->hasFlag(PlayerFlag_CannotUseSpells))
  603.         return false;
  604.  
  605.     if(player->hasFlag(PlayerFlag_IgnoreSpellCheck))
  606.         return true;
  607.  
  608.     if(!isEnabled())
  609.         return false;
  610.  
  611.     bool exhausted = false;
  612.     if(isAggressive)
  613.     {
  614.         if(!player->hasFlag(PlayerFlag_IgnoreProtectionZone) && player->getZone() == ZONE_PROTECTION)
  615.         {
  616.             player->sendCancelMessage(RET_ACTIONNOTPERMITTEDINPROTECTIONZONE);
  617.             return false;
  618.         }
  619.  
  620.         if(player->hasCondition(CONDITION_EXHAUST, EXHAUST_COMBAT))
  621.             exhausted = true;
  622.     }
  623.     else if(player->hasCondition(CONDITION_EXHAUST, EXHAUST_HEALING))
  624.         exhausted = true;
  625.  
  626.     if(exhausted && !player->hasFlag(PlayerFlag_HasNoExhaustion))
  627.     {
  628.         player->sendCancelMessage(RET_YOUAREEXHAUSTED);
  629.         if(isInstant())
  630.             g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  631.  
  632.         return false;
  633.     }
  634.  
  635.     if(isPremium() && !player->isPremium())
  636.     {
  637.         player->sendCancelMessage(RET_YOUNEEDPREMIUMACCOUNT);
  638.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  639.         return false;
  640.     }
  641.  
  642.     if((int32_t)player->getLevel() < level)
  643.     {
  644.         player->sendCancelMessage(RET_NOTENOUGHLEVEL);
  645.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  646.         return false;
  647.     }
  648.  
  649.     if((int32_t)player->getMagicLevel() < magLevel)
  650.     {
  651.         player->sendCancelMessage(RET_NOTENOUGHMAGICLEVEL);
  652.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  653.         return false;
  654.     }
  655.  
  656.     for(int16_t i = SKILL_FIRST; i <= SKILL_LAST; ++i)
  657.     {
  658.         if((int32_t)player->getSkill((skills_t)i, SKILL_LEVEL) < skills[i])
  659.         {
  660.             player->sendCancelMessage(RET_NOTENOUGHSKILL);
  661.             g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  662.             return false;
  663.         }
  664.     }
  665.  
  666.     if(player->getMana() < getManaCost(player) && !player->hasFlag(PlayerFlag_HasInfiniteMana))
  667.     {
  668.         player->sendCancelMessage(RET_NOTENOUGHMANA);
  669.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  670.         return false;
  671.     }
  672.  
  673.     if(player->getSoul() < soul && !player->hasFlag(PlayerFlag_HasInfiniteSoul))
  674.     {
  675.         player->sendCancelMessage(RET_NOTENOUGHSOUL);
  676.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  677.         return false;
  678.     }
  679.  
  680.     if(isInstant() && isLearnable() && !player->hasLearnedInstantSpell(getName()))
  681.     {
  682.         player->sendCancelMessage(RET_YOUNEEDTOLEARNTHISSPELL);
  683.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  684.         return false;
  685.     }
  686.  
  687.     if(!vocSpellMap.empty())
  688.     {
  689.         if(vocSpellMap.find(player->getVocationId()) == vocSpellMap.end())
  690.         {
  691.             player->sendCancelMessage(RET_YOURVOCATIONCANNOTUSETHISSPELL);
  692.             g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  693.             return false;
  694.         }
  695.     }
  696.  
  697.     if(needWeapon)
  698.     {
  699.         switch(player->getWeaponType())
  700.         {
  701.             case WEAPON_SWORD:
  702.             case WEAPON_CLUB:
  703.             case WEAPON_AXE:
  704.             case WEAPON_FIST:
  705.                 break;
  706.  
  707.             default:
  708.             {
  709.                 player->sendCancelMessage(RET_YOUNEEDAWEAPONTOUSETHISSPELL);
  710.                 g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  711.                 return false;
  712.             }
  713.         }
  714.     }
  715.  
  716.     return true;
  717. }
  718.  
  719. bool Spell::checkInstantSpell(Player* player, Creature* creature)
  720. {
  721.     if(!checkSpell(player))
  722.         return false;
  723.  
  724.     const Position& toPos = creature->getPosition();
  725.     const Position& playerPos = player->getPosition();
  726.     if(playerPos.z > toPos.z)
  727.     {
  728.         player->sendCancelMessage(RET_FIRSTGOUPSTAIRS);
  729.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  730.         return false;
  731.     }
  732.  
  733.     if(playerPos.z < toPos.z)
  734.     {
  735.         player->sendCancelMessage(RET_FIRSTGODOWNSTAIRS);
  736.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  737.         return false;
  738.     }
  739.  
  740.     Tile* tile = g_game.getTile(toPos);
  741.     if(!tile)
  742.     {
  743.         tile = new StaticTile(toPos.x, toPos.y, toPos.z);
  744.         g_game.setTile(tile);
  745.     }
  746.  
  747.     ReturnValue ret;
  748.     if((ret = Combat::canDoCombat(player, tile, isAggressive)) != RET_NOERROR)
  749.     {
  750.         player->sendCancelMessage(ret);
  751.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  752.         return false;
  753.     }
  754.  
  755.     if(blockingCreature && creature)
  756.     {
  757.         player->sendCancelMessage(RET_NOTENOUGHROOM);
  758.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  759.         return false;
  760.     }
  761.  
  762.     if(blockingSolid && tile->hasProperty(BLOCKSOLID))
  763.     {
  764.         player->sendCancelMessage(RET_NOTENOUGHROOM);
  765.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  766.         return false;
  767.     }
  768.  
  769.     if(!needTarget)
  770.     {
  771.         if(!isAggressive || player->getSkull() != SKULL_BLACK)
  772.             return true;
  773.  
  774.         player->sendCancelMessage(RET_YOUMAYNOTCASTAREAONBLACKSKULL);
  775.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  776.         return false;
  777.     }
  778.  
  779.     if(!creature)
  780.     {
  781.         player->sendCancelMessage(RET_NOTPOSSIBLE);
  782.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  783.         return false;
  784.     }
  785.  
  786.     Player* targetPlayer = creature->getPlayer();
  787.     if(!isAggressive || !targetPlayer || Combat::isInPvpZone(player, targetPlayer)
  788.         || player->getSkullType(targetPlayer) != SKULL_NONE)
  789.         return true;
  790.  
  791.     if(player->getSecureMode() == SECUREMODE_ON)
  792.     {
  793.         player->sendCancelMessage(RET_TURNSECUREMODETOATTACKUNMARKEDPLAYERS);
  794.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  795.         return false;
  796.     }
  797.  
  798.     if(player->getSkull() == SKULL_BLACK)
  799.     {
  800.         player->sendCancelMessage(RET_YOUMAYNOTATTACKTHISPLAYER);
  801.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  802.         return false;
  803.     }
  804.  
  805.     return true;
  806. }
  807.  
  808. bool Spell::checkInstantSpell(Player* player, const Position& toPos)
  809. {
  810.     if(!checkSpell(player))
  811.         return false;
  812.  
  813.     if(toPos.x == 0xFFFF)
  814.         return true;
  815.  
  816.     const Position& playerPos = player->getPosition();
  817.     if(playerPos.z > toPos.z)
  818.     {
  819.         player->sendCancelMessage(RET_FIRSTGOUPSTAIRS);
  820.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  821.         return false;
  822.     }
  823.  
  824.     if(playerPos.z < toPos.z)
  825.     {
  826.         player->sendCancelMessage(RET_FIRSTGODOWNSTAIRS);
  827.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  828.         return false;
  829.     }
  830.  
  831.     Tile* tile = g_game.getTile(toPos);
  832.     if(!tile)
  833.     {
  834.         tile = new StaticTile(toPos.x, toPos.y, toPos.z);
  835.         g_game.setTile(tile);
  836.     }
  837.  
  838.     ReturnValue ret;
  839.     if((ret = Combat::canDoCombat(player, tile, isAggressive)) != RET_NOERROR)
  840.     {
  841.         player->sendCancelMessage(ret);
  842.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  843.         return false;
  844.     }
  845.  
  846.     if(blockingCreature && tile->getTopVisibleCreature(player))
  847.     {
  848.         player->sendCancelMessage(RET_NOTENOUGHROOM);
  849.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  850.         return false;
  851.     }
  852.  
  853.     if(blockingSolid && tile->hasProperty(BLOCKSOLID))
  854.     {
  855.         player->sendCancelMessage(RET_NOTENOUGHROOM);
  856.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  857.         return false;
  858.     }
  859.  
  860.     if(player->getSkull() == SKULL_BLACK && isAggressive && range == -1) // CHECKME: -1 is (usually?) an area spell
  861.     {
  862.         player->sendCancelMessage(RET_YOUMAYNOTCASTAREAONBLACKSKULL);
  863.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  864.         return false;
  865.     }
  866.  
  867.     return true;
  868. }
  869.  
  870. bool Spell::checkRuneSpell(Player* player, const Position& toPos)
  871. {
  872.     if(!checkSpell(player))
  873.         return false;
  874.  
  875.     if(toPos.x == 0xFFFF)
  876.         return true;
  877.  
  878.     const Position& playerPos = player->getPosition();
  879.     if(playerPos.z > toPos.z)
  880.     {
  881.         player->sendCancelMessage(RET_FIRSTGOUPSTAIRS);
  882.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  883.         return false;
  884.     }
  885.  
  886.     if(playerPos.z < toPos.z)
  887.     {
  888.         player->sendCancelMessage(RET_FIRSTGODOWNSTAIRS);
  889.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  890.         return false;
  891.     }
  892.  
  893.     Tile* tile = g_game.getTile(toPos);
  894.     if(!tile)
  895.     {
  896.         player->sendCancelMessage(RET_NOTPOSSIBLE);
  897.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  898.         return false;
  899.     }
  900.  
  901.     if(range != -1 && !g_game.canThrowObjectTo(playerPos, toPos, true, range, range))
  902.     {
  903.         player->sendCancelMessage(RET_DESTINATIONOUTOFREACH);
  904.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  905.         return false;
  906.     }
  907.  
  908.     ReturnValue ret;
  909.     if((ret = Combat::canDoCombat(player, tile, isAggressive)) != RET_NOERROR)
  910.     {
  911.         player->sendCancelMessage(ret);
  912.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  913.         return false;
  914.     }
  915.  
  916.     Creature* targetCreature = tile->getTopVisibleCreature(player);
  917.     if(blockingCreature && targetCreature)
  918.     {
  919.         player->sendCancelMessage(RET_NOTENOUGHROOM);
  920.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  921.         return false;
  922.     }
  923.  
  924.     if(blockingSolid && tile->hasProperty(BLOCKSOLID))
  925.     {
  926.         player->sendCancelMessage(RET_NOTENOUGHROOM);
  927.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  928.         return false;
  929.     }
  930.  
  931.     if(!needTarget)
  932.     {
  933.         if(!isAggressive || player->getSkull() != SKULL_BLACK)
  934.             return true;
  935.  
  936.         player->sendCancelMessage(RET_YOUMAYNOTCASTAREAONBLACKSKULL);
  937.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  938.         return false;
  939.     }
  940.  
  941.     if(!targetCreature)
  942.     {
  943.         player->sendCancelMessage(RET_CANONLYUSETHISRUNEONCREATURES);
  944.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  945.         return false;
  946.     }
  947.  
  948.     Player* targetPlayer = targetCreature->getPlayer();
  949.     if(!isAggressive || !targetPlayer || Combat::isInPvpZone(player, targetPlayer)
  950.         || player->getSkullType(targetPlayer) != SKULL_NONE)
  951.         return true;
  952.  
  953.     if(player->getSecureMode() == SECUREMODE_ON)
  954.     {
  955.         player->sendCancelMessage(RET_TURNSECUREMODETOATTACKUNMARKEDPLAYERS);
  956.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  957.         return false;
  958.     }
  959.  
  960.     if(player->getSkull() != SKULL_BLACK)
  961.         return true;
  962.  
  963.     player->sendCancelMessage(RET_YOUMAYNOTATTACKTHISPLAYER);
  964.     g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  965.     return false;
  966. }
  967.  
  968. void Spell::postSpell(Player* player, bool finishedCast /*= true*/, bool payCost /*= true*/) const
  969. {
  970.     if(finishedCast)
  971.     {
  972.         if(!player->hasFlag(PlayerFlag_HasNoExhaustion) && exhaustion > 0)
  973.             player->addExhaust(exhaustion, isAggressive ? EXHAUST_COMBAT : EXHAUST_HEALING);
  974.  
  975.         if(isAggressive && !player->hasFlag(PlayerFlag_NotGainInFight))
  976.             player->addInFightTicks(false);
  977.     }
  978.  
  979.     if(payCost)
  980.         postSpell(player, (uint32_t)getManaCost(player), (uint32_t)getSoulCost());
  981. }
  982.  
  983. void Spell::postSpell(Player* player, uint32_t manaCost, uint32_t soulCost) const
  984. {
  985.     if(manaCost > 0)
  986.     {
  987.         player->changeMana(-(int32_t)manaCost);
  988.         if(!player->hasFlag(PlayerFlag_NotGainMana) && (player->getZone() != ZONE_HARDCORE
  989.             || g_config.getBool(ConfigManager::PVPZONE_ADDMANASPENT)))
  990.             player->addManaSpent(manaCost);
  991.     }
  992.  
  993.     if(soulCost > 0)
  994.         player->changeSoul(-(int32_t)soulCost);
  995. }
  996.  
  997. int32_t Spell::getManaCost(const Player* player) const
  998. {
  999.     if(player && manaPercent)
  1000.         return (int32_t)std::floor(double(player->getMaxMana() * manaPercent) / 100);
  1001.  
  1002.     return mana;
  1003. }
  1004.  
  1005. ReturnValue Spell::CreateIllusion(Creature* creature, const Outfit_t& outfit, int32_t time)
  1006. {
  1007.     ConditionOutfit* outfitCondition = new ConditionOutfit(CONDITIONID_COMBAT, CONDITION_OUTFIT, time, false, 0);
  1008.     if(!outfitCondition)
  1009.         return RET_NOTPOSSIBLE;
  1010.  
  1011.     outfitCondition->addOutfit(outfit);
  1012.     creature->addCondition(outfitCondition);
  1013.     return RET_NOERROR;
  1014. }
  1015.  
  1016. ReturnValue Spell::CreateIllusion(Creature* creature, const std::string& name, int32_t time)
  1017. {
  1018.     uint32_t mId = g_monsters.getIdByName(name);
  1019.     if(!mId)
  1020.         return RET_CREATUREDOESNOTEXIST;
  1021.  
  1022.     const MonsterType* mType = g_monsters.getMonsterType(mId);
  1023.     if(!mType)
  1024.         return RET_CREATUREDOESNOTEXIST;
  1025.  
  1026.     Player* player = creature->getPlayer();
  1027.     if(player && !player->hasFlag(PlayerFlag_CanIllusionAll) && !mType->isIllusionable)
  1028.         return RET_NOTPOSSIBLE;
  1029.  
  1030.     return CreateIllusion(creature, mType->outfit, time);
  1031. }
  1032.  
  1033. ReturnValue Spell::CreateIllusion(Creature* creature, uint32_t itemId, int32_t time)
  1034. {
  1035.     const ItemType& it = Item::items[itemId];
  1036.     if(!it.id)
  1037.         return RET_NOTPOSSIBLE;
  1038.  
  1039.     Outfit_t outfit;
  1040.     outfit.lookTypeEx = itemId;
  1041.     return CreateIllusion(creature, outfit, time);
  1042. }
  1043.  
  1044. InstantSpell::InstantSpell(LuaInterface* _interface) : TalkAction(_interface)
  1045. {
  1046.     needDirection = false;
  1047.     hasParam = false;
  1048.     checkLineOfSight = true;
  1049.     casterTargetOrDirection = false;
  1050.     limitRange = 0;
  1051.     function = NULL;
  1052. }
  1053.  
  1054. bool InstantSpell::configureEvent(xmlNodePtr p)
  1055. {
  1056.     if(!Spell::configureSpell(p))
  1057.         return false;
  1058.  
  1059.     if(!TalkAction::configureEvent(p))
  1060.         return false;
  1061.  
  1062.     std::string strValue;
  1063.     if(readXMLString(p, "param", strValue) || readXMLString(p, "params", strValue))
  1064.         hasParam = booleanString(strValue);
  1065.  
  1066.     if(readXMLString(p, "direction", strValue))
  1067.         needDirection = booleanString(strValue);
  1068.  
  1069.     if(readXMLString(p, "casterTargetOrDirection", strValue))
  1070.         casterTargetOrDirection = booleanString(strValue);
  1071.  
  1072.     if(readXMLString(p, "blockwalls", strValue))
  1073.         checkLineOfSight = booleanString(strValue);
  1074.  
  1075.     int32_t intValue;
  1076.     if(readXMLInteger(p, "limitRange", intValue))
  1077.         limitRange = intValue;
  1078.  
  1079.     return true;
  1080. }
  1081.  
  1082. bool InstantSpell::loadFunction(const std::string& functionName)
  1083. {
  1084.     std::string tmpFunctionName = asLowerCaseString(functionName);
  1085.     if(tmpFunctionName == "summonmonster")
  1086.         function = SummonMonster;
  1087.     else if(tmpFunctionName == "searchplayer")
  1088.     {
  1089.         isAggressive = false;
  1090.         function = SearchPlayer;
  1091.     }
  1092.     else if(tmpFunctionName == "levitate")
  1093.     {
  1094.         isAggressive = false;
  1095.         function = Levitate;
  1096.     }
  1097.     else if(tmpFunctionName == "illusion")
  1098.     {
  1099.         isAggressive = false;
  1100.         function = Illusion;
  1101.     }
  1102.     else
  1103.     {
  1104.         std::clog << "[Warning - InstantSpell::loadFunction] Function \"" << functionName << "\" does not exist." << std::endl;
  1105.         return false;
  1106.     }
  1107.  
  1108.     m_scripted = EVENT_SCRIPT_FALSE;
  1109.     return true;
  1110. }
  1111.  
  1112. bool InstantSpell::castInstant(Player* player, const std::string& param)
  1113. {
  1114.     LuaVariant var;
  1115.     if(selfTarget)
  1116.     {
  1117.         var.type = VARIANT_NUMBER;
  1118.         var.number = player->getID();
  1119.         if(!checkInstantSpell(player, player))
  1120.             return false;
  1121.     }
  1122.     else if(needTarget || casterTargetOrDirection)
  1123.     {
  1124.         Creature* target = NULL;
  1125.         if(hasParam)
  1126.         {
  1127.             Player* targetPlayer = NULL;
  1128.             ReturnValue ret = g_game.getPlayerByNameWildcard(param, targetPlayer);
  1129.  
  1130.             target = targetPlayer;
  1131.             if(limitRange && target && !Position::areInRange(Position(limitRange,
  1132.                 limitRange, 0), target->getPosition(), player->getPosition()))
  1133.                 target = NULL;
  1134.  
  1135.             if((!target || target->getHealth() <= 0) && !casterTargetOrDirection)
  1136.             {
  1137.                 player->sendCancelMessage(ret);
  1138.                 g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1139.                 return false;
  1140.             }
  1141.         }
  1142.         else
  1143.         {
  1144.             target = player->getAttackedCreature();
  1145.             if(limitRange && target && !Position::areInRange(Position(limitRange,
  1146.                 limitRange, 0), target->getPosition(), player->getPosition()))
  1147.                 target = NULL;
  1148.  
  1149.             if((!target || target->getHealth() <= 0) && !casterTargetOrDirection)
  1150.             {
  1151.                 player->sendCancelMessage(RET_YOUCANONLYUSEITONCREATURES);
  1152.                 g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1153.                 return false;
  1154.             }
  1155.         }
  1156.  
  1157.         if(target)
  1158.         {
  1159.             bool canSee = player->canSeeCreature(target);
  1160.             if(!canSee || !canThrowSpell(player, target))
  1161.             {
  1162.                 player->sendCancelMessage(canSee ? RET_CREATUREISNOTREACHABLE : RET_PLAYERWITHTHISNAMEISNOTONLINE);
  1163.                 g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1164.                 return false;
  1165.             }
  1166.  
  1167.             var.type = VARIANT_NUMBER;
  1168.             var.number = target->getID();
  1169.             if(!checkInstantSpell(player, target))
  1170.                 return false;
  1171.         }
  1172.         else
  1173.         {
  1174.             var.type = VARIANT_POSITION;
  1175.             var.pos = Spells::getCasterPosition(player, player->getDirection());
  1176.             if(!checkInstantSpell(player, var.pos))
  1177.                 return false;
  1178.         }
  1179.     }
  1180.     else if(hasParam)
  1181.     {
  1182.         var.type = VARIANT_STRING;
  1183.         var.text = param;
  1184.         if(!checkSpell(player))
  1185.             return false;
  1186.     }
  1187.     else
  1188.     {
  1189.         var.type = VARIANT_POSITION;
  1190.         if(needDirection)
  1191.             var.pos = Spells::getCasterPosition(player, player->getDirection());
  1192.         else
  1193.             var.pos = player->getPosition();
  1194.  
  1195.         if(!checkInstantSpell(player, var.pos))
  1196.             return false;
  1197.     }
  1198.  
  1199.     if(!internalCastSpell(player, var))
  1200.         return false;
  1201.  
  1202.     Spell::postSpell(player);
  1203.     return true;
  1204. }
  1205.  
  1206. bool InstantSpell::canThrowSpell(const Creature* creature, const Creature* target) const
  1207. {
  1208.     const Position& fromPos = creature->getPosition();
  1209.     const Position& toPos = target->getPosition();
  1210.     return (!(fromPos.z != toPos.z || (range == -1 && !g_game.canThrowObjectTo(fromPos, toPos, checkLineOfSight))
  1211.         || (range != -1 && !g_game.canThrowObjectTo(fromPos, toPos, checkLineOfSight, range, range))));
  1212. }
  1213.  
  1214. bool InstantSpell::castSpell(Creature* creature)
  1215. {
  1216.     if(!BaseSpell::castSpell(creature))
  1217.         return false;
  1218.  
  1219.     LuaVariant var;
  1220.     if(casterTargetOrDirection)
  1221.     {
  1222.         Creature* target = creature->getAttackedCreature();
  1223.         if(target && target->getHealth() > 0)
  1224.         {
  1225.             if(!creature->canSeeCreature(target) || !canThrowSpell(creature, target))
  1226.                 return false;
  1227.  
  1228.             var.type = VARIANT_NUMBER;
  1229.             var.number = target->getID();
  1230.             return internalCastSpell(creature, var);
  1231.         }
  1232.  
  1233.         return false;
  1234.     }
  1235.  
  1236.     if(needDirection)
  1237.     {
  1238.         var.type = VARIANT_POSITION;
  1239.         var.pos = Spells::getCasterPosition(creature, creature->getDirection());
  1240.     }
  1241.     else
  1242.     {
  1243.         var.type = VARIANT_POSITION;
  1244.         var.pos = creature->getPosition();
  1245.     }
  1246.  
  1247.     return internalCastSpell(creature, var);
  1248. }
  1249.  
  1250. bool InstantSpell::castSpell(Creature* creature, Creature* target)
  1251. {
  1252.     if(!BaseSpell::castSpell(creature, target))
  1253.         return false;
  1254.  
  1255.     if(!needTarget)
  1256.         return castSpell(creature);
  1257.  
  1258.     LuaVariant var;
  1259.     var.type = VARIANT_NUMBER;
  1260.     var.number = target->getID();
  1261.     return internalCastSpell(creature, var);
  1262. }
  1263.  
  1264. bool InstantSpell::internalCastSpell(Creature* creature, const LuaVariant& var)
  1265. {
  1266.     if(isScripted())
  1267.         return executeCastSpell(creature, var);
  1268.  
  1269.     return function ? function(this, creature, var.text) : false;
  1270. }
  1271.  
  1272. bool InstantSpell::executeCastSpell(Creature* creature, const LuaVariant& var)
  1273. {
  1274.     //onCastSpell(cid, var)
  1275.     if(m_interface->reserveEnv())
  1276.     {
  1277.         ScriptEnviroment* env = m_interface->getEnv();
  1278.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1279.         {
  1280.             env->setRealPos(creature->getPosition());
  1281.             std::stringstream scriptstream;
  1282.  
  1283.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  1284.             env->streamVariant(scriptstream, "var", var);
  1285.  
  1286.             scriptstream << m_scriptData;
  1287.             bool result = true;
  1288.             if(m_interface->loadBuffer(scriptstream.str()))
  1289.             {
  1290.                 lua_State* L = m_interface->getState();
  1291.                 result = m_interface->getGlobalBool(L, "_result", true);
  1292.             }
  1293.  
  1294.             m_interface->releaseEnv();
  1295.             return result;
  1296.         }
  1297.         else
  1298.         {
  1299.             #ifdef __DEBUG_LUASCRIPTS__
  1300.             char desc[60];
  1301.             sprintf(desc, "onCastSpell - %s", creature->getName().c_str());
  1302.             env->setEvent(desc);
  1303.             #endif
  1304.  
  1305.             env->setScriptId(m_scriptId, m_interface);
  1306.             env->setRealPos(creature->getPosition());
  1307.             lua_State* L = m_interface->getState();
  1308.  
  1309.             m_interface->pushFunction(m_scriptId);
  1310.             lua_pushnumber(L, env->addThing(creature));
  1311.             m_interface->pushVariant(L, var);
  1312.  
  1313.             bool result = m_interface->callFunction(2);
  1314.             m_interface->releaseEnv();
  1315.             return result;
  1316.         }
  1317.     }
  1318.     else
  1319.     {
  1320.         std::clog << "[Error - InstantSpell::executeCastSpell] Call stack overflow." << std::endl;
  1321.         return false;
  1322.     }
  1323. }
  1324.  
  1325. bool InstantSpell::SearchPlayer(const InstantSpell*, Creature* creature, const std::string& param)
  1326. {
  1327.     Player* player = creature->getPlayer();
  1328.     if(!player || player->isRemoved())
  1329.         return false;
  1330.  
  1331.     Player* targetPlayer = NULL;
  1332.     ReturnValue ret = g_game.getPlayerByNameWildcard(param, targetPlayer);
  1333.     if(ret != RET_NOERROR || !targetPlayer || targetPlayer->isRemoved())
  1334.     {
  1335.         player->sendCancelMessage(ret);
  1336.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1337.         return false;
  1338.     }
  1339.  
  1340.     if(targetPlayer->hasCustomFlag(PlayerCustomFlag_NotSearchable) && !player->hasCustomFlag(PlayerCustomFlag_GamemasterPrivileges))
  1341.     {
  1342.         player->sendCancelMessage(RET_PLAYERWITHTHISNAMEISNOTONLINE);
  1343.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1344.         return false;
  1345.     }
  1346.  
  1347.     std::stringstream ss;
  1348.     ss << targetPlayer->getName() << " " << g_game.getSearchString(player->getPosition(), targetPlayer->getPosition(), true, true) << ".";
  1349.     player->sendTextMessage(MSG_INFO_DESCR, ss.str().c_str());
  1350.  
  1351.     g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_WRAPS_BLUE);
  1352.     return true;
  1353. }
  1354.  
  1355. bool InstantSpell::SummonMonster(const InstantSpell* spell, Creature* creature, const std::string& param)
  1356. {
  1357.     Player* player = creature->getPlayer();
  1358.     if(!player)
  1359.         return false;
  1360.  
  1361.     MonsterType* mType = g_monsters.getMonsterType(param);
  1362.     if(!mType)
  1363.     {
  1364.         player->sendCancelMessage(RET_NOTPOSSIBLE);
  1365.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1366.         return false;
  1367.     }
  1368.  
  1369.     int32_t manaCost = (int32_t)(mType->manaCost * g_config.getDouble(ConfigManager::RATE_MONSTER_MANA));
  1370.     if(!player->hasFlag(PlayerFlag_CanSummonAll))
  1371.     {
  1372.         if(player->getSkull() == SKULL_BLACK)
  1373.         {
  1374.             player->sendCancelMessage(RET_NOTPOSSIBLE);
  1375.             g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1376.             return false;
  1377.         }
  1378.  
  1379.         if(!mType->isSummonable)
  1380.         {
  1381.             player->sendCancelMessage(RET_NOTPOSSIBLE);
  1382.             g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1383.             return false;
  1384.         }
  1385.  
  1386.         if(player->getMana() < manaCost)
  1387.         {
  1388.             player->sendCancelMessage(RET_NOTENOUGHMANA);
  1389.             g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1390.             return false;
  1391.         }
  1392.  
  1393.         if((int32_t)player->getSummonCount() >= g_config.getNumber(ConfigManager::MAX_PLAYER_SUMMONS))
  1394.         {
  1395.             player->sendCancel("You cannot summon more creatures.");
  1396.             g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1397.             return false;
  1398.         }
  1399.     }
  1400.  
  1401.     ReturnValue ret = g_game.placeSummon(creature, param);
  1402.     if(ret == RET_NOERROR)
  1403.     {
  1404.         spell->postSpell(player, (uint32_t)manaCost, (uint32_t)spell->getSoulCost());
  1405.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_WRAPS_BLUE);
  1406.         return true;
  1407.     }
  1408.  
  1409.     player->sendCancelMessage(ret);
  1410.     g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1411.     return false;
  1412. }
  1413.  
  1414. bool InstantSpell::Levitate(const InstantSpell*, Creature* creature, const std::string& param)
  1415. {
  1416.     Player* player = creature->getPlayer();
  1417.     if(!player)
  1418.         return false;
  1419.  
  1420.     uint16_t floor = 7;
  1421.     ReturnValue ret = RET_NOERROR;
  1422.     const Position& position = creature->getPosition();
  1423.     Position destination = Spells::getCasterPosition(creature, creature->getDirection());
  1424.  
  1425.     std::string tmpParam = asLowerCaseString(param);
  1426.     if(tmpParam == "up")
  1427.         floor = 8;
  1428.     else if(tmpParam != "down")
  1429.         ret = RET_NOTPOSSIBLE;
  1430.  
  1431.     if(ret == RET_NOERROR)
  1432.     {
  1433.         ret = RET_NOTPOSSIBLE;
  1434.         if(position.z != floor)
  1435.         {
  1436.             Tile* tmpTile = NULL;
  1437.             if(floor != 7)
  1438.             {
  1439.                 tmpTile = g_game.getTile(position.x, position.y, position.z - 1);
  1440.                 destination.z--;
  1441.             }
  1442.             else
  1443.             {
  1444.                 tmpTile = g_game.getTile(destination);
  1445.                 destination.z++;
  1446.             }
  1447.  
  1448.             if(!tmpTile || (!tmpTile->ground && !tmpTile->hasProperty(IMMOVABLEBLOCKSOLID)))
  1449.             {
  1450.                 Tile* tile = player->getTile();
  1451.                 tmpTile = g_game.getTile(destination);
  1452.                 if(tile && tmpTile && tmpTile->ground && !tmpTile->hasProperty(IMMOVABLEBLOCKSOLID) &&
  1453.                     !tmpTile->floorChange() && tile->hasFlag(TILESTATE_HOUSE) == tmpTile->hasFlag(TILESTATE_HOUSE)
  1454.                     && tile->hasFlag(TILESTATE_PROTECTIONZONE) == tmpTile->hasFlag(TILESTATE_PROTECTIONZONE))
  1455.                     ret = g_game.internalMoveCreature(NULL, player, tile, tmpTile, FLAG_IGNOREBLOCKITEM | FLAG_IGNOREBLOCKCREATURE);
  1456.             }
  1457.         }
  1458.     }
  1459.  
  1460.     if(ret == RET_NOERROR)
  1461.     {
  1462.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_TELEPORT, player->isGhost());
  1463.         return true;
  1464.     }
  1465.  
  1466.     player->sendCancelMessage(ret);
  1467.     g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF, player->isGhost());
  1468.     return false;
  1469. }
  1470.  
  1471. bool InstantSpell::Illusion(const InstantSpell*, Creature* creature, const std::string& param)
  1472. {
  1473.     Player* player = creature->getPlayer();
  1474.     if(!player)
  1475.         return false;
  1476.  
  1477.     ReturnValue ret = CreateIllusion(creature, param, 60000);
  1478.     if(ret == RET_NOERROR)
  1479.     {
  1480.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_WRAPS_RED);
  1481.         return true;
  1482.     }
  1483.  
  1484.     player->sendCancelMessage(ret);
  1485.     g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1486.     return (ret == RET_NOERROR);
  1487. }
  1488.  
  1489. bool InstantSpell::canCast(const Player* player) const
  1490. {
  1491.     if(player->hasFlag(PlayerFlag_CannotUseSpells))
  1492.         return false;
  1493.  
  1494.     if(player->hasFlag(PlayerFlag_IgnoreSpellCheck) || (!isLearnable() && (vocSpellMap.empty()
  1495.         || vocSpellMap.find(player->getVocationId()) != vocSpellMap.end())))
  1496.         return true;
  1497.  
  1498.     return player->hasLearnedInstantSpell(getName());
  1499. }
  1500.  
  1501. ConjureSpell::ConjureSpell(LuaInterface* _interface):
  1502.     InstantSpell(_interface)
  1503. {
  1504.     isAggressive = false;
  1505.     conjureId = 0;
  1506.     conjureCount = 1;
  1507.     conjureReagentId = 0;
  1508. }
  1509.  
  1510. bool ConjureSpell::configureEvent(xmlNodePtr p)
  1511. {
  1512.     if(!InstantSpell::configureEvent(p))
  1513.         return false;
  1514.  
  1515.     int32_t intValue;
  1516.     if(readXMLInteger(p, "conjureId", intValue))
  1517.         conjureId = intValue;
  1518.  
  1519.     if(readXMLInteger(p, "conjureCount", intValue))
  1520.         conjureCount = intValue;
  1521.     else if(conjureId != 0)
  1522.     {
  1523.         //load the default charge from items.xml
  1524.         const ItemType& it = Item::items[conjureId];
  1525.         if(it.charges != 0)
  1526.             conjureCount = it.charges;
  1527.     }
  1528.  
  1529.     if(readXMLInteger(p, "reagentId", intValue))
  1530.         conjureReagentId = intValue;
  1531.  
  1532.     return true;
  1533. }
  1534.  
  1535. bool ConjureSpell::loadFunction(const std::string& functionName)
  1536. {
  1537.     std::string tmpFunctionName = asLowerCaseString(functionName);
  1538.     if(tmpFunctionName == "conjureitem" || tmpFunctionName == "conjurerune")
  1539.         function = ConjureItem;
  1540.     else
  1541.     {
  1542.         std::clog << "[Warning - ConjureSpell::loadFunction] Function \"" << functionName << "\" does not exist." << std::endl;
  1543.         return false;
  1544.     }
  1545.  
  1546.     m_scripted = EVENT_SCRIPT_FALSE;
  1547.     return true;
  1548. }
  1549.  
  1550. ReturnValue ConjureSpell::internalConjureItem(Player* player, uint32_t conjureId, uint32_t conjureCount,
  1551.     bool transform/* = false*/, uint32_t reagentId/* = 0*/)
  1552. {
  1553.     if(!transform)
  1554.     {
  1555.         Item* newItem = Item::CreateItem(conjureId, conjureCount);
  1556.         if(!newItem)
  1557.             return RET_NOTPOSSIBLE;
  1558.  
  1559.         ReturnValue ret = g_game.internalPlayerAddItem(player, player, newItem, true);
  1560.         if(ret != RET_NOERROR)
  1561.             delete newItem;
  1562.  
  1563.         g_game.startDecay(newItem);
  1564.         return ret;
  1565.     }
  1566.  
  1567.     if(!reagentId)
  1568.         return RET_NOTPOSSIBLE;
  1569.  
  1570.     std::list<Container*> containers;
  1571.     Item *item = NULL, *fromItem = NULL;
  1572.     for(int32_t i = SLOT_FIRST; i < SLOT_LAST; ++i)
  1573.     {
  1574.         if(!(item = player->getInventoryItem((slots_t)i)))
  1575.             continue;
  1576.  
  1577.         if(!fromItem && item->getID() == reagentId)
  1578.             fromItem = item;
  1579.         else if(Container* container = item->getContainer())
  1580.             containers.push_back(container);
  1581.     }
  1582.  
  1583.     if(!fromItem)
  1584.     {
  1585.         for(std::list<Container*>::iterator cit = containers.begin(); cit != containers.end(); ++cit)
  1586.         {
  1587.             for(ItemList::const_reverse_iterator it = (*cit)->getReversedItems(); it != (*cit)->getReversedEnd(); ++it)
  1588.             {
  1589.                 if((*it)->getID() == reagentId)
  1590.                 {
  1591.                     fromItem = (*it);
  1592.                     break;
  1593.                 }
  1594.  
  1595.                 if(Container* tmp = (*it)->getContainer())
  1596.                     containers.push_back(tmp);
  1597.             }
  1598.         }
  1599.     }
  1600.  
  1601.     if(!fromItem)
  1602.         return RET_YOUNEEDAMAGICITEMTOCASTSPELL;
  1603.  
  1604.     if((fromItem->isStackable() || fromItem->hasCharges()) && fromItem->getSubType() > 1)
  1605.     {
  1606.         item = Item::CreateItem(conjureId, conjureCount);
  1607.         ReturnValue ret = g_game.internalPlayerAddItem(NULL, player, item, false);
  1608.         if(ret != RET_NOERROR)
  1609.             return ret;
  1610.  
  1611.         g_game.transformItem(fromItem, reagentId, (int32_t)(fromItem->getItemCount() - 1));
  1612.     }
  1613.     else
  1614.         g_game.transformItem(fromItem, conjureId, conjureCount);
  1615.  
  1616.     g_game.startDecay(item);
  1617.     return RET_NOERROR;
  1618. }
  1619.  
  1620. bool ConjureSpell::ConjureItem(const ConjureSpell* spell, Creature* creature, const std::string&)
  1621. {
  1622.     Player* player = creature->getPlayer();
  1623.     if(!player)
  1624.         return false;
  1625.  
  1626.     if(!player->hasFlag(PlayerFlag_IgnoreSpellCheck) && player->getZone() == ZONE_HARDCORE)
  1627.     {
  1628.         player->sendCancelMessage(RET_CANNOTCONJUREITEMHERE);
  1629.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1630.         return false;
  1631.     }
  1632.  
  1633.     ReturnValue result = RET_NOTPOSSIBLE;
  1634.     if(spell->getReagentId() != 0)
  1635.     {
  1636.         if((result = internalConjureItem(player, spell->getConjureId(), spell->getConjureCount(), true, spell->getReagentId())) == RET_NOERROR)
  1637.         {
  1638.             spell->postSpell(player);
  1639.             g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_WRAPS_RED);
  1640.             return true;
  1641.         }
  1642.     }
  1643.     else if((result = internalConjureItem(player, spell->getConjureId(), spell->getConjureCount())) == RET_NOERROR)
  1644.     {
  1645.         spell->postSpell(player);
  1646.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_WRAPS_RED);
  1647.         return true;
  1648.     }
  1649.  
  1650.     player->sendCancelMessage(result);
  1651.     g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1652.     return false;
  1653. }
  1654.  
  1655. bool ConjureSpell::castInstant(Player* player, const std::string& param)
  1656. {
  1657.     if(!checkSpell(player))
  1658.         return false;
  1659.  
  1660.     if(!isScripted())
  1661.         return function ? function(this, player, param) : false;
  1662.  
  1663.     LuaVariant var;
  1664.     var.type = VARIANT_STRING;
  1665.     var.text = param;
  1666.     return executeCastSpell(player, var);
  1667. }
  1668.  
  1669. RuneSpell::RuneSpell(LuaInterface* _interface):
  1670. Action(_interface)
  1671. {
  1672.     runeId = 0;
  1673.     function = NULL;
  1674.     hasCharges = allowFarUse = true;
  1675. }
  1676.  
  1677. bool RuneSpell::configureEvent(xmlNodePtr p)
  1678. {
  1679.     if(!Spell::configureSpell(p))
  1680.         return false;
  1681.  
  1682.     if(!Action::configureEvent(p))
  1683.         return false;
  1684.  
  1685.     int32_t intValue;
  1686.     if(readXMLInteger(p, "id", intValue))
  1687.         runeId = intValue;
  1688.     else
  1689.     {
  1690.         std::clog << "Error: [RuneSpell::configureSpell] Rune spell without id." << std::endl;
  1691.         return false;
  1692.     }
  1693.  
  1694.     std::string strValue;
  1695.     if(readXMLString(p, "charges", strValue))
  1696.         hasCharges = booleanString(strValue);
  1697.  
  1698.     ItemType& it = Item::items.getItemType(runeId);
  1699.     if(level && level != it.runeLevel)
  1700.         it.runeLevel = level;
  1701.  
  1702.     if(magLevel && magLevel != it.runeMagLevel)
  1703.         it.runeMagLevel = magLevel;
  1704.  
  1705.     it.vocationString = parseVocationString(vocStringVec);
  1706.     return true;
  1707. }
  1708.  
  1709. bool RuneSpell::loadFunction(const std::string& functionName)
  1710. {
  1711.     std::string tmpFunctionName = asLowerCaseString(functionName);
  1712.     if(tmpFunctionName == "chameleon")
  1713.         function = Illusion;
  1714.     else if(tmpFunctionName == "convince")
  1715.         function = Convince;
  1716.     else if(tmpFunctionName == "soulfire")
  1717.         function = Soulfire;
  1718.     else
  1719.     {
  1720.         std::clog << "[Warning - RuneSpell::loadFunction] Function \"" << functionName << "\" does not exist." << std::endl;
  1721.         return false;
  1722.     }
  1723.  
  1724.     m_scripted = EVENT_SCRIPT_FALSE;
  1725.     return true;
  1726. }
  1727.  
  1728. bool RuneSpell::Illusion(const RuneSpell*, Creature* creature, Item*, const Position&, const Position& posTo)
  1729. {
  1730.     Player* player = creature->getPlayer();
  1731.     if(!player)
  1732.         return false;
  1733.  
  1734.     Thing* thing = g_game.internalGetThing(player, posTo, 0, 0, STACKPOS_MOVE);
  1735.     if(!thing)
  1736.     {
  1737.         player->sendCancelMessage(RET_NOTPOSSIBLE);
  1738.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1739.         return false;
  1740.     }
  1741.  
  1742.     Item* illusionItem = thing->getItem();
  1743.     if(!illusionItem || !illusionItem->isMovable())
  1744.     {
  1745.         player->sendCancelMessage(RET_NOTPOSSIBLE);
  1746.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1747.         return false;
  1748.     }
  1749.  
  1750.     ReturnValue ret = CreateIllusion(creature, illusionItem->getID(), 60000);
  1751.     if(ret == RET_NOERROR)
  1752.     {
  1753.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_WRAPS_RED);
  1754.         return true;
  1755.     }
  1756.  
  1757.     player->sendCancelMessage(ret);
  1758.     g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1759.     return false;
  1760. }
  1761.  
  1762. bool RuneSpell::Convince(const RuneSpell* spell, Creature* creature, Item*, const Position&, const Position& posTo)
  1763. {
  1764.     Player* player = creature->getPlayer();
  1765.     if(!player)
  1766.         return false;
  1767.  
  1768.     if(!player->hasFlag(PlayerFlag_CanConvinceAll))
  1769.     {
  1770.         if(player->getSkull() == SKULL_BLACK)
  1771.         {
  1772.             player->sendCancelMessage(RET_NOTPOSSIBLE);
  1773.             g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1774.             return false;
  1775.         }
  1776.  
  1777.         if((int32_t)player->getSummonCount() >= g_config.getNumber(ConfigManager::MAX_PLAYER_SUMMONS))
  1778.         {
  1779.             player->sendCancelMessage(RET_NOTPOSSIBLE);
  1780.             g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1781.             return false;
  1782.         }
  1783.     }
  1784.  
  1785.     Thing* thing = g_game.internalGetThing(player, posTo, 0, 0, STACKPOS_LOOK);
  1786.     if(!thing)
  1787.     {
  1788.         player->sendCancelMessage(RET_NOTPOSSIBLE);
  1789.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1790.         return false;
  1791.     }
  1792.  
  1793.     Creature* convinceCreature = thing->getCreature();
  1794.     if(!convinceCreature)
  1795.     {
  1796.         player->sendCancelMessage(RET_NOTPOSSIBLE);
  1797.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1798.         return false;
  1799.     }
  1800.  
  1801.     if(!player->hasFlag(PlayerFlag_CanConvinceAll) && convinceCreature->getPlayerMaster())
  1802.     {
  1803.         player->sendCancelMessage(RET_NOTPOSSIBLE);
  1804.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1805.         return false;
  1806.     }
  1807.  
  1808.     int32_t manaCost = 0;
  1809.     if(Monster* monster = convinceCreature->getMonster())
  1810.         manaCost = (int32_t)(monster->getManaCost() * g_config.getDouble(ConfigManager::RATE_MONSTER_MANA));
  1811.  
  1812.     if(!player->hasFlag(PlayerFlag_HasInfiniteMana) && player->getMana() < manaCost)
  1813.     {
  1814.         player->sendCancelMessage(RET_NOTENOUGHMANA);
  1815.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1816.         return false;
  1817.     }
  1818.  
  1819.     if(!convinceCreature->convinceCreature(creature))
  1820.     {
  1821.         player->sendCancelMessage(RET_NOTPOSSIBLE);
  1822.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1823.         return false;
  1824.     }
  1825.  
  1826.     spell->postSpell(player, (uint32_t)manaCost, (uint32_t)spell->getSoulCost());
  1827.     g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_WRAPS_RED);
  1828.     return true;
  1829. }
  1830.  
  1831. bool RuneSpell::Soulfire(const RuneSpell* spell, Creature* creature, Item*, const Position&, const Position& posTo)
  1832. {
  1833.     Player* player = creature->getPlayer();
  1834.     if(!player)
  1835.         return false;
  1836.  
  1837.     Thing* thing = g_game.internalGetThing(player, posTo, 0, 0, STACKPOS_LOOK);
  1838.     if(!thing)
  1839.     {
  1840.         player->sendCancelMessage(RET_NOTPOSSIBLE);
  1841.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1842.         return false;
  1843.     }
  1844.  
  1845.     Creature* target = thing->getCreature();
  1846.     if(!target)
  1847.     {
  1848.         player->sendCancelMessage(RET_NOTPOSSIBLE);
  1849.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1850.         return false;
  1851.     }
  1852.  
  1853.     ConditionDamage* soulfireCondition = new ConditionDamage(CONDITIONID_COMBAT, CONDITION_FIRE, false, 0);
  1854.     soulfireCondition->setParam(CONDITIONPARAM_SUBID, 1);
  1855.     soulfireCondition->setParam(CONDITIONPARAM_OWNER, player->getID());
  1856.  
  1857.     soulfireCondition->addDamage(std::ceil((player->getLevel() + player->getMagicLevel()) / 3.), 9000, -10);
  1858.     if(!target->addCondition(soulfireCondition))
  1859.     {
  1860.         player->sendCancelMessage(RET_NOTPOSSIBLE);
  1861.         g_game.addMagicEffect(player->getPosition(), MAGIC_EFFECT_POFF);
  1862.         return false;
  1863.     }
  1864.  
  1865.     g_game.addDistanceEffect(player->getPosition(), posTo, SHOOT_EFFECT_FIRE);
  1866.     spell->postSpell(player, true, false);
  1867.     return true;
  1868. }
  1869.  
  1870. ReturnValue RuneSpell::canExecuteAction(const Player* player, const Position& toPos)
  1871. {
  1872.     if(player->hasFlag(PlayerFlag_CannotUseSpells))
  1873.         return RET_CANNOTUSETHISOBJECT;
  1874.  
  1875.     ReturnValue ret = Action::canExecuteAction(player, toPos);
  1876.     if(ret != RET_NOERROR)
  1877.         return ret;
  1878.  
  1879.     if(toPos.x == 0xFFFF)
  1880.     {
  1881.         if(needTarget)
  1882.             return RET_CANONLYUSETHISRUNEONCREATURES;
  1883.  
  1884.         if(!selfTarget)
  1885.             return RET_NOTENOUGHROOM;
  1886.     }
  1887.  
  1888.     return RET_NOERROR;
  1889. }
  1890.  
  1891. bool RuneSpell::executeUse(Player* player, Item* item, const PositionEx& posFrom,
  1892.     const PositionEx& posTo, bool, uint32_t creatureId)
  1893. {
  1894.     if(!checkRuneSpell(player, posTo))
  1895.         return false;
  1896.  
  1897.     bool result = false;
  1898.     if(isScripted())
  1899.     {
  1900.         LuaVariant var;
  1901.         if(creatureId && needTarget)
  1902.         {
  1903.             var.type = VARIANT_NUMBER;
  1904.             var.number = creatureId;
  1905.         }
  1906.         else
  1907.         {
  1908.             var.type = VARIANT_POSITION;
  1909.             var.pos = posTo;
  1910.         }
  1911.  
  1912.         result = internalCastSpell(player, var);
  1913.     }
  1914.     else if(function)
  1915.         result = function(this, player, item, posFrom, posTo);
  1916.  
  1917.     if(result)
  1918.     {
  1919.         Spell::postSpell(player);
  1920.         if(hasCharges && item && g_config.getBool(ConfigManager::REMOVE_RUNE_CHARGES))
  1921.             g_game.transformItem(item, item->getID(), std::max((int32_t)0, ((int32_t)item->getItemCount()) - 1));
  1922.     }
  1923.  
  1924.     return result;
  1925. }
  1926.  
  1927. bool RuneSpell::castSpell(Creature* creature)
  1928. {
  1929.     if(!BaseSpell::castSpell(creature))
  1930.         return false;
  1931.  
  1932.     LuaVariant var;
  1933.     var.type = VARIANT_NUMBER;
  1934.     var.number = creature->getID();
  1935.     return internalCastSpell(creature, var);
  1936. }
  1937.  
  1938. bool RuneSpell::castSpell(Creature* creature, Creature* target)
  1939. {
  1940.     if(!BaseSpell::castSpell(creature, target))
  1941.         return false;
  1942.  
  1943.     LuaVariant var;
  1944.     var.type = VARIANT_NUMBER;
  1945.     var.number = target->getID();
  1946.     return internalCastSpell(creature, var);
  1947. }
  1948.  
  1949. bool RuneSpell::internalCastSpell(Creature* creature, const LuaVariant& var)
  1950. {
  1951.     return isScripted() ? executeCastSpell(creature, var) : false;
  1952. }
  1953.  
  1954. bool RuneSpell::executeCastSpell(Creature* creature, const LuaVariant& var)
  1955. {
  1956.     //onCastSpell(cid, var)
  1957.     if(m_interface->reserveEnv())
  1958.     {
  1959.         ScriptEnviroment* env = m_interface->getEnv();
  1960.         if(m_scripted == EVENT_SCRIPT_BUFFER)
  1961.         {
  1962.             env->setRealPos(creature->getPosition());
  1963.             std::stringstream scriptstream;
  1964.  
  1965.             scriptstream << "local cid = " << env->addThing(creature) << std::endl;
  1966.             env->streamVariant(scriptstream, "var", var);
  1967.  
  1968.             scriptstream << m_scriptData;
  1969.             bool result = true;
  1970.             if(m_interface->loadBuffer(scriptstream.str()))
  1971.             {
  1972.                 lua_State* L = m_interface->getState();
  1973.                 result = m_interface->getGlobalBool(L, "_result", true);
  1974.             }
  1975.  
  1976.             m_interface->releaseEnv();
  1977.             return result;
  1978.         }
  1979.         else
  1980.         {
  1981.             #ifdef __DEBUG_LUASCRIPTS__
  1982.             char desc[60];
  1983.             sprintf(desc, "onCastSpell - %s", creature->getName().c_str());
  1984.             env->setEvent(desc);
  1985.             #endif
  1986.  
  1987.             env->setScriptId(m_scriptId, m_interface);
  1988.             env->setRealPos(creature->getPosition());
  1989.             lua_State* L = m_interface->getState();
  1990.  
  1991.             m_interface->pushFunction(m_scriptId);
  1992.             lua_pushnumber(L, env->addThing(creature));
  1993.             m_interface->pushVariant(L, var);
  1994.  
  1995.             bool result = m_interface->callFunction(2);
  1996.             m_interface->releaseEnv();
  1997.             return result;
  1998.         }
  1999.     }
  2000.     else
  2001.     {
  2002.         std::clog << "[Error - RuneSpell::executeCastSpell] Call stack overflow." << std::endl;
  2003.         return false;
  2004.     }
  2005. }
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!