/* EQ2Emulator: Everquest II Server Emulator Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) This file is part of EQ2Emulator. EQ2Emulator is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. EQ2Emulator is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with EQ2Emulator. If not, see . */ #include "SpellProcess.h" #include "../common/Log.h" #include "Tradeskills/Tradeskills.h" #include "ClientPacketFunctions.h" #include "Rules/Rules.h" extern MasterSpellList master_spell_list; extern MasterSkillList master_skill_list; extern ConfigReader configReader; extern LuaInterface* lua_interface; extern Commands commands; extern World world; extern RuleManager rule_manager; SpellProcess::SpellProcess(){ last_checked_time = 0; MRemoveTargetList.SetName("SpellProcess::MRemoveTargetList"); MSoloHO.SetName("SpellProcess::m_soloHO"); MGroupHO.SetName("SpellProcess:m_groupHO"); MSpellCancelList.SetName("SpellProcess::SpellCancelList"); } SpellProcess::~SpellProcess(){ RemoveAllSpells(); } void SpellProcess::RemoveCaster(Spawn* caster){ MutexList::iterator active_spells_itr = active_spells.begin(); while(active_spells_itr.Next()){ LuaSpell* spell = active_spells_itr->value; spell->MSpellTargets.writelock(__FUNCTION__, __LINE__); if(spell->caster == caster) { spell->caster = nullptr; } spell->MSpellTargets.releasewritelock(__FUNCTION__, __LINE__); } } void SpellProcess::RemoveAllSpells(bool reload_spells){ ClearSpellScriptTimerList(); MutexList::iterator active_spells_itr = active_spells.begin(); while(active_spells_itr.Next()){ DeleteCasterSpell(active_spells_itr->value, "", true, 0, !reload_spells); } MSpellProcess.lock(); active_spells_itr = active_spells.begin(); while(active_spells_itr.Next()){ active_spells.Remove(active_spells_itr->value, true); } active_spells.clear(); InterruptStruct* interrupt = 0; MutexList::iterator interrupt_list_itr = interrupt_list.begin(); while(interrupt_list_itr.Next()){ interrupt = interrupt_list_itr->value; CheckInterrupt(interrupt); interrupt_list.Remove(interrupt_list_itr->value, true); } interrupt_list.clear(); MutexList::iterator cast_timers_itr = cast_timers.begin(); while(cast_timers_itr.Next()){ safe_delete(cast_timers_itr->value->timer); safe_delete(cast_timers_itr->value->spell); cast_timers.Remove(cast_timers_itr->value, true); } cast_timers.clear(); MutexList::iterator recast_timers_itr = recast_timers.begin(); while(recast_timers_itr.Next()){ recast_timers.Remove(recast_timers_itr->value, true); } map*>::iterator remove_itr; MRemoveTargetList.writelock(__FUNCTION__, __LINE__); for (remove_itr = remove_target_list.begin(); remove_itr != remove_target_list.end(); remove_itr++){ safe_delete(remove_itr->second); } remove_target_list.clear(); MRemoveTargetList.releasewritelock(__FUNCTION__, __LINE__); map::iterator solo_ho_itr; MSoloHO.writelock(__FUNCTION__, __LINE__); for (solo_ho_itr = m_soloHO.begin(); solo_ho_itr != m_soloHO.end(); solo_ho_itr++) safe_delete(solo_ho_itr->second); m_soloHO.clear(); MSoloHO.releasewritelock(__FUNCTION__, __LINE__); map::iterator group_ho_itr; MGroupHO.writelock(__FUNCTION__, __LINE__); for (group_ho_itr = m_groupHO.begin(); group_ho_itr != m_groupHO.end(); group_ho_itr++) safe_delete(group_ho_itr->second); m_groupHO.clear(); MGroupHO.releasewritelock(__FUNCTION__, __LINE__); recast_timers.clear(); spell_que.clear(); MSpellCancelList.writelock(__FUNCTION__, __LINE__); SpellCancelList.clear(); MSpellCancelList.releasewritelock(__FUNCTION__, __LINE__); MSpellProcess.unlock(); } void SpellProcess::Process(){ if(last_checked_time > Timer::GetCurrentTime2()) return; last_checked_time = Timer::GetCurrentTime2() + 50; MSpellProcess.lock_shared(); CheckSpellScriptTimers(); if(active_spells.size(true) > 0){ LuaSpell* spell = 0; MutexList::iterator itr = active_spells.begin(); map >::iterator remove_itr; vector::iterator target_itr; vector::iterator remove_target_itr; while(itr.Next()){ spell = itr->value; if (!spell->spell->GetSpellData()->duration_until_cancel && spell->timer.Check()){ spell->num_calls++; // ProcessSpell(spell, flase) will atempt to call the tick() function in the lua script // if there is no tick function it will return false, this will cause the server to crash in the event // of a spell that has a duration but is not a "until canceled" spell or a spell with a tick (tradeskill buffs) // to counter this check to see if the spell has a call_frequency > 0 before we call ProcessSpell() if (spell->spell->GetSpellData()->call_frequency > 0 && !ProcessSpell(spell, false)) active_spells.Remove(spell, true, 2000); else if (((spell->timer.GetDuration() * spell->num_calls) >= spell->spell->GetSpellData()->duration1 * 100) || (spell->restored && (spell->timer.GetSetAtTrigger() * spell->num_calls) >= spell->spell->GetSpellData()->duration1 * 100)) DeleteCasterSpell(spell, "expired"); } else CheckRemoveTargetFromSpell(spell); } } if (SpellCancelList.size() > 0){ std::vector tmpList; MSpellCancelList.writelock(__FUNCTION__, __LINE__); vector::iterator itr = SpellCancelList.begin(); while (itr != SpellCancelList.end()){ tmpList.push_back(*itr); itr++; } SpellCancelList.clear(); MSpellCancelList.releasewritelock(__FUNCTION__, __LINE__); itr = tmpList.begin(); while (itr != tmpList.end()) { DeleteCasterSpell(*itr, "canceled"); itr++; } } if(interrupt_list.size(true) > 0){ InterruptStruct* interrupt = 0; MutexList::iterator itr = interrupt_list.begin(); while(itr.Next()){ interrupt = itr->value; CheckInterrupt(interrupt); safe_delete(interrupt); } interrupt_list.clear(); } if(cast_timers.size(true) > 0){ CastTimer* cast_timer = 0; MutexList::iterator itr = cast_timers.begin(); while (itr.Next()) { cast_timer = itr->value; if (cast_timer) { if (cast_timer->timer->Check(false)) { if (cast_timer->spell) { if (cast_timer->spell->caster && cast_timer->spell->caster->IsPlayer()) { Client* client = ((Player*)cast_timer->spell->caster)->GetClient(); if(client) { PacketStruct* packet = configReader.getStruct("WS_FinishCastSpell", client->GetVersion()); if (packet) { packet->setMediumStringByName("spell_name", cast_timer->spell->spell->GetSpellData()->name.data.c_str()); client->QueuePacket(packet->serialize()); safe_delete(packet); } } } if (cast_timer->spell && cast_timer->spell->caster) cast_timer->spell->caster->IsCasting(false); cast_timer->delete_timer = true; CastProcessedSpell(cast_timer->spell, false, cast_timer->in_heroic_opp); } else if (cast_timer->entity_command) { if (cast_timer->timer->Check(false)) { cast_timer->delete_timer = true; Spawn* target = cast_timer->zone->GetSpawnByID(cast_timer->target_id); CastProcessedEntityCommand(cast_timer->entity_command, cast_timer->caster, target, cast_timer->in_heroic_opp); } } } if (cast_timer->delete_timer) { safe_delete(cast_timer->timer); cast_timers.Remove(cast_timer, true); } } } } if (recast_timers.size(true) > 0) { RecastTimer* recast_timer = 0; MutexList::iterator itr = recast_timers.begin(); vector::iterator remove_recast_itr; while(itr.Next()){ recast_timer = itr->value; if(recast_timer->timer->Check(false)){ MaintainedEffects* effect = 0; if(recast_timer->caster && (!(effect = recast_timer->caster->GetMaintainedSpell(recast_timer->spell_id)) || !effect->spell->spell->GetSpellData()->duration_until_cancel)) UnlockSpell(recast_timer->client, recast_timer->spell); safe_delete(recast_timer->timer); recast_timers.Remove(recast_timer, true); } } } if(spell_que.size(true) > 0){ MutexMap::iterator itr = spell_que.begin(); while(itr.Next()){ if(itr->first->IsCasting() == false && IsReady(itr->second, itr->first)){ RemoveSpellFromQueue(itr->second, itr->first); ProcessSpell(itr->first->GetZone(), itr->second, itr->first, itr->first->GetTarget()); } } } // Check solo HO timers MSoloHO.writelock(__FUNCTION__, __LINE__); if (m_soloHO.size() > 0) { map::iterator itr = m_soloHO.begin(); while (itr != m_soloHO.end()) { if (itr->second->GetWheel() && Timer::GetCurrentTime2() >= (itr->second->GetStartTime() + (itr->second->GetTotalTime() * 1000))) { itr->second->SetComplete(1); ClientPacketFunctions::SendHeroicOPUpdate(itr->first, itr->second); safe_delete(itr->second); itr = m_soloHO.erase(itr); continue; } else itr++; } } MSoloHO.releasewritelock(__FUNCTION__, __LINE__); // Check group HO timers MGroupHO.writelock(__FUNCTION__, __LINE__); if (m_groupHO.size() > 0) { map::iterator itr = m_groupHO.begin(); while (itr != m_groupHO.end()) { if (itr->second->GetWheel() && Timer::GetCurrentTime2() >= (itr->second->GetStartTime() + (itr->second->GetTotalTime() * 1000))) { itr->second->SetComplete(1); world.GetGroupManager()->GroupLock(__FUNCTION__, __LINE__); deque::iterator itr2; PlayerGroup* group = world.GetGroupManager()->GetGroup(itr->first); if (group) { group->MGroupMembers.readlock(__FUNCTION__, __LINE__); deque* members = group->GetMembers(); for (itr2 = members->begin(); itr2 != members->end(); itr2++) { if ((*itr2)->client) ClientPacketFunctions::SendHeroicOPUpdate((*itr2)->client, itr->second); } group->MGroupMembers.releasereadlock(__FUNCTION__, __LINE__); } world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__); safe_delete(itr->second); itr = m_groupHO.erase(itr); continue; } else itr++; } } MGroupHO.releasewritelock(__FUNCTION__, __LINE__); MSpellProcess.unlock_shared(); } bool SpellProcess::IsReady(Spell* spell, Entity* caster){ if(caster->IsCasting()) { return false; } bool ret = true; RecastTimer* recast_timer = 0; MutexList::iterator itr = recast_timers.begin(); while(itr.Next()){ recast_timer = itr->value; if((recast_timer->spell == spell || recast_timer->spell_id == spell->GetSpellID()) && recast_timer->caster == caster){ ret = false; break; } } return ret; } void SpellProcess::CheckRecast(Spell* spell, Entity* caster, float timer_override, bool check_linked_timers) { if(spell && caster && spell->GetSpellData()->recast > 0.0f){ RecastTimer* timer = new RecastTimer; timer->caster = caster; if(caster->IsPlayer()) timer->client = ((Player*)caster)->GetClient(); else timer->client = 0; timer->spell = spell; int32 recast_time = static_cast(spell->GetSpellData()->recast * 1000.0f); if(timer_override == 0.0f) { recast_time = spell->CalculateRecastTimer(caster); timer->timer = new Timer(recast_time); } else { recast_time = spell->CalculateRecastTimer(caster, timer_override); timer->timer = new Timer(recast_time); } if(recast_time < 1) { safe_delete(timer->timer); safe_delete(timer); } else { timer->type_group_spell_id = spell->GetSpellData()->type_group_spell_id; timer->linked_timer = spell->GetSpellData()->linked_timer; timer->spell_id = spell->GetSpellID(); recast_timers.Add(timer); } if(caster->IsPlayer()){ if(recast_time < 1) { ((Player*)caster)->UnlockSpell(spell); } else { ((Player*)caster)->LockSpell(spell, (int16)(recast_time)); } if (check_linked_timers && spell->GetSpellData()->linked_timer > 0) { vector linkedSpells = ((Player*)caster)->GetSpellBookSpellsByTimer(spell, spell->GetSpellData()->linked_timer); for (int8 i = 0; i < linkedSpells.size(); i++) { Spell* spell2 = linkedSpells.at(i); if (spell2) CheckRecast(spell2, caster, static_cast(recast_time), false); } } } } } void SpellProcess::CheckInterrupt(InterruptStruct* interrupt){ if(!interrupt || !interrupt->interrupted || !interrupt->interrupted->IsEntity()) return; Entity* entity = (Entity*)interrupt->interrupted; Client* client = nullptr; if(entity->IsPlayer()) { client = ((Player*)entity)->GetClient(); } if(entity->IsPlayer() && client) SendFinishedCast(GetLuaSpell(entity), client); RemoveSpellTimersFromSpawn(entity, false); entity->IsCasting(false); entity->GetZone()->SendInterruptPacket(entity, interrupt->spell); if(interrupt->error_code > 0 && client) entity->GetZone()->SendSpellFailedPacket(client, interrupt->error_code); if(entity->IsPlayer()) { ((Player*)entity)->UnlockSpell(interrupt->spell->spell); if(client) { SendSpellBookUpdate(client); } } } bool SpellProcess::DeleteCasterSpell(Spawn* caster, Spell* spell, string reason){ bool ret = false; // need to use size(true) to get pending updates to the list as well if (caster && spell && active_spells.size() > 0) { LuaSpell* lua_spell = 0; MutexList::iterator itr = active_spells.begin(); while (itr.Next()){ lua_spell = itr->value; if (lua_spell->spell == spell && lua_spell->caster == caster) { ret = DeleteCasterSpell(lua_spell, reason); break; } } } return ret; } bool SpellProcess::DeleteCasterSpell(LuaSpell* spell, string reason, bool removing_all_spells, Spawn* remove_target, bool zone_shutting_down, bool shared_lock_spell){ if(shared_lock_spell && !removing_all_spells) { MSpellProcess.lock_shared(); } bool ret = false; Spawn* target = 0; bool target_valid = false; if(spell) { spell->MSpellTargets.writelock(__FUNCTION__, __LINE__); if(remove_target && spell->targets.size() > 1) { for (int32 i = 0; i < spell->targets.size(); i++) { if(remove_target->GetID() == spell->targets.at(i)) { if(remove_target->IsEntity()){ spell->removed_targets.push_back(remove_target->GetID()); ((Entity*)remove_target)->RemoveProc(0, spell); ((Entity*)remove_target)->RemoveSpellEffect(spell); ((Entity*)remove_target)->RemoveSpellBonus(spell); if(spell->spell->GetSpellData()->det_type > 0 && (spell->spell->GetSpellDuration() > 0 || spell->spell->GetSpellData()->duration_until_cancel)) ((Entity*)remove_target)->RemoveDetrimentalSpell(spell); } spell->targets.erase(spell->targets.begin()+i, spell->targets.begin()+i+1); target_valid = true; break; } } spell->MSpellTargets.releasewritelock(__FUNCTION__, __LINE__); if(shared_lock_spell && !removing_all_spells) { MSpellProcess.unlock_shared(); } return target_valid; } spell->MSpellTargets.releasewritelock(__FUNCTION__, __LINE__); if (active_spells.count(spell) > 0) active_spells.Remove(spell); if (!zone_shutting_down && spell->caster) { // spell->caster ptr cannot be trusted during zone shutdown if(spell->caster->GetThreatTransfer() && spell->caster->GetThreatTransfer()->Spell == spell) { spell->caster->SetThreatTransfer(nullptr); } if (spell->spell->GetSpellData()->cast_type == SPELL_CAST_TYPE_TOGGLE){ int8 actual_concentration = spell->spell->GetSpellData()->req_concentration; if (actual_concentration > 0) { int8 curConcentration = spell->caster->GetInfoStruct()->get_cur_concentration(); if(curConcentration >= actual_concentration) { spell->caster->GetInfoStruct()->set_cur_concentration(curConcentration - actual_concentration); if (spell->caster->IsPlayer()&& spell->caster->GetZone()) spell->caster->GetZone()->TriggerCharSheetTimer(); } } if(!spell->spell->GetSpellData()->duration_until_cancel) { CheckRecast(spell->spell, spell->caster); if (spell->caster && spell->caster->IsPlayer()) SendSpellBookUpdate(((Player*)spell->caster)->GetClient()); } } if(IsReady(spell->spell, spell->caster) && spell->caster->IsPlayer()) { ((Player*)spell->caster)->UnlockSpell(spell->spell); SendSpellBookUpdate(((Player*)spell->caster)->GetClient()); } spell->caster->RemoveProc(0, spell); spell->caster->RemoveMaintainedSpell(spell); CheckRemoveTargetFromSpell(spell, removing_all_spells, removing_all_spells); ZoneServer* zone = spell->caster->GetZone(); if(zone) { spell->MSpellTargets.readlock(__FUNCTION__, __LINE__); for (int32 i = 0; i < spell->targets.size(); i++) { target = zone->GetSpawnByID(spell->targets.at(i)); if(target && target->IsEntity()){ spell->removed_targets.push_back(target->GetID()); ((Entity*)target)->RemoveProc(0, spell); ((Entity*)target)->RemoveSpellEffect(spell); ((Entity*)target)->RemoveSpellBonus(spell); if(spell->spell->GetSpellData()->det_type > 0 && (spell->spell->GetSpellDuration() > 0 || spell->spell->GetSpellData()->duration_until_cancel)) ((Entity*)target)->RemoveDetrimentalSpell(spell); } else{ spell->caster->RemoveSpellEffect(spell); spell->caster->RemoveSpellBonus(spell); if(spell->spell->GetSpellData()->det_type > 0 && (spell->spell->GetSpellDuration() > 0 || spell->spell->GetSpellData()->duration_until_cancel)) spell->caster->RemoveDetrimentalSpell(spell); } if(target && target->IsPlayer() && spell->spell->GetSpellData()->fade_message.length() > 0){ Client* client = ((Player*)target)->GetClient(); if(client){ bool send_to_sender = true; string fade_message = spell->spell->GetSpellData()->fade_message; if(fade_message.find("%t") != string::npos) fade_message.replace(fade_message.find("%t"), 2, target->GetName()); client->Message(CHANNEL_SPELLS_OTHER, fade_message.c_str()); } } if (target && target->IsPlayer() && spell->spell->GetSpellData()->fade_message.length() > 0) { Client* client = ((Player*)target)->GetClient(); if (client) { bool send_to_sender = true; string fade_message_others = spell->spell->GetSpellData()->fade_message_others; if (fade_message_others.find("%t") != string::npos) fade_message_others.replace(fade_message_others.find("%t"), 2, target->GetName()); if (fade_message_others.find("%c") != string::npos) fade_message_others.replace(fade_message_others.find("%c"), 2, spell->caster->GetName()); if (fade_message_others.find("%T") != string::npos) { fade_message_others.replace(fade_message_others.find("%T"), 2, target->GetName()); send_to_sender = false; } if (fade_message_others.find("%C") != string::npos) { fade_message_others.replace(fade_message_others.find("%C"), 2, spell->caster->GetName()); send_to_sender = false; } if(spell->caster->GetZone()) { spell->caster->GetZone()->SimpleMessage(CHANNEL_SPELLS_OTHER, fade_message_others.c_str(), target, 50, send_to_sender); } } } } spell->MSpellTargets.releasereadlock(__FUNCTION__, __LINE__); } ret = true; } if(lua_interface && !zone_shutting_down) lua_interface->RemoveSpell(spell, true, SpellScriptTimersHasSpell(spell), reason, removing_all_spells); } if(shared_lock_spell && !removing_all_spells) { MSpellProcess.unlock_shared(); } return ret; } bool SpellProcess::ProcessSpell(LuaSpell* spell, bool first_cast, const char* function, SpellScriptTimer* timer, bool all_targets) { bool ret = false; if(!spell->state) { LogWrite(SPELL__ERROR, 0, "Spell", "Error: State is NULL! SpellProcess::ProcessSpell for Spell '%s'", (spell->spell != nullptr) ? spell->spell->GetName() : "Unknown"); } else if(lua_interface && !spell->interrupted){ if(all_targets) { for(int t=0;ttargets.size();t++) { if(spell->caster->GetZone()) { Spawn* altSpawn = spell->caster->GetZone()->GetSpawnByID(spell->targets[t]); if(altSpawn) { std::string functionCall = ApplyLuaFunction(spell, first_cast, function, timer, altSpawn); if(functionCall.length() < 1) ret = false; else ret = lua_interface->CallSpellProcess(spell, 2 + spell->spell->GetLUAData()->size(), functionCall); } } } return true; } std::string functionCall = ApplyLuaFunction(spell, first_cast, function, timer); if(functionCall.length() < 1) ret = false; else ret = lua_interface->CallSpellProcess(spell, 2 + spell->spell->GetLUAData()->size(), functionCall); } return ret; } std::string SpellProcess::ApplyLuaFunction(LuaSpell* spell, bool first_cast, const char* function, SpellScriptTimer* timer, Spawn* altTarget) { std::string functionCall = lua_interface->AddSpawnPointers(spell, first_cast, false, function, timer, false, altTarget); vector* data = spell->spell->GetLUAData(); for(int32 i=0;isize();i++){ switch(data->at(i)->type){ case 0:{ lua_interface->SetSInt32Value(spell->state, data->at(i)->int_value); break; } case 1:{ lua_interface->SetFloatValue(spell->state, data->at(i)->float_value); break; } case 2:{ lua_interface->SetBooleanValue(spell->state, data->at(i)->bool_value); break; } case 3:{ lua_interface->SetStringValue(spell->state, data->at(i)->string_value.c_str()); break; } default:{ LogWrite(SPELL__ERROR, 0, "Spell", "Error: Unknown LUA Type '%i' in SpellProcess::ProcessSpell for Spell '%s'", (int)data->at(i)->type, spell->spell->GetName()); return string(""); } } } return functionCall; } bool SpellProcess::CastPassives(Spell* spell, Entity* caster, bool remove) { CastInstant(spell, caster, caster, remove, true); return true; } bool SpellProcess::CastInstant(Spell* spell, Entity* caster, Entity* target, bool remove, bool passive) { LuaSpell* lua_spell = 0; if(lua_interface) lua_spell = lua_interface->GetSpell(spell->GetSpellData()->lua_script.c_str()); if(!lua_spell) { string lua_script = spell->GetSpellData()->lua_script; lua_script.append(".lua"); lua_spell = 0; if(lua_interface) lua_spell = lua_interface->GetSpell(lua_script.c_str()); if(!lua_spell) { LogWrite(SPELL__ERROR, 0, "Spell", "Failed to get a LuaSpell for %s (%u)", spell->GetName(), spell->GetSpellID()); return false; } else spell->GetSpellData()->lua_script = lua_script; } lua_spell->caster = caster; lua_spell->initial_caster_char_id = (caster && caster->IsPlayer()) ? ((Player*)caster)->GetCharacterID() : 0; lua_spell->spell = spell; lua_spell->initial_target = target->GetID(); lua_spell->initial_target_char_id = (target && target->IsPlayer()) ? ((Player*)target)->GetCharacterID() : 0; GetSpellTargets(lua_spell); if (!lua_spell->spell->IsCopiedSpell()) { lua_getglobal(lua_spell->state, "customspell"); if (lua_isfunction(lua_spell->state, lua_gettop(lua_spell->state))) { lua_pop(lua_spell->state, 1); Spell* tmpSpell = lua_spell->spell; lua_spell->spell = new Spell(lua_spell->spell); lua_interface->AddCustomSpell(lua_spell); lua_interface->AddSpawnPointers(lua_spell, false, false, "customspell",0,true); if (lua_pcall(lua_spell->state, 3, 3, 0) != 0) { lua_interface->RemoveCustomSpell(lua_spell->spell->GetSpellID()); lua_interface->ResetFunctionStack(lua_spell->state); safe_delete(lua_spell->spell); lua_spell->spell = tmpSpell; } else lua_interface->ResetFunctionStack(lua_spell->state); } else lua_interface->ResetFunctionStack(lua_spell->state); } bool result = CastProcessedSpell(lua_spell, passive); caster->GetZone()->SendCastSpellPacket(lua_spell, caster); if(!result) { lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return result; } if(!remove) return result; lua_interface->RemoveSpell(lua_spell, true, SpellScriptTimersHasSpell(lua_spell)); return true; } void SpellProcess::SendStartCast(LuaSpell* spell, Client* client){ if(client){ PacketStruct* packet = configReader.getStruct("WS_StartCastSpell", client->GetVersion()); if(packet){ packet->setDataByName("cast_time", spell->spell->GetSpellData()->cast_time*.01); packet->setMediumStringByName("spell_name", spell->spell->GetSpellData()->name.data.c_str()); EQ2Packet* outapp = packet->serialize(); //DumpPacket(outapp); client->QueuePacket(outapp); safe_delete(packet); } } } void SpellProcess::SendFinishedCast(LuaSpell* spell, Client* client){ if(client && spell && spell->spell){ if (spell->spell->GetSpellData()->cast_type == SPELL_CAST_TYPE_TOGGLE) UnlockAllSpells(client, spell->spell); else UnlockAllSpells(client); if(spell->resisted && spell->spell->GetSpellData()->recast > 0) CheckRecast(spell->spell, client->GetPlayer(), 0.5f); // half sec recast on resisted spells else if (!spell->interrupted) CheckRecast(spell->spell, client->GetPlayer()); else if(spell->caster && spell->caster->IsPlayer()) { ((Player*)spell->caster)->LockSpell(spell->spell, (int16)(spell->spell->CalculateRecastTimer(spell->caster))); } PacketStruct* packet = configReader.getStruct("WS_FinishCastSpell", client->GetVersion()); if(packet){ packet->setMediumStringByName("spell_name", spell->spell->GetSpellData()->name.data.c_str()); client->QueuePacket(packet->serialize()); safe_delete(packet); } SendSpellBookUpdate(client); } if (spell) { if (!spell->interrupted) { TakePower(spell); TakeHP(spell); TakeSavagery(spell); AddDissonance(spell); AddConcentration(spell); if (client && spell->spell && !spell->spell->GetSpellData()->friendly_spell) { if(!client->GetPlayer()->EngagedInCombat()) { client->GetPlayer()->InCombat(true, false); client->GetPlayer()->SetRangeAttack(false); } else if(client->GetPlayer()->EngagedInCombat() && client->GetPlayer()->GetRangeAttack() && spell->spell->GetSpellData()->type == SPELL_BOOK_TYPE_COMBAT_ART) { Spawn* target = client->GetPlayer()->GetZone()->GetSpawnByID(spell->initial_target); if(target) { float distance = client->GetPlayer()->GetDistance(target); if(distance <= rule_manager.GetGlobalRule(R_Combat, MaxCombatRange)->GetFloat()) { client->GetPlayer()->InCombat(true, false); client->GetPlayer()->SetRangeAttack(false); } } } } if(client && spell->caster) client->CheckPlayerQuestsSpellUpdate(spell->spell); } } } void SpellProcess::LockAllSpells(Client* client){ if(client){ client->GetPlayer()->LockAllSpells(); SendSpellBookUpdate(client); } } void SpellProcess::UnlockAllSpells(Client* client, Spell* exception){ if(client) client->GetPlayer()->UnlockAllSpells(false, exception); } void SpellProcess::UnlockSpell(Client* client, Spell* spell){ if(client && client->GetPlayer() && spell) { client->GetPlayer()->UnlockSpell(spell); SendSpellBookUpdate(client); } } bool SpellProcess::CheckPower(LuaSpell* spell){ int16 req = 0; if(spell->caster){ req = spell->spell->GetPowerRequired(spell->caster); if(spell->caster->GetPower() >= req) return true; } return false; } bool SpellProcess::TakePower(LuaSpell* spell, int32 custom_power_req){ int16 req = 0; if(spell->caster){ if(custom_power_req) req = custom_power_req; else req = spell->spell->GetPowerRequired(spell->caster); if(spell->caster->GetPower() >= req){ spell->caster->SetPower(spell->caster->GetPower() - req); if(spell->caster->IsPlayer() && spell->caster->GetZone()) spell->caster->GetZone()->TriggerCharSheetTimer(); return true; } } return false; } bool SpellProcess::CheckHP(LuaSpell* spell) { int16 req = 0; if(spell->caster){ req = spell->spell->GetHPRequired(spell->caster); if(spell->caster->GetHP() >= req) return true; } return false; } bool SpellProcess::TakeHP(LuaSpell* spell, int32 custom_hp_req) { int16 req = 0; if(spell->caster){ if(custom_hp_req) req = custom_hp_req; else req = spell->spell->GetHPRequired(spell->caster); if(spell->caster->GetHP() >= req){ spell->caster->SetHP(spell->caster->GetHP() - req); if(spell->caster->IsPlayer() && spell->caster->GetZone()) spell->caster->GetZone()->TriggerCharSheetTimer(); return true; } } return false; } bool SpellProcess::CheckConcentration(LuaSpell* spell) { if (spell && spell->caster) { int8 req = spell->spell->GetSpellData()->req_concentration; int8 current_avail = 5 - spell->caster->GetConcentrationCurrent(); if (current_avail >= req) return true; } return false; } bool SpellProcess::AddConcentration(LuaSpell* spell) { if (spell && spell->caster) { int8 req = spell->spell->GetSpellData()->req_concentration; int8 curConcentration = spell->caster->GetInfoStruct()->get_cur_concentration(); int8 current_avail = 5 - curConcentration; if (current_avail >= req) { spell->caster->GetInfoStruct()->set_cur_concentration(curConcentration + req); if (spell->caster->IsPlayer() && spell->caster->GetZone()) spell->caster->GetZone()->TriggerCharSheetTimer(); LogWrite(SPELL__DEBUG, 0, "Spell", "Concentration is now %u on %s (Spell %s)", spell->caster->GetInfoStruct()->get_cur_concentration(), spell->caster->GetName(), spell->spell->GetName()); return true; } } return false; } bool SpellProcess::CheckSavagery(LuaSpell* spell) { if (spell && spell->caster) { int16 req = spell->spell->GetSavageryRequired(spell->caster); if(spell->caster->GetSavagery() >= req) return true; } return false; } bool SpellProcess::TakeSavagery(LuaSpell* spell) { int16 req = 0; if(spell && spell->caster && spell->caster->IsPlayer()){ req = spell->spell->GetSavageryRequired(spell->caster); if(spell->caster->GetSavagery() >= req){ spell->caster->SetSavagery(spell->caster->GetSavagery() - req); if(spell->caster->IsPlayer() && spell->caster->GetZone()) spell->caster->GetZone()->TriggerCharSheetTimer(); return true; } } return false; } bool SpellProcess::CheckDissonance(LuaSpell* spell) { if (spell && spell->caster) { int16 req = spell->spell->GetDissonanceRequired(spell->caster); if(spell->caster->GetDissonance() <= req) return true; } return false; } bool SpellProcess::AddDissonance(LuaSpell* spell) { int16 req = 0; if(spell && spell->caster && spell->caster->IsPlayer()){ req = spell->spell->GetDissonanceRequired(spell->caster); if(spell->caster->GetDissonance() >= req){ spell->caster->SetDissonance(spell->caster->GetDissonance() - req); if(spell->caster->IsPlayer() && spell->caster->GetZone()) spell->caster->GetZone()->TriggerCharSheetTimer(); return true; } } return false; } void SpellProcess::AddSpellToQueue(Spell* spell, Entity* caster){ if(caster && caster->IsPlayer() && spell){ LogWrite(SPELL__DEBUG, 1, "Spell", "%s AddSpellToQueue casting %s.", caster->GetName(), spell->GetName()); spell_que.Put(caster, spell); ((Player*)caster)->QueueSpell(spell); Client* client = ((Player*)caster)->GetClient(); if(client) SendSpellBookUpdate(client); } } void SpellProcess::RemoveSpellFromQueue(Spell* spell, Entity* caster, bool send_update){ if(caster && caster->IsPlayer() && spell){ LogWrite(SPELL__DEBUG, 1, "Spell", "%s RemoveSpellFromQueue casting %s.", caster->GetName(), spell->GetName()); spell_que.erase(caster); ((Player*)caster)->UnQueueSpell(spell); Client* client = ((Player*)caster)->GetClient(); if(client && send_update) SendSpellBookUpdate(client); } } void SpellProcess::RemoveSpellFromQueue(Entity* caster, bool hostile_only) { if (caster && spell_que.count(caster) > 0) { Spell* spell = spell_que.Get(caster); if (spell) { bool remove = true; if (hostile_only && spell->GetSpellData()->target_type != SPELL_TARGET_ENEMY) remove = false; if (remove) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s RemoveSpellFromQueue::Secondary casting %s.", caster->GetName(), spell->GetName()); spell_que.erase(caster); ((Player*)caster)->UnQueueSpell(spell); Client* client = ((Player*)caster)->GetClient(); if (client) SendSpellBookUpdate(client); } } } } bool SpellProcess::CheckSpellQueue(Spell* spell, Entity* caster){ if(caster->IsPlayer()){ bool add = true; bool remove = false; Spell* prevSpell = 0; if(spell_que.count(caster) > 0){ prevSpell = spell_que.Get(caster); remove = true; if(prevSpell == spell) { add = false; } } if(remove) RemoveSpellFromQueue(prevSpell, caster, !add); if(add) { AddSpellToQueue(spell, caster); return true; } } return false; } void SpellProcess::SendSpellBookUpdate(Client* client){ if(client){ EQ2Packet* app = client->GetPlayer()->GetSpellBookUpdatePacket(client->GetVersion()); if(app) client->QueuePacket(app); } } LuaSpell* SpellProcess::GetLuaSpell(Entity* caster){ LuaSpell* spell = 0; if(caster && cast_timers.size() > 0){ CastTimer* cast_timer = 0; MutexList::iterator itr = cast_timers.begin(); while(itr.Next()){ cast_timer = itr->value; if(cast_timer && cast_timer->spell && cast_timer->spell->caster == caster){ spell = cast_timer->spell; break; } } } return spell; } Spell* SpellProcess::GetSpell(Entity* caster){ Spell* spell = 0; if(cast_timers.size() > 0){ CastTimer* cast_timer = 0; MutexList::iterator itr = cast_timers.begin(); while(itr.Next()){ cast_timer = itr->value; if(cast_timer && cast_timer->spell && cast_timer->spell->caster == caster){ spell = cast_timer->spell->spell; break; } } } return spell; } Spawn* SpellProcess::GetSpellTarget(Entity* caster){ Spawn* target = 0; if(cast_timers.size() > 0){ CastTimer* cast_timer = 0; MutexList::iterator itr = cast_timers.begin(); while(itr.Next()){ cast_timer = itr->value; if(cast_timer && cast_timer->spell->caster == caster){ target = caster->GetZone()->GetSpawnByID(cast_timer->spell->initial_target); break; } } } return target; } void SpellProcess::ProcessSpell(ZoneServer* zone, Spell* spell, Entity* caster, Spawn* target, bool lock, bool harvest_spell, LuaSpell* customSpell, int16 custom_cast_time, bool in_heroic_opp) { if((customSpell != 0 || spell != 0) && caster) { Client* client = 0; //int16 version = 0; LuaSpell* lua_spell = 0; if (customSpell) { lua_spell = customSpell; spell = lua_spell->spell; } else if(lua_interface) lua_spell = lua_interface->GetSpell(spell->GetSpellData()->lua_script.c_str()); // this will only hit if customSpell is null and we go through the lua_interface if(!lua_spell) { string lua_script = spell->GetSpellData()->lua_script; lua_script.append(".lua"); if(lua_interface) lua_spell = lua_interface->GetSpell(lua_script.c_str()); if(!lua_spell) return; else spell->GetSpellData()->lua_script = lua_script; } if (!target) target = caster; int8 target_type = spell->GetSpellData()->target_type; int8 spell_type = spell->GetSpellData()->spell_type; lua_spell->caster = caster; lua_spell->initial_caster_char_id = (caster && caster->IsPlayer()) ? ((Player*)caster)->GetCharacterID() : 0; lua_spell->spell = spell; int32 target_id = target->GetID(); lua_spell->initial_target = target_id; lua_spell->initial_target_char_id = (target && target->IsPlayer()) ? ((Player*)target)->GetCharacterID() : 0; if (!harvest_spell) GetSpellTargets(lua_spell); else{ AddLuaSpellTarget(lua_spell, target_id); } if (target_id == lua_spell->initial_target) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s is casting %s on %s.", caster->GetName(), spell->GetName(), ( target ) ? target->GetName() : "No Target" ); } else { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Casting on %s through %s as target.", spell->GetName(), caster->GetZone()->GetSpawnByID(lua_spell->initial_target)->GetName(), target->GetName()); } target = lua_spell->caster->GetZone()->GetSpawnByID(lua_spell->initial_target); if(caster->IsPlayer() && zone) { client = ((Player*)caster)->GetClient(); //version = client->GetVersion(); } if (!customSpell && !lua_spell->spell->IsCopiedSpell()) { lua_getglobal(lua_spell->state, "customspell"); if (lua_isfunction(lua_spell->state, lua_gettop(lua_spell->state))) { lua_pop(lua_spell->state, 1); Spell* tmpSpell = lua_spell->spell; lua_spell->spell = new Spell(lua_spell->spell); lua_interface->AddCustomSpell(lua_spell); lua_interface->AddSpawnPointers(lua_spell, false, false, "customspell", 0, true); if (lua_pcall(lua_spell->state, 3, 3, 0) != 0) { lua_interface->RemoveCustomSpell(lua_spell->spell->GetSpellID()); lua_interface->ResetFunctionStack(lua_spell->state); safe_delete(lua_spell->spell); lua_spell->spell = tmpSpell; } else lua_interface->ResetFunctionStack(lua_spell->state); } else lua_interface->ResetFunctionStack(lua_spell->state); } //If this spell is the toggle cast type and is being toggled off, do this now if (spell->GetSpellData()->cast_type == SPELL_CAST_TYPE_TOGGLE) { bool ret_val = DeleteCasterSpell(caster, spell, "purged"); if (ret_val) { lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } } // If a player is casting the spell AND spell is a tradeskill spell if (client && spell->GetSpellData()->spell_book_type == SPELL_BOOK_TYPE_TRADESKILL) { // If the player is currently crafting if (client->IsCrafting()) { Tradeskill* tradeskill = 0; zone->GetTradeskillMgr()->ReadLock(__FUNCTION__, __LINE__); tradeskill = zone->GetTradeskillMgr()->GetTradeskill(client); // Can not cast a crafting spell that doesn't match the current crafting technique if (spell->GetSpellData()->mastery_skill != tradeskill->recipe->GetTechnique()) { // send a message to the client, used chat_relationship to match other tradeskill messages, not sure if it is accurate though client->Message(CHANNEL_COLOR_CHAT_RELATIONSHIP, "You are not using %s on this recipe.", master_skill_list.GetSkill(spell->GetSpellData()->mastery_skill)->name.data.c_str()); // Write a spell debug message on why we couldn't cast LogWrite(SPELL__DEBUG, 1, "Spell", "%s could not cast tradeskill spell (%s), skills did not match. spell mastery skill = %u, tradeskill technique = %u", caster->GetName(), spell->GetName(), spell->GetSpellData()->mastery_skill, tradeskill->recipe->GetTechnique()); // make sure to release the lock before we return out zone->GetTradeskillMgr()->ReleaseReadLock(__FUNCTION__, __LINE__); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } // need to make sure the lock is released if the if passed zone->GetTradeskillMgr()->ReleaseReadLock(__FUNCTION__, __LINE__); } else // If the player is not currently crafting { LogWrite(SPELL__DEBUG, 1, "Spell", "%s cannot cast a tradeskill spell (%s) while not crafting.", caster->GetName(), spell->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_ONLY_WHEN_CRAFTING); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } } if (caster != target && target != NULL && !caster->CheckLoS(target)) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s cannot see target %s.", caster->GetName(), target->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_CANT_SEE_TARGET); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } LuaSpell* conflictSpell = caster->HasLinkedTimerID(lua_spell, target, (spell_type == SPELL_TYPE_DD || spell_type == SPELL_TYPE_DOT)); if(conflictSpell) { if(conflictSpell->spell->GetSpellData()->min_class_skill_req > 0 && lua_spell->spell->GetSpellData()->min_class_skill_req > 0) { if(conflictSpell->spell->GetSpellData()->min_class_skill_req <= lua_spell->spell->GetSpellData()->min_class_skill_req) { if(lua_spell->spell->GetSpellData()->duration_until_cancel && !lua_spell->num_triggers) { if(spell->GetSpellData()->friendly_spell) { ZoneServer* zone = caster->GetZone(); Spawn* tmpTarget = zone->GetSpawnByID(conflictSpell->initial_target); if(tmpTarget && tmpTarget->IsEntity()) { zone->RemoveTargetFromSpell(conflictSpell, tmpTarget); CheckRemoveTargetFromSpell(conflictSpell); ((Entity*)tmpTarget)->RemoveSpellEffect(conflictSpell); if(client && IsReady(conflictSpell->spell, client->GetPlayer())) UnlockSpell(client, conflictSpell->spell); } DeleteSpell(lua_spell); return; } else if(lua_spell->spell->GetSpellData()->spell_type == SPELL_TYPE_DEBUFF) { SpellCannotStack(zone, client, lua_spell->caster, lua_spell, conflictSpell); return; } } } else { SpellCannotStack(zone, client, lua_spell->caster, lua_spell, conflictSpell); return; } } } if ((caster->IsMezzed() && !spell->CastWhileMezzed()) || (caster->IsStunned() && !spell->CastWhileStunned())) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s cannot cast (mezzed or stunned).", caster->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_CANNOT_CAST_STUNNED); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if (caster->IsStifled() && !spell->CastWhileStifled()) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s cannot cast (stifled).", caster->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_CANNOT_CAST_STIFFLED); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if (caster->IsFeared() && !spell->CastWhileFeared()) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s cannot cast (feared).", caster->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_CANNOT_CAST_FEARED); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if(caster->IsPlayer() && !IsReady(spell, caster)) { LogWrite(SPELL__DEBUG, 1, "Spell", "Queuing spell for %s.", caster->GetName()); bool queueSpell = CheckSpellQueue(spell, caster); if(!queueSpell) { lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); } return; } if (target_type != SPELL_TARGET_SELF && target_type != SPELL_TARGET_GROUP_AE && spell_type != SPELL_TYPE_ALLGROUPTARGETS && target_type != SPELL_TARGET_NONE && spell->GetSpellData()->max_aoe_targets == 0) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Not Self, Not Group AE, Not None, Max Targets = 0", spell->GetName()); if (!target) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: No target.", spell->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NO_ELIGIBLE_TARGET); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } float tmpRange = spell->GetSpellData()->range; if (client && target != caster && !spell->GetSpellData()->range) { bool match = false; int tmpTier = 0; Spell* tmpSpell = 0; for (tmpTier = 0; tmpTier < spell->GetSpellTier(); tmpTier++) { tmpSpell = master_spell_list.GetSpell(spell->GetSpellData()->id, tmpTier); if (tmpSpell && tmpSpell->GetSpellData()->range) { match = true; break; } } if (tmpSpell) tmpRange = tmpSpell->GetSpellData()->range; if (!match) tmpTier = -1; char msg[512]; snprintf(msg, 512, "SpellCasted without proper spell range set %s ID %i Tier %i Range obtained from tier %i range %f", spell->GetName(), spell->GetSpellID(), spell->GetSpellTier(), tmpTier, tmpRange); if (!world.CheckTempBugCRC(msg)) commands.Command_ReportBug(client, new Seperator(msg)); } if(caster->GetDistance(target) > tmpRange) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Too far.", spell->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_TOO_FAR_AWAY); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if (caster->GetDistance(target) < spell->GetSpellData()->min_range) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Too close.", spell->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_TOO_CLOSE); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } } if(target_type == SPELL_TARGET_SELF && spell->GetSpellData()->max_aoe_targets == 0) { if (harvest_spell) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Harvest, Target Self, Max Targets = 0", spell->GetName()); if (!target || !target->IsGroundSpawn()) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: No target or not groundspawn.", spell->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NO_ELIGIBLE_TARGET); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } } else { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Target '%s' is Caster '%s'.", spell->GetName(), ( target ) ? target->GetName() : "None", caster->GetName()); target = caster; } } // Is enemy spell AND direct-damage (no AE) if (target_type == SPELL_TARGET_ENEMY && spell->GetSpellData()->max_aoe_targets == 0) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Target Enemy (%s) and Max AE Targets = 0.", spell->GetName(), target->GetName()); if((spell->GetSpellData()->friendly_spell && caster != target && (caster->IsPlayer() || caster->IsBot()) && (target->IsPlayer() || target->IsBot()) && ((Entity*)target)->GetInfoStruct()->get_engaged_encounter()) && ((!((Entity*)caster)->GetGroupMemberInfo() || !((Entity*)target)->GetGroupMemberInfo()) || (((Entity*)caster)->GetGroupMemberInfo()->group_id != ((Entity*)target)->GetGroupMemberInfo()->group_id))) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Target (%s) is engaged in combat and cannot be assisted.", spell->GetName(), target->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_A_FRIEND); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } else if (spell->GetSpellData()->friendly_spell && target->IsPlayer() ) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Is Friendly, Target is Player (%s).", spell->GetName(), target->GetName()); if (!target->IsEntity()) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: No target.", spell->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NO_ELIGIBLE_TARGET); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } /*if (target->appearance.attackable) { zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_A_FRIEND); return; }*/ } else if (spell->GetSpellData()->friendly_spell && target->IsNPC() && target->appearance.attackable) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Is Not Friendly (friendly and NPC)", spell->GetName()); if (target->IsPet()) { if (((NPC*)target)->GetOwner() && ((NPC*)target)->GetOwner()->IsNPC()) { zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_A_FRIEND); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } } else if(((Entity*)target)->GetInfoStruct()->get_friendly_target_npc()) { // it's a bypass! } else if (target->IsBot() && (caster->IsPlayer() || caster->IsBot())) { // Needed so bots or player can cast friendly spells on bots } else if (caster->IsNPC()) { // npcs can cast on other npcs } else { zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_A_FRIEND); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } } else if (spell->GetSpellData()->friendly_spell && target->IsNPC() && caster->IsNPC()) { // TODO: faction checks? some other checks to prevent an npc casting a friendly spell on another npc LogWrite(SPELL__DEBUG, 1, "Spell", "%s: NPC Cast", spell->GetName()); } else { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Is Not Friendly (catch all)", spell->GetName()); if (!target->IsEntity()) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: No target.", spell->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NO_ELIGIBLE_TARGET); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if (caster == target || (!target->IsPlayer() && !target->appearance.attackable)) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Not an Enemy (Target: %s).", spell->GetName(), target->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_AN_ENEMY); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if (!target->Alive()) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Target is not alive (Target: %s).", spell->GetName(), target->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_ALIVE); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if (target->GetInvulnerable()) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Target is invulnerable (Target: %s).", spell->GetName(), target->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_TARGET_INVULNERABLE); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } bool attackAllowed = (Entity*)caster->AttackAllowed((Entity*)target, 0); if (!attackAllowed) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Target (%s) is player and not attackable.", spell->GetName(), target->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_AN_ENEMY); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if (target->IsPet() && ((NPC*)target)->GetOwner() && ((NPC*)target)->GetOwner() == caster) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s: Target (%s) is casters pet and not attackable by caster.", spell->GetName(), target->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_AN_ENEMY); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } } } if (lua_spell->targets.size() == 0 && spell->GetSpellData()->max_aoe_targets == 0) { LogWrite(SPELL__ERROR, 0, "Spell", "SpellProcess::ProcessSpell Unable to find any spell targets for spell '%s', spell type: %u, target type %u.", spell->GetName(), spell->GetSpellData()->spell_type, spell->GetSpellData()->target_type); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if(target_type == SPELL_TARGET_ENEMY_CORPSE || target_type == SPELL_TARGET_GROUP_CORPSE) { if(target->Alive()) { zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_DEAD); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if(target->IsPlayer() && ((Player*)target)->GetClient() && ((Player*)target)->GetClient()->GetCurrentRez()->active){ zone->SendSpellFailedPacket(client, SPELL_ERROR_ALREADY_CAST); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } } if(!CheckPower(lua_spell)) { LogWrite(SPELL__WARNING, 1, "Spell", "%s: Caster Lacked Power to cast (%s).", spell->GetName(), caster->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_ENOUGH_POWER); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if (!CheckHP(lua_spell)) { LogWrite(SPELL__WARNING, 1, "Spell", "%s: Caster Lacked Health to cast (%s).", spell->GetName(), caster->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_ENOUGH_HEALTH); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if (!CheckSavagery(lua_spell)) { LogWrite(SPELL__WARNING, 1, "Spell", "%s: Caster Lacked Savagery to cast (%s).", spell->GetName(), caster->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_ENOUGH_SAVAGERY); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if (!CheckDissonance(lua_spell)) { LogWrite(SPELL__WARNING, 1, "Spell", "%s: Caster Lacked Dissonance to cast (%s).", spell->GetName(), caster->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_ENOUGH_DISSONANCE); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } if (!CheckConcentration(lua_spell)) { LogWrite(SPELL__WARNING, 1, "Spell", "%s: Caster Lacked Concentration to cast (%s).", spell->GetName(), caster->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_NOT_ENOUGH_CONC); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } // Precast in lua if (lua_interface) { bool result = false; lua_interface->AddSpawnPointers(lua_spell, false, true); if (lua_pcall(lua_spell->state, 2, 2, 0) == 0) { result = lua_interface->GetBooleanValue(lua_spell->state, 1); int8 error = lua_interface->GetInt8Value(lua_spell->state, 2) == 0 ? SPELL_ERROR_CANNOT_PREPARE : lua_interface->GetInt8Value(lua_spell->state, 2); lua_interface->ResetFunctionStack(lua_spell->state); if (!result) { zone->SendSpellFailedPacket(client, error); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } } else { LogWrite(SPELL__DEBUG, 1, "Spell", "No precast function found for %s", lua_spell->spell->GetName()); lua_interface->ResetFunctionStack(lua_spell->state); } } else LogWrite(SPELL__DEBUG, 1, "Spell", "Unable to do precast check as there was no lua_interface"); if (custom_cast_time > 0) { spell->GetSpellData()->orig_cast_time = custom_cast_time; spell->GetSpellData()->cast_time = custom_cast_time; } //Apply casting speed mod spell->ModifyCastTime(caster); //cancel stealth effects on cast if(caster->IsStealthed() || caster->IsInvis()) caster->CancelAllStealth(); if(caster && caster->IsEntity() && caster->CheckFizzleSpell(lua_spell)) { caster->GetZone()->SendCastSpellPacket(0, target ? target : caster, caster); caster->GetZone()->SendInterruptPacket(caster, lua_spell, true); caster->IsCasting(false); if(caster->IsPlayer()) { ((Player*)caster)->UnlockSpell(spell); SendSpellBookUpdate(((Player*)caster)->GetClient()); } // fizzle takes half int16 power_req = spell->GetPowerRequired(caster) / 2; TakePower(lua_spell, power_req); int16 hp_req = spell->GetHPRequired(caster) / 2; TakeHP(lua_spell, hp_req); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } SendStartCast(lua_spell, client); LockAllSpells(client); if(spell->GetSpellData()->cast_time > 0) { CastTimer* cast_timer = new CastTimer; cast_timer->entity_command = 0; cast_timer->target_id = target ? target->GetID() : 0; cast_timer->spell = lua_spell; cast_timer->spell->caster = caster; cast_timer->delete_timer = false; cast_timer->timer = new Timer(spell->GetSpellData()->cast_time * 10); cast_timer->zone = zone; cast_timer->in_heroic_opp = in_heroic_opp; cast_timers.Add(cast_timer); if(caster) caster->IsCasting(true); } else { if(!CastProcessedSpell(lua_spell, false, in_heroic_opp)) { lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); return; } } if(caster) caster->GetZone()->SendCastSpellPacket(lua_spell, caster); } } void SpellProcess::ProcessEntityCommand(ZoneServer* zone, EntityCommand* entity_command, Entity* caster, Spawn* target, bool lock, bool in_heroic_opp) { if (zone && entity_command && caster && target && !target->IsPlayer()) { Client* client = ((Player*)caster)->GetClient(); if(!client) { return; } if (caster->GetDistance(target) > entity_command->distance) { zone->SendSpellFailedPacket(client, SPELL_ERROR_TOO_FAR_AWAY); return; } if (entity_command->cast_time > 0) { PacketStruct* packet = configReader.getStruct("WS_StartCastSpell", client->GetVersion()); if (packet) { LockAllSpells(client); packet->setDataByName("cast_time", entity_command->cast_time * 0.01); packet->setMediumStringByName("spell_name", entity_command->name.c_str()); EQ2Packet* outapp = packet->serialize(); client->QueuePacket(outapp); safe_delete(packet); CastTimer* cast_timer = new CastTimer; cast_timer->caster = client; cast_timer->target_id = target ? target->GetID() : 0; cast_timer->entity_command = entity_command; cast_timer->spell = 0; cast_timer->delete_timer = false; cast_timer->timer = new Timer(entity_command->cast_time * 10); cast_timer->zone = zone; cast_timer->in_heroic_opp = in_heroic_opp; cast_timers.Add(cast_timer); caster->IsCasting(true); } } else if (!CastProcessedEntityCommand(entity_command, client, target, in_heroic_opp)) return; if (entity_command && entity_command->spell_visual > 0) caster->GetZone()->SendCastEntityCommandPacket(entity_command, caster->GetID(), target->GetID()); } } bool SpellProcess::CastProcessedSpell(LuaSpell* spell, bool passive, bool in_heroic_opp){ if(!spell || !spell->caster || !spell->spell || spell->interrupted) return false; Client* client = 0; if(spell->caster && spell->caster->IsPlayer()) client = ((Player*)spell->caster)->GetClient(); if (spell->spell->GetSpellData()->max_aoe_targets > 0 && spell->targets.size() == 0) { GetSpellTargetsTrueAOE(spell); if (spell->targets.size() == 0) { if(client) { client->GetPlayer()->UnlockAllSpells(true); SendSpellBookUpdate(client); } spell->caster->GetZone()->SendSpellFailedPacket(client, SPELL_ERROR_NO_TARGETS_IN_RANGE); return false; } } if(client && client->GetCurrentZone() && !spell->spell->GetSpellData()->friendly_spell) { ZoneServer* zone = client->GetCurrentZone(); Spawn* tmpTarget = zone->GetSpawnByID(spell->initial_target); int8 spell_type = spell->spell->GetSpellData()->spell_type; LuaSpell* conflictSpell = spell->caster->HasLinkedTimerID(spell, tmpTarget, (spell_type == SPELL_TYPE_DD || spell_type == SPELL_TYPE_DOT)); if(conflictSpell && tmpTarget && tmpTarget->IsEntity()) { ((Entity*)tmpTarget)->RemoveSpellEffect(conflictSpell); zone->RemoveTargetFromSpell(conflictSpell, tmpTarget); } } MutexList::iterator itr = active_spells.begin(); bool processedSpell = false; bool allTargets = (spell->spell->GetSpellData()->spell_type == SPELL_TYPE_ALLGROUPTARGETS); if (!processedSpell) processedSpell = ProcessSpell(spell, true, 0, 0, allTargets); // Quick hack to prevent a crash on spells that zones the caster (Gate) if (!spell->caster) return true; Skill* skill = spell->caster->GetSkillByID(spell->spell->GetSpellData()->mastery_skill, false); // trigger potential skill increase if we succeed in casting a mastery skill and it still has room to grow (against this spell) if(skill && skill->current_val < spell->spell->GetSpellData()->min_class_skill_req) spell->caster->GetSkillByID(spell->spell->GetSpellData()->mastery_skill, true); ZoneServer* zone = spell->caster->GetZone(); Spawn* target = 0; if(processedSpell){ for (int32 i = 0; i < spell->targets.size(); i++) { target = zone->GetSpawnByID(spell->targets[i]); if (!target) continue; if (client && client->IsZoning()) continue; // TODO: Establish actual hate per spell if (!spell->spell->GetSpellData()->friendly_spell && target->IsNPC()) ((NPC*)target)->AddHate((Entity*)spell->caster, 50); if(spell->spell->GetSpellData()->success_message.length() > 0){ if(client){ string success_message = spell->spell->GetSpellData()->success_message; if(success_message.find("%t") != string::npos) success_message.replace(success_message.find("%t"), 2, spell->caster->GetName()); client->Message(CHANNEL_SPELLS, success_message.c_str()); } } if(spell->spell->GetSpellData()->effect_message.length() > 0){ string effect_message = spell->spell->GetSpellData()->effect_message; bool send_to_sender = true; if(effect_message.find("%t") != string::npos) effect_message.replace(effect_message.find("%t"), 2, target->GetName()); if (effect_message.find("%c") != string::npos) effect_message.replace(effect_message.find("%c"), 2, spell->caster->GetName()); if (effect_message.find("%T") != string::npos) { effect_message.replace(effect_message.find("%T"), 2, target->GetName()); send_to_sender = false; } if (effect_message.find("%C") != string::npos) { effect_message.replace(effect_message.find("%C"), 2, spell->caster->GetName()); send_to_sender = false; } if(spell->caster && spell->caster->GetZone()) { spell->caster->GetZone()->SimpleMessage(CHANNEL_SPELLS_OTHER, effect_message.c_str(), target, 50, send_to_sender); } } if(target->GetZone()) { target->GetZone()->CallSpawnScript(target, SPAWN_SCRIPT_CASTED_ON, spell->caster, spell->spell->GetName()); } } } else{ if (!passive) SendFinishedCast(spell, client); return false; } if(!spell->resisted && (spell->spell->GetSpellDuration() > 0 || spell->spell->GetSpellData()->duration_until_cancel || spell->spell->GetSpellData()->spell_book_type == SPELL_BOOK_TYPE_NOT_SHOWN)) { for (int32 i = 0; i < spell->targets.size(); i++) { //LogWrite(SPELL__ERROR, 0, "Spell", "No precast function found for %s", ((Entity*)target)->GetName()); target = zone->GetSpawnByID(spell->targets.at(i)); if (!target && spell->targets.at(i) == spell->caster->GetID()) { target = spell->caster; } if (!target) { if(client) { client->SimpleMessage(CHANNEL_COLOR_YELLOW, "Zone has not finished loading process yet. Try again later."); } continue; } if (i == 0 && !spell->spell->GetSpellData()->not_maintained) { spell->caster->AddMaintainedSpell(spell); } SpellEffects* effect = ((Entity*)target)->GetSpellEffect(spell->spell->GetSpellID()); if (effect && effect->tier > spell->spell->GetSpellTier()) { if(client) { spell->caster->GetZone()->SendSpellFailedPacket(client, SPELL_ERROR_TAKE_EFFECT_MOREPOWERFUL); client->SimpleMessage(CHANNEL_COLOR_YELLOW, "The spell did not take hold as the target already has a better spell of this type."); } } else{ ((Entity*)target)->AddSpellEffect(spell); if(spell->spell->GetSpellData()->det_type > 0) ((Entity*)target)->AddDetrimentalSpell(spell); } } active_spells.Add(spell); if (spell->num_triggers > 0) ClientPacketFunctions::SendMaintainedExamineUpdate(client, spell->slot_pos, spell->num_triggers, 0); if (spell->damage_remaining > 0) ClientPacketFunctions::SendMaintainedExamineUpdate(client, spell->slot_pos, spell->damage_remaining, 1); spell->caster->GetZone()->TriggerCharSheetTimer(); } spell->num_calls = 1; if(!spell->resisted && spell->spell->GetSpellData()->duration1 > 0){ spell->timer.Start(); if(spell->spell->GetSpellData()->call_frequency > 0) spell->timer.SetTimer(spell->spell->GetSpellData()->call_frequency*100); else spell->timer.SetTimer(spell->spell->GetSpellData()->duration1*100); if (active_spells.count(spell) < 1) { active_spells.Add(spell); } } // if the caster is a player and the spell is a tradeskill spell check for a tradeskill event if (client && spell->spell->GetSpellData()->spell_book_type == SPELL_BOOK_TYPE_TRADESKILL) { spell->resisted = (spell->caster->DetermineHit(target ? target : spell->caster, DAMAGE_PACKET_TYPE_SPELL_DAMAGE, 255, 0, true, spell) == DAMAGE_PACKET_RESULT_RESIST); client->GetCurrentZone()->GetTradeskillMgr()->CheckTradeskillEvent(client, spell->resisted ? 0 : spell->spell->GetSpellData()->icon); } if (spell->spell->GetSpellData()->friendly_spell && zone->GetSpawnByID(spell->initial_target)) spell->caster->CheckProcs(PROC_TYPE_BENEFICIAL, zone->GetSpawnByID(spell->initial_target)); // Check HO's if (client && !in_heroic_opp) { HeroicOP* ho = nullptr; Spell* ho_spell = nullptr; int32 ho_target = 0; MSoloHO.writelock(__FUNCTION__, __LINE__); MGroupHO.writelock(__FUNCTION__, __LINE__); map::iterator soloItr = m_soloHO.find(client); if (soloItr != m_soloHO.end()) { ho = soloItr->second; bool match = false; LogWrite(SPELL__DEBUG, 0, "HO", "target = %u", ho->GetTarget()); spell->MSpellTargets.readlock(__FUNCTION__, __LINE__); for (int8 i = 0; i < spell->targets.size(); i++) { LogWrite(SPELL__DEBUG, 0, "HO", "Target ID: %u", spell->targets.at(i)); if (spell->targets.at(i) == ho->GetTarget() || spell->spell->GetSpellData()->friendly_spell) { match = true; LogWrite(SPELL__DEBUG, 0, "HO", "match found"); break; } } spell->MSpellTargets.releasereadlock(__FUNCTION__, __LINE__); if(match && !spell->spell) LogWrite(SPELL__ERROR, 0, "HO", "%s: spell->spell is nullptr", client->GetPlayer()->GetName()); else if (match && spell->spell && ho->UpdateHeroicOP(spell->spell->GetSpellIconHeroicOp())) { ClientPacketFunctions::SendHeroicOPUpdate(client, ho); if (ho->GetComplete() > 0) { if(!ho->GetWheel()) LogWrite(SPELL__ERROR, 0, "HO", "%s: Wheel is inactive (nullptr) cannot check for invalid spell", client->GetPlayer()->GetName()); else { ho_spell = master_spell_list.GetSpell(ho->GetWheel()->spell_id, 1); ho_target = ho->GetTarget(); if (!ho_spell) LogWrite(SPELL__ERROR, 0, "HO", "%s: Invalid spell for a HO, spell id = %u", client->GetPlayer()->GetName(), ho->GetWheel()->spell_id); safe_delete(ho); m_soloHO.erase(soloItr); } } } } else if (client->GetPlayer()->GetGroupMemberInfo()) { map::iterator groupItr = m_groupHO.find(client->GetPlayer()->GetGroupMemberInfo()->group_id); if (groupItr != m_groupHO.end()) { ho = groupItr->second; int32 group_id = client->GetPlayer()->GetGroupMemberInfo()->group_id; spell->MSpellTargets.readlock(__FUNCTION__, __LINE__); if (((spell->targets.size() > 0 && spell->targets.at(0) == ho->GetTarget()) || spell->spell->GetSpellData()->friendly_spell) && ho->UpdateHeroicOP(spell->spell->GetSpellIconHeroicOp())) { spell->MSpellTargets.releasereadlock(__FUNCTION__, __LINE__); world.GetGroupManager()->GroupLock(__FUNCTION__, __LINE__); deque::iterator itr; PlayerGroup* group = world.GetGroupManager()->GetGroup(group_id); if (group) { group->MGroupMembers.readlock(__FUNCTION__, __LINE__); deque* members = group->GetMembers(); for (itr = members->begin(); itr != members->end(); itr++) { if ((*itr)->client) ClientPacketFunctions::SendHeroicOPUpdate((*itr)->client, ho); } group->MGroupMembers.releasereadlock(__FUNCTION__, __LINE__); } world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__); if (ho->GetComplete() > 0) { ho_spell = master_spell_list.GetSpell(ho->GetWheel()->spell_id, 1); ho_target = ho->GetTarget(); if (!ho_spell) LogWrite(SPELL__ERROR, 0, "HO", "Invalid spell for a HO, spell id = %u", ho->GetWheel()->spell_id); safe_delete(ho); m_groupHO.erase(groupItr); } } else spell->MSpellTargets.releasereadlock(__FUNCTION__, __LINE__); } } MGroupHO.releasewritelock(__FUNCTION__, __LINE__); MSoloHO.releasewritelock(__FUNCTION__, __LINE__); if (ho_spell && ho_target != 0) client->GetCurrentZone()->ProcessSpell(ho_spell, client->GetPlayer(), spell->caster->GetZone()->GetSpawnByID(ho_target)); } if (spell->spell->GetSpellData()->friendly_spell == 1 && spell->initial_target) spell->caster->CheckProcs(PROC_TYPE_BENEFICIAL, spell->caster->GetZone()->GetSpawnByID(spell->initial_target)); if (!passive) SendFinishedCast(spell, client); return true; } bool SpellProcess::CastProcessedEntityCommand(EntityCommand* entity_command, Client* client, Spawn* target, bool in_heroic_opp) { bool ret = false; if (entity_command && client) { UnlockAllSpells(client); client->GetPlayer()->IsCasting(false); if (entity_command->cast_time == 0) { client->GetPlayer()->GetZone()->CallSpawnScript(target, SPAWN_SCRIPT_CASTED_ON, client->GetPlayer(), entity_command->command.c_str()); ret = true; } if (!ret) { PacketStruct* packet = configReader.getStruct("WS_FinishCastSpell", client->GetVersion()); if (packet) { packet->setMediumStringByName("spell_name", entity_command->name.c_str()); client->QueuePacket(packet->serialize()); safe_delete(packet); SendSpellBookUpdate(client); client->GetPlayer()->GetZone()->CallSpawnScript(target, SPAWN_SCRIPT_CASTED_ON, client->GetPlayer(), entity_command->command.c_str()); ret = true; } } if (ret) { EQ2_16BitString command; command.data = entity_command->command; command.size = entity_command->command.length(); int32 handler = commands.GetCommandHandler(command.data.c_str()); if (handler != 0xFFFFFFFF && handler < 999) commands.Process(handler, &command, client, target); } } return ret; } void SpellProcess::Interrupted(Entity* caster, Spawn* interruptor, int16 error_code, bool cancel, bool from_movement) { if(caster) { LogWrite(SPELL__DEBUG, 0, "Spell", "'%s' is Interrupting spell of '%s'...", interruptor ? interruptor->GetName() : "unknown", caster->GetName()); LuaSpell* spell = GetLuaSpell(caster); if (spell && ((from_movement && !spell->spell->GetSpellData()->cast_while_moving) || (!from_movement && spell->spell->GetSpellData()->interruptable) || cancel)) { Spawn* target = GetSpellTarget(caster); InterruptStruct* interrupt = new InterruptStruct; interrupt->interrupted = caster; interrupt->spell = spell; interrupt->target = target; interrupt->error_code = error_code; spell->interrupted = true; interrupt_list.Add(interrupt); Client* client = 0; if(interruptor && interruptor->IsPlayer()) { client = ((Player*)interruptor)->GetClient(); if(client) { client->Message(CHANNEL_SPELLS_OTHER, "You interrupt %s's ability to cast!", caster->GetName()); } } } } } void SpellProcess::RemoveSpellTimersFromSpawn(Spawn* spawn, bool remove_all, bool delete_recast, bool call_expire_function, bool lock_spell_process){ if(lock_spell_process) MSpellProcess.lock_shared(); int32 i = 0; if(cast_timers.size() > 0){ CastTimer* cast_timer = 0; MutexList::iterator itr = cast_timers.begin(); while(itr.Next()){ cast_timer = itr->value; if(cast_timer && cast_timer->spell && cast_timer->spell->caster == spawn){ cast_timer->spell->caster = 0; cast_timer->delete_timer = true; } } } if(remove_all){ LuaSpell* spell = 0; MutexList::iterator itr = active_spells.begin(); while(itr.Next()){ spell = itr->value; if (!spell) continue; if(spell->caster == spawn && call_expire_function){ DeleteCasterSpell(spell, "expired", remove_all, nullptr, false, lock_spell_process); continue; } if (spell->spell->GetSpellData()->persist_through_death) continue; bool foundMatch = false; spell->MSpellTargets.readlock(__FUNCTION__, __LINE__); for (i = 0; i < spell->targets.size(); i++){ if (spawn->GetID() == spell->targets.at(i)){ foundMatch = true; break; } } spell->MSpellTargets.releasereadlock(__FUNCTION__, __LINE__); if(foundMatch) { if (spawn->IsEntity()) ((Entity*)spawn)->RemoveSpellEffect(spell); RemoveTargetFromSpell(spell, spawn, remove_all); } } if(recast_timers.size() > 0 && delete_recast){ RecastTimer* recast_timer = 0; MutexList::iterator itr = recast_timers.begin(); while(itr.Next()){ recast_timer = itr->value; if(recast_timer && recast_timer->caster == spawn){ safe_delete(recast_timer->timer); recast_timers.Remove(recast_timer, true); } } } if(spell_que.size() > 0 && spawn->IsEntity()){ spell_que.erase((Entity*)spawn); } if(interrupt_list.size() > 0){ InterruptStruct* interrupt = 0; MutexList::iterator itr = interrupt_list.begin(); while(itr.Next()){ interrupt = itr->value; if(interrupt && interrupt->interrupted == spawn){ interrupt_list.Remove(interrupt, true); } } } } if(lock_spell_process) MSpellProcess.unlock_shared(); } void SpellProcess::GetSpellTargets(LuaSpell* luaspell) { if (luaspell && luaspell->spell && luaspell->caster && luaspell->spell->GetSpellData()->max_aoe_targets == 0) { int8 target_type = luaspell->spell->GetSpellData()->target_type; int8 spell_type = luaspell->spell->GetSpellData()->spell_type; Spawn* caster = luaspell->caster; Spawn* target = caster->GetZone()->GetSpawnByID(luaspell->initial_target); SpellData* data = luaspell->spell->GetSpellData(); bool implied = false; Spawn* secondary_target = nullptr; //implied target check -- only use this for players if (target && (target_type == SPELL_TARGET_ENEMY || target_type == SPELL_TARGET_ENEMY_CORPSE || target_type == SPELL_TARGET_GROUP_CORPSE || target_type == SPELL_TARGET_OTHER_GROUP_AE)) { if (caster->IsPlayer() && target->HasTarget()) { secondary_target = target->GetTarget(); // check if spell is friendly if (data->friendly_spell) { //if target is NPC (and not a bot) on friendly spell, check to see if target is friendly if (target->IsNPC() && !((Entity*)target)->GetInfoStruct()->get_friendly_target_npc() && !target->IsBot()) { if (!target->IsPet() || (target->IsPet() && ((NPC*)target)->GetOwner() && ((NPC*)target)->GetOwner()->IsNPC())) { if (secondary_target && secondary_target->IsPlayer()) { target = secondary_target; luaspell->initial_target = target->GetID(); luaspell->initial_target_char_id = (target && target->IsPlayer()) ? ((Player*)target)->GetCharacterID() : 0; AddLuaSpellTarget(luaspell, target->GetID()); } else if (secondary_target && secondary_target->IsPet() && ((NPC*)secondary_target)->GetOwner() && ((NPC*)secondary_target)->GetOwner()->IsPlayer()) implied = true; } else if (target->IsPet() && ((Entity*)target)->GetOwner()->IsPlayer()) { luaspell->initial_target = target->GetID(); luaspell->initial_target_char_id = (target && target->IsPlayer()) ? ((Player*)target)->GetCharacterID() : 0; AddLuaSpellTarget(luaspell, target->GetID()); } } } // if spell is not friendly else { // check if there is an implied target for this non-friendly spell if (target->IsPlayer() || (target->IsPet() && ((NPC*)target)->GetOwner() && ((NPC*)target)->GetOwner()->IsPlayer())) { if (secondary_target && secondary_target->IsNPC()) { if (!secondary_target->IsPet() || (secondary_target->IsPet() && ((NPC*)secondary_target)->GetOwner() && ((NPC*)secondary_target)->GetOwner()->IsNPC())) { implied = true; } } else if (target->IsPlayer() && ((Entity*)caster)->AttackAllowed((Entity*)target)) { secondary_target = target; implied = true; luaspell->initial_target = target->GetID(); luaspell->initial_target_char_id = (target && target->IsPlayer()) ? ((Player*)target)->GetCharacterID() : 0; AddLuaSpellTarget(luaspell, target->GetID()); GetPlayerGroupTargets((Player*)target, caster, luaspell); } else if (secondary_target && target->IsPlayer() && ((Entity*)caster)->AttackAllowed((Entity*)secondary_target)) { implied = true; luaspell->initial_target = secondary_target->GetID(); luaspell->initial_target_char_id = (secondary_target && secondary_target->IsPlayer()) ? ((Player*)secondary_target)->GetCharacterID() : 0; AddLuaSpellTarget(luaspell, secondary_target->GetID()); GetPlayerGroupTargets((Player*)secondary_target, caster, luaspell); } } } // end friendly spell check } else if (caster->IsPlayer()) { if (data->friendly_spell) { if (target->IsNPC() && !target->IsBot()) { if (!((Entity*)target)->GetInfoStruct()->get_friendly_target_npc() && (!target->IsPet() || (target->IsPet() && ((NPC*)target)->GetOwner() && ((NPC*)target)->GetOwner()->IsNPC()))) { target = caster; luaspell->initial_target = caster->GetID(); luaspell->initial_target_char_id = (caster && caster->IsPlayer()) ? ((Player*)caster)->GetCharacterID() : 0; } } } else { if (target->IsPlayer() && ((Entity*)caster)->AttackAllowed((Entity*)target)) { luaspell->initial_target = target->GetID(); luaspell->initial_target_char_id = (target && target->IsPlayer()) ? ((Player*)target)->GetCharacterID() : 0; AddLuaSpellTarget(luaspell, target->GetID()); } } } } else if (target_type == SPELL_TARGET_GROUP_AE || spell_type == SPELL_TYPE_ALLGROUPTARGETS || target_type == SPELL_TARGET_RAID_AE) { // player handling if (target) { if (data->icon_backdrop == 316 || data->icon_backdrop == 312) // using TARGET backdrop icon { // PLAYER LOGIC: if ((data->friendly_spell && (target->IsPlayer() && luaspell->caster->IsPlayer() && target != luaspell->caster && ((Player*)target)->GetGroupMemberInfo() != NULL && ((Player*)luaspell->caster)->GetGroupMemberInfo() != NULL && ((Player*)target)->GetGroupMemberInfo()->group_id == ((Player*)luaspell->caster)->GetGroupMemberInfo()->group_id)) || (!data->friendly_spell && (target->IsPlayer() && luaspell->caster->IsPlayer() && target != luaspell->caster && ((Player*)target)->GetGroupMemberInfo() != NULL))) { GetPlayerGroupTargets((Player*)target, caster, luaspell, true, false); } //TODO: NEED RAID SUPPORT // NPC LOGIC: else if (target->IsNPC()) { // Check to see if the npc is a spawn group by getting the group and checikng if valid vector* group = ((NPC*)target)->GetSpawnGroup(); if (group) { vector::iterator itr; // iterate through spawn group members for (itr = group->begin(); itr != group->end(); itr++) { Spawn* group_member = *itr; // if NPC group member is (still) an NPC (wtf?) and is alive, send the NPC group member back as a successful target of non-friendly spell group_member->Alive() if (group_member->GetZone() == caster->GetZone() && group_member->IsNPC() && (data->friendly_spell || ((Entity*)caster)->AttackAllowed((Entity*)group_member)) && group_member->Alive() && !((Entity*)group_member)->IsAOEImmune() && (!((Entity*)group_member)->IsMezzed() || group_member == target)) AddLuaSpellTarget(luaspell, group_member->GetID()); // note: this should generate some hate towards the caster } } // end is spawngroup else if(data->friendly_spell || ((Entity*)caster)->AttackAllowed((Entity*)target)) AddLuaSpellTarget(luaspell, target->GetID()); // return single target NPC for non-friendly spell } else if(data->friendly_spell) { // add self target = NULL; AddSelfAndPet(luaspell, caster); luaspell->initial_target = caster->GetID(); luaspell->initial_target_char_id = (caster && caster->IsPlayer()) ? ((Player*)caster)->GetCharacterID() : 0; } else if(target && target->IsPlayer()) { if(!GetPlayerGroupTargets((Player*)target, caster, luaspell, true, false) && ((Entity*)caster)->AttackAllowed((Entity*)target)) AddSelfAndPet(luaspell, target); } } else // default self cast for group/raid AE { target = caster; luaspell->initial_target = caster->GetID(); luaspell->initial_target_char_id = (caster && caster->IsPlayer()) ? ((Player*)caster)->GetCharacterID() : 0; } // spell target versus self cast } else if (data->icon_backdrop != 316) // default self cast for group/raid AE and not using TARGET backdrop icon { target = caster; luaspell->initial_target = caster->GetID(); luaspell->initial_target_char_id = (caster && caster->IsPlayer()) ? ((Player*)caster)->GetCharacterID() : 0; } } else if (target_type == SPELL_TARGET_SELF){ target = caster; luaspell->initial_target = caster->GetID(); luaspell->initial_target_char_id = (caster && caster->IsPlayer()) ? ((Player*)caster)->GetCharacterID() : 0; } //if using implied target, target = the implied target if (implied) { target = secondary_target; luaspell->initial_target = secondary_target->GetID(); luaspell->initial_target_char_id = (secondary_target && secondary_target->IsPlayer()) ? ((Player*)secondary_target)->GetCharacterID() : 0; } luaspell->MSpellTargets.writelock(__FUNCTION__, __LINE__); // Group AE type NOTE: Add support for RAID AE to affect raid members once raids have been completed if (target_type == SPELL_TARGET_GROUP_AE || spell_type == SPELL_TYPE_ALLGROUPTARGETS || target_type == SPELL_TARGET_RAID_AE) { if (data->icon_backdrop == 316) // single target in a group/raid { if (target) AddLuaSpellTarget(luaspell, target->GetID(), false); } // is friendly else if (data->friendly_spell) { // caster is an Entity if (luaspell->caster->IsEntity()) { // entity caster is in a player group if (((Entity*)caster)->GetGroupMemberInfo()) { world.GetGroupManager()->GroupLock(__FUNCTION__, __LINE__); // get group members PlayerGroup* group = world.GetGroupManager()->GetGroup(((Entity*)caster)->GetGroupMemberInfo()->group_id); if (group) { group->MGroupMembers.readlock(__FUNCTION__, __LINE__); deque* members = group->GetMembers(); deque::iterator itr; // iterate through list of group members for (itr = members->begin(); itr != members->end(); itr++) { // get group member player info Entity* group_member = (*itr)->member; if(!group_member){ continue; } LogWrite(SPELL__DEBUG, 0, "Player", "%s is group member for spell %s", group_member->GetName(), luaspell->spell->GetName()); // if the group member is in the casters zone, and is alive if( group_member->Alive()) { if(group_member->GetZone() != caster->GetZone()) { SpellProcess::AddSelfAndPetToCharTargets(luaspell, group_member); } else if (group_member->GetZone() == luaspell->caster->GetZone()) { AddLuaSpellTarget(luaspell, group_member->GetID(), false); if (group_member->HasPet()) { Entity* pet = group_member->GetPet(); if (!pet) pet = group_member->GetCharmedPet(); if (pet) AddLuaSpellTarget(luaspell, pet->GetID(), false); LogWrite(SPELL__DEBUG, 0, "Player", "%s added a pet %s (%u) for spell %s", group_member->GetName(), pet ? pet->GetName() : "", pet ? pet->GetID() : 0, luaspell->spell->GetName()); } } } } group->MGroupMembers.releasereadlock(__FUNCTION__, __LINE__); } world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__); } else AddSelfAndPet(luaspell, caster); // else caster is not in a group, thus alone } else if (caster->IsNPC()) // caster is NOT a player { // caster is NPC and in a spawn group with other NPCs vector* group = ((NPC*)caster)->GetSpawnGroup(); if (group) { vector::iterator itr; for (itr = group->begin(); itr != group->end(); itr++) { Spawn* group_member = *itr; if (group_member->IsNPC() && group_member->Alive() && ((Entity*)caster)->AttackAllowed(((Entity*)group_member))){ AddLuaSpellTarget(luaspell, group_member->GetID(), false); if (((Entity*)group_member)->HasPet()){ Entity* pet = ((Entity*)group_member)->GetPet(); if (pet) AddLuaSpellTarget(luaspell, pet->GetID(), false); pet = ((Entity*)group_member)->GetCharmedPet(); if (pet) AddLuaSpellTarget(luaspell, pet->GetID(), false); } } } } else AddSelfAndPet(luaspell, caster); safe_delete(group); } // end is player } // end is friendly } // end is Group AE else if (target_type == SPELL_TARGET_SELF && caster) AddLuaSpellTarget(luaspell, caster->GetID(), false); // if spell is SELF, return caster else if (target_type == SPELL_TARGET_CASTER_PET && caster && caster->IsEntity() && ((Entity*)caster)->HasPet()) { AddSelfAndPet(luaspell, caster, true); } else if (target_type == SPELL_TARGET_ENEMY && target && target->Alive()) // if target is enemy, and is alive { // if friendly spell if (data->friendly_spell > 0) { // if caster is a player if (caster->IsPlayer()) { // if spell can affect raid, only group members or is a group spell if (data->can_effect_raid > 0 || data->affect_only_group_members > 0 || data->group_spell > 0) { // if caster is in a group, and target is a player and targeted player is a group member if (((Player*)caster)->GetGroupMemberInfo() && (target->IsPlayer() || target->IsBot() || target->IsPet()) && ((Player*)caster)->IsGroupMember((Entity*)target)) AddLuaSpellTarget(luaspell, target->GetID(), false); // return the target else AddLuaSpellTarget(luaspell, caster->GetID(), false); // else return the caster } else if (target->IsPlayer() || target->IsBot() || (target->IsNPC() && ((Entity*)target)->GetInfoStruct()->get_friendly_target_npc())) // else it is not raid, group only or group spell AddLuaSpellTarget(luaspell, target->GetID(), false); // return target for single spell else if ((luaspell->targets.size() < 1) || (!target->IsPet() || (((Entity*)target)->GetOwner() && !((Entity*)target)->GetOwner()->IsPlayer()))) AddLuaSpellTarget(luaspell, caster->GetID(), false); // and if no target, cast on self } else if (caster->IsNPC()) // caster is an NPC { // if NPC's spell can affect raid, only group members or is a group spell if (data->can_effect_raid > 0 || data->affect_only_group_members > 0 || data->group_spell > 0) { if (caster->IsBot() && (target->IsBot() || target->IsPlayer())) { GroupMemberInfo* gmi = ((Entity*)caster)->GetGroupMemberInfo(); if (gmi && target->IsEntity() && world.GetGroupManager()->IsInGroup(gmi->group_id, (Entity*)target)) { AddLuaSpellTarget(luaspell, target->GetID(), false); // return the target } else AddSelfAndPet(luaspell, caster); } // if NPC caster is in a group, and target is a player and targeted player is a group member else if (((NPC*)caster)->HasSpawnGroup() && target->IsNPC() && ((NPC*)caster)->IsInSpawnGroup((NPC*)target)) AddLuaSpellTarget(luaspell, target->GetID(), false); // return the target else AddSelfAndPet(luaspell, caster); } else if (target->IsNPC()) AddLuaSpellTarget(luaspell, target->GetID(), false); // return target for single spell else { if (caster->IsBot() && (target->IsBot() || target->IsPlayer())) AddLuaSpellTarget(luaspell, target->GetID(), false); else AddLuaSpellTarget(luaspell, caster->GetID(), false); // and if no target, cast on self } } // end is player } // end is friendly else if (target && (data->group_spell > 0 || data->icon_backdrop == 312)) // is not friendly, but is a group spell, icon_backdrop 312 is green (encounter AE) { // target is non-player if (target->IsNPC()) { // Check to see if the npc is a spawn group by getting the group and checikng if valid vector* group = ((NPC*)target)->GetSpawnGroup(); if (group) { vector::iterator itr; // iterate through spawn group members for (itr = group->begin(); itr != group->end(); itr++) { Spawn* group_member = *itr; // if NPC group member is (still) an NPC (wtf?) and is alive, send the NPC group member back as a successful target of non-friendly spell group_member->Alive() if (group_member->GetZone() == caster->GetZone() && group_member->IsNPC() && group_member->Alive() && ((Entity*)caster)->AttackAllowed((Entity*)group_member) && !((Entity*)group_member)->IsAOEImmune() && (!((Entity*)group_member)->IsMezzed() || group_member == target)) AddLuaSpellTarget(luaspell, group_member->GetID(), false); // note: this should generate some hate towards the caster } } // end is spawngroup else AddLuaSpellTarget(luaspell, target->GetID(), false); // return single target NPC for non-friendly spell safe_delete(group); } // end is NPC else if (target->IsPlayer() && caster->IsNPC()) // the NPC is casting on a player { // player is in a group if (((Player*)target)->GetGroupMemberInfo()) { world.GetGroupManager()->GroupLock(__FUNCTION__, __LINE__); deque::iterator itr; PlayerGroup* group = world.GetGroupManager()->GetGroup(((Player*)target)->GetGroupMemberInfo()->group_id); if (group) { group->MGroupMembers.readlock(__FUNCTION__, __LINE__); deque* members = group->GetMembers(); // iterate through players group members for (itr = members->begin(); itr != members->end(); itr++) { Entity* group_member = (*itr)->member; // if the group member is in the same zone as caster, and group member is alive, and group member is within distance if (group_member && group_member->GetZone() == caster->GetZone() && group_member->Alive() && caster->GetDistance(group_member) <= data->range && (group_member == target || !group_member->IsAOEImmune())) AddLuaSpellTarget(luaspell, group_member->GetID(), false); // add as target } group->MGroupMembers.releasereadlock(__FUNCTION__, __LINE__); } world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__); } else AddLuaSpellTarget(luaspell, target->GetID(), false); // player not in group } // end is caster player or npc } else if (target) AddLuaSpellTarget(luaspell, target->GetID(), false); // is not friendly nor a group spell } //Rez spells else if(target && target_type == SPELL_TARGET_ENEMY_CORPSE){ //is friendly if(data->friendly_spell){ //target is player if(target->IsPlayer()){ AddLuaSpellTarget(luaspell, target->GetID(), false); } } } else if(target_type == SPELL_TARGET_GROUP_CORPSE){ //is friendly if(data->friendly_spell){ //target is player if(target && target->IsPlayer()){ //if target has group if(((Player*)target)->GetGroupMemberInfo()) { world.GetGroupManager()->GroupLock(__FUNCTION__, __LINE__); deque::iterator itr; PlayerGroup* group = world.GetGroupManager()->GetGroup(((Player*)target)->GetGroupMemberInfo()->group_id); if (group) { group->MGroupMembers.readlock(__FUNCTION__, __LINE__); deque* members = group->GetMembers(); Entity* group_member = 0; for (itr = members->begin(); itr != members->end(); itr++) { group_member = (*itr)->member; //Check if group member is in the same zone in range of the spell and dead if (group_member && group_member->GetZone() == target->GetZone() && !group_member->Alive() && target->GetDistance(group_member) <= data->radius) { AddLuaSpellTarget(luaspell, group_member->GetID(), false); } } group->MGroupMembers.releasereadlock(__FUNCTION__, __LINE__); } world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__); } else AddLuaSpellTarget(luaspell, target->GetID(), false); } } } luaspell->MSpellTargets.releasewritelock(__FUNCTION__, __LINE__); } if (luaspell && luaspell->targets.size() > 20) LogWrite(SPELL__WARNING, 0, "Spell", "Warning in %s: Size of targets array is %u", __FUNCTION__, luaspell->targets.size()); } bool SpellProcess::GetPlayerGroupTargets(Player* target, Spawn* caster, LuaSpell* luaspell, bool bypassSpellChecks, bool bypassRangeChecks) { if (bypassSpellChecks || luaspell->spell->GetSpellData()->group_spell > 0 || luaspell->spell->GetSpellData()->icon_backdrop == 312) { if (((Player*)target)->GetGroupMemberInfo()) { PlayerGroup* group = world.GetGroupManager()->GetGroup(((Player*)target)->GetGroupMemberInfo()->group_id); if (group) { group->MGroupMembers.readlock(__FUNCTION__, __LINE__); deque* members = group->GetMembers(); deque::iterator itr; GroupMemberInfo* info = 0; for (itr = members->begin(); itr != members->end(); itr++) { info = *itr; if (info == ((Player*)target)->GetGroupMemberInfo()) continue; else if (info && info->client && info->client->GetPlayer()->GetZone() == ((Player*)target)->GetZone() && info->client->GetPlayer()->Alive() && (bypassRangeChecks || caster->GetDistance((Entity*)info->client->GetPlayer()) <= luaspell->spell->GetSpellData()->range)) { AddSelfAndPet(luaspell, info->client->GetPlayer()); } } group->MGroupMembers.releasereadlock(__FUNCTION__, __LINE__); return true; } } } return false; } void SpellProcess::GetSpellTargetsTrueAOE(LuaSpell* luaspell) { if (luaspell && luaspell->caster && luaspell->spell && luaspell->spell->GetSpellData()->max_aoe_targets > 0) { if (luaspell->caster->HasTarget() && luaspell->caster->GetTarget() != luaspell->caster){ //Check if the caster has an implied target if (luaspell->caster->GetDistance(luaspell->caster->GetTarget()) <= luaspell->spell->GetSpellData()->radius) { luaspell->initial_target = luaspell->caster->GetTarget()->GetID(); luaspell->initial_target_char_id = (luaspell->caster->GetTarget() && luaspell->caster->GetTarget()->IsPlayer()) ? ((Player*)luaspell->caster->GetTarget())->GetCharacterID() : 0; } } int32 ignore_target = 0; vector spawns = luaspell->caster->GetZone()->GetAttackableSpawnsByDistance(luaspell->caster, luaspell->spell->GetSpellData()->radius); luaspell->MSpellTargets.writelock(__FUNCTION__, __LINE__); for (int8 i = 0; i < spawns.size(); i++) { if (i == 0){ Spawn* spawn = luaspell->caster->GetZone()->GetSpawnByID(luaspell->initial_target); if (spawn && luaspell->initial_target && luaspell->caster->GetID() != luaspell->initial_target && luaspell->caster->AttackAllowed((Entity*)spawn)){ //this is the "Direct" target and aoe can't be avoided AddLuaSpellTarget(luaspell, luaspell->initial_target, false); ignore_target = luaspell->initial_target; } } if (luaspell->targets.size() >= luaspell->spell->GetSpellData()->max_aoe_targets) break; int32 target_id = spawns.at(i); Spawn* spawn = luaspell->caster->GetZone()->GetSpawnByID(target_id); if(!spawn) { LogWrite(SPELL__ERROR, 0, "Spell", "Error: Spell target is NULL! SpellProcess::ProcessSpell for Spell '%s' target id %u", (luaspell->spell != nullptr) ? luaspell->spell->GetName() : "Unknown", target_id); } //If we have already added this spawn, check the next spawn in the list if (spawn && spawn->GetID() == ignore_target || (spawn->IsEntity() && !luaspell->caster->AttackAllowed((Entity*)spawn))){ continue; } if (spawn){ //If this spawn is immune to aoe, continue if (((Entity*)spawn)->IsAOEImmune() || ((Entity*)spawn)->IsMezzed()) continue; AddLuaSpellTarget(luaspell, spawn->GetID(), false); } if (luaspell->targets.size() >= luaspell->spell->GetSpellData()->max_aoe_targets) break; } luaspell->MSpellTargets.releasewritelock(__FUNCTION__, __LINE__); } if (luaspell->targets.size() > 20) LogWrite(SPELL__DEBUG, 0, "Spell", "Warning in SpellProcess::GetSpellTargetsTrueAOE Size of targets array is %u", luaspell->targets.size()); } void SpellProcess::AddSpellScriptTimer(SpellScriptTimer* timer) { MSpellScriptTimers.writelock(__FUNCTION__, __LINE__); m_spellScriptList.push_back(timer); MSpellScriptTimers.releasewritelock(__FUNCTION__, __LINE__); } void SpellProcess::RemoveSpellScriptTimer(SpellScriptTimer* timer, bool locked) { if (m_spellScriptList.size() == 0) return; vector::iterator itr; if(!locked) MSpellScriptTimers.writelock(__FUNCTION__, __LINE__); for (itr = m_spellScriptList.begin(); itr != m_spellScriptList.end(); itr++) { if ((*itr) == timer) { SpellScriptTimer* timer = *itr; if ((*itr) && (*itr)->deleteWhenDone && lua_interface) { lua_interface->AddPendingSpellDelete(timer->spell); } m_spellScriptList.erase(itr); safe_delete(timer); break; } } if(!locked) MSpellScriptTimers.releasewritelock(__FUNCTION__, __LINE__); } void SpellProcess::RemoveSpellScriptTimerBySpell(LuaSpell* spell, bool clearPendingDeletes) { vector::iterator itr; MSpellScriptTimers.writelock(__FUNCTION__, __LINE__); if (lua_interface && clearPendingDeletes) lua_interface->DeletePendingSpell(spell); if (m_spellScriptList.size() == 0) { MSpellScriptTimers.releasewritelock(__FUNCTION__, __LINE__); return; } for (itr = m_spellScriptList.begin(); itr != m_spellScriptList.end(); ) { if ((*itr)->spell == spell) { vector::iterator cur = itr; SpellScriptTimer* timer = *itr; m_spellScriptList.erase(cur); safe_delete(timer); break; } else itr++; } MSpellScriptTimers.releasewritelock(__FUNCTION__, __LINE__); } void SpellProcess::CheckSpellScriptTimers() { vector::iterator itr; vector temp_list; MSpellScriptTimers.writelock(__FUNCTION__, __LINE__); for (itr = m_spellScriptList.begin(); itr != m_spellScriptList.end(); itr++) { if (Timer::GetCurrentTime2() >= (*itr)->time) { temp_list.push_back((*itr)); ProcessSpell((*itr)->spell, false, (*itr)->customFunction.c_str(), (*itr)); } } for (itr = temp_list.begin(); itr != temp_list.end(); itr++) { RemoveSpellScriptTimer(*itr, true); } MSpellScriptTimers.releasewritelock(__FUNCTION__, __LINE__); } bool SpellProcess::SpellScriptTimersHasSpell(LuaSpell* spell) { bool ret = false; vector::iterator itr; MSpellScriptTimers.readlock(__FUNCTION__, __LINE__); for (itr = m_spellScriptList.begin(); itr != m_spellScriptList.end(); itr++) { SpellScriptTimer* timer = *itr; if (timer && timer->spell == spell) { ret = true; break; } } MSpellScriptTimers.releasereadlock(__FUNCTION__, __LINE__); return ret; } std::string SpellProcess::SpellScriptTimerCustomFunction(LuaSpell* spell) { bool ret = false; std::string val = string(""); vector::iterator itr; MSpellScriptTimers.readlock(__FUNCTION__, __LINE__); for (itr = m_spellScriptList.begin(); itr != m_spellScriptList.end(); itr++) { SpellScriptTimer* timer = *itr; if (timer && timer->spell == spell) { val = string(timer->customFunction); break; } } MSpellScriptTimers.releasereadlock(__FUNCTION__, __LINE__); return val; } void SpellProcess::ClearSpellScriptTimerList() { vector::iterator itr; MSpellScriptTimers.writelock(__FUNCTION__, __LINE__); for(itr = m_spellScriptList.begin(); itr != m_spellScriptList.end(); itr++) { if ((*itr) && (*itr)->deleteWhenDone && lua_interface) lua_interface->AddPendingSpellDelete((*itr)->spell); safe_delete((*itr)); } m_spellScriptList.clear(); MSpellScriptTimers.releasewritelock(__FUNCTION__, __LINE__); } void SpellProcess::RemoveTargetFromSpell(LuaSpell* spell, Spawn* target, bool removeCaster){ if (!spell || !target) return; LogWrite(SPELL__DEBUG, 0, "Spell", "%s RemoveTargetFromSpell %s (%u).", spell->spell->GetName(), target->GetName(), target->GetID()); MRemoveTargetList.writelock(__FUNCTION__, __LINE__); if(removeCaster && spell->caster && spell->caster == target) spell->caster = nullptr; if (!remove_target_list[spell]) remove_target_list[spell] = new vector; remove_target_list[spell]->push_back(target->GetID()); MRemoveTargetList.releasewritelock(__FUNCTION__, __LINE__); } void SpellProcess::CheckRemoveTargetFromSpell(LuaSpell* spell, bool allow_delete, bool removing_all_spells){ if (!spell) return; MRemoveTargetList.writelock(__FUNCTION__, __LINE__); if (remove_target_list.size() > 0){ map*>::iterator remove_itr; vector::iterator remove_target_itr; vector::iterator target_itr; vector* targets; vector* remove_targets = 0; Spawn* remove_spawn = 0; bool should_delete = false; for (remove_itr = remove_target_list.begin(); remove_itr != remove_target_list.end(); remove_itr++){ if (remove_itr->first == spell){ targets = &spell->targets; remove_targets = remove_itr->second; if (remove_targets && targets){ spell->MSpellTargets.writelock(__FUNCTION__, __LINE__); for (remove_target_itr = remove_targets->begin(); remove_target_itr != remove_targets->end(); remove_target_itr++){ if(!spell->caster || !spell->caster->GetZone()) continue; remove_spawn = spell->caster->GetZone()->GetSpawnByID((*remove_target_itr)); if (remove_spawn) { if(remove_spawn && remove_spawn->IsPlayer()) { multimap::iterator entries; while((entries = spell->char_id_targets.find(((Player*)remove_spawn)->GetCharacterID())) != spell->char_id_targets.end()) { spell->char_id_targets.erase(entries); } } for (target_itr = targets->begin(); target_itr != targets->end(); target_itr++) { if (remove_spawn->GetID() == (*target_itr)) { ((Entity*)remove_spawn)->RemoveProc(0, spell); ((Entity*)remove_spawn)->RemoveMaintainedSpell(spell); LogWrite(SPELL__DEBUG, 0, "Spell", "%s CheckRemoveTargetFromSpell %s (%u).", spell->spell->GetName(), remove_spawn->GetName(), remove_spawn->GetID()); targets->erase(target_itr); if (remove_spawn->IsEntity()) { if(!removing_all_spells) { if(remove_spawn->IsPlayer()) spell->char_id_targets.insert(make_pair(((Player*)remove_spawn)->GetCharacterID(),0)); else if(remove_spawn->IsPet() && ((Entity*)remove_spawn)->GetOwner() && ((Entity*)remove_spawn)->GetOwner()->IsPlayer()) { Entity* pet = (Entity*)remove_spawn; Player* ownerPlayer = (Player*)pet->GetOwner(); spell->char_id_targets.insert(make_pair(ownerPlayer->GetCharacterID(),pet->GetPetType())); } } ((Entity*)remove_spawn)->RemoveEffectsFromLuaSpell(spell); } break; } } if (targets->size() == 0 && spell->char_id_targets.size() == 0 && allow_delete) { spell->MSpellTargets.releasewritelock(__FUNCTION__, __LINE__); should_delete = true; break; } } } spell->MSpellTargets.releasewritelock(__FUNCTION__, __LINE__); } break; } } remove_target_list.erase(spell); if (remove_targets) remove_targets->clear(); safe_delete(remove_targets); MRemoveTargetList.releasewritelock(__FUNCTION__, __LINE__); if (should_delete) DeleteCasterSpell(spell, "purged"); } else { MRemoveTargetList.releasewritelock(__FUNCTION__, __LINE__); } } bool SpellProcess::AddHO(Client* client, HeroicOP* ho) { bool ret = true; if (client && ho) { MSoloHO.writelock(__FUNCTION__, __LINE__); if (m_soloHO.count(client) > 0) { if (m_soloHO[client]->GetWheel()) { ret = false; } else { safe_delete(m_soloHO[client]); m_soloHO[client] = ho; } } else m_soloHO[client] = ho; MSoloHO.releasewritelock(__FUNCTION__, __LINE__); } return ret; } bool SpellProcess::AddHO(int32 group_id, HeroicOP* ho) { bool ret = true; if (group_id > 0 && ho) { MGroupHO.writelock(__FUNCTION__, __LINE__); if (m_groupHO.count(group_id) > 0) { if (m_groupHO[group_id]->GetWheel()) { ret = false; } else { safe_delete(m_groupHO[group_id]); m_groupHO[group_id] = ho; } } else m_groupHO[group_id] = ho; MGroupHO.releasewritelock(__FUNCTION__, __LINE__); } return ret; } void SpellProcess::KillHOBySpawnID(int32 spawn_id) { // Check solo HO's MSoloHO.writelock(__FUNCTION__, __LINE__); map::iterator itr = m_soloHO.begin(); map::iterator delete_itr; while (itr != m_soloHO.end()) { if (itr->second->GetTarget() == spawn_id) { itr->second->SetComplete(1); ClientPacketFunctions::SendHeroicOPUpdate(itr->first, itr->second); delete_itr = itr; safe_delete(itr->second); itr++; m_soloHO.erase(delete_itr); } else itr++; } MSoloHO.releasewritelock(__FUNCTION__, __LINE__); // Check Group HO's MGroupHO.writelock(__FUNCTION__, __LINE__); map::iterator itr2 = m_groupHO.begin(); map::iterator delete_itr2; while (itr2 != m_groupHO.end()) { if (itr2->second->GetTarget() == spawn_id) { itr2->second->SetComplete(1); world.GetGroupManager()->GroupLock(__FUNCTION__ , __LINE__); deque::iterator itr3; PlayerGroup* group = world.GetGroupManager()->GetGroup(itr2->first); if (group) { group->MGroupMembers.readlock(__FUNCTION__, __LINE__); deque* members = group->GetMembers(); for (itr3 = members->begin(); itr3 != members->end(); itr3++) { if ((*itr3)->client) ClientPacketFunctions::SendHeroicOPUpdate((*itr3)->client, itr2->second); } group->MGroupMembers.releasereadlock(__FUNCTION__, __LINE__); } world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__); delete_itr2 = itr2; safe_delete(itr2->second); itr2++; m_groupHO.erase(delete_itr2); } else itr2++; } MGroupHO.releasewritelock(__FUNCTION__, __LINE__); } void SpellProcess::AddSpellCancel(LuaSpell* spell){ MSpellCancelList.writelock(__FUNCTION__, __LINE__); SpellCancelList.push_back(spell); MSpellCancelList.releasewritelock(__FUNCTION__, __LINE__); } void SpellProcess::DeleteSpell(LuaSpell* spell) { RemoveSpellFromQueue(spell->spell, spell->caster); if (spell->spell->IsCopiedSpell()) { lua_interface->RemoveCustomSpell(spell->spell->GetSpellID()); safe_delete(spell->spell); } lua_interface->SetLuaUserDataStale(spell); lua_interface->RemoveCurrentSpell(spell->state, true); DeleteActiveSpell(spell); } void SpellProcess::SpellCannotStack(ZoneServer* zone, Client* client, Entity* caster, LuaSpell* lua_spell, LuaSpell* conflictSpell) { LogWrite(SPELL__DEBUG, 1, "Spell", "%s cannot stack spell %s, conflicts with %s.", caster->GetName(), lua_spell->spell->GetName(), conflictSpell->spell->GetName()); zone->SendSpellFailedPacket(client, SPELL_ERROR_TAKE_EFFECT_MOREPOWERFUL); lua_spell->caster->GetZone()->GetSpellProcess()->RemoveSpellScriptTimerBySpell(lua_spell); DeleteSpell(lua_spell); } void SpellProcess::AddActiveSpell(LuaSpell* spell) { if(!active_spells.count(spell)) active_spells.Add(spell); } void SpellProcess::AddSelfAndPet(LuaSpell* spell, Spawn* self, bool onlyPet) { if(!onlyPet) AddLuaSpellTarget(spell, self->GetID(), false); if(self->IsEntity() && ((Entity*)self)->HasPet() && ((Entity*)self)->GetPet()) AddLuaSpellTarget(spell, ((Entity*)self)->GetPet()->GetID(), false); if(self->IsEntity() && ((Entity*)self)->HasPet() && ((Entity*)self)->GetCharmedPet()) AddLuaSpellTarget(spell, ((Entity*)self)->GetCharmedPet()->GetID(), false); if(!onlyPet && self->IsEntity() && ((Entity*)self)->IsPet() && ((Entity*)self)->GetOwner()) AddLuaSpellTarget(spell, ((Entity*)self)->GetOwner()->GetID(), false); } void SpellProcess::AddSelfAndPetToCharTargets(LuaSpell* spell, Spawn* caster, bool onlyPet) { if(!caster->IsPlayer()) return; Player* player = ((Player*)caster); int32 charID = player->GetCharacterID(); if(player->HasPet() && player->GetPet()) spell->char_id_targets.insert(make_pair(charID, player->GetPet()->GetPetType())); if(player->HasPet() && player->GetCharmedPet()) spell->char_id_targets.insert(make_pair(charID, player->GetPet()->GetPetType())); if(!onlyPet) spell->char_id_targets.insert(make_pair(charID, 0x00)); } void SpellProcess::DeleteActiveSpell(LuaSpell* spell) { active_spells.Remove(spell, true); } bool SpellProcess::AddLuaSpellTarget(LuaSpell* lua_spell, int32 id, bool lock_spell_targets) { bool ret = false; if(lock_spell_targets) lua_spell->MSpellTargets.writelock(__FUNCTION__, __LINE__); if(std::find(lua_spell->targets.begin(), lua_spell->targets.end(), id) != lua_spell->targets.end()) { ret = true; } else if(std::find(lua_spell->removed_targets.begin(), lua_spell->removed_targets.end(), id) == lua_spell->removed_targets.end()) { lua_spell->targets.push_back(id); ret = true; } if(lock_spell_targets) lua_spell->MSpellTargets.releasewritelock(__FUNCTION__, __LINE__); return ret; }