/// <summary>Reduces the damage.</summary>
        /// <param name="dInfo">The d information.</param>
        /// <param name="pawn">The pawn.</param>
        /// <returns></returns>
        protected DamageInfo ReduceDamage(DamageInfo dInfo, Pawn pawn)
        {
            float r;

            if (MutagenDefOf.defaultMutagen.CanInfect(pawn))
            {
                r = dInfo.Def.GetModExtension <MutagenicDamageExtension>()?.reduceValue ?? REDUCE_VALUE;
            }
            else
            {
                r = 1;
            }
            return(MutagenicDamageUtilities.ReduceDamage(dInfo, r));
        }
        private DamageResult ApplyToPawn(DamageInfo dinfo, Pawn pawn, MutagenDef mutagen)
        {
            //reduce the amount to make it less likely to kill the pawn
            float originalDamage = dinfo.Amount;

            dinfo = ReduceDamage(dinfo, pawn);

            DamageResult res = base.Apply(dinfo, pawn);
            float        severityPerDamage = dinfo.GetSeverityPerDamage();

            if (!mutagen.CanInfect(pawn))
            {
                return(res);
            }
            MutagenicDamageUtilities.ApplyMutagenicDamage(originalDamage, dinfo, pawn, res, severityPerDamage: severityPerDamage,
                                                          mutagen: mutagen);

            return(res);
        }
        /// <summary>
        /// does explosive damage to a thing
        /// </summary>
        /// <param name="explosion">The explosion.</param>
        /// <param name="t">The t.</param>
        /// <param name="damagedThings">The damaged things.</param>
        /// <param name="ignoredThings">The ignored things.</param>
        /// <param name="cell">The cell.</param>
        protected override void ExplosionDamageThing(Explosion explosion, Thing t, List <Thing> damagedThings, List <Thing> ignoredThings, IntVec3 cell)
        {
            if (t.def.category == ThingCategory.Mote || t.def.category == ThingCategory.Ethereal)
            {
                return;
            }
            if (damagedThings.Contains(t))
            {
                return;
            }
            damagedThings.Add(t);
            //it puts out fires
            if (def == DamageDefOf.Bomb && t.def == ThingDefOf.Fire && !t.Destroyed)
            {
                t.Destroy();
                return;
            }
            //only affects pawns

            if (!(t is Pawn pawn))
            {
                ignoredThings?.Add(t);
                return;
            }

            if (!MutagenDefOf.defaultMutagen.CanInfect(pawn))
            {
                ignoredThings?.Add(pawn);
                return; //only affects susceptible pawns
            }


            float num;

            if (t.Position == explosion.Position)
            {
                num = Rand.RangeInclusive(0, 359);
            }
            else
            {
                num = (t.Position - explosion.Position).AngleFlat;
            }
            DamageDef damageDef          = def;
            var       amount             = (float)explosion.GetDamageAmountAt(cell);
            float     armorPenetrationAt = explosion.GetArmorPenetrationAt(cell);
            float     angle      = num;
            Thing     instigator = explosion.instigator;
            ThingDef  weapon     = explosion.weapon;
            var       dinfo      = new DamageInfo(damageDef, amount, armorPenetrationAt, angle, instigator, null, weapon,
                                                  DamageInfo.SourceCategory.ThingOrUnknown, explosion.intendedTarget);
            float severityPerDamage = dinfo.GetSeverityPerDamage();

            MutagenicDamageUtilities.ApplyPureMutagenicDamage(dinfo, pawn,
                                                              severityPerDamage: severityPerDamage);


            BattleLogEntry_ExplosionImpact battleLogEntry_ExplosionImpact = null;

            battleLogEntry_ExplosionImpact =
                new BattleLogEntry_ExplosionImpact(explosion.instigator, t, explosion.weapon, explosion.projectile, def);
            Find.BattleLog.Add(battleLogEntry_ExplosionImpact);

            pawn.stances?.StaggerFor(95);
        }