@opencharacter/wwn-srd 0.0.0-stage → 0.2.0

package/rules/equipment.yaml

@@ -0,0 +1,45 @@
+fields:
+  coins.copper: { type: integer, input: true, default: 0, min: 0 }
+  coins.silver: { type: integer, input: true, default: 0, min: 0 }
+  coins.gold: { type: integer, input: true, default: 0, min: 0 }
+
+  # Encumbrance in items: Readied (equipped) and Stowed (carried, not equipped). Bundled goods
+  # count `bundle` to an item; clothing and the like count nothing while worn; every 100 coins
+  # is a Stowed item.
+  enc.readied:
+    type: integer
+    formula: >-
+      sumCopies(ceil(copy.quantity / copy.fields.bundle) * copy.fields.enc,
+        has(copy.fields.enc) && copy.equipped && !copy.fields.wornFree)
+  enc.stowed:
+    type: integer
+    formula: >-
+      sumCopies(ceil(copy.quantity / copy.fields.bundle) * copy.fields.enc,
+        has(copy.fields.enc) && !copy.equipped)
+        + floor((coins.copper + coins.silver + coins.gold) / 100)
+  enc.readiedLimit: { type: integer, formula: floor(attributes.str.score / 2) }
+  enc.stowedLimit: { type: integer, formula: attributes.str.score }
+  # Past the limits by up to 2 Readied or 4 Stowed items: 20 feet; by up to 4 or 8: 15 feet.
+  enc.over:
+    type: integer
+    formula: >-
+      max(enc.readied - enc.readiedLimit <= 0 ? 0 : enc.readied - enc.readiedLimit <= 2 ? 1
+          : enc.readied - enc.readiedLimit <= 4 ? 2 : 3,
+        enc.stowed - enc.stowedLimit <= 0 ? 0 : enc.stowed - enc.stowedLimit <= 4 ? 1
+          : enc.stowed - enc.stowedLimit <= 8 ? 2 : 3)
+  move.feet: { type: integer, formula: '[30, 20, 15, 0][enc.over]' }
+
+contentTypes:
+  gear:
+    carried: true
+    equippable: true
+    fields:
+      cost: { type: integer, min: 0 }
+      costUnit: { type: enum, values: [cp, sp], default: sp }
+      enc: { type: integer, default: 0, min: 0 }
+      bundle: { type: integer, default: 1, min: 1 }
+      wornFree: { type: boolean, default: false }
+
+constraints:
+  - id: encumbrance
+    check: enc.over < 3

package/rules/foci.yaml

@@ -0,0 +1,58 @@
+contentTypes:
+  focus:
+    fields:
+      maxLevel: { type: integer, default: 2, min: 1 }
+      # The skill gained with the Focus's first level: a skill, `any` (any but Magic), `combat`
+      # (Stab, Shoot or Punch), `punch-stab`, `perform-sneak`, `specialist` (any but Magic and
+      # the combat skills) or `none`.
+      bonusSkill:
+        type: enum
+        open: true
+        values:
+          [
+            none,
+            any,
+            combat,
+            punch-stab,
+            perform-sneak,
+            specialist,
+            administer,
+            connect,
+            convince,
+            craft,
+            exert,
+            heal,
+            know,
+            lead,
+            magic,
+            notice,
+            perform,
+            pray,
+            punch,
+            ride,
+            sail,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            trade,
+            work,
+          ]
+        default: none
+      # Taken more than once for different skills or attributes.
+      repeatable: { type: boolean, default: false }
+      # Who may take it: anyone, Mages, non-Mages, Experts, a hero with an attribute modifier of
+      # -1 or less, or Invokers.
+      requires:
+        {
+          type: enum,
+          values: [none, mage, non-mage, expert, low-attribute, invoker],
+          default: none,
+        }
+    state:
+      level: { type: integer, default: 1, min: 1, max: item.maxLevel }
+
+constraints:
+  - id: focus-once
+    copies: { type: focus, where: '!item.repeatable' }
+    check: "countCopies(copy.type == 'focus' && copy.item == item.id) <= 1"

package/rules/health.yaml

@@ -0,0 +1,178 @@
+fields:
+  # The rolled maximum: each level's hit dice plus the per-die bonus and Constitution modifier.
+  hp.rolled: { type: integer, input: true, default: 1, min: 1 }
+  # Die Hard adds 2 a level on top.
+  hp.max: { type: integer, formula: hp.rolled, min: 1 }
+  hp.current: { type: integer, input: true, default: 1, min: 0, max: hp.max }
+
+  strain.max: { type: integer, formula: attributes.con.score }
+  strain.current: { type: integer, input: true, default: 0, min: 0, max: strain.max }
+
+  conditions.frail: { type: boolean, input: true, default: false }
+  conditions.mortallyWounded: { type: boolean, input: true, default: false }
+
+followUps:
+  # At zero hit points a hero is mortally wounded (or dies, if Frail).
+  - id: downed
+    becomes: hp.current == 0 && !conditions.mortallyWounded
+    required: true
+    action: fall
+
+actions:
+  - id: fall
+    tags: [health]
+    available: hp.current == 0 && !conditions.mortallyWounded
+    results: [mortally-wounded, dead]
+    steps:
+      - id: down
+        kind: changes
+        when: '!conditions.frail'
+        changes:
+          - { type: set, field: conditions.mortallyWounded, value: true }
+      - id: result
+        kind: outcome
+        result: "conditions.frail ? 'dead' : 'mortally-wounded'"
+
+  # Stabilized: back with 1 hit point after ten minutes, and Frail.
+  - id: stabilize
+    tags: [health]
+    available: conditions.mortallyWounded
+    results: [stabilized]
+    steps:
+      - id: stable
+        kind: changes
+        changes:
+          - { type: set, field: conditions.mortallyWounded, value: false }
+          - { type: set, field: conditions.frail, value: true }
+          - { type: set, field: hp.current, value: 1 }
+      - id: result
+        kind: outcome
+        result: "'stabilized'"
+
+  - id: take-damage
+    tags: [health]
+    params:
+      amount: { type: integer, min: 0 }
+    results: [taken]
+    steps:
+      - id: deal
+        kind: changes
+        changes:
+          - {
+              type: adjust,
+              when: params.amount > 0,
+              field: hp.current,
+              by: -params.amount,
+              tags: [damage],
+            }
+      - id: result
+        kind: outcome
+        result: "'taken'"
+
+  # Magical healing also ends Mortally Wounded and Frail; strain is the healer's to add.
+  - id: heal
+    tags: [health]
+    params:
+      amount: { type: integer, min: 0 }
+      magical: { type: boolean, default: false }
+      strain: { type: integer, default: 0, min: 0 }
+    results: [healed, too-strained]
+    steps:
+      - id: strained
+        kind: outcome
+        when: params.strain > 0 && strain.current + params.strain > strain.max
+        result: "'too-strained'"
+      - id: restore
+        kind: changes
+        changes:
+          - {
+              type: adjust,
+              when: params.amount > 0,
+              field: hp.current,
+              by: params.amount,
+              tags: [healing],
+            }
+          - { type: adjust, when: params.strain > 0, field: strain.current, by: params.strain }
+          - { type: set, when: params.magical, field: conditions.mortallyWounded, value: false }
+          - { type: set, when: params.magical, field: conditions.frail, value: false }
+      - id: result
+        kind: outcome
+        result: "'healed'"
+
+  # First aid: 1d6 plus the healer's Heal skill (-1 without it), 1 System Strain each time.
+  - id: first-aid
+    tags: [health]
+    available: strain.current < strain.max && hp.current < hp.max
+    params:
+      healerSkill: { type: integer, default: -1, min: -1, max: 4 }
+    results: [healed]
+    steps:
+      - id: roll
+        kind: roll
+        tags: [healing]
+        parts:
+          - dice: 1d6
+          - value: params.healerSkill
+      - id: restore
+        kind: changes
+        changes:
+          - { type: adjust, field: hp.current, by: 'max(0, steps.roll.total)', tags: [healing] }
+          - { type: adjust, field: strain.current, by: 1 }
+      - id: result
+        kind: outcome
+        result: "'healed'"
+        data:
+          healed: max(0, steps.roll.total)
+
+  # A good night's rest: level in hit points and one System Strain back unless Frail; spells
+  # and Effort committed for the day or the scene return.
+  - id: rest
+    tags: [rest]
+    results: [rested]
+    steps:
+      - id: recover
+        tags: [rest.night]
+        kind: changes
+        changes:
+          - {
+              type: adjust,
+              when: '!conditions.frail',
+              field: hp.current,
+              by: level,
+              tags: [healing],
+            }
+          - {
+              type: adjust,
+              when: '!conditions.frail && strain.current > 0',
+              field: strain.current,
+              by: -1,
+            }
+          - { type: set, field: spells.castsUsed, value: 0 }
+          - { type: set, field: spells.pointsUsed, value: 0 }
+          - type: set
+            forEach: keysOf('effortTrad')
+            field: { formula: "fieldId('effort.{effortTrad}.day', x)" }
+            value: 0
+          - type: set
+            forEach: keysOf('effortTrad')
+            field: { formula: "fieldId('effort.{effortTrad}.scene', x)" }
+            value: 0
+      - id: result
+        kind: outcome
+        result: "'rested'"
+
+  - id: end-scene
+    tags: [rest]
+    results: [ended]
+    steps:
+      - id: reclaim
+        tags: [rest.scene]
+        kind: changes
+        changes:
+          - type: set
+            forEach: keysOf('effortTrad')
+            field: { formula: "fieldId('effort.{effortTrad}.scene', x)" }
+            value: 0
+      - id: result
+        kind: outcome
+        result: "'ended'"