v0 state

callerOf

assertOwner

assertAdmin

assertReferee

TransferOwnership

TransferOwnership hands the realm over to newOwner. Owner only. The previous owner keeps no privilege, unless it was also added to the admin or referee lists.

AddAdmin

AddAdmin adds addr to the admin list. Owner only.

RemoveAdmin

RemoveAdmin removes addr from the admin list. Owner only. The owner is an admin by definition and cannot be demoted this way, use TransferOwnership.

SetTreasury

SetTreasury sets the address the sales of skins and planes are forwarded to. Owner only.

AddReferee

AddReferee allows addr to submit kills. Admin only.

RemoveReferee

RemoveReferee stops addr from submitting kills. Admin only.

Owner

Treasury

IsAdmin

IsAdmin reports whether addr is an admin. The owner always is.

IsReferee

IsReferee reports whether addr may submit kills.

errSpoofedRealm

errNotOwner

errNotAdmin

errNotReferee

errInvalidAddress

errAlreadyAdmin

errNoSuchAdmin

errAlreadyReferee

errNoSuchReferee

errTreasurySelf

errUnknownParam

errInvalidBounds

errValueOutOfBounds

errLeaderboardMin

owner

// the single owner, always an admin

admins

// extra admins, managed by the owner: address -> nil

referees

// game servers allowed to submit kills: address -> nil

treasury

// where the sales of the skins and planes realms go

version

// bumps on every admin write, see Version

params

// fixed registry, in display order

pilots

// player address -> int64 kills, allocated at the first kill

killers

// the top players by kills recorded on-chain, see rankings.gno

webPath

// "/r/g1t2kg2vtr3fukg43eujkn6x53gfdyakhngt4sfd/gnofly/game/v0", used to build links in Render

init.37

bootstrap

bootstrap (re)creates the initial state: roles and params.

Version

Version returns a counter that bumps on every admin write: params, treasury and roles. Referee actions (kills) do not bump it. A reader that cached StateJSON only has to read it again when Version changed.

bump

bump marks the admin-tunable state as changed.

webPathOf

webPathOf turns "gno.land/r/g1t2kg2vtr3fukg43eujkn6x53gfdyakhngt4sfd/gnofly/game/v0" into "/r/g1t2kg2vtr3fukg43eujkn6x53gfdyakhngt4sfd/gnofly/game/v0".

itoa

StateJSON

StateJSON returns everything the game needs from the chain, as one JSON object: { "version": 12, "treasury": "g1...", "params": { "plane_speed": 70, "boost_speed": 130 } } The output has no whitespace. It only changes when Version does. The skins are in their own realm, gnofly/nfts/skins.

PlayerJSON

PlayerJSON returns one player as a JSON object: { "address": "g1...", "kills": 17 } The output has no whitespace. An unknown address has zero kills. The skins and planes a player owns are read from their realms (SkinsOf, PlanesOf).

KillLeaderboardJSON

KillLeaderboardJSON returns the top players by kills recorded on-chain as a JSON array, best first, at most leaderboard\_size entries: [ { "address": "g1...", "kills": 17 } ] The output has no whitespace. With equal kills, the player who got there first stays ahead.

quote

quote returns s as a JSON string literal, quotes included. It is for the strings the realm did not validate. Quotes and backslashes are escaped and anything outside printable ASCII is replaced by "?", so the result is valid JSON whatever s holds.

maxKillEntries

// players per SubmitKills call

maxKillCount

// kills per player per call

maxKillsLen

errKillsFormat

SubmitKills

SubmitKills adds kills to players' on-chain counts. Referee only. kills is 1 to 32 entries "address:count" separated by ";", for example g1abc...:3;g1def...:1 Each address must be valid and listed once, each count from 1 to 1000. Anything else aborts the transaction and nothing is recorded. The counts are added to what the players already have, and the kill leaderboard is updated. Kills are player actions: Version does not move.

parseKills

killsEntryError

param

param is one tunable number of the game, with the bounds an admin has to stay within.

paramLeaderboardSize

paramLeaderboardSize is the one param the realm itself consumes. Every other param is only stored here and applied by the game server.

defaultParams

defaultParams returns the registry with its default values. The order is the display order, in StateJSON as well as in Render.

findParam

findParam returns the param registered under key, or nil. The registry is a dozen entries, a linear scan is cheaper than any index.

SetParam

SetParam changes a game parameter. Admin only. The key must exist and the value must be within the bounds of that key, see Render("params"). Lowering leaderboard\_size truncates the kill leaderboard right away. Raising it does not bring back the lines that were dropped: the list fills up again as kills come in.

SetParamBounds

SetParamBounds changes the range SetParam accepts for a key. Owner only. The bounds are the guard rail between the owner and the admins: admins tune values within them, the owner decides how far tuning may go. The current value has to fit the new bounds, so that the registry never holds a value SetParam would refuse.

Param

Param returns the value of a game parameter. It panics on an unknown key.

indexFrom

indexFrom returns the index of the first c in s at or after i, or len(s) when there is none.

digits

digits parses a non-empty string of decimal digits. Kill counts are never negative, so there is no sign to read.

recordedKills

killsOf returns the kills recorded for addr.

ranking

ranking is a leaderboard on a single number that only goes up, the count of kills: the top players, best first, at most leaderboard\_size lines and one line per player. With equal scores, the player who got there first stays ahead. It is kept sorted at write time, so reading it never has to look at every player. Scores only going up is what makes that exact: a player outside the list can only enter it through raise. The two slices are parallel: slices of plain values are one stored object each, where a slice of structs would be one object per line. Measured on gnodev, a line costs about 190 bytes this way.

leaderboardSize

leaderboardSize returns how many lines a leaderboard may hold.

spliceAddrs

spliceInts

spliceInts is spliceAddrs for a column of numbers.

trimRankings

trimRankings cuts the kill leaderboard down to leaderboard\_size.

writeRanking

writeRanking writes a ranking as a JSON array of {"address":"g1...","\<key>":\<score>} objects, best first.

Render

Render returns the state of the game as markdown, for gnoweb: "" overview "leaderboard" the top players by kills "params" the game parameters and their bounds "player/<addr>" one player Everything printed here was validated against a narrow charset when it was written (see validate.gno), and the only caller-supplied value, the address of a player page, is printed only if it is a valid address. Nothing needs markdown escaping.

link

link returns the gnoweb URL of a Render path of this realm.

renderHome

renderLeaderboard

pilotLink

pilotLink returns a markdown link to the page of a player.

renderParams

renderPlayer

validAddress

validAddress reports whether addr is a valid address in its canonical, lowercase form. Bech32 can also be written in all capitals, and address.IsValid accepts that. To this realm the capitals would be a second key for the same account: a second player record, a second line on a leaderboard, an admin who can never be matched to a caller. Bech32 does not allow mixing cases, so looking at the first character is enough.