Example #1
0
        private int CalcDamage(DealDamage damage)
        {
            // First check for immunities, then resistance, then vulnerability (p. 197 Player's Handbook)
            if (Immunities.Contains(damage.DamageType))
            {
                return(0);
            }

            int actualHpDamage = damage.Hp;

            // Resistances and vulnerabilities do not stack, so one does as much as multiple.
            if (Resistances.Contains(damage.DamageType))
            {
                actualHpDamage /= 2; // integer division correctly rounds down
            }

            // It is technically possible to have a resistance and a vulnerability for the same damage type.
            // https://rpg.stackexchange.com/a/167448
            if (Vulnerabilities.Contains(damage.DamageType))
            {
                actualHpDamage *= 2;
            }

            return(actualHpDamage);
            // Possible future refactor: It's a little bit inefficient to check all of the
            // lists every time, especially since this function is called from in a loop.
        }
Example #2
0
 public bool IsImmune(ImmunityType type)
 {
     if (Immunities == null)
     {
         return(false);
     }
     return(Immunities.Contains(type));
 }
Example #3
0
 public int HowMuchWouldYouHitMe(Group s)
 {
     if (Immunities.Contains(s.AttackType))
     {
         return(0);
     }
     else if (Weaknesses.Contains(s.AttackType))
     {
         return(s.EffectivePower * 2);
     }
     {
         return(s.EffectivePower);
     }
 }
        public int CalculateDamageDone(string incomingAttackType, int effectivePower)
        {
            if (Immunities != null && Immunities.Contains(incomingAttackType))
            {
                return(0);
            }

            if (Weaknesses != null && Weaknesses.Contains(incomingAttackType))
            {
                return(effectivePower * 2);
            }

            return(effectivePower);
        }
Example #5
0
        /// <summary>
        /// Calculate Damage amount from damage and DamageType
        /// Taking into consideration Resistances and Immunities
        /// </summary>
        /// <param name="damage"></param>
        /// <param name="damageType"></param>
        /// <returns></returns>
        public int CalculateDamage(int damage, DamageType damageType)
        {
            double totalDamage = 0d;

            if (Resistances.Contains(damageType))
            {
                totalDamage = Math.Floor((double)damage / 2d);
            }
            else if (Immunities.Contains(damageType))
            {
            }
            else
            {
                totalDamage = damage;
            }

            return(Convert.ToInt32(totalDamage));
        }
Example #6
0
            public int GetDamage(BattleGroup attackingGroup)
            {
                if (attackingGroup.Type == Type)
                {
                    return(0);
                }

                int damage = attackingGroup.EffectivePower;

                if (Immunities.Contains(attackingGroup.AttackType))
                {
                    damage = 0;
                }
                if (Weaknesses.Contains(attackingGroup.AttackType))
                {
                    damage *= 2;
                }
                return(damage);
            }
Example #7
0
 private bool IsImmune(DamageType damageType)
 {
     return(Immunities.Contains(damageType));
 }
Example #8
0
        public int CalculateHitPointChange(List <DamageSet> damageSets)
        {
            int hpChange = 0;

            List <DamageSet> damageDone = new List <DamageSet>();

            foreach (DamageSet damageSet in damageSets)
            {
                damageDone.Add(new DamageSet(damageSet));
            }

            List <DamageReduction> damageReductions = DamageReductions.ToList();

            damageReductions.Sort((dr1, dr2) => dr2.Value.CompareTo(dr1.Value));

            List <EnergyResistance> energyResistances = EnergyResistances.ToList();

            foreach (DamageSet damageSet in damageDone)
            {
                foreach (EnergyResistance energyResistance in energyResistances)
                {
                    if (damageSet.DamageDescriptorSet.IsEnergyDamage() &&
                        damageSet.DamageDescriptorSet.Contains(energyResistance.EnergyType))
                    {
                        int numEnergyTypes   = damageSet.DamageDescriptorSet.Count;
                        int thisEnergyDamage = damageSet.Amount / numEnergyTypes;
                        int thisEnergyDamageAfterResistance = thisEnergyDamage - energyResistance.Value;
                        if (thisEnergyDamageAfterResistance < 0)
                        {
                            thisEnergyDamageAfterResistance = 0;
                        }

                        int difference = thisEnergyDamage - thisEnergyDamageAfterResistance;
                        damageSet.Amount -= difference;

                        if (damageSet.Amount < 0)
                        {
                            damageSet.Amount = 0;
                        }
                    }
                }
            }

            foreach (DamageSet damageSet in damageDone)
            {
                if (damageSet.DamageDescriptorSet.IsTyped())
                {
                    foreach (Types.Damage damageType in damageSet.DamageDescriptorSet.ToList())
                    {
                        if (Immunities.Contains(damageType))
                        {
                            damageSet.Amount = 0;
                        }
                    }

                    foreach (DamageReduction dr in damageReductions)
                    {
                        if (!dr.IsBypassedBy(damageSet.DamageDescriptorSet))
                        {
                            damageSet.Amount -= dr.Value;
                            break;
                        }
                    }

                    if (damageSet.Amount < 0)
                    {
                        damageSet.Amount = 0;
                    }
                }
            }

            foreach (DamageSet damageSet in damageDone)
            {
                hpChange -= damageSet.Amount;
            }

            return(hpChange);
        }
Example #9
0
 public bool IsImmuneTo(Attack attack) => Immunities.Contains(attack);