drwily/gogobee
1
0
Fork 0
mirror of https://github.com/prosolis/gogobee.git synced 2026-09-14 19:01:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: drwily/gogobee:85e5ba5fce32f80cd9508c9a6e342e42e5b31af0
Branches Tags
drwily/gogobee:main drwily/gogobee:dependabot/go_modules/maunium.net/go/mautrix-0.30.0 drwily/gogobee:dependabot/go_modules/golang.org/x/image-0.45.0 drwily/gogobee:dependabot/go_modules/modernc.org/sqlite-1.56.0 drwily/gogobee:dm-cadence-daily drwily/gogobee:w9-verbs-and-polish drwily/gogobee:equip-review-fixes drwily/gogobee:mischief-m3 drwily/gogobee:mischief-m1 drwily/gogobee:adventure-news drwily/gogobee:fix-automigration-player-meta-seed drwily/gogobee:sim-real-char-harness drwily/gogobee:n6-rivalry-siege drwily/gogobee:n3-p8-enemy-action-economy drwily/gogobee:review-followups-a-b drwily/gogobee:n1-restoration drwily/gogobee:long-expeditions-d1 drwily/gogobee:link-thumbnails-wotd-default drwily/gogobee:ignore-other-bots drwily/gogobee:camp-heal-on-pitch drwily/gogobee:restore-phase-H-orphans drwily/gogobee:forex-crypto-coingecko drwily/gogobee:phase-H-harvest-charges drwily/gogobee:holdem-tips-validation drwily/gogobee:feature/archetype-system drwily/gogobee:feature/uno-sudden-death
...
compare: drwily/gogobee:dependabot/go_modules/golang.org/x/image-0.45.0
Branches Tags
drwily/gogobee:dependabot/go_modules/maunium.net/go/mautrix-0.30.0 drwily/gogobee:dependabot/go_modules/golang.org/x/image-0.45.0 drwily/gogobee:dependabot/go_modules/modernc.org/sqlite-1.56.0 drwily/gogobee:dm-cadence-daily drwily/gogobee:main drwily/gogobee:w9-verbs-and-polish drwily/gogobee:equip-review-fixes drwily/gogobee:mischief-m3 drwily/gogobee:mischief-m1 drwily/gogobee:adventure-news drwily/gogobee:fix-automigration-player-meta-seed drwily/gogobee:sim-real-char-harness drwily/gogobee:n6-rivalry-siege drwily/gogobee:n3-p8-enemy-action-economy drwily/gogobee:review-followups-a-b drwily/gogobee:n1-restoration drwily/gogobee:long-expeditions-d1 drwily/gogobee:link-thumbnails-wotd-default drwily/gogobee:ignore-other-bots drwily/gogobee:camp-heal-on-pitch drwily/gogobee:restore-phase-H-orphans drwily/gogobee:forex-crypto-coingecko drwily/gogobee:phase-H-harvest-charges drwily/gogobee:holdem-tips-validation drwily/gogobee:feature/archetype-system drwily/gogobee:feature/uno-sudden-death
43 Commits
85e5ba5fce ... dependabot/go_modules/golang.org/x/image-0.45.0
Author SHA1 Message Date
dependabot[bot] 1e00d2585f build(deps): bump golang.org/x/image from 0.40.0 to 0.45.0 
Bumps [golang.org/x/image](https://github.com/golang/image) from 0.40.0 to 0.45.0.
- [Commits](https://github.com/golang/image/compare/v0.40.0...v0.45.0)

---
updated-dependencies:
- dependency-name: golang.org/x/image
  dependency-version: 0.45.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
 2026-08-19 12:14:42 +00:00
prosolis b1e6937c0c digest: report the day the player actually played 
The morning digest looked up log entries by e.CurrentDay - 1, which
assumed the day rollover happens in deliverBriefing. That only holds for
legacy UTC-anchored runs; event-anchored expeditions roll current_day at
night camp, so by 06:00 CurrentDay is already the day that is starting
and the digest reported a near-empty day. Window on the last briefing
timestamp instead, which also covers nights the autopilot never camped.

Also count real rooms out of the auto-walk summary instead of counting
ticks, and only emit the site footer when the Pete seam is on, since the
roster push is what creates the page the link points at.
 2026-07-26 21:00:12 -07:00
prosolis ae5e10435a expedition: cut the DM drip to one message a day 
Adventure's web feed now carries a live per-room run log, so the bot no
longer narrates every beat into Matrix. The three per-player DM sources
that fired on a clock collapse into the 06:00 briefing:

  - ambient events (6h cooldown, up to ~3/day)
  - the 21:00 recap
  - the autopilot's Night-camp end-of-day digest

Only the messaging goes quiet. Every mechanical effect still fires on
exactly the schedule it always did: ambient still applies its ±SU and
threat nudges, the recap still runs the night wandering check and its
threat bump, the night camp still burns supply and rolls the day. Each
now writes its outcome to the expedition log and stops there, and the
next morning's briefing reads that log back as a "Since yesterday"
block -- walks collapsed to a count, frame and narration types skipped,
capped with an explicit overflow note so a truncated digest never reads
as a complete one.

The briefing carries the reader's own /adventure/who/{token} link,
reusing the salted one-way roster token the board already publishes, so
a DM link and a board link resolve to one page and neither leaks a
Matrix handle. PETE_PUBLIC_URL overrides the default; it is deliberately
not PETE_INGEST_URL, which is Headscale-only and unreachable from a
player's phone.

N1/A6's digest-anchored mid-day event roll moved to deliverBriefing
along with the digest. An anchored roll's whole premise is firing at a
moment the player is demonstrably reading a DM, and the night camp no
longer sends one; leaving it in place would have quietly starved the
anchor for exactly the autopilot-only player it was added for.

Interrupt-driven DMs are untouched: a fork needs a human, a death and a
run-completion are terminal, and a boss-safety hold is an explicit
stop. Batching those would strand a decision behind the 8h auto-pick or
report a finished story.

Net effect for a player with an active expedition: roughly 6-10 DMs a
day down to one, plus whatever genuinely interrupts.

Tests: the recap and ambient send paths had no coverage at all, so
nothing would have caught them silently dropping their mechanics along
with their message. Adds behavioural tests via the message sink for all
three silenced paths, digest rendering, token-not-handle in the URL,
and a keep-set regression guard.
 2026-07-26 20:34:42 -07:00
prosolis 77dde5d133 dm: stop creating a duplicate DM room on every restart 
GetDMRoom's lookup chain could never hit. The in-memory cache died with the
process, and the m.direct account data it fell back on was never written by
the bot -- room creation only ever populated the map. As an appservice user
there is no /sync to populate it either, so after each restart the first DM to
a user fell through both checks and created a fresh room.

Persist the mapping in a new dm_rooms table and read it before anything else.
Creation now also publishes m.direct, so clients label the room as a DM.

A stored room is checked for liveness before reuse, counting the user as
present while merely invited -- they often never accept, and treating that as
gone would recreate the room on every send, which is the original bug wearing
a different hat. The same check now guards the m.direct path, which previously
took the last entry on faith.

Two adoption paths keep existing rooms from being orphaned: user-initiated DM
invites are claimed on join, and a room the user is already talking in is
adopted on first message (negative-cached so group rooms cost one member
lookup, not one per message). For users predating the table, a one-shot sweep
of joined rooms runs only on the path that would otherwise create a duplicate.

The sweep cannot rank duplicates -- without /sync there are no timestamps, so
it takes the newest by room-list order. First message from the user corrects
any wrong pick.
 2026-07-26 10:16:53 -07:00
prosolis 583616f9d0 llm: route every LLM caller through a shared backend client 
Replaces the per-plugin Ollama HTTP calls with internal/llm, which picks a
backend from the environment (vLLM or Ollama) behind one Chat interface, plus
internal/plugin/llm_client.go as the plugin-facing wrapper.

Startup now logs llm_backend/llm_endpoint/llm_model instead of the two
OLLAMA_* vars, which no longer describe where inference actually goes.

These files were already running in prod from the vLLM migration but had never
been committed; this is that live state, byte-for-byte.
 2026-07-26 10:16:33 -07:00
prosolis 3f9c338e67 adventure: give tier 6 a treasure rate, and stop it lying about near misses 
advTreasureDropRates stopped at tier 5, so every Mythic-zone roll returned
nil before it reached a pool: postgame zones have dropped no treasure at
all since T6 shipped. Add the rate, deliberately above T5's rather than
continuing the downward curve — a Mythic run is gated behind L18 and both
T5 bosses, so the same declining rate would mean a postgame player never
sees one.

The rate alone drops nothing: there is no advAllTreasures[6] yet, and
writing those four items is content work, not a code fix. TODO in place
where the pool goes, and a test that goes red the day it lands.

An empty pool now reports a zero rate instead of the configured one. The
caller reads a close roll as "treasure: just missed" — with a rate but no
pool that DM fires on the rolls the player actually won, for a treasure
that cannot be won. Better to say nothing until there is something to win.
 2026-07-25 10:33:59 -07:00
prosolis afa49b2d4c adventure: name the zone the treasure actually came from 
Every Tier 5 treasure line said the Abyssal Maw, whichever zone the drop
came from. A find in Dragon's Lair announced itself as the Maw while
Pete's dispatch, which reads the real location off the fact, named the
Lair. Two tellings of one moment that disagreed about where it happened.

Substitute the location instead, in the room announce and the discovery
DM both. {location_mid} lowercases the leading article so a line reads
"found in the Abyssal Maw" after a preposition; {location} keeps the
display form for sentence-initial and "The {location}" positions, which
the T1-T4 pools already rely on.
 2026-07-25 10:21:32 -07:00
prosolis c8878b095c flavor: rewrite rhythm-only lines, fix B2 voice-pass grammar scars, add lines 
- Rewrite the LootDropCommon offenders and ~20 other lines that had the
  cadence but no concrete detail (per VOICE_CANON craft rules)
- Fix 7 grammar scars from the third-person-to-first-person B2 pass
  ("...and am not worth picking up" where the subject wasn't TwinBee)
- Replace generic "every RPG" references with specific ones
- Add new lines across ambient/GM/housing/NPC pools, incl. funny-word
  register (kerfuffle, skedaddle, lollygagging) played straight
- New Thom Krooke line follows the pet-first arc
 2026-07-25 09:52:36 -07:00
prosolis 96f2125944 Merge party-known-flag: tell Pete this build knows what a party seat is 2026-07-24 23:16:25 -07:00
prosolis 10d1e4adf5 adventure: tell Pete this build knows what a party seat is 
The party list is omitempty, so a solo run and a game box too old to push
seats reach Pete as the same empty slice, and those two want opposite
buttons. Pete's page was reading the empty one as "solo, therefore leader"
and offering a party member the button that throws away everyone's day.

One boolean, set on every sheet a build makes — in town, solo, or seated
with three others. It says something about the sender, never about the
character, so it is set unconditionally: a conditional flag would read as
"this player is solo" and land straight back in the hole it closes. An
older build sends no key at all, which decodes to false, which is the
answer Pete wants when it cannot tell.

Pete's half shipped already and withholds the button until this arrives.

Verified end to end against a local Pete, not just in tests: a solo leader
on a live expedition gets "Call the whole thing off" back, a member still
gets "Turn back alone" and never the abandon, and stripping the flag from
the same push takes the solo button away again.
 2026-07-24 23:03:58 -07:00
prosolis ba41dc2d1b Merge w9-verbs-and-polish: headless verb twins, realm-firsts repair, review fixes 
Claude-Session: https://claude.ai/code/session_012bxpQQJDjC1mTtLN3VVtBQ
 2026-07-24 22:08:00 -07:00
prosolis 34519c9145 adventure: give the summary long enough to wake the model up 
The run summary had sixty seconds, which is a generation budget, and
this call almost never gets to just generate. Runs end hours apart,
Ollama drops an idle model after about five minutes, so the steady state
is weights on disk and a cold load before the first token. The old
budget expired during that load every time and filed the empty beat that
means "no summary, ever" — there is no retry, the beat itself is the row
that stops the sweep re-picking the run. Five minutes now, sized for
load-then-generate, so a timeout means what the comment always claimed
it meant: the box is down.

That can't sit on a two-minute ticker, so it doesn't. The sweep starts
beside the ticker behind a single-flight flag; ticks that land during a
load skip instead of queueing. Nothing reorders — the summary is written
to the local buffer with the next seq and still ships behind the run's
own log.

Claude-Session: https://claude.ai/code/session_012bxpQQJDjC1mTtLN3VVtBQ
 2026-07-24 22:07:47 -07:00
prosolis 509df7fadf adventure: stop the log claiming a win it didn't see 
Four things the review found, all of them the code telling a player
something that isn't true.

A run that walks into a dead end filed its ending as "cleared" whatever
the caller said, so both the liveblog and the summary reported a clear
for a party that merely ran out of map — and the end beat is
first-writer-wins, so nothing later could take it back. It says
"cleared" only for a boss now.

The re-offer branches of babysit and resume returned a zero cost, so a
player who was in fact charged read "0 coins" in the verdict. Both
re-quote the price they actually took.

And the realm-firsts reseed retired its one-shot job even when the read
under it had failed, which on a transient fault at Init would have left
the ledger mis-dated permanently. The read now says whether it worked,
and the job stays open when it didn't.

Claude-Session: https://claude.ai/code/session_012bxpQQJDjC1mTtLN3VVtBQ
 2026-07-24 22:07:38 -07:00
prosolis c327cfc5f1 adventure: give the web the three doors it kept pointing at 
The web's own refusals named commands it had no button for: "!expedition
abandon first", "!expedition leave to walk out alone", "no refund if you
cancel early". Three verbs, no arguments, no money.

Each Matrix handler becomes framing over a headless twin the order path
shares, so the web runs the game's real path: an abandon still disbands
the roster, still retires the region runs, still DMs the party, still
rolls the emergence pet.

The lock asymmetry is per verb and is the thing to be careful about.
performExpeditionAbandon and performExpeditionLeave cannot take
advUserLock — their Matrix caller holds it across the whole !expedition
switch — so their web wrappers do. performBabysitCancel takes it itself,
because its caller does not, so its wrapper must not. Both directions are
pinned by tests that hang rather than fail on regression.

Also flips the two W5a extract tests off setupZoneRunTestDB: it copies
data/gogobee.db and skips when it is missing, so they have been
green-by-skipping since they were written.
 2026-07-24 21:42:40 -07:00
prosolis a27fb298af adventure: repair the realm-firsts ledger the backfill got wrong 
The one-shot that seeded news_realm_firsts filtered on `abandoned = 0`, and
`abandoned` does not mean anybody gave up: abandonZoneRunByID exists to retire a
run whose boss is already dead when the expedition travels onward, which is how
30 of prod's 32 boss kills are stored. So the ledger holds 6 zones where the run
history knows 9, and it dates every row to the minute the job ran rather than to
the clear.

The ledger is what claimRealmFirst tiers live dispatches against, so each missed
zone is a spurious PRIORITY "realm first" waiting to fire the next time somebody
clears it, months late.

Fix the shared query, and add a re-seed (not a re-run) under its own job name: it
writes the ledger, backdated to the real earliest clear, and emits nothing at
all. It runs regardless of the news switches, because a ledger that is right only
while emission is on mis-tiers the first dispatch after somebody flips it. Kept
in place afterwards as an ordinary bootstrap for fresh deploys.

Claude-Session: https://claude.ai/code/session_012bxpQQJDjC1mTtLN3VVtBQ
 2026-07-24 20:35:47 -07:00
prosolis e5d4bd6dc5 adventure: tell Pete who else is on the expedition 
Party seats ride the roster detail, beside the supply and threat numbers the
same expedition already publishes. Leader first, the hireling named without a
token he has no board row for, and an opted-out player's seat kept and
anonymised — dropping it would make a party of three read as a pair while the
burn rate and enemy scaling beside it still felt three bodies.

The board itself was wrong about this: it resolved an expedition with a lookup
keyed on dnd_expedition.user_id, which is blind to members, so for the whole
life of N3 parties a seated player has shown as idle in town while standing in
a dungeon.

Pets also send the engine's XP threshold for their current level band, so the
web can draw progress without keeping a copy of a curve that would drift.
 2026-07-24 20:26:28 -07:00
prosolis f73ab56ac8 adventure: run the web's three new verbs through the game's own paths 
The game-side half of setting out, going back in, and hiring the sitter from
the web. Each is the existing command minus its framing: performExpeditionStart,
performResume and performBabysitPurchase now hold the guards and the money, and
!expedition start, !resume and !adventure babysit are what is left over. So a
departure booked from a phone is the same departure - same eligibility chain,
same supply freebies, same opening log line - rather than a second one that
drifts.

Refusals travel as advRefusal, which wraps a sentinel AND carries the finished
sentence. That is what lets the commands keep the exact copy they always sent
while the web gets a machine-readable verdict.

All three spend coins on a retrying wire, so the debit is keyed to the order
guid and a re-offer cannot charge twice. The subtle half is what a re-offer
should ANSWER: a settled debit plus an already-started expedition means the
order worked and lost its ack, not that the player is busy, so it reports
applied instead of refusing the thing it did. Nothing refunds-then-retries -
after a refund the keyed debit will not charge again, so a retry would hand over
the goods for free, and every failure past the debit is therefore permanent.

Also fixes a deadlock that predates all of this: !expedition extract and
!expedition resume are aliases for two commands that take the per-user lock
themselves, and the alias dispatcher already held it. Since it is a plain
sync.Mutex the handler blocked forever and, because the deferred unlock never
ran, every later adventure command from that player wedged too. It does not
fail loudly on regression - it hangs - so the new test asserts with a timeout.

Claude-Session: https://claude.ai/code/session_012bxpQQJDjC1mTtLN3VVtBQ
 2026-07-24 19:47:45 -07:00
prosolis fff2aa79d0 adventure: drain the actions a player asked for from the web 
Pete now records two verbs an owner can ask for: pull out of a run, and
take today's bout against the Siege. This is the game-side loop that
answers them, modelled on the equip poller down to the applied-order
ledger, because neither action is idempotent: replaying an extraction
would end a run they had resumed, and replaying a bout would spend a day
they never got back.

The web verbs run the game's own paths, not lookalikes. !extract and
!adventure worldboss fight are now thin command framing over
performExtraction and takeSiegeBout, which both take the per-user lock,
so a click and a command race each other exactly as two commands do. A
web extraction still DMs the whole party, still writes the log line, and
still resumes for seven days.

Claude-Session: https://claude.ai/code/session_012bxpQQJDjC1mTtLN3VVtBQ
 2026-07-24 18:55:52 -07:00
prosolis d6136d39d9 adventure: tell Pete what the realm is, not just what happened in it 
Adds the realm snapshot behind Pete's map, board and hall of firsts: every
zone with its clear history and who is standing in it, the ledger of things
that have happened exactly once, and one line per adventurer.

Snapshot semantics like the roster and the Siege — pushed whole, replaces
Pete's copy, dropped rather than retried. It rides the roster ticker but at a
ten-minute stride: these are aggregate scans over the whole run history, and a
first clear does not move.

Two things the real data corrected, neither of which any unit test would have
caught:

`abandoned` does not mean the player gave up. It means the run row was
retired, and abandonZoneRunByID exists precisely to retire a run whose boss is
already dead when the expedition travels on. 30 of prod's 32 boss kills carry
abandoned = 1, so filtering on `abandoned = 0` — as this did, copying the
shipped backfill — drew a realm in which almost nothing had ever been beaten.
boss_defeated = 1 is the clear.

And news_realm_firsts is not a usable history book on its own. It only covers
what happened after the news seam went live, its one-shot seeder carried that
same wrong filter, and its first_at is when the claim was written down, not
when the thing happened — every backfilled row in prod shares one timestamp.
So the zone half of the hall is derived from the run history instead, which is
complete and correctly dated, and the ledger supplies the kinds the run
history knows nothing about. That also makes the hall agree with the board by
construction rather than by coincidence.

Opt-out follows the rule that fits each surface: a first-clearer is anonymised
(deleting the claim would redraw a conquered zone as unbeaten), a player is
dropped from the board outright, and presence is dropped entirely — who is in
a dungeon right now is the live-location fact the liveblog already refuses.

Claude-Session: https://claude.ai/code/session_012bxpQQJDjC1mTtLN3VVtBQ
 2026-07-24 17:55:05 -07:00
prosolis 7a5c8341f0 adventure: read a finished run back and tell Pete what it was about 
Two halves of the same gap. A dispatch announcing a clear, a retreat or a death
said how an expedition ended and gave a reader no way to reach what happened in
it — so those three facts now carry the run they concluded, and Pete's permalink
can open the log behind the headline.

Finding that run is done by asking what is actually true at the moment a
dispatch is filed rather than by threading a run id through five call sites that
have already let go of it. Both guards on that lookup are load-bearing: a run
with no beats behind it would mint a link to a 404, and without the recency
window a campaign death at the Empty Throne would attach itself to whatever
dungeon that player last walked.

The other half is the summary. Every line of the liveblog is assembled by Pete
out of a beat's own nouns, which is right for a log — it has to be exactly what
happened, in order. But a report is read afterwards and the question it answers
is not "what happened", it is "what was that run", and that is a judgement. So
this is the one piece of prose on the channel, and it earns the model far better
than a dispatch headline does.

It runs on the roster ticker, not at the moment the run ends. A run ending is
already a chokepoint with a dispatch being authored against it, and a second
generation there would stall the command that killed the boss. One per tick, and
a run that can't be summarised is closed out with an empty beat rather than
retried forever — the row is what stops the sweep picking it up again, and a
report with no summary is still the log and the numbers.

The prompt states the one permitted name twice and forbids arithmetic: a model
asked to write warmly about a party will invent a second member of it, and a
total it works out itself will contradict the exact totals printed beside it.
Both were seen against the real box before this was tightened.

Claude-Session: https://claude.ai/code/session_012bxpQQJDjC1mTtLN3VVtBQ
 2026-07-24 17:11:21 -07:00
prosolis a5b1961486 adventure: send Pete the run, room by room 
The engine narrates every fight, trap and haul to one Matrix DM and then
discards the shape underneath it. This records that shape as it happens so
Pete can retell the run to somebody who wasn't in the room.

Beats ride the roster ticker (one extra request per two minutes, not one per
room) but on their own table, never pete_emit_queue: they are high-volume and
low-stakes, and a chatty run must not be able to spend the retry budget a
death dispatch depends on. Unlike the snapshots they ARE retried — a dropped
beat is a hole in a story, not a stale number the next tick corrects.

Recording is a leaf everywhere it is called. If a beat can't be written the
walk carries on exactly as it did before this existed.

Privacy is stricter here than on the board. The board omits an opted-out
player from a snapshot; a liveblog would be an account of where they are and
what is happening to them, so their beats never leave the box at all — and a
run whose owner can't be resolved is refused rather than published.

Claude-Session: https://claude.ai/code/session_012bxpQQJDjC1mTtLN3VVtBQ
 2026-07-24 16:34:02 -07:00
prosolis 0570afc2e4 worldboss: push the Siege to Pete and file its three dispatches 
The Siege had no web presence at all, and three dispatch templates
(siege_start / siege_win / siege_loss) have been sitting written and
unemitted in Pete's renderAdventure since the adventure section shipped.
Both halves fixed here.

The snapshot rides the existing roster ticker with the roster's rules:
pushed whole, replacing Pete's copy, dropped rather than retried on
failure. Retrying would be a lie about how much HP is left, and the next
tick carries the truth anyway.

The muster carries EVERY alive adventurer, not just contributors. The
zero-fight rows are the point: one bout per person per day means somebody
who hasn't swung today is a hit the town hasn't taken, and Pete can only
draw that column if the people in it are on the wire.

Opt-out departs from the board's rule on purpose. The board omits an
opted-out player outright — class + level + zone re-identifies them. A
contributor here is anonymised instead: the damage they did is on the
boss and is part of what the town accomplished, so deleting it would
understate the shared effort and stop the totals adding up. They keep
their damage and their rank, and carry no board token, so nothing links
back to a page that names them. An opted-out player who never fought is
still dropped — nothing to account for.

The three dispatches key their GUID on the boss row id, so a resolution
path re-entered (a redeploy mid-window, the ticker's safety net firing
after an inline kill) files the same guid and Pete dedupes it, rather
than announcing one Siege to the room twice.

Also retires the stale "deploy Pete first, an unknown event_type is a
400" note on emitBoredomDeparture. Pete now publishes an untemplated
type on a neutral fallback and counts it for the operator, so the
ordering is a property of the system rather than a rule to remember.
 2026-07-24 15:21:36 -07:00
prosolis 2ce3e682ea zones: stop the tools/backtrack path losing rooms and inventory 
Review fallout from the locked-doors commit. Five defects, all in the
seams that commit opened:

backtrackFromDeadFork stepped to VisitedNodes[idx-1]. That slice is a
first-entry ordered *set*, not a path stack (see appendVisited), so once
a run has doubled back once the entry before CurrentNode can sit on a
different branch entirely — the party teleports across the map to a room
no edge connects. `!revisit` refuses exactly that move via
adjacentNodes; the autopilot has no business doing what the player is
forbidden from doing. Now routed through backtrackTarget, which also
refuses to fall back into a corridor whose only exit is the sealed fork:
the lock rolls are seeded per (run, edge), so walking back in gets the
same answer every time, forever.

The autopilot spent the player's thieves' tools *before* committing the
move, so an advanceZoneRunNode failure left them charged and then had
the caller's backtrack clear the fork they had just paid to open. The
tools are now reported by autoPickWithTools and only removed once the
party is actually through the door.

`sell all` never learned the new "tool" type and turned a €600 set into
€300 of loot — the same silent deletion Robbie was taught to avoid two
commits ago. It was already doing this to "key" quest tokens, so both
now sit with the special gear.

The shop's tools branch asked "is the reply a substring of Thieves'
Tools", which is true for a bare "s", for "to", and for an empty message
body — and it runs ahead of the consumable list, so a stray keystroke in
the Supplies view bought a set. isThievesToolsReply matches on the
item's own words instead.

Plus two cleanups in the same code: Robbie built his haul gifts by
calling consumableCache(tier, 1) in a loop when it already takes a
count, and the unlock flow read the whole inventory three times per
command.
 2026-07-21 00:20:24 -07:00
prosolis 6bcac41aa2 zones: make locked doors openable and stop autopilot stalling on them 
Locks were fully implemented as pass/fail gates and nothing else. A
Perception or stat check rolls once per (run, edge), seeded so it can't
be reload-scummed — that half shipped in G5, the counterweight never did.
A bad roll simply deleted a branch of the graph for the rest of the run,
worst for a solo low-WIS character who quietly loses routes they never
learn existed. Three changes, one theme: a die roll should not be able to
permanently wall a player.

Party's best stat answers the check. evaluateEdgeLock read only the
acting character's mods, which made a party's rogue and its hired scout
decorative at every lock. Fold the whole roster — Pete included, since
excluding him would make hiring a scout worth less than the coins it
costs — and credit whoever got it open in the fork menu.

Thieves' tools as the escape hatch. A utility item (not a ConsumableDef,
or the fight engine would spend them for you) sold on Luigi's supplies
shelf, consumed by `!zone unlock <n>`. Deliberately not a skeleton key:
tools answer the two dice-driven locks only. A key lock is a quest token,
a level-min lock is progression, a region-clear lock is structure — none
of those are "you rolled badly", so none of them are pickable.

Autopilot picks a route instead of parking. The fork timeout was 8h,
which reads as "the player gets first say" and behaves as "the expedition
stops for a third of a day, at every fork" — a multi-day expedition
crosses a lot of forks. 30m keeps a genuine first say for anyone at the
keyboard. It now ranks by unvisited-then-edge-weight rather than taking
whatever the graph author happened to list first, spends tools when every
route is locked, and backtracks a room when it can't do even that, rather
than idling into the 24h reaper and losing the player days of progress to
a roll they never saw.

Sim A/B, same seeds, 90 runs/arm: 43.3% -> 42.2% clear, a single run
flipping and well inside the documented noise floor. A party+companion+pet
arm runs 31/32 clean through the new roster-folding path.
 2026-07-20 23:52:20 -07:00
prosolis 71b97763ce robbie: pay for the haul, not just for showing up 
The gift was one consumable every 10th visit, flat. A visit is a 40%
daily roll, so that works out to one item per ~25 real days — and it paid
exactly the same for a stockpile of sixty items as it did for one rock.
The player controls volume, not visit count, so volume is what the new
track pays on: one consumable per 15 items carried off, capped at 3,
stacking with the existing loyalty gift.

Also stop Robbie stealing thieves' tools. He skips keys already, for
exactly this reason — a key is bought to open something later, and a
bandit who pockets it between the purchase and the door has taken the
thing the player paid to still have. Tools are the same shape of promise.
 2026-07-20 23:52:03 -07:00
prosolis 690ff758fe worldboss: spawn the monthly Siege without the day-1 deadlock 
The Siege has never once spawned in prod. `select count(*) from
world_boss` is 0 and daily_prefetch has no worldboss_spawn row at all.

worldBossTick only auto-spawned when now.Day() == 1. The world boss
landed on main 2026-07-10..13 and the first deploy carrying it was after
July 1, so prod has never run a first-of-the-month tick with the code in
it. The feature has been live and unreachable for weeks, and the next
natural spawn would have been August 1.

The same gate also silently skipped any month where the bot happened to
be down or redeploying across the 1st, with no catch-up — one missed
minute costs the town a month.

The month key is already the whole dedup, so drop the day check and let
the rule be what it always read as: one Siege per calendar month, as
early as the process is up to run it. A missed 1st now self-heals on the
next tick.
 2026-07-20 23:52:03 -07:00
prosolis ca2d1a8ea3 pets: earn XP from combat wins again 
petGrantXP has been dead code since R1 deleted the legacy daily activity
loop it used to ride. Nothing replaced the call, so for the whole life of
Adventure 2.0 the only pet XP in the game came from a paid babysitter.
Prod bears it out: the one player who never subscribed has a pet sitting
at level 1 with 0 XP after months of play.

That is not cosmetic. DerivePlayerStats scales PetAttackProc,
PetDeflectProc and PetAttackDmg off pet level, so a frozen pet is a
permanently dead combat slot that the player has no way to revive.

Wire it into postCombatBookkeeping — the one seam all four combat
close-outs already meet, so a pet cannot level differently depending on
whether the fight auto-resolved or was played a round at a time. Both
slots earn on the same win, matching the babysit trickle: combat only
reads the two pets' averaged procs, so leveling both is not a spike.

Writes go through the narrow per-slot pet upserts rather than
saveAdvCharacter, because this runs on a path that does not hold the
per-user lock and a full-row write could clobber a concurrent save.

Verified against the sim: a level-3 pet finishes one L10 expedition at
level 4 with carryover, where before it finished exactly where it started.
 2026-07-20 23:51:49 -07:00
prosolis 5a8d21f780 adventure: fix concurrency + dup hazards in web equip path 
Code review of the Ask-7 web equipment-management path surfaced three
correctness issues, all fixed here:

- applyEquipOrder ran the poll-goroutine equip mutations without the
  per-user advUserLock that every Matrix-side mutation (!give, !equip,
  arena, …) holds, so the lock gave no mutual exclusion against the web
  path. A concurrent !give of the item being equipped could duplicate it.
  Now takes advUserLock(owner) for the whole apply, matching the DM path.

- applyMasterworkEquip evicted the displaced occupant to the pack BEFORE
  the destructive slot write, so a fault left the piece both worn and in
  the pack — and the 30s equip poll retry re-evicted it every tick. Now
  removes the incoming row, writes the slot, then re-packs the occupant
  last as a best-effort step: once the slot no longer references it, the
  re-pack cannot duplicate, and a failure is logged not aborted on (the
  DM confirm handler's tolerance).

- PlayerDetail.Balance dropped omitempty: a real €0 balance is an
  informative fact, not an absent one, and omitting it left the web
  confirm dialog with no balance to show.
 2026-07-17 21:04:38 -07:00
prosolis 68c8cdff2d adventure: ask 7 — apply web equipment management (poll half) 
Mirror of Pete's ask 7. gogobee polls the equip queue and applies the new
actions against the five standard gear slots:
  - equip: routes MasterworkGear/ArenaGear to applyMasterworkEquip (evicts
    any special occupant back to the pack; downgrade-blocked), else the
    existing applyMagicEquip.
  - unequip: EquipmentSlot vocabulary -> applyMasterworkUnequip (resets the
    slot to its tier-0 default, keeps the row), else applyMagicUnequip.
  - upgrade: purchaseEquipmentTier, euro-idempotent (DebitIdem keyed on the
    order GUID), downgrade + max-tier guarded.
  - repair: repair(), euro-idempotent, recomputes blacksmithRepairCost.

Detail push now carries Slots (EquipSlotView x5) + Balance; itemViews gives
masterwork/arena backpack rows an equip id; the compare decorator is guarded
to magic-only. buildDetailSnapshot is a method so it can read the euro balance.

Retry-safety: no CreditIdem refund on a later save fault (would double-pay a
guid-guarded retry) — we return retry=true and let the next poll re-run, since
the debit is guid-idempotent and the slot write is idempotent. Matches the
casino escrow precedent. Unit tests cover downgrade block, max-tier,
insufficient funds, idempotent replay, eviction, and take-off reset.

Deploy AFTER Pete: Pete's ingest must accept the new verdict strings before
this side emits them.
 2026-07-17 20:34:56 -07:00
prosolis b29dcf4360 combat: relabel DamageReduct comments to match calcDamage player-defender direction 
Review follow-up on the caster-floor rebaseline: the survival-half doc in
casterBlasterFloor described an HP add the code never makes (Defense only),
and the pre-existing Druid *0.95 rider still read as a damage cut when, for a
player-defender through calcDamage, DamageReduct<1 raises damage taken. Comment
-only; no runtime change, guardrail test unaffected.
 2026-07-17 17:22:06 -07:00
prosolis 1f62a8e842 combat: revive the caster sustained-cantrip floor in the turn engine 
The arcane-blaster "sustained floor" passives (CantripPerRound, DamageBonus,
FlatDmgStart from casterBlasterFloor) were built for the swing-based engine
(SimulateCombat, combat_engine.go:590). But every live expedition auto-resolves
through the turn engine (autoDriveCombat -> session -> combat_turn_engine),
where casters autocast every turn and never weapon-swing -- so CantripPerRound
never fired and DamageBonus was inert. Casters fought at bare cantrip dice
(~4d10~=22 at L20) instead of their intended floor, in sim AND in prod. This is
why every caster damage dial read as a dead lever across the whole rebaseline.

Fix (combat_cmd.go): bridge the already-computed CantripPerRound into the
turn-engine damage-cantrip cast, hit-gated (only lift a cast that already
connected, so the ~35% miss variance survives and the floor isn't a guaranteed
flat hammer). Self-targeting: only Mage/Sorcerer/Warlock carry a nonzero
CantripPerRound -- martials swing (untouched), cleric/bard/druid have floor 0.

Tuning (dnd_passives.go): casterCantripBase 9 -> 3, now a live, class-specific
lever. Mage/Sorcerer take base 3; Warlock passes 0 (its bare-dice cantrip plus
a structural edge already lands it mid-band, so an added floor overshoots).
Removed the dead casterHPPerLevel rider (it inflated the truncation-fraction
denominator without adding startable HP -- a bug).

Also lands the deterministic-seeding infra (sim_seed.go + simIntN/simFloat64
threading) used to read these deltas out of the process-seed noise; prod is
byte-identical (unseeded -> package rand).

Confirmation (expedition-sim, L20 T5 dragons_lair+abyss_portal, n=250):
casters now in the 35-45 floor -- sorcerer 39, mage 38, warlock 36; martial
leaders undisturbed (rogue 68, druid 66, ranger 65, fighter 64, ... paladin 55).
 2026-07-17 16:17:41 -07:00
prosolis 6e2782ac48 adventure: honor death-cheats on a cantrip kill and narrate the cantrip 
A caster's at-will cantrip that lands the killing blow returned via a raw
enemyHP<=0 read, skipping enemyDown -- so a survive_at_1 boss or T6 Valdris's
phylactery rebirth died instead of cheating death. Route it through enemyDown,
matching resolvePlayerAttack and the concentration-tick path.

Also add the missing renderEvent "cantrip" case: the CantripDesc narration
hook was set but never rendered, so cantrip damage dropped enemy HP with no
log line.
 2026-07-17 10:51:33 -07:00
prosolis 7e59697754 adventure: tell Pete whether a backpack item beats what's worn 
For each backpack magic item, compute the per-stat diff against whatever
occupies the slot it would equip into (mi.Slot — the same slot the web
Equip button targets, so the card describes the trade that actually
happens). The verdict is strict dominance: all-gain is an upgrade, all-loss
a downgrade, mixed a sidegrade with no winner claimed (the case the two
opaque effect strings could never show). Empty slot reads 'new'; an
attunement item with no free bond reads 'inert', which overrides the stat
verdict because wearing it does nothing.

The diff is over tempered effects on both sides and reuses the engine's
own magicItemEffectFor, so nothing here re-derives power math that could
drift from the game. Rides an additive Compare object on the private
backpack ItemView — no migration, no endpoint, no public surface.

Rings collapse to the same path: every ring equips to ring_1 (ring_2 is
declared but never assigned by any live code), so a backpack ring simply
compares against the ring_1 occupant.
 2026-07-17 10:04:18 -07:00
prosolis 22b7949791 adventure: author Pete's dispatches in his voice with the local LLM 
emitFact now runs the final fact through authorDispatch, which asks the local
Ollama model for a warm-reporter headline and lede and ships them on the Fact.
Pete guards and publishes them, falling back to its own templates on anything
it rejects — so authoring is best-effort by design: LLM off, a timeout, a
malformed generation, or an over-length pair all return an empty prose pair and
Pete templates the fact. The names allowed in the prose are the fact's Actors,
built from the post-opt-out subject/opponent, so what the model may say and what
Pete's guard permits are the same list. Synchronous like the holdem tip rewrite,
but on a tight 15s budget: news facts are infrequent and a template now beats a
voiced dispatch late. With no route for Pete to call back into this box, the
voice lives in the prompt here rather than in a Pete-owned inference endpoint.
 2026-07-17 09:28:13 -07:00
prosolis fbed45fc96 adventure: tell Pete when a story-grade treasure is found 
A treasure that earns a public room announce now also files a treasure_found
fact, so Pete can count it on the finder's trophy case. The emit rides inside
announceTreasureToRoom, reusing the RoomAnnounce != "" gate as the newsworthiness
filter — a copper-piece pickup never becomes news, and a reversed auto-swap never
emits, because the announce it shares is cancelled on undo.

The realm's first finder of a given treasure is a priority hoard; a later finder
of the same item is a bulletin, keyed on the treasure across the realm via
claimRealmFirst, the same first/repeat split zone_first uses. The item name rides
in stakes and the tier-derived rarity in outcome.

treasure_found is a new event_type, so Pete's ingest must deploy first or the
first finds park on the retry ladder forever.
 2026-07-17 09:09:23 -07:00
prosolis 7960838b3f adventure: drain Pete's equip queue and apply it for real 
Poll Pete for equip/unequip orders an owner placed on the web, run them through
the real magic-item equip path so bond caps and slot eviction still hold, and
file a verdict. Same reverse pipe as mischief, with one difference that matters:
the equip action is not idempotent, so a re-offered order after a lost ack would
double-move the item. An equip_applied_orders ledger keyed on the order guid is
the guard: applied once, re-offers only re-file the stored verdict.

The delicate remove-before-equip ordering that prevents item duplication is now
one shared applyMagicEquip/applyMagicUnequip core, called by both the DM
resolver and this poller, so the anti-dup ordering can't drift between two
copies. Items now carry their inventory row id to Pete as the equip handle.
 2026-07-17 08:44:44 -07:00
prosolis 32520eb7ec adventure: send Pete the fog-of-war zone map beside the room count 2026-07-17 08:18:11 -07:00
prosolis b6d4e4ccec adventure: send Pete what an item actually is, and what's worn 
The self-view listed a name, a tier and a price — everything except what a
player decides on. The facts were all there, just not on the wire.

Three things the contract spec got wrong, found by reading both sides:

Equipping *moves* the row out of adventure_inventory into
magic_item_equipped, so the two sets are disjoint. The spec's `attuned` on a
backpack item can never be true — bond state isn't false there, it's
undefined. The real gap was that worn items weren't sent at all: the panel
showed the backpack and hid the sword. Hence Equipped, where Attuned means
something and an inert item can be seen.

Stat modifiers ARE modeled. The spec said they weren't, and that shipping
them meant either an engine change or a display-only approximation that lies
the first time it disagrees with the engine. But magicItemEffectSummary is
the engine's own summary — the same function the game speaks with. Sending it
can't drift, because there's nothing to drift from.

SkillSource is two different things: "mining" on masterwork gear, and the
internal "magic_item:<id>" registry pointer on magic-item rows. Sending it
raw would put gogobee's IDs on a page, and Pete couldn't tell them apart to
filter them. Only the skill name goes out.

Desc and Effect resolve at the push site because an inventory row carries
neither — descriptions live on MagicItem/EquipmentDef, and the combat delta
is computed, never stored. Shop gear resolves by (slot, tier); Name is
decorative there.

All additive and omitempty on the private /api/ingest/detail push, so neither
side has to deploy first.
 2026-07-17 06:44:45 -07:00
prosolis 479f77b9c5 adventure: T6 Inversion Stitch (Seamstress) + boss re-strengthen (P8) 
Second in-combat Layer-2 mechanic, reusing Amendment's round-end seam. In the
Seamstress's phase 2 (<=35% HP) the room sews inside-out in a repeating
warn(1)->sting(2) cadence, telegraphed one round ahead: during a pulse player
heals (self + ally) invert to damage, floored at 1 HP. State
inversionActive/inversionTelegraph round-trips through CombatStatuses so a
suspend/resume can't drop or double a pulse.

Sim surfaced that unplace is reach-bound (only ~37% reach the boss, then cleared
her ~98%), so the mechanic alone is sub-noise. Re-strengthened the Seamstress,
the weakest T6 boss (over-softened by P7 for a zone lift that never came):
HP 385->460, Atk 39->45, Needle Rain proc 0.40->0.45. Sim-validated at
fighter zone 37.5% (in range), and a real boss fight now instead of a victory lap.

Claude-Session: https://claude.ai/code/session_0156WqjgsbmSY2U8eQ3Kkb1s
 2026-07-16 12:14:41 -07:00
prosolis 189a44e1eb adventure: T6 Amendment (Custodian) + in-combat round-end boss seam (P8) 
First in-combat Layer-2 mechanic. applyBossInCombatRoundEnd is a new
round-boundary seam called from the turn engine's stepRoundEnd, the
counterpart to the pre-combat applyBossRunModifiers. The Custodian snapshots
its HP at end of round 3 and rewinds to it once on the phase-2 crossing
(refunding front-loaded burst); a soft midnight timer past round 20 climbs
its Attack via the existing enemyAtkBuff. New state (EnemyRewindHP/Used)
round-trips through CombatStatuses so a suspend/resume can't replay the
rewind. Sim A/B (n=120 L20 party): last_meridian fighter 65->37.5% clear,
a clean -27.5pp swing attributable to the mechanic; shipped as-is per the
opt-in-endgame difficulty call.

Claude-Session: https://claude.ai/code/session_0156WqjgsbmSY2U8eQ3Kkb1s
 2026-07-16 09:20:29 -07:00
prosolis db13ed75b9 adventure: route round-end concentration kill through enemyDown (P8) 
The T6 Valdris phylactery rebirth (and the pre-existing survive_at_1
one-shot) live in enemyDown, on the premise that it is the single death
chokepoint. It isn't: the round-end concentration pulse ended the fight
on a raw enemyHP<=0 read, so a cleric's Spirit Guardians landing the
lethal blow robbed a revive-armed boss of its rebirth — exactly the
cleric-party arm P8 is tuned around. Route that win-check through
enemyDown so the boss gets its chance to stand back up. Regression test
covers both the armed (revives) and charge-less (still wins) paths.

Claude-Session: https://claude.ai/code/session_0156WqjgsbmSY2U8eQ3Kkb1s
 2026-07-16 08:41:58 -07:00
prosolis 686434f8e3 adventure: T6 Phylactery Verses + stackable-rebirth engine primitive (P8) 
The second Layer-2 postgame boss mechanic, and the first stateful in-combat one.
Valdris ("boss_valdris_ascendant", the Ossuary Ascendant) is bound to three
Verses hidden on the zone's secret nodes: every Verse the player finds and walks
before the fight unbinds one rebirth, every Verse they skip leaves it armed. A
full-clear explorer strips all three and fights a mortal lich; a speedrunner who
blows past the secrets fights a god who will not stay down.

New engine primitive: stackable rebirth. The stock survive_at_1 is a one-shot
1-HP stay; Valdris needs several rebirths that each restore a real pool.
combatState/CombatStatuses gain EnemyReviveCharges/EnemyReviveHP (round-tripped
through the turn engine so a suspend/resume keeps the live count), and enemyDown
consumes a charge after the survive_at_1 check, reviving to 25% of the
party-scaled max and emitting a phylactery_rebirth event. Zero for every
non-Valdris fight.

Unlike Greed Tax (a pure per-round recompute in applyBossRunModifiers), rebirths
are spent mid-fight, so the charge count is seeded ONCE at session creation
(seedBossRunStatuses, from unvisited secret Verses) and never re-derived on the
per-round enemy rebuild. Seeded from handleFightCmd after startPartyCombatSession.

Sim A/B (millenia, n=120 L20 party+Pete+pets, same binary, control neuters the
dispatch): mortal end (verses found) fighter 42.5% -- reproduces the deployed P7
ossuary baseline, confirming the mechanic doesn't touch the validated full-clear
path -- and the god end (0 verses) fighter 12.5%, a deadly-but-beatable flex arm.
The sim walks 0 verses (autopilot takes the first unlocked fork; Verses are
behind Perception locks), so the A/B brackets the whole player-agency gradient.

Claude-Session: https://claude.ai/code/session_0156WqjgsbmSY2U8eQ3Kkb1s
 2026-07-16 08:04:19 -07:00
prosolis fc9e055083 adventure: T6 postgame Layer-2 seam + Aurvandryx's Greed Tax (P8) 
Add the pre-combat boss-hook seam for Tier-6 postgame bosses and the first
bespoke mechanic on it.

Seam: applyBossRunModifiers(bossID, enemy, run) in postgame_boss_hooks.go —
a pure, idempotent, bestiary-ID-dispatched hook that folds run-state-derived
adjustments into the freshly-built boss Combatant. No-op for every non-hooked
enemy or nil run. The turn engine (which resolves both prod bosses and the
sim) rebuilds the enemy every round via partyCombatantsForSession, so the hook
must be a pure function of run state — fine at a terminal boss room, where the
route is frozen. Wired at both enemy-finalization points: the per-round rebuild
and buildFightSeats' initial HP persist (threaded a run param; the caller
already had it).

Greed Tax (boss_aurvandryx / first_hoard): her Attack rises with the richness
of the route walked to reach her — the summed excess LootBias (>1.0) over the
run's visited nodes. Note run.LootCollected is the wrong signal (BossOnly
signature manifest, empty at the boss); the gilded veins on the graph are.
Attack += min(2.0*richness, 12). Same-binary A/B sweep (n=150, L20 party +
Pete + pets): taxless 66.7% -> taxed 48.0%, landing first_hoard mid-band.

Claude-Session: https://claude.ai/code/session_0156WqjgsbmSY2U8eQ3Kkb1s
 2026-07-16 07:44:10 -07:00
113 changed files with 12628 additions and 985 deletions
Expand all files Collapse all files
cmd/expedition-sim/main.go
+28 -4
View File
@@ -65,9 +65,19 @@ func main() {
companion = flag.String("companion", "", "hire Pete into the party: \"auto\" fills the missing role, or name a class (cleric, fighter, …). Empty = no companion. He takes a seat but no loot/XP.")
jobs = flag.Int("jobs", 0, "matrix mode — concurrent worker count (each worker is a subprocess so it gets its own sqlite). 0 = runtime.NumCPU()")
seed = flag.Int64("seed", -1, "single-run mode — deterministic seed for zone layout + run id + combat sessions (peripheral procs stay random). <0 = off (default). Matrix mode passes this to each subprocess automatically; use -base-seed there.")
baseSeed = flag.Int64("base-seed", -1, "matrix mode — deterministic base seed. Each cell's subprocess gets seed=mix(base,level,zone,rep) (class-independent, so every class faces identical dungeons + dice). <0 = off (default, time-seeded).")
)
flag.Parse()
// Deterministic seeding for reproducible A/B tuning. Off unless -seed >= 0
// (the matrix parent sets it per-subprocess from -base-seed). Prod never
// calls SeedSim, so this is inert outside the sim.
if *seed >= 0 {
plugin.SeedSim(*seed)
}
if *petLevel < 0 || *petLevel > 10 {
fail("pet-level must be 0-10, got", *petLevel)
}
@@ -89,7 +99,7 @@ func main() {
includeLog = *logFlag
}
})
runMatrix(*classes, *levels, *zones, *runs, *bank, *cap, *days, includeLog, *jobs, *trace, *petLevel, *party, *partyClasses, *companion)
runMatrix(*classes, *levels, *zones, *runs, *bank, *cap, *days, includeLog, *jobs, *trace, *petLevel, *party, *partyClasses, *companion, *baseSeed)
return
}
@@ -200,7 +210,18 @@ type matrixJob struct {
rep int
}
func runMatrix(classes, levels, zones string, runs int, bank float64, cap, days int, includeLog bool, jobs int, trace bool, petLevel, party int, partyClasses, companion string) {
// mixSeed derives a per-cell subprocess seed from the base seed and the cell's
// (level, zone, rep) — deliberately class-independent, so every class runs the
// identical dungeon + combat dice at a given cell and A/B class deltas pair.
func mixSeed(base int64, level int, zone string, rep int) int64 {
h := uint64(1469598103934665603) // FNV-1a offset basis
for _, c := range fmt.Sprintf("%d|%s|%d", level, zone, rep) {
h = (h ^ uint64(c)) * 1099511628211
}
return int64((uint64(base) ^ h) &^ (uint64(1) << 63)) // non-negative
}
func runMatrix(classes, levels, zones string, runs int, bank float64, cap, days int, includeLog bool, jobs int, trace bool, petLevel, party int, partyClasses, companion string, baseSeed int64) {
cs := splitNonEmpty(classes)
ls := parseLevels(levels)
zs := splitNonEmpty(zones)
@@ -231,7 +252,7 @@ func runMatrix(classes, levels, zones string, runs int, bank float64, cap, days
var wg sync.WaitGroup
for i := 0; i < jobs; i++ {
wg.Add(1)
go matrixWorker(exe, workCh, resCh, &wg, bank, cap, days, includeLog, trace, petLevel, party, partyClasses, companion)
go matrixWorker(exe, workCh, resCh, &wg, bank, cap, days, includeLog, trace, petLevel, party, partyClasses, companion, baseSeed)
}
go func() {
for _, j := range work {
@@ -250,7 +271,7 @@ func runMatrix(classes, levels, zones string, runs int, bank float64, cap, days
}
}
func matrixWorker(exe string, in <-chan matrixJob, out chan<- *plugin.SimResult, wg *sync.WaitGroup, bank float64, cap, days int, includeLog, trace bool, petLevel, party int, partyClasses, companion string) {
func matrixWorker(exe string, in <-chan matrixJob, out chan<- *plugin.SimResult, wg *sync.WaitGroup, bank float64, cap, days int, includeLog, trace bool, petLevel, party int, partyClasses, companion string, baseSeed int64) {
defer wg.Done()
for j := range in {
uid := fmt.Sprintf("@sim:%s-l%d-%s-%d", j.class, j.level, j.zone, j.rep)
@@ -272,6 +293,9 @@ func matrixWorker(exe string, in <-chan matrixJob, out chan<- *plugin.SimResult,
fmt.Sprintf("-pet-level=%d", petLevel),
fmt.Sprintf("-party=%d", party),
}
if baseSeed >= 0 {
args = append(args, "-seed", strconv.FormatInt(mixSeed(baseSeed, j.level, j.zone, j.rep), 10))
}
// Left empty, each cell's followers clone that cell's own -class.
if partyClasses != "" {
args = append(args, "-party-classes", partyClasses)
go.mod
+3 -3
View File
@@ -13,7 +13,7 @@ require (
github.com/robfig/cron/v3 v3.0.1
github.com/rs/zerolog v1.35.1
github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
golang.org/x/image v0.40.0
golang.org/x/image v0.45.0
maunium.net/go/mautrix v0.28.1
modernc.org/sqlite v1.50.1
)
@@ -40,8 +40,8 @@ require (
golang.org/x/crypto v0.53.0 // indirect
golang.org/x/exp v0.0.0-20260611194520-c48552f49976 // indirect
golang.org/x/net v0.56.0 // indirect
golang.org/x/sys v0.46.0 // indirect
golang.org/x/text v0.38.0 // indirect
golang.org/x/sys v0.47.0 // indirect
golang.org/x/text v0.41.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
modernc.org/libc v1.72.3 // indirect
modernc.org/mathutil v1.7.1 // indirect
go.sum
+12 -12
View File
@@ -87,15 +87,15 @@ golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto=
golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio=
golang.org/x/exp v0.0.0-20260611194520-c48552f49976 h1:X8Hz2ImujgbmetVuW+w2YkyZChE3cBpZi2P158rTG9M=
golang.org/x/exp v0.0.0-20260611194520-c48552f49976/go.mod h1:vnf4pv9iKZXY58sQE1L86zmNWJ4159e1RkcWiLCkeEY=
golang.org/x/image v0.40.0 h1:Tw4GyDXMo+daZN1znreBRC3VayR1aLFUyUEOLUdW1a8=
golang.org/x/image v0.40.0/go.mod h1:uIc348UZMSvS5Z65CVZ7iDPaNobNFEPeJ4kbqTOszmA=
golang.org/x/image v0.45.0 h1:FMb1nTbH5H9vF55SriQHgFw5GnNL9Jg6L25BwXKzhB0=
golang.org/x/image v0.45.0/go.mod h1:n62x/7RqlwXDvGsSU4u6IUTUf6KghUZ9Bt7cG/T9Fx4=
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
golang.org/x/mod v0.37.0 h1:vF1DjpVEshcIqoEaauuHebaLk1O1forxjxBaVn884JQ=
golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=
golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk=
golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
@@ -114,8 +114,8 @@ golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -128,8 +128,8 @@ golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
@@ -148,16 +148,16 @@ golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=
golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=
golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8=
golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
golang.org/x/tools v0.46.0 h1:7jTurBkPZu4moS/Uy4OQT1M+QBlsj3wejyZwsT8Z7rk=
golang.org/x/tools v0.46.0/go.mod h1:FrD85F8l+NWL+9XWBSyVSHO6Ne4jutsfIFba7AWQ5Ys=
golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE=
golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
internal/db/db.go
+62
View File
@@ -700,6 +700,11 @@ func RunMaintenance() {
// weight the drain query already skips — drop it so a durable outage
// can't accrete rows forever.
{"pete_emit_queue_parked", `DELETE FROM pete_emit_queue WHERE sent_at IS NULL AND created_at < ?`, []interface{}{cutoff30d}},
// Run beats — the local copy is a delivery buffer, not an archive. Pete
// keeps the run report; once a beat is a week old it has either shipped
// or missed its window entirely (the liveblog it feeds is about a run
// happening *now*), so both states reap on the same clock.
{"pete_run_beat", `DELETE FROM pete_run_beat WHERE occurred_at < ?`, []interface{}{cutoff7d}},
// Rate limits — purge entries older than today
{"rate_limits", `DELETE FROM rate_limits WHERE date < ?`, []interface{}{today}},
@@ -1045,6 +1050,24 @@ CREATE TABLE IF NOT EXISTS pete_emit_queue (
sent_at INTEGER
);
-- Run beats: the room-by-room texture of an expedition, on its way to Pete's
-- liveblog. Deliberately NOT pete_emit_queue — these are high-volume and
-- low-stakes, and a run that generates forty beats must never be able to crowd
-- a death dispatch out of the retry budget. Ordering is the whole contract:
-- (run_id, seq) is the primary key and Pete is idempotent on the pair, so a
-- re-sent batch collapses and a re-ordered one still sorts right on arrival.
CREATE TABLE IF NOT EXISTS pete_run_beat (
run_id TEXT NOT NULL,
seq INTEGER NOT NULL,
kind TEXT NOT NULL,
occurred_at INTEGER NOT NULL DEFAULT (unixepoch()),
payload TEXT NOT NULL DEFAULT '{}',
sent_at INTEGER,
PRIMARY KEY (run_id, seq)
);
CREATE INDEX IF NOT EXISTS idx_pete_run_beat_unsent
ON pete_run_beat(sent_at, run_id, seq);
-- Players who opted out of being named in Pete's adventure news. Enforced at
-- emit time (anonymize, never delete). Mirrors shade_optout.
CREATE TABLE IF NOT EXISTS news_optout (
@@ -1232,6 +1255,16 @@ CREATE TABLE IF NOT EXISTS presence (
updated_at INTEGER DEFAULT (unixepoch())
);
-- DM rooms. The bot's m.direct account data is not a reliable store for an
-- appservice user (no /sync, and nothing writes it back), so the mapping lives
-- here. Without it every restart lost the cache and the bot created a fresh DM
-- room per user.
CREATE TABLE IF NOT EXISTS dm_rooms (
user_id TEXT PRIMARY KEY,
room_id TEXT NOT NULL,
updated_at INTEGER DEFAULT (unixepoch())
);
-- Markov
CREATE TABLE IF NOT EXISTS markov_corpus (
id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -1807,6 +1840,35 @@ CREATE INDEX IF NOT EXISTS idx_mischief_target ON mischief_contracts(target_id,
CREATE INDEX IF NOT EXISTS idx_mischief_buyer ON mischief_contracts(buyer_id, created_at);
CREATE INDEX IF NOT EXISTS idx_mischief_due ON mischief_contracts(status, window_ends_at);
-- The web equip queue's idempotency ledger. Pete records an owner's equip/unequip
-- intent and we poll it; the guid stamped here is what makes a re-offered order a
-- no-op. Mischief can lean on its contract row for the same job, but an equip
-- opens no durable object of its own — worse, the underlying action is NOT
-- idempotent (equipping consumes an inventory row, unequip mints a fresh one), so
-- without this a poll loop whose verdict-ack was lost would re-run the equip and
-- double-move the item. We record the guid the instant the mutation lands and
-- short-circuit on it before touching anything on a re-offer.
CREATE TABLE IF NOT EXISTS equip_applied_orders (
guid TEXT PRIMARY KEY,
status TEXT NOT NULL, -- the terminal verdict we filed, replayed on re-offer
detail TEXT NOT NULL DEFAULT '',
applied_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
);
-- The web ACTION queue's idempotency ledger — the same job as the table above,
-- for the verbs that play the game rather than dress the character (extract, a
-- Siege bout). Its own table because the two queues have their own guid spaces
-- and their own poll loops, and a shared ledger would make a bug in one able to
-- silence the other. The stakes are higher here than for equip: a replayed
-- extraction ends a run the player resumed, and a replayed bout spends a day the
-- player has not been given back.
CREATE TABLE IF NOT EXISTS adv_applied_orders (
guid TEXT PRIMARY KEY,
status TEXT NOT NULL, -- the terminal verdict we filed, replayed on re-offer
detail TEXT NOT NULL DEFAULT '',
applied_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
);
-- Babysitting Service
CREATE TABLE IF NOT EXISTS adventure_babysit_log (
id INTEGER PRIMARY KEY AUTOINCREMENT,
internal/flavor/twinbee_ambient_flavor.go
+6
View File
@@ -34,6 +34,10 @@ var AmbientMonologue = []string{
"The map in your pack has folded itself one extra time while you weren't looking. I decline to unfold it for science.",
"Your own footsteps echo back to you a half-second late, in slightly the wrong order. Noted. I'm choosing to walk in silence for a bit.",
"A long, slow scrape happens two rooms over. Then nothing. I waited for a second scrape. There wasn't one. The first scrape was the whole sentence.",
"I organized the ration wrappers by crinkle volume while you slept. There are four tiers. I will not be presenting the findings, but the findings exist.",
"A moth has been circling the torch for an hour with total commitment and no plan. I relate to it more than I intend to say out loud.",
"I counted your snores and cross-referenced them against the dungeon's ambient groans. Twice they harmonized. I have no notes. It was lovely.",
"A snail is crossing the camp. At current pace it reaches your boot by morning. I have elected not to interfere with its schedule and expect you to extend it the same courtesy.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -48,6 +52,7 @@ var AmbientNoise = []string{
"Stones shift overhead in a way that is not settling and not random. Something walked across the ceiling. I'm choosing not to elaborate on what 'across the ceiling' implies.",
"A horn sounds, very far away — the kind of horn that's a signal to a thing that signals to more things. I acknowledge the chain.",
"You hear someone whistling your name. You don't have that name. The whistler is workshopping options.",
"Somewhere below, something counted to four and stopped. The counting has not resumed. I preferred it when it was counting.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -74,6 +79,7 @@ var AmbientLuckyFind = []string{
"You step on something flat. It is a coin. It is also two more coins under the first coin. I suspect a coin-laying creature and choose not to share the theory.",
"A skeleton you walked past three days ago has, on review, a small purse you missed. I retrieve it with the discretion of a librarian recovering an overdue book.",
"You find coins in the lining of your own cloak. They were always there. I gently suggest counting your pockets more often.",
"There is a coin at the bottom of the waterskin. I have questions, beginning with how long you have been drinking past it.",
}
// ─────────────────────────────────────────────────────────────────────────────
internal/flavor/twinbee_expedition_flavor.go
+8 -8
View File
@@ -22,7 +22,7 @@ var ExpeditionStart = []string{
"An expedition. Not a run — an expedition. There's a difference. I'll explain the difference over the coming days and the explanation will be mostly experiential.",
"Horizon checked, then supplies, then you. In that order. 'Alright,' I say, with the quiet energy of something that has been looking forward to this. 'Let's go.'",
"You're not here for a quick visit. I know the difference between someone passing through and someone committing. You're committing. I appreciate the commitment.",
"Like the opening screen of a long RPG — the kind that asks for your name and warns you to find a comfortable position because this is going to take a while. I've found a comfortable position. I suggest you do the same.",
"Like starting Dragon Quest VII. Two hours of errands before the game permits a single fight, and the people who love it love it for exactly that. This is going to take a while. I have found a comfortable position. I suggest you do the same.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -49,7 +49,7 @@ var ExpeditionBoredomStart = []string{
// ─────────────────────────────────────────────────────────────────────────────
var MorningBriefingGeneric = []string{
"Another day in the dungeon. Said without resignation. The dungeon is still full of things worth doing and you are still the person to do them.",
"Another day in the dungeon. Morning count: you, me, the rations, one sword, and zero regrets logged before breakfast. Regrets logged before breakfast are the only ones that stick. Clean sheet. Out we go.",
"Morning. The dungeon has been quiet since you camped. Relative to what a dungeon considers quiet, which is not what you'd consider quiet, but everyone adjusts.",
"I've been watching the entrance to the camp since approximately three in the morning. Nothing came. Mentioned casually; no particular reaction expected.",
"Day [N]. The numbers are climbing. There's something satisfying about the numbers climbing — it means you're still here, which is always the first thing to confirm.",
@@ -89,7 +89,7 @@ var MorningBriefingDay14 = []string{
}
var MorningBriefingDay21 = []string{
"Three weeks. I've run out of historical comparisons for this. Three weeks is its own category. You have made a category. I report this as a fact and also as something that doesn't entirely have words yet.",
"Three weeks. The record book keeps a page for runs past twenty days. The page has three entries. One is you. One is a dwarf named Hensel. The third entry is water-damaged, and I have chosen to believe it also says Hensel.",
"Day twenty-one. I tried to write a clever framing for this morning's briefing and gave up halfway through, settling instead on the simplest version: 'You're still here.' That's the briefing. The rest is logistics.",
"Three weeks down. The dungeon has stopped being a place you're visiting and become a place you live in for now. I note the shift — the way you check rooms without being asked, the way the supply count is already in your head. The dungeon notices too.",
}
@@ -100,7 +100,7 @@ var MorningBriefingDay21 = []string{
var EveningRecapGeneric = []string{
"End of day [N]. Ledger tallied. The column marked 'survived' has another entry. I consider this column the most important one.",
"Day closes. I review what happened and find, on balance, more right than wrong — which in a dungeon is the operating definition of a good day.",
"Day closes. The ledger says: three rooms, one fight you picked, one fight that picked you, and a door you had the sense to leave shut. I have audited worse days. I have audited far worse doors.",
"Evening. The rooms behind you are cleared. The rooms ahead are not. Always true; never less relevant. Rest now. The math doesn't change overnight.",
"I compile the day: what was learned, what was fought, what was found. File it in the mental ledger I've been keeping since you entered. The ledger is favorable.",
"Like the experience screen at the end of a dungeon floor in Etrian Odyssey — the numbers settle, the progress registers, and for a moment the whole thing makes sense. I give you that moment.",
@@ -137,7 +137,7 @@ var EveningRecapNothingHappened = []string{
// ─────────────────────────────────────────────────────────────────────────────
var CampEstablished = []string{
"Camp established. I survey the perimeter with the efficiency of someone who has done this many times and learned from every time it went wrong.",
"Camp established. I walk the perimeter once for threats and once for acoustics, because a camp that echoes is a camp that advertises. This one holds its sound. Approved.",
"The camp goes up. I approve of the location — cleared room, defensible entry, no obvious curse residue. Could be worse. I've seen worse.",
"You set camp. I check the sightlines, the doors, the sound-bleed from the next room. Acceptable. Settling in for the night watch.",
"A camp in the middle of a dungeon. Either brave or pragmatic; I've stopped trying to distinguish between the two. Either way, the camp is set. Either way, I'm watching.",
@@ -312,7 +312,7 @@ var RegionTransitDeparture = []string{
var RegionTransitArrival = []string{
"You arrive in [REGION_NEXT]. I survey, take in the new geometry, and update the working assumptions. 'Different shape,' I say. 'Same general principle. We learn what wants to kill us here, and we get there first.'",
"[REGION_NEXT] receives you. I note the temperature, the sound, the things-not-said-by-the-room-but-implied. A region is not just a place. It's a posture. I adopt the new one and suggest you do as well.",
"[REGION_NEXT] receives you. I catalogue the differences: colder by about one coat, quieter by exactly one birdsong, and the dust on this side of the boundary shows a single set of tracks. The tracks are leaving. Noted. Adopting the local caution.",
"Boundary crossed. The day gets stamped in the log — one full day spent in transit, supplies adjusted, the wandering that happened on the way handled and filed. We are here now. The next stretch is what it is.",
}
@@ -321,7 +321,7 @@ var RegionTransitArrival = []string{
// ─────────────────────────────────────────────────────────────────────────────
var ExtractionVoluntary = []string{
"Extraction. I note the decision and respect it — knowing when to leave is a skill, not a failure, and I've watched enough expeditions end wrong to deeply appreciate the ones that end right.",
"Extraction. For the record, the ledger keeps two columns for expeditions that reached the door: 'left' and 'was left of.' You are in the first column. The first column is the good column.",
"You call the extraction and I begin the route out immediately. No argument, no editorializing. There will be time for the debrief later. The first priority is the door.",
"The dungeon doesn't like this. I can tell by the way the corridors feel as you head back out — a resistance that isn't structural, just atmospheric. The zone wanted more. It doesn't get more today. I lead the way.",
"Withdrawing with intent. I catalogue what you have — the loot, the XP, the knowledge of where the rooms are for the return — and convert the exit into preparation. This isn't retreat. This is the start of the next attempt.",
@@ -353,7 +353,7 @@ var ExpeditionResume = []string{
// ─────────────────────────────────────────────────────────────────────────────
var MilestoneFirstNight = []string{
"You survived the first night. I note this milestone specifically because not everyone does, and those who do carry something from it that changes how the rest of the expedition goes. You have that now. Already noticed.",
"You survived the first night. Somewhere around the third watch you rolled over, said a word I will not be repeating back to you, and slept on. The dungeon spent that same hour deciding you were not worth waking. Both of you were right.",
"Night one survived. I make a small mark in the corner of the manifest — the kind of mark you make for the things that count more than they look. First nights count. I've been in dungeons where they were the last nights too. This wasn't one of those.",
"Day two morning. The first night is behind you, which means the first watch is behind me, which means a thing worth confirming has been confirmed: you sleep through the noises that matter and wake for the ones that don't. That's a survival skill. Logged.",
}
internal/flavor/twinbee_gm_flavor.go
+15 -10
View File
@@ -22,7 +22,7 @@ var RoomEntryGeneric = []string{
"The room is quiet. I appreciate quiet. Quiet means the enemies haven't spotted you yet. Yet.",
"Forward. Always forward. I once tried going backward in a dungeon. It looped. This one might too.",
"Stock of the situation: ceiling intact, floor suspicious, walls leaning in slightly. Proceed.",
"You've cleared the room. I give a small, dignified nod. 'One continues,' I say, in the voice of someone who has seen this before and am choosing optimism anyway.",
"You've cleared the room. I give a small, dignified nod. 'One continues,' I say, in the voice of someone who has seen this before and is choosing optimism anyway.",
"The corridor ahead is long and straight. I find long straight corridors meditative. Also concerning. Mostly concerning.",
"A torch sputters on the wall. I light it mentally. 'It would be a shame,' I say, 'to come all this way and trip over something.'",
}
@@ -124,7 +124,7 @@ var CombatStart = []string{
"They've seen you. The kind of seeing that comes with intent. I suggest acting first.",
"FIGHT. I don't need to say more than that but I will absolutely say more than that.",
"Roll for initiative. This is the part I've been looking forward to since the Entry Room.",
"And we're in combat. I remind you to breathe, track your conditions, and remember that your character's survival is not guaranteed but am definitely preferred.",
"And we're in combat. I remind you to breathe, track your conditions, and remember that your character's survival is not guaranteed but is definitely preferred.",
"Something about your posture or your smell or your general presence has been found unacceptable. Combat begins.",
"I press start. Player one, it's your turn.",
"The enemy acts first — or thinks it does. I watch your dice like they're the only thing in the room, which, right now, they are.",
@@ -133,6 +133,7 @@ var CombatStart = []string{
"A wild encounter has appeared. I resist the urge to play the Pokémon battle music. Only barely.",
"They didn't want a fight. They wanted an easy meal. I'm about to demonstrate the difference. Your dice will do the actual demonstrating.",
"The tension peaks. Time slows. This is exactly the energy of the boss door opening in Mega Man. Except you didn't get to pick your loadout.",
"A kerfuffle, then. I had this logged as a fracas, but they drew weapons, and weapons upgrade a fracas to a kerfuffle. Anything beyond this point is a melee, which is the technical term.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -141,7 +142,7 @@ var CombatStart = []string{
var CombatVictory = []string{
"The last one drops. I allow a moment of silence for anyone who wanted a longer fight.",
"Victory. I would cue the jingle — the little three-note one that plays in every RPG after every fight — but I prefer to let the moment breathe.",
"Victory. I would cue the fanfare, the Final Fantasy one that plays even when you won by a single hit point while poisoned and on fire. Especially then. But I prefer to let the moment breathe.",
"Well fought. I make note of what you did well. There were things done well. I noticed.",
"They are defeated. You are not. In my experience, this is the correct outcome and worth a moment of genuine appreciation.",
"PLAYER WIN. I say this in full caps and mean it.",
@@ -166,6 +167,7 @@ var CombatRetreat = []string{
"Noted for the record: running is not losing. Running is data collection with legs.",
"The dungeon will be there. You will also be there — later, better prepared. I approve of this logic.",
"You've retreated to safety. I reset the encounter. Rest. Think. Return with a plan that has more 'survive' in it.",
"Skedaddle is the technical term and I will hear no other. Executed cleanly, all limbs accounted for. The ledger records a skedaddle of the highest order.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -206,6 +208,7 @@ var Nat1 = []string{
"The attack misses in a way that will be funny later. I promise it will be funny later. It is not funny right now.",
"A natural one is just the universe asking you to try differently. I'm an optimist about natural ones, mostly.",
"Your sword finds everything in the room except the enemy. The wall, the ceiling, the floor, your dignity. Not the enemy. I'll mention this once and then never again.",
"One. The die rolled off the table, hit a boot, and came back up one, as if it left to think it over and returned with conviction.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -329,7 +332,7 @@ var TrapTriggered = []string{
var LoreLines = []string{
"I settle in and prepare to speak at length, because I've been waiting for this question since you entered and I have a lot of thoughts.",
"Ah. A good question. I have context for this. I have more context than will fit comfortably in one telling but I'll try to prioritize.",
"The history of this place is long and not entirely flattering to anyone involved. I begin at the beginning, which is not actually the beginning, but am the closest I can find.",
"The history of this place is long and not entirely flattering to anyone involved. I begin at the beginning, which is not actually the beginning, but is the closest I can find.",
"I consult what I know — which is more than most, less than everything, and presented in order of relevance to your immediate survival.",
"Sit with this for a moment. What you're standing in has a story and I believe knowing it will change how you fight in it. Stories are tactical documents if you read them right.",
"You want lore? I have lore. I have so much lore that the challenge is not having it but choosing which pieces are useful and which are just fascinating.",
@@ -358,7 +361,7 @@ var ItemFound = []string{
"Something catches the light that isn't supposed to be here. I watch you reach for it with the specific alertness of someone who has seen cursed items do cursed things. It appears fine. I relax incrementally.",
"Loot. I say this word with genuine reverence. The whole system — the dungeon, the enemies, the traps — exists in part to produce this moment. I think it's worth it.",
"A chest. Unlocked. I note the unlocked status and consider what that might mean. Probably nothing. Possibly something. You open it while I consider.",
"The item is good. I evaluate it quickly — the stats, the rarity, the class match — and nod with the confidence of someone who has seen a lot of items and know when one is worth finding.",
"The item is good. I evaluate it quickly — the stats, the rarity, the class match — and nod with the confidence of someone who has seen a lot of items and knows when one is worth finding.",
"That's a rare one. I've seen fewer of those than common ones, by definition, but that doesn't stop me from being specifically pleased each time.",
"Like finding the Beam Sword in Kirby, the Boomerang in Zelda, the P Wing in Super Mario 3 — the right item at the right time changes what's possible. I think this might be that item. I hope it is.",
"Equipment upgrade. I watch the math update — new AC, new attack bonus, new possibilities — and file this moment under 'things going right.'",
@@ -402,6 +405,7 @@ var TauntResponses = []string{
"You taunt me. I smile. The smile does not reach the eyes, because I don't have eyes per se, but the quality of the smile communicates clearly. 'Proceed,' I say.",
"In Gradius, you could powerup into overconfidence and lose everything in one hit. I mention this as a purely historical observation.",
"I accept the taunt with grace. Also generate a trap for the next room with specific energy. These two events are unrelated. I maintain this position legally.",
"Hornswoggled. By you. I write the word in the ledger and it looks ridiculous there, which I suspect was the plan all along.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -430,6 +434,7 @@ var IdleLines = []string{
"The enemies are patient. Patience is one of their few virtues. I advise not testing the limits of their patience because those limits are lower than the patience suggests.",
"I hum something that sounds like the waiting music from Dr. Mario. It is not ominous. It is mildly ominous. I adjust.",
"The dungeon does not rush. The dungeon has time. I, however, am beginning to wonder if you've fallen asleep and am prepared to narrate events accordingly.",
"There is a word for this and the word is lollygagging. I don't get many chances to deploy it. Thank you for this one. Now move.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -464,7 +469,7 @@ var ConditionApplied = []string{
"You've been afflicted. I note the condition, its duration, and the mechanical consequences, then note the saving throw that might end it early. Details matter here.",
"Something is wrong with you now that wasn't wrong before. I catalog it without judgment and suggest addressing it before it addresses you.",
"Condition acquired. I process this the way a good DM processes bad news: honestly, quickly, and with an immediate pivot toward solutions.",
"Like the status screen turning an unfriendly color in a JRPG — the condition is visible, the effect is real, and I would very much like you to resolve it.",
"Like your sprite turning that little poison green in Final Fantasy while the walk animation carries on regardless. The condition is visible, the effect is real, and I would very much like you to resolve it.",
"The debuff lands. I name it, explain it, and remind you: conditions end. Keep fighting until this one does.",
}
@@ -485,10 +490,10 @@ var SaveSuccess = []string{
// ─────────────────────────────────────────────────────────────────────────────
var SaveFailed = []string{
"The save fails. I watch the condition take hold with the resignation of someone who has seen this before and know there's a path through it, just not a comfortable one.",
"The save fails. I watch the condition take hold with the resignation of someone who has seen this before and knows there's a path through it, just not a comfortable one.",
"It lands. Whatever the enemy threw at you, the dice didn't cooperate. I note the condition and its duration and suggest dealing with it before it compounds.",
"Failed. The number wasn't enough and I was rooting for the number. The condition applies. Fight through it.",
"Like the NES game over screen — inevitable in this moment, fixable in the next. The save failed. The dungeon continues. So do you.",
"Like the bird in Ninja Gaiden that exists solely to shove you into the pit. Inevitable in this moment, fixable in the next. The save failed. The dungeon continues. So do you.",
"The effect takes hold and I'm already calculating how you get out of it, because that's my job: keep you oriented toward solutions even when the immediate situation is a problem.",
}
@@ -502,7 +507,7 @@ var MoodAsidesHostile = []string{
"I'm not narrating this one in detail. You can read the room. Read it.",
"The dungeon offers me something to mention. I decline. You're on your own for color commentary.",
"I'm here. Watching. Not, currently, helping. There is a difference and you will feel it.",
"In the bad ending of every Castlevania, the protagonist gets less guidance than they did at the start. I have reached approximately that part of the playthrough.",
"Simon's Quest told you 'the morning sun has vanquished the horrible night' and then never said anything useful again. I have entered my Simon's Quest era.",
"I'm keeping several details to myself. The details would have been useful. I don't consider this my problem right now.",
"Whatever's in the next part of the room, I saw it and chose not to flag it. The mood is what it is.",
"I mutter something. You don't catch it. I do not repeat it.",
@@ -520,7 +525,7 @@ var MoodAsidesEffusive = []string{
"I lean in. The mood is good. Good moods, in my experience, lead to slightly more generous descriptions and slightly better odds of catching the small details.",
"This is the part of the run I'll tell other GMs about later. I make a small mental note and continue with visible enthusiasm.",
"I'm delighted. You can hear it in the pacing. You can hear it in the choice of adjectives. The dungeon is, briefly, on your side.",
"In the good ending of every JRPG, the world feels slightly warmer in the late game. I'm at that part of the playthrough and it shows.",
"Like the campfire scene in Chrono Trigger, where the game just lets everyone sit down for one night and nobody dies. I'm at that part of the playthrough and it shows.",
"I'm not normally given to footnotes, but I'm about to add a footnote. It will probably be useful. I'm in that kind of mood.",
"The mood is high. For the next stretch, I'm more likely to mention the loose flagstone, the suspicious tapestry, the thing on the ceiling. Take advantage.",
"I hum a victory fanfare softly to myself. It is not earned yet. I'm being optimistic on your behalf.",
internal/flavor/twinbee_housing_flavor.go
+3
View File
@@ -33,6 +33,7 @@ var ThomKrookeMortgageRate = []string{
"Good morning, friends! The ARM rate this week is {rate}% — and with Thom Krooke's modest service margin, your mortgage rate sits at {effective}%. All payments process Sunday. Thank you for your continued trust!",
"Weekly rate update! FRED reports {rate}% this week, so your effective rate with Thom Krooke is {effective}%. Nothing to worry about — Thom Krooke monitors these things so you don't have to. Mostly.",
"Rate check! The market says {rate}%, Thom Krooke adds a small, reasonable {margin}%, and your total comes to {effective}%. Thom Krooke appreciates your understanding of the margin. It keeps the lights on. Literally!",
"Rate news! The market did something this week that the newspapers describe with an arrow. The result for you is {effective}%. Thom Krooke does not fully understand the arrow either, but the arrow is binding. Budget however you must. The pet's portion is not part of 'however.'",
}
var ThomKrookeMortgageRateUp = []string{
@@ -127,6 +128,7 @@ var PastelNoteLevel1 = []string{
"Good day! The herb garden got some attention, the pets were walked (or equivalent — the fish were observed), and I collected the income. I accidentally shelved three items in the wrong slots but found them eventually. Everything is where it should be. Mostly. The weapons rack might be slightly reorganized.",
"Note from Pastel: pets fed, garden tended, income collected. I made one small mistake with the supply manifest — added a column that didn't need to be there — but the numbers are right, the column is just extra. Please ignore the extra column.",
"All tasks completed! Well — most tasks. The greenhouse watering got a little delayed because I was making sure the workshop tools were hung correctly and then it was later than I thought. The plants look fine. Probably fine. I'll check again in the morning.",
"Fed the pets, watered the garden, and spent forty minutes retrieving the trowel from where the small pet had buried it. It was buried with ceremony, judging by the arrangement of pebbles on top. The trowel is back on its hook. I am watching the small pet.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -204,6 +206,7 @@ var PastelPetEvent = []string{
"Your pet found something in the back of the storage room that I couldn't identify. I've put it on the workshop table. It doesn't seem dangerous. It is definitely something.",
"One of the pets has been sitting by the expedition outpost since this morning. I think it knows you've been out a long time. Everything is fine. I just thought you'd want to know.",
"The pets were restless today — I think they can tell you've been in a Tier 4 zone because they get like this around Day 10. Fed them an extra portion. They settled. They'll be glad to see you.",
"One of the pets discovered its own reflection in the vault door today. Negotiations lasted most of the afternoon. Both parties eventually withdrew with dignity, which I thought was big of them.",
}
var PastelLevelUpNote = []string{
internal/flavor/twinbee_npc_flavor.go
+4
View File
@@ -15,6 +15,7 @@ var MistyGreeting = []string{
"'Don't stand in the doorway,' Misty says, before you've even finished arriving.",
"Misty is already talking before you're settled. This is how it always goes.",
"'I wondered when you'd show up.' She says it like she'd actually been counting the days. She had.",
"'Boots.' Misty says the one word and points at the mat. The conversation resumes once the boots comply.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -36,6 +37,7 @@ var MistySkillFail = []string{
"'No,' Misty says, and returns to what she was doing.",
"Misty looks at you like you've asked a question that doesn't deserve an answer. She's not wrong.",
"'Come back when you actually know what you're asking.' Misty's version of helpful feedback.",
"Misty lets the silence answer for her. The silence is thorough.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -79,6 +81,7 @@ var ArinaGreeting = []string{
"'Perfect timing,' Arina says, in the tone of someone for whom most timings are perfect because everything is interesting. 'I was just thinking about—' She stops. 'Actually, what do you need?'",
"Arina has three things she's in the middle of and immediately sets all of them down to give you her full attention, which is considerable.",
"'You came back!' Arina says, as if there was any question. In her experience there sometimes isn't.",
"'I was just — okay, two things, no, three things—' Arina holds up a finger for each, and then a fourth finger surprises her. 'Four things. You first, though.'",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -91,6 +94,7 @@ var ArinaIdentify = []string{
"Arina holds the item up to the light, turns it twice, says something under her breath that might be an incantation or just enthusiasm, and then begins a very efficient explanation.",
"'Oh I know what this is.' The words land quickly, confidently, correctly. Arina has seen a lot of magic items and she remembers all of them.",
"Arina goes still in the specific way she goes still when magic is doing something she finds genuinely surprising. 'That's — huh. Okay. That's new. Let me—' The identification follows, along with three questions she has that you're under no obligation to answer.",
"Arina sniffs the item, which is not a recognized identification technique, and then names it correctly anyway. 'The nose knows,' she says, in the voice of someone who will not be defending the methodology.",
}
// ─────────────────────────────────────────────────────────────────────────────
internal/flavor/twinbee_resource_flavor.go
+19 -12
View File
@@ -15,7 +15,7 @@ package flavor
var HarvestForageSuccess = []string{
"The land gives something up. I watch you identify it with the quiet satisfaction of someone watching a skill be used correctly.",
"There — growing in a place that suggests it knows exactly what it's good for and has been waiting. You found it. I approve of the finding.",
"A Ranger's eye in a non-Ranger would have missed that entirely. I note the distinction.",
"You found it by the smell. Bruised stems, faintly peppery, which means something stepped on this patch within the hour and it grows back that fast. A Ranger taught me that trick. I never found out who taught you.",
"Like finding the hidden item block in a Mario level — you knew to look, you looked in the right place, and the thing that was always there is now yours.",
"The plant comes away cleanly. Good root structure, good potency. Mentally catalogued. Moving on.",
}
@@ -23,7 +23,7 @@ var HarvestForageSuccess = []string{
var HarvestMineSuccess = []string{
"The stone yields. I listen to the sound of it — the specific tone of rock giving up something it's been holding for a very long time.",
"Solid work. The ore comes out in a piece worth taking. I check the vein depth. There's more. There's always more if you're willing to dig.",
"Like the mining minigame in Stardew Valley, but with real consequences and no save file. I watch you extract the material with professional appreciation.",
"There's a note rock makes when it's ready to give. Duller, rounder, like knocking on a full barrel instead of an empty one. Third swing, you found the note. Some miners go twenty years and never hear it.",
"The wall gives up its contents without drama. I appreciate materials that cooperate.",
"Good strike. Clean extraction. I note the weight and the quality simultaneously.",
}
@@ -31,9 +31,9 @@ var HarvestMineSuccess = []string{
var HarvestScavengeSuccess = []string{
"There it is. Among the debris, the decay, the things that were left behind — something worth taking. I knew it was there. You found it. Pleased.",
"The room held something after all. I had estimated 60% odds and am updating the estimate to 'correct.'",
"Like finding the secret item in a dungeon chest that looked empty — you checked anyway. That's the habit. That's the discipline. I note both.",
"The chest looked empty. You knocked on the bottom anyway and it knocked back twice. Once for the bottom, once for the false bottom. I heard it too. I let you have the moment.",
"Scavenged. The word has a bad reputation it doesn't deserve. You found value in the discarded. I respect that entirely.",
"A Rogue's eye in a non-Rogue would have walked past this. I note the distinction.",
"You checked behind the crate that stood one inch too far from the wall. One inch. Ask any Rogue: that inch is the entire profession.",
}
var HarvestEssenceSuccess = []string{
@@ -41,7 +41,7 @@ var HarvestEssenceSuccess = []string{
"Drawn out cleanly. The Arcana check held and the essence responds to the knowledge behind it. I'm appropriately impressed.",
"Like tapping into a power source in Metroid — you knew the energy was there, you had the tool to reach it, you reached it. The vial fills.",
"The room releases something it didn't know it was holding. I watch the transfer and mark the yield in the ledger.",
"Essence harvested. Quality above average for this zone, below average for what you'd need to know to appreciate that distinction. I appreciate it on your behalf.",
"Essence harvested. Seventh decile for this zone, which is genuinely exciting to perhaps four people alive. I am one of them. It is a quiet life, but the charts are immaculate.",
}
var HarvestCommuneSuccess = []string{
@@ -55,8 +55,9 @@ var HarvestFishSuccess = []string{
"The line goes taut and I straighten up. Whatever's on the end of it, it came from somewhere deep and dark and it's yours now.",
"A catch. I identify it before you finish pulling it in — the coloring, the depth-marks, the specific opacity of its eyes. 'Good one,' I say, meaning it.",
"Fishing in a dungeon. I have opinions about fishing in dungeons and all of them are positive. The fish is landed. The opinions remain.",
"Like the fishing minigame in every RPG that ever had one — the moment the indicator hits perfect and everything pays off. Quiet delight, on my end.",
"Like landing the Hylian Loach. The fish the game never once required, the one you gave forty minutes to while the world stood ending, and the fisherman never asked why. This fish was optional too. That's what makes it yours.",
"The water gives up its catch with minimal argument. I respect fish that don't make it personal.",
"The fish comes up mid-argument with the hook and loses. I weigh it, log it, and admire it, in that order. The order is the job.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -68,6 +69,7 @@ var HarvestFail = []string{
"The attempt fails to produce anything useful. I mark the node and move on. Some rooms are stingier than others.",
"Not everything that looks like a resource is one. Filed under 'learned' and considered worth the attempt.",
"Empty-handed. I've seen this before and will see it again. The dungeon doesn't owe you anything. You ask anyway. That's the deal.",
"Nothing. The mushroom you spent four minutes prying loose is a rock. It was always a rock. I have struck it from the ledger and we will never speak of the rock again.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -82,6 +84,7 @@ var HarvestInterrupt = []string{
"A patrol. Bad timing, or very good timing from their perspective. I set aside the harvest log and open the combat log.",
"The forage was going well until it wasn't. I measure the distance between you and the enemy, between the enemy and the door, and start calculating options at speed.",
"Interrupted. The node is still there. The enemy is also still there, in a more immediate way. I suggest addressing the more immediate thing first.",
"You were elbow-deep in the node when the growling started. Your priorities, observed and logged in order: ore, ore, growling, ore, sword.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -93,6 +96,7 @@ var NodeDepleted = []string{
"Empty. The resource is gone. Something quietly melancholy about a depleted node and something practical about moving to the next one.",
"That's all it had. I confirm the node at zero and move on without ceremony.",
"Harvested clean. The room is now resource-dry until you rest and the dungeon replenishes. It will replenish. It always does.",
"Empty. You tap it twice more anyway, the way people press a lift button that's already lit. The node respects this exactly as much as the lift does.",
}
// ─────────────────────────────────────────────────────────────────────────────
@@ -102,7 +106,7 @@ var NodeDepleted = []string{
var RichYield = []string{
"A rich vein. My assessment upgrades mid-harvest — more than expected, better quality than the zone average. This room was generous. Marked.",
"The node gives more than it should have. I note the anomaly with appreciation and decline to question it.",
"Like finding the rare item drop that you stopped expecting — the dungeon decided to be kind today, in this specific way, in this specific room. I take it. We take it. We do not look it in the mouth.",
"The vein forks behind the wall. Then forks again. I revise my estimate upward twice in one sentence, which I hate doing and am currently doing. We take all of it. We do not look it in the mouth.",
"Exceptional yield. I catalog the bonus material with the efficiency of someone who's been waiting for exactly this and prepared for it anyway.",
"More than the DC promised. The dungeon overdelivered. Unusual. Also completely welcome.",
}
@@ -215,25 +219,28 @@ var PatrolEncounter = []string{
// ─────────────────────────────────────────────────────────────────────────────
var LootDropCommon = []string{
"They had something on them. I check it over. Common rarity — useful in the way that common things are useful, which is often.",
"Standard loot. Nothing that rewrites the story, but everything that keeps it going.",
"A drop. I catalog it efficiently and note: this is the economy of dungeons. Enemies have things. You take them. The loop continues.",
"They were carrying a coil of rope, half a candle, and a knife sharpened so many times it's mostly handle. I log all three. Somebody loved that knife once. It's yours now. That's dungeons.",
"Standard loot. Six copper, a whetstone, and a note that says REMEMBER THE THING. No further details. They did not, evidently, remember the thing.",
"I catalog the pockets. Then I find the second pocket sewn inside the first pocket, because I have been doing this a long time. So, apparently, had they.",
"A belt pouch. Inside: three teeth, none of them theirs, and a receipt. I don't read other people's receipts. I read the receipt. It was for soup.",
"Common drop. A tin whistle with one hole plugged with wax. Somewhere out there is a song missing a note, and now you own the reason.",
}
var LootDropUncommon = []string{
"Better than expected. I examine the drop with slightly elevated interest. Uncommon rarity — someone made this with intent.",
"An uncommon drop from a common enemy. Anomaly noted with satisfaction. The dungeon was generous in this room.",
"Uncommon. I turn it over once and nod. 'Keeper,' I say — which in my vocabulary means: this changes your math.",
"Uncommon. There's a maker's mark under the grip, two crossed nails. I don't know the smith. I know what their apprentices paid to train, because work this clean does not come out of cheap teachers.",
}
var LootDropRare = []string{
"I stop. Actually stop. 'That's rare,' I say, with the specific register of someone who uses the word correctly and use it seldom.",
"I stop. Actually stop. 'That's rare,' I say. I have said that word four times in my career. I keep count, because it is that kind of word.",
"A rare drop. I examine it the way you examine something that doesn't appear often — thoroughly, quietly, with appropriate appreciation.",
"The loot table gave you something uncommon and then kept going. Rare rarity. Filed in the column I reserve for things worth remembering.",
}
var LootDropLegendary = []string{
"I go very still. The drop sits in the light and I process what I am seeing. 'Legendary,' I say eventually. One word. That's all it needs.",
"Legendary rarity. I've seen a few of these in a long career and each time — each time — there is a moment that is separate from everything else. This is that moment. Pick it up carefully.",
"Legendary rarity. I have logged three of these in my career. The first one earned its bearer a statue. The second one is why there is a lake where Torbridge used to be. Pick it up carefully.",
"The dungeon produced a legendary item. I note the zone, the enemy, the day of the expedition, the Threat Clock value, the precise conditions. Some things deserve to be recorded completely.",
}
internal/flavor/zone_dragons_lair_flavor.go
+1 -1
View File
@@ -103,7 +103,7 @@ var LoreLinesDragonsLair = []string{
"The kobolds are not slaves. The kobolds are clergy. They serve voluntarily, in shifts, with rotation, and the rotation is run by elders who have written sermons. I respect the organization and note the kobold scale-sorcerers are graduates, not recruits.",
"The hoard is not random. Each piece is catalogued in Infernax's memory, by location and by year of acquisition. He will know if you take a single coin. I suggest not taking a single coin and instead taking the items the design doc expects you to take — those have been pre-cleared.",
"The Dragon Hoard mechanic exists because Infernax does not lose track of his coins. Killing him releases his hold on the catalogue. The 50d10 × 100 coin drop is the entire pile relaxing for the first time in eight centuries. I respect the math and note the rest of the surface economy will too.",
"Infernax has had three challengers in the last eight hundred years. Two were heroes. One was a younger dragon. He kept the younger dragon's skull as a paperweight on a treaty desk that has not been used since. I note the paperweight is in the treasury, on the third shelf, and am not worth picking up — picking it up triggers his attention from anywhere on the mountain.",
"Infernax has had three challengers in the last eight hundred years. Two were heroes. One was a younger dragon. He kept the younger dragon's skull as a paperweight on a treaty desk that has not been used since. I note the paperweight is in the treasury, on the third shelf, and is not worth picking up — picking it up triggers his attention from anywhere on the mountain.",
"The Young Red dragons in the outer chambers are his children. Or his grandchildren. Or unrelated and tolerated. Infernax does not clarify and I have not asked. They are loyal in the way that loyal works for dragons, which is to say: they will fight you, but they will not die for him, and the distinction matters more than it should.",
"The kobold scale-sorcerers cast through bloodline. The bloodline traces back to a single clutch laid in the magma chamber three centuries ago. I note the entire sorcerous gene pool of this zone is one extended family and that they all know each other's names.",
}
internal/flavor/zone_sunken_temple_flavor.go
+1 -1
View File
@@ -62,7 +62,7 @@ var EliteRoomEntrySunkenTemple = []string{
var AbolethTentacleMultiattackLines = []string{
"Three tentacles, three rolls. Each on-hit risks Diseased — no magical healing for 24 hours until cured. I say: 'Cleric's tools come back online tomorrow. Survive today.'",
"The Aboleth's tentacles arrive in sequence, three of them, the hits compounding. The disease isn't the damage — the disease is the design. Magical healing fails until you cleanse. I file this under 'durability problem.'",
"Three attacks, one turn. Any landing tentacle leaves a mark that locks out magical healing. I suggest potions, rest, and the kind of patience that pretends to be patience but am mostly grim arithmetic.",
"Three attacks, one turn. Any landing tentacle leaves a mark that locks out magical healing. I suggest potions, rest, and the kind of patience that pretends to be patience but is mostly grim arithmetic.",
}
// Enslave: recharge 6; WIS DC 14 or Charmed; player skips turn, drifts toward Aboleth.
internal/llm/llm.go
+161
View File
@@ -0,0 +1,161 @@
// Package llm wraps the local inference endpoint behind a backend-agnostic
// interface. Two concrete backends — Ollama (native /api/generate) and vLLM
// (OpenAI-compatible /v1/chat/completions) — implement Client; plugin code
// calls the interface only and never knows which one is active.
//
// Deliberately not routed through internal/safehttp: that client blocks
// RFC1918 and loopback destinations to defend against SSRF from feed-supplied
// URLs, and the inference endpoint is precisely such a destination. The URL
// here comes from our own config, never from user input.
package llm
import (
"context"
"os"
"strings"
"time"
)
// Request is the backend-neutral generation request. Zero-valued fields fall
// back to backend defaults.
type Request struct {
// Prompt is a single raw instruction. The vLLM backend wraps it as one
// user message so the model's chat template still applies; sending it to
// /v1/completions instead would bypass the template and degrade an
// instruction-tuned model badly.
Prompt string
// System is an optional system message. Empty means none, which keeps the
// single-message shape the majority of callers use.
System string
// NumCtx is the per-request context window. Ollama honours it directly;
// vLLM fixes the window server-side at launch (--max-model-len), so this
// is ignored there rather than silently misapplied.
NumCtx int
// MaxTokens caps the completion length. 0 means the backend default.
MaxTokens int
// Temperature is passed through when non-zero.
Temperature float64
// Timeout overrides the client's default per-request budget.
Timeout time.Duration
}
// Client is the single surface plugin code depends on.
type Client interface {
// Generate returns the full completion in one shot. Reasoning blocks are
// stripped before returning (see StripThink) — every caller in this repo
// wants the visible answer, not the chain of thought.
Generate(ctx context.Context, req Request) (string, error)
// Model reports the configured model id, for logging and /botinfo.
Model() string
// Ping reports the model ids the backend is currently serving. Used by
// /botinfo for a liveness line; the two backends expose this on different
// paths (/api/tags vs /v1/models), which is exactly the sort of difference
// this interface exists to hide.
Ping(ctx context.Context) ([]string, error)
// Backend reports "ollama" or "vllm", for logging and /botinfo.
Backend() string
}
// Config selects and configures a backend.
type Config struct {
Backend string // "ollama" | "vllm"
Endpoint string
Model string
Timeout time.Duration
}
// DefaultTimeout matches the budget the pre-refactor callOllama used.
const DefaultTimeout = 120 * time.Second
// ConfigFromEnv reads backend settings, preferring the new LLM_* names and
// falling back to the legacy OLLAMA_* pair so an existing deployment keeps
// working untouched after this refactor.
func ConfigFromEnv() Config {
backend := strings.ToLower(strings.TrimSpace(os.Getenv("LLM_BACKEND")))
if backend == "" {
backend = "ollama"
}
endpoint := firstNonEmpty(os.Getenv("LLM_ENDPOINT"), os.Getenv("OLLAMA_HOST"))
model := firstNonEmpty(os.Getenv("LLM_MODEL"), os.Getenv("OLLAMA_MODEL"))
timeout := DefaultTimeout
if d, err := time.ParseDuration(os.Getenv("LLM_TIMEOUT")); err == nil && d > 0 {
timeout = d
}
return Config{Backend: backend, Endpoint: endpoint, Model: model, Timeout: timeout}
}
// Configured reports whether enough config is present to talk to a backend.
// Plugins check this to stay dormant rather than erroring on every invocation,
// which is what the old `if ollamaHost == "" || ollamaModel == ""` guards did.
func (c Config) Configured() bool {
return c.Endpoint != "" && c.Model != ""
}
// New builds the client for cfg.Backend. An unrecognised backend falls back to
// Ollama, which is what every existing deployment runs.
func New(cfg Config) Client {
if cfg.Timeout <= 0 {
cfg.Timeout = DefaultTimeout
}
base := backend{
endpoint: strings.TrimRight(cfg.Endpoint, "/"),
model: cfg.Model,
timeout: cfg.Timeout,
}
switch cfg.Backend {
case "vllm":
return &VLLMClient{base}
default:
return &OllamaClient{base}
}
}
// backend holds the fields shared by both concrete clients.
type backend struct {
endpoint string
model string
timeout time.Duration
}
func (b backend) Model() string { return b.model }
// timeoutFor lets a single call widen or narrow the client default. The two
// dispatch-voice callers rely on this: a dispatch is authored on a game
// chokepoint and must not stall it, while a run summary rides a background
// ticker and can afford a bigger model.
func (b backend) timeoutFor(req Request) time.Duration {
if req.Timeout > 0 {
return req.Timeout
}
return b.timeout
}
// StripThink removes a leading <think>...</think> reasoning block, which Qwen
// models emit even when thinking is disabled by some backends. Callers that
// parse JSON out of the completion depend on this running first.
func StripThink(s string) string {
for {
i := strings.Index(s, "<think>")
if i < 0 {
break
}
j := strings.Index(s, "</think>")
if j < 0 || j < i {
break
}
s = s[:i] + s[j+len("</think>"):]
}
return strings.TrimSpace(s)
}
func firstNonEmpty(vals ...string) string {
for _, v := range vals {
if v = strings.TrimSpace(v); v != "" {
return v
}
}
return ""
}
internal/llm/ollama.go
+103
View File
@@ -0,0 +1,103 @@
package llm
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
)
// OllamaClient talks to Ollama's native /api/generate endpoint.
type OllamaClient struct {
backend
}
func (c *OllamaClient) Backend() string { return "ollama" }
type ollamaOptions struct {
NumCtx int `json:"num_ctx,omitempty"`
NumPredict int `json:"num_predict,omitempty"`
Temperature float64 `json:"temperature,omitempty"`
}
type ollamaRequest struct {
Model string `json:"model"`
Prompt string `json:"prompt"`
System string `json:"system,omitempty"`
Stream bool `json:"stream"`
Think bool `json:"think"`
Options ollamaOptions `json:"options,omitempty"`
}
// Generate posts a single non-streaming generation and returns the completion.
func (c *OllamaClient) Generate(ctx context.Context, req Request) (string, error) {
ctx, cancel := context.WithTimeout(ctx, c.timeoutFor(req))
defer cancel()
body, err := json.Marshal(ollamaRequest{
Model: c.model,
Prompt: req.Prompt,
System: req.System,
Stream: false,
Think: false,
Options: ollamaOptions{
NumCtx: req.NumCtx,
NumPredict: req.MaxTokens,
Temperature: req.Temperature,
},
})
if err != nil {
return "", fmt.Errorf("ollama: marshal payload: %w", err)
}
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost,
c.endpoint+"/api/generate", bytes.NewReader(body))
if err != nil {
return "", fmt.Errorf("ollama: build request: %w", err)
}
httpReq.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(httpReq)
if err != nil {
return "", fmt.Errorf("ollama request: %w", err)
}
defer resp.Body.Close()
respBody, err := io.ReadAll(resp.Body)
if err != nil {
return "", fmt.Errorf("ollama: read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("ollama HTTP %d: %s", resp.StatusCode, string(respBody))
}
var result struct {
Response string `json:"response"`
}
if err := json.Unmarshal(respBody, &result); err != nil {
return "", fmt.Errorf("ollama: parse response: %w", err)
}
return StripThink(result.Response), nil
}
// Ping lists locally installed models via Ollama's native /api/tags.
func (c *OllamaClient) Ping(ctx context.Context) ([]string, error) {
ctx, cancel := context.WithTimeout(ctx, pingTimeout)
defer cancel()
var out struct {
Models []struct {
Name string `json:"name"`
} `json:"models"`
}
if err := getJSON(ctx, c.endpoint+"/api/tags", &out); err != nil {
return nil, err
}
names := make([]string, 0, len(out.Models))
for _, m := range out.Models {
names = append(names, m.Name)
}
return names, nil
}
internal/llm/ping.go
+29
View File
@@ -0,0 +1,29 @@
package llm
import (
"context"
"encoding/json"
"fmt"
"net/http"
"time"
)
// pingTimeout keeps a liveness probe short — /botinfo renders synchronously and
// a hung endpoint must not hold the reply.
const pingTimeout = 5 * time.Second
func getJSON(ctx context.Context, url string, out any) error {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {
return err
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("HTTP %d", resp.StatusCode)
}
return json.NewDecoder(resp.Body).Decode(out)
}
internal/llm/vllm.go
+116
View File
@@ -0,0 +1,116 @@
package llm
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
)
// VLLMClient talks to an OpenAI-compatible /v1/chat/completions endpoint.
type VLLMClient struct {
backend
}
func (c *VLLMClient) Backend() string { return "vllm" }
type vllmMessage struct {
Role string `json:"role"`
Content string `json:"content"`
}
type vllmRequest struct {
Model string `json:"model"`
Messages []vllmMessage `json:"messages"`
MaxTokens int `json:"max_tokens,omitempty"`
Temperature float64 `json:"temperature,omitempty"`
Stream bool `json:"stream"`
// ChatTemplateKwargs is a vLLM extension to the OpenAI schema. It is how
// Qwen3-family reasoning is switched off; the Ollama backend spells the
// same intent as its native "think": false.
ChatTemplateKwargs map[string]any `json:"chat_template_kwargs,omitempty"`
}
// Generate posts a single non-streaming completion and returns the message
// content. The raw prompt is sent as one user message so the server-side chat
// template still wraps it.
func (c *VLLMClient) Generate(ctx context.Context, req Request) (string, error) {
ctx, cancel := context.WithTimeout(ctx, c.timeoutFor(req))
defer cancel()
msgs := make([]vllmMessage, 0, 2)
if req.System != "" {
msgs = append(msgs, vllmMessage{Role: "system", Content: req.System})
}
msgs = append(msgs, vllmMessage{Role: "user", Content: req.Prompt})
body, err := json.Marshal(vllmRequest{
Model: c.model,
Messages: msgs,
MaxTokens: req.MaxTokens,
Temperature: req.Temperature,
Stream: false,
ChatTemplateKwargs: map[string]any{"enable_thinking": false},
})
if err != nil {
return "", fmt.Errorf("vllm: marshal payload: %w", err)
}
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost,
c.endpoint+"/v1/chat/completions", bytes.NewReader(body))
if err != nil {
return "", fmt.Errorf("vllm: build request: %w", err)
}
httpReq.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(httpReq)
if err != nil {
return "", fmt.Errorf("vllm request: %w", err)
}
defer resp.Body.Close()
respBody, err := io.ReadAll(resp.Body)
if err != nil {
return "", fmt.Errorf("vllm: read response: %w", err)
}
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("vllm HTTP %d: %s", resp.StatusCode, string(respBody))
}
var result struct {
Choices []struct {
Message struct {
Content string `json:"content"`
} `json:"message"`
} `json:"choices"`
}
if err := json.Unmarshal(respBody, &result); err != nil {
return "", fmt.Errorf("vllm: parse response: %w", err)
}
if len(result.Choices) == 0 {
return "", fmt.Errorf("vllm: empty choices in response")
}
return StripThink(result.Choices[0].Message.Content), nil
}
// Ping lists served models via the OpenAI-compatible /v1/models.
func (c *VLLMClient) Ping(ctx context.Context) ([]string, error) {
ctx, cancel := context.WithTimeout(ctx, pingTimeout)
defer cancel()
var out struct {
Data []struct {
ID string `json:"id"`
} `json:"data"`
}
if err := getJSON(ctx, c.endpoint+"/v1/models", &out); err != nil {
return nil, err
}
names := make([]string, 0, len(out.Data))
for _, m := range out.Data {
names = append(names, m.ID)
}
return names, nil
}
internal/peteclient/client.go
+607 -9
View File
@@ -48,6 +48,20 @@ type Fact struct {
Milestone string `json:"milestone,omitempty"`
OccurredAt int64 `json:"occurred_at"`
NoPush bool `json:"no_push,omitempty"` // backfill: suppress Pete web-push
// RunID names the expedition this fact is the ENDING of, and only the three
// facts that are one carry it: a clear, a retreat, a death. It is what lets
// Pete's dispatch link back to the run's own report — the log, the numbers,
// the moment it turned — instead of leaving a paragraph about an outcome with
// no way back to what produced it. Empty everywhere else, and safe to be
// empty: Pete renders the dispatch exactly as it did before the report existed.
RunID string `json:"run_id,omitempty"`
// Headline/Lede are LLM-authored prose for this fact, both optional. Pete
// prefers them over its own template when present and past its prose-guard,
// and falls back to the template otherwise — so an empty pair (LLM off, or
// authoring failed) is the normal, safe case. Populated by emitFact; see
// authorDispatch. Names in the prose must come only from Actors.
Headline string `json:"headline,omitempty"`
Lede string `json:"lede,omitempty"`
}
// Config controls the seam. Enabled=false makes Emit a durable no-op (nothing
@@ -266,9 +280,75 @@ type RosterDetail struct {
Modifiers [6]int `json:"modifiers"` // matching ability modifiers
Gear []GearItem `json:"gear,omitempty"`
// Expedition context, present only while on a run.
Supplies int `json:"supplies,omitempty"`
ThreatLevel int `json:"threat_level,omitempty"`
Room string `json:"room,omitempty"`
Supplies int `json:"supplies,omitempty"`
ThreatLevel int `json:"threat_level,omitempty"`
Room string `json:"room,omitempty"`
Map *RosterMap `json:"map,omitempty"`
// Party is who else is on this expedition, leader first. Absent for a solo
// run — a party of one is not a party, and the page should say nothing rather
// than draw a roster with a single chair in it.
Party []PartySeatView `json:"party,omitempty"`
// PartyKnown says this sender knows what a party seat is. It is a fact about
// the build, never about the character, so it is set unconditionally on every
// sheet — in town, solo, or seated with three others — and must never be
// computed from whether Party has anything in it.
//
// Party being omitempty is why it exists: a solo run and a game box too old to
// push seats both arrive at Pete as an empty slice, and Pete's page has to
// decide from that whether the viewer may throw away everybody else's day. An
// old build sends no key, which lands as false, and Pete withholds the button.
// No omitempty here for the same reason — an absent field is the fail-closed
// answer and this one is never absent on purpose.
PartyKnown bool `json:"party_known"`
}
// PartySeatView is one body on a shared expedition, as the public page may see
// it. Kind is what the seat *is*, which the game keeps carefully separate:
// "leader" owns the expedition row everyone else references, "member" is another
// player, "companion" is the hired NPC (Pete) who fights but has no mailbox and
// no loot.
//
// Name/Token are the same pair the board and the Siege muster use. The opt-out
// rule here is the Siege *contributor* rule, not the realm-occupant rule: an
// opted-out player's seat is anonymised (kept, with no name and no token) rather
// than deleted. A party of three that renders as two is a false statement about
// the run — the supply burn, the enemy scaling and the loot split all felt three
// bodies — whereas an unnamed seat says only that somebody else was there, which
// the zone line on this same page already implies.
type PartySeatView struct {
Kind string `json:"kind"` // leader|member|companion
Name string `json:"name,omitempty"`
Token string `json:"token,omitempty"` // empty: opted out, or a companion (no board row)
Level int `json:"level,omitempty"`
}
// RosterMap is the fog-of-war cut of an adventurer's zone graph: every node
// they have visited, plus the one-hop frontier of doors leading out of visited
// nodes, with the rooms behind those doors withheld. It is per-adventurer and
// rides the roster push beside Room. Only ids and kinds cross the wire — a
// ZoneNode's Label and Content (encounter, loot bias, narration) are spoilers
// and never leave the game box. Frontier nodes carry kind "unknown".
type RosterMap struct {
ZoneID string `json:"zone_id"`
CurrentNode string `json:"current_node"`
Visited []string `json:"visited"`
Nodes []RosterMapNode `json:"nodes"`
Edges []RosterMapEdge `json:"edges"`
}
// RosterMapNode is one room reduced to what a public map may show.
type RosterMapNode struct {
ID string `json:"id"`
Kind string `json:"kind"` // ZoneNodeKind, or "unknown" for an unreached frontier room
}
// RosterMapEdge is one directed passage. Lock names the gate kind
// (perception_check, key_required, ...) so the map can mark a door as barred;
// LockData and Hint stay behind on the game box.
type RosterMapEdge struct {
From string `json:"from"`
To string `json:"to"`
Lock string `json:"lock,omitempty"`
}
// GearItem is one equipped piece for the armor/gear panel.
@@ -336,6 +416,234 @@ func PushRoster(ctx context.Context, snap RosterSnapshot) error {
return std.post(ctx, "/api/ingest/roster", payload)
}
// SiegeDefender is one adventurer's standing in the current Siege muster.
//
// Token is the same public board token the roster uses, so Pete can link a
// defender to their page — and it is EMPTY for an opted-out player, with Name
// carrying anonName instead. That is the whole opt-out story here: their damage
// still counts and still holds its rank (the town's effort is the town's), but
// there is no name to click. It differs from the board's rule (omit entirely)
// on purpose — a defender board that silently dropped contributors would
// understate what the town actually did to the boss.
type SiegeDefender struct {
Token string `json:"token,omitempty"`
Name string `json:"name"`
Level int `json:"level,omitempty"`
Fights int `json:"fights"`
Damage int `json:"damage"`
FoughtToday bool `json:"fought_today"`
}
// SiegePast is one closed-out Siege for the history table.
type SiegePast struct {
BossID int64 `json:"boss_id"`
BossName string `json:"boss_name"`
Tier int `json:"tier"`
Outcome string `json:"outcome"` // "defeated" | "survived"
HPRemaining int `json:"hp_remaining"`
HPMax int `json:"hp_max"`
Defenders int `json:"defenders"`
MVP string `json:"mvp,omitempty"`
MVPFights int `json:"mvp_fights,omitempty"`
EndedAt int64 `json:"ended_at"`
}
// SiegeSnapshot is the complete war room: the live boss (if any), its muster,
// and every Siege that came before. Same complete-snapshot contract as the
// roster — Pete replaces its copy — so a defender omitted here leaves the board
// and a resolved Siege stops showing a live bar.
//
// Defenders carries EVERY alive adventurer, not just contributors. The zero-fight
// rows are the point: one bout per person per day means somebody who hasn't
// swung today is a hit the town hasn't taken, and the page can only show that gap
// if the people in it are on the wire.
type SiegeSnapshot struct {
SnapshotAt int64 `json:"snapshot_at"`
Active bool `json:"active"`
BossID int64 `json:"boss_id,omitempty"`
BossName string `json:"boss_name,omitempty"`
Tier int `json:"tier,omitempty"`
HPCurrent int `json:"hp_current"`
HPMax int `json:"hp_max"`
StartsAt int64 `json:"starts_at,omitempty"`
EndsAt int64 `json:"ends_at,omitempty"`
BoutsToday int `json:"bouts_today"`
Defenders []SiegeDefender `json:"defenders,omitempty"`
History []SiegePast `json:"history,omitempty"`
}
// PushSiege sends the war room to Pete, synchronously, and drops it on failure —
// the same drop-the-lie semantics as PushRoster. A retried snapshot would claim
// a pool level that has since moved, and the next tick carries the truth anyway.
func PushSiege(ctx context.Context, snap SiegeSnapshot) error {
if !Enabled() {
return nil
}
payload, err := json.Marshal(snap)
if err != nil {
return err
}
return std.post(ctx, "/api/ingest/siege", payload)
}
// RunBeat is one structured moment inside an expedition run: a room entered, a
// fight resolved, a trap sprung, a haul taken. Facts, never prose — Pete owns
// the words, exactly as it does for a Fact. The engine already narrates every
// one of these to Matrix and then throws the narration away; this carries the
// shape underneath it so Pete can retell the run to somebody who wasn't there.
//
// (RunID, Seq) is the identity. Seq is monotonic per run and assigned at record
// time, so Pete can order a batch that arrives out of order and drop a duplicate
// without comparing contents.
//
// Nothing here is player-identifying except Token, which rides the `start` beat
// only and is the same public board token the roster uses. An opted-out player's
// beats are never pushed at all — see pushRunBeats.
type RunBeat struct {
RunID string `json:"run_id"`
Seq int64 `json:"seq"`
Kind string `json:"kind"` // start|room|combat|trap|treasure|haul|lock|camp|region|end|summary
OccurredAt int64 `json:"occurred_at"`
Token string `json:"token,omitempty"` // `start` only: whose run this is
Name string `json:"name,omitempty"` // `start` only: character name
Level int `json:"level,omitempty"` // `start` only
Zone string `json:"zone,omitempty"`
Region string `json:"region,omitempty"`
Room int `json:"room,omitempty"` // 1-based, as the player sees it
TotalRooms int `json:"total_rooms,omitempty"` // 0 when unknown
RoomKind string `json:"room_kind,omitempty"` // entry|exploration|trap|elite|boss|secret
Target string `json:"target,omitempty"` // monster, item, region, lock — the noun
Outcome string `json:"outcome,omitempty"`
Amount int `json:"amount,omitempty"` // damage taken, or a total quantity
Count int `json:"count,omitempty"` // how many distinct things Amount covers
HP int `json:"hp,omitempty"`
HPMax int `json:"hp_max,omitempty"`
Crits int `json:"crits,omitempty"`
Fumbles int `json:"fumbles,omitempty"`
// Prose is the single exception to "nouns and numbers only", and it is
// confined to the one kind that has any: `summary`, the three sentences the
// local model writes over a finished run. Pete guards it exactly as it guards
// a dispatch lede and drops the words (not the beat) on a rejection. Every
// other kind must leave this empty — Pete scrubs it if they don't.
Prose string `json:"prose,omitempty"`
}
// RealmZone is one zone as the realm map draws it: what it is, who first got
// through it, how many have since, and who is inside it right now.
//
// FirstClearBy is a character name and FirstClearToken the public board token,
// exactly as the Siege muster pairs them — and the token is EMPTY for a player
// who has opted out, keeping the name off the page too (see buildRealmSnapshot:
// an opted-out first-clearer is anonymised, not deleted, because deleting the
// claim would make the zone read as never-cleared, which is a different and
// false statement about the realm).
type RealmZone struct {
ID string `json:"id"`
Display string `json:"display"`
Tier int `json:"tier"`
LevelMin int `json:"level_min"`
LevelMax int `json:"level_max"`
Faction string `json:"faction,omitempty"`
Atmosphere string `json:"atmosphere,omitempty"`
Postgame bool `json:"postgame,omitempty"` // T6 mythic: gated, drawn apart
FirstClearBy string `json:"first_clear_by,omitempty"`
FirstClearToken string `json:"first_clear_token,omitempty"`
FirstClearAt int64 `json:"first_clear_at,omitempty"`
Clears int `json:"clears"` // boss-defeated runs, all time
Clearers int `json:"clearers"` // distinct adventurers who have managed it
Occupants []RealmOccupant `json:"occupants,omitempty"` // in there right now
}
// RealmOccupant is somebody currently on an expedition in a zone. Same
// name+token pair as everywhere else, and an opted-out player is omitted
// outright rather than anonymised: unlike a first clear, presence is not part of
// a shared tally that stops adding up without them, and "who is in there right
// now" is exactly the live-location fact the liveblog is careful about.
type RealmOccupant struct {
Token string `json:"token,omitempty"`
Name string `json:"name"`
Level int `json:"level,omitempty"`
Day int `json:"day,omitempty"`
}
// RealmFirst is one row of the hall of firsts: a thing that happened in the
// realm exactly once ever, and who it happened to. The ledger
// (news_realm_firsts) records only (kind, target, first_at) — the holder is
// recovered by gogobee at push time from the run history, which is why this is
// pushed rather than derived on Pete.
type RealmFirst struct {
Kind string `json:"kind"` // "zone" | "treasure"
Target string `json:"target"` // the zone id or treasure key
Display string `json:"display"` // the human name for it
Tier int `json:"tier,omitempty"` // zone tier, when kind is "zone"
Holder string `json:"holder,omitempty"` // character name, empty when unrecoverable
Token string `json:"token,omitempty"` // board token; empty when opted out
AtUnix int64 `json:"at_unix"` // when the realm first saw it
}
// RealmStanding is one adventurer's line on the board. Every number here is a
// lifetime total from the game's own run history — nothing is a rate, an
// average, or anything that would move on its own while nobody played.
type RealmStanding struct {
Token string `json:"token,omitempty"`
Name string `json:"name"`
Level int `json:"level"`
ClassRace string `json:"class_race,omitempty"`
DeepestTier int `json:"deepest_tier"` // deepest zone tier actually cleared
Clears int `json:"clears"`
Zones int `json:"zones"` // distinct zones cleared
Firsts int `json:"firsts"` // realm-firsts held
SiegeDamage int `json:"siege_damage"`
SiegeFights int `json:"siege_fights"`
}
// RealmSnapshot is the whole realm as one photograph: every zone, the hall of
// firsts, and the board. Snapshot semantics, like the roster and the Siege —
// Pete replaces its copy and a failed push is dropped, not retried.
//
// It is pushed on the roster ticker but NOT every tick: none of it moves fast
// enough to be worth the aggregate queries every two minutes, and the page's
// staleness window is generous for exactly that reason. See realmPushInterval.
type RealmSnapshot struct {
SnapshotAt int64 `json:"snapshot_at"`
Zones []RealmZone `json:"zones,omitempty"`
Firsts []RealmFirst `json:"firsts,omitempty"`
Standings []RealmStanding `json:"standings,omitempty"`
}
// PushRealm sends the realm pages' backing data to Pete. Drop-on-failure, same
// as the other two snapshots.
func PushRealm(ctx context.Context, snap RealmSnapshot) error {
if !Enabled() {
return nil
}
payload, err := json.Marshal(snap)
if err != nil {
return err
}
return std.post(ctx, "/api/ingest/realm", payload)
}
// PushRunBeats delivers a batch of beats. Unlike the snapshots this is
// append-only and IS retried — a dropped beat is a hole in a story, not a stale
// number that the next tick corrects. The caller only marks rows sent on success.
func PushRunBeats(ctx context.Context, beats []RunBeat) error {
if !Enabled() || len(beats) == 0 {
return nil
}
payload, err := json.Marshal(struct {
Beats []RunBeat `json:"beats"`
}{beats})
if err != nil {
return err
}
return std.post(ctx, "/api/ingest/run", payload)
}
// PlayerDetail is the private, owner-only expansion for one player: inventory,
// vault, house, and pets. Like MischiefBalance it is keyed by localpart (the
// sign-in name), in its own keyspace on Pete — Pete only ever serves it back to
@@ -348,17 +656,163 @@ type PlayerDetail struct {
Token string `json:"token"`
Inventory []ItemView `json:"inventory,omitempty"`
Vault []ItemView `json:"vault,omitempty"`
Equipped []ItemView `json:"equipped,omitempty"`
House HouseView `json:"house"`
Pets []PetView `json:"pets,omitempty"`
// Slots is the 5 standard equipment slots (weapon/armor/helmet/boots/tool) for
// the web management panel. Worn masterwork/arena pieces surface here (via
// CanTakeOff), not in Equipped, which stays magic-only (the DnD slots).
Slots []EquipSlotView `json:"slots,omitempty"`
// Balance is the owner's euro balance, for the web's upgrade/repair confirm.
// No omitempty: a €0 balance is a real, informative fact (a broke player), not
// an absent one — dropping it would let the confirm dialog show a stale amount.
Balance float64 `json:"balance"`
// Zones is where this adventurer may go right now, priced. It is the offer
// list behind the web's "send on expedition" picker: level gating and the T6
// postgame gate are resolved here, so a zone the player cannot enter is simply
// absent rather than shown and then refused. Empty while they are already out.
Zones []ZoneOffer `json:"zones,omitempty"`
// Resume is the extracted expedition waiting to be walked back into, priced
// the same way. Absent when there is nothing to resume.
Resume *ResumeOffer `json:"resume,omitempty"`
// Babysit is the pet-care subscription's standing and price. Always present
// for a live adventurer: "you already have one" is as useful to the page as a
// price is.
Babysit *BabysitOffer `json:"babysit,omitempty"`
}
// ItemView is one backpack or vault item for the private inventory panel.
// ZoneOffer is one place the owner may set out for, with what the trip costs.
// Pete renders these and does no arithmetic — the prices are the game's, quoted
// at push time, and gogobee re-quotes them for real when the order lands.
type ZoneOffer struct {
ID string `json:"id"`
Display string `json:"display"`
Tier int `json:"tier"`
Hook string `json:"hook,omitempty"`
Postgame bool `json:"postgame,omitempty"`
Loadouts []LoadoutOffer `json:"loadouts,omitempty"`
}
// LoadoutOffer is one supply preset for a zone: what it is called, what it
// costs, and roughly how long it lasts. Key is the token the order carries back.
type LoadoutOffer struct {
Key string `json:"key"` // lean|balanced|heavy
Name string `json:"name"`
Blurb string `json:"blurb,omitempty"`
Cost int `json:"cost"`
Days int `json:"days"` // provisions at the zone's daily burn
}
// ResumeOffer is the extracted expedition the owner can still walk back into,
// with the same priced loadouts as a fresh departure. ExpiresAt is the end of
// the seven-day window, so the page can say how long is left rather than just
// that there is a way back.
type ResumeOffer struct {
ZoneID string `json:"zone_id"`
Display string `json:"display"`
Tier int `json:"tier"`
Day int `json:"day"`
ExpiresAt int64 `json:"expires_at,omitempty"`
Loadouts []LoadoutOffer `json:"loadouts,omitempty"`
}
// BabysitOffer is the sitter's standing and price. WeekCost/MonthCost are the
// two durations the game sells; they scale with level, which is why they are
// pushed rather than hardcoded on Pete.
type BabysitOffer struct {
Active bool `json:"active"`
ExpiresAt int64 `json:"expires_at,omitempty"`
WeekCost int `json:"week_cost"`
MonthCost int `json:"month_cost"`
}
// EquipSlotView is one of the 5 standard equipment slots, carrying what the web
// management panel needs: what's worn now, whether it round-trips to the pack
// (masterwork/arena), the next tier's name and price for an upgrade offer, and a
// repair cost when the piece is damaged. Pete renders it and trusts only these
// facts — a client-forged tier or price is resolved back against this view.
type EquipSlotView struct {
Slot string `json:"slot"` // weapon|armor|helmet|boots|tool
Name string `json:"name"`
Tier int `json:"tier"`
Condition int `json:"condition"`
Masterwork bool `json:"masterwork,omitempty"`
ArenaTier int `json:"arena_tier,omitempty"`
CanTakeOff bool `json:"can_take_off,omitempty"` // masterwork/arena → round-trippable
NextTier int `json:"next_tier,omitempty"` // 0 = at max tier (5)
NextName string `json:"next_name,omitempty"`
NextPrice float64 `json:"next_price,omitempty"`
RepairCost int `json:"repair_cost,omitempty"` // 0 = full condition
}
// ItemView is one item in the private panels — backpack, vault, or worn.
//
// Slot/SkillSource/Desc/Effect are display resolutions done at the push site,
// because an adventure_inventory row carries none of them: descriptions live on
// MagicItem/EquipmentDef, and the combat delta is computed, never stored.
//
// SkillSource is only the player-facing skill a masterwork piece draws on
// ("mining"). Inventory rows smuggle "magic_item:<id>" through the same column
// as an internal registry pointer; that is not a fact about the item and never
// goes on the wire.
//
// Attunement (does it need a bond) and Attuned (does it have one) are distinct:
// with a hard cap of 3 bonds, a worn item can sit inert, and a player deciding
// what to wear needs to see the difference.
type ItemView struct {
Name string `json:"name"`
Type string `json:"type"`
Tier int `json:"tier"`
Value int64 `json:"value"`
Temper int `json:"temper,omitempty"`
// ID is the adventure_inventory row id, sent only for a backpack item the
// magic-item equip path will accept — so a non-zero ID is also the signal that
// this item can be equipped from the web. Worn and vault rows carry none: a
// worn item unequips by slot, and a vault item can't be equipped at all. Pete
// round-trips this id in an equip order; the table is AUTOINCREMENT, so a stale
// id (item already moved) misses cleanly rather than hitting the wrong row.
ID int64 `json:"id,omitempty"`
Name string `json:"name"`
Type string `json:"type"`
Tier int `json:"tier"`
Value int64 `json:"value"`
Temper int `json:"temper,omitempty"`
Slot string `json:"slot,omitempty"`
SkillSource string `json:"skill_source,omitempty"`
Desc string `json:"desc,omitempty"`
Effect string `json:"effect,omitempty"`
Attunement bool `json:"attunement,omitempty"`
Attuned bool `json:"attuned,omitempty"`
// Compare pairs a backpack magic item against whatever is worn in the slot it
// would equip into, so the owner can tell an upgrade from a sidegrade without
// eyeballing two opaque effect strings. Set only on backpack magic items (the
// ones that carry an equip ID); worn and vault rows never have it. Owner-private,
// rides detail_json — no migration, no public surface.
Compare *ItemCompare `json:"compare,omitempty"`
}
// ItemCompare is the per-stat verdict for equipping a backpack magic item over
// what is currently worn in its slot. gogobee computes it (the power math folds
// in tempering and bond availability, which live in the engine); Pete only
// renders it and does no arithmetic.
type ItemCompare struct {
// Verdict is one of: upgrade, downgrade, sidegrade, same, new, inert.
// upgrade every changed stat a gain
// downgrade every changed stat a loss
// sidegrade mixed — some better, some worse; no winner claimed
// same no stat differs
// new the target slot is empty; equipping fills it
// inert needs a bond and none is free — wearing it would do nothing
Verdict string `json:"verdict"`
// VsName is the worn item being replaced; "" when Verdict is new (empty slot).
VsName string `json:"vs_name,omitempty"`
// VsSlot is the slot the item would land in (e.g. "ring_1").
VsSlot string `json:"vs_slot,omitempty"`
// Deltas is one entry per changed stat, each flagged better/worse. Engine-
// rendered player-facing text; Pete draws arrows off Better and does no math.
Deltas []ItemDelta `json:"deltas,omitempty"`
}
// ItemDelta is one stat's change between the candidate item and the worn item.
type ItemDelta struct {
Label string `json:"label"`
Better bool `json:"better"`
Text string `json:"text"`
}
// HouseView is the owner's housing summary.
@@ -370,11 +824,19 @@ type HouseView struct {
}
// PetView is one pet slot.
//
// XP and XPNeeded are both in **centi-XP** — the engine's own unit, a hundredth
// of a point, because a pet earns 1.5 XP per action and the ledger is an int.
// Pete divides by 100 to show it and does no other arithmetic on either number:
// the curve behind XPNeeded is petXPToNextLevel's, per level band, and it is not
// Pete's business to know it. XPNeeded is 0 at the level cap, which is the only
// signal that there is nothing left to fill.
type PetView struct {
Type string `json:"type"`
Name string `json:"name"`
Level int `json:"level"`
XP int `json:"xp,omitempty"`
XPNeeded int `json:"xp_needed,omitempty"` // 0 = at the level cap
ArmorTier int `json:"armor_tier,omitempty"`
}
@@ -568,6 +1030,142 @@ func ClaimMischief(ctx context.Context, guid, status, detail string) error {
return std.post(ctx, "/api/mischief/claim", payload)
}
// ---------------------------------------------------------------------------
// The equip queue's reverse pipe
//
// An owner asks, on their own detail page, to wear or take off an item. Pete
// records the intent; we poll for it, run the real equip against our own
// equipment tables, and file a verdict. Same shape as mischief — Pete has no
// route in — but with one crucial difference: the game action is NOT naturally
// idempotent (equipping consumes an inventory row and regenerates it on
// unequip), so re-running a drained order would double-move items. The poller
// therefore short-circuits on the order guid before it mutates, the way
// placeWebMischief does on its contract; the guid is still the end-to-end key,
// but here it guards a non-idempotent action rather than riding a naturally
// idempotent one.
// ---------------------------------------------------------------------------
// EquipOrder is one equip/unequip as Pete describes it. owner_localpart is the
// Matrix localpart of the character to dress; item_id is the adventure_inventory
// row id for an equip (0 for an unequip, which keys on slot). character_name and
// item_name are display copy Pete froze at order time; we don't need them.
type EquipOrder struct {
GUID string `json:"guid"`
OwnerLocalpart string `json:"owner_localpart"`
ItemID int64 `json:"item_id"`
ItemName string `json:"item_name"`
Slot string `json:"slot"`
Action string `json:"action"` // equip / unequip / upgrade / repair
Tier int `json:"tier"` // upgrade target tier (an EquipmentSlot tier); unused by the others
Status string `json:"status"`
CreatedAt int64 `json:"created_at"`
}
// PendingEquip asks Pete for equip orders waiting on us. A Pete predating the
// queue answers 404, surfaced here as an error the poll loop logs quietly.
func PendingEquip(ctx context.Context) ([]EquipOrder, error) {
if !Enabled() {
return nil, nil
}
var out []EquipOrder
if err := std.getJSON(ctx, "/api/equip/pending", &out); err != nil {
return nil, err
}
return out, nil
}
// VerdictEquip files our verdict on an equip order. Idempotent on Pete, so a
// retried verdict is safe; the verdict rides this call directly.
func VerdictEquip(ctx context.Context, guid, status, detail string) error {
payload, err := json.Marshal(map[string]string{"guid": guid, "status": status, "detail": detail})
if err != nil {
return err
}
return std.post(ctx, "/api/equip/verdict", payload)
}
// ---------------------------------------------------------------------------
// The action queue
//
// The equip queue's sibling, and the first one that plays the game rather than
// dressing the character. An owner clicks "Pull out" on their own adventurer
// page or "Take your bout" on the war room; Pete records the intent and we drain
// it here. Same non-idempotent problem, same answer: the poller guards on the
// order guid before it runs anything, because an extraction ends a run and a
// bout spends the day's only swing, and neither converges on a replay.
//
// Nothing in an order names a character. Pete resolves that from the session
// (one account, one localpart, one adventurer) so there is no id on the wire for
// a client to forge — the contrast with EquipOrder, which has to carry an item
// id and a slot, is deliberate.
// ---------------------------------------------------------------------------
// AdvOrder is one requested action as Pete describes it. owner_localpart is the
// Matrix localpart whose adventurer acts; token and character_name are display
// copy Pete froze at order time and we ignore both.
type AdvOrder struct {
GUID string `json:"guid"`
OwnerLocalpart string `json:"owner_localpart"`
Token string `json:"token"`
CharacterName string `json:"character_name"`
Action string `json:"action"`
Status string `json:"status"`
CreatedAt int64 `json:"created_at"`
// Params is the verb's arguments, and only the verbs that take any carry it:
// which zone, which supply loadout, how many days of sitting. It never names
// an adventurer — that still comes from the session on Pete's side — and
// every field in it is re-resolved against the game's own tables before it
// means anything, so a forged zone or a forged price buys nothing.
Params *AdvOrderParams `json:"params,omitempty"`
}
// AdvOrderParams is the union of every verb's arguments, flat rather than
// per-verb because there are three of them and each reads one or two fields.
// Anything a verb does not read is ignored rather than rejected.
type AdvOrderParams struct {
Zone string `json:"zone,omitempty"` // zone id, for expedition_start
Loadout string `json:"loadout,omitempty"` // lean|balanced|heavy, for expedition_start / resume
Days int `json:"days,omitempty"` // 7 or 30, for babysit
}
// Action names, the wire contract's half of storage.AdvAction* on Pete.
const (
AdvOrderExtract = "extract"
AdvOrderSiegeJoin = "siege_join"
AdvOrderExpedition = "expedition_start"
AdvOrderResume = "expedition_resume"
AdvOrderBabysit = "babysit"
// The three doors the web verbs' own refusal text used to name without
// offering: `!expedition abandon`, `!expedition leave`, `!adventure babysit
// cancel`. None of them takes an argument and none of them spends money.
AdvOrderAbandon = "expedition_abandon"
AdvOrderLeave = "expedition_leave"
AdvOrderBabysitCancel = "babysit_cancel"
)
// PendingOrders asks Pete for web actions waiting on us. A Pete predating the
// queue answers 404, surfaced here as an error the poll loop logs quietly.
func PendingOrders(ctx context.Context) ([]AdvOrder, error) {
if !Enabled() {
return nil, nil
}
var out []AdvOrder
if err := std.getJSON(ctx, "/api/adventure/orders/pending", &out); err != nil {
return nil, err
}
return out, nil
}
// VerdictOrder files our verdict on a web action. Idempotent on Pete, so a
// retried verdict is safe.
func VerdictOrder(ctx context.Context, guid, status, detail string) error {
payload, err := json.Marshal(map[string]string{"guid": guid, "status": status, "detail": detail})
if err != nil {
return err
}
return std.post(ctx, "/api/adventure/orders/verdict", payload)
}
// getJSON does a bearer-authed GET and decodes the body.
func (c *Client) getJSON(ctx context.Context, path string, out any) error {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.cfg.IngestURL+path, nil)
internal/plugin/adventure.go
+16 -2
View File
@@ -253,6 +253,12 @@ func (p *AdventurePlugin) Init() error {
// deaths, single-holder achievements) the first boot the seam is live, so
// launch doesn't open onto an empty section. One-shot, kept (see gap #7).
p.bootstrapPeteNewsBackfill()
// Repair the zone half of news_realm_firsts: the original one-shot filtered
// on `abandoned = 0` (which does not mean anybody gave up) and dated every
// row to the minute it ran. Seeds only, emits nothing. Runs regardless of the
// news switches — a ledger that is right only while emission is on mis-tiers
// the first dispatch after somebody flips it. One-shot, kept.
bootstrapRealmFirstsReseed()
// Phase R1 orphan-archive used to run here on every Init, but it
// over-archived: it treats any active dnd_zone_run row not linked to
// an active expedition as a legacy `!adventure dungeon` orphan, which
@@ -291,6 +297,8 @@ func (p *AdventurePlugin) Init() error {
go p.expeditionBoredomTicker()
go p.mischiefTicker()
go p.peteMischiefTicker()
go p.peteEquipTicker()
go p.peteAdvOrderTicker()
// Auto-cashout any arena runs left in 'awaiting' from a prior restart
p.arenaCleanupStaleRuns()
@@ -1366,6 +1374,7 @@ func (p *AdventurePlugin) sendTreasureDiscoveryDM(userID id.UserID, char *Advent
"{treasure_name}": def.Name,
"{bonus_desc}": def.InventoryDesc,
"{location}": loc.Name,
"{location_mid}": advLocationMidSentence(loc.Name),
})
p.SendDM(userID, text)
@@ -1382,14 +1391,19 @@ func (p *AdventurePlugin) announceTreasureToRoom(char *AdventureCharacter, def *
if def == nil || def.RoomAnnounce == "" {
return
}
// The same story-grade gate feeds Pete's trophy case. Emit before the
// games-room check so a find is still recorded as news even when no room is
// configured to announce it in.
emitTreasureFound(char.UserID, def, loc)
gr := gamesRoom()
if gr == "" {
return
}
displayName, _ := loadDisplayName(char.UserID)
announce := advSubstituteFlavor(def.RoomAnnounce, map[string]string{
"{name}": displayName,
"{location}": loc.Name,
"{name}": displayName,
"{location}": loc.Name,
"{location_mid}": advLocationMidSentence(loc.Name),
})
p.SendMessage(id.RoomID(gr), announce)
}
internal/plugin/adventure_babysit.go
+135 -27
View File
@@ -1,6 +1,7 @@
package plugin
import (
"errors"
"fmt"
"log/slog"
"strings"
@@ -100,33 +101,91 @@ func (p *AdventurePlugin) handleBabysitCmd(ctx MessageContext, args string) erro
}
}
func (p *AdventurePlugin) handleBabysitPurchase(ctx MessageContext, days int) error {
userMu := p.advUserLock(ctx.Sender)
// Sentinels for the ways hiring a sitter can be refused, so the web action queue
// (pete_orders.go) can pick a verdict without parsing prose. Each is returned
// inside an advRefusal carrying the finished sentence, so `!adventure babysit`
// keeps the copy it always sent.
var (
errBabysitNoCharacter = errors.New("babysit: no adventurer")
errBabysitActive = errors.New("babysit: a sitter is already engaged")
errBabysitDead = errors.New("babysit: adventurer is dead")
errBabysitBroke = errors.New("babysit: cannot cover the fee")
errBabysitFailed = errors.New("babysit: could not engage a sitter")
)
// babysitOutcome is what hiring did, for a caller describing it somewhere other
// than a DM.
type babysitOutcome struct {
Days int
Cost int
PetName string
PetLine string
Confirm string
}
// performBabysitPurchase is `!adventure babysit week|month` minus the command
// framing. Shared with the web action queue so hiring a sitter from a phone
// engages the same one, on the same clock, with the same log reset.
//
// idemKey, when set, is the web order's guid and moves the fee onto DebitIdem so
// a re-offered order cannot charge twice.
func (p *AdventurePlugin) performBabysitPurchase(uid id.UserID, days int, idemKey string) (babysitOutcome, error) {
userMu := p.advUserLock(uid)
userMu.Lock()
defer userMu.Unlock()
char, err := loadAdvCharacter(ctx.Sender)
char, err := loadAdvCharacter(uid)
if err != nil {
return p.SendDM(ctx.Sender, "No adventurer found. Type `!adventure` to create one.")
return babysitOutcome{}, refuseAdv(errBabysitNoCharacter, "No adventurer found. Type `!adventure` to create one.")
}
if char.BabysitActive {
return p.SendDM(ctx.Sender, "🍼 The babysitter is already here. They're not leaving until the job is done.")
// A web order that already paid and already engaged the sitter lands here
// on the re-offer. The settled fee is what tells that apart from somebody
// who really does already have one.
if idemKey != "" && p.euro != nil && p.euro.HasExternalTx(idemKey) {
// Re-quote the fee rather than leaving it zero: the verdict this
// feeds prints the coin figure, and "0 coins" would be a false
// receipt for a hire the player did pay for.
return babysitOutcome{
Days: days,
Cost: babysitDailyCost(dndLevelForUser(char.UserID)) * days,
PetName: char.PetName,
}, nil
}
return babysitOutcome{}, refuseAdv(errBabysitActive, "🍼 The babysitter is already here. They're not leaving until the job is done.")
}
if !char.Alive {
return p.SendDM(ctx.Sender, "Your adventurer is dead. The babysitter does not work with corpses.")
return babysitOutcome{}, refuseAdv(errBabysitDead, "Your adventurer is dead. The babysitter does not work with corpses.")
}
daily := babysitDailyCost(dndLevelForUser(char.UserID))
totalCost := daily * days
balance := p.euro.GetBalance(char.UserID)
if balance < float64(totalCost) {
return p.SendDM(ctx.Sender, fmt.Sprintf("🍼 The babysitting service costs %s for %d days. You have %s. The service has standards. Not many, but some.", fmtEuro(totalCost), days, fmtEuro(balance)))
if p.euro == nil {
return babysitOutcome{}, refuseAdv(errBabysitFailed, "Coin system unavailable — try again later.")
}
// Skip the affordability gate on a re-offer that already paid: the fee is a
// settled fact, and re-reading the now-lower balance would bounce a sitter the
// player has bought.
if !(idemKey != "" && p.euro.HasExternalTx(idemKey)) {
balance := p.euro.GetBalance(char.UserID)
if balance < float64(totalCost) {
return babysitOutcome{}, refuseAdv(errBabysitBroke,
"🍼 The babysitting service costs %s for %d days. You have %s. The service has standards. Not many, but some.",
fmtEuro(totalCost), days, fmtEuro(balance))
}
}
if !p.euro.Debit(char.UserID, float64(totalCost), "babysit_purchase") {
return p.SendDM(ctx.Sender, "Payment failed. The babysitter looked at your wallet and walked away.")
debited := false
if idemKey != "" {
ok, _, err := p.euro.DebitIdem(char.UserID, float64(totalCost), "babysit_purchase", idemKey)
debited = err == nil && ok
} else {
debited = p.euro.Debit(char.UserID, float64(totalCost), "babysit_purchase")
}
if !debited {
return babysitOutcome{}, refuseAdv(errBabysitFailed, "Payment failed. The babysitter looked at your wallet and walked away.")
}
clearBabysitLogs(char.UserID)
@@ -138,23 +197,40 @@ func (p *AdventurePlugin) handleBabysitPurchase(ctx MessageContext, days int) er
if err := saveAdvCharacter(char); err != nil {
slog.Error("babysit: failed to save character", "user", char.UserID, "err", err)
p.euro.Credit(char.UserID, float64(totalCost), "babysit_refund")
return p.SendDM(ctx.Sender, "Something went wrong activating the service. Your gold has been refunded.")
if idemKey != "" {
if _, _, err := p.euro.CreditIdem(char.UserID, float64(totalCost), "babysit_refund", idemKey+":refund"); err != nil {
slog.Error("babysit: refund failed", "user", char.UserID, "order", idemKey, "err", err)
}
} else {
p.euro.Credit(char.UserID, float64(totalCost), "babysit_refund")
}
return babysitOutcome{}, refuseAdv(errBabysitFailed, "Something went wrong activating the service. Your gold has been refunded.")
}
if err := upsertPlayerMetaBabysitState(char.UserID, babysitStateFromAdvChar(char)); err != nil {
slog.Error("player_meta: babysit start dual-write failed", "user", char.UserID, "err", err)
}
confirm := pickBabysitFlavor(babysitConfirmLines)
durLabel := "1 week"
if days == 30 {
durLabel = "1 month"
}
petLine := "No pet to tend yet — the babysitter will keep that in mind."
if char.HasPet() {
petLine = fmt.Sprintf("Pet: %s (L%d) — daily care included", char.PetName, char.PetLevel)
}
return babysitOutcome{
Days: days, Cost: totalCost, PetName: char.PetName, PetLine: petLine,
Confirm: pickBabysitFlavor(babysitConfirmLines),
}, nil
}
// handleBabysitPurchase is the command framing around performBabysitPurchase.
func (p *AdventurePlugin) handleBabysitPurchase(ctx MessageContext, days int) error {
out, err := p.performBabysitPurchase(ctx.Sender, days, "")
if err != nil {
return p.SendDM(ctx.Sender, err.Error())
}
durLabel := "1 week"
if days == 30 {
durLabel = "1 month"
}
text := fmt.Sprintf("🍼 **Adventurer Babysitting Service — Activated**\n\n"+
"Duration: %s (%d days)\n"+
@@ -162,7 +238,7 @@ func (p *AdventurePlugin) handleBabysitPurchase(ctx MessageContext, days int) er
"%s\n"+
"Camp safety: standard camps now rest like fortified ones\n"+
"Rival duels: declined on your behalf\n\n"+
"_%s_", durLabel, days, totalCost, petLine, confirm)
"_%s_", durLabel, days, out.Cost, out.PetLine, out.Confirm)
return p.SendDM(ctx.Sender, text)
}
@@ -209,25 +285,49 @@ func (p *AdventurePlugin) handleBabysitStatus(ctx MessageContext) error {
return p.SendDM(ctx.Sender, text)
}
func (p *AdventurePlugin) handleBabysitCancel(ctx MessageContext) error {
userMu := p.advUserLock(ctx.Sender)
// babysitCancelOutcome is what dismissing the sitter did. Summary is the Matrix
// block of what they got through while they were here — a paragraph of counts,
// which is right under a DM and too much for a one-line web verdict, so the
// caller decides whether to print it.
type babysitCancelOutcome struct {
Summary string
PetName string
}
// errBabysitNoSitter is the one way cancelling can be refused. There is no
// "already cancelled" race to worry about: the check and the write are both under
// the per-user lock this takes.
var errBabysitNoSitter = errors.New("babysit: no sitter to dismiss")
// performBabysitCancel is `!adventure babysit cancel` minus the command framing.
// Shared with the web action queue.
//
// This one TAKES the per-user lock, unlike the abandon/leave twins beside it in
// the order path — because its Matrix caller does not hold it (handleBabysitCmd
// dispatches straight here, where `!expedition` holds the lock across its whole
// switch). Its web wrapper must therefore NOT take it. The asymmetry is per verb
// and is worth checking against the Matrix caller every time one is added.
//
// No refund, by design: the sitter was already here.
func (p *AdventurePlugin) performBabysitCancel(uid id.UserID) (babysitCancelOutcome, error) {
userMu := p.advUserLock(uid)
userMu.Lock()
defer userMu.Unlock()
char, err := loadAdvCharacter(ctx.Sender)
char, err := loadAdvCharacter(uid)
if err != nil {
return p.SendDM(ctx.Sender, "No adventurer found.")
return babysitCancelOutcome{}, refuseAdv(errBabysitNoCharacter, "No adventurer found.")
}
if !char.BabysitActive {
return p.SendDM(ctx.Sender, "🍼 There's nothing to cancel. The babysitter isn't here.")
return babysitCancelOutcome{}, refuseAdv(errBabysitNoSitter, "🍼 There's nothing to cancel. The babysitter isn't here.")
}
logs, err := loadBabysitLogs(char.UserID)
if err != nil {
slog.Error("babysit: failed to load logs", "user", char.UserID, "err", err)
}
summary := renderBabysitSummary(char, logs)
out := babysitCancelOutcome{Summary: renderBabysitSummary(char, logs), PetName: char.PetName}
char.BabysitActive = false
char.BabysitExpiresAt = nil
@@ -239,7 +339,15 @@ func (p *AdventurePlugin) handleBabysitCancel(ctx MessageContext) error {
slog.Error("player_meta: babysit cancel dual-write failed", "user", char.UserID, "err", err)
}
return p.SendDM(ctx.Sender, "🍼 Service cancelled. No refund. The babysitter was already there.\n\n"+summary)
return out, nil
}
func (p *AdventurePlugin) handleBabysitCancel(ctx MessageContext) error {
out, err := p.performBabysitCancel(ctx.Sender)
if err != nil {
return p.SendDM(ctx.Sender, err.Error())
}
return p.SendDM(ctx.Sender, "🍼 Service cancelled. No refund. The babysitter was already there.\n\n"+out.Summary)
}
// ── Expiry Check ────────────────────────────────────────────────────────────
internal/plugin/adventure_flavor_robbie.go
+6
View File
@@ -45,6 +45,12 @@ var robbieAllShopGear = "Nothing fancy today but that's alright. Clean inventory
var robbieLeftConsumable = "Oh -- one more thing. I tucked a %s into your bag on the way out. " +
"You've had me round enough times now that it felt rude not to. For the trouble, eh? _winks_"
// robbieLeftForTheHaul is the big-haul variant: he took enough in one go that
// walking off with only a handling fee would look bad. Takes the item list.
var robbieLeftForTheHaul = "Oh -- and I left you something. %s. " +
"You had me carting that lot down four flights, and a man who takes that much " +
"and gives back nothing isn't a bandit, he's a landlord. _winks_"
// ── Room Announcements ───────────────────────────────────────────────────────
var robbieRoomStandard = "🎩 Robbie paid %s a visit and collected %d item(s) from their inventory. " +
internal/plugin/adventure_flavor_treasure.go
+10 -10
View File
@@ -232,7 +232,7 @@ var TreasureDiscovery = map[int][]string{
// No exclamation marks. No enthusiasm. Just weight.
5: {
"The {treasure_name}.\n\n" +
"You found it in the Abyssal Maw. It found you in the Abyssal Maw. " +
"You found it in {location_mid}. It found you in {location_mid}. " +
"The distinction matters less at depth.\n" +
"BONUS: {bonus_desc}.\n\n" +
"It came with you. Some things don't come with you. This one did. " +
@@ -240,15 +240,15 @@ var TreasureDiscovery = map[int][]string{
"The {treasure_name} is in your inventory.\n\n" +
"BONUS: {bonus_desc}.\n\n" +
"This is a Tier 5 rare. The Abyssal Maw doesn't give these up. " +
"The Abyssal Maw gave this one up. " +
"This is a Tier 5 rare. Nothing in {location_mid} gives these up. " +
"Something in {location_mid} gave this one up. " +
"That's a sentence worth sitting with.",
"You have the {treasure_name}.\n\n" +
"BONUS: {bonus_desc}.\n\n" +
"It was in the Abyssal Maw. The things that were between you and it " +
"It was in {location_mid}. The things that were between you and it " +
"are not between anything and anything anymore. " +
"The Maw is noting this. So is the item.",
"The place is noting this. So is the item.",
"The {treasure_name}.\n\n" +
"It's warm. It was warm when you found it, which it shouldn't be, " +
@@ -262,14 +262,14 @@ var TreasureDiscovery = map[int][]string{
"The {treasure_name}. {bonus_desc}.\n\n" +
"You have it. " +
"Keep it somewhere it won't be lost. " +
"The Abyssal Maw does not give second chances.",
"There are no second chances in {location_mid}.",
"The {treasure_name} is yours.\n\n" +
"BONUS: {bonus_desc}.\n\n" +
"The Abyssal Maw had it. You have it now. " +
"The Maw is aware of the transfer. " +
"The Maw is considering its position. " +
"You should not be in the Maw when it finishes considering.",
"It sat in {location_mid} until you took it. You have it now. " +
"The place is aware of the transfer. " +
"The place is considering its position. " +
"You should not be in {location_mid} when it finishes considering.",
},
}
internal/plugin/adventure_pet_combat_xp_test.go
+118
View File
@@ -0,0 +1,118 @@
package plugin
import (
"testing"
"gogobee/internal/db"
"maunium.net/go/mautrix/id"
)
func newPetXPTestDB(t *testing.T) {
t.Helper()
dir := t.TempDir()
db.Close()
if err := db.Init(dir); err != nil {
t.Fatal(err)
}
t.Cleanup(db.Close)
}
// TestGrantPetCombatXPPersists is the regression guard for the bug this fixes:
// petGrantXP existed but nothing called it, so an un-babysat pet sat at its
// adoption level forever. A win must move XP on disk.
func TestGrantPetCombatXPPersists(t *testing.T) {
newPetXPTestDB(t)
uid := id.UserID("@petxp:test")
pet := PetState{Type: "dog", Name: "Rex", Arrived: true, Level: 1, XP: 0}
if err := upsertPlayerMetaPetState(uid, pet); err != nil {
t.Fatal(err)
}
if leveled := grantPetCombatXP(uid); len(leveled) != 0 {
t.Errorf("one win should not level a fresh pet, got %v", leveled)
}
got, err := loadPetState(uid)
if err != nil {
t.Fatal(err)
}
if got.XP != int(petXPPerAction*100) {
t.Errorf("XP = %d, want %d", got.XP, int(petXPPerAction*100))
}
if got.Level != 1 {
t.Errorf("Level = %d, want 1", got.Level)
}
}
// TestGrantPetCombatXPLevelsBothSlots checks the second pet earns off the same
// win, matching the babysit trickle — combat only reads the two pets' averaged
// procs, so leveling both is not a power spike.
func TestGrantPetCombatXPLevelsBothSlots(t *testing.T) {
newPetXPTestDB(t)
uid := id.UserID("@petxp2:test")
// Both one grant short of level 2 (needs 10 XP = 1000 centi-XP).
short := 1000 - int(petXPPerAction*100)
if err := upsertPlayerMetaPetState(uid,
PetState{Type: "dog", Name: "Rex", Arrived: true, Level: 1, XP: short}); err != nil {
t.Fatal(err)
}
if err := upsertPlayerMetaPet2State(uid,
PetState{Type: "cat", Name: "Whiskers", Arrived: true, Level: 1, XP: short}); err != nil {
t.Fatal(err)
}
leveled := grantPetCombatXP(uid)
if len(leveled) != 2 {
t.Fatalf("expected both pets to level, got %v", leveled)
}
p1, _ := loadPetState(uid)
p2, _ := loadPet2State(uid)
if p1.Level != 2 || p2.Level != 2 {
t.Errorf("levels = %d/%d, want 2/2", p1.Level, p2.Level)
}
}
// TestGrantPetCombatXPIgnoresChasedAway — a pet that isn't with you doesn't
// fight, so it doesn't earn.
func TestGrantPetCombatXPIgnoresChasedAway(t *testing.T) {
newPetXPTestDB(t)
uid := id.UserID("@petxp3:test")
if err := upsertPlayerMetaPetState(uid, PetState{
Type: "dog", Name: "Rex", Arrived: true, ChasedAway: true, Level: 3, XP: 100,
}); err != nil {
t.Fatal(err)
}
grantPetCombatXP(uid)
got, _ := loadPetState(uid)
if got.XP != 100 {
t.Errorf("chased-away pet gained XP: %d, want 100", got.XP)
}
}
// TestGrantPetCombatXPCapsAtTen — a maxed pet stops earning rather than
// accumulating dead XP.
func TestGrantPetCombatXPCapsAtTen(t *testing.T) {
newPetXPTestDB(t)
uid := id.UserID("@petxp4:test")
if err := upsertPlayerMetaPetState(uid, PetState{
Type: "dog", Name: "Rex", Arrived: true, Level: 10, XP: 0,
}); err != nil {
t.Fatal(err)
}
if leveled := grantPetCombatXP(uid); len(leveled) != 0 {
t.Errorf("L10 pet should not level, got %v", leveled)
}
got, _ := loadPetState(uid)
if got.XP != 0 || got.Level != 10 {
t.Errorf("L10 pet moved: level %d xp %d", got.Level, got.XP)
}
}
internal/plugin/adventure_pets.go
+67 -4
View File
@@ -15,6 +15,11 @@ import (
const petXPPerAction = 1.5
// petMaxLevel is where the curve stops. Named because two things read it for
// different reasons: the level-up loop stops here, and the web push reports "no
// more to earn" from it.
const petMaxLevel = 10
var petNameValid = regexp.MustCompile(`^[a-zA-Z0-9 '\-]+$`)
// petXPToNextLevel returns XP needed for a given pet level.
@@ -31,6 +36,19 @@ func petXPToNextLevel(level int) int {
}
}
// petXPNeededCenti is petXPToNextLevel in the unit the stored ledger actually
// uses — centi-XP — and 0 once the pet is capped, so a caller can tell "nothing
// left to earn" from "needs another 10 points". Every comparison against a
// stored PetXP multiplies by 100 (see advancePetLevelsFromXP); anything reading
// the curve for display has to do the same, and doing it in one place is how the
// web push avoids getting it wrong.
func petXPNeededCenti(level int) int {
if level >= petMaxLevel {
return 0
}
return petXPToNextLevel(level) * 100
}
// petGrantXP adds a per-action XP grant to the pet and handles level-ups.
// Returns true if leveled up. Shares the level-up loop with the babysit trickle
// via advancePetLevelsFromXP.
@@ -41,17 +59,62 @@ func petGrantXP(pet *PetState) bool {
return advancePetLevelsFromXP(&pet.XP, &pet.Level, &pet.Level10Date, int(petXPPerAction*100))
}
// grantPetCombatXP pays both pet slots their per-action XP for a fight the
// player won, and returns the names of any pet that leveled so the caller can
// narrate it.
//
// This is the pet's only *earned* XP source. It used to ride the legacy daily
// activity loop, which R1 deleted — and for the whole life of Adventure 2.0
// nothing replaced it, leaving petGrantXP orphaned and every un-babysat pet
// frozen at the level it was adopted with. Pet level is not cosmetic
// (DerivePlayerStats scales PetAttackProc / PetDeflectProc / PetAttackDmg off
// it), so a frozen pet is a permanently dead combat slot.
//
// Both slots earn on the same win, matching the babysit trickle: combat only
// ever reads the two pets' *averaged* procs, so leveling both is not a spike.
//
// Writes go through the narrow per-slot pet upserts rather than
// saveAdvCharacter: this runs on the combat close-out path, which does not
// hold the per-user lock, and a full-row write from here could clobber a
// concurrent character save.
func grantPetCombatXP(userID id.UserID) []string {
var leveled []string
slots := []struct {
n int
load func(id.UserID) (PetState, error)
upsert func(id.UserID, PetState) error
}{
{1, loadPetState, upsertPlayerMetaPetState},
{2, loadPet2State, upsertPlayerMetaPet2State},
}
for _, s := range slots {
pet, err := s.load(userID)
if err != nil || !pet.HasPet() {
continue
}
didLevel := petGrantXP(&pet)
if uerr := s.upsert(userID, pet); uerr != nil {
slog.Error("adventure: pet xp persist", "user", userID, "slot", s.n, "err", uerr)
continue
}
if didLevel {
leveled = append(leveled, fmt.Sprintf("%s reached level %d", pet.Name, pet.Level))
}
}
return leveled
}
// advancePetLevelsFromXP adds centi-XP to a pet and applies any level-ups, up
// to the level-10 cap, stamping the level-10 date on first reaching it. Shared
// by both pet slots (the babysit trickle). Returns true if the pet leveled.
func advancePetLevelsFromXP(xp, level *int, level10Date *string, addCentiXP int) bool {
if *level >= 10 {
if *level >= petMaxLevel {
return false
}
*xp += addCentiXP
leveled := false
for *level < 10 {
needed := petXPToNextLevel(*level) * 100
for *level < petMaxLevel {
needed := petXPNeededCenti(*level)
if *xp < needed {
break
}
@@ -59,7 +122,7 @@ func advancePetLevelsFromXP(xp, level *int, level10Date *string, addCentiXP int)
*level++
leveled = true
}
if *level >= 10 && *level10Date == "" {
if *level >= petMaxLevel && *level10Date == "" {
*level10Date = time.Now().UTC().Format("2006-01-02")
}
return leveled
internal/plugin/adventure_render.go
+12
View File
@@ -70,6 +70,18 @@ func advClearFlavorHistory() {
})
}
// advLocationMidSentence renders a location display name for use after a
// preposition: "The Abyssal Maw" becomes "the Abyssal Maw" so a line reads
// "found in the Abyssal Maw" rather than "found in The Abyssal Maw".
// Templates opt in with {location_mid}; {location} keeps the display form for
// sentence-initial and "The {location}" positions.
func advLocationMidSentence(name string) string {
if strings.HasPrefix(name, "The ") {
return "the " + strings.TrimPrefix(name, "The ")
}
return name
}
// advSubstituteFlavor replaces {var} placeholders in a flavor text string.
func advSubstituteFlavor(template string, vars map[string]string) string {
pairs := make([]string, 0, len(vars)*2)
internal/plugin/adventure_robbie.go
+76 -23
View File
@@ -164,20 +164,18 @@ func (p *AdventurePlugin) robbieVisitPlayer(userID id.UserID, displayName string
gaveCard = true
}
// Update visit count, and every 10th visit leave a small consumable
// "for the trouble" (D2 NPC arc).
var leftGift *AdvItem
// Update visit count and work out what he leaves behind.
var leftGifts []AdvItem
char, err := loadAdvCharacter(userID)
if err == nil {
char.RobbieVisitCount++
if char.RobbieVisitCount%robbieGiftEveryNVisits == 0 {
// Use the canonical DnD level (like the arena's tier gate), not the
// frozen legacy CombatLevel — that snapshots at 1–3 once D&D setup
// completes, so reading it here would peg every gift at tier 1.
if gifts := consumableCache(robbieGiftTier(arenaDnDLevelOrZero(userID)), 1); len(gifts) > 0 {
if err := addAdvInventoryItem(userID, gifts[0]); err == nil {
leftGift = &gifts[0]
}
// Use the canonical DnD level (like the arena's tier gate), not the
// frozen legacy CombatLevel — that snapshots at 1–3 once D&D setup
// completes, so reading it here would peg every gift at tier 1.
tier := robbieGiftTier(arenaDnDLevelOrZero(userID))
for _, gift := range consumableCache(tier, robbieGiftCount(char.RobbieVisitCount, len(takenItems))) {
if err := addAdvInventoryItem(userID, gift); err == nil {
leftGifts = append(leftGifts, gift)
}
}
_ = saveAdvCharacter(char)
@@ -185,7 +183,7 @@ func (p *AdventurePlugin) robbieVisitPlayer(userID id.UserID, displayName string
}
// Send DM
dm := renderRobbieDM(userID, takenItems, totalPayout, masterworkTaken, gaveCard, leftGift)
dm := renderRobbieDM(userID, takenItems, totalPayout, masterworkTaken, gaveCard, leftGifts)
if err := p.SendDM(userID, dm); err != nil {
slog.Error("adventure: robbie: failed to send DM", "user", userID, "err", err)
}
@@ -213,12 +211,17 @@ func (p *AdventurePlugin) robbieVisitPlayer(userID id.UserID, displayName string
func robbieQualifyingItems(inv []AdvItem, equip map[EquipmentSlot]*AdvEquipment) []AdvItem {
var result []AdvItem
for _, item := range inv {
// Never touch Arena gear, cards, consumables, or keys. Consumables are
// a player-curated stockpile (crafted or dropped); selling them is an
// explicit decision the player must make themselves. Keys are cross-zone
// unlock tokens (N5/D4) that must persist in inventory to open their
// vault later — sweeping one permanently breaks that unlock.
if item.Type == "ArenaGear" || item.Type == "card" || item.Type == "consumable" || item.Type == "key" {
// Never touch Arena gear, cards, consumables, keys, or tools.
// Consumables are a player-curated stockpile (crafted or dropped);
// selling them is an explicit decision the player must make themselves.
// Keys are cross-zone unlock tokens (N5/D4) that must persist in
// inventory to open their vault later — sweeping one permanently breaks
// that unlock. Tools are the same shape of promise: thieves' tools are
// bought precisely so a locked fork can be opened *later*, and a bandit
// who pockets them between the purchase and the door has taken the
// thing the player paid to still have.
switch item.Type {
case "ArenaGear", "card", "consumable", "key", thievesToolsItemType:
continue
}
@@ -267,9 +270,49 @@ func robbiePlayerHasCard(userID id.UserID) bool {
// ── DM Rendering ─────────────────────────────────────────────────────────────
// robbieGiftEveryNVisits is how often Robbie leaves a consumable behind.
// robbieGiftEveryNVisits is how often Robbie leaves a consumable behind on the
// loyalty track alone, independent of how much he hauled off.
const robbieGiftEveryNVisits = 10
// robbieHaulPerGift is how many items one visit has to be worth before Robbie
// leaves something for the trouble, and robbieMaxHaulGifts caps how generous a
// single monster haul can get.
//
// The loyalty track on its own was far too thin to read as a reward: a visit is
// a 40% daily roll, so every-10-visits works out to one consumable per ~25 real
// days — and it paid exactly the same for a stockpile of sixty items as it did
// for one rock. Volume is the thing the player actually controls, so volume is
// what the haul track pays on.
const (
robbieHaulPerGift = 15
robbieMaxHaulGifts = 3
)
// robbieGiftCount returns how many consumables Robbie leaves this visit: the
// every-Nth-visit loyalty gift plus one per robbieHaulPerGift items carried
// off, capped. Pure so the curve is testable without a DB or a Matrix stub.
func robbieGiftCount(visitCount, itemsTaken int) int {
n := 0
if visitCount > 0 && visitCount%robbieGiftEveryNVisits == 0 {
n++
}
if haul := itemsTaken / robbieHaulPerGift; haul > 0 {
n += min(haul, robbieMaxHaulGifts)
}
return n
}
// joinAnd renders a list as "a", "a and b", or "a, b and c".
func joinAnd(xs []string) string {
switch len(xs) {
case 0:
return ""
case 1:
return xs[0]
}
return strings.Join(xs[:len(xs)-1], ", ") + " and " + xs[len(xs)-1]
}
// robbieGiftTier maps a player's combat level to a consumable tier, matching
// the arena tier bands (1–3 / 4–7 / 8–12 / 13–17 / 18+).
func robbieGiftTier(level int) int {
@@ -287,7 +330,7 @@ func robbieGiftTier(level int) int {
}
}
func renderRobbieDM(userID id.UserID, items []AdvItem, total int64, mwTaken, gaveCard bool, leftGift *AdvItem) string {
func renderRobbieDM(userID id.UserID, items []AdvItem, total int64, mwTaken, gaveCard bool, leftGifts []AdvItem) string {
var sb strings.Builder
// Opening
@@ -334,9 +377,19 @@ func renderRobbieDM(userID id.UserID, items []AdvItem, total int64, mwTaken, gav
}
sb.WriteString("\n\n")
// Every-10th-visit consumable (D2).
if leftGift != nil {
sb.WriteString(fmt.Sprintf(robbieLeftConsumable, leftGift.Name))
// What he left behind: the every-10th-visit loyalty consumable (D2), the
// big-haul thank-you, or both rolled into one line. A single gift keeps the
// original loyalty phrasing; anything more is the haul talking.
if len(leftGifts) > 0 {
names := make([]string, 0, len(leftGifts))
for _, g := range leftGifts {
names = append(names, g.Name)
}
if len(names) == 1 {
sb.WriteString(fmt.Sprintf(robbieLeftConsumable, names[0]))
} else {
sb.WriteString(fmt.Sprintf(robbieLeftForTheHaul, joinAnd(names)))
}
sb.WriteString("\n\n")
}
internal/plugin/adventure_robbie_gift_test.go
+47
View File
@@ -0,0 +1,47 @@
package plugin
import "testing"
// TestRobbieGiftCount pins the two tracks: the every-10th-visit loyalty gift
// and the volume track that pays for a big haul, capped so one monster
// stockpile can't mint an unbounded pile of consumables.
func TestRobbieGiftCount(t *testing.T) {
cases := []struct {
name string
visits, taken int
want int
}{
{"small haul, off-loyalty visit", 7, 3, 0},
{"loyalty visit only", 10, 3, 1},
{"haul only", 7, 15, 1},
{"haul and loyalty stack", 20, 15, 2},
{"haul scales", 7, 45, 3},
{"haul capped", 7, 500, robbieMaxHaulGifts},
{"cap plus loyalty", 30, 500, robbieMaxHaulGifts + 1},
{"one under the haul threshold", 7, robbieHaulPerGift - 1, 0},
{"zeroth visit is not a loyalty visit", 0, 0, 0},
}
for _, c := range cases {
if got := robbieGiftCount(c.visits, c.taken); got != c.want {
t.Errorf("%s: robbieGiftCount(%d, %d) = %d, want %d",
c.name, c.visits, c.taken, got, c.want)
}
}
}
func TestJoinAnd(t *testing.T) {
cases := []struct {
in []string
want string
}{
{nil, ""},
{[]string{"a"}, "a"},
{[]string{"a", "b"}, "a and b"},
{[]string{"a", "b", "c"}, "a, b and c"},
}
for _, c := range cases {
if got := joinAnd(c.in); got != c.want {
t.Errorf("joinAnd(%v) = %q, want %q", c.in, got, c.want)
}
}
}
internal/plugin/adventure_shop.go
+45 -1
View File
@@ -845,7 +845,13 @@ func (p *AdventurePlugin) advSellAll(userID id.UserID) string {
var keptConsumable int
var keptMagic int
for _, item := range items {
if item.Type == "MasterworkGear" || item.Type == "ArenaGear" || item.Type == "card" {
// Keys and tools ride along with the special gear here for the same
// reason Robbie won't take them: both are bought or found precisely so a
// door can be opened *later*, and `sell all` is a bulk-loot verb the
// player fires after every haul without reading the list. Turning one
// into €300 silently deletes the unlock it was carried for.
switch item.Type {
case "MasterworkGear", "ArenaGear", "card", "key", thievesToolsItemType:
keptSpecial++
continue
}
@@ -1019,6 +1025,9 @@ func luigiSuppliesView(_ id.UserID, balance float64) string {
}
}
sb.WriteString(fmt.Sprintf("**%s** — €%d\n Opens one dungeon path a failed check closed (`!zone unlock <n>`). Not used in combat.\n\n",
thievesToolsName, thievesToolsPrice))
sb.WriteString("Reply with an item name to buy, or `back` to return.\n")
sb.WriteString("Stronger consumables drop from foraging, mining, fishing, and dungeons at T2+.")
return sb.String()
@@ -1073,6 +1082,13 @@ func (p *AdventurePlugin) resolveShopSupplyChoice(ctx MessageContext, interactio
return p.SendDM(ctx.Sender, "*Luigi nods and gestures toward the main counter.*")
}
// Thieves' tools sit on the supplies shelf but are not a ConsumableDef:
// the combat engine scans inventory against that table and would happily
// spend them mid-fight. They get their own branch and their own item type.
if isThievesToolsReply(reply) {
return p.buyThievesTools(ctx, interaction)
}
// Find matching consumable
var match *ConsumableDef
for i := range consumableDefs {
@@ -1115,6 +1131,34 @@ func (p *AdventurePlugin) resolveShopSupplyChoice(ctx MessageContext, interactio
match.Name, consumablePrice, newBalance))
}
// buyThievesTools sells one set off the supplies shelf. Mirrors the consumable
// purchase beside it — same session price factor, same 5% pot cut — and leaves
// the player in the supplies view so they can buy a second.
func (p *AdventurePlugin) buyThievesTools(ctx MessageContext, interaction *advPendingInteraction) error {
price := float64(thievesToolsPrice) * p.shopSessionPriceFactor(ctx.Sender)
balance := p.euro.GetBalance(ctx.Sender)
if balance < price {
p.pending.Store(string(ctx.Sender), interaction)
return p.SendDM(ctx.Sender, fmt.Sprintf("You need €%.0f for %s but only have €%.0f.",
price, thievesToolsName, balance))
}
p.euro.Debit(ctx.Sender, price, "shop_thieves_tools")
if potCut := int(math.Round(price * 0.05)); potCut > 0 {
communityPotAdd(potCut)
trackTaxPaid(ctx.Sender, potCut)
}
_ = addAdvInventoryItem(ctx.Sender, AdvItem{
Name: thievesToolsName,
Type: thievesToolsItemType,
Tier: 1,
Value: thievesToolsPrice / 2,
})
p.pending.Store(string(ctx.Sender), interaction)
return p.SendDM(ctx.Sender, fmt.Sprintf(
"Purchased **%s** for €%.0f. You carry %d.\n💰 Balance: €%.0f\n\nReply with another item name or `back` to return.",
thievesToolsName, price, countThievesTools(ctx.Sender), p.euro.GetBalance(ctx.Sender)))
}
// ── Curios (Magic Items) ────────────────────────────────────────────────────
// curiosStockSize — how many registry magic items Luigi stocks per day.
internal/plugin/adventure_treasure.go
+28 -6
View File
@@ -46,6 +46,16 @@ var advTreasureDropRates = map[int]float64{
3: 0.008,
4: 0.004,
5: 0.0015,
// Tier 6 (Mythic post-game) breaks the downward curve on purpose. The rate
// per roll falls tier over tier because the lower tiers are ground daily;
// a Mythic run is gated behind L18 and both T5 bosses and happens rarely,
// so the same declining rate would mean a postgame player effectively never
// sees a treasure. Slightly above T5 keeps the per-run odds in the band the
// other tiers land in.
//
// NOTE: this rate is inert until advAllTreasures gains a tier 6 pool — see
// the TODO there. A tier with a rate but no pool drops nothing.
6: 0.002,
}
const advMaxTreasures = 3
@@ -213,7 +223,7 @@ var advAllTreasures = map[int][]AdvTreasureDef{
{Type: "success_chance", Value: 10},
},
InventoryDesc: "[THUNDERFURY, BLESSED BLADE OF THE WINDSEEKER]. Yes you got it. +12 Combat.",
RoomAnnounce: "⚡ Did {name} get Thunderfury? {name} got Thunderfury. [THUNDERFURY, BLESSED BLADE OF THE WINDSEEKER] has been found in {location}.",
RoomAnnounce: "⚡ Did {name} get Thunderfury? {name} got Thunderfury. [THUNDERFURY, BLESSED BLADE OF THE WINDSEEKER] has been found in {location_mid}.",
},
{
Key: "ocarina", Name: "The Ocarina (Cracked, Still Plays)", Tier: 4,
@@ -221,6 +231,13 @@ var advAllTreasures = map[int][]AdvTreasureDef{
InventoryDesc: "The Ocarina (Cracked). Three songs. +10 all skills. Do not play the third one.",
},
},
// TODO(t6-treasures): there is no tier 6 pool yet, so Mythic zones drop no
// treasure at all — advTreasureDropRates has a tier 6 rate waiting for it.
// What's missing is the content: four Mythic treasures with bonuses above
// the T5 line, InventoryDesc + RoomAnnounce strings for each (RoomAnnounce
// must use {location_mid}, never a literal zone name), and a TIER 6 register
// in TreasureDiscovery. Write them against internal/flavor/VOICE_CANON.md;
// the T5 pool below is the tonal floor to clear, not the ceiling.
5: {
{
Key: "shard_of_unnamed", Name: "Shard of the Unnamed", Tier: 5,
@@ -230,13 +247,13 @@ var advAllTreasures = map[int][]AdvTreasureDef{
{Type: "death_chance", Value: -5},
},
InventoryDesc: "Shard of the Unnamed. +15 Combat, +10% XP, -5% death.",
RoomAnnounce: "🔴 {name} has recovered the Shard of the Unnamed from the Abyssal Maw. The server feels different.",
RoomAnnounce: "🔴 {name} has recovered the Shard of the Unnamed from {location_mid}. The server feels different.",
},
{
Key: "cartographers_final_map", Name: "The Cartographer's Final Map", Tier: 5,
Bonuses: []advTreasureBonusDef{{Type: "all_skills", Value: 12}},
InventoryDesc: "The Cartographer's Final Map. Updates on its own. +12 all skills, full map.",
RoomAnnounce: "🔴 {name} has found the Cartographer's Final Map in the Abyssal Maw. It has their name on it. It always did.",
RoomAnnounce: "🔴 {name} has found the Cartographer's Final Map in {location_mid}. It has their name on it. It always did.",
},
{
Key: "triforce_shard", Name: "The Triforce Shard (One Third of Something Larger)", Tier: 5,
@@ -246,7 +263,7 @@ var advAllTreasures = map[int][]AdvTreasureDef{
// Note: +15 to chosen skill is v2 interactive
},
InventoryDesc: "Triforce Shard (×1/3). Warm. Waiting. +5 all skills, -8% death.",
RoomAnnounce: "🔺 {name} has recovered a Triforce Shard from the Abyssal Maw. One third of something. The other two thirds are somewhere. Probably.",
RoomAnnounce: "🔺 {name} has recovered a Triforce Shard from {location_mid}. One third of something. The other two thirds are somewhere. Probably.",
},
{
Key: "the_corridor", Name: "The Corridor (You Know the One)", Tier: 5,
@@ -255,7 +272,7 @@ var advAllTreasures = map[int][]AdvTreasureDef{
{Type: "special_monthly_death_bypass", Value: 1}, // v2
},
InventoryDesc: "The Corridor. Folded. Don't look back. +12 all skills, monthly death bypass.",
RoomAnnounce: "🔴 {name} found The Corridor in the Abyssal Maw. They know the one. So does it.",
RoomAnnounce: "🔴 {name} found The Corridor in {location_mid}. They know the one. So does it.",
},
},
}
@@ -285,7 +302,12 @@ func rollAdvTreasureDropDetailed(tier int, userID id.UserID, chatLevel int, weig
pool, ok := advAllTreasures[tier]
if !ok || len(pool) == 0 {
return nil, roll, rate
// A tier that has a rate but no pool (tier 6, until the TODO above is
// filled) cannot drop anything. Report a zero rate rather than the
// configured one: the caller turns a close roll into a "just missed"
// DM, and telling a postgame player they nearly won a treasure that
// cannot be won is worse than staying quiet.
return nil, 0, 0
}
// Pick random treasure
internal/plugin/adventure_treasure_test.go
+30
View File
@@ -66,6 +66,36 @@ func TestAdvTreasureDropDetailed_ForcedRollGrantsTreasure(t *testing.T) {
}
}
// TestAdvTreasureTier6_PoolStillMissing pins the known tier 6 gap: Mythic zones
// carry a drop rate but no treasure pool, so a forced roll yields nothing and
// the player is told nothing either (a "just missed" DM for an unwinnable
// treasure would be a lie).
//
// This test is the reminder. Writing advAllTreasures[6] — see TODO(t6-treasures)
// in adventure_treasure.go — turns it red, and the fix is to delete it and
// assert the tier 6 drop instead, the way ForcedRollGrantsTreasure does for
// tier 1.
func TestAdvTreasureTier6_PoolStillMissing(t *testing.T) {
if err := db.Init(t.TempDir()); err != nil {
t.Fatalf("db.Init: %v", err)
}
if _, ok := advAllTreasures[6]; ok {
t.Fatal("a tier 6 treasure pool now exists — drop this test and assert the drop instead")
}
// The rate is configured and waiting, so the gap is the pool alone.
if advTreasureDropRates[6] == 0 {
t.Error("tier 6 drop rate went missing; a Mythic pool would be unreachable")
}
drop, roll, rate := rollAdvTreasureDropDetailed(6, "@mythic:example.org", 0, 1000)
if drop != nil {
t.Fatalf("tier 6 produced a drop from an empty pool: %+v", drop.Def)
}
// Zeroed, not merely no-drop: this is what keeps the near-miss DM quiet.
if roll != 0 || rate != 0 {
t.Errorf("empty pool reported roll=%v rate=%v, want 0/0 so no near-miss fires", roll, rate)
}
}
// The treasure and masterwork systems predate zones and speak AdvLocation.
func TestAdvLocForZone(t *testing.T) {
loc := advLocForZone(ZoneGoblinWarrens)
internal/plugin/adventure_worldboss.go
+81 -27
View File
@@ -2,6 +2,7 @@ package plugin
import (
"database/sql"
"errors"
"fmt"
"hash/fnv"
"log/slog"
@@ -394,14 +395,15 @@ func (p *AdventurePlugin) spawnWorldBoss(eventKey string) (*worldBossState, erro
return nil, err
}
p.announceWorldBossSpawn(boss, activeN)
emitSiegeStart(boss)
slog.Info("worldboss: spawned", "id", bossID, "name", name, "tier", tier, "hp", hpMax, "activeN", activeN)
return boss, nil
}
// worldBossTick rides the 1-minute event ticker. It auto-spawns a boss on the
// first of each UTC month and resolves a live boss whose window has lapsed. The
// defeat path is not here — a bout crossing the pool to zero resolves inline
// (W2), because the ticker never sees the pool between two 60s reads.
// worldBossTick rides the 1-minute event ticker. It auto-spawns the month's
// boss and resolves a live boss whose window has lapsed. The defeat path is not
// here — a bout crossing the pool to zero resolves inline (W2), because the
// ticker never sees the pool between two 60s reads.
func (p *AdventurePlugin) worldBossTick() {
boss, err := loadActiveWorldBoss()
if err != nil {
@@ -423,10 +425,17 @@ func (p *AdventurePlugin) worldBossTick() {
}
return
}
// No boss camped — auto-spawn on the 1st of the month, once.
if now.Day() != 1 {
return
}
// No boss camped — spawn this month's Siege, once.
//
// The month key below is the whole dedup, so the rule is simply "one Siege
// per calendar month, as early as the process is up to run it." It used to
// additionally require now.Day() == 1, which deadlocked the entire feature:
// the world boss shipped mid-July 2026 and prod never once ran a first-of-
// the-month tick with the code in it, so `select count(*) from world_boss`
// was still 0 weeks later. The day gate also silently skipped any month
// where the bot happened to be down or redeploying across the 1st, with no
// catch-up. Dropping it makes a missed 1st self-heal on the next tick
// instead of costing the town a month.
monthKey := now.Format("2006-01")
if db.JobCompleted("worldboss_spawn", monthKey) {
return
@@ -489,6 +498,7 @@ func (p *AdventurePlugin) resolveWorldBossDefeated(boss *worldBossState) {
}
}
p.announceWorldBossDefeated(boss, payouts)
emitSiegeWin(boss, len(payouts))
slog.Info("worldboss: defeated", "id", boss.ID, "contributors", len(payouts))
}
@@ -509,6 +519,7 @@ func (p *AdventurePlugin) resolveWorldBossSurvived(boss *worldBossState) {
paid = tribute
}
p.announceWorldBossSurvived(boss, paid)
emitSiegeLoss(boss)
slog.Info("worldboss: survived", "id", boss.ID, "tribute", paid)
}
@@ -597,42 +608,58 @@ func (p *AdventurePlugin) worldBossOperatorSpawn(ctx MessageContext) error {
boss.Name, boss.Tier, groupInt(boss.HPMax)))
}
// fightWorldBoss runs one player's daily bout against the Siege: an arena-style
// Sentinels for the four ways a bout can be refused, so a headless caller (the
// web action queue, pete_orders.go) can turn each into its own verdict instead of
// parsing a DM. `!adventure worldboss fight` maps them back to the prose it
// always sent.
var (
errSiegeNoBoss = errors.New("siege: nothing camped outside town")
errSiegeNoCharacter = errors.New("siege: no adventurer")
errSiegeDead = errors.New("siege: adventurer is dead")
errSiegeAlreadyFought = errors.New("siege: today's bout already spent")
)
// takeSiegeBout runs one player's daily bout against the Siege: an arena-style
// solo fight whose damage is subtracted from the shared pool win or lose. Real
// HP cost, no death — a loss leaves the fighter battered (floored at 1 HP) but
// standing. The per-user lock serialises a player's own repeat submits, so the
// once-per-day gate can't be raced by a double-tap.
func (p *AdventurePlugin) fightWorldBoss(ctx MessageContext) error {
userMu := p.advUserLock(ctx.Sender)
// once-per-day gate can't be raced by a double-tap — and that same lock is what
// makes it safe for the web queue and a Matrix command to reach for the bout at
// the same moment.
//
// The combat narration is DM'd from here whichever door the bout came through: a
// fight is thirty lines of blow-by-blow and belongs in Matrix, not in a one-line
// verdict on a web page. The caller gets the boss and the result to describe.
func (p *AdventurePlugin) takeSiegeBout(uid id.UserID) (worldBossBoutResult, *worldBossState, error) {
userMu := p.advUserLock(uid)
userMu.Lock()
defer userMu.Unlock()
boss, err := loadActiveWorldBoss()
if err != nil {
return p.SendDM(ctx.Sender, "Something went wrong reaching the Siege. Try again in a moment.")
return worldBossBoutResult{}, nil, fmt.Errorf("reaching the Siege: %w", err)
}
if boss == nil {
return p.SendDM(ctx.Sender, "No Siege is camped outside town right now.")
return worldBossBoutResult{}, nil, errSiegeNoBoss
}
char, err := loadAdvCharacter(ctx.Sender)
char, err := loadAdvCharacter(uid)
if err != nil || char == nil {
return p.SendDM(ctx.Sender, "You need an adventurer first — type `!adventure` to begin.")
return worldBossBoutResult{}, boss, errSiegeNoCharacter
}
if !char.Alive {
return p.SendDM(ctx.Sender, "You're dead. The Siege will have to wait until you're back on your feet.")
return worldBossBoutResult{}, boss, errSiegeDead
}
today := time.Now().UTC().Format("2006-01-02")
if worldBossBoutUsedToday(boss.ID, ctx.Sender, today) {
return p.SendDM(ctx.Sender, fmt.Sprintf(
"You've already taken your bout against **%s** today. Come back tomorrow — one fight per day.", boss.Name))
if worldBossBoutUsedToday(boss.ID, uid, today) {
return worldBossBoutResult{}, boss, errSiegeAlreadyFought
}
bout, err := p.resolveWorldBossBout(ctx.Sender, boss, today)
bout, err := p.resolveWorldBossBout(uid, boss, today)
if err != nil {
slog.Error("worldboss: bout failed", "user", ctx.Sender, "err", err)
return p.SendDM(ctx.Sender, "The Siege combat hit an error. Try again in a moment.")
slog.Error("worldboss: bout failed", "user", uid, "err", err)
return worldBossBoutResult{}, boss, fmt.Errorf("running the bout: %w", err)
}
// Resolve a defeat BEFORE streaming the (multi-second) narration. The pool is
@@ -643,7 +670,7 @@ func (p *AdventurePlugin) fightWorldBoss(ctx MessageContext) error {
p.resolveWorldBossDefeated(boss)
}
playerName, _ := loadDisplayName(ctx.Sender)
playerName, _ := loadDisplayName(uid)
if playerName == "" {
playerName = "You"
}
@@ -651,18 +678,45 @@ func (p *AdventurePlugin) fightWorldBoss(ctx MessageContext) error {
fmt.Sprintf("⚔️ **The Siege — %s** (Tier %d)", boss.Name, boss.Tier),
}, RenderCombatLog(bout.Combat, playerName, boss.Name)...)
<-p.sendZoneCombatMessages(uid, phaseMessages, siegeBoutFooter(bout, boss))
return bout, boss, nil
}
// siegeBoutFooter is the one-line result of a bout — the damage dealt and what
// the pool looks like now. It closes the Matrix narration and doubles as the web
// verdict, so the two doors can't drift into describing the same fight
// differently.
func siegeBoutFooter(bout worldBossBoutResult, boss *worldBossState) string {
var footer string
if bout.Killed {
footer = fmt.Sprintf("💥 You deal **%d** damage — the killing blow! **%s** falls!", bout.Damage, boss.Name)
footer = fmt.Sprintf("💥 You deal **%d** damage: the killing blow! **%s** falls!", bout.Damage, boss.Name)
} else {
footer = fmt.Sprintf("💥 You deal **%d** damage. **%s** has **%s / %s HP** left.",
bout.Damage, boss.Name, groupInt(bout.Remaining), groupInt(boss.HPMax))
}
if bout.Battered {
footer += "\nYou stagger out of the fight at 1 HP — rest up before your next outing."
footer += "\nYou stagger out of the fight at 1 HP. Rest up before your next outing."
}
return footer
}
<-p.sendZoneCombatMessages(ctx.Sender, phaseMessages, footer)
// fightWorldBoss is `!adventure worldboss fight`: the command framing around
// takeSiegeBout, which does the fight and the narration.
func (p *AdventurePlugin) fightWorldBoss(ctx MessageContext) error {
_, boss, err := p.takeSiegeBout(ctx.Sender)
switch {
case errors.Is(err, errSiegeNoBoss):
return p.SendDM(ctx.Sender, "No Siege is camped outside town right now.")
case errors.Is(err, errSiegeNoCharacter):
return p.SendDM(ctx.Sender, "You need an adventurer first — type `!adventure` to begin.")
case errors.Is(err, errSiegeDead):
return p.SendDM(ctx.Sender, "You're dead. The Siege will have to wait until you're back on your feet.")
case errors.Is(err, errSiegeAlreadyFought):
return p.SendDM(ctx.Sender, fmt.Sprintf(
"You've already taken your bout against **%s** today. Come back tomorrow — one fight per day.", boss.Name))
case err != nil:
return p.SendDM(ctx.Sender, "Something went wrong reaching the Siege. Try again in a moment.")
}
return nil
}
internal/plugin/bootstrap_pete_news.go
+99 -14
View File
@@ -58,34 +58,119 @@ func (p *AdventurePlugin) bootstrapPeteNewsBackfill() {
"zone_firsts", firsts, "deaths", deaths, "achievements", achv)
}
// backfillZoneFirsts seeds news_realm_firsts from history and emits one PRIORITY
// realm-first dispatch per zone, attributed to its earliest boss-defeating
// clearer. SQLite returns the user_id from the same row as MIN(completed_at)
// (bare-column min/max rule), so the (zone, first clearer, time) triple is
// consistent. Returns the count emitted.
func (p *AdventurePlugin) backfillZoneFirsts() int {
// zoneFirstClear is one zone's earliest boss kill: who did it and when.
type zoneFirstClear struct {
zoneID, userID, completedAt string
}
// zoneFirstClears reads the earliest boss-defeating run of every zone.
//
// The filter is `boss_defeated = 1` and NOTHING else, and that is the whole
// point. `abandoned` does not mean anybody gave up — abandonZoneRunByID exists
// to retire a run whose boss is ALREADY DEAD when the expedition travels onward
// (dnd_zone_run.go), so in prod 30 of 32 boss kills carry abandoned = 1. An
// `AND abandoned = 0` here drew a realm where 2 zones had ever been beaten
// instead of 9. It is the same filter loadRealmClearStats documents; do not
// reintroduce it.
//
// SQLite returns the user_id from the same row as MIN(completed_at) (bare-column
// min/max rule), so the (zone, first clearer, time) triple is internally
// consistent.
// ok is false only when the read itself failed. A caller that is about to mark
// a one-shot job complete has to be able to tell "no zone has ever been cleared"
// from "the query fell over", or a transient DB fault at boot retires the repair
// permanently.
func zoneFirstClears() (firsts []zoneFirstClear, ok bool) {
rows, err := db.Get().Query(
`SELECT zone_id, user_id, MIN(completed_at)
FROM dnd_zone_run
WHERE boss_defeated = 1 AND completed_at IS NOT NULL AND abandoned = 0
WHERE boss_defeated = 1 AND completed_at IS NOT NULL
GROUP BY zone_id`)
if err != nil {
slog.Error("backfill: zone-firsts query", "err", err)
return 0
return nil, false
}
type first struct {
zoneID, userID, completedAt string
}
var firsts []first
defer rows.Close()
for rows.Next() {
var f first
var f zoneFirstClear
if err := rows.Scan(&f.zoneID, &f.userID, &f.completedAt); err != nil {
slog.Error("backfill: zone-firsts scan", "err", err)
continue
}
firsts = append(firsts, f)
}
rows.Close()
if err := rows.Err(); err != nil {
slog.Error("backfill: zone-firsts rows", "err", err)
return nil, false
}
return firsts, true
}
// bootstrapRealmFirstsReseed repairs the zone half of news_realm_firsts.
//
// The ledger is what claimRealmFirst tiers live dispatches against, so a zone
// whose first clear the original one-shot missed is a spurious PRIORITY "realm
// first" waiting to fire the next time somebody clears it, months after the
// fact. Two things were wrong with what got seeded:
//
// 1. The `abandoned = 0` filter above, which is why prod holds 6 zones where
// the run history knows 9.
// 2. first_at is claimRealmFirst's unixepoch() — when the claim was RECORDED,
// not when the clear happened. Every backfilled prod row carries the one
// minute the job ran.
//
// This is a re-SEED, not a re-run: it writes the ledger and emits nothing at
// all, so no historical realm-first dispatch reaches the room. It has its own
// job name because the original one-shot's gate is already marked, and per
// feedback_loader_rewire_needs_bootstrap it stays in place afterwards — a fresh
// deploy runs it as an ordinary bootstrap.
//
// It runs unconditionally on the news seam's switches, unlike the backfill: a
// ledger that is correct only when emission happens to be on is a ledger that
// mis-tiers the first dispatch after somebody flips it.
//
// A zone claim with no surviving run behind it is left exactly as it is. The run
// history is the better record of both who and when, but only where it has one.
func bootstrapRealmFirstsReseed() {
const jobName = "pete_realm_firsts_reseed_v1"
if db.JobCompleted(jobName, "once") {
return
}
clears, ok := zoneFirstClears()
if !ok {
// The read failed. Leave the job unmarked so the next boot tries again —
// marking it here would retire the repair on the strength of a transient
// DB fault and leave the ledger wrong forever.
return
}
seeded := 0
for _, f := range clears {
ts, ok := parseSQLiteTime(f.completedAt)
if !ok {
slog.Warn("reseed: unparseable clear time", "zone", f.zoneID, "at", f.completedAt)
continue
}
// Upsert, not INSERT OR IGNORE: the six rows that already exist carry the
// wrong date and correcting them is half of what this job is for.
db.Exec("realm-firsts reseed",
`INSERT INTO news_realm_firsts (kind, target, first_at) VALUES ('zone', ?, ?)
ON CONFLICT(kind, target) DO UPDATE SET first_at = excluded.first_at`,
f.zoneID, ts.Unix())
seeded++
}
db.MarkJobCompleted(jobName, "once")
slog.Warn("bootstrap: realm-firsts ledger reseeded", "zones", seeded)
}
// backfillZoneFirsts seeds news_realm_firsts from history and emits one
// dispatch per zone, attributed to its earliest boss-defeating clearer.
// Returns the count emitted.
func (p *AdventurePlugin) backfillZoneFirsts() int {
firsts, _ := zoneFirstClears()
n := 0
for _, f := range firsts {
internal/plugin/bootstrap_realm_firsts_test.go
+160
View File
@@ -0,0 +1,160 @@
package plugin
import (
"testing"
"time"
"gogobee/internal/db"
)
// ledgerFirstAt reads a zone's recorded claim time, or -1 if the ledger has no
// row for it at all.
func ledgerFirstAt(t *testing.T, zoneID string) int64 {
t.Helper()
var at int64
err := db.Get().QueryRow(
`SELECT first_at FROM news_realm_firsts WHERE kind = 'zone' AND target = ?`,
zoneID).Scan(&at)
if err != nil {
return -1
}
return at
}
func unixOf(t *testing.T, sqliteTime string) int64 {
t.Helper()
ts, ok := parseSQLiteTime(sqliteTime)
if !ok {
t.Fatalf("parseSQLiteTime(%q) failed", sqliteTime)
}
return ts.Unix()
}
// TestReseedClaimsAZoneWhoseClearsWereAllRetired is the regression for the bug
// that made this job necessary: every clear of forest_shadows carries
// abandoned = 1, which is how the game stores a kill the expedition walked on
// from, and the original one-shot's `abandoned = 0` filter therefore never saw
// the zone at all. An unclaimed zone is a spurious PRIORITY "realm first"
// waiting to fire the next time somebody clears it, months after the fact — so
// the assertion that matters is the claimRealmFirst one at the end.
func TestReseedClaimsAZoneWhoseClearsWereAllRetired(t *testing.T) {
seedRealmFixture(t)
db.Exec("seed retired-only zone", `INSERT INTO dnd_zone_run
(run_id, user_id, zone_id, total_rooms, boss_defeated, abandoned, completed_at)
VALUES ('r7', '@josie:x', 'forest_shadows', 6, 1, 1, '2026-02-14 09:00:00')`)
if got := ledgerFirstAt(t, "forest_shadows"); got != -1 {
t.Fatalf("forest_shadows already claimed before the reseed (first_at=%d) — fixture drift", got)
}
bootstrapRealmFirstsReseed()
if got := ledgerFirstAt(t, "forest_shadows"); got != unixOf(t, "2026-02-14 09:00:00") {
t.Errorf("forest_shadows first_at = %d, want %d (the real clear, not the minute the job ran)",
got, unixOf(t, "2026-02-14 09:00:00"))
}
// The point of the whole job. Before the reseed this returns true and the
// next clear of a zone beaten in February announces itself as a realm first.
if claimRealmFirst("zone", "forest_shadows") {
t.Error("forest_shadows was still unclaimed after the reseed — the next clear would fire a spurious realm-first")
}
}
// TestReseedCorrectsTheBackfillsDates pins the second half. claimRealmFirst
// stamps unixepoch(), so every row the original one-shot wrote carries the one
// minute that job ran — in prod, all six share the identical timestamp. The
// reseed has to overwrite an existing row, not INSERT OR IGNORE past it.
func TestReseedCorrectsTheBackfillsDates(t *testing.T) {
seedRealmFixture(t)
// The fixture claims both zones the way the backfill did: at claim time.
before := ledgerFirstAt(t, "goblin_warrens")
if before < time.Now().Unix()-300 {
t.Fatalf("fixture claim for goblin_warrens is not a now-stamp (%d) — fixture drift", before)
}
bootstrapRealmFirstsReseed()
// Josie's r1, January, not r2 or r3 and not today.
if got, want := ledgerFirstAt(t, "goblin_warrens"), unixOf(t, "2026-01-10 12:00:00"); got != want {
t.Errorf("goblin_warrens first_at = %d, want %d (earliest real clear)", got, want)
}
// crypt_valdris has a clean clear (r4) and a retired-but-won one (r5). The
// earliest is r4.
if got, want := ledgerFirstAt(t, "crypt_valdris"), unixOf(t, "2026-05-01 12:00:00"); got != want {
t.Errorf("crypt_valdris first_at = %d, want %d", got, want)
}
}
// TestReseedEmitsNothing is the reason this is a re-seed and not a re-run of the
// backfill. The ledger has to be repaired without any historical realm-first
// dispatch reaching the room; a zone beaten in February is not news in July.
func TestReseedEmitsNothing(t *testing.T) {
seedRealmFixture(t)
db.Exec("seed retired-only zone", `INSERT INTO dnd_zone_run
(run_id, user_id, zone_id, total_rooms, boss_defeated, abandoned, completed_at)
VALUES ('r7', '@josie:x', 'forest_shadows', 6, 1, 1, '2026-02-14 09:00:00')`)
bootstrapRealmFirstsReseed()
var queued int
if err := db.Get().QueryRow(`SELECT COUNT(*) FROM pete_emit_queue`).Scan(&queued); err != nil {
t.Fatalf("count pete_emit_queue: %v", err)
}
if queued != 0 {
t.Errorf("reseed queued %d dispatches, want 0 — the ledger repair must be silent", queued)
}
}
// TestReseedIsAOneShot. It is a bootstrap kept in place for fresh deploys (per
// feedback_loader_rewire_needs_bootstrap), so it runs on every start and must
// cost nothing after the first — and, more importantly, must not undo a
// later live claim by rewriting the ledger from stale history on every boot.
func TestReseedIsAOneShot(t *testing.T) {
seedRealmFixture(t)
bootstrapRealmFirstsReseed()
// A zone cleared after the reseed, claimed live.
if !claimRealmFirst("zone", "sunken_temple") {
t.Fatal("sunken_temple should have been an unclaimed realm-first")
}
live := ledgerFirstAt(t, "sunken_temple")
bootstrapRealmFirstsReseed()
if got := ledgerFirstAt(t, "sunken_temple"); got != live {
t.Errorf("second reseed moved a live claim: %d -> %d", live, got)
}
if claimRealmFirst("zone", "goblin_warrens") {
t.Error("second reseed dropped an existing claim")
}
}
// TestZoneFirstClearsCountsRetiredKills guards the shared query itself, which
// the kept backfill also uses. `abandoned` means the run row was retired, not
// that anybody gave up.
func TestZoneFirstClearsCountsRetiredKills(t *testing.T) {
seedRealmFixture(t)
db.Exec("seed retired-only zone", `INSERT INTO dnd_zone_run
(run_id, user_id, zone_id, total_rooms, boss_defeated, abandoned, completed_at)
VALUES ('r7', '@josie:x', 'forest_shadows', 6, 1, 1, '2026-02-14 09:00:00')`)
clears, ok := zoneFirstClears()
if !ok {
t.Fatal("zoneFirstClears reported a read failure")
}
byZone := map[string]zoneFirstClear{}
for _, f := range clears {
byZone[f.zoneID] = f
}
if len(byZone) != 3 {
t.Fatalf("zoneFirstClears returned %d zones, want 3 (a regression to `abandoned = 0` gives 2)", len(byZone))
}
if got := byZone["forest_shadows"].userID; got != "@josie:x" {
t.Errorf("forest_shadows first clearer = %q, want @josie:x", got)
}
if _, ok := byZone["arena"]; ok {
t.Error("an unfinished run counted as a clear")
}
}
internal/plugin/botinfo.go
+12 -43
View File
@@ -1,12 +1,9 @@
package plugin
import (
"encoding/json"
"context"
"fmt"
"io"
"log/slog"
"net/http"
"os"
"strings"
"sync/atomic"
"time"
@@ -121,10 +118,8 @@ func (p *BotInfoPlugin) handleBotInfo(ctx MessageContext) error {
sb.WriteString(fmt.Sprintf("Active reminders: %d\n", activeReminders))
// LLM status
ollamaHost := os.Getenv("OLLAMA_HOST")
if ollamaHost != "" {
llmStatus := p.checkLLMStatus(ollamaHost)
sb.WriteString(fmt.Sprintf("LLM status: %s\n", llmStatus))
if llmConfigured() {
sb.WriteString(fmt.Sprintf("LLM status: %s\n", p.checkLLMStatus()))
} else {
sb.WriteString("LLM status: not configured\n")
}
@@ -159,42 +154,16 @@ func (p *BotInfoPlugin) handleBotInfo(ctx MessageContext) error {
return p.SendReply(ctx.RoomID, ctx.EventID, sb.String())
}
func (p *BotInfoPlugin) checkLLMStatus(ollamaHost string) string {
client := &http.Client{Timeout: 5 * time.Second}
apiURL := strings.TrimRight(ollamaHost, "/") + "/api/tags"
resp, err := client.Get(apiURL)
// checkLLMStatus reports backend liveness for /botinfo. The endpoint it probes
// differs per backend, which the llm package hides behind Ping.
func (p *BotInfoPlugin) checkLLMStatus() string {
c := llmClient()
models, err := c.Ping(context.Background())
if err != nil {
return fmt.Sprintf("offline (%s)", err.Error())
return fmt.Sprintf("offline (%s: %s)", c.Backend(), err.Error())
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return fmt.Sprintf("error (HTTP %d)", resp.StatusCode)
if len(models) == 0 {
return fmt.Sprintf("online (%s, no models loaded)", c.Backend())
}
body, err := io.ReadAll(resp.Body)
if err != nil {
return "online (could not read response)"
}
var result struct {
Models []struct {
Name string `json:"name"`
} `json:"models"`
}
if err := json.Unmarshal(body, &result); err != nil {
return "online (could not parse response)"
}
modelNames := make([]string, 0, len(result.Models))
for _, m := range result.Models {
modelNames = append(modelNames, m.Name)
}
if len(modelNames) == 0 {
return "online (no models loaded)"
}
return fmt.Sprintf("online (%d models: %s)", len(modelNames), strings.Join(modelNames, ", "))
return fmt.Sprintf("online (%s, %d models: %s)", c.Backend(), len(models), strings.Join(models, ", "))
}
internal/plugin/combat_armed_ability_test.go
+3 -3
View File
@@ -97,7 +97,7 @@ func TestBuildFightSeats_ConsumesTheAbilityOnceAndCarriesItOnTheSeat(t *testing.
ragingBerserker(t, uid)
seats, _, _, refusal := (&AdventurePlugin{}).buildFightSeats(
uid, []id.UserID{uid}, dndBestiary["goblin"], 1, 0)
uid, []id.UserID{uid}, dndBestiary["goblin"], 1, 0, nil)
if refusal != "" {
t.Fatalf("fight refused: %s", refusal)
}
@@ -125,7 +125,7 @@ func TestBuildZoneCombatants_RebuildKeepsTheRageForTheWholeFight(t *testing.T) {
ragingBerserker(t, uid)
p := &AdventurePlugin{}
seats, _, _, refusal := p.buildFightSeats(uid, []id.UserID{uid}, dndBestiary["goblin"], 1, 0)
seats, _, _, refusal := p.buildFightSeats(uid, []id.UserID{uid}, dndBestiary["goblin"], 1, 0, nil)
if refusal != "" {
t.Fatalf("fight refused: %s", refusal)
}
@@ -171,7 +171,7 @@ func TestBuildFightSeats_SatOutMemberKeepsTheirArmedAbility(t *testing.T) {
}
seats, _, _, refusal := (&AdventurePlugin{}).buildFightSeats(
leader, []id.UserID{leader, downed}, dndBestiary["goblin"], 1, 0)
leader, []id.UserID{leader, downed}, dndBestiary["goblin"], 1, 0, nil)
if refusal != "" {
t.Fatalf("fight refused: %s", refusal)
}
internal/plugin/combat_bridge.go
+15 -1
View File
@@ -32,6 +32,20 @@ func (p *AdventurePlugin) postCombatBookkeeping(
if err := persistDnDPostCombatSubclass(dndChar, raged, result, mods); err != nil {
slog.Error("dnd: post-combat subclass persist", "user", userID, "err", err)
}
// The pet fought too. A win is its only earned XP — see grantPetCombatXP
// for why this seam and not the room-clear one: it is the single place all
// four close-outs already meet, so a pet cannot level differently depending
// on whether the fight auto-resolved or was played a round at a time.
if result.PlayerWon {
if leveled := grantPetCombatXP(userID); len(leveled) > 0 {
for _, line := range leveled {
slog.Info("adventure: pet leveled", "user", userID, "pet", line)
}
if err := p.SendDM(userID, "🐾 "+strings.Join(leveled, "\n🐾 ")); err != nil {
slog.Warn("adventure: pet level-up DM", "user", userID, "err", err)
}
}
}
}
// grantCombatAchievements checks combat results for achievement-worthy moments.
@@ -371,7 +385,7 @@ type DeathTransitionResult struct {
func transitionDeath(p DeathTransitionParams) DeathTransitionResult {
var r DeathTransitionResult
if p.AllowPardon && p.ChatLevel >= 20 && p.Char.PardonAvailable() && rand.Float64() < 0.33 {
if p.AllowPardon && p.ChatLevel >= 20 && p.Char.PardonAvailable() && simFloat64() < 0.33 {
r.Pardoned = true
now := time.Now().UTC()
p.Char.LastPardonUsed = &now
internal/plugin/combat_cmd.go
+30 -1
View File
@@ -97,7 +97,7 @@ func (p *AdventurePlugin) handleFightCmd(ctx MessageContext) error {
// Seat the whole party, leader first. A solo player is a one-seat roster and
// takes the path they always took: one build, one INSERT, no participant rows.
seats, enemy, senderSkip, refusal := p.buildFightSeats(ctx.Sender, roster, monster, int(zone.Tier), run.DMMood)
seats, enemy, senderSkip, refusal := p.buildFightSeats(ctx.Sender, roster, monster, int(zone.Tier), run.DMMood, run)
if refusal != "" {
return p.replyDM(ctx, refusal)
}
@@ -119,6 +119,17 @@ func (p *AdventurePlugin) handleFightCmd(ctx MessageContext) error {
return p.replyDM(ctx, "Couldn't start the fight: "+err.Error())
}
// Layer-2 boss state that is spent mid-fight (Valdris's Phylactery Verses)
// is seeded onto the fresh session ONCE, from the route the player walked to
// get here — not on the per-round rebuild, which would resurrect spent
// rebirths. enemyHP is the party-scaled pool persisted above. No-op for every
// non-hooked enemy.
if seedBossRunStatuses(sess, monster.ID, enemyHP, run) {
if err := saveCombatSession(sess); err != nil {
return p.replyDM(ctx, "Couldn't start the fight: "+err.Error())
}
}
var b strings.Builder
if isBoss {
if line := composeBossEntry(zone.ID, run.RunID, run.CurrentRoom); line != "" {
@@ -696,6 +707,24 @@ func (p *AdventurePlugin) castActionForSeat(ct *combatTurn, seat int, args strin
PlayerHeal: out.PlayerHeal,
EnemySkip: out.EnemySkip,
}
// Revive the arcane-blaster sustained cantrip floor in the turn engine.
// combat_engine.go:590 deals CantripPerRound flat every round, but that
// path is the swing-based engine (SimulateCombat). Auto-resolve — the
// live path for every expedition — runs the turn engine, where a caster
// autocasts and never weapon-swings, so the floor was dead code: casters
// fought at bare cantrip dice (~4d10≈22 at L20). Lift LANDED cantrip
// damage to the floor, but only when the cast already connected
// (eff.EnemyDamage > 0) — a whiffed Fire Bolt still whiffs, so the ~35%
// miss variance survives and the floor doesn't become a guaranteed flat
// hammer (that overshot to ~99%). Damage cantrips only; slot spells keep
// their rolled damage. Only Mage/Sorcerer/Warlock carry a nonzero
// CantripPerRound, so this is self-targeting.
if spell.Level == 0 && eff.EnemyDamage > 0 &&
(spell.Effect == EffectDamageAttack || spell.Effect == EffectDamageSave || spell.Effect == EffectDamageAuto) {
if floor := ct.players[seat].Mods.CantripPerRound; floor > eff.EnemyDamage {
eff.EnemyDamage = floor
}
}
// §1 — redirect the heal onto the named ally. The roll is the same; only
// the body it lands on changes. This is the line that makes a cleric a
// cleric: until it existed, every heal in the engine was a self-heal, and
internal/plugin/combat_engine.go
+79
View File
@@ -181,6 +181,20 @@ type CombatModifiers struct {
SpellPreDamage int
SpellPreDamageDesc string
SpellEnemySkipFirst bool
// At-will cantrip channel. Arcane blasters (Mage/Sorcerer/Warlock) throw a
// scaling damage cantrip EVERY round — 5e cantrips are the caster's at-will
// floor and scale to 4 dice at L17 (Fire Bolt 4d10, Eldritch Blast 4 beams).
// The pre-combat one-shot SpellPreDamage modelled a single leveled cast and
// left the caster swinging a stick for the rest of the fight; that is the
// whole of the caster T5-room wall (one burst can't finish a 65-HP monster
// and the quarterstaff floor does nothing). CantripPerRound is dealt as flat
// magic damage at the top of resolvePlayerSwings each round — no dice roll,
// so the RNG stream is stable and variance stays low. 0 for non-casters, so
// martial combat is byte-identical. Halved by enemy spell_resist like any
// spell. CantripDesc is the narration hook (spell name).
CantripPerRound int
CantripDesc string
}
type Combatant struct {
@@ -428,6 +442,14 @@ type combatState struct {
enemyRegen int // regenerate: enemy heals this much each round end
enemySurviveArmed bool // survive_at_1: enemy cheats death once, dropping to 1 HP
// Phylactery Verses (T6 Valdris) — stackable rebirth. enemyReviveCharges is
// how many times the boss still cheats death; each revives it to
// enemyReviveHP. Seeded once at fight start from unfound Verses, round-tripped
// through CombatStatuses. Distinct from enemySurviveArmed (a one-shot 1-HP
// proc): a rebirth restores a meaningful pool, and there can be several.
enemyReviveCharges int
enemyReviveHP int
// Phase 13 bestiary slice 4 — the former flavor-only placeholders, now
// backed by real state.
enemySpellResist bool // spell_resist: player spell damage against this enemy is halved
@@ -435,6 +457,25 @@ type combatState struct {
enemyFearImmune bool // fear_immune: player control spells (enemy-skip) fizzle against this enemy
enemyAtkBuff int // ally_buff: flat, accumulating bonus to the enemy's attack damage
// Amendment (T6 Custodian) — an in-combat Layer-2 hook resolved at round end
// by applyBossInCombatRoundEnd. enemyRewindHP is the boss's round-3 HP
// snapshot (0 until captured); enemyRewindUsed gates the once-only rewind
// that restores it to that snapshot when the boss crosses into phase 2. The
// soft midnight timer past round 20 rides enemyAtkBuff. Round-tripped through
// CombatStatuses; zero/false for every non-Custodian fight.
enemyRewindHP int
enemyRewindUsed bool
// Inversion Stitch (T6 Seamstress) — an in-combat Layer-2 hook resolved at
// round end by applyBossInCombatRoundEnd, live only in the boss's phase 2.
// inversionActive is the number of rounds the room stays sewn inside-out
// (heals sting instead of mend, gated in stepPlayerActionEffect); it counts
// down one per round end. inversionTelegraph warns the round before a pulse
// activates, so a player who watches the tell can hold their heals. Both
// round-trip through CombatStatuses; zero/false for every non-Seamstress fight.
inversionActive int
inversionTelegraph bool
round int
events []CombatEvent
@@ -541,6 +582,31 @@ func maybeTriggerOrcRage(st *combatState, player *Combatant, phaseName string) {
// consumes once-per-fight openers (AutoCritFirst, FirstAttackBonus,
// AssassinateAdvantage) via st flags — extras roll vanilla.
func resolvePlayerSwings(st *combatState, player, enemy *Combatant, phase *CombatPhase, result *CombatResult) bool {
// At-will cantrip: fires once per round before the weapon swing, independent
// of whether the swing connects (a caster who whiffs the stick still throws
// its Fire Bolt). Flat magic damage, halved by spell_resist. 0 for
// non-casters → skipped entirely, so martial combat draws no extra events
// and no RNG. See CantripPerRound in CombatModifiers.
if player.Mods.CantripPerRound > 0 && st.enemyHP > 0 {
dmg := player.Mods.CantripPerRound
if enemyResistsSpells(enemy, st) {
dmg = max(1, dmg/2)
}
st.enemyHP = max(0, st.enemyHP-dmg)
st.events = append(st.events, CombatEvent{
Round: st.round, Phase: phase.Name, Actor: "player", Action: "cantrip",
Damage: dmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
Desc: player.Mods.CantripDesc,
})
// Route the kill through enemyDown, not a raw HP read: a boss that cheats
// death (survive_at_1) or holds a phylactery rebirth (T6 Valdris) must get
// that chance even when the lethal blow is the at-will cantrip. enemyDown
// restores its HP and returns false, so the weapon swing below resolves
// against the revived pool. Mirrors resolvePlayerAttack's own kill routing.
if enemyDown(st, phase.Name) {
return true
}
}
if resolvePlayerAttack(st, player, enemy, phase, result) {
return true
}
@@ -1308,6 +1374,19 @@ func enemyDown(st *combatState, phaseName string) bool {
})
return false
}
// Phylactery Verses (T6 Valdris): a stackable rebirth. Each unfound Verse
// left one of these charges, and each restores a real pool rather than the
// 1-HP stay above — a full-clear explorer stripped them all and fights a
// mortal, a skip-route fights a god who keeps getting back up.
if st.enemyReviveCharges > 0 {
st.enemyReviveCharges--
st.enemyHP = max(1, st.enemyReviveHP)
st.events = append(st.events, CombatEvent{
Round: st.round, Phase: phaseName, Actor: "enemy", Action: "phylactery_rebirth",
PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
})
return false
}
return true
}
internal/plugin/combat_narrative.go
+71
View File
@@ -242,6 +242,10 @@ func renderEvent(e CombatEvent, playerName, enemyName string, result CombatResul
case "concentration_tick":
return fmt.Sprintf(pickRand(narrativeConcentrationTick), e.Damage)
case "cantrip":
// e.Desc is the spell name (Fire Bolt / Eldritch Blast); e.Damage the hit.
return fmt.Sprintf(pickRand(narrativeCantrip), e.Desc, e.Damage)
case "pet_deflect":
return pickRand(narrativePetDeflect)
@@ -331,6 +335,18 @@ func renderEvent(e CombatEvent, playerName, enemyName string, result CombatResul
return pickRand(narrativeSurviveArmed)
case "survive_at_1":
return pickRand(narrativeSurvive)
case "phylactery_rebirth":
return pickRand(narrativePhylacteryRebirth)
case "amendment_rewind":
return pickRand(narrativeAmendmentRewind)
case "midnight_toll":
return fmt.Sprintf(pickRand(narrativeMidnightToll), e.Damage)
case "inversion_telegraph":
return pickRand(narrativeInversionTelegraph)
case "inversion_stitch":
return pickRand(narrativeInversionStitch)
case "heal_inverted":
return fmt.Sprintf(pickRand(narrativeHealInverted), e.Damage)
case "stat_drain":
return fmt.Sprintf(pickRand(narrativeStatDrain), e.Damage)
case "debuff":
@@ -546,6 +562,15 @@ var narrativeConcentrationTick = []string{
"🌀 The enemy steps wrong and the standing magic answers, %d damage. It does not move on.",
}
// narrativeCantrip fires each round an arcane blaster throws its at-will cantrip
// (Fire Bolt / Eldritch Blast) before the weapon swing. %s is the spell name,
// %d the damage — a caster's sustained floor, so it lands every round.
var narrativeCantrip = []string{
"✨ %s streaks out and burns home — %d damage. The at-will floor never stops.",
"✨ A bolt of %s answers before the staff even moves, scorching for %d.",
"✨ %s lances the enemy for %d. No incantation, no wind-up — just the steady arcane drum.",
}
var narrativePetDeflect = []string{
"🐾 Your pet intercepts the blow. Damage halved. Your pet is now your best piece of equipment.",
"🐾 Your pet pushes you aside at the last second. Impact reduced. You did not ask to be pushed. Results speak for themselves.",
@@ -761,6 +786,52 @@ var narrativeSurvive = []string{
"🕯️ The enemy by all rights should be down. It is, instead, very barely up.",
}
// narrativePhylacteryRebirth fires when Valdris burns a Verse the player left
// un-found: a bound rebirth spends and the lich reassembles. Each line reads as
// "you skipped one of these" so the mechanic teaches itself over a wipe.
var narrativePhylacteryRebirth = []string{
"💀 The lich comes apart — and a Verse you never found sings him back together. He rises, unhurried.",
"💀 Bone-dust swirls up off the floor and re-seats itself. A rebirth you didn't unbind just spent itself. He stands.",
"💀 That should have been the end of him. A Verse still hums somewhere in the cathedral, and Valdris simply *begins again*.",
}
// narrativeAmendmentRewind fires when the Custodian rewinds itself to its round-3
// HP snapshot — the once-only Amendment. Each line reads as time being undone so
// the mechanic (front-loaded burst is partly refunded) teaches itself over a run.
var narrativeAmendmentRewind = []string{
"🕰️ The Custodian raises a hand and *edits the last few minutes out of the record.* Wounds close in reverse; the clock-golem stands as it did rounds ago.",
"🕰️ \"That entry is amended.\" The damage you dealt simply un-happens — the Custodian rewinds to where it was and resumes, unhurried.",
"🕰️ Verdigris rings spin backward. Time you spent hurting it is refunded to the golem; it returns to its round-three self and keeps working.",
}
// narrativeMidnightToll fires past round 20 — the soft closing-time timer, the
// Custodian's Attack climbing each round a stalled fight refuses to end.
var narrativeMidnightToll = []string{
"🔔 A bell tolls somewhere above. Closing time — the Custodian's swings come harder. (+%d attack)",
"🔔 The hour is nearly spent, and so is its patience; each blow lands with more weight now. (+%d attack)",
}
// narrativeInversionTelegraph fires one round before an Inversion Stitch pulse —
// the Seamstress's tell. It reads as a warning so a player learns to hold heals.
var narrativeInversionTelegraph = []string{
"🧵 The Seamstress draws a thread taut and the room *shivers* — walls flexing toward inside-out. Whatever you were about to mend, hold it. (next round, healing turns against you)",
"🧵 A seam in the air puckers. The geometry is about to flip; a cure cast into it will run backward. (inversion incoming next round)",
}
// narrativeInversionStitch fires when a pulse activates — the room is sewn
// inside-out and healing now wounds for the pulse's duration.
var narrativeInversionStitch = []string{
"🧵 The stitch pulls through. The room is inside-out now — for a moment, to heal is to hurt.",
"🧵 Everything turns wrong-way-round. Mending and wounding have swapped ends of the needle.",
}
// narrativeHealInverted fires each time a heal lands during an active pulse: the
// cure runs backward and stings instead. Teaches the mechanic on the spot.
var narrativeHealInverted = []string{
"🧵 The heal runs backward through the inverted room — the cure opens the wound it meant to close. (%d damage)",
"🧵 Healing turns against its target in the sewn-inside-out air; the mend lands as a sting. (%d damage)",
}
var narrativeStatDrain = []string{
"🩸 The enemy saps your strength — your swings feel heavier, weaker. (-%d hit damage)",
"🩸 Something drains out of your limbs. Your hits won't bite as deep now. (-%d damage)",
internal/plugin/combat_party_start.go
+8 -1
View File
@@ -51,7 +51,7 @@ func fightRoster(sender id.UserID) []id.UserID {
// The enemy is built once. Every seat's build derives the identical stat block
// from (monster, tier, dmMood); only the player half varies.
func (p *AdventurePlugin) buildFightSeats(
sender id.UserID, roster []id.UserID, monster DnDMonsterTemplate, tier, dmMood int,
sender id.UserID, roster []id.UserID, monster DnDMonsterTemplate, tier, dmMood int, run *DungeonRun,
) (seats []CombatSeatSetup, enemy *Combatant, senderSkip, refusal string) {
skip := func(uid id.UserID, why string) {
if uid == sender {
@@ -157,6 +157,13 @@ func (p *AdventurePlugin) buildFightSeats(
// actually seated — a member who was skipped (downed, busy elsewhere) never
// joined the fight and must not be charged to the enemy.
applySeatWeights(seatCombatants(seats), levels, companions)
// Fold in any Layer-2 pre-combat boss mechanic before this enemy is used to
// persist the initial HP pool. partyCombatantsForSession re-applies the same
// modifier on every round's rebuild; doing it here keeps the persisted stat
// block consistent with the fight the engine will actually run. No-op for
// every non-hooked enemy.
applyBossRunModifiers(monster.ID, enemy, run)
return seats, enemy, senderSkip, ""
}
internal/plugin/combat_party_start_test.go
+5 -5
View File
@@ -109,7 +109,7 @@ func TestBuildFightSeats_SoloSeatsExactlyThePlayer(t *testing.T) {
fightTestChar(t, solo, 30)
seats, enemy, skip, refusal := (&AdventurePlugin{}).buildFightSeats(
solo, []id.UserID{solo}, dndBestiary["goblin"], 1, 0)
solo, []id.UserID{solo}, dndBestiary["goblin"], 1, 0, nil)
if refusal != "" || skip != "" {
t.Fatalf("solo fight refused: %s / %s", refusal, skip)
}
@@ -140,7 +140,7 @@ func TestBuildFightSeats_DownedMemberSitsOut(t *testing.T) {
roster := []id.UserID{leader, downed, standing}
seats, _, skip, refusal := (&AdventurePlugin{}).buildFightSeats(
leader, roster, dndBestiary["goblin"], 1, 0)
leader, roster, dndBestiary["goblin"], 1, 0, nil)
if refusal != "" {
t.Fatalf("party refused over a downed member: %s", refusal)
}
@@ -156,7 +156,7 @@ func TestBuildFightSeats_DownedMemberSitsOut(t *testing.T) {
// The one who was left behind typed `!fight` too, and silence is not an answer.
_, _, skip, refusal = (&AdventurePlugin{}).buildFightSeats(
downed, roster, dndBestiary["goblin"], 1, 0)
downed, roster, dndBestiary["goblin"], 1, 0, nil)
if refusal != "" {
t.Fatalf("a downed member must not refuse the party's fight: %s", refusal)
}
@@ -176,7 +176,7 @@ func TestBuildFightSeats_DownedLeaderRefusesTheFightForEveryone(t *testing.T) {
roster := []id.UserID{leader, member}
p := &AdventurePlugin{}
seats, _, _, refusal := p.buildFightSeats(leader, roster, dndBestiary["goblin"], 1, 0)
seats, _, _, refusal := p.buildFightSeats(leader, roster, dndBestiary["goblin"], 1, 0, nil)
if len(seats) != 0 || refusal == "" {
t.Fatalf("downed leader seated %d players, refusal %q", len(seats), refusal)
}
@@ -184,7 +184,7 @@ func TestBuildFightSeats_DownedLeaderRefusesTheFightForEveryone(t *testing.T) {
t.Errorf("the leader should be told to rest, got %q", refusal)
}
_, _, _, refusal = p.buildFightSeats(member, roster, dndBestiary["goblin"], 1, 0)
_, _, _, refusal = p.buildFightSeats(member, roster, dndBestiary["goblin"], 1, 0, nil)
if !strings.Contains(refusal, "leader") {
t.Errorf("the member should be told it is the leader holding things up, got %q", refusal)
}
internal/plugin/combat_session.go
+35
View File
@@ -215,12 +215,44 @@ type CombatStatuses struct {
EnemyRegen int `json:"enemy_regen,omitempty"`
EnemySurviveArmed bool `json:"enemy_survive_armed,omitempty"`
// Phylactery Verses (Tier-6 postgame, Valdris Ascendant). Unlike the
// proc-armed EnemySurviveArmed one-shot, this is a *count* of rebirths seeded
// once at fight start (seedBossRunStatuses) from how many of the zone's secret
// Verses the player left un-found. Each consumed rebirth (enemyDown) revives
// the boss to EnemyReviveHP. Both fields are frozen at seed time except
// EnemyReviveCharges, which decrements as rebirths are spent — so they must
// round-trip through combatState to survive a suspend/resume. Zero for every
// other enemy, so omitempty keeps them off every non-Valdris row.
EnemyReviveCharges int `json:"enemy_revive_charges,omitempty"`
EnemyReviveHP int `json:"enemy_revive_hp,omitempty"`
// Slice-4 monster-ability effects — the former flavor-only placeholders.
// EnemyRevealNext is a one-shot; the other three persist for the fight.
EnemySpellResist bool `json:"enemy_spell_resist,omitempty"`
EnemyRevealNext bool `json:"enemy_reveal_next,omitempty"`
EnemyFearImmune bool `json:"enemy_fear_immune,omitempty"`
EnemyAtkBuff int `json:"enemy_atk_buff,omitempty"`
// Amendment (Tier-6 postgame, The Custodian of the Last Hour). An in-combat
// Layer-2 hook resolved at round end (applyBossInCombatRoundEnd), not proc-
// armed: EnemyRewindHP snapshots the boss's HP at the end of round 3 (0 until
// captured); when the boss then crosses into phase 2 the hook restores it to
// that snapshot exactly once and sets EnemyRewindUsed. Both round-trip through
// combatState so the once-only rewind survives a suspend/resume. Zero/false
// for every other enemy. The soft midnight timer past round 20 rides the
// existing EnemyAtkBuff, so it needs no field of its own.
EnemyRewindHP int `json:"enemy_rewind_hp,omitempty"`
EnemyRewindUsed bool `json:"enemy_rewind_used,omitempty"`
// Inversion Stitch (Tier-6 postgame, The Seamstress). An in-combat Layer-2
// hook resolved at round end (applyBossInCombatRoundEnd), live only in the
// boss's phase 2. InversionActive is the rounds-remaining of the inside-out
// pulse during which player heals sting instead of mend (gated in
// stepPlayerActionEffect); InversionTelegraph is the one-round warning before
// a pulse activates. Both round-trip through combatState so a suspend/resume
// can't lose or replay a pulse mid-fight. Zero/false for every other enemy.
InversionActive int `json:"inversion_active,omitempty"`
InversionTelegraph bool `json:"inversion_telegraph,omitempty"`
}
// applyBuffDelta folds one resolved buff (the result of a !cast / !consume
@@ -450,6 +482,9 @@ const combatSessionCols = `
// newCombatSessionID — 16-char hex token. Same scheme as zone runs / expeditions.
func newCombatSessionID() string {
if simSeedOn() {
return simHexToken()
}
var b [8]byte
if _, err := cryptorand.Read(b[:]); err != nil {
// Vanishingly unlikely; fall through with a zeroed prefix.
internal/plugin/combat_session_build.go
+7
View File
@@ -211,6 +211,13 @@ func (p *AdventurePlugin) partyCombatantsForSession(sess *CombatSession) ([]*Com
// until every seat is built.
applySeatWeights(players, levels, companions)
// Layer-2 pre-combat boss mechanics: fold in any run-state-derived
// adjustment (e.g. Aurvandryx's Greed Tax) before the party HP scaling. This
// is re-derived every round like everything else here; its inputs are frozen
// for a terminal boss fight, so the result is stable. No-op for every
// non-hooked enemy.
applyBossRunModifiers(monster.ID, &enemy, run)
// Party-only enemy HP bump, re-derived each turn from the template so it never
// compounds. Matches the scalar startPartyCombatSession used for the initial
// persist; solo (one seat, weight 1) scales by 1.0.
internal/plugin/combat_turn_engine.go
+66 -14
View File
@@ -363,12 +363,20 @@ func resumeTurnEngine(sess *CombatSession, players []*Combatant, enemy *Combatan
enemyRetaliateFrac: sess.Statuses.EnemyRetaliateFrac,
enemyRegen: sess.Statuses.EnemyRegen,
enemySurviveArmed: sess.Statuses.EnemySurviveArmed,
enemyReviveCharges: sess.Statuses.EnemyReviveCharges,
enemyReviveHP: sess.Statuses.EnemyReviveHP,
// Slice-4 monster-ability effects — the former flavor-only placeholders.
enemySpellResist: sess.Statuses.EnemySpellResist,
enemyRevealNext: sess.Statuses.EnemyRevealNext,
enemyFearImmune: sess.Statuses.EnemyFearImmune,
enemyAtkBuff: sess.Statuses.EnemyAtkBuff,
rng: rng,
// Amendment (T6 Custodian) — round-3 snapshot + once-only rewind.
enemyRewindHP: sess.Statuses.EnemyRewindHP,
enemyRewindUsed: sess.Statuses.EnemyRewindUsed,
// Inversion Stitch (T6 Seamstress) — phase-2 heal-inverting pulses.
inversionActive: sess.Statuses.InversionActive,
inversionTelegraph: sess.Statuses.InversionTelegraph,
rng: rng,
}
order := turnOrder(sess, sess.Round, players, enemy)
sess.Statuses.TurnIdx = turnIdxForPhase(order, sess.Statuses.TurnIdx, sess.Phase)
@@ -568,10 +576,22 @@ func (te *turnEngine) stepPlayerActionEffect(eff *turnActionEffect) {
st.enemyHP = max(0, st.enemyHP-enemyDmg)
}
if eff.PlayerHeal > 0 {
// Respect any max_hp_drain monster ability — a drained player can't be
// healed back past the lowered ceiling.
hpCap := max(1, st.hpMax-st.maxHPDrain)
st.playerHP = min(hpCap, st.playerHP+eff.PlayerHeal)
if st.inversionActive > 0 {
// Inversion Stitch (T6 Seamstress phase 2): the room is sewn inside-out,
// so the cure lands as a wound. Floored at 1 so a player is never killed
// by their own heal — the Seamstress's own blows do the finishing; the
// sting just denies the sustain and softens the seat for them.
st.playerHP = max(1, st.playerHP-eff.PlayerHeal)
st.events = append(st.events, CombatEvent{
Round: st.round, Phase: turnCombatPhase.Name, Actor: "enemy", Action: "heal_inverted",
Damage: eff.PlayerHeal, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
})
} else {
// Respect any max_hp_drain monster ability — a drained player can't be
// healed back past the lowered ceiling.
hpCap := max(1, st.hpMax-st.maxHPDrain)
st.playerHP = min(hpCap, st.playerHP+eff.PlayerHeal)
}
}
// §1 — heal somebody else. The caster's cursor stays where it is; only the
// target's HP moves.
@@ -582,14 +602,27 @@ func (te *turnEngine) stepPlayerActionEffect(eff *turnActionEffect) {
// path depends on. Healing keeps people up; it does not bring them back.
if eff.AllyHeal > 0 && eff.AllySeat >= 0 && eff.AllySeat < len(st.actors) {
if tgt := st.actors[eff.AllySeat]; tgt.playerHP > 0 {
cap := max(1, tgt.hpMax-tgt.maxHPDrain)
before := tgt.playerHP
tgt.playerHP = min(cap, tgt.playerHP+eff.AllyHeal)
st.events = append(st.events, CombatEvent{
Round: st.round, Phase: turnCombatPhase.Name, Actor: "player", Action: "ally_heal",
Damage: tgt.playerHP - before, PlayerHP: tgt.playerHP, EnemyHP: st.enemyHP,
Seat: eff.AllySeat, Desc: eff.Label,
})
if st.inversionActive > 0 {
// Inversion Stitch: the ally-heal wounds the friend it was meant to
// mend. Floored at 1 like the self-heal sting above — the sting denies
// the sustain, it does not kill.
before := tgt.playerHP
tgt.playerHP = max(1, tgt.playerHP-eff.AllyHeal)
st.events = append(st.events, CombatEvent{
Round: st.round, Phase: turnCombatPhase.Name, Actor: "enemy", Action: "heal_inverted",
Damage: before - tgt.playerHP, PlayerHP: tgt.playerHP, EnemyHP: st.enemyHP,
Seat: eff.AllySeat, Desc: eff.Label,
})
} else {
cap := max(1, tgt.hpMax-tgt.maxHPDrain)
before := tgt.playerHP
tgt.playerHP = min(cap, tgt.playerHP+eff.AllyHeal)
st.events = append(st.events, CombatEvent{
Round: st.round, Phase: turnCombatPhase.Name, Actor: "player", Action: "ally_heal",
Damage: tgt.playerHP - before, PlayerHP: tgt.playerHP, EnemyHP: st.enemyHP,
Seat: eff.AllySeat, Desc: eff.Label,
})
}
}
}
// Arm / replace the concentration aura. A new concentration cast overwrites
@@ -840,7 +873,12 @@ func (te *turnEngine) stepRoundEnd() {
Round: st.round, Phase: CombatPhaseRoundEnd, Actor: "player", Action: "concentration_tick",
Damage: st.concentrationDmg, PlayerHP: st.playerHP, EnemyHP: st.enemyHP, Seat: i,
})
if st.enemyHP <= 0 {
// Route the kill through enemyDown, not a raw HP read: a boss that cheats
// death (survive_at_1) or holds a phylactery rebirth (T6 Valdris) must get
// that chance even when the lethal blow is a lingering concentration pulse.
// enemyDown restores its HP and returns false, so the next seat's pulse (or
// the following round) resolves against the revived pool.
if enemyDown(st, CombatPhaseRoundEnd) {
te.finish(CombatStatusWon)
return
}
@@ -872,6 +910,14 @@ func (te *turnEngine) stepRoundEnd() {
Damage: st.enemyRegen, PlayerHP: st.playerHP, EnemyHP: st.enemyHP,
})
}
// Tier-6 in-combat Layer-2 boss hooks (Amendment): round-3 HP snapshot +
// once-only phase-2 rewind + soft midnight timer, resolved on the round that
// just finished. A no-op for every enemy but the hooked bosses, and only
// while the enemy still stands, so it is safe to call unconditionally here
// after the round's damage has settled.
if st.enemyHP > 0 {
applyBossInCombatRoundEnd(st, te.sess.EnemyID, te.enemy.Stats.MaxHP)
}
st.round++
// Initiative is re-rolled each round, so the next round's order is derived
// here — off st.round, since commit has not yet pushed it onto the session.
@@ -926,10 +972,16 @@ func (te *turnEngine) commit() {
s.EnemyRetaliateFrac = st.enemyRetaliateFrac
s.EnemyRegen = st.enemyRegen
s.EnemySurviveArmed = st.enemySurviveArmed
s.EnemyReviveCharges = st.enemyReviveCharges
s.EnemyReviveHP = st.enemyReviveHP
s.EnemySpellResist = st.enemySpellResist
s.EnemyRevealNext = st.enemyRevealNext
s.EnemyFearImmune = st.enemyFearImmune
s.EnemyAtkBuff = st.enemyAtkBuff
s.EnemyRewindHP = st.enemyRewindHP
s.EnemyRewindUsed = st.enemyRewindUsed
s.InversionActive = st.inversionActive
s.InversionTelegraph = st.inversionTelegraph
te.sess.TurnLog = append(te.sess.TurnLog, st.events...)
}
internal/plugin/combat_turn_party_test.go
+54
View File
@@ -275,3 +275,57 @@ func TestTurnEngine_CommitPersistsSeatZeroNotTheCursor(t *testing.T) {
t.Error("seat 1's consumed Lucky reroll leaked onto the session row")
}
}
// A lingering concentration pulse that lands the killing blow must still give a
// revive-armed boss (survive_at_1 / T6 Valdris's phylactery rebirth) its chance
// to stand back up — the round-end tick routes the kill through enemyDown, not a
// raw enemyHP<=0 read. Regression for the concentration-bypass gap found in the
// P8 Layer-2 review.
func TestTurnEngine_ConcentrationKillHonorsRebirth(t *testing.T) {
// A charged rebirth: the pulse drops the enemy, a charge spends, it revives.
sess := turnSession(CombatPhaseRoundEnd, 500, 30)
p := basePlayer()
e := baseEnemy()
te := resumeTurnEngine(sess, []*Combatant{&p}, &e, combatSessionStepRNG(sess, enemySeat))
te.st.concentrationDmg = 100 // lethal against 30 HP
te.st.enemyReviveCharges = 1
te.st.enemyReviveHP = 40
if _, err := te.step(PlayerAction{}); err != nil {
t.Fatal(err)
}
te.commit()
if !sess.IsActive() {
t.Fatalf("a concentration kill ended the fight (%q) while a rebirth charge was armed", sess.Status)
}
if sess.EnemyHP != 40 {
t.Errorf("revived EnemyHP = %d, want the 40-HP revive pool", sess.EnemyHP)
}
if sess.Statuses.EnemyReviveCharges != 0 {
t.Errorf("post-revive charges = %d, want 0 (one spent)", sess.Statuses.EnemyReviveCharges)
}
rebirths := 0
for _, ev := range sess.TurnLog {
if ev.Action == "phylactery_rebirth" {
rebirths++
}
}
if rebirths != 1 {
t.Errorf("phylactery_rebirth events = %d, want 1", rebirths)
}
// With no charge left, the same pulse ends the fight cleanly (the win path
// is not broken by the enemyDown routing).
mortal := turnSession(CombatPhaseRoundEnd, 500, 30)
p2 := basePlayer()
e2 := baseEnemy()
te2 := resumeTurnEngine(mortal, []*Combatant{&p2}, &e2, combatSessionStepRNG(mortal, enemySeat))
te2.st.concentrationDmg = 100
if _, err := te2.step(PlayerAction{}); err != nil {
t.Fatal(err)
}
te2.commit()
if mortal.Status != CombatStatusWon {
t.Errorf("charge-less concentration kill status = %q, want %q", mortal.Status, CombatStatusWon)
}
}
internal/plugin/dnd_combat.go
+2
View File
@@ -607,6 +607,7 @@ func emitDeathNews(userID id.UserID, location string) {
Zone: location,
Level: lvl,
Outcome: "lost",
RunID: latestRunIDForNews(userID),
OccurredAt: ts,
}, userID, "")
}
@@ -655,6 +656,7 @@ func emitRetreatNews(userID id.UserID, reason string, zoneID ZoneID, day int) {
Level: charLevel(userID),
Count: day, // the day they got to before it fell apart
Outcome: "retreated",
RunID: latestRunIDForNews(userID),
OccurredAt: ts,
}, userID, "")
}
internal/plugin/dnd_expedition_cmd.go
+487 -140
View File
@@ -1,9 +1,11 @@
package plugin
import (
"errors"
"fmt"
"log/slog"
"math"
"sort"
"strconv"
"strings"
"time"
@@ -31,6 +33,23 @@ import (
// in E1e. !advance / !search / !rest / !extract are out-of-scope for E1.
func (p *AdventurePlugin) handleDnDExpeditionCmd(ctx MessageContext, args string) error {
args = strings.TrimSpace(args)
sub, rest := splitFirstWord(args)
// Two subcommands are aliases for top-level commands that take the per-user
// lock themselves. Dispatch them BEFORE we take it: advUserLock is a plain
// sync.Mutex, so grabbing it here and again in there does not merely block —
// it wedges the lock forever, because the deferred Unlock below never runs.
// Every later `!adventure` / `!expedition` / `!zone` command from that player
// then hangs too. Both aliases load their own character, so nothing below is
// being skipped.
switch strings.ToLower(sub) {
case "extract":
return p.handleExtractCmd(ctx, "")
case "resume":
return p.handleResumeCmd(ctx, rest)
}
userMu := p.advUserLock(ctx.Sender)
userMu.Lock()
defer userMu.Unlock()
@@ -44,8 +63,6 @@ func (p *AdventurePlugin) handleDnDExpeditionCmd(ctx MessageContext, args string
"No Adv 2.0 character yet — run `!setup` (or just enter combat and we'll auto-build one).")
}
args = strings.TrimSpace(args)
sub, rest := splitFirstWord(args)
switch strings.ToLower(sub) {
case "":
// If active, show status; otherwise help. A party member is on an
@@ -99,10 +116,6 @@ func (p *AdventurePlugin) handleDnDExpeditionCmd(ctx MessageContext, args string
return p.expeditionCmdHire(ctx, rest)
case "dismiss":
return p.expeditionCmdDismiss(ctx)
case "extract":
return p.handleExtractCmd(ctx, "")
case "resume":
return p.handleResumeCmd(ctx, rest)
case "map", "m":
return p.handleExpeditionMapCmd(ctx, "")
case "run", "explore", "advance":
@@ -331,83 +344,14 @@ func (p *AdventurePlugin) expeditionCmdStart(ctx MessageContext, c *DnDCharacter
if err != nil {
return p.SendDM(ctx.Sender, "Couldn't parse supply packs: "+err.Error())
}
if err := purchase.Validate(zoneForCaps.Tier); err != nil {
return p.SendDM(ctx.Sender, "Invalid pack selection: "+err.Error())
}
// Reject if any expedition or zone run already active. This runs before the
// price quote: a player who cannot leave doesn't need to hear what leaving
// would have cost.
//
// The seat check spans `extracting` as well as `active` — a member of an
// extracting party is still seated for the seven-day resume window, and
// letting them outfit a rival expedition double-books them the moment their
// leader types `!resume`.
if seated, _ := seatedExpeditionFor(ctx.Sender); seated != nil {
zone, _ := getZone(seated.ZoneID)
return p.SendDM(ctx.Sender, fmt.Sprintf(
"You're riding a party expedition in **%s** (Day %d). `!expedition leave` before starting your own.",
zone.Display, seated.CurrentDay))
}
if existing, _ := getActiveExpedition(ctx.Sender); existing != nil {
zone, _ := getZone(existing.ZoneID)
return p.SendDM(ctx.Sender, fmt.Sprintf(
"You're already on expedition in **%s** (Day %d). Finish it or `!expedition abandon` first.",
zone.Display, existing.CurrentDay))
}
// A leader who extracted still holds their roster for the resume window, and
// `!resume` only ever reaches the *newest* extracted row. Starting fresh on
// top of one would orphan it: unreachable, un-reapable until the sweeper
// catches it, with every member still seated and refused a run of their own.
//
// Only a row with a roster blocks. A solo extraction strands nobody, so
// walking away from it stays a normal thing to do.
if pending, _ := getResumableExpedition(ctx.Sender); pending != nil {
switch {
case extractionLapsed(pending, time.Now().UTC()):
// Past the window — reap it here rather than make them wait an hour
// for the sweeper, and let the new expedition proceed. Route through
// the shared reap so the freed members hear about it, same as the
// sweeper and `!expedition abandon` do.
if err := p.reapLapsedExtraction(pending); err != nil {
slog.Warn("expedition: reap lapsed on start", "expedition", pending.ID, "err", err)
}
default:
// A roster still holds; block. On a roster-read error, assume it is
// occupied and refuse — proceeding would orphan a party we could not
// confirm was empty, the one outcome this guard exists to prevent. A
// solo extraction (n == 1) strands nobody, so walking away is fine.
n, err := partySize(pending.ID)
if err != nil || n > 1 {
zone, _ := getZone(pending.ZoneID)
return p.SendDM(ctx.Sender, fmt.Sprintf(
"You extracted from **%s** on Day %d and your party is still waiting on you. `!resume` to lead them back in, or `!expedition abandon` to let it go — until you do one or the other, none of them can start a run of their own.",
zone.Display, pending.CurrentDay))
}
}
}
cost := float64(purchase.Cost())
if p.euro == nil {
return p.SendDM(ctx.Sender, "Coin system unavailable — try again later.")
}
if balance := p.euro.GetBalance(ctx.Sender); balance < cost {
return p.SendDM(ctx.Sender, fmt.Sprintf(
"Not enough coins. Outfitting costs **%d** but you have **%.0f**.",
int(cost), balance))
}
if existing, _ := getActiveZoneRun(ctx.Sender); existing != nil {
zone, _ := getZone(existing.ZoneID)
return p.SendDM(ctx.Sender, fmt.Sprintf(
"You have an active single-session zone run in **%s**. Finish or `!zone abandon` before starting an expedition.",
zone.Display))
}
zone := zoneForCaps
_, supplies, startLine, err := p.beginExpedition(ctx.Sender, c.Level, zone, purchase, "expedition outfitting")
out, err := p.performExpeditionStart(ctx.Sender, c, zoneForCaps, purchase, "")
if err != nil {
// Every refusal below carries its own finished sentence — see the sentinel
// block on performExpeditionStart — so the command only has to say it.
return p.SendDM(ctx.Sender, err.Error())
}
markActedToday(ctx.Sender)
zone, supplies, startLine := out.Zone, out.Supplies, out.StartLine
var b strings.Builder
b.WriteString(fmt.Sprintf("🗺 **Expedition begins — %s** _(T%d)_\n\n", zone.Display, int(zone.Tier)))
@@ -428,6 +372,182 @@ func (p *AdventurePlugin) expeditionCmdStart(ctx MessageContext, c *DnDCharacter
return p.SendDM(ctx.Sender, b.String())
}
// ── the headless twin of `!expedition start` ────────────────────────────────
// Sentinels for the ways outfitting can be refused, so the web action queue
// (pete_orders.go) can pick a verdict without parsing prose. Every refusal is
// returned as an advRefusal, which wraps one of these AND carries the
// finished player-facing sentence — that is how `!expedition start` keeps the
// exact copy it always sent while the web gets a machine-readable answer.
var (
errExpStartResting = errors.New("expedition start: still resting")
errExpStartZoneLocked = errors.New("expedition start: zone not available at this level")
errExpStartBadPacks = errors.New("expedition start: invalid pack selection")
errExpStartBusy = errors.New("expedition start: already adventuring")
errExpStartBroke = errors.New("expedition start: cannot cover outfitting")
errExpStartFailed = errors.New("expedition start: could not outfit")
)
// advRefusal is a refusal that is both classifiable and quotable: errors.Is
// picks the verdict, Error() is the sentence the command has always sent. Shared
// by every headless twin in the web action family (start, resume, babysit).
type advRefusal struct {
kind error
msg string
}
func (e advRefusal) Error() string { return e.msg }
func (e advRefusal) Unwrap() error { return e.kind }
func refuseAdv(kind error, format string, args ...any) error {
return advRefusal{kind: kind, msg: fmt.Sprintf(format, args...)}
}
// expStartOutcome is what outfitting did, for a caller describing it somewhere
// other than a DM.
type expStartOutcome struct {
Zone ZoneDefinition
Supplies ExpeditionSupplies
Cost int
Days int
StartLine string
}
// performExpeditionStart is `!expedition start` minus the command framing: the
// eligibility guards, the price gate, the debit, and the expedition row. It is
// shared with the web action queue so that leaving town from a phone is the
// *same* departure — same guards, same supplies, same opening log line.
//
// idemKey, when set, is the web order's guid: the debit then goes through
// DebitIdem so a re-offered order that already paid cannot pay twice. The Matrix
// command passes "" and keeps the plain debit, which is right — a Matrix message
// arrives exactly once.
//
// LOCKING, and this is the one asymmetry in the headless-twin family: this
// function does NOT take the per-user lock. performExtraction, takeSiegeBout and
// performBabysitPurchase all take it themselves, because their command framings
// do not hold it — but handleDnDExpeditionCmd holds it across its whole switch,
// so taking it here would wedge advUserLock permanently (it is a plain
// sync.Mutex, and the deferred unlock up there would never run). The web caller
// takes it explicitly instead; see applyAdvOrder.
func (p *AdventurePlugin) performExpeditionStart(uid id.UserID, c *DnDCharacter, zone ZoneDefinition, purchase SupplyPurchase, idemKey string) (expStartOutcome, error) {
if remaining := restingLockoutRemaining(c); remaining > 0 {
return expStartOutcome{}, refuseAdv(errExpStartResting,
"🛌 You're still resting — %s remaining. Pack up after.",
formatRespecDuration(remaining))
}
// Re-resolve availability against the game's own tables rather than trusting
// the caller. The web resolves a zone from an offer list gogobee itself
// pushed, but that snapshot can be minutes old and is not a permission.
if _, ok := resolveZoneInput(string(zone.ID), availableZonesFor(uid, c.Level)); !ok {
if reason := postgameLockReason(string(zone.ID), uid, c.Level); reason != "" {
return expStartOutcome{}, refuseAdv(errExpStartZoneLocked, "%s", reason)
}
return expStartOutcome{}, refuseAdv(errExpStartZoneLocked,
"Unknown zone for your level. Try `!expedition list`.")
}
if err := purchase.Validate(zone.Tier); err != nil {
return expStartOutcome{}, refuseAdv(errExpStartBadPacks,
"Invalid pack selection: %s", err.Error())
}
// Reject if any expedition or zone run already active. This runs before the
// price quote: a player who cannot leave doesn't need to hear what leaving
// would have cost.
//
// The seat check spans `extracting` as well as `active` — a member of an
// extracting party is still seated for the seven-day resume window, and
// letting them outfit a rival expedition double-books them the moment their
// leader types `!resume`.
if seated, _ := seatedExpeditionFor(uid); seated != nil {
z, _ := getZone(seated.ZoneID)
return expStartOutcome{}, refuseAdv(errExpStartBusy,
"You're riding a party expedition in **%s** (Day %d). `!expedition leave` before starting your own.",
z.Display, seated.CurrentDay)
}
if existing, _ := getActiveExpedition(uid); existing != nil {
// A web order that already paid and already started this expedition on an
// earlier tick lands here on the re-offer. Saying "you're already on
// expedition" would be a rejection for the thing the order in fact did, so
// the settled debit is what tells the two apart.
if idemKey != "" && p.euro != nil && p.euro.HasExternalTx(idemKey) && existing.ZoneID == zone.ID {
z, _ := getZone(existing.ZoneID)
return expStartOutcome{Zone: z, Supplies: existing.Supplies,
Cost: purchase.Cost(),
Days: estimateDays(existing.Supplies.Max, existing.Supplies.DailyBurn)}, nil
}
z, _ := getZone(existing.ZoneID)
return expStartOutcome{}, refuseAdv(errExpStartBusy,
"You're already on expedition in **%s** (Day %d). Finish it or `!expedition abandon` first.",
z.Display, existing.CurrentDay)
}
// A leader who extracted still holds their roster for the resume window, and
// `!resume` only ever reaches the *newest* extracted row. Starting fresh on
// top of one would orphan it: unreachable, un-reapable until the sweeper
// catches it, with every member still seated and refused a run of their own.
//
// Only a row with a roster blocks. A solo extraction strands nobody, so
// walking away from it stays a normal thing to do.
if pending, _ := getResumableExpedition(uid); pending != nil {
switch {
case extractionLapsed(pending, time.Now().UTC()):
// Past the window — reap it here rather than make them wait an hour
// for the sweeper, and let the new expedition proceed. Route through
// the shared reap so the freed members hear about it, same as the
// sweeper and `!expedition abandon` do.
if err := p.reapLapsedExtraction(pending); err != nil {
slog.Warn("expedition: reap lapsed on start", "expedition", pending.ID, "err", err)
}
default:
// A roster still holds; block. On a roster-read error, assume it is
// occupied and refuse — proceeding would orphan a party we could not
// confirm was empty, the one outcome this guard exists to prevent. A
// solo extraction (n == 1) strands nobody, so walking away is fine.
n, err := partySize(pending.ID)
if err != nil || n > 1 {
z, _ := getZone(pending.ZoneID)
return expStartOutcome{}, refuseAdv(errExpStartBusy,
"You extracted from **%s** on Day %d and your party is still waiting on you. `!resume` to lead them back in, or `!expedition abandon` to let it go — until you do one or the other, none of them can start a run of their own.",
z.Display, pending.CurrentDay)
}
}
}
cost := float64(purchase.Cost())
if p.euro == nil {
return expStartOutcome{}, refuseAdv(errExpStartFailed, "Coin system unavailable — try again later.")
}
// Skip the affordability gate on a re-offer that already paid: the debit is a
// settled fact and re-reading the now-lower balance would bounce a departure
// the player has bought. Same reasoning as purchaseEquipmentTier's.
if !(idemKey != "" && p.euro.HasExternalTx(idemKey)) {
if balance := p.euro.GetBalance(uid); balance < cost {
return expStartOutcome{}, refuseAdv(errExpStartBroke,
"Not enough coins. Outfitting costs **%d** but you have **%.0f**.",
int(cost), balance)
}
}
if existing, _ := getActiveZoneRun(uid); existing != nil {
z, _ := getZone(existing.ZoneID)
return expStartOutcome{}, refuseAdv(errExpStartBusy,
"You have an active single-session zone run in **%s**. Finish or `!zone abandon` before starting an expedition.",
z.Display)
}
_, supplies, startLine, err := p.beginExpeditionIdem(uid, c.Level, zone, purchase, "expedition outfitting", idemKey)
if err != nil {
// beginExpedition refunds and tears down on every failure path, so the
// player owes nothing and this is permanent rather than retryable — a retry
// after a refund would find the guid-keyed debit already settled and hand
// them the expedition for free.
return expStartOutcome{}, refuseAdv(errExpStartFailed, "%s", err.Error())
}
markActedToday(uid)
return expStartOutcome{
Zone: zone, Supplies: supplies, Cost: purchase.Cost(),
Days: estimateDays(supplies.Max, supplies.DailyBurn), StartLine: startLine,
}, nil
}
// beginExpedition performs the non-interactive half of starting an expedition:
// supply freebies, the coin debit, persistence, the starting region's run, and
// the opening log entry. It refunds and tears down on every failure path, so a
@@ -441,10 +561,38 @@ func (p *AdventurePlugin) expeditionCmdStart(ctx MessageContext, c *DnDCharacter
// It deliberately does NOT call markActedToday — an expedition the player did
// not ask for must not spend their daily action or count as them showing up.
func (p *AdventurePlugin) beginExpedition(uid id.UserID, charLevel int, zone ZoneDefinition, purchase SupplyPurchase, reason string) (*Expedition, ExpeditionSupplies, string, error) {
return p.beginExpeditionIdem(uid, charLevel, zone, purchase, reason, "")
}
// beginExpeditionIdem is beginExpedition with the money keyed to an idempotency
// id. idemKey empty keeps the plain Debit/Credit pair, which is correct for the
// two callers that arrive exactly once (a Matrix command, the boredom ticker).
//
// A non-empty key comes from the web action queue, whose wire retries: the debit
// then lands at most once however many times the order is re-offered, and the
// refunds are keyed too so a torn-down start cannot refund on every tick. Note
// what this means for the caller — once a refund has happened, retrying is
// *unsafe*, because the guid-keyed debit will not charge again and the player
// would get the expedition for free. performExpeditionStart therefore treats
// every error from here as permanent.
func (p *AdventurePlugin) beginExpeditionIdem(uid id.UserID, charLevel int, zone ZoneDefinition, purchase SupplyPurchase, reason, idemKey string) (*Expedition, ExpeditionSupplies, string, error) {
if p.euro == nil {
return nil, ExpeditionSupplies{}, "", fmt.Errorf("Coin system unavailable — try again later.")
}
cost := float64(purchase.Cost())
debit := func(why string) bool { return p.euro.Debit(uid, cost, why) }
refund := func(why, suffix string) { p.euro.Credit(uid, cost, why) }
if idemKey != "" {
debit = func(why string) bool {
ok, _, err := p.euro.DebitIdem(uid, cost, why, idemKey)
return err == nil && ok
}
refund = func(why, suffix string) {
if _, _, err := p.euro.CreditIdem(uid, cost, why, idemKey+":refund"+suffix); err != nil {
slog.Error("expedition: outfitting refund failed", "user", uid, "order", idemKey, "err", err)
}
}
}
// Holiday perk: a complimentary standard pack is added to the supplies
// snapshot without inflating the coin cost. Bypasses the per-tier cap
@@ -459,14 +607,14 @@ func (p *AdventurePlugin) beginExpedition(uid id.UserID, charLevel int, zone Zon
supplies := makeSupplies(zone.Tier, suppliesPurchase)
// Debit coins; bail on debit failure (race / cap).
if !p.euro.Debit(uid, cost, reason+": "+string(zone.ID)) {
if !debit(reason + ": " + string(zone.ID)) {
return nil, ExpeditionSupplies{}, "", fmt.Errorf("Couldn't debit outfitting cost (try again).")
}
exp, err := startExpedition(uid, zone.ID, "", supplies)
if err != nil {
// Refund on persistence failure.
p.euro.Credit(uid, cost, "expedition outfitting refund")
refund("expedition outfitting refund", "")
return nil, ExpeditionSupplies{}, "", fmt.Errorf("Couldn't start expedition: %s", err)
}
@@ -477,7 +625,7 @@ func (p *AdventurePlugin) beginExpedition(uid id.UserID, charLevel int, zone Zon
// Refund and tear the expedition row back down — without a
// linked run, harvest and rooms can't function.
_ = abandonExpedition(uid)
p.euro.Credit(uid, cost, "expedition outfitting refund (run-spawn failed)")
refund("expedition outfitting refund (run-spawn failed)", ":region")
return nil, ExpeditionSupplies{}, "", fmt.Errorf("Couldn't outfit the first region: %s", err)
}
@@ -696,65 +844,102 @@ func formatLogTimestamp(t time.Time) string {
// ── abandon ─────────────────────────────────────────────────────────────────
func (p *AdventurePlugin) expeditionCmdAbandon(ctx MessageContext) error {
exp, isLeader, err := activeExpeditionFor(ctx.Sender)
// Sentinels for the two ways abandoning can be refused, so the web action queue
// can pick a verdict without reading prose. Same contract as the start/resume
// family above: errors.Is classifies, Error() is the sentence Matrix has always
// sent.
var (
errAbandonNothing = errors.New("expedition abandon: nothing to abandon")
errAbandonNotLeader = errors.New("expedition abandon: only the leader may call it")
)
// abandonOutcome is what closing the expedition did, for a caller describing it
// somewhere other than a DM.
type abandonOutcome struct {
Zone ZoneDefinition
Day int
Extracted bool // it was already out and standing in town: loot and XP are kept
}
// performExpeditionAbandon is `!expedition abandon` minus the command framing.
// Shared with the web action queue so closing a run from a phone disbands the
// same roster, retires the same region runs, writes the same log line and tells
// the same party — the members hear it from their leader either way, because
// that is a fact about the expedition and not about which door was used.
//
// Like performExpeditionStart this does NOT take the per-user lock: its Matrix
// caller already holds it across the whole `!expedition` switch. applyWebAbandon
// takes it instead. Getting that backwards does not fail loudly — it wedges the
// player's lock forever and every later adventure command from them hangs.
func (p *AdventurePlugin) performExpeditionAbandon(uid id.UserID) (abandonOutcome, error) {
exp, isLeader, err := activeExpeditionFor(uid)
if err != nil {
return p.SendDM(ctx.Sender, "Couldn't read expedition state: "+err.Error())
return abandonOutcome{}, err
}
if exp == nil {
// An extracted expedition is still the owner's to close — it holds the
// roster until the resume window lapses. Without this, a leader who
// wanted out had to pay to `!resume` first just to abandon.
if exp, err = getResumableExpedition(ctx.Sender); err != nil {
return p.SendDM(ctx.Sender, "Couldn't read expedition state: "+err.Error())
if exp, err = getResumableExpedition(uid); err != nil {
return abandonOutcome{}, err
}
isLeader = exp != nil
}
if exp == nil {
return p.SendDM(ctx.Sender, "No active expedition to abandon.")
return abandonOutcome{}, refuseAdv(errAbandonNothing, "No active expedition to abandon.")
}
if !isLeader {
// Abandoning throws away everyone's day. A member leaves alone.
return p.SendDM(ctx.Sender,
return abandonOutcome{}, refuseAdv(errAbandonNotLeader,
"Only your party leader can abandon the expedition. `!expedition leave` to walk out alone.")
}
zone, _ := getZone(exp.ZoneID)
extracted := exp.Status == ExpeditionStatusExtracting
out := abandonOutcome{Zone: zone, Day: exp.CurrentDay, Extracted: exp.Status == ExpeditionStatusExtracting}
audience := expeditionAudience(exp) // read before abandonExpedition disbands the roster
if err := abandonExpedition(ctx.Sender); err != nil {
return p.SendDM(ctx.Sender, "Couldn't abandon: "+err.Error())
if err := abandonExpedition(uid); err != nil {
return abandonOutcome{}, err
}
markActedToday(ctx.Sender)
markActedToday(uid)
_ = retireAllRegionRuns(exp)
_ = appendExpeditionLog(exp.ID, exp.CurrentDay, "narrative", "expedition abandoned", "")
// The roster is being disbanded out from under the members; they hear it from
// their leader rather than discovering it the next time a command works again.
for _, member := range audience {
if member == uid {
continue
}
if err := p.SendDM(member, fmt.Sprintf(
"Your leader called off the expedition in **%s** on Day %d. You're free to start a run of your own.",
zone.Display, exp.CurrentDay)); err != nil {
slog.Warn("expedition: abandon DM failed", "user", member, "expedition", exp.ID, "err", err)
}
}
// Emergence seam: see maybeRollPetArrivalOnEmerge. Inside the twin because
// walking out of a dungeon is what rolls it, not saying so in a room.
p.maybeRollPetArrivalOnEmerge(uid)
return out, nil
}
func (p *AdventurePlugin) expeditionCmdAbandon(ctx MessageContext) error {
out, err := p.performExpeditionAbandon(ctx.Sender)
if err != nil {
var refusal advRefusal
if errors.As(err, &refusal) {
return p.SendDM(ctx.Sender, refusal.Error())
}
return p.SendDM(ctx.Sender, "Couldn't abandon: "+err.Error())
}
// An extracted party is standing in town, not in the dungeon: their supplies
// are already spent and their loot is already banked. Say the true thing.
body := fmt.Sprintf(
"Expedition in **%s** abandoned on Day %d. Supplies are forfeit. The dungeon remembers.",
zone.Display, exp.CurrentDay)
if extracted {
out.Zone.Display, out.Day)
if out.Extracted {
body = fmt.Sprintf(
"You let the expedition in **%s** go. Day %d is where it ends — loot, XP, and coins are kept. The dungeon remembers.",
zone.Display, exp.CurrentDay)
out.Zone.Display, out.Day)
}
// The roster is being disbanded out from under the members; they hear it from
// their leader rather than discovering it the next time a command works again.
for _, uid := range audience {
if uid == ctx.Sender {
continue
}
if err := p.SendDM(uid, fmt.Sprintf(
"Your leader called off the expedition in **%s** on Day %d. You're free to start a run of your own.",
zone.Display, exp.CurrentDay)); err != nil {
slog.Warn("expedition: abandon DM failed", "user", uid, "expedition", exp.ID, "err", err)
}
}
if err := p.SendDM(ctx.Sender, body); err != nil {
return err
}
// Emergence seam: see maybeRollPetArrivalOnEmerge.
p.maybeRollPetArrivalOnEmerge(ctx.Sender)
return nil
return p.SendDM(ctx.Sender, body)
}
// helper: ensure we don't shadow id.UserID import in test harness.
@@ -843,45 +1028,197 @@ func (p *AdventurePlugin) expeditionCmdRun(ctx MessageContext) error {
// run graph / harvest tally / supplies / threat — same as before, just
// no streamFlow here. compact==true switches the underlying combat
// narration into terse mode and auto-resolves elite (not boss) rooms.
// forkAutoPickTimeout — how long a background fork may sit unanswered
// before the autopilot picks an available route itself. Short enough that
// the expedition keeps moving rather than idling out to the 24h stale-run
// reaper; long enough that a player away for the evening still gets first
// say on a genuine fork.
const forkAutoPickTimeout = 8 * time.Hour
// forkAutoPickTimeout — how long a background fork may sit unanswered before
// the autopilot picks a route itself.
//
// This was 8h, which reads as "the player gets first say" and behaves as "the
// expedition stops for a third of a day, every fork." A multi-day expedition
// crosses a lot of forks; at 8h apiece the autopilot spends more of its life
// parked than walking, and a player who is simply asleep loses a night per
// branch. 30m keeps a genuine first say for anyone actually at the keyboard and
// costs an absent player almost nothing.
const forkAutoPickTimeout = 30 * time.Minute
// autoPickStaleFork commits the first unlocked option of a stale background
// fork, advancing the run to that node exactly as `!zone go <n>` would
// (advanceZoneRunNode + region-transition hook). Returns false — no pick —
// when every option is locked, so the caller re-emits the prompt and the
// run idles on toward the reaper. The choice is logged as a narrative entry
// so the end-of-day digest can surface the decision the player missed.
func (p *AdventurePlugin) autoPickStaleFork(exp *Expedition, run *DungeonRun, pf *pendingFork) bool {
var chosen *pendingChoice
for i := range pf.Options {
if pf.Options[i].Unlocked {
chosen = &pf.Options[i]
break
// rankForkOptions orders a fork's options by how much walking them is worth:
// somewhere new first, then the fatter edge (Weight is the author's own "this
// is the main line" signal), then menu order as the tiebreak so the pick is
// deterministic. Only unlocked options are returned.
//
// The old rule was "first unlocked option in the menu", which is edge-authoring
// order — meaningful to whoever wrote the graph, arbitrary to the player. It
// walked past unvisited branches to loop through cleared ones often enough to
// look broken.
func rankForkOptions(g ZoneGraph, run *DungeonRun, pf *pendingFork) []pendingChoice {
weights := map[string]int{}
for _, e := range g.outgoingEdges(run.CurrentNode) {
weights[e.To] = e.Weight
}
visited := map[string]bool{}
for _, n := range run.VisitedNodes {
visited[n] = true
}
open := make([]pendingChoice, 0, len(pf.Options))
for _, o := range pf.Options {
if o.Unlocked {
open = append(open, o)
}
}
if chosen == nil {
return false // nothing unlocked — leave it for the player / reaper
sort.SliceStable(open, func(i, j int) bool {
vi, vj := visited[open[i].To], visited[open[j].To]
if vi != vj {
return !vi // unvisited first
}
if wi, wj := weights[open[i].To], weights[open[j].To]; wi != wj {
return wi > wj
}
return open[i].Index < open[j].Index
})
return open
}
// autoPickStaleFork commits a stale background fork, advancing the run exactly
// as `!zone go <n>` would (advanceZoneRunNode + region-transition hook). The
// choice is logged as a narrative entry so the end-of-day digest can surface
// the decision the player missed.
//
// When every route is locked it does not give up: it spends a set of thieves'
// tools if the party is carrying any and one of the locks is the pickable kind.
// Returns false only when there is genuinely nothing it can do — the caller
// then backtracks rather than idling the expedition into the 24h reaper.
func (p *AdventurePlugin) autoPickStaleFork(exp *Expedition, run *DungeonRun, pf *pendingFork) bool {
g, _ := loadZoneGraph(run.ZoneID)
ranked := rankForkOptions(g, run, pf)
note := "autopilot took the most promising path"
var spendTool int64
if len(ranked) == 0 {
picked, toolID, ok := p.autoPickWithTools(run, pf)
if !ok {
return false
}
ranked = []pendingChoice{picked}
spendTool = toolID
note = "autopilot spent " + thievesToolsName + " on the only way forward"
}
chosen := ranked[0]
if _, err := advanceZoneRunNode(run.RunID, chosen.To); err != nil {
slog.Warn("expedition: auto-pick stale fork",
"user", run.UserID, "run", run.RunID, "err", err)
return false
}
g, _ := loadZoneGraph(run.ZoneID)
// The door is behind us, so now the set is actually used up. Billing before
// the advance would charge the player for a move that failed — and the
// caller's backtrack would then clear the fork the tools just paid for.
if spendTool != 0 {
if err := removeAdvInventoryItem(spendTool); err != nil {
slog.Warn("expedition: autopilot tools spend", "user", run.UserID, "err", err)
}
beatLock(run, chosen.Label, "picked")
}
fireGraphRegionTransition(run.UserID, g.Nodes[run.CurrentNode], g.Nodes[chosen.To])
if exp != nil {
_ = appendExpeditionLog(exp.ID, exp.CurrentDay, "narrative",
fmt.Sprintf("autopilot took an available path after %dh idle at the fork: %s",
int(forkAutoPickTimeout.Hours()), chosen.Label), "")
fmt.Sprintf("%s: %s", note, chosen.Label), "")
}
return true
}
// autoPickWithTools finds a route a set of thieves' tools could open when every
// option on the fork is locked, so a bad Perception roll can't quietly end an
// expedition the player paid days into. It only ever fires when there is no free
// route left — the player's tools are their own, and the autopilot does not get
// to burn them for convenience.
//
// It reports the route and the inventory row to spend, but does not spend it:
// the caller charges the player only once the move has actually committed.
func (p *AdventurePlugin) autoPickWithTools(run *DungeonRun, pf *pendingFork) (pendingChoice, int64, bool) {
toolID, ok := findThievesTools(id.UserID(run.UserID))
if !ok {
return pendingChoice{}, 0, false
}
for i := range pf.Options {
if pf.Options[i].Unlocked || !pickableLock(pf.Options[i].Lock) {
continue
}
// Local copy only — advanceZoneRunNode clears node_choices on success,
// and on failure the fork must stay as locked as the player left it
// rather than reading "open" for a set nobody paid for.
chosen := pf.Options[i]
chosen.Unlocked = true
chosen.Reason = "opened with " + thievesToolsName
return chosen, toolID, true
}
return pendingChoice{}, 0, false
}
// backtrackFromDeadFork walks the run back one room when a fork has no route
// the autopilot can take and no tools to buy one with. Without this the run
// simply sits there until the 24h stale reaper ends the expedition — a player
// losing days of progress to a die roll they never saw and could not answer.
// Backtracking at least returns them to a room with other exits.
//
// Returns false at the entry node, where there is nowhere behind to go, and
// wherever no fallback room would actually help — see backtrackTarget.
func (p *AdventurePlugin) backtrackFromDeadFork(exp *Expedition, run *DungeonRun) bool {
g, ok := loadZoneGraph(run.ZoneID)
if !ok {
return false
}
target, ok := backtrackTarget(g, run)
if !ok {
return false
}
// Clear the fork first: it belongs to the node being left, and both
// `!zone advance` and `!zone go` would otherwise resolve a prompt pointing
// at a room the party is no longer standing in.
if err := clearPendingFork(run.RunID); err != nil {
slog.Warn("expedition: backtrack clear fork", "run", run.RunID, "err", err)
return false
}
beatLock(run, "", "sealed")
if _, err := revisitZoneRun(run.RunID, target, run.VisitedNodes); err != nil {
slog.Warn("expedition: backtrack from dead fork", "run", run.RunID, "err", err)
return false
}
if exp != nil {
_ = appendExpeditionLog(exp.ID, exp.CurrentDay, "narrative",
"every way on was sealed — the party doubled back", "")
}
return true
}
// backtrackTarget picks the room a dead fork falls back to: the most recently
// entered visited node that is genuinely joined to the current one by an edge
// and that still offers a way on other than the sealed room.
//
// Both halves are load-bearing. VisitedNodes is a first-entry ordered *set*, not
// a path stack (see appendVisited) — after any earlier backtrack the entry
// before CurrentNode can sit on a completely different branch, so stepping to it
// blind teleports the party across the map. `!revisit` refuses exactly that move
// via adjacentNodes, and the autopilot has no business doing what the player is
// forbidden from doing. The second half stops the other failure: falling back
// into a corridor whose only exit is the fork we just fled from just walks
// straight back in — and the lock rolls are seeded per (run, edge), so the
// result is identical every time. That is an infinite loop, not a recovery.
func backtrackTarget(g ZoneGraph, run *DungeonRun) (string, bool) {
adj := adjacentNodes(g, run.CurrentNode)
for i := pathIndexOf(run.VisitedNodes, run.CurrentNode) - 1; i >= 0; i-- {
n := run.VisitedNodes[i]
if !adj[n] {
continue
}
for _, e := range g.outgoingEdges(n) {
if e.To != run.CurrentNode {
return n, true
}
}
}
return "", false
}
func (p *AdventurePlugin) runAutopilotWalk(ctx MessageContext, maxRooms int, compact, inlineBossCombat bool) autopilotWalkResult {
exp, err := getActiveExpedition(ctx.Sender)
if err != nil {
@@ -903,9 +1240,19 @@ func (p *AdventurePlugin) runAutopilotWalk(ctx MessageContext, maxRooms int, com
// (unlocked) route and keep walking instead of stalling out.
if run, rerr := getActiveZoneRun(ctx.Sender); rerr == nil && run != nil {
if pf, derr := decodePendingFork(run.NodeChoices); derr == nil && pf != nil {
picked := compact &&
time.Since(run.LastActionAt) > forkAutoPickTimeout &&
p.autoPickStaleFork(exp, run, pf)
stale := compact && time.Since(run.LastActionAt) > forkAutoPickTimeout
picked := stale && p.autoPickStaleFork(exp, run, pf)
// Stale and nothing takeable: every route locked, no tools. Back out
// one room rather than sitting here until the 24h reaper ends an
// expedition the player may be days into. The backtrack clears the
// fork, so the next tick walks from the previous room normally.
if stale && !picked && p.backtrackFromDeadFork(exp, run) {
return autopilotWalkResult{
finalMsg: "🔒 Every way on was sealed. The party doubled back to look for another line.",
rooms: 0,
reason: stopFork,
}
}
if !picked {
zone := zoneOrFallback(run.ZoneID)
return autopilotWalkResult{
internal/plugin/dnd_expedition_combat.go
+3 -4
View File
@@ -23,7 +23,6 @@ package plugin
import (
"encoding/json"
"fmt"
"math/rand/v2"
"strings"
"gogobee/internal/flavor"
@@ -75,7 +74,7 @@ func resolveCombatInterrupt(
rollFn func() int,
) (CombatInterruptKind, int) {
if rollFn == nil {
rollFn = func() int { return rand.IntN(20) + 1 }
rollFn = func() int { return simIntN(20) + 1 }
}
r := rollFn()
mod := tier
@@ -249,7 +248,7 @@ func surpriseRoundNickF(m DnDMonsterTemplate, tier, floorOverride int) int {
if tier < 1 {
tier = 1
}
dmg := 1 + rand.IntN(4) + m.AttackBonus/2
dmg := 1 + simIntN(4) + m.AttackBonus/2
floor := tier
if floorOverride >= 0 {
floor = floorOverride
@@ -484,7 +483,7 @@ func (p *AdventurePlugin) tryPatrolEncounter(
return
}
chance := rollPatrolChance(exp.ThreatLevel)
if chance <= 0 || rand.Float64() > chance {
if chance <= 0 || simFloat64() > chance {
return
}
monster, ok := pickZoneEnemy(zone, run.RunID, run.CurrentRoom, false)
internal/plugin/dnd_expedition_cycle.go
+36 -13
View File
@@ -350,6 +350,12 @@ func scanExpeditionRows(rows *sql.Rows) ([]*Expedition, error) {
// A double-fire on the same expedition is a no-op.
func (p *AdventurePlugin) deliverBriefing(e *Expedition, now time.Time) error {
priorBriefing := e.LastBriefingAt
// Everything logged since the previous briefing is what the overnight
// digest reports. Captured before the CAS below clobbers the column.
digestSince := e.StartDate
if priorBriefing != nil {
digestSince = *priorBriefing
}
threshold := time.Date(now.Year(), now.Month(), now.Day(),
expeditionBriefingHour, 0, 0, 0, time.UTC)
res, err := db.Get().Exec(`
@@ -373,7 +379,7 @@ func (p *AdventurePlugin) deliverBriefing(e *Expedition, now time.Time) error {
// DM (rollover happened recently) or force-fires processNightCamp
// itself (safety net for stalled autopilots).
if isEventAnchored(e) {
return p.deliverBriefingEventAnchored(e, priorBriefing)
return p.deliverBriefingEventAnchored(e, priorBriefing, digestSince)
}
burn, err := p.nightRolloverBurn(e)
@@ -400,6 +406,9 @@ func (p *AdventurePlugin) deliverBriefing(e *Expedition, now time.Time) error {
line := pickMorningBriefing(e.CurrentDay)
body := renderMorningBriefing(e, line, burn)
// The single daily message: fold in what the now-silent recap, night
// check and ambient events recorded since the last briefing.
body = appendOvernightDigest(body, e.ID, digestSince)
if sl := p.shadowBriefingLine(e); sl != "" {
body += "\n" + sl + "\n"
}
@@ -413,7 +422,13 @@ func (p *AdventurePlugin) deliverBriefing(e *Expedition, now time.Time) error {
body += "\n" + ml
}
p.fanOutExpeditionDM(e, body, p.briefingPetPrefix)
p.fanOutExpeditionDM(e, body, p.briefingPerReader)
// N1/A6 anchor, relocated here from the retired night-camp digest DM.
// Only on a run still under way: an expedition that just ended does not
// want a mid-day event landing on top of the emergence.
if e.Status == ExpeditionStatusActive {
p.fireDigestEventAnchor(e)
}
// Emergence seam: a briefing-time forced extraction (starvation / abyss
// collapse) surfaces the players alive — roll pet arrival. Combat/patrol
// deaths never reach deliverBriefing (the row is already abandoned), so an
@@ -489,7 +504,9 @@ func (p *AdventurePlugin) maybeDeliverDeferredBriefing(uid id.UserID, now time.T
//
// priorBriefing is the last_briefing_at value as of entry into deliverBriefing
// (before the CAS clobbered it). nil means day-1 or genuinely never rolled.
func (p *AdventurePlugin) deliverBriefingEventAnchored(e *Expedition, priorBriefing *time.Time) error {
// digestSince is the same instant collapsed to a non-nil cutoff (start date on
// day 1) — the window the overnight digest reports.
func (p *AdventurePlugin) deliverBriefingEventAnchored(e *Expedition, priorBriefing *time.Time, digestSince time.Time) error {
now := time.Now().UTC()
var since time.Duration
if priorBriefing != nil {
@@ -516,6 +533,7 @@ func (p *AdventurePlugin) deliverBriefingEventAnchored(e *Expedition, priorBrief
line := pickMorningBriefing(e.CurrentDay)
body := renderMorningBriefing(e, line, burn)
body = appendOvernightDigest(body, e.ID, digestSince)
if sl := p.shadowBriefingLine(e); sl != "" {
body += "\n" + sl + "\n"
}
@@ -529,7 +547,13 @@ func (p *AdventurePlugin) deliverBriefingEventAnchored(e *Expedition, priorBrief
body += "\n" + ml
}
p.fanOutExpeditionDM(e, body, p.briefingPetPrefix)
p.fanOutExpeditionDM(e, body, p.briefingPerReader)
// N1/A6 anchor, relocated here from the retired night-camp digest DM.
// Only on a run still under way: an expedition that just ended does not
// want a mid-day event landing on top of the emergence.
if e.Status == ExpeditionStatusActive {
p.fireDigestEventAnchor(e)
}
if forced && e.Status == ExpeditionStatusAbandoned {
for _, uid := range expeditionAudience(e) {
p.maybeRollPetArrivalOnEmerge(uid)
@@ -566,9 +590,10 @@ func (p *AdventurePlugin) deliverRecap(e *Expedition, now time.Time) error {
return nil
}
// E2b: night phase wandering check fires before the recap so its
// outcome is part of today's log when the recap renders.
var night *NightCheck
// E2b: night phase wandering check. Still fires on the 21:00 clock and
// still writes its own "night" log entry — processNightCheck owns that —
// which is how the outcome reaches the next morning's digest now that
// the recap itself no longer sends anything.
if e.Camp != nil && e.Camp.Active {
c, _ := LoadDnDCharacter(id.UserID(e.UserID))
var charClass DnDClass
@@ -579,7 +604,6 @@ func (p *AdventurePlugin) deliverRecap(e *Expedition, now time.Time) error {
if err := processNightCheck(e, nc); err != nil {
slog.Warn("expedition: night check", "expedition", e.ID, "err", err)
}
night = &nc
// §7.4: Feywild double-day fires an extra wandering check.
if e.ZoneID == ZoneFeywildCrossing {
if today, _ := e.RegionState["feywild_today"].(string); today == string(FeywildDistortionDouble) {
@@ -601,12 +625,11 @@ func (p *AdventurePlugin) deliverRecap(e *Expedition, now time.Time) error {
return err
}
line := pickEveningRecap(e, dayEntries)
body := renderEveningRecap(e, line, dayEntries)
if night != nil {
body += "\n" + renderNightCheck(*night)
}
p.fanOutExpeditionDM(e, body, nil)
// Once-a-day cadence: the night check above has already run and already
// written its own "night" log entry, so the morning digest reports the
// outcome. Nothing is sent here. The recap entry below still lands so
// the site keeps a day boundary to render against.
if err := appendExpeditionLog(e.ID, e.CurrentDay, "recap",
fmt.Sprintf("evening recap — %d log entries today", len(dayEntries)), line); err != nil {
return err
internal/plugin/dnd_expedition_extract.go
+171 -51
View File
@@ -352,32 +352,54 @@ func resumeExpedition(expID string, supplies ExpeditionSupplies) error {
// ── !extract command ────────────────────────────────────────────────────────
func (p *AdventurePlugin) handleExtractCmd(ctx MessageContext, _ string) error {
userMu := p.advUserLock(ctx.Sender)
// Sentinels for the two ways an extraction can be refused. They exist so the
// headless caller (the web action queue, pete_orders.go) can turn a refusal into
// its own verdict without parsing a DM. `!extract` maps them straight back to the
// prose it always sent.
var (
errExtractNoRun = errors.New("extract: no active expedition")
errExtractNotLeader = errors.New("extract: not the party leader")
)
// extractOutcome is what an extraction did, for a caller that has to describe it
// somewhere other than a DM.
type extractOutcome struct {
Zone string // display name
Day int
}
// performExtraction is the whole of `!extract` minus the command framing: the
// per-user lock, the leader check, the state flip, the log line, the party
// fan-out and the emergence pet roll. It is shared with the web action queue so
// that pulling out from a phone is the *same* extraction, not a second
// implementation of one — the party still gets DM'd, the log still gets its
// line, and the resume window is the same window.
func (p *AdventurePlugin) performExtraction(uid id.UserID) (extractOutcome, error) {
userMu := p.advUserLock(uid)
userMu.Lock()
defer userMu.Unlock()
exp, isLeader, err := activeExpeditionFor(ctx.Sender)
exp, isLeader, err := activeExpeditionFor(uid)
if err != nil {
return p.SendDM(ctx.Sender, "Couldn't read expedition state: "+err.Error())
return extractOutcome{}, fmt.Errorf("reading expedition state: %w", err)
}
if exp == nil {
return p.SendDM(ctx.Sender, "No active expedition to extract from.")
return extractOutcome{}, errExtractNoRun
}
if !isLeader {
// Extraction ends the expedition for the whole roster, so it is the
// leader's call — the same reasoning that makes `!flee` leader-only.
return p.SendDM(ctx.Sender, "Only your party leader can call the extraction. Ask them to `!extract`, or `!expedition leave` to walk out alone.")
return extractOutcome{}, errExtractNotLeader
}
zone, _ := getZone(exp.ZoneID)
updated, err := voluntaryExtractExpedition(ctx.Sender)
updated, err := voluntaryExtractExpedition(uid)
if err != nil {
return p.SendDM(ctx.Sender, "Couldn't extract: "+err.Error())
return extractOutcome{}, err
}
line := flavor.Pick(flavor.ExtractionVoluntary)
_ = appendExpeditionLog(updated.ID, updated.CurrentDay, "narrative",
"voluntary extraction", line)
markActedToday(ctx.Sender)
markActedToday(uid)
var b strings.Builder
b.WriteString(fmt.Sprintf("🚪 **Extraction — %s, Day %d**\n\n",
@@ -401,84 +423,167 @@ func (p *AdventurePlugin) handleExtractCmd(ctx MessageContext, _ string) error {
// Emergence seam: surfacing from a run is when an animal may have moved
// into the empty house. Every member surfaced, so every member rolls.
for _, uid := range expeditionAudience(updated) {
p.maybeRollPetArrivalOnEmerge(uid)
for _, member := range expeditionAudience(updated) {
p.maybeRollPetArrivalOnEmerge(member)
}
return extractOutcome{Zone: zone.Display, Day: updated.CurrentDay}, nil
}
// handleExtractCmd is `!extract`: the command framing around performExtraction.
// The extraction itself, including the DM everyone in the party gets, happens in
// there — so this only has to turn a refusal back into the prose it always sent.
func (p *AdventurePlugin) handleExtractCmd(ctx MessageContext, _ string) error {
_, err := p.performExtraction(ctx.Sender)
switch {
case errors.Is(err, errExtractNoRun):
return p.SendDM(ctx.Sender, "No active expedition to extract from.")
case errors.Is(err, errExtractNotLeader):
return p.SendDM(ctx.Sender, "Only your party leader can call the extraction. Ask them to `!extract`, or `!expedition leave` to walk out alone.")
case err != nil:
return p.SendDM(ctx.Sender, "Couldn't extract: "+err.Error())
}
return nil
}
// ── !resume command ─────────────────────────────────────────────────────────
func (p *AdventurePlugin) handleResumeCmd(ctx MessageContext, args string) error {
userMu := p.advUserLock(ctx.Sender)
// Sentinels for the ways going back in can be refused. Same contract as
// performExpeditionStart's: each one comes back inside an advRefusal that also
// carries the finished sentence, so `!resume` keeps its copy verbatim.
//
// errResumeNeedLoadout is the odd one out and deliberately so: it is not a
// refusal at all but the loadout prompt, returned as one so the whole decision
// stays inside the lock. The web never triggers it — it always names a loadout.
var (
errResumeNeedLoadout = errors.New("resume: no loadout named")
errResumeBusy = errors.New("resume: already on an expedition")
errResumeNothing = errors.New("resume: no extracted expedition")
errResumeLapsed = errors.New("resume: past the 7-day window")
errResumeBadPacks = errors.New("resume: invalid pack selection")
errResumeBroke = errors.New("resume: cannot cover outfitting")
errResumeFailed = errors.New("resume: could not resume")
)
// resumeOutcome is what going back in did, for a caller describing it somewhere
// other than a DM.
type resumeOutcome struct {
Zone ZoneDefinition
Day int
Supplies ExpeditionSupplies
Purchase SupplyPurchase
Threat int
Stack int
Line string
}
// performResume is `!resume` minus the command framing: the leader check, the
// lapse check, the re-outfitting purchase and the fresh region run. Shared with
// the web action queue so that walking back in from a phone is the same walk.
//
// loadoutTok is the raw `Ns Md` / preset token; empty asks for the prompt.
// idemKey, when set, is the web order's guid and moves the money onto the
// idempotent variants — see beginExpeditionIdem for why a refund then makes a
// retry unsafe, which is why every error here is permanent for the web caller.
func (p *AdventurePlugin) performResume(uid id.UserID, loadoutTok, idemKey string) (resumeOutcome, error) {
userMu := p.advUserLock(uid)
userMu.Lock()
defer userMu.Unlock()
c, err := LoadDnDCharacter(ctx.Sender)
c, err := LoadDnDCharacter(uid)
if err != nil {
return p.SendDM(ctx.Sender, "Couldn't load your character: "+err.Error())
return resumeOutcome{}, fmt.Errorf("Couldn't load your character: %s", err)
}
if c == nil || c.PendingSetup {
return p.SendDM(ctx.Sender, "No Adv 2.0 character yet — run `!setup` first.")
return resumeOutcome{}, refuseAdv(errResumeNothing, "No Adv 2.0 character yet — run `!setup` first.")
}
if existing, isLeader, _ := activeExpeditionFor(ctx.Sender); existing != nil {
if existing, isLeader, _ := activeExpeditionFor(uid); existing != nil {
zone, _ := getZone(existing.ZoneID)
if !isLeader {
return p.SendDM(ctx.Sender, fmt.Sprintf(
return resumeOutcome{}, refuseAdv(errResumeBusy,
"You're riding a party expedition in **%s** (Day %d). Only its leader can `!resume`.",
zone.Display, existing.CurrentDay))
zone.Display, existing.CurrentDay)
}
return p.SendDM(ctx.Sender, fmt.Sprintf(
// A web order that already paid and already resumed lands here on the
// re-offer; the settled debit is what tells that apart from a player who
// really is already out. Same tell as performExpeditionStart's.
if idemKey != "" && p.euro != nil && p.euro.HasExternalTx(idemKey) {
out := resumeOutcome{Zone: zone, Day: existing.CurrentDay,
Supplies: existing.Supplies, Threat: existing.ThreatLevel}
// Re-price the same loadout at the same tier so the verdict this feeds
// can still say what it cost. Leaving Purchase zero would file a
// "re-outfitted for 0 coins" receipt for a trip that was paid for.
if pp, perr := resolveLoadoutOrParse(strings.TrimSpace(loadoutTok), zone.Tier); perr == nil {
out.Purchase = pp
}
return out, nil
}
return resumeOutcome{}, refuseAdv(errResumeBusy,
"You already have an active expedition in **%s** (Day %d). Finish it or `!expedition abandon` first.",
zone.Display, existing.CurrentDay))
zone.Display, existing.CurrentDay)
}
exp, err := getResumableExpedition(ctx.Sender)
exp, err := getResumableExpedition(uid)
if err != nil {
return p.SendDM(ctx.Sender, "Couldn't read expedition state: "+err.Error())
return resumeOutcome{}, fmt.Errorf("Couldn't read expedition state: %s", err)
}
if exp == nil {
return p.SendDM(ctx.Sender, "No extracted expedition to resume. Use `!expedition start <zone>` to begin a new one.")
return resumeOutcome{}, refuseAdv(errResumeNothing,
"No extracted expedition to resume. Use `!expedition start <zone>` to begin a new one.")
}
if extractionLapsed(exp, time.Now().UTC()) {
// Expire it so it doesn't keep resurfacing. The hourly sweeper would get
// here on its own; this keeps the refusal and the reap in one breath.
_ = completeExpedition(exp.ID, ExpeditionStatusFailed)
return p.SendDM(ctx.Sender,
return resumeOutcome{}, refuseAdv(errResumeLapsed,
"That extraction is past its 7-day resume window — the dungeon has reshaped without you. Start a new expedition.")
}
resumeZone, _ := getZone(exp.ZoneID)
zone, _ := getZone(exp.ZoneID)
// D5-b: prompt for a preset loadout on empty args.
if strings.TrimSpace(args) == "" {
return p.SendDM(ctx.Sender, renderLoadoutPrompt(resumeZone, "resume"))
if strings.TrimSpace(loadoutTok) == "" {
return resumeOutcome{}, refuseAdv(errResumeNeedLoadout, "%s", renderLoadoutPrompt(zone, "resume"))
}
purchase, err := resolveLoadoutOrParse(strings.TrimSpace(args), resumeZone.Tier)
purchase, err := resolveLoadoutOrParse(strings.TrimSpace(loadoutTok), zone.Tier)
if err != nil {
return p.SendDM(ctx.Sender, "Couldn't parse supply packs: "+err.Error())
return resumeOutcome{}, refuseAdv(errResumeBadPacks, "Couldn't parse supply packs: %s", err.Error())
}
if err := purchase.Validate(resumeZone.Tier); err != nil {
return p.SendDM(ctx.Sender, "Invalid pack selection: "+err.Error())
if err := purchase.Validate(zone.Tier); err != nil {
return resumeOutcome{}, refuseAdv(errResumeBadPacks, "Invalid pack selection: %s", err.Error())
}
cost := float64(purchase.Cost())
if p.euro == nil {
return p.SendDM(ctx.Sender, "Coin system unavailable — try again later.")
return resumeOutcome{}, refuseAdv(errResumeFailed, "Coin system unavailable — try again later.")
}
if balance := p.euro.GetBalance(ctx.Sender); balance < cost {
return p.SendDM(ctx.Sender, fmt.Sprintf(
"Not enough coins. Outfitting costs **%d** but you have **%.0f**.",
int(cost), balance))
paid := idemKey != "" && p.euro.HasExternalTx(idemKey)
if !paid {
if balance := p.euro.GetBalance(uid); balance < cost {
return resumeOutcome{}, refuseAdv(errResumeBroke,
"Not enough coins. Outfitting costs **%d** but you have **%.0f**.",
int(cost), balance)
}
}
if !p.euro.Debit(ctx.Sender, cost, "expedition resume outfitting: "+string(exp.ZoneID)) {
return p.SendDM(ctx.Sender, "Couldn't debit outfitting cost (try again).")
debit := func(why string) bool { return p.euro.Debit(uid, cost, why) }
refund := func(why, suffix string) { p.euro.Credit(uid, cost, why) }
if idemKey != "" {
debit = func(why string) bool {
ok, _, err := p.euro.DebitIdem(uid, cost, why, idemKey)
return err == nil && ok
}
refund = func(why, suffix string) {
if _, _, err := p.euro.CreditIdem(uid, cost, why, idemKey+":refund"+suffix); err != nil {
slog.Error("expedition: resume refund failed", "user", uid, "order", idemKey, "err", err)
}
}
}
if !debit("expedition resume outfitting: " + string(exp.ZoneID)) {
return resumeOutcome{}, refuseAdv(errResumeFailed, "Couldn't debit outfitting cost (try again).")
}
zone, _ := getZone(exp.ZoneID)
supplies := makeSupplies(zone.Tier, purchase)
if err := resumeExpedition(exp.ID, supplies); err != nil {
p.euro.Credit(ctx.Sender, cost, "expedition resume refund")
return p.SendDM(ctx.Sender, "Couldn't resume: "+err.Error())
refund("expedition resume refund", "")
return resumeOutcome{}, refuseAdv(errResumeFailed, "Couldn't resume: %s", err.Error())
}
exp.Status = ExpeditionStatusActive
exp.Supplies = supplies
@@ -489,25 +594,40 @@ func (p *AdventurePlugin) handleResumeCmd(ctx MessageContext, args string) error
exp.RegionState[regionStateRegionRuns] = map[string]string{}
_ = persistRegionState(exp)
if _, err := ensureRegionRun(exp, c.Level); err != nil {
p.euro.Credit(ctx.Sender, cost, "expedition resume refund (run-spawn failed)")
return p.SendDM(ctx.Sender, "Couldn't outfit the resumed region: "+err.Error())
refund("expedition resume refund (run-spawn failed)", ":region")
return resumeOutcome{}, refuseAdv(errResumeFailed, "Couldn't outfit the resumed region: %s", err.Error())
}
line := flavor.Pick(flavor.ExpeditionResume)
_ = appendExpeditionLog(exp.ID, exp.CurrentDay, "narrative",
"expedition resumed", line)
return resumeOutcome{
Zone: zone, Day: exp.CurrentDay, Supplies: supplies, Purchase: purchase,
Threat: exp.ThreatLevel, Stack: exp.TemporalStack, Line: line,
}, nil
}
// handleResumeCmd is `!resume`: the command framing around performResume.
func (p *AdventurePlugin) handleResumeCmd(ctx MessageContext, args string) error {
out, err := p.performResume(ctx.Sender, args, "")
if err != nil {
// Every refusal — and the loadout prompt, which travels as one — arrives
// as a finished sentence, so this only has to say it.
return p.SendDM(ctx.Sender, err.Error())
}
var b strings.Builder
b.WriteString(fmt.Sprintf("🚪 **Expedition resumed — %s, Day %d**\n\n",
zone.Display, exp.CurrentDay))
if line != "" {
b.WriteString(line)
out.Zone.Display, out.Day))
if out.Line != "" {
b.WriteString(out.Line)
b.WriteString("\n\n")
}
b.WriteString(fmt.Sprintf("**Re-outfitted:** %.0f SU (%d standard, %d deluxe) — %d coins\n",
supplies.Max, purchase.StandardPacks, purchase.DeluxePacks, purchase.Cost()))
b.WriteString(fmt.Sprintf("**Threat:** %d / 100 (resumed at extraction value)\n", exp.ThreatLevel))
if exp.TemporalStack != 0 {
b.WriteString(fmt.Sprintf("**Zone stack:** %d (resumed)\n", exp.TemporalStack))
out.Supplies.Max, out.Purchase.StandardPacks, out.Purchase.DeluxePacks, out.Purchase.Cost()))
b.WriteString(fmt.Sprintf("**Threat:** %d / 100 (resumed at extraction value)\n", out.Threat))
if out.Stack != 0 {
b.WriteString(fmt.Sprintf("**Zone stack:** %d (resumed)\n", out.Stack))
}
b.WriteString("\nUse `!expedition status` for the daily briefing.")
return p.SendDM(ctx.Sender, b.String())
internal/plugin/dnd_expedition_extract_test.go
+25
View File
@@ -175,3 +175,28 @@ func TestResume_WindowExpired(t *testing.T) {
time.Since(*got.CompletedAt), extractResumeWindow)
}
}
// `!expedition extract` and `!expedition resume` are aliases for two top-level
// commands that take the per-user lock themselves. If the alias dispatcher takes
// that lock first the handler blocks on it forever and, because the deferred
// unlock never runs, every later adventure command from that player wedges too.
// This does not fail on regression — it hangs — so the timeout is the assertion.
func TestExpeditionAliasesDoNotWedgeTheUserLock(t *testing.T) {
setupEmptyTestDB(t)
uid := id.UserID("@exp-alias-lock:example")
t.Cleanup(func() { cleanupExpeditions(uid) })
for _, sub := range []string{"extract", "resume"} {
done := make(chan struct{})
go func() {
defer close(done)
p := &AdventurePlugin{euro: &EuroPlugin{}}
_ = p.handleDnDExpeditionCmd(MessageContext{Sender: uid}, sub)
}()
select {
case <-done:
case <-time.After(10 * time.Second):
t.Fatalf("!expedition %s never returned: the alias re-took advUserLock", sub)
}
}
}
internal/plugin/dnd_expedition_region_cmd.go
+7
View File
@@ -170,6 +170,13 @@ func (p *AdventurePlugin) advanceToNextRegion(userID id.UserID, exp *Expedition,
tc := resolveTransitWanderingCheck(exp, charClass, nil)
_ = processTransitWanderingCheck(exp, tc)
// The liveblog beat goes on the *outgoing* run, and it has to be filed before
// the run is retired — a region crossing is the last thing that happens in
// the region being left, and it is what explains why that run's log stops.
if outgoing, _ := getZoneRun(exp.RunID); outgoing != nil {
beatRegion(outgoing, cur.Name, next.Name)
}
// R2 — retire the outgoing region's DungeonRun before mutating
// CurrentRegion so retireRegionRun keys the right region.
if err := retireRegionRun(exp, cur.ID); err != nil {
internal/plugin/dnd_passives.go
+79 -6
View File
@@ -112,6 +112,56 @@ func applyRacePassives(stats *CombatStats, mods *CombatModifiers, c *DnDCharacte
// AutoCritFirst is already a one-shot bool.
// - A Cleric carrying a healing potion stacks: passive 5 + potion 8 = 13.
// The passive heal triggers first since both use the same threshold.
// cantripDice is the 5e at-will cantrip die progression (Fire Bolt / Eldritch
// Blast): 1 die L1–4, 2 at L5, 3 at L11, 4 at L17. Drives the per-round arcane
// blaster damage (CantripPerRound) that models a caster's sustained at-will
// floor — see CombatModifiers.CantripPerRound.
func cantripDice(level int) int {
switch {
case level >= 17:
return 4
case level >= 11:
return 3
case level >= 5:
return 2
default:
return 1
}
}
// casterBlasterFloor gives the arcane blasters (Mage/Sorcerer/Warlock) their
// shared sustained-DPS floor at T5. Two knobs, both LEVEL-SCALED so the L20
// floor lift stays negligible at low tiers — a flat +40 HP doubled a L1 mage
// and facerolled T5, which the class-balance guardrail (dnd_class_balance_test)
// correctly rejected.
//
// - Cantrip: kill-speed is the T5 currency (fights are truncation-bound), so
// the primary lever is damage. Multiplicative form — the spell modifier
// (INT for Mage, CHA for Sorcerer/Warlock) rides EVERY die, matching 5e
// Agonizing Blast. cantripDice scales 1→4 across levels.
// - Survival: just enough Defense (scaled by level) that the caster lives long
// enough for the cantrip to connect the kill — NOT a tank rider. This adds
// Defense only (no HP add); calcDamage's diminishing returns keep the L20
// +20 Def from becoming a wall.
//
// casterCantripBase / casterDefPerLevel are the caster tuning dials; see the
// rebaseline plan for the sweep that set them. The cantrip floor only becomes a
// live lever once combat_cmd.go bridges CantripPerRound into the turn engine
// (the swing engine, combat_engine.go:590, is not the auto-resolve path). Mage
// and Sorcerer take casterCantripBase; Warlock passes 0 — its bare-dice cantrip
// plus its structural edge already lands it mid-band, so an added floor would
// overshoot the 45 ceiling.
const (
casterCantripBase = 3 // per-die base before the ability modifier rides in
casterDefPerLevel = 1 // ~+20 Def at L20, +1 at L1
)
func casterBlasterFloor(stats *CombatStats, mods *CombatModifiers, level, abilityMod, base int, cantrip string) {
mods.CantripPerRound = cantripDice(level) * (base + clampNonNeg(abilityMod))
mods.CantripDesc = cantrip
stats.Defense += casterDefPerLevel * level
}
func applyClassPassives(stats *CombatStats, mods *CombatModifiers, c *DnDCharacter) {
switch c.Class {
case ClassFighter:
@@ -127,18 +177,23 @@ func applyClassPassives(stats *CombatStats, mods *CombatModifiers, c *DnDCharact
// re-tune in a follow-up if their win curves drift after this.
switch {
case c.Level >= 20:
mods.ExtraAttacks += 3
mods.ExtraAttacks += 2 // rebaseline: ceiling nerf — 3 swings at L20, was 4 (the engine-ceiling faceroll)
case c.Level >= 11:
mods.ExtraAttacks += 2
case c.Level >= 5:
mods.ExtraAttacks += 1
}
stats.AttackBonus -= 2 // rebaseline: sub-swing to-hit trim — 3 swings lands the Fighter in the ~60 band
case ClassRogue:
mods.AutoCritFirst = true
if c.Level >= 5 { // rebaseline: 2nd swing (was 1) fixes the 1-swing action-economy floor at T5
mods.ExtraAttacks += 1
}
stats.AttackBonus -= 3 // rebaseline: to-hit trim so the 2nd swing lands the Rogue in band, not the +75pp nuke
// Phase 2 class-balance: rogue's once-per-fight auto-crit goes stale
// at high tiers (T5 mean trails leaders by ~10pp pre-tune). Add a
// modest steady-DPS rider so post-opener rounds aren't pure attrition.
mods.DamageBonus += 0.05
mods.DamageBonus += -0.10 // rebaseline: fine-trim the 2-swing Rogue down into the ~60 band
// Class-identity audit (2026-05-16) — actual Sneak Attack as Nd6
// per hit, scaling with level per 5e (1d6 L1-2 ... 10d6 L19-20).
// AutoCritFirst + DamageBonus alone left the rogue's defining
@@ -154,6 +209,8 @@ func applyClassPassives(stats *CombatStats, mods *CombatModifiers, c *DnDCharact
mods.SneakAttackDie += sneakDice
case ClassMage:
stats.AttackBonus++
// At-will Fire Bolt + level-scaled survival — the sustained arcane floor.
casterBlasterFloor(stats, mods, c.Level, abilityModifier(c.INT), casterCantripBase, "Fire Bolt")
// Phase 2 class-balance: +1 attack alone left Mage mid-pack on damage
// per round. A modest damage rider lifts weapon hits (DamageBonus does
// not multiply queued SpellPreDamage — that path is its own field).
@@ -190,10 +247,19 @@ func applyClassPassives(stats *CombatStats, mods *CombatModifiers, c *DnDCharact
mods.ExtraAttacks += 1
}
case ClassDruid:
// Wild Resilience — multiplicative, so it stacks cleanly with the
// subclass DamageReduct riders. DamageReduct is initialized to 1.0
// by DerivePlayerStats before passives run.
// Multiplicative, so it stacks cleanly with the subclass DamageReduct
// riders (DamageReduct is initialized to 1.0 by DerivePlayerStats before
// passives run). NOTE the player-defender direction: DamageReduct feeds
// calcDamage as a defense multiplier, so <1 = MORE damage taken. This
// line is therefore a mild survival trim in the same direction as the
// rebaseline *0.2 below — not the damage cut the "Wild Resilience" name
// suggests. Left as-is because the rebaseline sweep is tuned to it.
mods.DamageReduct *= 0.95
// rebaseline: the Druid wins T5 rooms on the survival tiebreak, immune to
// every damage lever. DamageReduct is a defense multiplier (calcDamage) —
// <1 = take MORE damage. Combined with a damage trim to pull it to band.
mods.DamageReduct *= 0.2
mods.DamageBonus += -0.20
// Phase 3 class-balance: druid was the only caster chassis with a
// purely defensive passive, and the off-tier numbers showed it —
// L1/T2 mean 0.04 vs Mage 0.27. Mirror the other caster bursts so
@@ -219,6 +285,7 @@ func applyClassPassives(stats *CombatStats, mods *CombatModifiers, c *DnDCharact
stats.AttackBonus++
mods.DamageBonus += 0.05
mods.FlatDmgStart += c.Level + clampNonNeg(abilityModifier(c.CHA))
mods.DamageReduct *= 0.4 // rebaseline: Bard also wins T5 on the survival tiebreak — take more damage to reach band
case ClassSorcerer:
// Innate Sorcery — pre-combat burst, CHA-scaled like the Sorcerer's
// spellcasting stat. Floors at the flat base for low-CHA builds.
@@ -231,6 +298,9 @@ func applyClassPassives(stats *CombatStats, mods *CombatModifiers, c *DnDCharact
// touching the +0.05 rider that already saturates at high tier.
mods.FlatDmgStart += 5 + c.Level + clampNonNeg(abilityModifier(c.CHA))
mods.DamageBonus += 0.05
stats.AttackBonus++ // rebaseline: Sorcerer lagged the other blasters — match their +1 to-hit
// At-will Fire Bolt + level-scaled survival — sustained arcane floor.
casterBlasterFloor(stats, mods, c.Level, abilityModifier(c.CHA), casterCantripBase, "Fire Bolt")
case ClassWarlock:
// Phase 2 class-balance: bumped from 10% to 12% damage + 1 attack —
// the Warlock chassis read mid-pack at T5 (0.52) pre-tune. Eldritch
@@ -240,6 +310,8 @@ func applyClassPassives(stats *CombatStats, mods *CombatModifiers, c *DnDCharact
mods.DamageBonus += 0.12
stats.AttackBonus++
mods.FlatDmgStart += c.Level + clampNonNeg(abilityModifier(c.CHA))
// At-will Eldritch Blast + level-scaled survival — sustained arcane floor.
casterBlasterFloor(stats, mods, c.Level, abilityModifier(c.CHA), 0, "Eldritch Blast")
case ClassPaladin:
// Class-identity audit (2026-05-16) — Divine Smite as actual
// per-hit radiant bonus + L5 Extra Attack. 5e: smite consumes a
@@ -249,8 +321,9 @@ func applyClassPassives(stats *CombatStats, mods *CombatModifiers, c *DnDCharact
// down so an extra-attack paladin doesn't trivialize every fight.
// Rides DivineStrikePerHit (already in the weapon-hit damage path).
// Previous FlatDmgStart opener felt like Lay on Hands, not Smite.
smite := 3 + c.Level/3
smite := 4 + c.Level/2 // rebaseline: bigger Divine Smite lifts the Paladin from floor into band
mods.DivineStrikePerHit += smite
mods.DamageReduct *= 0.9 // rebaseline: small survival trim between the two integer smite steps for a ~60 landing
if c.Level >= 5 {
mods.ExtraAttacks += 1
}
internal/plugin/dnd_rest.go
+1 -2
View File
@@ -2,7 +2,6 @@ package plugin
import (
"fmt"
"math/rand/v2"
"sort"
"strings"
"time"
@@ -117,7 +116,7 @@ func (p *AdventurePlugin) handleDnDShortRest(ctx MessageContext) error {
before := c.HPCurrent
if !hpFull {
conMod := abilityModifier(c.CON)
healDie := 1 + rand.IntN(6) // 1d6
healDie := 1 + simIntN(6) // 1d6
heal := healDie + conMod
if heal < 1 {
heal = 1
internal/plugin/dnd_spell_combat.go
+6 -7
View File
@@ -3,7 +3,6 @@ package plugin
import (
"fmt"
"log/slog"
"math/rand/v2"
"maunium.net/go/mautrix/id"
)
@@ -128,7 +127,7 @@ func applyMageSubclassSpellHooks(c *DnDCharacter, spell SpellDefinition, slotLev
// applySpellDamageAttack — Fire Bolt, Inflict Wounds, Chill Touch, etc.
// Roll d20 + spell attack vs enemy AC; nat 20 doubles dice damage.
func applySpellDamageAttack(spell SpellDefinition, atk int, mods *CombatModifiers, enemy *CombatStats, slot, charLevel int) {
roll := 1 + rand.IntN(20)
roll := 1 + simIntN(20)
isCrit := roll == 20
isFumble := roll == 1
if isFumble || (!isCrit && roll+atk < enemy.AC) {
@@ -158,7 +157,7 @@ func applySpellDamageAttack(spell SpellDefinition, atk int, mods *CombatModifier
// future multi-enemy combat (Phase 11+) but is not consulted here.
func applySpellDamageSave(spell SpellDefinition, dc int, c *DnDCharacter, mods *CombatModifiers, enemy *CombatStats, slot int) {
saveMod := enemySpellSaveMod(enemy)
saveRoll := 1 + rand.IntN(20)
saveRoll := 1 + simIntN(20)
saved := saveRoll+saveMod >= dc
dmg := rollSpellDamageDice(spell, slot, c.Level)
if saved {
@@ -182,7 +181,7 @@ func applySpellDamageAuto(spell SpellDefinition, mods *CombatModifiers, slot, ch
}
total := 0
for i := 0; i < darts; i++ {
total += 1 + rand.IntN(4) + 1
total += 1 + simIntN(4) + 1
}
mods.SpellPreDamage += total
mods.SpellPreDamageDesc = fmt.Sprintf("Magic Missile (%d darts, %d dmg)", darts, total)
@@ -223,7 +222,7 @@ func enemySpellSaveMod(enemy *CombatStats) int {
// double damage (5e: paralyzed creatures auto-crit on melee hits).
func applySpellControl(spell SpellDefinition, dc int, mods *CombatModifiers, enemy *CombatStats, slot int) {
saveMod := enemySpellSaveMod(enemy)
saveRoll := 1 + rand.IntN(20)
saveRoll := 1 + simIntN(20)
if saveRoll+saveMod >= dc {
mods.SpellPreDamageDesc = spell.Name + " — resisted"
return
@@ -382,7 +381,7 @@ func rollTurnSpellHeal(c *DnDCharacter, spell SpellDefinition, slotLevel int) in
if supreme {
heal += faces
} else {
heal += 1 + rand.IntN(faces)
heal += 1 + simIntN(faces)
}
}
heal += abilityModifier(c.WIS)
@@ -418,7 +417,7 @@ func rollSpellDamageDice(spell SpellDefinition, slot, charLevel int) int {
}
total := flat
for i := 0; i < dice; i++ {
total += 1 + rand.IntN(faces)
total += 1 + simIntN(faces)
}
if total < 1 {
total = 1
internal/plugin/dnd_xp_test.go
+13 -6
View File
@@ -224,7 +224,14 @@ func TestApplyClassPassives(t *testing.T) {
wantFlatStart int
wantInitBias float64
}{
{ClassFighter, 0.05, 0, false, 0, 1.0, 0, 0},
// Fighter-ceiling rebaseline (2026-07-16): Fighter picked up a -2 to-hit
// sub-swing trim; Rogue's steady rider flipped +0.05→-0.10 and it took a
// -3 to-hit trim (both offset a new 2nd swing gated at L5, not seen here);
// Druid took a survival trim (DR 0.95→0.19) + -0.20 damage; Bard a DR 0.4
// survival trim; Sorcerer a +1 to-hit to match the blasters; Paladin a
// 0.9 DR survival trim. Caster CantripPerRound / Defense adds are
// not asserted here.
{ClassFighter, 0.05, -2, false, 0, 1.0, 0, 0},
// Phase 2 class-balance rebalance: rogue picked up +5% damage,
// Mage/Bard/Warlock gained a level-scaled FlatDmgStart burst, Sorcerer's
// burst now also scales with level, and Warlock picked up +1 attack.
@@ -233,7 +240,7 @@ func TestApplyClassPassives(t *testing.T) {
// Phase 3 class-balance: Druid picked up a WIS-scaled FlatDmgStart burst
// (lvl 1 + clamp(mod(WIS=0)) = 1), and Sorcerer's burst base went 3→5
// (5 + 1 + clamp(mod(CHA=10)=0) = 6).
{ClassRogue, 0.05, 0, true, 0, 1.0, 0, 0},
{ClassRogue, -0.10, -3, true, 0, 1.0, 0, 0},
{ClassMage, 0.05, 1, false, 0, 1.0, 1, 0},
{ClassCleric, 0, 0, false, 5, 1.0, 0, 0},
// Class-identity audit (2026-05-16): Ranger Hunter's Mark is now
@@ -243,11 +250,11 @@ func TestApplyClassPassives(t *testing.T) {
// FlatDmgStart compensation riders are gone; +1 to-hit stays on
// Ranger as the "read prey tells" half.
{ClassRanger, 0, 1, false, 0, 1.0, 0, 0},
{ClassDruid, 0, 0, false, 0, 0.95, 1, 0},
{ClassBard, 0.05, 1, false, 0, 1.0, 1, 1},
{ClassSorcerer, 0.05, 0, false, 0, 1.0, 6, 0},
{ClassDruid, -0.20, 0, false, 0, 0.95 * 0.2, 1, 0},
{ClassBard, 0.05, 1, false, 0, 0.4, 1, 1},
{ClassSorcerer, 0.05, 1, false, 0, 1.0, 6, 0},
{ClassWarlock, 0.12, 1, false, 0, 1.0, 1, 0},
{ClassPaladin, 0, 0, false, 0, 1.0, 0, 0},
{ClassPaladin, 0, 0, false, 0, 0.9, 0, 0},
}
for _, tc := range cases {
stats := CombatStats{AttackBonus: 5}
internal/plugin/dnd_zone_cmd.go
+21 -1
View File
@@ -53,6 +53,9 @@ func (p *AdventurePlugin) handleDnDZoneCmd(ctx MessageContext, args string) erro
// fork pending) the handler short-circuits with a friendly
// message — see zoneCmdGo for the full surface.
return p.zoneCmdGo(ctx, rest)
case "unlock", "pick", "force":
// Spend thieves' tools on a fork option a failed check closed.
return p.zoneCmdUnlock(ctx, rest)
case "status", "info":
return p.zoneCmdStatus(ctx)
case "map", "m":
@@ -83,6 +86,7 @@ func zoneHelpText() string {
b.WriteString("`!zone map` — show the room layout\n")
b.WriteString("`!zone advance` — resolve the current room and move on\n")
b.WriteString("`!zone go <n>` — at a fork, take path #n\n")
b.WriteString("`!zone unlock <n>` — spend thieves' tools to open a path you couldn't\n")
b.WriteString("`!revisit <n>` — walk back to a room you've already cleared\n")
b.WriteString("`!zone abandon` — end the active run (no rewards)\n")
b.WriteString("`!zone taunt` — poke TwinBee (they'll remember)\n")
@@ -889,6 +893,7 @@ func (p *AdventurePlugin) runHarvestForAdvance(
if herr != nil {
return autoHarvestResult{}, ""
}
beatHaul(fresh, hr.Summary)
return hr, renderAutoHarvestFooter(hr.Summary)
}
@@ -1057,7 +1062,8 @@ func (p *AdventurePlugin) resolveRoom(userID id.UserID, run *DungeonRun, zone Zo
case RoomEntry:
return
case RoomTrap:
_, narration := p.resolveTrapRoom(userID, run, zone)
damage, narration := p.resolveTrapRoom(userID, run, zone)
beatTrap(userID, run, damage)
outcome = narration
return
case RoomExploration:
@@ -1121,6 +1127,12 @@ func (p *AdventurePlugin) resolveCombatRoom(userID id.UserID, run *DungeonRun, z
result := pres.Seats[0]
postHP, maxHP := dndHPSnapshot(userID)
nat20s, nat1s := scanMoodEventsFromEvents(run.RunID, pres.Events)
// One beat for the fight, filed here rather than on each of the three
// outcome branches below — every one of them passes through this point with
// the result already decided, and a single site can't drift out of step with
// the others.
beatCombat(run, monster.Name, elite, isBoss, result.PlayerWon, result.TimedOut,
preHP, postHP, maxHP, nat20s, nat1s)
// Compact mode: skip TwinBee banter, skip the multi-beat play-by-play.
// Render a single outcome line. Still records kills, threat, and drops.
@@ -1222,6 +1234,14 @@ func (p *AdventurePlugin) resolveCombatRoom(userID id.UserID, run *DungeonRun, z
// tryPatrolEncounter); see retreatThreatBump in
// dnd_expedition_combat.go.
_, _ = applyMoodEvent(run.RunID, MoodEventPlayerDeath)
// Ahead of abandonZoneRun, which would close the story as "abandoned" —
// the difference between being killed and running out of clock is the
// most interesting fact in the whole log.
if result.TimedOut {
beatRunEnd(run, "retreated")
} else {
beatRunEnd(run, "died")
}
_ = abandonZoneRun(userID)
// Timeout loss = retreat; the fighters took wounds but nobody actually
// died. Don't fire markAdventureDead — that would trigger the 6h respawn
internal/plugin/dnd_zone_cmd_graph.go
+12
View File
@@ -188,6 +188,17 @@ func (p *AdventurePlugin) zoneCmdGo(ctx MessageContext, rest string) error {
if cerr != nil {
return p.SendDM(ctx.Sender, cerr.Error())
}
return p.commitForkChoice(ctx, run, chosen, "")
}
// commitForkChoice advances the run onto an already-validated fork option and
// emits the arrival teaser. Split out of zoneCmdGo so `!zone unlock` — which
// reaches the same place by paying for it — cannot drift from the plain
// `!zone go` arrival: same region-transition hook, same camp strike, same
// boss/elite prompt. header, if set, is printed above the move.
func (p *AdventurePlugin) commitForkChoice(
ctx MessageContext, run *DungeonRun, chosen pendingChoice, header string,
) error {
nextIdx, aerr := advanceZoneRunNode(run.RunID, chosen.To)
if aerr != nil {
return p.SendDM(ctx.Sender, "Couldn't advance: "+aerr.Error())
@@ -200,6 +211,7 @@ func (p *AdventurePlugin) zoneCmdGo(ctx MessageContext, rest string) error {
fireGraphRegionTransition(run.UserID, fromNode, nextNode)
nextRoom := nodeKindToRoomType(nextNode.Kind)
var b strings.Builder
b.WriteString(header)
if kind := autoBreakCampOnMove(ctx.Sender); kind != "" {
b.WriteString(fmt.Sprintf("⛺ Camp struck (**%s**) — the party moved on.\n\n", kind))
}
internal/plugin/dnd_zone_combat.go
+6
View File
@@ -238,6 +238,7 @@ func (p *AdventurePlugin) resolveSecretRoom(userID id.UserID, run *DungeonRun, z
it := item
if line := p.grantZoneItem(userID, &it, "🧪"); line != "" {
rewards = append(rewards, line)
beatTreasure(run, it.Name, "cache")
}
}
@@ -392,6 +393,11 @@ func (p *AdventurePlugin) rollZoneLoot(userID id.UserID, run *DungeonRun, zone Z
slog.Error("zone: addLoot audit", "user", userID, "item", entry.ItemID, "err", err)
}
granted = append(granted, entry.ItemID)
source := "zone"
if bossCleared {
source = "boss"
}
beatTreasure(run, item.Name, source)
}
return granted
}
internal/plugin/dnd_zone_loot.go
+5 -2
View File
@@ -358,7 +358,10 @@ func pickLootEntry(zone map[LootTier][]ZoneLootDrop, tier LootTier, rng *rand.Ra
// while production paths use the package-global generator.
func rngFloat(rng *rand.Rand) float64 {
if rng == nil {
return rand.Float64()
// Auto-resolve rooms pass nil. simFloat64 routes to the seeded combat
// stream when the sim is seeding, else the package global — so prod
// (never seeded) stays byte-identical while sim room combat pairs.
return simFloat64()
}
return rng.Float64()
}
@@ -368,7 +371,7 @@ func rngIntN(rng *rand.Rand, n int) int {
return 0
}
if rng == nil {
return rand.IntN(n)
return simIntN(n)
}
return rng.IntN(n)
}
internal/plugin/dnd_zone_run.go
+16 -1
View File
@@ -175,6 +175,9 @@ func generateRoomSequence(zone ZoneDefinition, rng *rand.Rand) []RoomType {
// newRunID — 16-char hex token. Crypto-random; collision-resistant.
func newRunID() string {
if simSeedOn() {
return simHexToken()
}
var b [8]byte
if _, err := cryptorand.Read(b[:]); err != nil {
// Fall back to math/rand if /dev/urandom is unavailable.
@@ -240,7 +243,11 @@ func startZoneRun(userID id.UserID, zoneID ZoneID, dndLevel int, rng *rand.Rand)
}
if rng == nil {
rng = rand.New(rand.NewPCG(uint64(time.Now().UnixNano()), uint64(time.Now().UnixMicro())))
if simSeedOn() {
rng = simZoneRNG()
} else {
rng = rand.New(rand.NewPCG(uint64(time.Now().UnixNano()), uint64(time.Now().UnixMicro())))
}
}
seq := generateRoomSequence(zone, rng)
@@ -288,6 +295,7 @@ func startZoneRun(userID id.UserID, zoneID ZoneID, dndLevel int, rng *rand.Rand)
); err != nil {
return nil, fmt.Errorf("insert zone run: %w", err)
}
beatRunStart(userID, run, zone)
return run, nil
}
@@ -574,6 +582,7 @@ func abandonZoneRun(userID id.UserID) error {
if r == nil {
return ErrNoActiveRun
}
beatRunEnd(r, "abandoned")
_, err = db.Get().Exec(`
UPDATE dnd_zone_run
SET abandoned = 1,
@@ -592,6 +601,12 @@ func abandonZoneRunByID(runID string) error {
if runID == "" {
return nil
}
// The generic funnel: it fires for an idle reap, a region retirement, and a
// completed run being tidied up alike. beatRunEnd is first-writer-wins, so
// this only ever supplies the outcome nothing more specific already did.
if r, _ := getZoneRun(runID); r != nil {
beatRunEnd(r, "abandoned")
}
_, err := db.Get().Exec(`
UPDATE dnd_zone_run
SET abandoned = 1,
internal/plugin/expedition_ambient.go
+3 -6
View File
@@ -186,13 +186,10 @@ func (p *AdventurePlugin) deliverAmbient(e *Expedition, now time.Time) error {
}
footer := p.applyAmbientEffect(e, ev)
body := renderAmbientDM(e, ev, line, footer)
if uid := id.UserID(e.UserID); uid != "" {
if err := p.SendDM(uid, body); err != nil {
slog.Warn("expedition: ambient DM", "user", uid, "err", err)
}
}
// Once-a-day cadence: the effect above still lands on schedule, but the
// DM does not. The log entry below is what the next morning's briefing
// digest reads back, and the site renders it as it happens.
summary := fmt.Sprintf("ambient: %s", ev.Kind)
if footer != "" {
summary += " — " + footer
internal/plugin/expedition_autorun.go
+11 -28
View File
@@ -304,15 +304,11 @@ func (p *AdventurePlugin) tryAutoRun(e *Expedition, now time.Time) error {
// every other quiet path stays silent until something interactive fires.
if body, ok := buildAutoRunDM(e.ID, r, campBlock, campDecision); ok {
p.fanOutExpeditionDM(e, body, nil)
// N1/A6 — the end-of-day digest is the primary mid-day event anchor.
// The anchor is a per-player roll against a per-player daily slot, so
// each member rolls their own; a party does not share one event.
if campDecision.Night {
for _, member := range expeditionAudience(e) {
p.maybeFireAnchoredEvent(member, advEventChanceDigest)
}
}
}
// N1/A6's digest event anchor has moved to the 06:00 briefing along with
// the digest itself — see deliverBriefing. The anchor's whole premise is
// firing at a moment the player is demonstrably reading a DM, and the
// night camp no longer sends one.
// Emergence seam: a run-complete reached by the background ticker is
// still a live emergence — roll pet arrival. See maybeRollPetArrivalOnEmerge.
@@ -336,8 +332,10 @@ func (p *AdventurePlugin) tryAutoRun(e *Expedition, now time.Time) error {
// Surface rules:
// - stopFork / stopEnded / stopComplete → render the walk DM. These
// are the interactive / climax beats and stay their own messages.
// - Night camp pitched → render the EoD digest +
// camp block. Walk stream is dropped (the digest summarizes the day).
// - Night camp pitched → silent. The once-a-day cadence
// (2026-07-26) retired the EoD digest DM: the camp writes its own
// `rest` log entry and the day it summarised is already in the log,
// so the 06:00 briefing reads the whole thing back the next morning.
// - Boss-safety camp pitched → short hold notice + camp
// block; walk stream dropped (compact bail was deliberate).
// - Anything else → silent.
@@ -354,24 +352,9 @@ func buildAutoRunDM(expID string, r autopilotWalkResult, camp string, dec autoCa
return "", false
}
if dec.Night {
// EoD digest. The camp pitch already bumped current_day in
// nightRolloverBurn, so the day-that-just-ended is CurrentDay-1.
// digest is the day rollup, then the camp block lays out the rest.
fresh, ferr := getExpedition(expID)
prevDay := 0
if ferr == nil && fresh != nil {
prevDay = fresh.CurrentDay - 1
}
digest := ""
if prevDay > 0 {
digest = renderEndOfDayDigest(expID, prevDay)
}
if digest == "" {
// No structured day yet — fall back to a thin header so the
// camp block isn't dropped on the player without context.
digest = "🌙 *The day winds down.*\n\n"
}
return digest + camp, true
// Silent: the morning briefing is the one daily message now, and it
// renders this same day out of the expedition log.
return "", false
}
if dec.Reason == "boss-safety hold — resting before re-engaging" {
return "⏸ *Holding before the boss — pitching a rest camp.*\n" + camp, true
internal/plugin/expedition_digest.go
+248
View File
@@ -0,0 +1,248 @@
package plugin
// Once-a-day cadence (2026-07-26).
//
// Adventure's web feed is now the place to watch a run move minute to minute,
// so the bot no longer narrates every beat into Matrix. The three per-player
// DM sources that fired on a clock — the 06:00 briefing, the 21:00 recap, and
// the 6-hourly ambient event — collapse into a single morning message.
//
// The rule that keeps this honest: only the *messaging* goes quiet. Every
// mechanical effect still fires on exactly the schedule it always did. The
// ambient ticker still applies its ±SU nudges, the recap still runs the night
// wandering check and its threat bump, the briefing still burns supply and
// rolls the day. What changes is that ambient and recap now write their
// outcome to the expedition log and stop there; the next morning's briefing
// reads that log back and reports it.
//
// Interrupt-driven DMs are deliberately untouched. A fork needs a human, a
// death and a run-completion are terminal, and a mischief hit or a rival
// challenge is somebody else acting on you. Those still arrive when they
// happen; batching them to the next morning would either strand a decision
// behind an 8h auto-pick or report a finished story.
import (
"fmt"
"log/slog"
"os"
"strings"
"time"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
const (
// defaultPeteSiteURL — Pete's public site. Distinct from PETE_INGEST_URL,
// which is the Headscale-only ingest endpoint and is not reachable by a
// player clicking a link in a DM.
defaultPeteSiteURL = "https://news.parodia.dev"
// digestMaxLines — how many prior-day log lines the morning digest
// carries before it defers to the site. The cap is the whole point of
// the change: the digest is a teaser for the feed, not a transcript.
digestMaxLines = 8
// digestScanLimit — how far back the digest reads before it gives up on
// finding the window's oldest entry. A day of autopilot ticks, ambient
// beats and room events runs to a few dozen rows; this is slack, not a
// budget.
digestScanLimit = 500
)
// peteSiteURL returns the public base URL for Pete's site, without a
// trailing slash. Overridable so a dev instance can point its links at
// a local Pete instead of prod.
func peteSiteURL() string {
if v := strings.TrimRight(os.Getenv("PETE_PUBLIC_URL"), "/"); v != "" {
return v
}
return defaultPeteSiteURL
}
// adventureFeedURL is the general Adventure feed: everyone's activity.
func adventureFeedURL() string {
return peteSiteURL() + "/adventure"
}
// adventureWhoURL is the reader's own adventurer page. Keyed by the same
// salted, one-way roster token the board already publishes (see
// pete_roster.go), so a DM link and a board link resolve to one page and
// neither one leaks a Matrix handle.
func adventureWhoURL(uid id.UserID) string {
if uid == "" {
return adventureFeedURL()
}
return peteSiteURL() + "/adventure/who/" + eventToken(uid, "roster")
}
// digestSiteFooter appends the reader's own site link. Per-reader rather
// than per-expedition: a party shares a briefing body but each member's
// link goes to their own sheet.
//
// Gated on the Pete seam: peteclient.Enabled() is what starts the roster
// ticker, and the roster push is what creates the page this link points at.
// With the seam off (a dev instance, or a deploy without an ingest token)
// every daily DM would otherwise carry a guaranteed 404.
func digestSiteFooter(uid id.UserID, body string) string {
if !peteclient.Enabled() {
return body
}
return body + "\n\n🔗 _Watch it live: " + adventureWhoURL(uid) + "_"
}
// briefingPerReader is the per-reader decorator for the one daily message:
// the reader's own pet event on the front, the reader's own site link on the
// back. Both are per-member, so a party's shared briefing body still reaches
// each player personalised at both ends.
func (p *AdventurePlugin) briefingPerReader(uid id.UserID, body string) string {
return digestSiteFooter(uid, p.briefingPetPrefix(uid, body))
}
// fireDigestEventAnchor rolls N1/A6's digest-anchored mid-day event for each
// member. It used to hang off the autopilot's night-camp digest DM; that DM is
// gone, so it moved here — the briefing is now the message the player is
// demonstrably reading, which is the whole premise of an anchored roll.
//
// Still a per-player roll against a per-player daily slot: a party does not
// share one event.
func (p *AdventurePlugin) fireDigestEventAnchor(e *Expedition) {
for _, member := range expeditionAudience(e) {
p.maybeFireAnchoredEvent(member, advEventChanceDigest)
}
}
// appendOvernightDigest folds everything that happened since the previous
// briefing into a briefing body. A log read failure is non-fatal: the briefing
// is the player's only daily message now, so a missing digest block must never
// cost them the whole DM.
//
// The window is a timestamp, not a day number, because the two disagree on
// every event-anchored expedition: the autopilot's night camp rolls
// current_day at camp time, so by 06:00 the day that just ended is already
// current_day-1 — and on a night the autopilot never camped, it isn't. A
// since-last-briefing window reports each entry exactly once either way.
func appendOvernightDigest(body, expID string, since time.Time) string {
entries, err := logEntriesSince(expID, since)
if err != nil {
slog.Warn("expedition: digest entries", "expedition", expID, "err", err)
return body
}
digest := renderOvernightDigest(entries)
if digest == "" {
return body
}
return body + "\n" + digest
}
// logEntriesSince returns an expedition's log entries stamped at or after
// `since`, oldest first.
//
// The cutoff is applied in Go rather than in the WHERE clause on purpose:
// dnd_expedition_log.timestamp is a DATETIME column filled by SQLite's own
// CURRENT_TIMESTAMP, and comparing it against a bound parameter goes through
// numeric affinity and does not reliably answer the question. Scanning the
// column into a time.Time does.
func logEntriesSince(expID string, since time.Time) ([]ExpeditionEntry, error) {
recent, err := recentExpeditionLog(expID, digestScanLimit)
if err != nil {
return nil, err
}
// CURRENT_TIMESTAMP has one-second resolution while the cutoff we are
// handed (a briefing stamp, or the start date on day 1) carries
// sub-second precision. Floor it, or an entry written in the same second
// as the previous briefing falls out of both windows and is never
// reported. Re-reporting inside that one second is the safe direction.
since = since.Truncate(time.Second)
out := make([]ExpeditionEntry, 0, len(recent))
for i := len(recent) - 1; i >= 0; i-- { // recent is newest-first
if recent[i].Timestamp.Before(since) {
continue
}
out = append(out, recent[i])
}
return out, nil
}
// digestSkipTypes — log entry types the morning digest never echoes.
// `briefing` and `recap` are the frame itself, and the free-narration
// types are the per-room prose the site renders in full.
var digestSkipTypes = map[string]bool{
"briefing": true,
"recap": true,
"narrative": true,
"transit": true,
"action": true,
"journal": true,
}
// renderOvernightDigest condenses one expedition-day of log entries into the
// "here is what you missed" block that opens the morning briefing. Walks
// collapse to a count; everything notable keeps its own summary line, capped
// at digestMaxLines with an explicit overflow note so a truncated digest
// never reads as a complete one.
//
// Returns "" when there is nothing worth reporting — a day with only walks
// and narration gets no block at all rather than an empty header.
func renderOvernightDigest(entries []ExpeditionEntry) string {
var rooms int
var lines []string
for _, en := range entries {
if en.Type == "walk" {
rooms += walkEntryRooms(en.Summary)
continue
}
if digestSkipTypes[en.Type] {
continue
}
s := strings.TrimSpace(en.Summary)
if s == "" {
continue
}
lines = append(lines, s)
}
if rooms == 0 && len(lines) == 0 {
return ""
}
var b strings.Builder
b.WriteString("📜 **Since yesterday**\n")
if rooms > 0 {
b.WriteString(fmt.Sprintf("• walked %s\n", pluralRooms(rooms)))
}
shown := lines
overflow := 0
if len(shown) > digestMaxLines {
overflow = len(shown) - digestMaxLines
shown = shown[:digestMaxLines]
}
for _, l := range shown {
b.WriteString("• " + l + "\n")
}
if overflow > 0 {
b.WriteString(fmt.Sprintf("• _...and %d more, on the site._\n", overflow))
}
return b.String()
}
// walkEntryRooms reads the room count back out of an auto-walk log summary
// ("auto-walk: 3 room(s)"). One `walk` entry is one background tick, and a
// tick covers as many rooms as the autopilot got through — counting entries
// would report a 12-room day as a 3-room one. Unparseable summaries count as
// a single room rather than vanishing.
func walkEntryRooms(summary string) int {
var n int
if _, err := fmt.Sscanf(strings.TrimSpace(summary), "auto-walk: %d room", &n); err == nil && n > 0 {
return n
}
return 1
}
// pluralRooms renders a room count with the right noun.
func pluralRooms(n int) string {
if n == 1 {
return "1 room"
}
return fmt.Sprintf("%d rooms", n)
}
internal/plugin/expedition_digest_test.go
+253
View File
@@ -0,0 +1,253 @@
package plugin
import (
"fmt"
"strings"
"testing"
"time"
"maunium.net/go/mautrix/id"
)
// Coverage for the once-a-day cadence (2026-07-26). The behavioural tests
// below are the point of the file: before this change nothing asserted that
// the recap and ambient paths sent a DM, so nothing would have caught them
// silently continuing to send — or, worse, silently dropping the mechanical
// effect along with the message.
func TestRenderOvernightDigest_CollapsesWalksAndSkipsFrameTypes(t *testing.T) {
entries := []ExpeditionEntry{
// One `walk` entry is one autopilot tick, and a tick can cover
// several rooms — the digest reports rooms, not ticks.
{Type: "walk", Summary: "auto-walk: 2 room(s)"},
{Type: "walk", Summary: "auto-walk: 3 room(s)"},
{Type: "briefing", Summary: "morning briefing — 1.0 SU consumed overnight"},
{Type: "narrative", Summary: "the corridor bends left"},
{Type: "ambient", Summary: "ambient: pack_rat — Supplies -0.5"},
{Type: "night", Summary: "Signs of passage near camp; no encounter."},
{Type: "recap", Summary: "evening recap — 6 log entries today"},
}
got := renderOvernightDigest(entries)
if !strings.Contains(got, "walked 5 rooms") {
t.Errorf("walks not collapsed to a count:\n%s", got)
}
if !strings.Contains(got, "ambient: pack_rat") {
t.Errorf("ambient entry missing from digest:\n%s", got)
}
if !strings.Contains(got, "Signs of passage") {
t.Errorf("night check missing from digest:\n%s", got)
}
for _, unwanted := range []string{"morning briefing", "evening recap", "corridor bends"} {
if strings.Contains(got, unwanted) {
t.Errorf("digest echoed frame/narration entry %q:\n%s", unwanted, got)
}
}
}
func TestRenderOvernightDigest_CapsAndReportsOverflow(t *testing.T) {
var entries []ExpeditionEntry
for i := 0; i < digestMaxLines+3; i++ {
entries = append(entries, ExpeditionEntry{
Type: "ambient",
Summary: fmt.Sprintf("ambient event %d", i),
})
}
got := renderOvernightDigest(entries)
if n := strings.Count(got, "ambient event"); n != digestMaxLines {
t.Errorf("digest carried %d lines, want the cap of %d:\n%s", n, digestMaxLines, got)
}
// A truncated digest must say so — otherwise it reads as the whole day.
if !strings.Contains(got, "and 3 more") {
t.Errorf("overflow not reported:\n%s", got)
}
}
func TestRenderOvernightDigest_EmptyWhenNothingNotable(t *testing.T) {
entries := []ExpeditionEntry{
{Type: "briefing", Summary: "morning briefing"},
{Type: "narrative", Summary: "dust everywhere"},
}
if got := renderOvernightDigest(entries); got != "" {
t.Errorf("want no digest block for an unremarkable day, got:\n%s", got)
}
}
func TestAdventureWhoURL_UsesRosterTokenNotHandle(t *testing.T) {
// The roster token is salted from a DB-persisted secret.
setupZoneRunTestDB(t)
uid := id.UserID("@digest-url:example")
got := adventureWhoURL(uid)
want := "/adventure/who/" + eventToken(uid, "roster")
if !strings.HasSuffix(got, want) {
t.Errorf("who URL = %q, want suffix %q", got, want)
}
if strings.Contains(got, "digest-url") {
t.Errorf("who URL leaked the Matrix handle: %q", got)
}
}
func TestAdventureWhoURL_FallsBackToFeedWithoutUser(t *testing.T) {
setupZoneRunTestDB(t)
if got := adventureWhoURL(""); got != adventureFeedURL() {
t.Errorf("empty user should fall back to the feed, got %q", got)
}
}
// TestBuildAutoRunDM_NightCampIsSilent — the autopilot's end-of-day digest was
// the last recurring second DM of the day. It goes quiet; the camp writes its
// own `rest` log entry, so the morning briefing still reports it.
func TestBuildAutoRunDM_NightCampIsSilent(t *testing.T) {
r := autopilotWalkResult{rooms: 4, reason: stopOK, stream: []string{"…walked…"}}
camp := "\n\n⛺ **Autopilot camp** — night"
body, ok := buildAutoRunDM("expid", r, camp, autoCampDecision{
Kind: CampTypeStandard, Night: true,
})
if ok || body != "" {
t.Errorf("night camp should be silent, got ok=%v body=%q", ok, body)
}
}
// The two interactive surfaces the night-camp cut must not touch.
func TestBuildAutoRunDM_KeepSetStillSurfaces(t *testing.T) {
fork := autopilotWalkResult{rooms: 1, reason: stopFork, finalMsg: "pick a path"}
if body, ok := buildAutoRunDM("expid", fork, "", autoCampDecision{}); !ok ||
!strings.Contains(body, "pick a path") {
t.Errorf("fork must still surface, got ok=%v body=%q", ok, body)
}
hold := autopilotWalkResult{rooms: 2, reason: stopBossSafety}
holdCamp := "\n\n⛺ **Rest camp**"
if body, ok := buildAutoRunDM("expid", hold, holdCamp, autoCampDecision{
Reason: "boss-safety hold — resting before re-engaging",
}); !ok || !strings.Contains(body, "Holding before the boss") {
t.Errorf("boss-safety hold must still surface, got ok=%v body=%q", ok, body)
}
}
// TestDeliverAmbient_SilentButStillLogs — the ambient event still fires and
// still records itself; it just stops DMing.
func TestDeliverAmbient_SilentButStillLogs(t *testing.T) {
setupZoneRunTestDB(t)
uid := id.UserID("@digest-ambient:example")
defer cleanupExpeditions(uid)
p := &AdventurePlugin{}
sink := installSink(p)
exp, err := startExpedition(uid, ZoneGoblinWarrens, "",
ExpeditionSupplies{Current: 10, Max: 10, DailyBurn: 1, HarshMod: 1})
if err != nil {
t.Fatal(err)
}
if err := p.deliverAmbient(exp, exp.StartDate.Add(time.Hour)); err != nil {
t.Fatal(err)
}
if dms := sink.dmsTo(uid); len(dms) != 0 {
t.Errorf("ambient sent %d DM(s), want 0:\n%s", len(dms), strings.Join(dms, "\n---\n"))
}
entries, _ := recentExpeditionLog(exp.ID, 10)
found := false
for _, e := range entries {
if e.Type == "ambient" {
found = true
}
}
if !found {
t.Error("ambient event fired without writing a log entry — the digest would lose it")
}
}
// TestDeliverRecap_SilentButStillRunsNightCheck — the recap's mechanical half
// (wandering check, threat bump) must survive the message going away.
func TestDeliverRecap_SilentButStillRunsNightCheck(t *testing.T) {
setupZoneRunTestDB(t)
uid := id.UserID("@digest-recap:example")
defer cleanupExpeditions(uid)
p := &AdventurePlugin{}
sink := installSink(p)
exp, err := startExpedition(uid, ZoneGoblinWarrens, "",
ExpeditionSupplies{Current: 10, Max: 10, DailyBurn: 1, HarshMod: 1})
if err != nil {
t.Fatal(err)
}
exp.Camp = &CampState{Active: true, Type: CampTypeStandard, EstablishedAt: exp.StartDate}
if err := updateCamp(exp.ID, exp.Camp); err != nil {
t.Fatal(err)
}
recapAt := exp.StartDate.Add(12 * time.Hour)
if err := p.deliverRecap(exp, recapAt); err != nil {
t.Fatal(err)
}
if dms := sink.dmsTo(uid); len(dms) != 0 {
t.Errorf("recap sent %d DM(s), want 0:\n%s", len(dms), strings.Join(dms, "\n---\n"))
}
entries, _ := recentExpeditionLog(exp.ID, 10)
sawNight, sawRecap := false, false
for _, e := range entries {
switch e.Type {
case "night":
sawNight = true
case "recap":
sawRecap = true
}
}
if !sawNight {
t.Error("night wandering check did not run — the recap dropped its mechanics, not just its DM")
}
if !sawRecap {
t.Error("recap log entry missing — the site loses its day boundary")
}
}
// TestDeliverBriefing_IsTheOneDailyMessage — the payoff: one DM, carrying the
// prior day's silent activity and the reader's own site link.
func TestDeliverBriefing_CarriesDigestAndSiteLink(t *testing.T) {
setupZoneRunTestDB(t)
uid := id.UserID("@digest-briefing:example")
defer cleanupExpeditions(uid)
enablePeteSeam(t)
p := &AdventurePlugin{}
sink := installSink(p)
exp, err := startExpedition(uid, ZoneGoblinWarrens, "",
ExpeditionSupplies{Current: 10, Max: 10, DailyBurn: 1, HarshMod: 1})
if err != nil {
t.Fatal(err)
}
// Stand in for the day that just went by silently. The day number is
// deliberately not CurrentDay: on an event-anchored run the night camp
// rolls current_day when it pitches, so entries either side of the
// rollover carry different day numbers. The digest windows on time.
if err := appendExpeditionLog(exp.ID, exp.CurrentDay+1, "ambient",
"ambient: pack_rat — Supplies -0.5", "Something nibbled the stores."); err != nil {
t.Fatal(err)
}
if err := p.deliverBriefing(exp, exp.StartDate.Add(20*time.Hour)); err != nil {
t.Fatal(err)
}
dms := sink.dmsTo(uid)
if len(dms) != 1 {
t.Fatalf("briefing sent %d DM(s), want exactly 1:\n%s", len(dms), strings.Join(dms, "\n---\n"))
}
body := dms[0]
if !strings.Contains(body, "Since yesterday") {
t.Errorf("briefing missing the overnight digest block:\n%s", body)
}
if !strings.Contains(body, "ambient: pack_rat") {
t.Errorf("digest did not carry the silent ambient event:\n%s", body)
}
if !strings.Contains(body, adventureWhoURL(uid)) {
t.Errorf("briefing missing the reader's own site link:\n%s", body)
}
}
internal/plugin/expedition_party_cmd.go
+47 -17
View File
@@ -280,47 +280,77 @@ func (p *AdventurePlugin) expeditionCmdParty(ctx MessageContext) error {
return p.SendDM(ctx.Sender, b.String())
}
// expeditionCmdLeave walks a member out. The leader cannot leave — their row is
// the expedition — so they are pointed at `!extract`, which ends it for all.
func (p *AdventurePlugin) expeditionCmdLeave(ctx MessageContext) error {
// Sentinels for the two ways walking out can be refused, so the web action queue
// can pick a verdict without reading prose. errLeaveIsLeader is deliberately not
// errAbandonNotLeader inverted-and-reused: they are opposite facts about the same
// person and a verdict that conflated them would tell a leader they weren't one.
var (
errLeaveNothing = errors.New("expedition leave: no expedition to leave")
errLeaveIsLeader = errors.New("expedition leave: the leader's row is the expedition")
)
// performExpeditionLeave is `!expedition leave` minus the command framing.
// Shared with the web action queue, so a member walking out from a phone unseats
// the same way and the leader is told either way.
//
// Like performExpeditionAbandon this does NOT take the per-user lock — its
// Matrix caller holds it across the whole `!expedition` switch, and applyWebLeave
// takes it instead. See the comment on performExpeditionAbandon for what getting
// that backwards costs.
func (p *AdventurePlugin) performExpeditionLeave(uid id.UserID) error {
// Resolve the seat the way the guards that trap them do. seatedExpeditionFor
// spans `extracting`, which activeExpeditionFor does not: a leader who
// extracts and never resumes would otherwise leave their members seated —
// refused a new adventure by the guard, and told "no active expedition" by
// the very command the guard points them at. The exit has to see every state
// the gate sees. It already excludes leaders, so they fall through below.
seated, err := seatedExpeditionFor(ctx.Sender)
seated, err := seatedExpeditionFor(uid)
if err != nil {
return p.SendDM(ctx.Sender, "Couldn't read expedition state: "+err.Error())
return err
}
if seated != nil {
return p.leaveSeatedParty(ctx, seated)
return p.leaveSeatedParty(uid, seated)
}
exp, isLeader, err := activeExpeditionFor(ctx.Sender)
exp, isLeader, err := activeExpeditionFor(uid)
if err != nil {
return p.SendDM(ctx.Sender, "Couldn't read expedition state: "+err.Error())
return err
}
if exp == nil {
return p.SendDM(ctx.Sender, "No active expedition.")
return refuseAdv(errLeaveNothing, "No active expedition.")
}
if isLeader {
return p.SendDM(ctx.Sender,
return refuseAdv(errLeaveIsLeader,
"You're leading this one — `!extract` ends it for everyone, or `!expedition abandon` to walk away from it.")
}
return p.leaveSeatedParty(ctx, exp)
return p.leaveSeatedParty(uid, exp)
}
// leaveSeatedParty unseats a member and tells both ends. Shared by the two ways
// a member's seat resolves: the `extracting` limbo and the plain active party.
func (p *AdventurePlugin) leaveSeatedParty(ctx MessageContext, exp *Expedition) error {
if err := leaveParty(exp.ID, ctx.Sender); err != nil {
// expeditionCmdLeave walks a member out. The leader cannot leave — their row is
// the expedition — so they are pointed at `!extract`, which ends it for all.
func (p *AdventurePlugin) expeditionCmdLeave(ctx MessageContext) error {
if err := p.performExpeditionLeave(ctx.Sender); err != nil {
var refusal advRefusal
if errors.As(err, &refusal) {
return p.SendDM(ctx.Sender, refusal.Error())
}
return p.SendDM(ctx.Sender, "Couldn't leave: "+err.Error())
}
return p.SendDM(ctx.Sender, "You turn back for town. Your supplies stay with the party.")
}
// leaveSeatedParty unseats a member and tells the leader. Shared by the two ways
// a member's seat resolves: the `extracting` limbo and the plain active party.
// The *member's* own confirmation is the caller's, because that is the one line
// that differs between a DM and a web verdict.
func (p *AdventurePlugin) leaveSeatedParty(uid id.UserID, exp *Expedition) error {
if err := leaveParty(exp.ID, uid); err != nil {
return err
}
// Supplies stay in the pool. They were spent on the expedition, not lent to
// it, and clawing them back would let a member starve the party on their way
// out of the door.
_ = p.SendDM(id.UserID(exp.UserID), fmt.Sprintf(
"**%s** turned back. Their supplies stay with the party.", p.DisplayName(ctx.Sender)))
return p.SendDM(ctx.Sender, "You turn back for town. Your supplies stay with the party.")
"**%s** turned back. Their supplies stay with the party.", p.DisplayName(uid)))
return nil
}
internal/plugin/expedition_sim.go
+9 -1
View File
@@ -318,8 +318,16 @@ func applyClassBaselineStats(c *DnDCharacter) {
c.STR, c.DEX, c.CON, c.INT, c.WIS, c.CHA = 16, 13, 15, 8, 12, 10
case ClassRogue, ClassRanger:
c.STR, c.DEX, c.CON, c.INT, c.WIS, c.CHA = 10, 16, 14, 12, 13, 8
case ClassMage, ClassSorcerer:
case ClassMage:
c.STR, c.DEX, c.CON, c.INT, c.WIS, c.CHA = 8, 14, 13, 16, 12, 10
case ClassSorcerer:
// Sorcerer is a CHA caster (spellcastingMod → CHA), so its 16 goes in
// CHA, not INT. Previously it shared the Mage's INT-heavy array, which
// left the synthetic sorcerer casting at CHA mod 0 — every CHA-scaled
// ability (cantrip, Innate Sorcery, spell DCs) ran crippled and sorc
// trailed the field in every sweep. Prod players always placed 16 in
// CHA; this makes the sim's sorcerer match a real one.
c.STR, c.DEX, c.CON, c.INT, c.WIS, c.CHA = 8, 14, 13, 10, 12, 16
case ClassCleric, ClassDruid:
c.STR, c.DEX, c.CON, c.INT, c.WIS, c.CHA = 12, 10, 14, 8, 16, 13
case ClassBard, ClassWarlock:
internal/plugin/hangman.go
+2 -4
View File
@@ -856,9 +856,7 @@ func (p *HangmanPlugin) handleSubmit(ctx MessageContext, phrase string) error {
}
// LLM screening
ollamaHost := os.Getenv("OLLAMA_HOST")
ollamaModel := os.Getenv("OLLAMA_MODEL")
if ollamaHost == "" || ollamaModel == "" {
if !llmConfigured() {
// No LLM available — add directly
if err := p.addPhrase(phrase); err != nil {
if err.Error() == "duplicate phrase" {
@@ -879,7 +877,7 @@ or
Phrase: %s`, phrase)
result, err := callOllama(ollamaHost, ollamaModel, prompt)
result, err := callLLM(prompt)
if err != nil {
slog.Error("hangman: LLM screening failed", "err", err)
// Fail open — add it
internal/plugin/holdem_tips.go
+16 -40
View File
@@ -1,24 +1,24 @@
package plugin
import (
"bytes"
"encoding/json"
"context"
"fmt"
"io"
"log/slog"
"net/http"
"os"
"regexp"
"strings"
"time"
"gogobee/internal/db"
"gogobee/internal/llm"
"github.com/chehsunliu/poker"
"maunium.net/go/mautrix/id"
)
var holdemTipsClient = &http.Client{Timeout: 60 * time.Second}
// holdemTipTimeout preserves the 60s budget the tip rewriter's own http.Client
// enforced. Tips are delivered as private messages during a hand, so this sits
// between the passive 30s paths and the interactive 120s default.
const holdemTipTimeout = 60 * time.Second
// loadTipsPref loads a user's tip preference from the database.
func loadTipsPref(userID id.UserID) bool {
@@ -491,11 +491,8 @@ func cardSuitIndex(c poker.Card) int {
func generateTip(ctx holdemTipContext) string {
base := generateRulesTip(ctx)
host := os.Getenv("OLLAMA_HOST")
model := os.Getenv("OLLAMA_MODEL")
if host != "" && model != "" {
rewritten, err := rewriteTipWithLLM(host, model, ctx, base)
if llmConfigured() {
rewritten, err := rewriteTipWithLLM(ctx, base)
if err != nil {
slog.Warn("holdem: LLM tip rewrite failed, using rules tip", "err", err)
} else if rewritten != "" {
@@ -626,40 +623,19 @@ func buildTipUserPrompt(ctx holdemTipContext) string {
// variety. The rules tip is the source of truth — if the rewrite diverges
// (empty, action vocabulary changed, etc.) we reject it and the caller falls
// back to the original.
func rewriteTipWithLLM(host, model string, ctx holdemTipContext, base string) (string, error) {
func rewriteTipWithLLM(ctx holdemTipContext, base string) (string, error) {
userMsg := buildTipUserPrompt(ctx) + "\nTIP:\n" + base + "\n"
req := ollamaChatRequest{
Model: model,
Messages: []chatMessage{
{Role: "system", Content: buildTipSystemPrompt()},
{Role: "user", Content: userMsg},
},
Stream: false,
}
body, err := json.Marshal(req)
raw, err := llmGenerate(context.Background(), llm.Request{
System: buildTipSystemPrompt(),
Prompt: userMsg,
Timeout: holdemTipTimeout,
})
if err != nil {
return "", fmt.Errorf("marshal: %w", err)
return "", err
}
url := strings.TrimRight(host, "/") + "/api/chat"
resp, err := holdemTipsClient.Post(url, "application/json", bytes.NewReader(body))
if err != nil {
return "", fmt.Errorf("request: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
respBody, _ := io.ReadAll(resp.Body)
return "", fmt.Errorf("status %d: %s", resp.StatusCode, string(respBody))
}
var ollamaResp ollamaChatResponse
if err := json.NewDecoder(resp.Body).Decode(&ollamaResp); err != nil {
return "", fmt.Errorf("decode: %w", err)
}
tip := extractTipFromResponse(ollamaResp.Message.Content)
tip := extractTipFromResponse(raw)
if tip == "" {
return "", fmt.Errorf("empty response")
}
internal/plugin/howami.go
+14 -61
View File
@@ -1,18 +1,15 @@
package plugin
import (
"bytes"
"context"
"database/sql"
"encoding/json"
"fmt"
"io"
"log/slog"
"net/http"
"os"
"strings"
"time"
"gogobee/internal/db"
"gogobee/internal/llm"
"maunium.net/go/mautrix"
"maunium.net/go/mautrix/id"
@@ -47,9 +44,7 @@ func (p *HowAmIPlugin) OnMessage(ctx MessageContext) error {
return nil
}
ollamaHost := os.Getenv("OLLAMA_HOST")
ollamaModel := os.Getenv("OLLAMA_MODEL")
if ollamaHost == "" || ollamaModel == "" {
if !llmConfigured() {
return p.SendReply(ctx.RoomID, ctx.EventID, "LLM is not configured.")
}
@@ -84,9 +79,9 @@ Write the roast now. Do not include any preamble or explanation, just the roast
botName, string(target), profile,
)
response, err := callOllama(ollamaHost, ollamaModel, prompt)
response, err := callLLM(prompt)
if err != nil {
slog.Error("howami: ollama call", "err", err)
slog.Error("howami: llm call", "err", err)
p.SendReply(ctx.RoomID, ctx.EventID, "Couldn't generate the profile. Thanks, Ollama.")
return
}
@@ -181,55 +176,13 @@ func (p *HowAmIPlugin) gatherProfile(userID id.UserID) string {
return sb.String()
}
// callOllama sends a prompt to the Ollama generate endpoint and returns the response.
func callOllama(host, model, prompt string) (string, error) {
apiURL := strings.TrimRight(host, "/") + "/api/generate"
payload := map[string]interface{}{
"model": model,
"prompt": prompt,
"stream": false,
"think": false,
"options": map[string]interface{}{
"num_ctx": 8192,
},
}
data, err := json.Marshal(payload)
if err != nil {
return "", fmt.Errorf("marshal payload: %w", err)
}
client := &http.Client{Timeout: 120 * time.Second}
resp, err := client.Post(apiURL, "application/json", bytes.NewReader(data))
if err != nil {
return "", fmt.Errorf("ollama request: %w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return "", fmt.Errorf("read response: %w", err)
}
if resp.StatusCode != 200 {
return "", fmt.Errorf("ollama HTTP %d: %s", resp.StatusCode, string(body))
}
var result struct {
Response string `json:"response"`
}
if err := json.Unmarshal(body, &result); err != nil {
return "", fmt.Errorf("parse response: %w", err)
}
response := result.Response
// Strip <think>...</think> blocks (Qwen 3.5 reasoning)
if i := strings.Index(response, "<think>"); i != -1 {
if j := strings.Index(response, "</think>"); j != -1 {
response = response[:i] + response[j+len("</think>"):]
}
}
return strings.TrimSpace(response), nil
// callLLM sends a prompt to whichever backend is configured and returns the
// completion. Reasoning blocks are stripped by the client. The 8192 context
// hint is what this path has always asked Ollama for; vLLM ignores it and uses
// the window fixed at server launch.
func callLLM(prompt string) (string, error) {
return llmGenerate(context.Background(), llm.Request{
Prompt: prompt,
NumCtx: 8192,
})
}
internal/plugin/llm_client.go
+45
View File
@@ -0,0 +1,45 @@
package plugin
import (
"context"
"sync"
"gogobee/internal/llm"
)
// The inference backend is process-wide: one endpoint, one model, selected by
// env at startup. Plugins share a single client rather than each rebuilding one
// per invocation, and read config through llmConfigured/llmGenerate so that
// swapping Ollama for vLLM is a config change rather than a code change.
var (
llmOnce sync.Once
llmShared llm.Client
llmCfg llm.Config
)
func llmInit() {
llmOnce.Do(func() {
llmCfg = llm.ConfigFromEnv()
llmShared = llm.New(llmCfg)
})
}
// llmConfigured reports whether an endpoint and model are set. Plugins call
// this to stay dormant instead of erroring on every invocation — the same role
// the old `if ollamaHost == "" || ollamaModel == ""` guards played.
func llmConfigured() bool {
llmInit()
return llmCfg.Configured()
}
// llmClient returns the shared backend client.
func llmClient() llm.Client {
llmInit()
return llmShared
}
// llmGenerate is the one-line path for the common case: a raw prompt in,
// visible completion out, reasoning blocks already stripped.
func llmGenerate(ctx context.Context, req llm.Request) (string, error) {
return llmClient().Generate(ctx, req)
}
internal/plugin/llm_passive.go
+40 -72
View File
@@ -1,13 +1,11 @@
package plugin
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"log/slog"
"math/rand"
"net/http"
"os"
"regexp"
"strconv"
@@ -18,6 +16,7 @@ import (
"gogobee/internal/db"
"gogobee/internal/dreamclient"
"gogobee/internal/llm"
"maunium.net/go/mautrix"
"maunium.net/go/mautrix/id"
@@ -54,29 +53,31 @@ type queueItem struct {
FormattedBody string
}
// LLMPassivePlugin classifies messages using Ollama and reacts accordingly.
// classifyTimeout is the per-message budget for passive classification. It
// preserves the 30s cap the plugin's own http.Client used to enforce, which is
// deliberately tighter than the interactive default: classification runs on
// sampled traffic and must never back up the queue.
const classifyTimeout = 30 * time.Second
// LLMPassivePlugin classifies messages using the configured LLM backend and
// reacts accordingly.
type LLMPassivePlugin struct {
Base
xp *XPPlugin
dict *dreamclient.Client
ollamaHost string
ollamaModel string
sampleRate float64
enabled bool
xp *XPPlugin
dict *dreamclient.Client
sampleRate float64
enabled bool
mu sync.Mutex
queue []queueItem
backoff time.Duration
httpClient *http.Client
stopCh chan struct{}
stopCh chan struct{}
}
// NewLLMPassivePlugin creates a new LLM passive classification plugin.
func NewLLMPassivePlugin(client *mautrix.Client, xp *XPPlugin, dict *dreamclient.Client) *LLMPassivePlugin {
host := os.Getenv("OLLAMA_HOST")
model := os.Getenv("OLLAMA_MODEL")
enabled := host != "" && model != ""
enabled := llmConfigured()
sampleRate := 0.15
if v := os.Getenv("LLM_SAMPLE_RATE"); v != "" {
@@ -86,16 +87,13 @@ func NewLLMPassivePlugin(client *mautrix.Client, xp *XPPlugin, dict *dreamclient
}
p := &LLMPassivePlugin{
Base: NewBase(client),
xp: xp,
dict: dict,
ollamaHost: host,
ollamaModel: model,
sampleRate: sampleRate,
enabled: enabled,
backoff: 5 * time.Second,
httpClient: &http.Client{Timeout: 30 * time.Second},
stopCh: make(chan struct{}),
Base: NewBase(client),
xp: xp,
dict: dict,
sampleRate: sampleRate,
enabled: enabled,
backoff: 5 * time.Second,
stopCh: make(chan struct{}),
}
return p
@@ -116,11 +114,11 @@ func (p *LLMPassivePlugin) Commands() []CommandDef {
func (p *LLMPassivePlugin) Init() error {
if p.enabled {
slog.Info("llm_passive: enabled", "host", p.ollamaHost, "model", p.ollamaModel, "sample_rate", p.sampleRate)
slog.Info("llm_passive: enabled", "backend", llmClient().Backend(),
"model", llmClient().Model(), "sample_rate", p.sampleRate)
go p.processQueue()
} else {
slog.Warn("llm_passive: disabled (OLLAMA_HOST or OLLAMA_MODEL not set)",
"host", p.ollamaHost, "model", p.ollamaModel)
slog.Warn("llm_passive: disabled (LLM endpoint or model not set)")
}
return nil
}
@@ -329,9 +327,9 @@ func (p *LLMPassivePlugin) classifyAndProcess(item queueItem) error {
var todayWOTD string
db.Get().QueryRow(`SELECT word FROM wotd_log WHERE date = ?`, today).Scan(&todayWOTD)
result, err := p.callOllama(item.Body+mentionHint, todayWOTD)
result, err := p.classify(item.Body+mentionHint, todayWOTD)
if err != nil {
return fmt.Errorf("ollama call: %w", err)
return fmt.Errorf("llm call: %w", err)
}
// Resolve any display names in LLM targets back to MXIDs
@@ -464,21 +462,9 @@ func (p *LLMPassivePlugin) classifyAndProcess(item queueItem) error {
return nil
}
// ollamaRequest is the request body for the Ollama API.
type ollamaRequest struct {
Model string `json:"model"`
Prompt string `json:"prompt"`
Stream bool `json:"stream"`
Think bool `json:"think"`
}
// ollamaResponse is the response from the Ollama API.
type ollamaResponse struct {
Response string `json:"response"`
}
// callOllama sends a classification prompt to Ollama and parses the JSON result.
func (p *LLMPassivePlugin) callOllama(messageText, wotd string) (*classificationResult, error) {
// classify sends a classification prompt to the configured backend and parses
// the JSON result.
func (p *LLMPassivePlugin) classify(messageText, wotd string) (*classificationResult, error) {
wotdInstruction := `"wotd_used": false`
if wotd != "" {
wotdInstruction = fmt.Sprintf(`"wotd_used": true | false (whether the message uses the word "%s" correctly and meaningfully — not just mentioning or quoting it)`, wotd)
@@ -500,36 +486,18 @@ JSON schema:
Message: %s`, wotdInstruction, messageText)
reqBody := ollamaRequest{
Model: p.ollamaModel,
Prompt: prompt,
Stream: false,
}
body, err := json.Marshal(reqBody)
slog.Debug("llm_passive: calling backend", "backend", llmClient().Backend(), "model", llmClient().Model())
// Classification rides the passive path on every sampled message, so it keeps
// the tighter budget it always had rather than the interactive default.
raw, err := llmGenerate(context.Background(), llm.Request{
Prompt: prompt,
Timeout: classifyTimeout,
})
if err != nil {
return nil, fmt.Errorf("marshal request: %w", err)
return nil, err
}
url := strings.TrimRight(p.ollamaHost, "/") + "/api/generate"
slog.Debug("llm_passive: calling ollama", "url", url, "model", p.ollamaModel)
resp, err := p.httpClient.Post(url, "application/json", bytes.NewReader(body))
if err != nil {
return nil, fmt.Errorf("ollama request: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
respBody, _ := io.ReadAll(resp.Body)
return nil, fmt.Errorf("ollama status %d: %s", resp.StatusCode, string(respBody))
}
var ollamaResp ollamaResponse
if err := json.NewDecoder(resp.Body).Decode(&ollamaResp); err != nil {
return nil, fmt.Errorf("decode ollama response: %w", err)
}
result, err := parseClassification(ollamaResp.Response)
result, err := parseClassification(raw)
if err != nil {
return nil, fmt.Errorf("parse classification: %w", err)
}
internal/plugin/magic_items_gameplay.go
+144 -91
View File
@@ -1,6 +1,7 @@
package plugin
import (
"errors"
"fmt"
"log/slog"
"math/rand/v2"
@@ -559,6 +560,133 @@ func magicItemEffectSummary(mi MagicItem) string {
return strings.Join(parts, ", ")
}
// The equip mutation, message-free, shared by the DM resolver above and the web
// equip queue (pete_equip.go). Splitting it out is deliberate: the ordering below
// — evict occupant, then remove-from-inventory *before* equip, with a rollback if
// equip fails — is the whole defence against item duplication, and a second copy
// of it living in the web path is exactly where that defence would silently rot.
// One implementation, two callers.
// errItemNotEquippable is a *permanent* refusal (not a magic item, or a slotless
// curio) — the caller should reject the request, not retry it. Every other error
// from applyMagicEquip is a transient DB fault the caller may retry.
var errItemNotEquippable = errors.New("magic-item: not equippable")
// errSlotEmpty is applyMagicUnequip's permanent refusal: nothing is in that slot.
var errSlotEmpty = errors.New("magic-item: slot empty")
// magicEquipOutcome is what an equip did, for the caller to narrate. BondsBefore
// is the attunement count *after* any swap-eviction and *before* this item, so a
// caller reporting "bonded (N/3)" adds one.
type magicEquipOutcome struct {
Effective MagicItem // the item as worn, tempering folded in
SwappedBack string // name of the occupant sent back to inventory, or ""
Bonded bool // this item took a bond just now
AtCap bool // worn but inert: it wants a bond and all 3 are used
BondsBefore int // bonds in use before this item was worn
Healed []string // stragglers a freed slot let bond, post-equip
}
// applyMagicEquip wears one inventory item, preserving the anti-duplication
// ordering. It mutates the equipment tables and sends nothing.
func applyMagicEquip(userID id.UserID, it AdvItem) (magicEquipOutcome, error) {
mi, ok := magicItemFromAdvItem(it)
if !ok || mi.Slot == "" {
return magicEquipOutcome{}, errItemNotEquippable
}
equipped, err := loadEquippedMagicItems(userID)
if err != nil {
return magicEquipOutcome{}, err
}
// Return whatever occupies that slot to inventory at full value, and drop it
// from the local map so the bond count below reflects the post-swap state.
var swappedBack string
if prev, exists := equipped[mi.Slot]; exists && prev.Item.ID != "" {
back := magicItemSellAt(prev.Item, prev.Temper)
back.SkillSource = "magic_item:" + prev.Item.ID
if err := addAdvInventoryItem(userID, back); err != nil {
return magicEquipOutcome{}, err
}
swappedBack = prev.Item.Name
delete(equipped, mi.Slot)
}
bondsBefore := countAttunedMagicItems(equipped)
bonded, atCap := false, false
if mi.Attunement {
if bondsBefore >= dndMagicItemAttuneLimit {
atCap = true
} else {
bonded = true
}
}
// Remove the inventory row FIRST, then equip; if equip fails, restore the row.
// The reverse order left a transient failure with the item both worn and in the
// pack — a free duplicate.
if err := removeAdvInventoryItem(it.ID); err != nil {
slog.Error("magic-item: failed to remove from inventory before equip",
"user", userID, "item", mi.ID, "err", err)
return magicEquipOutcome{}, err
}
if err := equipMagicItem(userID, mi.Slot, mi.ID, bonded, it.Temper); err != nil {
restored := magicItemSellAt(mi, it.Temper)
restored.Value = it.Value
restored.SkillSource = "magic_item:" + mi.ID
if rbErr := addAdvInventoryItem(userID, restored); rbErr != nil {
slog.Error("magic-item: equip failed AND inventory rollback failed",
"user", userID, "item", mi.ID, "equip_err", err, "rollback_err", rbErr)
}
return magicEquipOutcome{}, err
}
// Swapping the occupant out may have freed a bond slot — light up any straggler.
healed, _ := reconcileMagicAttunements(userID)
return magicEquipOutcome{
Effective: temperedItem(mi, it.Temper),
SwappedBack: swappedBack,
Bonded: bonded,
AtCap: atCap,
BondsBefore: bondsBefore,
Healed: healed,
}, nil
}
// magicUnequipOutcome is what an unequip did, for the caller to narrate.
type magicUnequipOutcome struct {
Item MagicItem // the item taken off, as it was worn
Healed []string // stragglers the freed bond slot let bond
}
// applyMagicUnequip takes the item off a slot and returns it to inventory,
// mirroring the equip ordering (destructive op first, restore on failure). Sends
// nothing.
func applyMagicUnequip(userID id.UserID, slot DnDSlot) (magicUnequipOutcome, error) {
equipped, err := loadEquippedMagicItems(userID)
if err != nil {
return magicUnequipOutcome{}, err
}
e, ok := equipped[slot]
if !ok || e.Item.ID == "" {
return magicUnequipOutcome{}, errSlotEmpty
}
if err := unequipMagicItem(userID, slot); err != nil {
return magicUnequipOutcome{}, err
}
back := magicItemSellAt(e.Item, e.Temper)
back.SkillSource = "magic_item:" + e.Item.ID
if err := addAdvInventoryItem(userID, back); err != nil {
if rbErr := equipMagicItem(userID, slot, e.Item.ID, e.Attuned, e.Temper); rbErr != nil {
slog.Error("magic-item: unequip failed AND re-equip rollback failed",
"user", userID, "item", e.Item.ID, "inv_err", err, "rollback_err", rbErr)
}
return magicUnequipOutcome{}, err
}
healed, _ := reconcileMagicAttunements(userID)
return magicUnequipOutcome{Item: e.Effective(), Healed: healed}, nil
}
func (p *AdventurePlugin) handleEquipMagicCmd(ctx MessageContext) error {
// Self-heal first: bond any worn item stranded inert while a slot is free
// (e.g. equipped at cap, then a bond slot opened). This is the only path a
@@ -639,86 +767,31 @@ func (p *AdventurePlugin) resolveMagicEquipReply(ctx MessageContext, interaction
}
it := data.Items[idx]
mi, ok := magicItemFromAdvItem(it)
if !ok || mi.Slot == "" {
out, err := applyMagicEquip(ctx.Sender, it)
if errors.Is(err, errItemNotEquippable) {
return p.SendDM(ctx.Sender, "That item can't be equipped anymore.")
}
equipped, err := loadEquippedMagicItems(ctx.Sender)
if err != nil {
return p.SendDM(ctx.Sender, "Failed to load your equipped magic items.")
}
// Return whatever currently occupies that slot to inventory at full
// value — swapping a curio shouldn't tax it. Evict from the local map
// too, so the attunement count below reflects the post-swap state and
// can re-open a slot the prior occupant was holding.
var swappedBackName string
if prev, exists := equipped[mi.Slot]; exists && prev.Item.ID != "" {
back := magicItemSellAt(prev.Item, prev.Temper)
back.SkillSource = "magic_item:" + prev.Item.ID
if err := addAdvInventoryItem(ctx.Sender, back); err != nil {
return p.SendDM(ctx.Sender, "Failed to return your currently-equipped item to inventory.")
}
swappedBackName = prev.Item.Name
delete(equipped, mi.Slot)
}
// Auto-attune when the item needs it and an attunement slot is free.
// Otherwise it equips inert until the player frees a slot.
attune := false
atCap := false
if mi.Attunement {
if countAttunedMagicItems(equipped) >= dndMagicItemAttuneLimit {
atCap = true
} else {
attune = true
}
}
// Remove the inventory row FIRST, then equip. If equip fails after the
// remove succeeded, restore inventory. Doing it in the other order
// meant a transient DB error on remove left the item both equipped
// *and* still in inventory — a free duplication.
if err := removeAdvInventoryItem(it.ID); err != nil {
slog.Error("magic-item: failed to remove from inventory before equip",
"user", ctx.Sender, "item", mi.ID, "err", err)
return p.SendDM(ctx.Sender, "Failed to equip that item.")
}
if err := equipMagicItem(ctx.Sender, mi.Slot, mi.ID, attune, it.Temper); err != nil {
// Roll back: try to put the item back in inventory so the player
// doesn't lose it. Best-effort; log if the rollback also fails.
restored := magicItemSellAt(mi, it.Temper)
restored.Value = it.Value
restored.SkillSource = "magic_item:" + mi.ID
if rbErr := addAdvInventoryItem(ctx.Sender, restored); rbErr != nil {
slog.Error("magic-item: equip failed AND inventory rollback failed",
"user", ctx.Sender, "item", mi.ID, "equip_err", err, "rollback_err", rbErr)
}
return p.SendDM(ctx.Sender, "Failed to equip that item.")
}
eqMI := temperedItem(mi, it.Temper)
var sb strings.Builder
sb.WriteString(fmt.Sprintf("✨ **%s** equipped in your %s slot — %s.",
eqMI.Name, eqMI.Slot, magicItemEffectSummary(eqMI)))
if swappedBackName != "" {
sb.WriteString(fmt.Sprintf("\n📦 **%s** moved back to inventory.", swappedBackName))
out.Effective.Name, out.Effective.Slot, magicItemEffectSummary(out.Effective)))
if out.SwappedBack != "" {
sb.WriteString(fmt.Sprintf("\n📦 **%s** moved back to inventory.", out.SwappedBack))
}
switch {
case mi.Attunement && attune:
case out.Bonded:
sb.WriteString(fmt.Sprintf("\nBonded (%d/%d bond slots used).",
countAttunedMagicItems(equipped)+1, dndMagicItemAttuneLimit))
case mi.Attunement && atCap:
out.BondsBefore+1, dndMagicItemAttuneLimit))
case out.AtCap:
sb.WriteString(fmt.Sprintf("\n⚠️ All %d bond slots are full — it's worn but **inert** until you free one (`!adventure unequip-magic` to take a bonded item off; this one bonds automatically once a slot opens).",
dndMagicItemAttuneLimit))
}
// Swapping out the prior occupant may have freed a bond slot — light up any
// item that was stranded inert (including a previously-equipped one the
// picker could never reach).
if healed, _ := reconcileMagicAttunements(ctx.Sender); len(healed) > 0 {
if len(out.Healed) > 0 {
sb.WriteString(fmt.Sprintf("\n🔗 A freed bond slot also activated **%s**.",
strings.Join(healed, "**, **")))
strings.Join(out.Healed, "**, **")))
}
return p.SendDM(ctx.Sender, sb.String())
}
@@ -783,39 +856,19 @@ func (p *AdventurePlugin) resolveMagicUnequipReply(ctx MessageContext, interacti
}
slot := data.Slots[idx]
equipped, err := loadEquippedMagicItems(ctx.Sender)
if err != nil {
return p.SendDM(ctx.Sender, "Failed to load your equipped magic items.")
}
e, ok := equipped[slot]
if !ok || e.Item.ID == "" {
out, err := applyMagicUnequip(ctx.Sender, slot)
if errors.Is(err, errSlotEmpty) {
return p.SendDM(ctx.Sender, "That slot is already empty.")
}
// Clear the slot FIRST, then return the item to inventory at full value.
// This mirrors the equip resolver's ordering (destructive op first, restore
// on failure): the other order could leave the item both worn and in
// inventory — a free duplicate — on a transient DB error.
if err := unequipMagicItem(ctx.Sender, slot); err != nil {
if err != nil {
return p.SendDM(ctx.Sender, "Failed to take that item off.")
}
back := magicItemSellAt(e.Item, e.Temper)
back.SkillSource = "magic_item:" + e.Item.ID
if err := addAdvInventoryItem(ctx.Sender, back); err != nil {
// Roll back: re-equip exactly as it was so the item isn't lost.
if rbErr := equipMagicItem(ctx.Sender, slot, e.Item.ID, e.Attuned, e.Temper); rbErr != nil {
slog.Error("magic-item: unequip failed AND re-equip rollback failed",
"user", ctx.Sender, "item", e.Item.ID, "inv_err", err, "rollback_err", rbErr)
}
return p.SendDM(ctx.Sender, "Failed to return that item to your inventory.")
}
mi := e.Effective()
msg := fmt.Sprintf("📦 **%s** taken off your %s slot and returned to inventory.", mi.Name, slot)
msg := fmt.Sprintf("📦 **%s** taken off your %s slot and returned to inventory.", out.Item.Name, slot)
// Freeing a bonded slot may let a worn-but-inert item finally bond.
if healed, _ := reconcileMagicAttunements(ctx.Sender); len(healed) > 0 {
if len(out.Healed) > 0 {
msg += fmt.Sprintf("\n🔗 That freed a bond slot — **%s** is now active.",
strings.Join(healed, "**, **"))
strings.Join(out.Healed, "**, **"))
}
return p.SendDM(ctx.Sender, msg)
}
internal/plugin/market.go
+18 -61
View File
@@ -1,10 +1,9 @@
package plugin
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"log/slog"
"math"
"net/http"
@@ -15,6 +14,7 @@ import (
"time"
"gogobee/internal/db"
"gogobee/internal/llm"
"maunium.net/go/mautrix"
"maunium.net/go/mautrix/id"
@@ -311,9 +311,7 @@ Do not use em dashes. Do not use exclamation marks. Do not offer financial advic
If markets are closed or data is stale, note it briefly and move on.`
func (p *MarketPlugin) generateDailySummary(date string) string {
host := os.Getenv("OLLAMA_HOST")
model := os.Getenv("OLLAMA_MODEL")
if host == "" || model == "" {
if !llmConfigured() {
return ""
}
@@ -349,7 +347,7 @@ func (p *MarketPlugin) generateDailySummary(date string) string {
}
prompt.WriteString("\nWrite a 2-3 sentence summary.")
result, err := p.callOllamaChat(host, model, marketSystemPrompt, prompt.String())
result, err := p.chatLLM(marketSystemPrompt, prompt.String())
if err != nil {
slog.Error("market: ollama summary failed", "err", err)
return ""
@@ -358,9 +356,7 @@ func (p *MarketPlugin) generateDailySummary(date string) string {
}
func (p *MarketPlugin) generateReportSummary(snapsByDate map[string][]marketSnapshot, dateRange string) string {
host := os.Getenv("OLLAMA_HOST")
model := os.Getenv("OLLAMA_MODEL")
if host == "" || model == "" {
if !llmConfigured() {
return ""
}
@@ -395,7 +391,7 @@ func (p *MarketPlugin) generateReportSummary(snapsByDate map[string][]marketSnap
}
prompt.WriteString("\nDescribe the trend in 2-3 sentences. Note any significant moves or divergences between indices.\nBe sardonic but accurate. Reference the VIX trajectory when relevant.")
result, err := p.callOllamaChat(host, model, marketSystemPrompt, prompt.String())
result, err := p.chatLLM(marketSystemPrompt, prompt.String())
if err != nil {
slog.Warn("market: ollama report summary failed", "err", err)
return ""
@@ -403,49 +399,14 @@ func (p *MarketPlugin) generateReportSummary(snapsByDate map[string][]marketSnap
return result
}
// callOllamaChat calls the Ollama /api/chat endpoint with a system and user message.
// Uses the types already defined in holdem_tips.go (same package).
func (p *MarketPlugin) callOllamaChat(host, model, systemPrompt, userPrompt string) (string, error) {
req := ollamaChatRequest{
Model: model,
Messages: []chatMessage{
{Role: "system", Content: systemPrompt},
{Role: "user", Content: userPrompt},
},
Stream: false,
}
body, err := json.Marshal(req)
if err != nil {
return "", fmt.Errorf("marshal: %w", err)
}
url := strings.TrimRight(host, "/") + "/api/chat"
resp, err := p.httpClient.Post(url, "application/json", bytes.NewReader(body))
if err != nil {
return "", fmt.Errorf("request: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
respBody, _ := io.ReadAll(resp.Body)
return "", fmt.Errorf("status %d: %s", resp.StatusCode, string(respBody))
}
var ollamaResp ollamaChatResponse
if err := json.NewDecoder(resp.Body).Decode(&ollamaResp); err != nil {
return "", fmt.Errorf("decode: %w", err)
}
text := ollamaResp.Message.Content
// Strip <think>...</think> blocks (reasoning models)
if i := strings.Index(text, "<think>"); i != -1 {
if j := strings.Index(text, "</think>"); j != -1 {
text = text[:i] + text[j+len("</think>"):]
}
}
return strings.TrimSpace(text), nil
// chatLLM sends a system+user pair to the configured backend. Both backends
// map this onto their own chat shape, so the market summaries read the same
// whichever one is serving.
func (p *MarketPlugin) chatLLM(systemPrompt, userPrompt string) (string, error) {
return llmGenerate(context.Background(), llm.Request{
System: systemPrompt,
Prompt: userPrompt,
})
}
// ── DB Helpers ───────────────────────────────────────────────────────────────
@@ -916,12 +877,10 @@ func (p *MarketPlugin) handleVixReport(ctx MessageContext) error {
}
var summary string
host := os.Getenv("OLLAMA_HOST")
model := os.Getenv("OLLAMA_MODEL")
if host != "" && model != "" {
if llmConfigured() {
prompt := fmt.Sprintf("VIX (fear index) data over %d days (%s to %s):\n%s\n\nDescribe the fear/greed trajectory in 2-3 sentences. Be sardonic but accurate.",
len(entries), entries[0].Date, entries[len(entries)-1].Date, strings.Join(prices, ", "))
summary, _ = p.callOllamaChat(host, model, marketSystemPrompt, prompt)
summary, _ = p.chatLLM(marketSystemPrompt, prompt)
}
var sb strings.Builder
@@ -1020,12 +979,10 @@ func (p *MarketPlugin) handleCompare(ctx MessageContext, args []string) error {
for _, e := range entries {
prices = append(prices, fmt.Sprintf("%.2f", e.Price))
}
host := os.Getenv("OLLAMA_HOST")
model := os.Getenv("OLLAMA_MODEL")
if host != "" && model != "" {
if llmConfigured() {
prompt := fmt.Sprintf("%s over %d days (%s to %s):\n%s\n\nDescribe the trend in 2-3 sentences. Be sardonic but accurate.",
idx.DisplayName, len(entries), entries[0].Date, entries[len(entries)-1].Date, strings.Join(prices, ", "))
if summary, err := p.callOllamaChat(host, model, marketSystemPrompt, prompt); err == nil && summary != "" {
if summary, err := p.chatLLM(marketSystemPrompt, prompt); err == nil && summary != "" {
sb.WriteString(summary)
sb.WriteString("\n\n")
}
internal/plugin/pete.go
+74 -2
View File
@@ -183,6 +183,12 @@ func emitFact(f peteclient.Fact, subjectUser, opponentUser id.UserID) {
}
}
f.Actors = actors
// Author the prose in Pete's voice from the FINAL fact, so the names in the
// dispatch match the Actors allow-list Pete guards against. Best-effort: an
// empty pair (LLM off or authoring failed) just means Pete templates the
// fact. Synchronous, like the holdem tip rewrite — news facts are infrequent
// and the call is tightly bounded (dispatchLLMTimeout).
f.Headline, f.Lede = authorDispatch(f)
peteclient.Emit(f)
}
@@ -273,8 +279,12 @@ func claimRealmFirst(kind, target string) bool {
// *started* — every dispatch was an outcome — which is why the two live boredom
// runs produced no news at all.
//
// The event_type must be one Pete already knows: an unknown type is a 400, which
// retries and then parks the bulletin forever. Deploy Pete first.
// The event_type no longer has to be one Pete already knows. It used to: an
// unknown type was a 400, which retried to the cap and then parked the bulletin
// forever, so shipping a new event type meant remembering to deploy Pete first.
// Pete now publishes an untemplated type on a neutral fallback and counts it for
// the operator, so the ordering rule is a property of the system rather than
// something a human has to hold.
func emitBoredomDeparture(userID id.UserID, zone ZoneDefinition, level int) {
if !peteclient.Enabled() || !newsEmissionOn() {
return
@@ -333,6 +343,68 @@ func emitZoneClearNews(userID id.UserID, exp *Expedition) {
Boss: zone.Boss.Name,
Level: lvl,
Outcome: "cleared",
RunID: latestRunIDForNews(userID),
OccurredAt: ts,
}, userID, "")
}
// treasureRarityWord maps a treasure def's tier to the rarity adjective Pete
// weaves into a find's dispatch. Story-grade treasures are typically tier 5, so
// "legendary" is the common case; the lower tiers are here for completeness.
func treasureRarityWord(tier int) string {
switch {
case tier >= 5:
return "legendary"
case tier == 4:
return "epic"
case tier == 3:
return "rare"
case tier == 2:
return "uncommon"
default:
return "common"
}
}
// emitTreasureFound files a story-grade treasure find. Only treasures carrying a
// RoomAnnounce string reach here — the same gate that earns them a public moment
// — so a copper-piece pickup never becomes news. The realm's first finder of a
// given treasure is a PRIORITY hoard; a later finder of the same item is a
// BULLETIN, the first/repeat split zone_first already uses. Character name only;
// no-op unless the seam is enabled.
//
// treasure_found is an event_type Pete's ingest must already know: an unknown
// type 400s, retries to the cap, then parks the bulletin forever. Deploy Pete
// first.
func emitTreasureFound(userID id.UserID, def *AdvTreasureDef, loc *AdvLocation) {
if !peteclient.Enabled() || !newsEmissionOn() {
return
}
if def == nil || loc == nil {
return
}
// Claim the realm-first BEFORE the name guard, so an unnamed straggler's
// genuine first find still seeds the ledger and the next finder isn't
// mis-billed as the first-ever. Mirrors emitZoneClearNews.
tier := "bulletin"
if claimRealmFirst("treasure", def.Key) {
tier = "priority"
}
name := charName(userID)
if name == "" {
return
}
ts := nowUnix()
disc := fmt.Sprintf("%s:%d", def.Key, ts)
emitFact(peteclient.Fact{
GUID: fmt.Sprintf("treasure_found:%s:%s:%d", eventToken(userID, disc), def.Key, ts),
EventType: "treasure_found",
Tier: tier,
Subject: name,
Zone: loc.Name,
Level: charLevel(userID),
Stakes: def.Name,
Outcome: treasureRarityWord(def.Tier),
OccurredAt: ts,
}, userID, "")
}
internal/plugin/pete_compare_test.go
+169
View File
@@ -0,0 +1,169 @@
package plugin
import (
"testing"
"gogobee/internal/peteclient"
)
// weapon/ring/wondrous helpers build a MagicItem the codified effect formula
// (magicItemEffectFor) can score without touching the DB.
func mkItem(kind MagicItemKind, rarity DnDRarity, slot DnDSlot) MagicItem {
return MagicItem{ID: string(kind) + "_" + string(rarity), Kind: kind, Rarity: rarity, Slot: slot}
}
// TestMagicItemDeltasDirection pins the "which way is better" call for each stat,
// including DamageReductMult where LOWER is the improvement.
func TestMagicItemDeltasDirection(t *testing.T) {
neutral := magicItemEffect{DamageReductMult: 1.0}
t.Run("more damage is better", func(t *testing.T) {
d := magicItemDeltas(magicItemEffect{DamageBonus: 0.15, DamageReductMult: 1.0}, magicItemEffect{DamageBonus: 0.10, DamageReductMult: 1.0})
if len(d) != 1 || d[0].Label != "damage" || !d[0].Better || d[0].Text != "+5% damage" {
t.Fatalf("got %+v", d)
}
})
t.Run("less damage taken is better", func(t *testing.T) {
// cand mult 0.90 (blocks 10%) vs worn neutral 1.0 (blocks nothing).
d := magicItemDeltas(magicItemEffect{DamageReductMult: 0.90}, neutral)
if len(d) != 1 || d[0].Label != "defense" || !d[0].Better || d[0].Text != "-10% damage taken" {
t.Fatalf("got %+v", d)
}
})
t.Run("weaker armor reads as worse", func(t *testing.T) {
// cand blocks less than worn: mult rises, damage taken goes up.
d := magicItemDeltas(magicItemEffect{DamageReductMult: 0.96}, magicItemEffect{DamageReductMult: 0.90})
if len(d) != 1 || d[0].Better || d[0].Text != "+6% damage taken" {
t.Fatalf("got %+v", d)
}
})
t.Run("hp and opening damage", func(t *testing.T) {
d := magicItemDeltas(
magicItemEffect{DamageReductMult: 1.0, MaxHP: 10, FlatDmgStart: 3},
magicItemEffect{DamageReductMult: 1.0, MaxHP: 6, FlatDmgStart: 5},
)
byLabel := map[string]itemDelta{}
for _, x := range d {
byLabel[x.Label] = itemDelta{x.Better, x.Text}
}
if v := byLabel["hp"]; v.text != "+4 HP" || !v.better {
t.Errorf("hp: %+v", v)
}
if v := byLabel["opening"]; v.text != "-2 opening damage" || v.better {
t.Errorf("opening: %+v", v)
}
})
t.Run("sub-percent change is dropped", func(t *testing.T) {
// 0.004 fraction = 0.4% → rounds to 0% → not a visible delta.
if d := magicItemDeltas(
magicItemEffect{DamageBonus: 0.104, DamageReductMult: 1.0},
magicItemEffect{DamageBonus: 0.100, DamageReductMult: 1.0},
); len(d) != 0 {
t.Fatalf("expected no visible delta, got %+v", d)
}
})
}
type itemDelta struct {
better bool
text string
}
// TestCompareVerdict pins strict-dominance classification and the overrides.
func TestCompareVerdict(t *testing.T) {
gain := []peteclient.ItemDelta{{Better: true}}
loss := []peteclient.ItemDelta{{Better: false}}
mixed := []peteclient.ItemDelta{{Better: true}, {Better: false}}
cases := []struct {
name string
deltas []peteclient.ItemDelta
empty, inrt bool
want string
}{
{"all gains", gain, false, false, "upgrade"},
{"all losses", loss, false, false, "downgrade"},
{"mixed", mixed, false, false, "sidegrade"},
{"no change", nil, false, false, "same"},
{"empty slot", gain, true, false, "new"},
{"inert overrides upgrade", gain, false, true, "inert"},
{"inert overrides new", gain, true, true, "inert"},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
if got := compareVerdict(c.deltas, c.empty, c.inrt); got != c.want {
t.Errorf("compareVerdict(%s) = %q, want %q", c.name, got, c.want)
}
})
}
}
// TestMagicItemCompareIntegration drives the whole builder against equipped maps.
func TestMagicItemCompareIntegration(t *testing.T) {
rareWpn := mkItem(MagicItemWeapon, RarityRare, DnDSlotMainHand) // +15% damage
uncWpn := mkItem(MagicItemWeapon, RarityUncommon, DnDSlotMainHand) // +10% damage
t.Run("upgrade over a weaker worn weapon", func(t *testing.T) {
eq := map[DnDSlot]EquippedMagicItem{DnDSlotMainHand: {Slot: DnDSlotMainHand, Item: uncWpn}}
c := magicItemCompare(rareWpn, 0, eq)
if c.Verdict != "upgrade" || c.VsName != uncWpn.Name || c.VsSlot != "main_hand" {
t.Fatalf("got %+v", c)
}
})
t.Run("downgrade under a stronger worn weapon", func(t *testing.T) {
eq := map[DnDSlot]EquippedMagicItem{DnDSlotMainHand: {Slot: DnDSlotMainHand, Item: rareWpn}}
if c := magicItemCompare(uncWpn, 0, eq); c.Verdict != "downgrade" {
t.Fatalf("got %+v", c)
}
})
t.Run("same as an identical worn weapon", func(t *testing.T) {
eq := map[DnDSlot]EquippedMagicItem{DnDSlotMainHand: {Slot: DnDSlotMainHand, Item: rareWpn}}
c := magicItemCompare(rareWpn, 0, eq)
if c.Verdict != "same" || len(c.Deltas) != 0 {
t.Fatalf("got %+v", c)
}
})
t.Run("new into an empty slot names no worn item", func(t *testing.T) {
c := magicItemCompare(rareWpn, 0, map[DnDSlot]EquippedMagicItem{})
if c.Verdict != "new" || c.VsName != "" || len(c.Deltas) == 0 {
t.Fatalf("got %+v", c)
}
})
t.Run("attunement item with no free bond is inert", func(t *testing.T) {
ring := mkItem(MagicItemRing, RarityRare, DnDSlotRing1)
ring.Attunement = true
// Three bonds spent elsewhere; the ring slot is empty. Wearing it does nothing.
eq := map[DnDSlot]EquippedMagicItem{
DnDSlotChest: {Slot: DnDSlotChest, Item: mkItem(MagicItemArmor, RarityRare, DnDSlotChest), Attuned: true},
DnDSlotAmulet: {Slot: DnDSlotAmulet, Item: mkItem(MagicItemWondrous, RarityRare, DnDSlotAmulet), Attuned: true},
DnDSlotCloak: {Slot: DnDSlotCloak, Item: mkItem(MagicItemWondrous, RarityRare, DnDSlotCloak), Attuned: true},
}
if c := magicItemCompare(ring, 0, eq); c.Verdict != "inert" {
t.Fatalf("got %+v", c)
}
})
t.Run("evicting the worn occupant frees its bond, so not inert", func(t *testing.T) {
ring := mkItem(MagicItemRing, RarityRare, DnDSlotRing1)
ring.Attunement = true
wornRing := mkItem(MagicItemRing, RarityUncommon, DnDSlotRing1)
wornRing.Attunement = true
// Three bonds spent — but one of them is the ring the candidate would replace.
eq := map[DnDSlot]EquippedMagicItem{
DnDSlotRing1: {Slot: DnDSlotRing1, Item: wornRing, Attuned: true},
DnDSlotChest: {Slot: DnDSlotChest, Item: mkItem(MagicItemArmor, RarityRare, DnDSlotChest), Attuned: true},
DnDSlotAmulet: {Slot: DnDSlotAmulet, Item: mkItem(MagicItemWondrous, RarityRare, DnDSlotAmulet), Attuned: true},
}
if c := magicItemCompare(ring, 0, eq); c.Verdict == "inert" {
t.Fatalf("bond freed by eviction, should not be inert: %+v", c)
}
})
}
internal/plugin/pete_detail_test.go
+55 -3
View File
@@ -138,7 +138,7 @@ func TestDetailSnapshotKeyedByLocalpart(t *testing.T) {
t.Fatalf("saveAdvCharacter: %v", err)
}
snap, err := buildDetailSnapshot(time.Now().UTC())
snap, err := (&AdventurePlugin{}).buildDetailSnapshot(time.Now().UTC())
if err != nil {
t.Fatalf("buildDetailSnapshot: %v", err)
}
@@ -189,7 +189,7 @@ func TestDetailSnapshotIgnoresOptOut(t *testing.T) {
}
// ...but the private detail set keeps them both.
detail, err := buildDetailSnapshot(time.Now().UTC())
detail, err := (&AdventurePlugin{}).buildDetailSnapshot(time.Now().UTC())
if err != nil {
t.Fatalf("buildDetailSnapshot: %v", err)
}
@@ -218,7 +218,7 @@ func TestDetailSnapshotSkipsDeadPlayers(t *testing.T) {
t.Fatalf("kill player: %v", err)
}
snap, err := buildDetailSnapshot(time.Now().UTC())
snap, err := (&AdventurePlugin{}).buildDetailSnapshot(time.Now().UTC())
if err != nil {
t.Fatalf("buildDetailSnapshot: %v", err)
}
@@ -226,3 +226,55 @@ func TestDetailSnapshotSkipsDeadPlayers(t *testing.T) {
t.Fatalf("detail set = %+v, want just the living player", snap.Players)
}
}
// TestPetXPRidesTheCurveNotACopyOfIt pins the unit and the cap, which are the two
// ways this can go quietly wrong on the web. XP is stored in centi-XP — a pet
// earns 1.5 points an action and the ledger is an int — so a page that read XP
// against a whole-number threshold would draw a bar 100x too full. And a capped
// pet must report 0 needed rather than the next band's number, or its bar sits
// forever short of a level it can never gain.
func TestPetXPRidesTheCurveNotACopyOfIt(t *testing.T) {
newMischiefTestDB(t)
uid := id.UserID("@quack:test")
seedDetailPlayer(t, uid, "Quack", 7)
adv, err := loadAdvCharacter(uid)
if err != nil {
t.Fatalf("loadAdvCharacter: %v", err)
}
adv.PetType = "cat"
adv.PetName = "Mittens"
adv.PetLevel = 4
adv.PetXP = 750 // 7.5 of the 20 points level 4 wants
adv.Pet2Type = "dog"
adv.Pet2Name = "Rex"
adv.Pet2Level = petMaxLevel
adv.Pet2XP = 0
if err := saveAdvCharacter(adv); err != nil {
t.Fatalf("saveAdvCharacter: %v", err)
}
snap, err := (&AdventurePlugin{}).buildDetailSnapshot(time.Now().UTC())
if err != nil {
t.Fatalf("buildDetailSnapshot: %v", err)
}
pets := snap.Players[0].Pets
if len(pets) != 2 {
t.Fatalf("pets = %+v, want both slots", pets)
}
byName := map[string]int{}
for i, p := range pets {
byName[p.Name] = i
}
mittens := pets[byName["Mittens"]]
if mittens.XP != 750 {
t.Errorf("Mittens XP = %d, want the stored centi-XP 750", mittens.XP)
}
if want := petXPToNextLevel(4) * 100; mittens.XPNeeded != want {
t.Errorf("Mittens XPNeeded = %d, want %d — the curve is in centi-XP too",
mittens.XPNeeded, want)
}
if rex := pets[byName["Rex"]]; rex.XPNeeded != 0 {
t.Errorf("a capped pet needs %d more XP; want 0, meaning nothing left to earn", rex.XPNeeded)
}
}
internal/plugin/pete_dispatch_voice.go
+169
View File
@@ -0,0 +1,169 @@
package plugin
import (
"context"
"encoding/json"
"fmt"
"log/slog"
"strings"
"time"
"gogobee/internal/llm"
"gogobee/internal/peteclient"
)
// LLM-authored adventure dispatches. gogobee owns the raw model compute; this is
// where a structured fact becomes warm-reporter prose for Pete to publish. Pete
// is still the editor and the safety boundary: it runs its own prose-guard over
// whatever we send and falls back to its templates on anything it does not like,
// so authoring here is best-effort by design — every failure path returns an
// empty pair and Pete templates the fact.
//
// The voice must live somewhere, and with no route for Pete to call back into
// this box (see roster.go in the Pete repo) it lives in the prompt below. Keep
// it faithful to pete_adventure_news_voice.md; Pete's persona, not gogobee's.
// dispatchLLMTimeout bounds the authoring call. emitFact runs on game-event
// chokepoints (a party wipe fires one per member), so this is deliberately far
// tighter than the interactive 120s tip budget: if the model cannot turn a
// handful of facts into two sentences this fast, it is effectively down, and a
// template dispatch now beats a voiced one late.
const dispatchLLMTimeout = 15 * time.Second
// Length ceilings, mirrored from Pete's proseGuard so we never ship prose Pete
// will reject for length alone. Byte counts, matching Pete's len() check.
const (
maxDispatchHeadline = 200
maxDispatchLede = 800
)
// authorDispatch turns a fact into a headline+lede in Pete's voice, or returns
// two empty strings if the model is unconfigured, errors, times out, or produces
// anything malformed. The fact must already have its FINAL Actors set (post
// opt-out anonymisation) — that list is the only set of names the prose may use,
// and it is what Pete's guard checks the output against.
func authorDispatch(f peteclient.Fact) (headline, lede string) {
if !llmConfigured() {
return "", ""
}
prompt := buildDispatchPrompt(f)
raw, err := callLLMDispatch(dispatchLLMTimeout, prompt)
if err != nil {
slog.Warn("pete dispatch: LLM authoring failed, Pete will template", "guid", f.GUID, "err", err)
return "", ""
}
h, l, ok := parseDispatch(raw)
if !ok {
slog.Warn("pete dispatch: unparseable LLM output, Pete will template", "guid", f.GUID)
return "", ""
}
// Ship only a complete, in-bounds pair. A half-authored dispatch or an
// over-long one is exactly what Pete would reject anyway; catch it here so a
// bad generation costs nothing on the wire.
if h == "" || l == "" || len(h) > maxDispatchHeadline || len(l) > maxDispatchLede {
slog.Warn("pete dispatch: LLM output empty or over length, Pete will template",
"guid", f.GUID, "headline_len", len(h), "lede_len", len(l))
return "", ""
}
return h, l
}
// buildDispatchPrompt renders the persona, the strict rules, and this fact's
// structured facts into a single prompt. The facts block lists only the fields
// that are set, each labelled, so the model has the who/what/where and no room
// to invent the rest.
func buildDispatchPrompt(f peteclient.Fact) string {
var facts strings.Builder
add := func(label, val string) {
if val != "" {
fmt.Fprintf(&facts, "- %s: %s\n", label, val)
}
}
addN := func(label string, n int) {
if n != 0 {
fmt.Fprintf(&facts, "- %s: %d\n", label, n)
}
}
add("event", f.EventType)
add("who this is about (the subject)", f.Subject)
add("the other person named", f.Opponent)
add("monster or boss", f.Boss)
add("dungeon or zone", f.Zone)
add("region", f.Region)
addN("character level", f.Level)
addN("count", f.Count)
add("outcome", f.Outcome)
add("stakes or item", f.Stakes)
add("class and race", f.ClassRace)
add("milestone", f.Milestone)
names := "(none — this is a realm-level event with no named adventurer)"
if len(f.Actors) > 0 {
names = strings.Join(f.Actors, ", ")
}
return fmt.Sprintf(`You are Pete, a warm, friendly local news reporter for a fantasy adventuring town. Think a beloved local newscaster who genuinely knows everyone and is glad to see them. You have journalistic bones — a clear headline and a who/what/where lede that gets the facts right — delivered with personable, first-person warmth. You root for the community, celebrate wins, mourn losses gently, welcome newcomers. Conversational, never snarky, never a caps-lock hype-man. Warmth carries the register, not exclamation marks.
Write a short news dispatch about the event below.
STRICT RULES — do not violate these:
- Use ONLY these adventurer names, exactly as written: %s. Never invent a name, never use any other person's name, never use an @-handle.
- Use ONLY the facts listed. Do not invent numbers, outcomes, items, or events that are not below.
- The monster/boss, zone, region and item names are game names — you may use them as given.
- Do not address the reader as "you" unless the event is Pete's own duel.
- No markdown, no emoji, no quotation marks around the whole thing.
Respond with ONLY a JSON object, no other text:
{"headline": "one short sentence, a real headline", "lede": "one to three warm sentences with the who/what/where"}
The event:
%s`, names, facts.String())
}
// callLLMDispatch posts a single non-streaming generation and returns the raw
// completion. The timeout is a parameter because the two callers have genuinely
// different patience: a dispatch is authored on a game chokepoint and must not
// stall it, while a run summary rides a background ticker and can afford to wait
// for a bigger model. See runSummaryTimeout.
func callLLMDispatch(timeout time.Duration, prompt string) (string, error) {
return llmGenerate(context.Background(), llm.Request{
Prompt: prompt,
NumCtx: 4096,
Timeout: timeout,
})
}
// parseDispatch pulls {headline, lede} out of the model's completion, tolerating
// the usual noise (think blocks, markdown fences, prose around the JSON). ok is
// false when no JSON object with a headline can be recovered.
func parseDispatch(raw string) (headline, lede string, ok bool) {
s := raw
// Drop a Qwen-style reasoning block if present.
if i := strings.Index(s, "<think>"); i != -1 {
if j := strings.Index(s, "</think>"); j != -1 {
s = s[:i] + s[j+len("</think>"):]
}
}
// Isolate the first {...} object so surrounding prose or fences don't break
// the decode.
start := strings.Index(s, "{")
end := strings.LastIndex(s, "}")
if start < 0 || end <= start {
return "", "", false
}
var out struct {
Headline string `json:"headline"`
Lede string `json:"lede"`
}
if err := json.Unmarshal([]byte(s[start:end+1]), &out); err != nil {
return "", "", false
}
headline = strings.TrimSpace(out.Headline)
lede = strings.TrimSpace(out.Lede)
if headline == "" {
return "", "", false
}
return headline, lede, true
}
internal/plugin/pete_dispatch_voice_test.go
+81
View File
@@ -0,0 +1,81 @@
package plugin
import (
"strings"
"testing"
"gogobee/internal/peteclient"
)
func TestParseDispatch(t *testing.T) {
cases := []struct {
name string
raw string
wantOK bool
wantHeadPre string
}{
{
name: "clean json",
raw: `{"headline": "Josie cleared the Ossuary.", "lede": "Alone, no less."}`,
wantOK: true,
wantHeadPre: "Josie cleared",
},
{
name: "wrapped in prose and fences",
raw: "Sure! Here you go:\n```json\n{\"headline\":\"A win.\",\"lede\":\"Nice one.\"}\n```",
wantOK: true,
wantHeadPre: "A win.",
},
{
name: "think block stripped",
raw: "<think>let me consider the tone</think>\n{\"headline\":\"Held the line.\",\"lede\":\"Proud of you all.\"}",
wantOK: true,
wantHeadPre: "Held the line.",
},
{name: "no json", raw: "I could not write that.", wantOK: false},
{name: "empty headline", raw: `{"headline":"","lede":"body"}`, wantOK: false},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
h, l, ok := parseDispatch(c.raw)
if ok != c.wantOK {
t.Fatalf("ok = %v, want %v (h=%q l=%q)", ok, c.wantOK, h, l)
}
if ok && !strings.HasPrefix(h, c.wantHeadPre) {
t.Errorf("headline = %q, want prefix %q", h, c.wantHeadPre)
}
})
}
}
// TestBuildDispatchPrompt pins the two properties the prose-guard depends on:
// the allowed names are stated verbatim, and only the set facts appear (no empty
// labels for the model to fill in with invention).
func TestBuildDispatchPrompt(t *testing.T) {
f := peteclient.Fact{
EventType: "boss_kill", Subject: "Josie", Boss: "the Bone Warden",
Zone: "the Ossuary", Level: 14, Actors: []string{"Josie"},
}
p := buildDispatchPrompt(f)
if !strings.Contains(p, "ONLY these adventurer names, exactly as written: Josie") {
t.Errorf("prompt does not constrain names to Actors:\n%s", p)
}
if !strings.Contains(p, "the Bone Warden") || !strings.Contains(p, "the Ossuary") {
t.Error("prompt dropped a supplied fact")
}
// Unset fields must not appear as empty labels.
if strings.Contains(p, "region:") || strings.Contains(p, "milestone:") {
t.Errorf("prompt lists an unset fact:\n%s", p)
}
}
// TestBuildDispatchPromptRealmEvent: a realm-level fact with no named adventurer
// still produces a usable prompt that tells the model there is no name to use.
func TestBuildDispatchPromptRealmEvent(t *testing.T) {
f := peteclient.Fact{EventType: "siege_start", Boss: "the Horde", Stakes: "the whole town"}
p := buildDispatchPrompt(f)
if !strings.Contains(p, "no named adventurer") {
t.Errorf("realm event prompt missing the no-name note:\n%s", p)
}
}
internal/plugin/pete_equip.go
+282
View File
@@ -0,0 +1,282 @@
package plugin
// The web equip queue's game-side loop.
//
// An owner asks, on their own detail page on Pete, to wear or take off an item.
// Pete records the intent; we poll for it, run the real equip against our own
// equipment tables, and file a verdict Pete shows them. Same reverse-pipe shape
// as mischief — Pete has no route into this box, so we ask for work rather than
// being told about it.
//
// The one thing that is NOT like mischief: the underlying action isn't
// idempotent. Equipping consumes an inventory row and unequipping mints a fresh
// one, so simply re-running a re-offered order would double-move the item. So
// before we touch anything we check the equip_applied_orders ledger: if this
// order's guid is already there, the mutation happened on an earlier tick and we
// only lost the verdict-ack — we re-file the stored verdict and mutate nothing.
// The guid is still the end-to-end key; here it guards a non-idempotent action
// instead of riding a naturally idempotent one.
import (
"context"
"database/sql"
"errors"
"fmt"
"log/slog"
"strings"
"time"
"gogobee/internal/db"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
const (
equipPollInterval = 30 * time.Second
equipPollTimeout = 20 * time.Second
)
// peteEquipTicker polls Pete for equip orders and fulfils them. Started alongside
// the other adventure tickers; exits on stopCh.
func (p *AdventurePlugin) peteEquipTicker() {
if !peteclient.Enabled() {
return // no Pete wire configured; the equip queue is simply off
}
ticker := time.NewTicker(equipPollInterval)
defer ticker.Stop()
for {
select {
case <-p.stopCh:
return
case <-ticker.C:
p.pollEquipOrders()
}
}
}
func (p *AdventurePlugin) pollEquipOrders() {
ctx, cancel := context.WithTimeout(context.Background(), equipPollTimeout)
defer cancel()
orders, err := peteclient.PendingEquip(ctx)
if err != nil {
// A Pete predating the queue answers 404; a wire blip looks the same. Quiet
// on purpose — this must not spam while Pete hasn't shipped the endpoint.
slog.Debug("equip: poll failed", "err", err)
return
}
for _, order := range orders {
p.fulfilEquipOrder(ctx, order)
}
}
// fulfilEquipOrder applies one order and files its verdict. A transient failure is
// left pending for the next poll (no verdict); a permanent one gets a specific
// rejection. The guid ledger makes a re-offer after a lost ack a no-op that simply
// re-files the verdict.
func (p *AdventurePlugin) fulfilEquipOrder(ctx context.Context, order peteclient.EquipOrder) {
// Already applied on an earlier tick? Re-file the stored verdict, mutate nothing.
if status, detail, ok := equipOrderAlreadyApplied(order.GUID); ok {
if err := peteclient.VerdictEquip(ctx, order.GUID, status, detail); err != nil {
slog.Warn("equip: re-file verdict push failed, will retry next poll",
"order", order.GUID, "status", status, "err", err)
}
return
}
owner, ok := p.equipOwnerMXID(order.OwnerLocalpart)
if !ok {
// The client isn't up (tests) or the localpart is empty. Not our order to
// fail permanently — leave it pending and try again once we can name the owner.
slog.Debug("equip: cannot resolve owner, leaving pending", "order", order.GUID, "owner", order.OwnerLocalpart)
return
}
status, detail, retry := p.applyEquipOrder(owner, order)
if retry {
return // transient; leave pending for the next tick
}
// Record the verdict BEFORE pushing it, so a crash after the mutation still
// short-circuits next tick and re-files rather than re-applying. The mutation
// and this insert aren't one transaction, but the window between them is a
// single statement — the same practical guarantee the DM equip path lives with.
if err := recordEquipApplied(order.GUID, status, detail); err != nil {
// If we can't record it, don't push the verdict either: leave the order
// pending so the ledger and Pete stay in step. Re-running an equip is the
// double-move we're guarding against, so a rare re-apply here is the lesser
// evil versus a verdict with no ledger behind it. Transient; retry.
slog.Warn("equip: failed to record applied order, leaving pending",
"order", order.GUID, "status", status, "err", err)
return
}
if err := peteclient.VerdictEquip(ctx, order.GUID, status, detail); err != nil {
slog.Warn("equip: verdict push failed, will re-file next poll",
"order", order.GUID, "status", status, "err", err)
return
}
slog.Info("equip: web order fulfilled", "order", order.GUID, "action", order.Action, "status", status)
}
// applyEquipOrder runs the real equip/unequip. It returns the terminal status and
// a human note for Pete, or retry=true for a transient fault that should leave the
// order pending. It records nothing and pushes nothing — the caller does both.
func (p *AdventurePlugin) applyEquipOrder(owner id.UserID, order peteclient.EquipOrder) (status, detail string, retry bool) {
// Serialize against the owner's own Matrix-side mutations (!give, !equip, !sell,
// arena, …), all of which hold this same per-user lock. Without it the poll
// goroutine's equip could interleave with a concurrent !give of the very item it
// resolved — the duplication the DM equip confirm takes this lock to prevent.
userMu := p.advUserLock(owner)
userMu.Lock()
defer userMu.Unlock()
switch order.Action {
case "equip":
inv, err := loadAdvInventory(owner)
if err != nil {
return "", "", true // transient
}
var it AdvItem
found := false
for _, cand := range inv {
if cand.ID == order.ItemID {
it, found = cand, true
break
}
}
if !found {
// The row left the pack before we got here (worn already, sold, a stale
// page). The table is AUTOINCREMENT, so the id can't have been reused for
// a different item — this is a clean miss, not a wrong hit.
return "rejected_not_owned", "That item wasn't in your pack anymore.", false
}
// Masterwork/arena pieces equip into a standard slot; everything else takes
// the magic-item path. Type alone routes it — the id resolved the same row.
if it.Type == "MasterworkGear" || it.Type == "ArenaGear" {
out, err := applyMasterworkEquip(owner, it)
if errors.Is(err, errItemNotEquippable) {
return "rejected_not_equippable", "That item can't be worn.", false
}
if errors.Is(err, errEquipDowngrade) {
return "rejected_downgrade", "That isn't an upgrade over what you're wearing.", false
}
if err != nil {
return "", "", true // transient DB fault
}
return "applied", masterworkEquipDetail(out), false
}
out, err := applyMagicEquip(owner, it)
if errors.Is(err, errItemNotEquippable) {
return "rejected_not_equippable", "That item can't be worn.", false
}
if err != nil {
return "", "", true // transient DB fault
}
return "applied", equipAppliedDetail(out), false
case "unequip":
// A standard slot (weapon/armor/…) takes a masterwork/arena piece off; a DnD
// slot takes a magic item off. The vocabularies are disjoint, so the slot
// string alone tells the two apart.
if isEquipmentSlot(order.Slot) {
out, err := applyMasterworkUnequip(owner, EquipmentSlot(order.Slot))
if errors.Is(err, errSlotEmpty) {
return "rejected_not_worn", "There was nothing to take off there.", false
}
if err != nil {
return "", "", true
}
return "applied", fmt.Sprintf("Took %s off, back in your pack.", out.Name), false
}
out, err := applyMagicUnequip(owner, DnDSlot(order.Slot))
if errors.Is(err, errSlotEmpty) {
return "rejected_not_worn", "That slot was already empty.", false
}
if err != nil {
return "", "", true
}
note := fmt.Sprintf("Took off %s, back in your pack.", out.Item.Name)
if len(out.Healed) > 0 {
note += fmt.Sprintf(" That freed a bond, so %s is active now.", strings.Join(out.Healed, ", "))
}
return "applied", note, false
case "upgrade":
return p.purchaseEquipmentTier(owner, EquipmentSlot(order.Slot), order.Tier, order.GUID)
case "repair":
return p.repairSlot(owner, EquipmentSlot(order.Slot), order.GUID)
default:
// Pete validates the action before it ever queues an order, so this is a
// contract breach, not a user mistake. Reject permanently rather than spin.
return "rejected_not_equippable", "Unknown action.", false
}
}
// equipAppliedDetail turns an equip outcome into the plain note Pete shows.
func equipAppliedDetail(out magicEquipOutcome) string {
b := fmt.Sprintf("Now worn in your %s slot.", out.Effective.Slot)
switch {
case out.Bonded:
b += fmt.Sprintf(" Bonded (%d of %d).", out.BondsBefore+1, dndMagicItemAttuneLimit)
case out.AtCap:
b += fmt.Sprintf(" Worn but inert: all %d bonds are in use, so take one off to activate it.", dndMagicItemAttuneLimit)
}
if out.SwappedBack != "" {
b += fmt.Sprintf(" %s went back to your pack.", out.SwappedBack)
}
if len(out.Healed) > 0 {
b += fmt.Sprintf(" A freed bond also activated %s.", strings.Join(out.Healed, ", "))
}
return b
}
// equipOwnerMXID reconstructs the owner's Matrix id from the localpart Pete sent,
// the same construction as the mischief buyer's. Fails closed if the client isn't
// up (tests) or the name is empty.
func (p *AdventurePlugin) equipOwnerMXID(localpart string) (id.UserID, bool) {
lp := strings.ToLower(strings.TrimSpace(localpart))
if lp == "" || p.Client == nil {
return "", false
}
server := p.Client.UserID.Homeserver()
if server == "" {
return "", false
}
return id.NewUserID(lp, server), true
}
// ---- the applied-order ledger --------------------------------------------------
// equipOrderAlreadyApplied reports the verdict we filed for an order, if we have
// already applied it. This is the short-circuit that keeps a re-offered order from
// re-running its non-idempotent mutation.
func equipOrderAlreadyApplied(guid string) (status, detail string, ok bool) {
err := db.Get().QueryRow(
`SELECT status, detail FROM equip_applied_orders WHERE guid = ?`, guid,
).Scan(&status, &detail)
if errors.Is(err, sql.ErrNoRows) {
return "", "", false
}
if err != nil {
// A read failure here would send us down the mutation path and risk a
// double-move, so treat it as "don't know" and let the caller leave the
// order pending rather than assume it's fresh. We signal that by returning
// ok=false but... the caller can't tell the difference. Log loudly; a
// persistent read failure is a real problem, but a transient one self-heals
// on the next poll because the mutation itself is guarded by this same table.
slog.Error("equip: applied-ledger read failed", "order", guid, "err", err)
return "", "", false
}
return status, detail, true
}
// recordEquipApplied stamps an order as applied with the verdict we're about to
// file. OR IGNORE so a re-file that somehow reaches here can't error on the guid.
func recordEquipApplied(guid, status, detail string) error {
_, err := db.Get().Exec(
`INSERT OR IGNORE INTO equip_applied_orders (guid, status, detail) VALUES (?, ?, ?)`,
guid, status, detail)
return err
}
internal/plugin/pete_equip_manage.go
+340
View File
@@ -0,0 +1,340 @@
package plugin
// Ask 7: full equipment management from the web.
//
// The magic-item equip path (magic_items_gameplay.go) only ever touched the DnD
// slots — off_hand, rings, and the like — which are almost always empty. Almost
// everything a player actually wears lives in the OTHER two systems: the 5
// standard EquipmentSlots (weapon/armor/helmet/boots/tool), whose power is the
// slot's integer Tier, and the masterwork/arena pieces that get equipped INTO a
// standard slot. This file is the game-side of managing all of that from Pete:
//
// - applyMasterworkEquip / applyMasterworkUnequip — move a masterwork/arena
// piece between the pack and a standard slot (no money).
// - purchaseEquipmentTier — buy the next standard tier with euros (confirm-gated
// on the web), the headless twin of the shop's advBuyEquipment.
// - repairSlot — mend a slot's condition with euros, the headless twin of the
// blacksmith's executeRepair.
// - buildEquipSlotViews — the owner-only snapshot the web panel renders from.
//
// The two euro-spending mutators run on the retrying poll wire, so every money
// move goes through the idempotent euro variants keyed on the order guid: a
// re-offered order that already debited skips the charge and just re-runs the
// idempotent slot write. That is why neither refunds on a later DB fault — a
// refund keyed on a fresh id, followed by a guid-guarded retry that no longer
// re-debits, would hand the player both the gear and their money back. The casino
// escrow (pete_games.go) settles the same way: idempotent move, then retry.
import (
"errors"
"fmt"
"log/slog"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
// errEquipDowngrade is a permanent refusal: the incoming piece is no better than
// what is worn. Downgrades are blocked by user decision (equip and upgrade both).
var errEquipDowngrade = errors.New("equip: would be a downgrade")
// mwEquipOutcome is what a masterwork/arena equip did, for the verdict note.
type mwEquipOutcome struct {
Name string
Slot EquipmentSlot
Tier int
Arena bool
SwappedBack string // the special occupant evicted back to the pack, or ""
}
// applyMasterworkEquip wears one masterwork/arena backpack piece into its standard
// slot. Ordering is anti-duplication AND safe under the equip poll's 30s retry:
// remove the incoming row FIRST (restoring it on a save fault), then write the
// slot, and only THEN evict any displaced special occupant back to the pack. The
// eviction comes last, once the slot no longer references the occupant, so it can
// never mint a duplicate; and it is best-effort — a failure there is logged, not
// aborted on, the same tolerance the DM confirm handler (adventure_masterwork.go)
// lives with. Aborting after the slot write would strand a completed equip for a
// retry that re-evicts the occupant on every tick.
func applyMasterworkEquip(uid id.UserID, it AdvItem) (mwEquipOutcome, error) {
if it.Slot == "" || (it.Type != "MasterworkGear" && it.Type != "ArenaGear") {
return mwEquipOutcome{}, errItemNotEquippable
}
equip, err := loadAdvEquipment(uid)
if err != nil {
return mwEquipOutcome{}, err
}
slot := it.Slot
cur := equip[slot]
// Downgrade block: the incoming effective tier must beat the current occupant.
incoming := &AdvEquipment{Tier: it.Tier}
if it.Type == "ArenaGear" {
incoming.ArenaTier = it.Tier
} else {
incoming.Masterwork = true
}
if advEffectiveTier(incoming) <= advEffectiveTier(cur) {
return mwEquipOutcome{}, errEquipDowngrade
}
// Capture the special occupant to evict, if any, BEFORE the slot write below
// mutates cur in place. A plain shop-tier occupant is not an item — it is just
// the slot's tier — so it is overwritten, not evicted, the same as the DM confirm
// handler and the shop. The actual re-pack happens after the slot write (below),
// so it can never duplicate the piece.
var evicted *AdvItem
if cur != nil && (cur.Masterwork || cur.ArenaTier > 0) {
old := AdvItem{Name: cur.Name, Type: "MasterworkGear", Tier: cur.Tier, Slot: slot, SkillSource: cur.SkillSource}
if cur.ArenaTier > 0 {
old.Type = "ArenaGear"
}
evicted = &old
}
// Destructive op first: pull the incoming row before writing the slot, so a save
// fault can't leave it both worn and in the pack. Restore it on failure.
if err := removeAdvInventoryItem(it.ID); err != nil {
return mwEquipOutcome{}, err
}
eq := cur
if eq == nil {
eq = &AdvEquipment{Slot: slot}
}
eq.Tier = it.Tier
eq.Condition = 100
eq.Name = it.Name
eq.ActionsUsed = 0
if it.Type == "ArenaGear" {
eq.Masterwork = false
eq.SkillSource = ""
eq.ArenaTier = it.Tier
eq.ArenaSet = ""
if gs := arenaGearByName(it.Name); gs != nil {
eq.ArenaSet = gs.SetKey
}
} else {
eq.ArenaTier = 0
eq.ArenaSet = ""
eq.Masterwork = true
eq.SkillSource = it.SkillSource
}
if err := saveAdvEquipment(uid, eq); err != nil {
restored := AdvItem{Name: it.Name, Type: it.Type, Tier: it.Tier, Value: it.Value, Slot: it.Slot, SkillSource: it.SkillSource}
if rbErr := addAdvInventoryItem(uid, restored); rbErr != nil {
slog.Error("equip: masterwork save failed AND inventory rollback failed",
"user", uid, "item", it.Name, "save_err", err, "rollback_err", rbErr)
}
return mwEquipOutcome{}, err
}
// The slot now holds the incoming piece, so the former occupant is referenced
// nowhere — re-packing it now cannot duplicate it. Best-effort: a failure is a
// bounded, non-compounding loss we log rather than abort on, since the equip has
// already succeeded and aborting would re-run (and re-evict) on the next poll.
var swappedBack string
if evicted != nil {
if err := addAdvInventoryItem(uid, *evicted); err != nil {
slog.Error("equip: masterwork equipped but evicted piece failed to return to pack",
"user", uid, "evicted", evicted.Name, "err", err)
} else {
swappedBack = evicted.Name
}
}
return mwEquipOutcome{Name: it.Name, Slot: slot, Tier: it.Tier, Arena: it.Type == "ArenaGear", SwappedBack: swappedBack}, nil
}
// mwUnequipOutcome is what a masterwork/arena take-off did.
type mwUnequipOutcome struct {
Name string
Slot EquipmentSlot
}
// applyMasterworkUnequip takes a worn masterwork/arena piece off a standard slot,
// returns it to the pack, and resets the slot to its tier-0 default. A plain
// shop-tier slot has nothing round-trippable (its tier is not an item), so that is
// errSlotEmpty — reverting a shop tier is not a take-off. The 5 slot rows are an
// invariant (PK user_id+slot), so the row is reset, never deleted. Destructive op
// first — reset the slot, then mint the pack row, restoring the slot on failure —
// mirroring the magic unequip so a fault can't duplicate the piece.
func applyMasterworkUnequip(uid id.UserID, slot EquipmentSlot) (mwUnequipOutcome, error) {
equip, err := loadAdvEquipment(uid)
if err != nil {
return mwUnequipOutcome{}, err
}
cur := equip[slot]
if cur == nil || (!cur.Masterwork && cur.ArenaTier == 0) {
return mwUnequipOutcome{}, errSlotEmpty
}
prev := *cur // snapshot for rollback
def0 := equipmentTiers[slot][0]
reset := &AdvEquipment{Slot: slot, Tier: 0, Condition: 100, Name: def0.Name, ActionsUsed: 0, ArenaTier: 0, ArenaSet: "", Masterwork: false, SkillSource: ""}
if err := saveAdvEquipment(uid, reset); err != nil {
return mwUnequipOutcome{}, err
}
old := AdvItem{Name: cur.Name, Type: "MasterworkGear", Tier: cur.Tier, Slot: slot, SkillSource: cur.SkillSource}
if cur.ArenaTier > 0 {
old.Type = "ArenaGear"
}
if err := addAdvInventoryItem(uid, old); err != nil {
if rbErr := saveAdvEquipment(uid, &prev); rbErr != nil {
slog.Error("equip: masterwork take-off failed AND slot rollback failed",
"user", uid, "slot", slot, "add_err", err, "rollback_err", rbErr)
}
return mwUnequipOutcome{}, err
}
return mwUnequipOutcome{Name: cur.Name, Slot: slot}, nil
}
// purchaseEquipmentTier buys a standard slot's tier with euros — the headless twin
// of advBuyEquipment, minus flavor. It returns a terminal verdict for Pete or
// retry=true for a transient fault. Money moves once, keyed on the order guid; the
// web only ever offers the next tier over a PLAIN shop-tier slot (buildEquipSlotViews
// suppresses the offer on special gear), so there is no occupant to evict here and
// the whole body is idempotent under a re-offered order.
func (p *AdventurePlugin) purchaseEquipmentTier(uid id.UserID, slot EquipmentSlot, tier int, guid string) (status, detail string, retry bool) {
defs, ok := equipmentTiers[slot]
if !ok {
return "rejected_not_equippable", "That isn't an equipment slot.", false
}
if tier < 1 || tier >= len(defs) {
// tier 0 is the free default, not a purchase; >= len is past the top tier.
return "rejected_max_tier", "That slot is already at the top tier.", false
}
def := defs[tier]
equip, err := loadAdvEquipment(uid)
if err != nil {
return "", "", true
}
cur := equip[slot]
if cur != nil {
// Buying a shop tier over a special piece strips its bonus — a downgrade in
// practice even when the raw number rises. Take it off first, then buy.
if cur.Masterwork || cur.ArenaTier > 0 {
return "rejected_downgrade", "Take off your special gear in that slot before buying a tier.", false
}
if cur.Tier >= def.Tier {
return "rejected_downgrade", "You already have that tier or better.", false
}
}
price := def.Price
if !p.euro.HasExternalTx(guid) {
ok, _, err := p.euro.DebitIdem(uid, price, "adventure_equip_upgrade", guid)
if err != nil {
return "", "", true
}
if !ok {
return "rejected_insufficient_funds", fmt.Sprintf("That upgrade costs €%.0f and you can't cover it.", price), false
}
}
eq := &AdvEquipment{Slot: slot, Tier: def.Tier, Condition: 100, Name: def.Name, ActionsUsed: 0}
if err := saveAdvEquipment(uid, eq); err != nil {
// No refund: the debit is guid-idempotent, so the next poll re-runs this with
// the charge already settled and only the (idempotent) slot write left to do.
// Refunding here would double-pay once that retry lands the gear.
return "", "", true
}
return "applied", fmt.Sprintf("Upgraded your %s to %s (T%d) for €%.0f.", slot, def.Name, def.Tier, price), false
}
// repairSlot mends one standard slot's condition with euros — the headless twin of
// the blacksmith's executeRepair. Idempotent on the order guid: the debit runs
// once, and setting condition to 100 is itself idempotent, so a re-offered order is
// safe with no refund.
func (p *AdventurePlugin) repairSlot(uid id.UserID, slot EquipmentSlot, guid string) (status, detail string, retry bool) {
equip, err := loadAdvEquipment(uid)
if err != nil {
return "", "", true
}
eq := equip[slot]
if eq == nil {
return "rejected_not_worn", "There's nothing in that slot to repair.", false
}
cost := blacksmithRepairCost(eq)
if cost <= 0 {
// Already full — nothing to charge for. Report it as applied so the order
// reaches a terminal state rather than parking.
return "applied", "That piece was already at full condition.", false
}
if !p.euro.HasExternalTx(guid) {
ok, _, err := p.euro.DebitIdem(uid, float64(cost), "adventure_repair", guid)
if err != nil {
return "", "", true
}
if !ok {
return "rejected_insufficient_funds", fmt.Sprintf("The repair costs €%d and you can't cover it.", cost), false
}
}
eq.Condition = 100
if err := saveAdvEquipment(uid, eq); err != nil {
return "", "", true // retry; the idempotent debit means no double-charge
}
return "applied", fmt.Sprintf("Repaired your %s for €%d.", eq.Name, cost), false
}
// buildEquipSlotViews is the owner-only snapshot of the 5 standard slots the web
// management panel renders from. Worn masterwork/arena pieces surface here (via
// CanTakeOff), not in the magic Equipped set. An upgrade is offered only over a
// plain shop-tier slot below max — a special piece is taken off, not shop-upgraded.
func buildEquipSlotViews(uid id.UserID) []peteclient.EquipSlotView {
equip, err := loadAdvEquipment(uid)
if err != nil {
return nil
}
var out []peteclient.EquipSlotView
for _, slot := range allSlots {
eq := equip[slot]
if eq == nil {
continue
}
v := peteclient.EquipSlotView{
Slot: string(slot),
Name: eq.Name,
Tier: eq.Tier,
Condition: eq.Condition,
Masterwork: eq.Masterwork,
ArenaTier: eq.ArenaTier,
CanTakeOff: eq.Masterwork || eq.ArenaTier > 0,
RepairCost: blacksmithRepairCost(eq),
}
if !eq.Masterwork && eq.ArenaTier == 0 && eq.Tier < 5 {
next := equipmentTiers[slot][eq.Tier+1]
v.NextTier = next.Tier
v.NextName = next.Name
v.NextPrice = next.Price
}
out = append(out, v)
}
return out
}
// masterworkEquipDetail turns a masterwork/arena equip outcome into the verdict
// note Pete shows.
func masterworkEquipDetail(out mwEquipOutcome) string {
kind := "masterwork"
if out.Arena {
kind = "arena"
}
b := fmt.Sprintf("Now worn in your %s slot (%s T%d).", out.Slot, kind, out.Tier)
if out.SwappedBack != "" {
b += fmt.Sprintf(" %s went back to your pack.", out.SwappedBack)
}
return b
}
// isEquipmentSlot reports whether a slot string names one of the 5 standard slots.
// The magic DnD slots and the standard slots are disjoint vocabularies, so this
// alone routes an unequip to the right path.
func isEquipmentSlot(slot string) bool {
for _, s := range allSlots {
if string(s) == slot {
return true
}
}
return false
}
internal/plugin/pete_equip_manage_test.go
+314
View File
@@ -0,0 +1,314 @@
package plugin
import (
"testing"
"maunium.net/go/mautrix/id"
)
// Ask 7: the headless equipment mutators the web equip queue drives. These pin the
// rules that cross the wire — downgrade block, max tier, insufficient funds,
// idempotent replay (one debit), masterwork evict/overwrite/take-off — at the
// gogobee end, on real rows.
// seedEquipPlayer stands up a playable adventurer (player_meta + tier-0 gear) with
// a euro plugin funded to `bankroll`, and returns the wired AdventurePlugin.
func seedEquipPlayer(t *testing.T, uid id.UserID, bankroll float64) *AdventurePlugin {
t.Helper()
if err := createAdvCharacter(uid, "Rurina"); err != nil {
t.Fatalf("createAdvCharacter: %v", err)
}
euro := &EuroPlugin{}
euro.ensureBalance(uid)
if bankroll > 0 {
euro.Credit(uid, bankroll, "test bankroll")
}
return &AdventurePlugin{euro: euro}
}
func slotOf(t *testing.T, uid id.UserID, slot EquipmentSlot) *AdvEquipment {
t.Helper()
equip, err := loadAdvEquipment(uid)
if err != nil {
t.Fatalf("loadAdvEquipment: %v", err)
}
return equip[slot]
}
// TestPurchaseEquipmentTierHappyAndIdempotentDebit: buying the next tier debits
// once and raises the slot, and the euro move is keyed on the order guid so a
// re-offer moves no money. (A re-offer never re-enters this function in prod — the
// equip_applied_orders ledger short-circuits it — but the guid is the belt to that
// suspenders, and the retry-after-save-fault path below leans on it directly.)
func TestPurchaseEquipmentTierHappyAndIdempotentDebit(t *testing.T) {
newMischiefTestDB(t)
uid := id.UserID("@rurina:test")
p := seedEquipPlayer(t, uid, 100000)
before := p.euro.GetBalance(uid)
price := equipmentTiers[SlotBoots][1].Price // Dead Man's Boots, €75
status, _, retry := p.purchaseEquipmentTier(uid, SlotBoots, 1, "guid-up-1")
if retry || status != "applied" {
t.Fatalf("upgrade = %q retry=%v, want applied", status, retry)
}
if got := slotOf(t, uid, SlotBoots); got.Tier != 1 || got.Name != equipmentTiers[SlotBoots][1].Name {
t.Fatalf("boots slot = %+v, want tier 1", got)
}
if got := p.euro.GetBalance(uid); got != before-price {
t.Fatalf("balance = %.2f, want %.2f (one debit of %.2f)", got, before-price, price)
}
// The guid is now a settled money move: a replayed debit on it is a no-op.
if !p.euro.HasExternalTx("guid-up-1") {
t.Fatal("the upgrade debit was not logged under the order guid")
}
if ok, _, err := p.euro.DebitIdem(uid, price, "adventure_equip_upgrade", "guid-up-1"); err != nil || !ok {
t.Fatalf("replayed debit = ok:%v err:%v, want a no-op ok", ok, err)
}
if got := p.euro.GetBalance(uid); got != before-price {
t.Fatalf("replayed debit double-charged: balance = %.2f, want %.2f", got, before-price)
}
// The retry-after-save-fault path: a prior attempt debited but its slot write
// never landed, so the slot is still tier 0. The retry must skip the debit
// (guid already settled) and finish the write, moving no further money.
helmetGUID := "guid-helm"
hprice := equipmentTiers[SlotHelmet][1].Price
if ok, _, err := p.euro.DebitIdem(uid, hprice, "adventure_equip_upgrade", helmetGUID); err != nil || !ok {
t.Fatalf("seed prior debit = ok:%v err:%v", ok, err)
}
mid := p.euro.GetBalance(uid)
status, _, retry = p.purchaseEquipmentTier(uid, SlotHelmet, 1, helmetGUID)
if retry || status != "applied" {
t.Fatalf("retry after fault = %q retry=%v, want applied", status, retry)
}
if got := slotOf(t, uid, SlotHelmet); got.Tier != 1 {
t.Fatalf("helmet not upgraded on retry: tier %d", got.Tier)
}
if got := p.euro.GetBalance(uid); got != mid {
t.Fatalf("retry re-debited: balance %.2f → %.2f", mid, got)
}
}
// TestPurchaseEquipmentTierRejections: a downgrade, a special-gear slot, the top
// tier, and an empty wallet all bounce without moving the slot or the money.
func TestPurchaseEquipmentTierRejections(t *testing.T) {
newMischiefTestDB(t)
uid := id.UserID("@rurina:test")
p := seedEquipPlayer(t, uid, 100000)
// Lift boots to tier 3 so we have something to (not) downgrade from.
if s, _, _ := p.purchaseEquipmentTier(uid, SlotBoots, 3, "seed-t3"); s != "applied" {
t.Fatalf("seed to tier 3 = %q", s)
}
// Same tier or lower is a downgrade.
if s, _, _ := p.purchaseEquipmentTier(uid, SlotBoots, 3, "g-eq"); s != "rejected_downgrade" {
t.Errorf("re-buy same tier = %q, want rejected_downgrade", s)
}
if s, _, _ := p.purchaseEquipmentTier(uid, SlotBoots, 2, "g-down"); s != "rejected_downgrade" {
t.Errorf("buy lower tier = %q, want rejected_downgrade", s)
}
// Past the top tier.
if s, _, _ := p.purchaseEquipmentTier(uid, SlotBoots, 6, "g-max"); s != "rejected_max_tier" {
t.Errorf("buy tier 6 = %q, want rejected_max_tier", s)
}
// A special piece in the slot: buying a plain tier over it strips the bonus.
weapon := slotOf(t, uid, SlotWeapon)
weapon.Masterwork = true
weapon.Tier = 2
weapon.Name = "Miner's Masterwork Blade"
weapon.SkillSource = "mining"
if err := saveAdvEquipment(uid, weapon); err != nil {
t.Fatal(err)
}
if s, _, _ := p.purchaseEquipmentTier(uid, SlotWeapon, 3, "g-special"); s != "rejected_downgrade" {
t.Errorf("buy plain over masterwork = %q, want rejected_downgrade", s)
}
// Insufficient funds: a broke player can't buy a €30000 tier-5 weapon.
broke := id.UserID("@broke:test")
pb := seedEquipPlayer(t, broke, 0)
bal := pb.euro.GetBalance(broke)
if s, _, _ := pb.purchaseEquipmentTier(broke, SlotWeapon, 5, "g-broke"); s != "rejected_insufficient_funds" {
t.Errorf("broke upgrade = %q, want rejected_insufficient_funds", s)
}
if got := pb.euro.GetBalance(broke); got != bal {
t.Errorf("a rejected upgrade moved money: %.2f → %.2f", bal, got)
}
if got := slotOf(t, broke, SlotWeapon); got.Tier != 0 {
t.Errorf("a rejected upgrade changed the slot: tier %d", got.Tier)
}
}
// TestRepairSlotHappyAndNoop: repairing a damaged slot debits the blacksmith cost
// and restores condition; repairing a full slot is a no-op that charges nothing.
func TestRepairSlotHappyAndNoop(t *testing.T) {
newMischiefTestDB(t)
uid := id.UserID("@rurina:test")
p := seedEquipPlayer(t, uid, 100000)
weapon := slotOf(t, uid, SlotWeapon)
weapon.Condition = 50
if err := saveAdvEquipment(uid, weapon); err != nil {
t.Fatal(err)
}
cost := blacksmithRepairCost(weapon)
if cost <= 0 {
t.Fatalf("expected a positive repair cost, got %d", cost)
}
before := p.euro.GetBalance(uid)
status, _, retry := p.repairSlot(uid, SlotWeapon, "guid-rep-1")
if retry || status != "applied" {
t.Fatalf("repair = %q retry=%v, want applied", status, retry)
}
if got := slotOf(t, uid, SlotWeapon); got.Condition != 100 {
t.Fatalf("condition = %d, want 100", got.Condition)
}
if got := p.euro.GetBalance(uid); got != before-float64(cost) {
t.Fatalf("balance = %.2f, want %.2f (debit %d)", got, before-float64(cost), cost)
}
// Now at full condition: a fresh repair is an applied no-op, no charge.
after := p.euro.GetBalance(uid)
status, _, _ = p.repairSlot(uid, SlotWeapon, "guid-rep-2")
if status != "applied" {
t.Fatalf("no-op repair = %q, want applied", status)
}
if got := p.euro.GetBalance(uid); got != after {
t.Errorf("no-op repair charged: %.2f → %.2f", after, got)
}
}
// TestMasterworkEquipEvictsOverwritesAndTakesOff: a masterwork piece equips into a
// plain slot (overwriting the tier), a better one evicts the special occupant back
// to the pack, a worse one is blocked, and take-off resets the slot to tier 0.
func TestMasterworkEquipEvictsOverwritesAndTakesOff(t *testing.T) {
newMischiefTestDB(t)
uid := id.UserID("@rurina:test")
seedEquipPlayer(t, uid, 0)
mw := func(name string, tier int) AdvItem {
if err := addAdvInventoryItem(uid, AdvItem{Name: name, Type: "MasterworkGear", Tier: tier, Slot: SlotWeapon, SkillSource: "mining"}); err != nil {
t.Fatal(err)
}
inv, _ := loadAdvInventory(uid)
for _, it := range inv {
if it.Name == name {
return it
}
}
t.Fatalf("just-added item %q not in inventory", name)
return AdvItem{}
}
// Equip a T3 masterwork over the tier-0 plain weapon: it overwrites, no eviction.
out, err := applyMasterworkEquip(uid, mw("Deepforged Blade", 3))
if err != nil {
t.Fatalf("equip T3: %v", err)
}
if out.SwappedBack != "" {
t.Errorf("plain occupant should be overwritten, not evicted; got swap %q", out.SwappedBack)
}
if got := slotOf(t, uid, SlotWeapon); !got.Masterwork || got.Tier != 3 || got.Name != "Deepforged Blade" {
t.Fatalf("weapon = %+v, want masterwork T3 Deepforged Blade", got)
}
// A better masterwork (T4) evicts the T3 back to the pack.
out, err = applyMasterworkEquip(uid, mw("Sunforged Blade", 4))
if err != nil {
t.Fatalf("equip T4: %v", err)
}
if out.SwappedBack != "Deepforged Blade" {
t.Errorf("evicted = %q, want Deepforged Blade", out.SwappedBack)
}
invHas := func(name string) bool {
inv, _ := loadAdvInventory(uid)
for _, it := range inv {
if it.Name == name {
return true
}
}
return false
}
if !invHas("Deepforged Blade") {
t.Error("the evicted T3 masterwork is not back in the pack")
}
// A worse masterwork (T2) is a blocked downgrade.
if _, err := applyMasterworkEquip(uid, mw("Rusty Masterwork", 2)); err != errEquipDowngrade {
t.Errorf("equip worse masterwork err = %v, want errEquipDowngrade", err)
}
// Take off the worn T4: it returns to the pack and the slot resets to tier 0.
un, err := applyMasterworkUnequip(uid, SlotWeapon)
if err != nil {
t.Fatalf("take off: %v", err)
}
if un.Name != "Sunforged Blade" {
t.Errorf("took off %q, want Sunforged Blade", un.Name)
}
if got := slotOf(t, uid, SlotWeapon); got.Masterwork || got.Tier != 0 || got.Name != equipmentTiers[SlotWeapon][0].Name {
t.Fatalf("weapon after take-off = %+v, want tier-0 default", got)
}
if !invHas("Sunforged Blade") {
t.Error("the taken-off masterwork is not back in the pack")
}
// Taking off a plain slot has nothing round-trippable.
if _, err := applyMasterworkUnequip(uid, SlotArmor); err != errSlotEmpty {
t.Errorf("take off plain slot err = %v, want errSlotEmpty", err)
}
}
// TestBuildEquipSlotViews: the panel snapshot offers an upgrade only over a plain
// sub-max slot, take-off only on special gear, and a repair cost only when damaged.
func TestBuildEquipSlotViews(t *testing.T) {
newMischiefTestDB(t)
uid := id.UserID("@rurina:test")
seedEquipPlayer(t, uid, 0)
// Boots: masterwork T3, damaged → take off + repair, no upgrade offer.
boots := slotOf(t, uid, SlotBoots)
boots.Masterwork = true
boots.Tier = 3
boots.Name = "The Wandering Sole"
boots.Condition = 70
if err := saveAdvEquipment(uid, boots); err != nil {
t.Fatal(err)
}
// Helmet: plain T2 → upgrade to T3 offered, no take off, no repair.
helmet := slotOf(t, uid, SlotHelmet)
helmet.Tier = 2
helmet.Name = equipmentTiers[SlotHelmet][2].Name
if err := saveAdvEquipment(uid, helmet); err != nil {
t.Fatal(err)
}
views := buildEquipSlotViews(uid)
bySlot := map[string]struct {
takeOff bool
nextTier int
repair int
}{}
for _, v := range views {
bySlot[v.Slot] = struct {
takeOff bool
nextTier int
repair int
}{v.CanTakeOff, v.NextTier, v.RepairCost}
}
if len(views) != len(allSlots) {
t.Fatalf("got %d slot views, want %d", len(views), len(allSlots))
}
if b := bySlot["boots"]; !b.takeOff || b.nextTier != 0 || b.repair <= 0 {
t.Errorf("boots view = %+v, want take-off, no upgrade, positive repair", b)
}
if h := bySlot["helmet"]; h.takeOff || h.nextTier != 3 || h.repair != 0 {
t.Errorf("helmet view = %+v, want upgrade to T3, no take-off, no repair", h)
}
// A pristine tier-0 slot: upgrade offered to T1, no take-off, no repair.
if w := bySlot["weapon"]; w.takeOff || w.nextTier != 1 || w.repair != 0 {
t.Errorf("weapon view = %+v, want upgrade to T1", w)
}
}
internal/plugin/pete_offers.go
+129
View File
@@ -0,0 +1,129 @@
package plugin
// The offer half of the web action queue: what a signed-in owner is allowed to
// ask for, and what it costs.
//
// W5a's two verbs needed none of this — "pull out" and "take your bout" have no
// arguments and no price. W5b's three do, and the page cannot invent either: the
// zone list is level-gated and postgame-gated per player, and every price scales
// with level. So gogobee quotes them here, on the self-detail push that already
// carries the owner's private panels, and Pete renders the quote without doing
// any arithmetic of its own.
//
// A quote is NOT a permission. It is up to two minutes stale by the time anybody
// clicks it, so every one of these is re-resolved against the game's own tables
// when the order lands (performExpeditionStart re-runs availableZonesFor,
// performBabysitPurchase re-reads the level). What the offer list buys is a page
// that does not show a button which is certain to be refused.
import (
"time"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
// advLoadoutKeys is the order the three presets are offered in — cheapest first,
// which is also how renderLoadoutPrompt lists them in Matrix.
var advLoadoutKeys = []SupplyLoadout{LoadoutLean, LoadoutBalanced, LoadoutHeavy}
// loadoutOffersFor prices the three supply presets at a tier. Days is the
// provisions estimate at that tier's calm daily burn — the same number
// `!expedition start` prints, and deliberately the pessimistic one: the holiday
// and Omen freebie packs are added at departure, so a run can outlast its quote
// but never fall short of it.
func loadoutOffersFor(tier ZoneTier) []peteclient.LoadoutOffer {
out := make([]peteclient.LoadoutOffer, 0, len(advLoadoutKeys))
for _, l := range advLoadoutKeys {
pp := loadoutPurchase(tier, l)
sup := makeSupplies(tier, pp)
out = append(out, peteclient.LoadoutOffer{
Key: loadoutName(l),
Name: loadoutName(l),
Blurb: loadoutBlurb(l),
Cost: pp.Cost(),
Days: estimateDays(sup.Max, sup.DailyBurn),
})
}
return out
}
// zoneOffersFor is where this adventurer may set out for right now, priced.
//
// It returns nothing at all when they cannot leave — already on an expedition,
// seated in somebody else's, or mid zone-run. That is not a second permission
// check duplicating performExpeditionStart's; it is what stops the page offering
// a departure it can already tell will be refused.
func zoneOffersFor(uid id.UserID) []peteclient.ZoneOffer {
if seated, _ := seatedExpeditionFor(uid); seated != nil {
return nil
}
if existing, _ := getActiveExpedition(uid); existing != nil {
return nil
}
if run, _ := getActiveZoneRun(uid); run != nil {
return nil
}
zones := availableZonesFor(uid, dndLevelForUser(uid))
out := make([]peteclient.ZoneOffer, 0, len(zones))
for _, z := range zones {
out = append(out, peteclient.ZoneOffer{
ID: string(z.ID),
Display: z.Display,
Tier: int(z.Tier),
Hook: z.Hook,
Postgame: z.Tier == ZoneTierMythic,
Loadouts: loadoutOffersFor(z.Tier),
})
}
return out
}
// resumeOfferFor is the extracted expedition still waiting to be walked back
// into. Nil when there is none, when the window has already lapsed, or when the
// player is out again — a lapsed row is left for the sweeper to reap rather than
// reaped here, because a push builder should not be quietly ending expeditions.
func resumeOfferFor(uid id.UserID) *peteclient.ResumeOffer {
if existing, _ := getActiveExpedition(uid); existing != nil {
return nil
}
exp, err := getResumableExpedition(uid)
if err != nil || exp == nil {
return nil
}
if extractionLapsed(exp, time.Now().UTC()) {
return nil
}
zone, _ := getZone(exp.ZoneID)
off := &peteclient.ResumeOffer{
ZoneID: string(exp.ZoneID),
Display: zone.Display,
Tier: int(zone.Tier),
Day: exp.CurrentDay,
Loadouts: loadoutOffersFor(zone.Tier),
}
if exp.CompletedAt != nil {
off.ExpiresAt = exp.CompletedAt.Add(extractResumeWindow).Unix()
}
return off
}
// babysitOfferFor is the sitter's standing and the two prices they charge. It is
// pushed even when a sitter is already engaged: "somebody is already looking
// after your pet until Tuesday" is exactly what the page should say instead of a
// buy button.
func babysitOfferFor(adv *AdventureCharacter) *peteclient.BabysitOffer {
if adv == nil {
return nil
}
daily := babysitDailyCost(dndLevelForUser(adv.UserID))
off := &peteclient.BabysitOffer{
Active: adv.BabysitActive,
WeekCost: daily * 7,
MonthCost: daily * 30,
}
if adv.BabysitActive && adv.BabysitExpiresAt != nil {
off.ExpiresAt = adv.BabysitExpiresAt.Unix()
}
return off
}
internal/plugin/pete_orders.go
+486
View File
@@ -0,0 +1,486 @@
package plugin
// The web action queue's game-side loop — the equip queue's sibling, and the
// first one where the web plays the game rather than dressing the character.
//
// An owner, signed in on Pete, asks for something: pull out of a run, take
// today's swing at the Siege, set out for a zone, walk back into the run they
// extracted from, hire the pet sitter. Pete records the intent; we poll for it,
// run the real command path (the same one `!extract`, `!expedition start`,
// `!resume` and the rest run — not a second implementation of it), and file a
// verdict Pete shows them.
//
// Same non-idempotency problem as equip, with higher stakes: replaying an
// extraction would end a run the player had already resumed, and replaying a bout
// would spend a day's swing they never got back. So before touching anything we
// check the adv_applied_orders ledger — if this order's guid is there, the
// mutation landed on an earlier tick and we only lost the verdict-ack, so we
// re-file the stored verdict and mutate nothing.
//
// The poll is faster than equip's (15s vs 30s) for one reason: an extraction is
// the answer to something the player is *watching* go wrong on the who page. A
// minute of silence there reads as a button that didn't work.
import (
"context"
"database/sql"
"errors"
"fmt"
"log/slog"
"time"
"gogobee/internal/db"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
const (
advOrderPollInterval = 15 * time.Second
// A Siege bout runs a full combat and streams its narration to Matrix before
// takeSiegeBout returns, so this budget is minutes, not seconds — the equip
// path's 20s would abandon a fight that was going fine.
advOrderPollTimeout = 5 * time.Minute
)
// peteAdvOrderTicker polls Pete for web actions and fulfils them. Started
// alongside the other adventure tickers; exits on stopCh.
func (p *AdventurePlugin) peteAdvOrderTicker() {
if !peteclient.Enabled() {
return // no Pete wire configured; the action queue is simply off
}
ticker := time.NewTicker(advOrderPollInterval)
defer ticker.Stop()
for {
select {
case <-p.stopCh:
return
case <-ticker.C:
p.pollAdvOrders()
}
}
}
func (p *AdventurePlugin) pollAdvOrders() {
ctx, cancel := context.WithTimeout(context.Background(), advOrderPollTimeout)
defer cancel()
orders, err := peteclient.PendingOrders(ctx)
if err != nil {
// A Pete predating the queue answers 404; a wire blip looks the same. Quiet
// on purpose — this must not spam while Pete hasn't shipped the endpoint.
slog.Debug("orders: poll failed", "err", err)
return
}
for _, order := range orders {
p.fulfilAdvOrder(ctx, order)
}
}
// fulfilAdvOrder applies one action and files its verdict. A transient failure is
// left pending for the next poll (no verdict); a permanent one gets a specific
// rejection. The guid ledger makes a re-offer after a lost ack a no-op that
// simply re-files the verdict.
func (p *AdventurePlugin) fulfilAdvOrder(ctx context.Context, order peteclient.AdvOrder) {
// Already applied on an earlier tick? Re-file the stored verdict, mutate nothing.
if status, detail, ok := advOrderAlreadyApplied(order.GUID); ok {
if err := peteclient.VerdictOrder(ctx, order.GUID, status, detail); err != nil {
slog.Warn("orders: re-file verdict push failed, will retry next poll",
"order", order.GUID, "status", status, "err", err)
}
return
}
owner, ok := p.equipOwnerMXID(order.OwnerLocalpart)
if !ok {
// The client isn't up (tests) or the localpart is empty. Not our order to
// fail permanently — leave it pending and try again once we can name the owner.
slog.Debug("orders: cannot resolve owner, leaving pending", "order", order.GUID, "owner", order.OwnerLocalpart)
return
}
status, detail, retry := p.applyAdvOrder(owner, order)
if retry {
return // transient; leave pending for the next tick
}
// Record the verdict BEFORE pushing it, so a crash after the mutation still
// short-circuits next tick and re-files rather than re-applying. Same ordering
// and the same reasoning as the equip poller.
if err := recordAdvApplied(order.GUID, status, detail); err != nil {
slog.Warn("orders: failed to record applied order, leaving pending",
"order", order.GUID, "status", status, "err", err)
return
}
if err := peteclient.VerdictOrder(ctx, order.GUID, status, detail); err != nil {
slog.Warn("orders: verdict push failed, will re-file next poll",
"order", order.GUID, "status", status, "err", err)
return
}
slog.Info("orders: web action fulfilled", "order", order.GUID, "action", order.Action, "status", status)
}
// applyAdvOrder runs the real action. It returns the terminal status and a human
// note for Pete, or retry=true for a transient fault that should leave the order
// pending. It records nothing and pushes nothing — the caller does both.
//
// Note what is NOT here: a per-user lock. Almost every verb takes it inside its
// own shared helper (performExtraction, takeSiegeBout, performResume,
// performBabysitPurchase), which is what serialises them against the Matrix
// commands running the very same code. Taking it here too would deadlock on a
// non-reentrant mutex.
//
// The exceptions are the three twins whose Matrix caller already holds the lock
// across the whole `!expedition` switch and so cannot take it themselves —
// performExpeditionStart, performExpeditionAbandon and performExpeditionLeave.
// Their apply wrappers below take it instead. That asymmetry is written down in
// both places because getting it wrong does not fail loudly: it wedges the
// player's lock forever and every later adventure command from them hangs. The
// rule for a new verb is not "web wrappers take the lock" — it is "look at what
// the Matrix caller does", and the two babysit verbs go the other way.
func (p *AdventurePlugin) applyAdvOrder(owner id.UserID, order peteclient.AdvOrder) (status, detail string, retry bool) {
switch order.Action {
case peteclient.AdvOrderExtract:
out, err := p.performExtraction(owner)
switch {
case errors.Is(err, errExtractNoRun):
return "rejected_not_running", "You weren't on an expedition.", false
case errors.Is(err, errExtractNotLeader):
return "rejected_not_leader", "Only the party leader can call the extraction.", false
case err != nil:
// Every remaining failure here is a DB fault. Leave it pending: nothing
// has been written, so the next tick retries cleanly.
slog.Warn("orders: extraction failed", "order", order.GUID, "user", owner, "err", err)
return "", "", true
}
return "applied", fmt.Sprintf(
"Out of %s on day %d. Loot, XP and coins kept. Say !resume within 7 days to go back in.",
out.Zone, out.Day), false
case peteclient.AdvOrderSiegeJoin:
bout, boss, err := p.takeSiegeBout(owner)
switch {
case errors.Is(err, errSiegeNoBoss):
return "rejected_no_siege", "No Siege is camped outside town right now.", false
case errors.Is(err, errSiegeNoCharacter):
return "rejected_unavailable", "You don't have an adventurer yet.", false
case errors.Is(err, errSiegeDead):
return "rejected_unavailable", "You're dead. The Siege will have to wait.", false
case errors.Is(err, errSiegeAlreadyFought):
return "rejected_already_fought", "You've already taken your bout today. One fight per day.", false
case err != nil:
// A combat that errored persisted nothing terminal, but it may have
// written HP. Retry is still right: the once-per-day gate is stamped by
// the contribution row, which only lands on a bout that completed.
slog.Warn("orders: siege bout failed", "order", order.GUID, "user", owner, "err", err)
return "", "", true
}
// The blow-by-blow went to Matrix; the web gets the same one-line result the
// narration closed with, minus its markdown.
return "applied", advOrderPlainText(siegeBoutFooter(bout, boss)), false
case peteclient.AdvOrderExpedition:
return p.applyWebExpeditionStart(owner, order)
case peteclient.AdvOrderResume:
return p.applyWebResume(owner, order)
case peteclient.AdvOrderBabysit:
return p.applyWebBabysit(owner, order)
case peteclient.AdvOrderAbandon:
return p.applyWebAbandon(owner)
case peteclient.AdvOrderLeave:
return p.applyWebLeave(owner)
case peteclient.AdvOrderBabysitCancel:
return p.applyWebBabysitCancel(owner)
default:
// Pete validates the action before it ever queues an order, so this is a
// contract breach, not a user mistake. Reject permanently rather than spin.
return "rejected_unavailable", "Unknown action.", false
}
}
// ---- the three verbs that take arguments and spend coins ------------------------
//
// Everything below re-resolves its own arguments against the game's own tables.
// Pete only ever offers what gogobee quoted it (see pete_offers.go), but a quote
// is up to two minutes stale and is not a permission — so the zone is looked up
// again in availableZonesFor, the loadout is priced again at the real tier, and
// the fee is read again at the real level. A forged param buys nothing.
//
// All three are money moves on a retrying wire, so each hands the order guid down
// as the idempotency key. Nothing here refunds-then-retries: once a refund has
// happened the guid-keyed debit will not charge again, so a retry would hand over
// the goods for free. Every failure past the debit is therefore permanent.
// applyWebExpeditionStart sends the owner's adventurer out of town.
func (p *AdventurePlugin) applyWebExpeditionStart(owner id.UserID, order peteclient.AdvOrder) (status, detail string, retry bool) {
if order.Params == nil || order.Params.Zone == "" {
return "rejected_unavailable", "That order didn't say where to.", false
}
// performExpeditionStart is the one headless twin that does NOT take the
// per-user lock (its Matrix caller already holds it across the whole
// `!expedition` switch), so this is the one order case that has to.
userMu := p.advUserLock(owner)
userMu.Lock()
defer userMu.Unlock()
c, err := LoadDnDCharacter(owner)
if err != nil {
return "", "", true // a DB fault; nothing written, so the next tick retries cleanly
}
if c == nil || c.PendingSetup {
return "rejected_unavailable", "You don't have an adventurer yet.", false
}
zoneID, ok := resolveZoneInput(order.Params.Zone, availableZonesFor(owner, c.Level))
if !ok {
if reason := postgameLockReason(order.Params.Zone, owner, c.Level); reason != "" {
return "rejected_zone_locked", advOrderPlainText(reason), false
}
return "rejected_zone_locked", "That zone isn't open to you right now.", false
}
zone, _ := getZone(zoneID)
// An unknown loadout is refused rather than defaulted. A default here would
// spend coins on a pack size the player never picked.
loadout, ok := parseLoadoutToken(order.Params.Loadout)
if !ok {
return "rejected_unavailable", "That isn't a loadout I sell.", false
}
out, err := p.performExpeditionStart(owner, c, zone, loadoutPurchase(zone.Tier, loadout), order.GUID)
if err != nil {
status := "rejected_unavailable"
switch {
case errors.Is(err, errExpStartZoneLocked):
status = "rejected_zone_locked"
case errors.Is(err, errExpStartBusy):
status = "rejected_busy"
case errors.Is(err, errExpStartBroke):
status = "rejected_insufficient_funds"
}
// Everything else — still resting, a bad pack count, a start that tore
// itself down and refunded — is rejected_unavailable, and the detail line
// carries the specifics.
return status, advOrderPlainText(err.Error()), false
}
return "applied", fmt.Sprintf(
"Out of town, bound for %s, with the %s loadout: %d coins, about %d days of provisions.",
out.Zone.Display, loadoutName(loadout), out.Cost, out.Days), false
}
// applyWebResume walks the owner back into the run they extracted from.
func (p *AdventurePlugin) applyWebResume(owner id.UserID, order peteclient.AdvOrder) (status, detail string, retry bool) {
// The loadout is required here, unlike in Matrix: an empty one asks
// performResume for the pick-a-loadout prompt, which is a DM, not a verdict.
if order.Params == nil || order.Params.Loadout == "" {
return "rejected_unavailable", "That order didn't say what to pack.", false
}
if _, ok := parseLoadoutToken(order.Params.Loadout); !ok {
return "rejected_unavailable", "That isn't a loadout I sell.", false
}
out, err := p.performResume(owner, order.Params.Loadout, order.GUID)
if err != nil {
var refusal advRefusal
if !errors.As(err, &refusal) {
// Not a refusal at all — a DB fault reading expedition state. Nothing
// has been written, so leave it pending.
slog.Warn("orders: resume failed", "order", order.GUID, "user", owner, "err", err)
return "", "", true
}
status := "rejected_unavailable"
switch {
case errors.Is(err, errResumeBusy):
status = "rejected_busy"
case errors.Is(err, errResumeNothing), errors.Is(err, errResumeLapsed):
status = "rejected_nothing_to_resume"
case errors.Is(err, errResumeBroke):
status = "rejected_insufficient_funds"
}
return status, advOrderPlainText(err.Error()), false
}
return "applied", fmt.Sprintf(
"Back into %s on day %d, re-outfitted for %d coins.",
out.Zone.Display, out.Day, out.Purchase.Cost()), false
}
// applyWebBabysit engages the pet sitter for a week or a month.
func (p *AdventurePlugin) applyWebBabysit(owner id.UserID, order peteclient.AdvOrder) (status, detail string, retry bool) {
// The two durations the game sells. Anything else is a contract breach rather
// than a user mistake, since Pete offers exactly these two.
days := 0
if order.Params != nil {
days = order.Params.Days
}
if days != 7 && days != 30 {
return "rejected_unavailable", "The sitter works by the week or by the month.", false
}
out, err := p.performBabysitPurchase(owner, days, order.GUID)
if err != nil {
status := "rejected_unavailable"
switch {
case errors.Is(err, errBabysitActive):
status = "rejected_busy"
case errors.Is(err, errBabysitBroke):
status = "rejected_insufficient_funds"
}
return status, advOrderPlainText(err.Error()), false
}
label := "a week"
if out.Days == 30 {
label = "a month"
}
note := fmt.Sprintf("Sitter engaged for %s, %d coins.", label, out.Cost)
if out.PetName != "" {
note += fmt.Sprintf(" %s is in good hands.", out.PetName)
}
return "applied", note, false
}
// ---- the three verbs that take no arguments and spend nothing -------------------
//
// Each of these was already named inside a verdict the web shows: "!expedition
// abandon first", "!expedition leave to walk out alone", "cancel early (no
// refund)". A page that tells somebody to go and type a command it could have
// offered them is a page with a hole in it, and these three close it.
//
// None of them touches money, so none of them needs an idempotency key — the
// guid ledger in fulfilAdvOrder is the whole guard, and a replay it somehow got
// past would be refused honestly ("nothing to abandon") rather than charging
// anybody twice.
// applyWebAbandon closes the owner's expedition down for good.
func (p *AdventurePlugin) applyWebAbandon(owner id.UserID) (status, detail string, retry bool) {
// performExpeditionAbandon does NOT take the per-user lock (its Matrix caller
// holds it across the whole `!expedition` switch), so this has to. See the
// note on applyAdvOrder.
userMu := p.advUserLock(owner)
userMu.Lock()
defer userMu.Unlock()
out, err := p.performExpeditionAbandon(owner)
if err != nil {
var refusal advRefusal
if !errors.As(err, &refusal) {
// A DB fault reading or writing expedition state. Nothing partial is
// left behind that a retry would double up, so leave it pending.
slog.Warn("orders: abandon failed", "user", owner, "err", err)
return "", "", true
}
status := "rejected_unavailable"
switch {
case errors.Is(err, errAbandonNothing):
status = "rejected_not_running"
case errors.Is(err, errAbandonNotLeader):
status = "rejected_not_leader"
}
return status, advOrderPlainText(err.Error()), false
}
// The extracted case keeps loot and XP, so saying "supplies are forfeit" there
// would be a straight lie. Same split the DM makes.
if out.Extracted {
return "applied", fmt.Sprintf(
"You let %s go on day %d. Loot, XP and coins are kept.", out.Zone.Display, out.Day), false
}
return "applied", fmt.Sprintf(
"Expedition in %s abandoned on day %d. Supplies are forfeit.", out.Zone.Display, out.Day), false
}
// applyWebLeave walks a party member out of somebody else's expedition.
func (p *AdventurePlugin) applyWebLeave(owner id.UserID) (status, detail string, retry bool) {
// Same lock asymmetry as applyWebAbandon.
userMu := p.advUserLock(owner)
userMu.Lock()
defer userMu.Unlock()
if err := p.performExpeditionLeave(owner); err != nil {
var refusal advRefusal
if !errors.As(err, &refusal) {
slog.Warn("orders: leave failed", "user", owner, "err", err)
return "", "", true
}
status := "rejected_unavailable"
switch {
case errors.Is(err, errLeaveNothing):
status = "rejected_not_running"
case errors.Is(err, errLeaveIsLeader):
status = "rejected_is_leader"
}
return status, advOrderPlainText(err.Error()), false
}
return "applied", "You turn back for town. Your supplies stay with the party.", false
}
// applyWebBabysitCancel dismisses the pet sitter early.
func (p *AdventurePlugin) applyWebBabysitCancel(owner id.UserID) (status, detail string, retry bool) {
// No lock here, and that is not an oversight: performBabysitCancel takes it
// itself, because ITS Matrix caller does not. The opposite of the two above.
out, err := p.performBabysitCancel(owner)
if err != nil {
status := "rejected_unavailable"
switch {
case errors.Is(err, errBabysitNoSitter):
status = "rejected_nothing_to_cancel"
}
return status, advOrderPlainText(err.Error()), false
}
// The DM prints the sitter's whole record of the stay; a verdict is one line
// under a button, so the web gets the fact and the page keeps its shape.
note := "Sitter dismissed. No refund — they were already here."
if out.PetName != "" {
note = fmt.Sprintf("Sitter dismissed. No refund. %s is back in your care.", out.PetName)
}
return "applied", note, false
}
// advOrderPlainText strips the Matrix markdown out of a line reused as a web
// verdict. Pete renders the detail as text, so asterisks and backticks would show
// up literally. The command hints inside those backticks stay — a verdict that
// says to type `!expedition abandon` is telling the truth about where the other
// door is, and the web has no button for it yet.
func advOrderPlainText(s string) string {
out := make([]rune, 0, len(s))
for _, r := range s {
switch r {
case '*', '`':
continue
case '\n':
out = append(out, ' ')
default:
out = append(out, r)
}
}
return string(out)
}
// ---- the applied-order ledger --------------------------------------------------
// advOrderAlreadyApplied reports the verdict we filed for an order, if we have
// already applied it. This is the short-circuit that keeps a re-offered order from
// re-running its non-idempotent mutation.
func advOrderAlreadyApplied(guid string) (status, detail string, ok bool) {
err := db.Get().QueryRow(
`SELECT status, detail FROM adv_applied_orders WHERE guid = ?`, guid,
).Scan(&status, &detail)
if errors.Is(err, sql.ErrNoRows) {
return "", "", false
}
if err != nil {
// A read failure sends us down the mutation path and risks re-running an
// extraction or a bout, so it is logged loudly. A transient one self-heals:
// the mutation is guarded by this same table, so the next poll reads it.
slog.Error("orders: applied-ledger read failed", "order", guid, "err", err)
return "", "", false
}
return status, detail, true
}
// recordAdvApplied stamps an order as applied with the verdict we're about to
// file. OR IGNORE so a re-file that somehow reaches here can't error on the guid.
func recordAdvApplied(guid, status, detail string) error {
_, err := db.Get().Exec(
`INSERT OR IGNORE INTO adv_applied_orders (guid, status, detail) VALUES (?, ?, ?)`,
guid, status, detail)
return err
}
internal/plugin/pete_orders_test.go
+385
View File
@@ -0,0 +1,385 @@
package plugin
import (
"strings"
"testing"
"time"
"gogobee/internal/db"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
// W5: the web action queue's game-side half. These pin the two things that would
// actually hurt in prod — a replayed order re-running a non-idempotent action,
// and a refusal being reported as a transient fault (which parks the order and
// leaves the player staring at "asked for…" forever).
// TestAdvOrderLedgerShortCircuitsAReoffer is the regression for the whole class
// of bug this ledger exists for. A verdict-ack lost on the wire means Pete
// re-offers an order we have already applied; if that re-offer reached
// applyAdvOrder it would extract a run the player had resumed, or spend a bout
// they were saving.
func TestAdvOrderLedgerShortCircuitsAReoffer(t *testing.T) {
newMischiefTestDB(t)
if _, _, ok := advOrderAlreadyApplied("guid-never-seen"); ok {
t.Fatal("an unknown guid reported as already applied")
}
if err := recordAdvApplied("guid-1", "applied", "Out of the Goblin Warrens on day 3."); err != nil {
t.Fatalf("recordAdvApplied: %v", err)
}
status, detail, ok := advOrderAlreadyApplied("guid-1")
if !ok || status != "applied" || !strings.Contains(detail, "Goblin Warrens") {
t.Fatalf("ledger read = %q/%q ok=%v, want the stored verdict back", status, detail, ok)
}
// A second stamp on the same guid must not error or overwrite — the re-file
// path can reach it.
if err := recordAdvApplied("guid-1", "rejected_not_running", "nonsense"); err != nil {
t.Fatalf("re-record: %v", err)
}
if status, _, _ := advOrderAlreadyApplied("guid-1"); status != "applied" {
t.Fatalf("verdict changed under a re-record: %q", status)
}
}
// TestExtractOrderRefusalsAreTerminal: neither refusal may come back as retry.
// A retried refusal never reaches a verdict, so the order sits pending forever
// and Pete's strip never stops saying "asked for…".
func TestExtractOrderRefusalsAreTerminal(t *testing.T) {
// W9: was setupZoneRunTestDB, which copies data/gogobee.db and t.Skip()s when
// it is missing — and that file is deleted after every local run, so this and
// the extraction test below have been green-by-skipping since W5a. Neither
// needs a prod row; startExpedition builds everything they touch.
setupEmptyTestDB(t)
uid := id.UserID("@web-extract-none:example.org")
defer cleanupExpeditions(uid)
p := &AdventurePlugin{}
status, detail, retry := p.applyAdvOrder(uid, peteclient.AdvOrder{
GUID: "g", Action: peteclient.AdvOrderExtract,
})
if retry {
t.Fatal("no-expedition extract asked for a retry; it must be terminal")
}
if status != "rejected_not_running" || detail == "" {
t.Fatalf("status = %q detail = %q, want rejected_not_running with prose", status, detail)
}
}
// TestExtractOrderIsTheSameExtraction: the web verb must run the game's own
// extraction, not a lookalike. The proof is the state the row lands in —
// 'extracting' (a resumable limbo) rather than 'abandoned' — plus the day burn
// and the log line the DM path writes.
func TestExtractOrderIsTheSameExtraction(t *testing.T) {
setupEmptyTestDB(t)
uid := id.UserID("@web-extract-live:example.org")
defer cleanupExpeditions(uid)
p := &AdventurePlugin{}
if _, err := startExpedition(uid, ZoneGoblinWarrens, "", ExpeditionSupplies{
Current: 10, Max: 10, DailyBurn: 1, HarshMod: 1, PacksStandard: 1,
}); err != nil {
t.Fatalf("startExpedition: %v", err)
}
status, detail, retry := p.applyAdvOrder(uid, peteclient.AdvOrder{
GUID: "g-extract", Action: peteclient.AdvOrderExtract,
})
if retry || status != "applied" {
t.Fatalf("extract = %q retry=%v, want applied", status, retry)
}
if !strings.Contains(detail, "resume") {
t.Fatalf("verdict %q never mentions the resume window, which is the whole point of an extraction", detail)
}
var dbStatus string
var day int
if err := db.Get().QueryRow(
`SELECT status, current_day FROM dnd_expedition WHERE user_id = ?`, string(uid),
).Scan(&dbStatus, &day); err != nil {
t.Fatalf("read expedition: %v", err)
}
if dbStatus != ExpeditionStatusExtracting {
t.Fatalf("expedition status = %q, want %q — a web extract must be resumable like the command's",
dbStatus, ExpeditionStatusExtracting)
}
if day != 2 {
t.Fatalf("current_day = %d, want 2 — extraction burns the day", day)
}
}
// TestSiegeJoinRefusalsAreTerminal covers the two refusals a bout can hit without
// running any combat: nothing camped, and a bout already spent today. Both must
// be terminal for the same reason as the extract refusals, and "already fought"
// especially — it is the one a double-click produces.
func TestSiegeJoinRefusalsAreTerminal(t *testing.T) {
newMischiefTestDB(t)
uid := id.UserID("@web-siege:example.org")
p := &AdventurePlugin{}
status, _, retry := p.applyAdvOrder(uid, peteclient.AdvOrder{
GUID: "g1", Action: peteclient.AdvOrderSiegeJoin,
})
if retry || status != "rejected_no_siege" {
t.Fatalf("no-boss bout = %q retry=%v, want rejected_no_siege", status, retry)
}
// Camp a boss and spend the day's bout, then ask again.
now := time.Now().UTC()
bossID, err := insertWorldBoss("Grelloth", 3, 18000, now.Add(-time.Hour), now.Add(48*time.Hour))
if err != nil {
t.Fatalf("insertWorldBoss: %v", err)
}
if err := createAdvCharacter(uid, "Rurina"); err != nil {
t.Fatalf("createAdvCharacter: %v", err)
}
today := now.Format("2006-01-02")
if err := upsertWorldBossContrib(bossID, uid, 250, today); err != nil {
t.Fatalf("upsertWorldBossContrib: %v", err)
}
status, detail, retry := p.applyAdvOrder(uid, peteclient.AdvOrder{
GUID: "g2", Action: peteclient.AdvOrderSiegeJoin,
})
if retry || status != "rejected_already_fought" {
t.Fatalf("second bout = %q retry=%v, want rejected_already_fought", status, retry)
}
if detail == "" {
t.Fatal("a refusal with no prose leaves the strip saying nothing useful")
}
}
// TestUnknownActionIsRejectedNotRetried: Pete validates the action before it ever
// queues one, so an unknown verb is a contract breach. Spinning on it would poll
// the same dead order every 15 seconds forever.
func TestUnknownActionIsRejectedNotRetried(t *testing.T) {
newMischiefTestDB(t)
p := &AdventurePlugin{}
status, _, retry := p.applyAdvOrder("@x:example.org", peteclient.AdvOrder{
GUID: "g", Action: "sell_house",
})
if retry || !strings.HasPrefix(status, "rejected_") {
t.Fatalf("unknown action = %q retry=%v, want a terminal rejection", status, retry)
}
}
// TestAdvOrderPlainText: the Siege verdict is the Matrix footer reused, and Pete
// renders a verdict as text — so the markdown has to come off or the player reads
// literal asterisks.
func TestAdvOrderPlainText(t *testing.T) {
got := advOrderPlainText("💥 You deal **412** damage. **Grelloth** has **5,800 / 18,000 HP** left.\nYou stagger out at 1 HP.")
if strings.Contains(got, "*") || strings.Contains(got, "\n") {
t.Fatalf("plain text still carries markup or a newline: %q", got)
}
if !strings.Contains(got, "412") || !strings.Contains(got, "Grelloth") {
t.Fatalf("plain text lost the facts: %q", got)
}
}
// ── W5b: the three verbs that take arguments and spend coins ───────────────────
// webOrderTestChar builds a character solvent enough to outfit an expedition.
func webOrderTestChar(t *testing.T, uid id.UserID, level int, coins float64) *AdventurePlugin {
t.Helper()
if err := createAdvCharacter(uid, "weborder"); err != nil {
t.Fatal(err)
}
c := &DnDCharacter{
UserID: uid, Race: RaceHuman, Class: ClassFighter, Level: level,
STR: 14, DEX: 12, CON: 14, INT: 10, WIS: 10, CHA: 10,
HPMax: 30, HPCurrent: 30, ArmorClass: 14,
}
if err := SaveDnDCharacter(c); err != nil {
t.Fatal(err)
}
euro := &EuroPlugin{}
euro.ensureBalance(uid)
if coins > 0 {
euro.Credit(uid, coins, "test bankroll")
}
return &AdventurePlugin{euro: euro}
}
// A forged zone must buy nothing. Pete only ever offers what gogobee quoted it,
// but a quote is a stale snapshot and not a permission — so the order path
// re-resolves against availableZonesFor and refuses anything that isn't there.
func TestWebExpeditionStartReResolvesTheZone(t *testing.T) {
setupEmptyTestDB(t)
uid := id.UserID("@web-start-forged:example.org")
t.Cleanup(func() { cleanupExpeditions(uid); cleanupZoneRuns(uid) })
p := webOrderTestChar(t, uid, 2, 100000)
before := p.euro.GetBalance(uid)
status, _, retry := p.applyAdvOrder(uid, peteclient.AdvOrder{
GUID: "forged-zone", Action: peteclient.AdvOrderExpedition,
Params: &peteclient.AdvOrderParams{Zone: "dragons_lair", Loadout: "lean"},
})
if retry {
t.Fatal("a locked zone asked for a retry; it must be terminal")
}
if status != "rejected_zone_locked" {
t.Fatalf("status = %q, want rejected_zone_locked", status)
}
if after := p.euro.GetBalance(uid); after != before {
t.Fatalf("a refused departure moved money: %.0f -> %.0f", before, after)
}
if exp, _ := getActiveExpedition(uid); exp != nil {
t.Fatal("a refused departure started an expedition anyway")
}
}
// An unknown loadout is refused, never defaulted. Defaulting would spend coins on
// a pack size the player never picked.
func TestWebExpeditionStartRefusesAnUnknownLoadout(t *testing.T) {
setupEmptyTestDB(t)
uid := id.UserID("@web-start-loadout:example.org")
t.Cleanup(func() { cleanupExpeditions(uid); cleanupZoneRuns(uid) })
p := webOrderTestChar(t, uid, 2, 100000)
before := p.euro.GetBalance(uid)
status, _, _ := p.applyAdvOrder(uid, peteclient.AdvOrder{
GUID: "bad-loadout", Action: peteclient.AdvOrderExpedition,
Params: &peteclient.AdvOrderParams{Zone: string(ZoneGoblinWarrens), Loadout: "enormous"},
})
if status != "rejected_unavailable" {
t.Fatalf("status = %q, want rejected_unavailable", status)
}
if after := p.euro.GetBalance(uid); after != before {
t.Fatalf("a refused loadout moved money: %.0f -> %.0f", before, after)
}
}
// The money test that matters: a re-offered order (verdict-ack lost before the
// ledger stamped it) must not charge twice, and must not answer "you're already
// on an expedition" for the expedition it just started.
func TestWebExpeditionStartChargesOnceOnAReoffer(t *testing.T) {
setupEmptyTestDB(t)
uid := id.UserID("@web-start-idem:example.org")
t.Cleanup(func() { cleanupExpeditions(uid); cleanupZoneRuns(uid) })
p := webOrderTestChar(t, uid, 2, 100000)
order := peteclient.AdvOrder{
GUID: "start-once", Action: peteclient.AdvOrderExpedition,
Params: &peteclient.AdvOrderParams{Zone: string(ZoneGoblinWarrens), Loadout: "lean"},
}
before := p.euro.GetBalance(uid)
status, _, retry := p.applyAdvOrder(uid, order)
if retry || status != "applied" {
t.Fatalf("first apply = %q retry=%v, want applied", status, retry)
}
afterFirst := p.euro.GetBalance(uid)
if afterFirst >= before {
t.Fatalf("outfitting cost nothing: %.0f -> %.0f", before, afterFirst)
}
// The re-offer. applyAdvOrder is reached directly here on purpose: the
// adv_applied_orders ledger would normally short-circuit it, and this asserts
// the layer *underneath* that guard is safe too.
status, _, retry = p.applyAdvOrder(uid, order)
if retry {
t.Fatal("the re-offer asked for a retry")
}
if status != "applied" {
t.Fatalf("re-offer = %q, want applied — the settled debit is what tells a "+
"replay apart from a player who really is already out", status)
}
if after := p.euro.GetBalance(uid); after != afterFirst {
t.Fatalf("the re-offer charged again: %.0f -> %.0f", afterFirst, after)
}
}
// Babysit: same replay contract, plus the two durations are the only two sold.
func TestWebBabysitChargesOnceAndSellsTwoDurations(t *testing.T) {
setupEmptyTestDB(t)
uid := id.UserID("@web-sitter:example.org")
p := webOrderTestChar(t, uid, 2, 100000)
status, _, _ := p.applyAdvOrder(uid, peteclient.AdvOrder{
GUID: "sitter-odd", Action: peteclient.AdvOrderBabysit,
Params: &peteclient.AdvOrderParams{Days: 3},
})
if status != "rejected_unavailable" {
t.Fatalf("3-day sitter = %q, want rejected_unavailable", status)
}
order := peteclient.AdvOrder{
GUID: "sitter-once", Action: peteclient.AdvOrderBabysit,
Params: &peteclient.AdvOrderParams{Days: 7},
}
before := p.euro.GetBalance(uid)
if status, _, _ := p.applyAdvOrder(uid, order); status != "applied" {
t.Fatalf("hire = %q, want applied", status)
}
afterFirst := p.euro.GetBalance(uid)
if afterFirst >= before {
t.Fatalf("the sitter worked for free: %.0f -> %.0f", before, afterFirst)
}
if status, _, _ := p.applyAdvOrder(uid, order); status != "applied" {
t.Fatalf("re-offer = %q, want applied", status)
}
if after := p.euro.GetBalance(uid); after != afterFirst {
t.Fatalf("the re-offer charged again: %.0f -> %.0f", afterFirst, after)
}
}
// A refusal must never come back as retry: a retried refusal never reaches a
// verdict, so the order parks and the strip says "asked for…" forever.
func TestWebMoneyVerbRefusalsAreTerminal(t *testing.T) {
setupEmptyTestDB(t)
uid := id.UserID("@web-broke:example.org")
t.Cleanup(func() { cleanupExpeditions(uid); cleanupZoneRuns(uid) })
p := webOrderTestChar(t, uid, 2, 0)
for _, tc := range []struct {
name string
order peteclient.AdvOrder
want string
}{
{"broke departure", peteclient.AdvOrder{
GUID: "broke-1", Action: peteclient.AdvOrderExpedition,
Params: &peteclient.AdvOrderParams{Zone: string(ZoneGoblinWarrens), Loadout: "heavy"},
}, "rejected_insufficient_funds"},
{"nothing to resume", peteclient.AdvOrder{
GUID: "resume-1", Action: peteclient.AdvOrderResume,
Params: &peteclient.AdvOrderParams{Loadout: "lean"},
}, "rejected_nothing_to_resume"},
{"broke sitter", peteclient.AdvOrder{
GUID: "broke-2", Action: peteclient.AdvOrderBabysit,
Params: &peteclient.AdvOrderParams{Days: 30},
}, "rejected_insufficient_funds"},
} {
status, detail, retry := p.applyAdvOrder(uid, tc.order)
if retry {
t.Fatalf("%s asked for a retry; it must be terminal", tc.name)
}
if status != tc.want {
t.Fatalf("%s = %q, want %q (detail %q)", tc.name, status, tc.want, detail)
}
if strings.ContainsAny(detail, "*`") {
t.Fatalf("%s verdict still carries Matrix markdown: %q", tc.name, detail)
}
}
}
// An order with no params at all is a contract breach, not a user mistake, and
// must be refused rather than defaulted into spending money.
func TestWebMoneyVerbsRefuseMissingParams(t *testing.T) {
setupEmptyTestDB(t)
uid := id.UserID("@web-noparams:example.org")
t.Cleanup(func() { cleanupExpeditions(uid); cleanupZoneRuns(uid) })
p := webOrderTestChar(t, uid, 2, 100000)
before := p.euro.GetBalance(uid)
for _, action := range []string{
peteclient.AdvOrderExpedition, peteclient.AdvOrderResume, peteclient.AdvOrderBabysit,
} {
status, _, retry := p.applyAdvOrder(uid, peteclient.AdvOrder{GUID: "np-" + action, Action: action})
if retry || status != "rejected_unavailable" {
t.Fatalf("%s with no params = %q retry=%v, want rejected_unavailable", action, status, retry)
}
}
if after := p.euro.GetBalance(uid); after != before {
t.Fatalf("a paramless order moved money: %.0f -> %.0f", before, after)
}
}
internal/plugin/pete_orders_undo_test.go
+209
View File
@@ -0,0 +1,209 @@
package plugin
import (
"strings"
"testing"
"time"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
// W9: the three web verbs that undo something — abandon an expedition, walk out
// of somebody else's party, send the sitter home.
//
// The thing worth pinning here is not the verdict text, it is the LOCK. Each of
// these three now has a headless twin shared between a Matrix command and the web
// order path, and the two halves take advUserLock on opposite sides: the two
// expedition twins cannot take it (their Matrix caller holds it across the whole
// `!expedition` switch) and their web wrappers must, while the babysit twin takes
// it itself and its web wrapper must not.
//
// Getting either of those backwards does not fail loudly. advUserLock is a plain
// sync.Mutex, so a second acquire parks the goroutine forever with the deferred
// Unlock never running — which wedges every later !adventure / !expedition /
// !zone command from that player, not just the one that deadlocked. That is a
// bug that shipped once already (see TestExpeditionAliasesDoNotWedgeTheUserLock),
// so both directions are tested here.
//
// NOTE: these two lock tests HANG rather than fail on regression. The timeout is
// the assertion.
// TestUndoCommandsDoNotWedgeTheUserLock is the Matrix half: `!expedition abandon`
// and `!expedition leave` reach their twins with the lock already held, so a twin
// that took it itself would park here.
func TestUndoCommandsDoNotWedgeTheUserLock(t *testing.T) {
setupEmptyTestDB(t)
uid := id.UserID("@w9-cmd-lock:example")
t.Cleanup(func() { cleanupExpeditions(uid) })
for _, sub := range []string{"abandon", "leave"} {
done := make(chan struct{})
go func() {
defer close(done)
p := &AdventurePlugin{euro: &EuroPlugin{}}
_ = p.handleDnDExpeditionCmd(MessageContext{Sender: uid}, sub)
}()
select {
case <-done:
case <-time.After(10 * time.Second):
t.Fatalf("!expedition %s never returned: its twin re-took advUserLock", sub)
}
}
}
// TestUndoOrdersDoNotWedgeTheUserLock is the web half, and it checks the harder
// half of the same property: not just that the order returns, but that the lock
// is FREE afterwards. A wrapper that took the lock around a twin that also takes
// it would park inside applyAdvOrder; a wrapper that forgot to release would let
// the order finish and wedge the next command instead, which is the failure that
// would have been missed by only timing the call.
func TestUndoOrdersDoNotWedgeTheUserLock(t *testing.T) {
setupEmptyTestDB(t)
uid := id.UserID("@w9-order-lock:example")
t.Cleanup(func() { cleanupExpeditions(uid) })
for _, action := range []string{
peteclient.AdvOrderAbandon,
peteclient.AdvOrderLeave,
peteclient.AdvOrderBabysitCancel,
} {
done := make(chan struct{})
go func() {
defer close(done)
p := &AdventurePlugin{euro: &EuroPlugin{}}
p.applyAdvOrder(uid, peteclient.AdvOrder{GUID: "g-" + action, Action: action})
// The lock must be back. Taking it here is what catches a wrapper that
// returned without unlocking.
mu := p.advUserLock(uid)
mu.Lock()
mu.Unlock()
}()
select {
case <-done:
case <-time.After(10 * time.Second):
t.Fatalf("order %q never returned or never released advUserLock", action)
}
}
}
// TestUndoOrderRefusalsAreTerminal: none of the three may come back as a retry.
// A retried refusal never reaches a verdict, so the order sits pending forever
// and the panel never stops saying "asked for…". Each also has to carry prose —
// the strip prefers gogobee's own sentence over its canned fallback, and an empty
// detail on a refusal is the one case where the page has nothing to show.
func TestUndoOrderRefusalsAreTerminal(t *testing.T) {
setupEmptyTestDB(t)
uid := id.UserID("@w9-refusals:example")
t.Cleanup(func() { cleanupExpeditions(uid) })
// A real character with nothing going on. Without one, babysit_cancel refuses
// with "no adventurer" and the sitter branch this is meant to cover is never
// reached — the first cut of this test passed the wrong assertion for that
// reason.
if err := createAdvCharacter(uid, "w9refusals"); err != nil {
t.Fatalf("createAdvCharacter: %v", err)
}
p := &AdventurePlugin{euro: &EuroPlugin{}}
cases := []struct {
action string
want string
}{
// Nothing to abandon and nothing to leave are the same fact from two
// doors, and both are the plain "you aren't on one" answer.
{peteclient.AdvOrderAbandon, "rejected_not_running"},
{peteclient.AdvOrderLeave, "rejected_not_running"},
// No sitter is its own verdict rather than rejected_unavailable: the page
// says something specific about it, and "unavailable" reads as a fault.
{peteclient.AdvOrderBabysitCancel, "rejected_nothing_to_cancel"},
}
for _, tc := range cases {
status, detail, retry := p.applyAdvOrder(uid, peteclient.AdvOrder{
GUID: "g-" + tc.action, Action: tc.action,
})
if retry {
t.Fatalf("%s asked for a retry on a refusal; it must be terminal", tc.action)
}
if status != tc.want {
t.Fatalf("%s status = %q, want %q", tc.action, status, tc.want)
}
if strings.TrimSpace(detail) == "" {
t.Fatalf("%s refused with no prose; the panel would have nothing to say", tc.action)
}
}
}
// TestUndoVerdictsCarryNoMarkdown: every detail line these file is reused from a
// Matrix sentence, and Pete renders a verdict as text. An asterisk or a backtick
// left in it shows up literally under the button.
//
// The backticks matter more than they look: the leave refusal names `!extract`
// and `!expedition abandon`, which is the correct thing to say (the web now has a
// button for one of them and not the other), but it must not say it in markup.
func TestUndoVerdictsCarryNoMarkdown(t *testing.T) {
setupEmptyTestDB(t)
uid := id.UserID("@w9-markdown:example")
t.Cleanup(func() { cleanupExpeditions(uid) })
p := &AdventurePlugin{euro: &EuroPlugin{}}
for _, action := range []string{
peteclient.AdvOrderAbandon,
peteclient.AdvOrderLeave,
peteclient.AdvOrderBabysitCancel,
} {
_, detail, _ := p.applyAdvOrder(uid, peteclient.AdvOrder{GUID: "g-md-" + action, Action: action})
if strings.ContainsAny(detail, "*`\n") {
t.Fatalf("%s verdict carries markdown or a newline: %q", action, detail)
}
}
}
// TestWebAbandonIsTheGamesOwnAbandon: the web verb must run the real path, not a
// lookalike. The proof is the state the row lands in — no expedition left at all,
// as opposed to the 'extracting' limbo an extraction leaves behind — and that the
// verdict says what became of the supplies, which is the one thing a player who
// clicked the wrong button needs to be told.
func TestWebAbandonIsTheGamesOwnAbandon(t *testing.T) {
// setupEmptyTestDB, NOT setupZoneRunTestDB: the latter copies data/gogobee.db
// and t.Skip()s when it is missing, and that file is deleted after every local
// run — so a test written on it is green-by-skipping on any clean checkout.
// See the Decisions note in the plan's progress file; W5a's order tests were
// silently skipping for exactly this reason.
setupEmptyTestDB(t)
uid := id.UserID("@w9-abandon-live:example.org")
t.Cleanup(func() { cleanupExpeditions(uid) })
if err := createAdvCharacter(uid, "w9abandon"); err != nil {
t.Fatalf("createAdvCharacter: %v", err)
}
p := &AdventurePlugin{euro: &EuroPlugin{}}
if _, err := startExpedition(uid, ZoneGoblinWarrens, "", ExpeditionSupplies{
Current: 10, Max: 10, DailyBurn: 1, HarshMod: 1, PacksStandard: 1,
}); err != nil {
t.Fatalf("startExpedition: %v", err)
}
status, detail, retry := p.applyAdvOrder(uid, peteclient.AdvOrder{
GUID: "g-abandon", Action: peteclient.AdvOrderAbandon,
})
if retry || status != "applied" {
t.Fatalf("abandon = %q retry=%v detail=%q, want applied", status, retry, detail)
}
if !strings.Contains(strings.ToLower(detail), "supplies") {
t.Fatalf("verdict %q never says the supplies are gone, which is the difference from pulling out", detail)
}
if exp, _, err := activeExpeditionFor(uid); err != nil {
t.Fatalf("read expedition: %v", err)
} else if exp != nil {
t.Fatalf("expedition survived a web abandon with status %q", exp.Status)
}
// And the second click, which is what a stale page produces: a terminal
// refusal, never a retry and never a second abandon.
status, _, retry = p.applyAdvOrder(uid, peteclient.AdvOrder{
GUID: "g-abandon-2", Action: peteclient.AdvOrderAbandon,
})
if retry || status != "rejected_not_running" {
t.Fatalf("re-abandon = %q retry=%v, want a terminal rejected_not_running", status, retry)
}
}
internal/plugin/pete_realm.go
+633
View File
@@ -0,0 +1,633 @@
package plugin
import (
"context"
"database/sql"
"log/slog"
"sort"
"time"
"gogobee/internal/db"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
// The realm snapshot: the world map, the hall of firsts, and the board.
//
// Everything Pete has shown so far is either the present moment (the roster, the
// Siege bar) or one thing that happened (a dispatch, a run log). None of it says
// what the realm *is* — that there are thirty-odd named places with a difficulty
// order, that some of them have never been beaten by anybody, and that the
// people playing have a history against them. That is what this carries.
//
// Snapshot semantics, like the roster and the Siege: pushed whole, replaces
// Pete's copy, dropped rather than retried on failure. The difference is the
// clock. The roster is a photograph of where people are standing and is worth
// re-taking every two minutes; a realm-first is a thing that happened once, ever,
// and re-deriving the whole ledger plus three aggregate scans at that rate would
// be pure waste. So this rides the same ticker at a much longer stride.
const (
// realmPushInterval — how often the realm is recomputed and pushed. The
// fastest-moving field in the whole snapshot is a zone's occupant list, and a
// ten-minute-old answer to "who is in the Sunken Vault" is still a true and
// useful one. Everything else moves on the scale of days.
realmPushInterval = 10 * time.Minute
// realmMaxOccupants bounds the per-zone occupant list. A realm has tens of
// players; this only stops a pathological case spooling a huge payload.
realmMaxOccupants = 50
)
// realmLastPush is when the realm snapshot last went out. Zero means never, so
// the first tick after start-up always pushes — an operator restarting the bot
// should not have to wait ten minutes to see whether the wire works.
var realmLastPush time.Time
// realmPushOK mirrors rosterPushOK: log the transitions and nothing else.
var realmPushOK bool
// pushRealm recomputes and sends the realm snapshot, at most once per
// realmPushInterval however often the ticker calls it.
func (p *AdventurePlugin) pushRealm() {
now := time.Now().UTC()
if !realmLastPush.IsZero() && now.Sub(realmLastPush) < realmPushInterval {
return
}
snap, err := buildRealmSnapshot(now)
if err != nil {
slog.Error("realm: build snapshot failed", "err", err)
return
}
ctx, cancel := context.WithTimeout(context.Background(), rosterPushTimeout)
defer cancel()
if err := peteclient.PushRealm(ctx, snap); err != nil {
if realmPushOK {
slog.Warn("realm: push failed, realm pages will go stale on Pete", "err", err)
} else {
slog.Debug("realm: push failed, dropping snapshot", "err", err)
}
realmPushOK = false
// Deliberately NOT stamping realmLastPush: a failed push should be retried
// on the next roster tick, not ten minutes from now. The stamp is a
// "we already told Pete this" marker, and we didn't.
return
}
realmLastPush = now
if !realmPushOK {
slog.Info("realm: snapshot accepted by Pete — realm pages are publishing",
"zones", len(snap.Zones), "firsts", len(snap.Firsts), "standings", len(snap.Standings))
realmPushOK = true
}
}
// realmClearStats is the per-zone clear history, read in one pass.
type realmClearStats struct {
clears int
clearers int
firstUser id.UserID
firstClearAt int64
}
// buildRealmSnapshot assembles the whole realm from the game's own tables.
//
// The three aggregate reads are done up front and once each, keyed into maps,
// rather than per-zone or per-player: this runs against the live DB on a ticker
// and a query-per-zone loop over a registry that only grows is the kind of thing
// that is fine until it isn't.
func buildRealmSnapshot(now time.Time) (peteclient.RealmSnapshot, error) {
snap := peteclient.RealmSnapshot{SnapshotAt: now.Unix()}
clearsByZone, err := loadRealmClearStats()
if err != nil {
return snap, err
}
occupantsByZone := loadRealmOccupants()
// ── Zones ───────────────────────────────────────────────────────────────
// zoneOrder is the design-doc ordering and is what the page draws in, so the
// realm reads the way it was designed rather than the way a map iterates.
for _, zid := range zoneOrder {
def, ok := dndZoneRegistry[zid]
if !ok {
continue
}
z := peteclient.RealmZone{
ID: string(def.ID),
Display: def.Display,
Tier: int(def.Tier),
LevelMin: def.LevelMin,
LevelMax: def.LevelMax,
Faction: def.Faction,
Atmosphere: def.Atmosphere,
Postgame: def.Tier == ZoneTierMythic,
Occupants: occupantsByZone[string(def.ID)],
}
if st, ok := clearsByZone[string(def.ID)]; ok {
z.Clears = st.clears
z.Clearers = st.clearers
z.FirstClearAt = st.firstClearAt
// An opted-out first-clearer keeps the claim and loses the identity —
// the Siege contributor rule, and for the same reason. Deleting the
// claim outright would leave the zone drawn as never-cleared, which is
// a false statement about the realm rather than a withheld one.
if !isNewsOptedOut(st.firstUser) {
z.FirstClearBy = charName(st.firstUser)
if z.FirstClearBy != "" {
z.FirstClearToken = eventToken(st.firstUser, "roster")
}
}
}
snap.Zones = append(snap.Zones, z)
}
snap.Firsts = loadRealmFirsts(clearsByZone)
// The three pages must not be able to contradict each other about the same
// zone. loadRealmFirsts derives the zone half of the hall from clearsByZone —
// the same map the tiles and the board use — but it also carries any ledger
// claim with no surviving run behind it, and that case would otherwise draw a
// place as never-beaten on the map while the hall named the year it fell.
//
// So an unbacked claim floors the clear count at one. Deliberately a floor and
// not an assignment: where the run history is intact it is the better answer
// and this only fills a hole. Nothing is attributed — the zone reads "cleared,
// by somebody", which is exactly what is known about it.
for i := range snap.Zones {
if snap.Zones[i].Clears > 0 {
continue
}
for _, f := range snap.Firsts {
if f.Kind == "zone" && f.Target == snap.Zones[i].ID {
snap.Zones[i].Clears = 1
snap.Zones[i].Clearers = 1
break
}
}
}
snap.Standings, err = loadRealmStandings(clearsByZone)
if err != nil {
return snap, err
}
return snap, nil
}
// loadRealmClearStats reads every zone's clear history in one pass: how many
// successful runs, how many distinct people managed it, and who did it first.
//
// MIN(completed_at) with a bare user_id column is SQLite's bare-column min/max
// rule — the user_id comes from the same row the minimum came from, so the
// (zone, first clearer, when) triple is internally consistent. backfillZoneFirsts
// relies on exactly this and has done since the news seam shipped.
//
// completed_at is selected raw as a string and parsed in Go rather than being
// wrapped in anything: modernc.org/sqlite rebuilds a time.Time from the column's
// declared type, and passing a DATETIME through MIN() alongside an aggregate is
// close enough to the COALESCE() trap that it is not worth finding out. The
// string always parses — it is written by SQLite's own CURRENT_TIMESTAMP.
//
// NOTE the absence of `AND abandoned = 0`, which looks like it belongs here and
// does not. `abandoned` does not mean "the player gave up" — it means the run
// ROW was retired, and abandonZoneRunByID exists specifically to retire a run
// whose boss is already dead when the expedition travels onward (see its comment
// in dnd_zone_run.go). In prod, 30 of the realm's 32 boss kills carry
// abandoned = 1. Filtering them out drew a map on which almost nothing had ever
// been beaten, while the hall of firsts — reading a different table — said six
// zones had been. boss_defeated = 1 is the clear, full stop.
func loadRealmClearStats() (map[string]realmClearStats, error) {
rows, err := db.Get().Query(`
SELECT zone_id,
COUNT(*) AS clears,
COUNT(DISTINCT user_id) AS clearers,
user_id,
MIN(completed_at)
FROM dnd_zone_run
WHERE boss_defeated = 1 AND completed_at IS NOT NULL
GROUP BY zone_id`)
if err != nil {
return nil, err
}
defer rows.Close()
out := map[string]realmClearStats{}
for rows.Next() {
var zoneID, userID, completedAt string
var st realmClearStats
if err := rows.Scan(&zoneID, &st.clears, &st.clearers, &userID, &completedAt); err != nil {
return nil, err
}
st.firstUser = id.UserID(userID)
if ts, ok := parseSQLiteTime(completedAt); ok {
st.firstClearAt = ts.Unix()
}
out[zoneID] = st
}
return out, rows.Err()
}
// loadRealmOccupants answers "who is in there right now", per zone.
//
// Presence is dropped for an opted-out player rather than anonymised. Unlike a
// first clear it is not part of a tally that stops adding up without them, and
// it is the same live-location fact the run liveblog refuses to publish — an
// anonymous "somebody is in the Drowned Star" next to a roster showing exactly
// one person out on expedition is not an anonymisation.
//
// Errors are swallowed to nil: an unreadable expedition table should cost the
// realm map its occupant dots, not the whole page.
func loadRealmOccupants() map[string][]peteclient.RealmOccupant {
rows, err := db.Get().Query(
`SELECT user_id, zone_id, current_day FROM dnd_expedition WHERE status = 'active'`)
if err != nil {
slog.Error("realm: occupants query", "err", err)
return nil
}
defer rows.Close()
type live struct {
uid id.UserID
zoneID string
day int
}
var found []live
for rows.Next() {
var uid, zoneID string
var day int
if err := rows.Scan(&uid, &zoneID, &day); err != nil {
slog.Error("realm: occupants scan", "err", err)
return nil
}
found = append(found, live{id.UserID(uid), zoneID, day})
}
if err := rows.Err(); err != nil {
slog.Error("realm: occupants rows", "err", err)
return nil
}
// Names and opt-out are resolved only after the cursor is drained. The pool
// is one connection wide and charName reads the DB; resolving inside the loop
// is the deadlock W2a shipped and then had to fix.
out := map[string][]peteclient.RealmOccupant{}
for _, l := range found {
if isNewsOptedOut(l.uid) {
continue
}
name := charName(l.uid)
if name == "" {
continue // never fall back to a Matrix handle on a public page
}
if len(out[l.zoneID]) >= realmMaxOccupants {
continue
}
out[l.zoneID] = append(out[l.zoneID], peteclient.RealmOccupant{
Token: eventToken(l.uid, "roster"),
Name: name,
Level: charLevel(l.uid),
Day: l.day,
})
}
for zid := range out {
sort.Slice(out[zid], func(i, j int) bool { return out[zid][i].Name < out[zid][j].Name })
}
return out
}
// loadRealmFirsts renders news_realm_firsts as a history book.
//
// The ledger stores only (kind, target, first_at) — it exists to tier a dispatch,
// not to remember who. The holder is recovered here from the game's own history:
// a zone first from the earliest boss-defeating run, a treasure first from the
// earliest surviving row in adventure_treasures. Both can come back empty — a
// treasure that was found and later discarded leaves no owner anywhere — and an
// unattributed first is rendered as one rather than dropped. It still happened.
// loadRealmFirsts renders the hall of firsts, and it takes the clear stats
// rather than reading the ledger alone, for two reasons that only showed up
// against real prod data:
//
// 1. news_realm_firsts is INCOMPLETE for zones. It has only been written since
// the news seam went live, and the one-shot that seeded it filtered on
// `abandoned = 0` — the same wrong filter loadRealmClearStats documents — so
// it missed every zone whose clears were all retired runs. In prod it holds 6
// zones where the run history knows 9.
// 2. Its first_at is when the CLAIM was recorded, not when the thing happened.
// Every backfilled row in prod carries the same timestamp: the minute the
// backfill ran. A history book dated by when somebody wrote it down is not
// much of a history book.
//
// So the zone half is derived from the run history, which is complete and
// correctly dated, and the ledger supplies the kinds the run history knows
// nothing about (treasures, and whatever ships next) plus any zone claim with no
// surviving run behind it. That also makes the hall agree with the board by
// construction: both count a zone-first as "you were the first to clear it".
func loadRealmFirsts(clearsByZone map[string]realmClearStats) []peteclient.RealmFirst {
rows, err := db.Get().Query(
`SELECT kind, target, first_at FROM news_realm_firsts ORDER BY first_at ASC`)
if err != nil {
slog.Error("realm: firsts query", "err", err)
return nil
}
defer rows.Close()
var out []peteclient.RealmFirst
for rows.Next() {
var f peteclient.RealmFirst
if err := rows.Scan(&f.Kind, &f.Target, &f.AtUnix); err != nil {
slog.Error("realm: firsts scan", "err", err)
return nil
}
out = append(out, f)
}
if err := rows.Err(); err != nil {
slog.Error("realm: firsts rows", "err", err)
return nil
}
// Same discipline as the occupants: the cursor is closed before anything
// else touches the database.
rows.Close()
// Drop the ledger's zone rows wherever the run history has the same zone —
// it is the better record of both who and when. A claim with no run behind it
// survives, unattributed, and is what floors that zone's clear count in
// buildRealmSnapshot.
kept := out[:0]
for _, f := range out {
if f.Kind == "zone" {
if _, ok := clearsByZone[f.Target]; ok {
continue
}
}
kept = append(kept, f)
}
out = kept
// The zone half, from the authority the map and the board also use.
for zoneID, st := range clearsByZone {
zone := zoneOrFallback(ZoneID(zoneID))
f := peteclient.RealmFirst{
Kind: "zone",
Target: zoneID,
Display: zone.Display,
Tier: int(zone.Tier),
AtUnix: st.firstClearAt,
}
if !isNewsOptedOut(st.firstUser) {
if name := charName(st.firstUser); name != "" {
f.Holder = name
f.Token = eventToken(st.firstUser, "roster")
}
}
out = append(out, f)
}
for i := range out {
switch out[i].Kind {
case "zone":
if out[i].Display == "" {
zone := zoneOrFallback(ZoneID(out[i].Target))
out[i].Display = zone.Display
out[i].Tier = int(zone.Tier)
out[i].Holder, out[i].Token = realmFirstZoneHolder(out[i].Target)
}
case "treasure":
if def := lookupAdvTreasureDef(out[i].Target); def != nil {
out[i].Display = def.Name
out[i].Tier = def.Tier
} else {
out[i].Display = out[i].Target
}
out[i].Holder, out[i].Token = realmFirstTreasureHolder(out[i].Target)
default:
// A kind nobody has taught this function about still belongs in the
// hall — it is a genuine realm-first and the ledger says so. It just
// arrives with the raw target as its name, which is the same
// degrade-don't-drop rule the unknown event_type inversion settled on.
out[i].Display = out[i].Target
}
}
// Oldest first: the order it happened in. Pete regroups it newest-year-first
// for the page, but the wire carries history in history's order.
sort.Slice(out, func(i, j int) bool {
if out[i].AtUnix != out[j].AtUnix {
return out[i].AtUnix < out[j].AtUnix
}
return out[i].Target < out[j].Target
})
return out
}
// realmFirstZoneHolder names the earliest clearer of a zone. Returns ("", "")
// when the run history no longer has one, and ("Name", "") when it does but the
// player has opted out — the claim survives the anonymisation, the link does not.
func realmFirstZoneHolder(zoneID string) (name, token string) {
var userID string
err := db.Get().QueryRow(`
SELECT user_id
FROM dnd_zone_run
WHERE zone_id = ? AND boss_defeated = 1 AND completed_at IS NOT NULL
ORDER BY completed_at ASC
LIMIT 1`, zoneID).Scan(&userID)
if err != nil {
if err != sql.ErrNoRows {
slog.Error("realm: zone-first holder", "zone", zoneID, "err", err)
}
return "", ""
}
uid := id.UserID(userID)
if isNewsOptedOut(uid) {
return "", ""
}
name = charName(uid)
if name == "" {
return "", ""
}
return name, eventToken(uid, "roster")
}
// realmFirstTreasureHolder names the earliest holder of a treasure key. A
// treasure writes one row per bonus, so the MIN is over what may be several rows
// for the same acquisition; that is fine, they share a timestamp.
func realmFirstTreasureHolder(key string) (name, token string) {
var userID string
err := db.Get().QueryRow(`
SELECT user_id
FROM adventure_treasures
WHERE treasure_key = ?
ORDER BY acquired_at ASC
LIMIT 1`, key).Scan(&userID)
if err != nil {
if err != sql.ErrNoRows {
slog.Error("realm: treasure-first holder", "key", key, "err", err)
}
return "", ""
}
uid := id.UserID(userID)
if isNewsOptedOut(uid) {
return "", ""
}
name = charName(uid)
if name == "" {
return "", ""
}
return name, eventToken(uid, "roster")
}
// loadRealmStandings builds the board: one line per living, named, opted-in
// adventurer, every number a lifetime total.
//
// It walks player_meta the way buildRosterSnapshot does, and for the same
// reason — that is the list of people who exist, and a standings table assembled
// by grouping the run history instead would silently include characters that have
// since been deleted or never finished setup.
func loadRealmStandings(clearsByZone map[string]realmClearStats) ([]peteclient.RealmStanding, error) {
rows, err := db.Get().Query(`SELECT user_id FROM player_meta WHERE alive = 1`)
if err != nil {
return nil, err
}
defer rows.Close()
var uids []id.UserID
for rows.Next() {
var uid string
if err := rows.Scan(&uid); err != nil {
return nil, err
}
uids = append(uids, id.UserID(uid))
}
if err := rows.Err(); err != nil {
return nil, err
}
rows.Close()
// Who holds how many realm-firsts, from the same authority the zone column
// uses — so a zone's "first cleared by X" and X's firsts count can never
// disagree with each other.
firstsBy := map[id.UserID]int{}
for _, st := range clearsByZone {
firstsBy[st.firstUser]++
}
perZone, err := loadRealmPlayerClears()
if err != nil {
return nil, err
}
siege := loadRealmSiegeTotals()
var out []peteclient.RealmStanding
for _, uid := range uids {
if isNewsOptedOut(uid) {
continue // the board omits an opted-out player outright, as it always has
}
c, err := LoadDnDCharacter(uid)
if err != nil || c == nil || c.PendingSetup {
continue
}
name := charName(uid)
if name == "" {
continue
}
s := peteclient.RealmStanding{
Token: eventToken(uid, "roster"),
Name: name,
Level: c.Level,
ClassRace: classRaceLabel(c),
Firsts: firstsBy[uid],
SiegeDamage: siege[uid].damage,
SiegeFights: siege[uid].fights,
}
for zoneID, n := range perZone[uid] {
s.Clears += n
s.Zones++
if t := int(zoneOrFallback(ZoneID(zoneID)).Tier); t > s.DeepestTier {
s.DeepestTier = t
}
}
out = append(out, s)
}
// Ranked here, not on Pete: the ordering is a statement about the game
// ("deepest tier beaten, then how much of the realm you have beaten"), and
// the game is the thing that gets to make it. Name breaks the tie so the
// board is stable between snapshots that are otherwise identical.
sort.Slice(out, func(i, j int) bool {
a, b := out[i], out[j]
switch {
case a.DeepestTier != b.DeepestTier:
return a.DeepestTier > b.DeepestTier
case a.Zones != b.Zones:
return a.Zones > b.Zones
case a.Clears != b.Clears:
return a.Clears > b.Clears
case a.Level != b.Level:
return a.Level > b.Level
default:
return a.Name < b.Name
}
})
return out, nil
}
// loadRealmPlayerClears returns clears[user][zone] = count, in one pass.
func loadRealmPlayerClears() (map[id.UserID]map[string]int, error) {
rows, err := db.Get().Query(`
SELECT user_id, zone_id, COUNT(*)
FROM dnd_zone_run
WHERE boss_defeated = 1 AND completed_at IS NOT NULL
GROUP BY user_id, zone_id`)
if err != nil {
return nil, err
}
defer rows.Close()
out := map[id.UserID]map[string]int{}
for rows.Next() {
var uid, zoneID string
var n int
if err := rows.Scan(&uid, &zoneID, &n); err != nil {
return nil, err
}
u := id.UserID(uid)
if out[u] == nil {
out[u] = map[string]int{}
}
out[u][zoneID] = n
}
return out, rows.Err()
}
type realmSiegeTotal struct{ damage, fights int }
// loadRealmSiegeTotals sums every Siege a player has ever turned up to. Across
// all bosses, not just the live one — the war room already shows the current
// muster, and what the board is for is the person who has shown up to all six.
func loadRealmSiegeTotals() map[id.UserID]realmSiegeTotal {
rows, err := db.Get().Query(
`SELECT user_id, SUM(damage), SUM(fights) FROM world_boss_contrib GROUP BY user_id`)
if err != nil {
slog.Error("realm: siege totals query", "err", err)
return nil
}
defer rows.Close()
out := map[id.UserID]realmSiegeTotal{}
for rows.Next() {
var uid string
var damage, fights int
if err := rows.Scan(&uid, &damage, &fights); err != nil {
slog.Error("realm: siege totals scan", "err", err)
return nil
}
out[id.UserID(uid)] = realmSiegeTotal{damage, fights}
}
if err := rows.Err(); err != nil {
slog.Error("realm: siege totals rows", "err", err)
return nil
}
return out
}
internal/plugin/pete_realm_test.go
+351
View File
@@ -0,0 +1,351 @@
package plugin
import (
"testing"
"time"
"gogobee/internal/db"
"maunium.net/go/mautrix/id"
)
// seedRealmFixture builds a small but realistic realm: two players, three
// cleared runs across two zones, one live expedition, and the realm-first ledger
// that the zone clears would have seeded.
func seedRealmFixture(t *testing.T) {
t.Helper()
dir := t.TempDir()
db.Close()
if err := db.Init(dir); err != nil {
t.Fatalf("db.Init: %v", err)
}
t.Cleanup(db.Close)
db.Exec("seed josie", `INSERT INTO player_meta (user_id, display_name, alive) VALUES (?, ?, 1)`,
"@josie:x", "Josie")
db.Exec("seed quack", `INSERT INTO player_meta (user_id, display_name, alive) VALUES (?, ?, 1)`,
"@quack:x", "Quack")
// The board walks player_meta and then loads a character, so both halves have
// to exist: a player_meta row with no character is somebody who never finished
// setup, and standings correctly leaves them off.
for _, c := range []*DnDCharacter{
{UserID: "@josie:x", Race: RaceHuman, Class: ClassFighter, Level: 12,
STR: 18, DEX: 14, CON: 16, INT: 10, WIS: 10, CHA: 10,
HPMax: 120, HPCurrent: 120, ArmorClass: 18},
{UserID: "@quack:x", Race: RaceElf, Class: ClassMage, Level: 8,
STR: 8, DEX: 16, CON: 12, INT: 18, WIS: 12, CHA: 10,
HPMax: 48, HPCurrent: 48, ArmorClass: 12},
} {
if err := SaveDnDCharacter(c); err != nil {
t.Fatalf("SaveDnDCharacter(%s): %v", c.UserID, err)
}
}
// Josie cleared the Warrens first, then again; Quack cleared them later. Only
// Josie has been through the Crypt — and it is a deeper tier, which is what
// makes the board's depth-before-breadth ordering testable.
for _, r := range []struct {
runID, user, zone, at string
}{
{"r1", "@josie:x", string(ZoneGoblinWarrens), "2026-01-10 12:00:00"},
{"r2", "@quack:x", string(ZoneGoblinWarrens), "2026-03-02 12:00:00"},
{"r3", "@josie:x", string(ZoneGoblinWarrens), "2026-04-05 12:00:00"},
{"r4", "@josie:x", string(ZoneCryptValdris), "2026-05-01 12:00:00"},
} {
db.Exec("seed run", `INSERT INTO dnd_zone_run
(run_id, user_id, zone_id, total_rooms, boss_defeated, abandoned, completed_at)
VALUES (?, ?, ?, 6, 1, 0, ?)`, r.runID, r.user, r.zone, r.at)
}
// A retired-but-won run: boss_defeated = 1 with abandoned = 1. This IS a
// clear — `abandoned` means the run row was retired (the expedition travelled
// on after the kill), not that anybody gave up, and in prod it is how 30 of
// the realm's 32 boss kills are stored. The fixture carries one so the
// aggregate can never quietly go back to filtering them out.
db.Exec("seed retired-win", `INSERT INTO dnd_zone_run
(run_id, user_id, zone_id, total_rooms, boss_defeated, abandoned, completed_at)
VALUES ('r5', '@quack:x', 'crypt_valdris', 6, 1, 1, '2026-05-02 12:00:00')`)
// A genuinely unfinished run: no boss, no completion. Not a clear.
db.Exec("seed inflight", `INSERT INTO dnd_zone_run
(run_id, user_id, zone_id, total_rooms, boss_defeated, abandoned, completed_at)
VALUES ('r6', '@quack:x', 'crypt_valdris', 6, 0, 0, NULL)`)
claimRealmFirst("zone", string(ZoneGoblinWarrens))
claimRealmFirst("zone", string(ZoneCryptValdris))
}
// TestRealmClearStatsPickTheEarliestClearer is the load-bearing query on the
// whole map: "who first got through here" is the single most interesting fact a
// zone has, and it has to be the person who was actually first.
//
// It leans on SQLite's bare-column min/max rule — the user_id comes from the same
// row MIN(completed_at) came from — which is the same thing backfillZoneFirsts
// has relied on since the news seam shipped. If that ever stopped holding, this
// would attribute somebody else's conquest to whoever the grouping happened to
// land on, silently.
func TestRealmClearStatsPickTheEarliestClearer(t *testing.T) {
seedRealmFixture(t)
stats, err := loadRealmClearStats()
if err != nil {
t.Fatalf("loadRealmClearStats: %v", err)
}
warrens, ok := stats["goblin_warrens"]
if !ok {
t.Fatal("no stats for goblin_warrens")
}
if warrens.clears != 3 {
t.Errorf("warrens clears = %d, want 3", warrens.clears)
}
if warrens.clearers != 2 {
t.Errorf("warrens clearers = %d, want 2", warrens.clearers)
}
if warrens.firstUser != id.UserID("@josie:x") {
t.Errorf("warrens first clearer = %q, want @josie:x — the earliest run didn't win", warrens.firstUser)
}
// Two clears: Josie's, and Quack's retired-but-won run. The in-flight run is
// correctly excluded. A regression to `AND abandoned = 0` shows up here as 1.
crypt := stats["crypt_valdris"]
if crypt.clears != 2 {
t.Errorf("crypt clears = %d, want 2 — a won-then-retired run is a clear, "+
"and an in-flight one is not", crypt.clears)
}
if crypt.firstUser != id.UserID("@josie:x") {
t.Errorf("crypt first clearer = %q, want @josie:x", crypt.firstUser)
}
}
// TestOptedOutFirstClearerIsAnonymisedNotErased. The Siege contributor rule,
// applied to the map: deleting an opted-out clearer's claim would leave the zone
// drawn as never-cleared, and "nobody has ever come out of there" is the most
// dramatic thing the page can say. Saying it falsely because somebody chose
// privacy would be worse than saying nothing.
func TestOptedOutFirstClearerIsAnonymisedNotErased(t *testing.T) {
seedRealmFixture(t)
setNewsOptout(id.UserID("@josie:x"), true)
snap, err := buildRealmSnapshot(time.Now().UTC())
if err != nil {
t.Fatalf("buildRealmSnapshot: %v", err)
}
var warrens *struct {
clears int
by, token string
}
for _, z := range snap.Zones {
if z.ID == "goblin_warrens" {
warrens = &struct {
clears int
by, token string
}{z.Clears, z.FirstClearBy, z.FirstClearToken}
}
}
if warrens == nil {
t.Fatal("goblin_warrens is not in the snapshot at all")
}
if warrens.clears != 3 {
t.Errorf("clears = %d, want 3 — an opt-out deleted the town's history", warrens.clears)
}
if warrens.by != "" || warrens.token != "" {
t.Errorf("opted-out clearer still named: by=%q token=%q", warrens.by, warrens.token)
}
}
// TestOptedOutPlayerLeavesTheBoardEntirely. Standings follow the board's rule,
// not the Siege's: an opted-out player is omitted outright. Their level, class
// and clear count would re-identify them, and unlike a siege contribution there
// is no shared total that stops adding up without them.
func TestOptedOutPlayerLeavesTheBoardEntirely(t *testing.T) {
seedRealmFixture(t)
setNewsOptout(id.UserID("@quack:x"), true)
snap, err := buildRealmSnapshot(time.Now().UTC())
if err != nil {
t.Fatalf("buildRealmSnapshot: %v", err)
}
for _, s := range snap.Standings {
if s.Name == "Quack" {
t.Fatal("an opted-out player is still on the standings board")
}
}
}
// TestOccupantsDropOptedOutPlayers. Presence is the strictest case on the page
// and deliberately stricter than a first clear: "who is in the Crypt of Valdris
// right now" is the live-location fact the run liveblog refuses to publish at
// all, so an opted-out player is dropped rather than anonymised.
func TestOccupantsDropOptedOutPlayers(t *testing.T) {
seedRealmFixture(t)
db.Exec("seed expedition", `INSERT INTO dnd_expedition
(expedition_id, user_id, zone_id, status, current_day)
VALUES ('e1', '@josie:x', 'crypt_valdris', 'active', 3)`)
if occ := loadRealmOccupants(); len(occ["crypt_valdris"]) != 1 {
t.Fatalf("opted-in occupant missing: %+v", occ)
} else if occ["crypt_valdris"][0].Name != "Josie" || occ["crypt_valdris"][0].Day != 3 {
t.Errorf("occupant = %+v, want Josie on day 3", occ["crypt_valdris"][0])
}
setNewsOptout(id.UserID("@josie:x"), true)
if occ := loadRealmOccupants(); len(occ["crypt_valdris"]) != 0 {
t.Errorf("opted-out player still shows as standing in a zone: %+v", occ["crypt_valdris"])
}
}
// TestStandingsCountFirstsFromTheSameAuthorityTheMapDoes. A zone's "first
// through: Josie" and Josie's own firsts count come off one map in one pass, so
// the two can never disagree — which they would if the board recounted the
// ledger itself and the two queries drifted.
func TestStandingsCountFirstsFromTheSameAuthorityTheMapDoes(t *testing.T) {
seedRealmFixture(t)
snap, err := buildRealmSnapshot(time.Now().UTC())
if err != nil {
t.Fatalf("buildRealmSnapshot: %v", err)
}
firstsByName := map[string]int{}
for _, s := range snap.Standings {
firstsByName[s.Name] = s.Firsts
}
// Josie was first through both zones; Quack was first through neither.
if firstsByName["Josie"] != 2 {
t.Errorf("Josie holds %d firsts, want 2", firstsByName["Josie"])
}
if firstsByName["Quack"] != 0 {
t.Errorf("Quack holds %d firsts, want 0", firstsByName["Quack"])
}
named := 0
for _, z := range snap.Zones {
if z.FirstClearBy == "Josie" {
named++
}
}
if named != firstsByName["Josie"] {
t.Errorf("the map names Josie on %d zones but the board credits her with %d — "+
"the two disagree about the same fact", named, firstsByName["Josie"])
}
}
// TestStandingsRankDeepestFirst. The ordering is the game's statement about what
// it values, and Pete renders it without renumbering — so it has to be right
// here. Depth beats breadth: somebody who has put down a Tier 5 boss is ahead of
// somebody who has cleared the whole of Tier 1 forty times.
func TestStandingsRankDeepestFirst(t *testing.T) {
seedRealmFixture(t)
rows, err := loadRealmStandings(map[string]realmClearStats{})
if err != nil {
t.Fatalf("loadRealmStandings: %v", err)
}
if len(rows) < 2 {
t.Fatalf("got %d standings rows, want 2", len(rows))
}
for i := 1; i < len(rows); i++ {
a, b := rows[i-1], rows[i]
if a.DeepestTier < b.DeepestTier {
t.Errorf("row %d (T%d) sorts above row %d (T%d) — the board is not deepest-first",
i-1, a.DeepestTier, i, b.DeepestTier)
}
if a.DeepestTier == b.DeepestTier && a.Zones < b.Zones {
t.Errorf("equal depth but row %d covers %d zones above row %d's %d",
i-1, a.Zones, i, b.Zones)
}
}
}
// TestFirstsLedgerIsRenderedNotJustCounted. news_realm_firsts has existed since
// the news seam shipped and has only ever been used to decide a dispatch tier —
// the ledger itself was never read back. This is the whole point of the hall: it
// is a history book, and every row needs a name and a date on it.
func TestFirstsLedgerIsRenderedNotJustCounted(t *testing.T) {
seedRealmFixture(t)
stats, err := loadRealmClearStats()
if err != nil {
t.Fatalf("loadRealmClearStats: %v", err)
}
firsts := loadRealmFirsts(stats)
if len(firsts) != 2 {
t.Fatalf("got %d firsts, want 2", len(firsts))
}
// Oldest first, which is the order it happened in.
if firsts[0].Target != "goblin_warrens" {
t.Errorf("ledger order starts with %q, want goblin_warrens", firsts[0].Target)
}
for _, f := range firsts {
if f.Display == "" {
t.Errorf("first %q has no display name — it would render as a blank row", f.Target)
}
if f.Holder != "Josie" {
t.Errorf("first %q holder = %q, want Josie (she cleared both zones first)", f.Target, f.Holder)
}
if f.Token == "" {
t.Errorf("first %q has a holder but no token, so the hall can't link to them", f.Target)
}
}
}
// TestUnrecoverableFirstStillGetsAnEntry. The ledger records (kind, target,
// first_at) and nothing else; the holder is recovered at push time from the run
// history. A treasure found and later discarded leaves no owner anywhere, and
// that entry has to survive as an unattributed first rather than vanish — it
// still happened, and the hall is a record of what happened.
func TestUnrecoverableFirstStillGetsAnEntry(t *testing.T) {
seedRealmFixture(t)
claimRealmFirst("treasure", "a_hat_nobody_kept")
var found bool
stats, err := loadRealmClearStats()
if err != nil {
t.Fatalf("loadRealmClearStats: %v", err)
}
for _, f := range loadRealmFirsts(stats) {
if f.Target == "a_hat_nobody_kept" {
found = true
if f.Holder != "" {
t.Errorf("holder = %q, want empty — nothing in the game knows who had it", f.Holder)
}
if f.Display == "" {
t.Error("an unrecoverable first got no display name at all")
}
}
}
if !found {
t.Error("a first with no recoverable holder was dropped from the ledger entirely")
}
}
// TestRealmPushIsRateLimitedBelowTheRosterTick. The realm rides the 2-minute
// roster ticker but is aggregate scans over the whole run history, and none of
// it moves at roster speed. The self-limit is the thing that makes riding that
// ticker acceptable, so it is worth pinning — and so is the other half: a FAILED
// push must not stamp the clock, or an outage would be followed by ten minutes
// of silence instead of a retry on the next tick.
func TestRealmPushIsRateLimitedBelowTheRosterTick(t *testing.T) {
if realmPushInterval <= rosterTickInterval {
t.Fatalf("realmPushInterval (%v) is not longer than the roster tick (%v) — "+
"the realm would be recomputed every tick", realmPushInterval, rosterTickInterval)
}
// The gate itself: zero means never-pushed and must always go.
realmLastPush = time.Time{}
t.Cleanup(func() { realmLastPush = time.Time{} })
now := time.Now().UTC()
if !realmLastPush.IsZero() {
t.Fatal("fixture broken")
}
// A stamp inside the window suppresses; one outside it does not.
realmLastPush = now.Add(-realmPushInterval / 2)
if now.Sub(realmLastPush) >= realmPushInterval {
t.Error("a push half an interval old is not being suppressed")
}
realmLastPush = now.Add(-realmPushInterval - time.Minute)
if now.Sub(realmLastPush) < realmPushInterval {
t.Error("a push older than the interval is still being suppressed")
}
}
internal/plugin/pete_roster.go
+380 -6
View File
@@ -4,6 +4,8 @@ import (
"context"
"fmt"
"log/slog"
"sort"
"strings"
"time"
"gogobee/internal/db"
@@ -50,6 +52,18 @@ func (p *AdventurePlugin) peteRosterTicker() {
}
p.pushRoster()
p.pushDetails()
p.pushSiege()
// Self-rate-limited to realmPushInterval: the realm is aggregate scans
// over the whole run history and none of it moves at roster speed.
p.pushRealm()
p.pushRunBeats()
// After the beats, not before: the summary is the last beat of a run's
// story and has no business overtaking the log it is about. It is also the
// only step here that can talk to the model, which is why it lives on a
// ticker at all rather than at the moment a run ends — and why it starts
// beside the ticker rather than on it, since a cold model takes longer to
// load than the interval between two pushes.
p.sweepRunSummariesAsync()
}
}
@@ -95,7 +109,7 @@ func (p *AdventurePlugin) pushRoster() {
var detailPushOK bool
func (p *AdventurePlugin) pushDetails() {
snap, err := buildDetailSnapshot(time.Now().UTC())
snap, err := p.buildDetailSnapshot(time.Now().UTC())
if err != nil {
slog.Error("roster: build detail snapshot failed", "err", err)
return
@@ -130,6 +144,10 @@ func rosterDetail(uid id.UserID, c *DnDCharacter) *peteclient.RosterDetail {
ArmorClass: c.ArmorClass,
Abilities: [6]int{c.STR, c.DEX, c.CON, c.INT, c.WIS, c.CHA},
Modifiers: c.Modifiers(),
// Unconditional, and this is the whole point of the field: it says this
// build knows about party seats, not that this character has any. Making
// it conditional would put it straight back in the hole it closes.
PartyKnown: true,
}
if equip, err := loadAdvEquipment(uid); err == nil {
for _, slot := range allSlots {
@@ -156,7 +174,7 @@ func rosterDetail(uid id.UserID, c *DnDCharacter) *peteclient.RosterDetail {
// owner it belongs to, so hiding a player from it would only deny them their own
// sheet. The board token rides along so Pete can match owner↔page without ever
// reversing the one-way token.
func buildDetailSnapshot(now time.Time) (peteclient.DetailSnapshot, error) {
func (p *AdventurePlugin) buildDetailSnapshot(now time.Time) (peteclient.DetailSnapshot, error) {
snap := peteclient.DetailSnapshot{SnapshotAt: now.Unix()}
rows, err := db.Get().Query(`SELECT user_id FROM player_meta WHERE alive = 1`)
if err != nil {
@@ -198,51 +216,334 @@ func buildDetailSnapshot(now time.Time) (peteclient.DetailSnapshot, error) {
}
if items, err := loadAdvInventory(uid); err == nil {
pd.Inventory = itemViews(items)
if equipped, err := loadEquippedMagicItems(uid); err == nil {
attachInventoryCompares(pd.Inventory, items, equipped)
}
}
if items, err := loadAdvVault(uid); err == nil {
pd.Vault = itemViews(items)
}
pd.Equipped = equippedViews(uid)
// Ask 7: the 5 standard slots for the web management panel, plus the euro
// balance the upgrade/repair confirm dialogs show. Balance is nil-guarded so
// the free-standing tests (which build no euro plugin) still run.
pd.Slots = buildEquipSlotViews(uid)
if p.euro != nil {
pd.Balance = p.euro.GetBalance(uid)
}
// W5b: what this owner may ask for from the web, priced. See pete_offers.go
// on why a quote is not a permission.
pd.Zones = zoneOffersFor(uid)
pd.Resume = resumeOfferFor(uid)
pd.Babysit = babysitOfferFor(adv)
snap.Players = append(snap.Players, pd)
}
return snap, nil
}
// itemViews renders inventory or vault rows for the private panel, resolving
// the display facts the row itself doesn't carry.
//
// Attuned is always false here and that is not an omission: equipping *moves*
// the row out of adventure_inventory into magic_item_equipped, so nothing in a
// backpack can hold a bond. Worn items come from equippedViews instead.
func itemViews(items []AdvItem) []peteclient.ItemView {
if len(items) == 0 {
return nil
}
out := make([]peteclient.ItemView, 0, len(items))
for _, it := range items {
out = append(out, peteclient.ItemView{
v := peteclient.ItemView{
Name: it.Name,
Type: it.Type,
Tier: it.Tier,
Value: it.Value,
Temper: it.Temper,
Slot: string(it.Slot),
}
// SkillSource is dual-use: a real skill name on masterwork gear, an
// internal registry pointer on magic-item rows. Only the former is a
// fact about the item; the latter is plumbing and stays home.
if !strings.HasPrefix(it.SkillSource, "magic_item:") {
v.SkillSource = it.SkillSource
}
if mi, ok := magicItemFromAdvItem(it); ok {
eff := temperedItem(mi, it.Temper)
v.Slot = string(eff.Slot)
v.Desc = eff.Desc
v.Effect = magicItemEffectSummary(eff)
v.Attunement = eff.Attunement
// The row id is the equip handle: a slotted magic item is the one thing
// the web equip path can wear, so only it carries an id. Mundane gear (the
// branch below) and unslotted curios get none, so no Equip button. This
// runs for vault rows too — a vault magic item would carry an id — but Pete
// offers the button on the backpack panel alone, so that's inert, not a leak.
if eff.Slot != "" {
v.ID = it.ID
}
} else if it.Slot != "" {
// Shop equipment resolves by (slot, tier) — Name is decorative.
v.Desc = equipmentDefByTier(it.Slot, it.Tier).Description
// A masterwork/arena piece carries a real slot, so it can be worn from the
// web (into a standard slot) — give it the equip handle. Plain shop gear in
// the pack stays button-less: its slot is just a category, not a wearable.
if it.Type == "MasterworkGear" || it.Type == "ArenaGear" {
v.ID = it.ID
}
}
out = append(out, v)
}
return out
}
// attachInventoryCompares fills the Compare card on every backpack magic item —
// the ones that carry an equip id, which is exactly the set the web Equip button
// acts on (equippedViews/vault rows are excluded by construction). views and items
// are index-aligned: itemViews appends one view per item and skips none.
func attachInventoryCompares(views []peteclient.ItemView, items []AdvItem, equipped map[DnDSlot]EquippedMagicItem) {
for i := range views {
if views[i].ID == 0 {
continue // no equip id → mundane gear or unslotted curio → no button, no compare
}
mi, ok := magicItemFromAdvItem(items[i])
if !ok || mi.Slot == "" {
continue
}
views[i].Compare = magicItemCompare(mi, items[i].Temper, equipped)
}
}
// magicItemCompare pairs a candidate backpack item against whatever is worn in
// the slot it would equip into (mi.Slot — the same slot applyMagicEquip targets,
// so the card describes the trade the Equip button actually makes). The diff is
// over *tempered* effects on both sides; bond availability decides the inert case.
func magicItemCompare(cand MagicItem, temper int, equipped map[DnDSlot]EquippedMagicItem) *peteclient.ItemCompare {
if cand.Slot == "" {
return nil
}
candEff := magicItemEffectFor(temperedItem(cand, temper))
worn, wornExists := equipped[cand.Slot]
if wornExists && worn.Item.ID == "" {
wornExists = false // an empty EquippedMagicItem is not a real occupant
}
// An empty slot compares against neutral: DamageReductMult is a multiplier, so
// its neutral is 1.0, not the zero value (0 would read as -100% damage taken).
wornEff := magicItemEffect{DamageReductMult: 1.0}
vsName := ""
if wornExists {
wornEff = magicItemEffectFor(worn.Effective())
vsName = worn.Effective().Name
}
deltas := magicItemDeltas(candEff, wornEff)
// Inert: the item wants a bond and none is free. Equipping evicts the slot's
// occupant first, so an attuned occupant frees its own bond — count post-swap.
inert := false
if cand.Attunement {
bonds := countAttunedMagicItems(equipped)
if wornExists && worn.Attuned {
bonds--
}
inert = bonds >= dndMagicItemAttuneLimit
}
return &peteclient.ItemCompare{
Verdict: compareVerdict(deltas, !wornExists, inert),
VsName: vsName,
VsSlot: string(cand.Slot),
Deltas: deltas,
}
}
// compareVerdict classifies a set of deltas by strict dominance. Different stats
// are not fungible — the engine can't say +3% damage beats -4 HP — so a mixed
// result is a sidegrade with no winner claimed, which is the whole reason the
// card exists. inert and new override the stat verdict.
func compareVerdict(deltas []peteclient.ItemDelta, empty, inert bool) string {
if inert {
return "inert" // wearing it does nothing until a bond frees; stat diff is moot
}
if empty {
return "new"
}
if len(deltas) == 0 {
return "same"
}
gains, losses := 0, 0
for _, d := range deltas {
if d.Better {
gains++
} else {
losses++
}
}
switch {
case losses == 0:
return "upgrade"
case gains == 0:
return "downgrade"
default:
return "sidegrade"
}
}
// magicItemDeltas returns one entry per stat that visibly changes between the
// candidate and the worn item. It diffs the structured effect fields, never the
// summary string (which drops zero fields and would lose deltas). A change too
// small to show at the rendered precision is omitted, so the verdict matches what
// the player sees.
func magicItemDeltas(cand, worn magicItemEffect) []peteclient.ItemDelta {
var d []peteclient.ItemDelta
// DamageBonus / DamageReductMult are fractions rendered as whole percents.
if pct := (cand.DamageBonus - worn.DamageBonus) * 100; roundedPct(pct) != 0 {
d = append(d, peteclient.ItemDelta{Label: "damage", Better: pct > 0, Text: signedPct(pct, "damage")})
}
// DamageReductMult is a multiplier on damage TAKEN, so lower is better. Express
// the change as damage taken: a positive number means you take more (worse).
if taken := (cand.DamageReductMult - worn.DamageReductMult) * 100; roundedPct(taken) != 0 {
d = append(d, peteclient.ItemDelta{Label: "defense", Better: taken < 0, Text: signedPct(taken, "damage taken")})
}
if diff := cand.FlatDmgStart - worn.FlatDmgStart; diff != 0 {
d = append(d, peteclient.ItemDelta{Label: "opening", Better: diff > 0, Text: signedInt(diff, "opening damage")})
}
if diff := cand.MaxHP - worn.MaxHP; diff != 0 {
d = append(d, peteclient.ItemDelta{Label: "hp", Better: diff > 0, Text: signedInt(diff, "HP")})
}
if cand.InitiativeBias != worn.InitiativeBias {
faster := cand.InitiativeBias > worn.InitiativeBias
text := "slower to act"
if faster {
text = "faster to act"
}
d = append(d, peteclient.ItemDelta{Label: "speed", Better: faster, Text: text})
}
return d
}
// roundedPct is the whole-percent a delta renders as; used to drop sub-percent
// noise so the verdict never disagrees with the displayed chips.
func roundedPct(v float64) int {
if v < 0 {
return int(v - 0.5)
}
return int(v + 0.5)
}
func signedPct(v float64, noun string) string { return fmt.Sprintf("%+d%% %s", roundedPct(v), noun) }
func signedInt(v int, noun string) string { return fmt.Sprintf("%+d %s", v, noun) }
// equippedViews returns the magic items the player is actually wearing. This is
// the only place Attuned means anything: the bond lives on the equipped row, and
// with a cap of dndMagicItemAttuneLimit a worn item can be inert.
func equippedViews(uid id.UserID) []peteclient.ItemView {
equipped, err := loadEquippedMagicItems(uid)
if err != nil || len(equipped) == 0 {
return nil
}
out := make([]peteclient.ItemView, 0, len(equipped))
for _, e := range equipped {
eff := e.Effective()
out = append(out, peteclient.ItemView{
Name: eff.Name,
Type: string(eff.Kind),
Value: int64(eff.Value),
Temper: e.Temper,
Slot: string(e.Slot),
Desc: eff.Desc,
Effect: magicItemEffectSummary(eff),
Attunement: eff.Attunement,
Attuned: e.Attuned,
})
}
// Map iteration is random; the panel must not reshuffle every 60s poll.
sort.Slice(out, func(i, j int) bool { return out[i].Slot < out[j].Slot })
return out
}
// petViews returns the player's live pet slots. A pet that was chased away is
// omitted — it isn't with them right now, and the self-view shows the present.
//
// XPNeeded rides along so the web can draw the progress toward the next level.
// It is the engine's number, not Pete's: the curve steps by level band and a
// copy of it on the web side would be a second answer to "how close is my dog"
// that drifts the first time the band moves.
func petViews(adv *AdventureCharacter) []peteclient.PetView {
var out []peteclient.PetView
if adv.PetType != "" && !adv.PetChasedAway {
out = append(out, peteclient.PetView{
Type: adv.PetType, Name: adv.PetName, Level: adv.PetLevel,
XP: adv.PetXP, ArmorTier: adv.PetArmorTier,
XP: adv.PetXP, XPNeeded: petXPNeededCenti(adv.PetLevel),
ArmorTier: adv.PetArmorTier,
})
}
if adv.Pet2Type != "" && !adv.Pet2ChasedAway {
out = append(out, peteclient.PetView{
Type: adv.Pet2Type, Name: adv.Pet2Name, Level: adv.Pet2Level,
XP: adv.Pet2XP, ArmorTier: adv.Pet2ArmorTier,
XP: adv.Pet2XP, XPNeeded: petXPNeededCenti(adv.Pet2Level),
ArmorTier: adv.Pet2ArmorTier,
})
}
return out
}
// partySeatViews describes who is on this expedition for the public detail page.
// Returns nil for a solo run: expeditionParty always hands back at least the
// leader, and a "party" of one chair is a worse thing to draw than nothing.
//
// The opt-out rule is the Siege contributor's, not the realm occupant's: a seat
// belonging to an opted-out player is kept and anonymised. Deleting it would
// make a party of three read as a pair, and the numbers beside it — the supply
// burn, the threat, the enemy scaling — all felt three bodies. What an unnamed
// seat discloses is that somebody else is down there, which the zone and day on
// this same page already say about everyone in the party.
//
// Levels come from a per-seat character load. Parties cap at three and the
// companion needs no load at all, so this is at most two extra reads for a
// player who is actually in one.
func partySeatViews(exp *Expedition) []peteclient.PartySeatView {
seats, err := expeditionParty(exp.ID, exp.UserID)
if err != nil {
slog.Debug("pete: party seats unavailable", "expedition", exp.ID, "err", err)
return nil
}
if len(seats) < 2 {
return nil // solo, or a roster that only holds its leader
}
out := make([]peteclient.PartySeatView, 0, len(seats))
for _, s := range seats {
if s.Kind == SeatCompanion {
// The hireling is named unconditionally: he is not a player, has no
// board row to link to and no privacy to protect.
out = append(out, peteclient.PartySeatView{
Kind: "companion", Name: companionDisplayName,
})
continue
}
kind := "member"
if s.Kind == SeatLeader {
kind = "leader"
}
v := peteclient.PartySeatView{Kind: kind}
if !isNewsOptedOut(s.UserID) {
v.Name = charName(s.UserID)
if v.Name != "" {
// Token only alongside a name: a link to a page that says who they are
// would undo the anonymising below all by itself.
v.Token = eventToken(s.UserID, "roster")
if c, cerr := LoadDnDCharacter(s.UserID); cerr == nil && c != nil {
v.Level = c.Level
}
}
}
out = append(out, v)
}
return out
}
// buildRosterSnapshot assembles the complete board.
//
// Complete is the contract: Pete *replaces* its board with this, so anyone we
@@ -329,7 +630,13 @@ func buildRosterSnapshot(now time.Time, euro *EuroPlugin) (peteclient.RosterSnap
e.Detail = rosterDetail(pl.uid, c)
if exp, _ := getActiveExpedition(pl.uid); exp != nil {
// activeExpeditionFor, not getActiveExpedition: the latter keys on
// dnd_expedition.user_id and is blind to members, so a player seated on
// somebody else's run has been reading as "idle in town" on the public board
// for the whole life of N3 parties — standing in a tier-4 dungeon. The
// expedition it resolves to is the leader's row, which is the right answer:
// a party shares one clock, one supply pool and one run.
if exp, _, _ := activeExpeditionFor(pl.uid); exp != nil {
zone := zoneOrFallback(exp.ZoneID)
e.Status = "expedition"
e.Zone = zone.Display
@@ -342,9 +649,11 @@ func buildRosterSnapshot(now time.Time, euro *EuroPlugin) (peteclient.RosterSnap
if e.Detail != nil {
e.Detail.Supplies = int(exp.Supplies.Current)
e.Detail.ThreatLevel = exp.ThreatLevel
e.Detail.Party = partySeatViews(exp)
if exp.RunID != "" {
if run, rerr := getZoneRun(exp.RunID); rerr == nil && run != nil && run.TotalRooms > 0 {
e.Detail.Room = fmt.Sprintf("%d / %d", run.CurrentRoom+1, run.TotalRooms)
e.Detail.Map = buildRosterMap(run)
}
}
}
@@ -358,6 +667,71 @@ func buildRosterSnapshot(now time.Time, euro *EuroPlugin) (peteclient.RosterSnap
return snap, nil
}
// buildRosterMap computes the fog-of-war cut of a run's zone graph for the
// public roster. It sends every visited node with its true kind, plus the
// one-hop frontier — the destinations of edges leading out of visited nodes,
// with their kind withheld as "unknown". Edges are directed and stored by
// from-node, so "one hop out of a visited node" is exactly g.Edges[visited].
// A frontier node's edges are NOT walked, so nothing past the first closed
// door reaches the wire — "view source to find the boss room" is not fog of
// war. Node Label/Content never leave the game box.
//
// Output order is deterministic (visited-path order, then frontier in
// discovery order) so an unchanged run produces a byte-identical snapshot and
// the roster push does not churn.
func buildRosterMap(run *DungeonRun) *peteclient.RosterMap {
g, ok := loadZoneGraph(run.ZoneID)
if !ok || len(run.VisitedNodes) == 0 {
return nil
}
// Unique visited nodes in path order — VisitedNodes repeats on backtrack.
orderedVisited := make([]string, 0, len(run.VisitedNodes))
seen := make(map[string]bool, len(run.VisitedNodes))
for _, id := range run.VisitedNodes {
if !seen[id] {
seen[id] = true
orderedVisited = append(orderedVisited, id)
}
}
m := &peteclient.RosterMap{
ZoneID: string(run.ZoneID),
CurrentNode: run.CurrentNode,
Visited: orderedVisited,
}
// Visited nodes first, in path order, with their real kind.
emitted := make(map[string]bool, len(orderedVisited))
for _, id := range orderedVisited {
emitted[id] = true
if n, ok := g.Nodes[id]; ok {
m.Nodes = append(m.Nodes, peteclient.RosterMapNode{ID: id, Kind: string(n.Kind)})
}
}
// Frontier: destinations of edges out of visited nodes, kind withheld.
// Walk visited in path order so the frontier order is stable.
for _, from := range orderedVisited {
for _, edge := range g.Edges[from] {
lock := edge.Lock
if lock == LockNone {
lock = "" // an open door needs no mark; omitempty drops it
}
m.Edges = append(m.Edges, peteclient.RosterMapEdge{
From: edge.From,
To: edge.To,
Lock: string(lock),
})
if !seen[edge.To] && !emitted[edge.To] {
emitted[edge.To] = true
m.Nodes = append(m.Nodes, peteclient.RosterMapNode{ID: edge.To, Kind: "unknown"})
}
}
}
return m
}
// resolveRosterToken maps a board token back to the adventurer it names. The
// token is a one-way HMAC (eventToken), so it can't be inverted — instead we
// recompute every live player's token and match. The salt is DB-persisted, so a
internal/plugin/pete_roster_map_test.go
+137
View File
@@ -0,0 +1,137 @@
package plugin
import (
"testing"
)
// mapFixtureGraph registers a small branching graph and returns a cleanup.
//
// n1(entry) --none--------> n2(exploration) --key_required--> n4(boss)
// \--perception_check--> n3(trap) ------------------------/
//
// n4 is reachable two ways; the validator wants a single entry and a reachable
// boss, which this satisfies.
func mapFixtureGraph(t *testing.T) ZoneID {
t.Helper()
const zid ZoneID = "map_test_zone"
g := ZoneGraph{
ZoneID: zid,
Entry: "n1",
Boss: "n4",
Nodes: map[string]ZoneNode{
"n1": {NodeID: "n1", ZoneID: zid, Kind: NodeKindEntry, IsEntry: true, Label: "The Gate"},
"n2": {NodeID: "n2", ZoneID: zid, Kind: NodeKindExploration, Label: "Dusty Hall"},
"n3": {NodeID: "n3", ZoneID: zid, Kind: NodeKindTrap, Label: "Spiked Pit"},
"n4": {NodeID: "n4", ZoneID: zid, Kind: NodeKindBoss, IsBoss: true, Label: "Throne of Bone"},
},
Edges: map[string][]ZoneEdge{
"n1": {
{From: "n1", To: "n2", Lock: LockNone, Weight: 1},
{From: "n1", To: "n3", Lock: LockPerception, Weight: 1},
},
"n2": {{From: "n2", To: "n4", Lock: LockKey, Weight: 1}},
"n3": {{From: "n3", To: "n4", Lock: LockNone, Weight: 1}},
},
}
registerZoneGraph(g)
t.Cleanup(func() { delete(zoneGraphRegistry, zid) })
return zid
}
func TestBuildRosterMap_FogOfWar(t *testing.T) {
zid := mapFixtureGraph(t)
run := &DungeonRun{
ZoneID: zid,
CurrentNode: "n2",
VisitedNodes: []string{"n1", "n2"},
TotalRooms: 4,
}
m := buildRosterMap(run)
if m == nil {
t.Fatal("buildRosterMap returned nil for a visited run")
}
if m.ZoneID != string(zid) || m.CurrentNode != "n2" {
t.Fatalf("header wrong: %+v", m)
}
kinds := map[string]string{}
for _, n := range m.Nodes {
if _, dup := kinds[n.ID]; dup {
t.Errorf("node %q emitted twice", n.ID)
}
kinds[n.ID] = n.Kind
}
// Visited nodes carry their true kind.
if kinds["n1"] != "entry" || kinds["n2"] != "exploration" {
t.Errorf("visited kinds wrong: %v", kinds)
}
// Frontier nodes are present but their kind is withheld.
if kinds["n3"] != "unknown" {
t.Errorf("n3 is one hop out of n1 and must be unknown, got %q", kinds["n3"])
}
if kinds["n4"] != "unknown" {
t.Errorf("n4 (the boss) is one hop out of n2 and must be unknown, got %q", kinds["n4"])
}
// The map must never leak a room the player has not reached a door to.
// n4 is a real boss node, but reachable only as frontier — its kind stays
// hidden. A node past a frontier door (there is none deeper here) must not
// appear at all; assert exactly four nodes.
if len(m.Nodes) != 4 {
t.Fatalf("want 4 nodes (2 visited + 2 frontier), got %d: %+v", len(m.Nodes), m.Nodes)
}
// Edges out of visited nodes only. n3->n4 must NOT appear: n3 is frontier,
// not visited, so walking its doors would leak structure past the fog.
var edgeKeys []string
for _, e := range m.Edges {
edgeKeys = append(edgeKeys, e.From+"->"+e.To+":"+e.Lock)
}
want := map[string]bool{
"n1->n2:": true, // LockNone dropped to ""
"n1->n3:perception_check": true,
"n2->n4:key_required": true,
}
if len(edgeKeys) != len(want) {
t.Fatalf("want %d edges, got %v", len(want), edgeKeys)
}
for _, k := range edgeKeys {
if !want[k] {
t.Errorf("unexpected edge %q (n3->n4 would be a fog leak)", k)
}
}
}
func TestBuildRosterMap_EmptyRunIsNil(t *testing.T) {
zid := mapFixtureGraph(t)
// A run that has visited nothing yet has no map to show.
if m := buildRosterMap(&DungeonRun{ZoneID: zid}); m != nil {
t.Errorf("empty VisitedNodes should yield nil, got %+v", m)
}
// An unknown zone (no graph, no legacy fallback row) yields nil, not a panic.
if m := buildRosterMap(&DungeonRun{ZoneID: "no_such_zone", VisitedNodes: []string{"x"}}); m != nil {
t.Errorf("unknown zone should yield nil, got %+v", m)
}
}
func TestBuildRosterMap_BacktrackDedup(t *testing.T) {
zid := mapFixtureGraph(t)
// VisitedNodes is an ordered set that repeats on backtrack: n1,n2,n1.
run := &DungeonRun{
ZoneID: zid,
CurrentNode: "n1",
VisitedNodes: []string{"n1", "n2", "n1"},
}
m := buildRosterMap(run)
seen := map[string]int{}
for _, n := range m.Nodes {
seen[n.ID]++
}
if seen["n1"] != 1 {
t.Errorf("backtracked node n1 emitted %d times, want 1", seen["n1"])
}
if len(m.Visited) != 2 {
t.Errorf("Visited should dedup to [n1 n2], got %v", m.Visited)
}
}
internal/plugin/pete_roster_party_test.go
+264
View File
@@ -0,0 +1,264 @@
package plugin
import (
"encoding/json"
"strings"
"testing"
"time"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
// TestSeatedMemberIsNotIdleInTown is the gap W7 closes. The board resolved an
// expedition with getActiveExpedition, which keys on dnd_expedition.user_id — so
// a party member, who owns no row of their own, read as "idle in town" while
// standing in a dungeon. The regression is silent: the page renders fine, it just
// says the wrong thing about where somebody is.
func TestSeatedMemberIsNotIdleInTown(t *testing.T) {
newBoredomTestDB(t)
now := time.Now().UTC()
old := now.Add(-30 * time.Hour)
leader := id.UserID("@leader:test")
member := id.UserID("@member:test")
seedRosterPlayer(t, leader, "Josie", &old, &old)
seedRosterPlayer(t, member, "Camcast", &old, &old)
seedExpedition(t, "exp-shared", leader, "active")
seatLeaderFixture(t, "exp-shared")
if err := joinParty("exp-shared", member); err != nil {
t.Fatalf("joinParty: %v", err)
}
snap, err := buildRosterSnapshot(now, nil)
if err != nil {
t.Fatalf("buildRosterSnapshot: %v", err)
}
byName := map[string]int{}
for i, a := range snap.Adventurers {
byName[a.Name] = i
}
for _, name := range []string{"Josie", "Camcast"} {
i, ok := byName[name]
if !ok {
t.Fatalf("%s is not on the board", name)
}
if got := snap.Adventurers[i].Status; got != "expedition" {
t.Errorf("%s status = %q, want expedition", name, got)
}
if snap.Adventurers[i].Zone == "" {
t.Errorf("%s is on an expedition with no zone named", name)
}
}
}
// TestPartySeatsNameTheWholeRoster covers the shape of the seat list: leader
// first, every human named with a linkable token, and the hireling named without
// one (he has no board row to link to).
func TestPartySeatsNameTheWholeRoster(t *testing.T) {
newBoredomTestDB(t)
now := time.Now().UTC()
old := now.Add(-30 * time.Hour)
leader := id.UserID("@leader:test")
member := id.UserID("@member:test")
seedRosterPlayer(t, leader, "Josie", &old, &old)
seedRosterPlayer(t, member, "Camcast", &old, &old)
seedExpedition(t, "exp-shared", leader, "active")
seatLeaderFixture(t, "exp-shared")
if err := joinParty("exp-shared", member); err != nil {
t.Fatalf("joinParty: %v", err)
}
if err := joinParty("exp-shared", companionUserID()); err != nil {
t.Fatalf("hire companion: %v", err)
}
seats := seatsForOwner(t, now, "Josie")
if len(seats) != 3 {
t.Fatalf("party has %d seats, want 3: %+v", len(seats), seats)
}
if seats[0].Kind != "leader" || seats[0].Name != "Josie" {
t.Errorf("first seat = %+v, want the leader Josie", seats[0])
}
if seats[0].Token == "" || seats[0].Level == 0 {
t.Errorf("leader seat is unlinkable or levelless: %+v", seats[0])
}
var companion, human int
for _, s := range seats {
switch s.Kind {
case "companion":
companion++
if s.Name != companionDisplayName {
t.Errorf("companion seat named %q, want %q", s.Name, companionDisplayName)
}
if s.Token != "" {
t.Errorf("companion seat carries a board token %q; he has no board row", s.Token)
}
case "leader", "member":
human++
if s.Name == "" || s.Token == "" {
t.Errorf("human seat %+v is missing its name/token pair", s)
}
default:
t.Errorf("unknown seat kind %q", s.Kind)
}
}
if companion != 1 || human != 2 {
t.Errorf("seats = %d human + %d companion, want 2 + 1", human, companion)
}
}
// TestSoloRunPublishesNoParty: expeditionParty always hands back at least the
// leader, so a naive render would draw every solo player a party of one.
func TestSoloRunPublishesNoParty(t *testing.T) {
newBoredomTestDB(t)
now := time.Now().UTC()
old := now.Add(-30 * time.Hour)
solo := id.UserID("@solo:test")
seedRosterPlayer(t, solo, "Josie", &old, &old)
seedExpedition(t, "exp-solo", solo, "active")
if seats := seatsForOwner(t, now, "Josie"); seats != nil {
t.Errorf("solo run published a party of %d: %+v", len(seats), seats)
}
// And with only the leader seated, which is what the roster table looks like
// between materialising and the first invite landing.
seatLeaderFixture(t, "exp-solo")
if seats := seatsForOwner(t, now, "Josie"); seats != nil {
t.Errorf("leader-only roster published a party of %d: %+v", len(seats), seats)
}
}
// TestOptedOutSeatIsAnonymisedNotDropped is the privacy contract for this
// surface, and it is deliberately NOT the board's rule. The board omits an
// opted-out player outright; a party seat is anonymised, because a party of three
// that renders as a pair is a false statement about the run everyone can see the
// supply burn and threat level of.
func TestOptedOutSeatIsAnonymisedNotDropped(t *testing.T) {
newBoredomTestDB(t)
now := time.Now().UTC()
old := now.Add(-30 * time.Hour)
leader := id.UserID("@leader:test")
hidden := id.UserID("@hidden:test")
seedRosterPlayer(t, leader, "Josie", &old, &old)
seedRosterPlayer(t, hidden, "Quack", &old, &old)
setNewsOptout(hidden, true)
seedExpedition(t, "exp-shared", leader, "active")
seatLeaderFixture(t, "exp-shared")
if err := joinParty("exp-shared", hidden); err != nil {
t.Fatalf("joinParty: %v", err)
}
seats := seatsForOwner(t, now, "Josie")
if len(seats) != 2 {
t.Fatalf("party has %d seats, want 2 — an opted-out seat was dropped, not anonymised: %+v",
len(seats), seats)
}
for _, s := range seats {
if s.Name == "Quack" {
t.Error("an opted-out player is named on a party roster")
}
}
var blank int
for _, s := range seats {
if s.Name == "" {
blank++
if s.Token != "" || s.Level != 0 {
t.Errorf("anonymised seat still carries a token or level: %+v", s)
}
}
}
if blank != 1 {
t.Errorf("%d anonymous seats, want exactly 1", blank)
}
}
// TestPartyKnownIsSetOnEverySheet pins the capability flag Pete's abandon button
// hangs off. Party is omitempty, so a solo run and a game box too old to know what
// a seat is both reach Pete as an empty slice; the flag is what tells them apart.
// It is a fact about this build, so it must be true on a sheet with no party on it
// at all — a conditional party_known reads as "this player is solo" and puts the
// flag back in the hole it was added to close.
func TestPartyKnownIsSetOnEverySheet(t *testing.T) {
newBoredomTestDB(t)
now := time.Now().UTC()
old := now.Add(-30 * time.Hour)
intown := id.UserID("@intown:test")
solo := id.UserID("@solo:test")
leader := id.UserID("@leader:test")
member := id.UserID("@member:test")
seedRosterPlayer(t, intown, "Nonk", &old, &old)
seedRosterPlayer(t, solo, "Quack", &old, &old)
seedRosterPlayer(t, leader, "Josie", &old, &old)
seedRosterPlayer(t, member, "Camcast", &old, &old)
seedExpedition(t, "exp-solo", solo, "active")
seedExpedition(t, "exp-shared", leader, "active")
seatLeaderFixture(t, "exp-shared")
if err := joinParty("exp-shared", member); err != nil {
t.Fatalf("joinParty: %v", err)
}
snap, err := buildRosterSnapshot(now, nil)
if err != nil {
t.Fatalf("buildRosterSnapshot: %v", err)
}
var seen int
for _, a := range snap.Adventurers {
if a.Detail == nil {
t.Fatalf("%s has no detail sheet to carry the flag", a.Name)
}
seen++
if !a.Detail.PartyKnown {
t.Errorf("%s (%s, %d seats) published party_known=false; this build knows what a seat is",
a.Name, a.Status, len(a.Detail.Party))
}
}
if seen != 4 {
t.Fatalf("checked %d sheets, want 4 — a case went missing", seen)
}
// The wire name is the contract: Pete decodes party_known and withholds the
// abandon button when it is absent, so a rename here fails silently and only
// on the far side.
blob, err := json.Marshal(&peteclient.RosterDetail{PartyKnown: true})
if err != nil {
t.Fatalf("marshal: %v", err)
}
if !strings.Contains(string(blob), `"party_known":true`) {
t.Errorf("detail sheet serialised without party_known: %s", blob)
}
// And it must not be omitempty: an absent key is Pete's fail-closed answer,
// which a false flag has to keep meaning.
if blob, err = json.Marshal(&peteclient.RosterDetail{}); err != nil {
t.Fatalf("marshal: %v", err)
} else if !strings.Contains(string(blob), `"party_known":false`) {
t.Errorf("party_known is omitempty; false must stay on the wire: %s", blob)
}
}
// seatsForOwner pulls one named adventurer's published party out of a whole
// snapshot, which is the only way to reach it — Party rides RosterDetail, so this
// also proves the wiring in buildRosterSnapshot and not just partySeatViews.
func seatsForOwner(t *testing.T, now time.Time, name string) []peteclient.PartySeatView {
t.Helper()
snap, err := buildRosterSnapshot(now, nil)
if err != nil {
t.Fatalf("buildRosterSnapshot: %v", err)
}
for _, a := range snap.Adventurers {
if a.Name == name && a.Detail != nil {
return a.Detail.Party
}
}
t.Fatalf("%s is not on the board with a detail sheet", name)
return nil
}
internal/plugin/pete_roster_test.go
+99
View File
@@ -1,6 +1,7 @@
package plugin
import (
"sort"
"testing"
"time"
@@ -125,3 +126,101 @@ func TestRosterTokenIsNotAnEventToken(t *testing.T) {
t.Error("board token not stable — the row would churn identity every snapshot")
}
}
// pickMagicItem returns a registry item matching want, so these tests read the
// real registry rather than pinning an item ID that a later SRD dump could drop.
func pickMagicItem(t *testing.T, want func(MagicItem) bool) MagicItem {
t.Helper()
var ids []string
for id := range magicItemRegistry {
ids = append(ids, id)
}
sort.Strings(ids) // map order is random; a flaky pick is a flaky test
for _, id := range ids {
if mi := magicItemRegistry[id]; want(mi) {
return mi
}
}
t.Skip("no registry item matches this shape")
return MagicItem{}
}
// TestItemViewsKeepsTheRegistryPointerHome is the leak guard. SkillSource is two
// different things depending on the row: a player-facing skill name on
// masterwork gear ("mining"), and the internal "magic_item:<id>" pointer that
// resolves an inventory row back to the registry. Only the first is a fact about
// the item. Sending the second would put gogobee's internal IDs on a page, and
// Pete would have no way to tell them apart to filter them out.
func TestItemViewsKeepsTheRegistryPointerHome(t *testing.T) {
newBoredomTestDB(t)
mi := pickMagicItem(t, func(m MagicItem) bool { return m.Desc != "" && m.Slot != "" })
views := itemViews([]AdvItem{
{Name: mi.Name, Type: "magic_item", Tier: 3, Value: 100,
SkillSource: "magic_item:" + mi.ID},
{Name: "Miner's Pick", Type: "MasterworkGear", Tier: 3, Value: 300,
Slot: SlotWeapon, SkillSource: "mining"},
})
if views[0].SkillSource != "" {
t.Errorf("the magic_item registry pointer went out on the wire: %q", views[0].SkillSource)
}
if views[0].Desc != mi.Desc {
t.Errorf("desc = %q, want the registry's %q", views[0].Desc, mi.Desc)
}
if views[0].Effect == "" {
t.Error("a magic item should carry the engine's own effect summary")
}
if views[1].SkillSource != "mining" {
t.Errorf("masterwork skill source = %q, want it kept", views[1].SkillSource)
}
}
// TestItemViewsNeverClaimABackpackBond: equipping *moves* the row out of
// adventure_inventory into magic_item_equipped, so nothing in a backpack can
// hold a bond. Attuned must stay false here whatever the item wants, or the
// panel tells a player an unworn item is working for them.
func TestItemViewsNeverClaimABackpackBond(t *testing.T) {
newBoredomTestDB(t)
mi := pickMagicItem(t, func(m MagicItem) bool { return m.Attunement && m.Slot != "" })
v := itemViews([]AdvItem{{Name: mi.Name, Type: "magic_item", Tier: 3,
SkillSource: "magic_item:" + mi.ID}})[0]
if !v.Attunement {
t.Error("an attunement item should say it wants a bond")
}
if v.Attuned {
t.Error("a backpack item claimed a bond it cannot hold")
}
}
// TestEquippedViewsCarryBondState: the worn set is the only place Attuned means
// anything, and the only way the page can show that a worn item is sitting inert
// against the cap of three.
func TestEquippedViewsCarryBondState(t *testing.T) {
newBoredomTestDB(t)
uid := id.UserID("@josie:example.org")
mi := pickMagicItem(t, func(m MagicItem) bool { return m.Attunement && m.Slot != "" })
if err := equipMagicItem(uid, mi.Slot, mi.ID, false, 0); err != nil {
t.Fatalf("equip: %v", err)
}
views := equippedViews(uid)
if len(views) != 1 {
t.Fatalf("equipped views = %d, want 1", len(views))
}
if views[0].Attuned {
t.Error("an inert worn item was reported as bonded")
}
if views[0].Slot != string(mi.Slot) {
t.Errorf("slot = %q, want %q", views[0].Slot, mi.Slot)
}
if err := equipMagicItem(uid, mi.Slot, mi.ID, true, 0); err != nil {
t.Fatalf("re-equip bonded: %v", err)
}
if !equippedViews(uid)[0].Attuned {
t.Error("a bonded worn item was reported as inert")
}
}
internal/plugin/pete_run_summary.go
+390
View File
@@ -0,0 +1,390 @@
package plugin
import (
"encoding/json"
"fmt"
"log/slog"
"sort"
"strings"
"sync/atomic"
"time"
"gogobee/internal/db"
"gogobee/internal/peteclient"
)
// The run summary — three sentences over forty beats.
//
// Every other line in the liveblog is assembled by Pete out of a beat's own
// nouns and numbers, and that is the right split: a log has to be exactly what
// happened, in order, and prose in the middle of it would be the more convincing
// of the two accounts and the less true. But a *report* is read afterwards, by
// somebody who wasn't watching, and the question it answers is not "what
// happened" — the log already answers that — it is "what was that run". That is
// a judgement, and no template makes judgements.
//
// So this is the one piece of prose on the channel, and it earns the model far
// better than a dispatch headline does. authorDispatch turns four fields into a
// sentence a template could nearly have written; this reads a whole expedition
// and picks out what mattered.
//
// Three rules, and the first one is why this file exists at all:
//
// - **Off the hot path.** It runs on the roster ticker, not at the moment the
// run ends. A run ending is already a player-facing beat with a dispatch
// being authored against it; adding a second bounded-but-real LLM call to
// that chokepoint would stall the command that killed the boss.
// - **One per tick.** A backlog after an outage drains over minutes rather
// than spooling a hundred generations at once.
// - **Best effort, exactly once.** A run that can't be summarised is filed
// with an empty summary beat rather than retried forever — the row is what
// stops the sweep picking it up again next tick, and a report with no
// summary is still the log and the numbers, which is most of it.
// runSummaryMaxBeats bounds what goes into the prompt. Far more than a normal
// run produces; the cap is for the multi-day expedition that beat out hundreds,
// where the last chunk is the part with the ending in it.
const runSummaryMaxBeats = 120
// maxRunSummary mirrors Pete's cap so we never ship prose Pete will reject on
// length alone. Byte count, matching Pete's len() check.
const maxRunSummary = 1200
// runSummaryTimeout has to cover a COLD model, not just a generation.
//
// dispatchLLMTimeout is tight because authoring runs on a game chokepoint and a
// template dispatch now beats a voiced one late. Nothing here is waiting on this:
// it is a background sweep, the run ended minutes ago, and the page it feeds is
// already serving without it. The cost of being impatient is the opposite of
// there — a timeout files an empty summary beat, and that run never gets another
// chance at one.
//
// And impatience is the live risk, because this call is almost always the one
// that pays the load. Ollama evicts an idle model after about five minutes, and
// runs end far further apart than that, so the steady state is: model on disk,
// nothing resident, weights to page in before the first token. A budget sized
// for generation alone would expire during the load on every single run and file
// an empty beat that says the box is down when the box is fine. So this is sized
// for load-then-generate, and a timeout here really does mean the box is down.
const runSummaryTimeout = 5 * time.Minute
// runSummaryBusy is the whole concurrency story: at most one sweep in flight,
// ever. The ticker starts one and moves on, so a cold model loading for minutes
// costs the board nothing, and the ticks that fire meanwhile find the flag set
// and skip rather than queue.
var runSummaryBusy atomic.Bool
// sweepRunSummariesAsync starts a sweep off the caller's goroutine if one isn't
// already running.
//
// It has to be off the ticker: runSummaryTimeout is minutes and the tick is two,
// so a synchronous call would hold the roster, details, siege and beat pushes
// behind a model load and put the live board permanently a tick or more behind
// the game. Ordering against those pushes is not lost by going async — the beat
// this files is written to the local buffer with the next seq, and the pusher
// ships it by seq on whichever tick comes after, still behind the run's own log.
func (p *AdventurePlugin) sweepRunSummariesAsync() {
if !runSummaryBusy.CompareAndSwap(false, true) {
return // one still working; the next tick will find it done or still busy
}
go func() {
defer runSummaryBusy.Store(false)
p.sweepRunSummaries()
}()
}
// sweepRunSummaries authors the summary for at most one finished run per call.
// Called from the roster ticker, after the beats themselves have been pushed —
// the summary is the last beat of a run's story and there is no rush to have it
// overtake the log it is about.
func (p *AdventurePlugin) sweepRunSummaries() {
if !peteclient.Enabled() || !newsEmissionOn() {
return
}
if !llmConfigured() {
return // no model, no summary, no wasted queries asking which run needs one
}
runID := nextRunNeedingSummary()
if runID == "" {
return
}
// File the beat whatever happens below. An empty one carries no prose and Pete
// stores nothing from it — its entire job is to be the row that stops this run
// coming back round every two minutes for the rest of the week.
summary, name := authorRunSummary(runID)
if summary == "" {
slog.Debug("run summary: nothing authored, filing an empty beat to close it out", "run", runID)
}
recordRunBeat(runID, peteclient.RunBeat{
Kind: "summary",
Name: name,
Prose: summary,
})
}
// nextRunNeedingSummary picks the most recently finished run that has an `end`
// beat and no `summary` beat yet.
//
// Newest first, deliberately. If the sweep is behind — an outage, a busy
// evening — the run somebody is most likely to be looking at right now is the
// one that just ended, not the one from four hours ago. The old ones still get
// their turn on later ticks; they just don't get to hold up the fresh one.
func nextRunNeedingSummary() string {
var runID string
err := db.Get().QueryRow(`
SELECT e.run_id
FROM pete_run_beat e
WHERE e.kind = 'end'
AND NOT EXISTS (
SELECT 1 FROM pete_run_beat s
WHERE s.run_id = e.run_id AND s.kind = 'summary')
ORDER BY e.occurred_at DESC
LIMIT 1`).Scan(&runID)
if err != nil {
return "" // ErrNoRows is the common case: nothing to summarise
}
if !runBeatAllowed(runID) {
// An opted-out player's beats never leave the box, so there is nothing for
// a summary to be attached to. File the closing beat anyway (it will be
// retired locally with the rest) so this run stops being picked.
recordRunBeat(runID, peteclient.RunBeat{Kind: "summary"})
return ""
}
return runID
}
// authorRunSummary reads a run's beats back and returns Pete's summary of it,
// plus the adventurer's name for the guard allow-list. Returns empty strings on
// any failure — the model being off, a timeout, an unparseable completion, an
// over-long generation — because every one of those is a report without a
// summary rather than a problem.
func authorRunSummary(runID string) (summary, name string) {
beats, err := loadRunBeatsForSummary(runID)
if err != nil || len(beats) == 0 {
return "", ""
}
name = runSummarySubject(beats)
if name == "" {
// No name means no allow-list on Pete's side, which means the guard rejects
// anything naming anyone. Don't spend a generation to have it thrown away.
return "", ""
}
raw, err := callLLMDispatch(runSummaryTimeout, buildRunSummaryPrompt(name, beats))
if err != nil {
slog.Warn("run summary: LLM authoring failed", "run", runID, "err", err)
return "", name
}
summary = parseRunSummary(raw)
if summary == "" || len(summary) > maxRunSummary {
slog.Warn("run summary: unusable output", "run", runID, "len", len(summary))
return "", name
}
return summary, name
}
// loadRunBeatsForSummary reads a run's own beats back out of the outbound
// buffer. It reads the TAIL and re-sorts, so a run long enough to hit the cap
// contributes the part with its ending in it rather than its first morning.
func loadRunBeatsForSummary(runID string) ([]peteclient.RunBeat, error) {
rows, err := db.Get().Query(`
SELECT seq, payload FROM pete_run_beat
WHERE run_id = ? ORDER BY seq DESC LIMIT ?`, runID, runSummaryMaxBeats)
if err != nil {
return nil, err
}
defer rows.Close()
var out []peteclient.RunBeat
for rows.Next() {
var seq int64
var payload string
if err := rows.Scan(&seq, &payload); err != nil {
return nil, err
}
var b peteclient.RunBeat
if err := json.Unmarshal([]byte(payload), &b); err != nil {
continue // a row the pusher will retire on its own; not this sweep's problem
}
b.RunID, b.Seq = runID, seq
out = append(out, b)
}
if err := rows.Err(); err != nil {
return nil, err
}
sort.Slice(out, func(i, j int) bool { return out[i].Seq < out[j].Seq })
return out, nil
}
// runSummarySubject finds the one name a summary is allowed to use. Only the
// `start` beat carries identity, by design — so a run whose start beat was
// dropped has no subject here, and gets no summary rather than an anonymous one.
func runSummarySubject(beats []peteclient.RunBeat) string {
for _, b := range beats {
if b.Name != "" {
return b.Name
}
}
return ""
}
// buildRunSummaryPrompt renders the run as a plain numbered log and asks for
// three sentences over it.
//
// The beats go in as facts, not as Pete's rendered lines: Pete's phrasing is
// Pete's, and feeding a model its own output back would have it summarising a
// summary. The rules are the dispatch prompt's, tightened in the one place that
// matters here — a run log is full of monster names and a model asked to write
// about a party is very willing to invent a second member of it.
func buildRunSummaryPrompt(name string, beats []peteclient.RunBeat) string {
var log strings.Builder
zone, outcome := "", ""
n := 0
for _, b := range beats {
if b.Zone != "" && zone == "" {
zone = b.Zone
}
line := describeBeatForPrompt(b)
if line == "" {
continue
}
if b.Kind == "end" {
outcome = b.Outcome
}
n++
fmt.Fprintf(&log, "%d. %s\n", n, line)
}
if zone == "" {
zone = "a dungeon"
}
ending := "the run ended"
switch outcome {
case "cleared":
ending = "they cleared it"
case "died":
ending = "they died down there"
case "retreated":
ending = "they walked out alive but beaten"
}
return fmt.Sprintf(`You are Pete, a warm, friendly local news reporter for a fantasy adventuring town. Think a beloved local newscaster who genuinely knows everyone and is glad to see them. Conversational, never snarky, never a caps-lock hype-man. Warmth carries the register, not exclamation marks.
Below is the log of one expedition, room by room, exactly as it was recorded. Write a SHORT summary of how the run went: what it cost them, the moment it turned, and how it ended.
STRICT RULES — do not violate these:
- The ONLY adventurer name you may use is: %s. Never invent another adventurer, companion, party member or friend. If the log does not say someone was there, they were not there.
- Monster, zone and item names in the log are game names — use them as given.
- Use ONLY what the log says. Do not invent numbers, fights, items or outcomes.
- Do NOT add numbers together and do NOT state any total. The exact totals are printed next to your summary and a total you worked out yourself will contradict them. Quote a number only if that exact number appears on one line of the log.
- Three sentences at most. No markdown, no emoji, no headline, no bullet points.
- Past tense, third person. Do not address the reader as "you".
Respond with ONLY a JSON object, no other text:
{"summary": "at most three sentences about how the run went"}
The expedition: %s went into %s, and %s.
The log:
%s`, name, name, zone, ending, log.String())
}
// describeBeatForPrompt renders one beat as a flat fact line for the prompt.
// Returns "" for a beat with nothing in it worth a sentence — a room with no
// identity, an empty haul — so the model isn't handed forty lines of "walked
// into the next room" to find three sentences in.
func describeBeatForPrompt(b peteclient.RunBeat) string {
switch b.Kind {
case "start":
if b.TotalRooms > 0 {
return fmt.Sprintf("set out into %s, %d rooms deep", orSomething(b.Zone), b.TotalRooms)
}
return "set out into " + orSomething(b.Zone)
case "combat":
what := orSomething(b.Target)
switch b.RoomKind {
case "boss":
what = "the boss, " + what
case "elite":
what = "an elite, " + what
}
switch b.Outcome {
case "won":
s := fmt.Sprintf("killed %s, taking %d damage", what, b.Amount)
if b.HPMax > 0 {
s += fmt.Sprintf(" (left on %d of %d health)", b.HP, b.HPMax)
}
if b.Crits > 0 {
s += fmt.Sprintf(", %d critical hit(s)", b.Crits)
}
return s
case "retreat":
return "could not finish " + what + " in time and withdrew"
default:
return "was beaten by " + what
}
case "trap":
if b.Amount <= 0 {
return "spotted a trap and stepped over it"
}
s := fmt.Sprintf("sprung a trap for %d damage", b.Amount)
if b.HPMax > 0 {
s += fmt.Sprintf(" (left on %d of %d health)", b.HP, b.HPMax)
}
return s
case "treasure":
return "found " + orSomething(b.Target)
case "lock":
if b.Outcome == "picked" {
return "picked a locked door"
}
return "found every way on sealed and doubled back"
case "region":
return "crossed out of " + orSomething(b.Region) + " into " + orSomething(b.Target)
case "haul":
if b.Amount <= 0 {
return ""
}
return fmt.Sprintf("gathered %d supplies along the way", b.Amount)
case "end":
switch b.Outcome {
case "cleared":
return "finished the run and got out"
case "died":
return "did not come home"
case "retreated":
return "withdrew, wounded but alive"
}
return "the run ended"
}
return ""
}
func orSomething(s string) string {
if s == "" {
return "something"
}
return s
}
// parseRunSummary pulls {"summary": ...} out of the completion, tolerating the
// same noise parseDispatch does: reasoning blocks, fences, prose around the JSON.
func parseRunSummary(raw string) string {
s := raw
if i := strings.Index(s, "<think>"); i != -1 {
if j := strings.Index(s, "</think>"); j != -1 {
s = s[:i] + s[j+len("</think>"):]
}
}
start := strings.Index(s, "{")
end := strings.LastIndex(s, "}")
if start < 0 || end <= start {
return ""
}
var out struct {
Summary string `json:"summary"`
}
if err := json.Unmarshal([]byte(s[start:end+1]), &out); err != nil {
return ""
}
return strings.TrimSpace(out.Summary)
}
internal/plugin/pete_run_summary_test.go
+199
View File
@@ -0,0 +1,199 @@
package plugin
import (
"strings"
"testing"
"gogobee/internal/db"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
// finishRun writes a small realistic run's beats and closes it.
func finishRun(runID, name string) {
recordRunBeat(runID, peteclient.RunBeat{Kind: "start", Token: "tok", Name: name,
Level: 14, Zone: "Crypt of Valdris", TotalRooms: 9, Room: 1})
recordRunBeat(runID, peteclient.RunBeat{Kind: "combat", Room: 2, Target: "Bone Chanter",
Outcome: "won", Amount: 7, HP: 61, HPMax: 68})
recordRunBeat(runID, peteclient.RunBeat{Kind: "trap", Room: 3, Outcome: "sprung",
Amount: 22, HP: 39, HPMax: 68})
recordRunBeat(runID, peteclient.RunBeat{Kind: "end", Room: 3, Outcome: "died"})
}
// TestSummarySweepPicksAFinishedRunOnce. The sweep runs every two minutes
// forever, so the property that matters is not that it finds a run — it is that
// it lets one go. A run that stayed pickable would author a fresh summary every
// tick for the rest of the week.
func TestSummarySweepPicksAFinishedRunOnce(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
seedBeatRun(t, "run-done", id.UserID("@josie:example.com"))
finishRun("run-done", "Josie")
if got := nextRunNeedingSummary(); got != "run-done" {
t.Fatalf("sweep didn't find the finished run: %q", got)
}
// Filing the closing beat is what retires it, whether or not any prose was
// authored into it.
recordRunBeat("run-done", peteclient.RunBeat{Kind: "summary"})
if got := nextRunNeedingSummary(); got != "" {
t.Errorf("run came back round after its summary beat was filed: %q", got)
}
}
// TestSummarySweepIgnoresARunStillWalking. A summary is a reading of a finished
// run. Writing one over a run in progress would be an ending invented before
// there was one.
func TestSummarySweepIgnoresARunStillWalking(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
seedBeatRun(t, "run-live", id.UserID("@josie:example.com"))
recordRunBeat("run-live", peteclient.RunBeat{Kind: "start", Name: "Josie", Zone: "Crypt"})
recordRunBeat("run-live", peteclient.RunBeat{Kind: "combat", Target: "Rat", Outcome: "won"})
if got := nextRunNeedingSummary(); got != "" {
t.Errorf("picked a run that hasn't ended: %q", got)
}
}
// TestSummarySweepRetiresAnOptedOutRun. Their beats never leave the box, so
// there is nothing on Pete for a summary to attach to — but the run must still
// stop being picked, or the sweep spends a generation on it every tick and
// throws the result away.
func TestSummarySweepRetiresAnOptedOutRun(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
uid := id.UserID("@quiet:example.com")
seedBeatRun(t, "run-quiet", uid)
finishRun("run-quiet", "Quack")
setNewsOptout(uid, true)
if got := nextRunNeedingSummary(); got != "" {
t.Errorf("offered an opted-out player's run for summarising: %q", got)
}
kinds := beatKinds(t, "run-quiet")
if kinds[len(kinds)-1] != "summary" {
t.Errorf("opted-out run wasn't closed out; kinds = %v", kinds)
}
// And it stays closed out.
if got := nextRunNeedingSummary(); got != "" {
t.Errorf("opted-out run came back round: %q", got)
}
}
// TestSummaryPromptCarriesTheRunAndOnlyOneName.
//
// The prompt is the whole safety story on this side (Pete's guard is the other
// half, and it only ever sees the answer). A run log is full of monster names,
// and a model asked to write warmly about "the party" will happily invent a
// second member of it — which on a public page is words put in a real person's
// mouth. So the one name is stated twice and the facts are handed over as facts.
func TestSummaryPromptCarriesTheRunAndOnlyOneName(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
seedBeatRun(t, "run-p", id.UserID("@josie:example.com"))
finishRun("run-p", "Josie")
beats, err := loadRunBeatsForSummary("run-p")
if err != nil {
t.Fatal(err)
}
if len(beats) != 4 {
t.Fatalf("want 4 beats, got %d", len(beats))
}
if beats[0].Seq >= beats[len(beats)-1].Seq {
t.Error("beats came back out of order; the log would read backwards")
}
if got := runSummarySubject(beats); got != "Josie" {
t.Fatalf("subject = %q, want Josie", got)
}
p := buildRunSummaryPrompt("Josie", beats)
for _, want := range []string{
"The ONLY adventurer name you may use is: Josie",
"Josie went into Crypt of Valdris, and they died down there",
"killed Bone Chanter, taking 7 damage",
"sprung a trap for 22 damage",
"did not come home",
"Three sentences at most",
} {
if !strings.Contains(p, want) {
t.Errorf("prompt is missing %q", want)
}
}
}
// TestUnattributedRunGetsNoSummary. Only the `start` beat carries identity. A
// run that lost it has no name to hand the guard, so Pete would reject any
// summary naming anybody — spending a generation to have it thrown away, and
// risking an anonymous paragraph about a player nobody can consent for.
func TestUnattributedRunGetsNoSummary(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
seedBeatRun(t, "run-anon", id.UserID("@josie:example.com"))
recordRunBeat("run-anon", peteclient.RunBeat{Kind: "combat", Target: "Rat", Outcome: "won"})
recordRunBeat("run-anon", peteclient.RunBeat{Kind: "end", Outcome: "cleared"})
summary, name := authorRunSummary("run-anon")
if summary != "" || name != "" {
t.Errorf("authored over a run with no owner: name=%q summary=%q", name, summary)
}
}
// TestParseRunSummaryTolerance mirrors parseDispatch's: the model wraps its
// answer in reasoning blocks, fences and apologies, and none of that is a reason
// to lose a summary that is sitting right there.
func TestParseRunSummaryTolerance(t *testing.T) {
cases := []struct{ name, raw, want string }{
{"plain", `{"summary": "It went badly."}`, "It went badly."},
{"think block", "<think>hmm</think>\n{\"summary\": \"It went badly.\"}", "It went badly."},
{"fenced with chatter", "Sure!\n```json\n{\"summary\": \"It went badly.\"}\n```\n", "It went badly."},
{"no json", "It went badly.", ""},
{"empty summary", `{"summary": " "}`, ""},
}
for _, c := range cases {
if got := parseRunSummary(c.raw); got != c.want {
t.Errorf("%s: parseRunSummary = %q, want %q", c.name, got, c.want)
}
}
}
// TestDispatchRunLinkNeedsARecentRunWithBeats.
//
// latestRunIDForNews answers "which run is this dispatch about", and it is asked
// from call sites that have already let go of the run. Both of its guards are
// load-bearing: a run with no beats behind it would mint a dispatch link to a
// 404, and a stale run would attach a campaign death at the Empty Throne to
// whatever dungeon that player last walked.
func TestDispatchRunLinkNeedsARecentRunWithBeats(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
uid := id.UserID("@josie:example.com")
// A run with no beats: pre-liveblog, or the seam was off while it walked.
seedBeatRun(t, "run-silent", uid)
if got := latestRunIDForNews(uid); got != "" {
t.Errorf("linked a dispatch to a run Pete has never heard of: %q", got)
}
// The real one, closed seconds ago.
seedBeatRun(t, "run-real", uid)
finishRun("run-real", "Josie")
if _, err := db.Get().Exec(
`UPDATE dnd_zone_run SET completed_at = CURRENT_TIMESTAMP WHERE run_id = 'run-real'`); err != nil {
t.Fatal(err)
}
if got := latestRunIDForNews(uid); got != "run-real" {
t.Errorf("run link = %q, want run-real", got)
}
// A day later, they die somewhere that isn't a dungeon at all.
if _, err := db.Get().Exec(
`UPDATE dnd_zone_run SET completed_at = datetime('now', '-1 day') WHERE run_id = 'run-real'`); err != nil {
t.Fatal(err)
}
if got := latestRunIDForNews(uid); got != "" {
t.Errorf("attached an unrelated death to yesterday's expedition: %q", got)
}
}
internal/plugin/pete_runbeat.go
+281
View File
@@ -0,0 +1,281 @@
package plugin
import (
"context"
"encoding/json"
"log/slog"
"time"
"gogobee/internal/db"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
// Run beats — the room-by-room texture of an expedition, on its way to Pete.
//
// Until now Pete learned that an expedition happened only when it ended: a
// zone_clear, a retreat, a death. The run itself — the fight that nearly went
// wrong, the trap, the haul — was narrated to one Matrix DM and then discarded.
// This records the shape of each moment as it happens so Pete can retell it.
//
// Three rules hold the design together:
//
// - **Facts, not prose.** A beat carries nouns and numbers; the engine's
// narration stays in Matrix. Pete owns the words, the same split every Fact
// already respects.
// - **Its own channel.** Beats never touch pete_emit_queue. They are
// high-volume and low-stakes, and a chatty run must not be able to spend the
// retry budget a death dispatch depends on.
// - **Never block, never fail the game.** recordRunBeat swallows its errors to
// a log line. A liveblog is a nice-to-have; the walk it is watching is not.
//
// Delivery rides the roster ticker (one extra request per 2 minutes, not one per
// room) but unlike the roster it is retried, because a dropped beat is a hole in
// a story rather than a stale number the next snapshot corrects.
// runBeatBatch bounds one push. A busy realm mid-evening might produce a few
// hundred beats between ticks; this keeps any single request small and lets the
// backlog drain over a few ticks instead of one enormous POST.
const runBeatBatch = 200
// recordRunBeat appends a beat to the outbound buffer. Never returns an error:
// every caller is on the walk's hot path and none of them can do anything useful
// with a failure to log a story.
//
// Seq is assigned by the INSERT itself (MAX+1 within the statement), so two
// concurrent writers on the same run can't collide on a number — SQLite
// serialises the statement, and the primary key would reject the loser anyway.
func recordRunBeat(runID string, b peteclient.RunBeat) {
if runID == "" || !peteclient.Enabled() || !newsEmissionOn() {
return
}
b.RunID = runID
if b.OccurredAt == 0 {
b.OccurredAt = nowUnix()
}
// Seq and RunID live in columns; the rest of the beat is the payload, so
// adding a field later needs no migration.
kind, occurred := b.Kind, b.OccurredAt
b.Seq = 0
payload, err := json.Marshal(b)
if err != nil {
slog.Debug("runbeat: marshal failed", "run", runID, "kind", kind, "err", err)
return
}
if _, err := db.Get().Exec(`
INSERT INTO pete_run_beat (run_id, seq, kind, occurred_at, payload)
SELECT ?, COALESCE(MAX(seq), 0) + 1, ?, ?, ?
FROM pete_run_beat WHERE run_id = ?`,
runID, kind, occurred, string(payload), runID); err != nil {
slog.Debug("runbeat: record failed", "run", runID, "kind", kind, "err", err)
}
}
// runHasEndBeat reports whether this run's story has already been closed. Cheap
// enough to ask at every end site because a run only ends once; see beatRunEnd
// for why the first answer is the one that must stick.
func runHasEndBeat(runID string) bool {
if runID == "" || !peteclient.Enabled() {
return false
}
var n int
err := db.Get().QueryRow(
`SELECT COUNT(*) FROM pete_run_beat WHERE run_id = ? AND kind = 'end'`, runID).Scan(&n)
return err == nil && n > 0
}
// latestRunIDForNews is the run a just-filed dispatch is about, or "" when there
// isn't one to point at.
//
// The three dispatches that end an expedition — a clear, a retreat, a death —
// are all emitted *after* the run they concluded has been closed, and two of
// them from call sites several frames away from the run row. So rather than
// thread a run id through five signatures and hope the lifetimes line up, this
// asks the question that is actually true at that moment: what is the last run
// this player started. A player has one run at a time and a dispatch about their
// expedition ending is about that one. Multi-region is the case worth stating:
// each region gets its own run, and the last one started is the one they were
// standing in when it ended, which is the log the dispatch should open.
//
// Two clauses do the real work and neither is optional:
//
// - The `pete_run_beat` check. Runs exist with no beats behind them — from
// before the liveblog shipped, or with the seam off — and handing Pete a run
// id it has nothing for would mint a dispatch link to a 404.
// - The recency window. Not every death happens in a dungeon: the campaign
// path kills people at the Empty Throne, and without this a death that had
// nothing to do with any expedition would link to whatever run that player
// last walked, possibly days ago. An expedition-ending dispatch is filed
// seconds after its run closes, so "still open, or closed just now" is the
// honest test for "this dispatch is about that run".
func latestRunIDForNews(userID id.UserID) string {
if userID == "" || !peteclient.Enabled() {
return ""
}
var runID string
err := db.Get().QueryRow(`
SELECT r.run_id
FROM dnd_zone_run r
WHERE r.user_id = ?
AND (r.completed_at IS NULL OR r.completed_at >= datetime('now', '-10 minutes'))
AND EXISTS (SELECT 1 FROM pete_run_beat b WHERE b.run_id = r.run_id)
ORDER BY r.started_at DESC, r.rowid DESC
LIMIT 1`, string(userID)).Scan(&runID)
if err != nil {
return ""
}
return runID
}
// runBeatPushOK mirrors rosterPushOK: log the transitions, stay quiet otherwise.
var runBeatPushOK bool
// pushRunBeats drains the unsent buffer to Pete. Called from the roster ticker.
func (p *AdventurePlugin) pushRunBeats() {
beats, drop, err := loadRunBeatBatch(runBeatBatch)
if err != nil {
slog.Error("runbeat: load batch failed", "err", err)
return
}
// Beats belonging to an opted-out player are retired locally without ever
// going out. Marking them sent (rather than deleting) keeps one code path for
// "this row is done with" and lets the retention sweep reap them on its own
// clock. Opting back in mid-run loses the earlier beats, which is the right
// way round to be wrong.
if len(drop) > 0 {
if err := markRunBeatsSent(drop); err != nil {
slog.Warn("runbeat: retire opted-out beats", "err", err)
}
}
if len(beats) == 0 {
return
}
ctx, cancel := context.WithTimeout(context.Background(), rosterPushTimeout)
defer cancel()
if err := peteclient.PushRunBeats(ctx, beats); err != nil {
if runBeatPushOK {
slog.Warn("runbeat: push failed, liveblog will lag on Pete", "err", err, "beats", len(beats))
} else {
slog.Debug("runbeat: push failed, will retry next tick", "err", err)
}
runBeatPushOK = false
return // rows stay unsent: this is the one push that retries
}
if err := markRunBeatsSent(beats); err != nil {
// Delivered but not marked. Pete is idempotent on (run_id, seq), so the
// re-send next tick is a no-op there — better than dropping the row.
slog.Warn("runbeat: mark sent failed, beats will re-send", "err", err)
}
if !runBeatPushOK {
slog.Info("runbeat: liveblog accepted by Pete", "beats", len(beats))
runBeatPushOK = true
}
}
// loadRunBeatBatch reads up to limit unsent beats in (run, seq) order and splits
// them into the ones to send and the ones to retire unsent.
//
// It drains the cursor completely before resolving a single owner, and that is
// not a style preference. The pool is one connection wide, so a query issued
// while these rows are still open waits for a connection that this loop is
// holding and will not release until the loop ends — a deadlock that the roster
// ticker would hit on its very first tick with any beat in the buffer.
//
// The opt-out check is then per *run*, resolved once and cached for the batch: a
// run belongs to exactly one player, and re-asking per beat would turn a 200-row
// batch into 200 lookups of an answer that cannot change inside one tick.
func loadRunBeatBatch(limit int) (send []peteclient.RunBeat, drop []peteclient.RunBeat, err error) {
type row struct {
runID string
seq int64
payload string
}
rows, qerr := db.Get().Query(`
SELECT run_id, seq, payload
FROM pete_run_beat
WHERE sent_at IS NULL
ORDER BY run_id ASC, seq ASC
LIMIT ?`, limit)
if qerr != nil {
return nil, nil, qerr
}
var raw []row
for rows.Next() {
var r row
if err := rows.Scan(&r.runID, &r.seq, &r.payload); err != nil {
rows.Close()
return nil, nil, err
}
raw = append(raw, r)
}
rerr := rows.Err()
rows.Close()
if rerr != nil {
return nil, nil, rerr
}
allowed := map[string]bool{}
for _, r := range raw {
var b peteclient.RunBeat
if err := json.Unmarshal([]byte(r.payload), &b); err != nil {
// An undecodable row is dead weight forever; retire it rather than
// letting it head the queue and block every beat behind it.
slog.Warn("runbeat: undecodable payload, retiring", "run", r.runID, "seq", r.seq, "err", err)
drop = append(drop, peteclient.RunBeat{RunID: r.runID, Seq: r.seq})
continue
}
b.RunID, b.Seq = r.runID, r.seq
ok, known := allowed[r.runID]
if !known {
ok = runBeatAllowed(r.runID)
allowed[r.runID] = ok
}
if ok {
send = append(send, b)
} else {
drop = append(drop, b)
}
}
return send, drop, nil
}
// runBeatAllowed reports whether this run's beats may leave the box. A run whose
// owner can't be resolved is refused: the liveblog is a public surface, and
// "don't know who this is" is not a safe basis for publishing where they are.
func runBeatAllowed(runID string) bool {
run, err := getZoneRun(runID)
if err != nil || run == nil || run.UserID == "" {
return false
}
return !isNewsOptedOut(id.UserID(run.UserID))
}
// markRunBeatsSent stamps a batch delivered, in one transaction so a crash
// mid-mark can't leave half a run looking unsent and re-send it.
func markRunBeatsSent(beats []peteclient.RunBeat) error {
if len(beats) == 0 {
return nil
}
tx, err := db.Get().Begin()
if err != nil {
return err
}
defer func() { _ = tx.Rollback() }()
stmt, err := tx.Prepare(`UPDATE pete_run_beat SET sent_at = ? WHERE run_id = ? AND seq = ?`)
if err != nil {
return err
}
defer stmt.Close()
now := time.Now().UTC().Unix()
for _, b := range beats {
if _, err := stmt.Exec(now, b.RunID, b.Seq); err != nil {
return err
}
}
return tx.Commit()
}
internal/plugin/pete_runbeat_emit.go
+241
View File
@@ -0,0 +1,241 @@
package plugin
import (
"sort"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
// The emit half of the run liveblog: the handful of places in the walk that
// know something worth telling, and the shape they tell it in.
//
// Every function here is a leaf. They read state, they append a row, they return
// nothing. None of them is allowed to change what the engine does or how long it
// takes to do it — if a beat can't be recorded, the run carries on exactly as it
// did before this file existed.
//
// The nouns are the payload and the numbers are the payload. No sentence
// assembled here ever reaches a reader: Pete writes the words, the same contract
// emitFact has always had.
// beatRunStart opens a run's story: who, where, and how far it goes. The token
// is the public board token, so Pete can hang the liveblog off the adventurer
// page the roster already links to.
//
// This is the only beat carrying identity. Every beat after it is keyed on the
// run id alone, which means a run whose start beat was dropped is anonymous
// rather than misattributed.
func beatRunStart(userID id.UserID, run *DungeonRun, zone ZoneDefinition) {
if run == nil {
return
}
b := peteclient.RunBeat{
Kind: "start",
Token: eventToken(userID, "roster"),
Zone: zone.Display,
TotalRooms: run.TotalRooms,
Room: 1,
RoomKind: string(RoomEntry),
}
if name := charName(userID); name != "" {
b.Name = name
}
if c, err := LoadDnDCharacter(userID); err == nil && c != nil && !c.PendingSetup {
b.Level = c.Level
}
recordRunBeat(run.RunID, b)
}
// beatRoom records an arrival. outcome distinguishes walking on from doubling
// back — the map on the who page already shows *where* the party is, and the
// difference between those two is most of what the log adds to it.
func beatRoom(run *DungeonRun, node string, idx int, outcome string) {
if run == nil {
return
}
b := peteclient.RunBeat{
Kind: "room",
Room: idx + 1,
TotalRooms: run.TotalRooms,
Outcome: outcome,
}
if g, ok := loadZoneGraph(run.ZoneID); ok {
if n, exists := g.Nodes[node]; exists {
b.RoomKind = string(nodeKindToRoomType(n.Kind))
}
}
recordRunBeat(run.RunID, b)
}
// beatCombat records one resolved fight: what it was, how it went, and what it
// cost. Amount is damage taken by the party's leader — the HP pair is the state
// after, so a reader can see the run getting thinner room by room, which is the
// tension the Matrix DM has and the web has never had.
func beatCombat(run *DungeonRun, monster string, elite, boss, won, timedOut bool,
preHP, postHP, maxHP, crits, fumbles int) {
if run == nil {
return
}
outcome := "won"
switch {
case won:
case timedOut:
outcome = "retreat" // outlasted, not killed: mechanically a withdrawal
default:
outcome = "down"
}
kind := string(RoomExploration)
switch {
case boss:
kind = string(RoomBoss)
case elite:
kind = string(RoomElite)
}
dmg := preHP - postHP
if dmg < 0 {
dmg = 0 // healed through the fight; "negative damage" is not a fact
}
recordRunBeat(run.RunID, peteclient.RunBeat{
Kind: "combat",
Room: run.CurrentRoom + 1,
TotalRooms: run.TotalRooms,
RoomKind: kind,
Target: monster,
Outcome: outcome,
Amount: dmg,
HP: postHP,
HPMax: maxHP,
Crits: crits,
Fumbles: fumbles,
})
}
// beatTrap records a sprung trap. A zero-damage trap is still worth a beat: the
// near-miss is part of the run, and the log reads wrong if the party walks
// through a trap room and nothing at all is said about it.
func beatTrap(userID id.UserID, run *DungeonRun, damage int) {
if run == nil {
return
}
hp, maxHP := dndHPSnapshot(userID)
outcome := "sprung"
if damage <= 0 {
outcome = "avoided"
}
recordRunBeat(run.RunID, peteclient.RunBeat{
Kind: "trap",
Room: run.CurrentRoom + 1,
TotalRooms: run.TotalRooms,
RoomKind: string(RoomTrap),
Outcome: outcome,
Amount: damage,
HP: hp,
HPMax: maxHP,
})
}
// beatTreasure records one thing found and kept. One beat per item rather than a
// count: an item is a name, and the name is the whole reason anybody reads a
// loot line.
func beatTreasure(run *DungeonRun, item, source string) {
if run == nil || item == "" {
return
}
recordRunBeat(run.RunID, peteclient.RunBeat{
Kind: "treasure",
Room: run.CurrentRoom + 1,
TotalRooms: run.TotalRooms,
Target: item,
Outcome: source, // "cache" | "boss" | "zone"
})
}
// beatHaul records a room's auto-harvest take, one beat for the room rather than
// one per resource — this is background gathering, and a per-resource beat would
// bury the fights it happens between. Target names the biggest single yield so
// the line has a noun in it; Amount is the total.
func beatHaul(run *DungeonRun, sum autoHarvestSummary) {
if run == nil || len(sum.Yields) == 0 {
return
}
total := 0
// Deterministic pick: biggest yield, ties broken by name, so re-running the
// same room can't produce two different beats from the same map.
keys := make([]string, 0, len(sum.Yields))
for k, v := range sum.Yields {
total += v
keys = append(keys, k)
}
sort.Slice(keys, func(i, j int) bool {
if sum.Yields[keys[i]] != sum.Yields[keys[j]] {
return sum.Yields[keys[i]] > sum.Yields[keys[j]]
}
return keys[i] < keys[j]
})
top := sum.Names[keys[0]]
if top == "" {
top = keys[0]
}
recordRunBeat(run.RunID, peteclient.RunBeat{
Kind: "haul",
Room: run.CurrentRoom + 1,
TotalRooms: run.TotalRooms,
Target: top,
Amount: total,
Count: len(sum.Yields),
})
}
// beatLock records a door the party had to deal with. Only the interesting
// outcomes reach here — an unlocked door is not an event.
func beatLock(run *DungeonRun, target, outcome string) {
if run == nil {
return
}
recordRunBeat(run.RunID, peteclient.RunBeat{
Kind: "lock",
Room: run.CurrentRoom + 1,
TotalRooms: run.TotalRooms,
Target: target,
Outcome: outcome, // "picked" | "sealed"
})
}
// beatRegion records a border crossing on a multi-region expedition. The run id
// changes at a crossing (each region gets its own run), so this beat closes one
// liveblog and the next run's start beat opens the next — naming the region
// ahead is what lets Pete stitch them into one journey.
func beatRegion(run *DungeonRun, from, to string) {
if run == nil {
return
}
recordRunBeat(run.RunID, peteclient.RunBeat{
Kind: "region",
Region: from,
Target: to,
Outcome: "crossed",
})
}
// beatRunEnd closes the story. outcome is the only field that matters and it is
// the one the whole log is read for.
//
// First writer wins, and that is load-bearing. A run ends once, but it passes
// through more than one place that could say so: a death in the combat resolver
// goes on to call abandonZoneRun, and a completed run gets retired by the
// expedition layer. The specific callers file first and know what happened; the
// generic funnels file "abandoned" and would otherwise overwrite them with the
// least informative answer available.
func beatRunEnd(run *DungeonRun, outcome string) {
if run == nil || runHasEndBeat(run.RunID) {
return
}
recordRunBeat(run.RunID, peteclient.RunBeat{
Kind: "end",
Room: run.CurrentRoom + 1,
TotalRooms: run.TotalRooms,
Outcome: outcome, // "cleared" | "died" | "retreated" | "abandoned"
})
}
internal/plugin/pete_runbeat_test.go
+343
View File
@@ -0,0 +1,343 @@
package plugin
import (
"testing"
"time"
"gogobee/internal/db"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
// seedBeatRun writes a dnd_zone_run row directly. The beat pusher resolves a
// run's owner through this table to decide whether the log may leave the box, so
// a test that skips it is testing a code path production never takes.
func seedBeatRun(t *testing.T, runID string, uid id.UserID) {
t.Helper()
if _, err := db.Get().Exec(`
INSERT INTO dnd_zone_run
(run_id, user_id, zone_id, total_rooms, rooms_cleared, gm_mood,
current_node, visited_nodes, node_choices, rooms_traversed)
VALUES (?, ?, 'goblin_warrens', 8, '[]', 50, 'goblin_warrens.r1', '["goblin_warrens.r1"]', '{}', 1)`,
runID, string(uid)); err != nil {
t.Fatalf("seed zone run: %v", err)
}
}
func beatKinds(t *testing.T, runID string) []string {
t.Helper()
rows, err := db.Get().Query(
`SELECT kind FROM pete_run_beat WHERE run_id = ? ORDER BY seq ASC`, runID)
if err != nil {
t.Fatalf("read beats: %v", err)
}
defer rows.Close()
var out []string
for rows.Next() {
var k string
if err := rows.Scan(&k); err != nil {
t.Fatal(err)
}
out = append(out, k)
}
return out
}
// TestRunBeatSeqIsMonotonicPerRun. (run_id, seq) is the identity Pete is
// idempotent on and it is also the render order, so a repeated or missing number
// is either a lost beat or a duplicated one. Two runs walking at once must not
// share a counter.
func TestRunBeatSeqIsMonotonicPerRun(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
for i := 0; i < 3; i++ {
recordRunBeat("run-a", peteclient.RunBeat{Kind: "room", Room: i + 1})
recordRunBeat("run-b", peteclient.RunBeat{Kind: "room", Room: i + 1})
}
for _, run := range []string{"run-a", "run-b"} {
rows, err := db.Get().Query(
`SELECT seq FROM pete_run_beat WHERE run_id = ? ORDER BY seq ASC`, run)
if err != nil {
t.Fatal(err)
}
var seqs []int64
for rows.Next() {
var s int64
if err := rows.Scan(&s); err != nil {
t.Fatal(err)
}
seqs = append(seqs, s)
}
rows.Close()
if len(seqs) != 3 {
t.Fatalf("%s: %d beats, want 3", run, len(seqs))
}
for i, s := range seqs {
if s != int64(i+1) {
t.Errorf("%s: seq[%d] = %d, want %d", run, i, s, i+1)
}
}
}
}
// TestRunBeatsAreDroppedForOptedOutPlayers is the privacy guard, and it is
// stricter than the board's.
//
// The board omits an opted-out player from a snapshot. The liveblog would be a
// room-by-room account of where somebody is and what is happening to them, which
// is the most exposing surface in the whole plan — so the rule here is that the
// beats never leave the box at all. They are retired locally instead, so the
// buffer can't fill up with rows that will never ship.
//
// It is also the pin on the connection-pool deadlock this originally shipped
// with: resolving an owner requires a second query, and doing that with the beat
// cursor still open waits forever on a one-connection pool. If loadRunBeatBatch
// ever goes back to resolving inside its own rows loop, this test stops failing
// and starts HANGING — which is what it did the first time, and is why the note
// is here rather than in a comment nobody reads at 3am.
func TestRunBeatsAreDroppedForOptedOutPlayers(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
now := time.Now().UTC()
seedRosterPlayer(t, "@shy:test", "Quack", &now, &now)
seedRosterPlayer(t, "@loud:test", "Josie", &now, &now)
seedBeatRun(t, "run-shy", "@shy:test")
seedBeatRun(t, "run-loud", "@loud:test")
setNewsOptout("@shy:test", true)
recordRunBeat("run-shy", peteclient.RunBeat{Kind: "room", Room: 2})
recordRunBeat("run-loud", peteclient.RunBeat{Kind: "room", Room: 2})
send, drop, err := loadRunBeatBatch(100)
if err != nil {
t.Fatalf("loadRunBeatBatch: %v", err)
}
if len(send) != 1 || send[0].RunID != "run-loud" {
t.Fatalf("sendable beats = %+v, want only run-loud", send)
}
if len(drop) != 1 || drop[0].RunID != "run-shy" {
t.Fatalf("dropped beats = %+v, want only run-shy", drop)
}
// Retiring means marked sent, not deleted — one code path for "done with this
// row", and the retention sweep reaps it on its own clock.
if err := markRunBeatsSent(drop); err != nil {
t.Fatalf("retire: %v", err)
}
send, drop, _ = loadRunBeatBatch(100)
if len(drop) != 0 {
t.Errorf("retired beats came back: %+v", drop)
}
if len(send) != 1 {
t.Errorf("retiring the opted-out beats disturbed the rest: %+v", send)
}
}
// TestRunBeatsRefuseAnUnresolvableRun. The liveblog is public. A run whose owner
// can't be resolved is not a run we know is safe to publish — "don't know who
// this is" is not a basis for saying where they are.
func TestRunBeatsRefuseAnUnresolvableRun(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
recordRunBeat("run-ghost", peteclient.RunBeat{Kind: "room", Room: 1})
send, drop, err := loadRunBeatBatch(100)
if err != nil {
t.Fatal(err)
}
if len(send) != 0 {
t.Errorf("beats for an unknown run were queued for publication: %+v", send)
}
if len(drop) != 1 {
t.Errorf("orphan beats = %d, want 1 retired", len(drop))
}
}
// TestRunEndIsFirstWriterWins. A run ends once, but it passes through more than
// one place that can say so: a death in the combat resolver goes on to call
// abandonZoneRun, and the expedition layer retires completed runs. The specific
// outcome is filed first and must survive the generic one behind it — a log that
// says "abandoned" about somebody who was killed is worse than no log.
func TestRunEndIsFirstWriterWins(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
now := time.Now().UTC()
seedRosterPlayer(t, "@a:test", "Josie", &now, &now)
seedBeatRun(t, "run-a", "@a:test")
run, err := getZoneRun("run-a")
if err != nil || run == nil {
t.Fatalf("load run: %v", err)
}
beatRunEnd(run, "died")
beatRunEnd(run, "abandoned")
beatRunEnd(run, "cleared")
if kinds := beatKinds(t, "run-a"); len(kinds) != 1 || kinds[0] != "end" {
t.Fatalf("beats = %v, want exactly one end beat", kinds)
}
send, _, err := loadRunBeatBatch(10)
if err != nil {
t.Fatal(err)
}
if len(send) != 1 || send[0].Outcome != "died" {
t.Errorf("stored outcome = %+v, want the first (specific) close", send)
}
}
// TestRunBeatsAreANoOpWhenTheSeamIsOff. The whole channel hangs off the same
// master switch as the dispatch queue: with news emission off, nothing is
// recorded at all, so turning it off doesn't quietly accrue a buffer that floods
// Pete the moment it comes back on.
func TestRunBeatsAreANoOpWhenTheSeamIsOff(t *testing.T) {
newBoredomTestDB(t)
recordRunBeat("run-a", peteclient.RunBeat{Kind: "room", Room: 1})
if kinds := beatKinds(t, "run-a"); len(kinds) != 0 {
t.Errorf("recorded %v with the seam disabled", kinds)
}
}
// TestBeatCombatReadsTheOutcome pins the three fight endings apart. "Outlasted
// by the monster" and "killed by the monster" are the same losing branch in the
// engine and mechanically different events — one starts a respawn timer and the
// other doesn't — so the log must not collapse them.
func TestBeatCombatReadsTheOutcome(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
now := time.Now().UTC()
seedRosterPlayer(t, "@a:test", "Josie", &now, &now)
seedBeatRun(t, "run-a", "@a:test")
run, _ := getZoneRun("run-a")
beatCombat(run, "Rat", false, false, true, false, 30, 24, 30, 1, 0)
beatCombat(run, "Aldric", false, true, false, true, 24, 8, 30, 0, 2)
beatCombat(run, "The Rotmother", false, true, false, false, 8, 0, 30, 0, 0)
send, _, err := loadRunBeatBatch(10)
if err != nil {
t.Fatal(err)
}
if len(send) != 3 {
t.Fatalf("got %d combat beats, want 3", len(send))
}
want := []string{"won", "retreat", "down"}
for i, w := range want {
if send[i].Outcome != w {
t.Errorf("beat %d outcome = %q, want %q", i, send[i].Outcome, w)
}
}
if send[0].Amount != 6 || send[0].HP != 24 || send[0].HPMax != 30 {
t.Errorf("won beat lost its numbers: %+v", send[0])
}
if send[0].Crits != 1 {
t.Errorf("crits = %d, want 1", send[0].Crits)
}
if send[1].RoomKind != "boss" {
t.Errorf("room kind = %q, want boss", send[1].RoomKind)
}
}
// TestBeatCombatNeverReportsNegativeDamage. A party that healed through a fight
// finishes on more HP than it started with. "Took −4 damage" is not a fact.
func TestBeatCombatNeverReportsNegativeDamage(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
now := time.Now().UTC()
seedRosterPlayer(t, "@a:test", "Josie", &now, &now)
seedBeatRun(t, "run-a", "@a:test")
run, _ := getZoneRun("run-a")
beatCombat(run, "Rat", false, false, true, false, 20, 28, 30, 0, 0)
send, _, _ := loadRunBeatBatch(10)
if len(send) != 1 || send[0].Amount != 0 {
t.Fatalf("amount = %+v, want 0", send)
}
}
// TestBeatHaulPicksTheBiggestYieldDeterministically. Go's map order is random,
// so a "mostly X" line built off a range would name a different resource every
// time the same room was rendered.
func TestBeatHaulPicksTheBiggestYieldDeterministically(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
now := time.Now().UTC()
seedRosterPlayer(t, "@a:test", "Josie", &now, &now)
for i, runID := range []string{"run-1", "run-2", "run-3", "run-4", "run-5"} {
seedBeatRun(t, runID, "@a:test")
run, _ := getZoneRun(runID)
beatHaul(run, autoHarvestSummary{
Yields: map[string]int{"ironcap": 5, "moss": 2, "flint": 1},
Names: map[string]string{"ironcap": "Ironcap", "moss": "Moss", "flint": "Flint"},
})
_ = i
}
send, _, err := loadRunBeatBatch(20)
if err != nil {
t.Fatal(err)
}
if len(send) != 5 {
t.Fatalf("got %d haul beats, want 5", len(send))
}
for _, b := range send {
if b.Target != "Ironcap" {
t.Fatalf("haul named %q, want Ironcap every time", b.Target)
}
if b.Amount != 8 || b.Count != 3 {
t.Errorf("haul totals = %d over %d kinds, want 8 over 3", b.Amount, b.Count)
}
}
// Nothing gathered is not a beat.
seedBeatRun(t, "run-empty", "@a:test")
empty, _ := getZoneRun("run-empty")
beatHaul(empty, autoHarvestSummary{})
if kinds := beatKinds(t, "run-empty"); len(kinds) != 0 {
t.Errorf("an empty haul produced %v", kinds)
}
}
// TestStartingARunOpensItsLog is the end-to-end seam check on the game side: the
// engine primitive every zone entry goes through files the one beat that carries
// identity, so nothing downstream has to be told who is walking.
func TestStartingARunOpensItsLog(t *testing.T) {
newBoredomTestDB(t)
enablePeteSeam(t)
now := time.Now().UTC()
seedRosterPlayer(t, "@a:test", "Josie", &now, &now)
run, err := startZoneRun("@a:test", "goblin_warrens", 5, nil)
if err != nil {
t.Fatalf("startZoneRun: %v", err)
}
send, _, err := loadRunBeatBatch(10)
if err != nil {
t.Fatal(err)
}
if len(send) != 1 || send[0].Kind != "start" {
t.Fatalf("beats = %+v, want one start", send)
}
b := send[0]
if b.RunID != run.RunID {
t.Errorf("start beat run = %q, want %q", b.RunID, run.RunID)
}
if b.Name != "Josie" || b.Level != 5 {
t.Errorf("start beat identity = %q L%d, want Josie L5", b.Name, b.Level)
}
if b.Token == "" || b.Token != eventToken("@a:test", "roster") {
t.Errorf("start beat token = %q, want the public board token", b.Token)
}
if b.TotalRooms != run.TotalRooms {
t.Errorf("start beat rooms = %d, want %d", b.TotalRooms, run.TotalRooms)
}
}
internal/plugin/pete_siege.go
+376
View File
@@ -0,0 +1,376 @@
package plugin
import (
"context"
"log/slog"
"sort"
"strconv"
"time"
"gogobee/internal/db"
"gogobee/internal/peteclient"
"maunium.net/go/mautrix/id"
)
// The Siege war room, pushed to Pete.
//
// The Siege is the only mechanic where the whole town works on one object, and
// until now it existed exclusively in Matrix — which means anybody not in the
// room at the time never knew it happened. A communal event nobody can see is a
// communal event that fails.
//
// It rides the roster ticker and follows the roster's rules exactly, because it
// is the same kind of thing: a snapshot of what is currently true, pushed whole,
// replacing whatever Pete had, dropped rather than retried on failure. A retried
// snapshot would be a lie about how much HP is left.
//
// The one place it deliberately departs from the board is the opt-out. The board
// omits an opted-out player entirely — a row showing class + level + zone is
// trivially re-identifiable, so absence is the only honest option there. Here a
// contributor is anonymised instead of dropped: their damage is part of what the
// town did to the boss, and a defender board that quietly deleted it would
// understate the shared effort and stop the numbers adding up. An opted-out
// player who has NOT fought is still omitted — there is nothing to account for,
// so naming their absence would be exposure for nothing.
// siegeHistoryLimit bounds the "sieges past" table. A Siege a month means this is
// years of history; the cap only exists so the payload can't grow without bound.
const siegeHistoryLimit = 24
// pushSiege builds and sends the war room. Mirrors pushRoster: transitions are
// logged, the steady state is silent.
var siegePushOK bool
func (p *AdventurePlugin) pushSiege() {
snap, err := buildSiegeSnapshot(time.Now().UTC())
if err != nil {
slog.Error("siege: build snapshot failed", "err", err)
return
}
ctx, cancel := context.WithTimeout(context.Background(), rosterPushTimeout)
defer cancel()
if err := peteclient.PushSiege(ctx, snap); err != nil {
if siegePushOK {
slog.Warn("siege: push failed, war room will go stale on Pete", "err", err)
} else {
slog.Debug("siege: push failed, dropping snapshot", "err", err)
}
siegePushOK = false
return
}
if !siegePushOK {
slog.Info("siege: war room accepted by Pete", "active", snap.Active, "defenders", len(snap.Defenders))
siegePushOK = true
}
}
// buildSiegeSnapshot assembles the whole war room: the live boss, the muster,
// and the history.
func buildSiegeSnapshot(now time.Time) (peteclient.SiegeSnapshot, error) {
snap := peteclient.SiegeSnapshot{SnapshotAt: now.Unix()}
hist, err := loadResolvedWorldBosses(siegeHistoryLimit)
if err != nil {
return snap, err
}
snap.History = hist
boss, err := loadActiveWorldBoss()
if err != nil {
return snap, err
}
if boss == nil {
return snap, nil // no Siege camped: a real answer, not an empty snapshot
}
snap.Active = true
snap.BossID = boss.ID
snap.BossName = boss.Name
snap.Tier = boss.Tier
snap.HPCurrent = boss.HPCurrent
snap.HPMax = boss.HPMax
snap.StartsAt = boss.StartsAt.Unix()
snap.EndsAt = boss.EndsAt.Unix()
defenders, boutsToday, err := buildSiegeMuster(boss.ID, now)
if err != nil {
return snap, err
}
snap.Defenders = defenders
snap.BoutsToday = boutsToday
return snap, nil
}
// buildSiegeMuster returns every alive adventurer's standing against this boss,
// ranked, plus how many bouts have been taken today.
//
// It starts from the contribution rows rather than from the roster so a
// contributor who has since died (or whose player_meta row went away) still
// appears — the damage they did is on the boss whether they are standing or not.
// The alive roster is then folded in on top to produce the zero-fight rows that
// make the "bout still going spare" column exist.
func buildSiegeMuster(bossID int64, now time.Time) ([]peteclient.SiegeDefender, int, error) {
contribs, err := loadWorldBossContribs(bossID)
if err != nil {
return nil, 0, err
}
today := now.Format("2006-01-02")
byUser := make(map[id.UserID]worldBossContrib, len(contribs))
for _, c := range contribs {
byUser[c.UserID] = c
}
// Everyone alive, so the un-fought have a row to stand in.
rows, err := db.Get().Query(`SELECT user_id FROM player_meta WHERE alive = 1`)
if err != nil {
return nil, 0, err
}
order := make([]id.UserID, 0, len(contribs))
seen := make(map[id.UserID]bool, len(contribs))
for rows.Next() {
var uid string
if err := rows.Scan(&uid); err != nil {
rows.Close()
return nil, 0, err
}
u := id.UserID(uid)
if !seen[u] {
seen[u] = true
order = append(order, u)
}
}
rows.Close()
if err := rows.Err(); err != nil {
return nil, 0, err
}
// Contributors who are no longer on the alive roster still owe the board a row.
for _, c := range contribs {
if !seen[c.UserID] {
seen[c.UserID] = true
order = append(order, c.UserID)
}
}
boutsToday := 0
out := make([]peteclient.SiegeDefender, 0, len(order))
for _, uid := range order {
c, fought := byUser[uid]
if fought && c.LastFightDate == today {
boutsToday++
}
optedOut := isNewsOptedOut(uid)
if optedOut && !fought {
continue // nothing to account for; naming the absence is exposure for nothing
}
d := peteclient.SiegeDefender{Name: anonName}
if fought {
d.Fights = c.Fights
d.Damage = c.Damage
d.FoughtToday = c.LastFightDate == today
}
if !optedOut {
name := charName(uid)
if name == "" {
// No character name means no honest way to render the row: never fall
// back to a Matrix handle on a public page. A contributor in this state
// keeps their damage, anonymously; a non-contributor is simply dropped.
if !fought {
continue
}
} else {
d.Name = name
d.Token = eventToken(uid, "roster")
if ch, err := LoadDnDCharacter(uid); err == nil && ch != nil && !ch.PendingSetup {
d.Level = ch.Level
}
}
}
out = append(out, d)
}
// Rank: damage, then bouts, then name. Deterministic to the last key so an
// unchanged muster produces a byte-identical snapshot and Pete's board doesn't
// reshuffle itself every two minutes.
sort.SliceStable(out, func(i, j int) bool {
if out[i].Damage != out[j].Damage {
return out[i].Damage > out[j].Damage
}
if out[i].Fights != out[j].Fights {
return out[i].Fights > out[j].Fights
}
return out[i].Name < out[j].Name
})
return out, boutsToday, nil
}
// loadResolvedWorldBosses reads the closed-out Sieges, newest first, each with
// its defender count and the contributor who turned up most.
func loadResolvedWorldBosses(limit int) ([]peteclient.SiegePast, error) {
// resolved_at is selected raw and folded in Go, never COALESCE()'d in SQL:
// modernc.org/sqlite rebuilds a time.Time from the column's DECLARED type and
// COALESCE erases that affinity, so the Scan would fail. Same trap
// buildRosterSnapshot documents.
rows, err := db.Get().Query(`
SELECT id, name, tier, hp_max, hp_current, status, resolved_at, ends_at
FROM world_boss
WHERE status IN ('defeated', 'survived')
ORDER BY id DESC
LIMIT ?`, limit)
if err != nil {
return nil, err
}
defer rows.Close()
var out []peteclient.SiegePast
for rows.Next() {
var (
h peteclient.SiegePast
resolvedAt, endsAt *time.Time
)
if err := rows.Scan(&h.BossID, &h.BossName, &h.Tier, &h.HPMax, &h.HPRemaining,
&h.Outcome, &resolvedAt, &endsAt); err != nil {
return nil, err
}
// A boss resolved by the ticker has resolved_at; a legacy row might not.
// The window's close is the honest fallback — it is when the Siege ended
// either way, and it is never null.
switch {
case resolvedAt != nil:
h.EndedAt = resolvedAt.Unix()
case endsAt != nil:
h.EndedAt = endsAt.Unix()
}
out = append(out, h)
}
if err := rows.Err(); err != nil {
return nil, err
}
for i := range out {
n, mvp, fights, err := worldBossMuster(out[i].BossID)
if err != nil {
slog.Warn("siege: history muster load failed", "boss", out[i].BossID, "err", err)
continue
}
out[i].Defenders = n
out[i].MVP = mvp
out[i].MVPFights = fights
}
return out, nil
}
// worldBossMuster reports how many people fought a boss and who fought it most.
// The MVP is by fights, not damage — the same accessibility call the payout
// split makes (computeWorldBossPayouts): turning up is the contribution the
// mechanic actually asks for. An opted-out MVP is anonymised, never dropped;
// the count behind the name is a fact about the town.
func worldBossMuster(bossID int64) (defenders int, mvp string, mvpFights int, err error) {
contribs, err := loadWorldBossContribs(bossID)
if err != nil {
return 0, "", 0, err
}
// loadWorldBossContribs already orders by fights desc, damage desc, so the
// first row with any fights at all is the MVP.
for _, c := range contribs {
if c.Fights <= 0 {
continue
}
defenders++
if mvp == "" {
mvp = anonName
if !isNewsOptedOut(c.UserID) {
if name := charName(c.UserID); name != "" {
mvp = name
}
}
mvpFights = c.Fights
}
}
return defenders, mvp, mvpFights, nil
}
// ── Dispatches ───────────────────────────────────────────────────────────────
// emitSiegeStart files the "a boss is at the gates" dispatch. PRIORITY: this is
// the one beat where the right response is for everyone to look up right now,
// and unlike a zone clear it is not something TwinBee has already announced to
// the same people — the games-room shout and this go to different rooms.
//
// Realm-level, so there is no subject player and no opt-out to apply.
func emitSiegeStart(boss *worldBossState) {
if !peteclient.Enabled() || !newsEmissionOn() {
return
}
emitFact(peteclient.Fact{
GUID: siegeGUID("siege_start", boss.ID),
EventType: "siege_start",
Tier: "priority",
Boss: boss.Name,
Level: boss.Tier,
Stakes: siegeWindowPhrase(boss),
OccurredAt: boss.StartsAt.Unix(),
}, "", "")
}
// emitSiegeWin files the "the town held" dispatch. Count is the number of
// defenders, which is what Pete's template reads to say how many stood.
func emitSiegeWin(boss *worldBossState, defenders int) {
if !peteclient.Enabled() || !newsEmissionOn() {
return
}
emitFact(peteclient.Fact{
GUID: siegeGUID("siege_win", boss.ID),
EventType: "siege_win",
Tier: "priority",
Boss: boss.Name,
Level: boss.Tier,
Count: defenders,
Outcome: "defeated",
OccurredAt: nowUnix(),
}, "", "")
}
// emitSiegeLoss files the "it broke through" dispatch.
func emitSiegeLoss(boss *worldBossState) {
if !peteclient.Enabled() || !newsEmissionOn() {
return
}
emitFact(peteclient.Fact{
GUID: siegeGUID("siege_loss", boss.ID),
EventType: "siege_loss",
Tier: "priority",
Boss: boss.Name,
Level: boss.Tier,
Outcome: "survived",
OccurredAt: nowUnix(),
}, "", "")
}
// siegeGUID keys a Siege dispatch on the boss row id, which is unique and stable
// for the life of the event. That makes each of the three beats fire at most
// once per Siege however many times its resolution path is re-entered — the
// status guard in setWorldBossStatus already dedupes the payout, and this dedupes
// the news the same way.
func siegeGUID(eventType string, bossID int64) string {
return eventType + ":" + strconv.FormatInt(bossID, 10)
}
// siegeWindowPhrase is the deadline as Pete's siege_start template wants it —
// "You've got %s" — so it must read as a duration, not a timestamp.
func siegeWindowPhrase(boss *worldBossState) string {
h := int(boss.EndsAt.Sub(boss.StartsAt).Hours())
switch {
case h <= 0:
return "no time at all"
case h == 24:
return "a day"
case h%24 == 0:
return strconv.Itoa(h/24) + " days"
default:
return strconv.Itoa(h) + " hours"
}
}
internal/plugin/pete_siege_test.go
+254
View File
@@ -0,0 +1,254 @@
package plugin
import (
"testing"
"time"
"gogobee/internal/db"
"maunium.net/go/mautrix/id"
)
// seedSiege writes a world_boss row directly and returns it. Real rows on
// purpose: the history query scans two declared DATETIME columns (resolved_at,
// ends_at) and the modernc affinity trap only fires against actual stored
// values, never against a hand-built struct.
func seedSiege(t *testing.T, name string, tier, hpMax, hpCurrent int, status string, starts, ends time.Time, resolved *time.Time) int64 {
t.Helper()
res, err := db.Get().Exec(
`INSERT INTO world_boss (name, tier, hp_max, hp_current, status, starts_at, ends_at, resolved_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
name, tier, hpMax, hpCurrent, status, starts, ends, resolved)
if err != nil {
t.Fatalf("seed world_boss: %v", err)
}
id, err := res.LastInsertId()
if err != nil {
t.Fatal(err)
}
return id
}
func seedContrib(t *testing.T, bossID int64, uid id.UserID, fights, damage int, lastDate string) {
t.Helper()
if _, err := db.Get().Exec(
`INSERT INTO world_boss_contrib (boss_id, user_id, fights, damage, last_fight_date)
VALUES (?, ?, ?, ?, ?)`, bossID, string(uid), fights, damage, lastDate); err != nil {
t.Fatalf("seed contrib: %v", err)
}
}
// TestSiegeSnapshotMustersEveryoneAlive is the reason the payload carries
// zero-fight rows at all. The mechanic is one bout per person per day, so the
// interesting number is not "who fought" but "who still could" — and Pete can
// only draw that column if the people in it are on the wire. A snapshot of
// contributors alone would render a board that quietly congratulates itself.
func TestSiegeSnapshotMustersEveryoneAlive(t *testing.T) {
newBoredomTestDB(t)
now := time.Now().UTC()
old := now.Add(-40 * time.Hour)
today := now.Format("2006-01-02")
seedRosterPlayer(t, "@a:test", "Josie", &old, &old)
seedRosterPlayer(t, "@b:test", "Quack", &old, &old)
seedRosterPlayer(t, "@c:test", "Camcast", &old, &old)
bossID := seedSiege(t, "Gorloth the Sunderer", 4, 1000, 400, "active",
now.Add(-2*time.Hour), now.Add(70*time.Hour), nil)
seedContrib(t, bossID, "@a:test", 3, 500, today)
seedContrib(t, bossID, "@b:test", 1, 100, now.AddDate(0, 0, -1).Format("2006-01-02"))
snap, err := buildSiegeSnapshot(now)
if err != nil {
t.Fatalf("buildSiegeSnapshot: %v", err)
}
if !snap.Active || snap.BossName != "Gorloth the Sunderer" {
t.Fatalf("snapshot missed the live boss: %+v", snap)
}
if snap.HPCurrent != 400 || snap.HPMax != 1000 {
t.Errorf("pool = %d/%d, want 400/1000", snap.HPCurrent, snap.HPMax)
}
if len(snap.Defenders) != 3 {
t.Fatalf("muster has %d rows, want 3 — the un-fought must have a row to stand in", len(snap.Defenders))
}
if snap.BoutsToday != 1 {
t.Errorf("bouts_today = %d, want 1 — only Josie has been out today", snap.BoutsToday)
}
// Ranked by damage: Josie, Quack, then the adventurer who hasn't started.
if snap.Defenders[0].Name != "Josie" || !snap.Defenders[0].FoughtToday {
t.Errorf("top of the muster = %+v, want Josie having fought today", snap.Defenders[0])
}
if snap.Defenders[1].Name != "Quack" || snap.Defenders[1].FoughtToday {
t.Errorf("second = %+v, want Quack with a bout still spare (hers was yesterday)", snap.Defenders[1])
}
if snap.Defenders[2].Name != "Camcast" || snap.Defenders[2].Fights != 0 {
t.Errorf("third = %+v, want Camcast at zero fights", snap.Defenders[2])
}
for _, d := range snap.Defenders {
if d.Token == "" {
t.Errorf("%s has no board token — the defender board can't link to their page", d.Name)
}
}
}
// TestSiegeOptOutAnonymisesContributorAndDropsBystander is the one place the
// Siege deliberately breaks the board's opt-out rule, so it is worth pinning
// both halves.
//
// The board omits an opted-out player outright: a row showing class + level +
// zone re-identifies them, so absence is the only honest option. Here a
// CONTRIBUTOR is anonymised instead — the damage they did is on the boss and is
// part of what the town accomplished, and deleting it would understate the
// shared effort and stop the totals adding up. A non-contributor is still
// dropped, because there is nothing to account for and naming their absence
// would be exposure for nothing.
func TestSiegeOptOutAnonymisesContributorAndDropsBystander(t *testing.T) {
newBoredomTestDB(t)
now := time.Now().UTC()
old := now.Add(-40 * time.Hour)
today := now.Format("2006-01-02")
seedRosterPlayer(t, "@shy:test", "Ghost", &old, &old) // opted out, fought
seedRosterPlayer(t, "@lurk:test", "Silent", &old, &old) // opted out, never fought
seedRosterPlayer(t, "@open:test", "Josie", &old, &old) // opted in, fought
setNewsOptout("@shy:test", true)
setNewsOptout("@lurk:test", true)
bossID := seedSiege(t, "The Iron Colossus", 4, 1000, 200, "active",
now.Add(-time.Hour), now.Add(71*time.Hour), nil)
seedContrib(t, bossID, "@shy:test", 4, 600, today)
seedContrib(t, bossID, "@open:test", 1, 200, today)
snap, err := buildSiegeSnapshot(now)
if err != nil {
t.Fatalf("buildSiegeSnapshot: %v", err)
}
if len(snap.Defenders) != 2 {
t.Fatalf("muster has %d rows, want 2 — the opted-out bystander should be gone and the opted-out contributor kept", len(snap.Defenders))
}
top := snap.Defenders[0]
if top.Damage != 600 {
t.Fatalf("top of the muster did %d damage, want 600 — the anonymous contributor lost their rank", top.Damage)
}
if top.Name != anonName {
t.Errorf("opted-out contributor rendered as %q, want %q", top.Name, anonName)
}
if top.Token != "" {
t.Error("opted-out contributor carries a board token — that is a link straight back to a page that names them")
}
if top.Level != 0 {
t.Errorf("opted-out contributor leaked level %d — level + damage is most of a re-identification", top.Level)
}
for _, d := range snap.Defenders {
if d.Name == "Silent" || d.Name == "Ghost" {
t.Errorf("opted-out player %q reached the wire under their character name", d.Name)
}
}
}
// TestSiegeHistoryReadsResolvedClock is the scan-affinity guard for the history
// query, the exact trap buildRosterSnapshot documents: resolved_at and ends_at
// are declared DATETIME, and a COALESCE() in the SQL would erase that affinity
// so the Scan fails — which would silently publish an empty history rather than
// anything obviously broken.
func TestSiegeHistoryReadsResolvedClock(t *testing.T) {
newBoredomTestDB(t)
now := time.Now().UTC()
old := now.Add(-40 * time.Hour)
seedRosterPlayer(t, "@a:test", "Josie", &old, &old)
seedRosterPlayer(t, "@b:test", "Quack", &old, &old)
resolved := now.Add(-24 * time.Hour)
won := seedSiege(t, "The Ashen Wyrm", 5, 1200, 0, "defeated",
now.Add(-96*time.Hour), now.Add(-24*time.Hour), &resolved)
seedContrib(t, won, "@a:test", 6, 700, "2026-07-01")
seedContrib(t, won, "@b:test", 2, 500, "2026-07-01")
// A legacy row with no resolved_at must still date itself — off the window's
// close, which is when the Siege ended either way and is never null.
lost := seedSiege(t, "Kravok, Maw of the Deep", 4, 800, 300, "survived",
now.Add(-200*time.Hour), now.Add(-128*time.Hour), nil)
seedContrib(t, lost, "@a:test", 1, 500, "2026-06-01")
snap, err := buildSiegeSnapshot(now)
if err != nil {
t.Fatalf("buildSiegeSnapshot: %v", err)
}
if snap.Active {
t.Error("no boss is camped but the snapshot claims one is")
}
if len(snap.History) != 2 {
t.Fatalf("history has %d rows, want 2", len(snap.History))
}
// Newest first (id desc): the survived Kravok was inserted last.
h := snap.History[0]
if h.BossName != "Kravok, Maw of the Deep" || h.Outcome != "survived" {
t.Fatalf("history[0] = %+v, want the survived Kravok first", h)
}
if h.HPRemaining != 300 || h.HPMax != 800 {
t.Errorf("survived bar = %d/%d, want 300/800", h.HPRemaining, h.HPMax)
}
if h.EndedAt != now.Add(-128*time.Hour).Unix() {
t.Errorf("legacy row dated %d, want the window close %d", h.EndedAt, now.Add(-128*time.Hour).Unix())
}
w := snap.History[1]
if w.Outcome != "defeated" || w.HPRemaining != 0 {
t.Errorf("defeated Siege = %+v, want a pool at zero", w)
}
if w.EndedAt != resolved.Unix() {
t.Errorf("resolved row dated %d, want resolved_at %d", w.EndedAt, resolved.Unix())
}
if w.Defenders != 2 {
t.Errorf("defenders = %d, want 2", w.Defenders)
}
// MVP is by fights, not damage — the same accessibility call the payout split
// makes. Josie fought six times for 700; had it been by damage she'd still win,
// so the ordering is pinned by loadWorldBossContribs' fights-desc ordering.
if w.MVP != "Josie" || w.MVPFights != 6 {
t.Errorf("MVP = %q with %d fights, want Josie with 6", w.MVP, w.MVPFights)
}
}
// TestSiegeDispatchesFireOncePerSiege. The three Siege beats key their GUID on
// the boss row id, so a resolution path re-entered (a redeploy mid-window, the
// ticker's safety net firing after an inline kill) files the same dispatch guid
// and Pete dedupes it. Without that, a restart could announce the same Siege
// twice to the whole room.
func TestSiegeDispatchesFireOncePerSiege(t *testing.T) {
if a, b := siegeGUID("siege_start", 7), siegeGUID("siege_start", 7); a != b {
t.Errorf("guid not stable: %q vs %q", a, b)
}
if a, b := siegeGUID("siege_start", 7), siegeGUID("siege_start", 8); a == b {
t.Errorf("two different Sieges share guid %q", a)
}
if a, b := siegeGUID("siege_win", 7), siegeGUID("siege_loss", 7); a == b {
t.Errorf("win and loss share guid %q — one Siege cannot file both", a)
}
}
// TestSiegeWindowPhrase: the siege_start template says "You've got %s", so the
// stakes field has to read as a duration in a sentence, not as a timestamp.
func TestSiegeWindowPhrase(t *testing.T) {
base := time.Date(2026, 7, 1, 0, 0, 0, 0, time.UTC)
cases := []struct {
window time.Duration
want string
}{
{worldBossWindow, "3 days"},
{24 * time.Hour, "a day"},
{36 * time.Hour, "36 hours"},
{0, "no time at all"},
}
for _, c := range cases {
b := &worldBossState{StartsAt: base, EndsAt: base.Add(c.window)}
if got := siegeWindowPhrase(b); got != c.want {
t.Errorf("siegeWindowPhrase(%v) = %q, want %q", c.window, got, c.want)
}
}
}
internal/plugin/pete_test.go
+66
View File
@@ -3,6 +3,7 @@ package plugin
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"os"
"sync"
"testing"
@@ -193,6 +194,71 @@ func TestEmitZoneClearTaxonomy(t *testing.T) {
}
}
// TestEmitTreasureFound: a story-grade find carries the item name and rarity,
// and the realm's first finder of a given treasure is billed a PRIORITY hoard
// while a later finder of the same item is a BULLETIN — the same first/repeat
// split zone_first uses, but keyed on the treasure across the whole realm.
func TestEmitTreasureFound(t *testing.T) {
dir := t.TempDir()
db.Close()
if err := db.Init(dir); err != nil {
t.Fatalf("db.Init: %v", err)
}
t.Cleanup(db.Close)
enablePeteSeam(t)
db.Exec("seed finder", `INSERT INTO player_meta (user_id, display_name) VALUES (?, ?)`, "@zapp:x", "Zapp")
db.Exec("seed second finder", `INSERT INTO player_meta (user_id, display_name) VALUES (?, ?)`, "@kif:x", "Kif")
def := &AdvTreasureDef{Key: "thunderfury", Name: "Thunderfury, Blessed Blade of the Windseeker",
Tier: 5, RoomAnnounce: "x got Thunderfury."}
loc := &AdvLocation{Name: "The Abyssal Maw"}
emitTreasureFound(id.UserID("@zapp:x"), def, loc) // realm-first
emitTreasureFound(id.UserID("@kif:x"), def, loc) // same item, later finder
if got := queuedCount(t, "treasure_found:%"); got != 2 {
t.Fatalf("treasure_found queued = %d, want 2", got)
}
// Pull both payloads and check the taxonomy split plus the carried fields.
rows, err := db.Get().Query(`SELECT payload FROM pete_emit_queue WHERE guid LIKE 'treasure_found:%'`)
if err != nil {
t.Fatal(err)
}
defer rows.Close()
tiers := map[string]int{}
for rows.Next() {
var payload string
if err := rows.Scan(&payload); err != nil {
t.Fatal(err)
}
var f map[string]any
if err := json.Unmarshal([]byte(payload), &f); err != nil {
t.Fatal(err)
}
tiers[f["tier"].(string)]++
if f["stakes"] != def.Name {
t.Errorf("stakes = %v, want the item name", f["stakes"])
}
if f["zone"] != "The Abyssal Maw" {
t.Errorf("zone = %v, want the location", f["zone"])
}
if f["outcome"] != "legendary" {
t.Errorf("outcome = %v, want legendary for a tier-5 find", f["outcome"])
}
}
if tiers["priority"] != 1 || tiers["bulletin"] != 1 {
t.Errorf("tier split = %v, want one priority (realm-first) and one bulletin (repeat)", tiers)
}
// The ledger is seeded, so a later live find of the same treasure won't
// mis-announce as the first-ever.
if claimRealmFirst("treasure", "thunderfury") {
t.Error("realm-first ledger not seeded for the treasure")
}
}
// TestNewsEmissionKillSwitch: the runtime flag defaults on and persists a flip.
func TestNewsEmissionKillSwitch(t *testing.T) {
dir := t.TempDir()
internal/plugin/plugin.go
+217 -11
View File
@@ -83,9 +83,17 @@ func PluginVersion(p Plugin) string {
}
// dmCache maps user IDs to their DM room IDs to avoid creating duplicate rooms.
// It fronts the dm_rooms table; notDMCache is the negative half, marking rooms
// LearnDMRoom has already ruled out so group rooms cost one member lookup ever.
var (
dmCache = make(map[id.UserID]id.RoomID)
dmCacheMu sync.Mutex
dmCache = make(map[id.UserID]id.RoomID)
dmMapped = make(map[id.UserID]bool)
notDMCache = make(map[id.RoomID]bool)
dmCacheMu sync.Mutex
// One-shot index of two-person rooms, built by findExistingDMRoom.
dmSweepOnce sync.Once
dmSweepIndex = make(map[id.UserID]id.RoomID)
)
// Base provides common helpers for plugin implementations.
@@ -686,6 +694,180 @@ func (b *Base) SendReact(roomID id.RoomID, eventID id.EventID, emoji string) err
return err
}
// rememberDMRoom pins a user's DM room in both the in-process cache and the
// database, so a restart doesn't send the bot off creating a duplicate room.
func rememberDMRoom(userID id.UserID, roomID id.RoomID) {
dmCacheMu.Lock()
dmCache[userID] = roomID
dmMapped[userID] = true
dmCacheMu.Unlock()
if d := db.Get(); d != nil {
_, err := d.Exec(`INSERT INTO dm_rooms (user_id, room_id, updated_at)
VALUES (?, ?, unixepoch())
ON CONFLICT(user_id) DO UPDATE SET room_id = excluded.room_id, updated_at = excluded.updated_at`,
string(userID), string(roomID))
if err != nil {
slog.Error("persist dm room", "user", userID, "room", roomID, "err", err)
}
}
}
// forgetDMRoom drops a mapping that no longer resolves to a live shared room.
func forgetDMRoom(userID id.UserID) {
dmCacheMu.Lock()
delete(dmCache, userID)
delete(dmMapped, userID)
dmCacheMu.Unlock()
if d := db.Get(); d != nil {
if _, err := d.Exec(`DELETE FROM dm_rooms WHERE user_id = ?`, string(userID)); err != nil {
slog.Error("forget dm room", "user", userID, "err", err)
}
}
}
// storedDMRoom reads the persisted DM room for a user, if any.
func storedDMRoom(userID id.UserID) (id.RoomID, bool) {
d := db.Get()
if d == nil {
return "", false
}
var roomID string
err := d.QueryRow(`SELECT room_id FROM dm_rooms WHERE user_id = ?`, string(userID)).Scan(&roomID)
if err != nil || roomID == "" {
return "", false
}
return id.RoomID(roomID), true
}
// dmRoomUsable reports whether the bot and the user still share the room. The
// user counts as present while merely invited — they often never accept, and
// treating that as "gone" is what would recreate the room on every send.
func (b *Base) dmRoomUsable(roomID id.RoomID, userID id.UserID) bool {
ctx := context.Background()
var self event.MemberEventContent
if err := b.Client.StateEvent(ctx, roomID, event.StateMember, string(b.Client.UserID), &self); err != nil {
return false
}
if self.Membership != event.MembershipJoin {
return false
}
var other event.MemberEventContent
if err := b.Client.StateEvent(ctx, roomID, event.StateMember, string(userID), &other); err != nil {
return false
}
return other.Membership == event.MembershipJoin || other.Membership == event.MembershipInvite
}
// publishDirect appends the room to the bot's m.direct account data, so the
// room is labelled as a DM rather than a nameless private room.
func (b *Base) publishDirect(userID id.UserID, roomID id.RoomID) {
ctx := context.Background()
dmRooms := map[id.UserID][]id.RoomID{}
// A missing m.direct is a 404 — start from empty rather than bailing.
_ = b.Client.GetAccountData(ctx, "m.direct", &dmRooms)
for _, existing := range dmRooms[userID] {
if existing == roomID {
return
}
}
dmRooms[userID] = append(dmRooms[userID], roomID)
if err := b.Client.SetAccountData(ctx, "m.direct", dmRooms); err != nil {
slog.Warn("publish m.direct", "user", userID, "room", roomID, "err", err)
}
}
// RecordDMRoom claims a room as the user's DM room. Used for user-initiated
// DM invites, where the invite itself is the intent — it overwrites any older
// mapping, since the user just told us which room they want to talk in.
func (b *Base) RecordDMRoom(userID id.UserID, roomID id.RoomID) {
slog.Info("recorded user-initiated DM room", "user", userID, "room", roomID)
rememberDMRoom(userID, roomID)
b.publishDirect(userID, roomID)
}
// LearnDMRoom records a room the user messaged the bot in as their DM room,
// when it really is a two-person room. This adopts DM rooms that predate the
// database mapping instead of leaving them orphaned beside a freshly created one.
func (b *Base) LearnDMRoom(userID id.UserID, roomID id.RoomID) {
if b == nil || b.Client == nil {
return
}
dmCacheMu.Lock()
_, known := dmCache[userID]
mapped := dmMapped[userID]
notDM := notDMCache[roomID]
dmCacheMu.Unlock()
if known || mapped || notDM {
return
}
if _, ok := storedDMRoom(userID); ok {
// Note it as mapped, not as resolved: caching the room here would let
// GetDMRoom skip its liveness check on a possibly-stale room.
dmCacheMu.Lock()
dmMapped[userID] = true
dmCacheMu.Unlock()
return
}
members, err := b.Client.JoinedMembers(context.Background(), roomID)
if err != nil {
return
}
_, botIn := members.Joined[b.Client.UserID]
_, userIn := members.Joined[userID]
if len(members.Joined) != 2 || !botIn || !userIn {
// Group room — remember that so every later message here is free.
dmCacheMu.Lock()
notDMCache[roomID] = true
dmCacheMu.Unlock()
return
}
slog.Info("adopted existing DM room", "user", userID, "room", roomID)
rememberDMRoom(userID, roomID)
}
// findExistingDMRoom scans the bot's joined rooms for a two-person room shared
// with userID. The scan is expensive (one member lookup per room), so it runs
// at most once per process and only on the path that would otherwise create a
// duplicate room.
func (b *Base) findExistingDMRoom(userID id.UserID) (id.RoomID, bool) {
dmSweepOnce.Do(func() {
ctx := context.Background()
joined, err := b.Client.JoinedRooms(ctx)
if err != nil {
slog.Warn("DM sweep: list joined rooms", "err", err)
return
}
for _, roomID := range joined.JoinedRooms {
members, err := b.Client.JoinedMembers(ctx, roomID)
if err != nil || len(members.Joined) != 2 {
continue
}
if _, ok := members.Joined[b.Client.UserID]; !ok {
continue
}
for member := range members.Joined {
if member != b.Client.UserID {
dmSweepIndex[member] = roomID
}
}
}
slog.Info("DM sweep complete", "rooms", len(joined.JoinedRooms), "dms", len(dmSweepIndex))
})
roomID, ok := dmSweepIndex[userID]
return roomID, ok
}
// GetDMRoom returns the DM room for a user, creating one if needed.
func (b *Base) GetDMRoom(userID id.UserID) (id.RoomID, error) {
dmCacheMu.Lock()
@@ -695,17 +877,42 @@ func (b *Base) GetDMRoom(userID id.UserID) (id.RoomID, error) {
}
dmCacheMu.Unlock()
// Check account data for existing DM rooms
var dmRooms map[id.UserID][]id.RoomID
err := b.Client.GetAccountData(context.Background(), "m.direct", &dmRooms)
if err == nil {
if rooms, ok := dmRooms[userID]; ok && len(rooms) > 0 {
roomID := rooms[len(rooms)-1] // use most recent
// Persisted mapping — the authoritative store across restarts.
if roomID, ok := storedDMRoom(userID); ok {
if b.dmRoomUsable(roomID, userID) {
dmCacheMu.Lock()
dmCache[userID] = roomID
dmCacheMu.Unlock()
return roomID, nil
}
slog.Info("stored DM room no longer usable, recreating", "user", userID, "room", roomID)
forgetDMRoom(userID)
}
// Check account data for existing DM rooms
var dmRooms map[id.UserID][]id.RoomID
err := b.Client.GetAccountData(context.Background(), "m.direct", &dmRooms)
if err == nil {
for i := len(dmRooms[userID]) - 1; i >= 0; i-- {
roomID := dmRooms[userID][i] // most recent first
if b.dmRoomUsable(roomID, userID) {
rememberDMRoom(userID, roomID)
return roomID, nil
}
}
}
// Last resort before creating: sweep the rooms the bot is already in for a
// two-person room shared with this user. Users who predate the dm_rooms
// table have such a room and nothing pointing at it — without this sweep
// their first post-upgrade DM would open yet another duplicate. If several
// duplicates exist we cannot tell which is liveliest (no /sync, so no
// timestamps), so the newest by room-list order wins.
if roomID, ok := b.findExistingDMRoom(userID); ok {
slog.Info("recovered pre-existing DM room by member sweep", "user", userID, "room", roomID)
rememberDMRoom(userID, roomID)
b.publishDirect(userID, roomID)
return roomID, nil
}
// No existing DM room — create one
@@ -728,9 +935,8 @@ func (b *Base) GetDMRoom(userID id.UserID) (id.RoomID, error) {
return "", fmt.Errorf("create DM room: %w", err)
}
dmCacheMu.Lock()
dmCache[userID] = resp.RoomID
dmCacheMu.Unlock()
rememberDMRoom(userID, resp.RoomID)
b.publishDirect(userID, resp.RoomID)
return resp.RoomID, nil
}

Some files were not shown because too many files have changed in this diff Show More