नियमसेट के चेक

इस पेज की मदद से तय करें कि आपका नियमसेट चेक या सेव कैसे रोल करे: हल करने के पाँच प्रकार, नतीजे के बैंड, अपने अलग तरीके से रोल होने वाले चेक, और रोल बदलने वाले खर्च या चार्म। यह पेज नियमसेट लिखने वालों के लिए है। शुरू करने से पहले Game Mode के नियमसेट लिखना पढ़ें।

हल करने के प्रकार

resolution.kind चुनता है कि चेक कैसे रोल हो। हर प्रकार एक ही कैरेक्टर शीट पढ़ता है और तीन कुंजियाँ साझा करता है, इसलिए प्रकार बदलने पर फ़ाइल में resolution के नीचे के भाग नहीं बदलते:

abilityModifier: शीट का स्कोर संख्या कैसे बनता है। identity में स्कोर ही संख्या है। floorHalfMinusTen 5e का नियम है। stepTable आपको अपनी सीमाएँ [[score, number], ...] के रूप में देने देता है।
proficiencyTiers: स्किल या सेव के प्रशिक्षण स्तर। सूची में न दी गई स्किल को पहला स्तर मिलता है। स्तर flat, या दक्षता बोनस का multiplier गुना, या दोनों जोड़ता है। आपके सिस्टम में दक्षता बोनस हो तो "proficiency": { "bonus": { "derived": "proficiency_bonus" } } से बताएँ कि वह कहाँ से आता है।
proficiency: वैकल्पिक; सिर्फ़ गुणा करने वाले स्तर को इसकी ज़रूरत होती है।

निकली संख्या का मतलब प्रकार तय करता है: dice-sum उसे रोल में जोड़ता है, dice-pool और dice-highest उतने डाइस फेंकते हैं। symbol-pool नैरेटिव डाइस बनाने और अपग्रेड करने के लिए एबिलिटी और प्रशिक्षण को अलग रखता है।

`dice-sum`: डाइस जोड़ना

"resolution": {
  "kind": "dice-sum",
  "dice": { "count": 2, "sides": 6 },
  "abilityModifier": { "op": "identity" },
  "proficiencyTiers": [
    { "id": "untrained", "label": "Untrained" },
    { "id": "trained", "label": "Trained", "flat": 1 }
  ],
  "advantage": false,
  "difficultyLadder": [
    { "label": "Easy", "dc": 6 },
    { "label": "Hard", "dc": 10 }
  ]
}

dice: कितने डाइस और उनमें कितने फलक। कुल की तुलना कठिनाई से होती है।
advantage: क्या Game Master डाइस दो बार रोल करवाकर एक रोल रखने को कह सकता है।
naturals: एक डाइस का सबसे ऊँचा और सबसे नीचा फलक चेक और सेव पर क्या करता है: none, both, max-only या min-only। सिर्फ़ गणित चाहिए तो इसे छोड़ दें। इसके लिए एक ही डाइस चाहिए, इसलिए 2d6 सिस्टम को none इस्तेमाल करना होगा।
dice.faces: हर फलक का मान, सबसे नीचे वाला फलक पहले, जहाँ फलक अपनी ही संख्या नहीं होते (Capability API 1.136)। Fate के चार Fudge डाइस { "count": 4, "sides": 3, "faces": [-1, 0, 1] } हैं: कार्ड −, खाली और + दिखाता है और उन्हें जोड़ता है, और संभावनाएँ ठीक Fate वाली ही रहती हैं। हर फलक के लिए एक मान दें।
openEnded: ऐसा अकेला डाइस जो आगे रोल होता रहता है (1.136)। high या उससे ऊपर का फलक फिर रोल होकर जुड़ता है, और तब तक फिर, जब तक नया डाइस high या उससे ज़्यादा दिखाए; low या उससे नीचे का फलक फिर रोल होकर घटता है, और वह रोल भी high पर उसी तरह आगे बढ़ता है। Rolemaster का खुला प्रतिशत रोल एक d100 पर { "high": 96, "low": 5 } है। एक रोल अधिकतम 20 डाइस फेंकता है। प्राकृतिक फलक, और बैंड का खिसकना, पहला डाइस पढ़ते हैं।
unmodified: एक डाइस के वे फलक जिन्हें रिकॉर्ड तब चिह्नित करता है जब पहला डाइस उन्हें दिखाए (1.136), ताकि "बिना बदलाव वाले 66" को अलग से मानने वाली टेबल लागू की जा सकें: [66, 100]। रिकॉर्ड unmodified="66" कहता है, कार्ड भी यही कहता है, और Game Master को बताया जाता है कि नियम इसके बारे में जो कहते हैं वह लागू करे।
difficultyLadder: वे कठिनाइयाँ जिनमें से Game Master को चुनने को कहा जाता है। dc वह संख्या है जहाँ तक कुल को पहुँचना है। Game Master संख्या लिखने के बजाय चरण का नाम भी दे सकता है, जैसे difficulty="Hard", और Engine संख्या उस चरण से पढ़ लेता है।

`dice-pool`: डाइस फेंककर गिनना

शीट की संख्या पूल का आकार है, उसके ऊपर जुड़ने वाला बोनस नहीं। रेटिंग 3 और 2 वाला पेशा मिलकर पाँच डाइस फेंकते हैं। पूरी तरकीब यही है: न नई शीट शब्दावली, न नया एडिटर, और जिस सिस्टम की रेटिंग मुट्ठी भर डाइस होती हैं, वह भी बाकी सबकी तरह वही abilities, skills और proficiencyTiers इस्तेमाल करके लिखा जाता है।

"resolution": {
  "kind": "dice-pool",
  "die": { "sides": 10 },
  "abilityModifier": { "op": "identity" },
  "proficiencyTiers": [
    { "id": "rating_0", "label": "Untried" },
    { "id": "rating_1", "label": "Shown once", "flat": 1 }
  ],
  "pool": { "min": 1, "max": 15, "abilityPlusAbility": true },
  "target": { "default": 7, "min": 5, "max": 9 },
  "explode": { "from": 10, "min": 8 },
  "cancel": { "upTo": 1 },
  "botch": { "upTo": 1 },
  "exceptional": { "successes": 5 },
  "situationalDice": { "min": -3, "max": 3 },
  "reroll": [{ "id": "careful", "upTo": 6, "mode": "once" }],
  "difficultyLadder": [
    { "label": "Plain work", "successes": 1, "target": 6 },
    { "label": "Grim", "successes": 3, "target": 8 }
  ]
}

die: पूल के एक डाइस में कितने फलक हैं, 2 से 100 तक।
pool: किसी भी डाइस के विस्फोट से पहले शीट की संख्या किस दायरे में रखी जाती है। min 0 होने पर खाली पूल बिना किसी रोल के विफल हो सकता है, और max अधिकतम 100 हो सकता है। abilityPlusAbility: true एबिलिटी चेक को with= से दूसरी एबिलिटी का नाम देने और दोनों के डाइस फेंकने देता है, उन सिस्टम के लिए जो दो एट्रिब्यूट साथ रोल करते हैं; इसके बिना एबिलिटी चेक पर with= का कोई मतलब नहीं।
target: गिने जाने के लिए डाइस को जिस फलक तक पहुँचना है। min को max से कम लिखें तो Game Master हर चेक में threshold= से इसे बदल सकता है; तीनों बराबर लिखें तो लक्ष्य तय रहता है।
double: वैकल्पिक। from या उससे ऊपर का फलक दो बार गिना जाता है।
explode: वैकल्पिक। from या उससे ऊपर का फलक एक और डाइस रोल करवाता है, और इस तरह जुड़ा डाइस भी आगे विस्फोट कर सकता है। अतिरिक्त डाइस पूल के ऊपर pool.max तक सीमित हैं, इसलिए एक चेक अधिकतम pool.max के दोगुने डाइस फेंकता है और छोटा from हमेशा रोल करवाता नहीं रह सकता।
दोनों में min हो सकता है: वह सबसे नीचा फलक जहाँ तक कोई चेक नियम को नीचे ला सकता है, टैग पर explode="N" या double="N" से, या कैरेक्टर की इस्तेमाल की गई एंट्री से। min हो तो आप from छोड़ सकते हैं, और तब नियम सिर्फ़ उसी चेक पर चलता है जो उसे माँगे: एक स्किल पर दस को फिर रोल करवाने वाली विशेषज्ञता "explode": { "min": 10 } है। from, min से नीचे नहीं हो सकता।
cancel: वैकल्पिक। upTo या उससे नीचे का फलक एक सफलता घटाता है। गिनती शून्य से नीचे नहीं जाती।
botch: वैकल्पिक। जब कोई डाइस सफल न हो और upTo या उससे नीचे का फलक आए, तो चेक गंभीर विफलता है। जिस पूल की इकलौती सफलता रद्द हो गई, वह विफल हुआ है, गंभीर विफल नहीं। "rule": "halfOrMore" इसे दूसरी तरह पढ़ता है: पहली बार फेंके गए कम से कम आधे डाइस (विस्फोट नहीं गिने जाते) पर upTo या उससे नीचे के फलक, कोई डाइस सफल न होने पर गंभीर विफलता हैं; वरना वे नतीजे को बना रहने देते हैं और उसे complication="true" चिह्नित करते हैं, यानी नतीजे के साथ कुछ गलत भी हो रहा है। "noSuccesses" डिफ़ॉल्ट है।
exceptional: वैकल्पिक। सफल चेक में इतनी या इससे ज़्यादा शुद्ध सफलताएँ असाधारण सफलता हैं।
situationalDice: वैकल्पिक। करतब, घाव या खराब रोशनी के लिए Game Master एक चेक में bonus= से कितने डाइस जोड़ या घटा सकता है, इसका दायरा।
reroll: वैकल्पिक। दोबारा फेंकने की वे छूटें जो सिस्टम बिना किसी कीमत के देता है, अधिकतम छह, हर एक के id के साथ जिसका नाम Game Master चेक पर reroll= से देता है। upTo या उससे नीचे के फलक फिर फेंके जाते हैं: "once" में नया फलक जो भी हो वही रहता है, और "until" में तब तक फेंके जाते हैं जब तक ऊपर का फलक न आए। upTo 1 से लेकर डाइस के फलकों से एक कम तक होता है, क्योंकि हर फलक को दोबारा फेंकना कभी नहीं रुकेगा, और until वैसे भी एक चेक पर सौ बार दोबारा फेंकने के बाद रुक जाता है। जब तक चेक नाम न दे, कोई भी दोबारा नहीं फेंका जाता। एक चेक एक ही बार दोबारा फेंकता है: जहाँ किसी खर्च या कैरेक्टर की इस्तेमाल की गई एंट्री ने भी एक खरीदा हो, वहाँ ज़्यादा फलकों तक पहुँचने वाला फेंका जाता है, और बराबर पहुँच होने पर once के बजाय until।
difficultyLadder: successes बताता है कि चेक को कितनी सफलताएँ चाहिए। चरण target भी बता सकता है, लेकिन सिर्फ़ तब जब लक्ष्य बदला जा सकता हो और सिर्फ़ उसके दायरे के अंदर। उस चरण के चेक में यही लक्ष्य गिना जाता है: जब Game Master difficulty= से चरण का नाम देता है, या ऐसा dc= लिखता है जिसकी ज़रूरत ठीक एक चरण को है। जहाँ कई चरणों को उतनी ही सफलताएँ चाहिए, वहाँ अकेला dc= नहीं बता सकता कि किसका मतलब था, इसलिए लक्ष्य डिफ़ॉल्ट रहता है; चरण का नाम दें।

target.from: वैकल्पिक। हर कैरेक्टर का लक्ष्य उसकी शीट से पढ़ता है, जैसे Lasers & Feelings का Number, जिसे कैरेक्टर एक बार चुनता है (कोई भी वैल्यू रेफ़रेंस: एबिलिटी, फ़ील्ड, निकाला गया मान)। इसे min..max के अंदर रखा जाता है, और threshold= इसे नहीं हिलाता, क्योंकि यह संख्या कैरेक्टर की अपनी है; कैरेक्टर की इस्तेमाल की गई एंट्री का खरीदा हुआ लक्ष्य इसे फिर भी हिलाता है। रिकॉर्ड का threshold= बताता है कि क्या इस्तेमाल हुआ।
stances: वैकल्पिक। अधिकतम छह, हर एक में id, label, count ("below" या "above") और वे skills जिन्हें वह शामिल करता है। इनमें से किसी स्किल का चेक लक्ष्य के बराबर या ऊपर वाले डाइस के बजाय लक्ष्य से नीचे या उससे ऊपर वाले डाइस गिनता है: Lasers & Feelings में Lasers रुख नीचे गिनता है और Feelings रुख ऊपर, और हर स्किल इनमें से किसी एक में होती है। एक स्किल सिर्फ़ एक रुख में हो सकती है। रुख explode, double, cancel और botch को छोड़ देते हैं, क्योंकि ये "बराबर या ऊपर" के हिसाब से पढ़े जाते हैं।
exact: वैकल्पिक। ठीक लक्ष्य दिखाने वाला डाइस: label उसका नाम देता है ("LASER FEELINGS"), text बता सकता है कि टेबल पर वह क्या करता है, और जब तक counts false न हो, वह एक सफलता गिना जाता है। रिकॉर्ड में exact="N" होता है, यानी ऐसे डाइस की संख्या, और डाइस कार्ड इसे नतीजे के बगल में दिखाता है, ताकि Game Master खिलाड़ी को वह अंतर्दृष्टि दे सके जो इससे मिलती है।

cancel और botch के फलक सबसे छोटे लक्ष्य से नीचे होने चाहिए, और इन नियमों में बताया गया हर फलक डाइस पर मौजूद होना चाहिए। कभी न चल सकने वाला नियम खेल में पता चलने के बजाय इंपोर्ट पर ही अस्वीकार हो जाता है।

पैकेज के रूप में दिया गया पूल नियमसेट Capability API 1.24 है; explode या double पर min, pool.abilityPlusAbility और botch.rule 1.37 हैं; reroll 1.38 है; target.from, stances और exact 1.137 हैं। आपका इंपोर्ट किया सामुदायिक नियमसेट उसे पढ़ने वाला Engine जाँचता है, इसलिए उसे कुछ और नहीं चाहिए।

पूल चेक में Game Master क्या लिख सकता है

[skill_check: skill="Ward" dc="2" who="Bram the Quiet" threshold="8" bonus="-2" with="Sinew"]
[skill_check: skill="Ward" difficulty="Grim" explode="9"]
[skill_check: skill="Nerve" dc="1" with="Warmth"]
[skill_check: skill="Ward" dc="2" reroll="careful"]

dc ज़रूरी सफलताओं की संख्या है, लक्ष्य संख्या नहीं। यह 1 से लेकर उस सबसे बड़ी संख्या तक कुछ भी हो सकता है जो एक रोल कभी गिन सकता है: पूल का अधिकतम, डाइस के विस्फोट कर सकने पर दोगुना, और फलकों के दो बार गिने जाने पर फिर दोगुना।
threshold= हर डाइस का लक्ष्य बदलता है, और सिर्फ़ तब मिलता है जब target.min, target.max से कम हो।
bonus= डाइस जोड़ता या घटाता है, और सिर्फ़ तब मिलता है जब situationalDice घोषित हो।
with= स्किल या सेव को उसकी अपनी एबिलिटी के बजाय दूसरी एबिलिटी से रोल करता है। यह दोनों प्रकारों में चलता है, इसलिए 5e नियमसेट को उसी एट्रिब्यूट से "Strength (Intimidation)" मिलता है। एबिलिटी चेक पर, जहाँ pool.abilityPlusAbility चालू है, यह इसके बजाय दूसरी एबिलिटी जोड़ता है।
difficulty= दोनों प्रकारों में dc= की जगह सीढ़ी के चरण का नाम देता है: उसकी सफलताएँ (या जोड़ वाले रोल पर उसकी कठिनाई) और, पूल पर, उसका लक्ष्य। साथ में लिखा dc= संख्या के लिए फिर भी जीतता है, और लक्ष्य के लिए threshold=। ऐसा नाम जिसका कोई चरण न हो, या जो दो चरणों का हो, अनदेखा होता है।
explode= और double= इस चेक के लिए उन नियमों के फलक बदलते हैं, और सिर्फ़ तब मिलते हैं जब नियम में min हो।
reroll= इस चेक के लिए आपकी reroll एंट्री में से एक का नाम देता है, और सिर्फ़ तब मिलता है जब आपने कोई घोषित की हो। ऐसा नाम जो किसी एंट्री का न हो, अनदेखा होता है।

हर मान आपकी फ़ाइल की घोषणा तक सीमित रहता है: दायरे से बाहर का मान नज़दीकी छोर पर लौटाया जाता है, और आपके नियमसेट में न दिया गया एट्रिब्यूट चेक को अस्वीकार करने के बजाय अनदेखा होता है। फिर सेव हुआ रिकॉर्ड दिखाता है कि रोल ने क्या इस्तेमाल किया: कठिनाई और लक्ष्य संख्याओं के रूप में, आपकी सीमाओं के बाद के बोनस डाइस, with= सिर्फ़ तब जब वह एबिलिटी बदली या जोड़ी गई हो, फलक सिर्फ़ तब जब चेक ने उसे बदला हो, reroll= सिर्फ़ तब जब उसका बताया दोबारा फेंकना ही फेंका गया हो और उसने कुछ फेंका हो, और complication="true" तब जब halfOrMore वाली गंभीर विफलता से नतीजे के साथ कुछ गलत हुआ हो। Engine हमेशा खुद डाइस फेंकता है। मॉडल का लिखा पूल नतीजा बदल दिया जाता है, mode="advantage" अनदेखा होता है क्योंकि इस प्रकार में एडवांटेज नहीं है, और टर्न से पहले खिलाड़ी का रोल किया डाइस लागू नहीं होता।

`dice-highest`: डाइस फेंककर सबसे ऊँचा पढ़ना

Blades in the Dark और Trophy Dark मुट्ठी भर d6 फेंकते हैं और सिर्फ़ सबसे ऊँचा डाइस पढ़ते हैं। Capability API 1.138।

"resolution": {
  "kind": "dice-highest",
  "die": { "sides": 6 },
  "abilityModifier": { "op": "identity" },
  "proficiencyTiers": [{ "id": "rating_0", "label": "0" }, { "id": "rating_1", "label": "1", "flat": 1 }],
  "pool": { "min": 0, "max": 6 },
  "zeroDice": "lowest-of-two",
  "critical": { "count": 2 },
  "situationalDice": { "min": -1, "max": 2 },
  "difficultyLadder": [{ "label": "Partial", "dc": 4 }, { "label": "Full", "dc": 6 }],
  "outcomes": {
    "by": "total",
    "tiers": [
      { "id": "critical", "label": "Critical", "on": "critical-success", "success": true },
      { "id": "full", "label": "Full success", "atLeast": 6, "success": true },
      { "id": "partial", "label": "Partial success", "atLeast": 4, "success": true, "text": "You do it, with a consequence." },
      { "id": "bad", "label": "Bad outcome" }
    ]
  }
}

शीट की संख्या बताती है कि कितने डाइस, जैसे पूल में, और यह pool के अंदर रखी जाती है (अधिकतम 20)। घाव, adjust, स्थितियाँ और आइटम डाइस जोड़ते या घटाते हैं।
keep: वैकल्पिक, 1 से 3, डिफ़ॉल्ट 1। सबसे ऊँचे कितने डाइस जोड़े जाते हैं: 1 Blades है, 2 Trophy Dark की लड़ाइयाँ।
zeroDice: जिस कैरेक्टर के पास कोई डाइस नहीं, वह क्या करता है। "lowest-of-two" (डिफ़ॉल्ट) दो फेंकता है और कम वाला रखता है, और कभी क्रिटिकल नहीं हो सकता; "fail" बिना रोल के विफल होता है।
critical: वैकल्पिक। सबसे ऊँचा फलक (या face और उससे ऊपर) दिखाने वाले count डाइस क्रिटिकल सफलता हैं: Blades के दो छक्के।
dark: वैकल्पिक, Trophy Dark के डार्क डाइस। label, max (1 से 10) और text। Game Master इन्हें dark="N" से किसी एक चेक में जोड़ता है। outcome डिफ़ॉल्ट रूप से "all" है: ये बाकी डाइस के साथ पढ़े जाते हैं। "outcome": "light" (Capability API 1.149) के साथ सिर्फ़ लाइट डाइस तय करते हैं कि कौन से डाइस रखे जाएँ, कुल, नतीजे के बैंड और क्रिटिकल। लाइट डाइस न होने पर लाइट वाली तरफ़ zeroDice लागू होता है: दो लाइट डाइस फेंकें और कम वाला रखें, या डार्क डाइस फेंकते हुए भी विफल हों। डार्क डाइस हमेशा फेंके जाते हैं और आखिर में दर्ज होते हैं; darkHighest="true" का मतलब है कि किसी डार्क डाइस का फलक हर लाइट डाइस से ऊँचा था, बराबर नहीं (विकल्प के तौर पर फेंके गए लाइट डाइस समेत; कोई लाइट डाइस न फेंका गया हो तो कोई भी डार्क डाइस जीतता है)। इसकी कीमत (Ruin) लागू करना Game Master का काम है। dark.outcome घोषित करने के लिए, "all" समेत, capabilityApi 1.149 चाहिए।
situationalDice: वैकल्पिक, वे डाइस जो Game Master bonus= से जोड़ या घटा सकता है (मदद करना, ज़ोर लगाना)।
spend सिर्फ़ डाइस खरीद सकता है।
difficultyLadder: dc वाले चरण, यानी वह संख्या जहाँ तक रखे गए डाइस को पहुँचना है। चेक पर dc= यही संख्या है, 1 से लेकर keep गुना डाइस के फलकों तक।
outcomes रखे गए डाइस से by: "total" पढ़ते हैं, और on: "critical-success" वाला बैंड क्रिटिकल को पकड़ता है।

रिकॉर्ड जोड़ वाला रूप रखता है (resolution="sum", modifier="0", रखे गए डाइस कुल के रूप में) और highest="1" जोड़ता है, साथ में जहाँ लागू हों वहाँ zeroDice="true" और dark="N"; डार्क डाइस rolls में आखिरी होते हैं। सिर्फ़ लाइट वाला नतीजा darkOutcome="light" भी दर्ज करता है, ताकि कार्ड सिर्फ़ रखे गए लाइट डाइस हाइलाइट करे, रीलोड के बाद भी। इस प्रकार के नियमसेट की अपनी कोई लड़ाई नहीं होती, इसलिए उसके साथ combat अस्वीकार होता है।

`roll-against`: शीट की संख्या के बराबर या उससे कम (या ज़्यादा) रोल करना

Call of Cthulhu, GURPS और पुराने ढंग के चोर (thief) के प्रतिशत डाइस में जोड़ने के बजाय शीट की किसी संख्या के विरुद्ध रोल करते हैं। Capability API 1.139।

"resolution": {
  "kind": "roll-against",
  "dice": { "count": 1, "sides": 100 },
  "abilityModifier": { "op": "identity" },
  "proficiencyTiers": [{ "id": "base", "label": "Base" }],
  "against": "at-most",
  "criticalSuccess": [{ "from": 1, "to": 1 }],
  "criticalFailure": [{ "from": 100, "to": 100 }, { "from": 96, "whenTarget": { "below": 50 } }],
  "tens": { "max": 2 },
  "difficultyLadder": [
    { "label": "Regular", "dc": 0 },
    { "label": "Hard", "dc": 0, "divide": 2 },
    { "label": "Extreme", "dc": 0, "divide": 5 }
  ],
  "outcomes": {
    "by": "fraction",
    "tiers": [
      { "id": "critical", "label": "Critical", "on": "critical-success", "success": true },
      { "id": "extreme", "label": "Extreme success", "atLeast": 5, "success": true },
      { "id": "hard", "label": "Hard success", "atLeast": 2, "success": true },
      { "id": "regular", "label": "Regular success", "atLeast": 1, "success": true },
      { "id": "fail", "label": "Failure" },
      { "id": "fumble", "label": "Fumble", "on": "critical-failure" }
    ]
  }
}

चेक के लिए शीट की संख्या ही लक्ष्य है। स्किल का प्रतिशत शीट का हर स्किल वाला बोनस है (bonusRange 100 तक जाता है), बिना एबिलिटी और बिना स्तर के बोनस के; GURPS की स्किल उसका एट्रिब्यूट और यह बोनस है।
dice: क्या रोल करके जोड़ा जाता है, डिफ़ॉल्ट रूप से 1d100 (GURPS के लिए 3d6, सेविंग थ्रो के लिए 1d20)।
against: "at-most" (डिफ़ॉल्ट) लक्ष्य के बराबर या उससे नीचे सफल होता है, "at-least" उसके बराबर या ऊपर।
difficultyLadder: हर चरण का dc लक्ष्य को हिलाता है, और divide (2 से 10) पहले शीट की संख्या को भाग देता है। Game Master difficulty= से चरण का नाम देता है; टैग पर dc= संख्या को -100 से 100 तक हिलाता है। रिकॉर्ड का dc वह संख्या है जिसके विरुद्ध रोल पढ़ा गया, और रिकॉर्ड against="at-most" कहता है।
criticalSuccess और criticalFailure: हर एक में अधिकतम छह नियम। नियम फलकों का नाम देता है (from, to, दोनों में से कोई भी खुला छोड़ा जा सकता है) या, विफलता के लिए, pastTarget, यानी विफल तरफ़ उतना या उससे दूर का रोल। whenTarget (atLeast, below) नियम को कुछ लक्ष्यों तक सीमित करता है: GURPS में 5 सिर्फ़ 15 या उससे ज़्यादा पर क्रिटिकल सफलता है। क्रिटिकल सफलता हमेशा सफल होती है और क्रिटिकल विफलता हमेशा विफल।
tens: वैकल्पिक, सिर्फ़ एक d100 पर। bonus="+N" दहाई के N और डाइस फेंकता है और सबसे अच्छा रोल रखता है, bonus="-N" सबसे बुरा, max तक।
outcomes at-most रोल पर by: "fraction" पढ़ सकते हैं: हर बैंड का atLeast लक्ष्य को भाग देता है, और उस हिस्से के बराबर या उससे नीचे का रोल उस बैंड में आता है। margin (लक्ष्य से कितना नीचे) और total माप भी चलते हैं।

`symbol-pool`: नैरेटिव डाइस फेंककर प्रतीक पढ़ना

Genesys किसी विशेषता (characteristic) और स्किल रैंक से पूल बनाता है, फिर विरोधी डाइस जोड़ता है। फलकों पर संख्याओं के बजाय सफलता, बढ़त (advantage), विजय (triumph), विफलता, खतरा (threat) और निराशा (despair) होते हैं। Capability API 1.141।

"resolution": {
  "kind": "symbol-pool",
  "abilityModifier": { "op": "identity" },
  "proficiencyTiers": [
    { "id": "untrained", "label": "Untrained", "flat": 0 },
    { "id": "rank_one", "label": "Rank 1", "flat": 1 }
  ],
  "symbols": [
    { "id": "s", "label": "Success" },
    { "id": "f", "label": "Failure", "cancels": "s" },
    { "id": "a", "label": "Advantage" },
    { "id": "h", "label": "Threat", "cancels": "a" },
    { "id": "t", "label": "Triumph", "counts": "s" },
    { "id": "d", "label": "Despair", "counts": "f" }
  ],
  "dice": [
    { "id": "ability", "label": "Ability", "faces": [[], ["s"], ["s"], ["s", "s"], ["a"], ["a"], ["s", "a"], ["a", "a"]] },
    { "id": "proficiency", "label": "Proficiency", "faces": [[], ["s"], ["s"], ["s", "s"], ["s", "s"], ["a"], ["s", "a"], ["s", "a"], ["s", "a"], ["a", "a"], ["a", "a"], ["t"]] },
    { "id": "difficulty", "label": "Difficulty", "faces": [[], ["f"], ["f", "f"], ["h"], ["h"], ["h"], ["h", "h"], ["f", "h"]] },
    { "id": "challenge", "label": "Challenge", "faces": [[], ["f"], ["f"], ["f", "f"], ["f", "f"], ["h"], ["h"], ["f", "h"], ["f", "h"], ["h", "h"], ["h", "h"], ["d"]] },
    { "id": "boost", "label": "Boost", "faces": [[], [], ["s"], ["s", "a"], ["a", "a"], ["a"]] },
    { "id": "setback", "label": "Setback", "faces": [[], [], ["f"], ["f"], ["h"], ["h"]] }
  ],
  "success": { "symbol": "s", "needed": 1 },
  "pool": { "die": "ability", "upgrade": "proficiency", "max": 6 },
  "difficulty": { "die": "difficulty", "upgrade": "challenge", "max": 5 },
  "boost": { "die": "boost", "max": 3 },
  "setback": { "die": "setback", "max": 3 },
  "criticalSuccess": "t",
  "criticalFailure": "d",
  "difficultyLadder": [{ "label": "Easy", "dc": 1 }, { "label": "Average", "dc": 2 }, { "label": "Hard", "dc": 3 }]
}

symbols: 2 से 10 नामित प्रतीक। counts रद्द होने से पहले किसी दूसरे प्रतीक का एक और जोड़ता है: विजय एक सफलता जोड़ती है और विजय बनी रहती है। यह ऐसे प्रतीक का नाम देता है जिसका अपना counts नहीं है; शृंखलाएँ और खुद का हवाला अस्वीकार होते हैं। cancels दो प्रतीकों की एक के बदले एक जोड़ी बनाता है, हर एक का अधिकतम एक साथी। उलटी घोषणा वैकल्पिक है। text Game Master को प्रतीक समझाता है।
dice: 2 से 8 नामित डाइस, हर एक में 2 से 20 फलक। फलक अधिकतम तीन प्रतीक ID की ऐरे हैं; [] खाली है और दोहराए गए ID दो बार गिने जाते हैं। हर हवाला मौजूद होना चाहिए।
pool: larger-upgraded (डिफ़ॉल्ट) एबिलिटी और रैंक में से बड़ी संख्या जितने डाइस फेंकता है, और upgrade घोषित होने पर छोटी संख्या जितने डाइस अपग्रेड करता है। sum दोनों को जोड़ता है और कुछ अपग्रेड नहीं करता। max का डिफ़ॉल्ट 6 है और यह 12 से ज़्यादा नहीं हो सकता। एबिलिटी abilityModifier इस्तेमाल करती है, इसलिए Genesys की विशेषताओं के लिए identity इस्तेमाल करें। रैंक स्किल या सेव के प्रशिक्षण स्तर से आती है; सीधे एबिलिटी चेक की रैंक शून्य होती है। with= दूसरे चेक की तरह विशेषता बदल देता है। शीट के बोनस, घाव, एडजस्टमेंट और असर नीचे दिए धनात्मक या ऋणात्मक बोनस के ज़रिए boost या setback डाइस जोड़ते हैं।
difficulty: dc= 0 से max तक (डिफ़ॉल्ट 5, सीमा 12) विरोधी डाइस गिनता है। difficulty= इसके बजाय सीढ़ी के चरण का नाम देता है। upgrade="N" इतने विरोधी डाइस को अपग्रेड डाइस से बदल देता है, फेंके गए डाइस की संख्या तक। यह कठिनाई से आगे कभी डाइस नहीं जोड़ता।
boost और setback: वैकल्पिक डाइस जो क्रमशः bonus="+N" और bonus="-N" से जुड़ते हैं, हर एक अपने max तक (डिफ़ॉल्ट 3, सीमा 6)। यह सीमा लागू होने से पहले धनात्मक और ऋणात्मक एडजस्टमेंट आपस में मिल जाते हैं। Capability API 1.150 setback="N" को अलग से भी लेता है: bonus="2" setback="1" दोनों तरफ़ के डाइस फेंकता है। ऋणात्मक बोनस setback में जुड़ता है, और मिलाकर बनी setback गिनती setback.max तक सीमित रहती है; boost डाइस boost.max के अंदर रहते हैं।
allowOwnUpgrade: वैकल्पिक, न होने पर false। true के साथ upgradeOwn="N" कैरेक्टर के N और डाइस को pool.upgrade (जो घोषित होना चाहिए) में अपग्रेड करता है, शीट के अपग्रेड और खरीदे गए डाइस के बाद। जब सारे मौजूदा डाइस अपग्रेड हो चुके हों, तो हर अतिरिक्त अपग्रेड एक अपग्रेड किया हुआ डाइस जोड़ता है, फिर भी pool.max के अंदर। यह pool.build: "sum" के साथ भी चलता है। यह कुंजी घोषित करने के लिए, false के रूप में भी, capabilityApi 1.150 चाहिए। एट्रिब्यूट के नाम zeroDice की तरह camel case में हैं; upgradeOwn रोल करने वाले पर असर डालता है और upgrade अब भी सिर्फ़ कठिनाई के डाइस पर। setback और upgradeOwn दोनों गैर-ऋणात्मक पूर्णांक लेते हैं और प्रतीक पूल के बाहर अनदेखे होते हैं; upgradeOwn चालू किए बिना अनदेखा होता है।
success: रद्द होने के बाद अपने प्रतीक में से इतने चाहिए, डिफ़ॉल्ट रूप से एक। क्रिटिकल सफलता और विफलता अपने नामित प्रतीक के हर आने को चिह्नित करती हैं, भले ही उसकी जोड़ी गई सफलता या विफलता रद्द हो जाए। दोनों निशान एक साथ आ सकते हैं, और दोनों में से कोई यह नहीं बदलता कि शुद्ध सफलताओं ने चेक पास किया या नहीं।
outcomes शुद्ध सफलताओं की गिनती (total) या net successes - needed + 1 (margin) पढ़ सकते हैं। बैंड अब भी अपने आम तरीके से सफलता तय करते हैं; मूल क्रिटिकल प्रतीक चिह्नित रहते हैं। spend सिर्फ़ pool.max के अंदर कैरेक्टर के अतिरिक्त बेस डाइस खरीदता है। इसकी लड़ाइयाँ symbol-pool वाली लड़ाइयाँ होती हैं (Capability API 1.382, प्रतीक डाइस में लड़ी जाने वाली लड़ाई देखें); इसके साथ किसी और युद्ध प्रकार को अस्वीकार किया जाता है।
चेक के बाहर, इस नियमसेट पर चलने वाला गेम अपने डाइस नाम से फेंक सकता है: संदेश लिखने वाले हिस्से की कस्टम डाइस फ़ील्ड और Game Master का roll_dice टूल 2 ability 1 proficiency vs 2 difficulty पढ़ते हैं (हर डाइस की id या label, छोटे-बड़े अक्षर के फ़र्क के बिना) और चेक की तरह प्रतीक गिनते और रद्द करते हैं, लेकिन शीट, अपग्रेड या कठिनाई की सीढ़ी के बिना। इसे चालू करने के लिए कोई कुंजी नहीं है।
रिकॉर्ड resolution="sum" रखता है, साथ में symbols="2s 1a 1t", हर डाइस को पहचानने वाला thrown=, और उसका 1 से शुरू होने वाला फलक रखने वाला rolls=। एनकोड किया गया symbolDetails लेबल, फलक के प्रतीक और दोनों क्रिटिकल निशान सुरक्षित रखता है। setback साझा setback सीमा के बाद जोड़े गए अलग setback डाइस दर्ज करता है, और upgradeOwn लागू हुए अतिरिक्त अपग्रेड; अनदेखे या शून्य जोड़ छोड़ दिए जाते हैं। कार्ड और सारांश फलक की संख्याएँ जोड़ने के बजाय शुद्ध प्रतीकों का नाम देते हैं, खाली नतीजे समेत। ओवरराइड इस प्रकार के नियम बदल सकते हैं, लेकिन symbols या dice की जगह कुछ और नहीं रख सकते।

क्या दायरे से बाहर है और क्यों

इन यांत्रिकियों को अब भी अपना हल करने का प्रकार चाहिए:

विरोधी पूल एक साथ दो कैरेक्टर हल करते हैं; एक चेक में रोल करने वाला एक ही होता है।
वाइल्ड डाइस वाले जोड़ के पूल (जैसे OpenD6 में) डाइस जोड़ते हैं और उनमें से एक को खास तरह से सँभालते हैं।

इस प्रकार से पहले बाहर रहीं दोनों चीज़ें अब मॉडल की जा चुकी हैं, और नीचे रोल बदलने के लिए खर्च वाला भाग बताता है कैसे। सिस्टम का अपना नियम, "सफलता के लिए एक पॉइंट खर्च करें" या "विफल डाइस फिर फेंकने के लिए एक पॉइंट खर्च करें", resolution.spend है। परिस्थिति माँगे तो सिस्टम का मुफ़्त में दिया दोबारा फेंकना resolution.reroll है, जो ऊपर है। कैरेक्टर की चुनी किसी चीज़ से जुड़ा दोबारा फेंकना कैटलॉग एंट्री का mechanics.check है, जिसे उसी एंट्री की अपनी कीमत से खरीदा जाता है।

नतीजे के बैंड: सफलता या विफलता से ज़्यादा

कई सिस्टम चेक को सिर्फ़ पास या फ़ेल के बजाय कई नतीजों में से एक की तरह पढ़ते हैं: Pathfinder की सफलता की चार डिग्रियाँ, "मुश्किल से" वाली ऐसी सफलता जिसकी कीमत चुकानी पड़ती है, Call of Cthulhu की कठिन और चरम सफलताएँ, Fate की "success with style"। resolution.outcomes इन बैंड के नाम देता है, और Engine हर चेक पर बताता है कि वह किस बैंड में आया (Capability API 1.135)। यह हल करने के हर प्रकार के साथ चलता है।

"outcomes": {
  "by": "margin",
  "naturals": "shift",
  "tiers": [
    { "id": "critical_success", "label": "Critical success", "atLeast": 10, "success": true, "critical": true },
    { "id": "success", "label": "Success", "atLeast": 0, "success": true },
    { "id": "failure", "label": "Failure", "atLeast": -9 },
    { "id": "critical_failure", "label": "Critical failure", "critical": true }
  ]
}

by: बैंड किससे पढ़े जाते हैं। "margin" (डिफ़ॉल्ट) बताता है कि नतीजा चेक की ज़रूरत से कितना आगे है: जोड़ा गया कुल घटा उसकी कठिनाई, या पूल की शुद्ध सफलताएँ घटा उसे चाहिए सफलताएँ। "total" खुद नतीजा है: जोड़ा गया कुल, या शुद्ध सफलताएँ, कठिनाई जो भी रही हो।
tiers: दो से आठ बैंड, सबसे अच्छा पहले। atLeast वह सबसे छोटी संख्या है जो किसी बैंड में आती है; हर बैंड का यह मान अपने से पहले वाले से कम होता है, और आखिरी बैंड में यह नहीं होता, क्योंकि वह नीचे की हर चीज़ पकड़ता है। success बताता है कि बैंड सफलता है या नहीं, और critical उसे अपनी तरह का क्रिटिकल चिह्नित करता है (success true होने पर क्रिटिकल सफलता, वरना क्रिटिकल विफलता)। कम से कम एक बैंड सफल और कम से कम एक विफल होना चाहिए। text वैकल्पिक लाइन है, अधिकतम 200 अक्षर, जो Game Master को बताती है कि टेबल पर उस बैंड का क्या मतलब है ("आप कर लेते हैं, लेकिन Game Master एक मुश्किल जोड़ता है")।
on: "critical-success" या "critical-failure" किसी बैंड को वह बैंड बनाता है जिसमें क्रिटिकल आता है, संख्या कुछ भी कहे, और उसमें कभी कुछ और नहीं आता। इसमें atLeast नहीं होता, क्रिटिकल सफलता वाला बैंड सफलता है और क्रिटिकल विफलता वाला नहीं, और हर एक का अधिकतम एक होता है। Blades in the Dark के "दो छक्के" एक छक्के वाले बैंड के ऊपर क्रिटिकल सफलता वाला बैंड हैं; बाकी बैंड, जो संख्या से पढ़े जाते हैं, आपस में ऊपर दिए नियम मानते हैं।
naturals: "shift": एक डाइस का सबसे ऊँचा फलक नतीजे को एक बैंड बेहतर करता है, और सबसे नीचा फलक एक बैंड बुरा, छोरों से आगे कभी नहीं। इसके लिए एक डाइस चाहिए, और यह resolution.naturals की जगह लेता है, इसलिए इसके साथ उसकी दोनों सेटिंग (चेक और सेव) none पर रखें।

बैंड नतीजा तय करता है: सफलता और दोनों क्रिटिकल उसी से आते हैं, सीधी तुलना से कभी नहीं। जहाँ जोड़ वाले नियमसेट के naturals किसी फलक को अपने आप सफलता या विफलता बनाते हैं, वह फलक उस क्रिटिकल वाले बैंड में आता है, वरना सबसे अच्छे या सबसे बुरे बैंड में, और क्रिटिकल बना रहता है। पूल की गंभीर विफलता नीचे की तरफ़ यही करती है, और बैंड वाला पूल exceptional छोड़ देता है, क्योंकि बैंड पहले ही बताते हैं कि क्रिटिकल सफलता क्या है।

by: "total" से पढ़ा गया पूल वह तरीका है जिससे तय कठिनाई वाला सिस्टम अपने नतीजे बताता है: Lasers & Feelings का "1 सफलता: आप मुश्किल से कर पाते हैं, 2: आप अच्छे से करते हैं, 3: क्रिटिकल सफलता" 3, 2 और 1 सफलता पर तीन बैंड और उनके नीचे एक चूक है।

रिकॉर्ड outcome="Critical success" से बैंड का नाम देता है, डाइस कार्ड इसे साधारण शब्द की जगह दिखाता है, और Game Master को बैंड और उनका text सिखाया जाता है और बैंड के हिसाब से नैरेशन करने को कहा जाता है। बैंड घोषित करने वाले पैकेज वाले नियमसेट को Capability API 1.135 चाहिए।

अपने अलग तरीके से रोल होने वाले चेक

कुछ गेम ज़्यादातर चेक एक तरह से रोल करते हैं और कुछ दूसरी तरह: पुराने ढंग का गेम एबिलिटी स्कोर के नीचे d20 रोल करता है, लेकिन चोर (thief) की स्किल d100 पर और Open Doors d6 पर। resolution.overrides उन चेक के नाम देता है, और वे हल करने की कुंजियाँ भी जिनसे वे इसके बजाय रोल होते हैं। Capability API 1.140।

"overrides": [
  { "id": "thief", "label": "Thief skills", "skills": ["open_locks", "pick_pockets"], "set": { "dice": { "count": 1, "sides": 100 } } },
  { "id": "x_in_6", "label": "X-in-6", "skills": ["open_doors", "listen"], "set": { "dice": { "count": 1, "sides": 6 } } },
  { "id": "favored", "label": "Favored", "skills": ["athletics"], "when": { "field": "favored_athletics" }, "set": { "cancel": null } }
]

हर ओवरराइड skills, saves या abilities (तीनों में से एक या ज़्यादा), एक label, और Game Master के लिए वैकल्पिक text का नाम देता है।
set में नियमसेट के अपने प्रकार की हल करने वाली कुंजियाँ होती हैं, जो उन चेक के लिए नियमसेट की कुंजियों की जगह लेती हैं। null कोई कुंजी हटा देता है: exwod में पसंदीदा (favored) एबिलिटी पर रद्द न करने वाले 1 "cancel": null हैं। प्रकार, शीट का गणित (abilityModifier, proficiency, proficiencyTiers, penaltyFrom, spend, adjust) और difficultyLadder नहीं बदले जा सकते। प्रतीक पूल अपने symbols और dice भी बंद रखता है। ओवरराइड से बनने वाला हल नियमसेट के अपने हल की तरह जाँचा जाता है, इसलिए उसमें बताया गया फलक उसके डाइस पर होना चाहिए।
when: वैकल्पिक। रोल करने वाले की शीट का एक मान; ओवरराइड सिर्फ़ वहाँ लागू होता है जहाँ यह 0 नहीं है, जैसे पसंदीदा एबिलिटी के लिए 0 या 1 वाला नंबर फ़ील्ड। इसके बिना ओवरराइड हमेशा लागू होता है।
चेक का नाम देने वाला ऐसा पहला ओवरराइड इस्तेमाल होता है जिसका when सही बैठता हो। एक चेक बिना when वाले अधिकतम एक ओवरराइड में आ सकता है।

रोल बदलने के लिए खर्च

कुछ सिस्टम खिलाड़ी को होने वाले रोल के लिए कीमत चुकाने देते हैं: अपने आप मिलने वाली सफलता के लिए इच्छाशक्ति का एक पॉइंट। resolution.spend इसे सिस्टम के स्थायी नियम के रूप में बताता है, कैरेक्टर की खरीदी हुई चीज़ के रूप में नहीं:

"spend": [{ "pool": "resolve", "amount": 1, "successes": 1, "perCheck": 2 }]

pool आपके live.pools में से एक है। यह ऐसा पूल नहीं हो सकता जो खाली शुरू होता हो, क्योंकि खेल शुरू होने पर उसमें खर्च करने को कुछ नहीं होगा।
amount एक खरीद की कीमत है। successes, dice और reroll बताते हैं कि उससे क्या मिलता है, और हर खरीद में इनमें से कम से कम एक चीज़ मिलनी चाहिए। सफलताएँ डाइस गिनने और किसी भी रद्द होने के बाद जुड़ती हैं, क्योंकि उन्हें किसी ने रोल नहीं किया। डाइस पूल के साथ, पूल के अपने दायरे में फेंके जाते हैं। reroll का रूप { "upTo": 6, "mode": "once" } है, जिसे resolution.reroll की तरह पढ़ा जाता है, और चेक कितनी भी खरीद करे, यह एक ही बार खरीदा जाता है: दो बार फिर फेंका गया डाइस भी एक ही दोबारा फेंकना है।
perCheck बताता है कि एक चेक कितनी खरीद कर सकता है, इसलिए एक चेक अधिकतम amount * perCheck पॉइंट की खरीद कर सकता है। यही सीमा भरे पूल को कभी न हारने वाला रोल खरीदने से रोकती है। यह 1 से 10 तक की संख्या हो सकती है, शीट का कोई मान उसी रूप में जिसमें निकाला गया मान पढ़ा जाता है ({ "abilityScore": "nerve" }, { "derived": "focus" }), या "pool": चेक में जितने डाइस हैं उतनी, यानी घाव, बोनस डाइस या मॉडिफ़ायर से पहले उस चेक के लिए शीट की संख्या। शीट का मान रोल करने वाले के लिए पढ़ा जाता है, नीचे राउंड होता है और 0 से 100 के बीच रखा जाता है, और जिस कैरेक्टर की सीमा 0 बनती है वह न कुछ खरीदता है, न कुछ चुकाता है।
dice-pool नियमसेट सफलताएँ, डाइस या दोबारा फेंकना खरीद सकता है। dice-highest और symbol-pool सिर्फ़ डाइस खरीदते हैं। बाकी प्रकार spend घोषित नहीं कर सकते।
अधिकतम चार एंट्री, और दो एंट्री एक ही पूल का नाम नहीं दे सकतीं, वरना चेक नहीं बता पाएगा कि उसका मतलब किससे था।
पैकेज वाले नियमसेट में reroll खरीदने वाला खर्च, संख्या के अलावा कुछ और वाला perCheck, और दो से ज़्यादा एंट्री Capability API 1.38 हैं।

यह चेक पर ही लिखा जाता है। Game Master [skill_check: skill="Nerve" dc="2" spend="resolve:1"] लिखता है, अलग [sheet:] कमांड नहीं, क्योंकि शीट कमांड लागू होने से पहले डाइस फेंके जा चुके होते हैं और बाद में बदलने को कुछ नहीं बचता। एक ही हल डाइस रोल करता है और उन्हें बदलने वाली चीज़ की कीमत चुकाता है।

रोल बदलने वाला चार्म

resolution.spend सिस्टम का नियम है। कैरेक्टर की चुनी गई एंट्री भी कैटलॉग एंट्री पर mechanics.check से चेक बदल सकती है:

"mechanics": {
  "kind": "utility",
  "cost": [{ "pool": "blood", "amount": 1 }],
  "perCostStep": { "flat": 1 },
  "check": { "reroll": { "upTo": 1, "mode": "once" }, "successes": 1 }
}

reroll, upTo या उससे नीचे वाले डाइस फिर फेंकता है। once हर एक को एक बार बदलता है और नया फलक रहता है; until चलता रहता है। upTo आपके डाइस के सबसे ऊँचे फलक से नीचे होना चाहिए, वरना पूरा पूल हमेशा फिर फेंका जाता रहेगा, और फ़ाइल कुछ भी कहे, Engine सीमित करता है कि एक चेक कितने डाइस दोबारा फेंक सकता है।
dice पूल फेंके जाने से पहले डाइस जोड़ता है, successes गिनती के बाद सफलताएँ जोड़ता है, और threshold उस एक रोल के लिए हर डाइस का लक्ष्य तय करता है, उस दायरे के अंदर जो आपका target देता है।
explode और double उस एक रोल के लिए उन नियमों के फलक बदलते हैं, और सिर्फ़ तब जब आपके नियम में min हो और उसके अंदर: "check": { "explode": 8 } ऐसी एंट्री है जो आठ को फिर रोल करवाती है। threshold की तरह ये भी Game Master के टैग पर लिखे मान से ऊपर हैं। Capability API 1.37।
इनमें से कम से कम एक चाहिए, वरना एंट्री कुछ नहीं कहती और अस्वीकार होती है।
इसमें से कुछ भी सिर्फ़ dice-pool नियमसेट निभा सकता है, इसलिए mechanics.check वाला dice-sum नियमसेट इंपोर्ट पर अस्वीकार होता है।

इसकी कीमत एंट्री की अपनी cost है, जो ठीक उसी व्यवस्था से चुकाई जाती है जिससे किसी भी और चीज़ के इस्तेमाल की कीमत: पूल, और उसी एंट्री के लिखे हर काउंटर का एक उपयोग। perCostStep बताता है कि एंट्री स्केल होती है; इसे घोषित करने वाली एंट्री उतनी बार खरीदी जाती है जितनी बार कीमत चुकाई गई, और बिना इसके वाली एंट्री कितनी भी कीमत दी जाए, एक ही बार खरीदी जाती है।

Game Master चेक पर इसका नाम देता है: [skill_check: skill="Brawl" dc="3" use="Potence" spend="blood:3"]। अलग शीट कमांड नहीं, उसी वजह से जो ऊपर बताई: कोई भी हिसाब चलने से पहले डाइस फेंके जा चुके होते हैं।

पूरा या कुछ नहीं। पूल कीमत न चुका सके तो खरीद नहीं होती और कुछ नहीं कटता: रोल बिल्कुल वैसा ही होता है जैसा बिना खरीद के होता। जो पॉइंट पूरी खरीदों में नहीं बँटते, वे भी कुछ नहीं खरीदते। perCheck से ज़्यादा माँगने पर अस्वीकृति नहीं, सीमा लगती है, और सिर्फ़ सीमा तक की कीमत चुकती है। यह सारा हिसाब Engine करता है; Game Master बस वह बताता है जो खिलाड़ी ने खर्च करने को कहा, और डाइस को कभी नहीं छूता। रिकॉर्ड बताता है कि कितना चुकाया गया, कौन सी एंट्री लागू हुई, कितनी सफलताएँ बिना रोल के मिलीं और कितने डाइस फिर फेंके गए। जो चार्म कैरेक्टर ने नहीं चुना, या जिसका कैटलॉग Engine नहीं पढ़ सकता, वह भरोसे पर लागू होने के बजाय कुछ भी नहीं करता।