Esempio n. 1
0
 public ActorAttack(ActorAttackType attackType, int range, int dps)
 {
     this.ActorAttackType = attackType;
     this.AttackRange     = range;
     this.ViewDistance    = 200;
     this.Dps             = dps;
 }
Esempio n. 2
0
 public void SetDetails(IBsActor actor, int health, bool isDead, int level, ActorAttackType type,
                        BsFaction factions)
 {
     DetailsView.Id.text         = "Player: " + actor.Id().ToString();
     DetailsView.Attack.text     = "Attack: " + actor.Config().BaseDamage().ToString();
     DetailsView.Heal.text       = "Heal: " + actor.Config().BaseHealing().ToString();
     DetailsView.Helth.text      = "Helth: " + health.ToString();
     DetailsView.Level.text      = "Level: " + level.ToString();
     DetailsView.Dead.text       = "Is Dead: " + isDead.ToString();
     DetailsView.AttackType.text = "Type: " + type.ToString();
     DetailsView.Factions.text   = "Factions: " + factions.ToString();
 }
Esempio n. 3
0
    public Damage CalculateCommonAttackDamage(BaseGameEntity targetEntity)
    {
        Damage damage = new Damage();

        damage.DamageValue = this.MyActor.ActorAttack.Dps / this.AttackInterval;
        //Debug.Log("Damage " + damage.DamageValue);
        damage.DamageValue *= this.AttackPlusRatio;
        //Debug.Log("After plus Ratio " + damage.DamageValue);
        if (!(targetEntity is ActorController))
        {
            return(damage);
        }

        ActorController targetActor = (ActorController)targetEntity;
        ActorSpell      dodgeSpell  = targetActor.MyActor.GetSpell(ActorSpellName.Dodge);

        if (dodgeSpell != null)
        {
            int randomIndex = Random.Range(1, 101);
            if (targetActor.MyActor.ActorType == ActorType.Supporter && randomIndex <= 15)
            {
                this.ShowTip("Miss");
                damage.DamageValue = 0;
                return(damage);
            }
        }

        Dictionary <ActorSpellName, ActorSpell> passiveSpellDictionary =
            this.MyActor.GetSpellsByType(ActorSpellType.PassiveSpell);

        if (passiveSpellDictionary != null)
        {
            foreach (KeyValuePair <ActorSpellName, ActorSpell> kv in passiveSpellDictionary)
            {
                switch (kv.Key)
                {
                case ActorSpellName.None:
                    break;

                case ActorSpellName.CirticalStrike:
                {
                    if (Random.Range(1, 101) <= 10)
                    {
                        //Debug.Log("致命一击");
                        damage.DamageValue   *= 1.5f;
                        damage.ShowCrit       = true;
                        damage.ActorSpellName = ActorSpellName.CirticalStrike;
                        //Debug.Log("After Cirtical Strike " + damage.DamageValue);
                    }
                    break;
                }

                case ActorSpellName.HeadShot:
                {
                    if (Random.Range(1, 101) <= 40)
                    {
                        damage.DamageValue   *= 3f;
                        damage.ShowCrit       = true;
                        damage.ActorSpellName = ActorSpellName.HeadShot;
                        //Debug.Log("After HeadShot" + damage.DamageValue);
                    }
                    break;
                }

                case ActorSpellName.SplashDamage:
                {
                    List <GameObject> enemies = targetActor.SeekAndGetFriendlyActorsInDistance(100);
                    if (enemies != null && enemies.Count != 0)
                    {
                        Damage splashDamage = new Damage();
                        splashDamage.DamageValue = 0.5f * damage.DamageValue;
                        //Debug.Log("splash Damage " + splashDamage.DamageValue);
                        enemies.ForEach(
                            enemy =>
                            {
                                if (enemy != null && enemy != targetActor.gameObject)
                                {
                                    ActorController actorCtrl = enemy.GetComponent <ActorController>();
                                    if (actorCtrl != null &&
                                        actorCtrl.gameObject != this.TargetEnemy.gameObject)
                                    {
                                        this.SendDamage(actorCtrl, splashDamage);
                                    }
                                }
                            });
                    }
                    break;
                }

                case ActorSpellName.Bleed:
                {
                    if (this.MyActor.ActorType == ActorType.GryphonRider)
                    {
                        if (Random.Range(1, 101) <= 25)
                        {
                            //Debug.Log("Bleed");
                            damage.Bleed         = true;
                            damage.BleedDuration = 3;
                            damage.BleedDps      = 15;
                        }
                    }
                    else if (this.MyActor.ActorType == ActorType.SeniorGryphonRider)
                    {
                        if (Random.Range(1, 101) <= 30)
                        {
                            damage.Bleed         = true;
                            damage.BleedDuration = 5;
                            damage.BleedDps      = 20;
                        }
                    }
                    break;
                }

                case ActorSpellName.Bash:
                {
                    if (this.MyActor.ActorType == ActorType.Crusader)
                    {
                        if (Random.Range(1, 101) <= 20)
                        {
                            //Debug.Log("重击");
                            damage.Stun         = true;
                            damage.StunDuration = 2;
                            damage.DamageValue += 25;
                            damage.ShowCrit     = true;
                        }
                    }
                    else if (this.MyActor.ActorType == ActorType.TemplarWarrior)
                    {
                        if (Random.Range(1, 101) <= 25)
                        {
                            //Debug.Log("重击");
                            damage.Stun         = true;
                            damage.StunDuration = 2;
                            damage.DamageValue += 30;
                            damage.ShowCrit     = true;
                        }
                    }
                    break;
                }

                case ActorSpellName.ChainLightning:
                {
                    if (this.MyActor.ActorType == ActorType.Sage)
                    {
                        if (Random.Range(1, 101) <= 25 && targetActor != null)
                        {
                            //Debug.Log("闪电链");
                            List <GameObject> enemies = this.SeekAndGetEnemiesInDistance(150);
                            if (enemies != null && enemies.Count != 0)
                            {
                                int attackCount = Mathf.Min(enemies.Count, 4);
                                for (int i = 0; i < attackCount; i++)
                                {
                                    GameObject enemy = enemies[i];
                                    if (enemy != null)
                                    {
                                        GameObject chainLightningEffectA =
                                            (GameObject)
                                            Instantiate(Resources.Load("GameScene/ActorSkillEffect"));
                                        chainLightningEffectA.name = "ChainLightningEffectA";
                                        chainLightningEffectA.transform.position = this.myTransform.position;
                                        this.SetRotation(chainLightningEffectA, enemy.transform.position);
                                        float scale = Vector3.Distance(
                                            this.myTransform.position,
                                            enemy.transform.position) / 32f;
                                        chainLightningEffectA.transform.localScale = new Vector3(scale, 1, 1);
                                        tk2dSpriteAnimator animator =
                                            chainLightningEffectA.GetComponent <tk2dSpriteAnimator>();
                                        animator.Play("ChainLightningA");
                                        animator.AnimationCompleted = delegate
                                        {
                                            Destroy(chainLightningEffectA);
                                            if (enemy != null)
                                            {
                                                Damage chainLightningDamage = new Damage();
                                                chainLightningDamage.DamageValue = 200;
                                                chainLightningDamage.ShowCrit    = true;
                                                this.SendDamage(enemy.GetComponent <ActorController>(), chainLightningDamage);
                                            }
                                        };
                                    }
                                }
                            }
                        }
                    }
                    break;
                }

                case ActorSpellName.FireBomb:
                {
                    //Debug.Log("燃烧弹 " + targetActor);
                    if (targetActor != null && !targetActor.FireBombAttacked)
                    {
                        if (this.MyActor.ActorType == ActorType.BatRider)
                        {
                            targetActor.AttackInterval *= 1.6f;
                            targetActor.MyActor.ActorArmor.ArmorAmount =
                                Mathf.Max(targetActor.MyActor.ActorArmor.ArmorAmount - 3, 0);
                            targetActor.FireBombAttacked = true;
                        }
                        else if (this.MyActor.ActorType == ActorType.SeniorBatRider)
                        {
                            targetActor.AttackInterval *= 1.6f;
                            targetActor.MyActor.ActorArmor.ArmorAmount =
                                Mathf.Max(targetActor.MyActor.ActorArmor.ArmorAmount - 6, 0);
                            targetActor.FireBombAttacked = true;
                        }
                    }
                    break;
                }

                case ActorSpellName.PoisonAttack:
                {
                    //Debug.Log("毒液攻击" + targetActor);
                    if (targetActor != null && !targetActor.IsPoisioning)
                    {
                        if (this.MyActor.ActorType == ActorType.Wyvern)
                        {
                            targetActor.PoisionDps   = 3;
                            targetActor.IsPoisioning = true;
                        }
                        else if (this.MyActor.ActorType == ActorType.WindRider)
                        {
                            targetActor.PoisionDps   = 5;
                            targetActor.IsPoisioning = true;
                        }
                    }
                    break;
                }

                case ActorSpellName.BurningOil:
                {
                    //Debug.Log("燃烧之油" + targetActor);
                    if (targetActor != null && !targetActor.isBurningOilAttacked)
                    {
                        if (this.MyActor.ActorType == ActorType.Catapult)
                        {
                            targetActor.BurningOilDps        = 48;
                            targetActor.BurningOilDuration   = 3;
                            targetActor.IsBurningOilAttacked = true;
                        }
                    }
                    break;
                }

                case ActorSpellName.Smash:
                {
                    //Debug.Log("粉碎 " + targetActor);
                    if (targetActor != null)
                    {
                        if (this.MyActor.ActorType == ActorType.Tauren && Random.Range(1, 101) <= 25)
                        {
                            List <GameObject> enemies = targetActor.SeekAndGetFriendlyActorsInDistance(120);
                            if (enemies != null && enemies.Count != 0)
                            {
                                Damage splashDamage = new Damage();
                                splashDamage.DamageValue = 0.6f * damage.DamageValue;
                                splashDamage.ShowCrit    = true;
                                //Debug.Log("splash Damage " + splashDamage.DamageValue);
                                enemies.ForEach(
                                    enemy =>
                                    {
                                        if (enemy != null && enemy != targetActor.gameObject)
                                        {
                                            ActorController actorCtrl =
                                                enemy.GetComponent <ActorController>();
                                            if (actorCtrl != null)
                                            {
                                                this.SendDamage(actorCtrl, splashDamage);
                                            }
                                        }
                                    });
                            }
                        }
                    }
                    break;
                }
                }
            }
        }

        ActorAttackType actorAttackType = this.MyActor.ActorAttack.ActorAttackType;

        switch (actorAttackType)
        {
        case ActorAttackType.Normal:
        {
            if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.LightArmor)
            {
                damage.DamageValue *= 0.9f;
            }
            else if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.HeavyArmor)
            {
                damage.DamageValue *= 0.8f;
            }
            else if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.HeroArmor)
            {
                damage.DamageValue *= 1;
            }
            break;
        }

        case ActorAttackType.Pierce:
        {
            ActorSpell parrySpell = targetActor.MyActor.GetSpell(ActorSpellName.Parry);
            if (parrySpell != null)
            {
                damage.DamageValue *= 0.7f;
            }

            if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.LightArmor)
            {
                damage.DamageValue *= 2f;
            }
            else if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.HeavyArmor)
            {
                damage.DamageValue *= 0.35f;
            }
            else if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.HeroArmor)
            {
                damage.DamageValue *= 0.5f;
            }
            break;
        }

        case ActorAttackType.Siege:
        {
            if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.LightArmor)
            {
                damage.DamageValue *= 1f;
            }
            else if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.HeavyArmor)
            {
                damage.DamageValue *= 1.5f;
            }
            else if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.HeroArmor)
            {
                damage.DamageValue *= 0.5f;
            }
            break;
        }

        case ActorAttackType.Magic:
        {
            if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.LightArmor)
            {
                damage.DamageValue *= 1.25f;
            }
            else if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.HeavyArmor)
            {
                damage.DamageValue *= 2f;
            }
            else if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.HeroArmor)
            {
                damage.DamageValue *= 0.35f;
            }
            break;
        }

        case ActorAttackType.Confuse:
        {
            if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.LightArmor)
            {
                damage.DamageValue *= 1f;
            }
            else if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.HeavyArmor)
            {
                damage.DamageValue *= 1f;
            }
            else if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.HeroArmor)
            {
                damage.DamageValue *= 1f;
            }
            break;
        }

        case ActorAttackType.HeroAttack:
        {
            if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.LightArmor)
            {
                damage.DamageValue *= 1.2f;
            }
            else if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.HeavyArmor)
            {
                damage.DamageValue *= 1.2f;
            }
            else if (targetActor.MyActor.ActorArmor.ActorArmorType == ActorArmorType.HeroArmor)
            {
                damage.DamageValue *= 1f;
            }
            break;
        }
        }
        //Debug.Log("After armor " + damage.DamageValue);
        return(damage);
    }