@opencharacter/cwn-srd 0.0.0-stage → 0.1.0

package/rules/cyberware.yaml

@@ -0,0 +1,156 @@
+contentTypes:
+  # Implanted cyberware. Each system adds its System Strain as permanent strain.
+  cyberware:
+    fields:
+      cost: { type: integer, default: 0, min: 0 }
+      category:
+        type: enum
+        values: [body, head, skin, limb, sensory, medical, nerve]
+        required: true
+      concealment: { type: enum, values: [medical, touch, sight], required: true }
+      strain: { type: decimal, default: 0, min: 0 }
+      # Eye and ear mods cost half their strain with a pair of cybereyes or cyberears.
+      eyeMod: { type: boolean, default: false }
+      earMod: { type: boolean, default: false }
+      # System Strain triggering the system costs, for systems that cost it every time.
+      triggerStrain: { type: integer, min: 1 }
+      # The base Armor Class dermal plating gives, and a bonus to the Trauma Target.
+      baseAc: { type: integer }
+      traumaMod: { type: integer, default: 0 }
+    state:
+      # Damaged cyber is useless until repaired.
+      damaged: { type: boolean, default: false }
+      # Bought with the Wired Edge's budget.
+      wired: { type: boolean, default: false }
+    effects:
+      - id: ranged-ac
+        target: ac.ranged.base
+        op: set
+        value: item.baseAc
+        when: has(item.baseAc) && !self.damaged
+      - id: melee-ac
+        target: ac.melee.base
+        op: set
+        value: item.baseAc
+        when: has(item.baseAc) && !self.damaged
+      - id: trauma
+        target: trauma.target
+        op: add
+        value: item.traumaMod
+        when: item.traumaMod != 0 && !self.damaged
+    actions:
+      - use: trigger-cyber
+
+  # A skillplug chip, slotted (`equipped`) in a skillplug jack: a skill at its level. Physical
+  # skills need a Skillplug Jack II, and level-2 and level-3 plugs Skillplug Wiring.
+  skillplug:
+    carried: true
+    equippable: true
+    fields:
+      cost: { type: integer, default: 0, min: 0 }
+      plugLevel: { type: integer, required: true, min: 0, max: 3 }
+
+  # Optional alienation: a chrome syndrome raises the alienation the character can bear.
+  syndrome:
+    fields:
+      alienation: { type: integer, required: true, min: 0 }
+    effects:
+      - { id: allowance, target: alienation.max, op: add, value: item.alienation }
+
+fields:
+  cyber.eyes:
+    type: boolean
+    formula: "countCopies(copy.type == 'cyberware' && 'cybereyes' in copy.tags) > 0"
+  # The best skillplug jack implanted (1 for Jack I, 2 for Jack II) and Skillplug Wiring.
+  cyber.plugJack: { type: integer, formula: '0' }
+  cyber.plugWiring: { type: boolean, formula: 'false' }
+  cyber.ears:
+    type: boolean
+    formula: "countCopies(copy.type == 'cyberware' && 'cyberears' in copy.tags) > 0"
+  # Strain from implants, eye and ear mods halved by a pair of cybereyes or cyberears.
+  strain.cyber:
+    type: decimal
+    formula: >-
+      sumCopies(copy.fields.strain
+        * ((copy.fields.eyeMod && cyber.eyes) || (copy.fields.earMod && cyber.ears) ? 0.5 : 1),
+        copy.type == 'cyberware')
+  # Implant strain the body ignores (Cybernetic Infrastructure Baseline).
+  strain.cyberIgnored: { type: decimal, formula: '0' }
+  # A cyberdoc's maintenance lowers implant strain by one or two points until the next one.
+  strain.maintenanceRelief: { type: integer, input: true, default: 0, min: 0, max: 2 }
+  # Other permanent strain: Hypervigilant, linked magic items, an implant complication.
+  strain.otherPermanent: { type: decimal, input: true, default: 0, min: 0 }
+  strain.permanent:
+    type: decimal
+    formula: >-
+      max(0, strain.cyber - strain.cyberIgnored - strain.maintenanceRelief) + strain.otherPermanent
+  # Strain from drugs, healing and cyber activation; one point goes each night's rest.
+  strain.temporary: { type: integer, input: true, default: 0, min: 0 }
+  strain.total:
+    type: decimal
+    formula: strain.permanent + strain.temporary
+    limits: { max: strain.max }
+  # The Constitution score the maximum counts (20 for a full body conversion).
+  strain.constitution: { type: integer, formula: attributes.con.score }
+  strain.max: { type: integer, formula: strain.constitution + lifestyle.strain }
+
+  # The Wired Edge's budget and the cyber bought with it.
+  cyber.wiredBudget: { type: integer, formula: '0' }
+  cyber.wiredUsed:
+    type: integer
+    formula: "sumCopies(copy.fields.cost, copy.type == 'cyberware' && copy.state.wired)"
+
+  # Optional: cyberware alienation. Each system adds its strain rounded up, two more for Nerve
+  # cyber; going over the Wisdom score (plus the chrome syndromes' allowances) is cyber-induced
+  # psychosis.
+  alienation.permanent:
+    type: integer
+    formula: >-
+      sumCopies(ceil(copy.fields.strain
+        * ((copy.fields.eyeMod && cyber.eyes) || (copy.fields.earMod && cyber.ears) ? 0.5 : 1))
+        + (copy.fields.category == 'nerve' ? 2 : 0), copy.type == 'cyberware')
+  alienation.current: { type: integer, input: true, default: 0, min: 0 }
+  alienation.max: { type: integer, formula: attributes.wis.score }
+  alienation.total:
+    type: integer
+    formula: max(alienation.permanent, alienation.current)
+    limits: { max: 'campaign.alienation ? alienation.max : 1000' }
+
+constraints:
+  - id: wired-budget
+    check: cyber.wiredUsed <= cyber.wiredBudget
+
+actions:
+  # Trigger a system that costs System Strain each use. It can't be triggered past the maximum.
+  - id: trigger-cyber
+    tags: [cyber]
+    available: >-
+      has(item.triggerStrain) && !self.damaged && strain.total + item.triggerStrain <= strain.max
+    steps:
+      - id: strain
+        kind: changes
+        changes:
+          - { type: adjust, field: strain.temporary, by: item.triggerStrain }
+
+  # Pick cyber with the Wired Edge's budget: new systems the character's strain can carry.
+  - id: acquire-wired-cyber
+    tags: [building]
+    params:
+      random: { type: boolean, default: false }
+    steps:
+      - id: cyber
+        kind: choice
+        sheet: proposed
+        options:
+          content:
+            type: cyberware
+            where: >-
+              item.cost <= cyber.wiredBudget - cyber.wiredUsed
+                && strain.total + item.strain <= strain.max
+                && countCopies(copy.item == item.id) == 0
+        repeat: { max: 8 }
+        recommend: options[0]
+        random: params.random
+        changes:
+          - type: addItem
+            entry: { item: picked.id, state: { wired: true } }

package/rules/drones.yaml

@@ -0,0 +1,38 @@
+contentTypes:
+  # Drones. Portable ones (tagged `portable`) have Encumbrance; fittings and mods are templates
+  # that add to the copy's fields.
+  drone:
+    carried: true
+    equippable: true
+    fields:
+      cost: { type: integer, default: 0, min: 0 }
+      enc: { type: integer, min: 0 }
+      ac: { type: integer, required: true }
+      traumaTarget: { type: integer, required: true }
+      hp: { type: integer, required: true, min: 1 }
+      fittings: { type: integer, default: 0, min: 0 }
+      fittingsUsed: { type: integer, default: 0, min: 0 }
+      move: { type: integer, required: true, min: 0 }
+      moveKind: { type: enum, values: [ground, fly, swim], required: true }
+      hardpoints: { type: integer, default: 0, min: 0 }
+    state:
+      hp: { type: integer, default: item.hp, min: 0, max: item.hp }
+      # Bought with a Drone Pilot's gear budget.
+      focusGear: { type: boolean, default: false }
+
+fields:
+  # A pilot's attack bonus with a drone's guns: their attack bonus, Int or Dex, and the better of
+  # Drive or Program.
+  drones.attackBonus:
+    type: integer
+    formula: >-
+      combat.attackBonus + max(attributes.int.mod, attributes.dex.mod)
+        + max(skills.drive.level, skills.program.level)
+  # Drones a pilot can command at once: one with a control board, one plus Drive with a Remote
+  # Control Unit.
+  drones.commandable: { type: integer, formula: '1' }
+
+constraints:
+  - id: drone-fittings
+    copies: { type: drone }
+    check: item.fittingsUsed <= item.fittings

package/rules/edges.yaml

@@ -0,0 +1,78 @@
+contentTypes:
+  # Edges are picked in the rules-level choices below: two at creation, a bonus one under the
+  # Underdog Rule, and a third at 5th level.
+  edge:
+    copies: { max: 0 }
+    fields:
+      # The skill the Edge grants as a bonus skill: a skill, `combat` (a combat skill) or `any`.
+      bonusSkill:
+        type: enum
+        values:
+          [
+            administer,
+            connect,
+            drive,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+            cast,
+            summon,
+            combat,
+            any,
+          ]
+      # A magical Edge: only in campaigns with magic, only for new characters, and never as the
+      # Underdog Rule's bonus Edge.
+      magic: { type: boolean, default: false }
+      # What taking the Edge brings besides its effects, which the action that gains it adds: gear
+      # by content ID, program elements, a cyber budget, spells, a Focus pick, Friend Contacts.
+      startingItems: { type: set, of: string, default: [] }
+      # Cyberware it brings, installed when the character's System Strain can take it all.
+      startingCyber: { type: set, of: string, default: [] }
+      startingCyberStrain: { type: decimal, default: 0, min: 0 }
+      programElements: { type: integer, default: 0, min: 0 }
+      cyberBudget: { type: integer, default: 0, min: 0 }
+      spells: { type: integer, default: 0, min: 0 }
+      extraFocus: { type: boolean, default: false }
+      friendContacts: { type: integer, default: 0, min: 0 }
+      # The Edge buys Graced arts with its art points.
+      buysArts: { type: boolean, default: false }
+      # The Edge asks for an attribute (Prodigy).
+      asksAttribute: { type: boolean, default: false }
+    effects:
+      - id: taken
+        target: edges.taken
+        op: grant
+        value: { formula: item.id }
+
+fields:
+  edges.taken: { type: set, of: edge }
+  # Extra hit points on each hit die (Hard to Kill).
+  hp.dieBonus: { type: integer, formula: '0' }
+  # Skill points each level brings (Educated adds one).
+  skillPoints.perLevel: { type: integer, formula: '3' }
+
+choices:
+  - id: edge
+    slots: [1, 2, 5]
+    unique: edges
+    when: slot < 5 || level >= 5
+    from: { type: edge }
+    eligible: (campaign.magic || !item.magic) && (slot < 5 || !item.magic)
+  - id: underdog-edge
+    unique: edges
+    when: underdog
+    from: { type: edge }
+    eligible: '!item.magic'

package/rules/foci.yaml

@@ -0,0 +1,115 @@
+contentTypes:
+  # A Focus is a copy with its level: the first time it is chosen it is level 1, the second time
+  # level 2. Specialist may be taken again for another skill.
+  focus:
+    fields:
+      maxLevel: { type: integer, default: 2, min: 1, max: 2 }
+      # Bonus skills on taking the first level: a skill or `combat`, `any`, `punch-stab`, or
+      # `noncombat` (the Specialist's skill). `bonusSkill2` is a second one.
+      bonusSkill:
+        type: enum
+        values:
+          [
+            administer,
+            connect,
+            drive,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+            combat,
+            any,
+            punch-stab,
+            noncombat,
+          ]
+      bonusSkill2:
+        type: enum
+        values:
+          [
+            administer,
+            connect,
+            drive,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+          ]
+      # A bonus skill on taking the second level (Ace Driver's Fix).
+      levelTwoSkill:
+        type: enum
+        values:
+          [
+            administer,
+            connect,
+            drive,
+            exert,
+            fix,
+            heal,
+            know,
+            lead,
+            notice,
+            perform,
+            program,
+            punch,
+            shoot,
+            sneak,
+            stab,
+            survive,
+            talk,
+            trade,
+            work,
+          ]
+      # Gear the first level brings, by content ID, and the gear budget it opens.
+      startingItems: { type: set, of: string, default: [] }
+      # Cyberware it brings, installed when the character's System Strain can take it all.
+      startingCyber: { type: set, of: string, default: [] }
+      startingCyberStrain: { type: decimal, default: 0, min: 0 }
+      gearBudget: { type: enum, values: [vehicle, drone] }
+    state:
+      level: { type: integer, default: 1, min: 1, max: item.maxLevel }
+
+fields:
+  # Focus levels the character may have: one at creation, one more at levels 2, 5, 7 and 10, and
+  # one per Focused Edge.
+  foci.allowed:
+    type: integer
+    formula: '1 + (level >= 2 ? 1 : 0) + (level >= 5 ? 1 : 0) + (level >= 7 ? 1 : 0) + (level >= 10 ? 1 : 0)'
+  foci.taken:
+    type: integer
+    formula: "sumCopies(copy.state.level, copy.type == 'focus')"
+
+constraints:
+  - id: foci-allowed
+    check: foci.taken <= foci.allowed
+  - id: focus-once
+    copies: { type: focus, where: "!('repeatable' in item.tags)" }
+    check: countCopies(copy.item == item.id) <= 1
+
+followUps:
+  - id: gain-focus
+    while: '!character.creating && foci.taken < foci.allowed'
+    action: gain-focus

package/rules/gear.yaml

@@ -0,0 +1,176 @@
+contentTypes:
+  # Mission gear: kits, tools, clothing, comms. Readied gear is `equipped`.
+  gear:
+    carried: true
+    equippable: true
+    fields:
+      cost: { type: integer, default: 0, min: 0 }
+      # Encumbrance; none for gear that fits in a pocket. Gear tagged `worn` (clothing, packs)
+      # counts nothing while Readied.
+      enc: { type: integer, min: 0 }
+
+  # Pharmaceuticals and street drugs. `minHeal` is the Heal skill needed to administer one (none
+  # for anyone); `strain` the System Strain a dose adds.
+  drug:
+    carried: true
+    fields:
+      cost: { type: integer, default: 0, min: 0 }
+      enc: { type: integer, default: 1, min: 0 }
+      minHeal: { type: integer, min: 0 }
+      strain: { type: integer, default: 0, min: 0 }
+      # Hit points a dose heals, plus the Heal skill of whoever applies it.
+      healDice: { type: dice }
+    actions:
+      - use: use-drug
+
+fields:
+  # Encumbrance: Readied gear up to half Strength, Stowed gear up to Strength. A character may
+  # push past both by two Readied and four Stowed, twice, losing Move each time.
+  enc.readied:
+    type: integer
+    formula: >-
+      sumCopies(copy.fields.enc * copy.quantity,
+        has(copy.fields.enc) && copy.equipped && !('worn' in copy.tags))
+    limits: { max: enc.readiedMax + 4 }
+  enc.stowed:
+    type: integer
+    formula: >-
+      sumCopies(copy.fields.enc * copy.quantity, has(copy.fields.enc) && !copy.equipped)
+    limits: { max: enc.stowedMax + 8 }
+  enc.readiedMax: { type: integer, formula: floor(attributes.str.score / 2) }
+  enc.stowedMax: { type: integer, formula: attributes.str.score }
+  # How far past the limits the load is: 0, 1 (Move 7 m) or 2 (Move 5 m).
+  enc.overload:
+    type: integer
+    formula: >-
+      min(2, max(0, max(ceil((enc.readied - enc.readiedMax) / 2),
+        ceil((enc.stowed - enc.stowedMax) / 4))))
+
+  # Mods a tech can keep maintained: Int and Con modifiers plus three times Fix (Tinker doubles
+  # it, and at level 2 counts Fix one level higher).
+  maintenance.multiplier: { type: integer, formula: '1' }
+  maintenance.fixBonus: { type: integer, formula: '0' }
+  maintenance.max:
+    type: integer
+    formula: >-
+      max(0, attributes.int.mod + attributes.con.mod
+        + 3 * min(5, max(0, skills.fix.level + maintenance.fixBonus))) * maintenance.multiplier
+  # Mods the character keeps up, counted by the player.
+  maintenance.used: { type: integer, input: true, default: 0, min: 0 }
+
+  # Focus gear budgets (Ace Driver and Roamer for vehicles, Drone Pilot for drones), and what the
+  # character's focus gear costs against them.
+  budget.vehicle: { type: integer, formula: '0' }
+  budget.drone: { type: integer, formula: '0' }
+  budget.vehicleUsed:
+    type: integer
+    formula: "sumCopies(copy.fields.cost, copy.type == 'vehicle' && copy.state.focusGear)"
+  budget.droneUsed:
+    type: integer
+    formula: "sumCopies(copy.fields.cost, copy.type == 'drone' && copy.state.focusGear)"
+
+effects:
+  - id: overload
+    target: combat.move
+    op: add
+    value: '-[0, 3, 5][enc.overload]'
+    when: enc.overload > 0
+
+constraints:
+  - id: vehicle-budget
+    check: budget.vehicleUsed <= budget.vehicle
+  - id: drone-budget
+    check: budget.droneUsed <= budget.drone
+
+actions:
+  # Take a dose: spends the copy, adds its System Strain and, for healing drugs, heals.
+  - id: use-drug
+    tags: [drug]
+    available: self.quantity > 0
+    params:
+      healerSkill: { type: integer, optional: true }
+    steps:
+      - id: heal
+        kind: roll
+        when: has(item.healDice)
+        tags: [healing]
+        parts:
+          - dice: item.healDice
+          - value: 'has(params.healerSkill) ? params.healerSkill : 0'
+      - id: take
+        kind: changes
+        changes:
+          - { type: adjustQuantity, entry: self, by: -1 }
+          - { type: adjust, when: item.strain > 0, field: strain.temporary, by: item.strain }
+          - { type: adjust, when: has(steps.heal), field: hp.current, by: steps.heal.total }
+
+  # Buy vehicles or drones with a Focus's gear budget: the dearest one the budget buys is
+  # recommended. More are offered while the budget lasts, the dearest that still fits recommended,
+  # so an automatic run spends the budget; a player stops with `#done`.
+  - id: acquire-focus-gear
+    tags: [building]
+    available: budget.vehicle > budget.vehicleUsed || budget.drone > budget.droneUsed
+    params:
+      kind: { type: enum, values: [vehicle, drone] }
+      random: { type: boolean, default: false }
+    steps:
+      - id: vehicle
+        kind: choice
+        when: params.kind == 'vehicle'
+        sheet: proposed
+        options:
+          content:
+            type: vehicle
+            where: >-
+              item.cost <= budget.vehicle - budget.vehicleUsed && !('restricted' in item.tags)
+        prefer: item.cost
+        random: params.random
+        changes:
+          - type: addItem
+            entry: { item: picked.id, state: { focusGear: true } }
+      - id: vehicles
+        kind: choice
+        when: params.kind == 'vehicle'
+        sheet: proposed
+        options:
+          content:
+            type: vehicle
+            where: >-
+              item.cost <= budget.vehicle - budget.vehicleUsed && !('restricted' in item.tags)
+        repeat: { max: 5 }
+        prefer: item.cost
+        random: params.random
+        changes:
+          - type: addItem
+            entry: { item: picked.id, state: { focusGear: true } }
+      - id: drone
+        kind: choice
+        when: params.kind == 'drone'
+        sheet: proposed
+        options:
+          content:
+            type: drone
+            where: >-
+              item.cost <= budget.drone - budget.droneUsed && !('restricted' in item.tags)
+                && (!has(item.enc) || enc.stowed + item.enc <= enc.stowedMax)
+        prefer: item.cost
+        random: params.random
+        changes:
+          - type: addItem
+            entry: { item: picked.id, state: { focusGear: true } }
+      - id: drones
+        kind: choice
+        when: params.kind == 'drone'
+        sheet: proposed
+        options:
+          content:
+            type: drone
+            where: >-
+              item.cost <= budget.drone - budget.droneUsed && !('restricted' in item.tags)
+                && (!has(item.enc) || enc.stowed + item.enc <= enc.stowedMax)
+        repeat: { max: 5 }
+        prefer: item.cost
+        random: params.random
+        changes:
+          - type: addItem
+            entry: { item: picked.id, state: { focusGear: true } }

package/rules/hacking.yaml

@@ -0,0 +1,131 @@
+contentTypes:
+  # Cyberdecks. The best deck the character carries is the one they hack with.
+  cyberdeck:
+    carried: true
+    equippable: true
+    fields:
+      cost: { type: integer, default: 0, min: 0 }
+      enc: { type: integer, min: 0 }
+      bonusAccess: { type: integer, default: 0 }
+      memory: { type: integer, default: 0, min: 0 }
+      shielding: { type: integer, default: 0, min: 0 }
+      cpu: { type: integer, default: 0, min: 0 }
+    state:
+      # Shielding spent absorbing Stun and Kill damage; it regenerates after fifteen minutes.
+      shieldingUsed: { type: integer, default: 0, min: 0 }
+    effects:
+      - { id: access, target: hacking.deck.bonusAccess, op: set, value: item.bonusAccess }
+      - { id: memory, target: hacking.memory.max, op: set, value: item.memory }
+      - { id: cpu, target: hacking.cpu, op: set, value: item.cpu }
+      - { id: shielding, target: hacking.shielding.max, op: set, value: item.shielding }
+      - id: shield
+        target: { incoming: { fields: [hp.current], tags: [damage.cyberspace] } }
+        op: add
+        value: min(item.shielding - self.shieldingUsed, -incoming.amount)
+        when: >-
+          self.equipped && item.shielding > self.shieldingUsed && incoming.amount < 0
+        then:
+          - type: adjustState
+            entry: self
+            key: shieldingUsed
+            by: min(item.shielding - self.shieldingUsed, -incoming.amount)
+
+  # Program elements in deck Memory: Verbs (what to do) and Subjects (what to do it to).
+  program:
+    carried: true
+    fields:
+      cost: { type: integer, default: 0, min: 0 }
+      kind: { type: enum, values: [verb, subject], required: true }
+      # A Verb's valid Subject types, the Access it costs and its skill check modifier.
+      targets: { type: set, of: string, default: [] }
+      accessCost: { type: integer, default: 1, min: 0 }
+      checkMod: { type: integer, default: 0 }
+      # A Subject's type.
+      subjectType: { type: enum, values: [avatar, data, device, cyber, program] }
+    state:
+      # Bought on the street, written and maintained by the hacker, or one of the Hacker Edge's
+      # eight free elements.
+      source: { type: enum, values: [bought, written, edge], default: bought }
+    actions:
+      - use: run-program
+
+fields:
+  hacking.deck.bonusAccess: { type: integer, formula: '0' }
+  hacking.memory.max: { type: integer, formula: '0' }
+  hacking.cpu: { type: integer, formula: '0' }
+  hacking.shielding.max: { type: integer, formula: '0' }
+  hacking.shielding.current:
+    type: integer
+    formula: >-
+      maxCopies(copy.fields.shielding - copy.state.shieldingUsed,
+        copy.type == 'cyberdeck' && copy.equipped)
+  # Access: Intelligence modifier, Program skill and the deck's bonus. It refreshes once a day.
+  hacking.access.max:
+    type: integer
+    formula: max(0, attributes.int.mod + skills.program.level + hacking.deck.bonusAccess)
+  hacking.access.spent: { type: integer, input: true, default: 0, min: 0 }
+  hacking.access.current:
+    { type: integer, formula: 'max(0, hacking.access.max - hacking.access.spent)' }
+  # Memory: one unit per program element (half with Expert Programmer 2) and per datafile.
+  hacking.datafiles: { type: integer, input: true, default: 0, min: 0 }
+  hacking.memory.perElement: { type: decimal, formula: '1' }
+  hacking.memory.used:
+    type: integer
+    formula: "ceil(countCopies(copy.type == 'program') * hacking.memory.perElement) + hacking.datafiles"
+    limits: { max: hacking.memory.max }
+  # Verbs and Subjects a hacker can write and keep current: two per level of Program skill.
+  hacking.programming.max:
+    type: integer
+    formula: 'skills.program.level >= 1 ? 2 * skills.program.level : 0'
+  hacking.programming.used:
+    type: integer
+    formula: "countCopies(copy.type == 'program' && copy.state.source == 'written')"
+    limits: { max: hacking.programming.max }
+
+actions:
+  # Run a program: this Verb with a Subject in Memory. Pay the Verb's Access and roll Int/Program
+  # against the security difficulty; a failure loses the Access.
+  - id: run-program
+    tags: [hacking]
+    available: >-
+      item.kind == 'verb' && hacking.cpu > 0 && hacking.access.current >= item.accessCost
+    params:
+      difficulty: { type: integer, optional: true }
+      wireless: { type: boolean, default: false }
+      crown: { type: boolean, default: false }
+      modifier: { type: integer, optional: true }
+    results: [success, failure, rolled]
+    steps:
+      - id: subject
+        kind: choice
+        options:
+          copies:
+            type: program
+            where: item.kind == 'subject' && item.subjectType in action.item.targets
+        recommend: options[0]
+      - id: start
+        kind: branch
+        cases:
+          - when: true
+            flags: { dc: 'has(params.difficulty) ? params.difficulty : -1' }
+      - id: check
+        kind: roll
+        tags: [hacking, skill-check, skill.program, attr.int]
+        bands: check
+        parts:
+          - { dice: 2d6kh2, tags: [skill-dice] }
+          - field: "'attributes.int.mod'"
+          - field: "'skills.program.level'"
+          - { value: item.checkMod, when: item.checkMod != 0 }
+          - { value: -2, when: params.wireless }
+          - { value: -1, when: params.crown }
+          - { value: params.modifier, when: has(params.modifier) }
+      - id: pay
+        kind: changes
+        when: item.accessCost > 0
+        changes:
+          - { type: adjust, field: hacking.access.spent, by: item.accessCost }
+      - id: result
+        kind: outcome
+        result: "flags.dc < 0 ? 'rolled' : steps.check.band"
+        data: { total: steps.check.total }