public void Damage(DamageType type, IDamageMaker damageMaker, BaseCharacterBehavior source)
 {
     if (damageHandler != null)
     {
         damageHandler(type, damageMaker, source);
     }
 }
Esempio n. 2
0
    private void Tower_damageHandler(DamageType type, IDamageMaker damageMaker, BaseCharacterBehavior source)
    {
        bool  isCritical;
        float addHit;
        float dmg = damageMaker.GetCurDamage(type, out isCritical, out addHit);

        hp.CurValue -= dmg;
        ht.SetText((int)dmg * -1, isCritical, false);
        source.CurrentMakeDamage += dmg;
    }
Esempio n. 3
0
    protected virtual void Build_damageHandler(DamageType type, IDamageMaker damageMaker, BaseCharacterBehavior source)
    {
        bool  isCritical;
        float addHit;
        float dmg = damageMaker.GetCurDamage(type, out isCritical, out addHit) * (1 - DamageReduce);

        hp.CurValue -= dmg;
        ht.SetText((int)dmg * -1, isCritical, false);
        source.CurrentMakeDamage += dmg;
    }
Esempio n. 4
0
        private void OnCollisionEnter2D(Collision2D other)
        {
            if (!IsAlive)
            {
                return;
            }
            IDamageMaker hit = other.gameObject.GetComponent <IDamageMaker>();

            if (hit != null)
            {
                GetHit(hit.MakeDamage());
            }
        }
Esempio n. 5
0
    protected override void Build_damageHandler(DamageType type, IDamageMaker damageMaker, BaseCharacterBehavior source)
    {
        NPCController highestHPStationer = null;

        for (int i = 0; i < stationNPC.Length; i++)
        {
            if (stationNPC[i] != null && (highestHPStationer == null ||
                                          stationNPC[i].status.GetConsumedAttrubute(ConsumedAttributeName.Health).CurValue >
                                          highestHPStationer.status.GetConsumedAttrubute(ConsumedAttributeName.Health).CurValue))
            {
                highestHPStationer = stationNPC[i];
            }
        }
        if (highestHPStationer != null)
        {
            highestHPStationer.Damage(type, damageMaker, source);
        }
        else
        {
            base.Build_damageHandler(type, damageMaker, source);
        }
    }
    public void Damage(DamageType type, IDamageMaker damageMaker, BaseCharacterBehavior source, bool triggerEvent)
    {
        if (IsDead)
        {
            return;
        }
        bool  isCritical;
        float additionHit;
        float mount = damageMaker.GetCurDamage(type, out isCritical, out additionHit);

        if (mount == 0)
        {
            return;
        }
        float damage = 0;

        if (type == DamageType.Nature)
        {
            damage = mount;
        }
        else
        {
            //Calculate hit
            float dodge    = status.GetSecondaryAttrubute(SecondaryAttributeName.Dodge).AdjustedValue;
            int   dodgeRnd = Random.Range(0, 1000);
            if (type != DamageType.Magic && dodgeRnd < dodge)
            {
                //Miss
                if (dodge > additionHit)
                {
                    ht.SetText("Miss!!");
                    return;
                }
            }
            float deffence = 0;
            switch (type)
            {
            case DamageType.Physical:
                deffence = status.GetSecondaryAttrubute(SecondaryAttributeName.PhysicalDeffence)
                           .AdjustedValue;
                break;

            case DamageType.Skill:
                deffence = status.GetSecondaryAttrubute(SecondaryAttributeName.SkillDeffence)
                           .AdjustedValue;
                break;

            case DamageType.Magic:
                deffence = status.GetSecondaryAttrubute(SecondaryAttributeName.MagicalDeffence)
                           .AdjustedValue;
                break;
            }
            //def 300 => 1-300/600 => .5f, def 1000=>1- 1000/1300=> .23f
            damage  = mount * (1 - deffence / (deffence + 300));
            damage *= status.GetStaticAttribute(StaticAttributeName.DamageTakeFix).AdjustedValue;
        }
        CurrentTakeDamage        += damage;
        source.CurrentMakeDamage += damage;
        ConsumedAttribute health = status.GetConsumedAttrubute(ConsumedAttributeName.Health);

        health.CurValue -= damage >= 1 ? damage : 1;
        if (isCritical)
        {
            ht.SetText((int)damage * -1, true);
        }
        else
        {
            if (damageColloctEnable)
            {
                DamageCounterInDelta += damage;
            }
            else
            {
                damageColloctEnable = true;
                ht.SetText((int)damage * -1);
            }
        }

        if (health.CurValue <= 0)
        {
            Dead();
        }
        else
        {
            if (triggerEvent && OnDamaged != null)
            {
                OnDamaged(mount, type, damage, this, source);
            }
        }
    }
 public void Damage(DamageType type, IDamageMaker damageMaker, BaseCharacterBehavior source)
 {
     Damage(type, damageMaker, source, true);
 }