src/game/Creature.cpp

   1 /*
   2  * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "Common.h"
  20 #include "Database/DatabaseEnv.h"
  21 #include "WorldPacket.h"
  22 #include "World.h"
  23 #include "ObjectMgr.h"
  24 #include "ObjectDefines.h"
  25 #include "SpellMgr.h"
  26 #include "Creature.h"
  27 #include "QuestDef.h"
  28 #include "GossipDef.h"
  29 #include "Player.h"
  30 #include "PoolManager.h"
  31 #include "Opcodes.h"
  32 #include "Log.h"
  33 #include "LootMgr.h"
  34 #include "MapManager.h"
  35 #include "CreatureAI.h"
  36 #include "CreatureAISelector.h"
  37 #include "Formulas.h"
  38 #include "WaypointMovementGenerator.h"
  39 #include "InstanceData.h"
  40 #include "BattleGroundMgr.h"
  41 #include "Spell.h"
  42 #include "Util.h"
  43 #include "GridNotifiers.h"
  44 #include "GridNotifiersImpl.h"
  45 #include "CellImpl.h"
  46
  47 // apply implementation of the singletons
  48 #include "Policies/SingletonImp.h"
  49
  50 TrainerSpell const* TrainerSpellData::Find(uint32 spell_id) const
  51 {
  52     TrainerSpellMap::const_iterator itr = spellList.find(spell_id);
  53     if (itr != spellList.end())
  54         return &itr->second;
  55
  56     return NULL;
  57 }
  58
  59 bool VendorItemData::RemoveItem( uint32 item_id )
  60 {
  61     for(VendorItemList::iterator i = m_items.begin(); i != m_items.end(); ++i )
  62     {
  63         if((*i)->item == item_id)
  64         {
  65             m_items.erase(i);
  66             return true;
  67         }
  68     }
  69     return false;
  70 }
  71
  72 size_t VendorItemData::FindItemSlot(uint32 item_id) const
  73 {
  74     for(size_t i = 0; i < m_items.size(); ++i )
  75         if(m_items[i]->item == item_id)
  76             return i;
  77     return m_items.size();
  78 }
  79
  80 VendorItem const* VendorItemData::FindItem(uint32 item_id) const
  81 {
  82     for(VendorItemList::const_iterator i = m_items.begin(); i != m_items.end(); ++i )
  83         if((*i)->item == item_id)
  84             return *i;
  85     return NULL;
  86 }
  87
  88 bool AssistDelayEvent::Execute(uint64 /*e_time*/, uint32 /*p_time*/)
  89 {
  90     if(Unit* victim = Unit::GetUnit(m_owner, m_victim))
  91     {
  92         while (!m_assistants.empty())
  93         {
  94             Creature* assistant = (Creature*)Unit::GetUnit(m_owner, *m_assistants.begin());
  95             m_assistants.pop_front();
  96
  97             if (assistant && assistant->CanAssistTo(&m_owner, victim))
  98             {
  99                 assistant->SetNoCallAssistance(true);
 100                 if(assistant->AI())
 101                     assistant->AI()->AttackStart(victim);
 102             }
 103         }
 104     }
 105     return true;
 106 }
 107
 108 bool ForcedDespawnDelayEvent::Execute(uint64 /*e_time*/, uint32 /*p_time*/)
 109 {
 110     m_owner.ForcedDespawn();
 111     return true;
 112 }
 113
 114 Creature::Creature(CreatureSubtype subtype) :
 115 Unit(), i_AI(NULL),
 116 lootForPickPocketed(false), lootForBody(false), m_groupLootTimer(0), m_groupLootId(0),
 117 m_lootMoney(0), m_lootRecipient(0),
 118 m_deathTimer(0), m_respawnTime(0), m_respawnDelay(25), m_corpseDelay(60), m_respawnradius(0.0f),
 119 m_subtype(subtype), m_defaultMovementType(IDLE_MOTION_TYPE), m_DBTableGuid(0), m_equipmentId(0),
 120 m_AlreadyCallAssistance(false), m_AlreadySearchedAssistance(false),
 121 m_regenHealth(true), m_AI_locked(false), m_isDeadByDefault(false), m_meleeDamageSchoolMask(SPELL_SCHOOL_MASK_NORMAL),
 122 m_creatureInfo(NULL), m_isActiveObject(false), m_splineFlags(SPLINEFLAG_WALKMODE)
 123 {
 124     m_regenTimer = 200;
 125     m_valuesCount = UNIT_END;
 126
 127     for(int i = 0; i < 4; ++i)
 128         m_spells[i] = 0;
 129
 130     m_CreatureSpellCooldowns.clear();
 131     m_CreatureCategoryCooldowns.clear();
 132     m_GlobalCooldown = 0;
 133
 134     m_splineFlags = SPLINEFLAG_WALKMODE;
 135 }
 136
 137 Creature::~Creature()
 138 {
 139     CleanupsBeforeDelete();
 140
 141     m_vendorItemCounts.clear();
 142
 143     delete i_AI;
 144     i_AI = NULL;
 145 }
 146
 147 void Creature::AddToWorld()
 148 {
 149     ///- Register the creature for guid lookup
 150     if(!IsInWorld() && GetGUIDHigh() == HIGHGUID_UNIT)
 151         GetMap()->GetObjectsStore().insert<Creature>(GetGUID(), (Creature*)this);
 152
 153     Unit::AddToWorld();
 154 }
 155
 156 void Creature::RemoveFromWorld()
 157 {
 158     ///- Remove the creature from the accessor
 159     if(IsInWorld() && GetGUIDHigh() == HIGHGUID_UNIT)
 160         GetMap()->GetObjectsStore().erase<Creature>(GetGUID(), (Creature*)NULL);
 161
 162     Unit::RemoveFromWorld();
 163 }
 164
 165 void Creature::RemoveCorpse()
 166 {
 167     if ((getDeathState() != CORPSE && !m_isDeadByDefault) || (getDeathState() != ALIVE && m_isDeadByDefault))
 168         return;
 169
 170     m_deathTimer = 0;
 171     setDeathState(DEAD);
 172     UpdateObjectVisibility();
 173     loot.clear();
 174     uint32 respawnDelay = m_respawnDelay;
 175     if (AI())
 176         AI()->CorpseRemoved(respawnDelay);
 177
 178     m_respawnTime = time(NULL) + respawnDelay;
 179
 180     float x, y, z, o;
 181     GetRespawnCoord(x, y, z, &o);
 182     GetMap()->CreatureRelocation(this, x, y, z, o);
 183 }
 184
 185 /**
 186  * change the entry of creature until respawn
 187  */
 188 bool Creature::InitEntry(uint32 Entry, uint32 team, const CreatureData *data )
 189 {
 190     CreatureInfo const *normalInfo = ObjectMgr::GetCreatureTemplate(Entry);
 191     if(!normalInfo)
 192     {
 193         sLog.outErrorDb("Creature::UpdateEntry creature entry %u does not exist.", Entry);
 194         return false;
 195     }
 196
 197     // get difficulty 1 mode entry
 198     uint32 actualEntry = Entry;
 199     CreatureInfo const *cinfo = normalInfo;
 200     // TODO correctly implement spawnmodes for non-bg maps
 201     for (uint32 diff = 0; diff < MAX_DIFFICULTY - 1; ++diff)
 202     {
 203         if (normalInfo->DifficultyEntry[diff])
 204         {
 205             // we already have valid Map pointer for current creature!
 206             if (GetMap()->GetSpawnMode() > diff)
 207             {
 208                 cinfo = ObjectMgr::GetCreatureTemplate(normalInfo->DifficultyEntry[diff]);
 209                 if (!cinfo)
 210                 {
 211                     // maybe check such things already at startup
 212                     sLog.outErrorDb("Creature::UpdateEntry creature difficulty %u entry %u does not exist.", diff + 1, actualEntry);
 213                     return false;
 214                 }
 215             }
 216         }
 217     }
 218
 219     SetEntry(Entry);                                        // normal entry always
 220     m_creatureInfo = cinfo;                                 // map mode related always
 221
 222     // equal to player Race field, but creature does not have race
 223     SetByteValue(UNIT_FIELD_BYTES_0, 0, 0);
 224
 225     // known valid are: CLASS_WARRIOR,CLASS_PALADIN,CLASS_ROGUE,CLASS_MAGE
 226     SetByteValue(UNIT_FIELD_BYTES_0, 1, uint8(cinfo->unit_class));
 227
 228     uint32 display_id = sObjectMgr.ChooseDisplayId(team, GetCreatureInfo(), data);
 229     if (!display_id)                                        // Cancel load if no display id
 230     {
 231         sLog.outErrorDb("Creature (Entry: %u) has no model defined in table `creature_template`, can't load.", Entry);
 232         return false;
 233     }
 234
 235     CreatureModelInfo const *minfo = sObjectMgr.GetCreatureModelRandomGender(display_id);
 236     if (!minfo)                                             // Cancel load if no model defined
 237     {
 238         sLog.outErrorDb("Creature (Entry: %u) has no model info defined in table `creature_model_info`, can't load.", Entry);
 239         return false;
 240     }
 241
 242     display_id = minfo->modelid;                            // it can be different (for another gender)
 243
 244     SetDisplayId(display_id);
 245     SetNativeDisplayId(display_id);
 246     SetByteValue(UNIT_FIELD_BYTES_0, 2, minfo->gender);
 247
 248     // Load creature equipment
 249     if(!data || data->equipmentId == 0)
 250     {                                                       // use default from the template
 251         LoadEquipment(cinfo->equipmentId);
 252     }
 253     else if(data && data->equipmentId != -1)
 254     {                                                       // override, -1 means no equipment
 255         LoadEquipment(data->equipmentId);
 256     }
 257
 258     SetName(normalInfo->Name);                              // at normal entry always
 259
 260     SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, minfo->bounding_radius);
 261     SetFloatValue(UNIT_FIELD_COMBATREACH, minfo->combat_reach);
 262
 263     SetFloatValue(UNIT_MOD_CAST_SPEED, 1.0f);
 264
 265     SetSpeedRate(MOVE_WALK, cinfo->speed);
 266     SetSpeedRate(MOVE_RUN,  cinfo->speed);
 267     SetSpeedRate(MOVE_SWIM, cinfo->speed);
 268
 269     SetFloatValue(OBJECT_FIELD_SCALE_X, cinfo->scale);
 270
 271     // checked at loading
 272     m_defaultMovementType = MovementGeneratorType(cinfo->MovementType);
 273     if(!m_respawnradius && m_defaultMovementType == RANDOM_MOTION_TYPE)
 274         m_defaultMovementType = IDLE_MOTION_TYPE;
 275
 276     return true;
 277 }
 278
 279 bool Creature::UpdateEntry(uint32 Entry, uint32 team, const CreatureData *data )
 280 {
 281     if(!InitEntry(Entry, team, data))
 282         return false;
 283
 284     m_regenHealth = GetCreatureInfo()->RegenHealth;
 285
 286     // creatures always have melee weapon ready if any
 287     SetSheath(SHEATH_STATE_MELEE);
 288
 289     SelectLevel(GetCreatureInfo());
 290     if (team == HORDE)
 291         setFaction(GetCreatureInfo()->faction_H);
 292     else
 293         setFaction(GetCreatureInfo()->faction_A);
 294
 295     SetUInt32Value(UNIT_NPC_FLAGS,GetCreatureInfo()->npcflag);
 296
 297     SetAttackTime(BASE_ATTACK,  GetCreatureInfo()->baseattacktime);
 298     SetAttackTime(OFF_ATTACK,   GetCreatureInfo()->baseattacktime);
 299     SetAttackTime(RANGED_ATTACK,GetCreatureInfo()->rangeattacktime);
 300
 301     SetUInt32Value(UNIT_FIELD_FLAGS,GetCreatureInfo()->unit_flags);
 302     SetUInt32Value(UNIT_DYNAMIC_FLAGS,GetCreatureInfo()->dynamicflags);
 303
 304     SetModifierValue(UNIT_MOD_ARMOR,             BASE_VALUE, float(GetCreatureInfo()->armor));
 305     SetModifierValue(UNIT_MOD_RESISTANCE_HOLY,   BASE_VALUE, float(GetCreatureInfo()->resistance1));
 306     SetModifierValue(UNIT_MOD_RESISTANCE_FIRE,   BASE_VALUE, float(GetCreatureInfo()->resistance2));
 307     SetModifierValue(UNIT_MOD_RESISTANCE_NATURE, BASE_VALUE, float(GetCreatureInfo()->resistance3));
 308     SetModifierValue(UNIT_MOD_RESISTANCE_FROST,  BASE_VALUE, float(GetCreatureInfo()->resistance4));
 309     SetModifierValue(UNIT_MOD_RESISTANCE_SHADOW, BASE_VALUE, float(GetCreatureInfo()->resistance5));
 310     SetModifierValue(UNIT_MOD_RESISTANCE_ARCANE, BASE_VALUE, float(GetCreatureInfo()->resistance6));
 311
 312     SetCanModifyStats(true);
 313     UpdateAllStats();
 314
 315     // checked and error show at loading templates
 316     if (FactionTemplateEntry const* factionTemplate = sFactionTemplateStore.LookupEntry(GetCreatureInfo()->faction_A))
 317     {
 318         if (factionTemplate->factionFlags & FACTION_TEMPLATE_FLAG_PVP)
 319             SetPvP(true);
 320         else
 321             SetPvP(false);
 322     }
 323
 324     for(int i = 0; i < CREATURE_MAX_SPELLS; ++i)
 325         m_spells[i] = GetCreatureInfo()->spells[i];
 326
 327     return true;
 328 }
 329
 330 void Creature::Update(uint32 diff)
 331 {
 332     if(m_GlobalCooldown <= diff)
 333         m_GlobalCooldown = 0;
 334     else
 335         m_GlobalCooldown -= diff;
 336
 337     switch( m_deathState )
 338     {
 339         case JUST_ALIVED:
 340             // Don't must be called, see Creature::setDeathState JUST_ALIVED -> ALIVE promoting.
 341             sLog.outError("Creature (GUIDLow: %u Entry: %u ) in wrong state: JUST_ALIVED (4)",GetGUIDLow(),GetEntry());
 342             break;
 343         case JUST_DIED:
 344             // Don't must be called, see Creature::setDeathState JUST_DIED -> CORPSE promoting.
 345             sLog.outError("Creature (GUIDLow: %u Entry: %u ) in wrong state: JUST_DEAD (1)",GetGUIDLow(),GetEntry());
 346             break;
 347         case DEAD:
 348         {
 349             if( m_respawnTime <= time(NULL) )
 350             {
 351                 DEBUG_LOG("Respawning...");
 352                 m_respawnTime = 0;
 353                 lootForPickPocketed = false;
 354                 lootForBody         = false;
 355
 356                 if(m_originalEntry != GetEntry())
 357                     UpdateEntry(m_originalEntry);
 358
 359                 CreatureInfo const *cinfo = GetCreatureInfo();
 360
 361                 SelectLevel(cinfo);
 362                 SetUInt32Value(UNIT_DYNAMIC_FLAGS, 0);
 363                 if (m_isDeadByDefault)
 364                 {
 365                     setDeathState(JUST_DIED);
 366                     SetHealth(0);
 367                     i_motionMaster.Clear();
 368                     clearUnitState(UNIT_STAT_ALL_STATE);
 369                     LoadCreaturesAddon(true);
 370                 }
 371                 else
 372                     setDeathState( JUST_ALIVED );
 373
 374                 //Call AI respawn virtual function
 375                 i_AI->JustRespawned();
 376
 377                 uint16 poolid = GetDBTableGUIDLow() ? sPoolMgr.IsPartOfAPool<Creature>(GetDBTableGUIDLow()) : 0;
 378                 if (poolid)
 379                     sPoolMgr.UpdatePool<Creature>(poolid, GetDBTableGUIDLow());
 380                 else
 381                     GetMap()->Add(this);
 382             }
 383             break;
 384         }
 385         case CORPSE:
 386         {
 387             if (m_isDeadByDefault)
 388                 break;
 389
 390             if( m_deathTimer <= diff )
 391             {
 392                 RemoveCorpse();
 393                 DEBUG_LOG("Removing corpse... %u ", GetEntry());
 394             }
 395             else
 396             {
 397                 m_deathTimer -= diff;
 398                 if (m_groupLootTimer && m_groupLootId)
 399                 {
 400                     if(diff <= m_groupLootTimer)
 401                     {
 402                         m_groupLootTimer -= diff;
 403                     }
 404                     else
 405                     {
 406                         if (Group* group = sObjectMgr.GetGroupById(m_groupLootId))
 407                             group->EndRoll();
 408                         m_groupLootTimer = 0;
 409                         m_groupLootId = 0;
 410                     }
 411                 }
 412             }
 413
 414             break;
 415         }
 416         case ALIVE:
 417         {
 418             if (m_isDeadByDefault)
 419             {
 420                 if( m_deathTimer <= diff )
 421                 {
 422                     RemoveCorpse();
 423                     DEBUG_LOG("Removing alive corpse... %u ", GetEntry());
 424                 }
 425                 else
 426                 {
 427                     m_deathTimer -= diff;
 428                 }
 429             }
 430
 431             Unit::Update( diff );
 432
 433             // creature can be dead after Unit::Update call
 434             // CORPSE/DEAD state will processed at next tick (in other case death timer will be updated unexpectedly)
 435             if(!isAlive())
 436                 break;
 437
 438             if(!IsInEvadeMode())
 439             {
 440                 // do not allow the AI to be changed during update
 441                 m_AI_locked = true;
 442                 i_AI->UpdateAI(diff);
 443                 m_AI_locked = false;
 444             }
 445
 446             // creature can be dead after UpdateAI call
 447             // CORPSE/DEAD state will processed at next tick (in other case death timer will be updated unexpectedly)
 448             if(!isAlive())
 449                 break;
 450             if(m_regenTimer > 0)
 451             {
 452                 if(diff >= m_regenTimer)
 453                     m_regenTimer = 0;
 454                 else
 455                     m_regenTimer -= diff;
 456             }
 457             if (m_regenTimer != 0)
 458                 break;
 459
 460             if (!isInCombat() || IsPolymorphed())
 461                 RegenerateHealth();
 462
 463             RegenerateMana();
 464
 465             m_regenTimer = REGEN_TIME_FULL;
 466             break;
 467         }
 468         case DEAD_FALLING:
 469         {
 470             if (!FallGround())
 471                 setDeathState(JUST_DIED);
 472         }
 473         default:
 474             break;
 475     }
 476 }
 477
 478 void Creature::RegenerateMana()
 479 {
 480     uint32 curValue = GetPower(POWER_MANA);
 481     uint32 maxValue = GetMaxPower(POWER_MANA);
 482
 483     if (curValue >= maxValue)
 484         return;
 485
 486     uint32 addvalue = 0;
 487
 488     // Combat and any controlled creature
 489     if (isInCombat() || GetCharmerOrOwnerGUID())
 490     {
 491         if(!IsUnderLastManaUseEffect())
 492         {
 493             float ManaIncreaseRate = sWorld.getRate(RATE_POWER_MANA);
 494             float Spirit = GetStat(STAT_SPIRIT);
 495
 496             addvalue = uint32((Spirit / 5.0f + 17.0f) * ManaIncreaseRate);
 497         }
 498     }
 499     else
 500         addvalue = maxValue / 3;
 501
 502     ModifyPower(POWER_MANA, addvalue);
 503 }
 504
 505 void Creature::RegenerateHealth()
 506 {
 507     if (!isRegeneratingHealth())
 508         return;
 509
 510     uint32 curValue = GetHealth();
 511     uint32 maxValue = GetMaxHealth();
 512
 513     if (curValue >= maxValue)
 514         return;
 515
 516     uint32 addvalue = 0;
 517
 518     // Not only pet, but any controlled creature
 519     if(GetCharmerOrOwnerGUID())
 520     {
 521         float HealthIncreaseRate = sWorld.getRate(RATE_HEALTH);
 522         float Spirit = GetStat(STAT_SPIRIT);
 523
 524         if( GetPower(POWER_MANA) > 0 )
 525             addvalue = uint32(Spirit * 0.25 * HealthIncreaseRate);
 526         else
 527             addvalue = uint32(Spirit * 0.80 * HealthIncreaseRate);
 528     }
 529     else
 530         addvalue = maxValue/3;
 531
 532     ModifyHealth(addvalue);
 533 }
 534
 535 void Creature::DoFleeToGetAssistance()
 536 {
 537     if (!getVictim())
 538         return;
 539
 540     float radius = sWorld.getConfig(CONFIG_CREATURE_FAMILY_FLEE_ASSISTANCE_RADIUS);
 541     if (radius >0)
 542     {
 543         Creature* pCreature = NULL;
 544
 545         CellPair p(MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY()));
 546         Cell cell(p);
 547         cell.data.Part.reserved = ALL_DISTRICT;
 548         cell.SetNoCreate();
 549         MaNGOS::NearestAssistCreatureInCreatureRangeCheck u_check(this, getVictim(), radius);
 550         MaNGOS::CreatureLastSearcher<MaNGOS::NearestAssistCreatureInCreatureRangeCheck> searcher(this, pCreature, u_check);
 551
 552         TypeContainerVisitor<MaNGOS::CreatureLastSearcher<MaNGOS::NearestAssistCreatureInCreatureRangeCheck>, GridTypeMapContainer > grid_creature_searcher(searcher);
 553
 554         cell.Visit(p, grid_creature_searcher, *GetMap(), *this, radius);
 555
 556         SetNoSearchAssistance(true);
 557         UpdateSpeed(MOVE_RUN, false);
 558
 559         if(!pCreature)
 560             SetFeared(true, getVictim()->GetGUID(), 0 ,sWorld.getConfig(CONFIG_CREATURE_FAMILY_FLEE_DELAY));
 561         else
 562             GetMotionMaster()->MoveSeekAssistance(pCreature->GetPositionX(), pCreature->GetPositionY(), pCreature->GetPositionZ());
 563     }
 564 }
 565
 566 bool Creature::AIM_Initialize()
 567 {
 568     // make sure nothing can change the AI during AI update
 569     if(m_AI_locked)
 570     {
 571         sLog.outDebug("AIM_Initialize: failed to init, locked.");
 572         return false;
 573     }
 574
 575     CreatureAI * oldAI = i_AI;
 576     i_motionMaster.Initialize();
 577     i_AI = FactorySelector::selectAI(this);
 578     if (oldAI)
 579         delete oldAI;
 580     return true;
 581 }
 582
 583 bool Creature::Create(uint32 guidlow, Map *map, uint32 phaseMask, uint32 Entry, uint32 team, const CreatureData *data)
 584 {
 585     ASSERT(map);
 586     SetMap(map);
 587     SetPhaseMask(phaseMask,false);
 588
 589     //oX = x;     oY = y;    dX = x;    dY = y;    m_moveTime = 0;    m_startMove = 0;
 590     const bool bResult = CreateFromProto(guidlow, Entry, team, data);
 591
 592     if (bResult)
 593     {
 594         //Notify the map's instance data.
 595         //Only works if you create the object in it, not if it is moves to that map.
 596         //Normally non-players do not teleport to other maps.
 597         if(map->IsDungeon() && ((InstanceMap*)map)->GetInstanceData())
 598             ((InstanceMap*)map)->GetInstanceData()->OnCreatureCreate(this);
 599
 600         switch (GetCreatureInfo()->rank)
 601         {
 602             case CREATURE_ELITE_RARE:
 603                 m_corpseDelay = sWorld.getConfig(CONFIG_CORPSE_DECAY_RARE);
 604                 break;
 605             case CREATURE_ELITE_ELITE:
 606                 m_corpseDelay = sWorld.getConfig(CONFIG_CORPSE_DECAY_ELITE);
 607                 break;
 608             case CREATURE_ELITE_RAREELITE:
 609                 m_corpseDelay = sWorld.getConfig(CONFIG_CORPSE_DECAY_RAREELITE);
 610                 break;
 611             case CREATURE_ELITE_WORLDBOSS:
 612                 m_corpseDelay = sWorld.getConfig(CONFIG_CORPSE_DECAY_WORLDBOSS);
 613                 break;
 614             default:
 615                 m_corpseDelay = sWorld.getConfig(CONFIG_CORPSE_DECAY_NORMAL);
 616                 break;
 617         }
 618         LoadCreaturesAddon();
 619     }
 620
 621     return bResult;
 622 }
 623
 624 bool Creature::isCanTrainingOf(Player* pPlayer, bool msg) const
 625 {
 626     if(!isTrainer())
 627         return false;
 628
 629     TrainerSpellData const* trainer_spells = GetTrainerSpells();
 630
 631     if(!trainer_spells || trainer_spells->spellList.empty())
 632     {
 633         sLog.outErrorDb("Creature %u (Entry: %u) have UNIT_NPC_FLAG_TRAINER but have empty trainer spell list.",
 634             GetGUIDLow(),GetEntry());
 635         return false;
 636     }
 637
 638     switch(GetCreatureInfo()->trainer_type)
 639     {
 640         case TRAINER_TYPE_CLASS:
 641             if(pPlayer->getClass() != GetCreatureInfo()->trainer_class)
 642             {
 643                 if(msg)
 644                 {
 645                     pPlayer->PlayerTalkClass->ClearMenus();
 646                     switch(GetCreatureInfo()->trainer_class)
 647                     {
 648                         case CLASS_DRUID:  pPlayer->PlayerTalkClass->SendGossipMenu( 4913,GetGUID()); break;
 649                         case CLASS_HUNTER: pPlayer->PlayerTalkClass->SendGossipMenu(10090,GetGUID()); break;
 650                         case CLASS_MAGE:   pPlayer->PlayerTalkClass->SendGossipMenu(  328,GetGUID()); break;
 651                         case CLASS_PALADIN:pPlayer->PlayerTalkClass->SendGossipMenu( 1635,GetGUID()); break;
 652                         case CLASS_PRIEST: pPlayer->PlayerTalkClass->SendGossipMenu( 4436,GetGUID()); break;
 653                         case CLASS_ROGUE:  pPlayer->PlayerTalkClass->SendGossipMenu( 4797,GetGUID()); break;
 654                         case CLASS_SHAMAN: pPlayer->PlayerTalkClass->SendGossipMenu( 5003,GetGUID()); break;
 655                         case CLASS_WARLOCK:pPlayer->PlayerTalkClass->SendGossipMenu( 5836,GetGUID()); break;
 656                         case CLASS_WARRIOR:pPlayer->PlayerTalkClass->SendGossipMenu( 4985,GetGUID()); break;
 657                     }
 658                 }
 659                 return false;
 660             }
 661             break;
 662         case TRAINER_TYPE_PETS:
 663             if(pPlayer->getClass() != CLASS_HUNTER)
 664             {
 665                 pPlayer->PlayerTalkClass->ClearMenus();
 666                 pPlayer->PlayerTalkClass->SendGossipMenu(3620, GetGUID());
 667                 return false;
 668             }
 669             break;
 670         case TRAINER_TYPE_MOUNTS:
 671             if(GetCreatureInfo()->trainer_race && pPlayer->getRace() != GetCreatureInfo()->trainer_race)
 672             {
 673                 if(msg)
 674                 {
 675                     pPlayer->PlayerTalkClass->ClearMenus();
 676                     switch(GetCreatureInfo()->trainer_class)
 677                     {
 678                         case RACE_DWARF:        pPlayer->PlayerTalkClass->SendGossipMenu(5865,GetGUID()); break;
 679                         case RACE_GNOME:        pPlayer->PlayerTalkClass->SendGossipMenu(4881,GetGUID()); break;
 680                         case RACE_HUMAN:        pPlayer->PlayerTalkClass->SendGossipMenu(5861,GetGUID()); break;
 681                         case RACE_NIGHTELF:     pPlayer->PlayerTalkClass->SendGossipMenu(5862,GetGUID()); break;
 682                         case RACE_ORC:          pPlayer->PlayerTalkClass->SendGossipMenu(5863,GetGUID()); break;
 683                         case RACE_TAUREN:       pPlayer->PlayerTalkClass->SendGossipMenu(5864,GetGUID()); break;
 684                         case RACE_TROLL:        pPlayer->PlayerTalkClass->SendGossipMenu(5816,GetGUID()); break;
 685                         case RACE_UNDEAD_PLAYER:pPlayer->PlayerTalkClass->SendGossipMenu( 624,GetGUID()); break;
 686                         case RACE_BLOODELF:     pPlayer->PlayerTalkClass->SendGossipMenu(5862,GetGUID()); break;
 687                         case RACE_DRAENEI:      pPlayer->PlayerTalkClass->SendGossipMenu(5864,GetGUID()); break;
 688                     }
 689                 }
 690                 return false;
 691             }
 692             break;
 693         case TRAINER_TYPE_TRADESKILLS:
 694             if(GetCreatureInfo()->trainer_spell && !pPlayer->HasSpell(GetCreatureInfo()->trainer_spell))
 695             {
 696                 if(msg)
 697                 {
 698                     pPlayer->PlayerTalkClass->ClearMenus();
 699                     pPlayer->PlayerTalkClass->SendGossipMenu(11031, GetGUID());
 700                 }
 701                 return false;
 702             }
 703             break;
 704         default:
 705             return false;                                   // checked and error output at creature_template loading
 706     }
 707     return true;
 708 }
 709
 710 bool Creature::isCanInteractWithBattleMaster(Player* pPlayer, bool msg) const
 711 {
 712     if(!isBattleMaster())
 713         return false;
 714
 715     BattleGroundTypeId bgTypeId = sBattleGroundMgr.GetBattleMasterBG(GetEntry());
 716     if (bgTypeId == BATTLEGROUND_TYPE_NONE)
 717         return false;
 718
 719     if(!msg)
 720         return pPlayer->GetBGAccessByLevel(bgTypeId);
 721
 722     if(!pPlayer->GetBGAccessByLevel(bgTypeId))
 723     {
 724         pPlayer->PlayerTalkClass->ClearMenus();
 725         switch(bgTypeId)
 726         {
 727             case BATTLEGROUND_AV:  pPlayer->PlayerTalkClass->SendGossipMenu(7616, GetGUID()); break;
 728             case BATTLEGROUND_WS:  pPlayer->PlayerTalkClass->SendGossipMenu(7599, GetGUID()); break;
 729             case BATTLEGROUND_AB:  pPlayer->PlayerTalkClass->SendGossipMenu(7642, GetGUID()); break;
 730             case BATTLEGROUND_EY:
 731             case BATTLEGROUND_NA:
 732             case BATTLEGROUND_BE:
 733             case BATTLEGROUND_AA:
 734             case BATTLEGROUND_RL:
 735             case BATTLEGROUND_SA:
 736             case BATTLEGROUND_DS:
 737             case BATTLEGROUND_RV: pPlayer->PlayerTalkClass->SendGossipMenu(10024, GetGUID()); break;
 738             default: break;
 739         }
 740         return false;
 741     }
 742     return true;
 743 }
 744
 745 bool Creature::isCanTrainingAndResetTalentsOf(Player* pPlayer) const
 746 {
 747     return pPlayer->getLevel() >= 10
 748         && GetCreatureInfo()->trainer_type == TRAINER_TYPE_CLASS
 749         && pPlayer->getClass() == GetCreatureInfo()->trainer_class;
 750 }
 751
 752 void Creature::AI_SendMoveToPacket(float x, float y, float z, uint32 time, SplineFlags flags, uint8 type)
 753 {
 754     /*    uint32 timeElap = getMSTime();
 755         if ((timeElap - m_startMove) < m_moveTime)
 756         {
 757             oX = (dX - oX) * ( (timeElap - m_startMove) / m_moveTime );
 758             oY = (dY - oY) * ( (timeElap - m_startMove) / m_moveTime );
 759         }
 760         else
 761         {
 762             oX = dX;
 763             oY = dY;
 764         }
 765
 766         dX = x;
 767         dY = y;
 768         m_orientation = atan2((oY - dY), (oX - dX));
 769
 770         m_startMove = getMSTime();
 771         m_moveTime = time;*/
 772     SendMonsterMove(x, y, z, type, flags, time);
 773 }
 774
 775 Player *Creature::GetLootRecipient() const
 776 {
 777     if (!m_lootRecipient)
 778         return NULL;
 779     else return ObjectAccessor::FindPlayer(m_lootRecipient);
 780 }
 781
 782 void Creature::SetLootRecipient(Unit *unit)
 783 {
 784     // set the player whose group should receive the right
 785     // to loot the creature after it dies
 786     // should be set to NULL after the loot disappears
 787
 788     if (!unit)
 789     {
 790         m_lootRecipient = 0;
 791         RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TAPPED);
 792         return;
 793     }
 794
 795     Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself();
 796     if(!player)                                             // normal creature, no player involved
 797         return;
 798
 799     m_lootRecipient = player->GetGUID();
 800     SetFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TAPPED);
 801 }
 802
 803 void Creature::SaveToDB()
 804 {
 805     // this should only be used when the creature has already been loaded
 806     // preferably after adding to map, because mapid may not be valid otherwise
 807     CreatureData const *data = sObjectMgr.GetCreatureData(m_DBTableGuid);
 808     if(!data)
 809     {
 810         sLog.outError("Creature::SaveToDB failed, cannot get creature data!");
 811         return;
 812     }
 813
 814     SaveToDB(GetMapId(), data->spawnMask,GetPhaseMask());
 815 }
 816
 817 void Creature::SaveToDB(uint32 mapid, uint8 spawnMask, uint32 phaseMask)
 818 {
 819     // update in loaded data
 820     if (!m_DBTableGuid)
 821         m_DBTableGuid = GetGUIDLow();
 822     CreatureData& data = sObjectMgr.NewOrExistCreatureData(m_DBTableGuid);
 823
 824     uint32 displayId = GetNativeDisplayId();
 825
 826     // check if it's a custom model and if not, use 0 for displayId
 827     CreatureInfo const *cinfo = GetCreatureInfo();
 828     if (cinfo)
 829     {
 830         if (displayId != cinfo->DisplayID_A[0] && displayId != cinfo->DisplayID_A[1] &&
 831             displayId != cinfo->DisplayID_H[0] && displayId != cinfo->DisplayID_H[1])
 832         {
 833             if (cinfo->DisplayID_A[0])
 834                 if (CreatureModelInfo const *minfo = sObjectMgr.GetCreatureModelInfo(cinfo->DisplayID_A[0]))
 835                     if(displayId == minfo->modelid_other_gender)
 836                         displayId = 0;
 837
 838             if (displayId && cinfo->DisplayID_A[1])
 839                 if (CreatureModelInfo const *minfo = sObjectMgr.GetCreatureModelInfo(cinfo->DisplayID_A[1]))
 840                     if(displayId == minfo->modelid_other_gender)
 841                         displayId = 0;
 842
 843             if (displayId && cinfo->DisplayID_H[0])
 844                 if (CreatureModelInfo const *minfo = sObjectMgr.GetCreatureModelInfo(cinfo->DisplayID_H[0]))
 845                     if(displayId == minfo->modelid_other_gender)
 846                         displayId = 0;
 847
 848             if (displayId && cinfo->DisplayID_H[1])
 849                 if (CreatureModelInfo const *minfo = sObjectMgr.GetCreatureModelInfo(cinfo->DisplayID_H[1]))
 850                     if(displayId == minfo->modelid_other_gender)
 851                         displayId = 0;
 852         }
 853         else
 854             displayId = 0;
 855     }
 856
 857     // data->guid = guid don't must be update at save
 858     data.id = GetEntry();
 859     data.mapid = mapid;
 860     data.phaseMask = phaseMask;
 861     data.displayid = displayId;
 862     data.equipmentId = GetEquipmentId();
 863     data.posX = GetPositionX();
 864     data.posY = GetPositionY();
 865     data.posZ = GetPositionZ();
 866     data.orientation = GetOrientation();
 867     data.spawntimesecs = m_respawnDelay;
 868     // prevent add data integrity problems
 869     data.spawndist = GetDefaultMovementType()==IDLE_MOTION_TYPE ? 0 : m_respawnradius;
 870     data.currentwaypoint = 0;
 871     data.curhealth = GetHealth();
 872     data.curmana = GetPower(POWER_MANA);
 873     data.is_dead = m_isDeadByDefault;
 874     // prevent add data integrity problems
 875     data.movementType = !m_respawnradius && GetDefaultMovementType()==RANDOM_MOTION_TYPE
 876         ? IDLE_MOTION_TYPE : GetDefaultMovementType();
 877     data.spawnMask = spawnMask;
 878
 879     // updated in DB
 880     WorldDatabase.BeginTransaction();
 881
 882     WorldDatabase.PExecuteLog("DELETE FROM creature WHERE guid = '%u'", m_DBTableGuid);
 883
 884     std::ostringstream ss;
 885     ss << "INSERT INTO creature VALUES ("
 886         << m_DBTableGuid << ","
 887         << GetEntry() << ","
 888         << mapid <<","
 889         << uint32(spawnMask) << ","                         // cast to prevent save as symbol
 890         << uint16(GetPhaseMask()) << ","                    // prevent out of range error
 891         << displayId <<","
 892         << GetEquipmentId() <<","
 893         << GetPositionX() << ","
 894         << GetPositionY() << ","
 895         << GetPositionZ() << ","
 896         << GetOrientation() << ","
 897         << m_respawnDelay << ","                            //respawn time
 898         << (float) m_respawnradius << ","                   //spawn distance (float)
 899         << (uint32) (0) << ","                              //currentwaypoint
 900         << GetHealth() << ","                               //curhealth
 901         << GetPower(POWER_MANA) << ","                      //curmana
 902         << (m_isDeadByDefault ? 1 : 0) << ","               //is_dead
 903         << GetDefaultMovementType() << ")";                 //default movement generator type
 904
 905     WorldDatabase.PExecuteLog("%s", ss.str().c_str());
 906
 907     WorldDatabase.CommitTransaction();
 908 }
 909
 910 void Creature::SelectLevel(const CreatureInfo *cinfo)
 911 {
 912     uint32 rank = isPet()? 0 : cinfo->rank;
 913
 914     // level
 915     uint32 minlevel = std::min(cinfo->maxlevel, cinfo->minlevel);
 916     uint32 maxlevel = std::max(cinfo->maxlevel, cinfo->minlevel);
 917     uint32 level = minlevel == maxlevel ? minlevel : urand(minlevel, maxlevel);
 918     SetLevel(level);
 919
 920     float rellevel = maxlevel == minlevel ? 0 : (float(level - minlevel))/(maxlevel - minlevel);
 921
 922     // health
 923     float healthmod = _GetHealthMod(rank);
 924
 925     uint32 minhealth = std::min(cinfo->maxhealth, cinfo->minhealth);
 926     uint32 maxhealth = std::max(cinfo->maxhealth, cinfo->minhealth);
 927     uint32 health = uint32(healthmod * (minhealth + uint32(rellevel*(maxhealth - minhealth))));
 928
 929     SetCreateHealth(health);
 930     SetMaxHealth(health);
 931     SetHealth(health);
 932
 933     // mana
 934     uint32 minmana = std::min(cinfo->maxmana, cinfo->minmana);
 935     uint32 maxmana = std::max(cinfo->maxmana, cinfo->minmana);
 936     uint32 mana = minmana + uint32(rellevel * (maxmana - minmana));
 937
 938     SetCreateMana(mana);
 939     SetMaxPower(POWER_MANA, mana);                          //MAX Mana
 940     SetPower(POWER_MANA, mana);
 941
 942     // TODO: set UNIT_FIELD_POWER*, for some creature class case (energy, etc)
 943
 944     SetModifierValue(UNIT_MOD_HEALTH, BASE_VALUE, health);
 945     SetModifierValue(UNIT_MOD_MANA, BASE_VALUE, mana);
 946
 947     // damage
 948     float damagemod = _GetDamageMod(rank);
 949
 950     SetBaseWeaponDamage(BASE_ATTACK, MINDAMAGE, cinfo->mindmg * damagemod);
 951     SetBaseWeaponDamage(BASE_ATTACK, MAXDAMAGE, cinfo->maxdmg * damagemod);
 952
 953     SetFloatValue(UNIT_FIELD_MINRANGEDDAMAGE,cinfo->minrangedmg * damagemod);
 954     SetFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE,cinfo->maxrangedmg * damagemod);
 955
 956     SetModifierValue(UNIT_MOD_ATTACK_POWER, BASE_VALUE, cinfo->attackpower * damagemod);
 957 }
 958
 959 float Creature::_GetHealthMod(int32 Rank)
 960 {
 961     switch (Rank)                                           // define rates for each elite rank
 962     {
 963         case CREATURE_ELITE_NORMAL:
 964             return sWorld.getRate(RATE_CREATURE_NORMAL_HP);
 965         case CREATURE_ELITE_ELITE:
 966             return sWorld.getRate(RATE_CREATURE_ELITE_ELITE_HP);
 967         case CREATURE_ELITE_RAREELITE:
 968             return sWorld.getRate(RATE_CREATURE_ELITE_RAREELITE_HP);
 969         case CREATURE_ELITE_WORLDBOSS:
 970             return sWorld.getRate(RATE_CREATURE_ELITE_WORLDBOSS_HP);
 971         case CREATURE_ELITE_RARE:
 972             return sWorld.getRate(RATE_CREATURE_ELITE_RARE_HP);
 973         default:
 974             return sWorld.getRate(RATE_CREATURE_ELITE_ELITE_HP);
 975     }
 976 }
 977
 978 float Creature::_GetDamageMod(int32 Rank)
 979 {
 980     switch (Rank)                                           // define rates for each elite rank
 981     {
 982         case CREATURE_ELITE_NORMAL:
 983             return sWorld.getRate(RATE_CREATURE_NORMAL_DAMAGE);
 984         case CREATURE_ELITE_ELITE:
 985             return sWorld.getRate(RATE_CREATURE_ELITE_ELITE_DAMAGE);
 986         case CREATURE_ELITE_RAREELITE:
 987             return sWorld.getRate(RATE_CREATURE_ELITE_RAREELITE_DAMAGE);
 988         case CREATURE_ELITE_WORLDBOSS:
 989             return sWorld.getRate(RATE_CREATURE_ELITE_WORLDBOSS_DAMAGE);
 990         case CREATURE_ELITE_RARE:
 991             return sWorld.getRate(RATE_CREATURE_ELITE_RARE_DAMAGE);
 992         default:
 993             return sWorld.getRate(RATE_CREATURE_ELITE_ELITE_DAMAGE);
 994     }
 995 }
 996
 997 float Creature::GetSpellDamageMod(int32 Rank)
 998 {
 999     switch (Rank)                                           // define rates for each elite rank
1000     {
1001         case CREATURE_ELITE_NORMAL:
1002             return sWorld.getRate(RATE_CREATURE_NORMAL_SPELLDAMAGE);
1003         case CREATURE_ELITE_ELITE:
1004             return sWorld.getRate(RATE_CREATURE_ELITE_ELITE_SPELLDAMAGE);
1005         case CREATURE_ELITE_RAREELITE:
1006             return sWorld.getRate(RATE_CREATURE_ELITE_RAREELITE_SPELLDAMAGE);
1007         case CREATURE_ELITE_WORLDBOSS:
1008             return sWorld.getRate(RATE_CREATURE_ELITE_WORLDBOSS_SPELLDAMAGE);
1009         case CREATURE_ELITE_RARE:
1010             return sWorld.getRate(RATE_CREATURE_ELITE_RARE_SPELLDAMAGE);
1011         default:
1012             return sWorld.getRate(RATE_CREATURE_ELITE_ELITE_SPELLDAMAGE);
1013     }
1014 }
1015
1016 bool Creature::CreateFromProto(uint32 guidlow, uint32 Entry, uint32 team, const CreatureData *data)
1017 {
1018     CreatureInfo const *cinfo = ObjectMgr::GetCreatureTemplate(Entry);
1019     if(!cinfo)
1020     {
1021         sLog.outErrorDb("Creature entry %u does not exist.", Entry);
1022         return false;
1023     }
1024     m_originalEntry = Entry;
1025
1026     Object::_Create(guidlow, Entry, HIGHGUID_UNIT);
1027
1028     if(!UpdateEntry(Entry, team, data))
1029         return false;
1030
1031     return true;
1032 }
1033
1034 bool Creature::LoadFromDB(uint32 guid, Map *map)
1035 {
1036     CreatureData const* data = sObjectMgr.GetCreatureData(guid);
1037
1038     if(!data)
1039     {
1040         sLog.outErrorDb("Creature (GUID: %u) not found in table `creature`, can't load. ",guid);
1041         return false;
1042     }
1043
1044     m_DBTableGuid = guid;
1045     if (map->GetInstanceId() == 0)
1046     {
1047         // Creature can be loaded already in map if grid has been unloaded while creature walk to another grid
1048         // FIXME: until creature guids is global and for instances used dynamic generated guids
1049         // in instance possible load creature duplicates with same DB guid but different in game guids
1050         // This will be until implementing per-map creature guids
1051         if (map->GetCreature(MAKE_NEW_GUID(guid, data->id, HIGHGUID_UNIT)))
1052             return false;
1053     }
1054     else
1055         guid = sObjectMgr.GenerateLowGuid(HIGHGUID_UNIT);
1056
1057     uint16 team = 0;
1058     if(!Create(guid, map, data->phaseMask, data->id, team, data))
1059         return false;
1060
1061     Relocate(data->posX, data->posY, data->posZ, data->orientation);
1062
1063     if(!IsPositionValid())
1064     {
1065         sLog.outError("Creature (guidlow %d, entry %d) not loaded. Suggested coordinates isn't valid (X: %f Y: %f)", GetGUIDLow(), GetEntry(), GetPositionX(), GetPositionY());
1066         return false;
1067     }
1068
1069     m_respawnradius = data->spawndist;
1070
1071     m_respawnDelay = data->spawntimesecs;
1072     m_isDeadByDefault = data->is_dead;
1073     m_deathState = m_isDeadByDefault ? DEAD : ALIVE;
1074
1075     m_respawnTime  = sObjectMgr.GetCreatureRespawnTime(m_DBTableGuid, GetInstanceId());
1076     if(m_respawnTime > time(NULL))                          // not ready to respawn
1077     {
1078         m_deathState = DEAD;
1079         if(canFly())
1080         {
1081             float tz = GetMap()->GetHeight(data->posX, data->posY, data->posZ, false);
1082             if(data->posZ - tz > 0.1)
1083                 Relocate(data->posX, data->posY, tz);
1084         }
1085     }
1086     else if(m_respawnTime)                                  // respawn time set but expired
1087     {
1088         m_respawnTime = 0;
1089         sObjectMgr.SaveCreatureRespawnTime(m_DBTableGuid,GetInstanceId(),0);
1090     }
1091
1092     uint32 curhealth = data->curhealth;
1093     if(curhealth)
1094     {
1095         curhealth = uint32(curhealth*_GetHealthMod(GetCreatureInfo()->rank));
1096         if(curhealth < 1)
1097             curhealth = 1;
1098     }
1099
1100     SetHealth(m_deathState == ALIVE ? curhealth : 0);
1101     SetPower(POWER_MANA, data->curmana);
1102
1103     SetMeleeDamageSchool(SpellSchools(GetCreatureInfo()->dmgschool));
1104
1105     // checked at creature_template loading
1106     m_defaultMovementType = MovementGeneratorType(data->movementType);
1107
1108     AIM_Initialize();
1109     return true;
1110 }
1111
1112 void Creature::LoadEquipment(uint32 equip_entry, bool force)
1113 {
1114     if(equip_entry == 0)
1115     {
1116         if (force)
1117         {
1118             for (uint8 i = 0; i < 3; ++i)
1119                 SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + i, 0);
1120             m_equipmentId = 0;
1121         }
1122         return;
1123     }
1124
1125     EquipmentInfo const *einfo = sObjectMgr.GetEquipmentInfo(equip_entry);
1126     if (!einfo)
1127         return;
1128
1129     m_equipmentId = equip_entry;
1130     for (uint8 i = 0; i < 3; ++i)
1131         SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + i, einfo->equipentry[i]);
1132 }
1133
1134 bool Creature::hasQuest(uint32 quest_id) const
1135 {
1136     QuestRelations const& qr = sObjectMgr.mCreatureQuestRelations;
1137     for(QuestRelations::const_iterator itr = qr.lower_bound(GetEntry()); itr != qr.upper_bound(GetEntry()); ++itr)
1138     {
1139         if(itr->second==quest_id)
1140             return true;
1141     }
1142     return false;
1143 }
1144
1145 bool Creature::hasInvolvedQuest(uint32 quest_id) const
1146 {
1147     QuestRelations const& qr = sObjectMgr.mCreatureQuestInvolvedRelations;
1148     for(QuestRelations::const_iterator itr = qr.lower_bound(GetEntry()); itr != qr.upper_bound(GetEntry()); ++itr)
1149     {
1150         if(itr->second == quest_id)
1151             return true;
1152     }
1153     return false;
1154 }
1155
1156 void Creature::DeleteFromDB()
1157 {
1158     if (!m_DBTableGuid)
1159     {
1160         sLog.outDebug("Trying to delete not saved creature!");
1161         return;
1162     }
1163
1164     sObjectMgr.SaveCreatureRespawnTime(m_DBTableGuid,GetInstanceId(),0);
1165     sObjectMgr.DeleteCreatureData(m_DBTableGuid);
1166
1167     WorldDatabase.BeginTransaction();
1168     WorldDatabase.PExecuteLog("DELETE FROM creature WHERE guid = '%u'", m_DBTableGuid);
1169     WorldDatabase.PExecuteLog("DELETE FROM creature_addon WHERE guid = '%u'", m_DBTableGuid);
1170     WorldDatabase.PExecuteLog("DELETE FROM creature_movement WHERE id = '%u'", m_DBTableGuid);
1171     WorldDatabase.PExecuteLog("DELETE FROM game_event_creature WHERE guid = '%u'", m_DBTableGuid);
1172     WorldDatabase.PExecuteLog("DELETE FROM game_event_model_equip WHERE guid = '%u'", m_DBTableGuid);
1173     WorldDatabase.PExecuteLog("DELETE FROM creature_battleground WHERE guid = '%u'", m_DBTableGuid);
1174     WorldDatabase.CommitTransaction();
1175 }
1176
1177 float Creature::GetAttackDistance(Unit const* pl) const
1178 {
1179     float aggroRate = sWorld.getRate(RATE_CREATURE_AGGRO);
1180     if(aggroRate == 0)
1181         return 0.0f;
1182
1183     uint32 playerlevel   = pl->getLevelForTarget(this);
1184     uint32 creaturelevel = getLevelForTarget(pl);
1185
1186     int32 leveldif       = int32(playerlevel) - int32(creaturelevel);
1187
1188     // "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."
1189     if ( leveldif < - 25)
1190         leveldif = -25;
1191
1192     // "The aggro radius of a mob having the same level as the player is roughly 20 yards"
1193     float RetDistance = 20;
1194
1195     // "Aggro Radius varies with level difference at a rate of roughly 1 yard/level"
1196     // radius grow if playlevel < creaturelevel
1197     RetDistance -= (float)leveldif;
1198
1199     if(creaturelevel+5 <= sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL))
1200     {
1201         // detect range auras
1202         RetDistance += GetTotalAuraModifier(SPELL_AURA_MOD_DETECT_RANGE);
1203
1204         // detected range auras
1205         RetDistance += pl->GetTotalAuraModifier(SPELL_AURA_MOD_DETECTED_RANGE);
1206     }
1207
1208     // "Minimum Aggro Radius for a mob seems to be combat range (5 yards)"
1209     if(RetDistance < 5)
1210         RetDistance = 5;
1211
1212     return (RetDistance*aggroRate);
1213 }
1214
1215 void Creature::setDeathState(DeathState s)
1216 {
1217     if ((s == JUST_DIED && !m_isDeadByDefault) || (s == JUST_ALIVED && m_isDeadByDefault))
1218     {
1219         m_deathTimer = m_corpseDelay*IN_MILISECONDS;
1220
1221         // always save boss respawn time at death to prevent crash cheating
1222         if (sWorld.getConfig(CONFIG_SAVE_RESPAWN_TIME_IMMEDIATLY) || isWorldBoss())
1223             SaveRespawnTime();
1224
1225         if (canFly() && FallGround())
1226             return;
1227
1228         if (!IsStopped())
1229             StopMoving();
1230     }
1231     Unit::setDeathState(s);
1232
1233     if (s == JUST_DIED)
1234     {
1235         SetTargetGUID(0);                                   // remove target selection in any cases (can be set at aura remove in Unit::setDeathState)
1236         SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE);
1237
1238         if (!isPet() && GetCreatureInfo()->SkinLootId)
1239             if (LootTemplates_Skinning.HaveLootFor(GetCreatureInfo()->SkinLootId))
1240                 SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
1241
1242         if (canFly() && FallGround())
1243             return;
1244
1245         if (HasSearchedAssistance())
1246         {
1247             SetNoSearchAssistance(false);
1248             UpdateSpeed(MOVE_RUN, false);
1249         }
1250
1251         Unit::setDeathState(CORPSE);
1252     }
1253     if (s == JUST_ALIVED)
1254     {
1255         SetHealth(GetMaxHealth());
1256         SetLootRecipient(NULL);
1257         CreatureInfo const *cinfo = GetCreatureInfo();
1258         SetUInt32Value(UNIT_DYNAMIC_FLAGS, 0);
1259         RemoveFlag (UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
1260         AddSplineFlag(SPLINEFLAG_WALKMODE);
1261         SetUInt32Value(UNIT_NPC_FLAGS, cinfo->npcflag);
1262         Unit::setDeathState(ALIVE);
1263         clearUnitState(UNIT_STAT_ALL_STATE);
1264         i_motionMaster.Clear();
1265         SetMeleeDamageSchool(SpellSchools(cinfo->dmgschool));
1266         LoadCreaturesAddon(true);
1267     }
1268 }
1269
1270 bool Creature::FallGround()
1271 {
1272     // Let's abort after we called this function one time
1273     if (getDeathState() == DEAD_FALLING)
1274         return false;
1275
1276     // Let's do with no vmap because no way to get far distance with vmap high call
1277     float tz = GetMap()->GetHeight(GetPositionX(), GetPositionY(), GetPositionZ(), false);
1278
1279     // Abort too if the ground is very near
1280     if (fabs(GetPositionZ() - tz) < 0.1f)
1281         return false;
1282
1283     Unit::setDeathState(DEAD_FALLING);
1284     GetMotionMaster()->MovePoint(0, GetPositionX(), GetPositionY(), tz);
1285     Relocate(GetPositionX(), GetPositionY(), tz);
1286     return true;
1287 }
1288
1289 void Creature::Respawn()
1290 {
1291     RemoveCorpse();
1292
1293     // forced recreate creature object at clients
1294     UnitVisibility currentVis = GetVisibility();
1295     SetVisibility(VISIBILITY_RESPAWN);
1296     UpdateObjectVisibility();
1297     SetVisibility(currentVis);                              // restore visibility state
1298     UpdateObjectVisibility();
1299
1300     if(getDeathState() == DEAD)
1301     {
1302         if (m_DBTableGuid)
1303             sObjectMgr.SaveCreatureRespawnTime(m_DBTableGuid,GetInstanceId(), 0);
1304         m_respawnTime = time(NULL);                         // respawn at next tick
1305     }
1306 }
1307
1308 void Creature::ForcedDespawn(uint32 timeMSToDespawn)
1309 {
1310     if (timeMSToDespawn)
1311     {
1312         ForcedDespawnDelayEvent *pEvent = new ForcedDespawnDelayEvent(*this);
1313
1314         m_Events.AddEvent(pEvent, m_Events.CalculateTime(timeMSToDespawn));
1315         return;
1316     }
1317
1318     if (isAlive())
1319         setDeathState(JUST_DIED);
1320
1321     RemoveCorpse();
1322     SetHealth(0);                                           // just for nice GM-mode view
1323 }
1324
1325 bool Creature::IsImmunedToSpell(SpellEntry const* spellInfo)
1326 {
1327     if (!spellInfo)
1328         return false;
1329
1330     if (GetCreatureInfo()->MechanicImmuneMask & (1 << (spellInfo->Mechanic - 1)))
1331         return true;
1332
1333     return Unit::IsImmunedToSpell(spellInfo);
1334 }
1335
1336 bool Creature::IsImmunedToSpellEffect(SpellEntry const* spellInfo, uint32 index) const
1337 {
1338     if (GetCreatureInfo()->MechanicImmuneMask & (1 << (spellInfo->EffectMechanic[index] - 1)))
1339         return true;
1340
1341     // Taunt immunity special flag check
1342     if (GetCreatureInfo()->flags_extra & CREATURE_FLAG_EXTRA_NOT_TAUNTABLE)
1343     {
1344         // Taunt aura apply check
1345         if (spellInfo->Effect[index] == SPELL_EFFECT_APPLY_AURA)
1346         {
1347             if (spellInfo->EffectApplyAuraName[index] == SPELL_AURA_MOD_TAUNT)
1348                 return true;
1349         }
1350         // Spell effect taunt check
1351         else if (spellInfo->Effect[index] == SPELL_EFFECT_ATTACK_ME)
1352             return true;
1353     }
1354
1355     return Unit::IsImmunedToSpellEffect(spellInfo, index);
1356 }
1357
1358 SpellEntry const *Creature::reachWithSpellAttack(Unit *pVictim)
1359 {
1360     if(!pVictim)
1361         return NULL;
1362
1363     for(uint32 i = 0; i < CREATURE_MAX_SPELLS; ++i)
1364     {
1365         if(!m_spells[i])
1366             continue;
1367         SpellEntry const *spellInfo = sSpellStore.LookupEntry(m_spells[i] );
1368         if(!spellInfo)
1369         {
1370             sLog.outError("WORLD: unknown spell id %i", m_spells[i]);
1371             continue;
1372         }
1373
1374         bool bcontinue = true;
1375         for(uint32 j = 0; j < 3; ++j)
1376         {
1377             if( (spellInfo->Effect[j] == SPELL_EFFECT_SCHOOL_DAMAGE )       ||
1378                 (spellInfo->Effect[j] == SPELL_EFFECT_INSTAKILL)            ||
1379                 (spellInfo->Effect[j] == SPELL_EFFECT_ENVIRONMENTAL_DAMAGE) ||
1380                 (spellInfo->Effect[j] == SPELL_EFFECT_HEALTH_LEECH )
1381                 )
1382             {
1383                 bcontinue = false;
1384                 break;
1385             }
1386         }
1387         if(bcontinue) continue;
1388
1389         if(spellInfo->manaCost > GetPower(POWER_MANA))
1390             continue;
1391         SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(spellInfo->rangeIndex);
1392         float range = GetSpellMaxRange(srange);
1393         float minrange = GetSpellMinRange(srange);
1394
1395         float dist = GetCombatDistance(pVictim);
1396
1397         //if(!isInFront( pVictim, range ) && spellInfo->AttributesEx )
1398         //    continue;
1399         if( dist > range || dist < minrange )
1400             continue;
1401         if(spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED))
1402             continue;
1403         if(spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED))
1404             continue;
1405         return spellInfo;
1406     }
1407     return NULL;
1408 }
1409
1410 SpellEntry const *Creature::reachWithSpellCure(Unit *pVictim)
1411 {
1412     if(!pVictim)
1413         return NULL;
1414
1415     for(uint32 i = 0; i < CREATURE_MAX_SPELLS; ++i)
1416     {
1417         if(!m_spells[i])
1418             continue;
1419         SpellEntry const *spellInfo = sSpellStore.LookupEntry(m_spells[i] );
1420         if(!spellInfo)
1421         {
1422             sLog.outError("WORLD: unknown spell id %i", m_spells[i]);
1423             continue;
1424         }
1425
1426         bool bcontinue = true;
1427         for(uint32 j = 0; j < 3; ++j)
1428         {
1429             if( (spellInfo->Effect[j] == SPELL_EFFECT_HEAL ) )
1430             {
1431                 bcontinue = false;
1432                 break;
1433             }
1434         }
1435         if(bcontinue)
1436             continue;
1437
1438         if(spellInfo->manaCost > GetPower(POWER_MANA))
1439             continue;
1440         SpellRangeEntry const* srange = sSpellRangeStore.LookupEntry(spellInfo->rangeIndex);
1441         float range = GetSpellMaxRange(srange);
1442         float minrange = GetSpellMinRange(srange);
1443
1444         float dist = GetCombatDistance(pVictim);
1445
1446         //if(!isInFront( pVictim, range ) && spellInfo->AttributesEx )
1447         //    continue;
1448         if( dist > range || dist < minrange )
1449             continue;
1450         if(spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED))
1451             continue;
1452         if(spellInfo->PreventionType == SPELL_PREVENTION_TYPE_PACIFY && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED))
1453             continue;
1454         return spellInfo;
1455     }
1456     return NULL;
1457 }
1458
1459 bool Creature::IsVisibleInGridForPlayer(Player* pl) const
1460 {
1461     // gamemaster in GM mode see all, including ghosts
1462     if(pl->isGameMaster())
1463         return true;
1464
1465     if (GetCreatureInfo()->flags_extra & CREATURE_FLAG_EXTRA_INVISIBLE)
1466         return false;
1467
1468     // Live player (or with not release body see live creatures or death creatures with corpse disappearing time > 0
1469     if(pl->isAlive() || pl->GetDeathTimer() > 0)
1470     {
1471         return (isAlive() || m_deathTimer > 0 || (m_isDeadByDefault && m_deathState == CORPSE));
1472     }
1473
1474     // Dead player see live creatures near own corpse
1475     if(isAlive())
1476     {
1477         Corpse *corpse = pl->GetCorpse();
1478         if(corpse)
1479         {
1480             // 20 - aggro distance for same level, 25 - max additional distance if player level less that creature level
1481             if(corpse->IsWithinDistInMap(this,(20+25)*sWorld.getRate(RATE_CREATURE_AGGRO)))
1482                 return true;
1483         }
1484     }
1485
1486     // Dead player can see ghosts
1487     if (GetCreatureInfo()->type_flags & CREATURE_TYPEFLAGS_GHOST_VISIBLE)
1488         return true;
1489
1490     // and not see any other
1491     return false;
1492 }
1493
1494 void Creature::SendAIReaction(AiReaction reactionType)
1495 {
1496     WorldPacket data(SMSG_AI_REACTION, 12);
1497
1498     data << uint64(GetGUID());
1499     data << uint32(reactionType);
1500
1501     ((WorldObject*)this)->SendMessageToSet(&data, true);
1502
1503     sLog.outDebug("WORLD: Sent SMSG_AI_REACTION, type %u.", reactionType);
1504 }
1505
1506 void Creature::CallAssistance()
1507 {
1508     if( !m_AlreadyCallAssistance && getVictim() && !isPet() && !isCharmed())
1509     {
1510         SetNoCallAssistance(true);
1511
1512         float radius = sWorld.getConfig(CONFIG_CREATURE_FAMILY_ASSISTANCE_RADIUS);
1513         if(radius > 0)
1514         {
1515             std::list<Creature*> assistList;
1516
1517             {
1518                 CellPair p(MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY()));
1519                 Cell cell(p);
1520                 cell.data.Part.reserved = ALL_DISTRICT;
1521                 cell.SetNoCreate();
1522
1523                 MaNGOS::AnyAssistCreatureInRangeCheck u_check(this, getVictim(), radius);
1524                 MaNGOS::CreatureListSearcher<MaNGOS::AnyAssistCreatureInRangeCheck> searcher(this, assistList, u_check);
1525
1526                 TypeContainerVisitor<MaNGOS::CreatureListSearcher<MaNGOS::AnyAssistCreatureInRangeCheck>, GridTypeMapContainer >  grid_creature_searcher(searcher);
1527
1528                 cell.Visit(p, grid_creature_searcher, *GetMap(), *this, radius);
1529             }
1530
1531             if (!assistList.empty())
1532             {
1533                 AssistDelayEvent *e = new AssistDelayEvent(getVictim()->GetGUID(), *this);
1534                 while (!assistList.empty())
1535                 {
1536                     // Pushing guids because in delay can happen some creature gets despawned => invalid pointer
1537                     e->AddAssistant((*assistList.begin())->GetGUID());
1538                     assistList.pop_front();
1539                 }
1540                 m_Events.AddEvent(e, m_Events.CalculateTime(sWorld.getConfig(CONFIG_CREATURE_FAMILY_ASSISTANCE_DELAY)));
1541             }
1542         }
1543     }
1544 }
1545
1546 void Creature::CallForHelp(float fRadius)
1547 {
1548     if (fRadius <= 0.0f || !getVictim() || isPet() || isCharmed())
1549         return;
1550
1551     CellPair p(MaNGOS::ComputeCellPair(GetPositionX(), GetPositionY()));
1552     Cell cell(p);
1553     cell.data.Part.reserved = ALL_DISTRICT;
1554     cell.SetNoCreate();
1555
1556     MaNGOS::CallOfHelpCreatureInRangeDo u_do(this, getVictim(), fRadius);
1557     MaNGOS::CreatureWorker<MaNGOS::CallOfHelpCreatureInRangeDo> worker(this, u_do);
1558
1559     TypeContainerVisitor<MaNGOS::CreatureWorker<MaNGOS::CallOfHelpCreatureInRangeDo>, GridTypeMapContainer >  grid_creature_searcher(worker);
1560
1561     cell.Visit(p, grid_creature_searcher, *GetMap(), *this, fRadius);
1562 }
1563
1564 bool Creature::CanAssistTo(const Unit* u, const Unit* enemy, bool checkfaction /*= true*/) const
1565 {
1566     // we don't need help from zombies :)
1567     if (!isAlive())
1568         return false;
1569
1570     // we don't need help from non-combatant ;)
1571     if (isCivilian())
1572         return false;
1573
1574     // skip fighting creature
1575     if (isInCombat())
1576         return false;
1577
1578     // only free creature
1579     if (GetCharmerOrOwnerGUID())
1580         return false;
1581
1582     // only from same creature faction
1583     if (checkfaction)
1584     {
1585         if (getFaction() != u->getFaction())
1586             return false;
1587     }
1588     else
1589     {
1590         if (!IsFriendlyTo(u))
1591             return false;
1592     }
1593
1594     // skip non hostile to caster enemy creatures
1595     if (!IsHostileTo(enemy))
1596         return false;
1597
1598     return true;
1599 }
1600
1601 void Creature::SaveRespawnTime()
1602 {
1603     if(isPet() || !m_DBTableGuid)
1604         return;
1605
1606     if(m_respawnTime > time(NULL))                          // dead (no corpse)
1607         sObjectMgr.SaveCreatureRespawnTime(m_DBTableGuid, GetInstanceId(), m_respawnTime);
1608     else if(m_deathTimer > 0)                               // dead (corpse)
1609         sObjectMgr.SaveCreatureRespawnTime(m_DBTableGuid, GetInstanceId(), time(NULL) + m_respawnDelay + m_deathTimer / IN_MILISECONDS);
1610 }
1611
1612 bool Creature::IsOutOfThreatArea(Unit* pVictim) const
1613 {
1614     if (!pVictim)
1615         return true;
1616
1617     if (!pVictim->IsInMap(this))
1618         return true;
1619
1620     if (!pVictim->isTargetableForAttack())
1621         return true;
1622
1623     if (!pVictim->isInAccessablePlaceFor(this))
1624         return true;
1625
1626     if (!pVictim->isVisibleForOrDetect(this,this,false))
1627         return true;
1628
1629     if(sMapStore.LookupEntry(GetMapId())->IsDungeon())
1630         return false;
1631
1632     float AttackDist = GetAttackDistance(pVictim);
1633     uint32 ThreatRadius = sWorld.getConfig(CONFIG_THREAT_RADIUS);
1634
1635     //Use AttackDistance in distance check if threat radius is lower. This prevents creature bounce in and out of combat every update tick.
1636     return !pVictim->IsWithinDist3d(CombatStartX, CombatStartY, CombatStartZ,
1637         ThreatRadius > AttackDist ? ThreatRadius : AttackDist);
1638 }
1639
1640 CreatureDataAddon const* Creature::GetCreatureAddon() const
1641 {
1642     if (m_DBTableGuid)
1643     {
1644         if(CreatureDataAddon const* addon = ObjectMgr::GetCreatureAddon(m_DBTableGuid))
1645             return addon;
1646     }
1647
1648     // dependent from difficulty mode entry
1649     return ObjectMgr::GetCreatureTemplateAddon(GetCreatureInfo()->Entry);
1650 }
1651
1652 //creature_addon table
1653 bool Creature::LoadCreaturesAddon(bool reload)
1654 {
1655     CreatureDataAddon const *cainfo = GetCreatureAddon();
1656     if(!cainfo)
1657         return false;
1658
1659     if (cainfo->mount != 0)
1660         Mount(cainfo->mount);
1661
1662     if (cainfo->bytes1 != 0)
1663     {
1664         // 0 StandState
1665         // 1 FreeTalentPoints   Pet only, so always 0 for default creature
1666         // 2 StandFlags
1667         // 3 StandMiscFlags
1668
1669         SetByteValue(UNIT_FIELD_BYTES_1, 0, uint8(cainfo->bytes1 & 0xFF));
1670         //SetByteValue(UNIT_FIELD_BYTES_1, 1, uint8((cainfo->bytes1 >> 8) & 0xFF));
1671         SetByteValue(UNIT_FIELD_BYTES_1, 1, 0);
1672         SetByteValue(UNIT_FIELD_BYTES_1, 2, uint8((cainfo->bytes1 >> 16) & 0xFF));
1673         SetByteValue(UNIT_FIELD_BYTES_1, 3, uint8((cainfo->bytes1 >> 24) & 0xFF));
1674     }
1675
1676     if (cainfo->bytes2 != 0)
1677     {
1678         // 0 SheathState
1679         // 1 UnitPVPStateFlags  Set at Creature::UpdateEntry (SetPvp())
1680         // 2 UnitRename         Pet only, so always 0 for default creature
1681         // 3 ShapeshiftForm     Must be determined/set by shapeshift spell/aura
1682
1683         SetByteValue(UNIT_FIELD_BYTES_2, 0, uint8(cainfo->bytes2 & 0xFF));
1684         //SetByteValue(UNIT_FIELD_BYTES_2, 1, uint8((cainfo->bytes2 >> 8) & 0xFF));
1685         //SetByteValue(UNIT_FIELD_BYTES_2, 2, uint8((cainfo->bytes2 >> 16) & 0xFF));
1686         SetByteValue(UNIT_FIELD_BYTES_2, 2, 0);
1687         //SetByteValue(UNIT_FIELD_BYTES_2, 3, uint8((cainfo->bytes2 >> 24) & 0xFF));
1688         SetByteValue(UNIT_FIELD_BYTES_2, 3, 0);
1689     }
1690
1691     if (cainfo->emote != 0)
1692         SetUInt32Value(UNIT_NPC_EMOTESTATE, cainfo->emote);
1693
1694     if (cainfo->splineFlags != 0)
1695         SetSplineFlags(SplineFlags(cainfo->splineFlags));
1696
1697     if(cainfo->auras)
1698     {
1699         for (CreatureDataAddonAura const* cAura = cainfo->auras; cAura->spell_id; ++cAura)
1700         {
1701             SpellEntry const *AdditionalSpellInfo = sSpellStore.LookupEntry(cAura->spell_id);
1702             if (!AdditionalSpellInfo)
1703             {
1704                 sLog.outErrorDb("Creature (GUIDLow: %u Entry: %u ) has wrong spell %u defined in `auras` field.",GetGUIDLow(),GetEntry(),cAura->spell_id);
1705                 continue;
1706             }
1707
1708             // skip already applied aura
1709             if(HasAura(cAura->spell_id,cAura->effect_idx))
1710             {
1711                 if(!reload)
1712                     sLog.outErrorDb("Creature (GUIDLow: %u Entry: %u ) has duplicate aura (spell %u effect %u) in `auras` field.",GetGUIDLow(),GetEntry(),cAura->spell_id,cAura->effect_idx);
1713
1714                 continue;
1715             }
1716
1717             Aura* AdditionalAura = CreateAura(AdditionalSpellInfo, cAura->effect_idx, NULL, this, this, 0);
1718             AddAura(AdditionalAura);
1719             sLog.outDebug("Spell: %u with Aura %u added to creature (GUIDLow: %u Entry: %u )", cAura->spell_id, AdditionalSpellInfo->EffectApplyAuraName[0],GetGUIDLow(),GetEntry());
1720         }
1721     }
1722     return true;
1723 }
1724
1725 /// Send a message to LocalDefense channel for players opposition team in the zone
1726 void Creature::SendZoneUnderAttackMessage(Player* attacker)
1727 {
1728     uint32 enemy_team = attacker->GetTeam();
1729
1730     WorldPacket data(SMSG_ZONE_UNDER_ATTACK, 4);
1731     data << uint32(GetZoneId());
1732     sWorld.SendGlobalMessage(&data, NULL, (enemy_team == ALLIANCE ? HORDE : ALLIANCE));
1733 }
1734
1735 void Creature::SetInCombatWithZone()
1736 {
1737     if (!CanHaveThreatList())
1738     {
1739         sLog.outError("Creature entry %u call SetInCombatWithZone but creature cannot have threat list.", GetEntry());
1740         return;
1741     }
1742
1743     Map* pMap = GetMap();
1744
1745     if (!pMap->IsDungeon())
1746     {
1747         sLog.outError("Creature entry %u call SetInCombatWithZone for map (id: %u) that isn't an instance.", GetEntry(), pMap->GetId());
1748         return;
1749     }
1750
1751     Map::PlayerList const &PlList = pMap->GetPlayers();
1752
1753     if (PlList.isEmpty())
1754         return;
1755
1756     for(Map::PlayerList::const_iterator i = PlList.begin(); i != PlList.end(); ++i)
1757     {
1758         if (Player* pPlayer = i->getSource())
1759         {
1760             if (pPlayer->isGameMaster())
1761                 continue;
1762
1763             if (pPlayer->isAlive())
1764             {
1765                 pPlayer->SetInCombatWith(this);
1766                 AddThreat(pPlayer);
1767             }
1768         }
1769     }
1770 }
1771
1772 void Creature::_AddCreatureSpellCooldown(uint32 spell_id, time_t end_time)
1773 {
1774     m_CreatureSpellCooldowns[spell_id] = end_time;
1775 }
1776
1777 void Creature::_AddCreatureCategoryCooldown(uint32 category, time_t apply_time)
1778 {
1779     m_CreatureCategoryCooldowns[category] = apply_time;
1780 }
1781
1782 void Creature::AddCreatureSpellCooldown(uint32 spellid)
1783 {
1784     SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellid);
1785     if(!spellInfo)
1786         return;
1787
1788     uint32 cooldown = GetSpellRecoveryTime(spellInfo);
1789     if(cooldown)
1790         _AddCreatureSpellCooldown(spellid, time(NULL) + cooldown/IN_MILISECONDS);
1791
1792     if(spellInfo->Category)
1793         _AddCreatureCategoryCooldown(spellInfo->Category, time(NULL));
1794
1795     m_GlobalCooldown = spellInfo->StartRecoveryTime;
1796 }
1797
1798 bool Creature::HasCategoryCooldown(uint32 spell_id) const
1799 {
1800     SpellEntry const *spellInfo = sSpellStore.LookupEntry(spell_id);
1801     if(!spellInfo)
1802         return false;
1803
1804     // check global cooldown if spell affected by it
1805     if (spellInfo->StartRecoveryCategory > 0 && m_GlobalCooldown > 0)
1806         return true;
1807
1808     CreatureSpellCooldowns::const_iterator itr = m_CreatureCategoryCooldowns.find(spellInfo->Category);
1809     return (itr != m_CreatureCategoryCooldowns.end() && time_t(itr->second + (spellInfo->CategoryRecoveryTime / IN_MILISECONDS)) > time(NULL));
1810 }
1811
1812 bool Creature::HasSpellCooldown(uint32 spell_id) const
1813 {
1814     CreatureSpellCooldowns::const_iterator itr = m_CreatureSpellCooldowns.find(spell_id);
1815     return (itr != m_CreatureSpellCooldowns.end() && itr->second > time(NULL)) || HasCategoryCooldown(spell_id);
1816 }
1817
1818 bool Creature::IsInEvadeMode() const
1819 {
1820     return !i_motionMaster.empty() && i_motionMaster.GetCurrentMovementGeneratorType() == HOME_MOTION_TYPE;
1821 }
1822
1823 bool Creature::HasSpell(uint32 spellID) const
1824 {
1825     uint8 i;
1826     for(i = 0; i < CREATURE_MAX_SPELLS; ++i)
1827         if(spellID == m_spells[i])
1828             break;
1829     return i < CREATURE_MAX_SPELLS;                         // break before end of iteration of known spells
1830 }
1831
1832 time_t Creature::GetRespawnTimeEx() const
1833 {
1834     time_t now = time(NULL);
1835     if(m_respawnTime > now)                                 // dead (no corpse)
1836         return m_respawnTime;
1837     else if(m_deathTimer > 0)                               // dead (corpse)
1838         return now + m_respawnDelay + m_deathTimer / IN_MILISECONDS;
1839     else
1840         return now;
1841 }
1842
1843 void Creature::GetRespawnCoord( float &x, float &y, float &z, float* ori, float* dist ) const
1844 {
1845     if (m_DBTableGuid)
1846     {
1847         if (CreatureData const* data = sObjectMgr.GetCreatureData(GetDBTableGUIDLow()))
1848         {
1849             x = data->posX;
1850             y = data->posY;
1851             z = data->posZ;
1852             if (ori)
1853                 *ori = data->orientation;
1854             if (dist)
1855                 *dist = data->spawndist;
1856
1857             return;
1858         }
1859     }
1860
1861     float orient;
1862
1863     GetSummonPoint(x, y, z, orient);
1864
1865     if (ori)
1866         *ori = orient;
1867     if (dist)
1868         *dist = GetRespawnRadius();
1869 }
1870
1871 void Creature::AllLootRemovedFromCorpse()
1872 {
1873     if (!HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE))
1874     {
1875         uint32 nDeathTimer;
1876
1877         CreatureInfo const *cinfo = GetCreatureInfo();
1878
1879         // corpse was not skinnable -> apply corpse looted timer
1880         if (!cinfo || !cinfo->SkinLootId)
1881             nDeathTimer = (uint32)((m_corpseDelay * IN_MILISECONDS) * sWorld.getRate(RATE_CORPSE_DECAY_LOOTED));
1882         // corpse skinnable, but without skinning flag, and then skinned, corpse will despawn next update
1883         else
1884             nDeathTimer = 0;
1885
1886         // update death timer only if looted timer is shorter
1887         if (m_deathTimer > nDeathTimer)
1888             m_deathTimer = nDeathTimer;
1889     }
1890 }
1891
1892 uint32 Creature::getLevelForTarget( Unit const* target ) const
1893 {
1894     if(!isWorldBoss())
1895         return Unit::getLevelForTarget(target);
1896
1897     uint32 level = target->getLevel()+sWorld.getConfig(CONFIG_WORLD_BOSS_LEVEL_DIFF);
1898     if(level < 1)
1899         return 1;
1900     if(level > 255)
1901         return 255;
1902     return level;
1903 }
1904
1905 std::string Creature::GetAIName() const
1906 {
1907     return ObjectMgr::GetCreatureTemplate(GetEntry())->AIName;
1908 }
1909
1910 std::string Creature::GetScriptName() const
1911 {
1912     return sObjectMgr.GetScriptName(GetScriptId());
1913 }
1914
1915 uint32 Creature::GetScriptId() const
1916 {
1917     return ObjectMgr::GetCreatureTemplate(GetEntry())->ScriptID;
1918 }
1919
1920 VendorItemData const* Creature::GetVendorItems() const
1921 {
1922     return sObjectMgr.GetNpcVendorItemList(GetEntry());
1923 }
1924
1925 uint32 Creature::GetVendorItemCurrentCount(VendorItem const* vItem)
1926 {
1927     if(!vItem->maxcount)
1928         return vItem->maxcount;
1929
1930     VendorItemCounts::iterator itr = m_vendorItemCounts.begin();
1931     for(; itr != m_vendorItemCounts.end(); ++itr)
1932         if(itr->itemId==vItem->item)
1933             break;
1934
1935     if(itr == m_vendorItemCounts.end())
1936         return vItem->maxcount;
1937
1938     VendorItemCount* vCount = &*itr;
1939
1940     time_t ptime = time(NULL);
1941
1942     if( vCount->lastIncrementTime + vItem->incrtime <= ptime )
1943     {
1944         ItemPrototype const* pProto = ObjectMgr::GetItemPrototype(vItem->item);
1945
1946         uint32 diff = uint32((ptime - vCount->lastIncrementTime)/vItem->incrtime);
1947         if((vCount->count + diff * pProto->BuyCount) >= vItem->maxcount )
1948         {
1949             m_vendorItemCounts.erase(itr);
1950             return vItem->maxcount;
1951         }
1952
1953         vCount->count += diff * pProto->BuyCount;
1954         vCount->lastIncrementTime = ptime;
1955     }
1956
1957     return vCount->count;
1958 }
1959
1960 uint32 Creature::UpdateVendorItemCurrentCount(VendorItem const* vItem, uint32 used_count)
1961 {
1962     if(!vItem->maxcount)
1963         return 0;
1964
1965     VendorItemCounts::iterator itr = m_vendorItemCounts.begin();
1966     for(; itr != m_vendorItemCounts.end(); ++itr)
1967         if(itr->itemId==vItem->item)
1968             break;
1969
1970     if(itr == m_vendorItemCounts.end())
1971     {
1972         uint32 new_count = vItem->maxcount > used_count ? vItem->maxcount-used_count : 0;
1973         m_vendorItemCounts.push_back(VendorItemCount(vItem->item,new_count));
1974         return new_count;
1975     }
1976
1977     VendorItemCount* vCount = &*itr;
1978
1979     time_t ptime = time(NULL);
1980
1981     if( vCount->lastIncrementTime + vItem->incrtime <= ptime )
1982     {
1983         ItemPrototype const* pProto = ObjectMgr::GetItemPrototype(vItem->item);
1984
1985         uint32 diff = uint32((ptime - vCount->lastIncrementTime)/vItem->incrtime);
1986         if((vCount->count + diff * pProto->BuyCount) < vItem->maxcount )
1987             vCount->count += diff * pProto->BuyCount;
1988         else
1989             vCount->count = vItem->maxcount;
1990     }
1991
1992     vCount->count = vCount->count > used_count ? vCount->count-used_count : 0;
1993     vCount->lastIncrementTime = ptime;
1994     return vCount->count;
1995 }
1996
1997 TrainerSpellData const* Creature::GetTrainerSpells() const
1998 {
1999     return sObjectMgr.GetNpcTrainerSpells(GetEntry());
2000 }
2001
2002 // overwrite WorldObject function for proper name localization
2003 const char* Creature::GetNameForLocaleIdx(int32 loc_idx) const
2004 {
2005     if (loc_idx >= 0)
2006     {
2007         CreatureLocale const *cl = sObjectMgr.GetCreatureLocale(GetEntry());
2008         if (cl)
2009         {
2010             if (cl->Name.size() > (size_t)loc_idx && !cl->Name[loc_idx].empty())
2011                 return cl->Name[loc_idx].c_str();
2012         }
2013     }
2014
2015     return GetName();
2016 }
2017
2018 void Creature::SetActiveObjectState( bool on )
2019 {
2020     if(m_isActiveObject==on)
2021         return;
2022
2023     bool world = IsInWorld();
2024
2025     Map* map;
2026     if(world)
2027     {
2028         map = GetMap();
2029         map->Remove(this,false);
2030     }
2031
2032     m_isActiveObject = on;
2033
2034     if(world)
2035         map->Add(this);
2036 }
2037
2038 void Creature::SendMonsterMoveWithSpeedToCurrentDestination(Player* player)
2039 {
2040     float x, y, z;
2041     if(GetMotionMaster()->GetDestination(x, y, z))
2042         SendMonsterMoveWithSpeed(x, y, z, 0, player);
2043 }
2044
2045 void Creature::SendMonsterMoveWithSpeed(float x, float y, float z, uint32 transitTime, Player* player)
2046 {
2047     if (!transitTime)
2048     {
2049         if(GetTypeId()==TYPEID_PLAYER)
2050         {
2051             Traveller<Player> traveller(*(Player*)this);
2052             transitTime = traveller.GetTotalTrevelTimeTo(x, y, z);
2053         }
2054         else
2055         {
2056             Traveller<Creature> traveller(*(Creature*)this);
2057             transitTime = traveller.GetTotalTrevelTimeTo(x, y, z);
2058         }
2059     }
2060     //float orientation = (float)atan2((double)dy, (double)dx);
2061     SendMonsterMove(x, y, z, 0, GetSplineFlags(), transitTime, player);
2062 }
2063
2064 void Creature::SendAreaSpiritHealerQueryOpcode(Player *pl)
2065 {
2066     uint32 next_resurrect = 0;
2067     if (Spell* pcurSpell = GetCurrentSpell(CURRENT_CHANNELED_SPELL))
2068         next_resurrect = pcurSpell->GetCastedTime();
2069     WorldPacket data(SMSG_AREA_SPIRIT_HEALER_TIME, 8 + 4);
2070     data << GetGUID() << next_resurrect;
2071     pl->SendDirectMessage(&data);
2072 }