Ich kann mich nur schwer an alles erinnern, was ich tun muss, um einen D & D-Charakter zu verbessern. Aus irgendeinem Grund ist eines der Dinge, die mir Probleme bereiten, herauszufinden, wie hoch ihr neuer maximaler HP-Wert sein sollte. Für diese Herausforderung schreiben Sie ein Programm oder eine Funktion, um den korrekten Wert automatisch zu berechnen.

Terminologie

Das erste, was Sie wissen müssen, um die maximale HP zu berechnen, ist der "Konstitutionsmodifikator". Jedes DND-Zeichen hat sechs ganzzahlige Fähigkeitswerte, darunter einen für die Konstitution. Das einzige relevante Wissen, das für diese Herausforderung erforderlich ist, ist, wie sich die Bewertung der Konstitutionsfähigkeit auf einen anderen Wert auswirkt, nämlich den Konstitutionsmodifikator. Kurz gesagt, der Modifikator ist gleich floor( (ability_score - 10) / 2 ). Abenteurer können nur Fähigkeitswerte von 1 bis einschließlich 20 haben. Ihr Code muss niemals Punkte außerhalb dieses Bereichs verarbeiten, was auch bedeutet, dass er niemals einen Modifikator verarbeiten muss, der kleiner als -5 oder größer als +5 ist. Obwohl sich der Konstitutionsmodifikator mit zunehmender Charakterstufe ändern kann, werden seine Auswirkungen auf HP rückwirkend angewendet, sodass nur sein aktueller Wert zur Berechnung der aktuellen maximalen HP benötigt wird.

(Dies ist für die Herausforderung völlig irrelevant, aber wenn Sie neugierig sind, wie sich dies auf die maximale HP auswirkt: Sie können davon ausgehen, dass das Talent "Tough" dem Konstitutionsmodifikator eines Charakters für die Zwecke der HP-Berechnung 2 hinzufügt, da dies effektiv der Fall ist Das ist nicht der Text des Kunststücks, aber die Mathematik funktioniert genau gleich. Sie müssen dieses Kunststück in Ihrer Antwort nicht behandeln.)

Als nächstes hat jede Klasse einen "Trefferwürfel" -Typ zugewiesen, der an der Berechnung der HP beteiligt ist. In der folgenden Tabelle sind die Trefferwürfel für jede Klasse aufgeführt.

Sorcerer:  d6
Wizard:    d6
Bard:      d8
Cleric:    d8
Druid:     d8
Monk:      d8
Rogue:     d8
Warlock:   d8
Fighter:   d10
Paladin:   d10
Ranger:    d10
Barbarian: d12

Schließlich das Level des Charakters. Dies wirkt sich lediglich darauf aus, wie oft im laufenden Abschnitt ein Wert zur laufenden Summe hinzugefügt werden soll. Die Stufe eines Charakters ist eine ganze Zahl von 1 bis 20, einschließlich ¹ . Ihr Code muss niemals eine Ebene außerhalb dieses Bereichs verarbeiten. Um ein Level zu erreichen n, beginnt ein Charakter mit Level 1 und erhöht die n-1Zeiten. Zum Beispiel kam ein Charakter der Stufe 3 dahin, wo er sich befindet, indem er ein Charakter der Stufe 1 war und zweimal aufstieg.

So berechnen Sie die maximale HP

Die maximale HP eines Charakters entspricht seiner HP auf Stufe 1 plus der Summe der Erhöhung, die er auf jeder Stufe erhalten hat.

Auf Stufe 1

Auf Stufe 1 entspricht die HP eines Charakters dem höchstmöglichen Wurf auf seinem Trefferwürfel (die Zahl im Namen des Würfels für diejenigen unter Ihnen, die mit Würfeln mit mehr als 6 Seiten nicht vertraut sind) plus ihrem Konstitutionsmodifikator. Denken Sie daran, dass Sie bei der Berechnung von HP auf einer späteren Ebene davon ausgehen können, dass die Konstitution eines Charakters immer dieselbe war, da dieser Teil der Berechnung jedes Mal wiederholt wird, wenn sich die Konstitution ändert.

Beim Aufstieg

Jedes Mal, wenn ein Charakter aufsteigt, haben sie zwei Möglichkeiten. Sie können entweder einen ihrer Trefferwürfel werfen oder den durchschnittlichen Wurf dieses Würfels (aufgerundet) nehmen. Unabhängig davon, was sie wählen, wird ihr Konstitutionsmodifikator zum Ergebnis hinzugefügt. Diese Summe ist der Betrag, um den sich ihre HP erhöhen. Für diese Herausforderung wird immer der durchschnittliche Wurf genommen, sodass die Ausgabe deterministisch ist. (Wenn Sie nicht mit> 6-seitigen Würfeln vertraut sind, können Sie den aufgerundeten Durchschnittswurf als berechnen (highest_possible_roll / 2) + 1.)

Es gibt eine bemerkenswerte Ausnahme. Die maximale HP eines Charakters erhöht sich jedes Mal um mindestens 1, wenn er ² erhöht . Wenn die Anweisungen im obigen Absatz beim Aufsteigen zu einer Erhöhung von 0 oder weniger führen würden, wird sie stattdessen um 1 erhöht.

Die Herausforderung

Ihr Programm oder Ihre Funktion benötigt drei Eingaben :

• Die Klasse des Charakters als Zeichenfolge
• Das Level des Charakters
• Die Konstitutionsfähigkeit des Charakters ( kein Modifikator)

Es wird nur eines ausgegeben : die aktuellen maximalen HP des Charakters.

Beispiele

Jede mögliche Kombination von Eingängen und den dazugehörigen Ausgängen finden Sie unter diesem Link. Um auf dieser Seite etwas zu sehen, sind hier 30 zufällig ausgewählte Testfälle:

Barbarian, 15th level, 13 CON: 125
    Rogue, 10th level, 18 CON: 93
   Wizard, 15th level, 18 CON: 122
   Wizard, 16th level,  1 CON: 16
Barbarian, 15th level,  7 CON: 80
  Warlock, 15th level,  3 CON: 18
   Ranger, 14th level,  1 CON: 18
  Warlock,  3rd level, 14 CON: 24
    Druid,  3rd level,  4 CON: 9
   Cleric, 11th level,  5 CON: 25
     Bard, 20th level, 11 CON: 103
Barbarian, 11th level, 13 CON: 93
     Bard,  8th level, 19 CON: 75
     Bard, 16th level, 17 CON: 131
  Fighter, 10th level,  6 CON: 44
     Monk, 10th level,  2 CON: 13
   Cleric, 14th level, 17 CON: 115
   Cleric,  6th level,  5 CON: 15
    Rogue,  7th level, 13 CON: 45
   Cleric,  4th level, 14 CON: 31
    Rogue, 19th level, 15 CON: 136
  Paladin, 13th level, 13 CON: 95
   Cleric, 13th level, 15 CON: 94
     Bard,  8th level,  5 CON: 19
     Monk, 20th level, 11 CON: 103
Barbarian,  8th level, 20 CON: 101
     Monk,  1st level,  4 CON: 5
     Bard,  5th level, 17 CON: 43
     Monk, 18th level,  7 CON: 57
   Wizard, 17th level,  5 CON: 19

^{1. Genau genommen glaube ich nicht, dass es eine Regel gibt, die besagt, dass 20 das maximale Level ist. 21 ist jedoch der Punkt, an dem es keine Tabellen mehr im Buch gibt, die Ihnen sagen, welche der verschiedenen Zahlen in den Regeln enthalten sein sollten, einschließlich der Menge an Erfahrung, die Sie benötigen, um sie zu erreichen. Das ist eine gute Levelobergrenze für mich.}

^{2. Ich glaube nicht, dass dies bei RAW der Fall ist. Ich habe auf rpg.se gefragt und so etwas scheint nirgendwo aufgeschrieben zu sein. Mike Mearls, Hauptdesigner von D & D, hat es jedoch im März 2015 getwittert . Dies ist nicht maßgeblich, wie Sie einen Tweet des führenden Regelentwicklers Jeremy Crawford argumentieren könnten, aber es ist ein Beweis dafür, dass es das ist, was sie beabsichtigt haben, also werde ich es für diese Herausforderung verwenden.}

Gelee , 34 Bytes

OSị“#®Ʋ?[’ṃ6¤ð+‘»1×⁵’¤+⁸Ḥ¤+ð⁹_10:2

Vollständiges Programm mit drei Befehlszeilenargumenten: Klasse, Punktzahl, Stufe.

Probieren Sie es online aus!

Wie?

Die durch ðs getrennte Mitte des Codes ist eine dyadische Verknüpfung, die das Ergebnis aus einigen zuvor berechneten Werten berechnet:

+‘»1×⁵’¤+⁸Ḥ¤+ - maxHitPoints(halfDieValue, modifier)
+             - add: halfDieValue + modifier
 ‘            - increment
  »1          - maximum of that and 1: this is the level-up delta
       ¤      - nilad followed by links as a nilad:
     ⁵        -   program's 3rd argument, level (5th command line argument)
      ’       -   decrement: this is the number of level-ups
    ×         - multiply: level-ups * level-up delta
           ¤  - nilad followed by links as a nilad:
         ⁸    -   link's left argument: halfDieValue
          Ḥ   -   double: dieValue
        +     - add: level-ups * level-up delta + dieValue
            + - add: level-ups * level-up delta + dieValue + modifier

Der Modifikator wird auf der rechten Seite berechnet:

⁹_10:2 - getModifier(class, score)
⁹      - link's right argument, the 2nd argument, the score
 _10   - minus 10
    :2 - integer divide by 2

Die Hälfte des Werkzeugwerts wird auf der linken Seite berechnet:

OSị“#®Ʋ?[’ṃ6¤ - getHalfDieValue(class)
O             - cast to ordinals
 S            - sum
            ¤ - nilad followed by link(s) as a nilad:
   “#®Ʋ?[’    -   base 250 literal 140775266092
          ṃ6  -   convert to base 6 but with 6s in place of 0s
  ị           - index into (1-indexed and modular)

Berücksichtigt man die Ordnungssummen der Klassennamen modulo mso, dass sie mminimal sind, während die Klassifikationen (nach Würfel) nicht kollidieren m=15. Wenn Sie die erforderlichen Werte (Half-Die-Roll) an diesen Indizes in einer Liste mit der Länge 15 platzieren, können Sie mithilfe der modularen Indizierung von Jelly mit nachschlagen ị. Das Komprimieren der Liste als Basis-6-Zahl, wobei der Einzelne 6durch a ersetzt wird, 0ist ein Byte kürzer als die Alternativen der Basis-7-Komprimierung oder der Basis-4-Komprimierung und erhöht die Werte (mit dem Byte-Overhead, der mit der Verwendung eines zusätzlichen Nullpunkts in der Kette verbunden ist). . Die Dekomprimierung der Basis 6 anstelle von 7 wird erreicht, indem die Tatsache verwendet wird, dass die Dekomprimierung der Basis ṃ(anstelle der Basiskonvertierung b) eine implizite Bereichskonstruktion aufweist, wenn das richtige Argument vorliegt.rist eine Ganzzahl, was bedeutet, rdass Sie 0in eine Basis konvertieren und dann eine beliebige in eine rAll-in-One-Funktion ändern .

Das ist:

         class: Sorcerer,Wizard,Bard,Cleric,Druid,Monk,Rogue,Warlock,Fighter,Paladin,Ranger,Barbarian
   Ordinal sum: 837,     625,   377, 594,   504,  405, 514,  723,    713,    697,    607,   898
        mod 15:  12,      10,     2,   9,     9,    0,   4,    3,      8,      7,      7,    13
required value:   3,       3,     4,   4,     4,    4,   4,    4,      5,      5,      5,     6

Neuanordnen in die Liste, Konvertieren der 6 bei Index 13 in eine Null und Minimieren in Basis 6:

mod 15:    2   3   4           7   8   9  10      12  13      0  
 value: 1, 4,  4,  4,  0,  0,  5,  5,  4,  3,  0,  3,  0,  0,  4

Den Code erstellen

                list: [1,4,4,4,0,0,5,5,4,3,0,3,0,0,4]
         from base 6: 140775266092
         to base 250: [36,9,154,64,92]
code page characters:   # ®   Ʋ  ?  [
          final code: “#®Ʋ?[’ṃ6

JavaScript (ES6), 81 78 76 74 Byte

Nimmt die Eingabe als (Klasse, Ebene, Constitution_ability_score) . Die Klasse unterscheidet nicht zwischen Groß- und Kleinschreibung.

(c,l,s,h=(d=parseInt(c,34)*59.9%97%77%6|4)+(s-10>>1))=>(h>0?h*l:h+l-1)+d-2

Dies verwendet im Wesentlichen dieselbe Mathematik wie meine ursprüngliche Version, aber d wird jetzt ohne Nachschlagetabelle berechnet.

Testfälle

let f =

(c,l,s,h=(d=parseInt(c,34)*59.9%97%77%6|4)+(s-10>>1))=>(h>0?h*l:h+l-1)+d-2

console.log(f('Barbarian', 15, 13))  // 125
console.log(f('Rogue',     10, 18))  // 93
console.log(f('Wizard',    15, 18))  // 122
console.log(f('Wizard',    16,  1))  // 16
console.log(f('Barbarian', 15,  7))  // 80
console.log(f('Warlock',   15,  3))  // 18
console.log(f('Ranger',    14,  1))  // 18
console.log(f('Warlock',    3, 14))  // 24
console.log(f('Druid',      3,  4))  // 9
console.log(f('Cleric',    11,  5))  // 25
console.log(f('Bard',      20, 11))  // 103
console.log(f('Barbarian', 11, 13))  // 93
console.log(f('Bard',       8, 19))  // 75
console.log(f('Bard',      16, 17))  // 131
console.log(f('Fighter',   10,  6))  // 44
console.log(f('Monk',      10,  2))  // 13
console.log(f('Cleric',    14, 17))  // 115
console.log(f('Cleric',     6,  5))  // 15
console.log(f('Rogue',      7, 13))  // 45
console.log(f('Cleric',     4, 14))  // 31
console.log(f('Rogue',     19, 15))  // 136
console.log(f('Paladin',   13, 13))  // 95
console.log(f('Cleric',    13, 15))  // 94
console.log(f('Bard',       8,  5))  // 19
console.log(f('Monk',      20, 11))  // 103
console.log(f('Barbarian',  8, 20))  // 101
console.log(f('Monk',       1,  4))  // 5
console.log(f('Bard',       5, 17))  // 43
console.log(f('Monk',      18,  7))  // 57
console.log(f('Wizard',    17,  5))  // 19

Anfangsversion, 87 84 Bytes

(c,l,s,h=(d=+'55654607554506'[parseInt(c,35)%24%15])+(s-10>>1))=>(h>0?h*l:h+l-1)+d-2

Wie es funktioniert

Der schwierige Teil besteht darin, die Klassenzeichenfolge c in die entsprechenden Trefferwürfel umzuwandeln . Genauer gesagt ist der Wert, den wir speichern werden, d = Würfel / 2 + 1 .

Wir verwenden die Formel, parseInt(c, 35) % 24 % 15die ergibt:

Class       | Base 35 -> decimal | MOD 24 | MOD 15 | d
------------+--------------------+--------+--------+---
"Sorcerer"  |      1847055419467 |     19 |      4 | 4
"Wizard"    |               1138 |     10 |     10 | 4
"Bard"      |             484833 |      9 |      9 | 5
"Cleric"    |          662409592 |     16 |      1 | 5
"Druid"     |           20703143 |     23 |      8 | 5
"Monk"      |             973475 |     11 |     11 | 5
"Rogue"     |           41566539 |      3 |      3 | 5
"Warlock"   |        59391165840 |      0 |      0 | 5
"Fighter"   |        28544153042 |      2 |      2 | 6
"Paladin"   |        46513817828 |     20 |      5 | 6
"Ranger"    |         1434103117 |     13 |     13 | 6
"Barbarian" |     25464249364423 |      7 |      7 | 7

Durch Einfügen der Werte von d an den entsprechenden Positionen in eine Zeichenfolge und Auffüllen nicht verwendeter Slots mit Nullen erhalten wir:

00000000001111
01234567890123
--------------
55654607554506

Daher die endgültige Formel:

d = +'55654607554506'[parseInt(c, 35) % 24 % 15]

Sobald wir d haben , berechnen wir:

h = d + ((s - 10) >> 1))

Dies ist die theoretische Anzahl von Punkten, die bei jedem Level-Up erzielt werden.

Wenn h positiv ist, berechnen wir einfach:

h * l

Wenn nicht, müssen wir berücksichtigen, dass bei jedem Level mindestens 1 Punkt erreicht wird. Also berechnen wir stattdessen:

h + l - 1

In beiden Fällen passen wir das Ergebnis durch Hinzufügen von d - 2 an , sodass die anfängliche Anzahl von Punkten korrekt integriert ist.

Testfälle

let f =

(c,l,s,h=(d=+'55654607554506'[parseInt(c,35)%24%15])+(s-10>>1))=>(h>0?h*l:h+l-1)+d-2

console.log(f('Barbarian', 15, 13))  // 125
console.log(f('Rogue',     10, 18))  // 93
console.log(f('Wizard',    15, 18))  // 122
console.log(f('Wizard',    16,  1))  // 16
console.log(f('Barbarian', 15,  7))  // 80
console.log(f('Warlock',   15,  3))  // 18
console.log(f('Ranger',    14,  1))  // 18
console.log(f('Warlock',    3, 14))  // 24
console.log(f('Druid',      3,  4))  // 9
console.log(f('Cleric',    11,  5))  // 25
console.log(f('Bard',      20, 11))  // 103
console.log(f('Barbarian', 11, 13))  // 93
console.log(f('Bard',       8, 19))  // 75
console.log(f('Bard',      16, 17))  // 131
console.log(f('Fighter',   10,  6))  // 44
console.log(f('Monk',      10,  2))  // 13
console.log(f('Cleric',    14, 17))  // 115
console.log(f('Cleric',     6,  5))  // 15
console.log(f('Rogue',      7, 13))  // 45
console.log(f('Cleric',     4, 14))  // 31
console.log(f('Rogue',     19, 15))  // 136
console.log(f('Paladin',   13, 13))  // 95
console.log(f('Cleric',    13, 15))  // 94
console.log(f('Bard',       8,  5))  // 19
console.log(f('Monk',      20, 11))  // 103
console.log(f('Barbarian',  8, 20))  // 101
console.log(f('Monk',       1,  4))  // 5
console.log(f('Bard',       5, 17))  // 43
console.log(f('Monk',      18,  7))  // 57
console.log(f('Wizard',    17,  5))  // 19

Stapel, 172 Bytes

@set/aa=1-%3/2,h=4-a
@for %%c in (-1.Sorcerer -1.Wizard 1.Fighter 1.Paladin 1.Ranger 2.Barbarian)do @if %%~xc==.%1 set/aa-=c=%%~nc,h+=c*2
@cmd/cset/a"a*=(a>>9),-~a*~-%2+h

Nimmt Klasse, Ebene und Konstitution als Befehlszeilenargumente. Erläuterung: Die HP können berechnet werden als (HP auf Stufe 1) + (Stufe - 1) + min (weitere HP pro Stufe, 0) * (Stufe - 1). Die weiteren HP pro Level sind die Hälfte des Trefferwürfels plus des Konstitutionsmodifikators. Die meisten Klassen verwenden d8, so dass dies weniger als die Hälfte der Konstitution ist ( %3/2-1), während die HP auf Stufe 1 3 mehr sind. Die weiteren HP pro Stufe und HP auf Stufe 1 werden dann für die sechs Klassen angepasst, die d8 nicht verwenden. Die weiteren HP pro Level sind dann auf 0 begrenzt (dies verwendet tatsächlich den negativen Wert, da es auf diese Weise etwas golfiger ist.)

R, 181 163 Bytes

function(s,n,t){a=Hmisc::Cs(rc,za,rd,er,ui,mk,gu,rl,gh,la,ng,rb)
b=c(6,6,rep(8,6),rep(10,3),12)
d=b[a == substr(s,3,4)]
m=floor((t-10)/2)
d+m+(n-1)*max(d/2+1+m,1)}

Anonyme Funktion. Läuft als f(class, level, CON).

Erläuterung: Erstellt Vektoren für die Klasse, sum maximal zu würfeln d, wobei der 3. und 4. Buchstabe im Klassennamen verwendet werden (kleinste eindeutige Zuordnung, die ich gefunden habe).

CON mod mist direkt aus der Spezifikation und HP = erste Ebene ( d + m) + die restlichen Ebenen ( (n-1) * max(average_die + m, 1).

> f("Barbarian", 15, 13)
[1] 125
> f("Rogue", 10, 18)
[1] 93
> f("Wizard", 15, 18)
[1] 122
> f("Wizard", 16, 1)
[1] 16
> f("Barbarian", 15, 7)
[1] 80
> f("Warlock", 15, 3)
[1] 18
> f("Ranger", 14, 1)
[1] 18