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/rpsoracle/v0"
gno = "0.9"

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

rpsoracle.gno

// Package rpsoracle is a rock-paper-scissors opponent that doesn't roll
// dice: it studies each player's move history and always throws the
// counter to whichever move that player has favored most. Play a fixed
// pattern and the oracle punishes it; play close to a uniform 1/3-1/3-1/3
// mix and it can't out-guess you better than chance.
package rpsoracle

import (
	"strconv"
	"strings"

	"chain"
	"chain/runtime"

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

// Move is one of rock, paper, or scissors, ordered so that
// (winner - loser + 3) % 3 == 1 for every winning pair.
type Move int

const (
	Rock Move = iota
	Paper
	Scissors
)

func moveName(m Move) string {
	switch m {
	case Rock:
		return "rock"
	case Paper:
		return "paper"
	case Scissors:
		return "scissors"
	default:
		return "?"
	}
}

func parseMove(s string) (Move, bool) {
	switch strings.ToLower(strings.TrimSpace(s)) {
	case "rock", "r":
		return Rock, true
	case "paper", "p":
		return Paper, true
	case "scissors", "s":
		return Scissors, true
	default:
		return 0, false
	}
}

// judge returns 0 for a tie, 1 if p beats h, 2 if h beats p.
func judge(p, h Move) int {
	return (int(p) - int(h) + 3) % 3
}

// beats returns the move that defeats m.
func beats(m Move) Move {
	return Move((int(m) + 1) % 3)
}

// playerState is the persisted record for one address.
type playerState struct {
	Counts     [3]int // history tally per move, what the oracle predicts from
	Rounds     int
	Wins       int // player beat the oracle
	Losses     int // oracle beat the player
	Draws      int
	BestStreak int
	streak     int // current player win streak against the oracle
}

var (
	players avl.Tree // address string -> *playerState

	nonce         int
	totalRounds   int
	oracleCorrect int // rounds the oracle won by successfully countering

	topOutwitter     address
	topOutwitterWins int
)

func getOrCreate(addr address) *playerState {
	key := addr.String()
	if v := players.Get(key); v != nil {
		return v.(*playerState)
	}
	ps := &playerState{}
	players.Set(key, ps)
	return ps
}

// predict guesses the player's next move as the most-played move in their
// history so far. Ties (including a fresh player's all-zero history) fall
// back to a chain-height-derived seed so the oracle doesn't always break
// ties the same way.
func predict(ps *playerState, seed int64) Move {
	best := Rock
	bestCount := ps.Counts[Rock]
	tied := []Move{Rock}
	for _, m := range []Move{Paper, Scissors} {
		switch {
		case ps.Counts[m] > bestCount:
			bestCount = ps.Counts[m]
			best = m
			tied = []Move{m}
		case ps.Counts[m] == bestCount:
			tied = append(tied, m)
		}
	}
	if len(tied) > 1 {
		if seed < 0 {
			seed = -seed
		}
		best = tied[int(seed)%len(tied)]
	}
	return best
}

// Play pits the caller against the oracle: it predicts your next move from
// your own move history and throws the counter. Accepts
// "rock"/"paper"/"scissors" or the single-letter shorthand "r"/"p"/"s".
func Play(cur realm, moveStr string) string {
	if !cur.IsCurrent() {
		panic("invalid realm")
	}
	caller := cur.Previous().Address()

	playerMove, ok := parseMove(moveStr)
	if !ok {
		panic("invalid move: use rock, paper, or scissors (r/p/s)")
	}

	ps := getOrCreate(caller)

	nonce++
	seed := runtime.ChainHeight() + int64(nonce)
	predicted := predict(ps, seed)
	oracleMove := beats(predicted)

	result := judge(playerMove, oracleMove)

	ps.Counts[playerMove]++
	ps.Rounds++
	totalRounds++

	var msg string
	switch result {
	case 1:
		ps.Wins++
		ps.streak++
		if ps.streak > ps.BestStreak {
			ps.BestStreak = ps.streak
		}
		if ps.Wins > topOutwitterWins {
			topOutwitterWins = ps.Wins
			topOutwitter = caller
		}
		msg = "you outwitted the oracle!"
	case 2:
		ps.Losses++
		ps.streak = 0
		oracleCorrect++
		msg = "the oracle read you like a book."
	default:
		ps.Draws++
		ps.streak = 0
		msg = "a draw — you and the oracle picked the same move."
	}

	chain.Emit("RoundPlayed",
		"player", caller.String(),
		"playerMove", moveName(playerMove),
		"oraclePredicted", moveName(predicted),
		"oracleMove", moveName(oracleMove),
		"result", strconv.Itoa(result),
	)

	return "you played " + moveName(playerMove) + ", the oracle predicted " +
		moveName(predicted) + " and threw " + moveName(oracleMove) + " -> " + msg
}

func renderHome() string {
	var b strings.Builder
	b.WriteString("# Rock-Paper-Scissors Oracle\n\n")
	b.WriteString("An adaptive opponent: it doesn't roll dice, it studies you. ")
	b.WriteString("Every throw is logged, and the oracle always counters whichever ")
	b.WriteString("move you've played most often. Play a uniform mixed strategy and ")
	b.WriteString("it can't out-guess you; fall into a habit and it will.\n\n")

	b.WriteString("- Total rounds played: " + strconv.Itoa(totalRounds) + "\n")
	if totalRounds > 0 {
		pct := oracleCorrect * 100 / totalRounds
		b.WriteString("- Oracle win rate: " + strconv.Itoa(pct) + "%\n")
	}
	if topOutwitter.IsValid() {
		b.WriteString("- Top outwitter: `" + topOutwitter.String() + "` (" +
			strconv.Itoa(topOutwitterWins) + " wins against the oracle)\n")
	} else {
		b.WriteString("- No one has beaten the oracle yet.\n")
	}

	b.WriteString("\n## How to play\n\n")
	b.WriteString("Call `Play(\"rock\"|\"paper\"|\"scissors\")` (or `r`/`p`/`s`). ")
	b.WriteString("View your own record at this realm's path plus your address, ")
	b.WriteString("e.g. `.../rpsoracle:g1youraddress...`\n")
	return b.String()
}

// escapeInline neutralizes markdown-active characters in untrusted text
// before it's embedded inline in Render output.
func escapeInline(s string) string {
	r := strings.NewReplacer(
		"\\", "\\\\",
		"`", "\\`",
		"*", "\\*",
		"_", "\\_",
		"[", "\\[",
		"]", "\\]",
		"|", "\\|",
	)
	return r.Replace(s)
}

func renderPlayer(rawAddr string) string {
	addr := strings.TrimSpace(rawAddr)
	safe := escapeInline(addr)

	v := players.Get(addr)
	if v == nil {
		return "# Player " + safe + "\n\nNo recorded rounds yet.\n"
	}
	ps := v.(*playerState)

	var b strings.Builder
	b.WriteString("# Player " + safe + "\n\n")
	b.WriteString("- Rounds played: " + strconv.Itoa(ps.Rounds) + "\n")
	b.WriteString("- Beat the oracle: " + strconv.Itoa(ps.Wins) + "\n")
	b.WriteString("- Lost to the oracle: " + strconv.Itoa(ps.Losses) + "\n")
	b.WriteString("- Draws: " + strconv.Itoa(ps.Draws) + "\n")
	b.WriteString("- Best win streak vs oracle: " + strconv.Itoa(ps.BestStreak) + "\n")
	b.WriteString("- Move history — rock: " + strconv.Itoa(ps.Counts[Rock]) +
		", paper: " + strconv.Itoa(ps.Counts[Paper]) +
		", scissors: " + strconv.Itoa(ps.Counts[Scissors]) + "\n")

	if ps.Rounds > 0 {
		maxCount := ps.Counts[Rock]
		for _, c := range ps.Counts[1:] {
			if c > maxCount {
				maxCount = c
			}
		}
		predictability := maxCount * 100 / ps.Rounds
		b.WriteString("- Predictability score: " + strconv.Itoa(predictability) +
			"% (lower is harder for the oracle to read)\n")
	}
	return b.String()
}

// Render shows the oracle's dashboard at "", or one player's record when
// path is their bech32 address.
func Render(path string) string {
	path = strings.TrimPrefix(strings.TrimSpace(path), "/")
	if path == "" {
		return renderHome()
	}
	return renderPlayer(path)
}