// 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/g1magld5ptgzaktqcexxq0pgq5lmdf0kz6re8hlv/kit/ui/v0" "gno.land/p/g1magld5ptgzaktqcexxq0pgq5lmdf0kz6re8hlv/x/daily/rps/v0" "gno.land/p/nt/avl/v0" ) // beats returns the move that defeats m. func beats(m rps.Move) rps.Move { return rps.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) rps.Move { best := rps.Rock bestCount := ps.Counts[rps.Rock] tied := []rps.Move{rps.Rock} for _, m := range []rps.Move{rps.Paper, rps.Scissors} { switch { case ps.Counts[m] > bestCount: bestCount = ps.Counts[m] best = m tied = []rps.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 := rps.Parse(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 := rps.Beats(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", playerMove.String(), "oraclePredicted", predicted.String(), "oracleMove", oracleMove.String(), "result", strconv.Itoa(result), ) return "you played " + playerMove.String() + ", the oracle predicted " + predicted.String() + " and threw " + oracleMove.String() + " -> " + 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() } func renderPlayer(rawAddr string) string { addr := strings.TrimSpace(rawAddr) safe := ui.Inline(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[rps.Rock]) + ", paper: " + strconv.Itoa(ps.Counts[rps.Paper]) + ", scissors: " + strconv.Itoa(ps.Counts[rps.Scissors]) + "\n") if ps.Rounds > 0 { maxCount := ps.Counts[rps.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) }