arena state

moveWindow

// seconds a player has for each move

openWindow

// seconds an open challenge stays on the board

maxBox

// bytes

maxPage

maxCleared

// expired challenges one Challenge deletes at most

idDigits

phaseOpen

phaseReveal

phasePlay

phaseEnded

phaseExpired

// reported for an open match past its expiry, never stored

lastID

OpenChallenge

OpenChallenge is an open challenge as the board lists it.

Challenge

Challenge posts a challenge for clan with the seals of the challenger's deck and round-1 plan, the box holding both, and an opponent who alone may accept, or none. It returns the new match's id. It first deletes up to 8 expired challenges, whoever posted them.

Open

Open lists open, unexpired challenges, newest first: limit of them after skipping offset. limit is 1 to 50.

forget

forget deletes open challenge id and its place among its challenger's matches. Its entry on the open list is the caller's to remove.

checkPage

boxBytes

boxBytes decodes a box argument: the standard base64 of 1 to maxBox bytes, in the one form that encodes them, so Match returns every box exactly as it was sent.

canonical

canonical accepts a valid address in the lowercase form callers carry. bech32 also allows uppercase, which would never equal a caller's address.

validSeal

validSeal accepts a sha256 sum in lowercase hex.

chunkSize

// match ids per chunk

addressSize

// bytes in an address's text

sealSize

// bytes in a raw sha256 seal

lockSize

openSize

standingFix

// a standing's bytes before its per-clan counts

clanSize

planBits

// bits per round in a side's plans: 2 for the length, 6 per card

cardBits

maxPlanLen

maxRound

maxPool

// cards in a clan's pool; a deck is one bit per pool card

bitsAt

bitsAt returns the width bits of v starting at bit at.

withBits

withBits returns v with the width bits at bit at replaced by x.

mask

planAt

planAt returns the plan made for round, or nil when it is not yet made.

withPlan

withPlan returns plans with round's plan set to p.

plansMade

plansMade counts the rounds from the first that have a plan.

planOffset

deckOnPool

deckOnPool returns deck, a set of card ids, as one bit per card of pool in id order.

deckFromPool

deckFromPool is the inverse of deckOnPool.

cardsIn

writer

reader

record

record is a match as the arena works on it, decoded from its stored bytes. clans holds each side's index in the ruleset plus one, 0 for none; decks and plans are the engine's card sets and the packed plans of withPlan; hp is the HP after each round, per side; carried holds only the Vulnerable and Strength left after the last resolved round. deckSeal and seal are 64 hex characters; box is the raw bytes, up to maxBox, stored with a 2-byte length.

flagOpponent

flagDeckSeal

flagSealBox

phaseNames

The value of each name is its index; 0 of result and reason is none.

resultNames

The value of each name is its index; 0 of result and reason is none.

reasonNames

The value of each name is its index; 0 of result and reason is none.

nameIndex

nameAt

encodeMatch

decodeMatch

clanNibble

clanNibble is a clan's stored form, its ruleset index plus one, checked against rules.

poolOf

poolOf returns the card pool of clan, 0 for no clan.

chunkRecord

chunkRecord returns the record in slot, or "" when it is removed or beyond the chunk.

withChunkRecord

withChunkRecord returns chunk with slot's record set to rec, adding empty slots up to it.

playerRecord

playerRecord is what the arena keeps per player: the ids of their matches, oldest first, their standing, nil until their first rated match, and the session locks that bind a session key to one match.

standing

standing is a player's rated record. lastClan is the clan number, index plus one, of their last rated match; perClan\[i] counts their rated matches with clan number i + 1.

sessionLock

decodePlayer

A player's bytes are a 2-byte id count, the ids at 4 bytes each, a 1-byte standing length, 0 for none, the standing, then the locks. A standing is the rating, wins, losses and draws at 2 bytes each, the last clan at 1, then a 2-byte count per clan. ceiling: joining a match or changing a lock rewrites all of a player's ids, up to 65,535, so gas grows with their matches; an avl index of ids per player if some play thousands.

decodeStanding

decodeStanding reads only the standing of a player's bytes, skipping their ids, so its cost does not grow with the player's matches; nil when they have none.

withStanding

withStanding returns a player's bytes s with their standing replaced by st. It copies the ids and locks without reading them, so its cost does not grow with the player's matches.

readStanding

encodePlayer

writeStanding

ladderKey

ladderKey orders the ladder: highest rating first, then address order.

clanRecord

clanRecord is a clan's rating and its record in rated matches against other clans.

decodeClans

The clan records are one string holding, per clan in ruleset order, the rating at 2 bytes and the wins, losses and draws at 4 each. decodeClans returns n clans; a clan past the end of s has no rated match yet.

encodeClans

openEntry

openEntry is a challenge on the board: its match id and expiry in Unix seconds.

openEntries

encodeOpen

guard

guard binds the session that signed the transaction to match id, held in m, saving the caller's record only when its locks change.

join

join adds match id to the caller's record and binds the session that signed the transaction to it, refused when that session is bound to a match already.

signingSession

lockSession

lockSession binds session to match id, refused when bound to another, or any when opening. It drops expired locks and any lock its key holds under another expiry (Unix seconds, 0 never).

self

self is the arena's package path; a deploy under another path changes it.

pagePath

pagePath is where the page lives on its origin, the start of every trigger's link; the registry accepts only a link that starts with "/".

init.81

tell

tell emits kind to player about match id. It emits nothing when player made the call, so an event never names its caller.

tellBoard

tellBoard emits Board about match id, whose change altered the open-challenge list. It names no address, so a caller cannot aim it at one player's browser.

tellEnded

tellEnded sends Ended to each player of the finished match m, numbered id, but caller, one event each, since gnotif reads only the first value of a repeated attribute.

endText

endText says how m ended to the player on side.

Accept

Accept answers open challenge id as clan, with deck and the round-1 plan in plain text. When the challenge names an opponent, only that address may accept.

Reveal

Reveal opens the challenger's sealed plan for the round being played, and on the first reveal the sealed deck, then resolves the round. A match that goes on needs nextSeal and nextBox for the challenger's next plan; one that ends takes neither.

Play

Play records the acceptor's plan for the round being played.

Resign

Resign withdraws the caller's open challenge, expired or not, deleting it, or concedes a running match.

ClaimForfeit

ClaimForfeit ends a running match whose deadline has passed: the player who had to move loses. Any wallet may claim it; a session may claim only a match its wallet plays.

find

lookup

lookup returns the match id names, false when there is none. Only an id's own decimal text names it, never "01" or "+1".

stateOf

stateOf rebuilds the engine state the next round of m starts from. A round is resolved once the challenger's plan for it is stored; the specials of resolved rounds are spent.

checkSeal

checkSeal panics unless seal is the sha256 of salt's bytes followed by text.

clanNumber

clanNumber is clan's index in rules plus one, as a record stores it, or 0 when no clan has that name.

clanName

clanName is the name of the clan a record stores as n, "" for none.

planOf

planOf maps comma-separated card names to the engine's ids.

deckBits

deckBits returns deck as the engine's bit set, panicking unless it is legal for c. A card named twice is illegal, so a legal deck text holds exactly the deck's names.

legal

samePlan

resultName

reasonOf

reasonOf says why a finished match ended: a gnome at 0 HP or less is a knockout.

MatchSummary

MatchSummary is one match as a player's list shows it. Round is the round being played, or the last one resolved once the match is over. ToMove is the address that must move next, empty when none. Deadline is the end of the current move's 24 hours, or the expiry of an open challenge, in Unix seconds. Opponent is the address an open challenge is reserved for, "" when anyone can accept it and once accepted.

MatchView

MatchView is everything one match screen needs. Plans holds \[challenger, acceptor] for each resolved round, and for the round being played while the match runs, "" while a plan is sealed or not yet made; HP holds both sides' HP after each resolved round; Box is the challenger's encrypted pending plan, in base64.

SessionLock

SessionLock binds the session key at address Session to the match whose id is Match. Expires is the session's expiry in Unix seconds, 0 for none.

Standing

Standing is one player's place on the ladder. Rank is 1 for the highest rating and equal ratings share it; Rank is 0 and Rating 1000 for a player with no rated match. Name is the player's gno.land name, "" without one. MainClan is "" until their first rated match.

ClanStanding

ClanStanding is one clan's record across rated cross-clan matches.

Leaderboard

Leaderboard lists rated players, highest rating first: limit of them after skipping offset.

StandingOf

StandingOf returns player's standing, rated or not.

RatedPlayers

RatedPlayers counts the players on the ladder.

ClanStandings

ClanStandings lists every clan of the ruleset, highest rating first; equal ratings keep ruleset order and share a rank.

standingOf

standingOf is player's standing without its rank.

nameOf

nameOf is player's gno.land name, "" when they have none.

Locks

Locks lists player's session locks. It can include locks whose session has expired.

Matches

Matches lists player's matches, newest first: limit of them after skipping offset.

Match

Match returns the view of match id.

deckText

deckText names the cards of deck in card id order.

planText

planText names the cards of p in play order.

startRating

maxRating

// a ladder key holds the rating in 2 bytes

playerK

clanK

expectedTable

expectedTable is the expected score, in thousandths, of a side whose opponent is rated 0, 25, …, 400 points above it: 1 / (1 + 10^(d / 400)), rounded.

expected

expected is the expected score, in thousandths, of a side rated a against one rated b. The gap is capped at 400 points and rounded to the nearest 25.

eloChange

eloChange is the change, rounded to the nearest point, of a side rated a that scored score thousandths (1000 a win, 500 a draw, 0 a loss) against one rated b.

applyChange

applyChange gives a the change delta and b its negative, each kept within 0 to maxRating.

clampRating

rate

rate counts match m, which has just ended, in both players' standings and on the ladder, and in the clan records when two different clans met. A match its challenger accepted is not rated.

ratedStanding

ratedStanding returns a's standing, created at startRating for a first rated match, with a count for every clan of rules, and takes its key off the ladder until it is counted.

scoreOf

scoreOf is the challenger's score, in thousandths, in a match that ended with result.

tally

rankOf

rankOf is the rank a rating holds: 1 plus the number of players rated above it.

notFound

Render

Render serves the board of open challenges at "", one player's matches at "player/\<address>", and one match at "match/\<id>".

renderBoard

renderPlayer

renderMatch

outcome

matchLink

date

orNone

chunks

// 4-byte chunk number → chunk string

players

// address → player string

ladder

// ladderKey of every rated player → nil

clanRecords

openList

chunkKey

loadMatch

loadMatch returns match id, or false when it does not exist or was removed.

saveMatch

dropMatch

dropMatch removes match id; an absent id is left alone.

putRecord

stringAt

stringAt returns the string under key, "" when there is none.

loadPlayer

savePlayer

loadStanding

loadStanding returns a's standing, nil before their first rated match.

saveStanding

openAdd

ceiling: each change rewrites the whole open list, 8 bytes per open challenge, so its gas grows with the board; an avl index keyed by expiry and id if the board holds thousands.

openRemove

openNewest

openNewest returns up to limit unexpired ids, newest first, after skipping offset of them.

openClear

openClear removes up to max expired entries from the front and returns their ids.