1. /*
  2. * Copyright (C) 2008-2011 TrinityCore <http://www.trinitycore.org/>
  3. * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
  4. *
  5. * This program is free software; you can redistribute it and/or modify it
  6. * under the terms of the GNU General Public License as published by the
  7. * Free Software Foundation; either version 2 of the License, or (at your
  8. * option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful, but WITHOUT
  11. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  13. * more details.
  14. *
  15. * You should have received a copy of the GNU General Public License along
  16. * with this program. If not, see <http://www.gnu.org/licenses/>.
  17. */
  19. #include "Common.h"
  20. #include "DatabaseEnv.h"
  21. #include "WorldPacket.h"
  22. #include "World.h"
  23. #include "ObjectMgr.h"
  24. #include "SpellMgr.h"
  25. #include "Creature.h"
  26. #include "QuestDef.h"
  27. #include "GossipDef.h"
  28. #include "Player.h"
  29. #include "PoolMgr.h"
  30. #include "Opcodes.h"
  31. #include "Log.h"
  32. #include "LootMgr.h"
  33. #include "MapManager.h"
  34. #include "CreatureAI.h"
  35. #include "CreatureAISelector.h"
  36. #include "Formulas.h"
  37. #include "WaypointMovementGenerator.h"
  38. #include "InstanceScript.h"
  39. #include "BattlegroundMgr.h"
  40. #include "Util.h"
  41. #include "GridNotifiers.h"
  42. #include "GridNotifiersImpl.h"
  43. #include "CellImpl.h"
  44. #include "OutdoorPvPMgr.h"
  45. #include "GameEventMgr.h"
  46. #include "CreatureGroups.h"
  47. #include "Vehicle.h"
  48. #include "SpellAuraEffects.h"
  49. #include "Group.h"
  50. // apply implementation of the singletons
  52. TrainerSpell const* TrainerSpellData::Find(uint32 spell_id) const
  53. {
  54. TrainerSpellMap::const_iterator itr = spellList.find(spell_id);
  55. if (itr != spellList.end())
  56. return &itr->second;
  58. return NULL;
  59. }
  61. bool VendorItemData::RemoveItem(uint32 item_id)
  62. {
  63. bool found = false;
  64. for (VendorItemList::iterator i = m_items.begin(); i != m_items.end();)
  65. {
  66. if ((*i)->item == item_id)
  67. {
  68. i = m_items.erase(i++);
  69. found = true;
  70. }
  71. else
  72. ++i;
  73. }
  74. return found;
  75. }
  77. VendorItem const* VendorItemData::FindItemCostPair(uint32 item_id, uint32 extendedCost) const
  78. {
  79. for (VendorItemList::const_iterator i = m_items.begin(); i != m_items.end(); ++i)
  80. if((*i)->item == item_id && (*i)->ExtendedCost == extendedCost)
  81. return *i;
  82. return NULL;
  83. }
  85. uint32 CreatureInfo::GetRandomValidModelId() const
  86. {
  87. uint8 c = 0;
  88. uint32 modelIDs[4];
  90. if (Modelid1) modelIDs[c++] = Modelid1;
  91. if (Modelid2) modelIDs[c++] = Modelid2;
  92. if (Modelid3) modelIDs[c++] = Modelid3;
  93. if (Modelid4) modelIDs[c++] = Modelid4;
  95. return ((c>0) ? modelIDs[urand(0,c-1)] : 0);
  96. }
  98. uint32 CreatureInfo::GetFirstValidModelId() const
  99. {
  100. if (Modelid1) return Modelid1;
  101. if (Modelid2) return Modelid2;
  102. if (Modelid3) return Modelid3;
  103. if (Modelid4) return Modelid4;
  104. return 0;
  105. }
  107. bool AssistDelayEvent::Execute(uint64 /*e_time*/, uint32 /*p_time*/)
  108. {
  109. if (Unit* victim = Unit::GetUnit(m_owner, m_victim))
  110. {
  111. while (!m_assistants.empty())
  112. {
  113. Creature* assistant = Unit::GetCreature(m_owner, *m_assistants.begin());
  114. m_assistants.pop_front();
  116. if (assistant && assistant->CanAssistTo(&m_owner, victim))
  117. {
  118. assistant->SetNoCallAssistance(true);
  119. assistant->CombatStart(victim);
  120. if (assistant->IsAIEnabled)
  121. assistant->AI()->AttackStart(victim);
  122. }
  123. }
  124. }
  125. return true;
  126. }
  128. CreatureBaseStats const* CreatureBaseStats::GetBaseStats(uint8 level, uint8 unitClass)
  129. {
  130. return sObjectMgr->GetCreatureBaseStats(level, unitClass);
  131. }
  133. bool ForcedDespawnDelayEvent::Execute(uint64 /*e_time*/, uint32 /*p_time*/)
  134. {
  135. m_owner.ForcedDespawn();
  136. return true;
  137. }
  139. Creature::Creature(): Unit(),
  140. lootForPickPocketed(false), lootForBody(false), m_groupLootTimer(0), lootingGroupLowGUID(0),
  141. m_PlayerDamageReq(0), m_lootMoney(0), m_lootRecipient(0), m_lootRecipientGroup(0), m_corpseRemoveTime(0), m_respawnTime(0),
  142. m_respawnDelay(300), m_corpseDelay(60), m_respawnradius(0.0f), m_reactState(REACT_AGGRESSIVE),
  143. m_defaultMovementType(IDLE_MOTION_TYPE), m_DBTableGuid(0), m_equipmentId(0), m_AlreadyCallAssistance(false),
  144. m_AlreadySearchedAssistance(false), m_regenHealth(true), m_AI_locked(false), m_isDeadByDefault(false),
  145. m_meleeDamageSchoolMask(SPELL_SCHOOL_MASK_NORMAL), m_creatureInfo(NULL), m_creatureData(NULL),
  146. m_formation(NULL)
  147. {
  148. m_regenTimer = CREATURE_REGEN_INTERVAL;
  149. m_valuesCount = UNIT_END;
  151. for (uint8 i = 0; i < CREATURE_MAX_SPELLS; ++i)
  152. m_spells[i] = 0;
  154. m_CreatureSpellCooldowns.clear();
  155. m_CreatureCategoryCooldowns.clear();
  156. DisableReputationGain = false;
  158. m_SightDistance = sWorld->getFloatConfig(CONFIG_SIGHT_MONSTER);
  159. m_CombatDistance = 0;//MELEE_RANGE;
  161. ResetLootMode(); // restore default loot mode
  162. TriggerJustRespawned = false;
  163. }
  165. Creature::~Creature()
  166. {
  167. m_vendorItemCounts.clear();
  169. delete i_AI;
  170. i_AI = NULL;
  172. //if (m_uint32Values)
  173. // sLog->outError("Deconstruct Creature Entry = %u", GetEntry());
  174. }
  176. void Creature::AddToWorld()
  177. {
  178. ///- Register the creature for guid lookup
  179. if (!IsInWorld())
  180. {
  181. if (m_zoneScript)
  182. m_zoneScript->OnCreatureCreate(this);
  183. sObjectAccessor->AddObject(this);
  184. Unit::AddToWorld();
  185. SearchFormation();
  186. AIM_Initialize();
  187. if (IsVehicle())
  188. GetVehicleKit()->Install();
  189. }
  190. }
  192. void Creature::RemoveFromWorld()
  193. {
  194. if (IsInWorld())
  195. {
  196. if (m_zoneScript)
  197. m_zoneScript->OnCreatureRemove(this);
  198. if (m_formation)
  199. sFormationMgr->RemoveCreatureFromGroup(m_formation, this);
  200. Unit::RemoveFromWorld();
  201. sObjectAccessor->RemoveObject(this);
  202. }
  203. }
  205. void Creature::DisappearAndDie()
  206. {
  207. DestroyForNearbyPlayers();
  208. //SetVisibility(VISIBILITY_OFF);
  209. //ObjectAccessor::UpdateObjectVisibility(this);
  210. if (isAlive())
  211. setDeathState(JUST_DIED);
  212. RemoveCorpse(false);
  213. }
  215. void Creature::SearchFormation()
  216. {
  217. if (isSummon())
  218. return;
  220. uint32 lowguid = GetDBTableGUIDLow();
  221. if (!lowguid)
  222. return;
  224. CreatureGroupInfoType::iterator frmdata = CreatureGroupMap.find(lowguid);
  225. if (frmdata != CreatureGroupMap.end())
  226. sFormationMgr->AddCreatureToGroup(frmdata->second->leaderGUID, this);
  227. }
  229. void Creature::RemoveCorpse(bool setSpawnTime)
  230. {
  231. if ((getDeathState() != CORPSE && !m_isDeadByDefault) || (getDeathState() != ALIVE && m_isDeadByDefault))
  232. return;
  234. m_corpseRemoveTime = time(NULL);
  235. setDeathState(DEAD);
  236. UpdateObjectVisibility();
  237. loot.clear();
  238. uint32 respawnDelay = m_respawnDelay;
  239. if (IsAIEnabled)
  240. AI()->CorpseRemoved(respawnDelay);
  242. // Should get removed later, just keep "compatibility" with scripts
  243. if(setSpawnTime)
  244. m_respawnTime = time(NULL) + respawnDelay;
  246. float x,y,z,o;
  247. GetRespawnCoord(x, y, z, &o);
  248. SetHomePosition(x,y,z,o);
  249. GetMap()->CreatureRelocation(this,x,y,z,o);
  250. }
  252. /**
  253. * change the entry of creature until respawn
  254. */
  255. bool Creature::InitEntry(uint32 Entry, uint32 /*team*/, const CreatureData *data)
  256. {
  257. CreatureInfo const *normalInfo = ObjectMgr::GetCreatureTemplate(Entry);
  258. if (!normalInfo)
  259. {
  260. sLog->outErrorDb("Creature::InitEntry creature entry %u does not exist.", Entry);
  261. return false;
  262. }
  264. // get difficulty 1 mode entry
  265. CreatureInfo const *cinfo = normalInfo;
  266. for (uint8 diff = uint8(GetMap()->GetSpawnMode()); diff > 0;)
  267. {
  268. // we already have valid Map pointer for current creature!
  269. if (normalInfo->DifficultyEntry[diff - 1])
  270. {
  271. cinfo = ObjectMgr::GetCreatureTemplate(normalInfo->DifficultyEntry[diff - 1]);
  272. if (cinfo)
  273. break; // template found
  275. // check and reported at startup, so just ignore (restore normalInfo)
  276. cinfo = normalInfo;
  277. }
  279. // for instances heroic to normal, other cases attempt to retrieve previous difficulty
  280. if (diff >= RAID_DIFFICULTY_10MAN_HEROIC && GetMap()->IsRaid())
  281. diff -= 2; // to normal raid difficulty cases
  282. else
  283. --diff;
  284. }
  286. SetEntry(Entry); // normal entry always
  287. m_creatureInfo = cinfo; // map mode related always
  289. // equal to player Race field, but creature does not have race
  290. SetByteValue(UNIT_FIELD_BYTES_0, 0, 0);
  292. // known valid are: CLASS_WARRIOR,CLASS_PALADIN,CLASS_ROGUE,CLASS_MAGE
  293. SetByteValue(UNIT_FIELD_BYTES_0, 1, uint8(cinfo->unit_class));
  295. // Cancel load if no model defined
  296. if (!(cinfo->GetFirstValidModelId()))
  297. {
  298. sLog->outErrorDb("Creature (Entry: %u) has no model defined in table `creature_template`, can't load. ",Entry);
  299. return false;
  300. }
  302. uint32 display_id = sObjectMgr->ChooseDisplayId(0, GetCreatureInfo(), data);
  303. CreatureModelInfo const *minfo = sObjectMgr->GetCreatureModelRandomGender(display_id);
  304. if (!minfo) // Cancel load if no model defined
  305. {
  306. sLog->outErrorDb("Creature (Entry: %u) has no model defined in table `creature_template`, can't load. ",Entry);
  307. return false;
  308. }
  310. display_id = minfo->modelid; // it can be different (for another gender)
  312. SetDisplayId(display_id);
  313. SetNativeDisplayId(display_id);
  314. SetByteValue(UNIT_FIELD_BYTES_0, 2, minfo->gender);
  316. // Load creature equipment
  317. if (!data || data->equipmentId == 0) // use default from the template
  318. LoadEquipment(cinfo->equipmentId);
  319. else if (data && data->equipmentId != -1) // override, -1 means no equipment
  320. LoadEquipment(data->equipmentId);
  322. SetName(normalInfo->Name); // at normal entry always
  324. SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS,minfo->bounding_radius);
  325. SetFloatValue(UNIT_FIELD_COMBATREACH,minfo->combat_reach);
  327. SetFloatValue(UNIT_MOD_CAST_SPEED, 1.0f);
  329. SetSpeed(MOVE_WALK, cinfo->speed_walk);
  330. SetSpeed(MOVE_RUN, cinfo->speed_run);
  331. SetSpeed(MOVE_SWIM, 1.0f); // using 1.0 rate
  332. SetSpeed(MOVE_FLIGHT, 1.0f); // using 1.0 rate
  334. SetFloatValue(OBJECT_FIELD_SCALE_X, cinfo->scale);
  336. // checked at loading
  337. m_defaultMovementType = MovementGeneratorType(cinfo->MovementType);
  338. if (!m_respawnradius && m_defaultMovementType == RANDOM_MOTION_TYPE)
  339. m_defaultMovementType = IDLE_MOTION_TYPE;
  341. for (uint8 i=0; i < CREATURE_MAX_SPELLS; ++i)
  342. m_spells[i] = GetCreatureInfo()->spells[i];
  344. return true;
  345. }
  347. bool Creature::UpdateEntry(uint32 Entry, uint32 team, const CreatureData *data)
  348. {
  349. if (!InitEntry(Entry,team,data))
  350. return false;
  352. CreatureInfo const* cInfo = GetCreatureInfo();
  354. m_regenHealth = cInfo->RegenHealth;
  356. // creatures always have melee weapon ready if any
  357. SetSheath(SHEATH_STATE_MELEE);
  359. SelectLevel(GetCreatureInfo());
  360. if (team == HORDE)
  361. setFaction(cInfo->faction_H);
  362. else
  363. setFaction(cInfo->faction_A);
  365. uint32 npcflag, unit_flags, dynamicflags;
  366. ObjectMgr::ChooseCreatureFlags(cInfo, npcflag, unit_flags, dynamicflags, data);
  368. if (cInfo->flags_extra & CREATURE_FLAG_EXTRA_WORLDEVENT)
  369. SetUInt32Value(UNIT_NPC_FLAGS, npcflag | sGameEventMgr->GetNPCFlag(this));
  370. else
  371. SetUInt32Value(UNIT_NPC_FLAGS, npcflag);
  373. SetAttackTime(BASE_ATTACK, cInfo->baseattacktime);
  374. SetAttackTime(OFF_ATTACK, cInfo->baseattacktime);
  375. SetAttackTime(RANGED_ATTACK,cInfo->rangeattacktime);
  377. SetUInt32Value(UNIT_FIELD_FLAGS, unit_flags);
  379. SetUInt32Value(UNIT_DYNAMIC_FLAGS, dynamicflags);
  381. RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
  383. SetMeleeDamageSchool(SpellSchools(cInfo->dmgschool));
  384. CreatureBaseStats const* stats = sObjectMgr->GetCreatureBaseStats(getLevel(), cInfo->unit_class);
  385. float armor = (float)stats->GenerateArmor(cInfo); // TODO: Why is this treated as uint32 when it's a float?
  386. SetModifierValue(UNIT_MOD_ARMOR, BASE_VALUE, armor);
  387. SetModifierValue(UNIT_MOD_RESISTANCE_HOLY, BASE_VALUE, float(cInfo->resistance1));
  388. SetModifierValue(UNIT_MOD_RESISTANCE_FIRE, BASE_VALUE, float(cInfo->resistance2));
  389. SetModifierValue(UNIT_MOD_RESISTANCE_NATURE, BASE_VALUE, float(cInfo->resistance3));
  390. SetModifierValue(UNIT_MOD_RESISTANCE_FROST, BASE_VALUE, float(cInfo->resistance4));
  391. SetModifierValue(UNIT_MOD_RESISTANCE_SHADOW, BASE_VALUE, float(cInfo->resistance5));
  392. SetModifierValue(UNIT_MOD_RESISTANCE_ARCANE, BASE_VALUE, float(cInfo->resistance6));
  394. SetCanModifyStats(true);
  395. UpdateAllStats();
  397. // checked and error show at loading templates
  398. if (FactionTemplateEntry const* factionTemplate = sFactionTemplateStore.LookupEntry(cInfo->faction_A))
  399. {
  400. if (factionTemplate->factionFlags & FACTION_TEMPLATE_FLAG_PVP)
  401. SetPvP(true);
  402. else
  403. SetPvP(false);
  404. }
  406. // trigger creature is always not selectable and can not be attacked
  407. if (isTrigger())
  408. SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
  410. InitializeReactState();
  412. if (cInfo->flags_extra & CREATURE_FLAG_EXTRA_NO_TAUNT)
  413. {
  414. ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
  415. ApplySpellImmune(0, IMMUNITY_EFFECT,SPELL_EFFECT_ATTACK_ME, true);
  416. }
  418. // TODO: In fact monster move flags should be set - not movement flags.
  419. if (cInfo->InhabitType & INHABIT_AIR)
  420. AddUnitMovementFlag(MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_FLYING);
  422. if (cInfo->InhabitType & INHABIT_WATER)
  423. AddUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
  425. return true;
  426. }
  428. void Creature::Update(uint32 diff)
  429. {
  430. if (IsAIEnabled && TriggerJustRespawned)
  431. {
  432. TriggerJustRespawned = false;
  433. AI()->JustRespawned();
  434. if (m_vehicleKit)
  435. m_vehicleKit->Reset();
  436. }
  438. switch(m_deathState)
  439. {
  440. case JUST_ALIVED:
  441. // Don't must be called, see Creature::setDeathState JUST_ALIVED -> ALIVE promoting.
  442. sLog->outError("Creature (GUID: %u Entry: %u) in wrong state: JUST_ALIVED (4)",GetGUIDLow(),GetEntry());
  443. break;
  444. case JUST_DIED:
  445. // Don't must be called, see Creature::setDeathState JUST_DIED -> CORPSE promoting.
  446. sLog->outError("Creature (GUID: %u Entry: %u) in wrong state: JUST_DEAD (1)",GetGUIDLow(),GetEntry());
  447. break;
  448. case DEAD:
  449. {
  450. time_t now = time(NULL);
  451. if (m_respawnTime <= now)
  452. {
  453. bool allowed = IsAIEnabled ? AI()->CanRespawn() : true; // First check if there are any scripts that object to us respawning
  454. if (!allowed) // Will be rechecked on next Update call
  455. break;
  457. uint64 dbtableHighGuid = MAKE_NEW_GUID(m_DBTableGuid, GetEntry(), HIGHGUID_UNIT);
  458. time_t linkedRespawntime = sObjectMgr->GetLinkedRespawnTime(dbtableHighGuid, GetMap()->GetInstanceId());
  459. if (!linkedRespawntime) // Can respawn
  460. Respawn();
  461. else // the master is dead
  462. {
  463. uint64 targetGuid = sObjectMgr->GetLinkedRespawnGuid(GetGUID());
  464. if (targetGuid == GetGUID()) // if linking self, never respawn (check delayed to next day)
  465. SetRespawnTime(DAY);
  466. else
  467. m_respawnTime = (now > linkedRespawntime ? now : linkedRespawntime)+urand(5,MINUTE); // else copy time from master and add a little
  468. SaveRespawnTime(); // also save to DB immediately
  469. }
  470. }
  471. break;
  472. }
  473. case CORPSE:
  474. {
  475. if (m_isDeadByDefault)
  476. break;
  478. if (m_groupLootTimer && lootingGroupLowGUID)
  479. {
  480. // for delayed spells
  481. m_Events.Update(diff);
  483. if (m_groupLootTimer <= diff)
  484. {
  485. Group* group = sObjectMgr->GetGroupByGUID(lootingGroupLowGUID);
  486. if (group)
  487. group->EndRoll(&loot);
  488. m_groupLootTimer = 0;
  489. lootingGroupLowGUID = 0;
  490. }
  491. else m_groupLootTimer -= diff;
  492. }
  493. else if (m_corpseRemoveTime <= time(NULL))
  494. {
  495. RemoveCorpse(false);
  496. sLog->outStaticDebug("Removing corpse... %u ", GetUInt32Value(OBJECT_FIELD_ENTRY));
  497. }
  498. else
  499. {
  500. // for delayed spells
  501. m_Events.Update(diff);
  502. }
  504. break;
  505. }
  506. case ALIVE:
  507. {
  508. if (m_isDeadByDefault)
  509. {
  510. if (m_corpseRemoveTime <= time(NULL))
  511. {
  512. RemoveCorpse(false);
  513. sLog->outStaticDebug("Removing alive corpse... %u ", GetUInt32Value(OBJECT_FIELD_ENTRY));
  514. }
  515. }
  517. Unit::Update(diff);
  519. // creature can be dead after Unit::Update call
  520. // CORPSE/DEAD state will processed at next tick (in other case death timer will be updated unexpectedly)
  521. if (!isAlive())
  522. break;
  524. // if creature is charmed, switch to charmed AI
  525. if (NeedChangeAI)
  526. {
  527. UpdateCharmAI();
  528. NeedChangeAI = false;
  529. IsAIEnabled = true;
  530. }
  532. if (!IsInEvadeMode() && IsAIEnabled)
  533. {
  534. // do not allow the AI to be changed during update
  535. m_AI_locked = true;
  536. i_AI->UpdateAI(diff);
  537. m_AI_locked = false;
  538. }
  540. // creature can be dead after UpdateAI call
  541. // CORPSE/DEAD state will processed at next tick (in other case death timer will be updated unexpectedly)
  542. if (!isAlive())
  543. break;
  545. if (m_regenTimer > 0)
  546. {
  547. if (diff >= m_regenTimer)
  548. m_regenTimer = 0;
  549. else
  550. m_regenTimer -= diff;
  551. }
  553. if (m_regenTimer != 0)
  554. break;
  556. bool bInCombat = isInCombat() && (!getVictim() || // if isInCombat() is true and this has no victim
  557. !getVictim()->GetCharmerOrOwnerPlayerOrPlayerItself() || // or the victim/owner/charmer is not a player
  558. !getVictim()->GetCharmerOrOwnerPlayerOrPlayerItself()->isGameMaster()); // or the victim/owner/charmer is not a GameMaster
  560. /*if (m_regenTimer <= diff)
  561. {*/
  562. if (!IsInEvadeMode() && (!bInCombat || IsPolymorphed())) // regenerate health if not in combat or if polymorphed
  563. RegenerateHealth();
  565. if (getPowerType() == POWER_ENERGY)
  566. {
  567. if (!IsVehicle() || GetVehicleKit()->GetVehicleInfo()->m_powerType != POWER_PYRITE)
  568. Regenerate(POWER_ENERGY);
  569. }
  570. else
  571. RegenerateMana();
  573. /*if (!bIsPolymorphed) // only increase the timer if not polymorphed
  574. m_regenTimer += CREATURE_REGEN_INTERVAL - diff;
  575. }
  576. else
  577. if (!bIsPolymorphed) // if polymorphed, skip the timer
  578. m_regenTimer -= diff;*/
  579. m_regenTimer = CREATURE_REGEN_INTERVAL;
  580. break;
  581. }
  582. case DEAD_FALLING:
  583. GetMotionMaster()->UpdateMotion(diff);
  584. break;
  585. default:
  586. break;
  587. }
  589. sScriptMgr->OnCreatureUpdate(this, diff);
  590. }
  592. void Creature::RegenerateMana()
  593. {
  594. uint32 curValue = GetPower(POWER_MANA);
  595. uint32 maxValue = GetMaxPower(POWER_MANA);
  597. if (curValue >= maxValue)
  598. return;
  600. uint32 addvalue = 0;
  602. // Combat and any controlled creature
  603. if (isInCombat() || GetCharmerOrOwnerGUID())
  604. {
  605. if (!IsUnderLastManaUseEffect())
  606. {
  607. float ManaIncreaseRate = sWorld->getRate(RATE_POWER_MANA);
  608. float Spirit = GetStat(STAT_SPIRIT);
  610. addvalue = uint32((Spirit / 5.0f + 17.0f) * ManaIncreaseRate);
  611. }
  612. }
  613. else
  614. addvalue = maxValue / 3;
  616. // Apply modifiers (if any).
  617. AuraEffectList const& ModPowerRegenPCTAuras = GetAuraEffectsByType(SPELL_AURA_MOD_POWER_REGEN_PERCENT);
  618. for (AuraEffectList::const_iterator i = ModPowerRegenPCTAuras.begin(); i != ModPowerRegenPCTAuras.end(); ++i)
  619. if ((*i)->GetMiscValue() == POWER_MANA)
  620. AddPctN(addvalue, (*i)->GetAmount());
  622. addvalue += GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_POWER_REGEN, POWER_MANA) * CREATURE_REGEN_INTERVAL / (5 * IN_MILLISECONDS);
  624. ModifyPower(POWER_MANA, addvalue);
  625. }
  627. void Creature::RegenerateHealth()
  628. {
  629. if (!isRegeneratingHealth())
  630. return;
  632. uint32 curValue = GetHealth();
  633. uint32 maxValue = GetMaxHealth();
  635. if (curValue >= maxValue)
  636. return;
  638. uint32 addvalue = 0;
  640. // Not only pet, but any controlled creature
  641. if (GetCharmerOrOwnerGUID())
  642. {
  643. float HealthIncreaseRate = sWorld->getRate(RATE_HEALTH);
  644. float Spirit = GetStat(STAT_SPIRIT);
  646. if (GetPower(POWER_MANA) > 0)
  647. addvalue = uint32(Spirit * 0.25 * HealthIncreaseRate);
  648. else
  649. addvalue = uint32(Spirit * 0.80 * HealthIncreaseRate);
  650. }
  651. else
  652. addvalue = maxValue/3;
  654. // Apply modifiers (if any).
  655. AuraEffectList const& ModPowerRegenPCTAuras = GetAuraEffectsByType(SPELL_AURA_MOD_HEALTH_REGEN_PERCENT);
  656. for (AuraEffectList::const_iterator i = ModPowerRegenPCTAuras.begin(); i != ModPowerRegenPCTAuras.end(); ++i)
  657. AddPctN(addvalue, (*i)->GetAmount());
  659. addvalue += GetTotalAuraModifier(SPELL_AURA_MOD_REGEN) * CREATURE_REGEN_INTERVAL / (5 * IN_MILLISECONDS);
  661. ModifyHealth(addvalue);
  662. }
  664. void Creature::DoFleeToGetAssistance()
  665. {
  666. if (!getVictim())
  667. return;
  669. if (HasAuraType(SPELL_AURA_PREVENTS_FLEEING))
  670. return;
  672. float radius = sWorld->getFloatConfig(CONFIG_CREATURE_FAMILY_FLEE_ASSISTANCE_RADIUS);
  673. if (radius >0)
  674. {
  675. Creature* pCreature = NULL;
  677. CellPair p(Trinity::ComputeCellPair(GetPositionX(), GetPositionY()));
  678. Cell cell(p);
  679. cell.data.Part.reserved = ALL_DISTRICT;
  680. cell.SetNoCreate();
  681. Trinity::NearestAssistCreatureInCreatureRangeCheck u_check(this, getVictim(), radius);
  682. Trinity::CreatureLastSearcher<Trinity::NearestAssistCreatureInCreatureRangeCheck> searcher(this, pCreature, u_check);
  684. TypeContainerVisitor<Trinity::CreatureLastSearcher<Trinity::NearestAssistCreatureInCreatureRangeCheck>, GridTypeMapContainer > grid_creature_searcher(searcher);
  686. cell.Visit(p, grid_creature_searcher, *GetMap(), *this, radius);
  688. SetNoSearchAssistance(true);
  689. UpdateSpeed(MOVE_RUN, false);
  691. if (!pCreature)
  692. //SetFeared(true, getVictim()->GetGUID(), 0 ,sWorld->getIntConfig(CONFIG_CREATURE_FAMILY_FLEE_DELAY));
  693. //TODO: use 31365
  694. SetControlled(true, UNIT_STAT_FLEEING);
  695. else
  696. GetMotionMaster()->MoveSeekAssistance(pCreature->GetPositionX(), pCreature->GetPositionY(), pCreature->GetPositionZ());
  697. }
  698. }
  700. bool Creature::AIM_Initialize(CreatureAI* ai)
  701. {
  702. // make sure nothing can change the AI during AI update
  703. if (m_AI_locked)
  704. {
  705. sLog->outDebug(LOG_FILTER_TSCR, "AIM_Initialize: failed to init, locked.");
  706. return false;
  707. }
  709. UnitAI *oldAI = i_AI;
  711. Motion_Initialize();
  713. i_AI = ai ? ai : FactorySelector::selectAI(this);
  714. delete oldAI;
  715. IsAIEnabled = true;
  716. i_AI->InitializeAI();
  717. // Initialize vehicle
  718. if (GetVehicleKit())
  719. GetVehicleKit()->Reset();
  720. return true;
  721. }
  723. void Creature::Motion_Initialize()
  724. {
  725. if (!m_formation)
  726. i_motionMaster.Initialize();
  727. else if (m_formation->getLeader() == this)
  728. {
  729. m_formation->FormationReset(false);
  730. i_motionMaster.Initialize();
  731. }
  732. else if (m_formation->isFormed())
  733. i_motionMaster.MoveIdle(MOTION_SLOT_IDLE); //wait the order of leader
  734. else
  735. i_motionMaster.Initialize();
  736. }
  738. bool Creature::Create(uint32 guidlow, Map *map, uint32 phaseMask, uint32 Entry, uint32 vehId, uint32 team, float x, float y, float z, float ang, const CreatureData *data)
  739. {
  740. ASSERT(map);
  741. SetMap(map);
  742. SetPhaseMask(phaseMask,false);
  744. CreatureInfo const *cinfo = ObjectMgr::GetCreatureTemplate(Entry);
  745. if (!cinfo)
  746. {
  747. sLog->outErrorDb("Creature::Create(): creature template (guidlow: %u, entry: %u) does not exist.", guidlow, Entry);
  748. return false;
  749. }
  751. Relocate(x, y, z, ang);
  753. if (!IsPositionValid())
  754. {
  755. sLog->outError("Creature::Create(): given coordinates for creature (guidlow %d, entry %d) are not valid (X: %f, Y: %f, Z: %f, O: %f)", guidlow, Entry, x, y, z, ang);
  756. return false;
  757. }
  759. //oX = x; oY = y; dX = x; dY = y; m_moveTime = 0; m_startMove = 0;
  760. if (!CreateFromProto(guidlow, Entry, vehId, team, data))
  761. return false;
  763. switch (GetCreatureInfo()->rank)
  764. {
  765. case CREATURE_ELITE_RARE:
  766. m_corpseDelay = sWorld->getIntConfig(CONFIG_CORPSE_DECAY_RARE);
  767. break;
  768. case CREATURE_ELITE_ELITE:
  769. m_corpseDelay = sWorld->getIntConfig(CONFIG_CORPSE_DECAY_ELITE);
  770. break;
  771. case CREATURE_ELITE_RAREELITE:
  772. m_corpseDelay = sWorld->getIntConfig(CONFIG_CORPSE_DECAY_RAREELITE);
  773. break;
  774. case CREATURE_ELITE_WORLDBOSS:
  775. m_corpseDelay = sWorld->getIntConfig(CONFIG_CORPSE_DECAY_WORLDBOSS);
  776. break;
  777. default:
  778. m_corpseDelay = sWorld->getIntConfig(CONFIG_CORPSE_DECAY_NORMAL);
  779. break;
  780. }
  782. LoadCreaturesAddon();
  783. CreatureModelInfo const *minfo = sObjectMgr->GetCreatureModelRandomGender(GetNativeDisplayId());
  784. if (minfo && !isTotem()) // Cancel load if no model defined or if totem
  785. {
  786. uint32 display_id = minfo->modelid; // it can be different (for another gender)
  788. SetDisplayId(display_id);
  789. SetNativeDisplayId(display_id);
  790. SetByteValue(UNIT_FIELD_BYTES_0, 2, minfo->gender);
  791. }
  793. if (GetCreatureInfo()->InhabitType & INHABIT_AIR)
  794. {
  795. if (GetDefaultMovementType() == IDLE_MOTION_TYPE)
  796. AddUnitMovementFlag(MOVEMENTFLAG_CAN_FLY);
  797. else
  798. SetFlying(true);
  799. }
  801. if (GetCreatureInfo()->InhabitType & INHABIT_WATER)
  802. AddUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
  804. LastUsedScriptID = GetCreatureInfo()->ScriptID;
  806. // TODO: Replace with spell, handle from DB
  807. if (isSpiritHealer())
  808. {
  809. m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_GHOST);
  810. m_serverSideVisibilityDetect.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_GHOST);
  811. }
  812. else if (isSpiritGuide())
  813. {
  814. m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_GHOST | GHOST_VISIBILITY_ALIVE);
  815. m_serverSideVisibilityDetect.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_GHOST | GHOST_VISIBILITY_ALIVE);
  816. }
  818. if (Entry == VISUAL_WAYPOINT)
  819. SetVisible(false);
  821. return true;
  822. }
  824. bool Creature::isCanTrainingOf(Player* pPlayer, bool msg) const
  825. {
  826. if (!isTrainer())
  827. return false;
  829. TrainerSpellData const* trainer_spells = GetTrainerSpells();
  831. if ((!trainer_spells || trainer_spells->spellList.empty()) && GetCreatureInfo()->trainer_type != TRAINER_TYPE_PETS)
  832. {
  833. sLog->outErrorDb("Creature %u (Entry: %u) have UNIT_NPC_FLAG_TRAINER but have empty trainer spell list.",
  834. GetGUIDLow(),GetEntry());
  835. return false;
  836. }
  838. switch(GetCreatureInfo()->trainer_type)
  839. {
  840. case TRAINER_TYPE_CLASS:
  841. if (pPlayer->getClass() != GetCreatureInfo()->trainer_class)
  842. {
  843. if (msg)
  844. {
  845. pPlayer->PlayerTalkClass->ClearMenus();
  846. switch(GetCreatureInfo()->trainer_class)
  847. {
  848. case CLASS_DRUID: pPlayer->PlayerTalkClass->SendGossipMenu(4913,GetGUID()); break;
  849. case CLASS_HUNTER: pPlayer->PlayerTalkClass->SendGossipMenu(10090,GetGUID()); break;
  850. case CLASS_MAGE: pPlayer->PlayerTalkClass->SendGossipMenu(328,GetGUID()); break;
  851. case CLASS_PALADIN:pPlayer->PlayerTalkClass->SendGossipMenu(1635,GetGUID()); break;
  852. case CLASS_PRIEST: pPlayer->PlayerTalkClass->SendGossipMenu(4436,GetGUID()); break;
  853. case CLASS_ROGUE: pPlayer->PlayerTalkClass->SendGossipMenu(4797,GetGUID()); break;
  854. case CLASS_SHAMAN: pPlayer->PlayerTalkClass->SendGossipMenu(5003,GetGUID()); break;
  855. case CLASS_WARLOCK:pPlayer->PlayerTalkClass->SendGossipMenu(5836,GetGUID()); break;
  856. case CLASS_WARRIOR:pPlayer->PlayerTalkClass->SendGossipMenu(4985,GetGUID()); break;
  857. }
  858. }
  859. return false;
  860. }
  861. break;
  862. case TRAINER_TYPE_PETS:
  863. if (pPlayer->getClass() != CLASS_HUNTER)
  864. {
  865. pPlayer->PlayerTalkClass->ClearMenus();
  866. pPlayer->PlayerTalkClass->SendGossipMenu(3620,GetGUID());
  867. return false;
  868. }
  869. break;
  870. case TRAINER_TYPE_MOUNTS:
  871. if (GetCreatureInfo()->trainer_race && pPlayer->getRace() != GetCreatureInfo()->trainer_race)
  872. {
  873. if (msg)
  874. {
  875. pPlayer->PlayerTalkClass->ClearMenus();
  876. switch(GetCreatureInfo()->trainer_class)
  877. {
  878. case RACE_DWARF: pPlayer->PlayerTalkClass->SendGossipMenu(5865,GetGUID()); break;
  879. case RACE_GNOME: pPlayer->PlayerTalkClass->SendGossipMenu(4881,GetGUID()); break;
  880. case RACE_HUMAN: pPlayer->PlayerTalkClass->SendGossipMenu(5861,GetGUID()); break;
  881. case RACE_NIGHTELF: pPlayer->PlayerTalkClass->SendGossipMenu(5862,GetGUID()); break;
  882. case RACE_ORC: pPlayer->PlayerTalkClass->SendGossipMenu(5863,GetGUID()); break;
  883. case RACE_TAUREN: pPlayer->PlayerTalkClass->SendGossipMenu(5864,GetGUID()); break;
  884. case RACE_TROLL: pPlayer->PlayerTalkClass->SendGossipMenu(5816,GetGUID()); break;
  885. case RACE_UNDEAD_PLAYER:pPlayer->PlayerTalkClass->SendGossipMenu(624,GetGUID()); break;
  886. case RACE_BLOODELF: pPlayer->PlayerTalkClass->SendGossipMenu(5862,GetGUID()); break;
  887. case RACE_DRAENEI: pPlayer->PlayerTalkClass->SendGossipMenu(5864,GetGUID()); break;
  888. }
  889. }
  890. return false;
  891. }
  892. break;
  893. case TRAINER_TYPE_TRADESKILLS:
  894. if (GetCreatureInfo()->trainer_spell && !pPlayer->HasSpell(GetCreatureInfo()->trainer_spell))
  895. {
  896. if (msg)
  897. {
  898. pPlayer->PlayerTalkClass->ClearMenus();
  899. pPlayer->PlayerTalkClass->SendGossipMenu(11031,GetGUID());
  900. }
  901. return false;
  902. }
  903. break;
  904. default:
  905. return false; // checked and error output at creature_template loading
  906. }
  907. return true;
  908. }
  910. bool Creature::isCanInteractWithBattleMaster(Player* pPlayer, bool msg) const
  911. {
  912. if (!isBattleMaster())
  913. return false;
  915. BattlegroundTypeId bgTypeId = sBattlegroundMgr->GetBattleMasterBG(GetEntry());
  916. if (!msg)
  917. return pPlayer->GetBGAccessByLevel(bgTypeId);
  919. if (!pPlayer->GetBGAccessByLevel(bgTypeId))
  920. {
  921. pPlayer->PlayerTalkClass->ClearMenus();
  922. switch(bgTypeId)
  923. {
  924. case BATTLEGROUND_AV: pPlayer->PlayerTalkClass->SendGossipMenu(7616,GetGUID()); break;
  925. case BATTLEGROUND_WS: pPlayer->PlayerTalkClass->SendGossipMenu(7599,GetGUID()); break;
  926. case BATTLEGROUND_AB: pPlayer->PlayerTalkClass->SendGossipMenu(7642,GetGUID()); break;
  927. case BATTLEGROUND_EY:
  928. case BATTLEGROUND_NA:
  929. case BATTLEGROUND_BE:
  930. case BATTLEGROUND_AA:
  931. case BATTLEGROUND_RL:
  932. case BATTLEGROUND_SA:
  933. case BATTLEGROUND_DS:
  934. case BATTLEGROUND_RV: pPlayer->PlayerTalkClass->SendGossipMenu(10024,GetGUID()); break;
  935. default: break;
  936. }
  937. return false;
  938. }
  939. return true;
  940. }
  942. bool Creature::isCanTrainingAndResetTalentsOf(Player* pPlayer) const
  943. {
  944. return pPlayer->getLevel() >= 10
  945. && GetCreatureInfo()->trainer_type == TRAINER_TYPE_CLASS
  946. && pPlayer->getClass() == GetCreatureInfo()->trainer_class;
  947. }
  949. void Creature::AI_SendMoveToPacket(float x, float y, float z, uint32 time, uint32 /*MovementFlags*/, uint8 /*type*/)
  950. {
  951. /* uint32 timeElap = getMSTime();
  952. if ((timeElap - m_startMove) < m_moveTime)
  953. {
  954. oX = (dX - oX) * ((timeElap - m_startMove) / m_moveTime);
  955. oY = (dY - oY) * ((timeElap - m_startMove) / m_moveTime);
  956. }
  957. else
  958. {
  959. oX = dX;
  960. oY = dY;
  961. }
  963. dX = x;
  964. dY = y;
  965. m_orientation = atan2((oY - dY), (oX - dX));
  967. m_startMove = getMSTime();
  968. m_moveTime = time;*/
  969. SendMonsterMove(x, y, z, time);
  970. }
  972. Player *Creature::GetLootRecipient() const
  973. {
  974. if (!m_lootRecipient)
  975. return NULL;
  976. return ObjectAccessor::FindPlayer(m_lootRecipient);
  977. }
  979. Group *Creature::GetLootRecipientGroup() const
  980. {
  981. if (!m_lootRecipientGroup)
  982. return NULL;
  983. return sObjectMgr->GetGroupByGUID(m_lootRecipientGroup);
  984. }
  986. void Creature::SetLootRecipient(Unit *unit)
  987. {
  988. // set the player whose group should receive the right
  989. // to loot the creature after it dies
  990. // should be set to NULL after the loot disappears
  992. if (!unit)
  993. {
  994. m_lootRecipient = 0;
  995. m_lootRecipientGroup = 0;
  996. RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE|UNIT_DYNFLAG_TAPPED);
  997. return;
  998. }
  1000. if (unit->GetTypeId() != TYPEID_PLAYER && !unit->IsVehicle())
  1001. return;
  1003. Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself();
  1004. if (!player) // normal creature, no player involved
  1005. return;
  1007. m_lootRecipient = player->GetGUID();
  1008. if (Group *group = player->GetGroup())
  1009. m_lootRecipientGroup = group->GetLowGUID();
  1011. SetFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TAPPED);
  1012. }
  1014. // return true if this creature is tapped by the player or by a member of his group.
  1015. bool Creature::isTappedBy(Player *player) const
  1016. {
  1017. if (player->GetGUID() == m_lootRecipient)
  1018. return true;
  1020. Group* playerGroup = player->GetGroup();
  1021. if (!playerGroup || playerGroup != GetLootRecipientGroup()) // if we dont have a group we arent the recipient
  1022. return false; // if creature doesnt have group bound it means it was solo killed by someone else
  1024. return true;
  1025. }
  1027. void Creature::SaveToDB()
  1028. {
  1029. // this should only be used when the creature has already been loaded
  1030. // preferably after adding to map, because mapid may not be valid otherwise
  1031. CreatureData const *data = sObjectMgr->GetCreatureData(m_DBTableGuid);
  1032. if (!data)
  1033. {
  1034. sLog->outError("Creature::SaveToDB failed, cannot get creature data!");
  1035. return;
  1036. }
  1038. SaveToDB(GetMapId(), data->spawnMask, GetPhaseMask());
  1039. }
  1041. void Creature::SaveToDB(uint32 mapid, uint8 spawnMask, uint32 phaseMask)
  1042. {
  1043. // update in loaded data
  1044. if (!m_DBTableGuid)
  1045. m_DBTableGuid = GetGUIDLow();
  1046. CreatureData& data = sObjectMgr->NewOrExistCreatureData(m_DBTableGuid);
  1048. uint32 displayId = GetNativeDisplayId();
  1049. uint32 npcflag = GetUInt32Value(UNIT_NPC_FLAGS);
  1050. uint32 unit_flags = GetUInt32Value(UNIT_FIELD_FLAGS);
  1051. uint32 dynamicflags = GetUInt32Value(UNIT_DYNAMIC_FLAGS);
  1053. // check if it's a custom model and if not, use 0 for displayId
  1054. CreatureInfo const *cinfo = GetCreatureInfo();
  1055. if (cinfo)
  1056. {
  1057. if (displayId == cinfo->Modelid1 || displayId == cinfo->Modelid2 ||
  1058. displayId == cinfo->Modelid3 || displayId == cinfo->Modelid4)
  1059. displayId = 0;
  1061. if (npcflag == cinfo->npcflag)
  1062. npcflag = 0;
  1064. if (unit_flags == cinfo->unit_flags)
  1065. unit_flags = 0;
  1067. if (dynamicflags == cinfo->dynamicflags)
  1068. dynamicflags = 0;
  1069. }
  1071. // data->guid = guid don't must be update at save
  1072. data.id = GetEntry();
  1073. data.mapid = mapid;
  1074. data.phaseMask = phaseMask;
  1075. data.displayid = displayId;
  1076. data.equipmentId = GetEquipmentId();
  1077. data.posX = GetPositionX();
  1078. data.posY = GetPositionY();
  1079. data.posZ = GetPositionZ();
  1080. data.orientation = GetOrientation();
  1081. data.spawntimesecs = m_respawnDelay;
  1082. // prevent add data integrity problems
  1083. data.spawndist = GetDefaultMovementType() == IDLE_MOTION_TYPE ? 0 : m_respawnradius;
  1084. data.currentwaypoint = 0;
  1085. data.curhealth = GetHealth();
  1086. data.curmana = GetPower(POWER_MANA);
  1087. data.is_dead = m_isDeadByDefault;
  1088. // prevent add data integrity problems
  1089. data.movementType = !m_respawnradius && GetDefaultMovementType() == RANDOM_MOTION_TYPE
  1090. ? IDLE_MOTION_TYPE : GetDefaultMovementType();
  1091. data.spawnMask = spawnMask;
  1092. data.npcflag = npcflag;
  1093. data.unit_flags = unit_flags;
  1094. data.dynamicflags = dynamicflags;
  1096. // updated in DB
  1097. SQLTransaction trans = WorldDatabase.BeginTransaction();
  1099. trans->PAppend("DELETE FROM creature WHERE guid = '%u'", m_DBTableGuid);
  1101. std::ostringstream ss;
  1102. ss << "INSERT INTO creature VALUES ("
  1103. << m_DBTableGuid << ","
  1104. << GetEntry() << ","
  1105. << mapid <<","
  1106. << uint32(spawnMask) << "," // cast to prevent save as symbol
  1107. << uint16(GetPhaseMask()) << "," // prevent out of range error
  1108. << displayId <<","
  1109. << GetEquipmentId() <<","
  1110. << GetPositionX() << ","
  1111. << GetPositionY() << ","
  1112. << GetPositionZ() << ","
  1113. << GetOrientation() << ","
  1114. << m_respawnDelay << "," //respawn time
  1115. << (float) m_respawnradius << "," //spawn distance (float)
  1116. << (uint32) (0) << "," //currentwaypoint
  1117. << GetHealth() << "," //curhealth
  1118. << GetPower(POWER_MANA) << "," //curmana
  1119. << (m_isDeadByDefault ? 1 : 0) << "," //is_dead
  1120. << GetDefaultMovementType() << "," //default movement generator type
  1121. << npcflag << ","
  1122. << unit_flags << ","
  1123. << dynamicflags << ")";
  1125. trans->Append(ss.str().c_str());
  1127. WorldDatabase.CommitTransaction(trans);
  1128. }
  1130. void Creature::SelectLevel(const CreatureInfo *cinfo)
  1131. {
  1132. uint32 rank = isPet()? 0 : cinfo->rank;
  1134. // level
  1135. uint8 minlevel = std::min(cinfo->maxlevel, cinfo->minlevel);
  1136. uint8 maxlevel = std::max(cinfo->maxlevel, cinfo->minlevel);
  1137. uint8 level = minlevel == maxlevel ? minlevel : urand(minlevel, maxlevel);
  1138. SetLevel(level);
  1140. CreatureBaseStats const* stats = sObjectMgr->GetCreatureBaseStats(level, cinfo->unit_class);
  1142. // health
  1143. float healthmod = _GetHealthMod(rank);
  1145. uint32 basehp = stats->GenerateHealth(cinfo);
  1146. uint32 health = uint32(basehp * healthmod);
  1148. SetCreateHealth(health);
  1149. SetMaxHealth(health);
  1150. SetHealth(health);
  1151. ResetPlayerDamageReq();
  1153. // mana
  1154. uint32 mana = stats->GenerateMana(cinfo);
  1156. SetCreateMana(mana);
  1157. SetMaxPower(POWER_MANA, mana); //MAX Mana
  1158. SetPower(POWER_MANA, mana);
  1160. // TODO: set UNIT_FIELD_POWER*, for some creature class case (energy, etc)
  1162. SetModifierValue(UNIT_MOD_HEALTH, BASE_VALUE, (float)health);
  1163. SetModifierValue(UNIT_MOD_MANA, BASE_VALUE, (float)mana);
  1165. //damage
  1166. float damagemod = 1.0f;//_GetDamageMod(rank);
  1168. SetBaseWeaponDamage(BASE_ATTACK, MINDAMAGE, cinfo->mindmg * damagemod);
  1169. SetBaseWeaponDamage(BASE_ATTACK, MAXDAMAGE, cinfo->maxdmg * damagemod);
  1171. SetFloatValue(UNIT_FIELD_MINRANGEDDAMAGE,cinfo->minrangedmg * damagemod);
  1172. SetFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE,cinfo->maxrangedmg * damagemod);
  1174. SetModifierValue(UNIT_MOD_ATTACK_POWER, BASE_VALUE, cinfo->attackpower * damagemod);
  1176. }
  1178. float Creature::_GetHealthMod(int32 Rank)
  1179. {
  1180. switch (Rank) // define rates for each elite rank
  1181. {
  1182. case CREATURE_ELITE_NORMAL:
  1183. return sWorld->getRate(RATE_CREATURE_NORMAL_HP);
  1184. case CREATURE_ELITE_ELITE:
  1185. return sWorld->getRate(RATE_CREATURE_ELITE_ELITE_HP);
  1186. case CREATURE_ELITE_RAREELITE:
  1187. return sWorld->getRate(RATE_CREATURE_ELITE_RAREELITE_HP);
  1188. case CREATURE_ELITE_WORLDBOSS:
  1189. return sWorld->getRate(RATE_CREATURE_ELITE_WORLDBOSS_HP);
  1190. case CREATURE_ELITE_RARE:
  1191. return sWorld->getRate(RATE_CREATURE_ELITE_RARE_HP);
  1192. default:
  1193. return sWorld->getRate(RATE_CREATURE_ELITE_ELITE_HP);
  1194. }
  1195. }
  1197. float Creature::_GetDamageMod(int32 Rank)
  1198. {
  1199. switch (Rank) // define rates for each elite rank
  1200. {
  1201. case CREATURE_ELITE_NORMAL:
  1202. return sWorld->getRate(RATE_CREATURE_NORMAL_DAMAGE);
  1203. case CREATURE_ELITE_ELITE:
  1204. return sWorld->getRate(RATE_CREATURE_ELITE_ELITE_DAMAGE);
  1205. case CREATURE_ELITE_RAREELITE:
  1206. return sWorld->getRate(RATE_CREATURE_ELITE_RAREELITE_DAMAGE);
  1207. case CREATURE_ELITE_WORLDBOSS:
  1208. return sWorld->getRate(RATE_CREATURE_ELITE_WORLDBOSS_DAMAGE);
  1209. case CREATURE_ELITE_RARE:
  1210. return sWorld->getRate(RATE_CREATURE_ELITE_RARE_DAMAGE);
  1211. default:
  1212. return sWorld->getRate(RATE_CREATURE_ELITE_ELITE_DAMAGE);
  1213. }
  1214. }
  1216. float Creature::GetSpellDamageMod(int32 Rank)
  1217. {
  1218. switch (Rank) // define rates for each elite rank
  1219. {
  1220. case CREATURE_ELITE_NORMAL:
  1221. return sWorld->getRate(RATE_CREATURE_NORMAL_SPELLDAMAGE);
  1222. case CREATURE_ELITE_ELITE:
  1223. return sWorld->getRate(RATE_CREATURE_ELITE_ELITE_SPELLDAMAGE);
  1224. case CREATURE_ELITE_RAREELITE:
  1225. return sWorld->getRate(RATE_CREATURE_ELITE_RAREELITE_SPELLDAMAGE);
  1226. case CREATURE_ELITE_WORLDBOSS:
  1227. return sWorld->getRate(RATE_CREATURE_ELITE_WORLDBOSS_SPELLDAMAGE);
  1228. case CREATURE_ELITE_RARE:
  1229. return sWorld->getRate(RATE_CREATURE_ELITE_RARE_SPELLDAMAGE);
  1230. default:
  1231. return sWorld->getRate(RATE_CREATURE_ELITE_ELITE_SPELLDAMAGE);
  1232. }
  1233. }
  1235. bool Creature::CreateFromProto(uint32 guidlow, uint32 Entry, uint32 vehId, uint32 team, const CreatureData *data)
  1236. {
  1237. SetZoneScript();
  1238. if (m_zoneScript && data)
  1239. {
  1240. Entry = m_zoneScript->GetCreatureEntry(guidlow, data);
  1241. if (!Entry)
  1242. return false;
  1243. }
  1245. CreatureInfo const *cinfo = ObjectMgr::GetCreatureTemplate(Entry);
  1246. if (!cinfo)
  1247. {
  1248. sLog->outErrorDb("Creature::CreateFromProto(): creature template (guidlow: %u, entry: %u) does not exist.", guidlow, Entry);
  1249. return false;
  1250. }
  1252. SetOriginalEntry(Entry);
  1254. if (!vehId)
  1255. vehId = cinfo->VehicleId;
  1257. if (vehId && !CreateVehicleKit(vehId, Entry))
  1258. vehId = 0;
  1260. Object::_Create(guidlow, Entry, vehId ? HIGHGUID_VEHICLE : HIGHGUID_UNIT);
  1262. if (!UpdateEntry(Entry, team, data))
  1263. return false;
  1265. return true;
  1266. }
  1268. bool Creature::LoadFromDB(uint32 guid, Map *map)
  1269. {
  1270. CreatureData const* data = sObjectMgr->GetCreatureData(guid);
  1272. if (!data)
  1273. {
  1274. sLog->outErrorDb("Creature (GUID: %u) not found in table `creature`, can't load. ",guid);
  1275. return false;
  1276. }
  1278. m_DBTableGuid = guid;
  1279. if (map->GetInstanceId() == 0)
  1280. {
  1281. if (map->GetCreature(MAKE_NEW_GUID(guid,data->id,HIGHGUID_UNIT)))
  1282. return false;
  1283. }
  1284. else
  1285. guid = sObjectMgr->GenerateLowGuid(HIGHGUID_UNIT);
  1287. uint16 team = 0;
  1288. if (!Create(guid,map,data->phaseMask,data->id,0,team,data->posX,data->posY,data->posZ,data->orientation,data))
  1289. return false;
  1291. //We should set first home position, because then AI calls home movement
  1292. SetHomePosition(data->posX,data->posY,data->posZ,data->orientation);
  1294. m_respawnradius = data->spawndist;
  1296. m_respawnDelay = data->spawntimesecs;
  1297. m_isDeadByDefault = data->is_dead;
  1298. m_deathState = m_isDeadByDefault ? DEAD : ALIVE;
  1300. m_respawnTime = sObjectMgr->GetCreatureRespawnTime(m_DBTableGuid,GetInstanceId());
  1301. if (m_respawnTime) // respawn on Update
  1302. {
  1303. m_deathState = DEAD;
  1304. if (canFly())
  1305. {
  1306. float tz = map->GetHeight(data->posX,data->posY,data->posZ,false);
  1307. if (data->posZ - tz > 0.1)
  1308. Relocate(data->posX,data->posY,tz);
  1309. }
  1310. }
  1312. uint32 curhealth;
  1314. if (!m_regenHealth)
  1315. {
  1316. curhealth = data->curhealth;
  1317. if (curhealth)
  1318. {
  1319. curhealth = uint32(curhealth*_GetHealthMod(GetCreatureInfo()->rank));
  1320. if (curhealth < 1)
  1321. curhealth = 1;
  1322. }
  1323. SetPower(POWER_MANA,data->curmana);
  1324. }
  1325. else
  1326. {
  1327. curhealth = GetMaxHealth();
  1328. SetPower(POWER_MANA,GetMaxPower(POWER_MANA));
  1329. }
  1331. SetHealth(m_deathState == ALIVE ? curhealth : 0);
  1333. // checked at creature_template loading
  1334. m_defaultMovementType = MovementGeneratorType(data->movementType);
  1336. m_creatureData = data;
  1338. return true;
  1339. }
  1341. void Creature::LoadEquipment(uint32 equip_entry, bool force)
  1342. {
  1343. if (equip_entry == 0)
  1344. {
  1345. if (force)
  1346. {
  1347. for (uint8 i = 0; i < 3; ++i)
  1348. SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + i, 0);
  1349. m_equipmentId = 0;
  1350. }
  1351. return;
  1352. }
  1354. EquipmentInfo const *einfo = sObjectMgr->GetEquipmentInfo(equip_entry);
  1355. if (!einfo)
  1356. return;
  1358. m_equipmentId = equip_entry;
  1359. for (uint8 i = 0; i < 3; ++i)
  1360. SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + i, einfo->equipentry[i]);
  1361. }
  1363. bool Creature::hasQuest(uint32 quest_id) const
  1364. {
  1365. QuestRelationBounds qr = sObjectMgr->GetCreatureQuestRelationBounds(GetEntry());
  1366. for (QuestRelations::const_iterator itr = qr.first; itr != qr.second; ++itr)
  1367. {
  1368. if (itr->second == quest_id)
  1369. return true;
  1370. }
  1371. return false;
  1372. }
  1374. bool Creature::hasInvolvedQuest(uint32 quest_id) const
  1375. {
  1376. QuestRelationBounds qir = sObjectMgr->GetCreatureQuestInvolvedRelationBounds(GetEntry());
  1377. for (QuestRelations::const_iterator itr = qir.first; itr != qir.second; ++itr)
  1378. {
  1379. if (itr->second == quest_id)
  1380. return true;
  1381. }
  1382. return false;
  1383. }
  1385. void Creature::DeleteFromDB()
  1386. {
  1387. if (!m_DBTableGuid)
  1388. {
  1389. sLog->outError("Trying to delete not saved creature! LowGUID: %u, Entry: %u", GetGUIDLow(), GetEntry());
  1390. return;
  1391. }
  1393. sObjectMgr->RemoveCreatureRespawnTime(m_DBTableGuid, GetInstanceId());
  1394. sObjectMgr->DeleteCreatureData(m_DBTableGuid);
  1396. SQLTransaction trans = WorldDatabase.BeginTransaction();
  1397. trans->PAppend("DELETE FROM creature WHERE guid = '%u'", m_DBTableGuid);
  1398. trans->PAppend("DELETE FROM creature_addon WHERE guid = '%u'", m_DBTableGuid);
  1399. trans->PAppend("DELETE FROM game_event_creature WHERE guid = '%u'", m_DBTableGuid);
  1400. trans->PAppend("DELETE FROM game_event_model_equip WHERE guid = '%u'", m_DBTableGuid);
  1401. WorldDatabase.CommitTransaction(trans);
  1402. }
  1404. bool Creature::isVisibleForInState(WorldObject const* seer) const
  1405. {
  1406. if (!Unit::isVisibleForInState(seer))
  1407. return false;
  1409. if (isAlive() || (m_isDeadByDefault && m_deathState == CORPSE) || m_corpseRemoveTime > time(NULL))
  1410. return true;
  1412. return false;
  1413. }
  1415. bool Creature::canSeeAlways(WorldObject const* obj) const
  1416. {
  1417. if (Unit::canSeeAlways(obj))
  1418. return true;
  1420. if (IsAIEnabled && AI()->CanSeeAlways(obj))
  1421. return true;
  1423. return false;
  1424. }
  1426. bool Creature::canStartAttack(Unit const* who, bool force) const
  1427. {
  1428. if (isCivilian())
  1429. return false;
  1431. if (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PASSIVE))
  1432. return false;
  1434. if (!canFly() && (GetDistanceZ(who) > CREATURE_Z_ATTACK_RANGE + m_CombatDistance))
  1435. //|| who->IsControlledByPlayer() && who->IsFlying()))
  1436. // we cannot check flying for other creatures, too much map/vmap calculation
  1437. // TODO: should switch to range attack
  1438. return false;
  1440. if (!force)
  1441. {
  1442. if (!_IsTargetAcceptable(who))
  1443. return false;
  1445. if (who->isInCombat())
  1446. if (Unit *victim = who->getAttackerForHelper())
  1447. if (IsWithinDistInMap(victim, sWorld->getFloatConfig(CONFIG_CREATURE_FAMILY_ASSISTANCE_RADIUS)))
  1448. force = true;
  1450. if (!force && (IsNeutralToAll() || !IsWithinDistInMap(who, GetAttackDistance(who) + m_CombatDistance)))
  1451. return false;
  1452. }
  1454. if (!canCreatureAttack(who, force))
  1455. return false;
  1457. return IsWithinLOSInMap(who);
  1458. }
  1460. float Creature::GetAttackDistance(Unit const* pl) const
  1461. {
  1462. float aggroRate = sWorld->getRate(RATE_CREATURE_AGGRO);
  1463. if (aggroRate == 0)
  1464. return 0.0f;
  1466. uint32 playerlevel = pl->getLevelForTarget(this);
  1467. uint32 creaturelevel = getLevelForTarget(pl);
  1469. int32 leveldif = int32(playerlevel) - int32(creaturelevel);
  1471. // "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."
  1472. if (leveldif < - 25)
  1473. leveldif = -25;
  1475. // "The aggro radius of a mob having the same level as the player is roughly 20 yards"
  1476. float RetDistance = 20;
  1478. // "Aggro Radius varies with level difference at a rate of roughly 1 yard/level"
  1479. // radius grow if playlevel < creaturelevel
  1480. RetDistance -= (float)leveldif;
  1482. if (creaturelevel+5 <= sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
  1483. {
  1484. // detect range auras
  1485. RetDistance += GetTotalAuraModifier(SPELL_AURA_MOD_DETECT_RANGE);
  1487. // detected range auras
  1488. RetDistance += pl->GetTotalAuraModifier(SPELL_AURA_MOD_DETECTED_RANGE);
  1489. }
  1491. // "Minimum Aggro Radius for a mob seems to be combat range (5 yards)"
  1492. if (RetDistance < 5)
  1493. RetDistance = 5;
  1495. return (RetDistance*aggroRate);
  1496. }
  1498. void Creature::setDeathState(DeathState s)
  1499. {
  1500. if ((s == JUST_DIED && !m_isDeadByDefault)||(s == JUST_ALIVED && m_isDeadByDefault))
  1501. {
  1502. m_corpseRemoveTime = time(NULL) + m_corpseDelay;
  1503. m_respawnTime = time(NULL) + m_respawnDelay + m_corpseDelay;
  1505. // always save boss respawn time at death to prevent crash cheating
  1506. if (sWorld->getBoolConfig(CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY) || isWorldBoss())
  1507. SaveRespawnTime();
  1508. }
  1509. Unit::setDeathState(s);
  1511. if (s == JUST_DIED)
  1512. {
  1513. SetUInt64Value(UNIT_FIELD_TARGET,0); // remove target selection in any cases (can be set at aura remove in Unit::setDeathState)
  1514. SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE);
  1516. setActive(false);
  1518. if (!isPet() && GetCreatureInfo()->SkinLootId)
  1519. if (LootTemplates_Skinning.HaveLootFor(GetCreatureInfo()->SkinLootId))
  1520. if (hasLootRecipient())
  1521. SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
  1523. if (HasSearchedAssistance())
  1524. {
  1525. SetNoSearchAssistance(false);
  1526. UpdateSpeed(MOVE_RUN, false);
  1527. }
  1529. //Dismiss group if is leader
  1530. if (m_formation && m_formation->getLeader() == this)
  1531. m_formation->FormationReset(true);
  1533. if (ZoneScript* zoneScript = GetZoneScript())
  1534. zoneScript->OnCreatureDeath(this);
  1536. if ((canFly() || IsFlying()) && FallGround())
  1537. return;
  1539. Unit::setDeathState(CORPSE);
  1540. }
  1541. else if (s == JUST_ALIVED)
  1542. {
  1543. //if (isPet())
  1544. // setActive(true);
  1545. SetFullHealth();
  1546. SetLootRecipient(NULL);
  1547. ResetPlayerDamageReq();
  1548. CreatureInfo const *cinfo = GetCreatureInfo();
  1549. AddUnitMovementFlag(MOVEMENTFLAG_WALKING);
  1550. if (GetCreatureInfo()->InhabitType & INHABIT_AIR)
  1551. AddUnitMovementFlag(MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_FLYING);
  1552. if (GetCreatureInfo()->InhabitType & INHABIT_WATER)
  1553. AddUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
  1554. SetUInt32Value(UNIT_NPC_FLAGS, cinfo->npcflag);
  1555. ClearUnitState(uint32(UNIT_STAT_ALL_STATE));
  1556. SetMeleeDamageSchool(SpellSchools(cinfo->dmgschool));
  1557. LoadCreaturesAddon(true);
  1558. Motion_Initialize();
  1559. if (GetCreatureData() && GetPhaseMask() != GetCreatureData()->phaseMask)
  1560. SetPhaseMask(GetCreatureData()->phaseMask, false);
  1561. Unit::setDeathState(ALIVE);
  1562. }
  1563. }
  1565. bool Creature::FallGround()
  1566. {
  1567. // Let's abort after we called this function one time
  1568. if (getDeathState() == DEAD_FALLING)
  1569. return false;
  1571. float x, y, z;
  1572. GetPosition(x, y, z);
  1573. // use larger distance for vmap height search than in most other cases
  1574. float ground_Z = GetMap()->GetHeight(x, y, z, true, MAX_FALL_DISTANCE);
  1575. if (fabs(ground_Z - z) < 0.1f)
  1576. return false;
  1578. GetMotionMaster()->MoveFall(ground_Z, EVENT_FALL_GROUND);
  1579. Unit::setDeathState(DEAD_FALLING);
  1580. return true;
  1581. }
  1583. void Creature::Respawn(bool force)
  1584. {
  1585. DestroyForNearbyPlayers();
  1587. if (force)
  1588. {
  1589. if (isAlive())
  1590. setDeathState(JUST_DIED);
  1591. else if (getDeathState() != CORPSE)
  1592. setDeathState(CORPSE);
  1593. }
  1595. RemoveCorpse(false);
  1597. if (getDeathState() == DEAD)
  1598. {
  1599. if (m_DBTableGuid)
  1600. sObjectMgr->RemoveCreatureRespawnTime(m_DBTableGuid, GetInstanceId());
  1602. sLog->outStaticDebug("Respawning...");
  1603. m_respawnTime = 0;
  1604. lootForPickPocketed = false;
  1605. lootForBody = false;
  1607. if (m_originalEntry != GetEntry())
  1608. UpdateEntry(m_originalEntry);
  1610. CreatureInfo const *cinfo = GetCreatureInfo();
  1611. SelectLevel(cinfo);
  1613. if (m_isDeadByDefault)
  1614. {
  1615. setDeathState(JUST_DIED);
  1616. i_motionMaster.Clear();
  1617. ClearUnitState(uint32(UNIT_STAT_ALL_STATE));
  1618. LoadCreaturesAddon(true);
  1619. }
  1620. else
  1621. setDeathState(JUST_ALIVED);
  1623. CreatureModelInfo const *minfo = sObjectMgr->GetCreatureModelRandomGender(GetNativeDisplayId());
  1624. if (minfo) // Cancel load if no model defined
  1625. {
  1626. uint32 display_id = minfo->modelid; // it can be different (for another gender)
  1628. SetDisplayId(display_id);
  1629. SetNativeDisplayId(display_id);
  1630. SetByteValue(UNIT_FIELD_BYTES_0, 2, minfo->gender);
  1631. }
  1633. GetMotionMaster()->InitDefault();
  1635. //Call AI respawn virtual function
  1636. if (IsAIEnabled)
  1637. TriggerJustRespawned = true;//delay event to next tick so all creatures are created on the map before processing
  1639. uint32 poolid = GetDBTableGUIDLow() ? sPoolMgr->IsPartOfAPool<Creature>(GetDBTableGUIDLow()) : 0;
  1640. if (poolid)
  1641. sPoolMgr->UpdatePool<Creature>(poolid, GetDBTableGUIDLow());
  1643. //Re-initialize reactstate that could be altered by movementgenerators
  1644. InitializeReactState();
  1645. }
  1647. UpdateObjectVisibility();
  1648. }
  1650. void Creature::ForcedDespawn(uint32 timeMSToDespawn)
  1651. {
  1652. if (timeMSToDespawn)
  1653. {
  1654. ForcedDespawnDelayEvent *pEvent = new ForcedDespawnDelayEvent(*this);
  1656. m_Events.AddEvent(pEvent, m_Events.CalculateTime(timeMSToDespawn));
  1657. return;
  1658. }
  1660. if (isAlive())
  1661. setDeathState(JUST_DIED);
  1663. RemoveCorpse(false);
  1664. }
  1666. void Creature::DespawnOrUnsummon(uint32 msTimeToDespawn /*= 0*/)
  1667. {
  1668. if (TempSummon* summon = this->ToTempSummon())
  1669. summon->UnSummon(msTimeToDespawn);
  1670. else
  1671. ForcedDespawn(msTimeToDespawn);
  1672. }
  1674. bool Creature::IsImmunedToSpell(SpellEntry const* spellInfo)
  1675. {
  1676. if (!spellInfo)
  1677. return false;
  1679. if (GetCreatureInfo()->MechanicImmuneMask & (1 << (spellInfo->Mechanic - 1)))
  1680. return true;
  1682. return Unit::IsImmunedToSpell(spellInfo);
  1683. }
  1685. bool Creature::IsImmunedToSpellEffect(SpellEntry const* spellInfo, uint32 index) const
  1686. {
  1687. if (GetCreatureInfo()->MechanicImmuneMask & (1 << (spellInfo->EffectMechanic[index] - 1)))
  1688. return true;
  1690. if (GetCreatureInfo()->type == CREATURE_TYPE_MECHANICAL && spellInfo->Effect[index] == SPELL_EFFECT_HEAL)
  1691. return true;
  1693. return Unit::IsImmunedToSpellEffect(spellInfo, index);
  1694. }
  1696. SpellEntry const *Creature::reachWithSpellAttack(Unit *pVictim)
  1697. {
  1698. if (!pVictim)
  1699. return NULL;
  1701. for (uint32 i=0; i < CREATURE_MAX_SPELLS; ++i)
  1702. {
  1703. if (!m_spells[i])
  1704. continue;
  1705. SpellEntry const *spellInfo = sSpellStore.LookupEntry(m_spells[i]);
  1706. if (!spellInfo)
  1707. {
  1708. sLog->outError("WORLD: unknown spell id %i", m_spells[i]);
  1709. continue;
  1710. }
  1712. bool bcontinue = true;
  1713. for (uint32 j = 0; j < MAX_SPELL_EFFECTS; j++)
  1714. {
  1715. if ((spellInfo->Effect[j] == SPELL_EFFECT_SCHOOL_DAMAGE) ||
  1716. (spellInfo->Effect[j] == SPELL_EFFECT_INSTAKILL) ||
  1717. (spellInfo->Effect[j] == SPELL_EFFECT_ENVIRONMENTAL_DAMAGE) ||
  1718. (spellInfo->Effect[j] == SPELL_EFFECT_HEALTH_LEECH)
  1719. )
  1720. {
  1721. bcontinue = false;
  1722. break;
  1723. }
  1724. }
  1725. if (bcontinue) continue;
  1727. if (spellInfo->manaCost > GetPower(POWER_MANA))
  1728. continue;
  1729. SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(spellInfo->rangeIndex);
  1730. float range = GetSpellMaxRangeForHostile(srange);
  1731. float minrange = GetSpellMinRangeForHostile(srange);
  1732. float dist = GetDistance(pVictim);
  1733. //if (!isInFront(pVictim, range) && spellInfo->AttributesEx)
  1734. // continue;
  1735. if (dist > range || dist < minrange)
  1736. continue;
  1737. if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED))
  1738. continue;
  1739. if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED))
  1740. continue;
  1741. return spellInfo;
  1742. }
  1743. return NULL;
  1744. }
  1746. SpellEntry const *Creature::reachWithSpellCure(Unit *pVictim)
  1747. {
  1748. if (!pVictim)
  1749. return NULL;
  1751. for (uint32 i=0; i < CREATURE_MAX_SPELLS; ++i)
  1752. {
  1753. if (!m_spells[i])
  1754. continue;
  1755. SpellEntry const *spellInfo = sSpellStore.LookupEntry(m_spells[i]);
  1756. if (!spellInfo)
  1757. {
  1758. sLog->outError("WORLD: unknown spell id %i", m_spells[i]);
  1759. continue;
  1760. }
  1762. bool bcontinue = true;
  1763. for (uint32 j = 0; j < MAX_SPELL_EFFECTS; j++)
  1764. {
  1765. if ((spellInfo->Effect[j] == SPELL_EFFECT_HEAL))
  1766. {
  1767. bcontinue = false;
  1768. break;
  1769. }
  1770. }
  1771. if (bcontinue) continue;
  1773. if (spellInfo->manaCost > GetPower(POWER_MANA))
  1774. continue;
  1775. SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(spellInfo->rangeIndex);
  1776. float range = GetSpellMaxRangeForFriend(srange);
  1777. float minrange = GetSpellMinRangeForFriend(srange);
  1778. float dist = GetDistance(pVictim);
  1779. //if (!isInFront(pVictim, range) && spellInfo->AttributesEx)
  1780. // continue;
  1781. if (dist > range || dist < minrange)
  1782. continue;
  1783. if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED))
  1784. continue;
  1785. if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED))
  1786. continue;
  1787. return spellInfo;
  1788. }
  1789. return NULL;
  1790. }
  1792. // select nearest hostile unit within the given distance (regardless of threat list).
  1793. Unit* Creature::SelectNearestTarget(float dist) const
  1794. {
  1795. CellPair p(Trinity::ComputeCellPair(GetPositionX(), GetPositionY()));
  1796. Cell cell(p);
  1797. cell.data.Part.reserved = ALL_DISTRICT;
  1798. cell.SetNoCreate();
  1800. Unit *target = NULL;
  1802. {
  1803. if (dist == 0.0f)
  1804. dist = MAX_VISIBILITY_DISTANCE;
  1806. Trinity::NearestHostileUnitCheck u_check(this, dist);
  1807. Trinity::UnitLastSearcher<Trinity::NearestHostileUnitCheck> searcher(this, target, u_check);
  1809. TypeContainerVisitor<Trinity::UnitLastSearcher<Trinity::NearestHostileUnitCheck>, WorldTypeMapContainer > world_unit_searcher(searcher);
  1810. TypeContainerVisitor<Trinity::UnitLastSearcher<Trinity::NearestHostileUnitCheck>, GridTypeMapContainer > grid_unit_searcher(searcher);
  1812. cell.Visit(p, world_unit_searcher, *GetMap(), *this, dist);
  1813. cell.Visit(p, grid_unit_searcher, *GetMap(), *this, dist);
  1814. }
  1816. return target;
  1817. }
  1819. // select nearest hostile unit within the given attack distance (i.e. distance is ignored if > than ATTACK_DISTANCE), regardless of threat list.
  1820. Unit* Creature::SelectNearestTargetInAttackDistance(float dist) const
  1821. {
  1822. CellPair p(Trinity::ComputeCellPair(GetPositionX(), GetPositionY()));
  1823. Cell cell(p);
  1824. cell.data.Part.reserved = ALL_DISTRICT;
  1825. cell.SetNoCreate();
  1827. Unit *target = NULL;
  1829. if (dist > ATTACK_DISTANCE)
  1830. sLog->outError("Creature (GUID: %u Entry: %u) SelectNearestTargetInAttackDistance called with dist > ATTACK_DISTANCE. Extra distance ignored.",GetGUIDLow(),GetEntry());
  1832. {
  1833. Trinity::NearestHostileUnitInAttackDistanceCheck u_check(this, dist);
  1834. Trinity::UnitLastSearcher<Trinity::NearestHostileUnitInAttackDistanceCheck> searcher(this, target, u_check);
  1836. TypeContainerVisitor<Trinity::UnitLastSearcher<Trinity::NearestHostileUnitInAttackDistanceCheck>, WorldTypeMapContainer > world_unit_searcher(searcher);
  1837. TypeContainerVisitor<Trinity::UnitLastSearcher<Trinity::NearestHostileUnitInAttackDistanceCheck>, GridTypeMapContainer > grid_unit_searcher(searcher);
  1839. cell.Visit(p, world_unit_searcher, *GetMap(), *this, ATTACK_DISTANCE);
  1840. cell.Visit(p, grid_unit_searcher, *GetMap(), *this, ATTACK_DISTANCE);
  1841. }
  1843. return target;
  1844. }
  1846. void Creature::SendAIReaction(AiReaction reactionType)
  1847. {
  1848. WorldPacket data(SMSG_AI_REACTION, 12);
  1850. data << uint64(GetGUID());
  1851. data << uint32(reactionType);
  1853. ((WorldObject*)this)->SendMessageToSet(&data, true);
  1855. sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Sent SMSG_AI_REACTION, type %u.", reactionType);
  1856. }
  1858. void Creature::CallAssistance()
  1859. {
  1860. if (!m_AlreadyCallAssistance && getVictim() && !isPet() && !isCharmed())
  1861. {
  1862. SetNoCallAssistance(true);
  1864. float radius = sWorld->getFloatConfig(CONFIG_CREATURE_FAMILY_ASSISTANCE_RADIUS);
  1866. if (radius > 0)
  1867. {
  1868. std::list<Creature*> assistList;
  1870. {
  1871. CellPair p(Trinity::ComputeCellPair(GetPositionX(), GetPositionY()));
  1872. Cell cell(p);
  1873. cell.data.Part.reserved = ALL_DISTRICT;
  1874. cell.SetNoCreate();
  1876. Trinity::AnyAssistCreatureInRangeCheck u_check(this, getVictim(), radius);
  1877. Trinity::CreatureListSearcher<Trinity::AnyAssistCreatureInRangeCheck> searcher(this, assistList, u_check);
  1879. TypeContainerVisitor<Trinity::CreatureListSearcher<Trinity::AnyAssistCreatureInRangeCheck>, GridTypeMapContainer > grid_creature_searcher(searcher);
  1881. cell.Visit(p, grid_creature_searcher, *GetMap(), *this, radius);
  1882. }
  1884. if (!assistList.empty())
  1885. {
  1886. AssistDelayEvent *e = new AssistDelayEvent(getVictim()->GetGUID(), *this);
  1887. while (!assistList.empty())
  1888. {
  1889. // Pushing guids because in delay can happen some creature gets despawned => invalid pointer
  1890. e->AddAssistant((*assistList.begin())->GetGUID());
  1891. assistList.pop_front();
  1892. }
  1893. m_Events.AddEvent(e, m_Events.CalculateTime(sWorld->getIntConfig(CONFIG_CREATURE_FAMILY_ASSISTANCE_DELAY)));
  1894. }
  1895. }
  1896. }
  1897. }
  1899. void Creature::CallForHelp(float fRadius)
  1900. {
  1901. if (fRadius <= 0.0f || !getVictim() || isPet() || isCharmed())
  1902. return;
  1904. CellPair p(Trinity::ComputeCellPair(GetPositionX(), GetPositionY()));
  1905. Cell cell(p);
  1906. cell.data.Part.reserved = ALL_DISTRICT;
  1907. cell.SetNoCreate();
  1909. Trinity::CallOfHelpCreatureInRangeDo u_do(this, getVictim(), fRadius);
  1910. Trinity::CreatureWorker<Trinity::CallOfHelpCreatureInRangeDo> worker(this, u_do);
  1912. TypeContainerVisitor<Trinity::CreatureWorker<Trinity::CallOfHelpCreatureInRangeDo>, GridTypeMapContainer > grid_creature_searcher(worker);
  1914. cell.Visit(p, grid_creature_searcher, *GetMap(), *this, fRadius);
  1915. }
  1917. bool Creature::CanAssistTo(const Unit* u, const Unit* enemy, bool checkfaction /*= true*/) const
  1918. {
  1919. // is it true?
  1920. if (!HasReactState(REACT_AGGRESSIVE))
  1921. return false;
  1923. // we don't need help from zombies :)
  1924. if (!isAlive())
  1925. return false;
  1927. // we don't need help from non-combatant ;)
  1928. if (isCivilian())
  1929. return false;
  1931. if (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_PASSIVE))
  1932. return false;
  1934. // skip fighting creature
  1935. if (isInCombat())
  1936. return false;
  1938. // only free creature
  1939. if (GetCharmerOrOwnerGUID())
  1940. return false;
  1942. // only from same creature faction
  1943. if (checkfaction)
  1944. {
  1945. if (getFaction() != u->getFaction())
  1946. return false;
  1947. }
  1948. else
  1949. {
  1950. if (!IsFriendlyTo(u))
  1951. return false;
  1952. }
  1954. // skip non hostile to caster enemy creatures
  1955. if (!IsHostileTo(enemy))
  1956. return false;
  1958. return true;
  1959. }
  1961. // use this function to avoid having hostile creatures attack
  1962. // friendlies and other mobs they shouldn't attack
  1963. bool Creature::_IsTargetAcceptable(const Unit *target) const
  1964. {
  1965. ASSERT(target);
  1967. // if the target cannot be attacked, the target is not acceptable
  1968. if (IsFriendlyTo(target)
  1969. || !target->isAttackableByAOE()
  1970. || (m_vehicle && (IsOnVehicle(target) || m_vehicle->GetBase()->IsOnVehicle(target))))
  1971. return false;
  1973. if (target->HasUnitState(UNIT_STAT_DIED))
  1974. {
  1975. // guards can detect fake death
  1976. if (isGuard() && target->HasFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_FEIGN_DEATH))
  1977. return true;
  1978. else
  1979. return false;
  1980. }
  1982. const Unit *myVictim = getAttackerForHelper();
  1983. const Unit *targetVictim = target->getAttackerForHelper();
  1985. // if I'm already fighting target, or I'm hostile towards the target, the target is acceptable
  1986. if (myVictim == target || targetVictim == this || IsHostileTo(target))
  1987. return true;
  1989. // if the target's victim is friendly, and the target is neutral, the target is acceptable
  1990. if (targetVictim && IsFriendlyTo(targetVictim))
  1991. return true;
  1993. // if the target's victim is not friendly, or the target is friendly, the target is not acceptable
  1994. return false;
  1995. }
  1997. void Creature::SaveRespawnTime()
  1998. {
  1999. if (isSummon() || !m_DBTableGuid || (m_creatureData && !m_creatureData->dbData))
  2000. return;
  2002. sObjectMgr->SaveCreatureRespawnTime(m_DBTableGuid,GetInstanceId(),m_respawnTime);
  2003. }
  2005. // this should not be called by petAI or
  2006. bool Creature::canCreatureAttack(Unit const *pVictim, bool force) const
  2007. {
  2008. if (!pVictim->IsInMap(this))
  2009. return false;
  2011. if (!canAttack(pVictim, force))
  2012. return false;
  2014. if (!pVictim->isInAccessiblePlaceFor(this))
  2015. return false;
  2017. if (IsAIEnabled && !AI()->CanAIAttack(pVictim))
  2018. return false;
  2020. if (sMapStore.LookupEntry(GetMapId())->IsDungeon())
  2021. return true;
  2023. //Use AttackDistance in distance check if threat radius is lower. This prevents creature bounce in and out of combat every update tick.
  2024. float dist = std::max(GetAttackDistance(pVictim), sWorld->getFloatConfig(CONFIG_THREAT_RADIUS)) + m_CombatDistance;
  2026. if (Unit *unit = GetCharmerOrOwner())
  2027. return pVictim->IsWithinDist(unit, dist);
  2028. else
  2029. return pVictim->IsInDist(&m_homePosition, dist);
  2030. }
  2032. CreatureDataAddon const* Creature::GetCreatureAddon() const
  2033. {
  2034. if (m_DBTableGuid)
  2035. {
  2036. if (CreatureDataAddon const* addon = ObjectMgr::GetCreatureAddon(m_DBTableGuid))
  2037. return addon;
  2038. }
  2040. // dependent from difficulty mode entry
  2041. return ObjectMgr::GetCreatureTemplateAddon(GetCreatureInfo()->Entry);
  2042. }
  2044. //creature_addon table
  2045. bool Creature::LoadCreaturesAddon(bool reload)
  2046. {
  2047. CreatureDataAddon const *cainfo = GetCreatureAddon();
  2048. if (!cainfo)
  2049. return false;
  2051. if (cainfo->mount != 0)
  2052. Mount(cainfo->mount);
  2054. if (cainfo->bytes1 != 0)
  2055. {
  2056. // 0 StandState
  2057. // 1 FreeTalentPoints Pet only, so always 0 for default creature
  2058. // 2 StandFlags
  2059. // 3 StandMiscFlags
  2061. SetByteValue(UNIT_FIELD_BYTES_1, 0, uint8(cainfo->bytes1 & 0xFF));
  2062. //SetByteValue(UNIT_FIELD_BYTES_1, 1, uint8((cainfo->bytes1 >> 8) & 0xFF));
  2063. SetByteValue(UNIT_FIELD_BYTES_1, 1, 0);
  2064. SetByteValue(UNIT_FIELD_BYTES_1, 2, uint8((cainfo->bytes1 >> 16) & 0xFF));
  2065. SetByteValue(UNIT_FIELD_BYTES_1, 3, uint8((cainfo->bytes1 >> 24) & 0xFF));
  2066. }
  2068. if (cainfo->bytes2 != 0)
  2069. {
  2070. // 0 SheathState
  2071. // 1 Bytes2Flags
  2072. // 2 UnitRename Pet only, so always 0 for default creature
  2073. // 3 ShapeshiftForm Must be determined/set by shapeshift spell/aura
  2075. SetByteValue(UNIT_FIELD_BYTES_2, 0, uint8(cainfo->bytes2 & 0xFF));
  2076. //SetByteValue(UNIT_FIELD_BYTES_2, 1, uint8((cainfo->bytes2 >> 8) & 0xFF));
  2077. //SetByteValue(UNIT_FIELD_BYTES_2, 2, uint8((cainfo->bytes2 >> 16) & 0xFF));
  2078. SetByteValue(UNIT_FIELD_BYTES_2, 2, 0);
  2079. //SetByteValue(UNIT_FIELD_BYTES_2, 3, uint8((cainfo->bytes2 >> 24) & 0xFF));
  2080. SetByteValue(UNIT_FIELD_BYTES_2, 3, 0);
  2081. }
  2083. if (cainfo->emote != 0)
  2084. SetUInt32Value(UNIT_NPC_EMOTESTATE, cainfo->emote);
  2086. //Load Path
  2087. if (cainfo->path_id != 0)
  2088. m_path_id = cainfo->path_id;
  2090. if (cainfo->auras)
  2091. {
  2092. for (CreatureDataAddonAura const* cAura = cainfo->auras; cAura->spell_id; ++cAura)
  2093. {
  2094. SpellEntry const *AdditionalSpellInfo = sSpellStore.LookupEntry(cAura->spell_id);
  2095. if (!AdditionalSpellInfo)
  2096. {
  2097. sLog->outErrorDb("Creature (GUID: %u Entry: %u) has wrong spell %u defined in `auras` field.",GetGUIDLow(),GetEntry(),cAura->spell_id);
  2098. continue;
  2099. }
  2101. // skip already applied aura
  2102. if (HasAura(cAura->spell_id))
  2103. {
  2104. if (!reload)
  2105. sLog->outErrorDb("Creature (GUID: %u Entry: %u) has duplicate aura (spell %u) in `auras` field.",GetGUIDLow(),GetEntry(),cAura->spell_id);
  2107. continue;
  2108. }
  2110. AddAura(AdditionalSpellInfo, cAura->effectMask, this);
  2111. sLog->outDebug(LOG_FILTER_UNITS, "Spell: %u with AuraEffectMask %u added to creature (GUID: %u Entry: %u)", cAura->spell_id, cAura->effectMask,GetGUIDLow(),GetEntry());
  2112. }
  2113. }
  2114. return true;
  2115. }
  2117. /// Send a message to LocalDefense channel for players opposition team in the zone
  2118. void Creature::SendZoneUnderAttackMessage(Player* attacker)
  2119. {
  2120. uint32 enemy_team = attacker->GetTeam();
  2122. WorldPacket data(SMSG_ZONE_UNDER_ATTACK,4);
  2123. data << (uint32)GetAreaId();
  2124. sWorld->SendGlobalMessage(&data,NULL,(enemy_team == ALLIANCE ? HORDE : ALLIANCE));
  2125. }
  2127. void Creature::SetInCombatWithZone()
  2128. {
  2129. if (!CanHaveThreatList())
  2130. {
  2131. sLog->outError("Creature entry %u call SetInCombatWithZone but creature cannot have threat list.", GetEntry());
  2132. return;
  2133. }
  2135. Map* pMap = GetMap();
  2137. if (!pMap->IsDungeon())
  2138. {
  2139. sLog->outError("Creature entry %u call SetInCombatWithZone for map (id: %u) that isn't an instance.", GetEntry(), pMap->GetId());
  2140. return;
  2141. }
  2143. Map::PlayerList const &PlList = pMap->GetPlayers();
  2145. if (PlList.isEmpty())
  2146. return;
  2148. for (Map::PlayerList::const_iterator i = PlList.begin(); i != PlList.end(); ++i)
  2149. {
  2150. if (Player* pPlayer = i->getSource())
  2151. {
  2152. if (pPlayer->isGameMaster())
  2153. continue;
  2155. if (pPlayer->isAlive())
  2156. {
  2157. this->SetInCombatWith(pPlayer);
  2158. pPlayer->SetInCombatWith(this);
  2159. AddThreat(pPlayer, 0.0f);
  2160. }
  2161. }
  2162. }
  2163. }
  2165. void Creature::_AddCreatureSpellCooldown(uint32 spell_id, time_t end_time)
  2166. {
  2167. m_CreatureSpellCooldowns[spell_id] = end_time;
  2168. }
  2170. void Creature::_AddCreatureCategoryCooldown(uint32 category, time_t apply_time)
  2171. {
  2172. m_CreatureCategoryCooldowns[category] = apply_time;
  2173. }
  2175. void Creature::AddCreatureSpellCooldown(uint32 spellid)
  2176. {
  2177. SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellid);
  2178. if (!spellInfo)
  2179. return;
  2181. uint32 cooldown = GetSpellRecoveryTime(spellInfo);
  2182. if (Player *modOwner = GetSpellModOwner())
  2183. modOwner->ApplySpellMod(spellid, SPELLMOD_COOLDOWN, cooldown);
  2185. if (cooldown)
  2186. _AddCreatureSpellCooldown(spellid, time(NULL) + cooldown/IN_MILLISECONDS);
  2188. if (spellInfo->Category)
  2189. _AddCreatureCategoryCooldown(spellInfo->Category, time(NULL));
  2190. }
  2192. bool Creature::HasCategoryCooldown(uint32 spell_id) const
  2193. {
  2194. SpellEntry const *spellInfo = sSpellStore.LookupEntry(spell_id);
  2195. if (!spellInfo)
  2196. return false;
  2198. CreatureSpellCooldowns::const_iterator itr = m_CreatureCategoryCooldowns.find(spellInfo->Category);
  2199. return(itr != m_CreatureCategoryCooldowns.end() && time_t(itr->second + (spellInfo->CategoryRecoveryTime / IN_MILLISECONDS)) > time(NULL));
  2200. }
  2202. bool Creature::HasSpellCooldown(uint32 spell_id) const
  2203. {
  2204. CreatureSpellCooldowns::const_iterator itr = m_CreatureSpellCooldowns.find(spell_id);
  2205. return (itr != m_CreatureSpellCooldowns.end() && itr->second > time(NULL)) || HasCategoryCooldown(spell_id);
  2206. }
  2208. bool Creature::HasSpell(uint32 spellID) const
  2209. {
  2210. uint8 i;
  2211. for (i = 0; i < CREATURE_MAX_SPELLS; ++i)
  2212. if (spellID == m_spells[i])
  2213. break;
  2214. return i < CREATURE_MAX_SPELLS; //broke before end of iteration of known spells
  2215. }
  2217. time_t Creature::GetRespawnTimeEx() const
  2218. {
  2219. time_t now = time(NULL);
  2220. if (m_respawnTime > now)
  2221. return m_respawnTime;
  2222. else
  2223. return now;
  2224. }
  2226. void Creature::GetRespawnCoord(float &x, float &y, float &z, float* ori, float* dist) const
  2227. {
  2228. if (m_DBTableGuid)
  2229. {
  2230. if (CreatureData const* data = sObjectMgr->GetCreatureData(GetDBTableGUIDLow()))
  2231. {
  2232. x = data->posX;
  2233. y = data->posY;
  2234. z = data->posZ;
  2235. if (ori)
  2236. *ori = data->orientation;
  2237. if (dist)
  2238. *dist = data->spawndist;
  2240. return;
  2241. }
  2242. }
  2244. x = GetPositionX();
  2245. y = GetPositionY();
  2246. z = GetPositionZ();
  2247. if (ori)
  2248. *ori = GetOrientation();
  2249. if (dist)
  2250. *dist = 0;
  2251. }
  2253. void Creature::AllLootRemovedFromCorpse()
  2254. {
  2255. if (!HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE))
  2256. {
  2257. time_t now = time(NULL);
  2258. if(m_corpseRemoveTime <= now)
  2259. return;
  2261. float decayRate;
  2262. CreatureInfo const *cinfo = GetCreatureInfo();
  2264. decayRate = sWorld->getRate(RATE_CORPSE_DECAY_LOOTED);
  2265. uint32 diff = uint32((m_corpseRemoveTime - now) * decayRate);
  2267. m_respawnTime -= diff;
  2269. // corpse skinnable, but without skinning flag, and then skinned, corpse will despawn next update
  2270. if (cinfo && cinfo->SkinLootId)
  2271. m_corpseRemoveTime = time(NULL);
  2272. else
  2273. m_corpseRemoveTime -= diff;
  2274. }
  2275. }
  2277. uint8 Creature::getLevelForTarget(WorldObject const* target) const
  2278. {
  2279. if (!isWorldBoss() || !target->ToUnit())
  2280. return Unit::getLevelForTarget(target);
  2282. uint16 level = target->ToUnit()->getLevel() + sWorld->getIntConfig(CONFIG_WORLD_BOSS_LEVEL_DIFF);
  2283. if (level < 1)
  2284. return 1;
  2285. if (level > 255)
  2286. return 255;
  2287. return uint8(level);
  2288. }
  2290. std::string Creature::GetAIName() const
  2291. {
  2292. return ObjectMgr::GetCreatureTemplate(GetEntry())->AIName;
  2293. }
  2295. std::string Creature::GetScriptName() const
  2296. {
  2297. return sObjectMgr->GetScriptName(GetScriptId());
  2298. }
  2300. uint32 Creature::GetScriptId() const
  2301. {
  2302. return ObjectMgr::GetCreatureTemplate(GetEntry())->ScriptID;
  2303. }
  2305. VendorItemData const* Creature::GetVendorItems() const
  2306. {
  2307. return sObjectMgr->GetNpcVendorItemList(GetEntry());
  2308. }
  2310. uint32 Creature::GetVendorItemCurrentCount(VendorItem const* vItem)
  2311. {
  2312. if (!vItem->maxcount)
  2313. return vItem->maxcount;
  2315. VendorItemCounts::iterator itr = m_vendorItemCounts.begin();
  2316. for (; itr != m_vendorItemCounts.end(); ++itr)
  2317. if (itr->itemId == vItem->item)
  2318. break;
  2320. if (itr == m_vendorItemCounts.end())
  2321. return vItem->maxcount;
  2323. VendorItemCount* vCount = &*itr;
  2325. time_t ptime = time(NULL);
  2327. if (time_t(vCount->lastIncrementTime + vItem->incrtime) <= ptime)
  2328. {
  2329. ItemPrototype const* pProto = ObjectMgr::GetItemPrototype(vItem->item);
  2331. uint32 diff = uint32((ptime - vCount->lastIncrementTime)/vItem->incrtime);
  2332. if ((vCount->count + diff * pProto->BuyCount) >= vItem->maxcount)
  2333. {
  2334. m_vendorItemCounts.erase(itr);
  2335. return vItem->maxcount;
  2336. }
  2338. vCount->count += diff * pProto->BuyCount;
  2339. vCount->lastIncrementTime = ptime;
  2340. }
  2342. return vCount->count;
  2343. }
  2345. uint32 Creature::UpdateVendorItemCurrentCount(VendorItem const* vItem, uint32 used_count)
  2346. {
  2347. if (!vItem->maxcount)
  2348. return 0;
  2350. VendorItemCounts::iterator itr = m_vendorItemCounts.begin();
  2351. for (; itr != m_vendorItemCounts.end(); ++itr)
  2352. if (itr->itemId == vItem->item)
  2353. break;
  2355. if (itr == m_vendorItemCounts.end())
  2356. {
  2357. uint32 new_count = vItem->maxcount > used_count ? vItem->maxcount-used_count : 0;
  2358. m_vendorItemCounts.push_back(VendorItemCount(vItem->item,new_count));
  2359. return new_count;
  2360. }
  2362. VendorItemCount* vCount = &*itr;
  2364. time_t ptime = time(NULL);
  2366. if (time_t(vCount->lastIncrementTime + vItem->incrtime) <= ptime)
  2367. {
  2368. ItemPrototype const* pProto = ObjectMgr::GetItemPrototype(vItem->item);
  2370. uint32 diff = uint32((ptime - vCount->lastIncrementTime)/vItem->incrtime);
  2371. if ((vCount->count + diff * pProto->BuyCount) < vItem->maxcount)
  2372. vCount->count += diff * pProto->BuyCount;
  2373. else
  2374. vCount->count = vItem->maxcount;
  2375. }
  2377. vCount->count = vCount->count > used_count ? vCount->count-used_count : 0;
  2378. vCount->lastIncrementTime = ptime;
  2379. return vCount->count;
  2380. }
  2382. TrainerSpellData const* Creature::GetTrainerSpells() const
  2383. {
  2384. return sObjectMgr->GetNpcTrainerSpells(GetEntry());
  2385. }
  2387. // overwrite WorldObject function for proper name localization
  2388. const char* Creature::GetNameForLocaleIdx(LocaleConstant loc_idx) const
  2389. {
  2390. if (loc_idx != DEFAULT_LOCALE)
  2391. {
  2392. uint8 uloc_idx = uint8(loc_idx);
  2393. CreatureLocale const *cl = sObjectMgr->GetCreatureLocale(GetEntry());
  2394. if (cl)
  2395. {
  2396. if (cl->Name.size() > uloc_idx && !cl->Name[uloc_idx].empty())
  2397. return cl->Name[uloc_idx].c_str();
  2398. }
  2399. }
  2401. return GetName();
  2402. }
  2404. void Creature::FarTeleportTo(Map* map, float X, float Y, float Z, float O)
  2405. {
  2406. InterruptNonMeleeSpells(true);
  2407. CombatStop();
  2408. ClearComboPointHolders();
  2409. DeleteThreatList();
  2410. GetMotionMaster()->Clear(false);
  2411. DestroyForNearbyPlayers();
  2413. RemoveFromWorld();
  2414. ResetMap();
  2415. SetMap(map);
  2416. AddToWorld();
  2418. SetPosition(X, Y, Z, O, true);
  2419. }
  2421. bool Creature::IsDungeonBoss() const
  2422. {
  2423. CreatureInfo const *cinfo = ObjectMgr::GetCreatureTemplate(GetEntry());
  2424. return cinfo && (cinfo->flags_extra & CREATURE_FLAG_EXTRA_DUNGEON_BOSS);
  2425. }