Method handler

eos/effects.py:16433–16546

(fit, module, context, projectionRange, **kwargs)

    @staticmethod
    def handler(fit, module, context, projectionRange, **kwargs):
        # pyfalog = Logger(__name__)

        damagePattern = module.rahPatternOverride if module.rahPatternOverride is not None else fit.damagePattern
        # pyfalog.debug('==============================')

        if damagePattern == 'disable':
            for attr in ('armorEmDamageResonance', 'armorThermalDamageResonance', 'armorKineticDamageResonance', 'armorExplosiveDamageResonance'):
                fit.ship.multiplyItemAttr(attr, module.getModifiedItemAttr(attr), stackingPenalties=True, penaltyGroup='preMul')
            return

        # Skip if there is no damage pattern. Example: projected ships or fleet boosters
        if damagePattern:

            # Populate a tuple with the damage profile modified by current armor resists.
            baseDamageTaken = (
                damagePattern.emAmount * fit.ship.getModifiedItemAttr('armorEmDamageResonance'),
                damagePattern.thermalAmount * fit.ship.getModifiedItemAttr('armorThermalDamageResonance'),
                damagePattern.kineticAmount * fit.ship.getModifiedItemAttr('armorKineticDamageResonance'),
                damagePattern.explosiveAmount * fit.ship.getModifiedItemAttr('armorExplosiveDamageResonance'),
            )
            # pyfalog.debug('Damage Adjusted for Armor Resists: %f/%f/%f/%f' % (baseDamageTaken[0], baseDamageTaken[1], baseDamageTaken[2], baseDamageTaken[3]))

            resistanceShiftAmount = module.getModifiedItemAttr(
                'resistanceShiftAmount') / 100  # The attribute is in percent and we want a fraction
            RAHResistance = [
                module.getModifiedItemAttr('armorEmDamageResonance'),
                module.getModifiedItemAttr('armorThermalDamageResonance'),
                module.getModifiedItemAttr('armorKineticDamageResonance'),
                module.getModifiedItemAttr('armorExplosiveDamageResonance'),
            ]

            # Simulate RAH cycles until the RAH either stops changing or enters a loop.
            # The number of iterations is limited to prevent an infinite loop if something goes wrong.
            cycleList = []
            loopStart = -20
            for num in range(50):
                # pyfalog.debug('Starting cycle %d.' % num)
                # The strange order is to emulate the ingame sorting when different types have taken the same amount of damage.
                # This doesn't take into account stacking penalties. In a few cases fitting a Damage Control causes an inaccurate result.
                damagePattern_tuples = [
                    (0, baseDamageTaken[0] * RAHResistance[0], RAHResistance[0]),
                    (3, baseDamageTaken[3] * RAHResistance[3], RAHResistance[3]),
                    (2, baseDamageTaken[2] * RAHResistance[2], RAHResistance[2]),
                    (1, baseDamageTaken[1] * RAHResistance[1], RAHResistance[1]),
                ]

                # Sort the tuple to drop the highest damage value to the bottom
                sortedDamagePattern_tuples = sorted(damagePattern_tuples, key=lambda damagePattern: damagePattern[1])

                if sortedDamagePattern_tuples[2][1] == 0:
                    # One damage type: the top damage type takes from the other three
                    # Since the resistances not taking damage will end up going to the type taking damage we just do the whole thing at once.
                    change0 = 1 - sortedDamagePattern_tuples[0][2]
                    change1 = 1 - sortedDamagePattern_tuples[1][2]
                    change2 = 1 - sortedDamagePattern_tuples[2][2]
                    change3 = -(change0 + change1 + change2)
                elif sortedDamagePattern_tuples[1][1] == 0: