pf2e-party-tracker 0.1.0

package/tools/build_reference.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""
+build_reference.py — convert the Foundry VTT `pf2e` system condition & action
+JSON into the compact reference data bundled by the party tracker.
+
+Source data: https://github.com/foundryvtt/pf2e  (game content under OGL/ORC).
+Get it with a sparse, shallow clone (only the two packs we need):
+
+    git clone --depth 1 --filter=blob:none --sparse \\
+        https://github.com/foundryvtt/pf2e.git pf2e-data
+    cd pf2e-data && git sparse-checkout set packs/pf2e/conditions packs/pf2e/actions
+
+Then:
+
+    python3 tools/build_reference.py --src /path/to/pf2e-data/packs/pf2e \\
+        --out data/reference.generated.js
+
+Output declares:
+    const GENERATED_REF_META  = {generated, source, sourceCommit, conditions, actions, sources[]}
+    const GENERATED_CONDITIONS = [{slug, name, description, valued, group}, ...]
+    const GENERATED_ACTIONS    = [{slug, name, category, traits, exploration, actionType, actions, description}, ...]
+Descriptions are cleaned plain text; newlines are meaningful (rendered as <br>).
+"""
+import argparse
+import datetime
+import glob
+import html
+import json
+import os
+import re
+import subprocess
+
+
+def src_commit(path):
+    """Best-effort short git commit of the Foundry data clone, for the stamp."""
+    try:
+        out = subprocess.check_output(
+            ["git", "-C", path, "rev-parse", "--short", "HEAD"],
+            stderr=subprocess.DEVNULL)
+        return out.decode().strip()
+    except Exception:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Inline Foundry markup -> readable text  (mirrors tools/build_spells.py)
+# ---------------------------------------------------------------------------
+GLYPH = {"1": "◆", "2": "◆◆", "3": "◆◆◆", "r": "⤳ reaction", "f": "◇ free"}
+
+
+def _glyph(content):
+    c = content.strip().lower()
+    return GLYPH.get(c, content)
+
+
+def _template(inner):
+    parts = inner.split("|")
+    ttype = parts[0]
+    dist = width = None
+    for p in parts[1:]:
+        if p.startswith("distance:"):
+            dist = p.split(":", 1)[1]
+        elif p.startswith("width:"):
+            width = p.split(":", 1)[1]
+    if dist and ttype == "line" and width:
+        return f"{dist}-foot line ({width} ft wide)"
+    if dist:
+        return f"{dist}-foot {ttype}"
+    return ttype
+
+
+def _damage(inner):
+    inner = inner.split(",")[0]
+    mtype = re.search(r"\[([^\]]+)\]", inner)
+    dtype = mtype.group(1).split(",")[0].strip() if mtype else ""
+    formula = inner[:mtype.start()] if mtype else inner
+    formula = formula.split("|")[0]
+    return f"{formula.strip()} {dtype}".strip()
+
+
+def _check(inner):
+    stat = inner.split("|")[0].split(":")[-1]
+    return f"{stat.capitalize()} check"
+
+
+def _uuid_label(inner):
+    seg = inner.split(".")[-1]
+    seg = re.sub(r"^(spell|feat|item|action|condition)s?[-_]?", "", seg, flags=re.I)
+    return seg.replace("-", " ").replace("_", " ").strip()
+
+
+def clean_html(raw):
+    if not raw:
+        return ""
+    s = raw
+    s = re.sub(r'<span class="action-glyph">(.*?)</span>',
+               lambda m: _glyph(m.group(1)), s, flags=re.S)
+    s = re.sub(r"@Template\[([^\]]+)\]", lambda m: _template(m.group(1)), s)
+    dmg = r"@Damage\[((?:[^\[\]]|\[[^\]]*\])*)\](?:\{([^}]+)\})?"
+    s = re.sub(dmg, lambda m: m.group(2) or _damage(m.group(1)), s)
+    s = re.sub(r"@Check\[([^\]]*)\]\{([^}]+)\}", r"\2", s)
+    s = re.sub(r"@Check\[([^\]]*)\]", lambda m: _check(m.group(1)), s)
+    s = re.sub(r"@UUID\[[^\]]+\]\{([^}]+)\}", r"\1", s)
+    s = re.sub(r"@UUID\[([^\]]+)\]", lambda m: _uuid_label(m.group(1)), s)
+    s = re.sub(r"@[A-Za-z]+\[[^\]]*\]\{([^}]+)\}", r"\1", s)
+    s = re.sub(r"@[A-Za-z]+\[[^\]]*\]", "", s)
+    s = re.sub(r"<hr\s*/?>", "\n", s)
+    s = re.sub(r"<li[^>]*>", "\n• ", s)
+    s = re.sub(r"</li>", "", s)
+    s = re.sub(r"<br\s*/?>", "\n", s)
+    s = re.sub(r"<p[^>]*>", "\n\n", s)
+    s = re.sub(r"</(p|ul|ol|div|table|tr)>", "\n", s)
+    s = re.sub(r"<[^>]+>", "", s)
+    # drop any remaining Foundry variable interpolation
+    s = re.sub(r"@[a-z]+\.[\w.]+(?:\*\d+)?", "", s, flags=re.I)
+    s = html.unescape(s)
+    s = re.sub(r"[ \t]+", " ", s)
+    s = re.sub(r" *\n *", "\n", s)
+    s = re.sub(r"\n{3,}", "\n\n", s)
+    return s.strip()
+
+
+# ---------------------------------------------------------------------------
+def load_json(path):
+    with open(path, encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+def transform_condition(doc):
+    sysd = doc.get("system", {})
+    value = sysd.get("value") or {}
+    pub = sysd.get("publication") or sysd.get("source") or {}
+    return {
+        "slug": doc.get("system", {}).get("slug") or slug_from(doc),
+        "name": doc.get("name", ""),
+        "description": clean_html((sysd.get("description") or {}).get("value", "")),
+        "valued": bool(value.get("isValued")),
+        "group": sysd.get("group") or None,
+        "_license": pub.get("license") or "",
+        "_source": pub.get("title") or "",
+    }
+
+
+def transform_action(doc):
+    sysd = doc.get("system", {})
+    traits = (sysd.get("traits") or {}).get("value", []) or []
+    pub = sysd.get("publication") or sysd.get("source") or {}
+    return {
+        "slug": sysd.get("slug") or slug_from(doc),
+        "name": doc.get("name", ""),
+        "category": sysd.get("category") or "",
+        "traits": traits,
+        "exploration": "exploration" in traits,
+        "actionType": (sysd.get("actionType") or {}).get("value", ""),
+        "actions": (sysd.get("actions") or {}).get("value"),
+        "description": clean_html((sysd.get("description") or {}).get("value", "")),
+        "_license": pub.get("license") or "",
+        "_source": pub.get("title") or "",
+    }
+
+
+def slug_from(doc):
+    name = doc.get("name", "item")
+    return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+
+
+def collect(pattern):
+    out = []
+    for path in sorted(glob.glob(pattern, recursive=True)):
+        try:
+            doc = load_json(path)
+        except Exception:
+            continue
+        yield_doc = doc if isinstance(doc, dict) else None
+        if yield_doc:
+            out.append(yield_doc)
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--src", required=True, help="path to <clone>/packs/pf2e")
+    ap.add_argument("--out", required=True, help="output .js path")
+    args = ap.parse_args()
+
+    cond_docs = collect(os.path.join(args.src, "conditions", "**", "*.json"))
+    # Only the GM-facing general actions (not every class/ancestry/archetype feat)
+    # — this keeps the reference relevant to exploration & passive play and the
+    # bundle small. Seek/Sense Motive are in basic/; Track/Cover Tracks/Recall
+    # Knowledge/Treat Wounds in skill/ & downtime/.
+    act_docs = []
+    for sub in ("exploration", "skill", "basic", "downtime"):
+        act_docs.extend(collect(os.path.join(args.src, "actions", sub, "**", "*.json")))
+
+    conditions, actions = [], []
+    src_counts = {}
+
+    for doc in cond_docs:
+        if doc.get("type") != "condition":
+            continue
+        c = transform_condition(doc)
+        _tally(src_counts, c)
+        conditions.append(_strip_private(c))
+
+    for doc in act_docs:
+        if doc.get("type") != "action":
+            continue
+        a = transform_action(doc)
+        _tally(src_counts, a)
+        actions.append(_strip_private(a))
+
+    conditions.sort(key=lambda x: x["name"])
+    actions.sort(key=lambda x: x["name"])
+
+    commit = src_commit(args.src)
+    meta = {
+        "generated": datetime.date.today().isoformat(),
+        "source": "foundryvtt/pf2e",
+        "sourceCommit": commit,
+        "conditions": len(conditions),
+        "actions": len(actions),
+        "sources": [{"title": t, "license": lic, "count": n}
+                    for (t, lic), n in sorted(src_counts.items(), key=lambda kv: -kv[1])],
+    }
+
+    header = ("/* data/reference.generated.js — AUTO-GENERATED. Do not hand-edit.\n"
+              "   Rebuild with:  npm run build:ref\n"
+              "   Source: foundryvtt/pf2e condition + action data (Paizo content, OGL/ORC). */\n")
+    with open(args.out, "w", encoding="utf-8") as fh:
+        fh.write(header)
+        fh.write("const GENERATED_REF_META = " + json.dumps(meta, ensure_ascii=False) + ";\n")
+        fh.write("const GENERATED_CONDITIONS = " + json.dumps(conditions, ensure_ascii=False) + ";\n")
+        fh.write("const GENERATED_ACTIONS = " + json.dumps(actions, ensure_ascii=False) + ";\n")
+
+    print(f"wrote {args.out}: {len(conditions)} conditions, {len(actions)} actions"
+          + (f" (commit {commit})" if commit else ""))
+
+
+def _tally(counts, item):
+    key = (item.get("_source") or "Unknown", item.get("_license") or "")
+    counts[key] = counts.get(key, 0) + 1
+
+
+def _strip_private(item):
+    return {k: v for k, v in item.items() if not k.startswith("_")}
+
+
+if __name__ == "__main__":
+    main()

package/tools/fixtures/investigator.json

@@ -0,0 +1 @@
+	{"success":true,"build":{"name":"Perengis \"Perry\"  Xvant","class":"Investigator","level":2,"ancestry":"Human","heritage":"Half-Elf","background":"Lesser Scion","alignment":"NG","gender":"Female","age":"20","deity":"None","size":2,"keyability":"int","languages":["Common","Dwarven","Elven","Goblin","Orcish","Sylvan"],"attributes":{"ancestryhp":8,"classhp":8,"bonushp":0,"bonushpPerLevel":0,"speed":25,"speedBonus":0},"abilities":{"str":10,"dex":14,"con":10,"int":18,"wis":14,"cha":12},"proficiencies":{"classDC":2,"perception":4,"fortitude":2,"reflex":4,"will":4,"heavy":0,"medium":0,"light":2,"unarmored":2,"advanced":0,"martial":2,"simple":2,"unarmed":2,"castingArcane":0,"castingDivine":0,"castingOccult":0,"castingPrimal":0,"acrobatics":2,"arcana":2,"athletics":0,"crafting":0,"deception":2,"diplomacy":2,"intimidation":2,"medicine":4,"nature":0,"occultism":2,"performance":0,"religion":2,"society":2,"stealth":2,"survival":0,"thievery":2},"feats":[["Hobnobber",null],["Battle Medicine",null],["Forensic Acumen",null],["Natural Ambition",null,"Ancestry Feat",1],["That's Odd",null,"Class Feat",1],["Half-Elf",null,"Heritage",1],["Known Weaknesses",null,"Class Feat",1],["Shared Stratagem",null,"Class Feat",2],["Continual Recovery",null,"Skill Feat",2]],"specials":["Low-Light Vision","Devise a Stratagem","On the Case","Clue In","Strategic Strike","Forensic Medicine Methodology","Pursue a Lead","Half-Elf"],"lores":[["Heraldry",2],["Osirion",0]],"equipment":[["Bedroll",1],["Chalk",10],["Flint and Steel",1],["Rope",1],["Rations",2],["Torch",5],["Waterskin",1],["Soap",1],["Healer's Tools",1],["Arrows",30],["Thieves' Tools",1],["Healing Potion (Minor)",1]],"specificProficiencies":{"trained":[],"expert":[],"master":[],"legendary":[]},"weapons":[{"name":"Bo Staff","qty":1,"prof":"martial","die":"d8","pot":0,"str":"","display":"Bo Staff","runes":[]},{"name":"Shortbow","qty":1,"prof":"martial","die":"d6","pot":0,"str":"","display":"Shortbow","runes":[]}],"money":{"pp":0,"gp":0,"sp":0,"cp":0},"armor":[{"name":"Leather Armor","qty":1,"prof":"light","pot":0,"res":"","display":"Leather","worn":true,"runes":[]}],"spellCasters":[],"formula":[],"pets":[],"acTotal":{"acProfBonus":4,"acAbilityBonus":2,"acItemBonus":1,"acTotal":17}}}

package/tools/test.mjs

@@ -0,0 +1,165 @@
+import { JSDOM, VirtualConsole } from "jsdom";
+import fs from "node:fs";
+
+const html = fs.readFileSync(new URL("../dist/index.html", import.meta.url), "utf8");
+
+let pass = 0, fail = 0;
+function ok(cond, msg) { (cond ? pass++ : fail++); console.log((cond ? "  ✓ " : "  ✗ FAIL ") + msg); }
+function eq(a, b, msg) { ok(a === b, `${msg} (got ${JSON.stringify(a)}, want ${JSON.stringify(b)})`); }
+
+const errors = [];
+const vc = new VirtualConsole();
+vc.on("jsdomError", (e) => errors.push(e.message));
+
+const dom = new JSDOM(html, {
+  runScripts: "dangerously",
+  virtualConsole: vc,
+  url: "https://example.org/",
+  beforeParse(window) { window.scrollTo = () => {}; window.confirm = () => true; window.alert = () => {}; },
+});
+const w = dom.window;
+const d = w.document;
+const ev = (expr) => w.eval(expr);
+
+/* The real L2 Investigator export (tools/fixtures/investigator.json), inlined so
+   the test is self-contained. Every derived value below is hand-computed. */
+const FIX = {
+  success: true,
+  build: {
+    name: 'Perengis "Perry"  Xvant', class: "Investigator", level: 2,
+    ancestry: "Half-Elf", heritage: "", background: "Criminal", size: 2, keyability: "int",
+    languages: ["Common", "Dwarven", "Elven", "Goblin", "Orcish", "Sylvan"],
+    abilities: { str: 10, dex: 14, con: 10, int: 18, wis: 14, cha: 12 },
+    attributes: { ancestryhp: 8, classhp: 8, bonushp: 0, bonushpPerLevel: 0, speed: 25, speedBonus: 0 },
+    proficiencies: {
+      perception: 4, fortitude: 2, reflex: 4, will: 4, classDC: 2,
+      acrobatics: 2, arcana: 2, athletics: 0, crafting: 0, deception: 2, diplomacy: 2,
+      intimidation: 2, medicine: 4, nature: 0, occultism: 2, performance: 0, religion: 2,
+      society: 2, stealth: 2, survival: 0, thievery: 2,
+    },
+    acTotal: { acProfBonus: 4, acAbilityBonus: 2, acItemBonus: 1, acTotal: 17 },
+    lores: [["Heraldry", 2], ["Osirion", 0]],
+    specials: ["Low-Light Vision", "Devise a Stratagem", "Half-Elf"],
+    spellCasters: [],
+  },
+};
+
+console.log("\n# load / no script errors");
+ok(errors.length === 0, "no jsdom script errors" + (errors.length ? ": " + errors[0] : ""));
+ok(!html.includes("/*__INJECT_"), "all build markers were replaced");
+ok(ev("pcs().length") === 0, "starts with an empty party");
+ok(!d.getElementById("view-roster").classList.contains("hide"), "lands on the roster view");
+ok(/No characters yet/.test(d.getElementById("view-roster").innerHTML), "roster shows the empty state");
+
+console.log("\n# arithmetic helpers");
+eq(w.abilityMod(18), 4, "abilityMod(18)");
+eq(w.abilityMod(10), 0, "abilityMod(10)");
+eq(w.abilityMod(7), -2, "abilityMod(7)");
+eq(w.profBonus(0, 5), 0, "profBonus untrained adds neither rank nor level");
+eq(w.profBonus(2, 1), 3, "profBonus trained @L1 = 2+1");
+eq(w.profBonus(8, 20), 28, "profBonus legendary @L20 = 8+20");
+
+console.log("\n# parsePathbuilder — derived stats vs the real fixture");
+const pc = w.parsePathbuilder(FIX);
+eq(pc.name, 'Perengis "Perry" Xvant', "name (whitespace collapsed)");
+eq(pc.level, 2, "level");
+eq(pc.mods.int, 4, "INT mod +4");
+eq(pc.mods.dex, 2, "DEX mod +2");
+eq(pc.mods.con, 0, "CON mod 0");
+eq(pc.perception, 8, "Perception +8 (wis+2, expert 4+2)");
+eq(pc.perceptionPassive, 18, "Perception passive 18");
+eq(pc.saves.fortitude, 4, "Fort +4");
+eq(pc.saves.reflex, 8, "Ref +8");
+eq(pc.saves.will, 8, "Will +8");
+eq(pc.ac, 17, "AC 17 (uses acTotal.acTotal)");
+eq(pc.classDC, 18, "Class DC 18 (10 + prof 6 + int 4) — no double level");
+eq(pc.hpMax, 24, "HP max 24 (8 + (8+0)*2)");
+eq(pc.speed, 25, "Speed 25");
+eq(pc.skills.athletics.mod, 0, "Athletics +0 (untrained, str 0)");
+eq(pc.skills.arcana.mod, 8, "Arcana +8 (int 4, trained 2+2)");
+eq(pc.skills.medicine.mod, 8, "Medicine +8 (wis 2, expert 4+2)");
+eq(pc.skills.deception.mod, 5, "Deception +5 (cha 1, trained 2+2)");
+eq(pc.skills.nature.mod, 2, "Nature +2 (untrained, wis 2)");
+eq(pc.skills.arcana.passive, 18, "Arcana passive 18");
+eq(pc.lores.length, 2, "two lores");
+eq(pc.lores[0].name + " " + pc.lores[0].mod, "Heraldry 8", "Heraldry Lore +8 (int 4, trained 2+2)");
+eq(pc.lores[1].mod, 4, "Osirion Lore +4 (untrained, int 4)");
+eq(pc.senses.join(","), "Low-Light Vision", "senses picks Low-Light Vision out of specials");
+eq(pc.languages.length, 6, "6 languages");
+eq(pc.spellcasting.length, 0, "no spellcasting");
+
+console.log("\n# parsePathbuilder — synthetic spellcaster DC/attack");
+const caster = w.parsePathbuilder({ build: {
+  name: "Sorc", level: 5, keyability: "cha",
+  abilities: { str: 8, dex: 14, con: 12, int: 10, wis: 10, cha: 18 },
+  attributes: { ancestryhp: 6, classhp: 6, bonushp: 0, bonushpPerLevel: 0, speed: 25, speedBonus: 0 },
+  proficiencies: { perception: 2, fortitude: 2, reflex: 2, will: 4, classDC: 0 },
+  acTotal: { acTotal: 20 }, lores: [],
+  spellCasters: [{ name: "Arcane", magicTradition: "arcane", ability: "cha", proficiency: 4, focusPoints: 1 }],
+} });
+eq(caster.spellcasting[0].dc, 10 + (4 + 5) + 4, "spell DC = 10 + prof(4,5) + cha 4 = 23");
+eq(caster.spellcasting[0].attack, (4 + 5) + 4, "spell attack = prof(4,5) + cha 4 = +13");
+eq(caster.focusPool, 1, "focus pool summed");
+eq(caster.hpMax, 6 + (6 + 1) * 5, "HP with positive Con: 6 + (6+1)*5 = 41");
+
+console.log("\n# validation");
+let threw = false; try { w.parsePathbuilder({ build: { name: "x" } }); } catch (e) { threw = true; }
+ok(threw, "missing core fields throws");
+
+console.log("\n# commitImport — add, then re-import preserves live state & clamps HP");
+w.commitImport(FIX, "102154");
+eq(ev("pcs().length"), 1, "one character after import");
+const id = ev("pcs()[0].id");
+ev(`library.characters['${id}'].live.hpCur = 5; library.characters['${id}'].live.conditions=[{key:'frightened',value:2}]; library.characters['${id}'].live.heroPoints=3;`);
+const r2 = w.commitImport(FIX, "102154");
+ok(r2.updated === true, "re-import by pbId updates in place (no duplicate)");
+eq(ev("pcs().length"), 1, "still one character (matched, not duplicated)");
+eq(ev(`library.characters['${id}'].live.hpCur`), 5, "live HP preserved across re-import");
+eq(ev(`library.characters['${id}'].live.conditions[0].value`), 2, "conditions preserved across re-import");
+
+console.log("\n# roller — degrees of success");
+eq(w.degreeOf(25, 10, 15), 3, "total >= DC+10 -> crit success");
+eq(w.degreeOf(15, 10, 15), 2, "total >= DC -> success");
+eq(w.degreeOf(14, 10, 15), 1, "below DC -> failure");
+eq(w.degreeOf(5, 10, 15), 0, "total <= DC-10 -> crit failure");
+eq(w.degreeOf(14, 20, 15), 2, "natural 20 shifts failure up to success");
+eq(w.degreeOf(15, 1, 15), 1, "natural 1 shifts success down to failure");
+eq(w.degreeOf(30, 10, ""), null, "no DC -> no degree");
+
+console.log("\n# roller — rolls once per PC, sorted, uses stored mods");
+w.go("roll");
+const realRandom = w.Math.random; let seq = [0.0, 0.95], k = 0;
+w.Math.random = () => seq[(k++) % seq.length];
+d.getElementById("rollStat").value = "perception";
+d.getElementById("rollDC").value = "";
+w.rollForParty();
+eq(ev("_lastRoll.rolls.length"), 1, "one roll for the one PC");
+w.Math.random = realRandom;
+
+console.log("\n# live tracking — damage soaks temp HP first, heal caps at max");
+ev(`library.activeId='${id}';`);
+ev(`library.characters['${id}'].live.hpCur=24; library.characters['${id}'].live.hpTemp=3;`);
+w.go("roster");
+w.setHP(id, 24);
+ev(`(function(){var a=document.getElementById('amt-${id}'); if(a) a.value=5;})()`);
+w.applyHP(id, -1);
+eq(ev(`library.characters['${id}'].live.hpTemp`), 0, "temp HP absorbed first (3 of 5)");
+eq(ev(`library.characters['${id}'].live.hpCur`), 22, "remaining 2 damage hits current (24 -> 22)");
+w.applyHP(id, 1);
+ev(`(function(){var a=document.getElementById('amt-${id}'); if(a) a.value=100;})()`);
+w.applyHP(id, 1);
+eq(ev(`library.characters['${id}'].live.hpCur`), 24, "heal caps at max HP");
+
+console.log("\n# backup codes round-trip");
+w.exportParty();
+const code = d.getElementById("backupIO").value;
+ok(code.startsWith("PF2EPARTY1:"), "party export produces a PF2EPARTY1 code");
+d.getElementById("backupIO").value = code;
+w.importBackup();
+eq(ev("pcs().length"), 2, "importing the party code adds the characters back");
+
+console.log("\n# no emoji in the shipped UI text");
+ok(!/[\u{1F000}-\u{1FAFF}\u{2600}-\u{27BF}]/u.test(html.replace(/[✓✗]/g, "")), "no stray emoji in dist");
+
+console.log(`\n${pass} passed, ${fail} failed`);
+process.exit(fail ? 1 : 0);