Pruebas de conjuntos de reglas

Usa esta página para establecer cómo tira tu conjunto de reglas una prueba o una salvación: los cinco tipos de resolución, las franjas de resultado, las pruebas que tiran a su manera y el gasto o los amuletos que cambian una tirada. Es para quienes escriben conjuntos de reglas. Antes de empezar, lee Escribir conjuntos de reglas de Game Mode.

Tipos de resolución

resolution.kind elige cómo tirar. Todos los tipos leen la misma ficha y comparten tres claves; las partes del archivo posteriores a resolution no cambian al alternar:

El significado del número depende del tipo: dice-sum lo suma a la tirada; dice-pool y dice-highest tiran esa cantidad de dados. symbol-pool mantiene separados el atributo y el entrenamiento para formar y mejorar dados narrativos.

dice-sum: sumar los 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: tirar los dados y contarlos

El número de la ficha es el tamaño de la reserva, no una bonificación adicional. Una puntuación de 3 y un oficio que vale 2 tiran cinco dados. Esa es toda la idea: sin vocabulario ni editor de fichas nuevos, un sistema cuyas puntuaciones son puñados de dados usa las mismas abilities, skills y proficiencyTiers que cualquier otro.

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

Las caras de cancel y botch deben estar por debajo del objetivo mínimo, y todas las caras nombradas deben existir en el dado. Una regla imposible de activar se rechaza al importar, en vez de descubrirse durante el juego.

Un conjunto empaquetado de reservas requiere Capability API 1.24; un min en explode o double, pool.abilityPlusAbility y botch.rule requieren 1.37; reroll, 1.38, y target.from, stances y exact, 1.137. Uno comunitario importado lo valida el motor que lo lee, así que no necesita nada más.

Qué puede escribir el Game Master en una prueba 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"]

Todo respeta el archivo: los valores fuera de rango se ajustan al extremo más cercano y un atributo no ofrecido se ignora, sin rechazar la prueba. El registro muestra lo usado: la dificultad y el umbral como números, los dados adicionales después de los límites, with= solo si se sustituyó o añadió el atributo, una cara solo si la prueba la movió, reroll= solo si la repetición que nombra fue la que se tiró y volvió a tirar algo, y complication="true" cuando una pifia halfOrMore salió mal junto a un resultado. El motor siempre tira los dados. Sustituye resultados de reserva escritos por el modelo, ignora mode="advantage" porque este tipo no tiene ventaja y no usa dados tirados por el jugador antes del turno.

dice-highest: tirar los dados y leer el más alto

Blades in the Dark y Trophy Dark tiran un puñado de d6 y solo leen el más alto. 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" }
    ]
  }
}

El registro conserva la forma sumada (resolution="sum", modifier="0", los dados conservados como total) y añade highest="1", con zeroDice="true" y dark="N" cuando corresponden; los dados oscuros son los últimos de rolls. Un resultado solo de dados claros también registra darkOutcome="light", así que la tarjeta resalta solo los dados claros conservados, también tras recargar. Un conjunto de este tipo no tiene combate propio, así que se rechaza combat junto a él.

roll-against: sacar como máximo (o como mínimo) el número de la ficha

Call of Cthulhu, GURPS y los porcentajes del ladrón de la vieja escuela tiran contra un número de la ficha en vez de sumarlo a los 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: tirar dados narrativos y leer los símbolos

Genesys forma una reserva a partir de una característica y un rango de habilidad, y después añade dados opuestos. Las caras llevan éxito, ventaja, triunfo, fracaso, amenaza y desesperación en 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 }]
}

Qué queda fuera y por qué

Estas mecánicas todavía necesitan su propio tipo de resolución:

Las dos cosas que antes quedaban fuera ya están modeladas; la sección sobre gastar para cambiar tiradas explica cómo. Una regla del propio sistema, "spend a point for a success" o "spend a point to throw the failures again", es resolution.spend. Una repetición que el sistema concede gratis cuando la situación lo pide es resolution.reroll, descrito arriba. Una que pertenece a algo elegido por el personaje es mechanics.check de una entrada de catálogo, pagado con el coste propio de esa entrada.

Franjas de resultado: más que éxito o fracaso

Muchos sistemas leen una prueba como uno de varios resultados, y no como un simple éxito o fracaso: los cuatro grados de éxito de Pathfinder, un "por los pelos" que tiene éxito a un coste, los éxitos difíciles y extremos de Call of Cthulhu, el "éxito con estilo" de Fate. resolution.outcomes nombra esas franjas, y el motor indica en cada prueba en cuál cayó (Capability API 1.135). Funciona con todos los tipos de resolución.

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

La franja decide el resultado: el éxito y los dos críticos proceden de ella, nunca de la simple comparación. Cuando los naturals de un conjunto sumado convierten una cara en un éxito o un fracaso automático, esa cara cae en la franja de ese crítico o, si no la hay, en la mejor o la peor franja, y sigue siendo un crítico. La pifia de una reserva hace lo mismo por abajo, y una reserva con franjas omite exceptional, porque las franjas ya dicen qué es un éxito crítico.

Una reserva leída by: "total" es como expresa sus resultados un sistema de dificultad fija: el "1 éxito: lo consigues por los pelos; 2: lo haces bien; 3: éxito crítico" de Lasers & Feelings son tres franjas con 3, 2 y 1 éxitos y un fallo por debajo.

El registro nombra la franja con outcome="Critical success", la tarjeta de dados la muestra en lugar de la palabra simple, y al Game Master se le enseñan las franjas y su text y se le indica que narre la franja. Un conjunto empaquetado que declara franjas necesita Capability API 1.135.

Pruebas que tiran a su manera

Algunos juegos tiran la mayoría de las pruebas de una forma y unas pocas de otra: un juego de la vieja escuela tira un d20 por debajo de una puntuación de atributo, pero las habilidades de un ladrón con un d100 y Open Doors con un d6. resolution.overrides nombra esas pruebas y las claves de resolución con las que tiran en su 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 cambiar una tirada

Algunos sistemas permiten pagar por una tirada que está a punto de hacerse: un punto de voluntad por un éxito automático. resolution.spend lo define como regla permanente del sistema, no como algo comprado por un personaje:

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

Se escribe en la propia prueba. El GM escribe [skill_check: skill="Nerve" dc="2" spend="resolve:1"], no un comando [sheet:] separado: los dados se tiran antes de aplicar esos comandos y ya no quedaría nada que cambiar. Una sola resolución tira los dados y paga lo que los modificó.

Un amuleto que cambia una tirada

resolution.spend es una regla del sistema. Una entrada que el personaje ELIGIÓ también puede cambiar una prueba, mediante mechanics.check en la entrada de catálogo:

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

El coste es el cost de la entrada, pagado con el mismo mecanismo que cualquier otro uso: la reserva y un uso de cada contador que escribió esa entrada. perCostStep indica que la entrada ESCALA: si lo declara, se compra tantas veces como se haya pagado su precio; si no, se compra una vez por mucho que se ofrezca.

El GM la nombra en la prueba: [skill_check: skill="Brawl" dc="3" use="Potence" spend="blood:3"]. No usa un comando de ficha separado por el mismo motivo: se tira antes de actualizar los registros.

Todo o nada. Si la reserva no alcanza, no se compra ni descuenta nada; la tirada queda como habría sido. Los puntos que no equivalen a un número entero de compras tampoco compran nada. Pedir más de perCheck se limita, no se rechaza; solo se paga hasta ese máximo. El motor lo calcula todo. El GM nombra lo que el jugador quiso gastar y nunca toca los dados. El registro indica lo pagado, la entrada aplicada, los éxitos que no se tiraron y cuántos dados se repitieron. Un amuleto no elegido por el personaje, o cuyo catálogo no pueda leer el motor, no hace nada; no se aplica por confianza.