adventure: keep the facts, not just the sentence we made of them
gogobee already sends boss/opponent/zone/outcome/level on every dispatch. renderAdventure melted them into prose and only the prose was persisted, so "how many bosses has she downed" was answerable only by parsing English back out of a headline. adventure_events keeps the fact as fact. It's the one adventure table that's a log rather than a snapshot: the roster answers where Josie is now and is replaced every tick; this answers what she has ever done, which no snapshot can. INSERT OR IGNORE on the guid because gogobee retries a fact whose ack it lost, and this is the only adventure store where a duplicate is permanently wrong — the roster forgives one by replacing itself, a double-counted kill is in the tally forever. On top of it the who page grows two public sections, counted from dispatches that were already public: the record (tallies, per-boss and per-zone, realm firsts, milestones) and the trail (the last 40 facts, each linking to the dispatch that told it). One read feeds both — the pool is MaxOpenConns(1), so six COUNT queries would serialize for an answer that fits in memory. Only the trail is capped. A limit on the read would truncate a *tally* rather than a list, and a veteran's kill count frozen at 40 reads as a fact instead of a missing page. Only the subject of a fact earns a trophy: a duel you lost still names you, and it belongs on your trail but not in your record. Trophies count forward only. Every adventurer's past is prose in the feed and can't be counted back out, so they show no record until they next do something — a clean absence rather than a wall of zeroes. No treasures: there's no loot fact on the wire, and inventory is current-state with no history, so counting the vault would score a bought sword as a trophy. Needs a fact type upstream.
This commit is contained in:
prosolis
253
internal/storage/adventure.go
Normal file
253
internal/storage/adventure.go
Normal file
@@ -0,0 +1,253 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"sort"
|
||||
)
|
||||
|
||||
// The durable record of what has actually happened in the realm.
|
||||
//
|
||||
// Every other adventure table is a snapshot gogobee replaces wholesale. This one
|
||||
// accumulates, because the questions it answers are historical: what has this
|
||||
// adventurer killed, where have they been, how many times have they died. The
|
||||
// story feed technically holds the same information — but as English, inside a
|
||||
// headline, which you cannot count.
|
||||
//
|
||||
// Pete still computes nothing about the *game*. It only counts facts gogobee
|
||||
// already told it. No row here is ever authored by Pete or edited after insert.
|
||||
|
||||
// AdvEvent is one game fact, kept as fact rather than as the sentence it was
|
||||
// rendered into. Mirrors web.AdvFact minus the transport-only fields (no_push,
|
||||
// stakes, class_race) that describe delivery rather than the event.
|
||||
type AdvEvent struct {
|
||||
GUID string `json:"guid"`
|
||||
EventType string `json:"event_type"`
|
||||
Tier string `json:"tier"`
|
||||
Subject string `json:"subject"`
|
||||
Opponent string `json:"opponent"`
|
||||
Boss string `json:"boss"`
|
||||
Zone string `json:"zone"`
|
||||
Region string `json:"region"`
|
||||
Level int `json:"level"`
|
||||
Tally int `json:"tally"`
|
||||
Outcome string `json:"outcome"`
|
||||
Milestone string `json:"milestone"`
|
||||
Actors []string `json:"actors"`
|
||||
OccurredAt int64 `json:"occurred_at"`
|
||||
}
|
||||
|
||||
// InsertAdventureEvent records a fact. Idempotent on guid via INSERT OR IGNORE:
|
||||
// gogobee retries a fact whose ack it lost, and a retried siege must not add a
|
||||
// second kill to anybody's tally. The story insert upstream is guarded by
|
||||
// IsGUIDSeen for the same reason; this is the same guarantee enforced by the
|
||||
// table rather than by a check-then-act that a concurrent retry could race.
|
||||
func InsertAdventureEvent(e *AdvEvent) error {
|
||||
actors, err := json.Marshal(e.Actors)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = Get().Exec(`
|
||||
INSERT OR IGNORE INTO adventure_events
|
||||
(guid, event_type, tier, subject, opponent, boss, zone, region,
|
||||
level, tally, outcome, milestone, actors, occurred_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||||
e.GUID, e.EventType, e.Tier, e.Subject, e.Opponent, e.Boss, e.Zone,
|
||||
e.Region, e.Level, e.Tally, e.Outcome, e.Milestone, string(actors), e.OccurredAt)
|
||||
return err
|
||||
}
|
||||
|
||||
// BossTally is one monster and how many times this adventurer has put it down.
|
||||
type BossTally struct {
|
||||
Boss string `json:"boss"`
|
||||
Kills int `json:"kills"`
|
||||
First bool `json:"first"` // they were the first in the realm to ever clear it
|
||||
}
|
||||
|
||||
// ZoneTally is one zone and how many times this adventurer has cleared it.
|
||||
type ZoneTally struct {
|
||||
Zone string `json:"zone"`
|
||||
Region string `json:"region"`
|
||||
Clears int `json:"clears"`
|
||||
First bool `json:"first"`
|
||||
}
|
||||
|
||||
// TrophyCase is an adventurer's whole history, counted.
|
||||
//
|
||||
// Note what is *not* here: treasure. The event vocabulary gogobee sends has no
|
||||
// loot fact — items appear only in the owner-private inventory snapshot, which
|
||||
// is a current-state list with no history and no "found it in X on day 3". So
|
||||
// "treasures found" is not derivable from anything on the wire today; it needs a
|
||||
// new fact type upstream rather than a query here. Deliberately absent instead of
|
||||
// faked out of the vault contents, which would silently count a bought sword as
|
||||
// a trophy.
|
||||
type TrophyCase struct {
|
||||
Name string `json:"name"`
|
||||
Bosses []BossTally `json:"bosses,omitempty"`
|
||||
Zones []ZoneTally `json:"zones,omitempty"`
|
||||
BossKills int `json:"boss_kills"` // total, including firsts
|
||||
BossFirsts int `json:"boss_firsts"` // realm-firsts among them
|
||||
ZoneClears int `json:"zone_clears"`
|
||||
ZoneFirsts int `json:"zone_firsts"`
|
||||
Deaths int `json:"deaths"`
|
||||
Retreats int `json:"retreats"`
|
||||
RivalWins int `json:"rival_wins"`
|
||||
Milestones []string `json:"milestones,omitempty"`
|
||||
Survived int `json:"survived"` // mischief contracts walked away from
|
||||
Downed int `json:"downed"` // mischief contracts that landed
|
||||
Events int `json:"events"` // total facts on file
|
||||
FirstSeen int64 `json:"first_seen"`
|
||||
LastSeen int64 `json:"last_seen"`
|
||||
}
|
||||
|
||||
// EventsBySubject returns every fact about a character, newest first. This is the
|
||||
// timeline *and* the trophy source: one read, aggregated in Go, because the pool
|
||||
// is MaxOpenConns(1) and six COUNT queries against it would serialize behind each
|
||||
// other for an answer that fits comfortably in memory (a busy adventurer
|
||||
// accumulates tens of facts, not millions).
|
||||
//
|
||||
// limit <= 0 means no limit, and callers who count should use it. A limit here
|
||||
// silently truncates a *tally*, not just a list: read 40 facts for a display cap
|
||||
// and a veteran's kill count quietly stops at 40 and stays wrong forever. Cap the
|
||||
// trail in the caller, after the counting is done.
|
||||
//
|
||||
// Facts where the character is the *opponent* are included: a duel they lost is
|
||||
// part of their history, and only the subject field would otherwise carry it.
|
||||
func EventsBySubject(name string, limit int) ([]AdvEvent, error) {
|
||||
if name == "" {
|
||||
return nil, nil
|
||||
}
|
||||
q := `
|
||||
SELECT guid, event_type, tier, subject, opponent, boss, zone, region,
|
||||
level, tally, outcome, milestone, actors, occurred_at
|
||||
FROM adventure_events
|
||||
WHERE subject = ? OR opponent = ?
|
||||
ORDER BY occurred_at DESC`
|
||||
args := []any{name, name}
|
||||
if limit > 0 {
|
||||
q += ` LIMIT ?`
|
||||
args = append(args, limit)
|
||||
}
|
||||
rows, err := Get().Query(q, args...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var out []AdvEvent
|
||||
for rows.Next() {
|
||||
var e AdvEvent
|
||||
var tier, subject, opponent, boss, zone, region, outcome, milestone, actors sql.NullString
|
||||
if err := rows.Scan(&e.GUID, &e.EventType, &tier, &subject, &opponent,
|
||||
&boss, &zone, ®ion, &e.Level, &e.Tally, &outcome, &milestone,
|
||||
&actors, &e.OccurredAt); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
e.Tier, e.Subject, e.Opponent = tier.String, subject.String, opponent.String
|
||||
e.Boss, e.Zone, e.Region = boss.String, zone.String, region.String
|
||||
e.Outcome, e.Milestone = outcome.String, milestone.String
|
||||
if actors.String != "" {
|
||||
_ = json.Unmarshal([]byte(actors.String), &e.Actors)
|
||||
}
|
||||
out = append(out, e)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// BuildTrophyCase counts a character's history out of their facts. Pure: it takes
|
||||
// the rows EventsBySubject already read rather than querying again, so the who
|
||||
// page pays for one database read and gets both the timeline and the trophies.
|
||||
//
|
||||
// Only facts where the character is the *subject* count toward trophies. They
|
||||
// appear in an ally's dispatch as an opponent too, and crediting those would let
|
||||
// a duel someone lost show up as a kill in their own case.
|
||||
func BuildTrophyCase(name string, events []AdvEvent) TrophyCase {
|
||||
tc := TrophyCase{Name: name}
|
||||
bosses := map[string]*BossTally{}
|
||||
zones := map[string]*ZoneTally{}
|
||||
|
||||
for _, e := range events {
|
||||
if tc.LastSeen == 0 || e.OccurredAt > tc.LastSeen {
|
||||
tc.LastSeen = e.OccurredAt
|
||||
}
|
||||
if tc.FirstSeen == 0 || e.OccurredAt < tc.FirstSeen {
|
||||
tc.FirstSeen = e.OccurredAt
|
||||
}
|
||||
tc.Events++
|
||||
|
||||
if e.Subject != name {
|
||||
continue // they're the other party in someone else's dispatch
|
||||
}
|
||||
switch e.EventType {
|
||||
case "boss_kill", "boss_first":
|
||||
tc.BossKills++
|
||||
if e.Boss != "" {
|
||||
b := bosses[e.Boss]
|
||||
if b == nil {
|
||||
b = &BossTally{Boss: e.Boss}
|
||||
bosses[e.Boss] = b
|
||||
}
|
||||
b.Kills++
|
||||
if e.EventType == "boss_first" {
|
||||
b.First = true
|
||||
}
|
||||
}
|
||||
if e.EventType == "boss_first" {
|
||||
tc.BossFirsts++
|
||||
}
|
||||
case "zone_clear", "zone_first":
|
||||
tc.ZoneClears++
|
||||
if e.Zone != "" {
|
||||
z := zones[e.Zone]
|
||||
if z == nil {
|
||||
z = &ZoneTally{Zone: e.Zone, Region: e.Region}
|
||||
zones[e.Zone] = z
|
||||
}
|
||||
z.Clears++
|
||||
if e.EventType == "zone_first" {
|
||||
z.First = true
|
||||
}
|
||||
}
|
||||
if e.EventType == "zone_first" {
|
||||
tc.ZoneFirsts++
|
||||
}
|
||||
case "death":
|
||||
tc.Deaths++
|
||||
case "retreat":
|
||||
tc.Retreats++
|
||||
case "rival_result":
|
||||
tc.RivalWins++ // the fact's subject is the winner; see renderAdventure
|
||||
case "milestone":
|
||||
if e.Milestone != "" {
|
||||
tc.Milestones = append(tc.Milestones, e.Milestone)
|
||||
}
|
||||
case "mischief_survived":
|
||||
tc.Survived++
|
||||
case "mischief_downed":
|
||||
tc.Downed++
|
||||
}
|
||||
}
|
||||
|
||||
for _, b := range bosses {
|
||||
tc.Bosses = append(tc.Bosses, *b)
|
||||
}
|
||||
for _, z := range zones {
|
||||
tc.Zones = append(tc.Zones, *z)
|
||||
}
|
||||
// Deterministic order: most-fought first, then alphabetical. The tiebreak is
|
||||
// not cosmetic — map iteration is randomized in Go, so without it the panel
|
||||
// reshuffles on every request and a cached page and a live one disagree.
|
||||
sort.Slice(tc.Bosses, func(i, j int) bool {
|
||||
if tc.Bosses[i].Kills != tc.Bosses[j].Kills {
|
||||
return tc.Bosses[i].Kills > tc.Bosses[j].Kills
|
||||
}
|
||||
return tc.Bosses[i].Boss < tc.Bosses[j].Boss
|
||||
})
|
||||
sort.Slice(tc.Zones, func(i, j int) bool {
|
||||
if tc.Zones[i].Clears != tc.Zones[j].Clears {
|
||||
return tc.Zones[i].Clears > tc.Zones[j].Clears
|
||||
}
|
||||
return tc.Zones[i].Zone < tc.Zones[j].Zone
|
||||
})
|
||||
return tc
|
||||
}
|
||||
120
internal/storage/adventure_test.go
Normal file
120
internal/storage/adventure_test.go
Normal file
@@ -0,0 +1,120 @@
|
||||
package storage
|
||||
|
||||
import "testing"
|
||||
|
||||
// adventure_events is the only adventure store that accumulates, so it is the
|
||||
// only one where a duplicate delivery is permanently wrong: the roster forgives
|
||||
// a double push by replacing itself, a double-counted boss kill is in the tally
|
||||
// forever. These tests pin that, and pin what the trophy case will and won't
|
||||
// credit an adventurer for.
|
||||
|
||||
func ev(guid, typ, subject string, at int64) *AdvEvent {
|
||||
return &AdvEvent{GUID: guid, EventType: typ, Subject: subject, OccurredAt: at}
|
||||
}
|
||||
|
||||
// TestInsertAdventureEventIdempotent: gogobee retries a fact whose ack it lost.
|
||||
// The retry must be a no-op, not a second kill.
|
||||
func TestInsertAdventureEventIdempotent(t *testing.T) {
|
||||
setupTestDB(t)
|
||||
e := ev("boss_kill:abc:1", "boss_kill", "Josie", 1000)
|
||||
e.Boss = "The Rotmother"
|
||||
|
||||
for i := 0; i < 3; i++ {
|
||||
if err := InsertAdventureEvent(e); err != nil {
|
||||
t.Fatalf("insert %d: %v", i, err)
|
||||
}
|
||||
}
|
||||
events, err := EventsBySubject("Josie", 0)
|
||||
if err != nil {
|
||||
t.Fatalf("EventsBySubject: %v", err)
|
||||
}
|
||||
if len(events) != 1 {
|
||||
t.Fatalf("after 3 deliveries of one fact: got %d rows, want 1", len(events))
|
||||
}
|
||||
if tc := BuildTrophyCase("Josie", events); tc.BossKills != 1 {
|
||||
t.Fatalf("boss kills: got %d, want 1 — a retry inflated the tally", tc.BossKills)
|
||||
}
|
||||
}
|
||||
|
||||
// TestTrophyCaseCounts walks a full history and checks each tally.
|
||||
func TestTrophyCaseCounts(t *testing.T) {
|
||||
setupTestDB(t)
|
||||
|
||||
first := ev("boss_first:1:1", "boss_first", "Josie", 100)
|
||||
first.Boss = "The Rotmother"
|
||||
repeat := ev("boss_kill:2:2", "boss_kill", "Josie", 200)
|
||||
repeat.Boss = "The Rotmother"
|
||||
other := ev("boss_kill:3:3", "boss_kill", "Josie", 300)
|
||||
other.Boss = "Gravebloom"
|
||||
zone := ev("zone_clear:4:4", "zone_clear", "Josie", 400)
|
||||
zone.Zone, zone.Region = "holymachina", "the Reach"
|
||||
death := ev("death:5:5", "death", "Josie", 500)
|
||||
mile := ev("milestone:6:6", "milestone", "Josie", 600)
|
||||
mile.Milestone = "level 20"
|
||||
|
||||
for _, e := range []*AdvEvent{first, repeat, other, zone, death, mile} {
|
||||
if err := InsertAdventureEvent(e); err != nil {
|
||||
t.Fatalf("insert %s: %v", e.GUID, err)
|
||||
}
|
||||
}
|
||||
|
||||
events, err := EventsBySubject("Josie", 0)
|
||||
if err != nil {
|
||||
t.Fatalf("EventsBySubject: %v", err)
|
||||
}
|
||||
tc := BuildTrophyCase("Josie", events)
|
||||
|
||||
if tc.BossKills != 3 {
|
||||
t.Errorf("boss kills: got %d, want 3 (a first is still a kill)", tc.BossKills)
|
||||
}
|
||||
if tc.BossFirsts != 1 {
|
||||
t.Errorf("boss firsts: got %d, want 1", tc.BossFirsts)
|
||||
}
|
||||
if tc.ZoneClears != 1 || tc.Deaths != 1 {
|
||||
t.Errorf("zones/deaths: got %d/%d, want 1/1", tc.ZoneClears, tc.Deaths)
|
||||
}
|
||||
if len(tc.Milestones) != 1 || tc.Milestones[0] != "level 20" {
|
||||
t.Errorf("milestones: got %v, want [level 20]", tc.Milestones)
|
||||
}
|
||||
// Ordering is by kills desc: the twice-killed Rotmother outranks Gravebloom.
|
||||
if len(tc.Bosses) != 2 || tc.Bosses[0].Boss != "The Rotmother" || tc.Bosses[0].Kills != 2 {
|
||||
t.Fatalf("boss tallies: got %+v, want Rotmother×2 first", tc.Bosses)
|
||||
}
|
||||
if !tc.Bosses[0].First {
|
||||
t.Error("Rotmother should be flagged as a realm-first")
|
||||
}
|
||||
if tc.FirstSeen != 100 || tc.LastSeen != 600 {
|
||||
t.Errorf("span: got %d..%d, want 100..600", tc.FirstSeen, tc.LastSeen)
|
||||
}
|
||||
}
|
||||
|
||||
// TestTrophyCaseIgnoresOpponentCredit is the one that matters for honesty. A
|
||||
// duel Josie *lost* still names her, as the opponent in Quack's dispatch. It
|
||||
// belongs on her timeline but must never be credited to her trophy case.
|
||||
func TestTrophyCaseIgnoresOpponentCredit(t *testing.T) {
|
||||
setupTestDB(t)
|
||||
|
||||
lost := ev("rival_result:1:1", "rival_result", "Quack", 100)
|
||||
lost.Opponent = "Josie" // Quack won; Josie is the one who got beaten
|
||||
won := ev("rival_result:2:2", "rival_result", "Josie", 200)
|
||||
won.Opponent = "Quack"
|
||||
|
||||
for _, e := range []*AdvEvent{lost, won} {
|
||||
if err := InsertAdventureEvent(e); err != nil {
|
||||
t.Fatalf("insert: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
events, err := EventsBySubject("Josie", 0)
|
||||
if err != nil {
|
||||
t.Fatalf("EventsBySubject: %v", err)
|
||||
}
|
||||
// Both facts are hers to *see* — the loss is part of her story.
|
||||
if len(events) != 2 {
|
||||
t.Fatalf("timeline: got %d events, want 2 (a loss is still history)", len(events))
|
||||
}
|
||||
// But only the one she won is hers to *claim*.
|
||||
if tc := BuildTrophyCase("Josie", events); tc.RivalWins != 1 {
|
||||
t.Fatalf("rival wins: got %d, want 1 — a loss was credited as a win", tc.RivalWins)
|
||||
}
|
||||
}
|
||||
@@ -52,6 +52,46 @@ CREATE TABLE IF NOT EXISTS adventure_roster_meta (
|
||||
snapshot_at INTEGER NOT NULL DEFAULT 0
|
||||
);
|
||||
|
||||
-- adventure_events is the structured residue of a dispatch, and it is the one
|
||||
-- adventure table that is a *log* rather than a snapshot. That inversion is the
|
||||
-- point. The roster answers "where is Josie now" and is replaced every tick;
|
||||
-- this answers "what has Josie ever done", which no snapshot can, because each
|
||||
-- push throws the last one away.
|
||||
--
|
||||
-- It exists because the facts were already arriving and we were burning them.
|
||||
-- gogobee sends boss/opponent/zone/outcome on every fact; renderAdventure melted
|
||||
-- them into a sentence and only the sentence was kept, so "how many bosses has
|
||||
-- she downed" was answerable only by parsing English back out of a headline.
|
||||
-- These rows are that fact, kept as fact. The story row remains the thing people
|
||||
-- read; this is the thing we can count.
|
||||
--
|
||||
-- Keyed on guid, the same idempotency key as stories: a gogobee retry must not
|
||||
-- double-count a kill. subject/opponent are *character names*, not roster tokens,
|
||||
-- because that is what a fact carries and what the feed already prints in public.
|
||||
-- Names are therefore the join back to a board row (roster.name -> token), which
|
||||
-- is weaker than an id: a renamed or recycled character takes their history with
|
||||
-- them. gogobee doesn't put a stable character id on the wire today, and inventing
|
||||
-- one Pete-side would only be a guess at which two names were the same person.
|
||||
CREATE TABLE IF NOT EXISTS adventure_events (
|
||||
guid TEXT PRIMARY KEY, -- == stories.guid; the dispatch this fact rendered into
|
||||
event_type TEXT NOT NULL,
|
||||
tier TEXT, -- "priority" | "bulletin"
|
||||
subject TEXT, -- character name: the one it happened to
|
||||
opponent TEXT, -- character name: the other player, when there is one
|
||||
boss TEXT, -- game-authored monster name, not player-controlled
|
||||
zone TEXT,
|
||||
region TEXT,
|
||||
level INTEGER NOT NULL DEFAULT 0,
|
||||
tally INTEGER NOT NULL DEFAULT 0, -- the fact's Count: defenders, days in, ...
|
||||
outcome TEXT,
|
||||
milestone TEXT,
|
||||
actors TEXT, -- JSON array; the fact-guard allow-list, kept for audit
|
||||
occurred_at INTEGER NOT NULL
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_adv_events_subject ON adventure_events(subject, occurred_at DESC);
|
||||
CREATE INDEX IF NOT EXISTS idx_adv_events_opponent ON adventure_events(opponent, occurred_at DESC) WHERE opponent IS NOT NULL AND opponent <> '';
|
||||
CREATE INDEX IF NOT EXISTS idx_adv_events_type ON adventure_events(event_type, occurred_at DESC);
|
||||
|
||||
-- A signed-in buyer's own euro balance, as of the last snapshot gogobee pushed.
|
||||
-- Keyed by localpart (== Authentik preferred_username == the session's Username),
|
||||
-- a *separate keyspace* from the anonymous roster tokens on purpose: it is only
|
||||
|
||||
Reference in New Issue
Block a user