mirror of
https://github.com/prosolis/gogobee.git
synced 2026-07-15 08:32:41 +00:00
8fc5a82b83
Mischief Makers M1 — the core engine, Matrix-only. `!mischief send elite @user`
debits the buyer, tells the games room a hit is out, and an hour later a monster
from the target's own level bracket walks into whatever dungeon they're in.
Survive it and they keep a cut of the money and the buyer is named; don't, and
they wake up on a cart home.
The monster comes from the target's bracket zone pool, not the arena ladder and
not the dungeon they happen to be standing in — the same selection code the M0
pricing sweep ran through, so the fee table can't drift away from the fight it
priced.
Three things that are load-bearing and don't look it:
* Survival is read off the target's HP, not PlayerWon. The engine's timeout is
a retreat, not a lethal blow — somebody who ran out the clock with HP left
held the thing off, and a bought monster that merely outlasted them hasn't
earned a maiming.
* Nobody dies for money, and that includes the party. The delivery skips
closeOutZoneWin/Loss (the fight is extrinsic to the dungeon — crediting it
would let a buyer unlock the target's kill-gated resources for them), so
nothing else floors a downed seat. Without floorMischiefRoster on BOTH
outcomes, a member the leader outlived is left alive at 0 HP, which every
`HPCurrent <= 0` gate reads as broken rather than dead.
* One live contract per target is a partial UNIQUE INDEX, not a read-then-write
check. Placement holds only the *buyer's* lock, so two buyers racing at the
same victim would both pass an in-code test. The loser is refunded.
Payouts are a percentage of the base fee, never of what the buyer actually paid —
the sign surcharge is a pure sink. Capped at 75%, so a survival purse is always
strictly less than the outlay and collusion loses to !baltransfer, which is free.
That cap is the entire anti-collusion story; no danger multiplier needed.
A crash between claiming a contract and closing it out used to be unrecoverable
in the design: the row would strand, the target could never be targeted again,
and the buyer's money was gone. The stale sweep refunds those in full — that one
is our fault, not a bet they lost.
Contract timestamps bind as Go time.Time, never CURRENT_TIMESTAMP. The driver
stores RFC3339 and SQLite's own stamp is space-separated; the two compare
lexicographically wrong.
Pete learns four mischief_* event types in a separate commit, and has to deploy
BEFORE this does — an unknown event_type is a 400, which retries and then parks
the bulletin forever.
418 lines
13 KiB
Go
418 lines
13 KiB
Go
package plugin
|
||
|
||
import (
|
||
"testing"
|
||
"time"
|
||
|
||
"gogobee/internal/db"
|
||
|
||
"maunium.net/go/mautrix/id"
|
||
)
|
||
|
||
func newWorldBossTestDB(t *testing.T) {
|
||
t.Helper()
|
||
dir := t.TempDir()
|
||
db.Close()
|
||
if err := db.Init(dir); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
t.Cleanup(db.Close)
|
||
}
|
||
|
||
func TestWorldBossName_DeterministicAndInPool(t *testing.T) {
|
||
first := worldBossNameFor("2026-07")
|
||
if again := worldBossNameFor("2026-07"); again != first {
|
||
t.Errorf("name not deterministic: %q vs %q", first, again)
|
||
}
|
||
inPool := false
|
||
for _, n := range worldBossNames {
|
||
if n == first {
|
||
inPool = true
|
||
break
|
||
}
|
||
}
|
||
if !inPool {
|
||
t.Errorf("generated name %q not in worldBossNames pool", first)
|
||
}
|
||
}
|
||
|
||
func TestMedianInt(t *testing.T) {
|
||
cases := []struct {
|
||
in []int
|
||
want int
|
||
}{
|
||
{nil, 0},
|
||
{[]int{5}, 5},
|
||
{[]int{3, 1, 2}, 2}, // odd, unsorted
|
||
{[]int{4, 2, 8, 6}, 5}, // even → mean of the two middles (4,6)
|
||
{[]int{10, 10, 10, 10}, 10}, // even, all equal
|
||
}
|
||
for _, c := range cases {
|
||
if got := medianInt(c.in); got != c.want {
|
||
t.Errorf("medianInt(%v) = %d, want %d", c.in, got, c.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestTierForCombinedLevel(t *testing.T) {
|
||
cases := []struct{ level, want int }{
|
||
{0, worldBossMinTier},
|
||
{11, worldBossMinTier},
|
||
{12, 4},
|
||
{20, 4},
|
||
{21, 5},
|
||
{99, 5},
|
||
}
|
||
for _, c := range cases {
|
||
if got := tierForCombinedLevel(c.level); got != c.want {
|
||
t.Errorf("tierForCombinedLevel(%d) = %d, want %d", c.level, got, c.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestWorldBoss_InsertLoadRoundTrip(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
now := time.Now().UTC().Truncate(time.Second)
|
||
id0, err := insertWorldBoss("Gorloth", 5, 2400, now, now.Add(worldBossWindow))
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
active, err := loadActiveWorldBoss()
|
||
if err != nil || active == nil {
|
||
t.Fatalf("loadActiveWorldBoss: %v (nil=%v)", err, active == nil)
|
||
}
|
||
if active.ID != id0 || active.Name != "Gorloth" || active.Tier != 5 ||
|
||
active.HPMax != 2400 || active.HPCurrent != 2400 || active.Status != "active" {
|
||
t.Errorf("round-trip mismatch: %+v", active)
|
||
}
|
||
}
|
||
|
||
func TestApplyWorldBossDamage_ClampsAndFells(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
now := time.Now().UTC()
|
||
bossID, err := insertWorldBoss("Kravok", 3, 100, now, now.Add(worldBossWindow))
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
|
||
rem, killed, err := applyWorldBossDamage(bossID, 40)
|
||
if err != nil || rem != 60 || killed {
|
||
t.Fatalf("first hit: rem=%d killed=%v err=%v (want 60,false)", rem, killed, err)
|
||
}
|
||
|
||
// Overkill clamps at 0 and reports the fell.
|
||
rem, killed, err = applyWorldBossDamage(bossID, 999)
|
||
if err != nil || rem != 0 || !killed {
|
||
t.Fatalf("overkill: rem=%d killed=%v err=%v (want 0,true)", rem, killed, err)
|
||
}
|
||
|
||
// Negative damage is treated as zero.
|
||
if rem, _, err := applyWorldBossDamage(bossID, -5); err != nil || rem != 0 {
|
||
t.Fatalf("negative: rem=%d err=%v", rem, err)
|
||
}
|
||
}
|
||
|
||
func TestSetWorldBossStatus_ResolvesOnce(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
now := time.Now().UTC()
|
||
bossID, err := insertWorldBoss("Ymirok", 4, 500, now, now.Add(worldBossWindow))
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if ok, err := setWorldBossStatus(bossID, "defeated"); err != nil || !ok {
|
||
t.Fatalf("first close-out: ok=%v err=%v (want true)", ok, err)
|
||
}
|
||
// A second close-out is a no-op — the boss is no longer active.
|
||
if ok, err := setWorldBossStatus(bossID, "survived"); err != nil || ok {
|
||
t.Fatalf("double close-out: ok=%v err=%v (want false)", ok, err)
|
||
}
|
||
// And damage no longer lands on a resolved boss.
|
||
if rem, killed, _ := applyWorldBossDamage(bossID, 500); rem != 500 || killed {
|
||
t.Errorf("damage on resolved boss changed pool: rem=%d killed=%v", rem, killed)
|
||
}
|
||
}
|
||
|
||
func TestWorldBossContrib_UpsertAccumulates(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
user := id.UserID("@a:test.invalid")
|
||
if err := upsertWorldBossContrib(1, user, 30, "2026-07-01"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := upsertWorldBossContrib(1, user, 45, "2026-07-02"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
c, err := loadWorldBossContrib(1, user)
|
||
if err != nil || c == nil {
|
||
t.Fatalf("load: %v (nil=%v)", err, c == nil)
|
||
}
|
||
if c.Fights != 2 || c.Damage != 75 || c.LastFightDate != "2026-07-02" {
|
||
t.Errorf("accumulate mismatch: %+v", c)
|
||
}
|
||
}
|
||
|
||
func TestLoadWorldBossContribs_OrderedByFights(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
a := id.UserID("@a:test.invalid")
|
||
b := id.UserID("@b:test.invalid")
|
||
// a: 1 fight; b: 2 fights → b sorts first.
|
||
upsertWorldBossContrib(7, a, 100, "2026-07-01")
|
||
upsertWorldBossContrib(7, b, 10, "2026-07-01")
|
||
upsertWorldBossContrib(7, b, 10, "2026-07-02")
|
||
got, err := loadWorldBossContribs(7)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if len(got) != 2 || got[0].UserID != b || got[1].UserID != a {
|
||
t.Errorf("order = %+v, want b then a", got)
|
||
}
|
||
}
|
||
|
||
func TestComputeWorldBossPayouts_ScalesByFights(t *testing.T) {
|
||
contribs := []worldBossContrib{
|
||
{UserID: "@a:t", Fights: 3, Damage: 999},
|
||
{UserID: "@b:t", Fights: 1, Damage: 10},
|
||
{UserID: "@c:t", Fights: 0, Damage: 0}, // no fights → no payout
|
||
}
|
||
pays := computeWorldBossPayouts(contribs, 1000)
|
||
if len(pays) != 2 {
|
||
t.Fatalf("got %d payouts, want 2 (zero-fight excluded)", len(pays))
|
||
}
|
||
if pays[0].Euro != 3000 || pays[1].Euro != 1000 {
|
||
t.Errorf("payouts = %d,%d want 3000,1000", pays[0].Euro, pays[1].Euro)
|
||
}
|
||
}
|
||
|
||
// TestWorldBossSpawnPlan_SizesToActiveTown seeds three active max-level players
|
||
// and checks the boss is T5 with a pool scaled to the turnout.
|
||
func TestWorldBossSpawnPlan_SizesToActiveTown(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
today := time.Now().UTC().Format("2006-01-02")
|
||
for _, u := range []string{"@a:test.invalid", "@b:test.invalid", "@c:test.invalid"} {
|
||
c := &AdventureCharacter{UserID: id.UserID(u), DisplayName: "P", Alive: true,
|
||
ForagingSkill: 30, CreatedAt: time.Now().UTC()}
|
||
if err := saveAdvCharacter(c); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if _, err := db.Get().Exec(
|
||
`INSERT INTO daily_activity (user_id, date, message_count) VALUES (?, ?, 1)`,
|
||
u, today); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
tier, hpMax, activeN := worldBossSpawnPlan()
|
||
if activeN != 3 {
|
||
t.Errorf("activeN = %d, want 3", activeN)
|
||
}
|
||
if tier != 5 {
|
||
t.Errorf("tier = %d, want 5 (combined >= 21)", tier)
|
||
}
|
||
// bouts = 3 × 2.0 = 6; perBout at T5 = 400 → pool 2400.
|
||
perBout, _, _, _, _ := arenaTierBaseStats(5)
|
||
if want := perBout * 6; hpMax != want {
|
||
t.Errorf("hpMax = %d, want %d", hpMax, want)
|
||
}
|
||
}
|
||
|
||
// TestWorldBossSpawnPlan_EmptyTownGetsFloorBoss: no active players still yields a
|
||
// beatable floor boss so a manual spawn works.
|
||
func TestWorldBossSpawnPlan_EmptyTownGetsFloorBoss(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
tier, hpMax, activeN := worldBossSpawnPlan()
|
||
if activeN != 0 {
|
||
t.Errorf("activeN = %d, want 0", activeN)
|
||
}
|
||
if tier != worldBossMinTier {
|
||
t.Errorf("tier = %d, want floor %d", tier, worldBossMinTier)
|
||
}
|
||
perBout, _, _, _, _ := arenaTierBaseStats(worldBossMinTier)
|
||
if want := perBout * worldBossMinBouts; hpMax != want {
|
||
t.Errorf("hpMax = %d, want %d (min bouts floor)", hpMax, want)
|
||
}
|
||
}
|
||
|
||
func TestSpawnWorldBoss_RefusesWhenOneIsActive(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
p := &AdventurePlugin{}
|
||
first, err := p.spawnWorldBoss("2026-07")
|
||
if err != nil || first == nil {
|
||
t.Fatalf("first spawn: %v (nil=%v)", err, first == nil)
|
||
}
|
||
second, err := p.spawnWorldBoss("2026-07")
|
||
if err == nil {
|
||
t.Error("second spawn should refuse while one is active")
|
||
}
|
||
if second == nil || second.ID != first.ID {
|
||
t.Error("refusal should return the existing active boss")
|
||
}
|
||
}
|
||
|
||
// TestResolveWorldBossSurvived_DebitsPot exercises the survive path end to end:
|
||
// the boss closes out and the pot loses its tribute.
|
||
func TestResolveWorldBossSurvived_DebitsPot(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
communityPotAdd(1000)
|
||
now := time.Now().UTC()
|
||
bossID, err := insertWorldBoss("Vornath", 5, 2400, now.Add(-worldBossWindow), now.Add(-time.Hour))
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
boss, _ := loadWorldBoss(bossID)
|
||
p := &AdventurePlugin{}
|
||
p.resolveWorldBossSurvived(boss)
|
||
|
||
after, _ := loadWorldBoss(bossID)
|
||
if after.Status != "survived" {
|
||
t.Errorf("status = %q, want survived", after.Status)
|
||
}
|
||
// tribute = 20% of 1000 = 200 → pot left with 800.
|
||
if bal := communityPotBalance(); bal != 800 {
|
||
t.Errorf("pot = %d, want 800 after 20%% tribute", bal)
|
||
}
|
||
}
|
||
|
||
// ── W2: the bout ─────────────────────────────────────────────────────────────
|
||
|
||
func fightableChar(t *testing.T, uid id.UserID) {
|
||
t.Helper()
|
||
if err := createAdvCharacter(uid, "boxer"); err != nil {
|
||
t.Fatalf("createAdvCharacter: %v", err)
|
||
}
|
||
c := &DnDCharacter{
|
||
UserID: uid, Race: RaceHuman, Class: ClassFighter, Level: 12,
|
||
STR: 18, DEX: 14, CON: 16, INT: 10, WIS: 10, CHA: 10,
|
||
HPMax: 120, HPCurrent: 120, ArmorClass: 18,
|
||
}
|
||
if err := SaveDnDCharacter(c); err != nil {
|
||
t.Fatalf("SaveDnDCharacter: %v", err)
|
||
}
|
||
}
|
||
|
||
func TestWorldBossFloorHP(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
uid := id.UserID("@floor:test.invalid")
|
||
fightableChar(t, uid)
|
||
if floorHPAtOne(uid) {
|
||
t.Error("floor should be a no-op above 0 HP")
|
||
}
|
||
if _, err := db.Get().Exec(`UPDATE dnd_character SET hp_current = 0 WHERE user_id = ?`, string(uid)); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if !floorHPAtOne(uid) {
|
||
t.Error("floor should raise a 0-HP fighter")
|
||
}
|
||
if cur, _ := dndHPSnapshot(uid); cur != 1 {
|
||
t.Errorf("hp after floor = %d, want 1", cur)
|
||
}
|
||
}
|
||
|
||
func TestResolveWorldBossBout_SubtractsAndRecords(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
uid := id.UserID("@bout:test.invalid")
|
||
fightableChar(t, uid)
|
||
now := time.Now().UTC()
|
||
// Big pool so one bout can only chip it — assert the partial subtract + contrib.
|
||
bossID, err := insertWorldBoss("Kravok", 3, 100000, now, now.Add(worldBossWindow))
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
boss, _ := loadWorldBoss(bossID)
|
||
p := &AdventurePlugin{}
|
||
bout, err := p.resolveWorldBossBout(uid, boss, "2026-07-05")
|
||
if err != nil {
|
||
t.Fatalf("bout: %v", err)
|
||
}
|
||
if bout.Damage < 0 {
|
||
t.Errorf("damage negative: %d", bout.Damage)
|
||
}
|
||
if bout.Killed {
|
||
t.Error("a 100k pool should survive one bout")
|
||
}
|
||
if bout.Remaining != 100000-bout.Damage {
|
||
t.Errorf("remaining %d != max-dmg %d", bout.Remaining, 100000-bout.Damage)
|
||
}
|
||
c, _ := loadWorldBossContrib(bossID, uid)
|
||
if c == nil || c.Fights != 1 || c.Damage != bout.Damage || c.LastFightDate != "2026-07-05" {
|
||
t.Errorf("contrib mismatch: %+v (bout dmg %d)", c, bout.Damage)
|
||
}
|
||
if !worldBossBoutUsedToday(bossID, uid, "2026-07-05") {
|
||
t.Error("bout should read as used for that day")
|
||
}
|
||
if worldBossBoutUsedToday(bossID, uid, "2026-07-06") {
|
||
t.Error("a different day should still be available")
|
||
}
|
||
}
|
||
|
||
func TestResolveWorldBossBout_FellsTinyPool(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
uid := id.UserID("@kill:test.invalid")
|
||
fightableChar(t, uid)
|
||
now := time.Now().UTC()
|
||
bossID, err := insertWorldBoss("Wisp", 3, 1, now, now.Add(worldBossWindow))
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
boss, _ := loadWorldBoss(bossID)
|
||
p := &AdventurePlugin{}
|
||
bout, err := p.resolveWorldBossBout(uid, boss, "2026-07-05")
|
||
if err != nil {
|
||
t.Fatalf("bout: %v", err)
|
||
}
|
||
// A L12 fighter lands at least one blow on a T3 dummy over a full boss fight,
|
||
// felling a 1-HP pool.
|
||
if !bout.Killed || bout.Remaining != 0 {
|
||
t.Errorf("tiny pool not felled: killed=%v remaining=%d dmg=%d", bout.Killed, bout.Remaining, bout.Damage)
|
||
}
|
||
// Resolution is the caller's job — the bout leaves the boss active.
|
||
after, _ := loadWorldBoss(bossID)
|
||
if after.Status != "active" {
|
||
t.Errorf("bout should not self-resolve; status=%q", after.Status)
|
||
}
|
||
}
|
||
|
||
// TestWorldBossTick_ResolvesZeroHPBossAsDefeated: a killing blow that committed
|
||
// the pool to 0 but (crash/redeploy) never resolved the status must be resolved
|
||
// as DEFEATED by the ticker net — never fall through to the survive/pot-debit
|
||
// path. No contributors here, so resolution never touches euro.
|
||
func TestWorldBossTick_ResolvesZeroHPBossAsDefeated(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
now := time.Now().UTC()
|
||
communityPotAdd(1000)
|
||
bossID, err := insertWorldBoss("Ghost", 3, 100, now, now.Add(worldBossWindow))
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if _, err := db.Get().Exec(`UPDATE world_boss SET hp_current = 0 WHERE id = ?`, bossID); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
p := &AdventurePlugin{}
|
||
p.worldBossTick()
|
||
after, _ := loadWorldBoss(bossID)
|
||
if after.Status != "defeated" {
|
||
t.Errorf("status = %q, want defeated (ticker safety net)", after.Status)
|
||
}
|
||
if bal := communityPotBalance(); bal != 1000 {
|
||
t.Errorf("pot = %d, want 1000 — a defeat mints, it must not debit the pot", bal)
|
||
}
|
||
}
|
||
|
||
// TestWorldBossTick_ResolvesLapsedBossAsSurvived: a boss whose window lapsed with
|
||
// the pool still up survives and loots the pot.
|
||
func TestWorldBossTick_ResolvesLapsedBossAsSurvived(t *testing.T) {
|
||
newWorldBossTestDB(t)
|
||
now := time.Now().UTC()
|
||
communityPotAdd(1000)
|
||
bossID, err := insertWorldBoss("Titan", 4, 500, now.Add(-worldBossWindow), now.Add(-time.Minute))
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
p := &AdventurePlugin{}
|
||
p.worldBossTick()
|
||
after, _ := loadWorldBoss(bossID)
|
||
if after.Status != "survived" {
|
||
t.Errorf("status = %q, want survived", after.Status)
|
||
}
|
||
if bal := communityPotBalance(); bal != 800 {
|
||
t.Errorf("pot = %d, want 800 after 20%% tribute", bal)
|
||
}
|
||
}
|