+ {{range .PetRows}}
+ -
+
+ {{if .Name}}{{.Name}}{{else}}your {{.Type}}{{end}} {{.Type}}
+ lv {{.Level}}{{if .ArmorTier}} · barding T{{.ArmorTier}}{{end}}
+
+
+
+ {{if .Capped}}fully grown{{else}}{{.Progress}} to level {{.NextLevel}}{{end}}
+
{{end}}
diff --git a/internal/web/who.go b/internal/web/who.go
index ae45985..75a699b 100644
--- a/internal/web/who.go
+++ b/internal/web/who.go
@@ -5,6 +5,8 @@ import (
"fmt"
"log/slog"
"net/http"
+ "strconv"
+ "strings"
"time"
"pete/internal/storage"
@@ -34,6 +36,78 @@ type whoDetail struct {
ThreatLevel int `json:"threat_level"`
Room string `json:"room"`
Map *whoMap `json:"map"`
+ // Party is who else is down there, leader first. Absent on a solo run.
+ Party []partySeat `json:"party"`
+}
+
+// partySeat is one body on a shared expedition as gogobee described it. Kind is
+// "leader", "member" or "companion" — the game keeps those three carefully
+// distinct and so does this page: a companion fights but is nobody's account, so
+// he is named without a link and never counted as a player.
+//
+// A seat with a Kind but no Name is an opted-out player, kept on purpose. gogobee
+// anonymises rather than deletes here (the Siege contributor rule, not the realm
+// occupant rule), because a party of three rendered as a pair contradicts the
+// supply burn and threat level printed beside it. Render it as an unnamed seat;
+// never as an absent one, and never with a link.
+type partySeat struct {
+ Kind string `json:"kind"`
+ Name string `json:"name"`
+ Token string `json:"token"`
+ Level int `json:"level"`
+}
+
+// Anonymous reports whether this seat belongs to a player who has opted out of
+// the news. Keyed on the name rather than the token because the two come apart
+// only in the direction that matters: gogobee never sends a token without a name.
+func (p partySeat) Anonymous() bool { return p.Kind != "companion" && p.Name == "" }
+
+// petRow is one pet with its levelling made legible. gogobee sends centi-XP and
+// the engine's own threshold for the pet's current level band; the arithmetic
+// here is presentation only — a percentage for the bar and a decimal for the
+// label — and there is deliberately no copy of the curve on this side.
+type petRow struct {
+ storage.PetView
+ // Capped is the level ceiling: gogobee reports 0 needed, which is not the same
+ // as an empty bar and must not render as one.
+ Capped bool
+ // Percent is 0-100 for the bar's width. Clamped, because a pet can sit above
+ // its own threshold for the moment between earning XP and the next level-up
+ // pass, and a bar wider than its track breaks the layout rather than the maths.
+ Percent int
+ // Progress is the human label: "7.5 / 20".
+ Progress string
+ // NextLevel is what the bar is filling toward. 0 when capped.
+ NextLevel int
+}
+
+// petRows makes the pushed pets renderable. Pets are owner-only — the public
+// sheet has never carried them — so this runs behind the ownership join.
+func petRows(pets []storage.PetView) []petRow {
+ if len(pets) == 0 {
+ return nil
+ }
+ out := make([]petRow, 0, len(pets))
+ for _, p := range pets {
+ row := petRow{PetView: p, Capped: p.XPNeeded <= 0}
+ if !row.Capped {
+ row.Percent = min(100, max(0, p.XP*100/p.XPNeeded))
+ row.Progress = fmt.Sprintf("%s / %s", centiXP(p.XP), centiXP(p.XPNeeded))
+ row.NextLevel = p.Level + 1
+ }
+ out = append(out, row)
+ }
+ return out
+}
+
+// centiXP renders the game's hundredths as the number a player recognises. A pet
+// earns 1.5 XP per action, so the halves are real and dropping them would make a
+// bar that visibly moved report the same figure twice.
+func centiXP(centi int) string {
+ if centi%100 == 0 {
+ return strconv.Itoa(centi / 100)
+ }
+ return strings.TrimRight(strings.TrimRight(fmt.Sprintf("%.2f", float64(centi)/100), "0"), ".")
}
// whoMap is the fog-of-war zone graph as gogobee cut it: visited rooms with
@@ -95,6 +169,7 @@ type whoPage struct {
Worn []itemRow
Backpack []itemRow
VaultRows []itemRow
+ PetRows []petRow
BondsUsed int
// History. Unlike everything above, these are not a gogobee snapshot — they
// are counted from the facts Pete has been keeping since adventure_events
@@ -244,6 +319,7 @@ func (s *Server) handleAdventureWho(w http.ResponseWriter, r *http.Request) {
page.Worn = itemRows(self.Equipped, "worn")
page.Backpack = itemRows(self.Inventory, "backpack")
page.VaultRows = itemRows(self.Vault, "vault")
+ page.PetRows = petRows(self.Pets)
for _, it := range self.Equipped {
if it.Attuned {
page.BondsUsed++
diff --git a/internal/web/who_party_test.go b/internal/web/who_party_test.go
new file mode 100644
index 0000000..03ba6a3
--- /dev/null
+++ b/internal/web/who_party_test.go
@@ -0,0 +1,151 @@
+package web
+
+import (
+ "encoding/json"
+ "strings"
+ "testing"
+ "time"
+
+ "pete/internal/storage"
+)
+
+// The two W7 additions to the adventurer page: the party roster (public, rides
+// the roster detail) and pet levelling (owner-only, rides the self detail). Both
+// are driven through the real templates, so a field slip 500s here.
+
+// seedPartyWho puts Josie on the board mid-run with a three-seat party: her, a
+// named companion player, an opted-out player (anonymised upstream: kind but no
+// name), and the hireling.
+func seedPartyWho(t *testing.T) *Server {
+ s, _ := newAdvServer(t, "tok")
+ s.auth = &Authenticator{secret: []byte("test-secret-key-at-least-16")}
+
+ raw, err := json.Marshal(map[string]any{
+ "hp_current": 30,
+ "hp_max": 42,
+ "armor_class": 17,
+ "abilities": [6]int{16, 14, 15, 10, 12, 8},
+ "modifiers": [6]int{3, 2, 2, 0, 1, -1},
+ "supplies": 8,
+ "room": "3 / 7",
+ "party": []map[string]any{
+ {"kind": "leader", "name": "Josie", "token": "tok-josie", "level": 14},
+ {"kind": "member", "name": "Camcast", "token": "tok-cam", "level": 12},
+ {"kind": "member"}, // opted out: anonymised upstream
+ {"kind": "companion", "name": "Pete"},
+ },
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ e := entry("tok-josie", "Josie", "expedition", "holymachina")
+ e.Level = 14
+ e.ClassRace = "human cleric"
+ e.Detail = raw
+ if w := postRoster(t, s, "tok", rosterPush{
+ SnapshotAt: time.Now().Unix(), Adventurers: []storage.RosterEntry{e},
+ }); w.Code != 200 {
+ t.Fatalf("seed roster = %d", w.Code)
+ }
+ return s
+}
+
+// TestWhoDrawsThePartyWithoutNamingAnOptOut. The roster has to add up — a party
+// of four rendered as three contradicts the supply burn printed beside it — while
+// the seat belonging to a player who keeps out of the news carries no name and no
+// link out.
+func TestWhoDrawsThePartyWithoutNamingAnOptOut(t *testing.T) {
+ s := seedPartyWho(t)
+
+ w := getWho(t, s, "tok-josie", "")
+ if w.Code != 200 {
+ t.Fatalf("GET who = %d, want 200", w.Code)
+ }
+ body := w.Body.String()
+ for _, want := range []string{"Down there together", "Camcast", "Pete", "leader", "companion"} {
+ if !strings.Contains(body, want) {
+ t.Errorf("party block missing %q", want)
+ }
+ }
+ // Four seats drawn, not three.
+ if got := strings.Count(body, `class="party-seat"`); got != 4 {
+ t.Errorf("drew %d seats, want 4 — an anonymised seat must still occupy a chair", got)
+ }
+ if !strings.Contains(body, "keeps out of the news") {
+ t.Error("the anonymised seat rendered as nothing at all")
+ }
+ // The named member links to their own page; the hireling and the anonymous
+ // seat have nothing to link to.
+ if !strings.Contains(body, `/adventure/who/tok-cam`) {
+ t.Error("a named party member is not linked to their page")
+ }
+ // Exactly two seat links: the two seats carrying tokens. The hireling and the
+ // anonymised seat must be text, not doors. (Counted on the href so the page's
+ // own /api/adventure/who/ poll URL does not register as a link.)
+ if got := strings.Count(body, `href="/adventure/who/`); got != 2 {
+ t.Errorf("seat links = %d, want 2 — only a named seat may link out", got)
+ }
+}
+
+// TestSoloRunDrawsNoPartyBlock: the block is the answer to "is anybody else down
+// there", so on a solo run it must not appear at all rather than list one chair.
+func TestSoloRunDrawsNoPartyBlock(t *testing.T) {
+ s := seedWho(t, "josie") // no party in its detail blob
+
+ w := getWho(t, s, "tok-josie", "")
+ if w.Code != 200 {
+ t.Fatalf("GET who = %d", w.Code)
+ }
+ if strings.Contains(w.Body.String(), "Down there together") {
+ t.Error("a solo run drew a party block")
+ }
+}
+
+// TestPetLevellingIsVisibleToTheOwner. Pets have been earning XP from every won
+// fight since that wiring was fixed and no web surface has ever shown it. The
+// unit matters more than the bar: XP arrives as centi-XP, so a page that printed
+// it raw would tell somebody their cat has 750 of 20 points.
+func TestPetLevellingIsVisibleToTheOwner(t *testing.T) {
+ s, _ := newAdvServer(t, "tok")
+ s.auth = &Authenticator{secret: []byte("test-secret-key-at-least-16")}
+ now := time.Now().Unix()
+
+ e := entry("tok-josie", "Josie", "idle", "")
+ e.Detail = publicDetail(t)
+ if w := postRoster(t, s, "tok", rosterPush{SnapshotAt: now, Adventurers: []storage.RosterEntry{e}}); w.Code != 200 {
+ t.Fatalf("seed roster = %d", w.Code)
+ }
+ if w := postDetail(t, s, "tok", detailPush{SnapshotAt: now, Players: []storage.PlayerDetail{{
+ Localpart: "josie", Token: "tok-josie",
+ Pets: []storage.PetView{
+ {Type: "cat", Name: "Mittens", Level: 4, XP: 750, XPNeeded: 2000},
+ {Type: "dog", Name: "Rex", Level: 10}, // capped: nothing left to earn
+ },
+ }}}); w.Code != 200 {
+ t.Fatalf("seed detail = %d", w.Code)
+ }
+
+ body := getWho(t, s, "tok-josie", "josie").Body.String()
+ if !strings.Contains(body, "7.5 / 20 to level 5") {
+ t.Error("Mittens' progress is not rendered in whole XP — check the centi-XP divide")
+ }
+ if strings.Contains(body, "750") {
+ t.Error("raw centi-XP leaked onto the page")
+ }
+ if !strings.Contains(body, "fully grown") {
+ t.Error("a capped pet has no label saying why its bar is full")
+ }
+ if !strings.Contains(body, "pet-xp-capped") {
+ t.Error("a capped pet's bar is styled like an in-progress one")
+ }
+ // A capped pet must not render an empty track, which reads as the opposite of
+ // what it means.
+ if strings.Contains(body, `class="pet-xp-fill" style="width: 0%"`) {
+ t.Error("a capped pet drew an empty bar")
+ }
+
+ // And none of it leaks to a visitor: pets are owner-only.
+ if strings.Contains(getWho(t, s, "tok-josie", "").Body.String(), "Mittens") {
+ t.Error("a visitor can see the owner's pets")
+ }
+}