Merge pull request #73 from IamMrCupp/feat/rpg-hp

feat(idlerpg): hit points + downed state (#67)

Author: IamMrCupp

docs/idlerpg.md

@@ -46,6 +46,9 @@ the NAMES list — you don't have to rejoin or speak to resume progress.
   (a big swing either way).
 - **Alignment** (`!rpg align good|neutral|evil`). Good fights at +11% power; evil
   crits twice as often; neutral is baseline.
+- **HP.** Derived from CON, level, and your class hit die. Losing a fight (and,
+  later, monsters) deals damage; at 0 HP you're **downed** — no progress until you
+  heal back, which happens a little each tick. `!rpg sheet` shows `HP cur/max`.
 - **Class** (`!rpg class <fighter|ranger|rogue|cleric|bard|wizard>`). Mechanical:
   each keys off a primary ability (fighter STR, wizard INT, rogue/ranger DEX,
   cleric WIS, bard CHA) whose modifier is added to your attack power, and whose

internal/idlerpg/hp.go

@@ -0,0 +1,73 @@
+package idlerpg
+
+import "context"
+
+// Hit points give combat stakes. We store damage *taken* (the "dmg" field) rather
+// than current HP, so an unset field (0) naturally means full health — no sentinel
+// needed. Current HP = maxHP − dmg. At 0 a character is "downed": they can't
+// progress until they heal back up (a little each tick). idlerpg.org has no HP at
+// all; this is core D&D feel.
+
+const baseHP = 8
+
+// maxHP derives the hit-point ceiling from level, CON, and the class hit die.
+func maxHP(sheet map[string]int64, class string) int64 {
+	die := int64(8) // unclassed characters use a d8
+	if c, ok := classOf(class); ok {
+		die = c.HitDie
+	}
+	perLevel := die/2 + 1 + abilityMod(sheet["con"]) // average die + CON modifier
+	if perLevel < 1 {
+		perLevel = 1
+	}
+	return baseHP + perLevel*(sheet["level"]+1)
+}
+
+// curHP returns current hit points (clamped at 0).
+func curHP(sheet map[string]int64, class string) int64 {
+	hp := maxHP(sheet, class) - sheet["dmg"]
+	if hp < 0 {
+		return 0
+	}
+	return hp
+}
+
+// isDowned reports whether the character is at 0 HP.
+func isDowned(sheet map[string]int64, class string) bool {
+	return curHP(sheet, class) <= 0
+}
+
+// damage applies amt damage and returns the new damage total.
+func (m *Manager) damage(ctx context.Context, key string, amt int64) int64 {
+	d, _ := m.store.HIncr(ctx, sheetKey(key), "dmg", amt)
+	return d
+}
+
+// heal removes amt damage, clamped so a character never goes below zero damage.
+func (m *Manager) heal(ctx context.Context, key string, amt int64) {
+	if d, _ := m.store.HIncr(ctx, sheetKey(key), "dmg", -amt); d < 0 {
+		_ = m.store.HSet(ctx, sheetKey(key), "dmg", 0)
+	}
+}
+
+// tickHP applies natural healing for one tick and reports whether the character is
+// still downed afterward (so the caller can freeze their progress).
+func (m *Manager) tickHP(ctx context.Context, key string) bool {
+	sheet, err := m.store.HGetAll(ctx, sheetKey(key))
+	if err != nil {
+		return false
+	}
+	class, _ := m.store.GetStr(ctx, classKey(key))
+	dmg := sheet["dmg"]
+	if dmg > 0 {
+		regen := sheet["level"]/2 + abilityMod(sheet["con"]) + 1
+		if regen < 1 {
+			regen = 1
+		}
+		m.heal(ctx, key, regen)
+		if dmg -= regen; dmg < 0 {
+			dmg = 0
+		}
+	}
+	return maxHP(sheet, class)-dmg <= 0
+}

internal/idlerpg/idlerpg.go

@@ -370,11 +370,13 @@ func (m *Manager) sheet(msg engine.Message, fields []string) string {
 	}
 	m.ensureAbilities(ctx, pkey)
 	sheet, _ := m.store.HGetAll(ctx, sheetKey(pkey))
+	class, _ := m.store.GetStr(ctx, classKey(pkey))
 	desc := alignName(sheet["align"])
-	if class, _ := m.store.GetStr(ctx, classKey(pkey)); class != "" {
+	if class != "" {
 		desc += " " + class
 	}
-	return fmt.Sprintf("%s the %s (lvl %d) — %s", name, desc, sheet["level"], abilityLine(sheet))
+	return fmt.Sprintf("%s the %s (lvl %d) — HP %d/%d · %s",
+		name, desc, sheet["level"], curHP(sheet, class), maxHP(sheet, class), abilityLine(sheet))
 }
 
 // adminVerb handles the privileged !rpg commands (pause/resume/push/hog). They are
@@ -558,6 +560,9 @@ func (m *Manager) Tick() {
 		ctx := context.Background()
 		key := sheetKey(p.key)
 		m.moveOnMap(ctx, p.key) // wander the world map (cosmetic; happens every tick)
+		if m.tickHP(ctx, p.key) {
+			continue // downed and recovering — no progress this tick
+		}
 		ttl, err := m.store.HIncr(ctx, key, "ttl", -step)
 		if err != nil {
 			continue
@@ -597,9 +602,8 @@ func (m *Manager) battle(ctx context.Context, p player, level int64) {
 		effPow = myPow * 111 / 100
 	}
 	// Class: your primary ability's modifier sharpens (or dulls) your attack.
-	if cls, _ := m.store.GetStr(ctx, classKey(p.key)); cls != "" {
-		effPow += classAttackMod(mine, cls)
-	}
+	myClass, _ := m.store.GetStr(ctx, classKey(p.key))
+	effPow += classAttackMod(mine, myClass)
 	if effPow < 0 {
 		effPow = 0
 	}
@@ -615,8 +619,17 @@ func (m *Manager) battle(ctx context.Context, p player, level int64) {
 	}
 
 	verb, dir, sign := "won", "sooner", int64(-1)
+	downed := false
 	if !win {
 		verb, dir, sign = "lost", "later", int64(1)
+		// Losing the bout also costs blood — and can leave you downed.
+		hurt := int64(m.roll(int(level)+3) + 2)
+		if crit {
+			hurt *= 2
+		}
+		m.damage(ctx, p.key, hurt)
+		after, _ := m.store.HGetAll(ctx, sheetKey(p.key))
+		downed = isDowned(after, myClass)
 	}
 	_, _ = m.store.HIncr(ctx, sheetKey(p.key), "ttl", sign*amt)
 
@@ -626,6 +639,9 @@ func (m *Manager) battle(ctx context.Context, p player, level int64) {
 	}
 	m.out.Say(p.network, p.channel, fmt.Sprintf("🗡️ %s [%d] challenged %s [%d] in combat and %s%s — %ds %s.",
 		p.nick, myPow, opp.nick, oppPow, verb, critStr, amt, dir))
+	if downed {
+		m.out.Say(p.network, p.channel, fmt.Sprintf("💢 %s is beaten down to 0 HP and must recover before pressing on.", p.nick))
+	}
 }
 
 const eventOdds = 6 // ~1-in-N chance an event fires each tick

internal/idlerpg/idlerpg_test.go

@@ -512,6 +512,45 @@ func TestStatusCommand(t *testing.T) {
 	}
 }
 
+func TestMaxHP(t *testing.T) {
+	sheet := map[string]int64{"level": 2, "con": 14} // CON 14 → +2
+	if got := maxHP(sheet, "fighter"); got != 32 {   // d10: (5+1+2)*3 + 8
+		t.Fatalf("fighter L2 CON14 maxHP = %d; want 32", got)
+	}
+	if got := maxHP(sheet, ""); got != 29 { // unclassed d8: (4+1+2)*3 + 8
+		t.Fatalf("unclassed L2 CON14 maxHP = %d; want 29", got)
+	}
+}
+
+func TestDamageDownedAndHeal(t *testing.T) {
+	m, _, st := newMgr()
+	ctx := context.Background()
+	m.Handle(chanMsg("alice", "!rpg"))
+	m.damage(ctx, "net|alice", 1000)
+	if s, _ := st.HGetAll(ctx, sheetKey("net|alice")); !isDowned(s, "") {
+		t.Fatal("massive damage should leave the character downed")
+	}
+	m.heal(ctx, "net|alice", 1000)
+	s, _ := st.HGetAll(ctx, sheetKey("net|alice"))
+	if isDowned(s, "") || s["dmg"] != 0 {
+		t.Fatalf("a full heal should clear downed and clamp dmg to 0, got dmg=%d", s["dmg"])
+	}
+}
+
+func TestDownedFreezesProgress(t *testing.T) {
+	m, r, st := newMgr() // 1s tick/ttl: a healthy player would level
+	ctx := context.Background()
+	m.Handle(chanMsg("alice", "!rpg"))
+	m.damage(ctx, "net|alice", 1000) // down alice
+	m.Tick()
+	if r.has("attained level") {
+		t.Fatal("a downed player must not level up")
+	}
+	if s, _ := st.HGetAll(ctx, sheetKey("net|alice")); s["level"] != 0 {
+		t.Fatalf("downed level = %d; want 0", s["level"])
+	}
+}
+
 func TestClassMustBeCanonical(t *testing.T) {
 	m, r, _ := newMgr()
 	m.Handle(chanMsg("alice", "!rpg"))
@@ -564,8 +603,8 @@ func TestSheetCommand(t *testing.T) {
 	m, r, _ := newMgr()
 	m.Handle(chanMsg("alice", "!rpg"))
 	m.Handle(chanMsg("alice", "!rpg sheet"))
-	if !strings.Contains(r.last(), "STR") || !strings.Contains(r.last(), "CHA") {
-		t.Fatalf("!rpg sheet should show the ability block, got %q", r.last())
+	if !strings.Contains(r.last(), "STR") || !strings.Contains(r.last(), "CHA") || !strings.Contains(r.last(), "HP") {
+		t.Fatalf("!rpg sheet should show HP + the ability block, got %q", r.last())
 	}
 }
 

internal/idlerpg/read.go

@@ -26,6 +26,8 @@ type CharView struct {
 	Key       string           // canonical character key (network|nick, or a linked account)
 	Name      string           // display name: the key with any "network|" prefix stripped
 	Level     int64            // current level
+	HP        int64            // current hit points
+	MaxHP     int64            // hit-point ceiling
 	TTL       int64            // seconds to the next level
 	Power     int64            // total equipment power (sum of item levels)
 	Align     string           // "good" / "neutral" / "evil"
@@ -138,6 +140,8 @@ func readChar(ctx context.Context, store state.Store, key string) CharView {
 		Key:       key,
 		Name:      displayName(key),
 		Level:     sheet["level"],
+		HP:        curHP(sheet, class),
+		MaxHP:     maxHP(sheet, class),
 		TTL:       sheet["ttl"],
 		Power:     itemSum(sheet),
 		Align:     alignName(sheet["align"]),

internal/rpgweb/rpgweb.go

@@ -246,6 +246,7 @@ const charTmpl = `<!doctype html>
 
 <table>
   <tr><td class="k">level</td><td class="lvl">{{.Level}}</td></tr>
+  <tr><td class="k">hp</td><td>{{.HP}} <span class="muted">/ {{.MaxHP}}</span></td></tr>
   <tr><td class="k">time to next</td><td class="muted">{{dur .TTL}}</td></tr>
   <tr><td class="k">power</td><td>{{.Power}}</td></tr>
 </table>