From 686434f8e325dddf1be4be48d0d97849c4960f9d Mon Sep 17 00:00:00 2001 From: prosolis <5590409+prosolis@users.noreply.github.com> Date: Thu, 16 Jul 2026 08:04:19 -0700 Subject: [PATCH] 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 --- internal/plugin/combat_cmd.go | 11 ++ internal/plugin/combat_engine.go | 21 ++++ internal/plugin/combat_narrative.go | 11 ++ internal/plugin/combat_session.go | 11 ++ internal/plugin/combat_turn_engine.go | 4 + internal/plugin/postgame_boss_hooks.go | 72 +++++++++++++ internal/plugin/postgame_boss_hooks_test.go | 109 ++++++++++++++++++++ 7 files changed, 239 insertions(+) diff --git a/internal/plugin/combat_cmd.go b/internal/plugin/combat_cmd.go index ed813d5..e8d3f91 100644 --- a/internal/plugin/combat_cmd.go +++ b/internal/plugin/combat_cmd.go @@ -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 != "" { diff --git a/internal/plugin/combat_engine.go b/internal/plugin/combat_engine.go index d92f30b..d501df6 100644 --- a/internal/plugin/combat_engine.go +++ b/internal/plugin/combat_engine.go @@ -428,6 +428,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 @@ -1308,6 +1316,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 } diff --git a/internal/plugin/combat_narrative.go b/internal/plugin/combat_narrative.go index ae3b8b3..35be08a 100644 --- a/internal/plugin/combat_narrative.go +++ b/internal/plugin/combat_narrative.go @@ -331,6 +331,8 @@ 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 "stat_drain": return fmt.Sprintf(pickRand(narrativeStatDrain), e.Damage) case "debuff": @@ -761,6 +763,15 @@ 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*.", +} + 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)", diff --git a/internal/plugin/combat_session.go b/internal/plugin/combat_session.go index f962b3d..8db97a5 100644 --- a/internal/plugin/combat_session.go +++ b/internal/plugin/combat_session.go @@ -215,6 +215,17 @@ 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"` diff --git a/internal/plugin/combat_turn_engine.go b/internal/plugin/combat_turn_engine.go index 6071e1f..487470e 100644 --- a/internal/plugin/combat_turn_engine.go +++ b/internal/plugin/combat_turn_engine.go @@ -363,6 +363,8 @@ 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, @@ -926,6 +928,8 @@ 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 diff --git a/internal/plugin/postgame_boss_hooks.go b/internal/plugin/postgame_boss_hooks.go index b764cad..a20c78d 100644 --- a/internal/plugin/postgame_boss_hooks.go +++ b/internal/plugin/postgame_boss_hooks.go @@ -96,3 +96,75 @@ func greedTaxAttack(richness float64) int { func applyGreedTax(enemy *Combatant, run *DungeonRun) { enemy.Stats.Attack += greedTaxAttack(greedRouteRichness(run)) } + +// ── Phylactery Verses — Valdris, At Last (The Ossuary Ascendant) ──────────── +// +// The plan Valdris has been running since he "died" in the T1 Crypt: the +// phylactery shard players looted for years was bait, and he has rebuilt as a +// true lich. His rebirths are bound into three Verses hidden in the cathedral, +// each a NodeKindSecret behind a Perception gate. Every Verse a player finds and +// walks before the fight UNBINDS one rebirth; every Verse they skip leaves it +// armed. Full-clear explorers strip all three and fight a mortal lich; +// speedrunners who blow past the secrets fight a god who will not stay down. +// +// This is the mirror-image of the Greed Tax's design axis: the Tax punishes +// greedy exploration, the Verses reward thorough exploration. Both are prod +// player-agency levers the headless sim only samples at whatever route its +// autopilot happens to walk. +// +// Unlike the Greed Tax (a pure per-round Attack recompute), a rebirth is spent +// mid-fight, so it is stateful: seedBossRunStatuses freezes the charge count +// onto the session ONCE at fight start, and the turn engine round-trips the +// live count through CombatStatuses. It must NOT be re-derived on the per-round +// enemy rebuild, or spent rebirths would come back every round. +const ( + // phylacteryReviveFrac is the fraction of the boss's (party-scaled) max HP + // each unbound rebirth restores him to — a real second wind, not the 1-HP + // stay of survive_at_1. + phylacteryReviveFrac = 4 // 1/4 == 25% +) + +// phylacteryReviveCharges is the number of rebirths still armed on Valdris: one +// per zone Verse (NodeKindSecret) the run has NOT visited. The Ossuary's only +// secret nodes are the three Verses (the shared builder stamps none by default), +// so counting unvisited secrets is exactly "unbound rebirths". Zero for any +// non-Valdris boss or a nil run. A pure function of frozen run state. +func phylacteryReviveCharges(bossID string, run *DungeonRun) int { + if bossID != "boss_valdris_ascendant" || run == nil { + return 0 + } + g, ok := loadZoneGraph(run.ZoneID) + if !ok { + return 0 + } + visited := make(map[string]bool, len(run.VisitedNodes)) + for _, id := range run.VisitedNodes { + visited[id] = true + } + charges := 0 + for id, n := range g.Nodes { + if n.Kind == NodeKindSecret && !visited[id] { + charges++ + } + } + return charges +} + +// seedBossRunStatuses folds any ONCE-AT-FIGHT-START Layer-2 boss state into the +// freshly-created session, reading the run the player took to get here. It is +// the stateful counterpart to applyBossRunModifiers (which is a per-round pure +// recompute): whatever it seeds here is mutated by the fight and round-tripped, +// never re-derived. enemyMaxHP is the party-scaled pool already persisted onto +// the session. Returns whether it changed anything (so the caller can skip a +// redundant save). No-op — false — for every non-hooked boss. +func seedBossRunStatuses(sess *CombatSession, bossID string, enemyMaxHP int, run *DungeonRun) bool { + if sess == nil { + return false + } + if charges := phylacteryReviveCharges(bossID, run); charges > 0 { + sess.Statuses.EnemyReviveCharges = charges + sess.Statuses.EnemyReviveHP = max(1, enemyMaxHP/phylacteryReviveFrac) + return true + } + return false +} diff --git a/internal/plugin/postgame_boss_hooks_test.go b/internal/plugin/postgame_boss_hooks_test.go index db86a67..3ce2d06 100644 --- a/internal/plugin/postgame_boss_hooks_test.go +++ b/internal/plugin/postgame_boss_hooks_test.go @@ -86,6 +86,115 @@ func TestApplyBossRunModifiers_GreedTax(t *testing.T) { } } +func TestPhylacteryReviveCharges(t *testing.T) { + // The Ossuary's three Verses are its only secret nodes: f1b2, f2b2, cap32 + // (see zone_graph_ossuary_ascendant.go). Node ids are zone-prefixed. + const pre = "ossuary_ascendant." + + // Skip every Verse → all three rebirths stay armed (fight a god). + skip := &DungeonRun{ZoneID: ZoneOssuaryAscendant, VisitedNodes: []string{pre + "entry", pre + "p1", pre + "boss"}} + if got := phylacteryReviveCharges("boss_valdris_ascendant", skip); got != 3 { + t.Errorf("skip-route charges = %d, want 3", got) + } + + // Find one Verse → one rebirth unbound, two remain. + one := &DungeonRun{ZoneID: ZoneOssuaryAscendant, VisitedNodes: []string{pre + "entry", pre + "f1b2", pre + "boss"}} + if got := phylacteryReviveCharges("boss_valdris_ascendant", one); got != 2 { + t.Errorf("one-Verse charges = %d, want 2", got) + } + + // Full-clear explorer finds all three → 0 rebirths, a mortal lich. + full := &DungeonRun{ZoneID: ZoneOssuaryAscendant, VisitedNodes: []string{pre + "entry", pre + "f1b2", pre + "f2b2", pre + "cap32", pre + "boss"}} + if got := phylacteryReviveCharges("boss_valdris_ascendant", full); got != 0 { + t.Errorf("full-clear charges = %d, want 0", got) + } + + // Only Valdris carries the Verses; a nil run and any other boss are 0. + if got := phylacteryReviveCharges("boss_aurvandryx", skip); got != 0 { + t.Errorf("non-Valdris boss charges = %d, want 0", got) + } + if got := phylacteryReviveCharges("boss_valdris_ascendant", nil); got != 0 { + t.Errorf("nil-run charges = %d, want 0", got) + } +} + +func TestSeedBossRunStatuses_Phylactery(t *testing.T) { + const pre = "ossuary_ascendant." + skip := &DungeonRun{ZoneID: ZoneOssuaryAscendant, VisitedNodes: []string{pre + "entry", pre + "boss"}} // 3 unfound + + // A skip-route seeds all three rebirths and the 25%-of-max revive pool. + sess := &CombatSession{} + if !seedBossRunStatuses(sess, "boss_valdris_ascendant", 560, skip) { + t.Fatal("skip-route seed returned false, want true (charges seeded)") + } + if sess.Statuses.EnemyReviveCharges != 3 { + t.Errorf("seeded charges = %d, want 3", sess.Statuses.EnemyReviveCharges) + } + if sess.Statuses.EnemyReviveHP != 140 { // 560/4 + t.Errorf("seeded revive HP = %d, want 140", sess.Statuses.EnemyReviveHP) + } + + // A full-clear seeds nothing and reports no change. + full := &DungeonRun{ZoneID: ZoneOssuaryAscendant, VisitedNodes: []string{pre + "f1b2", pre + "f2b2", pre + "cap32"}} + clean := &CombatSession{} + if seedBossRunStatuses(clean, "boss_valdris_ascendant", 560, full) { + t.Error("full-clear seed returned true, want false (no rebirths)") + } + if clean.Statuses.EnemyReviveCharges != 0 { + t.Errorf("full-clear seeded charges = %d, want 0", clean.Statuses.EnemyReviveCharges) + } + + // Non-hooked boss: no-op even on a skip route. + other := &CombatSession{} + if seedBossRunStatuses(other, "boss_seamstress", 560, skip) { + t.Error("non-hooked boss seed returned true, want false") + } +} + +// TestEnemyDown_PhylacteryRebirth exercises the engine primitive: each seeded +// charge revives the boss to the revive pool once, and the fight ends only when +// the last charge is spent. +func TestEnemyDown_PhylacteryRebirth(t *testing.T) { + player := &Combatant{Name: "Hero", IsPlayer: true, Stats: CombatStats{MaxHP: 100, AC: 15, Attack: 10}} + seat0 := newActor(player) + st := &combatState{actor: seat0, actors: []*actor{seat0}, enemyReviveCharges: 2, enemyReviveHP: 140} + + // First lethal blow: a charge spends, boss revives to the pool, not down. + st.enemyHP = 0 + if enemyDown(st, "test") { + t.Fatal("first killing blow reported down, want rebirth") + } + if st.enemyHP != 140 || st.enemyReviveCharges != 1 { + t.Errorf("after 1st rebirth: HP=%d charges=%d, want 140/1", st.enemyHP, st.enemyReviveCharges) + } + + // Second lethal blow: last charge spends, revives again. + st.enemyHP = -5 + if enemyDown(st, "test") { + t.Fatal("second killing blow reported down, want rebirth") + } + if st.enemyHP != 140 || st.enemyReviveCharges != 0 { + t.Errorf("after 2nd rebirth: HP=%d charges=%d, want 140/0", st.enemyHP, st.enemyReviveCharges) + } + + // Third lethal blow: no charges left, the lich stays dead. + st.enemyHP = 0 + if !enemyDown(st, "test") { + t.Error("charge-less killing blow reported alive, want down") + } + + // A rebirth event was emitted per revival (two), for the narrator. + rebirths := 0 + for _, e := range st.events { + if e.Action == "phylactery_rebirth" { + rebirths++ + } + } + if rebirths != 2 { + t.Errorf("phylactery_rebirth events = %d, want 2", rebirths) + } +} + func approxEq(a, b float64) bool { d := a - b return d < 1e-9 && d > -1e-9