{name}

1layer over ./Kind.obend
2edition ObjectiveBend 1
3import ./Abi.obend as Abi
4import ./List.obend as Lists
5import ./Form.obend as Form
6import ./Rows.obend as Rows
7type State = Super.State
8form make:
9  name: text 1..64
10  size: natural 3..11
11def make(state: State, input: MakeInput, context: Abi.Context) -> Activity<Super.Done>:
12  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.cons({head: {name: "size", value: natText(input.size)}, tail: Lists.List.nil()})}), "", context)
13form place:
14  name: text 1..64
15  size: natural 3..11
16  id: text 1..64
17def place(state: State, input: PlaceInput, context: Abi.Context) -> Activity<Super.Done>:
18  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.cons({head: {name: "size", value: natText(input.size)}, tail: Lists.List.cons({head: {name: "id", value: input.id}, tail: Lists.List.nil()})})}), "", context)

Each thing of this kind runs this layer over what the kind is of.

1layer over ./Record.obend
2edition ObjectiveBend 1
3import ./Abi.obend as Abi
4import ./List.obend as Lists
5import ./Document.obend as Document
6import ./Form.obend as Form
7import ./Plan.obend as Plans
8import ./World.obend as World
9import ./Card.obend as Card
10import ./Scenes.obend as Scenes
11import ./Relation.obend as Relations
12import ./Rows.obend as Rows
13import ./Text.obend as Text
14import ./View.obend as View
15# The hexboard's body, over RECORD (docs/VIEWS.md, the first view that is a board): a board of `size` by `size` hexes
16# (its kind's form, 3 to 11, 7 when none was given), numbered from 0 along each row, top row first. A hand places its
17# colour on an empty hex (`place / cell: N`), once a hex: each placing is the record's mark `hex N`, by whoever placed
18# it, which RECORD's law keeps (a mark is only added). Each hand's colour is the one its first placing came to, in
19# the order hands came (View.player: red, blue, green, …). Its view is the board as hex tiles, an empty hex a button
20# that places the reader's colour there; its card the same board in letters.
21type State = Super.State
22form place:
23  cell: natural 0..120
24form lines:
25  from: natural 1..1000000000
26form door:
27  label: text 1..32
28  to: text 1..128
29form undoor:
30  label: text 1..32
31def lines(state: State, input: LinesInput, context: Abi.Context) -> Activity<Card.Replied>:
32  Super.lines(state, {from: input.from}, context)
33def door(state: State, input: DoorInput, context: Abi.Context) -> Activity<Card.Replied>:
34  Super.door(state, {label: input.label, to: input.to}, context)
35def undoor(state: State, input: UndoorInput, context: Abi.Context) -> Activity<Card.Replied>:
36  Super.undoor(state, {label: input.label}, context)
37def actions(state: State, context: Abi.Context) -> Lists.List<String>:
38  if context.principal == state.owner then Text.words("place lines door undoor") else Text.words("place lines")
39def methods() -> Lists.List<String>:
40  Text.words("~made ~act")
41def views() -> Lists.List<String>:
42  Text.words("view")
43def size(state: State) -> Nat:
44  match Text.number(Super.field(state, "size")):
45    case yes(n): if n.value < 3n then 3n else if n.value > 11n then 11n else n.value
46    case no(_): 7n
47def cellName(n: Nat) -> String:
48  "hex {natText(n)}"
49def columns() -> String:
50  "ABCDEFGHIJK"
51# A hex as a person names it: its column's letter and its row from 1 (`D4`), and its number.
52def where(n: Nat, size: Nat) -> String:
53  "{textTake(textDrop(columns(), n % size), 1n)}{natText(n / size + 1n)}"
54def placed(state: State, n: Nat) -> Lists.Maybe<Rows.Mark>:
55  Relations.lookup(state.marks, {name: cellName(n)})
56def place(state: State, input: PlaceInput, context: Abi.Context) -> Activity<Bool>:
57  let id = Card.called(context, "hexboard")
58  if input.cell >= size(state) * size(state) then Card.refusing(false, {clause: "offBoard", reading: "The board's hexes are 0 to {natText(size(state) * size(state) - 1n)}: delvetalk {id} place / cell: 0"}, context) else placing(state, input.cell, id, context)
59def placing(state: State, n: Nat, id: String, context: Abi.Context) -> Activity<Bool>:
60  match placed(state, n):
61    case some(m): Card.refusing(false, {clause: "taken", reading: "{where(n, size(state))} is {Card.shown(m.value.who, m.value.handle, context)}'s already; an empty hex is a dot on the card: delvetalk {id} ?"}, context)
62    case none(_): placedNow(state, n, context)
63def placedNow(state: State, n: Nat, context: Abi.Context) -> Activity<Bool>:
64  let written(_) = write {marks: insert {name: cellName(n), who: context.principal, handle: context.handle, at: context.height}, tended: set context.clock}
65  Card.tell(true, Document.text("{toneOf(players(state), context.principal)} on {where(n, size(state))}.\n"))
66def isHex(mark: Rows.Mark) -> Bool:
67  Text.starts(mark.name, "hex ")
68# The hands that have placed, in the order they first did (their colours' order).
69def players(state: State) -> Lists.List<Rows.Mark>:
70  firsts(Relations.order(state.marks, fn(m: Rows.Mark) -> Nat: m.at), Lists.List.nil())
71def firsts(marks: Lists.List<Rows.Mark>, seen: Lists.List<Rows.Mark>) -> Lists.List<Rows.Mark>:
72  match marks:
73    case nil(_): seen
74    case cons(c): firsts(c.tail, if isHex(c.head) == false || Lists.any(seen, fn(p: Rows.Mark) -> Bool: p.who == c.head.who) then seen else Lists.append(seen, c.head))
75# A hand's colour: its place among the players, or the next colour for one who has not placed yet.
76def toneOf(players: Lists.List<Rows.Mark>, who: String) -> String:
77  match Lists.indexWhere(players, fn(p: Rows.Mark) -> Bool: p.who == who):
78    case some(i): View.player(i.value)
79    case none(_): View.player(Lists.length(players))
80def name(state: State) -> String:
81  if state.head == "" then "A HEXBOARD" else state.head
82def count(state: State) -> Nat:
83  Lists.length(Lists.filter(Relations.rows(state.marks), isHex))
84def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
85  let n = size(state)
86  let ps = players(state)
87  Document.Document.sequence({items: Document.Documents.cons({head: Document.text("{name(state)}, {natText(n)} by {natText(n)} hexes: {natText(count(state))} placed by {Text.countWord(Lists.length(ps))} hands. Your colour {yours(ps, context)}. Place it on an empty hex (a dot), numbered from 0 along each row: delvetalk {id} place / cell: <0 to {natText(n * n - 1n)}>\n"), tail: Document.Documents.cons({head: Document.text(board(state, ps, n, 0n)), tail: Document.Documents.cons({head: Document.text(Super.inactiveLine(state, id)), tail: Document.Documents.nil()})})})})
88def yours(players: Lists.List<Rows.Mark>, context: Abi.Context) -> String:
89  if Lists.any(players, fn(p: Rows.Mark) -> Bool: p.who == context.principal) then "is {toneOf(players, context.principal)}" else "will be {toneOf(players, context.principal)}"
90# The board in letters, each placed hex its colour's first letter and an empty one a dot, odd rows set in by one.
91def board(state: State, players: Lists.List<Rows.Mark>, n: Nat, y: Nat) -> String:
92  if y >= n then "" else "{indent(y)}{rowText(state, players, n, y * n, n)}\n{board(state, players, n, y + 1n)}"
93def indent(y: Nat) -> String:
94  if y % 2n == 1n then " " else ""
95def rowText(state: State, players: Lists.List<Rows.Mark>, n: Nat, at: Nat, left: Nat) -> String:
96  if left == 0n then "" else "{glyph(state, players, at)}{gap(left)}{rowText(state, players, n, at + 1n, left - 1n)}"
97def gap(left: Nat) -> String:
98  if left > 1n then " " else ""
99def glyph(state: State, players: Lists.List<Rows.Mark>, at: Nat) -> String:
100  match placed(state, at):
101    case some(m): textTake(toneOf(players, m.value.who), 1n)
102    case none(_): "."
103# What the page draws: the board as hex tiles, an empty one a button placing the reader's colour, and who is which.
104def view(state: State, context: Abi.Context) -> View.View:
105  let n = size(state)
106  let ps = players(state)
107  View.stack(View.three(View.heading(name(state)), View.hexes(n, View.tiles(0n, n * n, fn(i: Nat) -> View.Tile: tileAt(state, ps, n, i, context))), View.small(legend(state, ps, context))))
108def tileAt(state: State, players: Lists.List<Rows.Mark>, n: Nat, i: Nat, context: Abi.Context) -> View.Tile:
109  match placed(state, i):
110    case some(m): View.tile("leaf", toneOf(players, m.value.who), "", "{where(i, n)}: {Card.shown(m.value.who, m.value.handle, context)}{Card.mine(m.value.who, context)}", View.nothing())
111    case none(_): View.tile("leaf", "", "", "{where(i, n)}: place {toneOf(players, context.principal)} here", View.act("place", View.given("cell", natText(i))))
112def legend(state: State, players: Lists.List<Rows.Mark>, context: Abi.Context) -> String:
113  let hands = textJoin(Lists.map(players, fn(p: Rows.Mark) -> String: "{toneOf(players, p.who)}: {Card.shown(p.who, p.handle, context)}{Card.mine(p.who, context)}"), " · ")
114  "Your colour {yours(players, context)}. {natText(count(state))} of {natText(size(state) * size(state))} placed{semi(hands)}{hands}."
115def semi(hands: String) -> String:
116  if hands == "" then "" else "; "