/** * MaNGOS is a full featured server for World of Warcraft, supporting * the following clients: 1.12.x, 2.4.3, 3.3.5a, 4.3.4a and 5.4.8 * * Copyright (C) 2005-2016 MaNGOS project * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * World of Warcraft, and all World of Warcraft or Warcraft art, images, * and lore are copyrighted by Blizzard Entertainment, Inc. */ #include "Creature.h" #include "Database/DatabaseEnv.h" #include "WorldPacket.h" #include "World.h" #include "ObjectMgr.h" #include "ScriptMgr.h" #include "ObjectGuid.h" #include "SQLStorages.h" #include "SpellMgr.h" #include "QuestDef.h" #include "GossipDef.h" #include "Player.h" #include "GameEventMgr.h" #include "PoolManager.h" #include "Opcodes.h" #include "Log.h" #include "LootMgr.h" #include "MapManager.h" #include "CreatureAI.h" #include "CreatureAISelector.h" #include "Formulas.h" #include "WaypointMovementGenerator.h" #include "InstanceData.h" #include "MapPersistentStateMgr.h" #include "BattleGround/BattleGroundMgr.h" #include "OutdoorPvP/OutdoorPvP.h" #include "Spell.h" #include "Util.h" #include "GridNotifiers.h" #include "GridNotifiersImpl.h" #include "CellImpl.h" #include "movement/MoveSplineInit.h" #include "CreatureLinkingMgr.h" #ifdef ENABLE_ELUNA #include "LuaEngine.h" #endif /* ENABLE_ELUNA */ // apply implementation of the singletons #include "Policies/Singleton.h" TrainerSpell const* TrainerSpellData::Find(uint32 spell_id) const { TrainerSpellMap::const_iterator itr = spellList.find(spell_id); if (itr != spellList.end()) { return &itr->second; } return NULL; } bool VendorItemData::RemoveItem(uint32 item_id) { for (VendorItemList::iterator i = m_items.begin(); i != m_items.end(); ++i) { if ((*i)->item == item_id) { m_items.erase(i); return true; } } return false; } size_t VendorItemData::FindItemSlot(uint32 item_id) const { for (size_t i = 0; i < m_items.size(); ++i) if (m_items[i]->item == item_id) { return i; } return m_items.size(); } VendorItem const* VendorItemData::FindItem(uint32 item_id) const { for (VendorItemList::const_iterator i = m_items.begin(); i != m_items.end(); ++i) { // Skip checking for conditions, condition system is powerfull enough to not require additional entries only for the conditions if ((*i)->item == item_id) { return *i; } } return NULL; } bool ForcedDespawnDelayEvent::Execute(uint64 /*e_time*/, uint32 /*p_time*/) { m_owner.ForcedDespawn(); return true; } void CreatureCreatePos::SelectFinalPoint(Creature* cr) { // if object provided then selected point at specific dist/angle from object forward look if (m_closeObject) { if (m_dist == 0.0f) { m_pos.x = m_closeObject->GetPositionX(); m_pos.y = m_closeObject->GetPositionY(); m_pos.z = m_closeObject->GetPositionZ(); } else { m_closeObject->GetClosePoint(m_pos.x, m_pos.y, m_pos.z, cr->GetObjectBoundingRadius(), m_dist, m_angle); } } } bool CreatureCreatePos::Relocate(Creature* cr) const { cr->Relocate(m_pos.x, m_pos.y, m_pos.z, m_pos.o); if (!cr->IsPositionValid()) { sLog.outError("%s not created. Suggested coordinates isn't valid (X: %f Y: %f)", cr->GetGuidStr().c_str(), cr->GetPositionX(), cr->GetPositionY()); return false; } return true; } Creature::Creature(CreatureSubtype subtype) : Unit(), i_AI(NULL), loot(this), lootForPickPocketed(false), lootForBody(false), lootForSkin(false), m_groupLootTimer(0), m_groupLootId(0), m_lootMoney(0), m_lootGroupRecipientId(0), m_corpseRemoveTime(0), m_respawnTime(0), m_respawnDelay(25), m_corpseDelay(60), m_aggroDelay(0), m_respawnradius(5.0f), m_subtype(subtype), m_defaultMovementType(IDLE_MOTION_TYPE), m_equipmentId(0), m_AlreadyCallAssistance(false), m_AlreadySearchedAssistance(false), m_AI_locked(false), m_IsDeadByDefault(false), m_temporaryFactionFlags(TEMPFACTION_NONE), m_meleeDamageSchoolMask(SPELL_SCHOOL_MASK_NORMAL), m_originalEntry(0), m_creatureInfo(NULL), m_PlayerDamageReq(0) { /* Loot data */ hasBeenLootedOnce = false; assignedLooter = 0; m_killedTime = 0; m_regenTimer = 200; m_valuesCount = UNIT_END; for (int i = 0; i < CREATURE_MAX_SPELLS; ++i) { m_spells[i] = 0; } m_CreatureSpellCooldowns.clear(); m_CreatureCategoryCooldowns.clear(); DisableReputationGain = false; SetWalk(true, true); } Creature::~Creature() { CleanupsBeforeDelete(); m_vendorItemCounts.clear(); delete i_AI; i_AI = NULL; } void Creature::AddToWorld() { #ifdef ENABLE_ELUNA bool inWorld = IsInWorld(); #endif /* ENABLE_ELUNA */ ///- Register the creature for guid lookup if (!IsInWorld() && GetObjectGuid().IsCreature()) { GetMap()->GetObjectsStore().insert(GetObjectGuid(), (Creature*)this); } Unit::AddToWorld(); // Make active if required std::set const* mapList = sWorld.getConfigForceLoadMapIds(); if ((mapList && mapList->find(GetMapId()) != mapList->end()) || (GetCreatureInfo()->ExtraFlags & CREATURE_EXTRA_FLAG_ACTIVE)) { SetActiveObjectState(true); } #ifdef ENABLE_ELUNA if (!inWorld) sEluna->OnAddToWorld(this); #endif /* ENABLE_ELUNA */ } void Creature::RemoveFromWorld() { #ifdef ENABLE_ELUNA if (IsInWorld()) sEluna->OnRemoveFromWorld(this); #endif /* ENABLE_ELUNA */ ///- Remove the creature from the accessor if (IsInWorld() && GetObjectGuid().IsCreature()) { GetMap()->GetObjectsStore().erase(GetObjectGuid(), (Creature*)NULL); } Unit::RemoveFromWorld(); } void Creature::RemoveCorpse() { // since pool system can fail to roll unspawned object, this one can remain spawned, so must set respawn nevertheless if (uint16 poolid = sPoolMgr.IsPartOfAPool(GetGUIDLow())) { sPoolMgr.UpdatePool(*GetMap()->GetPersistentState(), poolid, GetGUIDLow()); } if (!IsInWorld()) // can be despawned by update pool { return; } if ((GetDeathState() != CORPSE && !m_IsDeadByDefault) || (GetDeathState() != ALIVE && m_IsDeadByDefault)) { return; } DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "Removing corpse of %s ", GetGuidStr().c_str()); m_corpseRemoveTime = time(NULL); SetDeathState(DEAD); UpdateObjectVisibility(); // stop loot rolling before loot clear and for close client dialogs StopGroupLoot(); loot.clear(); /* Loot data */ m_killedTime = 0; hasBeenLootedOnce = false; assignedLooter = 0; m_lootGroupRecipientId = 0; m_lootRecipientGuid.Clear(); RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TAPPED); uint32 respawnDelay = 0; if (AI()) { AI()->CorpseRemoved(respawnDelay); } if (m_isCreatureLinkingTrigger) GetMap()->GetCreatureLinkingHolder()->DoCreatureLinkingEvent(LINKING_EVENT_DESPAWN, this); if (InstanceData* mapInstance = GetInstanceData()) { mapInstance->OnCreatureDespawn(this); } // script can set time (in seconds) explicit, override the original if (respawnDelay) { m_respawnTime = time(NULL) + respawnDelay; } float x, y, z, o; GetRespawnCoord(x, y, z, &o); GetMap()->CreatureRelocation(this, x, y, z, o); // forced recreate creature object at clients UnitVisibility currentVis = GetVisibility(); SetVisibility(VISIBILITY_REMOVE_CORPSE); UpdateObjectVisibility(); SetVisibility(currentVis); // restore visibility state UpdateObjectVisibility(); } /** * change the entry of creature until respawn */ bool Creature::InitEntry(uint32 Entry, Team team, CreatureData const* data /*=NULL*/, GameEventCreatureData const* eventData /*=NULL*/) { // use game event entry if any instead default suggested if (eventData && eventData->entry_id) { Entry = eventData->entry_id; } CreatureInfo const* normalInfo = ObjectMgr::GetCreatureTemplate(Entry); if (!normalInfo) { sLog.outErrorDb("Creature::UpdateEntry creature entry %u does not exist.", Entry); return false; } CreatureInfo const* cinfo = normalInfo; SetEntry(Entry); // normal entry always m_creatureInfo = cinfo; // map mode related always SetObjectScale(cinfo->Scale); // equal to player Race field, but creature does not have race SetByteValue(UNIT_FIELD_BYTES_0, 0, 0); // known valid are: CLASS_WARRIOR,CLASS_PALADIN,CLASS_ROGUE,CLASS_MAGE SetByteValue(UNIT_FIELD_BYTES_0, 1, uint8(cinfo->UnitClass)); uint32 display_id = ChooseDisplayId(GetCreatureInfo(), data, eventData); if (!display_id) // Cancel load if no display id { sLog.outErrorDb("Creature (Entry: %u) has no model defined in table `creature_template`, can't load.", Entry); return false; } CreatureModelInfo const* minfo = sObjectMgr.GetCreatureModelRandomGender(display_id); if (!minfo) // Cancel load if no model defined { sLog.outErrorDb("Creature (Entry: %u) has no model info defined in table `creature_model_info`, can't load.", Entry); return false; } display_id = minfo->modelid; // it can be different (for another gender) SetNativeDisplayId(display_id); // special case for totems (model for team==HORDE is stored in creature_template as the default) if (team == ALLIANCE && cinfo->CreatureType == CREATURE_TYPE_TOTEM) { uint32 modelid_tmp = sObjectMgr.GetCreatureModelOtherTeamModel(display_id); display_id = modelid_tmp ? modelid_tmp : display_id; } // normally the same as native, see above for the exeption SetDisplayId(display_id); SetByteValue(UNIT_FIELD_BYTES_0, 2, minfo->gender); // set PowerType based on unit class switch (cinfo->UnitClass) { case CLASS_WARRIOR: SetPowerType(POWER_RAGE); break; case CLASS_PALADIN: case CLASS_MAGE: SetPowerType(POWER_MANA); break; case CLASS_ROGUE: SetPowerType(POWER_ENERGY); break; default: sLog.outErrorDb("Creature (Entry: %u) has unhandled unit class. Power type will not be set!", Entry); break; } // Load creature equipment if (eventData && eventData->equipment_id) { LoadEquipment(eventData->equipment_id); // use event equipment if any for active event } else if (!data || data->equipmentId == 0) { // use default from the template LoadEquipment(cinfo->EquipmentTemplateId); } else if (data && data->equipmentId != -1) { // override, -1 means no equipment LoadEquipment(data->equipmentId); } SetName(normalInfo->Name); // at normal entry always SetFloatValue(UNIT_MOD_CAST_SPEED, 1.0f); // update speed for the new CreatureInfo base speed mods UpdateSpeed(MOVE_WALK, false); UpdateSpeed(MOVE_RUN, false); SetLevitate(cinfo->InhabitType & INHABIT_AIR); // TODO: may not be correct to send opcode at this point (already handled by UPDATE_OBJECT createObject) // check if we need to add swimming movement. TODO: i thing movement flags should be computed automatically at each movement of creature so we need a sort of UpdateMovementFlags() method if (cinfo->InhabitType & INHABIT_WATER && // check inhabit type water data && // check if there is data to get creature spawn pos GetMap()->GetTerrain()->IsInWater(data->posX, data->posY, data->posZ)) // check if creature is in water m_movementInfo.AddMovementFlag(MOVEFLAG_SWIMMING); // add swimming movement // checked at loading m_defaultMovementType = MovementGeneratorType(cinfo->MovementType); return true; } bool Creature::UpdateEntry(uint32 Entry, Team team, const CreatureData* data /*=NULL*/, GameEventCreatureData const* eventData /*=NULL*/, bool preserveHPAndPower /*=true*/) { if (!InitEntry(Entry, team, data, eventData)) { return false; } // creatures always have melee weapon ready if any SetSheath(SHEATH_STATE_MELEE); SetByteValue(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_AURAS); SelectLevel(GetCreatureInfo(), preserveHPAndPower ? GetHealthPercent() : 100.0f); if (team == HORDE) { setFaction(GetCreatureInfo()->FactionHorde); } else { setFaction(GetCreatureInfo()->FactionAlliance); } SetUInt32Value(UNIT_NPC_FLAGS, GetCreatureInfo()->NpcFlags); uint32 attackTimer = GetCreatureInfo()->MeleeBaseAttackTime; SetAttackTime(BASE_ATTACK, attackTimer); SetAttackTime(OFF_ATTACK, attackTimer - attackTimer / 4); SetAttackTime(RANGED_ATTACK, GetCreatureInfo()->RangedBaseAttackTime); uint32 unitFlags = GetCreatureInfo()->UnitFlags; // we may need to append or remove additional flags if (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT)) { unitFlags |= UNIT_FLAG_IN_COMBAT; } SetUInt32Value(UNIT_FIELD_FLAGS, unitFlags); // preserve all current dynamic flags if exist uint32 dynFlags = GetUInt32Value(UNIT_DYNAMIC_FLAGS); SetUInt32Value(UNIT_DYNAMIC_FLAGS, dynFlags ? dynFlags : GetCreatureInfo()->DynamicFlags); SetModifierValue(UNIT_MOD_ARMOR, BASE_VALUE, float(GetCreatureInfo()->Armor)); SetModifierValue(UNIT_MOD_RESISTANCE_HOLY, BASE_VALUE, float(GetCreatureInfo()->ResistanceHoly)); SetModifierValue(UNIT_MOD_RESISTANCE_FIRE, BASE_VALUE, float(GetCreatureInfo()->ResistanceFire)); SetModifierValue(UNIT_MOD_RESISTANCE_NATURE, BASE_VALUE, float(GetCreatureInfo()->ResistanceNature)); SetModifierValue(UNIT_MOD_RESISTANCE_FROST, BASE_VALUE, float(GetCreatureInfo()->ResistanceFrost)); SetModifierValue(UNIT_MOD_RESISTANCE_SHADOW, BASE_VALUE, float(GetCreatureInfo()->ResistanceShadow)); SetModifierValue(UNIT_MOD_RESISTANCE_ARCANE, BASE_VALUE, float(GetCreatureInfo()->ResistanceArcane)); SetCanModifyStats(true); UpdateAllStats(); // checked and error show at loading templates if (FactionTemplateEntry const* factionTemplate = sFactionTemplateStore.LookupEntry(GetCreatureInfo()->FactionAlliance)) { if (factionTemplate->factionFlags & FACTION_TEMPLATE_FLAG_PVP) { SetPvP(true); } else { SetPvP(false); } } // Try difficulty dependend version before falling back to base entry CreatureTemplateSpells const* templateSpells = sCreatureTemplateSpellsStorage.LookupEntry(GetCreatureInfo()->Entry); if (!templateSpells) { templateSpells = sCreatureTemplateSpellsStorage.LookupEntry(GetEntry()); } if (templateSpells) for (int i = 0; i < CREATURE_MAX_SPELLS; ++i) { m_spells[i] = templateSpells->spells[i]; } // if eventData set then event active and need apply spell_start if (eventData) { ApplyGameEventSpells(eventData, true); } return true; } uint32 Creature::ChooseDisplayId(const CreatureInfo* cinfo, const CreatureData* data /*= NULL*/, GameEventCreatureData const* eventData /*=NULL*/) { // Use creature event model explicit, override any other static models if (eventData && eventData->modelid) { return eventData->modelid; } // Use creature model explicit, override template (creature.modelid) if (data && data->modelid_override) { return data->modelid_override; } // use defaults from the template uint32 display_id = 0; // model selected here may be replaced with other_gender using own function if (!cinfo->ModelId[1]) { display_id = cinfo->ModelId[0]; } else { display_id = cinfo->ModelId[urand(0, 1)]; } // fail safe, we use creature entry 1 and make error if (!display_id) { sLog.outErrorDb("Call customer support, ChooseDisplayId can not select native model for creature entry %u, model from creature entry 1 will be used instead.", cinfo->Entry); if (const CreatureInfo* creatureDefault = ObjectMgr::GetCreatureTemplate(1)) { display_id = creatureDefault->ModelId[0]; } } return display_id; } void Creature::Update(uint32 update_diff, uint32 diff) { switch (m_deathState) { case JUST_ALIVED: // Don't must be called, see Creature::SetDeathState JUST_ALIVED -> ALIVE promoting. sLog.outError("Creature (GUIDLow: %u Entry: %u ) in wrong state: JUST_ALIVED (4)", GetGUIDLow(), GetEntry()); break; case JUST_DIED: // Don't must be called, see Creature::SetDeathState JUST_DIED -> CORPSE promoting. sLog.outError("Creature (GUIDLow: %u Entry: %u ) in wrong state: JUST_DEAD (1)", GetGUIDLow(), GetEntry()); break; case DEAD: { if (m_respawnTime <= time(NULL) && (!m_isSpawningLinked || GetMap()->GetCreatureLinkingHolder()->CanSpawn(this))) { DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "Respawning..."); m_respawnTime = 0; m_aggroDelay = sWorld.getConfig(CONFIG_UINT32_CREATURE_RESPAWN_AGGRO_DELAY); lootForPickPocketed = false; lootForBody = false; lootForSkin = false; // Clear possible auras having IsDeathPersistent() attribute RemoveAllAuras(); if (m_originalEntry != GetEntry()) { // need preserver gameevent state GameEventCreatureData const* eventData = sGameEventMgr.GetCreatureUpdateDataForActiveEvent(GetGUIDLow()); UpdateEntry(m_originalEntry, TEAM_NONE, NULL, eventData); } CreatureInfo const* cinfo = GetCreatureInfo(); SelectLevel(cinfo); UpdateAllStats(); // to be sure stats is correct regarding level of the creature SetUInt32Value(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_NONE); if (m_IsDeadByDefault) { SetDeathState(JUST_DIED); SetHealth(0); i_motionMaster.Clear(); clearUnitState(UNIT_STAT_ALL_STATE); LoadCreatureAddon(true); } else { SetDeathState(JUST_ALIVED); } // Call AI respawn virtual function if (AI()) { AI()->JustRespawned(); } if (m_isCreatureLinkingTrigger) { GetMap()->GetCreatureLinkingHolder()->DoCreatureLinkingEvent(LINKING_EVENT_RESPAWN, this); } GetMap()->Add(this); } break; } case CORPSE: { Unit::Update(update_diff, diff); if (m_IsDeadByDefault) { break; } if (m_groupLootId) // Loot is stopped already if corpse got removed. { if (m_groupLootTimer <= update_diff) { StopGroupLoot(); } else { m_groupLootTimer -= update_diff; } } if (m_corpseRemoveTime <= time(NULL)) { RemoveCorpse(); } break; } case ALIVE: { if (m_aggroDelay <= update_diff) m_aggroDelay = 0; else m_aggroDelay -= update_diff; if (m_IsDeadByDefault) { if (m_corpseRemoveTime <= time(NULL)) { RemoveCorpse(); break; } } Unit::Update(update_diff, diff); // creature can be dead after Unit::Update call // CORPSE/DEAD state will processed at next tick (in other case death timer will be updated unexpectedly) if (!IsAlive()) { break; } if (!IsInEvadeMode()) { if (AI()) { // do not allow the AI to be changed during update m_AI_locked = true; AI()->UpdateAI(diff); // AI not react good at real update delays (while freeze in non-active part of map) m_AI_locked = false; } } // creature can be dead after UpdateAI call // CORPSE/DEAD state will processed at next tick (in other case death timer will be updated unexpectedly) if (!IsAlive()) { break; } RegenerateAll(update_diff); break; } default: break; } } void Creature::StartGroupLoot(Group* group, uint32 timer) { m_groupLootId = group->GetId(); m_groupLootTimer = timer; } void Creature::StopGroupLoot() { if (!m_groupLootId) { return; } if (Group* group = sObjectMgr.GetGroupById(m_groupLootId)) { group->EndRoll(); } m_groupLootTimer = 0; m_groupLootId = 0; } void Creature::RegenerateAll(uint32 update_diff) { if (m_regenTimer > 0) { if (update_diff >= m_regenTimer) { m_regenTimer = 0; } else { m_regenTimer -= update_diff; } } if (m_regenTimer != 0) { return; } if (!IsInCombat() || IsPolymorphed()) { RegenerateHealth(); } RegeneratePower(); m_regenTimer = REGEN_TIME_FULL; } void Creature::RegeneratePower() { if (!IsRegeneratingPower() && !IsPet()) return; Powers powerType = GetPowerType(); uint32 curValue = GetPower(powerType); uint32 maxValue = GetMaxPower(powerType); if (curValue >= maxValue) { return; } float addValue = 0.0f; switch (powerType) { case POWER_MANA: // Combat and any controlled creature if (IsInCombat() || GetCharmerOrOwnerGuid()) { if (!IsUnderLastManaUseEffect()) { float ManaIncreaseRate = sWorld.getConfig(CONFIG_FLOAT_RATE_POWER_MANA); float Spirit = GetStat(STAT_SPIRIT); addValue = (Spirit / 5.0f + 17.0f) * ManaIncreaseRate; } } else addValue = maxValue / 3.0f; break; case POWER_ENERGY: // ToDo: for vehicle this is different - NEEDS TO BE FIXED! addValue = 20 * sWorld.getConfig(CONFIG_FLOAT_RATE_POWER_ENERGY); break; case POWER_FOCUS: addValue = 24 * sWorld.getConfig(CONFIG_FLOAT_RATE_POWER_FOCUS); break; default: return; } // Apply modifiers (if any) AuraList const& ModPowerRegenAuras = GetAurasByType(SPELL_AURA_MOD_POWER_REGEN); for(AuraList::const_iterator i = ModPowerRegenAuras.begin(); i != ModPowerRegenAuras.end(); ++i) { Modifier const* modifier = (*i)->GetModifier(); if (modifier->m_miscvalue == int32(powerType)) { addValue += modifier->m_amount; } } AuraList const& ModPowerRegenPCTAuras = GetAurasByType(SPELL_AURA_MOD_POWER_REGEN_PERCENT); for(AuraList::const_iterator i = ModPowerRegenPCTAuras.begin(); i != ModPowerRegenPCTAuras.end(); ++i) { Modifier const* modifier = (*i)->GetModifier(); if (modifier->m_miscvalue == int32(powerType)) { addValue *= (modifier->m_amount + 100) / 100.0f; } } ModifyPower(powerType, int32(addValue)); } void Creature::RegenerateHealth() { if (!IsRegeneratingHealth()) { return; } uint32 curValue = GetHealth(); uint32 maxValue = GetMaxHealth(); if (curValue >= maxValue) { return; } uint32 addvalue = 0; // Not only pet, but any controlled creature if (GetCharmerOrOwnerGuid()) { float HealthIncreaseRate = sWorld.getConfig(CONFIG_FLOAT_RATE_HEALTH); float Spirit = GetStat(STAT_SPIRIT); if (GetPower(POWER_MANA) > 0) { addvalue = uint32(Spirit * 0.25 * HealthIncreaseRate); } else { addvalue = uint32(Spirit * 0.80 * HealthIncreaseRate); } } else { addvalue = maxValue / 3; } ModifyHealth(addvalue); } void Creature::DoFleeToGetAssistance() { if (!getVictim()) { return; } float radius = sWorld.getConfig(CONFIG_FLOAT_CREATURE_FAMILY_FLEE_ASSISTANCE_RADIUS); if (radius > 0) { Creature* pCreature = NULL; MaNGOS::NearestAssistCreatureInCreatureRangeCheck u_check(this, getVictim(), radius); MaNGOS::CreatureLastSearcher searcher(pCreature, u_check); Cell::VisitGridObjects(this, searcher, radius); SetNoSearchAssistance(true); UpdateSpeed(MOVE_RUN, false); if (!pCreature) { SetFeared(true, getVictim()->GetObjectGuid(), 0 , sWorld.getConfig(CONFIG_UINT32_CREATURE_FAMILY_FLEE_DELAY)); } else { SetTargetGuid(ObjectGuid()); // creature flee loose its target GetMotionMaster()->MoveSeekAssistance(pCreature->GetPositionX(), pCreature->GetPositionY(), pCreature->GetPositionZ()); } } } bool Creature::AIM_Initialize() { // make sure nothing can change the AI during AI update if (m_AI_locked) { DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "AIM_Initialize: failed to init, locked."); return false; } CreatureAI* oldAI = i_AI; i_motionMaster.Initialize(); i_AI = FactorySelector::selectAI(this); delete oldAI; return true; } bool Creature::Create(uint32 guidlow, CreatureCreatePos& cPos, CreatureInfo const* cinfo, Team team /*= TEAM_NONE*/, const CreatureData* data /*= NULL*/, GameEventCreatureData const* eventData /*= NULL*/) { SetMap(cPos.GetMap()); if (!CreateFromProto(guidlow, cinfo, team, data, eventData)) { return false; } cPos.SelectFinalPoint(this); if (!cPos.Relocate(this)) { return false; } // Notify the outdoor pvp script if (OutdoorPvP* outdoorPvP = sOutdoorPvPMgr.GetScript(GetZoneId())) { outdoorPvP->HandleCreatureCreate(this); } // Notify the map's instance data. // Only works if you create the object in it, not if it is moves to that map. // Normally non-players do not teleport to other maps. if (InstanceData* iData = GetMap()->GetInstanceData()) { iData->OnCreatureCreate(this); } switch (GetCreatureInfo()->Rank) { case CREATURE_ELITE_RARE: m_corpseDelay = sWorld.getConfig(CONFIG_UINT32_CORPSE_DECAY_RARE); break; case CREATURE_ELITE_ELITE: m_corpseDelay = sWorld.getConfig(CONFIG_UINT32_CORPSE_DECAY_ELITE); break; case CREATURE_ELITE_RAREELITE: m_corpseDelay = sWorld.getConfig(CONFIG_UINT32_CORPSE_DECAY_RAREELITE); break; case CREATURE_ELITE_WORLDBOSS: m_corpseDelay = sWorld.getConfig(CONFIG_UINT32_CORPSE_DECAY_WORLDBOSS); break; default: m_corpseDelay = sWorld.getConfig(CONFIG_UINT32_CORPSE_DECAY_NORMAL); break; } // Add to CreatureLinkingHolder if needed if (sCreatureLinkingMgr.GetLinkedTriggerInformation(this)) { cPos.GetMap()->GetCreatureLinkingHolder()->AddSlaveToHolder(this); } if (sCreatureLinkingMgr.IsLinkedEventTrigger(this)) { m_isCreatureLinkingTrigger = true; cPos.GetMap()->GetCreatureLinkingHolder()->AddMasterToHolder(this); } LoadCreatureAddon(false); return true; } bool Creature::IsTrainerOf(Player* pPlayer, bool msg) const { if (!IsTrainer()) { return false; } TrainerSpellData const* cSpells = GetTrainerSpells(); TrainerSpellData const* tSpells = GetTrainerTemplateSpells(); // for not pet trainer expected not empty trainer list always if ((!cSpells || cSpells->spellList.empty()) && (!tSpells || tSpells->spellList.empty())) { sLog.outErrorDb("Creature %u (Entry: %u) have UNIT_NPC_FLAG_TRAINER but have empty trainer spell list.", GetGUIDLow(), GetEntry()); return false; } switch (GetCreatureInfo()->TrainerType) { case TRAINER_TYPE_CLASS: if (pPlayer->getClass() != GetCreatureInfo()->TrainerClass) { if (msg) { pPlayer->PlayerTalkClass->ClearMenus(); switch (GetCreatureInfo()->TrainerClass) { case CLASS_DRUID: pPlayer->PlayerTalkClass->SendGossipMenu(4913, GetObjectGuid()); break; case CLASS_HUNTER: pPlayer->PlayerTalkClass->SendGossipMenu(10090, GetObjectGuid()); break; case CLASS_MAGE: pPlayer->PlayerTalkClass->SendGossipMenu(328, GetObjectGuid()); break; case CLASS_PALADIN: pPlayer->PlayerTalkClass->SendGossipMenu(1635, GetObjectGuid()); break; case CLASS_PRIEST: pPlayer->PlayerTalkClass->SendGossipMenu(4436, GetObjectGuid()); break; case CLASS_ROGUE: pPlayer->PlayerTalkClass->SendGossipMenu(4797, GetObjectGuid()); break; case CLASS_SHAMAN: pPlayer->PlayerTalkClass->SendGossipMenu(5003, GetObjectGuid()); break; case CLASS_WARLOCK: pPlayer->PlayerTalkClass->SendGossipMenu(5836, GetObjectGuid()); break; case CLASS_WARRIOR: pPlayer->PlayerTalkClass->SendGossipMenu(4985, GetObjectGuid()); break; } } return false; } break; case TRAINER_TYPE_PETS: if (pPlayer->getClass() != CLASS_HUNTER) { if (msg) { pPlayer->PlayerTalkClass->ClearMenus(); pPlayer->PlayerTalkClass->SendGossipMenu(3620, GetObjectGuid()); } return false; } break; case TRAINER_TYPE_MOUNTS: if (GetCreatureInfo()->TrainerRace && pPlayer->getRace() != GetCreatureInfo()->TrainerRace) { // Allowed to train if exalted if (FactionTemplateEntry const* faction_template = getFactionTemplateEntry()) { if (pPlayer->GetReputationRank(faction_template->faction) == REP_EXALTED) { return true; } } if (msg) { pPlayer->PlayerTalkClass->ClearMenus(); switch (GetCreatureInfo()->TrainerClass) { case RACE_DWARF: pPlayer->PlayerTalkClass->SendGossipMenu(5865, GetObjectGuid()); break; case RACE_GNOME: pPlayer->PlayerTalkClass->SendGossipMenu(4881, GetObjectGuid()); break; case RACE_HUMAN: pPlayer->PlayerTalkClass->SendGossipMenu(5861, GetObjectGuid()); break; case RACE_NIGHTELF: pPlayer->PlayerTalkClass->SendGossipMenu(5862, GetObjectGuid()); break; case RACE_ORC: pPlayer->PlayerTalkClass->SendGossipMenu(5863, GetObjectGuid()); break; case RACE_TAUREN: pPlayer->PlayerTalkClass->SendGossipMenu(5864, GetObjectGuid()); break; case RACE_TROLL: pPlayer->PlayerTalkClass->SendGossipMenu(5816, GetObjectGuid()); break; case RACE_UNDEAD: pPlayer->PlayerTalkClass->SendGossipMenu(624, GetObjectGuid()); break; } } return false; } break; case TRAINER_TYPE_TRADESKILLS: if (GetCreatureInfo()->TrainerSpell && !pPlayer->HasSpell(GetCreatureInfo()->TrainerSpell)) { if (msg) { pPlayer->PlayerTalkClass->ClearMenus(); pPlayer->PlayerTalkClass->SendGossipMenu(11031, GetObjectGuid()); } return false; } break; default: return false; // checked and error output at creature_template loading } return true; } bool Creature::CanInteractWithBattleMaster(Player* pPlayer, bool msg) const { if (!IsBattleMaster()) { return false; } BattleGroundTypeId bgTypeId = sBattleGroundMgr.GetBattleMasterBG(GetEntry()); if (bgTypeId == BATTLEGROUND_TYPE_NONE) { return false; } if (!msg) { return pPlayer->GetBGAccessByLevel(bgTypeId); } if (!pPlayer->GetBGAccessByLevel(bgTypeId)) { pPlayer->PlayerTalkClass->ClearMenus(); switch (bgTypeId) { case BATTLEGROUND_AV: pPlayer->PlayerTalkClass->SendGossipMenu(7616, GetObjectGuid()); break; case BATTLEGROUND_WS: pPlayer->PlayerTalkClass->SendGossipMenu(7599, GetObjectGuid()); break; case BATTLEGROUND_AB: pPlayer->PlayerTalkClass->SendGossipMenu(7642, GetObjectGuid()); break; default: break; } return false; } return true; } bool Creature::CanTrainAndResetTalentsOf(Player* pPlayer) const { return pPlayer->getLevel() >= 10 && GetCreatureInfo()->TrainerType == TRAINER_TYPE_CLASS && pPlayer->getClass() == GetCreatureInfo()->TrainerClass; } void Creature::PrepareBodyLootState() { loot.clear(); // if have normal loot then prepare it access if (!lootForBody) { // have normal loot if (GetCreatureInfo()->MaxLootGold > 0 || GetCreatureInfo()->LootId || (GetCreatureType() != CREATURE_TYPE_CRITTER && (GetCreatureInfo()->SkinningLootId && sWorld.getConfig(CONFIG_BOOL_CORPSE_EMPTY_LOOT_SHOW)))) { SetFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE); return; } } lootForBody = true; // pass this loot mode // if not have normal loot allow skinning if need if (!lootForSkin && GetCreatureInfo()->SkinningLootId) { RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE); SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE); return; } RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE); RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE); } /** * Return original player who tap creature, it can be different from player/group allowed to loot so not use it for loot code */ Player* Creature::GetOriginalLootRecipient() const { return m_lootRecipientGuid ? ObjectAccessor::FindPlayer(m_lootRecipientGuid) : NULL; } /** * Return group if player tap creature as group member, independent is player after leave group or stil be group member */ Group* Creature::GetGroupLootRecipient() const { // original recipient group if set and not disbanded return m_lootGroupRecipientId ? sObjectMgr.GetGroupById(m_lootGroupRecipientId) : NULL; } /** * Return player who can loot tapped creature (member of group or single player) * * In case when original player tap creature as group member then group tap prefered. * This is for example important if player after tap leave group. * If group not exist or disbanded or player tap creature not as group member return player */ Player* Creature::GetLootRecipient() const { // original recipient group if set and not disbanded Group* group = GetGroupLootRecipient(); // original recipient player if online Player* player = GetOriginalLootRecipient(); // if group not set or disbanded return original recipient player if any if (!group) { return player; } // group case // return player if it still be in original recipient group if (player && player->GetGroup() == group) { return player; } // find any in group for (GroupReference* itr = group->GetFirstMember(); itr != NULL; itr = itr->next()) if (Player* p = itr->getSource()) { return p; } return NULL; } /** * Set player and group (if player group member) who tap creature */ void Creature::SetLootRecipient(Unit* unit) { // set the player whose group should receive the right // to loot the creature after it dies // should be set to NULL after the loot disappears if (!unit) { m_lootRecipientGuid.Clear(); m_lootGroupRecipientId = 0; return; } Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself(); if (!player) // normal creature, no player involved { return; } // set player for non group case or if group will disbanded m_lootRecipientGuid = player->GetObjectGuid(); // set group for group existing case including if player will leave group at loot time if (Group* group = player->GetGroup()) { m_lootGroupRecipientId = group->GetId(); } SetFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TAPPED); } void Creature::SaveToDB() { // this should only be used when the creature has already been loaded // preferably after adding to map, because mapid may not be valid otherwise CreatureData const* data = sObjectMgr.GetCreatureData(GetGUIDLow()); if (!data) { sLog.outError("Creature::SaveToDB failed, can not get creature data!"); return; } SaveToDB(GetMapId()); } // return true if this creature is tapped by the player or by a member of his group. bool Creature::IsTappedBy(Player const* player) const { if (player == GetOriginalLootRecipient()) return true; Group const* playerGroup = player->GetGroup(); if (!playerGroup || playerGroup != GetGroupLootRecipient()) // if we dont have a group we arent the recipient return false; // if creature doesnt have group bound it means it was solo killed by someone else return true; } void Creature::SaveToDB(uint32 mapid) { // update in loaded data CreatureData& data = sObjectMgr.NewOrExistCreatureData(GetGUIDLow()); uint32 displayId = GetNativeDisplayId(); // check if it's a custom model and if not, use 0 for displayId CreatureInfo const* cinfo = GetCreatureInfo(); if (cinfo) { if (displayId != cinfo->ModelId[0] && displayId != cinfo->ModelId[1]) { for (int i = 0; i < MAX_CREATURE_MODEL && displayId; ++i) if (cinfo->ModelId[i]) if (CreatureModelInfo const* minfo = sObjectMgr.GetCreatureModelInfo(cinfo->ModelId[i])) if (displayId == minfo->modelid_other_gender) { displayId = 0; } } else { displayId = 0; } } // data->guid = guid don't must be update at save data.id = GetEntry(); data.mapid = mapid; data.modelid_override = displayId; data.equipmentId = GetEquipmentId(); data.posX = GetPositionX(); data.posY = GetPositionY(); data.posZ = GetPositionZ(); data.orientation = GetOrientation(); data.spawntimesecs = m_respawnDelay; // prevent add data integrity problems data.spawndist = GetDefaultMovementType() == IDLE_MOTION_TYPE ? 0 : m_respawnradius; data.currentwaypoint = 0; data.curhealth = GetHealth(); data.curmana = GetPower(POWER_MANA); data.is_dead = m_IsDeadByDefault; // prevent add data integrity problems data.movementType = !m_respawnradius && GetDefaultMovementType() == RANDOM_MOTION_TYPE ? IDLE_MOTION_TYPE : GetDefaultMovementType(); // updated in DB WorldDatabase.BeginTransaction(); WorldDatabase.PExecuteLog("DELETE FROM creature WHERE guid=%u", GetGUIDLow()); std::ostringstream ss; ss << "INSERT INTO creature VALUES (" << GetGUIDLow() << "," << data.id << "," << data.mapid << "," << data.modelid_override << "," << data.equipmentId << "," << data.posX << "," << data.posY << "," << data.posZ << "," << data.orientation << "," << data.spawntimesecs << "," // respawn time << (float) data.spawndist << "," // spawn distance (float) << data.currentwaypoint << "," // currentwaypoint << data.curhealth << "," // curhealth << data.curmana << "," // curmana << (data.is_dead ? 1 : 0) << "," // is_dead << uint32(data.movementType) << ")"; // default movement generator type, cast to prevent save as symbol WorldDatabase.PExecuteLog("%s", ss.str().c_str()); WorldDatabase.CommitTransaction(); } void Creature::SelectLevel(const CreatureInfo* cinfo, float percentHealth /*= 100.0f*/) { uint32 rank = IsPet() ? 0 : cinfo->Rank; // TODO :: IsPet probably not needed here // level uint32 const minlevel = cinfo->MinLevel; uint32 const maxlevel = cinfo->MaxLevel; uint32 level = minlevel == maxlevel ? minlevel : urand(minlevel, maxlevel); SetLevel(level); ////////////////////////////////////////////////////////////////////////// // Calculate level dependent stats ////////////////////////////////////////////////////////////////////////// uint32 health; uint32 mana; // TODO: Remove cinfo->ArmorMultiplier test workaround to disable classlevelstats when DB is ready CreatureClassLvlStats const* cCLS = sObjectMgr.GetCreatureClassLvlStats(level, cinfo->UnitClass); if (cinfo->ArmorMultiplier > 0 && cCLS) { // Use Creature Stats to calculate stat values // health health = cCLS->BaseHealth * cinfo->HealthMultiplier; // mana mana = cCLS->BaseMana * cinfo->PowerMultiplier; } else { // Use old style to calculate stat values float rellevel = maxlevel == minlevel ? 0 : (float(level - minlevel)) / (maxlevel - minlevel); // health uint32 minhealth = std::min(cinfo->MaxLevelHealth, cinfo->MinLevelHealth); uint32 maxhealth = std::max(cinfo->MaxLevelHealth, cinfo->MinLevelHealth); health = uint32(minhealth + uint32(rellevel * (maxhealth - minhealth))); // mana uint32 minmana = std::min(cinfo->MaxLevelMana, cinfo->MinLevelMana); uint32 maxmana = std::max(cinfo->MaxLevelMana, cinfo->MinLevelMana); mana = minmana + uint32(rellevel * (maxmana - minmana)); } health *= _GetHealthMod(rank); // Apply custom config setting if (health < 1) health = 1; ////////////////////////////////////////////////////////////////////////// // Set values ////////////////////////////////////////////////////////////////////////// // health SetCreateHealth(health); SetMaxHealth(health); if (percentHealth == 100.0f) { SetHealth(health); } else { SetHealthPercent(percentHealth); } ResetPlayerDamageReq(); SetModifierValue(UNIT_MOD_HEALTH, BASE_VALUE, float(health)); // all power types for (int i = POWER_MANA; i <= POWER_HAPPINESS; ++i) { uint32 maxValue; switch (i) { case POWER_MANA: maxValue = mana; break; case POWER_RAGE: maxValue = 0; break; case POWER_FOCUS: maxValue = POWER_FOCUS; break; case POWER_ENERGY: maxValue = POWER_ENERGY* cinfo->PowerMultiplier; break; case POWER_HAPPINESS: maxValue = POWER_HAPPINESS; break; } uint32 value = maxValue; // For non regenerating powers set 0 if ((i == POWER_ENERGY || i == POWER_MANA) && !IsRegeneratingPower()) value = 0; // Mana requires an extra field to be set if (i == POWER_MANA) SetCreateMana(value); SetMaxPower(Powers(i), maxValue); SetPower(Powers(i), value); SetModifierValue(UnitMods(UNIT_MOD_POWER_START + i), BASE_VALUE, float(value)); } // damage float damagemod = _GetDamageMod(rank); SetBaseWeaponDamage(BASE_ATTACK, MINDAMAGE, cinfo->MinMeleeDmg * damagemod); SetBaseWeaponDamage(BASE_ATTACK, MAXDAMAGE, cinfo->MaxMeleeDmg * damagemod); SetBaseWeaponDamage(OFF_ATTACK, MINDAMAGE, cinfo->MinMeleeDmg * damagemod); SetBaseWeaponDamage(OFF_ATTACK, MAXDAMAGE, cinfo->MaxMeleeDmg * damagemod); SetFloatValue(UNIT_FIELD_MINRANGEDDAMAGE, cinfo->MinRangedDmg * damagemod); SetFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE, cinfo->MaxRangedDmg * damagemod); SetModifierValue(UNIT_MOD_ATTACK_POWER, BASE_VALUE, cinfo->MeleeAttackPower * damagemod); } float Creature::_GetHealthMod(int32 Rank) { switch (Rank) // define rates for each elite rank { case CREATURE_ELITE_NORMAL: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_NORMAL_HP); case CREATURE_ELITE_ELITE: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_ELITE_HP); case CREATURE_ELITE_RAREELITE: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_RAREELITE_HP); case CREATURE_ELITE_WORLDBOSS: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_WORLDBOSS_HP); case CREATURE_ELITE_RARE: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_RARE_HP); default: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_ELITE_HP); } } float Creature::_GetDamageMod(int32 Rank) { switch (Rank) // define rates for each elite rank { case CREATURE_ELITE_NORMAL: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_NORMAL_DAMAGE); case CREATURE_ELITE_ELITE: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_ELITE_DAMAGE); case CREATURE_ELITE_RAREELITE: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_RAREELITE_DAMAGE); case CREATURE_ELITE_WORLDBOSS: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_WORLDBOSS_DAMAGE); case CREATURE_ELITE_RARE: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_RARE_DAMAGE); default: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_ELITE_DAMAGE); } } void Creature::LowerPlayerDamageReq(uint32 unDamage) { if (m_PlayerDamageReq) m_PlayerDamageReq > unDamage ? m_PlayerDamageReq -= unDamage : m_PlayerDamageReq = 0; } float Creature::_GetSpellDamageMod(int32 Rank) { switch (Rank) // define rates for each elite rank { case CREATURE_ELITE_NORMAL: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_NORMAL_SPELLDAMAGE); case CREATURE_ELITE_ELITE: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_ELITE_SPELLDAMAGE); case CREATURE_ELITE_RAREELITE: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_RAREELITE_SPELLDAMAGE); case CREATURE_ELITE_WORLDBOSS: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_WORLDBOSS_SPELLDAMAGE); case CREATURE_ELITE_RARE: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_RARE_SPELLDAMAGE); default: return sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_ELITE_ELITE_SPELLDAMAGE); } } bool Creature::CreateFromProto(uint32 guidlow, CreatureInfo const* cinfo, Team team, const CreatureData* data /*=NULL*/, GameEventCreatureData const* eventData /*=NULL*/) { m_originalEntry = cinfo->Entry; Object::_Create(guidlow, cinfo->Entry, cinfo->GetHighGuid()); if (!UpdateEntry(cinfo->Entry, team, data, eventData, false)) { return false; } return true; } bool Creature::LoadFromDB(uint32 guidlow, Map* map) { CreatureData const* data = sObjectMgr.GetCreatureData(guidlow); if (!data) { sLog.outErrorDb("Creature (GUID: %u) not found in table `creature`, can't load. ", guidlow); return false; } CreatureInfo const* cinfo = ObjectMgr::GetCreatureTemplate(data->id); if (!cinfo) { sLog.outErrorDb("Creature (Entry: %u) not found in table `creature_template`, can't load. ", data->id); return false; } GameEventCreatureData const* eventData = sGameEventMgr.GetCreatureUpdateDataForActiveEvent(guidlow); // Creature can be loaded already in map if grid has been unloaded while creature walk to another grid if (map->GetCreature(cinfo->GetObjectGuid(guidlow))) { return false; } CreatureCreatePos pos(map, data->posX, data->posY, data->posZ, data->orientation); if (!Create(guidlow, pos, cinfo, TEAM_NONE, data, eventData)) { return false; } SetRespawnCoord(pos); m_respawnradius = data->spawndist; m_respawnDelay = data->spawntimesecs; m_corpseDelay = std::min(m_respawnDelay * 9 / 10, m_corpseDelay); // set corpse delay to 90% of the respawn delay m_IsDeadByDefault = data->is_dead; m_deathState = m_IsDeadByDefault ? DEAD : ALIVE; m_respawnTime = map->GetPersistentState()->GetCreatureRespawnTime(GetGUIDLow()); if (m_respawnTime > time(NULL)) // not ready to respawn { m_deathState = DEAD; if (CanFly()) { float tz = GetTerrain()->GetHeightStatic(data->posX, data->posY, data->posZ, false); if (data->posZ - tz > 0.1) { Relocate(data->posX, data->posY, tz); } } } else if (m_respawnTime) // respawn time set but expired { m_respawnTime = 0; GetMap()->GetPersistentState()->SaveCreatureRespawnTime(GetGUIDLow(), 0); } uint32 curhealth = data->curhealth; if (curhealth) { curhealth = uint32(curhealth * _GetHealthMod(GetCreatureInfo()->Rank)); if (curhealth < 1) { curhealth = 1; } } if (sCreatureLinkingMgr.IsSpawnedByLinkedMob(this)) { m_isSpawningLinked = true; if (m_deathState == ALIVE && !GetMap()->GetCreatureLinkingHolder()->CanSpawn(this)) { m_deathState = DEAD; // Just set to dead, so need to relocate like above if (CanFly()) { float tz = GetTerrain()->GetHeightStatic(data->posX, data->posY, data->posZ, false); if (data->posZ - tz > 0.1) { Relocate(data->posX, data->posY, tz); } } } } SetHealth(m_deathState == ALIVE ? curhealth : 0); SetPower(POWER_MANA, data->curmana); SetMeleeDamageSchool(SpellSchools(GetCreatureInfo()->DamageSchool)); // checked at creature_template loading m_defaultMovementType = MovementGeneratorType(data->movementType); AIM_Initialize(); // Creature Linking, Initial load is handled like respawn if (m_isCreatureLinkingTrigger && IsAlive()) { GetMap()->GetCreatureLinkingHolder()->DoCreatureLinkingEvent(LINKING_EVENT_RESPAWN, this); } // check if it is rabbit day if (IsAlive() && sWorld.getConfig(CONFIG_UINT32_RABBIT_DAY)) { time_t rabbit_day = time_t(sWorld.getConfig(CONFIG_UINT32_RABBIT_DAY)); tm rabbit_day_tm = *localtime(&rabbit_day); tm now_tm = *localtime(&sWorld.GetGameTime()); if (now_tm.tm_mon == rabbit_day_tm.tm_mon && now_tm.tm_mday == rabbit_day_tm.tm_mday) { CastSpell(this, 10710 + urand(0, 2), true); } } return true; } void Creature::LoadEquipment(uint32 equip_entry, bool force) { if (equip_entry == 0) { if (force) { for (uint8 i = 0; i < MAX_VIRTUAL_ITEM_SLOT; ++i) { SetVirtualItem(VirtualItemSlot(i), 0); } m_equipmentId = 0; } return; } if (EquipmentInfo const* einfo = sObjectMgr.GetEquipmentInfo(equip_entry)) { m_equipmentId = equip_entry; for (uint8 i = 0; i < MAX_VIRTUAL_ITEM_SLOT; ++i) { SetVirtualItem(VirtualItemSlot(i), einfo->equipentry[i]); } } else if (EquipmentInfoRaw const* einfo = sObjectMgr.GetEquipmentInfoRaw(equip_entry)) { m_equipmentId = equip_entry; for (uint8 i = 0; i < MAX_VIRTUAL_ITEM_SLOT; ++i) { SetVirtualItemRaw(VirtualItemSlot(i), einfo->equipmodel[i], einfo->equipinfo[i], einfo->equipslot[i]); } } } bool Creature::HasQuest(uint32 quest_id) const { QuestRelationsMapBounds bounds = sObjectMgr.GetCreatureQuestRelationsMapBounds(GetEntry()); for (QuestRelationsMap::const_iterator itr = bounds.first; itr != bounds.second; ++itr) { if (itr->second == quest_id) { return true; } } return false; } bool Creature::HasInvolvedQuest(uint32 quest_id) const { QuestRelationsMapBounds bounds = sObjectMgr.GetCreatureQuestInvolvedRelationsMapBounds(GetEntry()); for (QuestRelationsMap::const_iterator itr = bounds.first; itr != bounds.second; ++itr) { if (itr->second == quest_id) { return true; } } return false; } struct CreatureRespawnDeleteWorker { explicit CreatureRespawnDeleteWorker(uint32 guid) : i_guid(guid) {} void operator()(MapPersistentState* state) { state->SaveCreatureRespawnTime(i_guid, 0); } uint32 i_guid; }; void Creature::DeleteFromDB() { CreatureData const* data = sObjectMgr.GetCreatureData(GetGUIDLow()); if (!data) { DEBUG_LOG("Trying to delete not saved creature!"); return; } DeleteFromDB(GetGUIDLow(), data); } void Creature::DeleteFromDB(uint32 lowguid, CreatureData const* data) { CreatureRespawnDeleteWorker worker(lowguid); sMapPersistentStateMgr.DoForAllStatesWithMapId(data->mapid, worker); sObjectMgr.DeleteCreatureData(lowguid); WorldDatabase.BeginTransaction(); WorldDatabase.PExecuteLog("DELETE FROM creature WHERE guid=%u", lowguid); WorldDatabase.PExecuteLog("DELETE FROM creature_addon WHERE guid=%u", lowguid); WorldDatabase.PExecuteLog("DELETE FROM creature_movement WHERE id=%u", lowguid); WorldDatabase.PExecuteLog("DELETE FROM game_event_creature WHERE guid=%u", lowguid); WorldDatabase.PExecuteLog("DELETE FROM game_event_creature_data WHERE guid=%u", lowguid); WorldDatabase.PExecuteLog("DELETE FROM creature_battleground WHERE guid=%u", lowguid); WorldDatabase.PExecuteLog("DELETE FROM creature_linking WHERE guid=%u OR master_guid=%u", lowguid, lowguid); WorldDatabase.CommitTransaction(); } float Creature::GetAttackDistance(Unit const* pl) const { float aggroRate = sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_AGGRO); if (aggroRate == 0) { return 0.0f; } uint32 playerlevel = pl->GetLevelForTarget(this); uint32 creaturelevel = GetLevelForTarget(pl); int32 leveldif = int32(playerlevel) - int32(creaturelevel); // "The maximum Aggro Radius has a cap of 25 levels under. Example: A level 30 char has the same Aggro Radius of a level 5 char on a level 60 mob." if (leveldif < - 25) { leveldif = -25; } // "The aggro radius of a mob having the same level as the player is roughly 20 yards" float RetDistance = 20; // "Aggro Radius varies with level difference at a rate of roughly 1 yard/level" // radius grow if playlevel < creaturelevel RetDistance -= (float)leveldif; if (creaturelevel + 5 <= sWorld.getConfig(CONFIG_UINT32_MAX_PLAYER_LEVEL)) { // detect range auras RetDistance += GetTotalAuraModifier(SPELL_AURA_MOD_DETECT_RANGE); // detected range auras RetDistance += pl->GetTotalAuraModifier(SPELL_AURA_MOD_DETECTED_RANGE); } // "Minimum Aggro Radius for a mob seems to be combat range (5 yards)" if (RetDistance < 5) { RetDistance = 5; } return (RetDistance * aggroRate); } void Creature::SetDeathState(DeathState s) { if ((s == JUST_DIED && !m_IsDeadByDefault) || (s == JUST_ALIVED && m_IsDeadByDefault)) { m_corpseRemoveTime = time(NULL) + m_corpseDelay; // the max/default time for corpse decay (before creature is looted/AllLootRemovedFromCorpse() is called) m_respawnTime = time(NULL) + m_respawnDelay; // respawn delay (spawntimesecs) // always save boss respawn time at death to prevent crash cheating if (sWorld.getConfig(CONFIG_BOOL_SAVE_RESPAWN_TIME_IMMEDIATELY) || IsWorldBoss()) { SaveRespawnTime(); } } Unit::SetDeathState(s); if (s == JUST_DIED) { SetTargetGuid(ObjectGuid()); // remove target selection in any cases (can be set at aura remove in Unit::SetDeathState) SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE); if (HasSearchedAssistance()) { SetNoSearchAssistance(false); UpdateSpeed(MOVE_RUN, false); } if (CanFly()) { i_motionMaster.MoveFall(); } Unit::SetDeathState(CORPSE); } if (s == JUST_ALIVED) { clearUnitState(UNIT_STAT_ALL_STATE); Unit::SetDeathState(ALIVE); SetHealth(GetMaxHealth()); SetLootRecipient(NULL); if (GetTemporaryFactionFlags() & TEMPFACTION_RESTORE_RESPAWN) { ClearTemporaryFaction(); } SetMeleeDamageSchool(SpellSchools(GetCreatureInfo()->DamageSchool)); // Dynamic flags must be set on Tapped by default. SetUInt32Value(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_NONE); LoadCreatureAddon(true); ResetPlayerDamageReq(); // Flags after LoadCreatureAddon. Any spell in *addon // will not be able to adjust these. SetUInt32Value(UNIT_NPC_FLAGS, GetCreatureInfo()->NpcFlags); RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE); SetWalk(true, true); i_motionMaster.Initialize(); } } void Creature::Respawn() { RemoveCorpse(); if (!IsInWorld()) // Could be removed as part of a pool (in which case respawn-time is handled with pool-system) { return; } if (IsDespawned()) { if (HasStaticDBSpawnData()) { GetMap()->GetPersistentState()->SaveCreatureRespawnTime(GetGUIDLow(), 0); } m_respawnTime = time(NULL); // respawn at next tick } } void Creature::ForcedDespawn(uint32 timeMSToDespawn) { if (timeMSToDespawn) { ForcedDespawnDelayEvent* pEvent = new ForcedDespawnDelayEvent(*this); m_Events.AddEvent(pEvent, m_Events.CalculateTime(timeMSToDespawn)); return; } if (IsDespawned()) { return; } if (IsAlive()) { SetDeathState(JUST_DIED); } RemoveCorpse(); SetHealth(0); // just for nice GM-mode view } bool Creature::IsImmuneToSpell(SpellEntry const* spellInfo, bool castOnSelf) { if (!spellInfo) { return false; } if (!castOnSelf && GetCreatureInfo()->MechanicImmuneMask & (1 << (spellInfo->Mechanic - 1))) { return true; } return Unit::IsImmuneToSpell(spellInfo, castOnSelf); } bool Creature::IsImmuneToSpellEffect(SpellEntry const* spellInfo, SpellEffectIndex index, bool castOnSelf) const { if (!castOnSelf && GetCreatureInfo()->MechanicImmuneMask & (1 << (spellInfo->EffectMechanic[index] - 1))) { return true; } // Taunt immunity special flag check if (GetCreatureInfo()->ExtraFlags & CREATURE_EXTRA_FLAG_NOT_TAUNTABLE) { // Taunt aura apply check if (spellInfo->Effect[index] == SPELL_EFFECT_APPLY_AURA) { if (spellInfo->EffectApplyAuraName[index] == SPELL_AURA_MOD_TAUNT) { return true; } } // Spell effect taunt check else if (spellInfo->Effect[index] == SPELL_EFFECT_ATTACK_ME) { return true; } } return Unit::IsImmuneToSpellEffect(spellInfo, index, castOnSelf); } SpellEntry const* Creature::ReachWithSpellAttack(Unit* pVictim) { if (!pVictim) { return NULL; } for (uint32 i = 0; i < CREATURE_MAX_SPELLS; ++i) { if (!m_spells[i]) { continue; } SpellEntry const* spellInfo = sSpellStore.LookupEntry(m_spells[i]); if (!spellInfo) { sLog.outError("WORLD: unknown spell id %i", m_spells[i]); continue; } bool bcontinue = true; for (int j = 0; j < MAX_EFFECT_INDEX; ++j) { if ((spellInfo->Effect[j] == SPELL_EFFECT_SCHOOL_DAMAGE) || (spellInfo->Effect[j] == SPELL_EFFECT_INSTAKILL) || (spellInfo->Effect[j] == SPELL_EFFECT_ENVIRONMENTAL_DAMAGE) || (spellInfo->Effect[j] == SPELL_EFFECT_HEALTH_LEECH) ) { bcontinue = false; break; } } if (bcontinue) { continue; } if (spellInfo->manaCost > GetPower(POWER_MANA)) { continue; } SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(spellInfo->rangeIndex); float range = GetSpellMaxRange(srange); float minrange = GetSpellMinRange(srange); float dist = GetCombatDistance(pVictim, spellInfo->rangeIndex == SPELL_RANGE_IDX_COMBAT); // if(!isInFront( pVictim, range ) && spellInfo->AttributesEx ) // continue; if (dist > range || dist < minrange) { continue; } if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED)) { continue; } if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED)) { continue; } return spellInfo; } return NULL; } SpellEntry const* Creature::ReachWithSpellCure(Unit* pVictim) { if (!pVictim) { return NULL; } for (uint32 i = 0; i < CREATURE_MAX_SPELLS; ++i) { if (!m_spells[i]) { continue; } SpellEntry const* spellInfo = sSpellStore.LookupEntry(m_spells[i]); if (!spellInfo) { sLog.outError("WORLD: unknown spell id %i", m_spells[i]); continue; } if (!spellInfo->HasSpellEffect(SPELL_EFFECT_HEAL)) { continue; } if (spellInfo->manaCost > GetPower(POWER_MANA)) { continue; } SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(spellInfo->rangeIndex); float range = GetSpellMaxRange(srange); float minrange = GetSpellMinRange(srange); float dist = GetCombatDistance(pVictim, spellInfo->rangeIndex == SPELL_RANGE_IDX_COMBAT); // if(!isInFront( pVictim, range ) && spellInfo->AttributesEx ) // continue; if (dist > range || dist < minrange) { continue; } if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED)) { continue; } if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED)) { continue; } return spellInfo; } return NULL; } bool Creature::IsVisibleInGridForPlayer(Player* pl) const { // gamemaster in GM mode see all, including ghosts if (pl->isGameMaster()) { return true; } if (GetCreatureInfo()->ExtraFlags & CREATURE_EXTRA_FLAG_INVISIBLE) { return false; } // Live player (or with not release body see live creatures or death creatures with corpse disappearing time > 0 if (pl->IsAlive() || pl->GetDeathTimer() > 0) { return (IsAlive() || m_corpseRemoveTime > time(NULL) || (m_IsDeadByDefault && m_deathState == CORPSE)); } // Dead player see live creatures near own corpse if (IsAlive()) { Corpse* corpse = pl->GetCorpse(); if (corpse) { // 20 - aggro distance for same level, 25 - max additional distance if player level less that creature level if (corpse->IsWithinDistInMap(this, (20 + 25)*sWorld.getConfig(CONFIG_FLOAT_RATE_CREATURE_AGGRO))) { return true; } } } // Dead player can see ghosts if (GetCreatureInfo()->CreatureTypeFlags & CREATURE_TYPEFLAGS_GHOST_VISIBLE) { return true; } // and not see any other return false; } void Creature::SendAIReaction(AiReaction reactionType) { WorldPacket data(SMSG_AI_REACTION, 12); data << GetObjectGuid(); data << uint32(reactionType); ((WorldObject*)this)->SendMessageToSet(&data, true); DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "WORLD: Sent SMSG_AI_REACTION, type %u.", reactionType); } void Creature::CallAssistance() { // FIXME: should player pets call for assistance? if (!m_AlreadyCallAssistance && getVictim() && !IsCharmed()) { SetNoCallAssistance(true); if (GetCreatureInfo()->ExtraFlags & CREATURE_EXTRA_FLAG_NO_CALL_ASSIST) return; AI()->SendAIEventAround(AI_EVENT_CALL_ASSISTANCE, getVictim(), sWorld.getConfig(CONFIG_UINT32_CREATURE_FAMILY_ASSISTANCE_DELAY), sWorld.getConfig(CONFIG_FLOAT_CREATURE_FAMILY_ASSISTANCE_RADIUS)); } } void Creature::CallForHelp(float fRadius) { if (fRadius <= 0.0f || !getVictim() || IsPet() || IsCharmed()) { return; } MaNGOS::CallOfHelpCreatureInRangeDo u_do(this, getVictim(), fRadius); MaNGOS::CreatureWorker worker(this, u_do); Cell::VisitGridObjects(this, worker, fRadius); } /// if enemy provided, check for initial combat help against enemy bool Creature::CanAssistTo(const Unit* u, const Unit* enemy, bool checkfaction /*= true*/) const { // we don't need help from zombies :) if (!IsAlive()) { return false; } // we don't need help from non-combatant ;) if (GetCreatureInfo()->ExtraFlags & CREATURE_EXTRA_FLAG_NO_AGGRO) { return false; } if (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_PASSIVE)) { return false; } // skip fighting creature if (enemy && IsInCombat()) { return false; } // only free creature if (GetCharmerOrOwnerGuid()) { return false; } // only from same creature faction if (checkfaction) { if (getFaction() != u->getFaction()) { return false; } } else { if (!IsFriendlyTo(u)) { return false; } } // skip non hostile to caster enemy creatures if (enemy && !IsHostileTo(enemy)) { return false; } return true; } bool Creature::CanInitiateAttack() { if (hasUnitState(UNIT_STAT_STUNNED | UNIT_STAT_DIED)) { return false; } if (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE)) { return false; } if (isPassiveToHostile()) { return false; } if (m_aggroDelay != 0) return false; return true; } void Creature::SaveRespawnTime() { if (IsPet() || !HasStaticDBSpawnData()) { return; } if (m_respawnTime > time(NULL)) // dead (no corpse) { GetMap()->GetPersistentState()->SaveCreatureRespawnTime(GetGUIDLow(), m_respawnTime); } else if (m_corpseRemoveTime > time(NULL)) // dead (corpse) { GetMap()->GetPersistentState()->SaveCreatureRespawnTime(GetGUIDLow(), m_corpseRemoveTime + m_respawnDelay); } } bool Creature::IsOutOfThreatArea(Unit* pVictim) const { if (!pVictim) { return true; } if (!pVictim->IsInMap(this)) { return true; } if (!pVictim->IsTargetableForAttack()) { return true; } if (!pVictim->isInAccessablePlaceFor(this)) { return true; } if (!pVictim->IsVisibleForOrDetect(this, this, false)) { return true; } if (sMapStore.LookupEntry(GetMapId())->IsDungeon()) { return false; } float AttackDist = GetAttackDistance(pVictim); float ThreatRadius = sWorld.getConfig(CONFIG_FLOAT_THREAT_RADIUS); // Use AttackDistance in distance check if threat radius is lower. This prevents creature bounce in and out of combat every update tick. return !pVictim->IsWithinDist3d(m_combatStartX, m_combatStartY, m_combatStartZ, ThreatRadius > AttackDist ? ThreatRadius : AttackDist); } CreatureDataAddon const* Creature::GetCreatureAddon() const { if (CreatureDataAddon const* addon = ObjectMgr::GetCreatureAddon(GetGUIDLow())) { return addon; } return ObjectMgr::GetCreatureTemplateAddon(GetCreatureInfo()->Entry); } // creature_addon table bool Creature::LoadCreatureAddon(bool reload) { CreatureDataAddon const* cainfo = GetCreatureAddon(); if (!cainfo) { return false; } if (cainfo->mount != 0) { Mount(cainfo->mount); } if (cainfo->bytes1 != 0) { // 0 StandState // 1 LoyaltyLevel Pet only, so always 0 for default creature // 2 ShapeshiftForm Must be determined/set by shapeshift spell/aura // 3 StandMiscFlags SetByteValue(UNIT_FIELD_BYTES_1, 0, uint8(cainfo->bytes1 & 0xFF)); // SetByteValue(UNIT_FIELD_BYTES_1, 1, uint8((cainfo->bytes1 >> 8) & 0xFF)); // SetByteValue(UNIT_FIELD_BYTES_1, 1, 0); // SetByteValue(UNIT_FIELD_BYTES_2, 2, 0); SetByteValue(UNIT_FIELD_BYTES_1, 3, uint8((cainfo->bytes1 >> 24) & 0xFF)); } // UNIT_FIELD_BYTES_2 // 0 SheathState // 1 Bytes2Flags, in 3.x used UnitPVPStateFlags, that have different meaning // 2 UnitRename Pet only, so always 0 for default creature // 3 ShapeshiftForm Must be determined/set by shapeshift spell/aura SetByteValue(UNIT_FIELD_BYTES_2, 0, cainfo->sheath_state); if (cainfo->flags != 0) { SetByteValue(UNIT_FIELD_BYTES_2, 1, cainfo->flags); } // SetByteValue(UNIT_FIELD_BYTES_2, 2, 0); // SetByteValue(UNIT_FIELD_BYTES_2, 3, 0); if (cainfo->emote != 0) { SetUInt32Value(UNIT_NPC_EMOTESTATE, cainfo->emote); } if (cainfo->auras) { for (uint32 const* cAura = cainfo->auras; *cAura; ++cAura) { if (HasAura(*cAura)) { if (!reload) { sLog.outErrorDb("Creature (GUIDLow: %u Entry: %u) has spell %u in `auras` field, but aura is already applied.", GetGUIDLow(), GetEntry(), *cAura); } continue; } CastSpell(this, *cAura, true); } } return true; } /// Sends a message to LocalDefense and WorldDefense channels for players of the other team void Creature::SendZoneUnderAttackMessage(Player* attacker) { sWorld.SendZoneUnderAttackMessage(GetZoneId(), attacker->GetTeam() == ALLIANCE ? HORDE : ALLIANCE); } void Creature::SetInCombatWithZone() { if (!CanHaveThreatList()) { sLog.outError("Creature entry %u call SetInCombatWithZone but creature can not have threat list.", GetEntry()); return; } Map* pMap = GetMap(); if (!pMap->IsDungeon()) { sLog.outError("Creature entry %u call SetInCombatWithZone for map (id: %u) that isn't an instance.", GetEntry(), pMap->GetId()); return; } Map::PlayerList const& PlList = pMap->GetPlayers(); if (PlList.isEmpty()) { return; } for (Map::PlayerList::const_iterator i = PlList.begin(); i != PlList.end(); ++i) { if (Player* pPlayer = i->getSource()) { if (pPlayer->isGameMaster()) { continue; } if (pPlayer->IsAlive() && !IsFriendlyTo(pPlayer)) { pPlayer->SetInCombatWith(this); AddThreat(pPlayer); } } } } bool Creature::MeetsSelectAttackingRequirement(Unit* pTarget, SpellEntry const* pSpellInfo, uint32 selectFlags) const { if (selectFlags & SELECT_FLAG_PLAYER && pTarget->GetTypeId() != TYPEID_PLAYER) { return false; } if (selectFlags & SELECT_FLAG_POWER_MANA && pTarget->GetPowerType() != POWER_MANA) { return false; } else if (selectFlags & SELECT_FLAG_POWER_RAGE && pTarget->GetPowerType() != POWER_RAGE) { return false; } else if (selectFlags & SELECT_FLAG_POWER_ENERGY && pTarget->GetPowerType() != POWER_ENERGY) { return false; } if (selectFlags & SELECT_FLAG_IN_MELEE_RANGE && !CanReachWithMeleeAttack(pTarget)) { return false; } if (selectFlags & SELECT_FLAG_NOT_IN_MELEE_RANGE && CanReachWithMeleeAttack(pTarget)) { return false; } if (selectFlags & SELECT_FLAG_IN_LOS && !IsWithinLOSInMap(pTarget)) { return false; } if (pSpellInfo) { switch (pSpellInfo->rangeIndex) { case SPELL_RANGE_IDX_SELF_ONLY: return false; case SPELL_RANGE_IDX_ANYWHERE: return true; case SPELL_RANGE_IDX_COMBAT: return CanReachWithMeleeAttack(pTarget); } SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(pSpellInfo->rangeIndex); float max_range = GetSpellMaxRange(srange); float min_range = GetSpellMinRange(srange); float dist = GetCombatDistance(pTarget, false); return dist < max_range && dist >= min_range; } return true; } Unit* Creature::SelectAttackingTarget(AttackingTarget target, uint32 position, uint32 uiSpellEntry, uint32 selectFlags) const { return SelectAttackingTarget(target, position, sSpellStore.LookupEntry(uiSpellEntry), selectFlags); } Unit* Creature::SelectAttackingTarget(AttackingTarget target, uint32 position, SpellEntry const* pSpellInfo /*= NULL*/, uint32 selectFlags/*= 0*/) const { if (!CanHaveThreatList()) { return NULL; } // ThreatList m_threatlist; ThreatList const& threatlist = GetThreatManager().getThreatList(); ThreatList::const_iterator itr = threatlist.begin(); ThreatList::const_reverse_iterator ritr = threatlist.rbegin(); if (position >= threatlist.size() || !threatlist.size()) { return NULL; } switch (target) { case ATTACKING_TARGET_RANDOM: { std::vector suitableUnits; suitableUnits.reserve(threatlist.size() - position); advance(itr, position); for (; itr != threatlist.end(); ++itr) if (Unit* pTarget = GetMap()->GetUnit((*itr)->getUnitGuid())) if (!selectFlags || MeetsSelectAttackingRequirement(pTarget, pSpellInfo, selectFlags)) { suitableUnits.push_back(pTarget); } if (!suitableUnits.empty()) { return suitableUnits[urand(0, suitableUnits.size() - 1)]; } break; } case ATTACKING_TARGET_TOPAGGRO: { advance(itr, position); for (; itr != threatlist.end(); ++itr) if (Unit* pTarget = GetMap()->GetUnit((*itr)->getUnitGuid())) if (!selectFlags || MeetsSelectAttackingRequirement(pTarget, pSpellInfo, selectFlags)) { return pTarget; } break; } case ATTACKING_TARGET_BOTTOMAGGRO: { advance(ritr, position); for (; ritr != threatlist.rend(); ++ritr) if (Unit* pTarget = GetMap()->GetUnit((*itr)->getUnitGuid())) if (!selectFlags || MeetsSelectAttackingRequirement(pTarget, pSpellInfo, selectFlags)) { return pTarget; } break; } } return NULL; } void Creature::_AddCreatureSpellCooldown(uint32 spell_id, time_t end_time) { m_CreatureSpellCooldowns[spell_id] = end_time; } void Creature::_AddCreatureCategoryCooldown(uint32 category, time_t apply_time) { m_CreatureCategoryCooldowns[category] = apply_time; } void Creature::AddCreatureSpellCooldown(uint32 spellid) { SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellid); if (!spellInfo) { return; } uint32 cooldown = GetSpellRecoveryTime(spellInfo); if (cooldown) { _AddCreatureSpellCooldown(spellid, time(NULL) + cooldown / IN_MILLISECONDS); } if (spellInfo->Category) { _AddCreatureCategoryCooldown(spellInfo->Category, time(NULL)); } } bool Creature::HasCategoryCooldown(uint32 spell_id) const { SpellEntry const* spellInfo = sSpellStore.LookupEntry(spell_id); if (!spellInfo) { return false; } CreatureSpellCooldowns::const_iterator itr = m_CreatureCategoryCooldowns.find(spellInfo->Category); return (itr != m_CreatureCategoryCooldowns.end() && time_t(itr->second + (spellInfo->CategoryRecoveryTime / IN_MILLISECONDS)) > time(NULL)); } uint32 Creature::GetCreatureSpellCooldownDelay(uint32 spellId) const { CreatureSpellCooldowns::const_iterator itr = m_CreatureSpellCooldowns.find(spellId); time_t t = time(NULL); return uint32(itr != m_CreatureSpellCooldowns.end() && itr->second > t ? itr->second - t : 0); } bool Creature::HasSpellCooldown(uint32 spell_id) const { CreatureSpellCooldowns::const_iterator itr = m_CreatureSpellCooldowns.find(spell_id); return (itr != m_CreatureSpellCooldowns.end() && itr->second > time(NULL)) || HasCategoryCooldown(spell_id); } bool Creature::IsInEvadeMode() const { return !i_motionMaster.empty() && i_motionMaster.GetCurrentMovementGeneratorType() == HOME_MOTION_TYPE; } bool Creature::HasSpell(uint32 spellID) const { uint8 i; for (i = 0; i < CREATURE_MAX_SPELLS; ++i) if (spellID == m_spells[i]) { break; } return i < CREATURE_MAX_SPELLS; // break before end of iteration of known spells } time_t Creature::GetRespawnTimeEx() const { time_t now = time(NULL); if (m_respawnTime > now) // dead (no corpse) { return m_respawnTime; } else if (m_corpseRemoveTime > time(NULL)) // dead (corpse) { return m_corpseRemoveTime + m_respawnDelay; } else { return now; } } void Creature::GetRespawnCoord(float& x, float& y, float& z, float* ori, float* dist) const { x = m_respawnPos.x; y = m_respawnPos.y; z = m_respawnPos.z; if (ori) { *ori = m_respawnPos.o; } if (dist) { *dist = GetRespawnRadius(); } // lets check if our creatures have valid spawn coordinates MANGOS_ASSERT(MaNGOS::IsValidMapCoord(x, y, z) || PrintCoordinatesError(x, y, z, "respawn")); } void Creature::ResetRespawnCoord() { if (CreatureData const* data = sObjectMgr.GetCreatureData(GetGUIDLow())) { m_respawnPos.x = data->posX; m_respawnPos.y = data->posY; m_respawnPos.z = data->posZ; m_respawnPos.o = data->orientation; } } void Creature::AllLootRemovedFromCorpse() { if (loot.loot_type != LOOT_SKINNING && !IsPet() && GetCreatureInfo()->LootId && GetLootRecipient()) { if (LootTemplates_Skinning.HaveLootFor(GetCreatureInfo()->LootId)) { // Check for Skinning Loot, and set flag is loot exists if (!lootForSkin) { HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE); } } } time_t now = time(NULL); if (m_corpseRemoveTime <= now) { return; } float decayRate = sWorld.getConfig(CONFIG_FLOAT_RATE_CORPSE_DECAY_LOOTED); // corpse skinnable, but without skinning flag, and then skinned, corpse will despawn next update if (loot.loot_type == LOOT_SKINNING) { m_corpseRemoveTime = now; } else { m_corpseRemoveTime = now + uint32(m_corpseDelay * decayRate); } m_respawnTime = m_corpseRemoveTime + m_respawnDelay; } uint32 Creature::GetLevelForTarget(Unit const* target) const { if (!IsWorldBoss()) { return Unit::GetLevelForTarget(target); } uint32 level = target->getLevel() + sWorld.getConfig(CONFIG_UINT32_WORLD_BOSS_LEVEL_DIFF); if (level < 1) { return 1; } if (level > 255) { return 255; } return level; } std::string Creature::GetAIName() const { return ObjectMgr::GetCreatureTemplate(GetEntry())->AIName; } std::string Creature::GetScriptName() const { return sScriptMgr.GetScriptName(GetScriptId()); } uint32 Creature::GetScriptId() const { // scripts bound to DB guid have priority over ones bound to creature entry return sScriptMgr.GetBoundScriptId(SCRIPTED_UNIT, -int32(GetGUIDLow())) ? sScriptMgr.GetBoundScriptId(SCRIPTED_UNIT, -int32(GetGUIDLow())) : sScriptMgr.GetBoundScriptId(SCRIPTED_UNIT, GetEntry()); } VendorItemData const* Creature::GetVendorItems() const { return sObjectMgr.GetNpcVendorItemList(GetEntry()); } VendorItemData const* Creature::GetVendorTemplateItems() const { uint32 vendorId = GetCreatureInfo()->VendorTemplateId; return vendorId ? sObjectMgr.GetNpcVendorTemplateItemList(vendorId) : NULL; } uint32 Creature::GetVendorItemCurrentCount(VendorItem const* vItem) { if (!vItem->maxcount) { return vItem->maxcount; } VendorItemCounts::iterator itr = m_vendorItemCounts.begin(); for (; itr != m_vendorItemCounts.end(); ++itr) if (itr->itemId == vItem->item) { break; } if (itr == m_vendorItemCounts.end()) { return vItem->maxcount; } VendorItemCount* vCount = &*itr; time_t ptime = time(NULL); if (vCount->lastIncrementTime + vItem->incrtime <= ptime) { ItemPrototype const* pProto = ObjectMgr::GetItemPrototype(vItem->item); uint32 diff = uint32((ptime - vCount->lastIncrementTime) / vItem->incrtime); if ((vCount->count + diff * pProto->BuyCount) >= vItem->maxcount) { m_vendorItemCounts.erase(itr); return vItem->maxcount; } vCount->count += diff * pProto->BuyCount; vCount->lastIncrementTime = ptime; } return vCount->count; } uint32 Creature::UpdateVendorItemCurrentCount(VendorItem const* vItem, uint32 used_count) { if (!vItem->maxcount) { return 0; } VendorItemCounts::iterator itr = m_vendorItemCounts.begin(); for (; itr != m_vendorItemCounts.end(); ++itr) if (itr->itemId == vItem->item) { break; } if (itr == m_vendorItemCounts.end()) { uint32 new_count = vItem->maxcount > used_count ? vItem->maxcount - used_count : 0; m_vendorItemCounts.push_back(VendorItemCount(vItem->item, new_count)); return new_count; } VendorItemCount* vCount = &*itr; time_t ptime = time(NULL); if (vCount->lastIncrementTime + vItem->incrtime <= ptime) { ItemPrototype const* pProto = ObjectMgr::GetItemPrototype(vItem->item); uint32 diff = uint32((ptime - vCount->lastIncrementTime) / vItem->incrtime); if ((vCount->count + diff * pProto->BuyCount) < vItem->maxcount) { vCount->count += diff * pProto->BuyCount; } else { vCount->count = vItem->maxcount; } } vCount->count = vCount->count > used_count ? vCount->count - used_count : 0; vCount->lastIncrementTime = ptime; return vCount->count; } TrainerSpellData const* Creature::GetTrainerTemplateSpells() const { uint32 trainerId = GetCreatureInfo()->TrainerTemplateId; return trainerId ? sObjectMgr.GetNpcTrainerTemplateSpells(trainerId) : NULL; } TrainerSpellData const* Creature::GetTrainerSpells() const { return sObjectMgr.GetNpcTrainerSpells(GetEntry()); } // overwrite WorldObject function for proper name localization const char* Creature::GetNameForLocaleIdx(int32 loc_idx) const { char const* name = GetName(); sObjectMgr.GetCreatureLocaleStrings(GetEntry(), loc_idx, &name); return name; } void Creature::SetFactionTemporary(uint32 factionId, uint32 tempFactionFlags) { m_temporaryFactionFlags = tempFactionFlags; setFaction(factionId); if (m_temporaryFactionFlags & TEMPFACTION_TOGGLE_NON_ATTACKABLE) { RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE); } if (m_temporaryFactionFlags & TEMPFACTION_TOGGLE_OOC_NOT_ATTACK) { RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE); } if (m_temporaryFactionFlags & TEMPFACTION_TOGGLE_PASSIVE) { RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PASSIVE); } if (m_temporaryFactionFlags & TEMPFACTION_TOGGLE_PACIFIED) { RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED); } if (m_temporaryFactionFlags & TEMPFACTION_TOGGLE_NOT_SELECTABLE) { RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE); } } void Creature::ClearTemporaryFaction() { // No restore if creature is charmed/possessed. // For later we may consider extend to restore to charmer faction where charmer is creature. // This can also be done by update any pet/charmed of creature at any faction change to charmer. if (IsCharmed()) { return; } // Reset to original faction setFaction(GetCreatureInfo()->FactionAlliance); // Reset UNIT_FLAG_NON_ATTACKABLE, UNIT_FLAG_OOC_NOT_ATTACKABLE, UNIT_FLAG_PASSIVE, UNIT_FLAG_PACIFIED or UNIT_FLAG_NOT_SELECTABLE flags if (m_temporaryFactionFlags & TEMPFACTION_TOGGLE_NON_ATTACKABLE && GetCreatureInfo()->UnitFlags & UNIT_FLAG_NON_ATTACKABLE) { SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE); } if (m_temporaryFactionFlags & TEMPFACTION_TOGGLE_OOC_NOT_ATTACK && GetCreatureInfo()->UnitFlags & UNIT_FLAG_OOC_NOT_ATTACKABLE && !IsInCombat()) { SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE); } if (m_temporaryFactionFlags & TEMPFACTION_TOGGLE_PASSIVE && GetCreatureInfo()->UnitFlags & UNIT_FLAG_PASSIVE) { SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PASSIVE); } if (m_temporaryFactionFlags & TEMPFACTION_TOGGLE_PACIFIED && GetCreatureInfo()->UnitFlags & UNIT_FLAG_PACIFIED) { SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED); } if (m_temporaryFactionFlags & TEMPFACTION_TOGGLE_NOT_SELECTABLE && GetCreatureInfo()->UnitFlags & UNIT_FLAG_NOT_SELECTABLE) { SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE); } m_temporaryFactionFlags = TEMPFACTION_NONE; } void Creature::SendAreaSpiritHealerQueryOpcode(Player* pl) { uint32 next_resurrect = 0; if (Spell* pcurSpell = GetCurrentSpell(CURRENT_CHANNELED_SPELL)) { next_resurrect = pcurSpell->GetCastedTime(); } WorldPacket data(SMSG_AREA_SPIRIT_HEALER_TIME, 8 + 4); data << ObjectGuid(GetObjectGuid()); data << uint32(next_resurrect); pl->SendDirectMessage(&data); } void Creature::ApplyGameEventSpells(GameEventCreatureData const* eventData, bool activated) { uint32 cast_spell = activated ? eventData->spell_id_start : eventData->spell_id_end; uint32 remove_spell = activated ? eventData->spell_id_end : eventData->spell_id_start; if (remove_spell) if (SpellEntry const* spellEntry = sSpellStore.LookupEntry(remove_spell)) if (IsSpellAppliesAura(spellEntry)) { RemoveAurasDueToSpell(remove_spell); } if (cast_spell) { CastSpell(this, cast_spell, true); } } void Creature::FillGuidsListFromThreatList(GuidVector& guids, uint32 maxamount /*= 0*/) { if (!CanHaveThreatList()) { return; } ThreatList const& threats = GetThreatManager().getThreatList(); maxamount = maxamount > 0 ? std::min(maxamount, uint32(threats.size())) : threats.size(); guids.reserve(guids.size() + maxamount); for (ThreatList::const_iterator itr = threats.begin(); maxamount && itr != threats.end(); ++itr, --maxamount) { guids.push_back((*itr)->getUnitGuid()); } } struct AddCreatureToRemoveListInMapsWorker { AddCreatureToRemoveListInMapsWorker(ObjectGuid guid) : i_guid(guid) {} void operator()(Map* map) { if (Creature* pCreature = map->GetCreature(i_guid)) { pCreature->AddObjectToRemoveList(); } } ObjectGuid i_guid; }; void Creature::AddToRemoveListInMaps(uint32 db_guid, CreatureData const* data) { AddCreatureToRemoveListInMapsWorker worker(data->GetObjectGuid(db_guid)); sMapMgr.DoForAllMapsWithMapId(data->mapid, worker); } struct SpawnCreatureInMapsWorker { SpawnCreatureInMapsWorker(uint32 guid, CreatureData const* data) : i_guid(guid), i_data(data) {} void operator()(Map* map) { // We use spawn coords to spawn if (map->IsLoaded(i_data->posX, i_data->posY)) { Creature* pCreature = new Creature; // DEBUG_LOG("Spawning creature %u",*itr); if (!pCreature->LoadFromDB(i_guid, map)) { delete pCreature; } else { map->Add(pCreature); } } } uint32 i_guid; CreatureData const* i_data; }; void Creature::SpawnInMaps(uint32 db_guid, CreatureData const* data) { SpawnCreatureInMapsWorker worker(db_guid, data); sMapMgr.DoForAllMapsWithMapId(data->mapid, worker); } bool Creature::HasStaticDBSpawnData() const { return sObjectMgr.GetCreatureData(GetGUIDLow()) != NULL; } void Creature::SetVirtualItem(VirtualItemSlot slot, uint32 item_id) { if (item_id == 0) { SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY + slot, 0); SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO + (slot * 2) + 0, 0); SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO + (slot * 2) + 1, 0); return; } EquipmentInfoItem const* proto = ObjectMgr::GetEquipmentInfoItem(item_id); if (!proto) { sLog.outError("Not listed in 'creature_item_template' item (ID:%u) used as virtual item for %s", item_id, GetGuidStr().c_str()); return; } SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY + slot, proto->DisplayID); SetByteValue(UNIT_VIRTUAL_ITEM_INFO + (slot * 2) + 0, VIRTUAL_ITEM_INFO_0_OFFSET_CLASS, proto->Class); SetByteValue(UNIT_VIRTUAL_ITEM_INFO + (slot * 2) + 0, VIRTUAL_ITEM_INFO_0_OFFSET_SUBCLASS, proto->SubClass); SetByteValue(UNIT_VIRTUAL_ITEM_INFO + (slot * 2) + 0, VIRTUAL_ITEM_INFO_0_OFFSET_MATERIAL, proto->Material); SetByteValue(UNIT_VIRTUAL_ITEM_INFO + (slot * 2) + 0, VIRTUAL_ITEM_INFO_0_OFFSET_INVENTORYTYPE, proto->InventoryType); SetByteValue(UNIT_VIRTUAL_ITEM_INFO + (slot * 2) + 1, VIRTUAL_ITEM_INFO_1_OFFSET_SHEATH, proto->Sheath); } void Creature::SetVirtualItemRaw(VirtualItemSlot slot, uint32 display_id, uint32 info0, uint32 info1) { SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY + slot, display_id); SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO + (slot * 2) + 0, info0); SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO + (slot * 2) + 1, info1); } void Creature::SetWalk(bool enable, bool asDefault) { if (asDefault) { if (enable) { clearUnitState(UNIT_STAT_RUNNING); } else { addUnitState(UNIT_STAT_RUNNING); } } // Nothing changed? if (enable == m_movementInfo.HasMovementFlag(MOVEFLAG_WALK_MODE)) { return; } if (enable) { m_movementInfo.AddMovementFlag(MOVEFLAG_WALK_MODE); } else { m_movementInfo.RemoveMovementFlag(MOVEFLAG_WALK_MODE); } WorldPacket data(enable ? SMSG_SPLINE_MOVE_SET_WALK_MODE : SMSG_SPLINE_MOVE_SET_RUN_MODE, 9); data << GetPackGUID(); SendMessageToSet(&data, true); } void Creature::SetLevitate(bool enable) { if (enable) { m_movementInfo.AddMovementFlag(MOVEFLAG_LEVITATING); } else { m_movementInfo.RemoveMovementFlag(MOVEFLAG_LEVITATING); } } void Creature::SetSwim(bool enable) { if (enable) m_movementInfo.AddMovementFlag(MOVEFLAG_SWIMMING); else m_movementInfo.RemoveMovementFlag(MOVEFLAG_SWIMMING); WorldPacket data(enable ? SMSG_SPLINE_MOVE_START_SWIM : SMSG_SPLINE_MOVE_STOP_SWIM); data << GetPackGUID(); SendMessageToSet(&data, true); } void Creature::SetCanFly(bool enable) { // TODO: check if there is something similar for 1.12.x (dragons and other flying NPCs) // if (enable) // m_movementInfo.AddMovementFlag(MOVEFLAG_CAN_FLY); // else // m_movementInfo.RemoveMovementFlag(MOVEFLAG_CAN_FLY); // // WorldPacket data(enable ? SMSG_SPLINE_MOVE_SET_FLYING : SMSG_SPLINE_MOVE_UNSET_FLYING, 9); // data << GetPackGUID(); // SendMessageToSet(&data, true); } void Creature::SetFeatherFall(bool enable) { if (enable) m_movementInfo.AddMovementFlag(MOVEFLAG_SAFE_FALL); else m_movementInfo.RemoveMovementFlag(MOVEFLAG_SAFE_FALL); WorldPacket data(enable ? SMSG_SPLINE_MOVE_FEATHER_FALL : SMSG_SPLINE_MOVE_NORMAL_FALL); data << GetPackGUID(); SendMessageToSet(&data, true); } void Creature::SetHover(bool enable) { if (enable) m_movementInfo.AddMovementFlag(MOVEFLAG_HOVER); else m_movementInfo.RemoveMovementFlag(MOVEFLAG_HOVER); WorldPacket data(enable ? SMSG_SPLINE_MOVE_SET_HOVER : SMSG_SPLINE_MOVE_UNSET_HOVER, 9); data << GetPackGUID(); SendMessageToSet(&data, false); } void Creature::SetRoot(bool enable) { if (enable) m_movementInfo.AddMovementFlag(MOVEFLAG_ROOT); else m_movementInfo.RemoveMovementFlag(MOVEFLAG_ROOT); WorldPacket data(enable ? SMSG_SPLINE_MOVE_ROOT : SMSG_SPLINE_MOVE_UNROOT, 9); data << GetPackGUID(); SendMessageToSet(&data, true); } void Creature::SetWaterWalk(bool enable) { if (enable) { m_movementInfo.AddMovementFlag(MOVEFLAG_WATERWALKING); } else { m_movementInfo.RemoveMovementFlag(MOVEFLAG_WATERWALKING); } WorldPacket data(enable ? SMSG_SPLINE_MOVE_WATER_WALK : SMSG_SPLINE_MOVE_LAND_WALK, 9); data << GetPackGUID(); SendMessageToSet(&data, true); }