डी एंड डी 5e एचपी कैलकुलेटर

11

मुझे एक डी एंड डी चरित्र को समतल करते समय मुझे जो कुछ भी करना है उसे याद रखने में परेशानी होती है। जो भी कारण के लिए, मुझे परेशान करने वाली चीजों में से एक यह पता लगा रहा है कि उनका नया अधिकतम एचपी मूल्य क्या होना चाहिए। इस चुनौती के लिए, आप स्वचालित रूप से सही मान की गणना करने के लिए एक कार्यक्रम या फ़ंक्शन लिखेंगे।

शब्दावली

अधिकतम एचपी की गणना करने के लिए आपको जिस चीज की जानकारी होनी चाहिए, वह है "संविधान संशोधन"। प्रत्येक DND चरित्र में संविधान के लिए एक सहित छह पूर्णांक क्षमता स्कोर हैं। इस चुनौती के लिए आवश्यक एकमात्र प्रासंगिक ज्ञान यह है कि संविधान की क्षमता स्कोर एक और स्टेट को कैसे प्रभावित करती है, जो संविधान संशोधन है। संक्षेप में, संशोधक के बराबर है floor( (ability_score - 10) / 2 )। एडवेंचरर्स में केवल 1 से 20 तक की क्षमता वाले स्कोर शामिल हो सकते हैं। आपके कोड को उस सीमा से बाहर के स्कोर को कभी भी संभालना नहीं पड़ेगा, जिसका अर्थ यह भी है कि इसे कभी भी -5 से कम या +5 से अधिक संशोधक को संभालना नहीं पड़ेगा। यद्यपि संविधान संशोधन एक चरित्र स्तर के रूप में बदल सकता है, एचपी पर इसके प्रभाव पूर्वव्यापी रूप से लागू होते हैं, इसलिए वर्तमान अधिकतम एचपी की गणना करने के लिए केवल इसके वर्तमान मूल्य की आवश्यकता होती है।

(यह पूरी तरह से चुनौती के लिए अप्रासंगिक है, लेकिन अगर आप इस बारे में उत्सुक हैं कि यह अधिकतम एचपी को कैसे प्रभावित करता है: आप मान सकते हैं कि "कठिन" करतब एचपी गणना के प्रयोजनों के लिए एक चरित्र के संविधान संशोधक में 2 जोड़ता है, क्योंकि यह प्रभावी रूप से क्या करता है (यह करतब का पाठ नहीं है, लेकिन गणित बिल्कुल समान है। आपको अपने जवाब में इस करतब को संभालने की जरूरत नहीं है।)

अगला, हर वर्ग के पास एक "हिट डाई" प्रकार है, जो एचपी की गणना में शामिल है। निम्न तालिका प्रत्येक वर्ग के हिट पासा को सूचीबद्ध करती है।

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

अंत में, चरित्र का स्तर। यह सब प्रभावित करता है कि निम्न अनुभाग में चल रहे कुल में एक मूल्य जोड़ने के लिए कितनी बार है। एक चरित्र का स्तर 1 से 20 तक एक पूर्णांक है, समावेशी 1 । आपके कोड को उस सीमा से बाहर के स्तर को कभी भी संभालना नहीं पड़ेगा। स्तर तक पहुंचने के लिए n, एक चरित्र 1 स्तर पर शुरू होता है और n-1कई बार स्तर होता है। उदाहरण के लिए, एक स्तर 3 चरित्र को मिला जहां वे एक स्तर 1 चरित्र होने और दो बार समतल होने से हैं।

मैक्स एचपी की गणना कैसे करें

एक चरित्र की अधिकतम एचपी उनके एचपी के स्तर 1 के बराबर है और प्रत्येक स्तर पर उन्हें प्राप्त हुई वृद्धि का योग है।

स्तर 1 पर

स्तर 1 पर, एक चरित्र का एचपी उनकी हिट डाई (मरने के नाम पर संख्या, आप में से उन लोगों के लिए अपरिचित है जो 6 से अधिक पक्षों के साथ अपरिचित हैं) प्लस उनके संविधान संशोधन के बराबर है। याद रखें कि बाद के स्तर पर एचपी की गणना करते समय, आप मान सकते हैं कि एक चरित्र का संविधान हमेशा से ऐसा ही रहा है, क्योंकि गणना का यह हिस्सा हर बार संविधान में परिवर्तन किया जाता है।

जब समतल करना

हर बार जब एक चरित्र का स्तर ऊपर होता है, तो उनके पास दो विकल्प होते हैं। वे या तो अपने हिट पासे में से किसी एक को रोल कर सकते हैं या उस डाई (राउंड अप) का औसत रोल ले सकते हैं। जो भी वे चुनते हैं, उनके संविधान संशोधन को परिणाम में जोड़ा जाता है। यह कुल राशि है जो उनके एचपी बढ़ जाती है। इस चुनौती के लिए, औसत रोल हमेशा लिया जाता है, इसलिए आउटपुट नियतात्मक होता है। (फिर, यदि आप> 6 पक्षीय पासा से परिचित नहीं हैं, तो आप गोल-अप औसत रोल की गणना कर सकते हैं (highest_possible_roll / 2) + 1।)

एक उल्लेखनीय अपवाद है। एक चरित्र की अधिकतम एचपी हमेशा कम से कम 1 तक बढ़ जाती है, हर बार वे 2 को ऊपर ले जाते हैं । यदि उपर्युक्त पैराग्राफ में दिए गए निर्देशों के फलस्वरूप 0 या उससे कम की वृद्धि होती है, तो यह 1 के बजाय बढ़ जाता है।

चुनौती

आपका प्रोग्राम या फ़ंक्शन तीन इनपुट लेगा :

  • चरित्र की कक्षा, एक स्ट्रिंग के रूप में
  • चरित्र का स्तर
  • चरित्र की संविधान क्षमता स्कोर ( संशोधक नहीं )

यह केवल एक चीज का उत्पादन करेगा : चरित्र की वर्तमान अधिकतम एचपी।

उदाहरण

इस लिंक पर इनपुट और उनके संबंधित आउटपुट के हर संभव संयोजन को पाया जा सकता है। इस पृष्ठ पर देखने के लिए कुछ होने के लिए, यहां 30 परीक्षण मामलों को यादृच्छिक रूप से चुना गया है:

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. कड़ाई से, मुझे नहीं लगता कि एक नियम है जो कहता है कि 20 अधिकतम स्तर है। हालाँकि, 21 वह बिंदु है, जहां आपको यह बताने के लिए कि विभिन्न संख्याओं में से कुछ में क्या होना चाहिए, यह बताने के लिए पुस्तक में तालिकाओं का होना बंद हो जाता है, जिस तक पहुंचने के लिए आपको कितना अनुभव प्राप्त करना चाहिए। मेरे लिए यह काफी अच्छा स्तर है।

2. मुझे नहीं लगता कि यह रॉ के साथ सच है। मैंने RPG.se पर पूछा और ऐसी बात कहीं भी लिखी हुई नहीं दिखती। हालांकि, डी एंड डी के प्रमुख डिजाइनर, माइक मेयरल्स ने मार्च 2015 में इसे ट्वीट किया । यह आधिकारिक तरीका नहीं है कि आप लीड नियम डेवलपर जेरेमी क्रॉफर्ड के एक ट्वीट पर बहस कर सकते हैं, लेकिन यह सबूत है कि यह वही है जो उनका इरादा था, इसलिए मैं इसे इस चुनौती के लिए उपयोग करूंगा।

code-golf 
— undergroundmonorail
स्रोत
क्या कक्षा को एक स्ट्रिंग के रूप में दिया जाना चाहिए, या इसे हिट मरने की संख्या के रूप में दिया जा सकता है, यह देखते हुए कि एक वर्ग के लिए एकमात्र प्रासंगिक जानकारी है। अन्यथा लोगों को बस "यदि ये वर्ग तब यह मर जाते हैं, यदि ये वर्ग तब यह मर जाते हैं" आदि की सामान्य तालिका की आवश्यकता होगी
— स्काइड्सडेव
इसके अलावा स्तर और संविधान पूर्णांकों के रूप में पारित किए गए हैं, या "xth स्तर" और "y CON" कहे जाने वाले तार के रूप में?
— स्काइडदेव
1
गोश, मैं बूढ़ा हूँ, मुझे अभी भी यह सारणी याद है: acientscrossroads.com/adnd_tools/con_table.htm
— नील
@ मेयूब शायद एक सवाल नहीं पूछा जाना चाहिए और तुरंत पिज्जा, हुह के लिए बाहर चला गया? : पी क्लास को एक स्ट्रिंग होना चाहिए, क्योंकि मुझे लगता है कि टेबल को छोटा करने के लिए पैटर्न खोजने के लिए उन स्ट्रिंग्स में पर्याप्त डेटा है (जो अब तक आए उत्तरों के आधार पर प्रतीत होता है)। स्तर और संविधान जड़ता है।
— भूमिगत
3
मुझे यह बहुत कठिन लगा कि वह मेरे ऊपर फेंकी जा रही सभी सूचनाओं की प्रासंगिक जानकारी को पार्स कर देगा।
— जोनाथन एलन

जवाबों:

2

जेली , 34 बाइट्स

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

फुल प्रोग्राम थ्री कमांड लाइन आर्ग्युमेंट्स: क्लास, स्कोर, लेवल।

इसे ऑनलाइन आज़माएं!

कैसे?

कोड के मध्य, ðs द्वारा अलग किया गया एक डाइएडिक लिंक है जो कुछ पहले से गणना किए गए मानों से परिणाम की गणना करता है:

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

संशोधक की गणना दाहिने हाथ की ओर की जाती है:

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

आधे मरने के मूल्य की गणना बाएं हाथ की ओर की जाती है:

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)

Modulo को ध्यान में रखते वर्ग नामों की क्रमसूचक रकम mऐसी है कि mकम से कम है टकराने की पैदावार से (मरने से) वर्गीकरण रखते हुए m=15। लंबाई 15 की सूची में उन अनुक्रमितों पर आवश्यक मान (आधा-मर रोल) रखने से जेली के मॉड्यूलर अनुक्रमण का उपयोग करके देखने की अनुमति मिलती है ị। सूची को आधार 6 नंबर के रूप में लोन से 6प्रतिस्थापित किया गया है 0, जो आधार -7 कम्प्रेशन या बेस -4 कम्प्रेशन के विकल्पों की तुलना में बाइट से छोटा है और मूल्यों को बढ़ाता है (बाइट ओवरहेड के साथ श्रृंखला में अतिरिक्त निलाद का उपयोग करके जुड़ा हुआ है) । बेस 6, 7 के बजाय, डिकम्प्रेसन को इस तथ्य का उपयोग करके हासिल किया जाता है कि बेस डिकम्प्रेसन, ṃ(बेस रूपांतरण के बजाय b), इसका सही तर्क होने पर अंतर्निहित निर्माण निर्माण होता है,r, एक पूर्णांक है, जिसका अर्थ है कि आधार को रूपांतरित करने rऔर फिर किसी 0एक में rसभी को बदलने के समान है ।

अर्थात्:

         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

सूची में पहुंचना, इंडेक्स 13 में 6 को शून्य में बदलना और इसे बेस 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

कोड बनाना

                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
— जोनाथन एलन
स्रोत
8

जावास्क्रिप्ट (ईएस 6), 81 78 76 74 बाइट्स

(वर्ग, स्तर, संविधान_बिलिटी_स्कोर) के रूप में इनपुट लेता है । वर्ग केस-असंवेदनशील है।

(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

यह अनिवार्य रूप से मेरे प्रारंभिक संस्करण के समान गणित का उपयोग कर रहा है, लेकिन d अब किसी भी लुकअप टेबल के बिना गणना की जाती है।

परीक्षण के मामलों

कोड स्निपेट दिखाएं

प्रारंभिक संस्करण, 87 84 बाइट्स

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

यह काम किस प्रकार करता है

मुश्किल हिस्सा वर्ग स्ट्रिंग सी को इसी हिट पासा में परिवर्तित करना है। अधिक सटीक रूप से, जो मूल्य हम स्टोर करने जा रहे हैं वह d = dice / 2 + 1 है ।

हम उस सूत्र का उपयोग करते हैं parseInt(c, 35) % 24 % 15जो देता है:

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

एक स्ट्रिंग में एक ही स्थिति में d के मानों को सम्मिलित करके और शून्य के साथ अप्रयुक्त स्लॉट्स को पैड करके, हम प्राप्त करते हैं:

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

इसलिए अंतिम सूत्र:

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

एक बार हमारे पास डी है , हम गणना करते हैं:

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

प्रत्येक स्तर पर प्राप्त होने वाले अंकों की सैद्धांतिक संख्या क्या है।

यदि एच पॉजिटिव है, तो हम बस गणना करते हैं:

h * l

यदि नहीं, तो हमें इस तथ्य को ध्यान में रखना होगा कि प्रत्येक स्तर पर कम से कम 1 अंक प्राप्त होता है। इसलिए हम इसके बजाय गणना करते हैं:

h + l - 1

दोनों मामलों में, हम परिणाम को d - 2 जोड़कर समायोजित करते हैं , ताकि प्रारंभिक संख्याओं को सही ढंग से एकीकृत किया जा सके।

परीक्षण के मामलों

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
लगता है कि आपके कोड में कुछ गड़बड़ है; 2 या 3 के CON वाले 1 या विजार्ड वाले Bards को अपने स्तर पर जो भी हिट अंक मिलते हैं।
— नील
1
@ नोट को धन्यवाद देने के लिए धन्यवाद। मुझे लगता है कि यह तय है।
— अरनौलड
3

बैच, 172 बाइट्स

@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

कमांड-लाइन तर्कों के रूप में वर्ग, स्तर और संविधान लेता है। स्पष्टीकरण: एचपी की गणना एचपी (लेवल 1) + (लेवल -1) + मिनट (आगे एचपी प्रति लेवल, 0) * (लेवल - 1) के रूप में की जा सकती है। एचपी प्रति लेवल आगे हिट हिट प्लस संविधान संशोधन है। अधिकांश कक्षाएं d8 का उपयोग करती हैं इसलिए यह आधे से कम संविधान ( %3/2-1) में से एक बन जाता है , जबकि एचपी 1 के स्तर से 3 अधिक है। इसके बाद एचपी प्रति स्तर और एचपी 1 स्तर पर तब छह वर्गों के लिए समायोजित किया जाता है जो डी 8 का उपयोग नहीं करते हैं। प्रति स्तर आगे एचपी 0 तक सीमित है (यह वास्तव में नकारात्मक मूल्य का उपयोग करता है क्योंकि यह इस तरह से थोड़ा गोल्फ खिलाड़ी है।)

— नील
स्रोत
2

आर, 181 163 बाइट्स

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

अनाम फ़ंक्शन। के रूप में चलाता है f(class, level, CON)।

स्पष्टीकरण: कक्षा के sलिए पासा अधिकतम के लिए वैक्टर बनाता है d, वर्ग नाम में 3 और 4 अक्षर का उपयोग करता है (मुझे मिला सबसे छोटा अनोखा मानचित्रण)।

कांग्रेस मॉड mसीधे कल्पना से है, और एचपी = पहला स्तर ( d + m) + शेष स्तर ( (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
— बीएलटी
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.