kind/weather

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  over: object 1..128
10  tide: object 1..128
11def make(state: State, input: MakeInput, context: Abi.Context) -> Activity<Super.Done>:
12  Super.making(state, Lists.List.cons({head: {name: "over", value: input.over}, tail: Lists.List.cons({head: {name: "tide", value: input.tide}, tail: Lists.List.nil()})}), "", context)
13form place:
14  over: object 1..128
15  tide: object 1..128
16  id: object 1..64
17def place(state: State, input: PlaceInput, context: Abi.Context) -> Activity<Super.Done>:
18  Super.making(state, Lists.List.cons({head: {name: "over", value: input.over}, 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 ./Rows.obend as Rows
12import ./Relation.obend as Relations
13import ./Text.obend as Text
14# The weather's body, over RECORD (docs/METAPHYSICS.md §7.2, §7.4 "feed"; TENURE §2): a record made
15# over a place (`over`) and the tide it reads (`tide`), which its owner can set again. As its kind finishes it, it places a rule
16# on its tide under its maker (`made`): at every twenty-fourth tick, a clock day, while someone has
17# been at the place within the day (it was tended: a garden's planting, a room's entering), the tide
18# casts `delvetalk <weather> rain`. A rain writes the weather's line, the place's weather line when the
19# place hangs a door to it (Record.forecast), and sends a rain to each bell the place holds or hangs a
20# door to (the first 48 of those, by their kind), sixteen of them a turn: a `drizzle` it sends itself
21# carries on while any remain (one turn sends at most 32, and reads each candidate's kind), and the
22# last writes the line and the forecast. A bell takes the weather's rain as the weather's line and is not
23# tended by it, so a bell nobody has been near goes quiet and takes nothing. Only its maker's rule on
24# the tide rains, and only while the place was tended within the day: a hand's `rain`, or another's
25# rule there, is refused by name.
26type State = Super.State
27form rain:
28form arm:
29form drizzle:
30  from: natural 0..1000000000
31  rained: natural 0..1000000000
32form write:
33  text: text 1..280
34form lines:
35  from: natural 0..1000000000
36form door:
37  label: text 1..32
38  to: text 1..128
39form undoor:
40  label: text 1..32
41def write(state: State, input: WriteInput, context: Abi.Context) -> Activity<Nat>:
42  Super.write(state, {text: input.text}, context)
43def lines(state: State, input: LinesInput, context: Abi.Context) -> Activity<Card.Replied>:
44  Super.lines(state, {from: input.from}, context)
45def door(state: State, input: DoorInput, context: Abi.Context) -> Activity<Card.Replied>:
46  Super.door(state, {label: input.label, to: input.to}, context)
47def undoor(state: State, input: UndoorInput, context: Abi.Context) -> Activity<Card.Replied>:
48  Super.undoor(state, {label: input.label}, context)
49def actions(state: State, context: Abi.Context) -> Lists.List<String>:
50  Lists.concat(Lists.concat(if context.principal == state.owner then Text.words("rain write lines door undoor set") else Text.words("rain write lines"), if context.principal == state.maker then Text.words("arm") else Text.words("")), Super.repairAction(state, context))
51def lenses() -> Lists.List<Form.Field>:
52  Super.objectLenses("tide")
53def setArms() -> Bool:
54  true
55def methods() -> Lists.List<String>:
56  Text.words("~made ~act ~drizzle")
57# The place it is over: `over`, or `garden` for a weather made before a weather could be over any place.
58def over(state: State) -> String:
59  if Super.field(state, "over") == "" then Super.field(state, "garden") else Super.field(state, "over")
60def tide(state: State) -> String:
61  Super.field(state, "tide")
62# How often it rains, in ticks of its tide (an hour each): once a clock day.
63def every() -> Nat:
64  24n
65# The rule on the tide, as its kind finishes it: named for the weather, cast under its maker.
66def made(state: State, input: {}, context: Abi.Context) -> Activity<Bool>:
67  if context.caller != state.kind then false else placing(state, context)
68def placing(state: State, context: Abi.Context) -> Activity<Bool>:
69  match world.rule({object: {world: context.world, object: tide(state)}, name: Text.identifier(context.object), when: "request.method == \"tick\" and new.ticks % {natText(every())} == 0 and request.clock <= \"{over(state)}\".tended + 1440", then: "delvetalk {context.object} rain"}):
70    case placed(_): Super.armedNow(state, context)
71    case refused(r): Super.unarmed(state, tide(state), r.clause, r.reading, context)
72# Its maker places its rule again (taken off first, if it stood).
73def arm(state: State, context: Abi.Context) -> Activity<Bool>:
74  if Super.mayArm(state, context) == false then Super.armRefused(state, context) else if Text.isObjectId(tide(state)) == false then Super.stranding(state, context) else rearming(state, context)
75def rearming(state: State, context: Abi.Context) -> Activity<Bool>:
76  match world.unrule({object: {world: context.world, object: tide(state)}, name: Text.identifier(context.object)}):
77    case _: placing(state, context)
78# Its maker's rule on the tide rains, while the place was tended within the day; anyone else, or
79# another's rule there, is told what does.
80def rain(state: State, context: Abi.Context) -> Activity<Nat>:
81  if Super.ruledFrom(state, tide(state), context) == false then unruled(state, context) else tended(state, context)
82def unruled(state: State, context: Abi.Context) -> Activity<Nat>:
83  let rule = if Text.isObjectId(tide(state)) then "the weather rains by its rule on {tide(state)}, once a clock day while someone has been at {over(state)}: {Card.tideLine(tide(state))}" else Card.tideLine(tide(state))
84  Card.refusing(0n, {clause: "ruled", reading: rule}, context)
85# The place was tended within the day, read again as the rain comes.
86def tended(state: State, context: Abi.Context) -> Activity<Nat>:
87  match world.viewField::<Nat>({object: placeOf(state, context), field: "tended"}):
88    case viewed(v): if context.clock <= v.state + 1440n then reaching(state, 0n, 0n, context) else unruled(state, context)
89    case _: unruled(state, context)
90def placeOf(state: State, context: Abi.Context) -> Plans.Reference:
91  {world: context.world, object: over(state)}
92# What the place holds, then what it hangs doors to (the first 48), and whether one of its doors is to
93# this weather. A rain begins at the first; a drizzle carries on from where the last turn stopped,
94# with the count of bells rained on so far.
95def reaching(state: State, from: Nat, rained: Nat, context: Abi.Context) -> Activity<Nat>:
96  match world.viewField::<Relations.Relation<Plans.Reference>>({object: placeOf(state, context), field: "things"}):
97    case viewed(v): opened(Relations.rows(v.state), state, from, rained, context)
98    case _: opened(Lists.List.nil(), state, from, rained, context)
99def opened(things: Lists.List<Plans.Reference>, state: State, from: Nat, rained: Nat, context: Abi.Context) -> Activity<Nat>:
100  match world.viewField::<Card.Doorways>({object: placeOf(state, context), field: "cites"}):
101    case viewed(v): chunk(skipping(Lists.take(Lists.concat(things, Lists.map(v.state, fn(d: Card.Doorway) -> Plans.Reference: d.to)), 48n), from), Lists.any(v.state, fn(d: Card.Doorway) -> Bool: d.to.object == context.object), state, from, rained, context)
102    case _: chunk(skipping(Lists.take(things, 48n), from), false, state, from, rained, context)
103# Sixteen of them a turn: each a bell by its kind is rained on; while any remain, the weather sends
104# itself the next `drizzle`; after the last, it writes its line and the place's forecast.
105def chunk(candidates: Lists.List<Plans.Reference>, cited: Bool, state: State, from: Nat, rained: Nat, context: Abi.Context) -> Activity<Nat>:
106  sorting(Lists.take(candidates, 16n), Lists.length(candidates) > 16n, cited, state, from + 16n, rained, context)
107def sorting(candidates: Lists.List<Plans.Reference>, more: Bool, cited: Bool, state: State, next: Nat, rained: Nat, context: Abi.Context) -> Activity<Nat>:
108  match candidates:
109    case nil(_): if more then continuing(next, rained, context) else forecasting(rained, cited, state, context)
110    case cons(c): kinded(c.head, c.tail, more, cited, state, next, rained, context)
111def kinded(thing: Plans.Reference, rest: Lists.List<Plans.Reference>, more: Bool, cited: Bool, state: State, next: Nat, rained: Nat, context: Abi.Context) -> Activity<Nat>:
112  match world.viewField::<String>({object: thing, field: "kind"}):
113    case viewed(v): if v.state == "kind/bell" then wetting(thing, rest, more, cited, state, next, rained, context) else sorting(rest, more, cited, state, next, rained, context)
114    case _: sorting(rest, more, cited, state, next, rained, context)
115def wetting(thing: Plans.Reference, rest: Lists.List<Plans.Reference>, more: Bool, cited: Bool, state: State, next: Nat, count: Nat, context: Abi.Context) -> Activity<Nat>:
116  match world.send({object: thing, method: "rain", argument: {text: rainText(context)}}):
117    case delivery(_): sorting(rest, more, cited, state, next, count + 1n, context)
118    case _: sorting(rest, more, cited, state, next, count, context)
119def skipping(things: Lists.List<Plans.Reference>, count: Nat) -> Lists.List<Plans.Reference>:
120  match things:
121    case nil(_): things
122    case cons(c): if count == 0n then things else skipping(c.tail, count - 1n)
123def rainText(context: Abi.Context) -> String:
124  "{context.object}'s rain, clock {natText(context.clock)}"
125def forecasting(rained: Nat, cited: Bool, state: State, context: Abi.Context) -> Activity<Nat>:
126  let written(_) = write {lines: insert {author: context.principal, handle: context.handle, verb: "rain", text: "rain at clock {natText(context.clock)} on {natText(rained)}", at: context.height, n: state.next}, next: add 1n}
127  if cited then forecastSent(rained, state, context) else rained
128def forecastSent(rained: Nat, state: State, context: Abi.Context) -> Activity<Nat>:
129  match world.send({object: placeOf(state, context), method: "forecast", argument: {line: "rain at clock {natText(context.clock)}, on {natText(rained)}"}}):
130    case _: rained
131def continuing(from: Nat, rained: Nat, context: Abi.Context) -> Activity<Nat>:
132  match world.send({object: Plans.self(context), method: "drizzle", argument: {from: from, rained: rained}}):
133    case _: rained
134# The rain's own continuation, sent by the weather to itself.
135def drizzle(state: State, input: DrizzleInput, context: Abi.Context) -> Activity<Nat>:
136  if context.sender != context.object then Card.refusing(0n, {clause: "ruled", reading: "the drizzle is the weather's own; delvetalk {context.object} rain"}, context) else reaching(state, input.from, input.rained, context)
137def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
138  let rains = if Relations.count(state.lines) == 0n then "; it has not rained yet." else ". Its rains:"
139  let rule = if Text.isObjectId(tide(state)) then ", by its rule on {tide(state)}:\n  {Card.tideLine(tide(state))}" else "; {Card.tideLine(tide(state))}"
140  Document.text("WEATHER over {over(state)}, made by {Card.shown(state.maker, state.makerHandle, context)}{Card.mine(state.maker, context)}: once a clock day, while someone has been at {over(state)} that day, it rains on every bell {over(state)} holds or hangs a door to{rule}\n{Super.inactiveLine(state, id)}A bell nobody has been near takes nothing{rains}\n")