Testy zestawu zasad

Ta strona pomoże ci ustalić, jak twój zestaw zasad wykonuje rzut w teście lub rzucie obronnym: pięć rodzajów rozstrzygania, przedziały wyników, testy rzucane na własny sposób oraz wydawanie zasobów lub talizmany zmieniające rzut. Jest przeznaczona dla osób piszących zestawy zasad. Zanim zaczniesz, przeczytaj przewodnik Pisanie zestawów zasad Game Mode.

Rodzaje rozstrzygania

resolution.kind wybiera sposób rzutu testu. Każdy rodzaj czyta ten sam arkusz postaci i korzysta z tych samych trzech kluczy, więc zmiana rodzaju nie zmienia części pliku poniżej resolution:

Znaczenie otrzymanej liczby zależy od rodzaju: dice-sum dodaje ją do rzutu, dice-pool i dice-highest rzucają tyloma kośćmi. symbol-pool trzyma atrybut i wyszkolenie osobno, aby zbudować i ulepszyć kości narracyjne.

dice-sum: dodawanie kości

"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-pool: rzucanie kości i liczenie wyników

Liczba z arkusza to wielkość puli, a nie premia dodawana do niej. Cecha 3 i umiejętność zawodowa warta 2 dają pięć kości. To cała zasada: bez nowego słownika arkusza, bez nowego edytora; system, którego wartości są garściami kości, zapisuje się tymi samymi abilities, skills i proficiencyTiers co każdy inny.

"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 }
  ]
}

Wyniki cancel i botch muszą być niższe niż najniższy próg, a każdy wynik wskazany przez te reguły musi istnieć na kości. Regułę, która nigdy nie zadziała, odrzuca import, zamiast wykrywać problem podczas gry.

Zestaw z pulą dostarczany jako pakiet wymaga Capability API 1.24; min w explode lub double, pool.abilityPlusAbility i botch.rule wymagają 1.37, reroll – 1.38, a target.from, stances i exact – 1.137. Importowany zestaw społecznościowy sprawdza czytający go Engine, więc dodatkowa deklaracja nie jest potrzebna.

Co Game Master może zapisać w teście puli

[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"]

Każde pole respektuje deklarację pliku: wartość poza zakresem jest przycinana do bliższego końca, a nieoferowany atrybut jest ignorowany zamiast odrzucać test. Zapis pokazuje użyte wartości: trudność i próg jako liczby, dodatkowe kości po ograniczeniu, with= tylko wtedy, gdy atrybut podmieniono lub dodano, wynik reguły tylko wtedy, gdy test go przesunął, reroll= tylko wtedy, gdy wskazany ponowny rzut był tym wykonanym i coś przerzucił, oraz complication="true", gdy reguła krytycznej porażki halfOrMore dała komplikację obok wyniku. Engine zawsze sam rzuca kośćmi. Zastępuje wynik puli napisany przez model, ignoruje mode="advantage", bo ten rodzaj nie ma ułatwienia, i nie używa kości rzuconej przez gracza przed turą.

dice-highest: rzucanie kośćmi i odczytywanie najwyższej

Blades in the Dark i Trophy Dark rzucają garścią kości d6 i odczytują tylko najwyższą z nich. 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" }
    ]
  }
}

Zapis zachowuje postać sumy (resolution="sum", modifier="0", zachowane kości jako suma) i dodaje highest="1", a tam, gdzie to ma zastosowanie, zeroDice="true" i dark="N"; ciemne kości są ostatnie w rolls. Wynik oparty wyłącznie na jasnych kościach zapisuje też darkOutcome="light", więc karta rzutu wyróżnia tylko zachowane jasne kości, także po ponownym wczytaniu. Zestaw tego rodzaju nie ma własnej walki, więc combat obok niego jest odrzucane.

roll-against: rzut najwyżej (lub co najmniej) równy liczbie z arkusza

Call of Cthulhu, GURPS i procenty złodzieja ze starej szkoły rzucają przeciw liczbie z arkusza, zamiast dodawać ją do kości. 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" }
    ]
  }
}

symbol-pool: rzucanie kośćmi narracyjnymi i odczytywanie symboli

Genesys buduje pulę z cechy i rangi umiejętności, a potem dodaje przeciwstawne kości. Ścianki zamiast liczb mają sukces, przewagę, triumf, porażkę, zagrożenie i rozpacz. 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 }]
}

Co jest poza zakresem i dlaczego

Te mechaniki nadal wymagają własnego rodzaju rozstrzygania:

Obie rzeczy wcześniej pomijane przez ten rodzaj są już modelowane; poniższa sekcja Wydawanie zasobów na zmianę rzutu wyjaśnia jak. Własna reguła systemu, "wydaj punkt za sukces" albo "wydaj punkt, aby ponownie rzucić nieudanymi kośćmi", to resolution.spend. Ponowny rzut przyznawany przez system za darmo, gdy wymaga tego sytuacja, to opisane wyżej resolution.reroll. Ponowny rzut należący do czegoś wybranego przez postać zapisuje się jako mechanics.check wpisu katalogu i opłaca kosztem tego wpisu.

Przedziały wyników: więcej niż sukces lub porażka

Wiele systemów odczytuje test jako jeden z kilku wyników, a nie samo zaliczenie lub porażkę: cztery stopnie sukcesu w Pathfinder, "ledwo", które udaje się kosztem czegoś, trudne i ekstremalne sukcesy w Call of Cthulhu, "sukces ze stylem" w Fate. resolution.outcomes nazywa te przedziały, a Engine przy każdym teście podaje, do którego trafił (Capability API 1.135). Działa z każdym rodzajem rozstrzygania.

"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 }
  ]
}

O wyniku decyduje przedział: sukces i oba wyniki krytyczne pochodzą z niego, nigdy z samego porównania. Gdy naturals zestawu z sumą czynią ściankę automatycznym sukcesem lub porażką, ta ścianka trafia do przedziału danego wyniku krytycznego, a w przeciwnym razie do najlepszego lub najgorszego przedziału, i pozostaje wynikiem krytycznym. Krytyczna porażka puli działa tak samo na dole, a pula z przedziałami pomija exceptional, bo przedziały już określają, czym jest krytyczny sukces.

Pula odczytywana by: "total" to sposób, w jaki system o stałej trudności podaje swoje wyniki: "1 sukces: ledwo ci się udaje, 2: robisz to dobrze, 3: krytyczny sukces" z Lasers & Feelings to trzy przedziały przy 3, 2 i 1 sukcesie oraz chybienie poniżej.

Zapis nazywa przedział przez outcome="Critical success", karta rzutu pokazuje go zamiast zwykłego słowa, a Game Master poznaje przedziały i ich text, a instrukcje nakazują mu opisać przedział w narracji. Zestaw dostarczany jako pakiet, który deklaruje przedziały, wymaga Capability API 1.135.

Testy rzucane na własny sposób

Niektóre gry rzucają większość testów w jeden sposób, a kilka w inny: gra w starym stylu rzuca d20 poniżej wartości atrybutu, ale umiejętności złodzieja na d100, a Open Doors na d6. resolution.overrides wskazuje te testy i klucze rozstrzygania, którymi są rzucane zamiast domyślnych. 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 } }
]

Wydawanie zasobów na zmianę rzutu

Niektóre systemy pozwalają graczowi zapłacić za nadchodzący rzut, np. punkt woli za automatyczny sukces. resolution.spend opisuje to jako stałą regułę systemu, nie rzecz kupioną przez postać:

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

Wpisuje się to w sam test. Game Master pisze [skill_check: skill="Nerve" dc="2" spend="resolve:1"], nie osobną komendę [sheet:], ponieważ kości rzuca się przed wykonaniem komend arkusza i później nie byłoby już czego zmieniać. Jedno rozstrzygnięcie rzuca kośćmi i płaci za to, co je zmieniło.

Talizman zmieniający rzut

resolution.spend jest regułą systemu. Wpis WYBRANY przez postać także może zmienić test, przez mechanics.check we wpisie katalogu:

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

Koszt określa własne cost wpisu, płacone dokładnie tym samym mechanizmem co użycie innych rzeczy: pula i jedno użycie każdego licznika zapisanego przez ten wpis. perCostStep określa SKALOWANIE; wpis z tym polem kupuje się tyle razy, ile zapłacono cenę, a bez niego jeden raz, niezależnie od zaoferowanej kwoty.

Game Master nazywa go w teście: [skill_check: skill="Brawl" dc="3" use="Potence" spend="blood:3"]. Nie w osobnej komendzie arkusza, z tego samego powodu co wyżej: kości rzuca się przed wszelkimi zapisami stanu.

Wszystko albo nic. Jeśli pula nie wystarcza, zakup nie następuje i nic nie jest odejmowane: rzut pozostaje dokładnie taki jak bez zakupu. Punkty niebędące całkowitą wielokrotnością zakupu także nic nie kupują. Żądanie przekraczające perCheck jest przycinane, nie odrzucane, i płaci się tylko za limit. Wszystko oblicza Engine; Game Master podaje zadeklarowany przez gracza wydatek i nigdy nie dotyka kości. Zapis pokazuje, ile zapłacono, jaki wpis zastosowano, ile sukcesów uzyskano bez rzutu i ile kości rzucono ponownie. Talizman niewybrany przez postać lub taki, którego katalogu Engine nie może odczytać, nie robi nic zamiast działać na zaufanie.