Merge pull request #44 from IamMrCupp/feat/rpg-quests-timed

feat(idlerpg): timed quests (parity #7)

Author: IamMrCupp

cmd/annoybot/main.go

@@ -92,7 +92,8 @@ func main() {
 	// IdleRPG — off by default; persists to the shared state store, keyed by account.
 	var rpgMgr *idlerpg.Manager
 	if cfg.IdleRPG.Enabled {
-		rpgMgr = idlerpg.New(store, router, acctMgr.Resolve, cfg.IdleRPG.Interval.D(), cfg.IdleRPG.BaseTTL.D(), log)
+		rpgMgr = idlerpg.New(store, router, acctMgr.Resolve, cfg.IdleRPG.Interval.D(), cfg.IdleRPG.BaseTTL.D(),
+			cfg.IdleRPG.QuestInterval.D(), cfg.IdleRPG.QuestDuration.D(), log)
 	}
 
 	// Optional inter-bot bus + skit coordinator (the "botnet").

internal/config/config.go

@@ -39,6 +39,12 @@ type IdleRPG struct {
 	Enabled  bool            `yaml:"enabled"`
 	Interval engine.Duration `yaml:"interval"`
 	BaseTTL  engine.Duration `yaml:"base_ttl"`
+
+	// Quests (idlerpg.net-style). The gods periodically draft idle players onto a
+	// timed quest; finishing it (without anyone talking/leaving) speeds everyone's
+	// clock, breaking it shoves them back. Zero values fall back to sane defaults.
+	QuestInterval engine.Duration `yaml:"quest_interval"` // avg time between quests (default 6h)
+	QuestDuration engine.Duration `yaml:"quest_duration"` // how long a quest runs (default 1h)
 }
 
 // ChanKeep configures eggdrop-style channel keeping (IRC only). Off by default:

internal/idlerpg/idlerpg.go

@@ -53,31 +53,49 @@ type Manager struct {
 	interval time.Duration
 	baseTTL  time.Duration
 
+	questInterval time.Duration
+	questDuration time.Duration
+	now           func() time.Time // injectable clock (quest deadlines); time.Now in prod
+
 	mu     sync.Mutex
 	online map[string]player // network|nick -> online player
 
+	qmu   sync.Mutex
+	quest *quest // the active quest, nil when none
+
 	rmu sync.Mutex
 	rng *rand.Rand
 }
 
 // New builds a Manager. interval is the tick period; baseTTL is the level 0→1 time.
+// questInterval/questDuration tune the quest cadence (zero → sane defaults).
 // resolve maps senders to canonical player keys (cross-network when linked).
-func New(store state.Store, out engine.Sender, resolve Resolver, interval, baseTTL time.Duration, log *slog.Logger) *Manager {
+func New(store state.Store, out engine.Sender, resolve Resolver, interval, baseTTL, questInterval, questDuration time.Duration, log *slog.Logger) *Manager {
 	if interval <= 0 {
 		interval = 30 * time.Second
 	}
 	if baseTTL <= 0 {
 		baseTTL = 10 * time.Minute
 	}
+	if questInterval <= 0 {
+		questInterval = defaultQuestInterval
+	}
+	if questDuration <= 0 {
+		questDuration = defaultQuestDuration
+	}
 	if resolve == nil {
 		resolve = func(network, _, nick string) string { return strings.ToLower(network) + "|" + strings.ToLower(nick) }
 	}
-	return &Manager{
+	m := &Manager{
 		store: store, out: out, resolve: resolve, log: log,
 		interval: interval, baseTTL: baseTTL,
+		questInterval: questInterval, questDuration: questDuration,
+		now:    time.Now,
 		online: map[string]player{},
 		rng:    rand.New(rand.NewSource(time.Now().UnixNano())),
 	}
+	m.loadQuest(context.Background())
+	return m
 }
 
 // roll returns a value in [0,n). Guarded so battles/events can roll concurrently.
@@ -111,13 +129,15 @@ func (m *Manager) Handle(msg engine.Message) bool {
 		m.command(msg, fields)
 		return true
 	}
-	// Talking is the cardinal sin — penalize online players.
+	// Talking is the cardinal sin — penalize online players, and if they're on a
+	// quest, talking blows the whole quest.
 	if p, ok := m.onlinePlayer(msg.Network, msg.Nick); ok {
 		pen := int64(len(msg.Text))
 		if pen > talkCapSec {
 			pen = talkCapSec
 		}
 		_, _ = m.store.HIncr(context.Background(), sheetKey(p.key), "ttl", pen)
+		m.questViolation(context.Background(), p.key, p.nick, "spoke up")
 	}
 	return false
 }
@@ -302,34 +322,46 @@ func (m *Manager) penalizeOnline(network, nick string, secs int64) {
 	}
 }
 
-// OnPart / OnQuit / OnKick penalize then take the player offline.
+// OnPart / OnQuit / OnKick penalize, break any quest they were on, then take the
+// player offline.
 func (m *Manager) OnPart(ev event.Event) {
 	if ev.Kind == event.Part {
 		m.penalizeOnline(ev.Network, ev.Nick, partPenalty)
+		m.failQuestBy(ev.Network, ev.Nick, "abandoned the party")
 		m.OnLeave(ev)
 	}
 }
 
 func (m *Manager) OnQuit(ev event.Event) {
 	if ev.Kind == event.Quit {
 		m.penalizeOnline(ev.Network, ev.Nick, quitPenalty)
+		m.failQuestBy(ev.Network, ev.Nick, "vanished from the realm")
 		m.OnLeave(ev)
 	}
 }
 
 func (m *Manager) OnKick(ev event.Event) {
 	if ev.Kind == event.Kick {
 		m.penalizeOnline(ev.Network, ev.Nick, kickPenalty)
+		m.failQuestBy(ev.Network, ev.Nick, "was hurled from the channel")
 		m.OnLeave(ev)
 	}
 }
 
-// OnNick penalizes a nick change and follows the player to their new nick.
+// failQuestBy ruins the active quest if (network, nick) resolves to a quester.
+func (m *Manager) failQuestBy(network, nick, reason string) {
+	key := m.resolve(network, "", nick)
+	m.questViolation(context.Background(), key, nick, reason)
+}
+
+// OnNick penalizes a nick change, breaks any quest, and follows the player to
+// their new nick.
 func (m *Manager) OnNick(ev event.Event) {
 	if ev.Kind != event.Nick {
 		return
 	}
 	m.penalizeOnline(ev.Network, ev.Nick, nickPenalty)
+	m.failQuestBy(ev.Network, ev.Nick, "slipped away under a new name")
 	m.mu.Lock()
 	if p, ok := m.online[okey(ev.Network, ev.Nick)]; ok {
 		delete(m.online, okey(ev.Network, ev.Nick))
@@ -353,6 +385,7 @@ func (m *Manager) Tick() {
 		step = 1
 	}
 	m.maybeEvent(context.Background())
+	m.questTick(context.Background())
 	for _, p := range m.snapshot() {
 		ctx := context.Background()
 		key := sheetKey(p.key)

internal/idlerpg/idlerpg_test.go

@@ -42,7 +42,8 @@ func newMgr() (*Manager, *recorder, state.Store) {
 	st := state.NewMem()
 	log := slog.New(slog.NewTextHandler(io.Discard, nil))
 	// 1s tick, 1s base ttl → one quiet tick levels you up. nil resolver = key by network|nick.
-	m := New(st, r, nil, time.Second, time.Second, log)
+	// Long quest interval so quests never start unless a test forces one.
+	m := New(st, r, nil, time.Second, time.Second, time.Hour, time.Hour, log)
 	m.rng = rand.New(rand.NewSource(1)) // deterministic for item rolls
 	return m, r, st
 }
@@ -285,6 +286,116 @@ func TestPresenceIgnoresUnenrolled(t *testing.T) {
 	}
 }
 
+// enrollOnline enrolls a player and leaves them online (via the !rpg path).
+func enrollOnline(m *Manager, nick string) { m.Handle(chanMsg(nick, "!rpg")) }
+
+func TestQuestStartAndComplete(t *testing.T) {
+	m, r, st := newMgr()
+	ctx := context.Background()
+	base := time.Unix(1000, 0)
+	m.now = func() time.Time { return base }
+	enrollOnline(m, "alice")
+	enrollOnline(m, "bob")
+
+	m.startQuest(ctx)
+	if m.quest == nil {
+		t.Fatal("a quest should have started with two idlers online")
+	}
+	if !r.has("a quest begins") {
+		t.Fatalf("expected quest announcement, got %v", r.lines)
+	}
+	st.HSet(ctx, sheetKey("net|alice"), "ttl", 1000)
+	st.HSet(ctx, sheetKey("net|bob"), "ttl", 1000)
+
+	// Roll the clock past the deadline; the tick completes the quest.
+	m.now = func() time.Time { return base.Add(2 * time.Hour) }
+	m.questTick(ctx)
+	if m.quest != nil {
+		t.Fatal("quest should be cleared after completion")
+	}
+	if !r.has("quest is complete") {
+		t.Fatalf("expected completion announcement, got %v", r.lines)
+	}
+	if s, _ := st.HGetAll(ctx, sheetKey("net|alice")); s["ttl"] >= 1000 {
+		t.Fatalf("completing a quest should lower ttl, got %d", s["ttl"])
+	}
+}
+
+func TestQuestFailsOnTalk(t *testing.T) {
+	m, r, st := newMgr()
+	ctx := context.Background()
+	enrollOnline(m, "alice")
+	enrollOnline(m, "bob")
+	m.startQuest(ctx)
+	st.HSet(ctx, sheetKey("net|bob"), "ttl", 1000)
+
+	if m.Handle(chanMsg("alice", "oops I talked")) {
+		t.Fatal("chatter is not a consumed command")
+	}
+	if m.quest != nil {
+		t.Fatal("talking during a quest must ruin it")
+	}
+	if !r.has("quest is RUINED") {
+		t.Fatalf("expected ruin announcement, got %v", r.lines)
+	}
+	// The silent partner still eats the party-wide penalty.
+	if s, _ := st.HGetAll(ctx, sheetKey("net|bob")); s["ttl"] <= 1000 {
+		t.Fatalf("a ruined quest should push the whole party back, bob ttl=%d", s["ttl"])
+	}
+}
+
+func TestQuestFailsOnPart(t *testing.T) {
+	m, _, _ := newMgr()
+	ctx := context.Background()
+	enrollOnline(m, "alice")
+	enrollOnline(m, "bob")
+	m.startQuest(ctx)
+	m.OnPart(event.Event{Kind: event.Part, Network: "net", Nick: "alice"})
+	if m.quest != nil {
+		t.Fatal("a quester parting must ruin the quest")
+	}
+}
+
+func TestQuestNeedsAParty(t *testing.T) {
+	m, _, _ := newMgr()
+	enrollOnline(m, "alice") // only one idler online
+	m.startQuest(context.Background())
+	if m.quest != nil {
+		t.Fatal("a quest should not start with fewer than two idlers")
+	}
+}
+
+func TestQuestTickStartsOnOdds(t *testing.T) {
+	m, _, _ := newMgr()
+	m.questInterval = m.interval // denom == 1 → a start is attempted every tick
+	enrollOnline(m, "alice")
+	enrollOnline(m, "bob")
+	m.questTick(context.Background())
+	if m.quest == nil {
+		t.Fatal("questTick should start a quest when the odds guarantee it")
+	}
+}
+
+func TestQuestRehydratesAcrossRestart(t *testing.T) {
+	m1, _, st := newMgr()
+	ctx := context.Background()
+	enrollOnline(m1, "alice")
+	enrollOnline(m1, "bob")
+	m1.startQuest(ctx)
+	if m1.quest == nil {
+		t.Fatal("setup: quest should be active")
+	}
+	// A fresh manager on the same store must recover the in-flight quest.
+	log := slog.New(slog.NewTextHandler(io.Discard, nil))
+	m2 := New(st, &recorder{}, nil, time.Second, time.Second, time.Hour, time.Hour, log)
+	if m2.quest == nil {
+		t.Fatal("quest should rehydrate from the store after a restart")
+	}
+	if len(m2.quest.Members) != 2 {
+		t.Fatalf("recovered party size = %d; want 2", len(m2.quest.Members))
+	}
+}
+
 func TestLeaderboard(t *testing.T) {
 	m, r, _ := newMgr()
 	m.Handle(chanMsg("alice", "!rpg"))