Testes de conjuntos de regras

Use esta página para definir como o seu conjunto de regras rola um teste ou uma salvaguarda: os cinco tipos de resolução, faixas de resultado, testes que rolam do próprio jeito e gastos ou amuletos que mudam uma rolagem. Ela é para autores de conjuntos de regras. Antes de começar, leia Escrever conjuntos de regras de Game Mode.

Tipos de resolução

resolution.kind escolhe como rolar um teste. Todos os tipos leem a mesma ficha e compartilham três chaves; as partes do arquivo depois de resolution não mudam ao alternar:

O significado do número depende do tipo: dice-sum o soma à rolagem; dice-pool e dice-highest rolam essa quantidade de dados. symbol-pool mantém atributo e treinamento separados para montar e aprimorar dados narrativos.

dice-sum: somar os dados

"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: rolar os dados e contá-los

O número da ficha é o tamanho da reserva, não um bônus adicional. Uma pontuação de 3 e um ofício que vale 2 rolam cinco dados. Essa é a ideia: sem novo vocabulário de ficha nem novo editor, um sistema cujas pontuações são punhados de dados usa as mesmas abilities, skills e proficiencyTiers de qualquer outro.

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

As faces de cancel e botch precisam ficar abaixo do alvo mínimo, e toda face nomeada deve existir no dado. Uma regra impossível de ativar é recusada na importação, em vez de ser descoberta durante a partida.

Um conjunto empacotado que usa reservas exige Capability API 1.24; um min em explode ou double, pool.abilityPlusAbility e botch.rule exigem 1.37; reroll exige 1.38; target.from, stances e exact exigem 1.137. Um conjunto comunitário importado é validado pelo Engine que o lê, então não precisa de nada mais.

O que o Game Master pode escrever num teste de reserva

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

Tudo respeita seu arquivo: valores fora dos limites são ajustados ao extremo mais próximo e um atributo não oferecido é ignorado sem recusar o teste. O registro salvo mostra o que a rolagem usou: a dificuldade e o alvo como números, os dados extras depois dos limites, with= só quando o atributo foi trocado ou adicionado, uma face só quando o teste a moveu, reroll= só quando a nova rolagem que ele nomeia foi a rolada e rolou alguma coisa, e complication="true" quando uma falha crítica halfOrMore deu errado junto com um resultado. O Engine sempre rola os dados. Substitui resultados de reserva escritos pelo modelo, ignora mode="advantage" porque esse tipo não tem vantagem e não usa um dado que o jogador rolou antes do turno.

dice-highest: rolar os dados e ler o maior

Blades in the Dark e Trophy Dark rolam um punhado de d6 e leem só o maior. 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" }
    ]
  }
}

O registro mantém a forma somada (resolution="sum", modifier="0", os dados mantidos como total) e acrescenta highest="1", com zeroDice="true" e dark="N" quando se aplicam; os dados sombrios são os últimos em rolls. Um resultado só dos dados claros também registra darkOutcome="light", para que o cartão destaque só os dados claros mantidos, inclusive depois de recarregar. Um conjunto desse tipo não tem luta própria, então combat é recusado ao lado dele.

roll-against: rolar no máximo (ou no mínimo) o número da ficha

Call of Cthulhu, GURPS e as porcentagens de um ladrão old-school rolam contra um número da ficha em vez de somá-lo aos dados. 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: rolar dados narrativos e ler os símbolos

Genesys monta uma reserva a partir de uma característica e da graduação de uma perícia e depois acrescenta dados opostos. As faces trazem sucesso, vantagem, triunfo, falha, ameaça e desespero em vez de números. 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 }]
}

O que fica fora e por quê

Estas mecânicas ainda precisam de um tipo de resolução próprio:

As duas coisas que esse tipo deixava de fora já estão modeladas; a seção sobre gastar para mudar uma rolagem, abaixo, explica como. Uma regra do próprio sistema, "spend a point for a success" ou "spend a point to throw the failures again", é resolution.spend. Uma nova rolagem que o sistema concede de graça quando a situação pede é resolution.reroll, acima. Uma que pertence a algo escolhido pelo personagem é mechanics.check numa entrada de catálogo, paga com o custo da própria entrada.

Faixas de resultado: mais que sucesso ou falha

Muitos sistemas leem um teste como um entre vários resultados, e não como um simples passou ou falhou: os quatro graus de sucesso de Pathfinder, um "por pouco" que tem sucesso com um custo, os sucessos difíceis e extremos de Call of Cthulhu, o "sucesso com estilo" de Fate. resolution.outcomes nomeia essas faixas, e o Engine diz em todo teste em qual delas ele caiu (Capability API 1.135). Funciona com todos os tipos de resolução.

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

A faixa decide o resultado: o sucesso e os dois críticos vêm dela, nunca da comparação simples. Quando os naturals de um conjunto somado fazem de uma face um sucesso ou uma falha automática, essa face cai na faixa desse crítico ou, sem ela, na melhor ou na pior faixa, e continua sendo um crítico. A falha crítica de uma reserva faz o mesmo na ponta de baixo, e uma reserva com faixas deixa exceptional de fora, porque as faixas já dizem o que é um sucesso crítico.

Uma reserva lida com by: "total" é como um sistema de dificuldade fixa expressa seus resultados: o "1 sucesso: você consegue por pouco, 2: você faz bem, 3: sucesso crítico" de Lasers & Feelings são três faixas em 3, 2 e 1 sucessos e um erro abaixo disso.

O registro nomeia a faixa com outcome="Critical success", o cartão de dados a mostra no lugar da palavra simples, e o Game Master aprende as faixas e seu text e é instruído a narrar a faixa. Um conjunto empacotado que declara faixas exige Capability API 1.135.

Testes que rolam do próprio jeito

Alguns jogos rolam a maioria dos testes de um jeito e alguns de outro: um jogo old-school rola um d20 abaixo de um atributo, mas as perícias de ladrão num d100 e Open Doors num d6. resolution.overrides nomeia esses testes e as chaves de resolução com que eles rolam no lugar. 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 } }
]

Gastar para mudar uma rolagem

Alguns sistemas permitem pagar por uma rolagem prestes a acontecer: um ponto de vontade por um sucesso automático. resolution.spend define isso como regra permanente do sistema, não como algo comprado pelo personagem:

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

Isso vai no próprio teste. O GM escreve [skill_check: skill="Nerve" dc="2" spend="resolve:1"], não um comando [sheet:] separado: os dados são rolados antes de aplicar comandos de ficha e não restaria nada para mudar. Uma única resolução rola os dados e paga pelo que os modificou.

Um amuleto que muda uma rolagem

resolution.spend é uma regra do sistema. Uma entrada que o personagem ESCOLHEU também pode mudar um teste, com mechanics.check na entrada de catálogo:

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

O custo é o cost da entrada, pago pelo mesmo mecanismo de qualquer outro uso: a reserva e um uso de cada contador que essa entrada escreveu. perCostStep indica que ela ESCALA: se o declara, é comprada tantas vezes quantas seu preço foi pago; caso contrário, é comprada uma vez, independentemente do valor oferecido.

O GM a nomeia no teste: [skill_check: skill="Brawl" dc="3" use="Potence" spend="blood:3"]. Não usa um comando de ficha separado pelo mesmo motivo: os dados rolam antes da atualização dos registros.

Tudo ou nada. Se a reserva não cobre o custo, a compra não acontece e nada é descontado; a rolagem continua exatamente como seria. Pontos que não equivalem a um número inteiro de compras também não compram nada. Pedir mais que perCheck é limitado, não recusado; só o teto é pago. O Engine calcula tudo. O GM nomeia o que o jogador disse que gastaria e nunca mexe nos dados. O registro informa o que foi pago, a entrada aplicada, os sucessos não rolados e quantos dados foram rolados novamente. Um amuleto não escolhido, ou cujo catálogo o Engine não consegue ler, não faz nada em vez de ser aplicado por confiança.