Example #1
0
        private void OnDamageTaken(IDamagable source, DamageArgs args)
        {
            HitboxID hitboxId    = ((HitReceiver)source).HitboxID;
            float    totalDamage = args.Damage * hitboxMapper[hitboxId].DamageMultiplier;

            Health.TakeDamage(new DamageArgs(args.Origin, args.Dealer, totalDamage));
        }
Example #2
0
        public void TakeDamage(DamageArgs args)
        {
            DamageArgs pointDamageArgs = new DamageArgs(args.Origin, args.Dealer, 1);

            health.TakeDamage(pointDamageArgs);
            DamageTaken?.Invoke(this, pointDamageArgs);
        }
Example #3
0
 private void CallStaticDamaged(DamageArgs args)
 {
     if (Damaged != null)
     {
         Damaged(args);
     }
 }
Example #4
0
    private void takeDamage(object sender, DamageArgs args)
    {
        currentHP      -= args.Damage;
        damageThisTurn += args.Damage;
        float percentage = (float)currentHP / maxHP;

        setSaturation(percentage);
        if (OnHpChange != null)
        {
            OnHpChange(this, new HpChangeArgs(currentHP));
        }

        AnimateArgs animateArgs = new AnimateArgs("CurrentLife");

        animateArgs.F = percentage;

        BroadcastMessage("animateFloat", animateArgs);

        if (currentHP <= 0)
        {
            Destroy(gameObject.GetComponent <OnHurtOverworld>());
            Destroy(gameObject.GetComponent <Jump>());
            Destroy(gameObject.GetComponent <Move>());
            BroadcastMessage("die");
        }
    }
Example #5
0
        private void OnDamageTaken(IDamagable source, DamageArgs args)
        {
            HitReceiver    receiver        = (HitReceiver)source;
            float          angle           = Vector3.Angle(args.Dealer.transform.position, receiver.transform.position);
            var            inverseRotation = Quaternion.Euler(0, 0, angle - 180);
            PositionedArgs effectArgs      = new PositionedArgs(receiver.transform.position, inverseRotation);

            PlayEffects(effectArgs);
        }
Example #6
0
        public void Damage(IEnumerable <IDamagable> damagables)
        {
            DamageArgs damageArgs = new DamageArgs(Origin, gameObject, damage);

            foreach (var damagable in damagables)
            {
                damagable.TakeDamage(damageArgs);
            }
            Damaged?.Invoke(damagables);
        }
Example #7
0
 void onHurt(DamageArgs args)
 {
     if (!isRecovering)
     {
         if (OnIsHurt != null)
         {
             OnIsHurt(this, args);
         }
         gameObject.BroadcastMessage("animateHurt");
         isRecovering = true;
         StartCoroutine(StartRecovery(recoveryTime));
         Rigidbody2D rb = gameObject.GetComponent <Rigidbody2D> ();
         rb.AddForce(args.Collision.contacts [0].normal * -force, ForceMode2D.Impulse);
     }
 }
    /*
     * public void doTargetDamage(DamageAcceptor damageAcceptor, GameObject argInSource, float argInDmg, string argInDamageType, Vector2 argInKnockBack)
     * {
     *  if (damageAcceptor != null)
     *  {
     *      if (((Component)damageAcceptor).gameObject != argInSource)
     *      {
     *              DamageArgs args = new DamageArgs();
     *              args.knockback = argInKnockBack;
     *              args.dmg = argInDmg;
     *              args.source = argInSource;
     *              args.type = argInDamageType;
     *
     *              damageAcceptor.acceptDamage(args);
     *      }
     *  }
     * }*/

    public void doTargetDamage(DamageAcceptor damageAcceptor, GameObject argInSource, float argInDmg, string argInDamageType, Vector2 argInKnockBack /*,  List<string> argInIgnoreGroups*/)
    {
        if (damageAcceptor != null)
        {
            if (((Component)damageAcceptor).gameObject != argInSource)
            {
                //if (!(damageAcceptor.groups.Intersect(argInIgnoreGroups).Any()))
                {
                    DamageArgs args = new DamageArgs();
                    args.knockback = argInKnockBack;
                    args.dmg       = argInDmg;
                    args.source    = argInSource;
                    args.type      = argInDamageType;

                    damageAcceptor.acceptDamage(args);
                }
            }
        }
    }
    public void doAreaDamage(GameObject argInSource, Vector2 argInCentralPoint, float argInAffectRadius, float argInDmg, string argInDamageType, float argInKnockBack)
    {
        foreach (DamageAcceptor damageAcceptor in damageAcceptors.ToList())
        {
            //if (((Component)damageAcceptor).gameObject != argInSource)
            {
                if (Vector2.Distance(((Component)damageAcceptor).gameObject.transform.position, argInCentralPoint) < argInAffectRadius)
                {
                    DamageArgs args = new DamageArgs();
                    args.knockback =
                        (((Vector2)((Component)damageAcceptor).gameObject.transform.position) - argInCentralPoint).normalized
                        * argInKnockBack
                        * (1 - (((Vector2)((Component)damageAcceptor).gameObject.transform.position) - argInCentralPoint).magnitude / argInAffectRadius);
                    args.dmg    = argInDmg;
                    args.source = argInSource;
                    args.type   = argInDamageType;

                    damageAcceptor.acceptDamage(args);
                }
            }
        }
    }
Example #10
0
 public void TakeDamage(DamageArgs args)
 {
     UpdateHealth(args.Origin, args.Dealer, -args.Damage);
     DamageTaken?.Invoke(this, args);
 }
Example #11
0
 public DeathArgs(DamageArgs dmg, GameObject victim)
 {
     Damage = dmg;
     Victim = victim;
 }
Example #12
0
 public void TakeDamage(DamageArgs args) => DamageTaken?.Invoke(this, args);
Example #13
0
 private void OnDamageTaken(IDamagable damagable, DamageArgs args) => UpdateHealthUI();