示例#1
0
void Guardian::UpdateMaxHealth()
{
    UnitMods unitMod = UNIT_MOD_HEALTH;
    float stamina = GetStat(STAT_STAMINA) - GetCreateStat(STAT_STAMINA);

    uint32 basehealth = 0;
    if (Unit* owner = GetCharmerOrOwner())
        basehealth = owner->GetMaxHealth();

    float multiplicator;
    switch (GetEntry())
    {
        case ENTRY_IMP:                 multiplicator = 0.30f;   break;
        case ENTRY_VOIDWALKER:          multiplicator = 0.50f;  break;
        case ENTRY_SUCCUBUS:            multiplicator = 0.45f;   break;
        case ENTRY_FELHUNTER:           multiplicator = 0.70f; break;
        case ENTRY_FELGUARD:            multiplicator = 0.75f;  break;
        case ENTRY_BLOODWORM:           multiplicator = 0.10f;   break;
        case ENTRY_GHOUL:               multiplicator = 0.75f;  break;
        case ENTRY_GARGOYLE:            multiplicator = 0.75f;  break;
        case ENTRY_WATER_ELEMENTAL:     multiplicator = 0.50f;  break;
        default:                        multiplicator = 0.70f;  break;
    }

    basehealth *= multiplicator;

    float value = GetModifierValue(unitMod, BASE_VALUE) + basehealth;
    value *= GetModifierValue(unitMod, BASE_PCT);
    value += GetModifierValue(unitMod, TOTAL_VALUE) + stamina * 10;
    value *= GetModifierValue(unitMod, TOTAL_PCT);

    // Glyph of Voidwalker
    if (GetEntry() == ENTRY_VOIDWALKER)
    {
        if (Player * owner = GetSpellModOwner())
            if (AuraEffect * auraEff = owner->GetAuraEffect(56247, 0))
                AddPct(value, auraEff->GetAmount());
    }

    SetMaxHealth((uint32)value);
}
示例#2
0
void TemporarySummon::Update(uint32 update_diff,  uint32 diff)
{
    switch (m_type)
    {
        case TEMPSUMMON_MANUAL_DESPAWN:
            break;
        case TEMPSUMMON_TIMED_DESPAWN:
        {
            if (m_timer <= update_diff)
            {
                UnSummon();
                return;
            }

            m_timer -= update_diff;
            break;
        }
        case TEMPSUMMON_TIMED_OOC_DESPAWN:
        {
            if (!IsInCombat())
            {
                if (m_timer <= update_diff)
                {
                    UnSummon();
                    return;
                }

                m_timer -= update_diff;
            }
            else if (m_timer != m_lifetime)
                m_timer = m_lifetime;

            break;
        }

        case TEMPSUMMON_CORPSE_TIMED_DESPAWN:
        {
            if (IsCorpse())
            {
                if (m_timer <= update_diff)
                {
                    UnSummon();
                    return;
                }

                m_timer -= update_diff;
            }
            if (IsDespawned())
            {
                UnSummon();
                return;
            }
            break;
        }
        case TEMPSUMMON_CORPSE_DESPAWN:
        {
            // if m_deathState is DEAD, CORPSE was skipped
            if (IsDead())
            {
                UnSummon();
                return;
            }

            break;
        }
        case TEMPSUMMON_DEAD_DESPAWN:
        {
            if (IsDespawned())
            {
                UnSummon();
                return;
            }
            break;
        }
        case TEMPSUMMON_TIMED_OOC_OR_CORPSE_DESPAWN:
        {
            // if m_deathState is DEAD, CORPSE was skipped
            if (IsDead())
            {
                UnSummon();
                return;
            }

            if (!IsInCombat())
            {
                if (m_timer <= update_diff)
                {
                    UnSummon();
                    return;
                }
                else
                    m_timer -= update_diff;
            }
            else if (m_timer != m_lifetime)
                m_timer = m_lifetime;
            break;
        }
        case TEMPSUMMON_TIMED_OOC_OR_DEAD_DESPAWN:
        {
            // if m_deathState is DEAD, CORPSE was skipped
            if (IsDespawned())
            {
                UnSummon();
                return;
            }

            if (!IsInCombat() && IsAlive())
            {
                if (m_timer <= update_diff)
                {
                    UnSummon();
                    return;
                }
                else
                    m_timer -= update_diff;
            }
            else if (m_timer != m_lifetime)
                m_timer = m_lifetime;
            break;
        }
        case TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN:
        {
            // if m_deathState is DEAD, CORPSE was skipped
            if (IsDead())
            {
                UnSummon();
                return;
            }
            if (m_timer <= update_diff)
            {
                UnSummon();
                return;
            }
            m_timer -= update_diff;
            break;
        }
        case TEMPSUMMON_TIMED_OR_DEAD_DESPAWN:
        {
            // if m_deathState is DEAD, CORPSE was skipped
            if (IsDespawned())
            {
                UnSummon();
                return;
            }
            if (m_timer <= update_diff)
            {
                UnSummon();
                return;
            }
            m_timer -= update_diff;
            break;
        }
        default:
            UnSummon();
            sLog.outError("Temporary summoned creature (entry: %u) have unknown type %u of ", GetEntry(), m_type);
            break;
    }

    switch (m_deathState)
    {
        case ALIVE:
            if (m_linkedToOwnerAura & TEMPSUMMON_LINKED_AURA_OWNER_CHECK)
            {
                // we have to check if owner still have the required aura
                Unit* owner = GetCharmerOrOwner();
                uint32 const& spellId = GetUInt32Value(UNIT_CREATED_BY_SPELL);
                if (!owner || !spellId || !owner->HasAura(spellId))
                    UnSummon();
            }
            break;

        case DEAD:
        case CORPSE:
            if (m_linkedToOwnerAura & TEMPSUMMON_LINKED_AURA_REMOVE_OWNER)
            {
                RemoveAuraFromOwner();
                m_linkedToOwnerAura = 0;                    // we dont need to recheck
            }

        default:
            break;
    }
    
    Creature::Update(update_diff, diff);
}