Example #1
0
        public override double Fight(Character opponant)
        {
            var mageHunterDamage = (opponant.Magic > 0) ? 1 : 0;
            var birdBonus        = 1;

            var damageCaused     = 0;
            var actionsRemaining = Actions;

            while (actionsRemaining > 0)
            {
                actionsRemaining--;

                var hit = opponant.TakeHit(AttackType.Ranged, Accuracy + Rules.AimingBonus + birdBonus);

                var damageSpread = new DamageExpression[4] {
                    new DamageExpression(0),
                    new DamageExpression(2 + mageHunterDamage),
                    new DamageExpression(1, DiceShape.D4, 1 + mageHunterDamage),
                    new DamageExpression(1, DiceShape.D4, 3 + mageHunterDamage)
                };

                damageCaused += opponant.TakeDamage(AttackType.Ranged, hit, damageSpread);
            }

            return((double)damageCaused / opponant.Health * 100);
        }
Example #2
0
        public override double Fight(Character opponant)
        {
            var damageCaused     = 0;
            var actionsRemaining = Actions;

            while (actionsRemaining > 0)
            {
                if (actionsRemaining <= 1)
                {
                    break;
                }

                actionsRemaining -= 2;

                var hit = opponant.TakeHit(AttackType.Melee, Might);

                var damageSpread = new DamageExpression[4] {
                    new DamageExpression(0),
                    new DamageExpression(2, DiceShape.D4),
                    new DamageExpression(2, DiceShape.D4, 1),
                    new DamageExpression(2, DiceShape.D4, 3)
                };

                damageCaused += opponant.TakeDamage(AttackType.Melee, hit, damageSpread);
            }

            damageCaused += DiceRoller.Roll(DiceShape.D4, 2);

            return((double)damageCaused / opponant.Health * 100);
        }
Example #3
0
        public override double Fight(Character opponant)
        {
            var damageCaused     = 0;
            var actionsRemaining = Actions;

            while (actionsRemaining > 0)
            {
                actionsRemaining--;

                var hit = opponant.TakeHit(AttackType.Melee, Might);
                if (hit != AttackResult.Miss)
                {
                    opponant.ApplyEffect(Effect.Poison);
                }

                var damageSpread = new DamageExpression[4] {
                    new DamageExpression(0),
                    new DamageExpression(1),
                    new DamageExpression(1, DiceShape.D4),
                    new DamageExpression(1, DiceShape.D4, 2)
                };

                damageCaused += opponant.TakeDamage(AttackType.Melee, hit, damageSpread);
            }

            if (opponant.Effects.Contains(Effect.Poison))
            {
                damageCaused += DiceRoller.Roll(DiceShape.D6, 2);
            }

            return((double)damageCaused / opponant.Health * 100);
        }
Example #4
0
        public override double Fight(Character opponant)
        {
            var damageCaused = 0;

            var actionsRemaining = Actions;

            while (actionsRemaining > 0)
            {
                actionsRemaining--;

                var hit = opponant.TakeHit(AttackType.Magic, Magic);

                var damageSpread = new DamageExpression[4] {
                    new DamageExpression(0),
                    new DamageExpression(2),
                    new DamageExpression(1, DiceShape.D6, 1),
                    new DamageExpression(1, DiceShape.D6, 2)
                };

                damageCaused += opponant.TakeDamage(AttackType.Magic, hit, damageSpread, true);
            }

            damageCaused += DiceRoller.Roll(DiceShape.D6, opponant.Resilience);

            return((double)damageCaused / opponant.Health * 100);
        }
Example #5
0
        public override double Fight(Character opponant)
        {
            var damageCaused     = 0;
            var actionsRemaining = Actions;

            while (actionsRemaining > 0)
            {
                actionsRemaining--;

                var hit = opponant.TakeHit(AttackType.Magic, Magic);

                var damageSpread = new DamageExpression[4] {
                    new DamageExpression(0),
                    new DamageExpression(2),
                    new DamageExpression(1, DiceShape.D4, 1),
                    new DamageExpression(1, DiceShape.D4, 3)
                };

                damageCaused += opponant.TakeDamage(AttackType.Magic, hit, damageSpread);
            }

            actionsRemaining = 2;

            while (actionsRemaining > 0)
            {
                actionsRemaining--;

                var hit = opponant.TakeHit(AttackType.Melee, Might);

                var damageSpread = new DamageExpression[4] {
                    new DamageExpression(0),
                    new DamageExpression(1),
                    new DamageExpression(2),
                    new DamageExpression(3)
                };

                damageCaused += opponant.TakeDamage(AttackType.Melee, hit, damageSpread);
            }

            return((double)damageCaused / opponant.Health * 100);
        }
Example #6
0
        public override double Fight(Character opponant)
        {
            var shouldCharge = true;
            var rage         = 0;

            var damageCaused     = 0;
            var actionsRemaining = Actions;

            while (actionsRemaining > 0)
            {
                bool charged = false;
                if (shouldCharge && actionsRemaining == Actions)
                {
                    charged = true;
                    rage   += 1;
                    actionsRemaining--;
                }

                actionsRemaining--;

                var hit = opponant.TakeHit(AttackType.Melee, Might + (charged ? Rules.ChargeBonus : 0));
                if (hit == AttackResult.Critical)
                {
                    rage += 1;
                }

                var damageSpread = new DamageExpression[4] {
                    new DamageExpression(0),
                    new DamageExpression(2),
                    new DamageExpression(1, DiceShape.D6, 1),
                    new DamageExpression(1, DiceShape.D6, 2)
                };

                damageCaused += opponant.TakeDamage(AttackType.Melee, hit, damageSpread);
            }

            damageCaused += DiceRoller.Roll(DiceShape.D6, rage);

            return((double)damageCaused / opponant.Health * 100);
        }
        public override double Fight(Character opponant)
        {
            var damageCaused = 0;

            var actionsRemaining = Actions;

            while (actionsRemaining > 0)
            {
                actionsRemaining--;

                var hit = opponant.TakeHit(AttackType.Ranged, Accuracy);

                var damageSpread = new DamageExpression[4] {
                    new DamageExpression(0),
                    new DamageExpression(1),
                    new DamageExpression(1, DiceShape.D4),
                    new DamageExpression(1, DiceShape.D4, 2)
                };

                damageCaused += opponant.TakeDamage(AttackType.Ranged, hit, damageSpread);
            }

            return((double)damageCaused / opponant.Health * 100);
        }