Tenho dificuldade em lembrar de tudo o que tenho que fazer ao subir de nível um personagem de D&D. Por qualquer motivo, uma das coisas que me causa problemas é descobrir qual deve ser o novo valor máximo da HP. Para esse desafio, você escreverá um programa ou função para calcular o valor correto automaticamente.

Terminologia

A primeira coisa que você precisa saber para calcular o HP máximo é o "modificador de Constituição". Cada caractere DND possui seis pontuações de habilidades inteiras, incluindo uma para Constituição. O único conhecimento relevante necessário para esse desafio é como a pontuação da habilidade de Constituição afeta outra estatística, que é o modificador de Constituição. Em resumo, o modificador é igual a floor( (ability_score - 10) / 2 ). Os aventureiros só podem ter notas de habilidade de 1 a 20, inclusive. Seu código nunca precisará lidar com pontuações fora desse intervalo, o que também significa que nunca precisará lidar com um modificador menor que -5 ou maior que +5. Embora o modificador de Constituição possa mudar à medida que o caractere sobe de nível, seus efeitos sobre a HP são aplicados retroativamente, portanto, apenas seu valor atual é necessário para calcular o máximo de HP atual.

(Isso é totalmente irrelevante para o desafio, mas se você estiver curioso sobre como isso afeta o HP máximo: Você pode assumir que o talento "Difícil" adiciona 2 ao modificador de Constituição de um personagem para fins de cálculo da HP, pois é efetivamente o que ele faz Esse não é o texto da façanha, mas a matemática é exatamente a mesma. Você não precisa lidar com essa façanha na sua resposta.)

Em seguida, toda classe tem um tipo de "dado de batida" atribuído, envolvido no cálculo da HP. A tabela a seguir lista os dados de acerto para cada classe.

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

Finalmente, o nível do personagem. Tudo o que isso afeta é quantas vezes adicionar um valor ao total em execução na seção a seguir. O nível de um personagem é um número inteiro de 1 a 20, inclusive ¹ . Seu código nunca precisará lidar com um nível fora desse intervalo. Para atingir o nível n, um personagem começa no nível 1 e sobe de nível n-1. Por exemplo, um personagem de nível 3 chegou onde está sendo um personagem de nível 1 e subiu de nível duas vezes.

Como calcular o HP máximo

O HP máximo de um personagem é igual ao HP no nível 1 mais a soma do aumento que eles receberam em cada nível.

No nível 1

No nível 1, o HP de um personagem é igual à maior jogada possível no seu dado de acerto (o número no nome do dado, para aqueles que não estão familiarizados com dados com mais de 6 lados) mais o modificador de Constituição. Lembre-se de que, ao calcular o HP em um nível posterior, você pode assumir que a Constituição de um personagem sempre foi a mesma, pois essa parte do cálculo é repetida toda vez que a Constituição for alterada.

Ao subir de nível

Toda vez que um personagem sobe de nível, ele tem duas opções. Eles podem rolar um de seus dados de vida ou fazer o lançamento médio desse dado (arredondado para cima). Qualquer que seja a sua escolha, seu modificador de Constituição é adicionado ao resultado. Esse total é a quantia que o HP deles aumenta. Para esse desafio, o rolo médio é sempre obtido, portanto a produção é determinística. (Novamente, se você não estiver familiarizado com> dados de 6 lados, poderá calcular a média da rolagem arredondada como (highest_possible_roll / 2) + 1.)

Há uma exceção notável. O HP máximo de um personagem sempre aumenta em pelo menos 1 cada vez que ele aumenta de nível ² . Se as instruções no parágrafo acima resultarem em um aumento de 0 ou menos ao subir de nível, ele aumentará em 1.

O desafio

Seu programa ou função terá três entradas :

• A classe do personagem, como uma string
• O nível do personagem
• A pontuação de habilidade de Constituição do personagem ( não modificador)

Ele produzirá apenas uma coisa: o HP máximo atual do personagem.

Exemplos

Todas as combinações possíveis de entradas e saídas associadas podem ser encontradas neste link. Para ter algo para ver nesta página, aqui estão 30 casos de teste escolhidos aleatoriamente:

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. A rigor, não acho que exista uma regra que diga que 20 é o nível máximo. No entanto, 21 é o ponto em que deixa de haver tabelas no livro para dizer quais devem ser alguns dos vários números das regras, incluindo a quantidade de experiência necessária para alcançá-lo. Esse é um limite de nível bom o suficiente para mim.}

^{2. Na verdade, não acho que isso seja verdade com o RAW. Eu perguntei no rpg.se e tal coisa não parece estar escrita em lugar algum. No entanto, Mike Mearls, designer-chefe de D&D, twittou em março de 2015 . Isso não é autoritário da maneira que você poderia argumentar com um tweet do desenvolvedor de regras líder Jeremy Crawford, mas é uma evidência de que é o que eles pretendiam, então eu o usarei para esse desafio.}

Geléia , 34 bytes

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

Programa completo com três argumentos de linha de comando: classe, pontuação, nível.

Experimente online!

Quão?

O meio do código, separado por ðs, é um link diádico que calcula o resultado de alguns valores calculados anteriormente:

+‘»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

O modificador é calculado no lado direito:

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

Metade do valor do dado é calculado no lado esquerdo:

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)

Considerando as somas ordinais do módulo de nomes de classe m, isso mé mínimo e, ao mesmo tempo, impede que as classificações (por matriz) colidam os rendimentos m=15. Colocar os valores necessários (rolo de meia matriz) nesses índices em uma lista de comprimento 15 permite a pesquisa usando a indexação modular da Jelly com ị. A compactação da lista como um número 6 base com o único 6substituído por a 0é um byte mais curto que as alternativas de compactação na base 7 ou na compactação na base 4 e aumentando os valores (com a sobrecarga de bytes associada ao uso de um nilad extra na cadeia) . A descompressão base 6, em vez de 7, é obtida usando o fato de que a descompressão base ṃ(em vez da conversão base b) tem construção implícita de intervalo quando é o argumento correto,r, é um número inteiro, o que significa que é como converter para base re depois alterar qualquer 0um para um de uma rsó vez.

Isso é:

         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

Reorganizando a lista, convertendo o 6 no índice 13 para zero e tornando-o mínimo na base 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

Fazendo o código

                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 bytes

Recebe entrada como (classe, nível, constitution_ability_score) . A classe não diferencia maiúsculas de minúsculas.

(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

Isso é essencialmente usando a mesma matemática da minha versão inicial, mas d agora é calculado sem nenhuma tabela de pesquisa.

Casos de teste

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

Versão inicial, 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

Como funciona

A parte complicada é converter a string de classe c nos dados de acerto correspondentes. Mais precisamente, o valor que vamos armazenar é d = dice / 2 + 1 .

Usamos a fórmula parseInt(c, 35) % 24 % 15que fornece:

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

Inserindo os valores de d nas posições correspondentes em uma string e preenchendo slots não utilizados com zeros, obtemos:

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

Daí a fórmula final:

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

Depois de termos d , calculamos:

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

que é o número teórico de pontos ganhos em cada nível.

Se h for positivo, simplesmente calculamos:

h * l

Caso contrário, precisamos levar em consideração o fato de que pelo menos 1 ponto é ganho em cada nível. Então calculamos:

h + l - 1

Nos dois casos, ajustamos o resultado adicionando d - 2 , para que o número inicial de pontos seja corretamente integrado.

Casos de teste

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

Lote, 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

Recebe classe, nível e constituição como argumentos da linha de comando. Explicação: O HP pode ser calculado como (HP no nível 1) + (nível - 1) + min (HP adicional por nível, 0) * (nível - 1). O HP adicional por nível é metade da matriz de acerto mais o modificador de constituição. A maioria das classes usa d8, então isso se torna um a menos da metade da constituição ( %3/2-1), enquanto o HP no nível 1 é 3 a mais que isso. O HP adicional por nível e o HP no nível 1 são então ajustados para as seis classes que não usam o d8. O HP adicional por nível é então limitado a 0 (na verdade, ele usa o valor negativo, pois é um pouco mais golfista dessa maneira).

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)}

Função anônima. Executa como f(class, level, CON).

Explicação: Cria vetores para a classe sdividir no máximo d, usando a 3ª e a 4ª letras no nome da classe (menor mapeamento exclusivo que encontrei).

O mod CON mé direto da especificação e HP = primeiro nível ( d + m) + o restante dos níveis ( (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