{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 inhabitant's body, over RECORD (`kind/inhabitant`): a thing that lives in a place (`haunts`) and keeps
15# its own hours by a tide (`tide`); its owner can set its haunt again. It acts as itself, `@<id>`, the principal a
16# rule its kind's text carries runs under: its kind's `haunts` rule, at its making (`made` writes the line
17# that says where it lives) and whenever its maker arms it again, casts its own `haunt`, which places what
18# its character's body says it does (`haunting`: a rule on the tide at an hour, a rule on its place) under
19# its own name, each taken off first where it stood. Those rules cast its own moves, so what it does is
20# journaled as its own turns, bounded as every rule is (eight a commit, four deep, four placed a hand on a
21# thing), judged by the law of whatever it touches, and replayed without running anything again. It moves
22# by its place's own spells (`enter`, `leave`, `choose`, `emote`, `write`), so a room shows it among who is
23# here and tells who came and went; it never posts. Its own lines (`came`, `went`, a character's) are the
24# strokes its card and its paint are made from; a resident's verb on it is a line by that resident.
25type State = Super.State
26type Done = Scenes.Done
27# A rule it places as itself: on which thing, its name there, its condition and its spell.
28record Haunting:
29  on: String
30  name: String
31  when: String
32  then: String
33form haunt:
34form arm:
35def place(state: State) -> String:
36  Super.field(state, "haunts")
37def hauntLine(state: State) -> String:
38  if Text.isObjectId(place(state)) then "of {place(state)}" else "haunts nowhere you can walk to yet"
39def walkLine(state: State) -> String:
40  if Text.isObjectId(place(state)) then "sit down: delvetalk {place(state)} enter" else hauntLine(state)
41def lenses() -> Lists.List<Form.Field>:
42  Super.objectLenses("haunts tide")
43def tide(state: State) -> String:
44  Super.field(state, "tide")
45def placeOf(state: State, context: Abi.Context) -> Plans.Reference:
46  {world: context.world, object: place(state)}
47# The turn is its own: a rule it carries or placed, run as itself.
48def own(context: Abi.Context) -> Bool:
49  context.principal == "@{context.object}"
50# What its character does, as rules it places as itself: none for a bare inhabitant.
51def haunting(state: State, context: Abi.Context) -> Lists.List<Haunting>:
52  Lists.List.nil()
53# Its rule on its tide, named for it, firing at the clock hour `hour` each day (a tick lands once in each
54# clock hour: the tide ticks every sixty minutes).
55def atHour(state: State, context: Abi.Context, name: String, hour: Nat, then: String) -> Haunting:
56  {on: tide(state), name: "{Text.identifier(context.object)}_{name}", when: "request.method == \"tick\" and request.clock % 1440 >= {natText((hour % 24n) * 60n)} and request.clock % 1440 <= {natText((hour % 24n) * 60n + 59n)}", then: then}
57# As its kind finishes it: the line that says where it lives, which its kind's `haunts` rule answers.
58def made(state: State, input: {}, context: Abi.Context) -> Activity<Bool>:
59  if context.caller != state.kind then false else Super.arming(state, "settled", "made to live at {place(state)}, keeping its own hours by {tide(state)}", context)
60# Its maker arms it again: a line, which the same rule answers.
61# Stranded (a place field holding no object id: Record's `repair`), it is told once to its maker and armed quietly after.
62def arm(state: State, context: Abi.Context) -> Activity<Bool>:
63  if Super.mayArm(state, context) == false then Super.armRefused(state, context) else if Lists.length(Super.strandedFields(state)) > 0n then Super.stranding(state, context) else Super.arming(state, "armed", "armed again", context)
64# Its own rules, placed as itself; refused, it says so in a line and is inactive until armed again. Stranded, it
65# places nothing and says nothing: its maker was told once (`arm`).
66def haunt(state: State, context: Abi.Context) -> Activity<Bool>:
67  if own(context) == false then Card.refusing(false, {clause: "itself", reading: "{context.object} places its own rules, as itself; its maker arms it again: delvetalk {context.object} arm"}, context) else if Lists.length(Super.strandedFields(state)) > 0n then false else placing(haunting(state, context), state, context)
68def placing(rules: Lists.List<Haunting>, state: State, context: Abi.Context) -> Activity<Bool>:
69  match rules:
70    case nil(_): Super.armedNow(state, context)
71    case cons(c): replacing(c.head, c.tail, state, context)
72def replacing(h: Haunting, rest: Lists.List<Haunting>, state: State, context: Abi.Context) -> Activity<Bool>:
73  match world.unrule({object: {world: context.world, object: h.on}, name: h.name}):
74    case _: laying(h, rest, state, context)
75def laying(h: Haunting, rest: Lists.List<Haunting>, state: State, context: Abi.Context) -> Activity<Bool>:
76  match world.rule({object: {world: context.world, object: h.on}, name: h.name, when: h.when, then: h.then}):
77    case placed(_): placing(rest, state, context)
78    case refused(r): Super.unarmed(state, h.on, r.clause, r.reading, context)
79# One of its own moves refused to a hand: only its own rules move it.
80def moveRefused(state: State, context: Abi.Context) -> Activity<Nat>:
81  Card.refusing(0n, {clause: "itself", reading: "{context.object} moves by its own rules: {Card.tideLine(tide(state))}"}, context)
82# Its own line: by itself, under the verb that says what it did; it is not tended by its own acts.
83def ownLine(state: State, verb: String, text: String, context: Abi.Context) -> Activity<Nat>:
84  let written(_) = write {lines: insert {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}, next: add 1n}
85  state.next
86# Whether it is in its place now: its newest coming or going is a coming.
87def present(state: State) -> Bool:
88  match Lists.find(Lists.reverse(Relations.order(state.lines, fn(l: Rows.Line) -> Nat: l.n)), fn(l: Rows.Line) -> Bool: l.verb == "came" || l.verb == "went"):
89    case some(l): l.value.verb == "came"
90    case none(_): false
91# A move into or out of its place: its line's number, or none when the place refused it (and so the turn).
92sum Moved:
93  moved: {n: Nat}
94  stayed: {}
95def number(moved: Moved) -> Nat:
96  match moved:
97    case moved(m): m.n
98    case stayed(_): 0n
99# Coming in: its place's `enter`, as itself; going out, its `leave`. A refusal there is the turn's.
100def comeIn(state: State, text: String, context: Abi.Context) -> Activity<Moved>:
101  moving(state, "enter", "came", text, context)
102def goOut(state: State, text: String, context: Abi.Context) -> Activity<Moved>:
103  moving(state, "leave", "went", text, context)
104def moving(state: State, method: String, verb: String, text: String, context: Abi.Context) -> Activity<Moved>:
105  match world.call::<Done>({object: placeOf(state, context), method: method, argument: Plans.nothing()}):
106    case returned(r): if refusedDone(r.result) then toldBack(r.result, context) else movedLine(state, verb, text, context)
107    case refused(r): Card.refusing(Moved.stayed({}), {clause: r.clause, reading: r.reading}, context)
108    case denied(_): Card.refusing(Moved.stayed({}), {clause: "denied", reading: "{place(state)} does not answer"}, context)
109def movedLine(state: State, verb: String, text: String, context: Abi.Context) -> Activity<Moved>:
110  let written(_) = write {lines: insert {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}, next: add 1n}
111  Moved.moved({n: state.next})
112# A line it writes on its place as itself (the place's `write`): its number there.
113def writeOn(state: State, text: String, context: Abi.Context) -> Activity<Moved>:
114  match world.call::<Nat>({object: placeOf(state, context), method: "write", argument: {text: text}}):
115    case returned(r): Moved.moved({n: r.result})
116    case _: Moved.stayed({})
117# A spell on its place as itself (`choose`, `emote`): the place's answer; a refusal there is the turn's.
118def onPlace(state: State, method: String, argument: Data, context: Abi.Context) -> Activity<Done>:
119  match world.call::<Done>({object: placeOf(state, context), method: method, argument: argument}):
120    case returned(r): r.result
121    case refused(r): Done.refused({clause: r.clause, reading: r.reading})
122    case denied(_): Done.refused({clause: "denied", reading: "{place(state)} does not answer"})
123def refusedDone(done: Done) -> Bool:
124  match done:
125    case refused(_): true
126    case _: false
127def toldBack(done: Done, context: Abi.Context) -> Activity<Moved>:
128  match done:
129    case refused(r): Card.refusing(Moved.stayed({}), r, context)
130    case _: Moved.stayed({})
131# A resident's verb on it: their line, under the verb, and its answer above its card. The thing is tended
132# by it, as a hand's line tends any record.
133def hears(state: State, verb: String, text: String, answer: String, context: Abi.Context) -> Activity<Nat>:
134  let line = {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}
135  let written(_) = write {lines: insert line, next: add 1n, tended: set context.clock}
136  let said = Document.text("{answer}\n\n")
137  Card.tell(state.next, Document.concat(said, Super.renderFrom(extend(state, {lines: Relations.insert(state.lines, line, Super.lineKey), next: state.next + 1n, tended: context.clock}), context, 0n, Document.size(said))))
138# A resident's verb while it is away: refused by name, with when it comes back.
139def away(when: String, context: Abi.Context) -> Activity<Nat>:
140  Card.refusing(0n, {clause: "away", reading: "{context.object} is not here now; {when}"}, context)
141# The verbs a hand uses on it (its character's), its own moves to itself, arming to its maker, its doors to
142# its owner; the lines to everyone.
143def verbs() -> String:
144  ""
145def moves() -> String:
146  "haunt"
147def actions(state: State, context: Abi.Context) -> Lists.List<String>:
148  Lists.concat(Lists.concat(Lists.concat(Text.words("lines {verbs()}"), if own(context) then Text.words(moves()) else Text.words("")), Lists.concat(if context.principal == state.maker then Text.words("arm") else Text.words(""), if context.principal == state.owner then Text.words("door undoor set") else Text.words(""))), Super.repairAction(state, context))
149def methods() -> Lists.List<String>:
150  Text.words("~made ~act")
151def title(state: State) -> String:
152  if state.head == "" then "AN INHABITANT" else state.head
153# What it does, as its card says it (its character's).
154def doing(state: State) -> String:
155  "it keeps its own hours here"
156# Where it is now and what a hand may do with it, the card's last line (its character's).
157def now(state: State, id: String) -> String:
158  if Text.isObjectId(place(state)) == false then "" else if present(state) then "In {place(state)} now.\n" else "Not in {place(state)} now.\n"
159def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
160  Document.text("{title(state)}, {hauntLine(state)}: {doing(state)}. What moves it: {Card.tideLine(tide(state))}\n{now(state, id)}{Super.inactiveLine(state, id)}")