Skip to content Search Apps Documentation Source Content Run Reset Eval Playground File Folder Download Copy Actions State String Boolean Number Struct Map Slice Pointer Function Closure Reference Nil Package Type Interface Unknown

Playground

gnomod.toml

module = "gno.land/r/moul/x/daily/rpgroom/v0"
gno = "0.9"

[addpkg]
  creator = "g1manfred47kzduec920z88wfr64ylksmdcedlf5"
  height = 26392
  max_deposit = "100000000ugnot"

rpgroom.gno

// Package rpgroom is a tiny single-room on-chain RPG. There is exactly one
// monster in the room at a time. Spawn a hero, take a swing, and see what
// happens: land the killing blow and the room's monster gets replaced by a
// tougher one while your hero gains XP, gold, and (eventually) a level; get
// hit hard enough and your hero falls until it's revived. A room-wide
// leaderboard tracks who has climbed the highest.
package rpgroom

import (
	"sort"
	"strconv"
	"strings"

	"chain"
	"chain/runtime"

	"gno.land/p/nt/avl/v0"
	"gno.land/p/nt/markdown/sanitize/v0"
)

// Hero is one player's on-chain character in the room.
type Hero struct {
	Name   string
	Level  int
	XP     int
	HP     int
	MaxHP  int
	Attack int
	Kills  int
	Gold   int
	Alive  bool
}

// Monster is the room's current resident.
type Monster struct {
	Name   string
	Level  int
	HP     int
	MaxHP  int
	Attack int
}

var (
	heroes     avl.Tree // address string -> *Hero
	monster    *Monster
	roomLevel  int
	totalKills int
)

var monsterNames = []string{
	"Slime", "Giant Rat", "Goblin", "Skeleton", "Cave Bat",
	"Orc Grunt", "Wraith", "Stone Troll", "Dread Wolf", "Young Dragon",
}

func init() {
	roomLevel = 1
	monster = spawnMonster(roomLevel)
}

func spawnMonster(level int) *Monster {
	name := monsterNames[(level-1)%len(monsterNames)]
	hp := 20 + level*15
	return &Monster{
		Name:   name,
		Level:  level,
		HP:     hp,
		MaxHP:  hp,
		Attack: 3 + level*2,
	}
}

// Spawn creates the caller's hero in the room. Each address gets exactly one
// hero; call Revive (not Spawn again) if it dies.
func Spawn(cur realm, name string) {
	if !cur.Previous().IsUserCall() {
		panic("only a direct EOA call can spawn a hero")
	}
	name = strings.TrimSpace(name)
	if name == "" {
		panic("name required")
	}
	if len(name) > 24 {
		panic("name too long (max 24 chars)")
	}
	addr := cur.Previous().Address().String()
	if heroes.Has(addr) {
		panic("you already have a hero in this room")
	}
	heroes.Set(addr, &Hero{
		Name:   name,
		Level:  1,
		HP:     30,
		MaxHP:  30,
		Attack: 5,
		Alive:  true,
	})
	chain.Emit("HeroSpawned", "addr", addr, "name", name)
}

// Attack swings the caller's hero at the room's current monster. Killing it
// grants XP and gold and replaces it with a tougher one; otherwise the
// monster strikes back.
func Attack(cur realm) {
	if !cur.Previous().IsUserCall() {
		panic("only a direct EOA call can attack")
	}
	addr := cur.Previous().Address().String()
	v := heroes.Get(addr)
	if v == nil {
		panic("no hero found; call Spawn first")
	}
	hero := v.(*Hero)
	if !hero.Alive {
		panic("your hero is dead; call Revive first")
	}

	dmg := hero.Attack
	if runtime.ChainHeight()%7 == 0 {
		dmg *= 2 // occasional critical hit, tied to block height parity
	}
	monster.HP -= dmg
	chain.Emit("HeroAttacked", "addr", addr, "damage", strconv.Itoa(dmg), "monsterHP", strconv.Itoa(monster.HP))

	if monster.HP <= 0 {
		reward := monster.Level * 10
		gained := monster.Level * 20
		hero.Gold += reward
		hero.XP += gained
		hero.Kills++
		levelUp(hero)
		chain.Emit("MonsterSlain", "addr", addr, "monster", monster.Name, "level", strconv.Itoa(monster.Level))

		totalKills++
		roomLevel++
		monster = spawnMonster(roomLevel)
		return
	}

	hero.HP -= monster.Attack
	if hero.HP <= 0 {
		hero.HP = 0
		hero.Alive = false
		chain.Emit("HeroDied", "addr", addr, "monster", monster.Name)
	}
}

// Rest heals the caller's hero for a quarter of its max HP.
func Rest(cur realm) {
	if !cur.Previous().IsUserCall() {
		panic("only a direct EOA call can rest")
	}
	addr := cur.Previous().Address().String()
	v := heroes.Get(addr)
	if v == nil {
		panic("no hero found; call Spawn first")
	}
	hero := v.(*Hero)
	if !hero.Alive {
		panic("your hero is dead; call Revive first")
	}
	if hero.HP >= hero.MaxHP {
		panic("already at full health")
	}
	heal := hero.MaxHP / 4
	if heal < 1 {
		heal = 1
	}
	hero.HP += heal
	if hero.HP > hero.MaxHP {
		hero.HP = hero.MaxHP
	}
	chain.Emit("HeroRested", "addr", addr, "hp", strconv.Itoa(hero.HP))
}

// Revive brings a fallen hero back at half max HP.
func Revive(cur realm) {
	if !cur.Previous().IsUserCall() {
		panic("only a direct EOA call can revive")
	}
	addr := cur.Previous().Address().String()
	v := heroes.Get(addr)
	if v == nil {
		panic("no hero found; call Spawn first")
	}
	hero := v.(*Hero)
	if hero.Alive {
		panic("your hero is not dead")
	}
	hero.Alive = true
	hero.HP = hero.MaxHP / 2
	if hero.HP < 1 {
		hero.HP = 1
	}
	chain.Emit("HeroRevived", "addr", addr, "hp", strconv.Itoa(hero.HP))
}

// levelUp applies every level-up a hero's current XP qualifies for. The
// threshold to reach level N+1 from level N is N*50 XP.
func levelUp(h *Hero) {
	for h.XP >= h.Level*50 {
		h.XP -= h.Level * 50
		h.Level++
		h.MaxHP += 10
		h.HP = h.MaxHP
		h.Attack += 3
	}
}

// byRank orders heroes for the leaderboard: highest level first, then XP,
// then kills, as a tiebreaker.
type byRank []*Hero

func (r byRank) Len() int      { return len(r) }
func (r byRank) Swap(i, j int) { r[i], r[j] = r[j], r[i] }
func (r byRank) Less(i, j int) bool {
	if r[i].Level != r[j].Level {
		return r[i].Level > r[j].Level
	}
	if r[i].XP != r[j].XP {
		return r[i].XP > r[j].XP
	}
	return r[i].Kills > r[j].Kills
}

func collectHeroes() []*Hero {
	var out []*Hero
	heroes.Iterate("", "", func(key string, value any) bool {
		out = append(out, value.(*Hero))
		return false
	})
	return out
}

func hpBar(hp, maxHP int) string {
	if maxHP <= 0 {
		maxHP = 1
	}
	filled := hp * 10 / maxHP
	if filled < 0 {
		filled = 0
	}
	if filled > 10 {
		filled = 10
	}
	bar := strings.Repeat("#", filled) + strings.Repeat("-", 10-filled)
	return "`" + bar + "` " + strconv.Itoa(hp) + "/" + strconv.Itoa(maxHP) + " HP"
}

// Render shows the room overview and leaderboard at path "", or a single
// hero's detail page when path is a bech32 address.
func Render(path string) string {
	path = strings.TrimSpace(path)
	if path != "" {
		return renderHero(path)
	}
	return renderRoom()
}

func renderRoom() string {
	var b strings.Builder
	b.WriteString("# RPG Room\n\n")
	b.WriteString("A single dungeon room with one monster in it at a time. ")
	b.WriteString("Call `Spawn(\"name\")` to enter, `Attack()` to fight the resident monster, ")
	b.WriteString("`Rest()` to heal up, and `Revive()` if you fall.\n\n")

	b.WriteString("## Current monster\n\n")
	b.WriteString("**" + sanitize.InlineText(monster.Name) + "** — level " + strconv.Itoa(monster.Level) + "\n\n")
	b.WriteString(hpBar(monster.HP, monster.MaxHP) + "\n\n")
	b.WriteString("- Attack: " + strconv.Itoa(monster.Attack) + "\n")
	b.WriteString("- Monsters cleared so far: " + strconv.Itoa(totalKills) + "\n\n")

	b.WriteString("## Leaderboard\n\n")
	all := collectHeroes()
	if len(all) == 0 {
		b.WriteString("_No heroes yet. Be the first: `Spawn(\"name\")`._\n")
		return b.String()
	}
	sort.Sort(byRank(all))
	b.WriteString("| # | Hero | Lvl | HP | Kills | Gold | Status |\n")
	b.WriteString("|---|---|---|---|---|---|---|\n")
	limit := len(all)
	if limit > 20 {
		limit = 20
	}
	for i := 0; i < limit; i++ {
		h := all[i]
		status := "alive"
		if !h.Alive {
			status = "fallen"
		}
		b.WriteString("| " + strconv.Itoa(i+1) + " | " + sanitize.InlineText(h.Name) + " | " +
			strconv.Itoa(h.Level) + " | " + strconv.Itoa(h.HP) + "/" + strconv.Itoa(h.MaxHP) + " | " +
			strconv.Itoa(h.Kills) + " | " + strconv.Itoa(h.Gold) + " | " + status + " |\n")
	}
	return b.String()
}

func renderHero(addr string) string {
	v := heroes.Get(addr)
	if v == nil {
		return "> [!WARNING]\n> No hero found for `" + sanitize.InlineText(addr) + "`.\n"
	}
	h := v.(*Hero)
	var b strings.Builder
	b.WriteString("# " + sanitize.InlineText(h.Name) + "\n\n")
	b.WriteString(hpBar(h.HP, h.MaxHP) + "\n\n")
	b.WriteString("- Level: " + strconv.Itoa(h.Level) + "\n")
	b.WriteString("- XP: " + strconv.Itoa(h.XP) + " (next level at " + strconv.Itoa(h.Level*50) + ")\n")
	b.WriteString("- Attack: " + strconv.Itoa(h.Attack) + "\n")
	b.WriteString("- Kills: " + strconv.Itoa(h.Kills) + "\n")
	b.WriteString("- Gold: " + strconv.Itoa(h.Gold) + "\n")
	if !h.Alive {
		b.WriteString("- Status: fallen — call `Revive()` to return\n")
	}
	return b.String()
}