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