예제 #1
0
    public void MonsterSet(int _maxlife, int _baseDamage)
    {
        isAlive     = true;
        isHited     = false;
        moveAble    = true;
        maxLife     = _maxlife;
        currentLife = maxLife;
        baseDamage  = _baseDamage;

        currentDisTanceArray  = new float[player.Length];
        aggroRank             = new float[player.Length];
        playerToMonsterDamage = new float[player.Length];

        animator  = this.gameObject.GetComponent <Animator> ();
        HittedBox = this.gameObject.GetComponent <BoxCollider> ();

        StartCoroutine(LookatChange());

        if (attackCollider != null)
        {
            attackCollider = this.transform.GetComponentInChildren <MonsterWeapon> ();
            attackCollider.MonsterWeaponSet();
        }
        if (shockWaveInstantiate != null)
        {
            shockWaveInstantiate.GetDamage(baseDamage, this.gameObject.GetComponent <ShockWaveMonster> ());
        }
        if (shockWaveInstantiate != null || attackCollider != null)
        {
            //NormalMonsterRealizePattern ();
            //bossmonsterWeapon damageGet;
        }
    }
예제 #2
0
        private void PhysicalAttack(Player player)
        {
            int attackAmount = 0;

            try {
                if (MonsterWeapon.Equipped && MonsterWeapon.WeaponGroup != WeaponType.Bow)
                {
                    attackAmount += MonsterWeapon.Attack();
                }
                if (MonsterWeapon.Equipped &&
                    MonsterWeapon.WeaponGroup == WeaponType.Bow &&
                    MonsterQuiver.HaveArrows())
                {
                    MonsterQuiver.UseArrow();
                    attackAmount += MonsterWeapon.Attack();
                }
                if (MonsterWeapon.Equipped &&
                    MonsterWeapon.WeaponGroup == WeaponType.Bow &&
                    !MonsterQuiver.HaveArrows())
                {
                    attackAmount += UnarmedAttackDamage;
                }
            } catch (NullReferenceException) {
                if (MonsterCategory == MonsterType.Elemental)
                {
                    attackAmount += UnarmedAttackDamage;
                }
                else
                {
                    string monsterDisarmed = $"The {Name} is disarmed! They are going hand to hand!";
                    OutputHelper.Display.StoreUserOutput(
                        Settings.FormatFailureOutputText(),
                        Settings.FormatDefaultBackground(),
                        monsterDisarmed);
                    attackAmount += UnarmedAttackDamage;
                }
            }

            int    randomChanceToHit = GameHelper.GetRandomNumber(1, 100);
            double chanceToDodge     = player.DodgeChance;

            if (chanceToDodge > 50)
            {
                chanceToDodge = 50;
            }

            if (randomChanceToHit <= chanceToDodge)
            {
                string missString = $"The {Name} missed you!";
                OutputHelper.Display.StoreUserOutput(
                    Settings.FormatAttackFailText(),
                    Settings.FormatDefaultBackground(),
                    missString);
                return;
            }

            int baseAttackAmount = attackAmount;

            foreach (IEffect effect in player.Effects.Where(effect => effect.IsEffectExpired is false).ToList())
            {
                if (effect is FrozenEffect frozenEffect)
                {
                    attackAmount = frozenEffect.GetIncreasedDamageFromFrozen(attackAmount);

                    frozenEffect.ProcessRound();
                }

                if (effect is ChangeMonsterDamageEffect changeMonsterDmgEffect)
                {
                    attackAmount = changeMonsterDmgEffect.GetUpdatedDamageFromChange(attackAmount);

                    changeMonsterDmgEffect.ProcessChangeMonsterDamageRound(player);
                }

                if (effect is IChangeDamageEffect changeDamageEffect)
                {
                    int incomingDamage = attackAmount;

                    attackAmount = changeDamageEffect.GetChangedDamageFromEffect(incomingDamage);

                    changeDamageEffect.ProcessChangeDamageRound(incomingDamage);
                }

                if (baseAttackAmount > attackAmount && attackAmount - player.ArmorRating(this) <= 0)
                {
                    string effectAbsorbString = $"Your {effect.Name} absorbed all of {Name}'s attack!";
                    OutputHelper.Display.StoreUserOutput(
                        Settings.FormatAttackFailText(),
                        Settings.FormatDefaultBackground(),
                        effectAbsorbString);
                    return;
                }

                GameHelper.RemovedExpiredEffectsAsync(this);
            }

            if (attackAmount - player.ArmorRating(this) <= 0)
            {
                string armorAbsorbString = $"Your armor absorbed all of {Name}'s attack!";
                OutputHelper.Display.StoreUserOutput(
                    Settings.FormatAttackFailText(),
                    Settings.FormatDefaultBackground(),
                    armorAbsorbString);
            }
            else if (attackAmount - player.ArmorRating(this) > 0)
            {
                attackAmount -= player.ArmorRating(this);
                string hitString = $"The {Name} hits you for {attackAmount} physical damage.";
                OutputHelper.Display.StoreUserOutput(
                    Settings.FormatAttackSuccessText(),
                    Settings.FormatDefaultBackground(),
                    hitString);
                player.HitPoints -= attackAmount;
            }
        }