@opencharacter/cwn-srd 0.0.0-stage → 0.2.0

package/pack.yaml

@@ -0,0 +1,13 @@
+id: cwn-srd
+version: 0.2.0
+specVersion: 0.3.0
+license: CC0-1.0
+# CC0 asks for nothing, but the SRD's waiver asks that a work built on it not be presented as
+# official or endorsed, so apps pass this on as they would any notice.
+notices:
+  not-affiliated: >-
+    This pack is compatible with Cities Without Number, a game by Kevin Crawford published by
+    Sine Nomine Publishing. It is built on the Cities Without Number System Reference Document,
+    which its author dedicated to the public domain under CC0 1.0. It is unofficial: it is not
+    affiliated with, approved or endorsed by Kevin Crawford or Sine Nomine Publishing.
+defaultLanguage: en

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@opencharacter/cwn-srd",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Open Character Format pack for the character rules of the Cities Without Number SRD (CC0). Unofficial.",
+  "keywords": [
+    "character-sheet",
+    "cities-without-number",
+    "content-pack",
+    "cyberpunk",
+    "ocf",
+    "open-character-format",
+    "rpg",
+    "tabletop",
+    "ttrpg"
+  ],
+  "homepage": "https://opencharacterformat.org",
+  "bugs": {
+    "url": "https://github.com/pixelqueue/opencharacter/issues"
+  },
+  "license": "CC0-1.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pixelqueue/opencharacter.git",
+    "directory": "packs/cwn/srd"
+  },
+  "files": [
+    "dist",
+    "pack.yaml",
+    "rules",
+    "content",
+    "i18n",
+    "upgrades",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/release.json"
+    },
+    "./release.json": "./dist/release.json",
+    "./i18n/*": {
+      "types": "./dist/i18n/*.d.ts",
+      "import": "./dist/i18n/*.js",
+      "default": "./dist/i18n/*.json"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@opencharacter/engine": "0.3.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {}
 }

package/rules/advancement.yaml

@@ -0,0 +1,163 @@
+actions:
+  # Gain a level: a third Edge at 5th level, a Focus level at 2nd, 5th, 7th and 10th, new hit
+  # points, and skill points to spend.
+  - id: level-up
+    tags: [advancement]
+    available: '!character.creating && level < 10 && xp.current >= xp.next'
+    params:
+      random: { type: boolean, default: false }
+    results: [raised]
+    steps:
+      - id: raise
+        tags: [advancement.level]
+        kind: changes
+        changes:
+          - { type: adjust, field: level, by: 1 }
+      - id: edge
+        kind: action
+        when: level + 1 == 5
+        use: gain-edge
+        params: { choice: "'edge-5'", random: params.random }
+      - id: focus
+        kind: action
+        when: (level + 1) in [2, 5, 7, 10]
+        use: gain-focus
+        params: { random: params.random }
+      # Hit points: roll 1d6 per level, each plus the Constitution modifier (and Hard to Kill's
+      # +2) and at least 1. A total over the old maximum replaces it; otherwise it rises by one.
+      - id: dice
+        kind: branch
+        sheet: proposed
+        cases:
+          - when: true
+            flags:
+              perDie: attributes.con.mod + hp.dieBonus
+              dice: level
+      - id: hp
+        kind: roll
+        tags: [hit-points]
+        parts:
+          - dice: >-
+              flags.perDie >= 0 ? (flags.dice)d6 : flags.perDie == -1 ? (flags.dice)d6min2
+                : flags.perDie == -2 ? (flags.dice)d6min3 : flags.perDie == -3 ? (flags.dice)d6min4
+                : (flags.dice)d6min5
+          - value: flags.dice * flags.perDie
+      - id: gains
+        kind: changes
+        sheet: proposed
+        changes:
+          - { type: set, field: hp.rolled, value: 'max(steps.hp.total, hp.rolled + 1)' }
+          - { type: adjust, field: skillPoints.unspent, by: skillPoints.perLevel }
+      # Choices the new level opens (All Natural's attribute picks).
+      - id: picks
+        kind: choice
+        options: { pending: {} }
+        random: params.random
+      - { id: done, kind: outcome, result: "'raised'" }
+
+  # Spend skill points on the next level of a skill: level-0 costs 1, level-1 2, level-2 3 (from
+  # 3rd level), level-3 4 (from 6th) and level-4 5 (from 9th). Banked credit is spent first.
+  - id: improve-skill
+    tags: [advancement]
+    available: >-
+      !character.creating && (skillPoints.unspent > 0 || maxList(keysOf('skill'), fieldOf('skills.{skill}.credit', x)) > 0)
+    params:
+      skill:
+        type: enum
+        open: true
+        values:
+          [
+            administer,
+            connect,
+            drive,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+            cast,
+            summon,
+          ]
+    results: [improved, refused]
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              level: fieldOf('skills.{skill}.base', params.skill)
+              credit: fieldOf('skills.{skill}.credit', params.skill)
+      - id: cost
+        kind: branch
+        cases:
+          - when: flags.level < 4
+            flags:
+              cost: flags.level + 2
+              allowed: >-
+                level >= [1, 1, 3, 6, 9][flags.level + 1]
+                  && skillPoints.unspent + flags.credit >= flags.level + 2
+          - when: true
+            flags: { cost: 0, allowed: false }
+      - id: buy
+        kind: changes
+        when: flags.allowed
+        changes:
+          - type: set
+            field: { formula: "fieldId('skills.{skill}.base', params.skill)" }
+            value: flags.level + 1
+          - type: set
+            field: { formula: "fieldId('skills.{skill}.credit', params.skill)" }
+            value: max(0, flags.credit - flags.cost)
+          - type: adjust
+            field: skillPoints.unspent
+            by: -max(0, flags.cost - flags.credit)
+      - id: result
+        kind: outcome
+        result: "flags.allowed ? 'improved' : 'refused'"
+
+  # Spend skill points on an attribute boost: +1 to a score, costing 1 for the first boost, 2 for
+  # the second and so on. The third needs 3rd level, the fourth 6th and the fifth 9th; five in
+  # all. Not for characters who took the Underdog Rule.
+  - id: improve-attribute
+    tags: [advancement]
+    available: >-
+      !character.creating && !underdog && advancement.attributeBoosts < 5
+        && skillPoints.unspent > advancement.attributeBoosts
+        && level >= [1, 1, 3, 6, 9][advancement.attributeBoosts]
+    params:
+      attribute: { type: enum, values: [str, dex, con, int, wis, cha] }
+    results: [improved, refused]
+    steps:
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags:
+              cost: advancement.attributeBoosts + 1
+              allowed: >-
+                skillPoints.unspent >= advancement.attributeBoosts + 1
+                  && level >= [1, 1, 3, 6, 9][advancement.attributeBoosts]
+                  && fieldOf('attributes.{attribute}.base', params.attribute) < 18
+      - id: buy
+        kind: changes
+        when: flags.allowed
+        changes:
+          - type: adjust
+            field: { formula: "'attributes.' + params.attribute + '.base'" }
+            by: 1
+          - { type: adjust, field: advancement.attributeBoosts, by: 1 }
+          - { type: adjust, field: skillPoints.unspent, by: -flags.cost }
+      - id: result
+        kind: outcome
+        result: "flags.allowed ? 'improved' : 'refused'"

package/rules/armor.yaml

@@ -0,0 +1,81 @@
+contentTypes:
+  # Armor must be Readied (`equipped`) to protect. Clothing and suits set the base Armor Classes;
+  # a shield adds to them. Damage Soak ablates in a fight: the copy counts what it has absorbed.
+  armor:
+    carried: true
+    equippable: true
+    fields:
+      cost: { type: integer, default: 0, min: 0 }
+      enc: { type: integer, min: 0 }
+      kind: { type: enum, values: [clothing, suit, shield], required: true }
+      # The Armor Classes clothing and suits set, or a shield's bonus to them.
+      rangedAc: { type: integer, required: true }
+      meleeAc: { type: integer, required: true }
+      soak: { type: integer, default: 0, min: 0 }
+      traumaMod: { type: integer, default: 0 }
+      # Heavy items: each puts -1 on Sneak and Exert checks. Accessories add to it.
+      heavy: { type: integer, default: 0, min: 0 }
+      obvious: { type: boolean, default: false }
+    state:
+      soakUsed: { type: integer, default: 0, min: 0 }
+    effects:
+      - id: ranged-ac
+        target: ac.ranged.base
+        op: set
+        value: item.rangedAc
+        when: self.equipped && item.kind != 'shield'
+      - id: melee-ac
+        target: ac.melee.base
+        op: set
+        value: item.meleeAc
+        when: self.equipped && item.kind != 'shield'
+      - id: shield-ranged
+        target: ac.ranged
+        op: add
+        value: item.rangedAc
+        when: self.equipped && item.kind == 'shield'
+      - id: shield-melee
+        target: ac.melee
+        op: add
+        value: item.meleeAc
+        when: self.equipped && item.kind == 'shield'
+      - id: trauma
+        target: trauma.target
+        op: add
+        value: item.traumaMod
+        when: self.equipped && item.traumaMod != 0
+      # Damage Soak takes weapon and other physical damage first, until it is spent for the fight.
+      - id: soak
+        target: { incoming: { fields: [hp.current], tags: [damage] } }
+        op: add
+        value: min(item.soak - self.soakUsed, -incoming.amount)
+        when: >-
+          self.equipped && item.soak > self.soakUsed && incoming.amount < 0
+            && !('damage.cyberspace' in incoming.tags) && !('damage.direct' in incoming.tags)
+        then:
+          - type: adjustState
+            entry: self
+            key: soakUsed
+            by: min(item.soak - self.soakUsed, -incoming.amount)
+
+fields:
+  # Damage Soak left on Readied armor, and its total.
+  soak.max:
+    type: integer
+    formula: "sumCopies(copy.fields.soak, copy.type == 'armor' && copy.equipped)"
+  soak.current:
+    type: integer
+    formula: >-
+      sumCopies(copy.fields.soak - copy.state.soakUsed, copy.type == 'armor' && copy.equipped)
+  # Heavy items worn: the penalty to Sneak and Exert checks.
+  armor.heavy:
+    type: integer
+    formula: "sumCopies(copy.fields.heavy, copy.type == 'armor' && copy.equipped)"
+
+effects:
+  - id: heavy-armor
+    target: { rolls: [skill.sneak, skill.exert] }
+    op: add
+    value: -armor.heavy
+    when: armor.heavy > 0
+    tags: [armor.heavy]

package/rules/attributes.yaml

@@ -0,0 +1,46 @@
+families:
+  attribute: [str, dex, con, int, wis, cha]
+
+fields:
+  # The rolled (or assigned) score, raised by background and advancement boosts. 18 is the cap.
+  'attributes.{attribute}.base':
+    type: integer
+    input: true
+    default: 10
+    min: 3
+    max: 18
+    tags: [attribute-base, 'attr.{attribute}']
+  # What everything reads. Cyberware that sets a score (Muscle Fiber Replacement) acts here.
+  'attributes.{attribute}.score':
+    { type: integer, formula: 'attributes.{attribute}.base', tags: [attribute, 'attr.{attribute}'] }
+  # The modifier a score gives: 3 is -2, 4-7 -1, 8-13 +0, 14-17 +1, 18 +2. Prodigy raises it to +3.
+  'attributes.{attribute}.scoreMod':
+    type: integer
+    tags: [attribute-score-mod, 'attr.{attribute}']
+    formula: >-
+      attributes.{attribute}.score >= 18 ? 2 : attributes.{attribute}.score >= 14 ? 1
+        : attributes.{attribute}.score >= 8 ? 0 : attributes.{attribute}.score >= 4 ? -1 : -2
+  # Bonuses and penalties to the modifier itself (foci, cyberware, Graced arts, injuries).
+  'attributes.{attribute}.modBonus':
+    { type: integer, formula: '0', tags: [attribute-mod-bonus, 'attr.{attribute}'] }
+  # Bonuses can't raise a modifier past +2 unless their source says so (+3 for All Natural and
+  # the Graced arts).
+  'attributes.{attribute}.modCap':
+    { type: integer, formula: '2', tags: [attribute-mod-cap, 'attr.{attribute}'] }
+  'attributes.{attribute}.mod':
+    type: integer
+    tags: [attribute-mod, 'attr.{attribute}']
+    formula: >-
+      max(-3, min(max(attributes.{attribute}.modCap, attributes.{attribute}.scoreMod),
+        attributes.{attribute}.scoreMod + attributes.{attribute}.modBonus))
+
+  # The Underdog Rule reads the sum of the modifiers the six rolled scores give, before Edges,
+  # Foci and cyber (so its own bonus Edge can't undo it).
+  attributes.modTotal:
+    type: integer
+    formula: >-
+      sumList(['str', 'dex', 'con', 'int', 'wis', 'cha'],
+        fieldOf('attributes.{attribute}.base', x) >= 18 ? 2
+          : fieldOf('attributes.{attribute}.base', x) >= 14 ? 1
+          : fieldOf('attributes.{attribute}.base', x) >= 8 ? 0
+          : fieldOf('attributes.{attribute}.base', x) >= 4 ? -1 : -2)

package/rules/backgrounds.yaml

@@ -0,0 +1,102 @@
+families:
+  growthRoll: [1, 2, 3, 4, 5, 6]
+  learningRoll: [1, 2, 3, 4, 5, 6, 7, 8]
+
+contentTypes:
+  # A background is picked in the rules-level choice `background`. Its tables are read by the
+  # creation action: the free skill, then three rolls split between Growth (d6) and Learning (d8),
+  # or two picks from Learning.
+  background:
+    grantOnly: true
+    copies: { max: 0 }
+    fields:
+      freeSkill:
+        type: enum
+        open: true
+        required: true
+        values:
+          [
+            administer,
+            connect,
+            drive,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+            combat,
+          ]
+      'growth{growthRoll}':
+        type: enum
+        open: true
+        required: true
+        values:
+          [
+            administer,
+            connect,
+            drive,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+            combat,
+            any,
+            any-stat-1,
+            physical-2,
+            mental-2,
+          ]
+      'learning{learningRoll}':
+        type: enum
+        open: true
+        required: true
+        values:
+          [
+            administer,
+            connect,
+            drive,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+            combat,
+            any,
+          ]
+
+choices:
+  - id: background
+    from: { type: background }