Possible kwarg usage?

def defense_layer_calc(char, only_skill_return, only_rb_return):
    """
    Defensive rank bonus includes up to 3 layers of defense.
    The highest RB defensive manuever of each high, mid, and low will gain 100% of it's RB.
    The second highest RB will supply 50% and the third will only be worth 33%.
    Each layer can only consist of a single defensive manuever from each of the following categories:
        Weapon Blocks, Combat Manuever Dodges, and Shield Blocks.
        Weapons that require 2 hands can only ever gain 2 defensive layers. Shields are the only way to gain all 3 layers.

    For Example:
    Staves Mid Block with 100 Rank Bonus * 1 = 100
    CM Mid Dodge with 80 Rank Bonus * 0.5 = 40
    Total Mid Defensive Rank Bonus = 140

    Swords Mid Block with 100 Rank Bonus * 0.33 = 33
    CM Mid Dodge with 150 Rank Bonus * 0.5 = 75
    Shield Mid Block with 200 Rank Bonus * 1 = 200
    Total Mid Defensive Rank Bonus = 308

    Floats are used to determine the highest RB priority, but only rounded down integers are used to determine the total RB.

    TODO: Add a round down for the final RB.
    TODO: Remove rank bonuses from character attributes and only ever dynamically produce them
            based on the character's ranks, so that RB formula can always be changed later
            without editing character attributes.

    High, Mid, and Low always refer to the area
    of the body that the attack targets and not the numerical value.
    """

    b_defense_skill_list = []
    r_defense_skill_list = []
    l_defense_skill_list = []

    weap_high_skill, weap_mid_skill, weap_low_skill = '', '', ''
    offhand_high_skill, offhand_mid_skill, offhand_low_skill = '', '', ''
    dodge_high_skill, dodge_mid_skill, dodge_low_skill = '', '', ''

    # Initialize rankbonus values.
    weap_high_rb, weap_mid_rb, weap_low_rb = 0.0, 0.0, 0.0
    offhand_high_rb, offhand_mid_rb, offhand_low_rb = 0.0, 0.0, 0.0
    dodge_high_rb, dodge_mid_rb, dodge_low_rb = 0.0, 0.0, 0.0

    # Decide how many layers, based on if wielding.
    wielding = char.attributes.get('wielding')
    l_wield = wielding.get('left')
    r_wield = wielding.get('right')
    b_wield = wielding.get('both')


    if b_wield:
        if b_wield.attributes.has('skillset'):
            b_wield_skillset = b_wield.attributes.get('skillset')
            char_b_weapon_skillset = char.attributes.get(b_wield_skillset) # Grab weapon skillset dictionary from char.
            skills = [*char_b_weapon_skillset] # Create a list of the skill names.

            # Check each key in the dictionary against all viable skills.
            for i in skills:
                if skillsets[b_wield_skillset].get(i):
                    if skillsets[b_wield_skillset][i]['skill_type'] == 'defense':
                        b_defense_skill_list.append(i)

            # Sort
            for i in b_defense_skill_list:
                if skillsets[b_wield_skillset][i]['default_aim'] == 'high':
                    weap_high_rb += char_b_weapon_skillset[i].get('rank_bonus')
                    weap_high_skill = i
                elif skillsets[b_wield_skillset][i]['default_aim'] == 'mid':
                    weap_mid_rb += char_b_weapon_skillset[i].get('rank_bonus')
                    weap_mid_skill = i
                elif skillsets[b_wield_skillset][i]['default_aim'] == 'low':
                    weap_low_rb += char_b_weapon_skillset[i].get('rank_bonus')
                    weap_low_skill = i

    if r_wield:
        if r_wield.attributes.has('skillset'):
            r_wield_skillset = r_wield.attributes.get('skillset')
            char_r_weapon_skillset = char.attributes.get(r_wield_skillset) # Grab weapon skillset dictionary from char.
            skills = [*char_r_weapon_skillset] # Create a list of the skill names.

            # Check each key in the dictionary against all viable skills.
            for i in skills:
                if skillsets[r_wield_skillset].get(i):
                    if skillsets[r_wield_skillset][i]['skill_type'] == 'defense':
                        r_defense_skill_list.append(i)

            for i in r_defense_skill_list:
                if skillsets[r_wield_skillset][i]['default_aim'] == 'high':
                    weap_high_rb += char_r_weapon_skillset[i].get('rank_bonus')
                    weap_high_skill = i
                elif skillsets[r_wield_skillset][i]['default_aim'] == 'mid':
                    weap_mid_rb += char_r_weapon_skillset[i].get('rank_bonus')
                    weap_mid_skill = i
                elif skillsets[r_wield_skillset][i]['default_aim'] == 'low':
                    weap_low_rb += char_r_weapon_skillset[i].get('rank_bonus')
                    weap_low_skill = i

    if l_wield:
        if l_wield.is_typeclass('typeclasses.objects.Shields'):
            if l_wield.attributes.has('skillset'):
                l_wield_skillset = l_wield.attributes.get('skillset')
                char_l_weapon_skillset = char.attributes.get(l_wield_skillset) # Grab weapon skillset dictionary from char.
                skills = [*char_l_weapon_skillset] # Create a list of the skill names.

                # Check each key in the dictionary against all viable skills.
                for i in skills:
                    if skillsets[l_wield_skillset].get(i):
                        if skillsets[l_wield_skillset][i]['skill_type'] == 'defense':
                            l_defense_skill_list.append(i)

                for i in l_defense_skill_list:
                    if skillsets[l_wield_skillset][i]['default_aim'] == 'high':
                        offhand_high_rb += char_l_weapon_skillset[i].get('rank_bonus')
                        offhand_high_skill = i
                    elif skillsets[l_wield_skillset][i]['default_aim'] == 'mid':
                        offhand_mid_rb += char_l_weapon_skillset[i].get('rank_bonus')
                        offhand_mid_skill = i
                    elif skillsets[l_wield_skillset][i]['default_aim'] == 'low':
                        offhand_low_rb += char_l_weapon_skillset[i].get('rank_bonus')
                        offhand_low_skill = i
        else:
            if l_wield.attributes.has('skillset'):
                l_wield_skillset = l_wield.attributes.get('skillset')
                char_l_weapon_skillset = char.attributes.get(l_wield_skillset) # Grab weapon skillset dictionary from char.
                skills = [*char_l_weapon_skillset] # Create a list of the skill names.

                # Check each key in the dictionary against all viable skills.
                for i in skills:
                    if skillsets[l_wield_skillset].get(i):
                        if skillsets[l_wield_skillset][i]['skill_type'] == 'defense':
                            l_defense_skill_list.append(i)

                for i in l_defense_skill_list:
                    if skillsets[l_wield_skillset][i]['default_aim'] == 'high':
                        offhand_high_rb += char_l_weapon_skillset[i].get('rank_bonus')
                        offhand_high_skill = i
                    elif skillsets[l_wield_skillset][i]['default_aim'] == 'mid':
                        offhand_mid_rb += char_l_weapon_skillset[i].get('rank_bonus')
                        offhand_mid_skill = i
                    elif skillsets[l_wield_skillset][i]['default_aim'] == 'low':
                        offhand_low_rb += char_l_weapon_skillset[i].get('rank_bonus')
                        offhand_low_skill = i

    # Get all dodge rank bonuses
    # !!! NO DODGES EXIST YET !!!

    high_skills = [weap_high_skill, offhand_high_skill, dodge_high_skill]
    mid_skills = [weap_mid_skill, offhand_mid_skill, dodge_mid_skill]
    low_skills = [weap_low_skill, offhand_low_skill, dodge_low_skill]

    # High Layer
    h_rb = [weap_high_rb, dodge_high_rb, offhand_high_rb]
    h_rb.sort(reverse=True)
    h_layer1 = h_rb[0] * 1
    h_layer2 = h_rb[1] * 0.5
    h_layer3 = h_rb[2] * 0.33
    high_def_rb = (h_layer1 + h_layer2 + h_layer3)

    # Mid Layer
    m_rb = [weap_mid_rb, dodge_mid_rb, offhand_mid_rb]
    m_rb.sort(reverse=True)
    m_layer1 = m_rb[0] * 1
    m_layer2 = m_rb[1] * 0.5
    m_layer3 = m_rb[2] * 0.33
    mid_def_rb = (m_layer1 + m_layer2 + m_layer3)

    # Low Layer
    l_rb = [weap_low_rb, dodge_low_rb, offhand_low_rb]
    l_rb.sort(reverse=True)
    l_layer1 = l_rb[0] * 1
    l_layer2 = l_rb[1] * 0.5
    l_layer3 = l_rb[2] * 0.33
    low_def_rb = (l_layer1 + l_layer2 + l_layer3)

    # Assign the values to the character.
    def_rb = char.db.def_rb
    def_rb['high'] = high_def_rb
    def_rb['mid'] = mid_def_rb
    def_rb['low'] = low_def_rb

    if only_skill_return:
        return high_skills, mid_skills, low_skills
    elif only_rb_return:
        return high_def_rb, mid_def_rb, low_def_rb
    else:
        return high_skills, mid_skills, low_skills, high_def_rb, mid_def_rb, low_def_rb