Merge pull request #61 from IamMrCupp/feat/rpg-world-map

feat(idlerpg): persistent world map (/map)

Author: IamMrCupp

docs/idlerpg.md

@@ -101,9 +101,10 @@ stack). It still needs Redis for game state.
 
 ## The web dashboard
 
-A separate read-only service renders the realm as a web page — the top idlers and
-the active quest, auto-refreshing. It reads the same Redis the bots write, so it's
-just a view; it never touches the game.
+A separate read-only service renders the realm as a web page — the top idlers, the
+active quest, per-character pages (`/p/<name>`), and a **world map** (`/map`) where
+every player wanders as a dot and the towns are marked. It reads the same Redis the
+bots write, so it's just a view; it never touches the game. Auto-refreshes.
 
 - **Docker Compose:** it's the `dashboard` service — browse <http://localhost:8080>.
 - **Kubernetes:** `kubectl apply -k deploy/k8s/dashboard -n annoybots`, then

internal/idlerpg/idlerpg.go

@@ -544,6 +544,7 @@ func (m *Manager) Tick() {
 	for _, p := range m.snapshot() {
 		ctx := context.Background()
 		key := sheetKey(p.key)
+		m.moveOnMap(ctx, p.key) // wander the world map (cosmetic; happens every tick)
 		ttl, err := m.store.HIncr(ctx, key, "ttl", -step)
 		if err != nil {
 			continue

internal/idlerpg/idlerpg_test.go

@@ -512,6 +512,20 @@ func TestStatusCommand(t *testing.T) {
 	}
 }
 
+func TestWorldMapMovement(t *testing.T) {
+	m, _, st := newMgr()
+	ctx := context.Background()
+	m.Handle(chanMsg("alice", "!rpg")) // enroll + online
+	if s, _ := st.HGetAll(ctx, sheetKey("net|alice")); s["mx"] != 0 {
+		t.Fatal("a fresh player should start unplaced (mx=0)")
+	}
+	m.Tick() // moves (places) alice
+	s, _ := st.HGetAll(ctx, sheetKey("net|alice"))
+	if s["mx"] < 1 || s["mx"] > worldSize || s["my"] < 1 || s["my"] > worldSize {
+		t.Fatalf("alice should be placed in-bounds, got (%d,%d)", s["mx"], s["my"])
+	}
+}
+
 func allowAll(engine.Message) bool { return true }
 
 func TestAdminVerbsRequireAuthz(t *testing.T) {

internal/idlerpg/read.go

@@ -42,6 +42,49 @@ type QuestView struct {
 	MapSize int
 }
 
+// MapDot is a player's position on the world map.
+type MapDot struct {
+	Name  string
+	X, Y  int
+	Level int64
+}
+
+// Town is a named landmark on the world map.
+type Town struct {
+	Name string
+	X, Y int
+}
+
+// WorldView is everything the dashboard needs to draw the world map: every placed
+// player's position and the static towns.
+type WorldView struct {
+	Players []MapDot
+	Towns   []Town
+	Size    int
+}
+
+// ReadWorld returns the world map — up to limit placed players plus the towns.
+func ReadWorld(ctx context.Context, store state.Store, limit int) (WorldView, error) {
+	top, err := store.ZTop(ctx, boardKey(), limit)
+	if err != nil {
+		return WorldView{}, err
+	}
+	w := WorldView{Size: worldSize}
+	for _, e := range towns {
+		w.Towns = append(w.Towns, Town(e))
+	}
+	for _, e := range top {
+		sheet, _ := store.HGetAll(ctx, sheetKey(e.Member))
+		if sheet["mx"] == 0 || sheet["my"] == 0 {
+			continue // not placed on the map yet
+		}
+		w.Players = append(w.Players, MapDot{
+			Name: displayName(e.Member), X: int(sheet["mx"]), Y: int(sheet["my"]), Level: sheet["level"],
+		})
+	}
+	return w, nil
+}
+
 // ReadLeaderboard returns up to n characters ranked by level (highest first).
 func ReadLeaderboard(ctx context.Context, store state.Store, n int) ([]CharView, error) {
 	top, err := store.ZTop(ctx, boardKey(), n)

internal/idlerpg/read_test.go

@@ -40,6 +40,30 @@ func TestReadLeaderboard(t *testing.T) {
 	}
 }
 
+func TestReadWorld(t *testing.T) {
+	m, _, st := newMgr()
+	ctx := context.Background()
+	m.Handle(chanMsg("alice", "!rpg"))
+	m.Tick() // places alice on the map
+
+	w, err := ReadWorld(ctx, st, 50)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(w.Towns) == 0 || w.Size != worldSize {
+		t.Fatalf("world should carry towns + size, got %d towns size %d", len(w.Towns), w.Size)
+	}
+	found := false
+	for _, p := range w.Players {
+		if p.Name == "alice" {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatalf("alice should be on the map, got %+v", w.Players)
+	}
+}
+
 func TestReadChar(t *testing.T) {
 	m, _, st := newMgr()
 	ctx := context.Background()

internal/idlerpg/world.go

@@ -0,0 +1,61 @@
+package idlerpg
+
+import (
+	"context"
+)
+
+// The world map: every player has a persistent position and wanders a step each
+// tick while they're online (idlerpg.net's marquee "watch everyone roam" map).
+// Positions are 1-based (mx/my fields on the sheet); 0 means "not placed yet", so
+// a brand-new or pre-existing character gets dropped somewhere random on its first
+// move. This is cosmetic — movement doesn't affect leveling.
+
+const (
+	worldSize = 500 // the realm is worldSize×worldSize
+	worldStep = 14  // max distance a player drifts per tick
+)
+
+// town is a static, named landmark drawn on the world map for flavor.
+type town struct {
+	Name string
+	X, Y int
+}
+
+// towns are fixed points of interest on the map.
+var towns = []town{
+	{"Idlecrest", 250, 250},
+	{"Lurk Harbor", 70, 410},
+	{"Mount AFK", 420, 90},
+	{"Quietford", 130, 150},
+	{"The Lag Marsh", 360, 380},
+	{"Tab-Away Tavern", 200, 60},
+}
+
+// moveOnMap drifts an online player one random step, placing them first if they've
+// never been on the map. Caller passes the player's character key.
+func (m *Manager) moveOnMap(ctx context.Context, key string) {
+	sheet, err := m.store.HGetAll(ctx, sheetKey(key))
+	if err != nil {
+		return
+	}
+	x, y := sheet["mx"], sheet["my"]
+	if x == 0 || y == 0 {
+		x = int64(m.roll(worldSize) + 1)
+		y = int64(m.roll(worldSize) + 1)
+	} else {
+		x = clampWorld(x + int64(m.roll(2*worldStep+1)-worldStep))
+		y = clampWorld(y + int64(m.roll(2*worldStep+1)-worldStep))
+	}
+	_ = m.store.HSet(ctx, sheetKey(key), "mx", x)
+	_ = m.store.HSet(ctx, sheetKey(key), "my", y)
+}
+
+func clampWorld(v int64) int64 {
+	if v < 1 {
+		return 1
+	}
+	if v > worldSize {
+		return worldSize
+	}
+	return v
+}

internal/rpgweb/rpgweb.go

@@ -18,11 +18,14 @@ import (
 
 const boardSize = 25
 
+const worldDots = 200 // most players to plot on the world map
+
 // Server renders the dashboard from a read-only view of the state store.
 type Server struct {
 	store    state.Store
 	tmpl     *template.Template
 	charTmpl *template.Template
+	mapTmpl  *template.Template
 	now      func() time.Time
 }
 
@@ -43,6 +46,7 @@ func New(store state.Store) *Server {
 		store:    store,
 		tmpl:     template.Must(template.New("index").Funcs(tmplFuncs).Parse(indexTmpl)),
 		charTmpl: template.Must(template.New("char").Funcs(tmplFuncs).Parse(charTmpl)),
+		mapTmpl:  template.Must(template.New("map").Funcs(tmplFuncs).Parse(mapTmpl)),
 		now:      time.Now,
 	}
 }
@@ -51,6 +55,7 @@ func New(store state.Store) *Server {
 func (s *Server) Handler() http.Handler {
 	mux := http.NewServeMux()
 	mux.HandleFunc("/", s.index)
+	mux.HandleFunc("/map", s.worldMap)
 	mux.HandleFunc("/p/", s.char)
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, _ *http.Request) {
 		w.WriteHeader(http.StatusOK)
@@ -89,6 +94,19 @@ func (s *Server) index(w http.ResponseWriter, r *http.Request) {
 	_ = s.tmpl.Execute(w, data)
 }
 
+// worldMap renders the persistent world map: every placed player + the towns.
+func (s *Server) worldMap(w http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)
+	defer cancel()
+	world, err := idlerpg.ReadWorld(ctx, s.store, worldDots)
+	if err != nil {
+		http.Error(w, "the realm is unreachable right now.", http.StatusServiceUnavailable)
+		return
+	}
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	_ = s.mapTmpl.Execute(w, world)
+}
+
 // char renders one character's sheet at /p/<key>.
 func (s *Server) char(w http.ResponseWriter, r *http.Request) {
 	key := strings.TrimPrefix(r.URL.Path, "/p/")
@@ -154,6 +172,7 @@ const indexTmpl = `<!doctype html>
 </head>
 <body>
 <h1>⚔ the idle realm</h1>
+<p class="muted"><a href="/map">🗺 the realm map</a> — see where everyone's wandering.</p>
 {{if .Quest}}
 <div class="quest">
   <strong>A quest is underway.</strong>
@@ -240,3 +259,46 @@ const charTmpl = `<!doctype html>
 <footer><a href="/">&larr; back to the realm</a></footer>
 </body>
 </html>`
+
+const mapTmpl = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta http-equiv="refresh" content="30">
+<title>annoybots · the realm map</title>
+<style>
+  :root { color-scheme: dark; }
+  body { background:#0e0f13; color:#d6d8de; font:15px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace; margin:0; padding:2rem; }
+  h1 { font-size:1.4rem; margin:0 0 .25rem; color:#e9b949; }
+  .sub { color:#8aa0c6; margin:0 0 1rem; }
+  .world { display:block; width:100%; max-width:680px; margin:0 auto; background:#0b0c10; border:1px solid #2a2f3a; border-radius:8px; }
+  .town { fill:#4a3c14; stroke:#e9b949; stroke-width:2; }
+  .town-l { fill:#b9912f; font-size:11px; }
+  .dot { fill:#7fd1a8; stroke:#0e0f13; stroke-width:1.5; }
+  .dot-l { fill:#9aa0ac; font-size:9px; }
+  .muted { color:#6b7280; }
+  a { color:#7fd1a8; text-decoration:none; }
+  a:hover { text-decoration:underline; }
+  footer { margin-top:1.5rem; color:#4b5563; font-size:.8rem; text-align:center; }
+</style>
+</head>
+<body>
+<h1>🗺 the realm map</h1>
+<p class="sub">{{len .Players}} adventurers roaming · towns in gold</p>
+<svg class="world" viewBox="-12 -12 {{add .Size 24}} {{add .Size 24}}" role="img" aria-label="world map of player positions">
+  <rect x="0" y="0" width="{{.Size}}" height="{{.Size}}" fill="#0b0c10" stroke="#20232b" stroke-width="1"/>
+  {{range .Towns}}
+  <rect x="{{add .X -5}}" y="{{add .Y -5}}" width="10" height="10" class="town"/>
+  <text x="{{add .X 9}}" y="{{add .Y 4}}" class="town-l">{{.Name}}</text>
+  {{end}}
+  {{range .Players}}
+  <circle cx="{{.X}}" cy="{{.Y}}" r="4" class="dot"/>
+  <text x="{{add .X 6}}" y="{{add .Y 3}}" class="dot-l">{{.Name}}</text>
+  {{else}}
+  <text x="{{add .Size -250}}" y="250" class="dot-l">no one has wandered onto the map yet.</text>
+  {{end}}
+</svg>
+<footer><a href="/">&larr; back to the realm</a> · auto-refreshes every 30s</footer>
+</body>
+</html>`

internal/rpgweb/rpgweb_test.go

@@ -106,6 +106,26 @@ func TestCharPage(t *testing.T) {
 	}
 }
 
+func TestWorldMapPage(t *testing.T) {
+	st := state.NewMem()
+	log := slog.New(slog.NewTextHandler(io.Discard, nil))
+	m := idlerpg.New(st, noopSender{}, nil, time.Second, time.Second, time.Hour, time.Hour, log)
+	m.Handle(engine.Message{Network: "net", Channel: "#c", Nick: "alice", Text: "!rpg"})
+	m.Tick() // places alice on the map
+
+	rr := httptest.NewRecorder()
+	New(st).Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/map", nil))
+	if rr.Code != http.StatusOK {
+		t.Fatalf("map status = %d; want 200", rr.Code)
+	}
+	body := rr.Body.String()
+	for _, want := range []string{"<svg", "alice", "Idlecrest", "back to the realm"} {
+		if !strings.Contains(body, want) {
+			t.Fatalf("world map missing %q\n%s", want, body)
+		}
+	}
+}
+
 func TestHealthz(t *testing.T) {
 	rr := httptest.NewRecorder()
 	New(state.NewMem()).Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/healthz", nil))