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()
}