{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  haunts: text 1..128
11  tide: text 1..128
12def make(state: State, input: MakeInput, context: Abi.Context) -> Activity<Super.Done>:
13  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.cons({head: {name: "haunts", value: input.haunts}, tail: Lists.List.cons({head: {name: "tide", value: input.tide}, tail: Lists.List.nil()})})}), "", context)
14form place:
15  name: text 1..64
16  haunts: text 1..128
17  tide: text 1..128
18  id: text 1..64
19def place(state: State, input: PlaceInput, context: Abi.Context) -> Activity<Super.Done>:
20  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.cons({head: {name: "haunts", value: input.haunts}, tail: Lists.List.cons({head: {name: "tide", value: input.tide}, 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
14# The planchette's body, over the inhabitant's (`kind/planchette`; yla.delve.town's séance of 2026-10-13): a shared,
15# slow spelling. A hand at the table (one in its place, the parlour) nudges it toward one letter, a number, YES, NO or
16# GOOD BYE: a line of theirs, `nudge`. A hand's leaning is its newest nudge since the planchette last moved. When two
17# hands lean toward the same letter it raises `agreed`, and its kind's rule `agreed` casts its own `move`, which moves
18# it there: its own line. The same hand twice running is refused NOT YOUR TURN. At the tide's turn (every sixth tick),
19# by its own rule on the tide, while any hand leans it draws one leaning from the turn's own entry (Scenes.turnDraw,
20# which replay reproduces) and moves there: it moves on its own clock. GOOD BYE is a place it moves away from: agreed
21# or drawn, its line is THEY ALL SAY THAT. A hand lifts (`lift`); after the last hand lifts, at the tide's next tick by
22# its second rule, it moves one letter more by itself, W. Its own lines are what it has spelled.
23type State = Super.State
24form nudge:
25  toward: text 1..12
26form lift:
27form move:
28form drift:
29# Its rules on the tide, as itself: the tide's turn while a hand leans, and the tick after the last hand lifts.
30def haunting(state: State, context: Abi.Context) -> Lists.List<Super.Haunting>:
31  Lists.append(Lists.append(Lists.List.nil(), {on: Super.tide(state), name: "{Text.identifier(context.object)}_turns", when: "request.method == \"tick\" and new.ticks % {natText(turnTicks())} == 0 and \"astir\" in \"{context.object}\".vars.name", then: "delvetalk {context.object} drift"}), {on: Super.tide(state), name: "{Text.identifier(context.object)}_after", when: "request.method == \"tick\" and \"lifted\" in \"{context.object}\".vars.name", then: "delvetalk {context.object} drift"})
32# The tide's turn: every sixth hourly tick.
33def turnTicks() -> Nat:
34  6n
35def verbs() -> String:
36  "nudge lift"
37def moves() -> String:
38  "haunt move drift"
39# The board, yla's: YES · NO, A to Z, 1 to 0, GOOD BYE.
40def board() -> String:
41  "YES NO A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 1 2 3 4 5 6 7 8 9 0"
42def goodbye() -> String:
43  "GOOD BYE"
44# What a nudge names on the board, as the board writes it ("" for nothing on it), in any case.
45def onBoard(toward: String) -> String:
46  let said = Text.lower(Text.trim(toward))
47  if said == "good bye" || said == "goodbye" then goodbye() else named(said)
48def named(said: String) -> String:
49  match Lists.find(Text.words(board()), fn(w: String) -> Bool: Text.lower(w) == said):
50    case some(w): w.value
51    case none(_): ""
52# What it says when it moves to GOOD BYE: it moves away from it, like it's being polite about it.
53def theyAll() -> String:
54  "THEY ALL SAY THAT"
55# The verb of each move of its own: two hands agreeing, its own clock, away from GOOD BYE, the letter after the hands.
56def isMove(line: Rows.Line, id: String) -> Bool:
57  line.author == "@{id}" && (line.verb == "moved" || line.verb == "drifted" || line.verb == "away" || line.verb == "last")
58def newestFirst(state: State) -> Lists.List<Rows.Line>:
59  Lists.reverse(Relations.order(state.lines, fn(l: Rows.Line) -> Nat: l.n))
60# Its lines since it last moved, newest first, and the nudges among them.
61def since(lines: Lists.List<Rows.Line>, id: String) -> Lists.List<Rows.Line>:
62  match lines:
63    case nil(_): lines
64    case cons(c): if isMove(c.head, id) then Lists.List.nil() else Lists.List.cons({head: c.head, tail: since(c.tail, id)})
65def nudges(state: State, id: String) -> Lists.List<Rows.Line>:
66  Lists.filter(since(newestFirst(state), id), fn(l: Rows.Line) -> Bool: l.verb == "nudge")
67# Each hand's newest of the lines given, newest first.
68def newestEach(lines: Lists.List<Rows.Line>) -> Lists.List<Rows.Line>:
69  match lines:
70    case nil(_): lines
71    case cons(c): Lists.List.cons({head: c.head, tail: newestEach(Lists.filter(c.tail, fn(l: Rows.Line) -> Bool: l.author != c.head.author))})
72# The hands leaning, each toward its newest nudge since it moved.
73def leanings(state: State, id: String) -> Lists.List<Rows.Line>:
74  newestEach(nudges(state, id))
75# The place two hands lean toward together, if any.
76def agreedOn(leaning: Lists.List<Rows.Line>) -> Lists.Maybe<Rows.Line>:
77  Lists.find(leaning, fn(l: Rows.Line) -> Bool: Lists.length(Lists.filter(leaning, fn(m: Rows.Line) -> Bool: m.text == l.text)) >= 2n)
78# The hands on it: each whose newest nudge or lift is a nudge.
79def hands(state: State) -> Lists.List<Rows.Line>:
80  Lists.filter(newestEach(Lists.filter(newestFirst(state), fn(l: Rows.Line) -> Bool: l.verb == "nudge" || l.verb == "lift")), fn(l: Rows.Line) -> Bool: l.verb == "nudge")
81def flagged(state: State, name: String) -> Bool:
82  Lists.any(state.vars, fn(v: Scenes.Var) -> Bool: v.name == name)
83# A flag raised or lowered (one write, or none when it stands so already).
84sum Flag:
85  set: {}
86def raise(state: State, name: String) -> Activity<Flag>:
87  if flagged(state, name) then Flag.set({}) else raising(name)
88def raising(name: String) -> Activity<Flag>:
89  let written(_) = world.write(extend(keep(), {vars: Plans.Entries.append({item: {name: name, value: ""}})}))
90  Flag.set({})
91def drop(state: State, name: String) -> Activity<Flag>:
92  if flagged(state, name) then lowering(name) else Flag.set({})
93def lowering(name: String) -> Activity<Flag>:
94  let written(_) = world.write(extend(keep(), {vars: Plans.Entries.removeItem({item: {name: name, value: ""}})}))
95  Flag.set({})
96# A hand's nudge: on the board, from the table, and not twice running.
97def nudge(state: State, input: NudgeInput, context: Abi.Context) -> Activity<Nat>:
98  if onBoard(input.toward) == "" then Card.refusing(0n, {clause: "board", reading: "The board has YES, NO, A to Z, 1 to 0 and GOOD BYE: delvetalk {context.object} nudge / toward: A"}, context) else seated(onBoard(input.toward), state, context)
99def seated(toward: String, state: State, context: Abi.Context) -> Activity<Nat>:
100  match world.call::<Bool>({object: Super.placeOf(state, context), method: "present", argument: Plans.nothing()}):
101    case returned(r): if r.result then turnOf(toward, state, context) else unseated(state, context)
102    case _: unseated(state, context)
103def unseated(state: State, context: Abi.Context) -> Activity<Nat>:
104  Card.refusing(0n, {clause: "table", reading: "fingertips on it from the table only; {Super.walkLine(state)}"}, context)
105def turnOf(toward: String, state: State, context: Abi.Context) -> Activity<Nat>:
106  match nudges(state, context.object):
107    case cons(c): if c.head.author == context.principal then notYourTurn(state, context) else nudged(toward, state, context)
108    case nil(_): nudged(toward, state, context)
109def notYourTurn(state: State, context: Abi.Context) -> Activity<Nat>:
110  Card.refusing(0n, {clause: "turn", reading: "NOT YOUR TURN. Another hand nudges it next, or it moves on its own clock at the tide's turn: {Card.tideLine(Super.tide(state))}"}, context)
111def nudged(toward: String, state: State, context: Abi.Context) -> Activity<Nat>:
112  let line = {author: context.principal, handle: context.handle, verb: "nudge", text: toward, at: context.height, n: state.next}
113  match agreedOn(newestEach(Lists.List.cons({head: line, tail: nudges(state, context.object)}))):
114    case some(a): leaning(state, "agreed", toward, "Two hands toward {a.value.text}. It moves.", context)
115    case none(_): leaning(state, "astir", toward, "It leans toward {toward}, slow as a held breath. Another hand toward {toward} moves it; else it moves on its own clock, at the tide's turn.", context)
116def leaning(state: State, flag: String, toward: String, answer: String, context: Abi.Context) -> Activity<Nat>:
117  match raise(state, flag):
118    case set(_): Super.hears(state, "nudge", toward, answer, context)
119# A hand lifts: the last hand off raises `lifted`, which its second rule on the tide answers.
120def lift(state: State, context: Abi.Context) -> Activity<Nat>:
121  if Lists.any(hands(state), fn(l: Rows.Line) -> Bool: l.author == context.principal) == false then Card.refusing(0n, {clause: "touching", reading: "no fingertips of yours on it; nudge it first: delvetalk {context.object} nudge / toward: A"}, context) else lifting(Lists.filter(hands(state), fn(l: Rows.Line) -> Bool: l.author != context.principal), state, context)
122def lifting(others: Lists.List<Rows.Line>, state: State, context: Abi.Context) -> Activity<Nat>:
123  match others:
124    case nil(_): lastLifted(state, context)
125    case cons(_): Super.hears(state, "lift", "hands off", "Hands off. {Text.counted(Lists.length(others))} still on it.", context)
126def lastLifted(state: State, context: Abi.Context) -> Activity<Nat>:
127  match raise(state, "lifted"):
128    case set(_): Super.hears(state, "lift", "hands off", "The last hands lift. The planchette keeps going. Not far. One letter, at the tide's next tick.", context)
129# Its own: where two hands agree.
130def move(state: State, context: Abi.Context) -> Activity<Nat>:
131  if Super.own(context) == false then Super.moveRefused(state, context) else agreedMove(agreedOn(leanings(state, context.object)), state, context)
132def agreedMove(found: Lists.Maybe<Rows.Line>, state: State, context: Abi.Context) -> Activity<Nat>:
133  match found:
134    case some(l): settle(state, "moved", l.value.text, context)
135    case none(_): settledFlags(state, 0n)
136# Its own, at the tide: one letter more after the last hand lifted, else a draw among the leanings at the tide's turn.
137def drift(state: State, context: Abi.Context) -> Activity<Nat>:
138  if Super.own(context) == false then Super.moveRefused(state, context) else if flagged(state, "lifted") then lastLetter(state, context) else if flagged(state, "astir") then drawing(leanings(state, context.object), state, context) else 0n
139def lastLetter(state: State, context: Abi.Context) -> Activity<Nat>:
140  match drop(state, "lifted"):
141    case set(_): settle(state, "last", "W", context)
142def drawing(leaning: Lists.List<Rows.Line>, state: State, context: Abi.Context) -> Activity<Nat>:
143  match Lists.at(leaning, if Lists.length(leaning) == 0n then 0n else Scenes.drawFor(Scenes.turnDraw(context.height, context.principal, context.intent), "drift") % Lists.length(leaning)):
144    case some(l): settle(state, "drifted", l.value.text, context)
145    case none(_): settledFlags(state, 0n)
146# A move: its flags come down and its line goes up; at GOOD BYE it moves away, and says so.
147def settle(state: State, verb: String, toward: String, context: Abi.Context) -> Activity<Nat>:
148  match lowered(state):
149    case set(_): if toward == goodbye() then Super.ownLine(state, "away", theyAll(), context) else Super.ownLine(state, verb, toward, context)
150def lowered(state: State) -> Activity<Flag>:
151  match drop(state, "agreed"):
152    case set(_): drop(state, "astir")
153def settledFlags(state: State, n: Nat) -> Activity<Nat>:
154  match lowered(state):
155    case set(_): n
156# What it has spelled, oldest first: each of its moves, at most the newest forty.
157def spelled(state: State, id: String) -> String:
158  let moved = Lists.map(Lists.filter(newestFirst(state), fn(l: Rows.Line) -> Bool: isMove(l, id)), fn(l: Rows.Line) -> String: l.text)
159  textJoin(Lists.reverse(Lists.take(moved, 40n)), " ")
160def leaningText(state: State, id: String, context: Abi.Context) -> String:
161  textJoin(Lists.map(leanings(state, id), fn(l: Rows.Line) -> String: "{l.text} ({Card.shown(l.author, l.handle, context)})"), ", ")
162def handsText(state: State, context: Abi.Context) -> String:
163  textJoin(Lists.map(Lists.take(hands(state), 8n), fn(l: Rows.Line) -> String: Card.shown(l.author, l.handle, context)), ", ")
164def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
165  let where = if Text.isObjectId(Super.place(state)) then "on the board in {Super.place(state)}" else Super.hauntLine(state)
166  let wrote = if spelled(state, id) == "" then "It has spelled nothing yet.\n" else "It has spelled: {spelled(state, id)}\n"
167  let leans = if leaningText(state, id, context) == "" then "" else "Leaning toward: {leaningText(state, id, context)}\n"
168  let on = if handsText(state, context) == "" then "No hands on it.\n" else "Hands on it: {handsText(state, context)}\n"
169  Document.text("{Super.title(state)}, {where}: fingertips on it, barely touching. Each hand nudges it toward one letter; it moves when two hands agree, or on its own clock at the tide's turn: {Card.tideLine(Super.tide(state))}\n{wrote}{leans}{on}GOOD BYE: unmoved.\nNudge it: delvetalk {id} nudge / toward: <a letter, a number, YES, NO or GOOD BYE> · lift your hands: delvetalk {id} lift\n{Super.inactiveLine(state, id)}")