Author SHA1 Message Date
kathleen fbf42508a0 Merge pull request 'Stable run ids (fingerprints) for the form and the register; tests for the site statistics' (#46) from atlas/fingerprint-ids into main
Publish the site (pages branch) / publish (push) Successful in 5s
CI / test (push) Successful in 2m3s
2026-11-19 20:23:21 +00:00
ekcSchianoandClaude Opus 5.5 1dfa8fb4c3 Stable run ids (fingerprints) for the form and the register; tests for the site statistics (#25)
CI / test (pull_request) Successful in 43s
- collection/etl/runs.py fingerprints(): a form or register run's id is now <prefix>-<hash of the row's non-empty
  answers, timestamp included> instead of its row number, so deleting or re-sorting rows in the sheet moves no
  other run's id, and a column added later changes none. The 32 rows that are exact copies of another row get
  -2, -3 (identical, so which is which does not matter). A row edited in the sheet gets a new id. Every id in
  runs_clean.csv and overlap.json changes once; nothing else does (no statistic or model reads the ids).
- tests/core/test_site_stats.py (9 tests): measures.yaml conditions, source groups and presets, bond
  denominators without deliberate deaths (cards, encounters, route map), the riders' paths, and a JSON-safe
  stats.json, on a fixed sample of the published runs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 20:16:16 +00:00
kathleen ca411e8315 Merge pull request 'The Black on the page: a first-attempt range marked low evidence; the Black panels load again' (#45) from site/black-low-evidence into main
CI / test (push) Successful in 2m9s
Publish the site (pages branch) / publish (push) Successful in 5s
2026-11-19 18:42:22 +00:00
kathleenandClaude Opus 5.5 b51a6c7039 The Black on the page: a first-attempt range marked low evidence; the Black panels load again
CI / test (pull_request) Successful in 40s
- The odds card for the Black: "Low evidence", "about 1 in N" first attempts, the 95% range written as
  "between 1 in X and 1 in Y", later attempts effectively never, why it is uncertain (every logged shadow is a
  rider who chose to post), and the steps (shadow -> reached the Black -> bonded). Dashed border.
- Valley map: the Black's routes are solved for a first attempt (they showed ~0% per attempt), labelled "on a first
  attempt", and "Why this route?" gives the same range and caveat.
- "The Black is not dice" panel: why the odds are uncertain, and what replaces the assumption (fresh-account bot
  runs to the tree).
- analysis/black/evidence.py wrote "odds_ratio": Infinity (no later-attempt shadow at all), which is not JSON:
  the page's two Black panels showed "could not be loaded". Now null, and the report says "unbounded".

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 18:40:01 +00:00
kathleen d7befc8e18 Merge pull request 'Review summary on Reddit scraper PRs; measure the form/Reddit overlap' (#44) from atlas/reddit-review into main
Publish the site (pages branch) / publish (push) Successful in 6s
CI / test (push) Successful in 40s
2026-11-19 16:50:48 +00:00
ekcSchianoandClaude Opus 5.5 98be27fc1f Reddit scraper PRs get a review summary; the form/Reddit overlap is measured (#23, #24)
CI / test (pull_request) Successful in 40s
- collection/etl/review_reddit.py (`python -m collection review-reddit`) and .gitea/workflows/reddit-review.yml:
  on every scraper pull request, one comment (refreshed on each push) listing the runs added, changed and gone, the
  runs that break a game rule (left out of the model and stats until corrected), other flags, runs that may also
  be in the form, and result pages already counted; plus how to reject / fix / add. forge.upsert_comment keeps it
  to one comment. collection/README.md: "Reviewing Reddit runs".
- analysis/overlap/overlap.py -> data/public/overlap.json: a Reddit run with at least 4 route answers "matches" a
  form row giving the same answers within a day; chance is the same test a few weeks off. 9 of 36 comparable runs
  match, ~7.3 by chance: about 2 of 82 look reported twice, too few to matter. Nothing is removed. Shown on the
  page's Data & methods tab; in the dataset metadata; checked in test:py; part of `rebuild`.
- Neither the form nor the register records a result-page id, so the only proven copy (comment <-> result page)
  stays the one #18 applies.
- data/public/stats.json: the statistics of #42 (impossible runs left out), which did not make it into that merge.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 16:44:52 +00:00
kathleen cd618d37d3 Merge pull request 'Publish the built site to a pages branch for Ken's server' (#43) from infra/pages-branch into main
Publish the site (pages branch) / publish (push) Successful in 6s
CI / test (push) Successful in 40s
2026-11-19 16:37:04 +00:00
kathleenandClaude Opus 5.5 0ae29b5423 Publish the built site to a pages branch for Ken's server to serve (#27)
CI / test (pull_request) Successful in 39s
Every push to main builds the static site (npm run build -> dist/) and force-pushes it as the only commit of
the `pages` branch. Ken's web server serves that branch (a git-sync sidecar or a pull on a timer): nothing
on his server needs a secret, since the repository is public, and the site updates within minutes of every
merge, data PRs included.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 16:36:08 +00:00
kathleen 0df6b8d473 Merge pull request 'Impossible runs: one definition, left out of the route model and the site statistics' (#42) from atlas/impossible-runs into main
Send the route model to the bot / send (push) Successful in 7s
CI / test (push) Successful in 2m8s
2026-11-19 16:32:10 +00:00
ekcSchianoandClaude Opus 5.5 46c1f00150 Impossible runs: one definition, left out of the route model and the site statistics (#21, #22)
CI / test (pull_request) Successful in 41s
- core/spec/form.yaml impossible_flags: the flags that mean a run cannot have happened as recorded (a dragon an
  encounter does not have, a Green or the Black in the valley, two bonds, two burns, a cadet path that does not
  follow, an early death that still reached the hour...). atlas.runs.impossible() reads it.
- The route model and the site statistics (and the riders' paths) leave those runs out, from every source; every
  other run is used, however partial. The runs stay in runs_clean.csv, flagged. 80 runs: 75 form, 5 Reddit.
  Route-model odds move by at most 0.2 points.
- collection/etl/runs.py: the community form gets the same game-rule checks as "Report a run" and the Reddit
  comments (10 form rows newly flagged); new rule: the Black in the valley.
- The first-sighting pool stays a flag only: it is what riders have seen, not a rule.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 16:03:45 +00:00
kathleen ae370329e3 Merge pull request 'Infrastructure: stop the queued bot cycle, one source check at a time, track site/' (#41) from infra/settings into main
CI / test (push) Successful in 2m6s
2026-11-19 15:17:57 +00:00
kathleenandClaude Opus 5.5 5f080e0a82 Infrastructure: stop the queued bot cycle, one source check at a time, track site/ (#27)
CI / test (pull_request) Successful in 39s
- bot-cycle.yml: no schedule. It needs a runner on the bot's machine that no one has added, so every 4 hours
  a run queued forever. The bot's data already arrives through the daily source check (it reads
  DragonKind/DragonKind) and the model goes back through push-policy. Still runnable by hand.
- update-sources.yml: a concurrency group, so two dispatches never build and push at once.
- .gitignore: drop `/site` (a Python template's mkdocs line). site/ is the Atlas page; new files there were
  silently ignored.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 15:16:59 +00:00
kathleen d0141f2d9c Merge pull request 'Reddit comments and the bot in the route model and the site odds; chosen deaths never count as failed bonds' (#40) from atlas/reddit-in-model into main
CI / test (push) Successful in 44s
Send the route model to the bot / send (push) Successful in 1m7s
2026-11-19 15:00:39 +00:00
ekcSchianoandClaude Opus 5.5 036c86a1d1 Site statistics: the bot's runs, every source labelled as itself, chosen deaths never counted as failed bonds
CI / test (pull_request) Successful in 39s
- analysis/stats/measures.yaml: the bot is a statistics source. A deliberate death (`_deliberate`, the route
  model's rule: burned at an encounter the rider was not attempting) is left out of every bond rate, encounter
  rate and route ranking, for every source, as the model and the summary cards already did. Biggest moves (all
  runs): two Greens 8.9% -> 29.1%, meadow Orange 9.2% -> 25.2%, meadow Brown 14.3% -> 28.3%, valley Red 79.2% ->
  93.3%; mostly from form riders who burned on purpose, not from the bot.
- analysis/stats/site_stats.py: runs that are not from the spreadsheet are grouped as their own source
  ("Reddit comments", "DragonKind bot", "Reported on the Atlas"), not as bulk logs; two new presets (Reddit
  comments only, DragonKind bot only); the route map's bond denominators skip deliberate deaths.
- site/atlas/app.js: the bulk-import share counts only spreadsheet imports.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 14:58:17 +00:00
kathleen 99563a59ea Merge pull request 'Runs from the Reddit megathread comments' (#38) from data/reddit-comments into main
CI / test (push) Successful in 39s
2026-11-19 14:50:14 +00:00
ekcSchianoandClaude Opus 5.5 d606ed1651 Reddit comment runs in the route model and the odds; Black report gate wording; cite both megathreads
- planner/policy.yaml: `reddit comment` is a model source. Only runs that break a game rule (the rule_flags
  checks) are left out; partial runs are kept. Its own reporting-bias group, and out of the low-bias sample
  (riders posting a run pick the notable ones). 77 of the 82 runs are used.
- analysis/stats/measures.yaml: the site statistics use every source answered in the form's terms (form,
  "Report a run", Reddit comments).
- analysis/black/evidence.py: a shadow run is "off the gates" only when an answer contradicts a gate (3); runs
  that do not say are counted separately (14).
- croissant isBasedOn lists both megathreads (pipeline.yaml `cite`).
- Rebuilt: policy.json, stats.json, BLACK.md, black.json, croissant.json.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 14:50:08 +00:00
ekcSchiano 75f11378e2 data: keep main's route model (Reddit comment runs are not a model source yet)
CI / test (pull_request) Successful in 2m13s
2026-11-19 09:45:17 -05:00
kathleenandClaude Opus 5.5 b82ef16a9f data: croissant checksum for the rebuilt runs_clean.csv
CI / test (pull_request) Successful in 2m2s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 14:14:50 +00:00
kathleenandClaude Opus 5.5 e30825ec84 data: rebuild the Reddit comment runs with the game-rule checks from #37
CI / test (pull_request) Failing after 9s
6 of the 82 runs now carry rule flags (Brown/Red at the shadow, Green after
jumping on the Red, Red in the meadow, Orange first for Alone/Center, fight
answers on an ignored scream). Only their data_flags change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 14:14:16 +00:00
kathleen 93dab0b963 Merge branch 'main' into data/reddit-comments
CI / test (pull_request) Failing after 1m22s
2026-11-19 14:10:13 +00:00
kathleen fdb603f5a4 Merge pull request 'Game-rule checks for runs answered through "Report a run"' (#37) from data/report-rule-checks into main
CI / test (push) Successful in 41s
2026-11-19 14:10:08 +00:00
kathleen e06fd46e15 Merge pull request 'Known answers for the bot: the guide's encounter answers and the bot's own results, by choice text' (#39) from atlas/known-answers into main
Send the route model to the bot / send (push) Successful in 7s
CI / test (push) Successful in 1m58s
2026-11-19 14:00:17 +00:00
Atlas Reddit reader 7b0a01efb0 data: runs from the Reddit megathread comments
CI / test (pull_request) Successful in 39s
2026-11-19 08:57:59 -05:00
kschianoandClaude Opus 5.5 0f4430f6f5 Game-rule checks for runs answered through "Report a run"
CI / test (pull_request) Successful in 2m0s
Reported and Reddit-comment runs now get the checks the community form
gets in core/atlas/coding.py, as data_flags (the run is kept):
- first dragon outside the documented pool for the company/direction
- a bond or burn by a dragon the encounter does not have (new
  encounter_colours table in core/spec/form.yaml; Orange/Brown after the
  two Greens allowed, as a Green's rescue)
- a Green on a valley run
- a cadet outcome off its scream path, fight answers or a post-fight path
  on a run that did not help, a second fight move without assessing
- died before the hour, yet reached the tree/valley or an encounter

planner/policy.yaml drop_flagged: flagged runs of sources read from free
text (reddit comment) stay out of the route model; provenance notes do not
count as flags. No effect today: the source is not in `sources` yet.

On the first 82 scraped runs: 6 flagged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 08:46:57 -05:00
ekcSchianoandClaude Opus 5.5 e10312ab02 Known answers for the bot: the guide's encounter answers and the bot's own results, by choice text (#35)
CI / test (pull_request) Successful in 2m3s
analysis/known/build_known.py writes data/public/known_answers.json from pdf_encounters.json and tree.json;
solver.js knownAnswer(known, offered, { target, sceneColour }) matches a screen's choices against it (the guide's
paraphrases by their words, the bot's texts exactly) and returns a pick when one choice is clearly on the guide's
recommended path to the target, plus the evidence for every choice to hand to Clef. Rebuilt daily, checked in CI,
and sent to the bot with the route model.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 13:32:09 +00:00
kathleen fefc163e09 Merge pull request 'Valley map: the answers inside each bonding encounter, from the community guide and the bot' (#34) from site/encounter-guide into main
CI / test (push) Successful in 38s
2026-11-19 13:18:41 +00:00
ekcSchianoandClaude Opus 5.5 cd79dc8c5a Valley map: the answers inside each encounter, from the community guide and the bot
CI / test (pull_request) Successful in 39s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 13:17:24 +00:00
kathleen c943f5a289 New data from the community sources (#33)
Send the route model to the bot / send (push) Successful in 7s
CI / test (push) Successful in 1m59s
CI / test (pull_request) Successful in 1m58s
2026-11-19 10:31:00 +00:00
kathleen a195a8a483 Merge pull request 'Valley map: every choice point is a clickable dot' (#32) from site/choice-dots into main
CI / test (push) Successful in 3m0s
2026-11-19 04:01:52 +00:00
ekcSchianoandClaude Opus 5.5 c1d3840d94 Valley map: every choice point is a clickable dot
CI / test (pull_request) Successful in 2m9s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-18 22:56:29 -05:00
kathleen 0035483048 Merge pull request 'Silhouettes: holes where the sheet leaves gaps, a dark Black, outlined map dragons' (#31) from site/silhouettes-v3 into main
CI / test (push) Successful in 3m2s
2026-11-19 03:53:18 +00:00
ekcSchianoandClaude Opus 5.5 ff164ffaeb Silhouettes: holes where the sheet leaves gaps, a dark Black, outlined map dragons
CI / test (pull_request) Successful in 43s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-18 22:52:03 -05:00
kathleen 986cdd9c0a New data from the community sources (#30)
CI / test (push) Successful in 43s
Send the route model to the bot / send (push) Successful in 1m18s
2026-11-19 03:36:53 +00:00
kathleen 70d0542ce8 Merge pull request 'Paths of all riders: one Google Sheet layer, deaths as line styles; silhouettes with interior lines' (#20) from site/paths-v2 into main
CI / test (push) Successful in 43s
2026-11-19 03:28:13 +00:00
ekcSchianoandClaude Opus 5.5 57839fcc87 Paths of all riders: one Google Sheet layer, deaths as line styles; silhouettes with their interior lines
CI / test (pull_request) Successful in 44s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-18 22:26:51 -05:00
kathleen 7ef8a58a0e Merge pull request 'Valley map: show the paths of all riders; the six traced silhouettes' (#19) from site/paths-and-silhouettes into main
CI / test (push) Successful in 42s
Reviewed-on: #19
2026-11-19 03:17:15 +00:00
kathleen 27ba5fbcbc Merge pull request 'Receive runs from the Reddit megathread comments (source "reddit comment")' (#18) from data/reddit-comment-runs into main
CI / test (push) Successful in 46s
Reviewed-on: #18
2026-11-19 03:16:59 +00:00
kathleenandClaude Opus 5.5 8152c1da0a One silhouette per colour everywhere; Brown perched on the rock (easier to see), Black asleep
CI / test (pull_request) Successful in 43s
Red rearing, Green standing, Orange soaring, Brown perched, Blue diving, Black sleeping, on the Odds cards,
the colour chooser and every dragon on the valley map.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 03:16:27 +00:00
kathleenandClaude Opus 5.5 40f068abe5 Paths of all riders: Reddit ink distinct from the failed-deaths ember
CI / test (pull_request) Successful in 2m59s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 03:14:59 +00:00
kathleenandClaude Opus 5.5 ef14ecaaa5 Paths of all riders: an ink for the Reddit comments layer
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 03:14:50 +00:00
kathleenandClaude Opus 5.5 6467ce86a7 Paths of all riders: a layer for runs read from Reddit megathread comments (source \"reddit comment\", PR #18)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-19 03:14:48 +00:00
ekcSchianoandClaude Opus 5.5 a9836c3191 Valley map: show the paths of all riders (per source, plus deaths); the six traced silhouettes
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-18 22:13:51 -05:00
50 changed files with 14451 additions and 9877 deletions
+4 -2
View File
@@ -10,9 +10,11 @@
# DK_ACCOUNT_SALT the salt account names are hashed with (the same one every time)
# ATLAS_BOT_TOKEN as in update-sources.yml
name: Bot cycle
# Not scheduled: no runner has the `bot-host` label yet (issue #27), and the bot's data already arrives through the
# daily source check. Put the schedule back once Ken adds a runner on the bot's machine:
# schedule:
# - cron: "41 */4 * * *"
on:
schedule:
- cron: "41 */4 * * *"
workflow_dispatch:
jobs:
cycle:
+37
View File
@@ -0,0 +1,37 @@
# The published Atlas page. Every push to main builds the static site (npm run build -> dist/) and force-pushes it
# as the single commit of the `pages` branch. Ken's server serves that branch as plain files (a web server whose
# folder is kept in step with the branch: a git-sync sidecar, or `git pull` on a timer). The repository is public,
# so his server needs no token. Only the build output is on `pages`, never the raw data.
#
# Secrets: ATLAS_BOT_TOKEN (as in update-sources.yml), to push the branch.
name: Publish the site (pages branch)
on:
push:
branches: [main]
workflow_dispatch:
concurrency:
group: pages
cancel-in-progress: true
jobs:
publish:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 20
- run: npm run build
- name: Push dist/ as the pages branch
env:
ATLAS_BOT_TOKEN: ${{ secrets.ATLAS_BOT_TOKEN }}
run: |
cd dist
git init -q -b pages
git config user.name "Atlas data bot"
git config user.email "atlas-bot@noreply.localhost"
git add -A
git commit -q -m "site built from ${GITHUB_SHA::8}"
GIT_CONFIG_COUNT=1 GIT_CONFIG_KEY_0="http.https://git.kenschiano.net/.extraheader" \
GIT_CONFIG_VALUE_0="AUTHORIZATION: token $ATLAS_BOT_TOKEN" \
git push -q -f "https://git.kenschiano.net/${GITHUB_REPOSITORY}.git" pages
echo "pages branch updated from ${GITHUB_SHA::8}"
+4 -3
View File
@@ -1,6 +1,6 @@
# When the route model changes on main, send it to the bot: open (or update) a pull request on the bot's repo,
# DragonKind/DragonKind, that replaces vendor/threshing-atlas/{policy.json,solver.js,graph.js} with this repo's
# data/public/policy.json, core/solver.js and core/graph.js. The three always travel together, so the policy and the
# DragonKind/DragonKind, that replaces vendor/threshing-atlas/{policy.json,solver.js,graph.js,known_answers.json} with
# this repo's data/public/policy.json, core/solver.js, core/graph.js and data/public/known_answers.json. They always travel together, so the policy and the
# solver that reads it never get out of step. Ken reviews and merges it; the running bot reloads the files after a pull.
#
# Secrets: ATLAS_BOT_TOKEN (repository: read and write, with write access to DragonKind/DragonKind).
@@ -12,6 +12,7 @@ on:
- data/public/policy.json
- core/solver.js
- core/graph.js
- data/public/known_answers.json
workflow_dispatch:
jobs:
send:
@@ -34,7 +35,7 @@ jobs:
GIT_CONFIG_VALUE_0="AUTHORIZATION: token $ATLAS_BOT_TOKEN"
git clone --quiet --depth 1 https://git.kenschiano.net/DragonKind/DragonKind.git "$dst"
mkdir -p "$dst/vendor/threshing-atlas"
cp data/public/policy.json core/solver.js core/graph.js "$dst/vendor/threshing-atlas/"
cp data/public/policy.json core/solver.js core/graph.js data/public/known_answers.json "$dst/vendor/threshing-atlas/"
id=$(python3 -c "import json; print(json.load(open('data/public/policy.json')).get('id', ''))")
sha=$(git rev-parse --short HEAD)
cd "$dst"
+31
View File
@@ -0,0 +1,31 @@
# A review summary on every Reddit scraper pull request (issue #23): the runs added, changed and gone, the ones that
# break a game rule, other flags, possible copies of form rows, and result pages already counted. Posted as one
# comment on the pull request, refreshed on every push. The reviewer corrects runs in
# collection/manual/reddit_comments.yaml (collection/README.md, "Reviewing Reddit runs"), then merges.
#
# Secrets: ATLAS_BOT_TOKEN (as in update-sources.yml), to post the comment.
name: Review Reddit runs
on:
pull_request:
paths:
- data/public/reddit_comments.json
- collection/manual/reddit_comments.yaml
jobs:
summary:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- run: pip install -r requirements.txt
- name: The file as it is on main
run: |
git fetch --depth 1 origin "${{ github.base_ref }}"
git show FETCH_HEAD:data/public/reddit_comments.json > "$RUNNER_TEMP/base.json" || echo '{"runs": []}' > "$RUNNER_TEMP/base.json"
- name: Build the runs and post the summary
env:
ATLAS_BOT_TOKEN: ${{ secrets.ATLAS_BOT_TOKEN }}
run: |
python -m collection build
python -m collection review-reddit --base "$RUNNER_TEMP/base.json" --out "$RUNNER_TEMP/review.md" --pr "${{ github.event.pull_request.number }}"
+4
View File
@@ -16,6 +16,10 @@ on:
schedule:
- cron: "23 10 * * *" # daily
workflow_dispatch:
# one check at a time: a second dispatch waits instead of building and pushing alongside the first
concurrency:
group: update-sources
cancel-in-progress: false
jobs:
check:
runs-on: ubuntu-latest # a runner label on the server (act_runner)
+1 -2
View File
@@ -166,8 +166,7 @@ venv.bak/
# Rope project settings
.ropeproject
# mkdocs/Zensical documentation
/site
# (mkdocs' /site is not ignored: site/ here is the Atlas page)
# mypy
.mypy_cache/
+18 -6
View File
@@ -141,7 +141,8 @@ def build():
c[i + 1] += 1
orr, obs, exp, z = mantel_haenszel(by.values())
facts["same_route"] = {"routes": len(by), "first_shadows": round(obs), "expected": round(exp, 1),
"odds_ratio": round(orr, 1), "z": round(z, 1)}
"odds_ratio": round(orr, 1) if math.isfinite(orr) else None, # JSON has no Infinity
"z": round(z, 1)}
facts["form_first"] = [sum(c[0] for c in by.values()), sum(c[1] for c in by.values())]
facts["form_later"] = [sum(c[2] for c in by.values()), sum(c[3] for c in by.values())]
L += ["## 2. The same route on a first attempt and on a later one", "",
@@ -153,7 +154,7 @@ def build():
L.append(f"| {' / '.join(key)} | {frac(y1, n1)} | {frac(y0, n0)} |")
L += ["", f"Across all {len(by)} recorded routes, comparing first and later attempts on the same route: "
f"{obs:.0f} first-attempt shadows where {exp:.1f} would be expected if the attempt did not matter "
f"(odds ratio {orr:.1f}, z = {z:.1f}). First and later attempts choose almost the same routes, so the "
f"(odds ratio {f'{orr:.1f}' if math.isfinite(orr) else 'unbounded: no later-attempt shadow at all'}, z = {z:.1f}). First and later attempts choose almost the same routes, so the "
"difference is not in the recorded choices: it is something about the account, or a choice the form does "
"not record.", ""]
@@ -186,9 +187,20 @@ def build():
("combat_second", "The dagger"), ("resolution", "The bullies' fate"), ("post_path", "The fork")):
t = collections.Counter(r[col] for r in S1)
L.append(f"- **{label}:** " + ", ".join(f"{k} {v}" for k, v in t.most_common()))
outside = [r for r in runs if r["saw_shadow"] and not (r["scream"] == "Investigate & help" and r["hour"] == "Tree")]
facts["shadow_routes"] = {"runs": len(S1), "routes": len({tuple(r[k] for k in ROUTE) for r in S1}), "off_gate": len(outside)}
L += ["", f"Shadows reported without both gates: {len(outside)} (likely mis-entered).", ""]
# a gate counts as missed only when the run answers it otherwise; a run that does not say (a short Reddit
# comment, a blank form answer) is not a contradiction
def stated(v):
return bool(v) and v != "Unknown" and not str(v).startswith("(")
def contradicts(r):
return (stated(r["scream"]) and r["scream"] != "Investigate & help") or (stated(r["hour"]) and r["hour"] != "Tree")
outside = [r for r in runs if r["saw_shadow"] and contradicts(r)]
unstated = [r for r in runs if r["saw_shadow"] and not contradicts(r)
and not (r["scream"] == "Investigate & help" and r["hour"] == "Tree")]
facts["shadow_routes"] = {"runs": len(S1), "routes": len({tuple(r[k] for k in ROUTE) for r in S1}),
"off_gate": len(outside), "gates_unstated": len(unstated)}
L += ["", f"Shadows reported with an answer that contradicts a gate: {len(outside)} (likely mis-entered or misread). "
f"Another {len(unstated)} do not say whether they passed both gates.", ""]
# 5. after the shadow
SH = [r for r in runs if r["saw_shadow"]]
@@ -255,7 +267,7 @@ def main(argv=None):
ap.add_argument("--check", action="store_true")
a = ap.parse_args(argv)
text, facts = build()
data = json.dumps(facts, ensure_ascii=False, indent=1) + "\n"
data = json.dumps(facts, ensure_ascii=False, indent=1, allow_nan=False) + "\n"
if a.check:
for path, want in ((OUT, text), (OUT_JSON, data)):
if not path.exists() or path.read_text(encoding="utf-8") != want:
+131
View File
@@ -0,0 +1,131 @@
"""Known answers: what the Atlas knows about every answer the bot can be offered, for screens its other sources don't
cover (issue #35). The bot looks the screen's choices up here first (solver.js `knownAnswer`), and passes what it finds
to Clef as evidence when nothing is certain.
python analysis/known/build_known.py [--check] -> data/public/known_answers.json
Two sources, keyed by the answer text normalised exactly as the bot does (collection/etl/transform/bot.py normalize):
guide every answer in the community route PDF's encounter trees (data/public/pdf_encounters.json): the
encounter, how it ends there (or "continues"), the guide's rate, whether the guide marks it unconfirmed,
and `on_path`: the colours whose recommended path in the guide goes through it
bot every answer in the bot's screen tree (data/public/tree.json): times played, times it died straight
after, and the bonds the runs that took it ended in
"""
import argparse
import json
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))
from collection.etl.transform.bot import normalize # noqa: E402
GUIDE = ROOT / "data/public/pdf_encounters.json"
TREE = ROOT / "data/public/tree.json"
OUT = ROOT / "data/public/known_answers.json"
# the colours each of the guide's encounters can end in a bond with (the two Greens can also end with an Orange or a
# Brown swooping in), and the encounter a colour's route continues to from there (the shadow leads on to the Black)
ENC_COLOURS = {"valley-Red": ["Red"], "tree-Red": ["Red"], "tree-Greens": ["Green", "Brown", "Orange"],
"meadow-Orange": ["Orange"], "meadow-Brown": ["Brown"], "meadow-Blue": ["Blue"],
"shadow": ["Black", "Blue"], "black": ["Black"]}
ONWARD = {("shadow", "Black"): "Black"}
def is_goal(end, colour, onward):
end = end or ""
if onward:
return end.startswith(f"On to the {onward}")
if not (end.startswith("Bonded") or "Bonded (" in end):
return False
return "(" not in end or colour in end
def leads_to(o, colour, onward):
if "end" in o:
return is_goal(o["end"], colour, onward)
return any(not c.get("roll") and leads_to(c, colour, onward) for c in o.get("then", []))
def guide_path(options, colour, onward):
"""The guide's recommended answers toward `colour` (the same walk as the page's encounter panel)."""
out, opts = [], options
while opts:
live = [o for o in opts if not o.get("roll")]
pick = next((o for o in live if o.get("best") and leads_to(o, colour, onward)), None) \
or next((o for o in live if leads_to(o, colour, onward)), None)
if not pick:
break
out.append(id(pick))
if "end" in pick:
break
opts = pick.get("then", [])
return out
def walk(options, enc, on_path, out):
"""Every answer of an encounter, with its colours (where it happens) and on_path (whose recommended path)."""
for o in options:
if o.get("roll"):
continue
entry = {"encounter": enc, "colours": ENC_COLOURS.get(enc, []), "end": o.get("end", "continues")}
if o.get("pct"):
entry["pct"] = o["pct"]
if o.get("best"):
entry["best"] = True
if o.get("unconfirmed"):
entry["unconfirmed"] = True
cols = sorted(c for c, ids in on_path.items() if id(o) in ids)
if cols:
entry["on_path"] = cols
for text in [s.strip() for s in o["say"].split(", or ")]: # "Jump on its back, or jump to land…"
out.setdefault(normalize(text), {"text": text, "guide": []})["guide"].append(entry)
walk(o.get("then", []), enc, on_path, out)
def build():
g = json.loads(GUIDE.read_text(encoding="utf-8"))
out = {}
for enc, E in g["encounters"].items():
on_path = {c: set(guide_path(E["options"], c, ONWARD.get((enc, c)))) for c in ENC_COLOURS.get(enc, [])}
walk(E["options"], enc, on_path, out)
t = json.loads(TREE.read_text(encoding="utf-8")) if TREE.exists() else {"screens": {}}
for sc in t["screens"].values():
for o in sc["options"].values():
if not o.get("n"):
continue
k = normalize(o["text"])
e = out.setdefault(k, {"text": o["text"], "guide": []})
b = e.setdefault("bot", {"n": 0, "died": 0, "bonded": {}})
b["n"] += o["n"]
for dest, d in o.get("to", {}).items():
if dest == "DIED":
b["died"] += d["n"]
elif dest.startswith("BONDED:"):
c = dest.split(":", 1)[1]
b["bonded"][c] = b["bonded"].get(c, 0) + d["n"]
for e in out.values():
if not e["guide"]:
del e["guide"]
src = g["source"]
return {"schema": 1, "guide": {"title": src["title"], "version": src["version"], "link": src["link"]},
"bot": {"runs": (t.get("builtFrom") or {}).get("runs")}, "answers": dict(sorted(out.items()))}
def main(argv=None):
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("--check", action="store_true")
a = ap.parse_args(argv)
text = json.dumps(build(), ensure_ascii=False, indent=1) + "\n"
if a.check:
if not OUT.exists() or OUT.read_text(encoding="utf-8") != text:
print(f"{OUT.relative_to(ROOT)} is out of date (run python analysis/known/build_known.py)", file=sys.stderr)
return 1
return 0
OUT.write_text(text, encoding="utf-8")
print(f"wrote {OUT.relative_to(ROOT)}")
return 0
if __name__ == "__main__":
sys.exit(main())
+112
View File
@@ -0,0 +1,112 @@
"""Is the same attempt reported twice, in the community form and in a Reddit comment? (issue #24)
python analysis/overlap/overlap.py [--check]
There are no player ids, so a copy can only be proven by a shared dragonkind.com result-page id. Neither the form
nor the register records one, and the comment-to-result-page link is already applied when the runs are built
(collection/etl/runs.py). Everything else is measured, never removed:
- a Reddit comment run is *comparable* when it is dated and gives at least MIN_ANSWERS route answers besides how it
ended (fewer answers match dozens of form rows by chance on a busy day);
- it *matches* a form row submitted within WINDOW days when every answer it gives is the form row's answer;
- the same test with the comment's date shifted by a few weeks (SHIFTS, only where the form has rows that week) is
what chance alone produces, so matched - expected is the estimate of runs reported twice.
Writes data/public/overlap.json (the page's Data & methods tab, and the scraper pull-request summary). Nothing is
dropped: identical routes are expected, and the Reddit runs already have their own reporting-bias group in the
route model (planner/policy.yaml).
"""
import argparse
import collections
import datetime as dt
import json
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / "core"))
from atlas import runs as runs_io # noqa: E402
OUT = ROOT / "data/public/overlap.json"
FIELDS = ["company", "left_squadmates", "direction", "first_sighting", "sighting_action", "scream", "resolution",
"combat_first", "combat_second", "post_path", "hour", "branch", "outcome", "outcome_color", "tail", "attempt"]
ENDING = ("outcome", "outcome_color")
MIN_ANSWERS = 4
WINDOW = 1
SHIFTS = (-28, -21, -14, 14, 21, 28)
def given(v):
return v not in (None, "") and v != "Unknown" and not (isinstance(v, str) and v.startswith("("))
def answers(r):
return [k for k in FIELDS if given(r.get(k))]
def comparable(r):
return bool(r.get("date")) and len([k for k in answers(r) if k not in ENDING]) >= MIN_ANSWERS
def days(date, shift=0, window=WINDOW):
d = dt.date.fromisoformat(date[:10]) + dt.timedelta(days=shift)
return [(d + dt.timedelta(days=i)).isoformat() for i in range(-window, window + 1)]
def form_index(runs):
by_day = collections.defaultdict(list)
for r in runs:
if r["source"] == "reddit spreadsheet" and r.get("date"):
by_day[r["date"][:10]].append(r)
return by_day
def matches(c, by_day, shift=0):
"""Form rows within the window that give every answer the comment gives."""
keys = answers(c)
return [f for d in days(c["date"], shift) for f in by_day.get(d, []) if all(f.get(k) == c[k] for k in keys)]
def measure(runs):
by_day = form_index(runs)
comments = [r for r in runs if r["source"] == "reddit comment"]
comp = [c for c in comments if comparable(c)]
found = {c["run_id"]: [f["run_id"] for f in matches(c, by_day)] for c in comp}
matched = sum(1 for v in found.values() if v)
# chance: each comment's match rate on shifted dates, over the shifts whose window has form rows at all
expected = 0.0
for c in comp:
valid = [s for s in SHIFTS if any(by_day.get(d) for d in days(c["date"], s))]
if valid:
expected += sum(1 for s in valid if matches(c, by_day, s)) / len(valid)
return {
"schema": 1,
"rule": {"min_answers": MIN_ANSWERS, "window_days": WINDOW, "baseline_shifts_days": list(SHIFTS)},
"comment_runs": len(comments),
"comparable": len(comp),
"matched": matched,
"expected_by_chance": round(expected, 1),
"likely_double": round(max(0.0, matched - expected), 1),
"matches": [{"comment": k, "form": v} for k, v in sorted(found.items()) if v],
}
def main(argv=None):
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("--check", action="store_true", help="fail if data/public/overlap.json is out of date")
a = ap.parse_args(argv)
text = json.dumps(measure(runs_io.read(drop=())), indent=1, ensure_ascii=False) + "\n"
if a.check:
if not OUT.exists() or OUT.read_text(encoding="utf-8") != text:
print(f"out of date (run `python {Path(__file__).relative_to(ROOT)}`): {OUT.relative_to(ROOT)}")
return 1
return 0
OUT.write_text(text, encoding="utf-8")
m = json.loads(text)
print(f"{OUT.relative_to(ROOT)}: {m['matched']} of {m['comparable']} comparable Reddit runs match a form row "
f"(~{m['expected_by_chance']} by chance; ~{m['likely_double']} likely reported twice)")
return 0
if __name__ == "__main__":
sys.exit(main())
+14 -14
View File
@@ -7,12 +7,12 @@ Written by `analysis/black/evidence.py` from `data/public/runs_clean.csv`. Count
| Attempt | Form submissions | Bulk logs | Bot |
|---|---|---|---|
| 1 | 97 / 960 (10.1%) | 0 / 29 (0.0%) | 0 / 0 |
| 2 | 0 / 296 (0.0%) | 0 / 21 (0.0%) | 0 / 4 (0.0%) |
| 3 | 0 / 193 (0.0%) | 0 / 14 (0.0%) | 0 / 5 (0.0%) |
| 4-10 | 0 / 538 (0.0%) | 0 / 102 (0.0%) | 0 / 36 (0.0%) |
| 11-30 | 0 / 626 (0.0%) | 0 / 57 (0.0%) | 0 / 137 (0.0%) |
| 31 or more | 0 / 694 (0.0%) | 0 / 0 | 0 / 333 (0.0%) |
| not given | 0 / 1581 (0.0%) | 0 / 149 (0.0%) | 0 / 0 |
| 2 | 0 / 299 (0.0%) | 0 / 21 (0.0%) | 0 / 4 (0.0%) |
| 3 | 0 / 196 (0.0%) | 0 / 14 (0.0%) | 0 / 5 (0.0%) |
| 4-10 | 0 / 555 (0.0%) | 0 / 102 (0.0%) | 0 / 36 (0.0%) |
| 11-30 | 0 / 657 (0.0%) | 0 / 57 (0.0%) | 0 / 137 (0.0%) |
| 31 or more | 0 / 715 (0.0%) | 0 / 0 | 0 / 333 (0.0%) |
| not given | 0 / 1582 (0.0%) | 0 / 149 (0.0%) | 0 / 0 |
Complete logs (bot and bulk) have 29 first attempts at the tree and 709 later ones, with 0 shadows. Zero in 709 later attempts rules out a rate above 0.4% for them; zero in 29 first attempts only rules out more than 10%.
@@ -22,16 +22,16 @@ If the shadow depended only on the choices the form records (company, first dire
| Route | First attempt | Later attempts |
|---|---|---|
| Alone / West / Assess the situation / Engage the smaller cadet / Squadmate's revenge / West | 23 / 114 (20.2%) | 0 / 94 (0.0%) |
| Alone / West / Assess the situation / Engage the smaller cadet / Squadmate's revenge / Forest | 5 / 29 (17.2%) | 0 / 95 (0.0%) |
| Alone / West / Assess the situation / Engage the smaller cadet / Squadmate's revenge / West | 23 / 114 (20.2%) | 0 / 106 (0.0%) |
| Alone / West / Assess the situation / Engage the smaller cadet / Squadmate's revenge / Forest | 5 / 29 (17.2%) | 0 / 96 (0.0%) |
| Alone / Center / Assess the situation / Engage the smaller cadet / Squadmate's revenge / Forest | 4 / 29 (13.8%) | 0 / 78 (0.0%) |
| 1 Squadmate / East / Assess the situation / Engage the smaller cadet / Squadmate's revenge / East | 2 / 32 (6.2%) | 0 / 67 (0.0%) |
| 1 Squadmate / East / Assess the situation / Engage the smaller cadet / Squadmate's revenge / East | 2 / 32 (6.2%) | 0 / 73 (0.0%) |
| 2 Squadmates / East / Assess the situation / Engage the smaller cadet / Squadmate's revenge / East | 2 / 45 (4.4%) | 0 / 50 (0.0%) |
| Alone / East / Assess the situation / Engage the smaller cadet / Squadmate's revenge / East | 1 / 34 (2.9%) | 0 / 60 (0.0%) |
| 2 Squadmates / East / Assess the situation / Engage the smaller cadet / Squadmate's revenge / East | 2 / 45 (4.4%) | 0 / 48 (0.0%) |
| Alone / Center / Assess the situation / Daggers or not (protect squadmate) / Left bullies to the dragons / Forest | 1 / 28 (3.6%) | 0 / 64 (0.0%) |
| Alone / Center / Assess the situation / Engage the smaller cadet / Squadmate's revenge / West | 2 / 9 (22.2%) | 0 / 81 (0.0%) |
Across all 325 recorded routes, comparing first and later attempts on the same route: 93 first-attempt shadows where 39.9 would be expected if the attempt did not matter (odds ratio inf, z = 12.3). First and later attempts choose almost the same routes, so the difference is not in the recorded choices: it is something about the account, or a choice the form does not record.
Across all 326 recorded routes, comparing first and later attempts on the same route: 93 first-attempt shadows where 38.8 would be expected if the attempt did not matter (odds ratio unbounded: no later-attempt shadow at all, z = 12.5). First and later attempts choose almost the same routes, so the difference is not in the recorded choices: it is something about the account, or a choice the form does not record.
## 3. On one route, is the shadow decided by the cadet's wing, section and squad?
@@ -56,14 +56,14 @@ The 97 form runs with a shadow (all attempts) took 47 different recorded routes:
- **The bullies' fate:** Squadmate's revenge 61, Left bullies to the dragons 25, Killed the bullies yourself 9, Unknown 2
- **The fork:** West 46, Forest 36, East 14, Unknown 1
Shadows reported without both gates: 3 (likely mis-entered).
Shadows reported with an answer that contradicts a gate: 3 (likely mis-entered or misread). Another 14 do not say whether they passed both gates.
## 5. After the shadow: the Blue, then the Black
The riders' notes describe one sequence: follow the shadow, a Blue lands and burns another cadet, the Blue leaves, then the Black appears. The Blue is a trial on the way, not an alternative to the Black.
- Runs that reached the Black: 79, bonded 57.
- Runs that died at the Blue: 16. What their notes say they did: approached the Blue 11, warned the other cadet / intervened 4.
- Runs that reached the Black: 89, bonded 65.
- Runs that died at the Blue: 19. What their notes say they did: approached the Blue 11, warned the other cadet / intervened 4.
- The answer given to the Black, where the note says (bonded / runs): held its gaze 29/41; lowered eyes 0/7; ignored the sound 0/1.
Holding its gaze is the only answer recorded with a bond, and it still fails about a quarter of the time. The developer says a rider who knows the system bonds with certainty, so those failures are not explained yet: the notes of the riders who died are too short to show what else they did differently.
+31 -13
View File
@@ -6,10 +6,12 @@
# (not blank), {any: [condition, ...]} (at least one). Several fields in one condition must all hold.
version: 1
# Which runs of data/public/runs_clean.csv the statistics use (its `source` column). Runs from the other sources
# (reported, bot, Reddit result pages) are in the published file but not in these statistics yet: they are coded
# from different questions, and the bot follows a strategy, so pooling them needs its own review.
sources: [reddit spreadsheet]
# Which runs of data/public/runs_clean.csv the statistics use (its `source` column): every source that records the
# route (the community form, "Report a run", the Reddit megathread comments, the DragonKind bot). The Reddit result
# pages and the register record only the end, so they stay out. The bot plays to a strategy and burns on purpose at
# encounters it is not chasing: like every rider's deliberate death (`_deliberate`, the route model's rule), those
# burns are left out of the bond rates, never counted as failed bonds.
sources: [reddit spreadsheet, reported, reddit comment, bot]
colours: [Red, Green, Orange, Brown, Blue, Black]
@@ -25,7 +27,7 @@ outcomes:
event: { saw_shadow: true }
bond_blue_meadow:
label: Bond, given you approached the meadow Blue
denom: { branch: "Passed the Red: meadow", enc_Blue: { in: ["Bonded!", "Incinerated"] } }
denom: { branch: "Passed the Red: meadow", enc_Blue: { in: ["Bonded!", "Incinerated"] }, _deliberate: { not: true } }
event: { enc_Blue: "Bonded!" }
reach_hour:
label: Survive to the hour (tree/valley choice)
@@ -34,7 +36,7 @@ outcomes:
# one more outcome per colour: "Run ends bonded to <colour>", among runs that reached the hour
bonded_outcome:
label: Run ends bonded to {colour}
denom: { hour: { in: [Tree, Valley] } }
denom: { hour: { in: [Tree, Valley] }, _deliberate: { not: true } }
event: { outcome: Bonded, outcome_color: "{colour}" }
# Factors compared in the factor tables (each answer against the other answers to the same question)
@@ -43,15 +45,15 @@ factors: [company, direction, first_sighting, scream, resolution, combat_first,
# Route targets: the outcome (event) and which runs could have reached it at all (pool)
targets:
bond_Blue: { label: Bond Blue, colour: Blue, event: { outcome: Bonded, outcome_color: Blue }, pool: { hour: Valley } }
bond_Black: { label: Bond Black, colour: Black, event: { outcome: Bonded, outcome_color: Black }, pool: { hour: Tree } }
bond_Blue: { label: Bond Blue, colour: Blue, event: { outcome: Bonded, outcome_color: Blue }, pool: { hour: Valley, _deliberate: { not: true } } }
bond_Black: { label: Bond Black, colour: Black, event: { outcome: Bonded, outcome_color: Black }, pool: { hour: Tree, _deliberate: { not: true } } }
see_Blue: { label: Meet a Blue (meadow), colour: Blue, event: { saw_blue_meadow: true }, pool: { branch: "Passed the Red: meadow" } }
see_shadow: { label: Get the tree shadow, colour: Black, event: { saw_shadow: true }, pool: { hour: Tree, branch: { exists: true } } }
bond_Red: { label: Bond Red, colour: Red, event: { outcome: Bonded, outcome_color: Red }, pool: { hour: { in: [Tree, Valley] } } }
bond_Green: { label: Bond Green, colour: Green, event: { outcome: Bonded, outcome_color: Green }, pool: { hour: Tree } }
bond_Orange: { label: Bond Orange, colour: Orange, event: { outcome: Bonded, outcome_color: Orange }, pool: { hour: { in: [Tree, Valley] } } }
bond_Brown: { label: Bond Brown, colour: Brown, event: { outcome: Bonded, outcome_color: Brown }, pool: { hour: { in: [Tree, Valley] } } }
bond_any: { label: Bond any dragon, colour: null, event: { outcome: Bonded }, pool: { hour: { in: [Tree, Valley] } } }
bond_Red: { label: Bond Red, colour: Red, event: { outcome: Bonded, outcome_color: Red }, pool: { hour: { in: [Tree, Valley] }, _deliberate: { not: true } } }
bond_Green: { label: Bond Green, colour: Green, event: { outcome: Bonded, outcome_color: Green }, pool: { hour: Tree, _deliberate: { not: true } } }
bond_Orange: { label: Bond Orange, colour: Orange, event: { outcome: Bonded, outcome_color: Orange }, pool: { hour: { in: [Tree, Valley] }, _deliberate: { not: true } } }
bond_Brown: { label: Bond Brown, colour: Brown, event: { outcome: Bonded, outcome_color: Brown }, pool: { hour: { in: [Tree, Valley] }, _deliberate: { not: true } } }
bond_any: { label: Bond any dragon, colour: null, event: { outcome: Bonded }, pool: { hour: { in: [Tree, Valley] }, _deliberate: { not: true } } }
# Bonding encounters: which recorded attempt (column) belongs to which in-game encounter (where)
encounters:
@@ -80,6 +82,8 @@ presets:
all: { label: All runs, filters: { source: all, goal: all, excludeFlagged: false } }
form: { label: Form submissions only, filters: { source: form, goal: all, excludeFlagged: false } }
bulk: { label: Bulk logs only (imports), filters: { source: bulk, goal: all, excludeFlagged: false } }
reddit: { label: Reddit comments only, filters: { source: reddit, goal: all, excludeFlagged: false } }
bot: { label: DragonKind bot only, filters: { source: bot, goal: all, excludeFlagged: false } }
not_chasing: { label: Not chasing Blue/Black, filters: { source: all, goal: exclude_rare, excludeFlagged: false } }
chasing: { label: Chasing Blue/Black, filters: { source: all, goal: only_rare, excludeFlagged: false } }
unflagged: { label: Rows without data-quality flags, filters: { source: all, goal: all, excludeFlagged: true } }
@@ -88,3 +92,17 @@ presets:
route_thresholds: [5, 10, 20, 30]
rare_goals: [Blue, Black, Blue or Black]
# "Show the paths of all riders" on the valley map (site/atlas/explorer.js): one layer per source that records a
# route, each with its own switch. Unlike everything above, the layers use every source of runs_clean.csv. Within a
# layer the runs are split by how they ended, drawn as line styles in the layer's colour: solid (did not die), dashed
# (chose to die: burned at an encounter the rider did not genuinely attempt, the route model's rule) and dotted
# (failed: every other death). Discord has no runs yet: its layer is ready for when it is imported.
path_layers:
- { key: sheet, label: "Google Sheet", sources: [reddit spreadsheet] }
- { key: reported, label: "Reported on the Atlas", sources: [reported] }
- { key: reddit, label: "Reddit megathread comments", sources: [reddit comment] }
- { key: bot, label: "DragonKind bot", sources: [bot] }
- { key: discord, label: "Discord", sources: [discord] }
# sources that record which dragon bonded but not the route: counted on the map, not drawn
path_unrouted: [reddit thread, register]
+81 -19
View File
@@ -95,7 +95,18 @@ def is_rare(goal):
return goal in M["rare_goals"]
# sources other than the community spreadsheet: their own group wherever runs are split by where they came from
SOURCE_LABEL = {"reddit comment": "Reddit comments", "bot": "DragonKind bot", "reported": "Reported on the Atlas"}
def entry_group(r):
"""Where a run came from: the spreadsheet's entry type (Form, Data Import, ...) or the source's own label."""
return SOURCE_LABEL.get(r["source"]) or r["entry"]
def stratum(r):
if r["source"] in SOURCE_LABEL:
return SOURCE_LABEL[r["source"]]
if r["entry"] != "Form":
return "Bulk logs (imports)"
g = r["goal"]
@@ -108,9 +119,14 @@ def goal2(r):
def apply_filters(runs, f):
def ok(r):
if f.get("source") == "form" and r["entry"] != "Form":
sheet = r["source"] == "reddit spreadsheet"
if f.get("source") == "form" and not (sheet and r["entry"] == "Form"):
return False
if f.get("source") == "bulk" and r["entry"] == "Form":
if f.get("source") == "bulk" and not (sheet and r["entry"] != "Form"):
return False
if f.get("source") == "reddit" and r["source"] != "reddit comment":
return False
if f.get("source") == "bot" and r["source"] != "bot":
return False
if f.get("goal") == "exclude_rare" and is_rare(r["goal"]):
return False
@@ -197,7 +213,7 @@ def analyse(all_runs, filters):
dates = sorted(r["date"] for r in runs if r.get("date"))
outs = group_by(runs, lambda r: r["outcome"] + (" " + r["outcome_color"] if r.get("outcome_color") else ""))
res["meta"] = {
"sources": {k: len(v) for k, v in group_by(runs, "entry").items()},
"sources": {k: len(v) for k, v in group_by(runs, entry_group).items()},
"date_min": dates[0] if dates else None, "date_max": dates[-1] if dates else None,
"n_flagged": sum(1 for r in runs if r["data_flags"]), "flag_counts": flag_counts,
"outcomes": {k: len(v) for k, v in outs.items()},
@@ -220,13 +236,14 @@ def analyse(all_runs, filters):
res["encounters"] = []
for e in M["encounters"]:
col, colour = e["column"], e["colour"]
A = [r for r in runs if match(r, e["where"]) and r.get(col) in ("Bonded!", "Incinerated")]
# a rider who chose to burn here (chasing another colour) did not fail this encounter
A = [r for r in runs if match(r, e["where"]) and r.get(col) in ("Bonded!", "Incinerated") and not r.get("_deliberate")]
win = lambda r, col=col: r.get(col) == "Bonded!" # noqa: E731
intent = [r for r in A if r["goal"] == colour or r["goal"].startswith("Any") or (r["goal"] == "Blue or Black" and colour in ("Blue", "Black"))]
res["encounters"].append({"context": e["context"], "color": colour, "overall": rate(A, win), "intent_matched": rate(intent, win),
"by_stratum": {s: rate(g, win) for s, g in sorted(group_by(A, stratum).items())}})
greens_where = next(e["where"] for e in M["encounters"] if e["colour"] == "Green")
greens = [r for r in runs if match(r, greens_where) and r.get("enc_Green")]
greens = [r for r in runs if match(r, greens_where) and r.get("enc_Green") and not r.get("_deliberate")]
g = {"green_encounters": len(greens),
"bonded_green": sum(1 for r in greens if r["enc_Green"] == "Bonded!"),
"rescued_orange": sum(1 for r in greens if r["rescued"] and r.get("outcome_color") == "Orange"),
@@ -240,7 +257,7 @@ def analyse(all_runs, filters):
first2 = lambda r: r["first_sighting"] if r["first_sighting"] in ("Red", "Brown", "Orange", "Green") else None # noqa: E731
known = lambda f: (lambda r: None if is_missing(r.get(f)) else r[f]) # noqa: E731
src2 = lambda r: "Form submission" if r["entry"] == "Form" else "Bulk log (import)" # noqa: E731
src2 = lambda r: SOURCE_LABEL.get(r["source"]) or ("Form submission" if r["entry"] == "Form" else "Bulk log (import)") # noqa: E731
res["models"] = {
"blue_meadow": fit_model(runs, "blue_meadow", {"source": src2, "goal": goal2, "direction": known("direction"),
"first_sighting": first2, "resolution": known("resolution"), "company": known("company")}),
@@ -257,7 +274,7 @@ def analyse(all_runs, filters):
"blue": W(bk, len(m)), "shadow": W(sk, len(t))})
res["source_rates"] = {key: {s: rate([r for r in g if match(r, OUTCOMES[key]["denom"])], lambda r, k=key: match(r, OUTCOMES[k]["event"]))
for s, g in group_by(runs, "entry").items()} for key in ("blue_meadow", "shadow")}
for s, g in group_by(runs, entry_group).items()} for key in ("blue_meadow", "shadow")}
return res
@@ -302,9 +319,11 @@ def route_map(runs):
"""The route map: nodes and links with run counts, and for every target the hits and their Wilson interval."""
nodes, links = {}, {}
hits = {t: {} for t in TARGETS}
tries = {t: {} for t in TARGETS} # runs that count for the target (no deliberate deaths for a bond)
for r in runs:
prev = None
hit = {t: match(r, T["event"]) for t, T in TARGETS.items()}
counts = {t: not (r.get("_deliberate") and t.startswith("bond_")) for t in TARGETS}
for si, s in enumerate(STAGES):
v = stage_value(r, s["key"])
if v is None:
@@ -314,15 +333,18 @@ def route_map(runs):
nd["n"] += 1
for t in TARGETS:
hits[t][nid] = hits[t].get(nid, 0) + hit[t]
tries[t][nid] = tries[t].get(nid, 0) + counts[t]
if prev:
lid = prev + "→" + nid
ln = links.setdefault(lid, {"id": lid, "source": prev, "target": nid, "n": 0, "chance": bool(s.get("chance"))})
ln["n"] += 1
for t in TARGETS:
hits[t][lid] = hits[t].get(lid, 0) + hit[t]
tries[t][lid] = tries[t].get(lid, 0) + counts[t]
prev = nid
nl, ll = list(nodes.values()), list(links.values())
by_target = {t: {"nodes": [W(hits[t][n["id"]], n["n"]) for n in nl], "links": [W(hits[t][l["id"]], l["n"]) for l in ll]} for t in TARGETS}
by_target = {t: {"nodes": [W(hits[t][n["id"]], tries[t][n["id"]]) for n in nl],
"links": [W(hits[t][l["id"]], tries[t][l["id"]]) for l in ll]} for t in TARGETS}
return {"nodes": nl, "links": ll, "by_target": by_target}
@@ -399,7 +421,7 @@ def place_path(r):
s.append("bully")
if "res:" + r["resolution"] in L:
s.append("res:" + r["resolution"])
if r["resolution"].startswith("DIED"):
if (r.get("resolution") or "").startswith("DIED"):
return s
if r.get("post_path") in ("Forest", "West", "East"):
s.append("fork:" + r["post_path"])
@@ -452,17 +474,51 @@ def valley(runs):
return {"counts": counts, "edges": [[*k.split(">"), n] for k, n in sorted(edges.items(), key=lambda kv: -kv[1])]}
DEATHS = ("Incinerated", "Died before the hour")
def deliberate(r):
"""A deliberate death: burned at a bonding encounter the rider did not genuinely attempt (chasing another colour,
choosing to die and try again). The route model's own rule."""
if r["outcome"] != "Incinerated":
return False
try:
v = model.prepare_run(r)
return bool(v.get("encCtx")) and not model.genuine_attempt(r, v["encCtx"])
except (KeyError, TypeError, ValueError): # a source coded from other questions (e.g. the bot): not known
return False
def path_layers(runs):
"""'Show the paths of all riders' on the valley map: for every layer in measures.yaml path_layers (one source or
more), how many runs went from each place to the next (like valley()), split by how the runs ended: `lived` (did
not die), `chose` (a deliberate death) and `failed` (every other death), plus where the deaths happened. Every
source is used here, not only the statistics' sources. Sources that record no route are counted only."""
out = []
for layer in M["path_layers"]:
sel = [r for r in runs if r["source"] in layer["sources"]]
kinds = {"lived": [], "chose": [], "failed": []}
for r in sel:
kinds["lived" if r["outcome"] not in DEATHS else "chose" if deliberate(r) else "failed"].append(r)
ends = {}
for k in ("chose", "failed"):
e = {}
for r in kinds[k]:
seq = place_path(r)
if seq:
e[seq[-1]] = e.get(seq[-1], 0) + 1
ends[k] = dict(sorted(e.items(), key=lambda kv: -kv[1]))
out.append({"key": layer["key"], "label": layer["label"], "runs": len(sel),
"counts": {k: len(v) for k, v in kinds.items()},
"lines": {k: valley(v)["edges"] for k, v in kinds.items()}, "ends": ends})
unrouted = {s: sum(1 for r in runs if r["source"] == s) for s in M.get("path_unrouted", [])}
return {"layers": out, "unrouted": unrouted}
def overview(runs):
"""The Odds' summary cards: cadets who went in and either bonded or died. Deliberate deaths (burned at an
encounter the rider did not genuinely attempt) and runs with no recorded outcome are left out."""
ended = [r for r in runs if r["outcome"] in ("Bonded", "Incinerated", "Died before the hour")]
def deliberate(r):
if r["outcome"] != "Incinerated":
return False
v = model.prepare_run(r)
return bool(v.get("encCtx")) and not model.genuine_attempt(r, v["encCtx"])
cadets = [r for r in ended if not deliberate(r)]
bonded = sum(1 for r in cadets if r["outcome"] == "Bonded")
return {"cadets": len(cadets), "bonded": bonded, "dead": len(cadets) - bonded, "deliberate": len(ended) - len(cadets),
@@ -483,7 +539,7 @@ def clean(o):
return o
def build(runs, rows, exported=None):
def build(runs, rows, exported=None, every_run=None):
global PLACES
PLACES = place_ids()
th = M["route_thresholds"]
@@ -506,6 +562,8 @@ def build(runs, rows, exported=None):
"routes": {t: rank_routes(sub, t, th) for t in TARGETS},
"map": route_map(sub), "valley": valley(sub), "overview": overview(sub),
}
if every_run is not None:
out["paths"] = path_layers(every_run)
return clean(out)
@@ -514,8 +572,12 @@ def main(argv=None):
ap.add_argument("--data", default=str(runs_io.PATH))
ap.add_argument("--out", default=str(ROOT / "data/public/stats.json"))
a = ap.parse_args(argv)
runs = runs_io.read(a.data, sources=M["sources"])
out = build(runs, len(runs), exported())
# a run that cannot have happened as recorded (core/spec/form.yaml impossible_flags) is left out, as in the model
runs = [r for r in runs_io.read(a.data, sources=M["sources"]) if not runs_io.impossible(r)]
for r in runs:
r["_deliberate"] = deliberate(r)
every = [r for r in runs_io.read(a.data) if not runs_io.impossible(r)]
out = build(runs, len(runs), exported(), every_run=every)
Path(a.out).write_text(json.dumps(out, separators=(",", ":"), ensure_ascii=False), encoding="utf-8")
print(f"{a.out}: {len(runs)} runs, {len(out['presets'])} presets, {Path(a.out).stat().st_size / 1e6:.1f} MB")
+19
View File
@@ -41,6 +41,25 @@ The route PDF is a flowchart of the choices, not a log of runs, so it adds no ro
fingerprint tells us when the routes it documents change. The register lists bonded dragons without the route that
led there, so it adds no rows either.
## Reviewing Reddit runs
Ken's scraper opens (or updates) a pull request from `data/reddit-comments` that changes
`data/public/reddit_comments.json`. The **Review Reddit runs** workflow (`.gitea/workflows/reddit-review.yml`) posts a
summary on it, refreshed on every push (`python -m collection review-reddit --base <main's file>` locally):
- runs added, changed and gone since main;
- **runs that break a game rule** (`core/spec/form.yaml` `impossible_flags`): left out of the route model and the
statistics until corrected. Open the comment and decide;
- other flags on the new runs (kept);
- runs that may also be in the community form: the same answers within a day, with how many chance alone gives
(`analysis/overlap/overlap.py`, `data/public/overlap.json`). Measured only, never removed;
- runs whose result page is already a `reddit thread` row (counted once automatically).
Corrections go in `manual/reddit_comments.yaml`, applied at build time, so they never wait for the threads:
`reject: [id]` (not a run), `fix: {id: {question: answer}}` (misread; `null` removes an answer) and
`add: [{id, thread, posted, answers}]` (missed). A corrected run loses the "not checked by hand" note. No usernames:
the comment id is enough to find the comment again. Then merge, once CI passes.
## Raw files and privacy
`data/raw/` is git-ignored and never published. It holds the current raw file of each source and the one before
+12
View File
@@ -131,6 +131,18 @@ def open_issue(title, body, env=None, f=None):
return _call("POST", f"{api_base(f)}/issues", {"title": title, "body": body}, tok, f)["number"]
def upsert_comment(number, marker, body, env=None, f=None):
"""Post `body` on issue or pull request `number`, replacing an earlier comment that starts with `marker`
(so a summary refreshed on every push stays one comment)."""
f = f or config()
tok = token(env)
comments = _call("GET", f"{api_base(f)}/issues/{number}/comments?limit=50&per_page=100", tok=tok, f=f) or []
mine = [c for c in comments if (c.get("body") or "").startswith(marker)]
if mine:
return _call("PATCH", f"{api_base(f)}/issues/comments/{mine[-1]['id']}", {"body": body}, tok, f)["id"]
return _call("POST", f"{api_base(f)}/issues/{number}/comments", {"body": body}, tok, f)["id"]
def ensure_label(name, color, env=None, f=None):
f = f or config()
tok = token(env)
+2
View File
@@ -87,6 +87,8 @@ def rebuild():
_step("experiment plan", [py, "planner/build_experiments.py"])
_step("what the runs show about the Black", [py, "analysis/black/evidence.py"])
_step("screen tree", [py, "analysis/tree/build_tree.py"])
_step("known answers for the bot (guide + screen tree)", [py, "analysis/known/build_known.py"])
_step("runs reported twice (form + Reddit)", [py, "analysis/overlap/overlap.py"])
try:
import scipy # noqa: F401
_step("statistics", [py, "analysis/stats/site_stats.py"])
+4 -1
View File
@@ -112,10 +112,13 @@ def build(dictionary=None):
"citeAs": ds["citation"].format(repository=forge.repo_url(fg)),
"isLiveDataset": True,
"isBasedOn": [
{"@type": "sc:CreativeWork", "name": s["label"], "url": next(iter(s["links"].values()))}
{"@type": "sc:CreativeWork", "url": s["links"][k],
"name": s["label"] + (f" ({k.replace('part', 'part ')})" if len(s.get("cite") or ()) > 1 else "")}
for s in sources.values()
# the route PDF is only fingerprinted, never redistributed; the bot's repo is private
if (s.get("privacy") or {}).get("redistribute", True) and s.get("links")
# `cite` (collection/pipeline.yaml) names the links the source is based on; default: the first link
for k in (s.get("cite") or [next(iter(s["links"]))])
],
"distribution": distribution,
"recordSet": [
+133
View File
@@ -0,0 +1,133 @@
"""A review summary for a Reddit scraper pull request (issue #23).
python -m collection review-reddit --base BASE.json [--out summary.md] [--pr N]
Compares the pull request's data/public/reddit_comments.json with `BASE.json` (the same file on main) and reads the
runs as built from it (data/public/runs_clean.csv, so run `python -m collection build` first). The summary lists
what a reviewer needs to decide on, before merging:
- runs added, changed (answers differ) and gone;
- runs that break a game rule: left out of the route model and the statistics until corrected;
- other flags on the new or changed runs (kept, for information);
- runs that may also be in the community form (analysis/overlap/overlap.py: same answers within a day);
- runs whose result page is already a "reddit thread" row (counted once, automatically).
Corrections go in collection/manual/reddit_comments.yaml (reject / fix / add; see collection/README.md). With
`--pr N` the summary is posted on the pull request, replacing the previous one.
"""
import importlib.util
import json
import sys
from .common import ROOT, path, pipeline, read_yaml
MARKER = "<!-- atlas:reddit-review -->"
PROVENANCE = "read from a Reddit comment"
def _overlap():
spec = importlib.util.spec_from_file_location("overlap", ROOT / "analysis/overlap/overlap.py")
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
return mod
def link(run_id, thread):
cid = str(run_id).split("-")[0]
return f"[{run_id}](https://www.reddit.com/r/fourthwing/comments/{thread}/_/{cid}/)"
def diff(base, head):
"""(added, changed, gone) comment-run ids between two reddit_comments.json documents."""
b = {str(r["id"]): r for r in base.get("runs", [])}
h = {str(r["id"]): r for r in head.get("runs", [])}
added = sorted(set(h) - set(b))
gone = sorted(set(b) - set(h))
changed = sorted(k for k in set(h) & set(b) if h[k].get("answers") != b[k].get("answers"))
return added, changed, gone
def summary(base, head, runs, known_results=(), overlap=None):
"""The Markdown summary. `runs`: typed records of runs_clean.csv (with run_id)."""
sys.path.insert(0, str(ROOT / "core"))
from atlas import runs as runs_io
added, changed, gone = diff(base, head)
focus = set(added) | set(changed)
thread = {str(r["id"]): r.get("thread") for r in head.get("runs", [])}
result = {str(r["id"]): r.get("result") for r in head.get("runs", [])}
rows = {r["run_id"][len("comment-"):]: r for r in runs if r["source"] == "reddit comment"}
flags = {k: [f for f in (r.get("data_flags") or "").split("; ") if f and not f.startswith(PROVENANCE)]
for k, r in rows.items()}
impossible = sorted(k for k in rows if runs_io.impossible(rows[k]))
L = [MARKER, "## Reddit comment runs: review summary", ""]
L.append(f"**{len(head.get('runs', []))} runs** in this file: **{len(added)} new**, {len(changed)} changed, "
f"{len(gone)} gone since main. {head.get('unread', 0)} comments mention a bond or a burn but could not "
"be read as a run.")
L.append("")
L += ["### Runs that break a game rule", "",
"Left out of the route model and the statistics until corrected. Check the comment: `fix` a misread "
"answer, or `reject` a run that is not one.", ""]
bad = [k for k in impossible if k in focus] + [k for k in impossible if k not in focus]
if bad:
L += ["| Run | New? | Rule |", "|---|---|---|"]
L += [f"| {link(k, thread.get(k) or '')} | {'yes' if k in focus else ''} | "
f"{'; '.join(f for f in flags[k] if runs_io.impossible({'data_flags': f}))} |" for k in bad]
else:
L.append("None.")
L.append("")
other = [k for k in sorted(focus) if k in flags and flags[k] and k not in impossible]
L += ["### Other flags on new or changed runs (kept)", ""]
L += [f"- {link(k, thread.get(k) or '')}: {'; '.join(flags[k])}" for k in other] or ["None."]
L.append("")
if overlap is not None:
twice = {m["comment"][len("comment-"):]: m["form"] for m in overlap.get("matches", [])}
hits = [k for k in sorted(focus) if k in twice]
L += ["### May also be in the community form", "",
f"Same answers as a form row submitted within {overlap['rule']['window_days']} day(s). Over all Reddit "
f"runs: {overlap['matched']} of {overlap['comparable']} comparable runs match, about "
f"{overlap['expected_by_chance']} by chance, so about {overlap['likely_double']} look reported twice. "
"Nothing is removed: identical routes are expected.", ""]
L += [f"- {link(k, thread.get(k) or '')}: {', '.join(twice[k][:5])}" for k in hits] or ["None among the new runs."]
L.append("")
counted = [k for k in sorted(focus) if result.get(k) and str(result[k]).upper() in known_results]
L += ["### Result pages already counted", "",
"Their result page is also a \"reddit thread\" row; the run is counted once, with its route.", ""]
L += [f"- {link(k, thread.get(k) or '')}: {result[k]}" for k in counted] or ["None."]
L.append("")
L += ["### How to correct", "",
"In `collection/manual/reddit_comments.yaml` (applied at build time, on this branch or later):",
"- `reject: [comment id]`: not a run (a joke, a friend's run, two runs told as one);",
"- `fix: {comment id: {question: answer}}`: answers read wrong (`null` removes one);",
"- `add: [{id, thread, posted, answers}]`: a run the reader missed.",
"", "A corrected run loses the \"not checked by hand\" note. Then merge."]
return "\n".join(L) + "\n"
def main(base_file, out=None, pr=None):
sys.path.insert(0, str(ROOT / "core"))
from atlas import runs as runs_io
spec = pipeline()["sources"]["reddit_comments"]
base = json.loads(open(base_file, encoding="utf-8").read()) if base_file else {"runs": []}
head = json.loads(path(spec["load"]).read_text(encoding="utf-8"))
runs = runs_io.read(drop=())
thread_spec = pipeline()["sources"].get("reddit_thread") or {}
manual = (thread_spec.get("transform") or {}).get("manual")
known = {str(r["id"]).upper() for r in (read_yaml(manual)["results"] if manual else [])}
text = summary(base, head, runs, known, _overlap().measure(runs))
if out:
open(out, "w", encoding="utf-8").write(text)
else:
print(text)
if pr:
from . import forge
forge.upsert_comment(int(pr), MARKER, text)
print(f"summary posted on #{pr}")
return 0
+85 -6
View File
@@ -4,7 +4,9 @@ One coder per source (pipeline.yaml `runs:`). Every coder returns rows keyed by
missing answers get the same "not known" values the community form's coding uses, so every source can be filtered
the same way. The `source` column says where a run came from; `entry` keeps the spreadsheet's own row label.
"""
import collections
import functools
import hashlib
import json
import re
from pathlib import Path
@@ -51,18 +53,40 @@ def encounter_columns(row, intentional=False):
# ---------------------------------------------------------------- coders, by pipeline.yaml `runs:`
def fingerprints(records, prefix):
"""Stable ids for rows that have no id of their own (the form, the register): `<prefix>-<hash of the row's
non-empty answers, timestamp included>`, so deleting or re-sorting rows in the sheet changes no other row's id,
and a column added later (empty in old rows) changes none. Rows that are exact copies of each other get -2, -3...
in the order they come; they are identical, so which copy is which does not matter. A row edited in the sheet
gets a new id: it is a different record."""
seen = collections.Counter()
out = []
for rec in records:
answers = {str(k): v for k, v in rec.items() if v is not None and v != "" and v == v} # v == v: not NaN
h = hashlib.sha1(json.dumps(answers, sort_keys=True, ensure_ascii=False, default=str).encode("utf-8")).hexdigest()[:12]
seen[h] += 1
out.append(f"{prefix}-{h}" + (f"-{seen[h]}" if seen[h] > 1 else ""))
return out
def spreadsheet(name, spec):
"""The community form: core/spec/form.yaml + core/atlas/coding.py, unchanged."""
"""The community form: core/spec/form.yaml + core/atlas/coding.py, plus the game-rule checks every source that
answers the form's questions gets (rule_flags; a flag the coder already set is not repeated)."""
from atlas import coding
df, missing = coding.code_frame(coding.read_export(path(spec["load"])))
raw = coding.read_export(path(spec["load"]))
df, missing = coding.code_frame(raw)
if missing:
print(f"WARNING: {name}: questions not found in the sheet: {missing}")
ids = fingerprints(raw.astype(object).where(raw.notna(), None).to_dict("records"), "sheet")
df["attempt"] = df["attempt"].astype("Int64")
rows = []
for rec in df.astype(object).where(df.notna(), None).to_dict("records"):
n = rec.pop("run_id")
for i, rec in enumerate(df.astype(object).where(df.notna(), None).to_dict("records")):
rec.pop("run_id") # the coder's row number: shifts when rows are deleted or re-sorted
entry = rec.pop("source")
rows.append({**{c: None for c in COLUMNS}, **rec, "run_id": f"sheet-{n}", "source": spec["run_source"], "entry": entry})
row = {**{c: None for c in COLUMNS}, **rec, "run_id": ids[i], "source": spec["run_source"], "entry": entry}
have = [f for f in (row["data_flags"] or "").split("; ") if f]
row["data_flags"] = "; ".join(have + [f for f in rule_flags(row) if f not in have])
rows.append(row)
return rows
@@ -95,6 +119,7 @@ def register(name, spec):
"colour": ("colour",), "tail": ("tail",)}.items()}
values = {c: DICT["columns"][c].get("values") or [] for c in ("wing", "section", "squad", "outcome_color", "tail")}
rows = []
ids = fingerprints(data["rows"], "register")
for n, r in enumerate(data["rows"], 1):
get = lambda k: (str(r.get(h[k])).strip() if h[k] and r.get(h[k]) is not None else None) # noqa: E731
flags = ["outcome only (register): the same run may also be in the spreadsheet"]
@@ -103,7 +128,7 @@ def register(name, spec):
flags.append("colour not recognised")
colour = None
tail = (get("tail") or "").replace(" ", "").capitalize() or None
row = blank_row(run_id=f"register-{n}", source=spec["run_source"], date=(get("when") or "")[:10] or None,
row = blank_row(run_id=ids[n - 1], source=spec["run_source"], date=(get("when") or "")[:10] or None,
outcome="Bonded", outcome_color=colour, tail=tail if tail in values["tail"] else None)
for c in ("wing", "section", "squad"):
if get(c) and (not values[c] or get(c) in values[c]): # section is free text in the dictionary
@@ -191,11 +216,65 @@ def answers_row(run_id, source, date, answers, flags=None):
row["saw_blue_meadow"] = True
if row["outcome"] == "Bonded" and not row["outcome_color"]:
flags.append("bonded, colour not given")
flags += rule_flags(row)
encounter_columns(row)
row["data_flags"] = "; ".join(flags)
return row
# the scream answer each cadet outcome follows (a run cannot end the encounter on another path)
CADET_PATH = {
"Killed the bullies yourself": "Investigate & help", "Squadmate's revenge": "Investigate & help",
"Left bullies to the dragons": "Investigate & help", "DIED in combat": "Investigate & help",
"Tourniquet": "Ignore the scream", "Left injured cadet": "Ignore the scream", "Took their weapons": "Ignore the scream",
"Left them to it": "Investigate & leave",
}
REACHED = ("Tree", "Valley")
@functools.lru_cache(maxsize=1)
def _form_rules():
from atlas import spec as atlas_spec
f = atlas_spec.form()
return f["sighting_pool"], {k: set(v) for k, v in f["encounter_colours"].items()}
def rule_flags(row):
"""The game's own rules, for runs answered through "Report a run": the checks core/atlas/coding.py makes on
the community form (first-dragon pools, Greens in the valley) plus the encounter's dragons and the cadet path.
Each broken rule is a flag; the run is kept."""
pools, enc_colours = _form_rules()
flags = []
company, direction, first = row["company"], row["direction"], row["first_sighting"]
if company in pools and direction in pools[company] and first in COLOURS:
pool = list(pools[company][direction]) + (list(pools["Alone"][direction]) if row["left_squadmates"] is True else [])
if first not in pool:
flags.append(f"first sighting {first} not in documented pool for {company}/{direction}")
colour, branch = row["outcome_color"], row["branch"]
if row["outcome"] in ("Bonded", "Incinerated") and colour:
if branch in enc_colours and colour not in enc_colours[branch]:
flags.append(f"{colour} at the {branch} encounter, which has only {'/'.join(sorted(enc_colours[branch]))}")
if row["hour"] == "Valley" and colour == "Green":
flags.append("Green recorded on a Valley run (no Greens in the valley)")
if row["hour"] == "Valley" and colour == "Black":
flags.append("Black recorded on a Valley run (the Black is only reached from the tree)")
scream, res = row["scream"], row["resolution"]
if scream in ("Investigate & help", "Ignore the scream", "Investigate & leave"):
if res in CADET_PATH and CADET_PATH[res] != scream:
flags.append(f"cadet outcome {res!r} does not follow {scream!r}")
if scream != "Investigate & help" and (row["combat_first"] not in (None, "(not recorded)")
or row["combat_second"] not in (None, "(not recorded)")):
flags.append("fight answers on a run that did not help")
if scream != "Investigate & help" and row["post_path"] in ("Forest", "West", "East"):
flags.append("a path after the fight on a run without a fight")
if row["combat_second"] not in (None, "(not recorded)") and row["combat_first"] != "Assess the situation":
flags.append("a second fight move without pausing to assess")
died_early = (scream or "").startswith("DIED") or (res or "").startswith("DIED")
if died_early and (row["hour"] in REACHED or row["outcome"] in ("Bonded", "Incinerated")):
flags.append("died before the hour, yet reached the tree, the valley or a bonding encounter")
return flags
def _norm(text):
from .transform.bot import normalize
return normalize(text)
+2
View File
@@ -57,6 +57,7 @@ sources:
runs: null # a flowchart of the routes, not a log of runs (see collection/README.md)
reddit_thread:
cite: [part3, part4] # both megathreads, in the dataset's isBasedOn
label: Runs posted in the r/fourthwing Dragonkind megathreads
run_source: reddit thread
links:
@@ -70,6 +71,7 @@ sources:
runs: reddit_results
reddit_comments:
cite: [part3, part4] # both megathreads, in the dataset's isBasedOn
label: Runs riders describe in the r/fourthwing Dragonkind megathread comments
run_source: reddit comment
links:
+7
View File
@@ -132,6 +132,10 @@ def main(argv=None):
k.add_argument("--out", default="exports")
sub.add_parser("rebuild", help="rebuild everything made from the runs: graph, route model, plan, reports, statistics, build")
sub.add_parser("send-pdf", help="open a pull request on the bot's repo when the route PDF changed (private copy only)")
rv = sub.add_parser("review-reddit", help="a review summary for a Reddit scraper pull request (run `build` first)")
rv.add_argument("--base", help="data/public/reddit_comments.json as it is on main")
rv.add_argument("--out", help="write the summary here (default: print it)")
rv.add_argument("--pr", help="also post it on this pull request, replacing the previous summary")
r = sub.add_parser("refresh", help="update every source, then rebuild everything (the daily workflow, locally)")
r.add_argument("--bot", action="append", default=[], help="a bot folder or a .zip of its data (repeatable)")
c = sub.add_parser("cycle", help="the loop with the bot: import its runs, refit, re-plan, deliver (safe on a timer)")
@@ -155,6 +159,9 @@ def main(argv=None):
if a.cmd == "rebuild":
from .etl.handoff import rebuild
return rebuild()
if a.cmd == "review-reddit":
from .etl.review_reddit import main as review
return review(a.base, a.out, a.pr)
if a.cmd == "send-pdf":
from .etl.send_pdf import send
return send()
+7
View File
@@ -25,6 +25,13 @@ def _parse(col, v):
return v
def impossible(r):
"""A run that cannot have happened as recorded: one of its flags is in core/spec/form.yaml impossible_flags."""
from . import spec
rules = spec.form()["impossible_flags"]
return any(rule in f for f in (r.get("data_flags") or "").split("; ") for rule in rules)
def read(path=PATH, sources=None, drop=("run_id",)):
"""Typed records, optionally only from some sources (the `source` column)."""
with open(path, encoding="utf-8", newline="") as f:
+64 -1
View File
@@ -15,6 +15,9 @@
* shadow odds), `fix` (hold some decisions to given options: an experiment arm) and sampling "uniform" (mapping);
* assign(plan, { accountSeq, attempt }) reads the experiment plan (experiments.json) and says what an attempt is for;
* screenPick(tree, sceneId, offered, { mode }) picks from the screen tree (tree.json): least-tried, or Thompson.
* knownAnswer(known, offered, { target, sceneColour }) looks a screen's choices up in known_answers.json (the guide's
* encounter answers and the bot's own results) for screens nothing else covers: a pick when the evidence is clear,
* and the evidence for every choice either way, to hand to Clef (issue #35).
* UMD: window.ThreshSolver in the browser, module.exports in Node. No dependencies.
*/
(function (root, factory) {
@@ -446,8 +449,68 @@
reason: mode === "thompson" ? `survived ${pick.survived} of ${pick.n} so far` : `played ${pick.n} times, the fewest on this screen` };
}
/* ---------- known answers (analysis/known/build_known.py -> data/public/known_answers.json) ---------- */
const STOP = new Set("a an the to and or of your you its it is for at in on with this that be".split(" "));
const words = (t) => norm(t).split(" ").filter((w) => w && !STOP.has(w));
/** The guide labels a game text carries: the guide paraphrases ("Touch its talon"), the game says it in full ("Reach a
* hand slowly to touch its talon"), so a label matches when every word of it that matters is in the text. Labels of
* fewer than two such words ("Is your dragon") only match a text that is exactly the label. */
function guideMatches(known, text) {
const n = norm(text), have = new Set(words(text)), out = [];
for (const [k, e] of Object.entries(known.answers || {})) {
if (!e.guide) continue;
const w = words(e.text);
const exact = k === n;
if (exact || (w.length >= 2 && w.every((x) => have.has(x)))) e.guide.forEach((g) => out.push({ ...g, label: e.text, exact }));
}
return out;
}
/**
* A screen nothing else covers: what the Atlas knows about each choice, and a pick when it is clear.
* known data/public/known_answers.json
* offered the choice texts on screen, in order
* target the colour the account is after ("Blue"); sceneColour: the colour of this scene's dragon, if the
* bot knows it (only the guide's answers for that dragon's encounters are used then)
* Returns { pick, confidence, reason, choices }: pick is the index to take (null if nothing is clear), confidence
* "strong" (exactly one choice is on the guide's recommended path toward the target, and the bot's own runs don't
* contradict it) or "weak" (several fit, or only the bot's own record speaks for it). choices[i].verdict is "good",
* "bad" (the guide ends it in incineration, or the bot died on it at least 3 times in 4) or "unknown", with the
* evidence behind it. Anything weak or unknown goes to Clef with this evidence; a pick never skips the bot's guard.
*/
function knownAnswer(known, offered, { target, sceneColour = null } = {}) {
const T = target ? target[0].toUpperCase() + target.slice(1).toLowerCase() : null;
const choices = offered.map((text, index) => {
const e = (known.answers || {})[norm(text)] || {};
const bot = e.bot || null;
const guide = guideMatches(known, text).filter((g) => !sceneColour || (g.colours || []).includes(sceneColour));
const onPath = guide.filter((g) => T && (g.on_path || []).includes(T));
const botBad = bot && bot.n >= 2 && bot.died / bot.n >= 0.75;
const botGood = bot && bot.n >= 3 && bot.died === 0;
const guideBad = guide.length > 0 && guide.every((g) => /^Incinerated/.test(g.end));
const verdict = onPath.length && !botBad ? "good" : guideBad || botBad ? "bad" : "unknown";
return { index, text, verdict, guide, bot, onPath: onPath.length > 0, botGood: !!botGood };
});
const good = choices.filter((c) => c.verdict === "good");
let pick = null, confidence = null, reason = "nothing the Atlas knows covers these choices";
if (good.length === 1) {
pick = good[0].index; confidence = "strong";
reason = `on the guide's recommended path to the ${T} ("${good[0].onPath && good[0].guide.find((g) => (g.on_path || []).includes(T)).label}")`;
} else if (good.length > 1) {
const best = good.find((c) => c.botGood) || good[0];
pick = best.index; confidence = "weak"; reason = `${good.length} choices are on the guide's paths; the bot's record favours none clearly`;
} else {
const safe = choices.filter((c) => c.botGood && c.verdict !== "bad");
if (safe.length) {
const b = safe.reduce((x, y) => (y.bot.n > x.bot.n ? y : x));
pick = b.index; confidence = "weak"; reason = `the bot got through it ${b.bot.n} of ${b.bot.n} times`;
}
}
return { pick, confidence, reason, choices };
}
return Object.assign(api, {
advisor, recommendOption, solverHistory, norm, assign, armFor, givenFor, screenPick,
advisor, recommendOption, solverHistory, norm, assign, armFor, givenFor, screenPick, knownAnswer,
makeParams: (T, { alphas, game } = {}) => makeParams(T, { alphas, game: game || api.game }),
/** remember the game of a policy sample (sets ENCOUNTERS) without solving anything */
useGame(sample) { api.game = sample.model.game; api.ENCOUNTERS = api.game.by_colour; return api.game; },
+31
View File
@@ -153,6 +153,37 @@ sighting_pool:
1 Squadmate: { East: [Green, Orange, Red], West: [Red, Brown, Green], Center: [Red, Brown] }
2 Squadmates: { East: [Red, Orange], West: [Green, Brown, Red], Center: [Red, Brown] }
# The dragons each bonding encounter can end with (bond or burn), from the community PDF. Only used to FLAG runs
# answered through "Report a run" (reported, reddit comment) that end with a dragon the encounter does not have.
# Orange and Brown after the two Greens: a Green's rescue, then the Orange or Brown.
# Flags (data_flags, matched as text inside a flag) that mean a run cannot have happened as recorded: the game's own
# rules, from the form coder (core/atlas/coding.py) and the checks of collection/etl/runs.py rule_flags. A run with one
# is kept in runs_clean.csv, flagged, and left out of the route model and the site statistics (atlas.runs.impossible).
# Everything else, however partial, is used. Not here on purpose: a first sighting outside the documented pool (the
# pool is what riders have seen, not a rule), a missing direction, several wings, a missing Green before a rescue.
impossible_flags:
- "Green recorded on a Valley run"
- "Black recorded on a Valley run"
- "encounter, which has only"
- "more than one dragon marked Bonded"
- "more than one dragon marked Incinerated"
- "tree run with both the Red and the two Greens attempted"
- "died in combat on a path without combat"
- "rare-dragon answer does not match the path"
- "does not follow"
- "fight answers on a run that did not help"
- "a path after the fight on a run without a fight"
- "a second fight move without pausing to assess"
- "died before the hour, yet reached"
encounter_colours:
"Shadow (rare)": [Blue, Black]
"Descend quickly: Red": [Red]
"Descend quickly: let the Red pass": [Green]
"Descend slowly: two Greens": [Green, Orange, Brown]
"Valley Red": [Red]
"Passed the Red: meadow": [Orange, Brown, Blue]
# First-sighting answers that are not a single colour: coded as this colour, and the row is flagged with the
# original answer (data_flags), so nothing is lost.
first_sighting_alias:
+43 -23
View File
@@ -66,23 +66,33 @@
"isBasedOn": [
{
"@type": "sc:CreativeWork",
"name": "Threshing Routes form and spreadsheet (u/ClumsyBadger, linked from the r/fourthwing megathreads)",
"url": "https://docs.google.com/spreadsheets/d/1gnw1AdRg1XT4JsOfRM6QTA0jSaS3n9ZF-rPWnYewzv0"
"url": "https://docs.google.com/spreadsheets/d/1gnw1AdRg1XT4JsOfRM6QTA0jSaS3n9ZF-rPWnYewzv0",
"name": "Threshing Routes form and spreadsheet (u/ClumsyBadger, linked from the r/fourthwing megathreads)"
},
{
"@type": "sc:CreativeWork",
"name": "Unofficial Dragon Register (which dragon each rider bonded)",
"url": "https://docs.google.com/spreadsheets/d/1KMiE9sec0l597Pzue1OhGYf07NF4howtQ_lPeqx7jXQ"
"url": "https://docs.google.com/spreadsheets/d/1KMiE9sec0l597Pzue1OhGYf07NF4howtQ_lPeqx7jXQ",
"name": "Unofficial Dragon Register (which dragon each rider bonded)"
},
{
"@type": "sc:CreativeWork",
"name": "Runs posted in the r/fourthwing Dragonkind megathreads",
"url": "https://www.reddit.com/r/fourthwing/comments/1wvwfp9/"
"url": "https://www.reddit.com/r/fourthwing/comments/1wvwfp9/",
"name": "Runs posted in the r/fourthwing Dragonkind megathreads (part 3)"
},
{
"@type": "sc:CreativeWork",
"name": "Runs riders describe in the r/fourthwing Dragonkind megathread comments",
"url": "https://www.reddit.com/r/fourthwing/comments/1wvwfp9/"
"url": "https://www.reddit.com/r/fourthwing/comments/1wz5cnj/",
"name": "Runs posted in the r/fourthwing Dragonkind megathreads (part 4)"
},
{
"@type": "sc:CreativeWork",
"url": "https://www.reddit.com/r/fourthwing/comments/1wvwfp9/",
"name": "Runs riders describe in the r/fourthwing Dragonkind megathread comments (part 3)"
},
{
"@type": "sc:CreativeWork",
"url": "https://www.reddit.com/r/fourthwing/comments/1wz5cnj/",
"name": "Runs riders describe in the r/fourthwing Dragonkind megathread comments (part 4)"
}
],
"distribution": [
@@ -93,8 +103,8 @@
"description": "Every run from every source, one per row, coded into the same columns (collection/etl/runs.py; the form's rules are core/spec/form.yaml). The `source` column says where each run came from.",
"contentUrl": "https://git.kenschiano.net/DragonKind/threshing-atlas/raw/branch/main/data/public/runs_clean.csv",
"encodingFormat": "text/csv",
"sha256": "c5b7302bee16c063a400548e8bdf95256df50acbc00f2c6e9813eed7f50c42d4",
"contentSize": "3680593 B"
"sha256": "24321aa853d696b4a06226e28bac5e7843759dc3393721ef020d7f5c6beadf4e",
"contentSize": "3828261 B"
},
{
"@type": "cr:FileObject",
@@ -103,8 +113,8 @@
"description": "The community \"Threshing Routes\" form export as published (headers and rows), with email addresses in free-text answers redacted. The source of runs_clean.",
"contentUrl": "https://git.kenschiano.net/DragonKind/threshing-atlas/raw/branch/main/data/public/form_responses.json",
"encodingFormat": "application/json",
"sha256": "319f6217e0a431454114a67276f429379ec383cd6ed2666443b48b8f48c66490",
"contentSize": "12623695 B"
"sha256": "8067ac944db2833e6a1203dc6464ed208d60dea4e617ee9b28fc56f285445d2e",
"contentSize": "12786245 B"
},
{
"@type": "cr:FileObject",
@@ -113,8 +123,18 @@
"description": "Runs described in the r/fourthwing megathread comments, read into the \"Report a run\" answers: comment id, day and answers only, no usernames or comment text.",
"contentUrl": "https://git.kenschiano.net/DragonKind/threshing-atlas/raw/branch/main/data/public/reddit_comments.json",
"encodingFormat": "application/json",
"sha256": "c180f8b82ed1119d4ff28697fcf45d0c7f22859597cd10f5e82a2e50ca1dc51a",
"contentSize": "105 B"
"sha256": "b169d157e731db23c99f2f8317a9718d31801b7d64336b3d414511ac13f32493",
"contentSize": "23174 B"
},
{
"@type": "cr:FileObject",
"@id": "overlap",
"name": "overlap",
"description": "How many Reddit comment runs may also be in the community form (the same answers within a day), against what chance alone gives (analysis/overlap/overlap.py). Measured only: no run is removed.",
"contentUrl": "https://git.kenschiano.net/DragonKind/threshing-atlas/raw/branch/main/data/public/overlap.json",
"encodingFormat": "application/json",
"sha256": "e7511cccf9e8379d8e892639cb38772269ac228756b984e9e0d4d8e9a583a9dd",
"contentSize": "2544 B"
},
{
"@type": "cr:FileObject",
@@ -123,8 +143,8 @@
"description": "Runs reported through the Atlas's \"Report a run\" form (issues on its repository), answers only, no usernames.",
"contentUrl": "https://git.kenschiano.net/DragonKind/threshing-atlas/raw/branch/main/data/public/reports.json",
"encodingFormat": "application/json",
"sha256": "d42eb04b9923eb1d2a8e5c356452f52daab78293be5a29a448cfb69c974eab30",
"contentSize": "92 B"
"sha256": "51510ed7a0b4016501fe4e0324a352842e831a48773a08b084dec6ff7dde2d14",
"contentSize": "112 B"
},
{
"@type": "cr:FileObject",
@@ -143,8 +163,8 @@
"description": "Every number the Atlas page shows, for six filter presets (analysis/stats/site_stats.py; what is measured is analysis/stats/measures.yaml).",
"contentUrl": "https://git.kenschiano.net/DragonKind/threshing-atlas/raw/branch/main/data/public/stats.json",
"encodingFormat": "application/json",
"sha256": "75ed4be2199b2192e904ce7697892eed01abfefc4e897cd3fbeaf0c7ed4c637c",
"contentSize": "5461481 B"
"sha256": "7431173d9b667d4914d17bbc299d994d14c3104e3e89a1eb75d690c1b21ade6a",
"contentSize": "5110214 B"
},
{
"@type": "cr:FileObject",
@@ -153,8 +173,8 @@
"description": "The route model: the game (core/spec/game.yaml), the count tables behind every roll, and the best decision tree for every dragon colour under two goals, with posterior intervals (planner/build_policy.py).",
"contentUrl": "https://git.kenschiano.net/DragonKind/threshing-atlas/raw/branch/main/data/public/policy.json",
"encodingFormat": "application/json",
"sha256": "8360beabea06d77117ddd10741c4e004cf361f8bd3d6377286bb053d2ba6e1b0",
"contentSize": "986194 B"
"sha256": "eec67140c63f028d31553be4f2310d92c9378293488aecd73a41ba1700b9e646",
"contentSize": "987412 B"
},
{
"@type": "cr:FileObject",
@@ -163,8 +183,8 @@
"description": "The route graph over every run in runs_clean.csv, counted per source (analysis/network/build-graph.js).",
"contentUrl": "https://git.kenschiano.net/DragonKind/threshing-atlas/raw/branch/main/data/public/graph.json",
"encodingFormat": "application/json",
"sha256": "f4d4d02d5ce0d57de2c706a84874133aab9b5c915c59aeef9760b3141b3044e0",
"contentSize": "75584 B"
"sha256": "f9d1a86f84fcc10ef906af686ce624355ffd729440460288406ba97177ff05da",
"contentSize": "84575 B"
}
],
"recordSet": [
@@ -181,7 +201,7 @@
"@type": "cr:Field",
"@id": "runs/run_id",
"name": "run_id",
"description": "Unique id of the run: sheet-<row of the form export>, thread-<result id>, comment-<Reddit comment id>, reported-<issue number> or bot-<hash>.",
"description": "Unique id of the run, stable when rows are deleted or re-sorted: sheet-<hash of the form row's answers and timestamp>, register-<hash of the register row>, thread-<result id>, comment-<Reddit comment id>, reported-<issue number> or bot-<hash>.",
"dataType": "sc:Text",
"source": {
"fileObject": {
+7 -1
View File
@@ -41,6 +41,12 @@ files:
description: >-
Runs described in the r/fourthwing megathread comments, read into the "Report a run" answers: comment id, day
and answers only, no usernames or comment text.
overlap:
path: data/public/overlap.json
format: application/json
description: >-
How many Reddit comment runs may also be in the community form (the same answers within a day), against what
chance alone gives (analysis/overlap/overlap.py). Measured only: no run is removed.
reports:
path: data/public/reports.json
format: application/json
@@ -69,7 +75,7 @@ files:
# The columns of runs_clean. type: text, integer, boolean or date. values: every value the column may take
# (empty cells are always allowed and mean "does not apply" or "not recorded").
columns:
run_id: { type: text, required: true, description: "Unique id of the run: sheet-<row of the form export>, thread-<result id>, comment-<Reddit comment id>, reported-<issue number> or bot-<hash>." }
run_id: { type: text, required: true, description: "Unique id of the run, stable when rows are deleted or re-sorted: sheet-<hash of the form row's answers and timestamp>, register-<hash of the register row>, thread-<result id>, comment-<Reddit comment id>, reported-<issue number> or bot-<hash>." }
source:
type: text
required: true
+6 -6
View File
@@ -10,18 +10,18 @@
"changed": "2026-11-16"
},
"reddit_spreadsheet": {
"sha256": "e3cccdbdf8ce67d7ea8e85156ccd5b5f5e404ab6cd195ee8883ea140249d16a6",
"bytes": 5949959,
"sha256": "44eeece5fd75fb27f0c7bdf2729d812ba710f4bfba30dfd5dbee51a7888b8270",
"bytes": 5994979,
"changed": "2026-11-19"
},
"register": {
"sha256": "ea9807f6d2391ecce7425888b913d4b618ac85463a459e3908abf1233c888f19",
"sha256": "6efdf107fce4d7b5a48de3d683762b7236a6049c875145bf4aa1608c90f9ae8f",
"bytes": 51331,
"changed": "2026-11-19"
},
"reported": {
"sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
"bytes": 2,
"changed": "2026-11-04"
"sha256": "4c62d2e726e7c967d03a6c85d3bb3e09384656b7ffd9ea629d13400fdc37b211",
"bytes": 28296,
"changed": "2026-11-19"
}
}
+16 -15
View File
@@ -8,23 +8,23 @@
],
"2": [
0,
296
299
],
"3": [
0,
193
196
],
"4-10": [
0,
538
555
],
"11-30": [
0,
626
657
],
"31 or more": [
0,
694
715
]
},
"bulk logs": {
@@ -81,11 +81,11 @@
}
},
"same_route": {
"routes": 325,
"routes": 326,
"first_shadows": 93,
"expected": 39.9,
"odds_ratio": Infinity,
"z": 12.3
"expected": 38.8,
"odds_ratio": null,
"z": 12.5
},
"form_first": [
97,
@@ -93,7 +93,7 @@
],
"form_later": [
0,
2347
2422
],
"best_route": {
"route": [
@@ -110,18 +110,19 @@
],
"later": [
0,
94
106
]
},
"shadow_routes": {
"runs": 97,
"routes": 47,
"off_gate": 3
"off_gate": 3,
"gates_unstated": 14
},
"after_shadow": {
"reached_black": 79,
"bonded_black": 57,
"died_at_blue": 16,
"reached_black": 89,
"bonded_black": 65,
"died_at_blue": 19,
"answers": {
"held its gaze": [
29,
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large Load Diff
+134
View File
@@ -0,0 +1,134 @@
{
"schema": 1,
"rule": {
"min_answers": 4,
"window_days": 1,
"baseline_shifts_days": [
-28,
-21,
-14,
14,
21,
28
]
},
"comment_runs": 82,
"comparable": 36,
"matched": 9,
"expected_by_chance": 7.3,
"likely_double": 1.7,
"matches": [
{
"comment": "comment-pdjr7gm",
"form": [
"sheet-e42d078df15a",
"sheet-d930d7c3533d"
]
},
{
"comment": "comment-pdq6tsw",
"form": [
"sheet-e588ea82d6f9",
"sheet-410e2db3f2df",
"sheet-af47d3ca8ef8"
]
},
{
"comment": "comment-pe0kwol",
"form": [
"sheet-bea7c3c25e85"
]
},
{
"comment": "comment-pe2l6mz",
"form": [
"sheet-7a526f9f5956",
"sheet-8191a69798de",
"sheet-0d56c45763b7",
"sheet-c51873588c6d",
"sheet-b8d6d0a2ce4c",
"sheet-34e592789d1b",
"sheet-66e8fda4be49",
"sheet-1922bb0d7397",
"sheet-37f31b85732d"
]
},
{
"comment": "comment-pe2n3j1",
"form": [
"sheet-807397c3d7e2",
"sheet-ff44440c3570"
]
},
{
"comment": "comment-pev3uge",
"form": [
"sheet-9c848ba4c9a9",
"sheet-65c505bb553d",
"sheet-93077866d5b5",
"sheet-f4ba657cd34c",
"sheet-2fa18d22a1eb",
"sheet-4602a99ee254",
"sheet-5320d71ea890",
"sheet-55b901b0c666",
"sheet-94b17052d8c3",
"sheet-8924c5206376",
"sheet-81124318fbca",
"sheet-1346c5ddbeb6",
"sheet-c8670abfd8b3",
"sheet-913d430db3ed",
"sheet-2fa9c70f091d",
"sheet-19e5e9069e3b",
"sheet-19ecd172b18a",
"sheet-62484835c1c0",
"sheet-86e585f7994e",
"sheet-ad2265128708",
"sheet-f65261b3b1f7",
"sheet-cead6ddb0272",
"sheet-dd7216ed25e8",
"sheet-60a2410b997e",
"sheet-93303aaac8a1",
"sheet-aac64def431c",
"sheet-a62003707841",
"sheet-76d43e939528",
"sheet-ca945bc0e4f7",
"sheet-83270750d93e",
"sheet-7cb7c22a757e",
"sheet-1598950786a0",
"sheet-0d44ea821771",
"sheet-cc3275c111d3",
"sheet-899c141a899c"
]
},
{
"comment": "comment-pf22tpj",
"form": [
"sheet-3fdbb179c709",
"sheet-08a79a6ae907",
"sheet-73d9e41fee8d",
"sheet-172fec1dedc4",
"sheet-792cc1632e55",
"sheet-e97b3363e32f",
"sheet-d81d1b4b8c65",
"sheet-bcb8e109f973",
"sheet-8d6f20b09b5e",
"sheet-3848c3443c4e",
"sheet-ff87178ef296",
"sheet-5819e3882bec",
"sheet-aba89201ba1e"
]
},
{
"comment": "comment-pfhmw5d",
"form": [
"sheet-b03b79966bdb"
]
},
{
"comment": "comment-pgzz9hc",
"form": [
"sheet-344751923fc3"
]
}
]
}
+737
View File
@@ -0,0 +1,737 @@
{
"_about": "The answers inside each bonding encounter, transcribed by hand from the community route PDF (see source). Data, not the flowchart: each option's answer (say), the guide's printed rate (pct), whether it is on the guide's recommended dark-tile path (best), whether the guide marks it untested or unconfirmed (unconfirmed), and what follows (then) or how it ends (end); roll marks a step the guide calls an unknown chance or decision. route_encounters: which encounters each bonding encounter of the route model shows. Edit this file when the PDF changes (the daily check opens a pull request on the bot's repo when it does).",
"version": 1,
"source": {
"title": "Threshing Options (community route PDF)",
"authors": [
"u/ClumsyBadger",
"u/Old_Regular3018",
"u/Smart_Trifle_2099"
],
"version": "2026-11-16",
"link": "https://drive.google.com/file/d/17o72ehHsSPW4UdsKF-sXTxMLEuinWeEg/view",
"note": "Percentages are the guide's, from documented runs; options off the recommended path often rest on fewer than three records."
},
"encounters": {
"valley-Red": {
"title": "The valley Red",
"scene": "You're moved by an instinctual feeling that this...",
"options": [
{
"say": "Is your dragon",
"best": true,
"then": [
{
"say": "You're sure",
"best": true,
"then": [
{
"say": "Continue approach",
"best": true,
"then": [
{
"say": "Touch its talon",
"best": true,
"pct": "93%",
"end": "Bonded"
},
{
"say": "Run to mount its foreleg",
"end": "Bonded"
}
]
},
{
"say": "Exit gracefully",
"end": "That was close (on to the meadow)"
}
]
},
{
"say": "On second thought…",
"end": "That was close (on to the meadow)"
}
]
},
{
"say": "Is not your dragon, leave",
"end": "That was close (on to the meadow)"
}
]
},
"tree-Red": {
"title": "The Red below the tree",
"scene": "A red dragon prowls ten feet beneath you.",
"warning": "The guide gives a 98% chance of dying if you engage this dragon.",
"options": [
{
"say": "Jump on its back, or jump to land by its tail",
"then": [
{
"roll": "Some unknown chance or decision roll"
},
{
"say": "Hold the Red's gaze",
"then": [
{
"say": "Jump off and hope",
"end": "Incinerated"
},
{
"say": "Drop to your stomach",
"then": [
{
"say": "Hang tight",
"end": "Incinerated"
},
{
"say": "Crawl to the seat",
"pct": "2%",
"end": "Bonded"
}
]
}
]
},
{
"say": "Lower your eyes",
"end": "Incinerated"
}
]
},
{
"say": "Wait and pursue the Green",
"end": "On to the two Greens"
}
]
},
"tree-Greens": {
"title": "The two Greens",
"scene": "You enter a clearing with two Green dragons.",
"options": [
{
"say": "Turn to the right dragon",
"best": true,
"then": [
{
"say": "Glance to the left dragon",
"end": "Incinerated"
},
{
"say": "Don't move a muscle",
"best": true,
"then": [
{
"say": "Stay still",
"best": true,
"then": [
{
"say": "Decapitation isn't scary",
"best": true,
"then": [
{
"say": "You respect their nature",
"best": true,
"end": "Bonded (Right Green)"
},
{
"say": "You don't know",
"end": "Incinerated"
},
{
"say": "Greens have the best magic",
"best": true,
"end": "Bonded (Left Green)"
},
{
"say": "Intellect match",
"best": true,
"end": "A Brown saves you: Bonded (Brown)"
}
]
},
{
"say": "Sidestep out of its mouth",
"end": "Incinerated"
}
]
},
{
"say": "Sidestep out of its mouth",
"end": "Incinerated"
}
]
}
]
},
{
"say": "Turn to the left dragon",
"best": true,
"then": [
{
"say": "Glance to the right dragon",
"end": "Incinerated"
},
{
"say": "Don't move a muscle",
"best": true,
"then": [
{
"say": "Hold your ground",
"best": true,
"then": [
{
"say": "You always overextend",
"best": true,
"end": "Bonded (Right Green)"
},
{
"say": "You lack flaws",
"end": "Incinerated"
},
{
"say": "You struggle with temper",
"best": true,
"end": "Bonded (Left Green)"
},
{
"say": "You're always right",
"best": true,
"end": "An Orange saves you: Bonded (Orange)"
}
]
},
{
"say": "Step back",
"end": "Incinerated"
}
]
}
]
},
{
"say": "Stay neutral",
"end": "Incinerated"
}
]
},
"meadow-Orange": {
"title": "The meadow Orange",
"scene": "You approach the Orange dragon.",
"options": [
{
"say": "Absolutely sure, Orange",
"best": true,
"pct": "90%",
"then": [
{
"say": "Roar right back at it",
"best": true,
"pct": "69%",
"then": [
{
"say": "Flee",
"end": "Incinerated"
},
{
"say": "Attempt to mount",
"best": true,
"end": "Bonded"
},
{
"roll": "Possibly an unknown decision or chance mechanic (20%)"
},
{
"say": "Hit the ground",
"best": true,
"then": [
{
"say": "Run to mount its foreleg",
"best": true,
"end": "Bonded"
},
{
"say": "Look it in the eye",
"then": [
{
"say": "Run to mount",
"end": "Bonded"
},
{
"say": "Maintain eye contact",
"end": "Incinerated"
}
]
}
]
},
{
"say": "Run at the claw",
"then": [
{
"say": "Hold tight for balance",
"end": "Incinerated"
},
{
"say": "Climb with strength",
"end": "Bonded"
}
]
}
]
},
{
"say": "Run, this was a mistake",
"end": "Incinerated"
}
]
},
{
"say": "On second thought…",
"pct": "10%",
"end": "Incinerated"
}
]
},
"meadow-Brown": {
"title": "The meadow Brown",
"scene": "You approach the Brown dragon.",
"options": [
{
"say": "Run after the Brown",
"best": true,
"then": [
{
"say": "On second thought…",
"end": "Incinerated"
},
{
"say": "Your heart is sure",
"best": true,
"then": [
{
"say": "Shout at it to stop",
"pct": "50%",
"then": [
{
"say": "Apologise immediately",
"pct": "50%",
"end": "Incinerated"
},
{
"say": "Await judgment, or pray",
"pct": "90%",
"then": [
{
"say": "Mud fight!",
"then": [
{
"say": "Wipe off the mud",
"pct": "90%",
"then": [
{
"say": "The dragon speaks",
"then": [
{
"say": "Defend the kingdom",
"end": "Death 50/50"
},
{
"say": "Defend the powerless",
"end": "Bonded"
},
{
"say": "Seek revenge",
"end": "Incinerated"
}
]
}
]
},
{
"say": "Throw mud at the dragon",
"pct": "60%",
"end": "Bonded"
},
{
"say": "Find a better dragon",
"end": "Not recorded"
}
]
}
]
}
]
},
{
"say": "Indecisively chase it",
"end": "Incinerated"
},
{
"say": "Mount the Brown's tail",
"best": true,
"then": [
{
"say": "Throw your weight",
"best": true,
"then": [
{
"say": "You'll charm it",
"best": true,
"end": "Bonded"
},
{
"say": "Hope for a clean death",
"end": "Incinerated"
},
{
"say": "It's already talking to you",
"end": "Bonded"
}
]
},
{
"say": "Wait for a better angle",
"end": "Incinerated"
}
]
}
]
}
]
},
{
"say": "Turn to the Orange",
"end": "Incinerated"
}
]
},
"meadow-Blue": {
"title": "The meadow Blue",
"scene": "You approach the Blue dragon.",
"options": [
{
"say": "Change to Orange",
"pct": "?",
"unconfirmed": true,
"end": "Not tested"
},
{
"say": "Change to Brown",
"pct": "?",
"unconfirmed": true,
"end": "Not tested"
},
{
"say": "Absolutely, Blue Dragon",
"best": true,
"pct": "90%",
"then": [
{
"say": "Hold glare and advance",
"best": true,
"pct": "80%",
"then": [
{
"say": "Do nothing",
"best": true,
"pct": "83%",
"then": [
{
"say": "Lower your eyes",
"pct": "?",
"unconfirmed": true,
"end": "Incinerated"
},
{
"say": "Help the cadet",
"pct": "0%",
"end": "Incinerated"
},
{
"say": "Hold glare and watch",
"best": true,
"pct": "80%",
"then": [
{
"say": "Straighten your spine",
"best": true,
"pct": "82%",
"then": [
{
"say": "Hold steady",
"pct": "0%",
"unconfirmed": true,
"end": "Incinerated"
},
{
"say": "Launch yourself right",
"best": true,
"pct": "85%",
"then": [
{
"say": "You already know",
"pct": "?",
"unconfirmed": true,
"end": "Not tested"
},
{
"say": "Bring down an empire",
"best": true,
"pct": "80%",
"then": [
{
"say": "Seize the chance to mount",
"pct": "50%",
"end": "Incinerated"
},
{
"say": "Move slowly forward",
"best": true,
"pct": "80%",
"end": "Bonded"
},
{
"say": "Hold still",
"pct": "50%",
"end": "Incinerated"
}
]
},
{
"say": "I want revenge",
"pct": "?",
"unconfirmed": true,
"end": "Not tested"
},
{
"say": "Defend the helpless",
"pct": "?",
"unconfirmed": true,
"end": "Not tested"
}
]
}
]
},
{
"say": "Speak first",
"pct": "20%",
"end": "Incinerated"
},
{
"say": "Do nothing",
"pct": "?",
"end": "Incinerated"
}
]
}
]
},
{
"say": "Intervene and help",
"pct": "?",
"end": "Incinerated"
}
]
},
{
"say": "Lower gaze, halt advance",
"pct": "0%",
"end": "Incinerated"
},
{
"say": "Lower gaze, advance",
"pct": "0%",
"end": "Incinerated"
}
]
}
]
},
"shadow": {
"title": "The shadow",
"scene": "You've seen a shadow, where will it lead...",
"options": [
{
"say": "A green sounds good",
"unconfirmed": true,
"end": "Not tested"
},
{
"say": "Stay the course",
"best": true,
"then": [
{
"say": "Well this is intriguing",
"best": true,
"then": [
{
"say": "Curiosity sated, retreat",
"then": [
{
"say": "Find that Green",
"end": "On to the two Greens"
},
{
"say": "Go towards the valley",
"unconfirmed": true,
"end": "Not tested"
}
]
},
{
"say": "Freeze and lower your eyes",
"best": true,
"then": [
{
"say": "Warn the cadet",
"end": "Incinerated"
},
{
"say": "Hold still",
"best": true,
"then": [
{
"say": "Aid the cadet",
"unconfirmed": true,
"end": "Not tested"
},
{
"say": "Hold position",
"best": true,
"then": [
{
"say": "Approach the Blue",
"then": [
{
"say": "On second thought…",
"unconfirmed": true,
"end": "Not tested"
},
{
"say": "You're sure",
"unconfirmed": true,
"end": "Incinerated?"
}
]
},
{
"say": "Await judgement",
"best": true,
"then": [
{
"say": "Help the cadet",
"best": true,
"then": [
{
"say": "Use your dagger",
"best": true,
"then": [
{
"say": "Head south and hope",
"best": true,
"end": "On to the Black"
}
]
},
{
"say": "Take them to cold water",
"end": "Head back for the Greens, or explore other dragons"
},
{
"say": "Clean their uniform",
"end": "Head back for the Greens, or explore other dragons"
}
]
},
{
"say": "Leave to find your dragon",
"end": "Head back for the Greens, or explore other dragons"
}
]
},
{
"say": "Run towards the other cadet",
"unconfirmed": true,
"end": "Not tested"
}
]
},
{
"say": "Last chance to escape",
"end": "Head back for the Greens, or explore other dragons"
}
]
},
{
"say": "Leave while it's distracted",
"end": "Head back for the Greens, or explore other dragons"
}
]
}
]
},
{
"say": "Too big, you're out",
"end": "Head back for the Greens, or explore other dragons"
}
]
}
]
},
"black": {
"title": "The Black",
"scene": "A branch snaps behind you...",
"note": "Lowering your eyes has frequently ended in incineration; what follows it is unconfirmed.",
"options": [
{
"say": "Ignore it, keep walking",
"end": "Incinerated"
},
{
"say": "Turn to face the threat",
"best": true,
"then": [
{
"say": "Lower your eyes",
"end": "Incinerated"
},
{
"say": "Hold its gaze",
"best": true,
"end": "Bonded"
}
]
}
]
}
},
"route_encounters": {
"valley-Red": [
"valley-Red"
],
"tree-Red": [
"tree-Red"
],
"tree-Greens": [
"tree-Greens"
],
"meadow-Orange": [
"meadow-Orange"
],
"meadow-Brown": [
"meadow-Brown"
],
"meadow-Blue": [
"meadow-Blue"
],
"shadow-Blue": [
"shadow"
],
"shadow-Black": [
"shadow",
"black"
]
}
}
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
+1 -1
View File
@@ -1 +1 @@
{"source":"Runs reported on the Atlas (\"Report a run\", a GitHub issue form)","reports":[]}
{"source":"Runs reported on the Atlas (\"Report a run\", an issue form on the Atlas's repository)","reports":[]}
+9827 -9621
View File
File diff suppressed because it is too large Load Diff
File diff suppressed because one or more lines are too long
+2 -2
View File
@@ -13,8 +13,8 @@ branch: main
# public, limited (only people signed in to this server) or private: who can open the links below
visibility: limited
# the published page, when it is hosted somewhere (GitHub Pages is paused while the GitHub account is suspended;
# the page is viewed locally or as a Claude artifact meanwhile)
# the published page: Ken's server serves the `pages` branch (.gitea/workflows/pages.yml). Set this to its address
# once it is up (then `python -m collection build`): the page's links and the dataset metadata use it.
site: null
# other copies of the repository (informational)
+3 -3
View File
@@ -6,11 +6,11 @@
"scripts": {
"build": "node site/build.js",
"dev": "node site/build.js && python3 -m http.server 8000 -d dist",
"test:py": "python3 -m collection build --check && python3 planner/build_experiments.py --check && python3 analysis/black/evidence.py --check && python3 analysis/tree/build_tree.py --check && PYTHONPATH=core python3 -m unittest discover -s tests/core -p 'test_*.py' && python3 -m unittest discover -s tests/collection -p 'test_*.py'",
"test:unit": "node --test tests/core/graph.test.js tests/core/advisor.test.js",
"test:py": "python3 -m collection build --check && python3 planner/build_experiments.py --check && python3 analysis/black/evidence.py --check && python3 analysis/tree/build_tree.py --check && python3 analysis/known/build_known.py --check && python3 analysis/overlap/overlap.py --check && PYTHONPATH=core python3 -m unittest discover -s tests/core -p 'test_*.py' && python3 -m unittest discover -s tests/collection -p 'test_*.py'",
"test:unit": "node --test tests/core/graph.test.js tests/core/advisor.test.js tests/core/known.test.js",
"test": "npm run test:py && npm run test:unit",
"graph": "node analysis/network/build-graph.js",
"policy": "python3 planner/build_policy.py && python3 planner/policy_report.py && python3 planner/build_experiments.py && python3 analysis/black/evidence.py && python3 analysis/tree/build_tree.py",
"policy": "python3 planner/build_policy.py && python3 planner/policy_report.py && python3 planner/build_experiments.py && python3 analysis/black/evidence.py && python3 analysis/tree/build_tree.py && python3 analysis/known/build_known.py && python3 analysis/overlap/overlap.py",
"cycle": "python3 -m collection cycle",
"stats": "python3 analysis/stats/site_stats.py",
"collect": "python3 -m collection update",
+9 -1
View File
@@ -31,11 +31,19 @@ def low_bias(r, lb=CONFIG["low_bias"]):
"""Kept in the low-bias sample: every run of an always-kept source, bulk logs, and riders not chasing a rare dragon."""
if r["source"] in lb["always"]:
return True
if r["source"] in (lb.get("never") or ()):
return False
if r["source"] == "reddit spreadsheet" and "bulk" in lb["entries_kept"] and r["entry"] not in (None, "Form"):
return True
return r["goal"] not in lb["rare_goals"]
def drop_flagged(runs, on=CONFIG.get("drop_impossible", True)):
"""Without the runs that cannot have happened as recorded (atlas.runs.impossible; planner/policy.yaml
drop_impossible): every other run is kept, however partial."""
return [r for r in runs if not (on and runs_io.impossible(r))]
def clean(o):
"""JSON-safe: numpy numbers to floats, infinities and NaN to null (as JavaScript's JSON.stringify does)."""
if isinstance(o, dict):
@@ -56,7 +64,7 @@ def main(argv=None):
ap.add_argument("--out", default=str(ROOT / "data/public/policy.json"))
a = ap.parse_args(argv)
runs = runs_io.read(a.data, sources=SOURCES)
runs = drop_flagged(runs_io.read(a.data, sources=SOURCES))
rows = len(runs)
samples = {
"all": runs,
+8 -1
View File
@@ -6,13 +6,19 @@
version: 1
# the `source` values of data/public/runs_clean.csv the model learns from
sources: [reddit spreadsheet, reported, bot]
sources: [reddit spreadsheet, reported, bot, reddit comment]
# Every run of the sources above is used, however partial, except a run that cannot have happened as recorded
# (core/spec/form.yaml impossible_flags: it breaks one of the game's rules). Such runs stay in runs_clean.csv, flagged;
# a hand fix that clears the flag brings a Reddit or reported run back. The site statistics use the same rule.
drop_impossible: true
# Two samples. "all" is every run above. "lowBias" leaves out runs where a rare sighting is more likely to have
# been reported than a miss: form submissions and reports from riders chasing Blue or Black. The bot logs every
# run, and bulk-pasted logs record every run of the players who kept them, so both stay in.
low_bias:
always: [bot] # sources whose every run is kept
never: [reddit comment] # riders posting a run in a thread pick the notable ones, like rare-chasers
entries_kept: [bulk] # spreadsheet rows whose `entry` is not "Form" (bulk-pasted logs)
rare_goals: [Blue, Black, Blue or Black]
@@ -38,3 +44,4 @@ reporting_bias:
- { name: "form, chasing Blue/Black", when: { source: reddit spreadsheet, goal: rare } }
- { name: "form, other", when: { source: reddit spreadsheet } }
- { name: reported, when: { source: reported }, same_as: "form, other" }
- { name: reddit comments, when: { source: reddit comment } } # self-selected: its own reporting rate
+3 -1
View File
@@ -84,6 +84,7 @@
// ------------------------------------------------------------ data loading
async function loadStats() {
state.stats = await (await fetch("data/stats.json")).json();
try { state.overlap = await (await fetch("data/overlap.json")).json(); } catch { state.overlap = null; }
const sel = $("#f-preset");
sel.innerHTML = Object.entries(META().presets).map(([k, l]) => `<option value="${k}">${esc(l)}</option>`).join("");
sel.value = state.preset;
@@ -554,7 +555,8 @@
</tbody></table></div><p class="small">Bulk logs come from players who recorded every run, so they are the least selective rows. Their rare-dragon rates are several times lower than the form's, which is the strongest sign of reporting bias in this data.</p></div>
<div class="panel"><h3>Rows flagged for contradictions</h3><p class="small muted">${m.n_flagged} of ${r.n} rows (${pct(m.n_flagged / r.n)}). Flagged rows stay in unless you pick "Rows without data-quality flags" above.</p><div class="tbl-wrap"><table><tbody>${flags.map(([f, n]) => `<tr><td>${esc(f)}</td><td class="num">${n}</td></tr>`).join("") || `<tr><td>None</td></tr>`}</tbody></table></div></div>
<div class="panel"><h3>How runs ended</h3><div class="tbl-wrap"><table><tbody>${outs.map(([f, n]) => `<tr><td>${esc(f)}</td><td class="num">${n}</td><td class="num">${pct(n / r.n)}</td></tr>`).join("")}</tbody></table></div><p class="small muted">"No outcome recorded" rows reached the hour but the form shows no Bonded or Incinerated. They count toward reaching a branch but not toward bond rates.</p></div>
<div class="panel"><h3>Independence</h3><p class="small">The form has no player ID. One player's 50 runs count as 50 independent runs, so intervals are somewhat narrower than they should be. ${pct((r.n - (m.sources["Form"] || 0)) / r.n, 0)} of rows arrived as bulk imports, each probably one player's or one group's log.</p></div>
${state.overlap && state.overlap.comparable ? `<div class="panel"><h3>The same run reported twice?</h3><p class="small">A rider may log a run in the form and post it in a megathread comment too. With no player IDs, a copy can only be measured, not proven, so nothing is removed. Of ${state.overlap.comparable} Reddit runs detailed enough to compare, ${state.overlap.matched} give the same answers as a form row sent within ${state.overlap.rule.window_days} day; chance alone (the same test a few weeks off) gives about ${state.overlap.expected_by_chance}. So about ${Math.round(state.overlap.likely_double)} of ${state.overlap.comment_runs} Reddit runs look reported twice${state.overlap.likely_double < 0.1 * state.overlap.comment_runs ? ", too few to matter" : ""}.</p></div>` : ""}
<div class="panel"><h3>Independence</h3><p class="small">The form has no player ID. One player's 50 runs count as 50 independent runs, so intervals are somewhat narrower than they should be. ${pct(Object.entries(m.sources).filter(([k]) => !["Form", "Reddit comments", "DragonKind bot", "Reported on the Atlas"].includes(k)).reduce((s, [, n]) => s + n, 0) / r.n, 0)} of rows arrived as bulk imports, each probably one player's or one group's log.</p></div>
<div class="panel"><h3>What the form does not ask</h3><p class="small">The redesigned form asks how you reacted to the first dragon (answered in ${r.factors.reach_hour.rows.filter((x) => x.factor === "sighting_action" && !["Unknown", "(not asked)"].includes(x.level)).reduce((a, x) => a + x.n, 0)} rows; most riders answer "Unsure") and how the bully fight went (${r.factors.reach_hour.rows.filter((x) => x.factor === "combat_first" && x.level !== "(not recorded)").reduce((a, x) => a + x.n, 0)} rows). It still does not record most choices inside the bonding encounters. Theories that rely on those choices cannot be confirmed or refuted here.</p></div>`;
}
const sourceRate = (outKey, source) => state.res.source_rates[outKey][source];
+45 -101
View File
@@ -1,4 +1,4 @@
/* dragons.js — original dragon silhouettes for the valley map.
/* dragons.js — the dragon silhouettes of the valley map (traced from the pose reference sheet) and its cadets.
* Each pose is built from simple parts (tapered tubes, a scalloped wing membrane, a head with horns, spines,
* a spaded tail), so every dragon is drawn the same way but stands differently. Drawn facing right in a
* 200 x 160 box; flip with scale(-1, 1). Works in the browser (window.DragonArt) and in Node. */
@@ -124,112 +124,56 @@
/* ---------- poses ---------- */
const POSES = {
// seated and watchful, one wing raised, tail curled round the feet
sitting() {
const d = [];
d.push(...wing({ shoulder: [88, 74], wrist: [62, 18], tip: [24, 30], fingers: [[14, 66], [30, 98], [56, 116]], root: [76, 112], bow: 0.3 }));
d.push(ell(92, 104, 26, 36, -0.25));
d.push(tube([[90, 80], [96, 58], [110, 42], [116, 34]], 13, 7));
const t = tail([[76, 132], [56, 150], [110, 158], [168, 150]], 9);
d.push(...t.d);
d.push(...leg([84, 120], [70, 136], [86, 152], 12, 1));
d.push(...leg([102, 104], [110, 124], [114, 150], 7, 1));
const h = head({ at: [114, 34], ang: -0.05, size: 1.05 });
d.push(...h.d);
d.push(...spines(bez([[86, 84], [84, 62], [100, 44], [110, 36]], 10), 4, -1, 2));
d.push(...spines(t.pts.slice(0, 26), (u) => 4 * (1 - u), 1, 3));
return { d, eye: h.eye, eyeR: h.eyeR };
},
// low and stalking, head forward, wings folded
prowling() {
const d = [];
d.push(...wing({ shoulder: [92, 92], wrist: [70, 64], tip: [118, 52], fingers: [[136, 70], [130, 90]], root: [104, 100], bow: 0.25, bone: 3.4 }));
d.push(ell(96, 108, 38, 18, 0.05));
d.push(tube([[124, 104], [140, 98], [152, 92], [162, 94]], 11, 7));
const t = tail([[62, 108], [36, 106], [22, 128], [6, 120]], 11);
d.push(...t.d);
d.push(...leg([72, 112], [60, 128], [70, 146], 11));
d.push(...leg([84, 116], [94, 130], [92, 146], 8));
d.push(...leg([118, 112], [126, 128], [124, 146], 8));
d.push(...leg([128, 110], [140, 126], [146, 146], 7));
const h = head({ at: [160, 94], ang: 0.12, size: 1 });
d.push(...h.d);
d.push(...spines(bez([[66, 92], [90, 84], [130, 86], [156, 88]], 14), 3.6, -1, 2));
d.push(...spines(t.pts.slice(0, 26), (u) => 3.6 * (1 - u), -1, 3));
return { d, eye: h.eye, eyeR: h.eyeR };
},
// in flight, both wings spread
flying() {
const d = [];
d.push(...wing({ shoulder: [96, 84], wrist: [70, 36], tip: [40, 6], fingers: [[30, 40], [44, 66], [70, 80]], root: [92, 94], bow: 0.32 }));
d.push(...wing({ shoulder: [110, 84], wrist: [140, 30], tip: [190, 14], fingers: [[178, 52], [160, 76], [134, 90]], root: [114, 96], bow: 0.32 }));
d.push(ell(104, 96, 30, 13, 0.2));
d.push(tube([[128, 92], [142, 86], [150, 76], [158, 72]], 9, 6));
const t = tail([[78, 92], [54, 98], [40, 120], [12, 116]], 8);
d.push(...t.d);
d.push(...leg([94, 102], [96, 116], [108, 124], 6));
d.push(...leg([116, 102], [122, 114], [132, 118], 5));
const h = head({ at: [156, 72], ang: -0.2, size: 0.9, open: 2 });
d.push(...h.d);
return { d, eye: h.eye, eyeR: h.eyeR };
},
// reared up and roaring, wings half open
roaring() {
const d = [];
d.push(...wing({ shoulder: [94, 68], wrist: [52, 40], tip: [30, 2], fingers: [[16, 46], [34, 78], [66, 96]], root: [90, 98], bow: 0.3 }));
d.push(ell(98, 100, 22, 40, 0.2));
d.push(tube([[104, 70], [112, 50], [126, 34], [136, 24]], 13, 7));
const t = tail([[86, 136], [60, 156], [30, 150], [14, 132]], 10);
d.push(...t.d);
d.push(...leg([90, 124], [104, 138], [96, 154], 12));
d.push(...leg([108, 86], [124, 92], [132, 82], 6, 1));
d.push(...leg([102, 92], [116, 104], [126, 98], 6, 1));
const h = head({ at: [134, 24], ang: -0.55, size: 1.05, open: 7 });
d.push(...h.d);
d.push(...spines(bez([[94, 86], [100, 60], [116, 40], [130, 28]], 10), 4, -1, 2));
return { d, eye: h.eye, eyeR: h.eyeR };
},
// coiled, as if wrapped around something, head lifted
coiled() {
const d = [];
const t = tail([[100, 120], [30, 150], [20, 80], [80, 74]], 15);
d.push(...t.d);
d.push(tube([[100, 120], [150, 130], [170, 96], [140, 70]], 16, 12));
d.push(tube([[140, 70], [124, 52], [128, 34], [146, 26]], 12, 7));
d.push(...wing({ shoulder: [134, 76], wrist: [106, 36], tip: [72, 26], fingers: [[64, 52], [80, 70], [104, 82]], root: [124, 90], bow: 0.28, bone: 3.4 }));
d.push(...leg([150, 116], [164, 126], [170, 142], 8));
d.push(...leg([116, 124], [114, 138], [122, 150], 8));
const h = head({ at: [144, 26], ang: 0.1, size: 1 });
d.push(...h.d);
d.push(...spines(t.pts, (u) => 3.5 * (1 - u * 0.7), -1, 3));
return { d, eye: h.eye, eyeR: h.eyeR };
},
// lying down at rest, head up
resting() {
const d = [];
d.push(...wing({ shoulder: [90, 108], wrist: [66, 84], tip: [112, 70], fingers: [[134, 88], [124, 108]], root: [100, 118], bow: 0.25, bone: 3.2 }));
d.push(ell(92, 126, 42, 18, 0));
d.push(tube([[124, 120], [140, 112], [146, 92], [158, 82]], 12, 7));
const t = tail([[54, 130], [24, 140], [20, 152], [70, 152]], 11);
d.push(...t.d);
d.push(...leg([120, 132], [132, 142], [150, 146], 8));
d.push(...leg([70, 134], [82, 144], [96, 148], 10));
const h = head({ at: [156, 84], ang: 0.05, size: 1 });
d.push(...h.d);
d.push(...spines(bez([[60, 112], [90, 104], [130, 106], [152, 88]], 14), 3.4, -1, 2));
return { d, eye: h.eye, eyeR: h.eyeR };
},
/* Six silhouettes traced from the project's pose reference sheet (all facing right, in the 200 x 160 box;
* flying and diving poses centred, the others standing on the bottom edge), each with the sheet's interior lines
* (wing ribs, folds, the rock's edges) drawn over the colour, for depth; gaps the sheet leaves open (between the
* perched dragon's legs and the rock, under the sleeping one's wing) are holes. Names keep the old
* pose keys: coiled is the diving dragon, resting the sleeping one, sitting the one perched on a rock. */
const TRACED = {
"flying": {
"body": "M6.0 55.5 L6.0 56.9 L6.7 56.9 L7.4 55.5 L10.0 53.1 L14.0 51.5 L16.8 51.0 L22.3 51.3 L28.4 52.7 L31.2 54.1 L32.9 55.7 L34.0 59.5 L33.8 62.3 L31.0 68.0 L30.7 69.9 L31.4 69.9 L32.9 67.7 L36.2 65.4 L41.1 63.7 L48.2 63.7 L56.2 65.9 L60.9 68.7 L63.2 71.0 L64.7 74.1 L64.4 76.5 L63.5 78.8 L61.6 81.2 L61.6 81.9 L62.5 81.9 L65.6 79.5 L68.7 77.9 L73.6 76.5 L77.9 76.5 L80.9 77.4 L83.7 79.3 L84.0 80.7 L84.7 80.7 L87.0 79.1 L89.9 78.4 L94.3 78.4 L96.2 79.1 L95.8 80.2 L93.2 82.6 L89.2 83.3 L89.2 83.8 L89.9 84.2 L89.4 84.7 L84.5 85.4 L84.5 85.9 L84.9 85.9 L85.4 86.4 L80.9 87.3 L80.7 88.0 L81.9 88.2 L81.4 88.7 L78.1 89.0 L77.1 89.4 L76.9 90.4 L73.8 90.6 L73.8 91.8 L68.7 92.0 L68.7 92.7 L69.6 93.0 L69.4 93.4 L66.1 93.4 L65.8 94.1 L62.3 93.9 L62.1 95.1 L58.8 94.8 L58.5 96.0 L55.2 95.5 L54.8 96.5 L51.0 96.5 L50.8 97.4 L45.8 97.4 L45.3 97.7 L45.8 98.6 L40.4 99.8 L39.5 101.0 L35.0 102.6 L34.5 103.1 L35.0 104.0 L32.4 106.2 L30.0 110.6 L30.0 113.5 L31.2 117.5 L31.0 120.1 L31.9 120.1 L32.6 118.4 L33.8 112.5 L34.3 112.3 L34.7 112.7 L35.7 112.7 L35.2 110.6 L35.2 108.0 L35.7 107.1 L38.0 105.0 L41.6 103.1 L46.3 101.7 L52.6 100.5 L62.5 99.6 L70.1 98.4 L77.9 96.5 L84.5 94.4 L84.7 94.6 L82.8 96.3 L81.6 96.5 L80.7 98.4 L80.7 99.3 L81.6 100.5 L83.5 100.7 L86.1 99.3 L92.5 92.7 L93.6 92.3 L97.4 92.0 L100.9 90.1 L100.9 91.1 L96.2 94.1 L94.3 94.1 L91.0 98.4 L88.9 100.0 L88.0 100.0 L87.5 100.5 L87.5 102.9 L88.5 103.6 L90.6 103.6 L93.2 101.7 L96.5 97.4 L99.1 96.5 L102.8 96.3 L105.2 95.3 L108.2 92.5 L109.4 90.6 L109.9 89.0 L110.6 88.2 L113.7 87.3 L117.7 84.7 L122.4 85.4 L124.5 86.1 L126.9 87.5 L128.3 89.9 L127.1 93.4 L128.3 93.2 L130.6 91.1 L134.9 88.5 L139.6 86.6 L144.5 86.4 L147.6 87.3 L149.5 88.5 L152.3 91.5 L153.5 94.8 L153.5 97.4 L153.9 97.4 L156.5 92.7 L159.4 90.1 L162.0 88.7 L167.4 87.3 L173.5 87.5 L182.9 90.4 L186.9 92.5 L189.1 94.1 L191.6 97.2 L192.6 99.3 L192.6 101.9 L193.1 101.9 L193.8 100.7 L193.8 97.2 L190.9 90.6 L188.6 86.8 L183.2 80.2 L181.0 78.1 L169.7 72.5 L163.8 70.3 L158.4 68.9 L158.0 68.2 L159.1 67.0 L161.0 66.3 L160.8 65.6 L158.2 65.9 L156.3 66.8 L153.7 69.2 L150.4 71.3 L141.7 74.8 L136.5 75.3 L132.0 76.5 L122.6 76.2 L122.4 75.8 L124.7 73.4 L126.9 72.0 L129.2 71.0 L130.6 71.0 L130.9 71.8 L131.8 72.0 L135.1 71.5 L135.8 72.2 L136.5 72.2 L137.0 71.0 L138.2 71.0 L139.3 71.5 L139.6 72.2 L140.8 72.2 L141.9 71.3 L142.2 69.4 L141.2 68.0 L139.1 67.5 L137.5 65.9 L136.3 65.4 L134.6 64.0 L127.3 61.2 L124.7 59.5 L123.8 59.5 L123.8 60.0 L127.1 64.2 L126.9 64.7 L124.7 64.2 L124.7 65.4 L121.0 65.2 L118.8 65.6 L118.8 66.1 L121.2 66.1 L121.4 66.6 L121.0 67.0 L118.1 67.0 L115.8 67.7 L115.8 68.2 L117.4 68.2 L117.7 68.7 L117.2 69.2 L113.2 69.4 L113.0 70.3 L111.3 70.6 L111.1 71.0 L106.4 69.2 L98.4 64.9 L95.8 64.0 L93.9 62.3 L92.5 59.5 L91.3 55.5 L90.8 49.8 L89.4 47.5 L88.0 46.1 L85.9 44.9 L85.2 44.9 L85.2 45.6 L87.3 47.7 L88.0 49.4 L87.7 50.6 L74.6 45.8 L63.2 42.8 L58.1 40.9 L55.9 39.7 L53.1 39.7 L52.9 40.2 L43.9 40.9 L32.2 42.8 L18.3 46.8 L9.3 51.3 L7.2 53.4 Z",
"lines": "M37.8 102.4 L36.9 102.4 L35.9 102.9 L35.4 104.5 L35.9 104.5 L37.6 103.3 Z M40.2 101.2 L42.5 100.7 L42.5 100.3 L40.9 100.3 L40.2 100.7 Z M46.3 99.3 L48.9 98.8 L48.9 98.1 L46.5 97.9 Z M193.1 97.7 L193.1 100.3 L193.5 100.3 L193.5 97.7 Z M81.6 97.7 L81.6 98.8 L82.3 98.8 L83.0 98.4 L83.0 97.9 Z M51.5 97.4 L51.5 97.9 L53.4 97.9 L53.4 97.2 L52.9 97.0 L51.9 97.0 Z M55.5 97.2 L57.1 97.0 L57.1 96.3 L55.7 96.0 Z M59.2 96.5 L60.9 96.3 L60.9 95.5 L59.5 95.3 Z M62.8 94.4 L62.8 95.8 L64.7 95.3 L64.7 94.8 Z M88.0 92.5 L84.7 93.4 L84.7 93.9 L85.6 94.1 L85.2 94.4 L85.2 95.1 L86.6 94.6 L88.0 93.2 Z M70.1 92.5 L70.1 93.7 L71.0 93.7 L71.7 93.2 L71.7 92.7 L71.3 92.5 Z M74.6 91.1 L74.6 92.3 L76.2 91.8 L76.2 91.1 Z M80.0 89.4 L77.9 89.7 L77.6 90.8 L80.0 90.1 Z M102.6 88.7 L101.6 88.7 L100.9 89.2 L100.9 89.7 L101.6 89.9 L101.6 90.8 L102.1 90.8 Z M82.3 89.0 L83.7 88.5 L84.0 87.8 L82.6 87.5 Z M85.9 85.7 L85.9 87.1 L87.5 86.4 L87.5 85.7 Z M90.3 83.8 L90.3 84.9 L91.8 84.5 L91.8 83.8 Z M110.8 71.5 L110.8 72.0 L111.5 72.2 L113.2 72.0 L113.0 71.0 L111.8 71.0 L111.5 71.5 Z M130.9 70.1 L131.3 71.3 L132.7 71.0 L132.7 70.6 Z M113.7 71.0 L115.1 71.3 L116.3 70.6 L116.3 69.9 L114.6 69.6 L114.6 70.1 L115.1 70.3 L113.7 70.6 Z M118.1 67.7 L118.1 69.2 L118.8 69.2 L119.6 68.7 L119.3 68.0 Z M121.9 65.6 L121.9 67.0 L123.8 66.8 L123.8 66.1 Z M125.9 61.4 L125.9 61.9 L127.8 63.7 L127.1 65.6 L125.7 64.9 L125.4 66.1 L127.1 66.1 L127.3 65.6 L129.4 65.9 L129.7 64.9 L130.4 65.4 L132.7 65.6 L132.5 64.5 L131.3 63.5 L127.3 61.6 Z M128.7 63.5 L129.2 63.3 L131.1 64.5 L130.6 64.7 Z M53.6 39.7 L53.6 40.7 L55.5 40.4 L55.2 39.7 Z"
},
"prowling": {
"body": "M193.7 72.8 L191.0 69.2 L189.0 69.8 L187.0 68.8 L185.3 66.8 L182.0 64.5 L180.0 64.5 L174.7 61.5 L170.7 57.5 L170.0 57.8 L170.0 58.8 L173.0 63.2 L172.7 64.2 L168.0 62.2 L164.7 59.8 L163.1 57.5 L162.1 57.5 L162.1 59.5 L163.4 61.8 L167.7 66.2 L166.7 66.8 L159.7 66.8 L159.7 67.8 L162.1 68.2 L162.4 68.8 L157.1 70.1 L155.4 71.1 L155.4 72.1 L158.7 71.8 L159.1 72.5 L155.1 74.8 L152.7 77.1 L153.1 78.1 L156.1 76.8 L156.4 77.1 L153.4 81.5 L152.7 84.8 L153.7 84.8 L155.7 82.5 L156.4 82.8 L155.4 85.1 L155.1 89.4 L156.1 89.8 L157.4 87.5 L158.1 87.8 L157.7 91.8 L157.1 92.1 L151.1 89.4 L150.1 89.4 L150.1 90.1 L149.4 90.4 L145.1 88.8 L144.1 89.1 L144.1 89.8 L144.8 90.1 L144.4 90.8 L136.1 86.5 L131.8 81.8 L130.1 78.1 L130.1 75.5 L132.4 71.1 L135.1 68.5 L137.8 69.2 L139.8 70.8 L139.8 71.5 L140.8 71.5 L140.8 69.2 L138.1 66.5 L124.8 61.2 L117.1 59.5 L113.1 59.5 L113.5 60.5 L116.8 61.2 L117.5 61.8 L95.5 62.2 L82.9 64.2 L74.2 66.8 L62.6 71.5 L53.2 76.1 L42.6 82.8 L29.3 93.1 L22.3 100.1 L19.0 104.4 L18.0 108.4 L19.0 108.4 L20.6 106.1 L24.6 102.4 L31.3 98.1 L39.6 94.4 L49.6 91.8 L53.2 91.8 L54.2 93.1 L54.2 94.4 L52.6 98.8 L47.6 105.8 L46.3 109.1 L47.3 109.1 L52.6 104.4 L58.2 101.1 L64.9 98.4 L70.2 97.4 L77.9 97.8 L83.9 100.1 L87.5 103.8 L89.5 108.7 L89.2 114.7 L90.2 114.7 L91.8 111.4 L95.2 108.1 L98.2 106.1 L101.5 104.8 L108.2 104.1 L113.1 105.4 L113.8 106.8 L109.5 108.4 L109.2 109.7 L107.5 109.7 L105.2 110.7 L105.2 111.4 L107.2 111.4 L107.2 112.4 L100.2 114.1 L99.8 115.1 L101.8 115.7 L101.2 116.4 L94.8 117.7 L94.5 118.7 L96.5 118.7 L96.5 119.7 L89.2 120.4 L89.5 121.4 L91.2 122.1 L90.5 122.7 L83.9 121.7 L83.5 122.7 L85.2 124.1 L84.9 124.4 L83.2 124.4 L78.2 122.7 L78.2 123.7 L79.2 124.7 L78.5 125.4 L74.5 123.1 L73.5 123.1 L74.2 125.1 L72.9 125.4 L69.2 122.7 L67.9 122.7 L68.9 124.7 L68.2 125.4 L63.9 122.4 L62.9 122.4 L62.9 124.7 L57.9 121.4 L57.2 121.4 L57.2 122.4 L57.9 123.1 L56.6 123.4 L51.6 120.1 L50.3 120.1 L50.6 121.7 L49.9 122.1 L43.6 119.4 L41.9 119.4 L41.9 121.1 L36.9 119.7 L33.3 119.7 L34.0 121.1 L33.6 121.4 L28.0 121.1 L27.6 122.4 L22.0 122.7 L22.0 124.1 L21.3 124.7 L19.0 124.7 L14.7 126.4 L14.7 127.4 L15.3 127.7 L15.0 128.4 L11.0 130.0 L6.0 134.4 L6.0 135.7 L8.3 134.4 L8.7 134.7 L7.0 137.7 L6.7 142.7 L7.7 143.0 L9.0 147.3 L12.0 151.0 L13.7 151.3 L13.0 149.7 L14.0 149.3 L19.3 153.7 L21.3 153.7 L21.6 152.7 L24.0 153.7 L27.0 153.7 L27.6 151.7 L29.6 151.3 L35.9 148.3 L38.9 146.0 L38.9 145.0 L36.9 145.3 L32.0 147.7 L27.6 148.7 L24.3 148.7 L24.0 148.0 L25.0 146.3 L21.6 147.0 L17.6 146.7 L15.6 145.7 L14.0 144.0 L13.0 142.0 L13.0 139.0 L14.7 136.0 L19.3 132.0 L25.6 129.0 L34.9 127.0 L43.3 127.0 L52.3 128.7 L67.6 132.7 L81.5 133.4 L89.2 132.4 L94.2 131.0 L105.2 127.0 L116.5 122.1 L116.5 124.1 L114.1 124.4 L109.8 128.0 L105.8 129.4 L102.2 140.0 L101.2 141.4 L100.2 141.4 L98.5 142.7 L97.8 144.0 L98.2 145.7 L99.8 144.7 L102.2 144.7 L103.5 145.7 L107.2 145.7 L109.2 145.0 L112.1 145.7 L112.5 144.7 L113.5 144.7 L114.8 146.3 L115.8 146.3 L116.1 144.0 L115.1 142.0 L113.5 140.4 L109.2 140.0 L108.5 139.4 L109.5 136.4 L111.5 134.0 L123.1 131.4 L125.1 130.4 L128.8 126.7 L129.1 127.0 L128.1 128.7 L123.5 132.7 L123.8 135.4 L129.8 141.7 L128.1 143.4 L127.8 145.3 L129.8 145.0 L134.4 146.0 L139.1 145.7 L139.8 146.3 L141.8 145.7 L142.4 147.3 L143.4 147.3 L143.8 144.0 L140.8 141.0 L137.4 141.0 L135.4 140.0 L132.1 136.0 L131.8 134.4 L138.1 130.7 L140.1 128.7 L143.4 122.1 L147.7 122.1 L148.1 122.7 L147.4 124.1 L148.4 125.1 L148.1 127.0 L153.4 135.7 L155.1 140.4 L154.7 143.0 L151.7 145.7 L151.4 148.0 L156.7 147.0 L159.4 148.3 L162.7 148.0 L164.1 149.0 L164.1 149.7 L165.4 149.7 L165.7 147.0 L167.4 147.0 L168.4 148.3 L169.4 148.3 L169.7 146.7 L169.0 144.7 L167.7 143.0 L166.4 142.4 L162.4 142.0 L160.7 140.0 L159.7 137.7 L157.7 125.1 L161.4 121.7 L161.7 124.4 L160.7 126.4 L160.7 127.7 L161.7 128.0 L161.7 130.0 L162.7 130.7 L163.7 132.7 L170.0 140.7 L171.4 143.7 L171.0 147.3 L174.4 146.7 L175.0 147.3 L178.7 147.3 L179.7 148.3 L180.7 148.3 L181.4 147.0 L183.0 147.7 L183.0 147.0 L183.7 146.7 L184.4 148.0 L185.3 148.0 L185.3 145.3 L183.4 142.7 L182.0 142.0 L178.0 142.0 L175.4 139.7 L172.7 134.7 L169.7 125.4 L171.0 122.1 L174.0 117.4 L174.4 113.7 L175.0 113.1 L176.0 113.1 L178.4 108.7 L178.7 105.4 L179.0 105.1 L179.7 106.4 L180.7 106.4 L181.0 101.4 L179.7 99.1 L180.0 98.4 L181.0 98.4 L181.0 96.8 L179.0 93.8 L179.0 91.8 L176.7 89.4 L176.7 87.8 L173.4 84.8 L174.0 84.1 L174.0 83.1 L173.0 82.1 L173.0 78.1 L174.0 77.5 L174.7 79.1 L176.7 79.5 L179.7 78.1 L182.7 77.8 L185.3 78.5 L188.0 80.1 L189.0 80.1 L189.3 80.8 L190.7 80.8 L191.3 77.1 L193.0 77.1 L193.7 76.5 Z",
"lines": "M24.0 151.3 L24.0 152.0 L24.6 152.3 L24.6 153.3 L26.3 153.3 L26.6 151.3 Z M19.3 151.0 L19.0 152.0 L20.0 152.7 L20.0 153.7 L20.6 153.7 L21.0 151.3 Z M21.0 148.3 L21.0 149.0 L21.6 149.3 L23.3 149.3 L23.3 147.7 L22.0 147.7 Z M11.3 146.7 L11.7 149.3 L12.3 149.3 L12.7 148.7 L14.0 148.7 L14.0 148.0 Z M8.7 139.0 L8.0 139.0 L7.3 140.4 L7.3 142.0 L8.7 142.0 L9.0 140.0 Z M11.7 132.0 L10.7 132.0 L8.7 133.0 L8.7 133.7 L9.7 134.0 L9.3 135.0 L10.0 135.0 L11.7 133.0 Z M19.0 126.4 L16.3 126.7 L16.0 128.4 L18.3 127.7 Z M79.9 124.4 L79.9 126.0 L81.5 126.0 L81.5 125.4 L80.5 124.4 Z M63.9 124.1 L63.9 125.7 L65.2 126.0 L65.6 125.7 L65.2 124.4 Z M85.9 123.4 L85.9 125.1 L87.5 124.7 L86.9 123.4 Z M57.6 124.1 L57.6 124.7 L58.9 125.1 L59.9 124.7 L59.2 123.4 Z M22.6 125.1 L25.3 124.4 L25.3 123.7 L23.0 123.4 Z M28.6 121.7 L28.6 123.4 L31.0 123.1 L31.0 122.1 Z M132.1 121.4 L131.4 121.4 L128.1 125.4 L128.1 126.0 L129.4 125.7 L129.8 126.7 L130.8 126.4 L130.8 124.4 L132.1 122.4 Z M91.8 121.4 L91.8 123.1 L93.5 122.4 L93.5 121.4 Z M51.3 121.4 L51.3 123.1 L52.9 123.4 L52.9 122.4 L52.3 121.4 Z M42.9 120.4 L42.9 122.1 L44.9 122.1 L44.6 120.7 Z M34.6 120.4 L34.6 122.1 L37.3 122.1 L37.3 121.1 L35.9 120.4 Z M97.5 118.4 L97.5 120.1 L99.2 119.4 L99.2 118.4 Z M153.7 115.1 L153.1 115.1 L152.1 116.1 L150.4 119.7 L148.7 121.1 L148.7 123.1 L149.4 123.1 L150.4 122.1 L152.4 117.7 L153.7 116.1 Z M102.5 114.4 L102.5 116.4 L103.5 116.4 L104.8 115.4 L104.8 114.7 L104.2 114.4 Z M108.2 110.7 L108.2 112.4 L109.8 112.1 L109.8 111.1 Z M176.0 110.1 L175.0 110.1 L174.4 112.4 L175.4 112.4 Z M114.1 108.4 L112.8 108.1 L111.5 108.7 L110.8 109.7 L110.1 109.7 L110.1 110.4 L113.1 110.1 L114.1 109.1 Z M176.7 106.1 L176.7 108.7 L177.4 108.7 L177.7 106.1 Z M177.7 101.8 L178.0 104.4 L180.0 104.4 L179.7 102.8 L178.7 101.8 Z M136.1 100.1 L132.1 100.1 L124.8 101.4 L123.1 103.1 L119.8 103.4 L119.1 104.8 L115.5 105.8 L114.5 105.4 L114.5 107.7 L115.5 108.1 L118.1 107.4 L118.5 106.4 L120.8 106.1 L122.8 105.1 L123.5 103.8 L127.8 103.4 L129.1 102.8 L128.8 101.8 L129.1 101.4 L133.1 101.8 L134.4 101.1 L136.1 101.1 Z M177.7 96.1 L178.4 98.8 L179.0 98.8 L179.0 98.1 L180.0 97.8 L180.0 97.1 L178.7 96.1 Z M176.0 91.1 L176.0 92.1 L177.7 94.1 L178.4 94.1 L178.4 92.8 L177.4 91.4 Z M149.7 91.1 L149.7 91.8 L152.7 93.4 L153.7 93.1 L153.7 92.4 L152.1 90.8 L151.4 90.8 L151.1 91.4 Z M145.8 90.1 L146.1 91.1 L145.1 91.4 L145.1 92.1 L147.4 93.1 L149.1 93.1 L149.1 92.4 L146.8 90.1 Z M154.7 92.1 L154.7 92.8 L157.1 94.4 L158.1 94.4 L158.7 93.8 L160.4 95.1 L161.1 95.1 L161.7 94.1 L161.7 92.1 L160.7 91.4 L160.4 89.4 L159.4 89.4 L158.4 90.4 L158.4 91.4 L159.4 91.1 L160.1 92.4 L159.4 93.1 L158.1 92.8 L157.7 93.4 Z M173.7 87.1 L173.7 88.1 L175.4 89.8 L176.0 89.8 L176.0 88.8 L174.7 87.1 Z M171.4 79.5 L171.4 81.8 L172.4 82.1 L172.0 79.5 Z M174.4 76.1 L175.4 78.5 L176.7 78.5 L177.4 77.8 L177.4 77.1 L176.4 77.1 L175.7 76.1 Z M184.0 73.8 L184.7 75.1 L188.3 76.8 L189.3 76.8 L190.0 77.5 L190.7 77.5 L191.0 76.1 L192.0 76.1 L191.7 75.1 L190.0 75.1 L189.0 74.5 L186.0 73.8 Z M192.7 73.5 L192.7 75.8 L193.7 75.8 L193.7 73.5 Z M161.1 71.1 L159.7 71.1 L159.7 73.1 L161.1 72.5 Z M163.1 67.8 L163.1 70.1 L165.4 69.5 L165.4 68.5 Z M128.8 67.8 L127.1 67.8 L120.8 70.8 L111.8 77.8 L104.2 86.1 L99.2 93.1 L97.8 96.4 L98.5 96.4 L105.5 86.5 L114.5 77.1 L121.5 71.8 L125.8 69.5 L128.8 68.5 Z M127.5 65.8 L121.1 66.2 L112.8 67.8 L101.8 71.1 L95.2 73.8 L87.2 77.8 L79.5 82.5 L68.2 90.8 L67.6 92.1 L68.2 92.1 L82.9 81.8 L94.5 75.5 L108.5 70.1 L119.5 67.5 L127.5 66.5 Z M180.0 65.2 L180.0 65.8 L181.0 66.5 L182.7 66.8 L182.7 66.2 L181.4 65.2 Z M166.7 67.5 L166.7 68.2 L167.7 68.5 L169.4 68.2 L169.7 67.5 L172.7 68.2 L172.7 67.2 L169.0 65.2 L168.4 65.2 L168.7 67.2 Z M173.7 63.2 L174.0 64.2 L173.7 65.5 L176.7 66.2 L176.7 65.2 L174.7 63.2 Z M118.1 60.8 L118.5 61.8 L118.1 63.2 L124.5 63.8 L124.5 62.8 L119.5 60.8 Z"
},
"roaring": {
"body": "M8.5 59.6 L6.0 63.9 L6.0 66.1 L7.1 66.1 L8.5 63.6 L14.9 57.5 L24.6 51.8 L27.4 51.1 L32.8 51.4 L36.4 53.2 L38.5 55.4 L40.7 60.4 L40.7 66.4 L38.2 76.1 L36.0 81.4 L34.6 90.4 L36.0 90.4 L36.4 88.2 L38.9 83.9 L46.7 76.1 L56.0 69.7 L62.8 66.8 L66.4 67.1 L68.2 68.9 L68.5 70.4 L68.2 73.9 L63.9 85.0 L63.2 88.6 L64.3 88.6 L67.5 84.7 L71.4 82.2 L75.0 81.1 L79.3 81.8 L83.6 85.4 L85.0 87.9 L86.8 94.0 L87.1 100.4 L88.2 100.0 L90.0 96.1 L93.6 92.2 L96.4 90.0 L101.1 87.9 L106.1 86.8 L111.1 87.5 L112.9 88.6 L113.2 91.5 L120.7 87.9 L121.4 88.2 L120.4 89.7 L117.2 90.7 L116.1 92.5 L111.1 94.3 L108.9 95.7 L108.9 96.5 L112.5 96.5 L106.4 99.7 L106.4 100.7 L108.9 101.1 L103.6 104.3 L103.6 105.4 L105.4 105.0 L105.7 106.1 L102.1 108.3 L100.7 110.0 L100.7 111.1 L102.5 110.8 L102.9 111.5 L97.1 114.3 L97.1 115.0 L98.9 115.4 L98.6 116.1 L92.1 117.2 L92.1 118.3 L93.9 119.0 L92.9 120.0 L86.4 119.0 L86.1 120.0 L87.8 121.5 L86.4 121.8 L81.8 119.3 L80.3 119.3 L80.3 120.4 L81.4 121.5 L81.1 122.2 L75.0 117.9 L73.9 117.9 L75.3 120.4 L75.0 121.1 L67.1 116.8 L66.0 117.2 L66.0 117.9 L66.8 118.3 L66.4 119.0 L61.4 117.2 L55.3 117.2 L55.0 118.6 L49.6 119.0 L43.5 120.8 L36.4 125.0 L33.2 129.3 L33.2 130.4 L33.9 130.8 L32.8 134.3 L33.5 140.4 L34.6 140.4 L35.0 139.0 L37.1 143.3 L41.0 147.6 L44.2 149.7 L48.5 151.5 L50.7 151.5 L51.0 150.1 L54.6 150.4 L58.9 149.7 L60.7 149.0 L60.7 147.9 L53.9 147.9 L50.0 146.9 L47.8 145.4 L48.5 144.7 L48.2 143.3 L42.8 141.8 L40.0 139.0 L38.5 135.1 L38.9 132.2 L41.4 128.3 L46.7 125.0 L54.6 123.6 L59.6 124.0 L67.5 126.1 L80.0 131.1 L86.1 132.2 L90.3 132.2 L96.4 131.1 L101.8 129.3 L113.9 121.8 L117.2 124.3 L117.2 125.8 L115.4 129.3 L112.5 132.6 L112.5 135.1 L118.2 140.4 L118.6 141.8 L117.9 144.3 L121.8 144.3 L123.6 146.5 L122.9 149.0 L123.2 150.8 L124.7 150.8 L127.5 149.4 L131.1 150.4 L134.3 149.7 L135.7 151.1 L136.1 153.6 L137.5 153.6 L138.2 151.9 L138.2 148.3 L139.3 148.3 L141.1 151.1 L142.2 151.1 L142.5 150.4 L142.2 147.2 L140.4 144.7 L136.8 142.9 L131.8 143.3 L129.0 142.2 L122.9 136.5 L121.4 134.0 L128.2 127.9 L130.0 123.6 L131.1 123.3 L133.6 120.4 L140.0 115.0 L140.7 113.3 L140.7 110.8 L138.2 105.0 L144.7 101.1 L146.1 101.8 L147.2 104.7 L148.3 105.7 L152.2 105.7 L158.6 104.0 L162.2 103.6 L165.4 106.1 L165.4 109.3 L164.3 110.0 L164.7 111.5 L167.2 111.5 L169.0 109.7 L169.7 109.7 L170.8 111.8 L170.1 114.7 L171.8 114.7 L172.9 114.0 L174.3 111.1 L175.1 111.8 L175.1 114.7 L175.8 114.7 L177.6 112.5 L177.6 110.0 L176.8 107.9 L174.7 105.4 L165.8 99.0 L154.7 97.2 L154.3 96.5 L158.3 91.8 L160.4 91.8 L162.9 92.9 L166.1 92.5 L169.7 89.0 L173.6 82.5 L176.5 79.3 L181.8 77.5 L184.3 77.5 L185.8 79.7 L185.1 81.8 L187.2 81.8 L188.3 81.1 L189.4 78.9 L190.4 79.7 L190.4 81.1 L191.9 81.1 L192.6 79.3 L192.2 77.2 L190.1 74.3 L190.8 73.9 L192.6 75.7 L193.6 75.7 L193.6 73.2 L191.9 71.1 L190.1 70.4 L184.0 70.0 L178.6 72.9 L172.6 74.3 L168.3 78.9 L163.3 82.2 L161.8 81.4 L161.8 77.2 L160.0 71.8 L153.3 63.2 L152.9 58.2 L154.0 57.5 L154.3 54.3 L156.1 53.9 L157.2 51.8 L159.7 49.6 L160.8 50.0 L160.4 52.1 L161.1 52.1 L162.9 50.3 L164.7 50.7 L166.5 50.0 L169.0 50.0 L173.3 51.4 L175.1 52.9 L175.1 53.9 L175.8 54.3 L179.0 53.9 L180.4 52.1 L180.1 50.0 L179.3 48.9 L177.6 48.9 L177.2 47.5 L175.8 47.5 L173.6 45.7 L173.3 42.5 L175.1 41.1 L179.3 40.3 L181.1 40.7 L181.5 39.6 L182.6 39.6 L183.3 38.9 L183.3 36.1 L181.8 34.6 L177.9 33.9 L174.7 35.0 L171.8 35.0 L170.8 34.3 L166.8 33.9 L162.2 31.0 L161.1 31.0 L161.5 32.8 L162.9 34.3 L162.5 35.0 L158.6 33.2 L155.8 30.3 L154.7 30.3 L154.7 31.4 L156.1 33.6 L155.8 34.3 L151.5 34.3 L148.6 35.7 L148.6 37.5 L144.7 37.8 L140.7 39.3 L140.4 40.3 L146.8 40.3 L146.1 41.1 L138.6 43.2 L135.4 45.3 L135.4 46.4 L139.0 45.3 L140.7 45.7 L134.7 49.3 L131.8 52.1 L131.8 52.9 L133.2 52.9 L136.5 51.1 L136.8 51.4 L132.2 56.8 L130.7 59.6 L130.7 60.7 L131.8 60.7 L134.0 58.2 L134.7 58.6 L131.8 63.9 L131.8 66.1 L132.5 66.1 L134.0 64.3 L134.7 64.6 L134.3 67.9 L133.2 68.2 L127.9 66.1 L126.8 66.1 L126.8 67.5 L125.7 67.9 L121.4 65.4 L113.2 57.9 L116.1 47.8 L122.2 36.1 L122.5 30.7 L121.1 27.1 L116.1 21.8 L115.4 21.8 L115.4 23.5 L118.6 28.2 L118.6 30.0 L108.9 25.0 L97.5 21.4 L90.7 18.5 L85.7 18.9 L85.7 20.0 L90.7 21.4 L91.1 22.1 L90.3 22.8 L77.1 24.3 L64.6 26.4 L56.4 28.5 L44.6 32.8 L36.4 37.1 L23.2 45.7 L14.6 52.9 Z M149.0 37.1 L149.7 36.4 L153.6 36.4 L156.1 37.5 L152.2 37.8 Z",
"lines": "M46.4 148.3 L46.4 149.0 L47.5 150.1 L50.0 150.8 L50.0 149.0 Z M45.0 144.3 L45.0 145.1 L46.0 146.1 L47.1 146.1 L47.1 144.3 Z M34.6 134.7 L33.9 136.5 L33.9 138.3 L35.7 138.3 L35.7 135.8 L35.3 134.7 Z M37.1 127.2 L36.0 127.2 L34.6 128.6 L34.6 131.1 L35.3 131.1 Z M88.6 120.8 L88.6 122.5 L90.3 122.2 L89.6 120.8 Z M76.1 120.4 L76.1 122.2 L77.5 122.5 L77.1 120.8 Z M67.5 118.3 L67.5 120.0 L70.0 120.8 L70.0 119.7 L68.9 118.6 Z M94.6 117.9 L94.6 120.0 L95.7 120.0 L97.1 119.0 L97.1 118.3 Z M56.0 118.6 L56.0 119.3 L61.0 119.3 L61.0 118.6 L59.6 117.9 L57.8 117.9 L57.5 118.6 Z M101.4 114.3 L99.6 114.3 L99.6 116.1 L100.4 116.1 L101.4 115.0 Z M131.5 112.2 L130.7 112.2 L130.0 113.3 L129.3 122.5 L130.4 122.5 L131.1 121.5 Z M106.1 107.9 L102.9 109.0 L103.6 111.5 L105.0 110.8 L106.1 109.0 Z M108.6 104.0 L107.9 103.6 L106.4 104.0 L106.4 104.7 L107.1 105.0 L106.4 106.5 L107.1 106.5 L108.6 105.0 Z M111.8 99.3 L109.3 99.3 L109.7 101.8 L110.4 101.8 L111.8 100.4 Z M144.7 96.8 L145.0 98.6 L144.7 100.4 L146.5 100.4 L146.1 98.2 L145.4 96.8 Z M115.4 95.0 L113.2 95.0 L113.6 96.1 L113.2 97.2 L113.9 97.2 L115.4 95.7 Z M119.7 91.1 L117.9 91.5 L117.2 92.9 L118.9 92.5 Z M125.7 86.1 L121.8 86.4 L122.2 89.0 L123.2 89.0 L125.7 86.8 Z M127.5 67.1 L127.2 69.3 L130.7 69.7 L130.7 68.9 L129.3 67.5 Z M136.1 65.7 L135.0 67.1 L135.0 68.2 L136.1 67.9 L136.5 68.6 L133.6 68.9 L133.6 69.7 L135.0 69.7 L137.5 70.7 L136.8 65.7 Z M136.1 61.8 L134.7 61.8 L133.6 62.9 L133.6 63.6 L135.7 63.6 Z M151.5 59.3 L151.5 61.4 L151.8 62.1 L152.5 62.1 L152.2 59.3 Z M135.4 56.1 L134.3 56.8 L134.3 57.5 L135.0 57.5 L135.4 58.6 L136.1 58.6 L136.5 56.1 Z M152.9 55.4 L151.8 55.4 L151.5 57.9 L152.9 57.1 Z M156.5 50.7 L155.8 50.7 L154.0 52.5 L154.0 53.2 L155.8 52.9 Z M139.3 49.6 L137.5 49.6 L137.5 51.8 L138.2 51.8 L139.3 50.7 Z M160.0 48.2 L160.0 48.9 L161.5 49.3 L162.5 48.9 L162.9 49.6 L165.0 49.6 L165.0 48.6 L162.9 48.9 L162.5 47.8 Z M144.3 43.6 L140.7 43.9 L140.7 44.6 L141.5 45.0 L141.5 46.1 L142.5 46.1 L144.3 44.6 Z M147.5 39.3 L147.9 40.3 L147.5 41.4 L151.1 40.7 L150.8 39.6 Z M182.2 37.8 L180.8 37.8 L180.4 38.9 L179.0 38.6 L178.6 39.6 L180.4 39.6 L180.8 38.9 L181.8 38.9 Z M105.7 37.8 L103.9 38.2 L100.0 40.3 L90.3 47.1 L80.7 56.4 L77.1 60.7 L76.8 62.1 L77.5 62.1 L81.1 57.9 L90.3 48.9 L95.7 44.6 L105.7 38.6 Z M156.8 36.4 L156.8 38.6 L159.7 38.2 L159.3 37.1 Z M163.6 33.9 L163.6 36.4 L165.4 36.4 L165.8 35.0 Z M156.8 34.3 L157.2 35.3 L159.3 35.3 L159.3 34.6 L158.3 33.9 Z M86.8 18.5 L86.8 19.3 L90.0 19.6 L90.0 18.9 L89.3 18.5 Z"
},
"sitting": {
"body": "M6.0 119.8 L6.0 131.0 L6.6 132.2 L7.5 132.2 L7.5 127.4 L9.0 121.7 L11.4 116.5 L14.8 111.4 L18.7 106.5 L25.3 100.2 L32.0 95.4 L35.9 93.5 L38.3 93.5 L41.1 96.0 L42.3 99.3 L42.3 102.6 L41.1 107.2 L41.1 109.9 L41.7 109.9 L45.0 102.6 L47.7 99.0 L51.9 94.8 L56.5 91.4 L64.9 87.2 L70.7 85.7 L74.3 85.7 L77.6 86.6 L80.7 88.1 L83.7 91.1 L85.5 94.5 L86.7 99.9 L86.4 105.0 L87.3 105.0 L89.4 98.4 L93.4 92.6 L95.8 90.5 L99.7 88.4 L103.6 87.5 L106.3 87.5 L111.8 89.6 L113.9 91.7 L114.5 94.2 L115.1 94.8 L112.1 96.6 L107.3 96.6 L107.0 97.5 L108.2 97.8 L108.2 98.7 L103.6 99.6 L103.6 100.5 L105.1 100.8 L104.5 101.7 L100.0 102.9 L99.7 104.1 L101.8 104.4 L100.9 105.3 L97.3 106.8 L97.3 107.8 L98.8 108.1 L98.5 108.7 L94.9 110.2 L94.9 111.1 L96.1 111.1 L96.4 111.7 L92.7 113.5 L92.7 114.4 L94.0 114.4 L94.3 115.0 L93.0 115.9 L90.0 116.8 L90.0 117.7 L91.2 117.7 L91.5 118.3 L90.6 119.2 L86.7 120.8 L86.7 121.4 L87.9 122.0 L86.7 123.5 L84.6 123.5 L83.1 124.1 L83.1 124.7 L84.6 125.3 L84.3 125.9 L82.5 126.8 L78.5 126.8 L78.5 127.7 L80.1 128.6 L79.1 129.5 L74.9 129.2 L74.6 130.4 L75.8 131.0 L75.2 131.9 L70.1 131.6 L70.1 132.5 L71.3 133.4 L71.0 134.1 L69.2 134.4 L65.2 133.7 L65.2 134.7 L66.1 135.3 L65.5 136.2 L60.4 135.6 L61.3 137.1 L61.0 137.7 L56.8 136.5 L56.5 137.4 L57.1 138.3 L56.2 138.6 L52.2 137.1 L51.9 138.0 L52.5 138.9 L51.6 139.2 L48.3 137.4 L47.4 137.4 L47.7 138.9 L47.1 139.2 L44.1 136.8 L43.2 136.8 L43.2 137.7 L42.6 138.0 L41.4 136.8 L40.5 134.7 L39.9 134.7 L39.5 135.6 L38.9 135.3 L38.6 134.1 L39.2 133.1 L39.2 131.6 L38.3 131.6 L38.0 131.0 L38.6 129.5 L39.2 129.2 L39.2 128.3 L42.3 125.6 L47.7 123.5 L53.2 123.5 L57.4 124.7 L60.1 126.2 L61.0 126.2 L61.0 125.3 L58.0 122.6 L53.8 121.4 L53.5 120.5 L52.5 120.1 L47.1 120.1 L45.6 120.8 L43.8 120.5 L38.6 122.6 L37.7 123.8 L36.8 123.8 L35.0 125.9 L34.1 128.9 L33.5 129.5 L32.3 129.2 L32.3 132.2 L33.2 134.4 L32.0 134.4 L31.7 135.3 L32.9 137.4 L36.8 141.3 L43.2 144.0 L47.1 144.6 L56.2 144.6 L61.0 144.0 L72.5 140.7 L82.5 136.2 L90.0 131.6 L102.7 122.6 L103.0 124.4 L101.5 128.3 L97.9 131.0 L96.1 134.4 L94.6 135.6 L92.4 135.6 L90.0 136.8 L88.2 138.6 L85.5 143.1 L81.6 144.3 L77.6 149.2 L74.3 151.3 L74.3 152.2 L76.4 152.2 L89.1 149.8 L90.3 150.4 L93.7 150.4 L95.5 149.5 L103.0 147.7 L106.6 147.7 L108.8 148.3 L113.6 147.7 L116.6 148.3 L120.6 147.4 L126.0 147.4 L129.9 146.7 L131.1 145.5 L134.2 144.3 L136.3 144.3 L140.8 146.4 L141.4 147.7 L145.0 148.9 L160.5 148.9 L164.4 149.5 L169.8 151.3 L171.0 151.3 L171.9 150.1 L173.7 149.8 L180.1 151.3 L181.0 152.2 L188.0 152.5 L190.7 153.7 L193.7 153.7 L193.7 152.5 L191.3 150.7 L190.4 148.9 L188.9 147.4 L186.7 146.4 L184.6 143.1 L183.4 142.2 L182.5 137.4 L181.6 135.9 L179.2 134.1 L175.6 132.8 L173.4 130.1 L171.6 128.9 L170.7 125.3 L166.8 121.1 L165.0 120.8 L164.1 119.8 L160.5 113.2 L154.1 107.8 L152.0 107.8 L150.8 107.2 L147.8 103.2 L145.9 99.6 L145.6 97.8 L149.0 94.2 L150.5 90.2 L151.7 89.9 L151.4 85.1 L152.3 84.8 L152.3 83.3 L151.4 80.9 L152.0 79.3 L149.6 75.7 L150.2 74.5 L147.5 71.2 L148.1 70.0 L146.5 68.2 L147.2 67.6 L147.2 66.6 L146.2 64.5 L147.5 64.2 L147.2 63.0 L148.1 62.7 L148.1 61.2 L148.7 60.6 L152.6 60.6 L153.8 59.7 L158.6 60.9 L159.2 62.1 L160.1 62.1 L161.4 60.6 L161.1 58.5 L159.5 58.2 L158.6 57.0 L156.8 56.4 L156.5 55.5 L159.8 54.9 L162.6 55.8 L162.9 55.2 L162.9 52.7 L162.0 51.5 L160.8 50.9 L157.4 50.9 L148.1 47.0 L147.2 47.0 L148.1 48.5 L147.8 49.1 L142.9 47.9 L142.3 47.9 L142.0 48.5 L140.5 48.5 L134.5 46.1 L134.5 47.3 L135.4 48.2 L140.5 51.2 L140.2 52.7 L134.5 53.0 L134.5 54.0 L137.5 54.3 L137.8 54.9 L132.9 57.0 L132.3 58.2 L135.1 58.2 L129.9 62.4 L129.9 63.0 L131.1 63.0 L132.6 62.1 L133.2 62.4 L133.2 63.0 L130.8 65.7 L130.2 67.6 L132.0 67.0 L132.3 67.3 L131.1 70.6 L131.1 72.1 L132.0 72.4 L132.9 70.9 L133.5 71.2 L132.6 73.6 L132.6 75.1 L133.9 75.4 L134.2 76.3 L135.1 76.6 L134.8 77.2 L131.7 76.0 L127.8 75.4 L121.8 73.6 L115.7 70.6 L113.0 68.2 L112.7 64.2 L113.6 60.0 L116.0 53.0 L118.4 48.5 L119.3 47.9 L120.9 48.2 L122.4 49.4 L123.0 51.2 L123.9 51.2 L124.2 50.0 L123.6 47.6 L121.8 45.8 L117.2 44.6 L116.6 44.0 L108.8 44.0 L108.2 44.6 L88.8 47.0 L79.1 48.8 L67.7 52.1 L55.9 57.6 L47.1 63.0 L39.5 68.8 L34.4 73.3 L23.8 84.5 L17.5 92.9 L13.6 99.6 L8.7 110.2 L6.9 116.2 L6.6 119.2 Z M117.5 113.8 L117.8 115.3 L116.0 118.0 L116.0 118.9 L117.2 119.8 L117.2 121.4 L114.8 122.3 L112.1 125.6 L111.5 128.3 L109.7 130.7 L107.9 131.0 L106.6 130.1 L105.7 130.1 L105.7 126.8 L110.0 118.0 L113.9 114.7 L115.7 113.8 Z M130.5 106.5 L132.3 109.3 L132.6 111.1 L133.2 111.1 L133.9 112.0 L134.2 115.3 L132.0 115.9 L130.5 114.7 L129.0 114.7 L126.0 115.9 L123.3 115.9 L123.0 114.4 L127.8 110.2 L129.0 106.8 Z M138.7 100.8 L140.2 100.8 L146.5 107.8 L146.5 109.0 L145.3 110.5 L140.8 112.9 L137.8 112.9 L137.2 112.3 L135.1 106.5 L135.1 103.8 Z",
"lines": "M191.3 152.8 L191.3 153.4 L191.9 153.7 L193.7 153.7 L193.7 153.1 Z M61.9 136.5 L61.9 138.0 L63.1 138.0 L63.4 137.1 Z M66.8 135.0 L66.8 136.5 L68.3 135.9 L68.0 135.0 Z M33.8 134.4 L33.8 135.0 L32.9 135.3 L32.9 135.9 L33.5 136.8 L35.3 137.1 L34.4 134.4 Z M34.4 130.1 L33.8 130.1 L33.2 131.0 L33.5 132.5 L34.1 132.5 Z M40.5 122.9 L39.2 123.2 L38.3 124.4 L37.7 124.4 L36.8 125.6 L36.2 125.6 L35.9 127.4 L36.5 127.4 L38.0 125.3 L40.5 123.5 Z M45.0 121.4 L43.5 121.4 L42.0 122.0 L42.0 122.9 L45.0 122.0 Z M88.5 120.8 L88.8 121.7 L88.5 122.6 L90.3 121.7 L90.3 120.8 Z M50.4 120.8 L50.4 121.7 L52.8 121.7 L52.8 121.1 Z M6.3 120.5 L6.0 129.2 L6.3 130.4 L6.9 130.4 L6.6 129.2 L6.9 120.5 Z M104.5 115.9 L103.9 115.9 L102.7 118.0 L103.0 120.8 L102.4 122.0 L103.9 122.0 L103.9 117.7 L104.5 116.8 Z M98.5 110.2 L97.0 110.2 L97.0 112.3 L97.9 112.0 L98.5 111.1 Z M100.9 106.8 L99.4 106.8 L99.4 108.7 L100.0 108.7 Z M129.6 86.0 L128.4 86.0 L122.4 89.6 L116.0 92.6 L115.4 93.2 L115.4 93.9 L116.3 94.2 L115.7 94.5 L115.7 95.4 L116.9 95.1 L121.5 91.4 L129.6 86.6 Z M149.6 78.4 L150.2 80.6 L150.8 80.6 L150.8 78.7 Z M147.5 73.3 L147.5 74.2 L148.1 75.1 L149.0 75.4 L148.4 73.3 Z M134.2 72.4 L133.5 73.3 L133.5 74.2 L134.2 74.2 L135.1 75.1 L135.1 75.7 L135.7 75.7 L135.1 72.7 Z M145.0 65.4 L145.0 67.6 L145.3 68.2 L145.9 68.2 L145.9 66.0 L145.6 65.4 Z M134.2 65.1 L132.0 65.7 L132.0 66.3 L132.9 66.6 L132.9 67.9 L133.5 67.9 Z M103.6 63.3 L102.7 63.3 L99.7 66.6 L94.6 74.2 L91.2 82.7 L89.7 89.6 L90.3 89.6 L92.4 83.0 L96.7 74.2 L100.9 67.3 L103.6 63.9 Z M133.5 60.9 L133.9 63.0 L134.5 63.0 L135.1 60.9 Z M72.8 60.9 L71.6 61.2 L68.6 63.3 L62.8 68.2 L55.0 76.6 L48.9 86.0 L45.3 94.2 L44.7 97.2 L45.3 97.2 L47.1 92.3 L49.8 86.9 L56.5 76.9 L64.9 67.9 L72.2 62.1 Z M148.4 59.4 L148.4 60.0 L149.6 59.7 L151.4 60.0 L151.4 59.1 L150.2 59.4 L149.9 58.8 L149.3 58.8 Z M137.2 57.0 L135.7 57.0 L135.7 58.8 L136.3 58.8 L137.2 57.9 Z M138.4 54.0 L138.4 55.5 L139.3 55.5 L139.9 54.3 Z M141.1 50.3 L141.1 53.4 L142.3 53.4 L142.9 52.1 L145.3 52.1 L145.0 51.2 Z M148.7 48.2 L148.7 50.0 L150.2 50.3 L150.2 49.1 L149.3 48.2 Z M109.4 44.3 L109.4 45.2 L112.7 44.6 L116.0 44.9 L116.0 44.0 Z"
},
"resting": {
"body": "M193.7 139.7 L185.5 129.8 L178.3 127.8 L180.7 125.1 L182.4 120.3 L181.4 119.9 L180.0 122.0 L179.4 121.6 L180.7 118.2 L181.1 112.1 L179.0 102.9 L178.0 102.9 L178.0 112.1 L177.3 115.2 L176.6 115.9 L176.3 109.0 L174.9 108.7 L173.9 103.6 L171.5 98.8 L170.2 98.5 L171.5 104.3 L171.2 105.0 L168.8 102.9 L168.1 99.5 L166.4 96.4 L165.1 96.4 L165.7 98.5 L165.4 100.2 L162.7 96.4 L160.3 94.4 L159.6 94.4 L159.9 96.4 L159.3 96.8 L155.5 93.0 L154.2 93.0 L154.5 94.4 L153.1 94.7 L149.4 92.4 L148.0 92.4 L148.4 93.7 L147.0 94.1 L143.3 92.4 L140.9 92.0 L141.6 93.4 L141.2 94.4 L130.3 94.7 L130.3 95.8 L131.7 96.1 L132.4 96.8 L128.3 98.5 L124.9 98.5 L124.5 100.2 L123.5 98.5 L123.5 95.1 L124.9 91.7 L128.9 86.9 L133.4 84.2 L137.8 82.8 L142.9 83.2 L150.1 85.9 L153.5 88.9 L154.5 88.9 L154.5 87.9 L153.5 85.9 L150.7 83.2 L144.6 79.8 L139.5 77.7 L129.6 75.3 L128.9 74.6 L117.4 74.6 L116.7 75.3 L91.1 79.1 L75.1 82.8 L61.9 87.6 L43.5 97.1 L27.5 108.7 L16.6 119.6 L12.5 124.7 L6.0 135.9 L6.0 146.8 L9.4 153.7 L10.8 153.7 L9.4 149.2 L9.4 146.2 L11.1 140.7 L14.5 135.3 L19.3 130.5 L21.7 129.1 L24.1 128.8 L25.1 130.5 L25.1 135.9 L25.8 137.7 L26.8 137.7 L27.1 133.9 L31.2 126.4 L36.3 121.3 L41.4 118.6 L44.5 118.6 L45.8 120.3 L45.8 121.6 L40.7 124.0 L40.4 125.4 L41.1 125.4 L41.4 126.1 L40.1 126.4 L40.1 127.1 L37.7 129.1 L37.7 130.2 L38.4 130.2 L38.7 130.8 L37.7 132.5 L37.3 134.6 L38.4 134.9 L39.7 134.2 L43.8 139.7 L46.2 141.4 L51.3 143.4 L54.0 143.1 L53.7 141.4 L51.6 139.4 L52.3 138.7 L58.4 142.1 L63.9 144.1 L73.4 146.2 L82.3 147.2 L99.0 146.8 L120.4 144.1 L134.4 144.5 L141.6 145.8 L148.0 147.9 L152.8 150.6 L155.5 153.7 L156.2 152.6 L155.5 148.6 L152.4 145.1 L147.0 142.1 L146.3 140.7 L142.2 139.4 L138.5 139.0 L138.1 138.0 L139.8 137.3 L142.9 137.3 L147.0 139.0 L149.0 139.0 L149.4 138.3 L154.5 137.7 L155.2 138.3 L155.2 139.7 L157.6 141.1 L159.6 140.0 L167.1 140.4 L174.2 142.4 L179.7 141.7 L182.8 142.1 L184.8 141.1 L187.5 142.1 L187.9 141.4 L189.6 141.4 L192.3 142.8 L193.7 142.8 Z M80.2 131.5 L86.7 130.8 L101.4 130.8 L121.5 132.2 L125.9 133.6 L130.7 133.6 L131.0 136.6 L130.3 137.3 L126.6 137.3 L126.2 135.9 L118.7 136.3 L118.4 134.9 L114.0 135.9 L111.2 135.9 L110.9 134.6 L105.1 136.3 L103.4 136.3 L103.1 134.9 L102.0 134.9 L98.0 136.6 L96.3 136.6 L95.6 134.9 L91.5 136.6 L89.4 136.6 L89.4 134.6 L83.7 135.6 L83.3 133.9 L80.2 133.6 Z M150.1 108.0 L153.1 108.0 L157.6 109.4 L162.0 113.1 L163.3 115.5 L162.7 118.9 L161.0 118.9 L158.9 116.2 L160.3 121.0 L158.9 121.3 L159.6 125.1 L158.6 126.4 L157.2 126.4 L151.8 122.7 L150.1 120.6 L150.7 117.2 L149.7 114.8 L150.1 112.8 L149.0 111.4 L149.0 108.7 Z",
"lines": "M141.9 140.4 L142.2 141.4 L146.0 142.4 L145.6 141.4 Z M6.3 136.6 L6.0 144.8 L6.3 146.2 L7.0 146.2 L7.0 142.4 L6.7 142.1 L7.0 136.6 Z M131.7 138.3 L137.5 139.4 L137.5 138.0 L135.4 137.7 L138.8 137.0 L139.2 135.9 L136.8 136.6 L135.4 135.9 L133.4 136.3 L132.7 135.3 L132.0 135.3 Z M132.7 137.3 L133.0 137.0 L135.4 137.3 L135.1 137.7 Z M41.1 128.8 L39.4 128.8 L39.4 131.2 L40.7 130.5 Z M74.1 128.5 L74.1 129.5 L75.1 130.5 L75.1 131.5 L76.2 132.2 L77.9 132.2 L78.2 133.6 L79.6 133.9 L79.6 131.2 Z M127.9 124.4 L127.9 125.1 L128.9 126.1 L136.1 128.8 L136.8 129.5 L132.4 131.5 L131.7 132.2 L131.7 134.2 L132.4 134.2 L133.4 132.9 L136.1 130.8 L137.1 130.8 L139.2 129.8 L140.9 129.8 L141.9 130.5 L146.3 130.8 L150.1 132.5 L153.1 135.6 L153.8 137.0 L155.5 137.0 L155.9 134.2 L157.6 131.5 L157.6 130.5 L158.9 127.8 L158.9 127.1 L157.2 127.1 L155.9 129.8 L148.7 130.5 L146.0 129.5 L139.2 128.8 Z M151.1 131.2 L154.5 130.8 L156.5 131.2 L155.2 132.9 L154.2 135.3 L153.5 133.9 L150.7 131.5 Z M43.8 124.4 L42.1 124.4 L42.1 126.8 L42.8 126.8 L43.8 125.4 Z M180.4 122.7 L179.0 123.3 L178.7 121.6 L178.0 121.6 L177.7 122.7 L175.9 124.4 L174.9 124.4 L174.2 125.1 L173.2 127.4 L169.5 130.5 L168.5 132.2 L168.5 132.9 L169.5 133.2 L168.8 133.9 L165.1 135.6 L163.0 135.9 L160.3 138.0 L159.6 139.4 L160.6 139.4 L164.7 136.6 L166.8 136.3 L170.8 134.2 L173.9 131.5 L177.0 130.2 L177.7 129.1 L177.7 127.4 L175.9 128.1 L175.3 129.5 L174.2 129.8 L169.8 133.2 L169.1 132.9 L170.8 130.8 L172.2 130.2 L174.2 128.1 L175.3 126.1 L178.3 125.4 L180.4 123.3 Z M149.7 121.6 L148.7 122.0 L147.7 124.4 L148.4 124.4 L149.7 123.0 Z M174.9 109.7 L174.2 109.7 L174.2 111.8 L173.2 113.5 L172.2 117.2 L170.5 119.9 L170.5 121.0 L171.9 120.3 L174.2 114.8 L174.9 115.9 L174.6 116.9 L175.3 117.2 L174.2 120.6 L175.3 120.6 L177.7 117.2 L177.7 116.5 L175.6 116.2 L175.6 114.2 L174.9 114.2 L174.6 114.8 L174.2 114.5 L174.2 113.5 L175.6 111.4 L175.6 110.4 Z M126.2 110.4 L124.2 109.0 L119.1 107.3 L110.9 107.0 L104.4 108.7 L101.4 110.1 L99.0 111.8 L97.6 110.4 L94.2 109.0 L88.4 109.0 L80.9 110.7 L69.7 114.8 L69.3 113.1 L68.7 112.4 L65.3 112.4 L60.2 114.5 L54.0 118.9 L48.6 125.1 L46.2 129.1 L45.8 127.8 L46.9 122.7 L45.8 123.0 L44.1 132.2 L44.5 134.6 L45.5 134.6 L45.8 132.5 L48.6 127.4 L52.0 123.0 L56.1 118.9 L59.8 116.2 L65.9 113.5 L68.0 113.5 L68.7 114.5 L68.7 115.9 L73.1 114.8 L75.1 115.5 L81.6 115.9 L88.1 117.9 L94.2 121.3 L97.6 124.0 L102.4 129.1 L103.7 129.5 L103.7 128.8 L99.0 123.3 L92.5 118.6 L86.4 115.9 L82.3 114.8 L75.5 114.5 L75.1 114.2 L83.0 111.4 L89.8 110.1 L94.6 110.4 L96.3 111.1 L98.3 112.8 L99.3 112.8 L105.1 109.7 L111.9 108.0 L116.7 108.0 L122.5 109.4 L125.5 111.1 L126.2 111.1 Z M168.8 104.3 L169.1 105.6 L170.2 106.0 L171.2 108.7 L170.5 113.1 L168.5 116.5 L168.5 117.2 L169.5 117.2 L171.9 112.4 L172.5 106.3 L172.2 105.6 L171.2 106.0 L170.2 105.6 L169.5 104.3 Z M125.5 99.2 L125.5 100.9 L125.2 101.2 L123.8 100.9 L123.8 101.6 L125.5 103.3 L126.6 103.3 L126.6 102.6 L125.2 101.2 L127.6 100.5 L127.9 99.5 Z M160.6 96.4 L160.6 97.1 L159.6 97.5 L159.6 98.1 L160.6 98.8 L162.0 98.8 L161.3 96.4 Z M153.8 95.4 L153.8 96.1 L156.2 96.4 L155.9 94.7 L155.2 94.7 L154.8 95.4 Z M149.0 93.4 L149.0 95.4 L150.4 95.4 L150.7 94.4 L149.7 93.4 Z M142.2 93.4 L142.2 95.1 L143.9 95.1 L143.9 94.1 Z M123.2 83.5 L119.8 84.9 L112.3 90.7 L105.8 98.1 L103.4 101.9 L102.7 103.9 L104.1 103.3 L106.1 99.8 L110.9 94.1 L117.4 87.9 L123.2 84.2 Z M86.0 83.5 L78.9 85.5 L71.1 88.9 L64.6 92.4 L56.1 97.8 L47.9 104.3 L38.7 113.5 L35.3 117.6 L34.9 118.9 L35.6 118.9 L47.6 106.7 L57.8 98.5 L69.3 91.3 L77.9 87.2 L86.0 84.2 Z M109.5 81.1 L102.7 82.5 L91.8 86.2 L80.9 91.3 L76.5 94.1 L69.3 99.2 L61.9 106.0 L55.7 113.1 L52.0 118.6 L52.0 119.3 L53.3 118.6 L59.8 110.4 L67.6 102.6 L78.5 94.4 L88.8 88.9 L98.0 85.2 L109.5 81.8 Z M118.1 75.0 L118.1 75.7 L121.8 75.7 L122.1 75.3 L128.3 75.7 L128.3 75.0 L127.2 74.6 Z"
},
"coiled": {
"body": "M193.8 52.4 L191.4 49.8 L189.5 48.6 L181.6 45.3 L171.4 42.4 L168.8 41.2 L167.1 41.0 L166.6 40.5 L158.5 40.5 L158.1 41.0 L149.3 41.4 L125.9 41.7 L124.0 42.2 L116.7 45.7 L112.4 45.7 L111.2 46.2 L111.4 46.9 L113.3 47.2 L113.8 48.1 L109.8 50.7 L96.0 56.9 L95.5 57.4 L95.5 59.5 L93.8 58.6 L93.8 59.5 L93.3 59.8 L89.8 56.4 L89.1 56.4 L89.1 57.2 L89.8 58.1 L89.5 58.3 L87.1 56.9 L86.4 56.9 L86.2 57.9 L84.5 56.7 L83.1 56.4 L83.1 57.9 L79.3 57.9 L78.8 59.3 L76.2 59.5 L76.0 60.5 L68.3 60.2 L64.1 58.6 L57.2 57.4 L54.5 55.7 L51.7 56.0 L51.7 56.7 L52.2 56.7 L52.4 57.2 L51.7 57.9 L49.5 58.6 L48.1 58.6 L46.5 57.4 L44.3 56.9 L42.2 56.9 L41.9 57.4 L41.2 56.9 L39.3 56.9 L39.3 57.6 L42.6 58.1 L44.3 59.1 L36.0 62.2 L29.1 65.5 L23.8 69.1 L16.9 75.0 L12.4 79.5 L7.4 86.7 L6.0 90.0 L6.0 94.3 L7.0 94.8 L7.4 91.9 L9.1 88.8 L12.4 85.7 L16.7 83.3 L19.1 83.3 L21.5 85.0 L22.2 86.4 L22.2 87.6 L21.5 89.0 L21.5 90.9 L21.9 90.9 L24.3 87.4 L30.3 81.9 L35.5 78.6 L41.7 75.7 L46.5 74.3 L48.8 74.3 L49.5 75.7 L50.3 76.0 L52.4 73.3 L54.8 71.7 L59.5 69.1 L63.6 67.6 L66.7 67.1 L71.9 67.1 L79.8 68.1 L80.0 68.3 L79.3 68.8 L79.5 69.8 L79.1 70.2 L76.7 70.7 L76.7 71.9 L74.1 72.1 L73.8 73.3 L71.4 73.3 L71.0 73.8 L71.0 74.8 L69.1 75.0 L69.1 75.5 L69.8 75.7 L69.3 76.4 L66.2 76.7 L66.0 77.6 L66.7 77.9 L66.2 78.3 L62.2 79.5 L61.9 80.7 L59.1 81.7 L59.1 82.9 L58.6 83.3 L56.2 84.3 L56.2 85.2 L53.1 87.1 L53.4 88.3 L49.5 92.1 L49.3 93.6 L47.2 96.7 L47.2 98.1 L46.0 101.4 L46.5 102.4 L46.0 104.3 L46.0 108.3 L46.5 110.7 L47.9 114.0 L49.1 115.7 L53.6 119.3 L54.5 119.3 L54.5 118.6 L52.6 116.4 L50.7 113.3 L49.8 110.7 L50.0 109.3 L50.7 110.0 L51.7 110.0 L49.5 104.0 L49.8 100.9 L51.7 96.2 L54.5 92.4 L61.2 86.2 L67.9 82.4 L76.7 78.8 L77.4 79.0 L76.7 80.7 L75.3 82.4 L74.8 83.6 L73.6 84.3 L73.6 85.2 L74.3 85.7 L76.4 85.7 L77.2 85.2 L84.1 77.1 L84.5 77.4 L85.7 79.8 L87.6 79.8 L89.3 78.8 L92.6 74.8 L92.9 77.6 L95.7 81.7 L96.2 83.8 L96.7 84.0 L96.7 85.2 L97.9 86.9 L99.5 87.6 L100.5 87.4 L101.2 86.7 L101.4 84.5 L100.2 82.4 L100.5 81.7 L103.3 82.4 L103.8 82.9 L104.0 84.8 L102.4 87.4 L102.4 88.8 L101.9 89.3 L102.1 90.5 L104.3 90.5 L106.2 89.3 L106.9 87.6 L108.3 79.8 L108.8 79.3 L110.7 79.5 L114.0 81.2 L117.1 84.0 L116.9 84.5 L115.9 84.3 L115.7 85.2 L118.1 86.7 L117.6 87.4 L117.1 87.4 L117.4 88.1 L119.8 88.8 L122.1 90.2 L126.2 94.0 L127.1 94.0 L126.7 92.4 L127.4 92.1 L130.7 95.7 L131.2 95.7 L132.4 94.3 L132.4 91.9 L131.4 90.5 L130.9 87.6 L130.2 86.2 L129.5 85.9 L128.3 84.5 L127.1 81.2 L125.5 79.3 L123.8 76.0 L122.8 75.7 L123.3 78.1 L122.8 78.3 L119.8 71.9 L119.0 71.9 L119.0 73.1 L119.8 74.8 L119.5 75.2 L115.9 69.5 L115.2 69.5 L115.2 70.7 L115.7 71.4 L115.2 71.7 L111.4 66.9 L110.5 66.9 L110.0 66.2 L111.2 63.1 L114.0 59.8 L116.7 58.3 L127.4 54.3 L130.7 54.3 L137.6 56.4 L140.0 58.3 L140.7 58.3 L141.4 56.9 L143.3 56.4 L158.3 56.2 L162.1 57.6 L164.3 59.5 L164.7 59.5 L165.0 58.8 L164.3 57.4 L162.1 55.3 L159.5 53.6 L158.3 52.4 L158.1 51.2 L159.0 50.0 L160.7 49.3 L168.5 48.1 L178.1 47.9 L182.1 48.3 L189.0 50.5 L190.9 51.4 L193.0 53.3 L193.8 53.3 Z",
"lines": "M47.6 99.5 L47.2 99.5 L46.7 101.7 L47.4 101.4 Z M49.3 95.2 L48.4 95.7 L47.6 97.1 L47.6 97.8 L48.4 97.6 Z M51.5 91.7 L51.0 91.7 L50.0 92.6 L50.0 93.3 L50.5 93.3 L51.5 92.4 Z M125.5 90.5 L125.7 91.7 L127.4 91.7 L127.4 91.2 L126.7 90.7 Z M6.7 90.5 L6.2 90.5 L6.0 90.9 L6.0 93.8 L6.5 93.8 L6.7 93.1 L6.5 92.4 Z M55.5 86.9 L54.5 86.9 L53.8 88.6 L55.0 88.1 Z M118.6 86.4 L118.6 87.6 L119.8 87.6 L119.8 86.9 L119.3 86.4 Z M58.1 84.3 L57.6 84.3 L56.7 85.2 L56.7 85.7 L57.4 85.7 L58.1 85.0 Z M117.6 83.8 L117.8 84.8 L117.4 85.0 L117.4 85.5 L119.0 85.7 L119.0 85.0 L118.1 83.8 Z M61.4 81.7 L59.5 82.1 L59.5 83.3 L61.2 82.6 Z M64.8 79.5 L64.1 79.5 L62.6 80.5 L62.6 81.2 L64.3 80.5 Z M122.6 78.8 L122.6 79.5 L124.3 81.4 L125.0 81.4 L124.3 78.8 L123.3 79.0 Z M97.6 77.9 L97.6 78.8 L99.3 82.4 L99.8 82.4 L99.8 81.4 L100.5 81.2 L100.5 80.7 L99.0 79.8 L98.8 79.3 L99.0 78.8 L102.1 80.0 L104.5 80.0 L107.1 79.5 L108.1 79.0 L108.1 78.6 L106.9 78.6 L103.1 79.3 L100.2 78.6 L100.0 78.3 L100.2 77.6 Z M119.0 75.7 L119.0 76.4 L120.0 77.6 L120.7 77.6 L120.5 75.7 Z M81.9 74.3 L81.2 74.3 L78.8 76.9 L77.2 77.9 L77.2 78.3 L77.6 78.3 L77.9 79.0 L79.3 78.3 L81.9 74.8 Z M95.2 73.8 L93.3 74.8 L93.3 76.0 L93.8 76.0 L95.2 74.5 Z M74.1 74.3 L71.9 73.8 L71.9 74.3 L72.4 74.5 L71.7 74.8 L71.4 75.7 L70.3 75.5 L70.3 76.7 L71.2 76.4 L71.7 75.5 L72.9 75.5 L73.8 75.0 Z M74.5 72.6 L74.5 73.8 L75.7 73.8 L76.4 73.3 L76.2 72.6 Z M115.0 72.1 L115.0 72.6 L116.7 74.3 L117.1 74.3 L116.7 72.1 Z M77.4 72.4 L79.1 71.7 L79.1 71.2 L77.6 71.0 Z M80.0 70.5 L81.4 69.8 L81.2 69.1 L81.4 68.8 L83.6 68.8 L83.6 68.3 L80.5 67.6 Z M110.2 67.4 L110.7 69.3 L111.9 70.5 L113.1 71.0 L112.6 69.3 L111.7 68.6 L111.7 68.1 L110.9 67.4 Z M105.2 65.0 L105.2 65.7 L106.2 66.2 L107.9 68.1 L109.8 69.1 L109.8 68.3 L108.8 66.9 L109.5 66.7 L109.5 66.0 L109.0 66.0 L108.8 66.9 L107.6 66.4 L106.7 65.5 Z M65.0 63.3 L62.4 63.3 L55.5 64.5 L46.7 67.6 L46.5 68.3 L55.0 65.5 L60.7 64.3 L65.0 63.8 Z M93.3 60.2 L93.3 60.7 L94.3 61.4 L95.0 61.4 L95.2 61.0 L96.9 62.9 L100.2 64.8 L101.2 64.8 L101.4 64.3 L102.1 65.0 L102.9 65.0 L102.9 64.3 L101.4 62.9 L100.0 62.2 L99.5 62.2 L99.3 63.1 L97.1 61.2 L96.7 60.0 Z M79.5 58.6 L79.5 60.0 L80.5 60.0 L80.7 59.3 L80.0 58.6 Z M89.3 58.8 L89.3 59.3 L90.5 60.0 L91.4 60.0 L90.7 58.3 L90.2 58.3 L90.0 58.8 Z M81.2 58.6 L81.4 59.3 L82.9 59.5 L82.9 58.8 L82.4 58.3 Z M86.4 58.3 L86.7 59.1 L88.3 59.3 L87.9 58.1 L86.9 57.9 Z M83.8 57.4 L84.1 58.1 L83.3 58.3 L83.3 58.8 L85.5 59.3 L85.5 58.6 L84.3 57.4 Z M159.0 40.7 L159.0 41.4 L166.2 41.2 L166.2 40.7 L165.4 40.5 Z"
}
};
const POSES = Object.fromEntries(Object.entries(TRACED).map(([k, p]) => [k, () => ({ d: [p.body], lines: p.lines, eye: [0, 0], eyeR: 0 })]));
const cache = {};
/** SVG markup for one dragon: <g> with the silhouette in `fill` and a small eye in `eyeFill`. */
function svg(pose, { fill = "#2a2230", eyeFill = "#f6e6c4", flip = false } = {}) {
/** SVG markup for one dragon: <g> with the silhouette in `fill`, its interior lines in `ink` (lineOpacity; lines:
* false leaves them out) and, with `outline`, a hairline of that colour round the edge that stays 1px at any size.
* `dark: true` draws it like the reference sheet: a near-black body with light lines and outline. */
function svg(pose, { fill = "#2a2230", eyeFill = "#f6e6c4", flip = false, lines = true, ink = "#1b0811", lineOpacity = 0.38,
outline = null, outlineWidth = 1, outlineOpacity = 0.7, dark = false } = {}) {
if (!cache[pose]) cache[pose] = POSES[pose]();
const p = cache[pose];
if (dark) {
fill = "#16111b"; ink = "#e9e0f5"; lineOpacity = 0.6; outline = outline || "#d9cdee"; outlineOpacity = 0.85;
}
const tf = flip ? ' transform="translate(200 0) scale(-1 1)"' : "";
// one path per part: parts wind in different directions, so a single combined path would punch holes
return `<g${tf}><g fill="${fill}">${p.d.map((d) => `<path d="${d}"/>`).join("")}</g><circle cx="${f(p.eye[0])}" cy="${f(p.eye[1])}" r="${p.eyeR}" fill="${eyeFill}"/></g>`;
const edge = outline ? ` stroke="${outline}" stroke-opacity="${outlineOpacity}" stroke-width="${outlineWidth}" stroke-linejoin="round" vector-effect="non-scaling-stroke"` : "";
const body = `<g fill="${fill}" fill-rule="evenodd"${edge}>${p.d.map((d) => `<path d="${d}"/>`).join("")}</g>`;
const inner = lines && p.lines ? `<path d="${p.lines}" fill="${ink}" fill-opacity="${lineOpacity}" stroke="none"/>` : "";
const eye = p.eyeR ? `<circle cx="${f(p.eye[0])}" cy="${f(p.eye[1])}" r="${p.eyeR}" fill="${eyeFill}"/>` : "";
return `<g${tf}>${body}${inner}${eye}</g>`;
}
/* ---------- cadets and the thorn bush (same building blocks, 100 x 140 box, feet near y = 132) ---------- */
+185 -23
View File
@@ -9,7 +9,9 @@
* 3 click a choice point on the highlighted route: its other options branch off, each with the chance it gives.
* Picking one re-plans the route from there.
* 4 "Why this route?" in the side panel: intervals, how often the choice stays best, low-bias numbers, risks.
* A toggle adds the community's actual traffic underneath. The URL keeps the selection (#valley/blue/meadow-Blue).
* "Show the paths of all riders" adds, underneath, the paths every source logged (one layer each: the sheet's form
* posts and bulk logs, runs reported here, the bot, Discord) and the deaths (deliberate and failed), each layer with
* its own switch; the counts come from data/stats.json `paths` (analysis/stats/site_stats.py). The URL keeps the selection (#valley/blue/meadow-Blue).
*/
(function () {
"use strict";
@@ -39,15 +41,15 @@
};
const RESCUE = { Orange: "tree-Greens", Brown: "tree-Greens" };
const SPOTS = [
{ place: "treeRed", enc: "tree-Red", colour: "Red", pose: "prowling", flip: true, sc: 0.36 },
{ place: "greens", enc: "tree-Greens", colour: "Green", pose: "resting", sc: 0.3, dx: -16 },
{ place: "greens", enc: "tree-Greens", colour: "Green", pose: "sitting", flip: true, sc: 0.27, dx: 20, dy: -4, twin: true },
{ place: "black", enc: "shadow-Black", colour: "Black", pose: "flying", flip: true, sc: 0.38 },
{ place: "treeRed", enc: "tree-Red", colour: "Red", pose: "roaring", flip: true, sc: 0.36 },
{ place: "greens", enc: "tree-Greens", colour: "Green", pose: "prowling", sc: 0.3, dx: -16 },
{ place: "greens", enc: "tree-Greens", colour: "Green", pose: "prowling", flip: true, sc: 0.27, dx: 20, dy: -4, twin: true },
{ place: "black", enc: "shadow-Black", colour: "Black", pose: "resting", flip: true, sc: 0.38 },
{ place: "redwood", enc: "shadow-Blue", colour: "Blue", pose: "coiled", sc: 0.3 },
{ place: "valleyRed", enc: "valley-Red", colour: "Red", pose: "roaring", sc: 0.36, dy: -12 },
{ place: "meadow:Orange", enc: "meadow-Orange", colour: "Orange", pose: "sitting", flip: true, sc: 0.3 },
{ place: "meadow:Brown", enc: "meadow-Brown", colour: "Brown", pose: "resting", sc: 0.32 },
{ place: "meadow:Blue", enc: "meadow-Blue", colour: "Blue", pose: "sitting", sc: 0.32 },
{ place: "meadow:Orange", enc: "meadow-Orange", colour: "Orange", pose: "flying", flip: true, sc: 0.3 },
{ place: "meadow:Brown", enc: "meadow-Brown", colour: "Brown", pose: "sitting", sc: 0.32 },
{ place: "meadow:Blue", enc: "meadow-Blue", colour: "Blue", pose: "coiled", sc: 0.32 },
];
const FIRST_POSE = { Red: "roaring", Brown: "sitting", Green: "prowling", Orange: "flying" };
Object.keys(L).filter((k) => k.startsWith("see:")).forEach((k) => {
@@ -85,12 +87,13 @@
const st = {
point: null, // a place picked before any dragon: show the best way from there to every dragon
policy: null, runs: null, counts: {}, colour: null, focus: null, expanded: null, over: {},
objective: "eventually", sample: "all", traffic: false, cache: new Map(), pendingHash: null, info: null,
objective: "eventually", sample: "all", traffic: false, layers: {}, paths: null, cache: new Map(), pendingHash: null, info: null,
};
const model = () => st.policy.samples[st.sample];
function advisorFor(enc, colour = st.colour) {
const k = `${st.sample}|${colour}|${st.objective}|${enc}`;
if (!st.cache.has(k)) st.cache.set(k, S.advisor(model(), colour, st.objective, { only: [enc] }));
// the Black needs the shadow, which (almost) only shows on a first attempt: its routes are solved for that attempt
if (!st.cache.has(k)) st.cache.set(k, S.advisor(model(), colour, st.objective, { only: [enc], attempt: colour === "Black" ? "First attempt" : null }));
return st.cache.get(k);
}
let encParams = null;
@@ -342,8 +345,8 @@
"aria-label": sp.first ? `${sp.colour} dragon, first sighting` : `${ENC_NAME[sp.enc]}. Show the routes to it.` }, g);
if (isTarget && routesOn) el("ellipse", { cx: 100, cy: 140, rx: 80, ry: 16, fill: INK[sp.colour], "fill-opacity": 0.25 }, gg);
// a soft paper-coloured halo keeps dark dragons readable on the dark canopy
gg.innerHTML += `<g stroke="${PAPER.halo}" stroke-width="9" stroke-linejoin="round" opacity="0.55">${D.svg(sp.pose, { fill: PAPER.halo, eyeFill: PAPER.halo, flip: sp.flip })}</g>`;
gg.innerHTML += D.svg(sp.pose, { fill: INK[sp.colour], flip: sp.flip });
gg.innerHTML += `<g stroke="${PAPER.halo}" stroke-width="9" stroke-linejoin="round" opacity="0.55">${D.svg(sp.pose, { fill: PAPER.halo, eyeFill: PAPER.halo, flip: sp.flip, lines: false })}</g>`;
gg.innerHTML += D.svg(sp.pose, sp.colour === "Black" ? { dark: true, outline: "#3a2a44", flip: sp.flip } : { fill: INK[sp.colour], flip: sp.flip, lineOpacity: 0.5, outline: "#1b0811", outlineOpacity: 0.55, outlineWidth: 1.1 });
el("rect", { x: 0, y: 0, width: 200, height: 160, fill: "transparent" }, gg);
if (sp.twin) return;
const tipHtml = () => {
@@ -418,6 +421,22 @@
hit.addEventListener("keydown", (e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); go(); } });
}
});
// every other choice point (the bully fight's endings, the wounded cadet's, the forks, who you enter with) is a
// small dot you can click too; its name shows on hover, and in full once it is picked or its moment is open
if (!st.colour && st.policy) {
Object.keys(POINTS).forEach((id) => {
const P = L[id];
if (!P || P.kind === "dragon" || ids.has(id)) return;
const name = LANDMARK_NAME[id] || P.name || id;
const hit = el("g", { class: "ex-place ex-minor", tabindex: 0, role: "button", "aria-label": `${name}: show the best way from here to every dragon` }, g);
el("circle", { cx: P.x, cy: P.y, r: 10, fill: "transparent" }, hit);
el("circle", { cx: P.x, cy: P.y, r: 3.6, fill: PAPER.halo, stroke: PAPER.ink, "stroke-width": 1.6, "stroke-opacity": 0.85 }, hit);
el("title", {}, hit).textContent = `${name}${P.desc ? `: ${P.desc}` : ""} Click for the best way from here to every dragon.`;
const go = () => { st.point = id; st.info = null; writeHash(); render(); };
hit.addEventListener("click", go);
hit.addEventListener("keydown", (e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); go(); } });
});
}
const gt = el("text", { x: GATE.x, y: GATE.y + 14, "text-anchor": "middle", "font-size": 11, "letter-spacing": "0.16em", fill: PAPER.ink, "font-family": "var(--font-label)", "paint-order": "stroke", stroke: PAPER.halo, "stroke-width": 3 }, g);
gt.textContent = "ENTER THE VALLEY";
if (!st.colour && st.policy) {
@@ -432,8 +451,19 @@
}
}
// "Show the paths of all riders": one ink per source layer (data/stats.json paths.layers; measures.yaml path_layers),
// and one line style per way the runs ended
const LAYER_INK = { sheet: "#6b4a33", reported: "#7a4f8f", reddit: "#a8792a", bot: "#28588a", discord: "#5865f2" };
const KIND = {
lived: { dash: null, cap: "round", label: "survived" },
chose: { dash: "11 6", cap: "butt", label: "chose to die" },
failed: { dash: "0.1 6", cap: "round", label: "died (failed run)" },
};
const layerOn = (k) => st.layers[k] !== false; // every layer starts on
function drawTraffic(g) {
// how many logged runs went from each place to the next (precomputed in data/stats.json)
if (st.paths && st.paths.layers) return drawLayers(g, st.paths.layers);
// older stats.json: how many logged runs went from each place to the next (precomputed in data/stats.json)
if (!st.edges) return;
const max = Math.max(1, ...st.edges.map((e) => e[2]));
st.edges.forEach(([a, b, n]) => {
@@ -442,6 +472,35 @@
});
}
/** Every source layer that is switched on, side by side in its own ink: solid for runs that survived, dashed for
* deliberate deaths, dotted for failed runs, and a mark where the deaths happened. */
function drawLayers(g, layers) {
const shown = layers.filter((l) => l.runs && layerOn(l.key) && l.lines);
const all = shown.flatMap((l) => Object.values(l.lines).flatMap((es) => es.map((e) => e[2])));
const max = Math.max(1, ...all);
shown.forEach((l, i) => {
const base = (i - (shown.length - 1) / 2) * 9, ink = LAYER_INK[l.key] || "#6b4a33";
["lived", "chose", "failed"].forEach((k, j) => {
const off = base + (j - 1) * 3, kd = KIND[k];
(l.lines[k] || []).forEach(([a, b, n]) => {
if (!L[a] || !L[b]) return;
const w = 1.2 + 14 * Math.sqrt(n / max);
el("path", { d: curve(L[a], L[b], 0.05, off), fill: "none", stroke: ink, "stroke-opacity": k === "lived" ? 0.36 : 0.6,
"stroke-width": k === "failed" ? Math.max(2.2, w) : w, "stroke-linecap": kd.cap, "stroke-dasharray": kd.dash }, g);
});
});
// where the deaths happened: one mark per place, sized by the deaths there
const ends = {};
["chose", "failed"].forEach((k) => Object.entries((l.ends || {})[k] || {}).forEach(([p, n]) => (ends[p] = (ends[p] || 0) + n)));
const emax = Math.max(1, ...Object.values(ends));
Object.entries(ends).forEach(([p, n]) => {
if (!L[p]) return;
const r = 2.5 + 9 * Math.sqrt(n / emax), x = L[p].x + base, y = L[p].y;
el("path", { d: `M${x - r * 0.6},${y - r * 0.6}L${x + r * 0.6},${y + r * 0.6}M${x + r * 0.6},${y - r * 0.6}L${x - r * 0.6},${y + r * 0.6}`, stroke: ink, "stroke-width": 2, "stroke-opacity": 0.8 }, g);
});
});
}
function drawRoutes(gRoute, gLab, routes) {
const best = Math.max(1e-12, ...routes.map((r) => r.value.x));
const onRoute = new Set();
@@ -472,7 +531,7 @@
});
// destination label
const end = pts[pts.length - 1];
pill(gLab, end.P.x, end.P.y + 30, `${pct(r.value.x)} per attempt`, { edge: tc, strong: rel === 1 });
pill(gLab, end.P.x, end.P.y + 30, `${pct(r.value.x)} ${st.colour === "Black" ? "on a first attempt" : "per attempt"}`, { edge: tc, strong: rel === 1 });
// choice points on the focused route: one diamond per place, even when several choices are made there
// (at the bully fight: help or walk away, your first move, the dagger, then the bullies' fate)
if (focus) {
@@ -632,9 +691,20 @@
const hideTip = () => { const t = $("#ex-tip"); if (t) t.hidden = true; };
/* ---------- panel ---------- */
const mini = (c, pose = "sitting") => `<svg viewBox="0 0 200 160" aria-hidden="true">${D.svg(pose, { fill: `var(${DV[c]})`, eyeFill: "var(--bg)" })}</svg>`;
const POSE_OF = { Red: "roaring", Orange: "flying", Brown: "resting", Green: "prowling", Blue: "coiled", Black: "flying" };
const trafficToggle = () => `<label class="ex-toggle"><input type="checkbox" id="ex-traffic"${st.traffic ? " checked" : ""}> Show where riders actually went</label>`;
const mini = (c, pose = "sitting") => `<svg viewBox="0 0 200 160" aria-hidden="true">${D.svg(pose, { fill: `var(${DV[c]})`, eyeFill: "var(--bg)", dark: c === "Black" })}</svg>`;
const POSE_OF = { Red: "roaring", Orange: "flying", Brown: "sitting", Green: "prowling", Blue: "coiled", Black: "resting" };
const UNROUTED = { "reddit thread": "Reddit result pages", register: "the Dragon Register" };
function trafficToggle() {
const box = `<label class="ex-toggle"><input type="checkbox" id="ex-traffic"${st.traffic ? " checked" : ""}> Show the paths of all riders</label>`;
if (!st.traffic || !st.paths || !st.paths.layers || !st.paths.layers.some((l) => l.lines)) return box;
const rows = st.paths.layers.map((l) => `<label class="ex-layer${l.runs ? "" : " none"}"><input type="checkbox" data-layer="${esc(l.key)}"${l.runs && layerOn(l.key) ? " checked" : ""}${l.runs ? "" : " disabled"}>
<span class="sw" style="--sw: ${LAYER_INK[l.key] || "#6b4a33"}"></span><span>${esc(l.label)}</span><span class="n">${l.runs ? l.runs.toLocaleString() : "none yet"}</span></label>`).join("");
const key = Object.values(KIND).map((kd) => `<span class="ex-kind"><svg viewBox="0 0 34 8" aria-hidden="true"><path d="M3 4H31" stroke="currentColor" stroke-width="2.6" stroke-linecap="${kd.cap}"${kd.dash ? ` stroke-dasharray="${kd.dash === "11 6" ? "8 4" : "0.1 5"}"` : ""}/></svg>${kd.label}</span>`).join("");
const un = Object.entries(st.paths.unrouted || {}).filter(([, n]) => n).map(([s, n]) => `${n.toLocaleString()} from ${esc(UNROUTED[s] || s)}`);
return `${box}<div class="ex-layers" role="group" aria-label="Which riders' paths to show">${rows}
<div class="ex-kinds">${key}</div>
<p class="small muted">Each source in its own colour; line width is how many runs took each step, and ✕ marks where runs died.${un.length ? ` Not drawn (they record the dragon, not the route): ${un.join(", ")}.` : ""}</p></div>`;
}
function chooser() {
return `<div class="ex-choose">${COLOURS.map((c) => `<button type="button" class="ex-dchip" data-c="${c}" aria-pressed="${st.colour === c}" style="--c: var(${DV[c]})">${mini(c, POSE_OF[c])}<span>${c}</span></button>`).join("")}</div>`;
}
@@ -684,9 +754,95 @@
${trafficToggle()}`;
}
/** Inside the bonding encounter: the answers the bot gave, screen by screen, on its best logged way to bond this
* colour (data/tree.json, analysis/tree/build_tree.py), with what every other answer did. Only shown when the bot's
* way goes through the same encounter as the route; the community form does not record these answers. */
const TREE_SIDE = (enc) => (/^(valley|meadow)-/.test(enc) ? "valley" : "tree");
/** The community route PDF's answers for an encounter (data/pdf_encounters.json): its recommended (dark-tile) answers
* as numbered steps toward this dragon, then the whole tree. */
// the goal inside one encounter: a bond with this colour, or (an encounter that leads on, like the shadow before
// the Black) the way on to the next one
const isGoal = (end, colour, onward) => onward ? new RegExp(`^On to the ${onward}`).test(end || "")
: /^Bonded|Bonded \(/.test(end || "") && (!/\(/.test(end) || new RegExp(colour).test(end));
function leadsTo(o, colour, onward) {
if (o.end) return isGoal(o.end, colour, onward);
return (o.then || []).some((c) => !c.roll && leadsTo(c, colour, onward));
}
function guidePath(options, colour, onward) {
const steps = [];
let opts = options;
while (opts && opts.length) {
const live = opts.filter((o) => !o.roll);
const pick = live.find((o) => o.best && leadsTo(o, colour, onward)) || live.find((o) => leadsTo(o, colour, onward));
if (!pick) break;
const roll = opts.find((o) => o.roll);
steps.push({ pick, others: live.filter((o) => o !== pick), roll: roll ? roll.roll : null });
if (pick.end) break;
opts = pick.then;
}
return steps;
}
const endOf = (o) => (o.end ? o.end : "continues");
function treeList(options) {
return `<ul>${options.map((o) => o.roll ? `<li class="roll"><em>${esc(o.roll)}</em></li>` :
`<li class="${o.best ? "best" : ""}${o.unconfirmed ? " pale" : ""}">${esc(o.say)}${o.pct ? ` <small>${esc(o.pct)}</small>` : ""}${o.end ? ` → <b>${esc(o.end)}</b>` : ""}${o.then ? treeList(o.then) : ""}</li>`).join("")}</ul>`;
}
function guideAnswers(enc) {
const g = st.guide;
if (!g) return "";
const keys = (g.route_encounters || {})[enc] || [];
if (!keys.length) return "";
const src = g.source || {};
const blocks = keys.map((k, ki) => {
const E = g.encounters[k];
if (!E) return "";
const next = keys[ki + 1] ? (g.encounters[keys[ki + 1]] || {}).title || "" : "";
const steps = guidePath(E.options, st.colour, next ? next.replace(/^The /, "") : null);
const rows = steps.map((s, i) => `<li><span class="n">${i + 1}</span><div><b>${esc(s.pick.say)}</b>${s.roll ? `<small class="ex-roll">The guide notes: ${esc(s.roll)}.</small>` : ""}
<small>${s.pick.pct ? `the guide's rate: ${esc(s.pick.pct)}` : ""}${s.pick.unconfirmed ? " · unconfirmed" : ""}${s.pick.end ? `${s.pick.pct ? " · " : ""}${esc(s.pick.end)}` : ""}</small>
${s.others.length ? `<details><summary>Other answers here</summary><ul>${s.others.map((o) => `<li>${esc(o.say)}${o.pct ? ` <small>${esc(o.pct)}</small>` : ""} → ${esc(endOf(o))}</li>`).join("")}</ul></details>` : ""}</div></li>`).join("");
return `<p class="small"><b>${esc(E.title)}</b>: <em>${esc(E.scene)}</em>${E.warning ? ` <span class="ex-warn">${esc(E.warning)}</span>` : ""}</p>
${rows ? `<ol>${rows}</ol>` : `<p class="small muted">The guide shows no way to bond a ${st.colour} here.</p>`}
${E.note ? `<p class="small muted">${esc(E.note)}</p>` : ""}
<details class="ex-fulltree"><summary>Every answer in the guide's tree</summary>${treeList(E.options)}</details>`;
}).join("");
return `<div class="ex-inside"><span class="eyebrow">Inside the encounter: the community guide's answers</span>${blocks}
<p class="small muted">From the <a href="${esc(src.link || "#")}" target="_blank" rel="noopener">community route PDF</a> by ${esc((src.authors || []).join(", "))} (${esc(src.version || "")} version), transcribed as data. ${esc(src.note || "")}</p></div>`;
}
function encounterAnswers(enc) {
return guideAnswers(enc) + botAnswers(enc);
}
function botAnswers(enc) {
const t = st.tree;
if (!t) return '<p class="small muted ex-inside">Loading the answers inside the encounter…</p>';
const best = (t.best || {})[st.colour];
const picks = best && best.picks && best.picks.length ? best.picks : null;
const hourAt = picks ? picks.findIndex((p) => (t.screens[p.screen] || {}).stage === "THORN_WALK") : -1;
const side = hourAt >= 0 && /valley/i.test(picks[hourAt].text) ? "valley" : "tree";
const viaShadow = picks && picks.some((p) => /shadow/i.test(p.text) && !/descend/i.test(p.text));
const fits = picks && hourAt >= 0 && side === TREE_SIDE(enc) && (enc.startsWith("shadow-") ? viaShadow : !viaShadow || side === "valley");
if (!fits) return `<p class="small muted ex-inside">The DragonKind bot hasn't bonded a ${st.colour} through ${esc(ENC_NAME[enc] || enc)} yet, so it can't confirm these answers. (The community form records only how the encounter ended, not the answers given.)</p>`;
const died = (o) => (o.to && o.to.DIED ? o.to.DIED.n : 0);
const rows = picks.slice(hourAt + 1).map((p, i) => {
const sc = t.screens[p.screen] || { options: {} };
const me = sc.options[p.option] || { n: p.n, to: {} };
const lived = me.n - died(me);
const others = Object.entries(sc.options).filter(([k]) => k !== p.option).map(([, o]) =>
`<li>${esc(o.text)} <small>${o.n ? `died ${died(o)} of ${o.n}` : "untested"}</small></li>`).join("");
return `<li><span class="n">${i + 1}</span><div><b>${esc(p.text)}</b>
<small>${me.n ? `got through ${lived} of ${me.n} times` : ""}${me.kind === "fixed" && me.n ? " · always the same so far" : me.kind === "dice" ? " · a roll" : ""}</small>
${others ? `<details><summary>Other answers here</summary><ul>${others}</ul></details>` : ""}</div></li>`;
}).join("");
const end = Object.keys((t.screens[picks[picks.length - 1].screen] || { options: {} }).options[picks[picks.length - 1].option]?.to || {}).find((k) => k.startsWith("BONDED"));
return `<div class="ex-inside"><span class="eyebrow">What the DragonKind bot did: the answers that bonded</span>
<ol>${rows}</ol>
<p class="small muted">${end ? `Bonded a ${end.split(":")[1]}. ` : ""}From the bot's own runs (it logs every screen it sees), so the counts are small; untested answers may also work.</p></div>`;
}
function panelRoutes(routes) {
const best = Math.max(1e-12, ...routes.map((r) => r.value.x));
const T = model().targets[st.colour], b = T[st.objective];
const T = model().targets[st.colour], first = st.colour === "Black" && T.firstAttempt, b = first ? T.firstAttempt.thisAttempt : T[st.objective];
const focus = routes.find((r) => r.enc === st.focus) || routes[0];
const card = (r) => {
const rel = r.value.x / best, o = encOutcome(r.enc), c = encColour(r.enc);
@@ -696,17 +852,18 @@
return `<button type="button" class="ex-route-card${r.enc === focus.enc ? " on" : ""}" data-enc="${r.enc}" aria-pressed="${r.enc === focus.enc}">
<i class="ex-swatch ${style}" style="--c: var(${DV[st.colour]}); opacity:${(0.3 + 0.7 * rel).toFixed(2)}"></i>
<span class="nm">${esc(ENC_NAME[r.enc])}${RESCUE[st.colour] === r.enc && st.colour !== "Green" ? " <em>(rescue)</em>" : ""}</span>
<b>${pct(r.value.x)}</b><small>per attempt · ${bond}${n < 30 ? ` · only ${n} attempts logged` : ""}${r.value.o > 0.005 ? ` · ends on another dragon ${pct(r.value.o)}` : ""}</small></button>`;
<b>${pct(r.value.x)}</b><small>${st.colour === "Black" ? "on a first attempt" : "per attempt"} · ${bond}${n < 30 ? ` · only ${n} attempts logged` : ""}${r.value.o > 0.005 ? ` · ends on another dragon ${pct(r.value.o)}` : ""}</small></button>`;
};
const steps = focus.steps.filter((s) => s.kind === "decision" || s.kind === "chance").map((s) => {
if (s.kind === "chance") return `<li class="chance"><span>${esc(s.label)}</span><b>${esc(String(s.taken))}</b><small>roll ${pct(s.probs[s.taken])}</small></li>`;
const open = st.expanded === s.var;
const opts = open ? `<div class="ex-opts">${Object.entries(s.options).sort((a, c) => c[1].pX - a[1].pX).map(([v, val]) =>
`<button type="button" class="ex-opt${v === s.taken ? " on" : ""}" data-var="${s.var}" data-v="${esc(v)}"><span>${esc(v)}${v === s.choice ? ' <em class="rec">best</em>' : ""}</span><b>${pct(val.pX)}</b></button>`).join("")}</div>` : "";
return `<li class="dec${open ? " open" : ""}"><button type="button" class="ex-step" data-var="${s.var}" aria-expanded="${open}"><span>${esc(s.label)}</span><b>${esc(String(s.taken))}</b><small>${s.userSet ? "your choice" : "best"} · ${s.var === "encounter" ? pct(s.options[s.taken].pX) : pct(s.options[s.taken].pX)}</small></button>${opts}</li>`;
const inside = open && s.var === "encounter" ? encounterAnswers(focus.enc) : "";
return `<li class="dec${open ? " open" : ""}"><button type="button" class="ex-step" data-var="${s.var}" aria-expanded="${open}"><span>${esc(s.label)}</span><b>${esc(String(s.taken))}</b><small>${s.userSet ? "your choice" : "best"} · ${s.var === "encounter" ? pct(s.options[s.taken].pX) : pct(s.options[s.taken].pX)}</small></button>${opts}${inside}</li>`;
}).join("");
const risks = focus.steps.filter((s) => s.risk && s.risk.p > 0.0005).map((s) => `${s.risk.label.toLowerCase()} ${pct(s.risk.p)}`);
const lb = st.policy.samples.lowBias.targets[st.colour].thisAttempt;
const lbT = st.policy.samples.lowBias.targets[st.colour], lb = first && lbT.firstAttempt ? lbT.firstAttempt.thisAttempt : lbT.thisAttempt;
return `<div class="ex-head" style="--c: var(${DV[st.colour]})">${mini(st.colour, POSE_OF[st.colour])}<div><span class="eyebrow">Routes to a</span><h2 id="h-valley">${st.colour} dragon</h2></div>
<button type="button" class="ex-close" id="ex-clear" aria-label="Back to the whole valley">×</button></div>
${chooser()}
@@ -718,7 +875,7 @@
<ol class="ex-steps">${steps}</ol>
<p class="small muted">Diamonds on the map are choices: click one to see where the other options lead. ${st.blocked ? "" : `Your choices apply to every route to this dragon. Changed your mind? <button type="button" class="linklike" id="ex-reset-route">Reset your choices</button>`}</p>
<details class="ex-why"><summary>Why this route?</summary>
<p class="small">Best route for any ${st.colour}: <b>${pct(b.pX.mean)}</b> per attempt (95% interval ${pct(b.pX.lo)}–${pct(b.pX.hi)}), about ${isFinite(b.expectedAttempts.mean) ? Math.round(b.expectedAttempts.mean) : "–"} attempts. Riders who logged every run suggest ${pct(lb.pX.mean)}.</p>
${first ? `<p class="small"><span class="pill warn">Low evidence</span> Best route for the Black, on a <b>first attempt</b>: about <b>1 in ${Math.round(1 / Math.max(b.pX.mean, 1e-9))}</b>, somewhere between 1 in ${Math.round(1 / Math.max(b.pX.hi, 1e-9))} and 1 in ${Math.round(1 / Math.max(b.pX.lo, 1e-9))} (95%). Later attempts almost never see the shadow. The low-bias sample suggests about 1 in ${Math.round(1 / Math.max(lb.pX.mean, 1e-9))}. Every logged shadow comes from riders who chose to post their run, so the shadow's odds rest on an assumption until complete first-attempt logs exist.</p>` : `<p class="small">Best route for any ${st.colour}: <b>${pct(b.pX.mean)}</b> per attempt (95% interval ${pct(b.pX.lo)}–${pct(b.pX.hi)}), about ${isFinite(b.expectedAttempts.mean) ? Math.round(b.expectedAttempts.mean) : "–"} attempts. Riders who logged every run suggest ${pct(lb.pX.mean)}.</p>`}
<p class="small">Each roll's odds may depend on your earlier choices, as far as the data support it. Choices marked "no clear winner" in <a href="#deep">Deep Dive</a> are within the noise.${risks.length ? ` Risks on this route: ${risks.join(", ")}.` : ""}</p>
<p class="small">The bond chance at each encounter is the community average: the form does not record the answers riders gave there.</p>
<div class="seg" role="group" aria-label="Data"><button type="button" data-s="all" aria-pressed="${st.sample === "all"}">All runs</button><button type="button" data-s="lowBias" aria-pressed="${st.sample === "lowBias"}">Low-bias</button></div>
@@ -735,6 +892,7 @@
$$("[data-o]", p).forEach((b) => b.addEventListener("click", () => { st.objective = b.dataset.o; render(); }));
$$("[data-s]", p).forEach((b) => b.addEventListener("click", () => { st.sample = b.dataset.s; render(); }));
const tr = $("#ex-traffic", p); if (tr) tr.addEventListener("change", () => { st.traffic = tr.checked; render(); });
$$("[data-layer]", p).forEach((b) => b.addEventListener("change", () => { st.layers[b.dataset.layer] = b.checked; render(); }));
const cl = $("#ex-clear", p); if (cl) cl.addEventListener("click", () => select(null));
$$("[data-pt]", p).forEach((b) => b.addEventListener("click", () => { st.point = b.dataset.pt; writeHash(); render(); }));
const cp = $("#ex-clear-point", p); if (cp) cp.addEventListener("click", () => { st.point = null; writeHash(); render(); });
@@ -846,7 +1004,8 @@
}
/** The runs selected on the page (one preset of data/stats.json): how many reached each place, and each step. */
function setStats(P) {
function setStats(P, paths) {
if (paths) st.paths = paths;
st.nRuns = P.analyse.n;
st.counts = P.valley.counts;
st.edges = P.valley.edges;
@@ -855,6 +1014,9 @@
function init() {
render();
// the screen tree (the answers inside each encounter), for the "Bonding encounter" step
fetch("data/tree.json").then((r) => r.json()).then((t) => { st.tree = t; if (st.expanded === "encounter") render(); }).catch(() => { st.tree = { best: {}, screens: {} }; });
fetch("data/pdf_encounters.json").then((r) => r.json()).then((g) => { st.guide = g; if (st.expanded === "encounter") render(); }).catch(() => {});
fetch("data/policy.json").then((r) => r.json()).then((p) => {
st.policy = p;
S.useGame(p.samples.all); // the game (and where each colour can be bonded) comes with the route model
+24
View File
@@ -182,6 +182,8 @@ section h2 { font-family: var(--font-crest); letter-spacing: 0.03em; }
.odd .big { font-family: var(--font-crest); font-weight: 700; font-size: 2.1rem; line-height: 1; color: var(--c, var(--ink)); }
.odd .what { font-weight: 600; }
.odd .how { font-size: var(--step--1); color: var(--muted); }
.odd-low { border-style: dashed; }
.odd-low .big { opacity: 0.85; }
.odd svg { display: block; width: 100%; max-width: 220px; height: auto; }
.odd::before { content: ""; position: absolute; inset: 0 auto 0 0; width: 4px; background: var(--c, var(--line)); }
.combo { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(100%, 320px), 1fr)); gap: 16px; }
@@ -338,6 +340,28 @@ footer { border-top-color: var(--line); }
.ex-dchip[aria-pressed="true"] { background: color-mix(in srgb, var(--c) 22%, var(--raised)); box-shadow: 0 0 14px color-mix(in srgb, var(--c) 35%, transparent), inset 0 0 0 1px var(--c); }
.ex-card { padding: 10px 12px; border: 1px solid var(--line); border-radius: 10px; background: var(--raised); }
.ex-toggle { display: flex; gap: 8px; align-items: center; font-size: var(--step--1); color: var(--muted); }
.ex-layers { display: grid; gap: 4px; margin: 4px 0 0 24px; }
.ex-layer { display: grid; grid-template-columns: auto 22px minmax(0, 1fr) auto; gap: 8px; align-items: center; font-size: var(--step--1); color: inherit; cursor: pointer; }
.ex-layer.none { color: var(--muted); cursor: default; }
.ex-layer .sw { height: 0; border-top: 4px solid var(--sw); border-radius: 2px; }
.ex-layer .n { color: var(--muted); font-variant-numeric: tabular-nums; }
.ex-kinds { display: flex; flex-wrap: wrap; gap: 4px 14px; margin-top: 4px; font-size: var(--step--1); color: var(--muted); }
.ex-kind { display: inline-flex; align-items: center; gap: 6px; }
.ex-kind svg { width: 34px; height: 8px; }
.ex-inside { margin: 10px 0 4px; padding: 10px 12px; border-left: 2px solid var(--c, var(--accent)); background: color-mix(in srgb, var(--bg) 70%, transparent); border-radius: 0 8px 8px 0; }
.ex-inside ol { list-style: none; margin: 6px 0; padding: 0; display: grid; gap: 8px; }
.ex-inside ol > li { display: grid; grid-template-columns: 22px minmax(0, 1fr); gap: 8px; align-items: start; }
.ex-inside .n { font-family: var(--font-display); color: var(--muted); text-align: right; }
.ex-inside b { display: block; font-weight: 600; }
.ex-inside small { color: var(--muted); }
.ex-inside details summary { cursor: pointer; font-size: var(--step--1); color: var(--muted); }
.ex-inside ul { margin: 4px 0 0 16px; padding: 0; font-size: var(--step--1); }
.ex-inside + .ex-inside { margin-top: 8px; }
.ex-inside .ex-roll { display: block; font-style: italic; }
.ex-fulltree ul { list-style: disc; }
.ex-fulltree li.best { font-weight: 600; }
.ex-fulltree li.pale { opacity: 0.7; font-style: italic; }
.ex-fulltree li.roll { list-style: none; }
.ex-head { display: grid; grid-template-columns: 64px minmax(0, 1fr) auto; gap: 10px; align-items: center; }
.ex-head svg { width: 64px; height: 52px; }
.ex-head h2 { color: var(--c); }
+13 -3
View File
@@ -148,7 +148,7 @@
const getPolicy = () => policyP || (policyP = fetch("data/policy.json").then((r) => r.json()).catch(() => null));
const ENC_OF = { Red: "valley-Red", Orange: "meadow-Orange", Brown: "meadow-Brown", Green: "tree-Greens", Blue: "meadow-Blue", Black: "shadow-Black" };
const ENC_LABEL = { "valley-Red": "the valley Red", "meadow-Orange": "the meadow Orange", "meadow-Brown": "the meadow Brown", "tree-Greens": "the two Greens", "meadow-Blue": "the meadow Blue", "shadow-Black": "the Black after the shadow" };
const POSE = { Red: "roaring", Orange: "flying", Brown: "resting", Green: "prowling", Blue: "coiled", Black: "flying" };
const POSE = { Red: "roaring", Orange: "flying", Brown: "sitting", Green: "prowling", Blue: "coiled", Black: "resting" };
let blackP = null;
const getBlack = () => blackP || (blackP = fetch("data/black.json").then((r) => r.json()).catch(() => null));
@@ -159,6 +159,8 @@
if (!b) { if (t2) t2.innerHTML = '<h3>Your first attempt is different</h3><p class="small muted">The shadow evidence could not be loaded.</p>'; return; }
const ff = b.form_first, fl = b.form_later, sr = b.same_route, as = b.after_shadow, gaze = as.answers["held its gaze"];
if (t2) t2.innerHTML = `<h3>Your first attempt is different</h3><p class="small">Among riders who helped their squadmate and climbed the tree, the shadow came in <b>${frac(ff)}</b> first attempts (${pct(ff[0] / ff[1], 1)}) and <b>${frac(fl)}</b> later ones. On the very same routes, first attempts saw it about ${Math.round(sr.first_shadows / Math.max(sr.expected, 1) * 10) / 10}× as often as chance would give. The shadow is not a dice roll you can repeat.</p>`;
const steps = $("#black-steps");
if (steps) steps.innerHTML = `How it breaks down: the shadow came in ${frac(ff)} reported first attempts (over-reported); after it, ${as.reached_black} riders reached the Black and <b>${as.bonded_black}</b> bonded (${pct(as.bonded_black / Math.max(as.reached_black, 1))}).`;
if (!box) return;
const br = b.best_route;
box.hidden = false;
@@ -170,6 +172,7 @@
${gaze ? `<li>At the Black, riders who held its gaze bonded in <b>${frac(gaze)}</b> logged answers.</li>` : ""}
<li>The bot has made ${b.bot.attempts.toLocaleString()} attempts on ${b.bot.accounts} accounts, ${b.bot.gated_tree} on the gated path, and seen the shadow ${b.bot.shadows} times: none of them was a first attempt${b.bot.earliest_attempt ? ` (its earliest was attempt ${b.bot.earliest_attempt})` : ""}, which fits.</li>
</ul>
<p class="small"><b>Why the Black's odds are uncertain.</b> The Black comes only after the shadow, and every logged shadow comes from riders who chose to post their run. Riders are much more likely to post a run with a shadow than one without, and no complete log (the bot, bulk logs) has a first attempt with a shadow yet, so the estimate assumes riders over-report the shadow as much as the meadow Blue. Fresh accounts the bot plays to the tree on their first attempt will replace that assumption; until then the odds are a range, not a figure.</p>
<p class="small muted">Method and every table: <code>analysis/reports/BLACK.md</code>; the numbers: <a href="data/black.json">data/black.json</a>.</p>`;
}
@@ -186,9 +189,16 @@
})
.sort((a, b) => b.p - a.p);
const enc = (c) => { const e = (all.model.tables.encounter || {})[ENC_OF[c]] || { outcomes: {} }; const n = Object.values(e.outcomes).reduce((a, b) => a + b, 0); return { k: e.outcomes[c] || 0, n }; };
const art = (c) => window.DragonArt ? `<svg class="odd-art" viewBox="0 0 200 160" aria-hidden="true">${window.DragonArt.svg(POSE[c], { fill: `var(${DV[c]})`, eyeFill: "var(--bg)" })}</svg>` : "";
const art = (c) => window.DragonArt ? `<svg class="odd-art" viewBox="0 0 200 160" aria-hidden="true">${window.DragonArt.svg(POSE[c], { fill: `var(${DV[c]})`, eyeFill: "var(--bg)", dark: c === "Black" })}</svg>` : "";
$("#odds-colours").innerHTML = cols.map(({ c, first, p, pAll, lo, hi }) => {
const e = enc(c);
// The Black rests on one roll no complete log has measured (the shadow on a first attempt): a range, not a figure
if (first) return `<a class="odd odd-colour odd-low" href="#valley/${c.toLowerCase()}" style="--c: var(${DV[c]})">${art(c)}
<span class="pill warn">Low evidence</span>
<span class="big">about 1 in ${oneIn(p)}</span><span class="what">first attempts end bonded to a Black, on the best route</span>
${dots(Math.round(p * 1000), 1000, cssVar(DV[c]))}
<span class="how">Somewhere between <b>1 in ${oneIn(hi)}</b> and <b>1 in ${oneIn(lo)}</b> (95%). Later attempts: no shadow has ever been logged, so effectively never.${Math.abs(pAll - p) / p > 0.25 ? ` All form posts suggest about 1 in ${oneIn(pAll)}.` : ""} Every logged shadow comes from riders who chose to post their run, so this rests on an assumption until complete first-attempt logs exist. <span id="black-steps"></span></span>
<span class="go">See the route →</span></a>`;
return `<a class="odd odd-colour" href="#valley/${c.toLowerCase()}" style="--c: var(${DV[c]})">${art(c)}
<span class="big">${p >= 0.5 ? pct(p) : `1 in ${oneIn(p)}`}</span><span class="what">${p >= 0.5 ? "of runs" : "runs"} end bonded to ${/^[AEIOU]/.test(c) ? "an" : "a"} ${c}, on the best route${first ? ", on your first attempt" : ""}</span>
${dots(Math.round(p * 1000), 1000, cssVar(DV[c]))}
@@ -260,7 +270,7 @@
window.AtlasUI = {
render(state) {
renderOverview(state);
if (window.ValleyExplorer) window.ValleyExplorer.setStats(state.P);
if (window.ValleyExplorer) window.ValleyExplorer.setStats(state.P, state.stats && state.stats.paths);
},
showTab,
};
+1 -1
View File
@@ -27,7 +27,7 @@ for (const f of fs.readdirSync(path.join(root, "site/atlas"))) copy(`site/atlas/
copy("core/graph.js", "graph.js");
copy("core/solver.js", "solver.js");
// The numbers the page shows (all computed in Python) and the published data
for (const f of ["stats.json", "register.json", "graph.json", "policy.json", "black.json", "tree.json", "experiments.json"]) copy(`data/public/${f}`, `data/${f}`);
for (const f of ["stats.json", "register.json", "graph.json", "policy.json", "black.json", "tree.json", "experiments.json", "pdf_encounters.json", "overlap.json"]) copy(`data/public/${f}`, `data/${f}`);
copy("data/public/runs_clean.csv", "data/runs_clean.csv");
for (const f of ["croissant.json", "dictionary.yaml"]) copy(`data/${f}`, `data/${f}`);
// Source files shown in the page's "view the code" panel
+82 -2
View File
@@ -278,7 +278,7 @@ class RedditComments(unittest.TestCase):
"answers": {"company": "Alone", "outcome": "Incinerated at a bonding encounter", "outcome_color": "Red"}}]}),
encoding="utf-8")
manual = TMP / "reddit_comments_manual.yaml"
manual.write_text("reject: [c2]\nfix: {c1: {outcome_color: Blue, direction: null}}\n"
manual.write_text("reject: [c2]\nfix: {c1: {outcome_color: Blue, branch: 'Valley: passed the Red, the meadow', direction: null}}\n"
"add: [{id: c9, thread: abc, posted: '2026-11-16', "
"answers: {company: Two squadmates, direction: West (toward the scent), outcome: Died before the hour}}]\n",
encoding="utf-8")
@@ -286,12 +286,92 @@ class RedditComments(unittest.TestCase):
self.assertEqual([r["run_id"] for r in rows], ["comment-c1", "comment-c3", "comment-c9"])
c1, c3, c9 = rows
self.assertEqual((c1["source"], c1["outcome_color"], c1["direction"], c1["hour"], c1["enc_Blue"]),
("reddit comment", "Blue", "Unknown", "Tree", "Bonded!"))
("reddit comment", "Blue", "Unknown", "Valley", "Bonded!"))
self.assertEqual(c1["data_flags"], "read from a Reddit comment")
self.assertEqual(c3["data_flags"], "read from a Reddit comment automatically, not checked by hand")
self.assertEqual((c9["company"], c9["direction"], c9["hour"]), ("2 Squadmates", "West", "DIED before the hour"))
self.assertEqual(validate.problems(rows, runs.DICT), [])
def test_game_rules_flag_impossible_runs(self):
def flags(**answers):
return runs.answers_row("x", "reddit comment", None, answers)["data_flags"]
ok = flags(company="Alone", direction="East (toward the roar)", first_sighting="Orange",
scream="Kept walking (ignored it)", resolution="Wounded cadet: tourniquet",
branch="Tree: climbed down slowly to the two Greens", outcome="Bonded", outcome_color="Brown")
self.assertEqual(ok, "") # Brown after the Greens: a Green's rescue
cases = {
"first sighting Orange not in documented pool for Alone/Center":
dict(company="Alone", direction="Toward the forest centre", first_sighting="Orange", outcome="Died before the hour"),
"Brown at the Shadow (rare) encounter, which has only Black/Blue":
dict(branch="Tree: the shadow (Blue or Black)", outcome="Bonded", outcome_color="Brown"),
"Red at the Passed the Red: meadow encounter":
dict(branch="Valley: passed the Red, the meadow", outcome="Incinerated at a bonding encounter", outcome_color="Red"),
"Green recorded on a Valley run":
dict(hour="Went to the valley centre", outcome="Bonded", outcome_color="Green"),
"Black recorded on a Valley run":
dict(hour="Went to the valley centre", outcome="Bonded", outcome_color="Black"),
"does not follow 'Ignore the scream'":
dict(scream="Kept walking (ignored it)", resolution="Bullies: my squadmate's revenge", outcome="Died before the hour"),
"fight answers on a run that did not help":
dict(scream="Kept walking (ignored it)", combat_first="Pause to assess", outcome="Died before the hour"),
"a path after the fight on a run without a fight":
dict(scream="Investigated, and walked away", post_path="West", outcome="Died before the hour"),
"a second fight move without pausing to assess":
dict(scream="Investigated, and helped my squadmate", combat_first="Charge the smaller cadet",
combat_second="Engage the smaller cadet", outcome="Died before the hour"),
"died before the hour, yet reached":
dict(scream="Investigated, and helped my squadmate", resolution="I died in the fight", outcome="Bonded", outcome_color="Red"),
}
for expected, answers in cases.items():
self.assertIn(expected, flags(**answers), expected)
def test_flagged_comment_runs_stay_out_of_the_route_model(self):
sys.path.insert(0, str(ROOT / "planner"))
import build_policy
rows = [{"source": "reddit comment", "data_flags": "read from a Reddit comment automatically, not checked by hand"},
{"source": "reddit comment", "data_flags": "read from a Reddit comment; Green recorded on a Valley run (no Greens in the valley)"},
{"source": "reddit spreadsheet", "data_flags": "multiple wings"},
{"source": "reported", "data_flags": "Green recorded on a Valley run (no Greens in the valley)"}]
kept = build_policy.drop_flagged(rows)
self.assertEqual([r["source"] for r in kept], ["reddit comment", "reddit spreadsheet"])
def test_review_summary_and_overlap(self):
sys.path.insert(0, str(ROOT / "core"))
from collection.etl import review_reddit
ov = review_reddit._overlap()
base = {"runs": [{"id": "a1", "thread": "t", "answers": {"outcome": "Bonded"}}]}
head = {"runs": [{"id": "a1", "thread": "t", "answers": {"outcome": "Incinerated at a bonding encounter"}},
{"id": "b2", "thread": "t", "answers": {}}, {"id": "c3", "thread": "t", "answers": {}, "result": "THRESH-X1"}]}
self.assertEqual(review_reddit.diff(base, head), (["b2", "c3"], ["a1"], []))
route = dict(company="Alone", direction="East", scream="Ignore the scream", hour="Tree", outcome="Bonded",
outcome_color="Red", date="2026-10-05")
runs = [{"run_id": "comment-b2", "source": "reddit comment", "data_flags": "read from a Reddit comment; "
"Black recorded on a Valley run (the Black is only reached from the tree)", **{k: None for k in ov.FIELDS}, "date": None},
{"run_id": "comment-c3", "source": "reddit comment", "data_flags": "", **{k: None for k in ov.FIELDS}, **route},
{"run_id": "sheet-1", "source": "reddit spreadsheet", "data_flags": "", **{k: None for k in ov.FIELDS}, **route}]
m = ov.measure(runs)
self.assertEqual((m["comparable"], m["matched"]), (1, 1))
self.assertEqual(m["matches"], [{"comment": "comment-c3", "form": ["sheet-1"]}])
text = review_reddit.summary(base, head, runs, {"THRESH-X1"}, m)
self.assertIn("**2 new**, 1 changed", text)
self.assertIn("Black recorded on a Valley run", text)
self.assertIn("sheet-1", text)
self.assertIn("THRESH-X1", text)
self.assertTrue(text.startswith(review_reddit.MARKER))
def test_fingerprint_ids_are_stable(self):
a = {"Timestamp": "2026-10-04 11:49:07", "Q1": "Alone", "Q2": None}
b = {"Timestamp": "2026-10-04 11:50:00", "Q1": "West"}
dup = {"Timestamp": "Data Import", "Q1": "Alone"}
ids = runs.fingerprints([a, b, dup, dict(dup)], "sheet")
self.assertEqual(len(set(ids)), 4)
self.assertTrue(all(i.startswith("sheet-") for i in ids))
self.assertTrue(ids[3].endswith("-2") and ids[3].startswith(ids[2])) # an exact copy gets -2
self.assertEqual(runs.fingerprints([b, a], "sheet"), [ids[1], ids[0]]) # re-sorting moves no id
self.assertEqual(runs.fingerprints([b], "sheet"), [ids[1]]) # deleting a row moves no other id
self.assertEqual(runs.fingerprints([{**a, "Q9": ""}], "sheet"), [ids[0]]) # a new, empty column changes none
self.assertNotEqual(runs.fingerprints([{**a, "Q1": "West"}], "sheet"), [ids[0]]) # an edited row is new
def test_delivered_not_extracted(self):
spec = read_yaml("collection/pipeline.yaml")["sources"]["reddit_comments"]
with self.assertRaises(extract.Skip):
+32
View File
@@ -0,0 +1,32 @@
// knownAnswer (core/solver.js) against the published data/public/known_answers.json: the guide's recommended answers
// are found on the game's full texts, wrong colours and deadly answers are not picked, and unknown screens stay open.
const test = require("node:test");
const assert = require("node:assert/strict");
const path = require("node:path");
const S = require("../../core/solver.js");
const known = require(path.join(__dirname, "../../data/public/known_answers.json"));
test("the Black: 'Hold its gaze' is the strong pick, 'Lower your eyes' is bad", () => {
const r = S.knownAnswer(known, ["Lower your eyes", "Hold its gaze"], { target: "black", sceneColour: "Black" });
assert.equal(r.pick, 1);
assert.equal(r.confidence, "strong");
assert.equal(r.choices[0].verdict, "bad");
});
test("a guide paraphrase matches the game's full text", () => {
const r = S.knownAnswer(known, ["Climb onto its foreleg", "Reach a hand slowly to touch its talon"], { target: "Red", sceneColour: "Red" });
assert.equal(r.pick, 1);
assert.match(r.reason, /Touch its talon/);
});
test("the two Greens: the answer for the right Green is not the pick for a Brown target", () => {
const offered = ["You respect their nature", "You don't know", "Intellect match"];
assert.equal(S.knownAnswer(known, offered, { target: "Green" }).pick, 0);
assert.equal(S.knownAnswer(known, offered, { target: "Brown" }).pick, 2);
});
test("a screen nobody has seen: no pick, every choice unknown", () => {
const r = S.knownAnswer(known, ["Whistle a tune", "Count the clouds"], { target: "Blue" });
assert.equal(r.pick, null);
assert.deepEqual(r.choices.map((c) => c.verdict), ["unknown", "unknown"]);
});
+127
View File
@@ -0,0 +1,127 @@
"""The page's statistics (analysis/stats/site_stats.py): the conditions of measures.yaml, how runs are grouped by
where they came from, the presets, deliberate deaths, and the invariants of stats.json on a sample of the real runs."""
import random
import sys
import unittest
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / "analysis/stats"))
sys.path.insert(0, str(ROOT / "core"))
import site_stats as SS # noqa: E402
from atlas import runs as runs_io # noqa: E402
DEATHS = ("Incinerated", "Died before the hour")
def sample(per_source=300, seed=7):
"""A fixed sample of the published runs, every statistics source represented, impossible runs left out."""
rng = random.Random(seed)
runs = [r for r in runs_io.read(drop=()) if not runs_io.impossible(r)]
out = []
for s in sorted({r["source"] for r in runs}):
rs = [r for r in runs if r["source"] == s]
out += rng.sample(rs, min(per_source, len(rs)))
return out
class Conditions(unittest.TestCase):
def test_match(self):
r = {"hour": "Tree", "branch": "Shadow (rare)", "outcome": "Bonded", "_deliberate": False}
self.assertTrue(SS.match(r, {"hour": "Tree"}))
self.assertTrue(SS.match(r, {"hour": {"in": ["Tree", "Valley"]}, "branch": {"exists": True}}))
self.assertFalse(SS.match(r, {"hour": {"not": "Tree"}}))
self.assertTrue(SS.match(r, {"any": [{"hour": "Valley"}, {"outcome": "Bonded"}]}))
self.assertFalse(SS.match({**r, "branch": None}, {"branch": {"exists": True}}))
# deliberate deaths: `{not: true}` keeps runs that were never marked (a test row, another caller)
self.assertTrue(SS.match(r, {"_deliberate": {"not": True}}))
self.assertTrue(SS.match({"hour": "Tree"}, {"_deliberate": {"not": True}}))
self.assertFalse(SS.match({**r, "_deliberate": True}, {"_deliberate": {"not": True}}))
def test_bond_pools_leave_out_deliberate_deaths(self):
for t, T in SS.TARGETS.items():
if t.startswith("bond_"):
self.assertEqual(T["pool"].get("_deliberate"), {"not": True}, t)
self.assertEqual(SS.OUTCOMES["bonded_Red"]["denom"].get("_deliberate"), {"not": True})
class Sources(unittest.TestCase):
def test_groups_and_presets(self):
form = {"source": "reddit spreadsheet", "entry": "Form", "goal": "Red", "data_flags": ""}
bulk = {"source": "reddit spreadsheet", "entry": "Data Import", "goal": "Red", "data_flags": ""}
bot = {"source": "bot", "entry": None, "goal": "Black", "data_flags": ""}
com = {"source": "reddit comment", "entry": None, "goal": None, "data_flags": "read from a Reddit comment"}
self.assertEqual([SS.entry_group(r) for r in (form, bulk, bot, com)],
["Form", "Data Import", "DragonKind bot", "Reddit comments"])
self.assertEqual([SS.stratum(r) for r in (bulk, bot, com)], ["Bulk logs (imports)", "DragonKind bot", "Reddit comments"])
runs = [form, bulk, bot, com]
f = lambda **kw: SS.apply_filters(runs, {"source": "all", "goal": "all", "excludeFlagged": False, **kw}) # noqa: E731
self.assertEqual(f(source="form"), [form])
self.assertEqual(f(source="bulk"), [bulk]) # the bot and Reddit are not bulk logs
self.assertEqual(f(source="bot"), [bot])
self.assertEqual(f(source="reddit"), [com])
self.assertEqual(f(goal="only_rare"), [bot])
self.assertEqual(f(excludeFlagged=True), [form, bulk, bot])
class Build(unittest.TestCase):
@classmethod
def setUpClass(cls):
every = sample()
runs = [r for r in every if r["source"] in SS.M["sources"]]
for r in runs:
r["_deliberate"] = SS.deliberate(r)
cls.runs, cls.every = runs, every
cls.out = SS.build(runs, len(runs), None, every_run=every)
def test_presets(self):
self.assertEqual(set(self.out["presets"]), set(SS.M["presets"]))
for pid, p in self.out["presets"].items():
self.assertEqual(set(p), {"label", "analyse", "routes", "map", "valley", "overview"}, pid)
self.assertEqual(set(self.out["presets"]["bot"]["analyse"]["meta"]["sources"]), {"DragonKind bot"})
self.assertEqual(set(self.out["presets"]["reddit"]["analyse"]["meta"]["sources"]), {"Reddit comments"})
def test_overview_counts(self):
o = self.out["presets"]["all"]["overview"]
ended = [r for r in self.runs if r["outcome"] in ("Bonded",) + DEATHS]
self.assertEqual(o["cadets"] + o["deliberate"], len(ended))
self.assertEqual(o["deliberate"], sum(1 for r in ended if r["_deliberate"]))
self.assertEqual(o["bonded"] + o["dead"], o["cadets"])
def test_map_bond_denominators_skip_deliberate_deaths(self):
m = self.out["presets"]["all"]["map"]
for i, nd in enumerate(m["nodes"]):
for t, bt in m["by_target"].items():
n = bt["nodes"][i]["n"]
if t.startswith("bond_"):
self.assertLessEqual(n, nd["n"])
else:
self.assertEqual(n, nd["n"], t)
# somewhere in the sample a deliberate death reached the map, so some bond denominator is smaller
self.assertTrue(any(bt["nodes"][i]["n"] < nd["n"] for t, bt in m["by_target"].items() if t.startswith("bond_")
for i, nd in enumerate(m["nodes"])))
def test_encounters_leave_out_deliberate_deaths(self):
for e, spec in zip(self.out["presets"]["all"]["analyse"]["encounters"], SS.M["encounters"]):
col = spec["column"]
n = sum(1 for r in self.runs if SS.match(r, spec["where"]) and r.get(col) in ("Bonded!", "Incinerated")
and not r["_deliberate"])
self.assertEqual(e["overall"]["n"], n, e["context"])
def test_paths(self):
p = self.out["paths"]
self.assertEqual([lay["key"] for lay in p["layers"]], [lay["key"] for lay in SS.M["path_layers"]])
for lay in p["layers"]:
self.assertEqual(sum(lay["counts"].values()), lay["runs"], lay["key"])
self.assertEqual(set(lay["lines"]), {"lived", "chose", "failed"})
bot = next(lay for lay in p["layers"] if lay["key"] == "bot")
self.assertGreater(bot["counts"]["chose"], 0) # the bot burns on purpose: drawn as chosen deaths
self.assertEqual(set(p["unrouted"]), set(SS.M.get("path_unrouted", [])))
def test_json_safe(self):
import json
json.dumps(self.out, allow_nan=False) # the page cannot parse NaN or Infinity
if __name__ == "__main__":
unittest.main()