golf state

wearCells

maxData

maxData bounds a version's data: a hole at every limit of the format is about 21 KB.

Publish

Publish puts a course hole's data into its slot as its next version and returns the new id ("garden/7/v2"). Only the owner can. hexData is the hole as course.Encode wrote it, in hex. slot must be the data's own world and order ("garden/7", order 1 to 999), so a mis-edited file cannot replace the wrong hole; the course holds at most 9999 slots (maxCourse). Data identical to the current version's is refused. The version it replaces is archived: its records stay, its bests leave the course standings. note (at most 140 characters, cleaned) says why.

PublishMine

PublishMine publishes a community hole of the caller's own and returns its id: "\<caller>/\<slug>/v1", then v2 and on. Anyone can while publishing is open (SetPublishing); only the same address adds versions. slug is 1 to 32 of a-z, 0-9 and "-". The data is checked as Publish checks it, its world and order aside; its name and note carry no web address. It is playable and recorded, in no cup and not in the course ranking; a new version of a hidden hole stays hidden. The publisher pays the storage deposit (about half a GNOT a version), and nothing published can be deleted.

newestRow

newestRow is the height of an author's newest row in byAuthor ("\<address> \<height> \<slug>"), "" if they have none.

moveAuthor

moveAuthor moves an author's own row in byAuthor (recentKey(height, address)) from the height was to now, "" for none: it stays at their newest row's, and goes with their last.

linkish

linkish spots a web address in a community hole's name or note: "www.", a dot between a letter or digit and two letters ("claim.xyz", "t.me"; not "e.g."), or an IP address, look-alike dots (．。․﹒) read as dots, letters in any case. Basic (the owner can Hide what gets past) and strict on purpose ("St.Andrews" is refused). It reads s a byte at a time: every mark is ASCII, so a non-ASCII character is decoded only to tell İ and the Kelvin sign (which lower-case to ASCII), the look-alike dots and spaces apart.

isLower

isDigit

decodeData

decodeData checks a version's data as it arrives: hex, GG1 within the format's limits, stored lengths bit-exact (DecodeChecked: every later Decode trusts them), and in the one form Encode gives.

nothingNew

nothingNew refuses data identical to the alias's current version: it would reset the hole's ranking for nothing.

dataEntry

worlds

worlds is the course's worlds in play order, with their names on the page.

worldRank

worldRank is a world's place among worlds; any other comes after.

slotKey

slotKey is a slot's key: its world's rank, the world, and the order in three digits, so the slots tree is in course order.

slotKeyOf

slotKeyOf reads a slot, "world/order" (as "garden/7"), into its key.

validSlug

HoleData

HoleData is a version's GG1, in hex, as it was published (an alias gives its current version's): what a golf/v2 or an auditor reads back.

Current

Current is the id of the version an alias ("garden/7", "\<address>/\<slug>") plays now, "" if the alias has none.

Versions

Versions is every version of an alias, oldest first (the newest pageMax if there are more): its id, number, the height it was published at, by whom, its data's sha256, its note, and the version that took its place. slot is the alias, "" (and no versions) for one that has none.

firstVersion

firstVersion is the oldest of now's versions a list shows: the newest pageMax are (now is its alias's current version).

BestOf

BestOf is a player's best finished round on a hole in a mode, 0 if none.

maxPower

maxShots

errShot

The refusals said in more than one place.

errStrokeLimit

The refusals said in more than one place.

errShotTooHeavy

The refusals said in more than one place.

errTooStormy

The refusals said in more than one place.

errUnknownHole

The refusals said in more than one place.

entry

record

record is the hole's record in one mode: who holds it, in how many strokes, 0 if never completed.

bestOf

bestOf is how a best is kept: "\<strokes> \<height> \<period> \<shots>". The height ranks it before a later tie (boardKey); the period and shots let Ghost replay it in its own weather. The mode is in the key.

errBest

errBest is a best not as bestOf writes it: never written, refused if read.

bestStrokes

bestStrokes is a kept best's strokes, 0 for none (a tree's nil).

bestFields

bestFields is a kept best's height, period and shots.

view

view is the rows of a shared index under prefix p, read and written without it. p ends with a space, which no id holds, so its rows are exactly the keys from p to p with the space made a "!".

before

before is how many keys of t sort before k: a binary search by index.

seeded

seeded is a shared index whose first leaf the deployer pays at init, not its first player. Its key "" sorts before every view's rows: no view sees it.

newEntry

draining

draining is an archived hole's drain, per mode: the next player to take out, whether all are out, and the players whose first finish came after it was archived: never counted, so never taken out.

round

assisted

A round is played in one of two modes, each with its own records and rankings: assisted (the full aim preview) or pro (the preview cut short). The chain cannot see a screen: the mode is the player's word.

pro

A round is played in one of two modes, each with its own records and rankings: assisted (the full aim preview) or pro (the preview cut short). The chain cannot see a screen: the mode is the player's word.

modes

A round is played in one of two modes, each with its own records and rankings: assisted (the full aim preview) or pro (the preview cut short). The chain cannot see a screen: the mode is the player's word.

modeOf

modeOf reads a mode's name: "assisted" (or "") or "pro"; anything else panics rather than answer for another mode.

modeNames

modeTitles

modeTitles is how the pages head a mode's board.

courseHoles

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

community

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

holeData

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

slots

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

aliases

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

byAuthor

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

hidden

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

archived

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

rounds

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

bests

bests is the version's results in mode m: player address -> their best finished round there, kept across replays, as bestOf writes it.

boards

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

allTotals

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

totals

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

allRanks

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

ranks

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

idle

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

archiving

The indexes are B+ trees (32 entries a leaf: far cheaper an entry than an AVL node). What players add goes to five of them, shared by every version and mode and seeded at init (views): a first player pays for their own rows only. A B+ tree must not change while it is iterated: no callback below writes to the tree it walks (drain walks a hole's bests and writes the standings).

row

row is one player's standing across the course: their best on each hole counted, summed, and those holes' pars, summed. Its score against par, strokes - par, is what ranks it after its holes.

topSize

named

named reports whether a player has a gno.land name (r/sys/users). Only named players rank: a name takes a registration, so a script cannot fill the boards with free addresses. Every finish is still kept.

nameOf

nameOf is a named player's name, "" for anyone else.

nameish

nameish is a name as r/sys/users registers it (a-z, then a-z, 0-9, "\_" and "-", at most 64), checked again because the pages print names in links.

find

find is the hole with this exact id, nil if none.

current

current is the id an alias points at now: a course slot's or a community hole's current version; "" if it is neither.

mustHole

mustHole is the hole a write names: its exact id. An alias is refused: a new version may have taken its place since the round's shots were chosen.

readHole

readHole is the hole a read names: an exact id, or an alias for its current version.

recentKey

recentKey orders by height, then by what is at that height.

pad

pad writes n in width digits, zeros first: keys that sort as numbers.

rankKey

rankKey orders the course ranking: most holes first, then the best score against par (a hole at par counts the same whatever its par), then the first there, then the address. The score is signed: vsParBias puts it in seven digits. The holes take five: a standing can count more than the course's slots while a republished hole drains (its old best still counts, its new one adds a hole), so they get room well past maxCourse.

maxCourse

maxCourse bounds the course's slots (Publish); a standing's holes are at most those plus the archived versions drain has not taken it out of yet. vsParBias is more than a standing can be under or over par: a hole is -18 to +59 (1 to 60 strokes, par 1 to 19), so a full course at most 9999 \* 59 = 589,941 over, 179,982 under, and the seven digits hold 55,555 holes.

vsParBias

maxCourse bounds the course's slots (Publish); a standing's holes are at most those plus the archived versions drain has not taken it out of yet. vsParBias is more than a standing can be under or over par: a hole is -18 to +59 (1 to 60 strokes, par 1 to 19), so a full course at most 9999 \* 59 = 589,941 over, 179,982 under, and the seven digits hold 55,555 holes.

boardKey

boardKey orders a hole's board by each player's best v: fewest strokes, then the first to make them (a best's shots are public: whoever replays them ties it and ranks after), then the address.

boardStrokes

boardStrokes is the strokes of a board's key: always its three digits.

setRow

setRow moves a player's standing, as of height at, and keeps the ranking in step. A standing with no hole left is not freed, nor its key, which moves to idle: its deposit is the player's, and freeing it would refund whoever drained it. It moves back at the player's next hole.

improve

improve moves a player's standing by a new best on an official hole of par par (was: their old best there, 0 if none): only those count, or anyone's own hole would be a way to the top. The standing is kept, not recomputed, so a finish costs the same however many play.

retire

retire archives an official hole replaced by next. Its bests stay there as its records but leave the course standings, in batches (drain): the Publish takes retireBatch, each course finish finishBatch, a Drain up to drainMax.

retireBatch

How many archived players a Publish, a course finish and a Drain take out of the standings: sized so none costs more however many played.

finishBatch

How many archived players a Publish, a course finish and a Drain take out of the standings: sized so none costs more however many played.

drainMax

How many archived players a Publish, a course finish and a Drain take out of the standings: sized so none costs more however many played.

drain

drain takes up to n archived players out of the standings, oldest archived hole first.

Drain

Drain takes up to n players (1 to 400) of archived holes out of the course standings, sooner than the finishes would, and returns how many archived holes still have players in them. Anyone can call it. A standing it empties is kept at 0 holes (setRow): nothing is refunded to the caller.

counts

counts reports whether a best on e by player (was: their previous best, 0 if none) moves their standing: e is a current official hole, or an archived one whose drain has not reached them yet and where they already counted. A first finish on an archived hole never counts.

Launch

Launch plays one shot of the caller's round on hole (an exact id): angle in degrees (0 = right, 90 = down), power in (0, 10]. It is how gnoweb plays, with no aim preview, so its rounds are pro rounds. It answers with where the ball stopped, or the score if holed; PlayRoundAt commits many shots.

aim

aim is the angle, in the shot's degrees, and the straight-line distance from a ball to the cup: walls and slopes are the player's to allow for.

PlayRound

PlayRound is PlayRoundAt in the current period, for a caller with none to give (a form, a script); a round under way keeps its own. Prefer PlayRoundAt: a commit included after the weather turned is then played in the weather its shots were chosen in.

PlayRoundAt

PlayRoundAt replays shots into the caller's assisted round on hole (an exact id), continuing it, in the weather of period: the current one or the one before, and a round under way keeps its own. The client sends decisions, never outcomes: the chain replays them. shots is "angle,power\[,tick];…" (MsgCall carries no slice), at most 12, fewer on a heavy hole: a commit past the work budget is refused with the number of shots that fit, and the rest goes in the next commit.

PlayRoundPro

PlayRoundPro is PlayRoundAt for a round played in pro mode: the aim preview cut short. It counts on the pro records and rankings only.

playRound

otherMode

otherMode refuses to go on with a round in a mode it was not started in.

shotList

shotList is a commit's shots: the non-empty entries of "a,p;a,p;…", at least one and at most maxShots.

work

work is a commit's estimated gas so far. A shot counts the larger of its path's estimate and its Shot.Work's, plus its pulses' set-up, on top of what the commit spent before its shots (fixed: decoding, forecast). A shot that could pass workBudget is refused before anything is kept, and each is played under a work cap (physics.Field.Cap), so no commit can pass it; the client mirrors the model. An estimate, not a gas meter: see docs/golf.md, "The work budget".

workBudget

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerShot

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerWall

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerPoint

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerPiece

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerUnit

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerPulseWall

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

workPerPulsePost

The budget: of the 2e9 gas a wallet lets a transaction simulate, 1.4e9 for a commit, decoding and forecast included; the rest for package loads and bookkeeping.

decodeBase

Decoding a hole's data costs at most decodeBase and decodePerByte a byte.

decodePerByte

Decoding a hole's data costs at most decodeBase and decodePerByte a byte.

fixedGas

fixedGas is what a commit on e spends before its shots, in the forecast fc: decoding the hole, and drawing the forecast.

decodeGas

decodeGas bounds decoding size bytes of a hole's data.

maxShotGas

maxShotGas bounds a hole's heaviest shot (shotBound and its pulses' set-up): a hole past it is refused at publish.

minShotWork

minShotWork is the work, in the physics' units, a commit's first shot may always do whatever the weather: four fifths of MaxWork. A shot is capped at what is left of the budget (work.next), so a hole whose dearest weather would leave less is refused at publish (worstGas): on a published hole, every shot of less than minShotWork plays out in any weather (as a commit's first, if need be), and an author whose board is too heavy is told at publish, not by a hole that misbehaves in the rain. A shot past it may be cut short; none is known: the course's heaviest real shot does 441,737 over the full grid of tee shots (mountain/16, full power, in a storm), and the heaviest found in an adversarial search 0.74 of MaxWork (docs/golf.md); the course's tightest room in its dearest weather is 839,278 (mountain/7), 39,278 over the floor.

worstGas

worstGas is what a commit on h (size bytes of data) spends up to a first shot of minShotWork in its dearest weather: decoding, the forecast at its most (course.WorstForecastWork), and the shot, its walls and its pulses' set-up, as work.next caps it.

newWork

newWork is a commit's work on a hole, before any shot: its walls and pieces, a pulse's as if always there, and the weather's.

shotBound

shotBound is the most one shot on a board of walls walls can cost: the physics ends a stroke at MaxWork, passing it by MaxWorkStep at most.

pieces

pieces counts what a ball is tested against: each wall, post and zone, and each edge of a zone's polygon.

Reset

Reset abandons the caller's round under way on hole (an exact id), freeing its storage: the next stroke starts a new one from the tee. A finished round is not kept (its best is), so a new one needs no Reset. With no round under way it does nothing, and says nothing.

validShot

validShot refuses what would poison a round and returns the shot as recorded. NaN and infinities pass every comparison, so they are refused by name. The power is quantized before it is checked (0.00001 would round to 0). The angle is brought into (-360, 360), so a huge one cannot overflow to NaN in the physics, and again after rounding (-359.99996 is -0, not -360).

resolve

resolve checks what the physics returned for a stroke: a path a read may print, and a ball that is a number. A hole is anyone's data.

back

back brings a ball that came to rest off the board (a leak in a hole's walls) back to from, where the shot started; the stroke counts, with no penalty. Every stroke golf plays or replays goes through it.

stroke

stroke resolves one shot into the round and reports whether it was holed.

seat

seat puts a named player where their best puts them: on the hole's board, in its record if it tops it, and in the course ranking if they stand in it. Every finish does it, improved or not, so a player named since ranks.

Claim

Claim ranks the caller's bests kept while they had no name: on the boards of the course's current holes, in both modes, and in the course ranking. It returns how many bests it seated, and refuses a caller with no gno.land name. It reads the course's holes only, so it costs the same for everyone.

maxRoundStrokes

maxRoundStrokes bounds a round's history (Round shows it); maxPath the path a hole may return for a stroke (an honest one: a few hundred points).

maxPath

maxRoundStrokes bounds a round's history (Round shows it); maxPath the path a hole may return for a stroke (an honest one: a few hundred points).

q4

q4 rounds to the precision a shot is recorded at.

maxTick

maxTick bounds the third field of a shot: any timed piece turns in fewer.

parseShot

parseShot reads "angle,power" or "angle,power,tick". The tick is where the timed pieces were when the player let go (0 if absent), clamped to 0..maxTick.

clampTick

clampTick reads a tick: an optional sign and digits, clamped to 0..maxTick, even past what an int holds.

roundOf

roundOf is the player's round under way on e, or a new one from the tee, not stored: its commit stores it if it does not finish it.

maxName

maxName and maxNote bound a hole's name and a version's note.

maxNote

maxName and maxNote bound a hole's name and a version's note.

cleanName

cleanName keeps a hole's name to one short line of plain text (cleanText), with at least a letter or a digit in it.

cleanText

cleanText keeps an author's text to one line of plain text, at most max characters: no control, format (Cf: bidi, zero-width, tags) or nonspacing (Mn: stacked accents, variation selectors) characters, no blank-looking ones, nothing that ends a markdown table cell or opens a link, a tag, an HTML entity, a strikethrough, a mention or an email link.

maxSkin

maxSkin bounds a skin's length.

cleanSkin

cleanSkin keeps a skin to what it is meant to be: a short lower-case id.

owner

pending

self

self is golf's own pkgpath, hub its gnoweb path: every link follows from them, so the same code serves under any namespace.

hub

self is golf's own pkgpath, hub its gnoweb path: every link follows from them, so the same code serves under any namespace.

officialPrefix

// the namespace's realms, as "…/"

playURL

playURL is the 3D client every page links to (SetPlayURL moves it).

successor

successor is the realm that took this course over, "" until the owner names it, once (SetSuccessor).

init.143

setUp

setUp is init: the deployer owns the course, and community publishing starts closed. Only \`gno test\` (chain "dev") runs it with no signer: the owner stays "", which holds no power, and publishing starts open, since nobody there could open it.

Owner

Pending

Successor

Successor is the realm that took this course over, "" if none.

isOwner

isOwner is the one owner check: a live role, held by the caller.

Transfer

Transfer offers the role to another address, which takes it with Accept. Offering it to the owner themselves cancels an offer.

Accept

Accept takes the role a Transfer offered the caller.

Renounce

Renounce gives the role up for good: no owner, no offer, and none possible.

maxURL

maxURL bounds the play link, maxPkgPath a successor's pkgpath.

maxPkgPath

maxURL bounds the play link, maxPkgPath a successor's pkgpath.

SetPlayURL

SetPlayURL moves the link every page gives to the 3D client. Only the owner can. url is https://, at most 100 of letters, digits and "-.\_~/:%", with no query or fragment: a hole's link adds "?cup=…&hole=…" to it.

validURL

SetSuccessor

SetSuccessor names the realm that takes this course over, once and for good: a pkgpath under gno.land/r/, not golf itself, with no "", "." or ".." segment. Only the owner can. It moves and blocks nothing: the pages and Holes say where the course went, and play goes on here. golf does not check the realm exists: check the path before sending.

Hide

Hide takes a community hole ("\<address>/\<slug>", every version) off the lists (the hub, Holes, the 3D game), for a scam or abuse in its name or note; hide=false puts it back. Only the owner can. Its data, rounds and page stay, Community still has it, and a new version stays hidden. A hole already as asked is left alone, with no event.

publishing

publishing is whether anyone can publish a community hole (PublishMine): closed at deploy (setUp), opened later without a redeploy.

Publishing

Publishing is whether PublishMine is open.

SetPublishing

SetPublishing opens community publishing (PublishMine) or closes it again. Only the owner can. Closing stops new holes and versions only: every hole published stays playable and listed. Setting it as it is does nothing.

validPkgPath

EventHolePublished

// hole, slot, sha, by, official ("true"/"false")

EventHoleRetired

// hole, next

EventShot

// hole, player, strokes, mode, shot ("angle,power,tick" as recorded)

EventHoled

// hole, player, strokes, mode, shots (the round's)

EventRoundReset

// hole, player

EventOwnershipOffered

// owner, to

EventOwnershipOfferCancelled

// owner

EventOwnershipTransfer

// from, to

EventOwnershipRenounced

// from

EventPlayURLSet

// url

EventSuccessorSet

// successor

EventHoleHidden

// slot, hidden ("true"/"false")

EventPublishingSet

// open ("true"/"false")

wearRunes

// pristine grass blank: a shot's dots stand out on it

wearLight

wearRunes draw a cell's wear: none, then up to wearLight, wearWorn and wearGroove balls come to rest there, and past.

wearWorn

wearRunes draw a cell's wear: none, then up to wearLight, wearWorn and wearGroove balls come to rest there, and past.

wearGroove

wearRunes draw a cell's wear: none, then up to wearLight, wearWorn and wearGroove balls come to rest there, and past.

maxTunnels

maxTunnels is how many tunnels the board numbers, 1 to 9.

markWall

markPost

markCup

// not O: in gnoweb's font O and the post's 0 look alike

markTee

Render

Render is the game as text: gnoweb draws the board and submits the shot. Paths: "" the hub; "\<world>" a cup's holes; "\<address>" the holes an address published; "\<hole>" a hole's page, "\<hole>/\<address>" the same with that player's ball, "\<hole>/data" a version's provenance and data. \<hole> is a version's id or an alias. A query string ("?…") is ignored.

noSuch

noSuch is the page for a path that is no hole, cup or address.

lookup

lookup is readHole that answers nil for no hole.

playLink

playLink is the 3D client's link to this hole: a current course hole by cup and order, any other by its id, which no newer version can take.

cupName

cupName is how a world is called on the page.

who

who is a player as a link to their gno.land profile.

renderHub

moved

moved is the banner a course taken over shows on every page.

renderCup

renderCup is a cup's page: its current holes, in order.

renderAuthor

renderAuthor is the holes an address published, as their current versions.

bestCell

bestCell is a hole's records, assisted then pro, for a table cell. names caches holders: r/sys/users is read once a player, not once a record.

weatherNote

weatherNote is the hole's weather now (f, the forecast of this period) and how long it lasts, on a hole's own page.

noAdmin

noAdmin states who can change what, the owner's own powers included.

source

source links a hole's data page: read it before trusting it with a round.

md

vsPar

vsPar is a score against par: "even", "+3", "-2" (ufmt has no %+d).

flatRolls

flatRolls is how far a shot rolls on flat grass (a tee shot's Kick, the usual friction).

renderHole

roundSummary

roundSummary is how a player stands on the hole: their round under way, if any, and their best in each mode, with where it puts them on the hole's board, or why nowhere. A holed round is not kept: its best is.

shotsOf

shotsOf is a round's shots for a page: golf's own "%.4f,%.4f,%d", digits and punctuation only.

renderData

renderData is a data version's page: where it came from, its versions, and its data, which is all the hole there is.

board

board is the version's board in mode m: boardKey(best, player) -> player, the named players' bests, fewest strokes first.

drawZone

drawZone marks the cells whose centre the zone holds, as the physics sees it (physics.Zone.Contains): a polygon's row from where the centre line crosses its edges, an ellipse's as the run the physics' test finds from its middle.

boxCells

boxCells is the cells from int(lo) to int(hi), within 0..n, whose centre lies in \[lo, hi): the cells the physics' box test takes.

cellAt

cellAt is the first cell in \[lo, hi), lo >= 0, whose centre is at or past c (!(x+0.5 \< c), as the physics compares), hi if none: ceil(c-0.5).

firstCell

firstCell is the first x in \[lo, hi) where ok turns true, hi if it never does: ok is false up to some x, and true from there.

fillRow

span

span is the cells from int(lo) to int(hi), within 0..n.

maxBoardWork

maxBoardWork bounds a board's drawing, in thousands of gas (boardWork): past it the page does not draw, far under the 3e9 a query may use.

boardWork

boardWork estimates board's cost in thousands of gas, with measured weights: a board cell; a cell and a polygon edge per row of a zone's box (every edge counted as crossing, as a zigzag's do); a step along a wall; a cell of a post's box.

key

key names the board's fixed marks it shows (tee and cup always), with the skins of the walls drawn \`#\`.

legend

legend names the pieces the hole gave a skin (a slope with the way it falls), and the skins of its \`#\` walls.

mark

mark counts a ball come to rest in wear cell i.

wearRune

wearRune takes wear-cell coordinates.

trace

trace draws a wall as points every half unit, put inlined: a board has thousands.

fill

fill draws a post: the cells whose centre is within its radius. LenCmp skips Len's software square root.

put