?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[1852] Applied MaNGOS coding style (see [source:trunk/bcpp.cfg bcpp.cfg]).
[mangos-git.git] / src / game / Unit.cpp
blobec260b3d8b96f245a5a968da2c8bfaf4eb2ceea0
1 /*
2 * Copyright (C) 2005,2006 MaNGOS <http://www.mangosproject.org/>
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 "Log.h"
21 #include "Opcodes.h"
22 #include "WorldPacket.h"
23 #include "WorldSession.h"
24 #include "World.h"
25 #include "ObjectMgr.h"
26 #include "Unit.h"
27 #include "QuestDef.h"
28 #include "Player.h"
29 #include "Creature.h"
30 #include "Spell.h"
31 #include "Stats.h"
32 #include "Group.h"
33 #include "SpellAuras.h"
34 #include "MapManager.h"
35 #include "ObjectAccessor.h"
36 #include "CreatureAI.h"
37 #include "Formulas.h"
38 #include "Pet.h"
39 #include "Util.h"
40
41 #include <math.h>
42
43 Unit::Unit() : Object()
44 {
45 m_objectType |= TYPE_UNIT;
46 m_objectTypeId = TYPEID_UNIT;
47
48 m_attackTimer = 0;
49
50 m_state = 0;
51 m_form = 0;
52 m_deathState = ALIVE;
53 m_currentSpell = NULL;
54 m_currentMeleeSpell = NULL;
55 m_addDmgOnce = 0;
56 m_TotemSlot1 = m_TotemSlot2 = m_TotemSlot3 = m_TotemSlot4 = 0;
57 //m_Aura = NULL;
58 //m_AurasCheck = 2000;
59 //m_removeAuraTimer = 4;
60 //tmpAura = NULL;
61 m_silenced = false;
62 waterbreath = false;
63
64 m_immuneToMechanic = 0;
65 m_immuneToEffect = 0;
66 m_immuneToState = 0;
67 m_immuneToSchool = 0;
68 m_immuneToDmg = 0;
69 m_immuneToDispel = 0;
70 m_detectStealth = 0;
71 m_stealthvalue = 0;
72 m_transform = 0;
73 m_ShapeShiftForm = 0;
74
75 for (int i = 0; i < TOTAL_AURAS; i++)
76 m_AuraModifiers[i] = -1;
77
78 m_attacking = NULL;
79 m_modDamagePCT = 0;
80 m_RegenPCT = 0;
81 m_modHitChance = 0;
82 m_modSpellHitChance = 0;
83 m_baseSpellCritChance = 5;
84 m_spellCritSchool.clear();
85 m_reflectSpellSchool.clear();
86 m_scAuras.clear();
87 m_damageDoneCreature.clear();
88 }
89
90 Unit::~Unit()
91 {
92 }
93
94 void Unit::Update( uint32 p_time )
95 {
96 /*if(p_time > m_AurasCheck)
97 {
98 m_AurasCheck = 2000;
99 _UpdateAura();
100 }else
101 m_AurasCheck -= p_time;*/
102
103 _UpdateSpells( p_time );
104 _UpdateHostil( p_time );
105
106 if(m_attackTimer > 0)
107 {
108 if(p_time >= m_attackTimer)
109 m_attackTimer = 0;
110 else
111 m_attackTimer -= p_time;
112 }
113 }
114
115 void Unit::SendMoveToPacket(float x, float y, float z, bool run)
116 {
117 float dx = x - GetPositionX();
118 float dy = y - GetPositionY();
119 float dz = z - GetPositionZ();
120 float dist = ((dx*dx) + (dy*dy) + (dz*dz));
121 if(dist<0)
122 dist = 0;
123 else
124 dist = ::sqrt(dist);
125 double speed = GetSpeed(run ? MOVE_RUN : MOVE_WALK);
126 if(speed<=0)
127 speed = 2.5f;
128 speed *= 0.001f;
129 uint32 time = static_cast<uint32>(dist / speed + 0.5);
130 //float orientation = (float)atan2((double)dy, (double)dx);
131 SendMonsterMove(x,y,z,false,run,time);
132
133 }
134
135 void Unit::SendMonsterMove(float NewPosX, float NewPosY, float NewPosZ, bool Walkback, bool Run, uint32 Time)
136 {
137 WorldPacket data;
138 data.Initialize( SMSG_MONSTER_MOVE );
139 data << uint8(0xFF) << GetGUID();
140 // Point A, starting location
141 data << GetPositionX() << GetPositionY() << GetPositionZ();
142 // little trick related to orientation
143 data << (uint32)((*((uint32*)&GetOrientation())) & 0x30000000);
144 data << uint8(Walkback); // walkback when walking from A to B
145 data << uint32(Run ? 0x00000100 : 0x00000000); // flags
146 /* Flags:
147 512: Floating, moving without walking/running
148 */
149 data << Time; // Time in between points
150 data << uint32(1); // 1 single waypoint
151 data << NewPosX << NewPosY << NewPosZ; // the single waypoint Point B
152 WPAssert( data.size() == 50 );
153 SendMessageToSet( &data, true );
154 }
155
156 void Unit::setAttackTimer(uint32 time, bool rangeattack)
157 {
158 if(time)
159 m_attackTimer = time;
160 else
161 {
162 if(rangeattack)
163 {
164 if (GetTypeId() == TYPEID_PLAYER)
165 {
166 m_attackTimer = GetUInt32Value(UNIT_FIELD_RANGEDATTACKTIME);
167 }
168 }
169 else
170 {
171 if (GetTypeId() == TYPEID_PLAYER)
172 {
173 m_attackTimer = GetUInt32Value(UNIT_FIELD_BASEATTACKTIME);
174 }
175 }
176 m_attackTimer = (m_attackTimer >= 200) ? m_attackTimer : 2000;
177 }
178 }
179
180 bool Unit::canReachWithAttack(Unit *pVictim) const
181 {
182 assert(pVictim);
183 float reach = GetFloatValue(UNIT_FIELD_COMBATREACH);
184 if( reach <= 0.0f )
185 reach = 1.0f;
186 float distance = GetDistanceSq(pVictim);
187
188 return ( distance <= reach * reach );
189 }
190
191 void Unit::RemoveSpellsCausingAura(uint32 auraType)
192 {
193 AuraMap::iterator iter, next;
194 for (iter = m_Auras.begin(); iter != m_Auras.end(); iter = next)
195 {
196 next = iter;
197 ++next;
198
199 if ((*iter).second)
200 {
201 if (((*iter).second)->GetModifier()->m_auraname == auraType)
202 {
203 uint32 spellId = ((*iter).second)->GetId();
204 RemoveAurasDueToSpell(spellId);
205 if (!m_Auras.empty())
206 next = m_Auras.begin();
207 else
208 return;
209 }
210 }
211 }
212 }
213
214 bool Unit::HasAuraType(uint32 auraType) const
215 {
216 return (m_AuraModifiers[auraType] != -1);
217 }
218
219 void Unit::DealDamage(Unit *pVictim, uint32 damage, uint32 procFlag, bool durabilityLoss)
220 {
221 if (!pVictim->isAlive()) return;
222
223 if(isStealth())
224 RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH);
225
226 if(pVictim->GetTypeId() != TYPEID_PLAYER)
227 {
228 //pVictim->SetInFront(this);
229 // no loot,xp,health if type 8 /critters/
230 if ( ((Creature*)pVictim)->GetCreatureInfo()->type == 8)
231 {
232 pVictim->setDeathState(JUST_DIED);
233 pVictim->SetHealth(0);
234 pVictim->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_ATTACKING);
235 return;
236 }
237 ((Creature*)pVictim)->AI().AttackStart(this);
238 }
239
240 DEBUG_LOG("DealDamageStart");
241
242 uint32 health = pVictim->GetHealth();
243 sLog.outDetail("deal dmg:%d to heals:%d ",damage,health);
244 if (health <= damage)
245 {
246 DEBUG_LOG("DealDamage: victim just died");
247
248 DEBUG_LOG("SET JUST_DIED");
249 pVictim->setDeathState(JUST_DIED);
250
251 uint64 attackerGuid, victimGuid;
252 attackerGuid = GetGUID();
253 victimGuid = pVictim->GetGUID();
254
255 DEBUG_LOG("DealDamageAttackStop");
256 pVictim->SendAttackStop(attackerGuid);
257
258 DEBUG_LOG("DealDamageHealth1");
259 pVictim->SetHealth(0);
260 pVictim->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_ATTACKING);
261
262 // 10% durability loss on death
263 // clean hostilList
264 if (pVictim->GetTypeId() == TYPEID_PLAYER)
265 {
266 DEBUG_LOG("We are dead, loosing 10 percents durability");
267 if (durabilityLoss)
268 {
269 ((Player*)pVictim)->DeathDurabilityLoss(0.10);
270 }
271 HostilList::iterator i;
272 for(i = m_hostilList.begin(); i != m_hostilList.end(); i++)
273 {
274 if(i->UnitGuid==victimGuid)
275 {
276 m_hostilList.erase(i);
277 break;
278 }
279 }
280
281 Creature *pet = pVictim->GetPet();
282 if(pet && pet->isPet())
283 {
284 pet->setDeathState(JUST_DIED);
285 pet->SendAttackStop(attackerGuid);
286 pet->SetHealth(0);
287 pet->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_ATTACKING);
288 pet->addUnitState(UNIT_STAT_DIED);
289 for(i = m_hostilList.begin(); i != m_hostilList.end(); ++i)
290 {
291 if(i->UnitGuid==pet->GetGUID())
292 {
293 m_hostilList.erase(i);
294 break;
295 }
296 }
297 }
298 }
299 else
300 {
301 pVictim->m_hostilList.clear();
302 DEBUG_LOG("DealDamageNotPlayer");
303 pVictim->SetUInt32Value(UNIT_DYNAMIC_FLAGS, 1);
304 }
305
306 //judge if GainXP, Pet kill like player kill,kill pet not like PvP
307 bool playerkill = false;
308 bool PvP = false;
309 Player *player;
310
311 if(GetTypeId() == TYPEID_PLAYER)
312 {
313 playerkill = true;
314 player = (Player*)this;
315 if(pVictim->GetTypeId() == TYPEID_PLAYER)
316 PvP = true;
317 }
318 else if(((Creature*)this)->isPet())
319 {
320 Unit* owner = ((Pet*)this)->GetOwner();
321 if(!owner)
322 playerkill = false;
323 else if(owner->GetTypeId() == TYPEID_PLAYER)
324 {
325 player = (Player*)owner;
326 playerkill = true;
327 }
328 }
329
330 if(playerkill)
331 {
332 player->CalculateHonor(pVictim);
333 player->CalculateReputation(pVictim);
334
335 if(!PvP)
336 {
337 DEBUG_LOG("DealDamageIsPvE");
338 uint32 xp = MaNGOS::XP::Gain(player, pVictim);
339 uint32 entry = 0;
340 entry = pVictim->GetUInt32Value(OBJECT_FIELD_ENTRY );
341
342 Group *pGroup = objmgr.GetGroupByLeader(player->GetGroupLeader());
343 if(pGroup)
344 {
345 DEBUG_LOG("Kill Enemy In Group");
346 xp /= pGroup->GetMembersCount();
347 for (uint32 i = 0; i < pGroup->GetMembersCount(); i++)
348 {
349 Player *pGroupGuy = ObjectAccessor::Instance().FindPlayer(pGroup->GetMemberGUID(i));
350 if(!pGroupGuy)
351 continue;
352 if(GetDistanceSq(pGroupGuy) > sWorld.getConfig(CONFIG_GETXP_DISTANCE))
353 continue;
354 if(uint32(abs((int)pGroupGuy->getLevel() - (int)pVictim->getLevel())) > sWorld.getConfig(CONFIG_GETXP_LEVELDIFF))
355 continue;
356 pGroupGuy->GiveXP(xp, pVictim);
357 pGroupGuy->KilledMonster(entry, victimGuid);
358 }
359 }
360 else
361 {
362 DEBUG_LOG("Player kill enemy alone");
363 player->GiveXP(xp, pVictim);
364 player->KilledMonster(entry,victimGuid);
365 }
366 }
367 }
368 else
369 {
370 DEBUG_LOG("Monster kill Monster");
371 SendAttackStop(victimGuid);
372 addUnitState(UNIT_STAT_DIED);
373 }
374 AttackStop();
375 }
376 else
377 {
378 DEBUG_LOG("DealDamageAlive");
379 pVictim->SetHealth(health - damage);
380 Attack(pVictim);
381
382 if(pVictim->getTransForm())
383 {
384 pVictim->RemoveAurasDueToSpell(pVictim->getTransForm());
385 pVictim->setTransForm(0);
386 }
387
388 if (pVictim->GetTypeId() != TYPEID_PLAYER)
389 {
390 ((Creature *)pVictim)->AI().DamageInflict(this, damage);
391 pVictim->AddHostil(GetGUID(), damage);
392 if( GetTypeId() == TYPEID_PLAYER
393 && (getClass() == WARRIOR || m_form == 5 || m_form == 8) )
394 ((Player*)this)->CalcRage(damage,true);
395 }
396 else
397 {
398 if( pVictim->getClass() == WARRIOR )
399 ((Player*)pVictim)->CalcRage(damage,false);
400
401 // random durability for items (HIT)
402 int randdurability = urand(0, 300);
403 if (randdurability == 10)
404 {
405 DEBUG_LOG("HIT: We decrease durability with 5 percent");
406 ((Player*)pVictim)->DeathDurabilityLoss(0.05);
407 }
408 }
409 }
410
411 DEBUG_LOG("DealDamageEnd");
412 }
413
414 void Unit::CastSpell(Unit* Victim, uint32 spellId, bool triggered)
415 {
416
417 SpellEntry *spellInfo = sSpellStore.LookupEntry(spellId );
418
419 if(!spellInfo)
420 {
421 sLog.outError("WORLD: unknown spell id %i\n", spellId);
422 return;
423 }
424
425 Spell *spell = new Spell(this, spellInfo, triggered, 0);
426 WPAssert(spell);
427
428 SpellCastTargets targets;
429 targets.setUnitTarget( Victim );
430 spell->prepare(&targets);
431 m_canMove = false;
432 }
433
434 void Unit::SpellNonMeleeDamageLog(Unit *pVictim, uint32 spellID, uint32 damage)
435 {
436
437 if(!this || !pVictim)
438 return;
439 if(!this->isAlive() || !pVictim->isAlive())
440 return;
441 uint32 absorb=0;
442 uint32 resist=0;
443 int32 critchance = m_baseSpellCritChance;
444 int crit = 0;
445 CreatureInfo *cinfo = NULL;
446 if(pVictim->GetTypeId() != TYPEID_PLAYER)
447 cinfo = ((Creature*)pVictim)->GetCreatureInfo();
448
449 SpellEntry *spellInfo = sSpellStore.LookupEntry(spellID);
450 if(spellInfo)
451 {
452 for(std::list<struct SpellCritSchool*>::iterator i = m_spellCritSchool.begin();i != m_spellCritSchool.end();i++)
453 {
454 if((*i)->school == -1 || (*i)->school == spellInfo->School)
455 {
456 critchance += (*i)->chance;
457 }
458 }
459 critchance += int32(GetStat(STAT_INTELLECT)/100-1);
460 critchance = critchance > 0 ? critchance :0;
461 if(critchance >= urand(0,100))
462 {
463 damage = uint32(damage*1.5);
464 crit = 1;
465 }
466 for(std::list<struct DamageDoneCreature*>::iterator i = m_damageDoneCreature.begin();i != m_damageDoneCreature.end();i++)
467 {
468 if(cinfo && cinfo->type == (*i)->creaturetype)
469 {
470 damage += (*i)->damage;
471 break;
472 }
473 }
474 absorb = CalDamageAbsorb(pVictim,spellInfo->School,damage,&resist);
475 }
476
477 //WorldPacket data;
478 if(m_modSpellHitChance+100 < urand(0,100))
479 {
480 SendAttackStateUpdate(HITINFO_HITSTRANGESOUND1|HITINFO_MISS, pVictim->GetGUID(), 1, spellInfo->School, 0, 0,0,1,0);
481 return;
482 }
483
484 if( (damage-absorb-resist)<= 0 )
485 {
486 SendAttackStateUpdate(HITINFO_HITSTRANGESOUND1|HITINFO_NOACTION, pVictim->GetGUID(), 1, spellInfo->School, damage, absorb,resist,1,0);
487 return;
488 }
489
490 sLog.outDetail("SpellNonMeleeDamageLog: %u %X attacked %u %X for %u dmg inflicted by %u,abs is %u,resist is %u crit is %i.",
491 GetGUIDLow(), GetGUIDHigh(), pVictim->GetGUIDLow(), pVictim->GetGUIDHigh(), damage, spellID, absorb, resist,crit);
492
493 SendSpellNonMeleeDamageLog(pVictim->GetGUID(), spellID, damage, spellInfo->School, absorb, resist, false, 0);
494 DealDamage(pVictim, damage<(absorb+resist)?0:(damage-absorb-resist), 0, true);
495 }
496
497 void Unit::PeriodicAuraLog(Unit *pVictim, SpellEntry *spellProto, Modifier *mod)
498 {
499 uint32 procFlag = 0;
500 if(!this || !pVictim || !isAlive() || !pVictim->isAlive())
501 {
502 return;
503 }
504 uint32 absorb=0;
505 uint32 resist=0;
506 int32 critchance = m_baseSpellCritChance;
507 int crit = 0;
508 uint32 pdamage = mod->m_amount;
509 CreatureInfo *cinfo = NULL;
510 if(pVictim->GetTypeId() != TYPEID_PLAYER)
511 cinfo = ((Creature*)pVictim)->GetCreatureInfo();
512
513 SpellEntry *spellInfo = sSpellStore.LookupEntry(spellProto->Id);
514 if(spellInfo)
515 {
516 for(std::list<struct SpellCritSchool*>::iterator i = m_spellCritSchool.begin();i != m_spellCritSchool.end();i++)
517 {
518 if((*i)->school == -2 || (*i)->school == spellInfo->School)
519 {
520 critchance += (*i)->chance;
521 }
522 }
523 critchance += int32(GetStat(STAT_INTELLECT)/100-1);
524 critchance = critchance > 0 ? critchance :0;
525 if(critchance >= urand(0,100))
526 {
527 pdamage = uint32(pdamage*1.5);
528 crit = 1;
529 }
530 for(std::list<struct DamageDoneCreature*>::iterator i = m_damageDoneCreature.begin();i != m_damageDoneCreature.end();i++)
531 {
532 if(cinfo && cinfo->type == (*i)->creaturetype)
533 {
534 pdamage += (*i)->damage;
535 break;
536 }
537 }
538 absorb = CalDamageAbsorb(pVictim,spellInfo->School,pdamage,&resist);
539 }
540
541 sLog.outDetail("PeriodicAuraLog: %u %X attacked %u %X for %u dmg inflicted by %u abs is %u crit is %u",
542 GetGUIDLow(), GetGUIDHigh(), pVictim->GetGUIDLow(), pVictim->GetGUIDHigh(), pdamage, spellProto->Id,absorb,crit);
543
544 WorldPacket data;
545 data.Initialize(SMSG_PERIODICAURALOG);
546 data << uint8(0xFF) << pVictim->GetGUID();
547 data << uint8(0xFF) << this->GetGUID();
548 data << spellProto->Id;
549 data << uint32(1);
550
551 data << mod->m_auraname;
552 data << (uint32)(mod->m_amount);
553 data << spellProto->School;
554 data << uint32(0);
555 SendMessageToSet(&data,true);
556
557 if(mod->m_auraname == SPELL_AURA_PERIODIC_DAMAGE)
558 {
559 SendSpellNonMeleeDamageLog(pVictim->GetGUID(), spellProto->Id, mod->m_amount, spellProto->School, absorb, resist, false, 0);
560 SendMessageToSet(&data,true);
561
562 DealDamage(pVictim, mod->m_amount <= int32(absorb+resist) ? 0 : (mod->m_amount-absorb-resist), procFlag, true);
563 }
564 else if(mod->m_auraname == SPELL_AURA_PERIODIC_DAMAGE_PERCENT)
565 {
566 int32 pdamage = GetHealth()*(100+mod->m_amount)/100;
567 SendSpellNonMeleeDamageLog(pVictim->GetGUID(), spellProto->Id, pdamage, spellProto->School, absorb, resist, false, 0);
568 SendMessageToSet(&data,true);
569 DealDamage(pVictim, pdamage <= int32(absorb+resist) ? 0 : (pdamage-absorb-resist), procFlag, true);
570 }
571 else if(mod->m_auraname == SPELL_AURA_PERIODIC_HEAL)
572 {
573 if(GetHealth() + mod->m_amount*(100+m_RegenPCT)/100 < GetMaxHealth() )
574 SetHealth(GetHealth() + mod->m_amount*(100+m_RegenPCT)/100);
575 else
576 SetHealth(GetMaxHealth());
577 }
578 else if(mod->m_auraname == SPELL_AURA_PERIODIC_LEECH)
579 {
580 uint32 tmpvalue = 0;
581 for(int x=0;x<3;x++)
582 {
583 if(mod->m_auraname != spellInfo->EffectApplyAuraName[x])
584 continue;
585 if(pVictim->GetHealth() - mod->m_amount > 0)
586 tmpvalue = uint32(mod->m_amount*spellInfo->EffectMultipleValue[x]);
587 else
588 tmpvalue = uint32(pVictim->GetHealth()*spellInfo->EffectMultipleValue[x]);
589
590 DealDamage(pVictim, mod->m_amount <= int32(absorb+resist) ? 0 : (mod->m_amount-absorb-resist), procFlag, false);
591 if (!pVictim->isAlive() && m_currentSpell)
592 if (m_currentSpell->m_spellInfo)
593 if (m_currentSpell->m_spellInfo->Id == spellProto->Id)
594 m_currentSpell->cancel();
595
596 break;
597 }
598 if(GetHealth() + tmpvalue*(100+m_RegenPCT)/100 < GetMaxHealth() )
599 SetHealth(GetHealth() + tmpvalue*(100+m_RegenPCT)/100);
600 else SetHealth(GetMaxHealth());
601 }
602 else if(mod->m_auraname == SPELL_AURA_PERIODIC_MANA_LEECH)
603 {
604 uint32 tmpvalue = 0;
605 for(int x=0;x<3;x++)
606 {
607 if(mod->m_auraname != spellInfo->EffectApplyAuraName[x])
608 continue;
609 if(pVictim->GetPower(POWER_MANA) - mod->m_amount > 0)
610 {
611 pVictim->SetPower(POWER_MANA,pVictim->GetPower(POWER_MANA) - mod->m_amount);
612 tmpvalue = uint32(mod->m_amount*spellInfo->EffectMultipleValue[x]);
613 }
614 else
615 {
616 tmpvalue = uint32(pVictim->GetPower(POWER_MANA)*spellInfo->EffectMultipleValue[x]);
617 pVictim->SetPower(POWER_MANA,0);
618 }
619 break;
620 }
621 if(GetPower(POWER_MANA) + tmpvalue < GetMaxPower(POWER_MANA) )
622 SetPower(POWER_MANA,GetPower(POWER_MANA) + tmpvalue);
623 else SetPower(POWER_MANA,GetMaxPower(POWER_MANA));
624 }
625 else if(mod->m_auraname == SPELL_AURA_PERIODIC_ENERGIZE)
626 {
627 if(mod->m_miscvalue < 0 || mod->m_miscvalue > 4)
628 return;
629 SetPower(Powers(mod->m_miscvalue),GetPower(Powers(mod->m_miscvalue))+mod->m_amount);
630 }
631 }
632
633 void Unit::HandleEmoteCommand(uint32 anim_id)
634 {
635 WorldPacket data;
636
637 data.Initialize( SMSG_EMOTE );
638 data << anim_id << GetGUID();
639 WPAssert(data.size() == 12);
640
641 SendMessageToSet(&data, true);
642 }
643
644 uint32 Unit::CalDamageAbsorb(Unit *pVictim,uint32 School,const uint32 damage,uint32 *resist)
645 {
646 uint32 AbsorbDamage=0;
647 uint32 currAbsorbDamage=0;
648 uint32 currentPower;
649 bool removeAura=false;
650
651 if(!pVictim)
652 return 0;
653 if(!pVictim->isAlive())
654 return 0;
655
656 for(std::list<struct DamageManaShield*>::iterator i = pVictim->m_damageManaShield.begin();i != pVictim->m_damageManaShield.end();i++)
657 {
658 SpellEntry *spellInfo = sSpellStore.LookupEntry( (*i)->m_spellId);
659
660 if(((*i)->m_schoolType & School) || (*i)->m_schoolType == School || (*i)->m_schoolType ==127)
661 {
662 currAbsorbDamage = damage+ (*i)->m_currAbsorb;
663 if(currAbsorbDamage < (*i)->m_totalAbsorb)
664 {
665 AbsorbDamage = damage;
666 (*i)->m_currAbsorb = currAbsorbDamage;
667 }
668 else
669 {
670 AbsorbDamage = (*i)->m_totalAbsorb - (*i)->m_currAbsorb;
671 (*i)->m_currAbsorb = (*i)->m_totalAbsorb;
672 removeAura = true;
673 }
674
675 if((*i)->m_modType == SPELL_AURA_MANA_SHIELD)
676 {
677 float multiple;
678 for(int x=0;x<3;x++)
679 if(spellInfo->EffectApplyAuraName[x] == SPELL_AURA_MANA_SHIELD)
680 {
681 multiple = spellInfo->EffectMultipleValue[x];
682 break;
683 }
684 currentPower = pVictim->GetPower(POWER_MANA);
685 if ( (float)(currentPower) > AbsorbDamage*multiple )
686 {
687 pVictim->SetPower(POWER_MANA, (uint32)(currentPower-AbsorbDamage*multiple) );
688 }
689 else
690 {
691 pVictim->SetPower(POWER_MANA, 0 );
692 }
693 }
694
695 if(removeAura)
696 pVictim->RemoveAurasDueToSpell((*i)->m_spellId);
697 }
698 break;
699 }
700 if(School == 0)
701 {
702 uint32 armor = pVictim->GetArmor();
703 float tmpvalue = armor/(pVictim->getLevel()*85.0 +400.0 +armor);
704 if(tmpvalue < 0)
705 tmpvalue = 0.0;
706 if(tmpvalue > 1.0)
707 tmpvalue = 1.0;
708 AbsorbDamage += uint32(damage * tmpvalue);
709 if(AbsorbDamage > damage)
710 AbsorbDamage = damage;
711 }
712 if( School > 0)
713 {
714 uint32 tmpvalue2 = pVictim->GetResistance(SpellSchools(School));
715 *resist += uint32(damage*tmpvalue2*0.0025*pVictim->getLevel()/getLevel());
716 if(*resist > damage)
717 *resist = damage;
718 }
719
720 // random durability loss for items on absorb (ABSORB)
721 if (pVictim->GetTypeId() == TYPEID_PLAYER)
722 {
723 int randdurability = urand(0, 300);
724 if (randdurability == 10)
725 {
726 DEBUG_LOG("BLOCK: We decrease durability with 5 percent");
727 ((Player*)pVictim)->DeathDurabilityLoss(0.05);
728 }
729 }
730
731 return AbsorbDamage;
732 }
733
734 void Unit::DoAttackDamage(Unit *pVictim, uint32 *damage, uint32 *blocked_amount, uint32 *damageType, uint32 *hitInfo, uint32 *victimState,uint32 *absorbDamage,uint32 *resist)
735 {
736 MeleeHitOutcome outcome = RollMeleeOutcomeAgainst (pVictim);
737 if (outcome == MELEE_HIT_MISS)
738 {
739 *hitInfo |= HITINFO_MISS;
740 return;
741 }
742
743 CreatureInfo *cinfo = NULL;
744 if(pVictim->GetTypeId() != TYPEID_PLAYER)
745 cinfo = ((Creature*)pVictim)->GetCreatureInfo();
746
747 *damage = (CalculateDamage (false) * (m_modDamagePCT+100))/100;
748 for(std::list<struct DamageDoneCreature*>::iterator i = m_damageDoneCreature.begin();i != m_damageDoneCreature.end();i++)
749 {
750 if(cinfo && cinfo->type == (*i)->creaturetype)
751 {
752 *damage += (*i)->damage;
753 break;
754 }
755 }
756
757 if(GetTypeId() == TYPEID_PLAYER && pVictim->GetTypeId() != TYPEID_PLAYER && ((Creature*)pVictim)->GetCreatureInfo()->type != 8 )
758 ((Player*)this)->UpdateMeleeSkillWeapon();
759
760 switch (outcome)
761 {
762 case MELEE_HIT_CRIT:
763 //*hitInfo = 0xEA;
764 *hitInfo = HITINFO_HITSTRANGESOUND1 | HITINFO_HITSTRANGESOUND2 | HITINFO_CRITICALHIT
765 | HITINFO_NORMALSWING2 | 0x8; // 0xEA
766 *damage *= 2;
767
768 pVictim->HandleEmoteCommand(EMOTE_ONESHOT_WOUNDCRITICAL);
769 break;
770
771 case MELEE_HIT_PARRY:
772 *damage = 0;
773 *victimState = 2;
774
775 if(pVictim->GetTypeId() == TYPEID_PLAYER)
776 {
777 ((Player*)pVictim)->UpdateDefense();
778 pVictim->m_attackTimer = 0; // parry sets attack timer to 0
779 }
780
781 pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYUNARMED);
782 break;
783
784 case MELEE_HIT_DODGE:
785 *damage = 0;
786 *victimState = 3;
787
788 if(pVictim->GetTypeId() == TYPEID_PLAYER)
789 ((Player*)pVictim)->UpdateDefense();
790
791 pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYUNARMED);
792 break;
793
794 case MELEE_HIT_BLOCK:
795 *blocked_amount = (pVictim->GetUnitBlockValue() * (pVictim->GetStat(STAT_STRENGTH) / 20));
796
797 if (*blocked_amount < *damage)
798 *damage -= *blocked_amount;
799 else
800 *damage = 0;
801
802 if (pVictim->GetUnitBlockValue())
803 pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYSHIELD);
804 else
805 pVictim->HandleEmoteCommand(EMOTE_ONESHOT_PARRYUNARMED);
806
807 *victimState = 4;
808
809 if(pVictim->GetTypeId() == TYPEID_PLAYER)
810 ((Player*)pVictim)->UpdateDefense();
811 break;
812
813 case MELEE_HIT_GLANCING:
814 {
815 // 30% reduction at 15 skill diff, no reduction at 5 skill diff
816 int32 reducePerc = 100 - (pVictim->GetDefenceSkillValue() - GetWeaponSkillValue() - 5) * 3;
817 if (reducePerc < 70)
818 reducePerc = 70;
819 *damage = *damage * reducePerc / 100;
820 *hitInfo |= HITINFO_GLANCING;
821 break;
822 }
823 case MELEE_HIT_CRUSHING:
824 // 150% normal damage
825 *damage += (*damage / 2);
826 *hitInfo |= HITINFO_CRUSHING;
827 // TODO: victimState, victim animation?
828 break;
829
830 default:
831 break;
832 }
833
834 for(std::list<struct DamageShield>::iterator i = pVictim->m_damageShields.begin();i != pVictim->m_damageShields.end();i++)
835 {
836 pVictim->SpellNonMeleeDamageLog(this,i->m_spellId,i->m_damage);
837 }
838 uint32 absorb= CalDamageAbsorb(pVictim,NORMAL_DAMAGE,*damage,resist);
839
840 if (*damage <= absorb + *resist)
841 {
842 //*hitInfo = 0x00010020;
843 *hitInfo = HITINFO_NOACTION | HITINFO_HITSTRANGESOUND1;
844 *absorbDamage = absorb;
845 *damageType = 0;
846 return;
847 }
848 else
849 {
850 *absorbDamage = absorb;
851 }
852 // proc trigger damage
853 for (AuraMap::iterator i = pVictim->m_Auras.begin(); i != pVictim->m_Auras.end(); ++i)
854 {
855 ProcTriggerDamage *procdamage = (*i).second->GetProcDamage();
856 if(procdamage)
857 {
858 bool nocharges = procdamage->procCharges == 0 ? true : false;
859 if((procdamage->procFlags & 40) && procdamage->procChance > rand_chance()
860 && (procdamage->procCharges > 0 || nocharges))
861 {
862 pVictim->SpellNonMeleeDamageLog(this,(*i).second->GetSpellProto()->Id,procdamage->procDamage);
863 if(!nocharges)
864 procdamage->procCharges -= 1;
865 }
866 else if(procdamage->procFlags == 64 && procdamage->procChance > rand_chance()
867 && (procdamage->procCharges > 0 || nocharges) && *victimState == 4)
868 {
869 pVictim->SpellNonMeleeDamageLog(this,(*i).second->GetSpellProto()->Id,procdamage->procDamage);
870 if(!nocharges)
871 procdamage->procCharges -= 1;
872 }
873 }
874 }
875 for (AuraMap::iterator i = m_Auras.begin(); i != m_Auras.end(); ++i)
876 {
877 ProcTriggerDamage *procdamage = (*i).second->GetProcDamage();
878 if(procdamage)
879 {
880 bool nocharges = procdamage->procCharges == 0 ? true : false;
881 if(procdamage->procFlags == 1 && procdamage->procChance > rand_chance()
882 && (procdamage->procCharges > 0 || nocharges))
883 {
884 SpellNonMeleeDamageLog(pVictim,(*i).second->GetSpellProto()->Id,procdamage->procDamage);
885 if(!nocharges)
886 procdamage->procCharges -= 1;
887 }
888 }
889 }
890 // proc trigger aura, Fix Me about procflag & what case.
891 for (AuraMap::iterator i = pVictim->m_Auras.begin(); i != pVictim->m_Auras.end(); ++i)
892 {
893 if(ProcTriggerSpell* procspell = (*i).second->GetProcSpell())
894 {
895 bool nocharges = procspell->procCharges == 0 ? true : false;
896 if((procspell->procFlags & 40) && procspell->procChance > rand_chance()
897 && (procspell->procCharges > 0 || nocharges))
898 {
899 if(!nocharges)
900 procspell->procCharges -= 1;
901 SpellEntry *spellInfo = sSpellStore.LookupEntry((*i).second->GetProcSpell()->trigger);
902
903 if(!spellInfo)
904 {
905 sLog.outError("WORLD: unknown spell id %i\n", (*i).second->GetProcSpell()->trigger);
906 return;
907 }
908
909 Spell *spell = new Spell(pVictim, spellInfo, true, 0);
910 WPAssert(spell);
911
912 SpellCastTargets targets;
913 targets.setUnitTarget( this );
914 spell->prepare(&targets);
915
916 if((*i).second->GetProcSpell()->trigger == 26545)
917 pVictim->SpellNonMeleeDamageLog(this,(*i).second->GetSpellProto()->Id,(*i).second->CalculateDamage());
918 }
919 }
920 }
921 for (AuraMap::iterator i = m_Auras.begin(); i != m_Auras.end(); ++i)
922 {
923 if(ProcTriggerSpell* procspell = (*i).second->GetProcSpell())
924 {
925 bool nocharges = procspell->procCharges == 0 ? true : false;
926 if((procspell->procFlags & 20) && procspell->procChance > rand_chance()
927 && (procspell->procCharges > 0 || nocharges))
928 {
929 if(!nocharges)
930 procspell->procCharges -= 1;
931 SpellEntry *spellInfo = sSpellStore.LookupEntry((*i).second->GetProcSpell()->trigger );
932
933 if(!spellInfo)
934 {
935 sLog.outError("WORLD: unknown spell id %i\n", (*i).second->GetProcSpell()->trigger);
936 return;
937 }
938
939 Spell *spell = new Spell(pVictim, spellInfo, true, 0);
940 WPAssert(spell);
941
942 SpellCastTargets targets;
943 targets.setUnitTarget( this );
944 spell->prepare(&targets);
945 }
946 }
947 }
948
949 if(pVictim->m_currentSpell && pVictim->GetTypeId() == TYPEID_PLAYER && *damage)
950 {
951 if (pVictim->m_currentSpell->getState() != SPELL_STATE_CASTING)
952 {
953 sLog.outString("Spell Delayed!%d",(int32)(0.25f * pVictim->m_currentSpell->casttime));
954 pVictim->m_currentSpell->Delayed((int32)(0.25f * pVictim->m_currentSpell->casttime));
955 }
956 else
957 {
958 sLog.outString("Spell Canceled!");
959 pVictim->m_currentSpell->cancel();
960 }
961 }
962 }
963
964 void Unit::AttackerStateUpdate (Unit *pVictim)
965 {
966 if(hasUnitState(UNIT_STAT_CONFUSED) || hasUnitState(UNIT_STAT_STUNDED))
967 return;
968
969 if (!pVictim->isAlive())
970 {
971 SendAttackStop(pVictim->GetGUID());
972 return;
973 }
974
975 if(m_currentSpell)
976 return;
977
978 if (m_currentMeleeSpell)
979 {
980 m_currentMeleeSpell->cast();
981 return;
982 }
983
984 WorldPacket data;
985 uint32 hitInfo = HITINFO_NORMALSWING2|HITINFO_HITSTRANGESOUND1;
986 uint32 damageType = NORMAL_DAMAGE;
987 uint32 victimState = VICTIMSTATE_NORMAL;
988
989 uint32 damage = 0;
990 uint32 blocked_dmg = 0;
991 uint32 absorbed_dmg = 0;
992 uint32 resisted_dmg = 0;
993
994 DoAttackDamage (pVictim, &damage, &blocked_dmg, &damageType, &hitInfo, &victimState, &absorbed_dmg, &resisted_dmg);
995
996 if (hitInfo & HITINFO_MISS)
997 //send miss
998 SendAttackStateUpdate (hitInfo, pVictim->GetGUID(), 1, damageType, damage, absorbed_dmg, resisted_dmg, victimState, blocked_dmg);
999 else
1000 {
1001 //do animation
1002 SendAttackStateUpdate (hitInfo, pVictim->GetGUID(), 1, damageType, damage, absorbed_dmg, resisted_dmg, victimState, blocked_dmg);
1003 if (damage >= (absorbed_dmg + resisted_dmg))
1004 damage -= (absorbed_dmg + resisted_dmg);
1005 else
1006 damage = 0;
1007 DealDamage (pVictim, damage, 0, true);
1008
1009 if(GetTypeId() == TYPEID_PLAYER && pVictim->isAlive())
1010 {
1011 for(int i = EQUIPMENT_SLOT_START; i < EQUIPMENT_SLOT_END; i++)
1012 ((Player*)this)->CastItemCombatSpell(((Player*)this)->GetItemByPos(INVENTORY_SLOT_BAG_0,i),pVictim);
1013 }
1014 }
1015
1016 if (GetTypeId() == TYPEID_PLAYER)
1017 DEBUG_LOG("AttackerStateUpdate: (Player) %u %X attacked %u %X for %u dmg, absorbed %u, resisted %u.",
1018 GetGUIDLow(), GetGUIDHigh(), pVictim->GetGUIDLow(), pVictim->GetGUIDHigh(), damage, absorbed_dmg, resisted_dmg);
1019 else
1020 DEBUG_LOG("AttackerStateUpdate: (NPC) %u %X attacked %u %X for %u dmg, absorbed %u, resisted %u.",
1021 GetGUIDLow(), GetGUIDHigh(), pVictim->GetGUIDLow(), pVictim->GetGUIDHigh(), damage, absorbed_dmg, resisted_dmg);
1022 }
1023
1024 MeleeHitOutcome Unit::RollMeleeOutcomeAgainst (const Unit *pVictim) const
1025 {
1026 int32 skillDiff = GetWeaponSkillValue() - pVictim->GetDefenceSkillValue();
1027 // bonus from skills is 0.04%
1028 int32 skillBonus = skillDiff * 4;
1029 int32 sum = 0, tmp = 0;
1030 int32 roll = urand (0, 10000);
1031
1032 DEBUG_LOG ("RollMeleeOutcomeAgainst: skill bonus of %d for attacker", skillBonus);
1033 DEBUG_LOG ("RollMeleeOutcomeAgainst: rolled %d, +hit %d, dodge %u, parry %u, block %u, crit %u",
1034 roll, m_modHitChance, (uint32)(pVictim->GetUnitDodgeChance()*100), (uint32)(pVictim->GetUnitParryChance()*100),
1035 (uint32)(pVictim->GetUnitBlockChance()*100), (uint32)(GetUnitCriticalChance()*100));
1036
1037 // FIXME: dual wield has 24% base chance to miss instead of 5%, also
1038 // dual wield is hard-limited to min. 19% miss rate
1039 // base miss rate is 5% and can't get higher than 60%
1040 tmp = 500 - skillBonus - m_modHitChance*100;
1041 if (tmp > 0 && roll < (sum += (tmp >= 6000 ? 6000 : tmp)))
1042 { DEBUG_LOG ("RollMeleeOutcomeAgainst: MISS"); return MELEE_HIT_MISS; }
1043
1044 // always crit against a sitting target
1045 if ( (pVictim->GetTypeId() == TYPEID_PLAYER)
1046 && (((Player*)pVictim)->getStandState() & (PLAYER_STATE_SLEEP | PLAYER_STATE_SIT
1047 | PLAYER_STATE_SIT_CHAIR
1048 | PLAYER_STATE_SIT_LOW_CHAIR
1049 | PLAYER_STATE_SIT_MEDIUM_CHAIR
1050 | PLAYER_STATE_SIT_HIGH_CHAIR)))
1051 { DEBUG_LOG ("RollMeleeOutcomeAgainst: CRIT (sitting victim)"); return MELEE_HIT_CRIT; }
1052
1053 // stunned target cannot dodge and this is check in GetUnitDodgeChance()
1054 tmp = (int32)(pVictim->GetUnitDodgeChance()*100) - skillBonus;
1055 if (tmp > 0 && roll < (sum += tmp))
1056 { DEBUG_LOG ("RollMeleeOutcomeAgainst: DODGE <%d, %d)", sum-tmp, sum); return MELEE_HIT_DODGE; }
1057
1058 int32 modCrit = 0;
1059
1060 // check if attack comes from behind
1061 if (!pVictim->HasInArc(M_PI,this))
1062 {
1063 // ASSUME +10% crit from behind
1064 DEBUG_LOG ("RollMeleeOutcomeAgainst: attack came from behind.");
1065 modCrit += 1000;
1066 }
1067 else
1068 {
1069 // cannot parry or block attacks from behind, but can from forward
1070 tmp = (int32)(pVictim->GetUnitParryChance()*100);
1071 if ( (tmp > 0) // check if unit _can_ parry
1072 && ((tmp -= skillBonus) > 0)
1073 && (roll < (sum += tmp)))
1074 { DEBUG_LOG ("RollMeleeOutcomeAgainst: PARRY <%d, %d)", sum-tmp, sum); return MELEE_HIT_PARRY; }
1075
1076 tmp = (int32)(pVictim->GetUnitBlockChance()*100);
1077 if ( (tmp > 0) // check if unit _can_ block
1078 && ((tmp -= skillBonus) > 0)
1079 && (roll < (sum += tmp)))
1080 { DEBUG_LOG ("RollMeleeOutcomeAgainst: BLOCK <%d, %d)", sum-tmp, sum); return MELEE_HIT_BLOCK; }
1081 }
1082
1083 // flat 40% chance to score a glancing blow if you're 3 or more levels
1084 // below mob level or your weapon skill is too low
1085 if ( (GetTypeId() == TYPEID_PLAYER)
1086 && (pVictim->GetTypeId() != TYPEID_PLAYER)
1087 && ((getLevel() + 3 <= pVictim->getLevel()) || (skillDiff <= -15))
1088 && (roll < (sum += 4000)))
1089 { DEBUG_LOG ("RollMeleeOutcomeAgainst: GLANCING <%d, %d)", sum-4000, sum); return MELEE_HIT_GLANCING; }
1090
1091 // FIXME: +skill and +defense has no effect on crit chance in PvP combat
1092 tmp = (int32)(GetUnitCriticalChance()*100) + skillBonus + modCrit;
1093 if (tmp > 0 && roll < (sum += tmp))
1094 { DEBUG_LOG ("RollMeleeOutcomeAgainst: CRIT <%d, %d)", sum-tmp, sum); return MELEE_HIT_CRIT; }
1095
1096 // mobs can score crushing blows if they're 3 or more levels above victim
1097 // or when their weapon skill is 15 or more above victim's defense skill
1098 if ( (GetTypeId() != TYPEID_PLAYER)
1099 && ((getLevel() >= pVictim->getLevel() + 3) || (skillDiff >= 15)))
1100 {
1101 // tmp = player's max defense skill - player's current defense skill
1102 tmp = 5*pVictim->getLevel() - pVictim->GetDefenceSkillValue();
1103 // having defense above your maximum (from items, talents etc.) has no effect
1104 // add 2% chance per lacking skill point, min. is 15%
1105 // FIXME: chance should go up with mob lvl
1106 tmp = 1500 + (tmp > 0 ? tmp*200 : 0);
1107 if (roll < (sum += tmp))
1108 { DEBUG_LOG ("RollMeleeOutcomeAgainst: CRUSHING <%d, %d)", sum-tmp, sum); return MELEE_HIT_CRUSHING; }
1109 }
1110
1111 DEBUG_LOG ("RollMeleeOutcomeAgainst: NORMAL");
1112 return MELEE_HIT_NORMAL;
1113 }
1114
1115 uint32 Unit::CalculateDamage(bool ranged)
1116 {
1117 float min_damage, max_damage, dmg;
1118 if(ranged)
1119 {
1120 min_damage = GetFloatValue(UNIT_FIELD_MINRANGEDDAMAGE);
1121 max_damage = GetFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE);
1122 }
1123 else
1124 {
1125 min_damage = GetFloatValue(UNIT_FIELD_MINDAMAGE)+GetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE)/2;
1126 max_damage = GetFloatValue(UNIT_FIELD_MAXDAMAGE)+GetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE)/2;
1127 }
1128 if (min_damage > max_damage)
1129 {
1130 std::swap(min_damage,max_damage);
1131 }
1132
1133 if(max_damage == 0.0)
1134 max_damage = 5.0;
1135
1136 float diff = max_damage - min_damage + 1;
1137
1138 dmg = float (rand()%(uint32)diff + (uint32)min_damage);
1139 return (uint32)dmg;
1140 }
1141
1142 void Unit::SendAttackStop(uint64 victimGuid)
1143 {
1144 WorldPacket data;
1145 data.Initialize( SMSG_ATTACKSTOP );
1146 data << uint8(0xFF) << GetGUID();
1147 data << uint8(0xFF) << victimGuid;
1148 data << uint32( 0 );
1149 data << (uint32)0;
1150
1151 SendMessageToSet(&data, true);
1152 sLog.outDetail("%u %X stopped attacking "I64FMT, GetGUIDLow(), GetGUIDHigh(), victimGuid);
1153
1154 Creature *pVictim = ObjectAccessor::Instance().GetCreature(*this, victimGuid);
1155 if( pVictim != NULL )
1156 pVictim->AI().AttackStop(this);
1157 }
1158
1159 uint16 Unit::GetDefenceSkillValue() const
1160 {
1161 if(GetTypeId() == TYPEID_PLAYER)
1162 return ((Player*)this)->GetSkillValue (SKILL_DEFENSE);
1163 else
1164 return GetUnitMeleeSkill();
1165 }
1166
1167 float Unit::GetUnitDodgeChance() const
1168 {
1169 if(hasUnitState(UNIT_STAT_STUNDED))
1170 return 0;
1171
1172 return GetTypeId() == TYPEID_PLAYER ? m_floatValues[ PLAYER_DODGE_PERCENTAGE ] : 5;
1173 }
1174
1175 float Unit::GetUnitParryChance() const
1176 {
1177 float chance = 0;
1178 if(GetTypeId() == TYPEID_PLAYER)
1179 {
1180 Player const* player = (Player const*)this;
1181 // Parry passive skill
1182 if(player->HasSpell(3127) || player->HasSpell(18848))
1183 {
1184 Item *tmpitem = ((Player*)this)->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
1185 if(!tmpitem)
1186 tmpitem = ((Player*)this)->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
1187
1188 if(tmpitem && tmpitem->GetProto()->InventoryType == INVTYPE_WEAPON)
1189 chance = GetFloatValue(PLAYER_PARRY_PERCENTAGE);
1190 }
1191 }
1192 else if(GetTypeId() == TYPEID_UNIT)
1193 {
1194 if(((Creature const*)this)->GetCreatureInfo()->type == CREATURE_TYPE_HUMANOID)
1195 chance = 5;
1196 }
1197
1198 return chance;
1199 }
1200
1201 float Unit::GetUnitBlockChance() const
1202 {
1203 float chance = 0;
1204 if(GetTypeId() == TYPEID_PLAYER)
1205 {
1206 Item *tmpitem = ((Player const*)this)->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
1207 if(tmpitem && tmpitem->GetProto()->Block)
1208 chance = GetFloatValue(PLAYER_BLOCK_PERCENTAGE);
1209 }
1210 else
1211 chance = 5;
1212
1213 return chance;
1214 }
1215
1216 uint16 Unit::GetWeaponSkillValue() const
1217 {
1218 if(GetTypeId() == TYPEID_PLAYER)
1219 {
1220 uint32 skill = 0;
1221 Item *item = ((Player*)this)->GetItemByPos (INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
1222 if(!item)
1223 Item *item = ((Player*)this)->GetItemByPos (INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
1224
1225 skill = item ? item->GetSkill() : SKILL_UNARMED;
1226 return ((Player*)this)->GetSkillValue (skill);
1227 }
1228 else
1229 return GetUnitMeleeSkill();
1230 }
1231
1232 void Unit::_UpdateSpells( uint32 time )
1233 {
1234 if(m_currentSpell != NULL)
1235 {
1236 m_currentSpell->update(time);
1237 if(m_currentSpell->IsAutoRepeat())
1238 {
1239 if(m_currentSpell->getState() == SPELL_STATE_FINISHED)
1240 {
1241 //Auto shot
1242 if( m_currentSpell->m_spellInfo->Id == 75 && GetTypeId() == TYPEID_PLAYER )
1243 setAttackTimer( 0, true );
1244 else
1245 setAttackTimer(m_currentSpell->m_spellInfo->RecoveryTime);
1246
1247 m_currentSpell->setState(SPELL_STATE_IDLE);
1248 }
1249 else if(m_currentSpell->getState() == SPELL_STATE_IDLE && m_attackTimer == 0)
1250 {
1251 // recheck range and req. items (ammo and gun, etc)
1252 if(m_currentSpell->CheckRange() == 0 && m_currentSpell->CheckItems() == 0 )
1253 {
1254 m_currentSpell->setState(SPELL_STATE_PREPARING);
1255 m_currentSpell->ReSetTimer();
1256 }
1257 else
1258 {
1259 m_currentSpell->cancel();
1260 delete m_currentSpell;
1261 m_currentSpell = NULL;
1262 }
1263 }
1264 }
1265 else if(m_currentSpell->getState() == SPELL_STATE_FINISHED)
1266 {
1267 delete m_currentSpell;
1268 m_currentSpell = NULL;
1269 }
1270 }
1271
1272 if(m_currentMeleeSpell != NULL)
1273 {
1274 m_currentMeleeSpell ->update(time);
1275 if(m_currentMeleeSpell ->getState() == SPELL_STATE_FINISHED)
1276 {
1277 delete m_currentMeleeSpell ;
1278 m_currentMeleeSpell = NULL;
1279 }
1280 }
1281
1282 // TODO: Find a better way to prevent crash when multiple auras are removed.
1283 m_removedAuras = 0;
1284 for (AuraMap::iterator i = m_Auras.begin(); i != m_Auras.end(); ++i)
1285 if ((*i).second)
1286 (*i).second->SetUpdated(false);
1287
1288 for (AuraMap::iterator i = m_Auras.begin(), next; i != m_Auras.end(); i = next)
1289 {
1290 next = i;
1291 next++;
1292 if ((*i).second)
1293 {
1294 // prevent double update
1295 if ((*i).second->IsUpdated())
1296 continue;
1297 (*i).second->SetUpdated(true);
1298 (*i).second->Update( time );
1299 // several auras can be deleted due to update
1300 if (m_removedAuras)
1301 {
1302 if (m_Auras.empty()) break;
1303 next = m_Auras.begin();
1304 m_removedAuras = 0;
1305 }
1306 }
1307 }
1308
1309 for (AuraMap::iterator i = m_Auras.begin(); i != m_Auras.end();)
1310 {
1311 if ((*i).second)
1312 {
1313 if ( !(*i).second->GetAuraDuration() && !(*i).second->IsPermanent() )
1314 {
1315 RemoveAura(i);
1316 }
1317 else
1318 {
1319 ++i;
1320 }
1321 }
1322 else
1323 {
1324 ++i;
1325 }
1326 }
1327
1328 if(m_dynObj.empty())
1329 return;
1330 std::list<DynamicObject*>::iterator ite, dnext;
1331 for (ite = m_dynObj.begin(); ite != m_dynObj.end(); ite = dnext)
1332 {
1333 dnext = ite;
1334 dnext++;
1335 //(*i)->Update( difftime );
1336 if( (*ite)->isFinished() )
1337 {
1338 (*ite)->Delete();
1339 m_dynObj.erase(ite);
1340 if(m_dynObj.empty())
1341 break;
1342 else
1343 dnext = m_dynObj.begin();
1344 }
1345 }
1346 if(m_gameObj.empty())
1347 return;
1348 std::list<GameObject*>::iterator ite1, dnext1;
1349 for (ite1 = m_gameObj.begin(); ite1 != m_gameObj.end(); ite1 = dnext1)
1350 {
1351 dnext1 = ite1;
1352 dnext1++;
1353 //(*i)->Update( difftime );
1354 if( (*ite1)->isFinished() )
1355 {
1356 (*ite1)->Delete();
1357 m_gameObj.erase(ite1);
1358 if(m_gameObj.empty())
1359 break;
1360 else
1361 dnext1 = m_gameObj.begin();
1362 }
1363 }
1364 }
1365
1366 void Unit::_UpdateHostil( uint32 time )
1367 {
1368 if(!isInCombat() && m_hostilList.size() )
1369 {
1370 HostilList::iterator iter;
1371 for(iter=m_hostilList.begin(); iter!=m_hostilList.end(); ++iter)
1372 {
1373 iter->Hostility-=time/1000.0f;
1374 if(iter->Hostility<=0.0f)
1375 {
1376 m_hostilList.erase(iter);
1377 if(!m_hostilList.size())
1378 break;
1379 else
1380 iter = m_hostilList.begin();
1381 }
1382 }
1383 }
1384 }
1385
1386 Unit* Unit::SelectHostilTarget()
1387 {
1388 if(!m_hostilList.size())
1389 return NULL;
1390
1391 m_hostilList.sort();
1392 m_hostilList.reverse();
1393 uint64 guid = m_hostilList.front().UnitGuid;
1394 if(guid != getVictim()->GetGUID())
1395 return ObjectAccessor::Instance().GetUnit(*this, guid);
1396 else
1397 return NULL;
1398 }
1399
1400 void Unit::castSpell( Spell * pSpell )
1401 {
1402
1403 if(pSpell->IsMeleeSpell())
1404 {
1405 if(m_currentMeleeSpell)
1406 {
1407 m_currentMeleeSpell->cancel();
1408 delete m_currentMeleeSpell;
1409 m_currentMeleeSpell = NULL;
1410 }
1411 m_currentMeleeSpell = pSpell;
1412 }
1413 else
1414 {
1415 if(m_currentSpell)
1416 {
1417 m_currentSpell->cancel();
1418 delete m_currentSpell;
1419 m_currentSpell = NULL;
1420 }
1421 m_currentSpell = pSpell;
1422 }
1423 }
1424
1425 void Unit::InterruptSpell()
1426 {
1427 if(m_currentSpell)
1428 {
1429 //m_currentSpell->SendInterrupted(0x20);
1430 m_currentSpell->cancel();
1431 }
1432 }
1433
1434 bool Unit::isInFront(Unit const* target, float radius)
1435 {
1436 return GetDistanceSq(target)<=radius * radius && HasInArc( M_PI, target );
1437 }
1438
1439 void Unit::SetInFront(Unit const* target)
1440 {
1441 m_orientation = GetAngle(target);
1442 }
1443
1444 void Unit::DeMorph()
1445 {
1446
1447 uint32 displayid = GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID);
1448 SetUInt32Value(UNIT_FIELD_DISPLAYID, displayid);
1449 }
1450
1451 void Unit::DealWithSpellDamage(DynamicObject &obj)
1452 {
1453 obj.DealWithSpellDamage(*this);
1454 }
1455
1456 long Unit::GetTotalAuraModifier(uint32 ModifierID)
1457 {
1458 uint32 modifier = 0;
1459 bool auraFound = false;
1460
1461 AuraMap::const_iterator i;
1462 for (i = m_Auras.begin(); i != m_Auras.end(); i++)
1463 {
1464 if ((*i).second && (*i).second->GetModifier()->m_auraname == ModifierID)
1465 {
1466 auraFound = true;
1467 modifier += (*i).second->GetModifier()->m_amount;
1468 }
1469 }
1470 if (auraFound)
1471 modifier++;
1472
1473 return modifier;
1474 }
1475
1476 bool Unit::AddAura(Aura *Aur, bool uniq)
1477 {
1478 AuraMap::iterator i = m_Auras.find( spellEffectPair(Aur->GetId(), Aur->GetEffIndex()) );
1479 // take out same spell
1480 if (i != m_Auras.end())
1481 {
1482 (*i).second->SetAuraDuration(Aur->GetAuraDuration());
1483 if ((*i).second->GetTarget())
1484 if ((*i).second->GetTarget()->GetTypeId() == TYPEID_PLAYER )
1485 (*i).second->UpdateAuraDuration();
1486 delete Aur;
1487 }
1488 else
1489 {
1490 if (!Aur->IsPassive()) // passive auras stack with all
1491 {
1492 if (!RemoveNoStackAurasDueToAura(Aur))
1493 {
1494 delete Aur;
1495 return false; // couldnt remove conflicting aura with higher rank
1496 } // couldnt remove conflicting aura with higher rank
1497 }
1498
1499 Aur->_AddAura();
1500 m_Auras[spellEffectPair(Aur->GetId(), Aur->GetEffIndex())] = Aur;
1501 m_AuraModifiers[Aur->GetModifier()->m_auraname] += (Aur->GetModifier()->m_amount + 1);
1502
1503 if (Aur->IsSingleTarget() && Aur->GetTarget() && Aur->GetSpellProto())
1504 {
1505 std::list<Aura *> *scAuras = Aur->GetCaster()->GetSingleCastAuras();
1506 std::list<Aura *>::iterator itr, next;
1507 for (itr = scAuras->begin(); itr != scAuras->end(); itr = next)
1508 {
1509 next = itr;
1510 next++;
1511 if ((*itr)->GetTarget() != Aur->GetTarget() &&
1512 (*itr)->GetSpellProto()->Category == Aur->GetSpellProto()->Category &&
1513 (*itr)->GetSpellProto()->SpellIconID == Aur->GetSpellProto()->SpellIconID &&
1514 (*itr)->GetSpellProto()->SpellVisual == Aur->GetSpellProto()->SpellVisual &&
1515 (*itr)->GetSpellProto()->Attributes == Aur->GetSpellProto()->Attributes &&
1516 (*itr)->GetSpellProto()->AttributesEx == Aur->GetSpellProto()->AttributesEx &&
1517 (*itr)->GetSpellProto()->AttributesExEx == Aur->GetSpellProto()->AttributesExEx)
1518 {
1519 (*itr)->GetTarget()->RemoveAura((*itr)->GetId(), (*itr)->GetEffIndex());
1520 if(scAuras->empty())
1521 break;
1522 else
1523 next = scAuras->begin();
1524 }
1525 }
1526 scAuras->push_back(Aur);
1527 }
1528 }
1529 return true;
1530 }
1531
1532 void Unit::RemoveRankAurasDueToSpell(uint32 spellId)
1533 {
1534 SpellEntry *spellInfo = sSpellStore.LookupEntry(spellId);
1535 if(!spellInfo)
1536 return;
1537 AuraMap::iterator i,next;
1538 for (i = m_Auras.begin(); i != m_Auras.end(); i = next)
1539 {
1540 next = i;
1541 next++;
1542 uint32 i_spellId = (*i).second->GetId();
1543 if((*i).second && i_spellId && i_spellId != spellId)
1544 {
1545 if(IsRankSpellDueToSpell(spellInfo,i_spellId))
1546 {
1547 RemoveAurasDueToSpell(i_spellId);
1548
1549 if( m_Auras.empty() )
1550 break;
1551 else
1552 next = m_Auras.begin();
1553 }
1554 }
1555 }
1556 }
1557
1558 bool Unit::RemoveNoStackAurasDueToAura(Aura *Aur)
1559 {
1560 if (!Aur)
1561 return false;
1562 if (!Aur->GetSpellProto()) return false;
1563 uint32 spellId = Aur->GetId();
1564 uint32 effIndex = Aur->GetEffIndex();
1565 bool is_sec = IsSpellSingleEffectPerCaster(spellId);
1566 AuraMap::iterator i,next;
1567 for (i = m_Auras.begin(); i != m_Auras.end(); i = next)
1568 {
1569 next = i;
1570 next++;
1571 if (!(*i).second) continue;
1572 if (!(*i).second->GetSpellProto()) continue;
1573 if (IsPassiveSpell((*i).second->GetId())) continue;
1574
1575 uint32 i_spellId = (*i).second->GetId();
1576 uint32 i_effIndex = (*i).second->GetEffIndex();
1577 if(i_spellId != spellId)
1578 {
1579 bool sec_match = false;
1580 if (is_sec && IsSpellSingleEffectPerCaster(i_spellId))
1581 if (Aur->GetCaster() == (*i).second->GetCaster())
1582 if (GetSpellSpecific(spellId) == GetSpellSpecific(i_spellId))
1583 sec_match = true;
1584
1585 if(IsNoStackSpellDueToSpell(spellId, i_spellId) || sec_match)
1586 {
1587 // if sec_match this isnt always true, needs to be rechecked
1588 if (IsRankSpellDueToSpell(Aur->GetSpellProto(), i_spellId))
1589 if(CompareAuraRanks(spellId, effIndex, i_spellId, i_effIndex) < 0)
1590 return false; // cannot remove higher rank
1591
1592 RemoveAurasDueToSpell(i_spellId);
1593
1594 if( m_Auras.empty() )
1595 break;
1596 else
1597 next = m_Auras.begin();
1598 }
1599 else // Potions stack aura by aura
1600 if (Aur->GetSpellProto()->SpellFamilyName == SPELLFAMILY_POTION &&
1601 (*i).second->GetSpellProto()->SpellFamilyName == SPELLFAMILY_POTION)
1602 {
1603 if (IsNoStackAuraDueToAura(spellId, effIndex, i_spellId, i_effIndex))
1604 {
1605 if(CompareAuraRanks(spellId, effIndex, i_spellId, i_effIndex) < 0)
1606 return false; // cannot remove higher rank
1607
1608 RemoveAura(i);
1609
1610 if( m_Auras.empty() )
1611 break;
1612 else
1613 next = m_Auras.begin();
1614 }
1615 }
1616 }
1617 }
1618 return true;
1619 }
1620
1621 void Unit::RemoveFirstAuraByDispel(uint32 dispel_type)
1622 {
1623 AuraMap::iterator i;
1624 for (i = m_Auras.begin(); i != m_Auras.end(); ++i)
1625 {
1626 if ((*i).second && (*i).second->GetSpellProto()->Dispel == dispel_type)
1627 {
1628 if(dispel_type == 1)
1629 {
1630 bool positive = true;
1631 switch((*i).second->GetSpellProto()->EffectImplicitTargetA[(*i).second->GetEffIndex()])
1632 {
1633 case TARGET_S_E:
1634 case TARGET_AE_E:
1635 case TARGET_AE_E_INSTANT:
1636 case TARGET_AC_E:
1637 case TARGET_INFRONT:
1638 case TARGET_DUELVSPLAYER:
1639 case TARGET_AE_E_CHANNEL:
1640 case TARGET_AE_SELECTED:
1641 positive = false;
1642 break;
1643
1644 default:
1645 positive = ((*i).second->GetSpellProto()->AttributesEx & (1<<7)) ? false : true;
1646 }
1647 if(positive)
1648 continue;
1649 }
1650 break;
1651 }
1652 }
1653
1654 if(i == m_Auras.end()) return;
1655
1656 RemoveAura(i);
1657 }
1658
1659 void Unit::RemoveAura(uint32 spellId, uint32 effindex)
1660 {
1661 AuraMap::iterator i = m_Auras.find( spellEffectPair(spellId, effindex) );
1662 if(i != m_Auras.end())
1663 RemoveAura(i);
1664 }
1665
1666 void Unit::RemoveAurasDueToSpell(uint32 spellId)
1667 {
1668 for (int i = 0; i < 3; i++)
1669 {
1670 AuraMap::iterator iter = m_Auras.find(spellEffectPair(spellId, i));
1671 if (iter != m_Auras.end())
1672 RemoveAura(iter);
1673 }
1674 }
1675
1676 void Unit::RemoveAura(AuraMap::iterator &i)
1677 {
1678 if ((*i).second->IsSingleTarget())
1679 {
1680 std::list<Aura *> *scAuras = (*i).second->GetCaster()->GetSingleCastAuras();
1681 scAuras->remove((*i).second);
1682 }
1683 // remove aura from party members when the caster turns off the aura
1684 if((*i).second->IsAreaAura())
1685 {
1686 Unit *i_caster = (*i).second->GetCaster(), *i_target = (*i).second->GetTarget();
1687 if(i_caster->GetTypeId() == TYPEID_PLAYER && i_caster->GetGUID() == i_target->GetGUID())
1688 {
1689 Group* pGroup = objmgr.GetGroupByLeader(((Player*)i_caster)->GetGroupLeader());
1690 float radius = GetRadius(sSpellRadius.LookupEntry((*i).second->GetSpellProto()->EffectRadiusIndex[(*i).second->GetEffIndex()]));
1691 if(pGroup)
1692 {
1693 for(uint32 p=0;p<pGroup->GetMembersCount();p++)
1694 {
1695 Unit* Target = ObjectAccessor::Instance().FindPlayer(pGroup->GetMemberGUID(p));
1696 if(!Target || Target->GetGUID() == i_caster->GetGUID())
1697 continue;
1698 Aura *t_aura = Target->GetAura((*i).second->GetId(), (*i).second->GetEffIndex());
1699 if (t_aura)
1700 if (t_aura->GetCaster()->GetGUID() == i_caster->GetGUID())
1701 Target->RemoveAura((*i).second->GetId(), (*i).second->GetEffIndex());
1702 }
1703 }
1704 }
1705 }
1706 m_AuraModifiers[(*i).second->GetModifier()->m_auraname] -= ((*i).second->GetModifier()->m_amount + 1);
1707 (*i).second->_RemoveAura();
1708 delete (*i).second;
1709 m_Auras.erase(i++);
1710 m_removedAuras++; // internal count used by unit update
1711 }
1712
1713 bool Unit::SetAurDuration(uint32 spellId, uint32 effindex,uint32 duration)
1714 {
1715 AuraMap::iterator iter = m_Auras.find(spellEffectPair(spellId, effindex));
1716 if (iter != m_Auras.end())
1717 {
1718 (*iter).second->SetAuraDuration(duration);
1719 return true;
1720 }
1721 return false;
1722 }
1723
1724 uint32 Unit::GetAurDuration(uint32 spellId, uint32 effindex)
1725 {
1726 AuraMap::iterator iter = m_Auras.find(spellEffectPair(spellId, effindex));
1727 if (iter != m_Auras.end())
1728 {
1729 return (*iter).second->GetAuraDuration();
1730 }
1731 return 0;
1732 }
1733
1734 void Unit::RemoveAllAuras()
1735 {
1736 while (!m_Auras.empty())
1737 {
1738 AuraMap::iterator iter = m_Auras.begin();
1739 RemoveAura(iter);
1740 }
1741 }
1742
1743 void Unit::_RemoveStatsMods()
1744 {
1745 ApplyStats(false);
1746 }
1747
1748 void Unit::_ApplyStatsMods()
1749 {
1750 ApplyStats(true);
1751 }
1752
1753 void Unit::ApplyStats(bool apply)
1754 {
1755 // TODO:
1756 // -- add --
1757 // spell crit formula: 5 + INT/100
1758 // skill formula: skill*0,04 for all, use defense skill for parry/dodge
1759 // froze spells gives + 50% change to crit
1760
1761 if(GetTypeId() != TYPEID_PLAYER) return;
1762
1763 PlayerCreateInfo* pinfo = ((Player*)this)->GetPlayerInfo();
1764 if(!pinfo) return;
1765
1766 float val;
1767 uint32 val2,tem_att_power;
1768
1769 // Armor
1770 val2 = 2*GetStat(STAT_AGILITY);
1771
1772 ApplyArmorMod( val2, apply);
1773
1774 // HP
1775 val2 = (GetStat(STAT_STAMINA) - pinfo->stamina)*10;
1776
1777 ApplyMaxHealthMod( val2, apply);
1778
1779 // MP
1780 if(getClass() != WARRIOR && getClass() != ROGUE)
1781 {
1782 val2 = (GetStat(STAT_INTELLECT) - pinfo->intellect)*15;
1783
1784 ApplyMaxPowerMod(POWER_MANA, val2, apply);
1785
1786 }
1787
1788 float classrate = 0;
1789
1790 // Melee Attack Power
1791 // && Melee DPS - (Damage Per Second)
1792
1793 //Ranged
1794 if(getClass() == HUNTER)
1795 val2 = getLevel() * 2 + GetStat(STAT_AGILITY) * 2 - 20;
1796 else
1797 val2 = getLevel() + GetStat(STAT_AGILITY) * 2 - 20;
1798
1799 if(!apply)
1800 tem_att_power = GetUInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER) + GetUInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER_MODS);
1801
1802 ApplyModUInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER, val2, apply);
1803
1804 if(apply)
1805 tem_att_power = GetUInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER) + GetUInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER_MODS);
1806
1807 val = GetFloatValue(UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER);
1808 if(val>0)
1809 tem_att_power = uint32(val*tem_att_power);
1810
1811 val = tem_att_power/14.0f * GetUInt32Value(UNIT_FIELD_RANGEDATTACKTIME)/1000;
1812 ApplyModFloatValue(UNIT_FIELD_MINRANGEDDAMAGE, val, apply);
1813 ApplyModFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE, val, apply);
1814
1815 //Not-ranged
1816
1817 switch(getClass())
1818 {
1819 case WARRIOR: val2 = getLevel()*3 + GetStat(STAT_STRENGTH)*2 - 20; break;
1820 case PALADIN: val2 = getLevel()*3 + GetStat(STAT_STRENGTH)*2 - 20; break;
1821 case ROGUE: val2 = getLevel()*2 + GetStat(STAT_STRENGTH) + GetStat(STAT_AGILITY) - 20; break;
1822 case HUNTER: val2 = getLevel()*2 + GetStat(STAT_STRENGTH) + GetStat(STAT_AGILITY) - 20; break;
1823 case SHAMAN: val2 = getLevel()*2 + GetStat(STAT_STRENGTH)*2 - 20; break;
1824 case DRUID: val2 = GetStat(STAT_STRENGTH)*2 - 20; break;
1825 case MAGE: val2 = GetStat(STAT_STRENGTH) - 10; break;
1826 case PRIEST: val2 = GetStat(STAT_STRENGTH) - 10; break;
1827 case WARLOCK: val2 = GetStat(STAT_STRENGTH) - 10; break;
1828 }
1829 tem_att_power = GetUInt32Value(UNIT_FIELD_ATTACK_POWER) + GetUInt32Value(UNIT_FIELD_ATTACK_POWER_MODS);
1830
1831 ApplyModUInt32Value(UNIT_FIELD_ATTACK_POWER, val2, apply);
1832
1833 if(apply)
1834 tem_att_power = GetUInt32Value(UNIT_FIELD_ATTACK_POWER) + GetUInt32Value(UNIT_FIELD_ATTACK_POWER_MODS);
1835
1836 val = GetFloatValue(UNIT_FIELD_ATTACK_POWER_MULTIPLIER);
1837 if(val>0)
1838 tem_att_power = uint32(val*tem_att_power);
1839
1840 val = tem_att_power/14.0f * GetUInt32Value(UNIT_FIELD_BASEATTACKTIME)/1000;
1841
1842 ApplyModFloatValue(UNIT_FIELD_MINDAMAGE, val, apply);
1843 ApplyModFloatValue(UNIT_FIELD_MAXDAMAGE, val, apply);
1844
1845 // critical
1846 if(getClass() == HUNTER) classrate = 53;
1847 else if(getClass() == ROGUE) classrate = 29;
1848 else classrate = 20;
1849
1850 val = float(5 + GetStat(STAT_AGILITY)/classrate);
1851
1852 ApplyModFloatValue(PLAYER_CRIT_PERCENTAGE, val, apply);
1853
1854 //dodge
1855 if(getClass() == HUNTER) classrate = 26.5;
1856 else if(getClass() == ROGUE) classrate = 14.5;
1857 else classrate = 20;
1858 ///*+(Defense*0,04);
1859 if (getRace() == NIGHTELF)
1860 val = float(GetStat(STAT_AGILITY)/classrate + 1);
1861 else
1862 val = float(GetStat(STAT_AGILITY)/classrate);
1863
1864 ApplyModFloatValue(PLAYER_DODGE_PERCENTAGE, val, apply);
1865
1866 //parry
1867 val = float(5);
1868
1869 ApplyModFloatValue(PLAYER_PARRY_PERCENTAGE, val, apply);
1870
1871 //block
1872 val = float(GetStat(STAT_STRENGTH)/22);
1873
1874 ApplyModFloatValue(PLAYER_BLOCK_PERCENTAGE, val, apply);
1875
1876 }
1877
1878 void Unit::_RemoveAllAuraMods()
1879 {
1880 for (AuraMap::iterator i = m_Auras.begin(); i != m_Auras.end(); ++i)
1881 {
1882 ApplyStats(false);
1883 (*i).second->ApplyModifier(false);
1884 ApplyStats(true);
1885 }
1886 }
1887
1888 void Unit::_ApplyAllAuraMods()
1889 {
1890 for (AuraMap::iterator i = m_Auras.begin(); i != m_Auras.end(); ++i)
1891 {
1892 ApplyStats(false);
1893 (*i).second->ApplyModifier(true);
1894 ApplyStats(true);
1895 }
1896 }
1897
1898 // TODO: FIX-ME!!!
1899 /*void Unit::_UpdateAura()
1900 {
1901 if(GetTypeId() != TYPEID_PLAYER || !m_Auras)
1902 return;
1903
1904 Player* pThis = (Player*)this;
1905
1906 Player* pGroupGuy;
1907 Group* pGroup;
1908
1909 pGroup = objmgr.GetGroupByLeader(pThis->GetGroupLeader());
1910
1911 if(!SetAffDuration(m_Auras->GetId(),this,6000))
1912 AddAura(m_Auras);
1913
1914 if(!pGroup)
1915 return;
1916 else
1917 {
1918 for(uint32 i=0;i<pGroup->GetMembersCount();i++)
1919 {
1920 pGroupGuy = ObjectAccessor::Instance().FindPlayer(pGroup->GetMemberGUID(i));
1921
1922 if(!pGroupGuy)
1923 continue;
1924 if(pGroupGuy->GetGUID() == GetGUID())
1925 continue;
1926 if(sqrt(
1927 (GetPositionX()-pGroupGuy->GetPositionX())*(GetPositionX()-pGroupGuy->GetPositionX())
1928 +(GetPositionY()-pGroupGuy->GetPositionY())*(GetPositionY()-pGroupGuy->GetPositionY())
1929 +(GetPositionZ()-pGroupGuy->GetPositionZ())*(GetPositionZ()-pGroupGuy->GetPositionZ())
1930 ) <=30)
1931 {
1932 if(!pGroupGuy->SetAffDuration(m_Auras->GetId(),this,6000))
1933 pGroupGuy->AddAura(m_Auras);
1934 }
1935 else
1936 {
1937 if(m_removeAuraTimer == 0)
1938 {
1939 printf("remove aura from %u\n", pGroupGuy->GetGUID());
1940 pGroupGuy->RemoveAura(m_Auras->GetId());
1941 }
1942 }
1943 }
1944 }
1945 if(m_removeAuraTimer > 0)
1946 m_removeAuraTimer -= 1;
1947 else
1948 m_removeAuraTimer = 4;
1949 }*/
1950
1951 Aura* Unit::GetAura(uint32 spellId, uint32 effindex)
1952 {
1953 AuraMap::iterator iter = m_Auras.find(spellEffectPair(spellId, effindex));
1954 if (iter != m_Auras.end())
1955 return iter->second;
1956 return NULL;
1957 }
1958
1959 float Unit::GetHostility(uint64 guid) const
1960 {
1961 HostilList::const_iterator i;
1962 for ( i = m_hostilList.begin(); i!= m_hostilList.end(); i++)
1963 {
1964 if(i->UnitGuid==guid)
1965 return i->Hostility;
1966 }
1967 return 0.0f;
1968 }
1969
1970 void Unit::AddHostil(uint64 guid, float hostility)
1971 {
1972 HostilList::iterator i;
1973 for(i = m_hostilList.begin(); i != m_hostilList.end(); i++)
1974 {
1975 if(i->UnitGuid==guid)
1976 {
1977 i->Hostility+=hostility;
1978 return;
1979 }
1980 }
1981 m_hostilList.push_back(Hostil(guid,hostility));
1982 }
1983
1984 void Unit::AddItemEnchant(uint32 enchant_id,bool apply)
1985 {
1986 if (GetTypeId() != TYPEID_PLAYER)
1987 return;
1988
1989 SpellItemEnchantment *pEnchant;
1990 pEnchant = sSpellItemEnchantmentStore.LookupEntry(enchant_id);
1991 if(!pEnchant)
1992 return;
1993 uint32 enchant_display = pEnchant->display_type;
1994 uint32 enchant_value1 = pEnchant->value1;
1995 //uint32 enchant_value2 = pEnchant->value2;
1996 uint32 enchant_spell_id = pEnchant->spellid;
1997 //uint32 enchant_aura_id = pEnchant->aura_id;
1998 //uint32 enchant_description = pEnchant->description;
1999 SpellEntry *enchantSpell_info = sSpellStore.LookupEntry(enchant_spell_id);
2000
2001 if(enchant_display ==4)
2002 {
2003 ApplyArmorMod(enchant_value1,apply);
2004 }
2005 else if(enchant_display ==2)
2006 {
2007 if(getClass() == CLASS_HUNTER)
2008 {
2009 ApplyModUInt32Value(UNIT_FIELD_MINRANGEDDAMAGE,enchant_value1,apply);
2010 ApplyModUInt32Value(UNIT_FIELD_MAXRANGEDDAMAGE,enchant_value1,apply);
2011 }
2012 else
2013 {
2014 ApplyModUInt32Value(UNIT_FIELD_MINDAMAGE,enchant_value1,apply);
2015 ApplyModUInt32Value(UNIT_FIELD_MAXDAMAGE,enchant_value1,apply);
2016 }
2017 }
2018 else
2019 {
2020 if(apply && ((Player*)this)->IsItemSpellToEquip(enchantSpell_info))
2021 {
2022 Spell *spell = new Spell(this, enchantSpell_info, true, 0);
2023 SpellCastTargets targets;
2024 targets.setUnitTarget(this);
2025 spell->prepare(&targets);
2026 }
2027 else RemoveAurasDueToSpell(enchant_spell_id);
2028 }
2029 }
2030
2031 void Unit::AddDynObject(DynamicObject* dynObj)
2032 {
2033 m_dynObj.push_back(dynObj);
2034 }
2035
2036 void Unit::RemoveDynObject(uint32 spellid)
2037 {
2038 if(m_dynObj.empty())
2039 return;
2040 std::list<DynamicObject*>::iterator i, next;
2041 for (i = m_dynObj.begin(); i != m_dynObj.end(); i = next)
2042 {
2043 next = i;
2044 next++;
2045 if(spellid == 0 || (*i)->GetSpellId() == spellid)
2046 {
2047 (*i)->Delete();
2048 m_dynObj.erase(i);
2049 if(m_dynObj.empty())
2050 break;
2051 else
2052 next = m_dynObj.begin();
2053 }
2054 }
2055 }
2056
2057 void Unit::AddGameObject(GameObject* gameObj)
2058 {
2059 m_gameObj.push_back(gameObj);
2060 }
2061
2062 void Unit::RemoveGameObject(uint32 spellid, bool del)
2063 {
2064 if(m_gameObj.empty())
2065 return;
2066 std::list<GameObject*>::iterator i, next;
2067 for (i = m_gameObj.begin(); i != m_gameObj.end(); i = next)
2068 {
2069 next = i;
2070 next++;
2071 if(spellid == 0 || (*i)->GetSpellId() == spellid)
2072 {
2073 if(del)
2074 (*i)->Delete();
2075
2076 m_gameObj.erase(i);
2077 if(m_gameObj.empty())
2078 break;
2079 else
2080 next = m_gameObj.begin();
2081 }
2082 }
2083 }
2084
2085 void Unit::SendSpellNonMeleeDamageLog(uint64 targetGUID,uint32 SpellID,uint32 Damage, uint8 DamageType,uint32 AbsorbedDamage, uint32 Resist,bool PhysicalDamage, uint32 Blocked)
2086 {
2087 WorldPacket data;
2088 data.Initialize(SMSG_SPELLNONMELEEDAMAGELOG);
2089 data << uint8(0xFF) << targetGUID;
2090 data << uint8(0xFF) << GetGUID();
2091 data << SpellID;
2092 data << Damage;
2093 data << DamageType; //damagetype
2094 data << AbsorbedDamage; //AbsorbedDamage
2095 data << Resist; //resist
2096 data << (uint8)PhysicalDamage;
2097 data << uint8(0);
2098 data << Blocked; //blocked
2099 data << uint8(0);
2100 SendMessageToSet( &data, true );
2101 }
2102
2103 void Unit::SendAttackStateUpdate(uint32 HitInfo, uint64 targetGUID, uint8 SwingType, uint32 DamageType, uint32 Damage, uint32 AbsorbDamage, uint32 Resist, uint32 TargetState, uint32 BlockedAmount)
2104 {
2105 sLog.outDebug("WORLD: Sending SMSG_ATTACKERSTATEUPDATE");
2106
2107 WorldPacket data;
2108 data.Initialize(SMSG_ATTACKERSTATEUPDATE);
2109 data << (uint32)HitInfo;
2110 data << uint8(0xFF) << GetGUID(); //source GUID
2111 data << uint8(0xFF) << targetGUID; //Target GUID
2112 data << (uint32)(Damage-AbsorbDamage);
2113
2114 data << (uint8)SwingType;
2115 data << (uint32)DamageType;
2116
2117 data << (float)Damage; //
2118 data << (uint32)Damage; // still need to double check damaga
2119 data << (uint32)AbsorbDamage;
2120 data << (uint32)Resist;
2121 data << (uint32)TargetState;
2122
2123 if( AbsorbDamage == 0 ) //also 0x3E8 = 0x3E8, check when that happens
2124 data << (uint32)0;
2125 else
2126 data << (uint32)-1;
2127
2128 data << (uint32)0;
2129 data << (uint32)BlockedAmount;
2130
2131 SendMessageToSet( &data, true );
2132 }
2133
2134 void Unit::setPowerType(Powers PowerType)
2135 {
2136 uint32 tem_bytes_0 = GetUInt32Value(UNIT_FIELD_BYTES_0);
2137 SetUInt32Value(UNIT_FIELD_BYTES_0,((tem_bytes_0<<8)>>8) + (uint32(PowerType)<<24));
2138 Powers new_powertype = getPowerType();
2139 switch(new_powertype)
2140 {
2141 default:
2142 case POWER_MANA:
2143 break;
2144 case POWER_RAGE:
2145 SetMaxPower(POWER_RAGE,1000);
2146 SetPower( POWER_RAGE,0);
2147 break;
2148 case POWER_FOCUS:
2149 SetMaxPower(POWER_FOCUS,100);
2150 SetPower( POWER_FOCUS,100);
2151 break;
2152 case POWER_ENERGY:
2153 SetMaxPower(POWER_ENERGY,100);
2154 SetPower( POWER_ENERGY,100);
2155 break;
2156 case POWER_HAPPINESS:
2157 SetMaxPower(POWER_HAPPINESS,1000000);
2158 SetPower(POWER_HAPPINESS,1000000);
2159 break;
2160 }
2161 }
2162
2163 FactionTemplateEntry* Unit::getFactionTemplateEntry() const
2164 {
2165 FactionTemplateEntry* entry = sFactionTemplateStore.LookupEntry(getFaction());
2166 if(!entry)
2167 {
2168 static uint64 guid = 0; // prevent repeating spam same faction problem
2169
2170 if(GetGUID() != guid)
2171 {
2172 if(GetTypeId() == TYPEID_PLAYER)
2173 sLog.outError("Player %s have invalide faction (fuction template id) #%u", ((Player*)this)->GetName(), getFaction());
2174 else
2175 sLog.outError("Creature (template id: %u) have invalide faction (fuction template id) #%u", ((Creature*)this)->GetCreatureInfo()->Entry, getFaction());
2176 guid = GetGUID();
2177 }
2178 }
2179 return entry;
2180 }
2181
2182 bool Unit::Attack(Unit *victim)
2183 {
2184 if(victim == this)
2185 return false;
2186
2187 if (m_attacking)
2188 {
2189 if (m_attacking == victim)
2190 return false;
2191 AttackStop();
2192 }
2193 addUnitState(UNIT_STAT_ATTACKING);
2194 SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_ATTACKING);
2195 m_attacking = victim;
2196 m_attacking->_addAttacker(this);
2197 return true;
2198 }
2199
2200 bool Unit::AttackStop()
2201 {
2202 if (!m_attacking)
2203 return false;
2204
2205 m_attacking->_removeAttacker(this);
2206 m_attacking = NULL;
2207 clearUnitState(UNIT_STAT_ATTACKING);
2208 RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_ATTACKING);
2209 return true;
2210 }
2211
2212 bool Unit::isInCombatWithPlayer() const
2213 {
2214 if(getVictim() && getVictim()->GetTypeId() == TYPEID_PLAYER)
2215 return true;
2216
2217 for(AttackerSet::const_iterator i = m_attackers.begin(); i != m_attackers.end(); ++i)
2218 {
2219 if((*i)->GetTypeId() == TYPEID_PLAYER) return true;
2220 }
2221 return false;
2222 }
2223
2224 void Unit::RemoveAllAttackers()
2225 {
2226 while (m_attackers.size() != 0)
2227 {
2228 AttackerSet::iterator iter = m_attackers.begin();
2229 if(!(*iter)->AttackStop())
2230 {
2231 sLog.outError("WORLD: Unit has an attacker that isnt attacking it!");
2232 m_attackers.erase(iter);
2233 }
2234 }
2235 }
2236
2237 void Unit::SetStateFlag(uint32 index, uint32 newFlag )
2238 {
2239 index |= newFlag;
2240 }
2241
2242 void Unit::RemoveStateFlag(uint32 index, uint32 oldFlag )
2243 {
2244 index &= ~ oldFlag;
2245 }
2246
2247 Creature* Unit::GetPet() const
2248 {
2249 uint64 pet_guid = GetPetGUID();
2250 if(pet_guid)
2251 {
2252 Creature* pet = ObjectAccessor::Instance().GetCreature(*this, pet_guid);
2253 if(!pet)
2254 {
2255 sLog.outError("Unit::GetPet: Pet %u not exist.",GUID_LOPART(pet_guid));
2256 const_cast<Unit*>(this)->SetPet(0);
2257 }
2258 return pet;
2259 }
2260 else
2261 return NULL;
2262 }
2263
2264 void Unit::SetPet(Creature* pet)
2265 {
2266 SetUInt64Value(UNIT_FIELD_SUMMON,pet ? pet->GetGUID() : 0);
2267 }
2268
2269 void Unit::UnsummonTotem(int8 slot)
2270 {
2271 uint64 t_guids[4] = { m_TotemSlot1, m_TotemSlot2, m_TotemSlot3, m_TotemSlot4 };
2272 WorldPacket data;
2273
2274 for (int8 i = 0; i < 4; i++)
2275 {
2276 if (i != slot && slot != -1) continue;
2277 Creature *OldTotem = ObjectAccessor::Instance().GetCreature(*this, t_guids[i]);
2278
2279 if(OldTotem)
2280 {
2281 data.Initialize(SMSG_GAMEOBJECT_DESPAWN_ANIM);
2282 data << t_guids[i];
2283 SendMessageToSet(&data, true);
2284
2285 data.Initialize(SMSG_DESTROY_OBJECT);
2286 data << t_guids[i];
2287 SendMessageToSet(&data, true);
2288 MapManager::Instance().GetMap(OldTotem->GetMapId())->Remove(OldTotem, true);
2289 OldTotem = NULL;
2290 }
2291 }
2292 }
Open Source reference implementation for a MMORPG server system