Пример #1
0
def getSwordBarb():
  # Changes by level:
  # 01: AC 14, proficiency 2, rage 2
  # 02: reckless
  # 04: AC 15, ASI
  # 05: AC 16, proficiency 3, Extra Attack
  # 08: AC 17, ASI
  # 09: AC 18, proficiency 4, rage 3, brutal1
  # 13: AC 19, proficiency 5, brutal2
  # 16: rage 4
  # 17: AC 20, proficiency 6, brutal3
  # 20: primal rage 24

  b01 = calculageAverage(14, 5, [(1, 8)], 5)
  b02 = calculageAverage(14, 5, [(1, 8)], 5)
  b04 = calculageAverageAdvantage(15, 6, [(1, 8)], 6)
  b05 = 2 * calculageAverageAdvantage(16, 7, [(1, 8)], 6)
  b08 = 2 * calculageAverageAdvantage(17, 8, [(1, 8)], 7)
  b09 = 2 * (calculageAverageAdvantage(18, 9, [(1, 8)], 8) + 0.098 * d(1, 8))
  b13 = 2 * (calculageAverageAdvantage(19, 10, [(1, 8)], 8) + 0.098 * d(2, 8))
  b16 = 2 * (calculageAverageAdvantage(19, 10, [(1, 8)], 9) + 0.098 * d(2, 8))
  b17 = 2 * (calculageAverageAdvantage(20, 11, [(1, 8)], 9) + 0.098 * d(3, 8))
  b20 = 2 * (calculageAverageAdvantage(20, 15, [(1, 8)], 13) + 0.098 * d(3, 8))

  return [b01, b02, b02, b04, b05, b05, b05, b08, b09, b09, b09, b09, b13, b13, b13, b16, b17, b17, b17, b20]
Пример #2
0
def getSwordFighter():
  # Changes by level:
  # 01: AC 14, proficiency 2
  # 04: AC 15, ASI
  # 05: AC 16, proficiency 3, Extra Attack
  # 06: ASI
  # 08: AC 17, ASI
  # 09: AC 18, proficiency 4
  # 11: Extra Attack
  # 13: AC 19, proficiency 5
  # 17: AC 20, proficiency 6, Extra Attack

  f01 = 1 * calculageAverage(14, 5, [(1, 8)], 5)
  f04 = 1 * calculageAverage(15, 6, [(1, 8)], 6)
  f05 = 2 * calculageAverage(16, 7, [(1, 8)], 6)
  f06 = 2 * calculageAverage(16, 8, [(1, 8)], 7)
  f08 = 2 * calculageAverage(17, 8, [(1, 8)], 7)
  f09 = 2 * calculageAverage(18, 9, [(1, 8)], 7)
  f11 = 3 * calculageAverage(18, 9, [(1, 8)], 7)
  f13 = 3 * calculageAverage(19, 10, [(1, 8)], 7)
  f17 = 4 * calculageAverage(20, 11, [(1, 8)], 7)

  f13a = 3 * calculageAverage(19, 11, [(1, 8)], 8)
  print('fighter: ' + str(f13a))

  return [f01, f01, f01, f04, f05, f06, f06, f08, f09, f09, f11, f11, f13, f13, f13, f13, f17, f17, f17, f17]
Пример #3
0
def getGWMFighter():
  # Changes by level:
  # 01: AC 14, Archery, proficiency 2
  # 04: AC 15, ASI
  # 05: AC 16, proficiency 3, Extra Attack
  # 06: ASI
  # 08: AC 17, ASI
  # 09: AC 18, proficiency 4
  # 11: Extra Attack
  # 13: AC 19, proficiency 5
  # 17: AC 20, proficiency 6, Extra Attack

  f01 = 1 * calculageAverage(14, 5, [(2, 6)], 3)
  f03 = 1 * (calculageAverage(14, 5, [(2, 6)], 3) + 0.05 * d(2, 6))
  f04 = 1 * (calculageAverage(15, 0, [(2, 6)], 13) + 0.05 * d(2, 6))
  f05 = 2 * (calculageAverage(16, 1, [(2, 6)], 13) + 0.05 * d(2, 6))
  f06 = 2 * (calculageAverage(16, 2, [(2, 6)], 14) + 0.05 * d(2, 6))
  f08 = 2 * (calculageAverage(17, 3, [(2, 6)], 15) + 0.05 * d(2, 6))
  f09 = 2 * (calculageAverage(18, 4, [(2, 6)], 15) + 0.05 * d(2, 6))
  f11 = 3 * (calculageAverage(18, 4, [(2, 6)], 15) + 0.05 * d(2, 6))
  f13 = 3 * (calculageAverage(19, 5, [(2, 6)], 15) + 0.05 * d(2, 6))
  f15 = 3 * (calculageAverage(19, 5, [(2, 6)], 15) + 0.1 * d(2, 6))
  f17 = 4 * (calculageAverage(20, 6, [(2, 6)], 15) + 0.1 * d(2, 6))

  return [f01, f01, f03, f04, f05, f06, f06, f08, f09, f09, f11, f11, f13, f13, f15, f15, f17, f17, f17, f17]
Пример #4
0
def getCrossbowFighter():
  # Changes by level:
  # 01: AC 14, Archery, proficiency 2
  # 04: AC 15, ASI
  # 05: AC 16, proficiency 3, Extra Attack
  # 06: ASI
  # 08: AC 17, ASI
  # 09: AC 18, proficiency 4
  # 11: Extra Attack
  # 13: AC 19, proficiency 5
  # 17: AC 20, proficiency 6, Extra Attack

  f01 = 2 * calculageAverage(14, 7, [(1, 6)], 3)
  f03 = 2 * (calculageAverage(14, 7, [(1, 6)], 3) + 0.05 * d(1, 6))
  f04 = 2 * (calculageAverage(15, 2, [(1, 6)], 13) + 0.05 * d(1, 6))
  f05 = 3 * (calculageAverage(16, 3, [(1, 6)], 13) + 0.05 * d(1, 6))
  f06 = 3 * (calculageAverage(16, 4, [(1, 6)], 14) + 0.05 * d(1, 6))
  f08 = 3 * (calculageAverage(17, 5, [(1, 6)], 15) + 0.05 * d(1, 6))
  f09 = 3 * (calculageAverage(18, 6, [(1, 6)], 15) + 0.05 * d(1, 6))
  f11 = 4 * (calculageAverage(18, 6, [(1, 6)], 15) + 0.05 * d(1, 6))
  f13 = 4 * (calculageAverage(19, 7, [(1, 6)], 15) + 0.05 * d(1, 6))
  f15 = 4 * (calculageAverage(19, 7, [(1, 6)], 15) + 0.1 * d(1, 6))
  f17 = 5 * (calculageAverage(20, 8, [(1, 6)], 15) + 0.1 * d(1, 6))

  return [f01, f01, f03, f04, f05, f06, f06, f08, f09, f09, f11, f11, f13, f13, f15, f15, f17, f17, f17, f17]
Пример #5
0
def getWayOfMercy():
    # Changes by level:
    # 01: AC 14, proficiency 2, Unarmed 1d4
    # 04: AC 15, ASI
    # 05: AC 16, proficiency 3, Extra Attack, Unarmed 1d6
    # 08: AC 17, ASI
    # 09: AC 18, proficiency 4
    # 11: Unarmed 1d8
    # 12: ASI
    # 13: AC 19, proficiency 5
    # 16: ASI
    # 17: AC 20, proficiency 6, Unarmed 1d10

    m01 = calculageAverage(14, 5, [(1, 10)], 3) + calculageAverage(
        14, 5, [(1, 4)], 3)
    m04 = calculageAverage(15, 6, [(1, 10)], 4) + calculageAverage(
        15, 6, [(1, 4)], 4)
    m05 = 2 * calculageAverage(16, 7, [(1, 10)], 4) + calculageAverage(
        16, 7, [(1, 6)], 4)
    m08 = 2 * calculageAverage(17, 8, [(1, 10)], 5) + calculageAverage(
        17, 8, [(1, 6)], 5)
    m09 = 2 * calculageAverage(18, 9, [(1, 10)], 5) + calculageAverage(
        18, 9, [(1, 6)], 5)
    m11 = 2 * calculageAverage(18, 9, [(1, 10)], 5) + calculageAverage(
        18, 9, [(2, 8)], 8)
    m12 = 2 * calculageAverage(18, 9, [(1, 10)], 5) + calculageAverage(
        18, 9, [(2, 8)], 9)
    m13 = 2 * calculageAverage(19, 10, [(1, 10)], 5) + calculageAverage(
        19, 10, [(2, 8)], 9)
    m16 = 2 * calculageAverage(19, 10, [(1, 10)], 5) + calculageAverage(
        19, 10, [(2, 8)], 10)
    m17 = 2 * calculageAverage(20, 11, [(1, 10)], 5) + calculageAverage(
        20, 11, [(2, 10)], 10)

    return [
        m01, m01, m01, m04, m05, m05, m05, m08, m09, m09, m11, m12, m13, m13,
        m13, m16, m17, m17, m17, m17
    ]
Пример #6
0
def calculateSneakAttackTWF(ac, prof, mod, sa):
  return calculageAverage(ac, prof, [(1, 6)], mod) + calculageAverage(ac, prof, [(1, 6)], 0) + hitChanceAdvantage(ac, prof) * d(sa, 6) + 0.098 * d(sa, 6)
Пример #7
0
def getClericGFBWithLowSpiritWeapon():
  # extra bonus (spirit weapon) at 5, 9, 13, 17
  # extra ASI at 12, 16
  # extra 1d8 a turn at level 8, 2d8 at level 14
  c01 = calculageAverage(14, 5, [(2, 6)], 4)
  c03 = calculageAverage(14, 5, [(2, 6)], 4)
  c04 = calculageAverage(15, 6, [(2, 6)], 5)
  c05 = calculageAverage(16, 7, [(2, 6), (2, 8)], 5) + calculageAverage(16, 6, [(1, 8)], 3)
  c07 = calculageAverage(16, 7, [(2, 6), (2, 8)], 5) + calculageAverage(16, 6, [(1, 8)], 3)
  c08 = calculageAverage(17, 8, [(2, 6), (3, 8)], 6) + calculageAverage(17, 6, [(1, 8)], 3)
  c09 = calculageAverage(18, 9, [(2, 6), (3, 8)], 6) + calculageAverage(18, 7, [(2, 8)], 3)
  c11 = calculageAverage(18, 9, [(2, 6), (5, 8)], 6) + calculageAverage(18, 7, [(2, 8)], 3)
  c12 = calculageAverage(18, 9, [(2, 6), (5, 8)], 6) + calculageAverage(18, 8, [(2, 8)], 4)
  c13 = calculageAverage(19, 10, [(2, 6), (5, 8)], 6) + calculageAverage(19, 9, [(3, 8)], 4)
  c14 = calculageAverage(19, 10, [(2, 6), (6, 8)], 6) + calculageAverage(19, 9, [(3, 8)], 4)
  c15 = calculageAverage(19, 10, [(2, 6), (6, 8)], 6) + calculageAverage(19, 9, [(3, 8)], 4)
  c16 = calculageAverage(19, 10, [(2, 6), (6, 8)], 6) + calculageAverage(19, 10, [(3, 8)], 5)
  c17 = calculageAverage(20, 11, [(2, 6), (8, 8)], 6) + calculageAverage(20, 11, [(4, 8)], 5)

  return [c01, c01, c03, c04, c05, c05, c07, c08, c09, c09, c11, c12, c13, c14, c15, c16, c17, c17, c17, c17]
Пример #8
0
def getClericGFB():
  # extra ASI at 12, 16
  # extra 1d8 a turn at level 8, 2d8 at level 14
  c01 = calculageAverage(14, 5, [(2, 6)], 4)
  c03 = calculageAverage(14, 5, [(2, 6)], 4)
  c04 = calculageAverage(15, 6, [(2, 6)], 5)
  c05 = calculageAverage(16, 7, [(2, 6), (2, 8)], 5)
  c07 = calculageAverage(16, 7, [(2, 6), (2, 8)], 5)
  c08 = calculageAverage(17, 8, [(2, 6), (3, 8)], 6)
  c09 = calculageAverage(18, 9, [(2, 6), (3, 8)], 6)
  c11 = calculageAverage(18, 9, [(2, 6), (5, 8)], 6)
  c12 = calculageAverage(18, 9, [(2, 6), (5, 8)], 6)
  c13 = calculageAverage(19, 10, [(2, 6), (5, 8)], 6)
  c14 = calculageAverage(19, 10, [(2, 6), (6, 8)], 6)
  c15 = calculageAverage(19, 10, [(2, 6), (6, 8)], 6)
  c16 = calculageAverage(19, 10, [(2, 6), (6, 8)], 6)
  c17 = calculageAverage(20, 11, [(2, 6), (8, 8)], 6)

  return [c01, c01, c03, c04, c05, c05, c07, c08, c09, c09, c11, c12, c13, c14, c15, c16, c17, c17, c17, c17]
Пример #9
0
def getArtilleristShooter():
    # Changes by level:
    # 01: AC 14, proficiency 2, cantrip scale 1
    # 02: Enhanced Focus +1, Homunculus
    # 03: Eldrich Cannon (2d8), Faerie Fire
    # 04: AC 15, ASI
    # 05: AC 16, proficiency 3, cantrip scale 2, Arcane Firearm (1d8)
    # 08: AC 17, ASI
    # 09: AC 18, proficiency 4,
    # 10: Enhanced Focus +2
    # 11: cantrip scale 3, Haste
    # 13: AC 19, proficiency 5
    # 15: Double Cannon, Summon Construct
    # 17: AC 20, proficiency 6, cantrip scale 4

    a01 = calculageAverage(14, 5, [(1, 10)], 0)
    a02 = calculageAverage(14, 6, [(1, 10)], 0) + calculageAverage(
        14, 5, [(1, 4)], 2)
    a03 = calculageAverageAdvantage(
        14, 6, [(1, 10)], 0) + calculageAverageAdvantage(14, 5, [(2, 8)], 0)
    a04 = calculageAverageAdvantage(
        15, 7, [(1, 10)], 0) + calculageAverageAdvantage(15, 6, [(2, 8)], 0)
    a05 = calculageAverageAdvantage(
        16, 8, [(2, 10),
                (1, 8)], 0) + calculageAverageAdvantage(16, 7, [(2, 8)], 0)
    a08 = calculageAverageAdvantage(
        17, 9, [(2, 10),
                (1, 8)], 0) + calculageAverageAdvantage(17, 8, [(2, 8)], 0)
    a09 = calculageAverageAdvantage(
        18, 10, [(2, 10),
                 (1, 8)], 0) + calculageAverageAdvantage(18, 9, [(2, 8)], 0)
    a10 = calculageAverageAdvantage(
        18, 11, [(2, 10),
                 (1, 8)], 0) + calculageAverageAdvantage(18, 9, [(2, 8)], 0)
    a11 = 2 * calculageAverage(18, 11, [(3, 10),
                                        (1, 8)], 0) + calculageAverage(
                                            18, 9, [(2, 8)], 0)
    a13 = 2 * calculageAverage(19, 12, [(3, 10),
                                        (1, 8)], 0) + calculageAverage(
                                            19, 10, [(2, 8)], 0)
    a15 = calculageAverage(
        19, 12, [(3, 10), (1, 8)], 0) + 2 * calculageAverage(
            19, 10, [(2, 8)], 0) + 2 * calculageAverage(19, 10, [(1, 8)], 8)
    a17 = calculageAverage(
        20, 13, [(4, 10), (1, 8)], 0) + 2 * calculageAverage(
            20, 11, [(2, 8)], 0) + 2 * calculageAverage(20, 11, [(1, 8)], 8)

    return [
        a01, a02, a03, a04, a05, a05, a05, a08, a09, a10, a11, a11, a13, a13,
        a15, a15, a17, a17, a17, a17
    ]
Пример #10
0
def getSwarmRangerCrossbow():
    # Changes by level:
    # 01: AC 14, proficiency 2, favored (1d4)
    # 02: Archery
    # 03: swarm (1d6)
    # 04: AC 15, ASI
    # 05: AC 16, proficiency 3, Extra attack
    # 06: favored 1d6

    # 07: Summon Beast
    # 08: AC 17, ASI
    # 09: AC 18, proficiency 4

    # 11: swarm (1d8), Conjure Animals (2 wolves)
    # 12 : ASI
    # 13: AC 19, proficiency 5

    # 15: Guardian Nature
    # 17: AC 20, proficiency 6

    # 19: Conjure Animals (4 wolves)

    r01 = 2 * calculageAverage(14, 5, [(1, 6)], 3) + calculageAverageAdvantage(
        14, 5, [(1, 4)], 0)
    r02 = 2 * calculageAverage(14, 7, [(1, 6)], 3) + calculageAverageAdvantage(
        14, 7, [(1, 4)], 0)
    r03 = 2 * calculageAverage(14, 7, [(1, 6)], 3) + calculageAverageAdvantage(
        14, 7, [(1, 4), (1, 6)], 0)
    r04 = 2 * calculageAverage(15, 2, [
        (1, 6)
    ], 13) + calculageAverageAdvantage(15, 2, [(1, 4), (1, 6)], 0)
    r05 = 3 * calculageAverage(16, 3, [
        (1, 6)
    ], 13) + calculageAverageElvenAdvantage(16, 3, [(1, 4), (1, 6)], 0)
    r06 = 3 * calculageAverage(16, 3, [
        (1, 6)
    ], 13) + calculageAverageElvenAdvantage(16, 3, [(2, 6)], 0)

    r07 = 3 * calculageAverage(
        16, 3, [(1, 6)], 13) + calculageAverageElvenAdvantage(
            16, 3, [(1, 6)], 0) + calculageAverage(16, 6, [(1, 8)], 6)
    r08 = 3 * calculageAverage(
        17, 4, [(1, 6)], 14) + calculageAverageElvenAdvantage(
            17, 4, [(1, 6)], 0) + calculageAverage(17, 6, [(1, 8)], 6)
    r09 = 3 * calculageAverage(
        18, 5, [(1, 6)], 14) + calculageAverageElvenAdvantage(
            18, 5, [(1, 6)], 0) + calculageAverage(18, 7, [(1, 8)], 7)

    r11 = 3 * calculageAverage(18, 5, [
        (1, 6)
    ], 14) + calculageAverageElvenAdvantage(18, 5, [
        (1, 8)
    ], 0) + 2 * calculageAverageAdvantage(18, 6, [(2, 6)], 3)
    r12 = 3 * calculageAverage(18, 6, [
        (1, 6)
    ], 15) + calculageAverageElvenAdvantage(18, 6, [
        (1, 8)
    ], 0) + 2 * calculageAverageAdvantage(18, 6, [(2, 6)], 3)
    r13 = 3 * calculageAverage(19, 7, [
        (1, 6)
    ], 15) + calculageAverageElvenAdvantage(19, 7, [
        (1, 8)
    ], 0) + 2 * calculageAverageAdvantage(18, 6, [(2, 6)], 3)

    r15 = 3 * calculageAverageAdvantage(19, 7, [
        (1, 6)
    ], 15) + calculageAverageMultiAdvantage(19, 7, [(1, 8)], 0, 6)
    r17 = 3 * calculageAverageAdvantage(20, 8, [
        (1, 6)
    ], 15) + calculageAverageMultiAdvantage(20, 8, [(1, 8)], 0, 6)

    r19 = 3 * calculageAverage(20, 8, [
        (1, 6)
    ], 15) + calculageAverageElvenAdvantage(20, 8, [
        (1, 8)
    ], 0) + 4 * calculageAverageAdvantage(18, 6, [(2, 6)], 3)

    return [
        r01, r02, r03, r04, r05, r06, r07, r08, r09, r09, r11, r12, r13, r13,
        r15, r15, r17, r17, r19, r19
    ]
Пример #11
0
def getSwarmRangerHuntersMark():
    # Changes by level:
    # 01: AC 14, proficiency 2,
    # 02: Archery
    # 03: swarm (1d6)
    # 04: AC 15, ASI
    # 05: AC 16, proficiency 3, Extra attack
    # 08: AC 17, ASI
    # 09: AC 18, proficiency 4
    # 11: swarm (1d8)
    # 13: AC 19, proficiency 5
    # 17: AC 20, proficiency 6
    # 20: Foe Slayer

    r01 = calculageAverage(14, 5, [(1, 8), (1, 6)], 3)
    r02 = calculageAverage(14, 7, [(1, 8), (1, 6)], 3)
    r03 = calculageAverage(14, 7, [(1, 8), (2, 6)], 3)
    r04 = calculageAverage(15, 2, [(1, 8), (2, 6)], 13)
    r05 = 2 * calculageAverage(
        16, 3, [(1, 8),
                (1, 6)], 13) + calculageAverageAdvantage(16, 3, [(1, 6)], 0)
    r08 = 2 * calculageAverage(
        17, 4, [(1, 8),
                (1, 6)], 14) + calculageAverageAdvantage(17, 4, [(1, 6)], 0)
    r09 = 2 * calculageAverage(
        18, 5, [(1, 8),
                (1, 6)], 14) + calculageAverageAdvantage(18, 5, [(1, 6)], 0)
    r11 = 2 * calculageAverage(
        18, 5, [(1, 8),
                (1, 6)], 14) + calculageAverageAdvantage(18, 5, [(1, 8)], 0)
    r12 = 2 * calculageAverage(
        18, 6, [(1, 8),
                (1, 6)], 15) + calculageAverageAdvantage(18, 6, [(1, 8)], 0)
    r13 = 2 * calculageAverage(
        19, 7, [(1, 8),
                (1, 6)], 15) + calculageAverageAdvantage(19, 7, [(1, 8)], 0)
    r17 = 2 * calculageAverage(
        20, 8, [(1, 8),
                (1, 6)], 15) + calculageAverageAdvantage(20, 8, [(1, 8)], 0)
    r20 = 2 * calculageAverage(
        20, 8, [(1, 8),
                (1, 6)], 15) + calculageAverageAdvantage(20, 13, [(1, 8)], 5)

    return [
        r01, r02, r03, r04, r05, r05, r05, r08, r09, r09, r11, r11, r13, r13,
        r13, r13, r17, r17, r17, r20
    ]
Пример #12
0
def getBeastRanger():
    # Changes by level:
    # 01: AC 14, proficiency 2, Favored (1d4)
    # 02: Archery
    # 03: Pimal Companion 1d8 + 1d6 + 2 + PB (wisdom to hit)
    # 04: AC 15, ASI
    # 05: AC 16, proficiency 3, Extra attack
    # 06: favored 1d6

    # 07: Summon Beast
    # 08: AC 17, ASI
    # 09: AC 18, proficiency 4

    # 11: Beast Extra Attack, Conjure Animals (2 wolves)
    # 12 : ASI
    # 13: AC 19, proficiency 5

    # 15: Guardian Nature, Share Spells
    # 16: ASI
    # 17: AC 20, proficiency 6

    # 19: ASI, Conjure Animals (4 wolves)

    r01 = calculageAverage(14, 5, [(1, 8), (1, 4)], 3)
    r02 = calculageAverage(14, 7, [(1, 8), (1, 6)], 3)
    r03 = calculageAverage(14, 7, [(1, 8), (1, 4)], 3) + calculageAverage(
        14, 5, [(1, 8), (1, 6)], 4)
    r04 = calculageAverage(15, 2, [(1, 8), (1, 4)], 13) + calculageAverage(
        15, 5, [(1, 8), (1, 6)], 4)

    r05 = 2 * calculageAverage(
        16, 3, [(1, 8)], 13) + calculageAverageAdvantage(
            16, 3, [(1, 4)], 0) + calculageAverage(16, 6, [(1, 8), (1, 6)], 5)
    r06 = 2 * calculageAverage(
        16, 3, [(1, 8)], 13) + calculageAverageAdvantage(
            16, 3, [(1, 6)], 0) + calculageAverage(16, 6, [(1, 8), (1, 6)], 5)

    r07 = 2 * calculageAverage(16, 3, [(1, 8)], 13) + calculageAverage(
        16, 6, [(1, 8), (1, 6)], 5) + calculageAverage(16, 6, [(1, 8)], 6)
    r08 = 2 * calculageAverage(17, 4, [(1, 8)], 14) + calculageAverage(
        17, 6, [(1, 8), (1, 6)], 5) + calculageAverage(17, 6, [(1, 8)], 6)
    r09 = 2 * calculageAverage(18, 5, [(1, 8)], 14) + calculageAverage(
        18, 7, [(1, 8), (1, 6)], 6) + calculageAverage(18, 7, [(1, 8)], 7)

    # no spells
    # r07 = 2 * calculageAverage(16, 3, [(1, 8)], 13) + calculageAverageAdvantage(16, 3, [(1, 6)], 0) + calculageAverage(16, 6, [(1, 8)], 6)
    # r08 = 2 * calculageAverage(17, 4, [(1, 8)], 14) + calculageAverageAdvantage(17, 4, [(1, 6)], 0) + calculageAverage(17, 6, [(1, 8)], 6)
    # r09 = 2 * calculageAverage(18, 5, [(1, 8)], 14) + calculageAverageAdvantage(18, 5, [(1, 6)], 0) + calculageAverage(18, 7, [(1, 8)], 7)

    r11 = 2 * calculageAverage(18, 5, [(1, 8)], 14) + 2 * calculageAverage(
        18, 7, [(1, 8), (1, 6)], 6) + 2 * calculageAverageAdvantage(
            18, 6, [(2, 6)], 3)
    r12 = 2 * calculageAverage(18, 6, [(1, 8)], 15) + 2 * calculageAverage(
        18, 7, [(1, 8), (1, 6)], 6) + 2 * calculageAverageAdvantage(
            18, 6, [(2, 6)], 3)
    r13 = 2 * calculageAverage(19, 7, [(1, 8)], 15) + 2 * calculageAverage(
        19, 8, [(1, 8), (1, 6)], 7) + 2 * calculageAverageAdvantage(
            18, 6, [(2, 6)], 3)

    r15 = 2 * calculageAverageAdvantage(19, 7, [
        (1, 8)
    ], 15) + 2 * calculageAverageAdvantage(19, 8, [(1, 8), (1, 6)], 7)
    r16 = 2 * calculageAverageAdvantage(19, 7, [
        (1, 8)
    ], 15) + 2 * calculageAverageAdvantage(19, 9, [(1, 8), (1, 6)], 8)
    r17 = 2 * calculageAverageAdvantage(20, 8, [
        (1, 8)
    ], 15) + 2 * calculageAverageAdvantage(20, 10, [(1, 8), (1, 6)], 9)

    r19 = 2 * calculageAverage(20, 8, [(1, 8)], 15) + 2 * calculageAverage(
        20, 11, [(1, 8), (1, 6)], 10) + 4 * calculageAverageAdvantage(
            18, 6, [(2, 6)], 3)

    return [
        r01, r02, r03, r04, r05, r06, r07, r08, r09, r09, r11, r12, r13, r13,
        r15, r16, r17, r17, r19, r19
    ]
Пример #13
0
def getHorizonRangerStr():
    # Changes by level:
    # 01: AC 14, proficiency 2, Favored (1d4)
    # 02: Hunter's Mark
    # 03: Planar (1d8)
    # 04: AC 15, ASI
    # 05: AC 16, proficiency 3, Extra attack
    # 06: favored 1d6

    # 07: Summon Beast
    # 08: AC 17, ASI
    # 09: AC 18, proficiency 4

    # 11: Planar (2d8), Conjure Animals (2 wolves), Distance Strike
    # 12 : ASI
    # 13: AC 19, proficiency 5

    # 15: Guardian Nature
    # 17: AC 20, proficiency 6

    # 19: Conjure Animals (4 wolves)

    r01 = calculageAverage(14, 5, [(1, 12), (1, 4)], 3)
    r02 = calculageAverage(14, 5, [(1, 12), (1, 6)], 3)
    r03 = calculageAverage(14, 5, [(1, 12), (1, 4), (1, 8)], 3)
    r04 = calculageAverage(15, 0, [(1, 12), (1, 4), (1, 8)], 13)
    r05 = 2 * calculageAverage(16, 1, [
        (1, 12)
    ], 13) + calculageAverageAdvantage(16, 1, [(1, 4), (1, 8)], 0)
    r06 = 2 * calculageAverage(16, 1, [
        (1, 12)
    ], 13) + calculageAverageAdvantage(16, 1, [(1, 6), (1, 8)], 0)

    r07 = 2 * calculageAverage(
        16, 1, [(1, 12)], 13) + calculageAverageAdvantage(
            16, 1, [(1, 8)], 0) + calculageAverage(16, 6, [(1, 8)], 6)
    r08 = 2 * calculageAverage(
        17, 2, [(1, 12)], 14) + calculageAverageAdvantage(
            17, 2, [(1, 8)], 0) + calculageAverage(17, 6, [(1, 8)], 6)
    r09 = 2 * calculageAverage(
        18, 3, [(1, 12)], 14) + calculageAverageAdvantage(
            18, 3, [(1, 8)], 0) + calculageAverage(18, 7, [(1, 8)], 7)

    r11 = 3 * calculageAverage(18, 3, [
        (1, 12)
    ], 14) + calculageAverageMultiAdvantage(18, 5, [
        (2, 8)
    ], 0, 3) + 2 * calculageAverageAdvantage(18, 6, [(2, 6)], 3)
    r12 = 3 * calculageAverage(18, 4, [
        (1, 12)
    ], 15) + calculageAverageMultiAdvantage(18, 6, [
        (2, 8)
    ], 0, 3) + 2 * calculageAverageAdvantage(18, 6, [(2, 6)], 3)
    r13 = 3 * calculageAverage(19, 5, [
        (1, 12)
    ], 15) + calculageAverageMultiAdvantage(19, 7, [
        (2, 8)
    ], 0, 3) + 2 * calculageAverageAdvantage(18, 6, [(2, 6)], 3)

    r15 = 3 * calculageAverageAdvantage(19, 5, [
        (1, 12), (1, 6)
    ], 15) + calculageAverageMultiAdvantage(19, 7, [(2, 8)], 0, 6)
    r17 = 3 * calculageAverageAdvantage(20, 6, [
        (1, 12), (1, 6)
    ], 15) + calculageAverageMultiAdvantage(20, 8, [(2, 8)], 0, 6)

    r19 = 3 * calculageAverage(20, 6, [
        (1, 12)
    ], 15) + calculageAverageMultiAdvantage(20, 8, [
        (2, 8)
    ], 0, 3) + 4 * calculageAverageAdvantage(18, 6, [(2, 6)], 3)

    return [
        r01, r02, r03, r04, r05, r06, r07, r08, r09, r09, r11, r12, r13, r13,
        r15, r15, r17, r17, r19, r19
    ]