How the characters live

Seventeen characters share the world with the player, and every one of them takes a turn after each of the player's -- wherever it is, seen or not. A character is an ordinary object record with a slot in CHARACTERS pointing into a small script, and what it does is always an action tried as if it had typed it, through the same code as the player's (How a sentence is understood). This page is the machinery, and twenty real turns of it.

The slots

Seven bytes each, from CHARACTERS, read from the tape: the character, how many of its ordinary scripts a random switch may choose among, where its script has got to, its script table, and how many of the player's orders it takes at once. Three slots are empty on the tape and are filled in by arrival hooks when the story reaches their characters. The step names are the listing's labels.

The steps

A script is a list of steps. The low four bits of a step's first byte are its opcode (read from CHARACTERS_ACT's own tests):

and three more bits of the same byte change how it is taken:

The whole of every script is written out on the Characters page.

A character's turn

END_OF_TURN calls CHARACTERS_ACT, which goes through the slots in order. For each character (read):

1. It becomes the subject of the sentence: ACTING, ACTOR and ACTOR_AT are set to it, and printing is turned off.
2. If the player can see it, printing is turned on -- unless the player is in the dark, when the first thing anyone does is only heard, “you hear a noise.”, and nothing else is printed.
3. If something holds it (CAPTIVE), it tries to climb out, or does nothing if that something is closed.
4. If an order is waiting for it and the step it is on may be interrupted, it takes the order instead (TAKE_ORDER): that is its turn.
5. Otherwise it runs steps from where its script has got to. A step that is tried goes through ACTOR_TRIES: WOULD_WORK tests it exactly as the player's commands are tested, and only then does DO_ACTION do it and NARRATE_ACTION tell it. A refused step (STEP_REFUSED ($99AA)) is counted and the script goes on at its fallback or the next step; one that works, a pause, or six refusals end the turn.

So what a character does is decided and done whether anyone sees it or not; the player is told only what happens in sight. The runs below show both, because the sentences were captured at PRINT_CHAR before its gate, while DOING_IT said the action was real, which is where the out-of-sight ones are composed and then not printed.

Twenty turns of WAIT

A game started as the build starts one, and WAIT typed at the first prompt 20 times, in Bag End, in SkoolKit's simulator. Probes on CHARACTERS_ACT's slot loop ($9826), each step it considers (SCRIPT_STEP, $9885), the refusals ($99AA), the random switches, DO_ACTION's call from ACTOR_TRIES ($9A32) and REACT recorded each character's turn; the places are the object records' location bytes after each turn. Gandalf, Thorin and the vicious warg:

gandalf

Gandalf's first steps give the player the curious map and open the round green door (the map before the first prompt, the door on the first WAIT). After that he has five ordinary scripts (GANDALF_A, GANDALF_B, GANDALF_C, GANDALF_D, GANDALF_E), and they are one list entered at different places: each is RUN and one more thing, running on into the next, and the last ends in a switch at random. So he goes somewhere, tries to do something there -- take, drop, give, chat, open, close -- and goes on, and a refusal falls through to the next step. Where he is after twenty turns is chance: RUN picks a direction with RANDOM, and the switches pick a script.

thorin

Thorin's script is a loop that tries the same things in the same order every turn: FOLLOW the player (refused: they are already together), TAKE the small curious key (refused: it is not here), ask where the thief is (refused: the player can be seen), and then his chatter routine, which always does something -- waits, says his line or sings -- and ends his turn. The script then goes back to the start. Only the last step is ever seen.

vicious warg

The warg's script is ATTACK WITH, whatever fits; failing that FOLLOW and howl; failing that RUN; failing that a pause. Every turn it could see nobody to attack, so it ran. Then it met the wood elf, attacked, and the fight is decided as on How a fight is decided. The elf's answer, on its next turn, was to capture it, and captives of the elf go to dark dungeon: there RUN is refused, and the warg pauses every turn.

Reactions seen in these twenty turns -- the calls of REACT from REACT_TO_ACTION whose target was a character:

• Turn 10: vicious warg did ATTACK WITH ($0F) to wood elf; its table has an entry for that action, so its script was moved to WOOD_ELF_A.
• Turn 11: wood elf did CAPTURE ($30) to vicious warg; its table has no entry for that action, so its script went on as it was.

REACT_TO_ACTION also calls REACT, harmlessly, for many actions with no target at all (a RUN, say): it tests the flags of whatever record TARGET_RECORD last held, and REACT then finds no character numbered $FF (read, and seen in the same run).

Where they went

The player stays in Bag End throughout; the location of each after every turn, grey where it did not change (the wood elf, whose turns are not tabled above, is added for the warg's sake):

Everyone, in sum

The same twenty turns for all the characters in play: how many turns each took, how many steps it considered and how many of those were refused, the random switches, how many places it was in, and how many of its turns the player was told about.

Almost everything happens out of sight: the trolls try their one step six times a turn and are refused each time until the player comes, the goblins patrol their tunnels, Gollum paces by his lake, and only gandalf and thorin were seen at all. Nothing in the scripts is tied to a place, which is why no two games play alike.

Reactions

A script table's entries keyed 0 are the ordinary scripts; any other key is an action code, and that entry is the character's reaction when that action is done to it. After an action for real, DO_ACTION calls REACT_TO_ACTION for each object that is a living character, and REACT looks the action up in the character's table and, if it is there, moves its script to that entry. Every table in the game:

Orders, and why Bard is different

What the player says in quotes is parsed into frames of its own and filed in ORDERS; TALK TO's handler, DO_TALK, gives the character a random number of them up to its limit (slot byte 6), and on its turn one replaces the step it is on, unless that step has bit 6. The whole path, from the quote mark to Thorin opening a chest, is followed on How a sentence is understood. A limit of 0 means the character never listens, and a random 0 means it refuses this time.

Bard's slot takes orders too, but his only ordinary script is BARD_TAKES_ORDER and one step at $C9E2, both with bit 6: no order can interrupt them. Instead the routine parses a waiting order itself and writes its action and objects into that step, which he then tries every turn until it works. So an order to Bard is not done once, on his next turn: it is kept, and carried out as soon as it can be -- which is how SHOOT THE DRAGON is meant to be given. On the tape the step reads: TAKE: wooden chest (an order cannot interrupt it). Because the game rewrites it, SAVE carries its three bytes, and a new game does not put it back (see Bugs).

What is confirmed, and what is not

• Run when this page was built: every step, refusal, switch, sentence and place in the twenty turns, and the reaction watched.
• Read: the slot and step formats (the build decodes every script and requires every byte from the scripts' start to TIMERS to be a table or a step), the turn's order of events, the reactions tables, and Bard's order step. The notes record Thorin's used-up step and the trolls' dawn as measured in earlier runs.
• Not worked out: how a step's “whatever fits” chooses among several candidates (assumed to be the order of the object index, as MATCH_AND_TRY walks it), and part of ACTOR_TRIES ($99E5), two ways into NARRATE_ACTION.