Playground
closestguess.gno
// Package closestguess is a blind, multiplayer number-guessing puzzle.
//
// Unlike a classic higher/lower guessing game, closestguess gives NO feedback
// per guess. Each round hides a target in 1..1000 (derived deterministically
// from the block height the round started at); every address may submit
// exactly one blind Guess for the round. Whenever someone calls Reveal, the
// round closes: the target is disclosed, the guess with the smallest absolute
// distance wins (ties go to whoever guessed first), the winner is recorded on
// the leaderboard, and a fresh round starts immediately.
package closestguess
import (
"strconv"
"strings"
"chain"
"chain/runtime"
)
const (
minTarget = 1
maxTarget = 1000
)
// roundT holds the mutable state of the open round. The target stays hidden
// (never rendered, never returned) until Reveal closes the round.
type roundT struct {
number int
startHeight int64
target int
}
// winRecord is one closed-round result, kept for the leaderboard.
type winRecord struct {
round int
winner string
target int
guess int
distance int
players int
}
// guessEntry is one address's blind guess for the current round.
type guessEntry struct {
addr string
n int
}
var (
current *roundT
// entries holds one guessEntry per address for the CURRENT round only, in
// submission order (so Reveal can break distance ties in favor of
// whoever guessed first). Reset on every Reveal. A plain slice is fine
// here: rounds are player-scoped and small, unlike long-lived global
// state where avl.Tree would matter.
entries []guessEntry
// leaderboard is append-only across all rounds; sorted on render.
leaderboard []winRecord
)
func init() {
current = newRound(1, runtime.ChainHeight())
}
// newRound builds a fresh round whose hidden target derives deterministically
// from the start height and round number. Gno has no runtime RNG, so mixing
// height with the round number is the only available entropy, and it also
// keeps consecutive rounds at the same height from repeating a target.
func newRound(number int, height int64) *roundT {
return &roundT{
number: number,
startHeight: height,
target: targetFromHeight(height, number),
}
}
func targetFromHeight(h int64, round int) int {
if h < 0 {
h = -h
}
span := int64(maxTarget - minTarget + 1)
mixed := h*2654435761 + int64(round)*40503 + 12345
if mixed < 0 {
mixed = -mixed
}
return int(mixed%span) + minTarget
}
// Guess records the caller's single blind guess for the current round. It
// returns no hint about correctness — that is the whole point of the puzzle.
// Crossing function: caller invokes as Guess(cross(cur), n).
func Guess(cur realm, n int) string {
if n < minTarget || n > maxTarget {
panic("guess must be in " + strconv.Itoa(minTarget) + ".." + strconv.Itoa(maxTarget))
}
caller := cur.Previous().Address().String()
if hasGuessed(caller) {
panic("you already guessed this round; wait for Reveal()")
}
entries = append(entries, guessEntry{addr: caller, n: n})
chain.Emit("GuessSubmitted",
"round", strconv.Itoa(current.number),
"player", caller,
)
return "guess recorded for round " + strconv.Itoa(current.number) + " (" +
strconv.Itoa(len(entries)) + " player(s) so far) — call Reveal() to see who's closest"
}
func hasGuessed(addr string) bool {
for _, e := range entries {
if e.addr == addr {
return true
}
}
return false
}
// Reveal closes the current round: discloses the target, crowns whoever
// landed closest (ties favor the earliest guesser), records a leaderboard
// entry, and opens a fresh round. Panics if nobody has guessed yet.
// Crossing function.
func Reveal(cur realm) string {
if len(entries) == 0 {
panic("no guesses submitted yet this round")
}
target := current.target
winner := entries[0]
best := distance(winner.n, target)
for _, e := range entries[1:] {
if d := distance(e.n, target); d < best {
best = d
winner = e
}
}
rec := winRecord{
round: current.number,
winner: winner.addr,
target: target,
guess: winner.n,
distance: best,
players: len(entries),
}
leaderboard = append(leaderboard, rec)
chain.Emit("RoundRevealed",
"round", strconv.Itoa(rec.round),
"winner", winner.addr,
"target", strconv.Itoa(target),
"distance", strconv.Itoa(best),
)
closedRound := current.number
current = newRound(closedRound+1, runtime.ChainHeight())
entries = nil
return "round " + strconv.Itoa(closedRound) + " revealed: target was " + strconv.Itoa(target) +
" — " + shortAddr(winner.addr) + " wins, guessed " + strconv.Itoa(winner.n) +
" (distance " + strconv.Itoa(best) + ") among " + strconv.Itoa(rec.players) +
" player(s). Round " + strconv.Itoa(current.number) + " is now open."
}
func distance(guess, target int) int {
d := guess - target
if d < 0 {
d = -d
}
return d
}
// Render produces the gnoweb Markdown view. The current round's target and
// individual guess values are never shown — only the player count — so
// rendering the page can't leak the puzzle.
func Render(path string) string {
var b strings.Builder
b.WriteString("# Closest Guess\n\n")
b.WriteString("A blind, multiplayer number-guessing puzzle. Each round hides a target in ")
b.WriteString("**" + strconv.Itoa(minTarget) + ".." + strconv.Itoa(maxTarget) + "**. ")
b.WriteString("Call `Guess(n)` once per round — you get no feedback. ")
b.WriteString("Anyone can call `Reveal()` to close the round: the target is disclosed and ")
b.WriteString("whoever landed closest wins.\n\n")
b.WriteString("## Current round\n\n")
b.WriteString("- Round: **" + strconv.Itoa(current.number) + "**\n")
b.WriteString("- Started at block height: " + strconv.FormatInt(current.startHeight, 10) + "\n")
b.WriteString("- Players guessed so far: " + strconv.Itoa(len(entries)) + "\n")
b.WriteString("- Status: **open** — target hidden until `Reveal()` is called.\n\n")
b.WriteString("## Leaderboard (closest-ever wins)\n\n")
b.WriteString(renderLeaderboard())
b.WriteString("\n## How to play\n\n")
b.WriteString("```\n")
b.WriteString("Guess(n) // n in 1..1000, one shot per address per round, no feedback\n")
b.WriteString("Reveal() // closes the round: reveals target, crowns the closest guess\n")
b.WriteString("```\n")
return b.String()
}
// renderLeaderboard formats closed rounds ranked by smallest distance (ties:
// earlier round first). Sorted on a copy so state is untouched.
func renderLeaderboard() string {
if len(leaderboard) == 0 {
return "_No round has been revealed yet — be the first to call `Reveal()`!_\n"
}
ranked := make([]winRecord, len(leaderboard))
copy(ranked, leaderboard)
sortByClosest(ranked)
var b strings.Builder
b.WriteString("| Rank | Player | Round | Target | Guess | Distance | Players |\n")
b.WriteString("|---|---|---|---|---|---|---|\n")
for i, w := range ranked {
b.WriteString("| " + strconv.Itoa(i+1) + " | `" + shortAddr(w.winner) + "` | " +
strconv.Itoa(w.round) + " | " + strconv.Itoa(w.target) + " | " +
strconv.Itoa(w.guess) + " | " + strconv.Itoa(w.distance) + " | " +
strconv.Itoa(w.players) + " |\n")
}
return b.String()
}
// sortByClosest does an in-place insertion sort: smallest distance first,
// then earlier round first on ties. Small n; insertion sort keeps it
// deterministic and dependency-free.
func sortByClosest(rs []winRecord) {
for i := 1; i < len(rs); i++ {
j := i
for j > 0 && closer(rs[j], rs[j-1]) {
rs[j], rs[j-1] = rs[j-1], rs[j]
j--
}
}
}
func closer(a, b winRecord) bool {
if a.distance != b.distance {
return a.distance < b.distance
}
return a.round < b.round
}
func shortAddr(a string) string {
if len(a) <= 12 {
return a
}
return a[:6] + "…" + a[len(a)-4:]
}
gnomod.toml
module = "gno.land/r/moul/x/daily/closestguess/v0" gno = "0.9" [addpkg] creator = "g1manfred47kzduec920z88wfr64ylksmdcedlf5" height = 25999 max_deposit = "100000000ugnot"