public static DamageResult RollFTDamage(IDiceUtility roller, int numberOfDice, int drm = 0, int targetScreenRating = 0, bool dealPenetrating = false, int recursionDepth = 0)
        {
            var indent           = string.Empty.PadRight(4 * recursionDepth);
            var penetrationCount = 0;
            var damageResult     = new DamageResult();

            var diceRolled = roller.RollStandardDice(numberOfDice);
            var rolls      = diceRolled.ToList().OrderByDescending(v => v);

/*
 *          Console.WriteLine(
 * $@"{indent}[Rolled {numberOfDice}] dice
 * with DRM {drm}, screen {targetScreenRating}{(dealPenetrating ? ", penetrating" : ", non-penetrating")}
 * : {string.Join(",", rolls)}");
 */
            foreach (var roll in rolls)
            {
                var dieDamage = CountSuccessesOnRoll(roll, drm, targetScreenRating);
                damageResult.StandardRolls.Add(roll);

                if (dieDamage > 0)
                {
                    // Console.WriteLine($"{indent}Roll of {roll} deals {dieDamage} damage");
                    damageResult.Standard += dieDamage;

                    if (roll >= Constants.MinRollForDoubleSuccess && dealPenetrating)
                    {
                        penetrationCount++;
                    }
                }

                // Exit early if dieDamage == 0, since dice are sorted in descending order?
            }

            if (penetrationCount > 0)
            {
                // Console.WriteLine($"{indent}Rolling {penetrationCount} penetrating dice: [");

                // On a "natural" max roll, deal recursive, shield-ignoring, DRM-ignoring, penetrating followup damage
                var penetrationFollowup = FullThrustDieRolls.RollFTDamage(roller, penetrationCount, 0, 0, true, recursionDepth + 1);
                damageResult.Penetrating += penetrationFollowup.Standard;

                // Penetrating damage could ITSELF penetrate, but it all rolls up to just one count of penetrating damage
                // TODO: revisit this; what about the case of multiple layers of armor + multiple penetrating recursions?
                damageResult.Penetrating += penetrationFollowup.Penetrating;

                damageResult.PenetratingRolls.AddRange(penetrationFollowup.StandardRolls);
                damageResult.PenetratingRolls.AddRange(penetrationFollowup.PenetratingRolls);
            }

            return(damageResult);
        }
        public static int RollFTSuccesses(IDiceUtility roller, int numberOfDice, out IEnumerable <int> rolls, int drm = 0, int difficultyLevel = 0)
        {
            if (numberOfDice == 0)
            {
                rolls = new List <int>();
                return(0); // No successes possible if no dice rolled!
            }

            int    successes  = 0;
            string expression = $"{numberOfDice}D6";

            rolls = roller.RollStandardDice(numberOfDice).OrderByDescending(i => i);

            foreach (int roll in rolls)
            {
                successes += CountSuccessesOnRoll(roll, drm, difficultyLevel);
            }

            return(successes);
        }