Automtic dialogue choices

README.md

@@ -1,6 +1,6 @@
 # Inform 7
 
-[Version](notes/versioning.md): 10.2.0-beta+6X28 'Krypton' (1 January 2024)
+[Version](notes/versioning.md): 10.2.0-beta+6X29 'Krypton' (2 January 2024)
 
 ## About Inform
 

build.txt

@@ -1,3 +1,3 @@
 Prerelease: beta
-Build Date: 1 January 2024
-Build Number: 6X28
+Build Date: 2 January 2024
+Build Number: 6X29

docs/DialogueKit/S-chc.html

@@ -91,6 +91,7 @@ looks to see if the current action matches the given action pattern.
 <span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">TYPE_DCMETADATA</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
 <span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">AVAILABILITY_DCMETADATA</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
 <span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">CONTENT_DCMETADATA</span><span class="plain-syntax"> = </span><span class="constant-syntax">2</span><span class="plain-syntax">;</span>
+<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">STATE_DCMETADATA</span><span class="plain-syntax"> = </span><span class="constant-syntax">3</span><span class="plain-syntax">;</span>
 
 <span class="plain-syntax">                                         </span><span class="comment-syntax">Flow markers:</span>
 <span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">AGAIN_DSEL</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;                 </span><span class="comment-syntax">&lt;-</span>
@@ -108,6 +109,12 @@ looks to see if the current action matches the given action pattern.
 <span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">INSTEAD_OF_DSEL</span><span class="plain-syntax"> = </span><span class="constant-syntax">11</span><span class="plain-syntax">;           </span><span class="comment-syntax">&mdash; instead of taking something</span>
 <span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">AFTER_DSEL</span><span class="plain-syntax"> = </span><span class="constant-syntax">12</span><span class="plain-syntax">;                </span><span class="comment-syntax">&mdash; after examining the rabbit hole</span>
 <span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">OTHERWISE_DSEL</span><span class="plain-syntax"> = </span><span class="constant-syntax">13</span><span class="plain-syntax">;            </span><span class="comment-syntax">&mdash; otherwise</span>
+<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">CHOOSE_RANDOMLY_DSEL</span><span class="plain-syntax"> = </span><span class="constant-syntax">14</span><span class="plain-syntax">;      </span><span class="comment-syntax">&mdash; choose randomly</span>
+<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">SHUFFLE_THROUGH_DSEL</span><span class="plain-syntax"> = </span><span class="constant-syntax">15</span><span class="plain-syntax">;      </span><span class="comment-syntax">&mdash; shuffle through</span>
+<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">CYCLE_THROUGH_DSEL</span><span class="plain-syntax"> = </span><span class="constant-syntax">16</span><span class="plain-syntax">;        </span><span class="comment-syntax">&mdash; cycle through</span>
+<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">STEP_THROUGH_DSEL</span><span class="plain-syntax"> = </span><span class="constant-syntax">17</span><span class="plain-syntax">;         </span><span class="comment-syntax">&mdash; step through</span>
+<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">STEP_THROUGH_AND_STOP_DSEL</span><span class="plain-syntax"> = </span><span class="constant-syntax">18</span><span class="plain-syntax">; </span><span class="comment-syntax">&mdash; step through and stop</span>
+<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">OR_DSEL</span><span class="plain-syntax"> = </span><span class="constant-syntax">19</span><span class="plain-syntax">;                   </span><span class="comment-syntax">&mdash; or</span>
 </pre>
 <p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. Extracting choice data. </b></p>
 
@@ -134,6 +141,18 @@ looks to see if the current action matches the given action pattern.
 <span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">chdata</span><span class="plain-syntax">--&gt;</span><span class="identifier-syntax">TYPE_DCMETADATA</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">];</span>
 
+<span class="plain-syntax">[ </span><span class="identifier-syntax">DirectorReadChoiceState</span><span class="plain-syntax"> </span><span class="identifier-syntax">dc</span><span class="plain-syntax"> </span><span class="identifier-syntax">chdata</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">dc</span><span class="plain-syntax"> &lt;= </span><span class="constant-syntax">0</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">dc</span><span class="plain-syntax"> &gt; </span><span class="identifier-syntax">NO_DIALOGUE_CHOICES</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="identifier-syntax">chdata</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TableOfDialogueChoices</span><span class="plain-syntax">--&gt;</span><span class="identifier-syntax">dc</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">chdata</span><span class="plain-syntax">--&gt;</span><span class="identifier-syntax">STATE_DCMETADATA</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">];</span>
+
+<span class="plain-syntax">[ </span><span class="identifier-syntax">DirectorWriteChoiceState</span><span class="plain-syntax"> </span><span class="identifier-syntax">dc</span><span class="plain-syntax"> </span><span class="identifier-syntax">val</span><span class="plain-syntax"> </span><span class="identifier-syntax">chdata</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">dc</span><span class="plain-syntax"> &lt;= </span><span class="constant-syntax">0</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">dc</span><span class="plain-syntax"> &gt; </span><span class="identifier-syntax">NO_DIALOGUE_CHOICES</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="identifier-syntax">chdata</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TableOfDialogueChoices</span><span class="plain-syntax">--&gt;</span><span class="identifier-syntax">dc</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="identifier-syntax">chdata</span><span class="plain-syntax">--&gt;</span><span class="identifier-syntax">STATE_DCMETADATA</span><span class="plain-syntax"> = </span><span class="identifier-syntax">val</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">];</span>
+
 <span class="plain-syntax">[ </span><span class="identifier-syntax">DirectorChoiceRawContent</span><span class="plain-syntax"> </span><span class="identifier-syntax">dc</span><span class="plain-syntax"> </span><span class="identifier-syntax">chdata</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">dc</span><span class="plain-syntax"> &lt;= </span><span class="constant-syntax">0</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">dc</span><span class="plain-syntax"> &gt; </span><span class="identifier-syntax">NO_DIALOGUE_CHOICES</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">chdata</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TableOfDialogueChoices</span><span class="plain-syntax">--&gt;</span><span class="identifier-syntax">dc</span><span class="plain-syntax">;</span>

docs/DialogueKit/S-prg.html

@@ -115,6 +115,11 @@ next typed command and see what action it produced.
 <span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">TEXTUAL_DCODEDT</span><span class="plain-syntax"> = </span><span class="constant-syntax">2</span><span class="plain-syntax">;</span>
 <span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">PARSED_COMMAND_DCODEDT</span><span class="plain-syntax"> = </span><span class="constant-syntax">3</span><span class="plain-syntax">;</span>
 <span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">FLOW_DCODEDT</span><span class="plain-syntax"> = </span><span class="constant-syntax">4</span><span class="plain-syntax">;</span>
+<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">RANDOMISED_CONTROL_DDT</span><span class="plain-syntax"> = </span><span class="constant-syntax">5</span><span class="plain-syntax">;</span>
+<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">SHUFFLE_CONTROL_DDT</span><span class="plain-syntax"> = </span><span class="constant-syntax">6</span><span class="plain-syntax">;</span>
+<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">CYCLE_CONTROL_DDT</span><span class="plain-syntax"> = </span><span class="constant-syntax">7</span><span class="plain-syntax">;</span>
+<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">STEP_CONTROL_DDT</span><span class="plain-syntax"> = </span><span class="constant-syntax">8</span><span class="plain-syntax">;</span>
+<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">STEP_STOP_CONTROL_DDT</span><span class="plain-syntax"> = </span><span class="constant-syntax">9</span><span class="plain-syntax">;</span>
 </pre>
 <p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. Containment. </b>This enables us to implement the test for whether a given line or choice
 occurs in a beat, because we need only look to see whether it occurs as
@@ -208,6 +213,11 @@ whether the choice <span class="extract"><span class="extract-syntax">dc</span><
 <span class="plain-syntax">                </span><span class="identifier-syntax">TEXTUAL_DCODEDT</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"TEXTUAL"</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">PARSED_COMMAND_DCODEDT</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"PARSED"</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">FLOW_DCODEDT</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"FLOW"</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">RANDOMISED_CONTROL_DDT</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"RANDOMISED"</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">SHUFFLE_CONTROL_DDT</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"SHUFFLE"</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">CYCLE_CONTROL_DDT</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"CYCLE"</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">STEP_CONTROL_DDT</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"STEP"</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">STEP_STOP_CONTROL_DDT</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"STEP_STOP"</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">                </span><span class="reserved-syntax">default</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"*** Unknown ***"</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">            }</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">default</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"*** Unimplemented ***"</span><span class="plain-syntax">;</span>
@@ -409,7 +419,7 @@ those are always underneath <span class="extract"><span class="extract-syntax">D
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
-<span class="plain-syntax">[ </span><span class="identifier-syntax">DirectorRun</span><span class="plain-syntax"> </span><span class="identifier-syntax">program</span><span class="plain-syntax"> </span><span class="identifier-syntax">pc</span><span class="plain-syntax"> </span><span class="identifier-syntax">last_pc</span><span class="plain-syntax"> </span><span class="identifier-syntax">instruction</span><span class="plain-syntax"> </span><span class="identifier-syntax">operand</span><span class="plain-syntax"> </span><span class="identifier-syntax">depth</span><span class="plain-syntax"> </span><span class="identifier-syntax">next_instruction</span><span class="plain-syntax"> </span><span class="identifier-syntax">sc</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">[ </span><span class="identifier-syntax">DirectorRun</span><span class="plain-syntax"> </span><span class="identifier-syntax">program</span><span class="plain-syntax"> </span><span class="identifier-syntax">pc</span><span class="plain-syntax"> </span><span class="identifier-syntax">last_pc</span><span class="plain-syntax"> </span><span class="identifier-syntax">instruction</span><span class="plain-syntax"> </span><span class="identifier-syntax">operand</span><span class="plain-syntax"> </span><span class="identifier-syntax">operand_at</span><span class="plain-syntax"> </span><span class="identifier-syntax">depth</span><span class="plain-syntax"> </span><span class="identifier-syntax">next_instruction</span><span class="plain-syntax"> </span><span class="identifier-syntax">sc</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="reserved-syntax">true</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">director_is_paused_for_command</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
 
@@ -437,7 +447,8 @@ those are always underneath <span class="extract"><span class="extract-syntax">D
 <span class="plain-syntax">        </span><span class="identifier-syntax">program</span><span class="plain-syntax"> = </span><span class="identifier-syntax">DirectorBeatGetProgram</span><span class="plain-syntax">(</span><span class="identifier-syntax">DirectorStackBeat</span><span class="plain-syntax">--&gt;(</span><span class="identifier-syntax">director_sp</span><span class="plain-syntax">-1));</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">instruction</span><span class="plain-syntax"> = (</span><span class="identifier-syntax">program</span><span class="plain-syntax">--&gt;</span><span class="identifier-syntax">pc</span><span class="plain-syntax">)/100;</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">depth</span><span class="plain-syntax"> = (</span><span class="identifier-syntax">program</span><span class="plain-syntax">--&gt;</span><span class="identifier-syntax">pc</span><span class="plain-syntax">)%100;</span>
-<span class="plain-syntax">        </span><span class="identifier-syntax">operand</span><span class="plain-syntax"> = </span><span class="identifier-syntax">program</span><span class="plain-syntax">--&gt;(</span><span class="identifier-syntax">pc</span><span class="plain-syntax">+1);</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">operand_at</span><span class="plain-syntax"> = </span><span class="identifier-syntax">pc</span><span class="plain-syntax">+1;</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">operand</span><span class="plain-syntax"> = </span><span class="identifier-syntax">program</span><span class="plain-syntax">--&gt;</span><span class="identifier-syntax">operand_at</span><span class="plain-syntax">;</span>
 
 <span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">instruction</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) { </span><span class="identifier-syntax">DirectorPop</span><span class="plain-syntax">(); </span><span class="reserved-syntax">return</span><span class="plain-syntax">; }</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">depth</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">DirectorStackMin</span><span class="plain-syntax">--&gt;(</span><span class="identifier-syntax">director_sp</span><span class="plain-syntax">-1)) { </span><span class="identifier-syntax">DirectorPop</span><span class="plain-syntax">(); </span><span class="reserved-syntax">return</span><span class="plain-syntax">; }</span>
@@ -464,7 +475,8 @@ those are always underneath <span class="extract"><span class="extract-syntax">D
 <span class="plain-syntax">                </span><span class="identifier-syntax">DirectorExecuteLine</span><span class="plain-syntax">(</span><span class="identifier-syntax">operand</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">            </span><span class="identifier-syntax">DECISION_DCODEI</span><span class="plain-syntax">:</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">DirectorStackDecisionPC</span><span class="plain-syntax">--&gt;(</span><span class="identifier-syntax">director_sp</span><span class="plain-syntax">-1) = </span><span class="identifier-syntax">last_pc</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">                </span><span class="identifier-syntax">DirectorExecuteDecision</span><span class="plain-syntax">(</span><span class="identifier-syntax">operand</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">program</span><span class="plain-syntax">--&gt;</span><span class="identifier-syntax">operand_at</span><span class="plain-syntax"> = (</span><span class="identifier-syntax">program</span><span class="plain-syntax">--&gt;</span><span class="identifier-syntax">operand_at</span><span class="plain-syntax">)%100 +</span>
+<span class="plain-syntax">                    </span><span class="constant-syntax">100</span><span class="plain-syntax">*(</span><span class="identifier-syntax">DirectorExecuteDecision</span><span class="plain-syntax">(</span><span class="identifier-syntax">operand</span><span class="plain-syntax">%100, </span><span class="identifier-syntax">operand</span><span class="plain-syntax">/100));</span>
 <span class="plain-syntax">            </span><span class="identifier-syntax">CHOICE_DCODEI</span><span class="plain-syntax">:</span>
 <span class="plain-syntax">                </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"*** Encountered CHOICE_DCODEI ***^"</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">            </span><span class="reserved-syntax">default</span><span class="plain-syntax">: </span><span class="string-syntax">"*** Bad D-code instruction ***"</span><span class="plain-syntax">;</span>
@@ -501,15 +513,18 @@ and we silently return.
 
 <p class="commentary">We deal with <span class="extract"><span class="extract-syntax">TEXTUAL_DCODEDT</span></span> and <span class="extract"><span class="extract-syntax">FLOW_DCODEDT</span></span> decisions immediately, and
 empty the choices list as soon as we can. Perhaps surprisingly, we do nothing
-at all about a <span class="extract"><span class="extract-syntax">PARSED_COMMAND_DCODEDT</span></span>. This function call nevertheless has
-an effect because it leaves the choices list on the stack, where it will cause
-the D-code interpreter to halt waiting for a command, to be re-entered later
-on when actions are processed.
+at all about a <span class="extract"><span class="extract-syntax">PARSED_COMMAND_DCODEDT</span></span> except to signal a sort of exception.
+This function call nevertheless has an effect because it leaves the choices list
+on the stack, where it will cause the D-code interpreter to halt waiting for a
+command, to be re-entered later on when actions are processed.
+</p>
+
+<p class="commentary">This function is passed a state value, and must return it (even if unchanged).
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
-<span class="plain-syntax">[ </span><span class="identifier-syntax">DirectorExecuteDecision</span><span class="plain-syntax"> </span><span class="identifier-syntax">decision</span><span class="plain-syntax"> </span><span class="identifier-syntax">dc</span><span class="plain-syntax"> </span><span class="identifier-syntax">count</span><span class="plain-syntax"> </span><span class="identifier-syntax">n</span><span class="plain-syntax"> </span><span class="identifier-syntax">spc</span><span class="plain-syntax"> </span><span class="identifier-syntax">list</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">director_sp</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">[ </span><span class="identifier-syntax">DirectorExecuteDecision</span><span class="plain-syntax"> </span><span class="identifier-syntax">decision</span><span class="plain-syntax"> </span><span class="identifier-syntax">state</span><span class="plain-syntax"> </span><span class="identifier-syntax">dc</span><span class="plain-syntax"> </span><span class="identifier-syntax">count</span><span class="plain-syntax"> </span><span class="identifier-syntax">n</span><span class="plain-syntax"> </span><span class="identifier-syntax">m</span><span class="plain-syntax"> </span><span class="identifier-syntax">spc</span><span class="plain-syntax"> </span><span class="identifier-syntax">list</span><span class="plain-syntax"> </span><span class="identifier-syntax">k</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">director_sp</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">state</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">list</span><span class="plain-syntax"> = </span><span class="identifier-syntax">DirectorStackChoices</span><span class="plain-syntax">--&gt;(</span><span class="identifier-syntax">director_sp</span><span class="plain-syntax">-1);</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">DirectorListChoices</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">count</span><span class="plain-syntax"> = </span><span class="identifier-syntax">LIST_OF_TY_GetLength</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">);</span>
@@ -520,7 +535,7 @@ on when actions are processed.
 <span class="plain-syntax">            </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"-- available options: "</span><span class="plain-syntax">; </span><span class="identifier-syntax">LIST_OF_TY_Say</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">); </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"^"</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        }</span>
 <span class="plain-syntax">    }</span>
-<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">count</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">count</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">state</span><span class="plain-syntax">;</span>
 
 <span class="plain-syntax">    </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">decision</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">TEXTUAL_DCODEDT</span><span class="plain-syntax">:</span>
@@ -529,7 +544,7 @@ on when actions are processed.
 <span class="plain-syntax">            </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">BeginActivity</span><span class="plain-syntax">(</span><span class="identifier-syntax">OFFERING_A_DIALOGUE_CHOICE</span><span class="plain-syntax">, </span><span class="identifier-syntax">list</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">ForActivity</span><span class="plain-syntax">(</span><span class="identifier-syntax">OFFERING_A_DIALOGUE_CHOICE</span><span class="plain-syntax">, </span><span class="identifier-syntax">list</span><span class="plain-syntax">)) &amp;&amp;</span>
-<span class="plain-syntax">                    (</span><span class="identifier-syntax">RulebookFailed</span><span class="plain-syntax">())) </span><span class="reserved-syntax">rfalse</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">                    (</span><span class="identifier-syntax">RulebookFailed</span><span class="plain-syntax">())) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">state</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">EndActivity</span><span class="plain-syntax">(</span><span class="identifier-syntax">OFFERING_A_DIALOGUE_CHOICE</span><span class="plain-syntax">, </span><span class="identifier-syntax">list</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">            }</span>
 <span class="plain-syntax">            </span><span class="identifier-syntax">DivideParagraphPoint</span><span class="plain-syntax">();</span>
@@ -549,9 +564,60 @@ on when actions are processed.
 <span class="plain-syntax">            </span><span class="identifier-syntax">dc</span><span class="plain-syntax"> = </span><span class="identifier-syntax">LIST_OF_TY_GetItem</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">            </span><span class="identifier-syntax">LIST_OF_TY_SetLength</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">            </span><span class="identifier-syntax">DirectorFollowFlowMarker</span><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">RANDOMISED_CONTROL_DDT</span><span class="plain-syntax">:</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="reserved-syntax">random</span><span class="plain-syntax">(</span><span class="identifier-syntax">count</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">dc</span><span class="plain-syntax"> = </span><span class="identifier-syntax">LIST_OF_TY_GetItem</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">LIST_OF_TY_SetLength</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">DirectorExerciseChoice</span><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">SHUFFLE_CONTROL_DDT</span><span class="plain-syntax">:</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">state</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
+<span class="plain-syntax">                </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">=1: </span><span class="identifier-syntax">n</span><span class="plain-syntax">&lt;=</span><span class="identifier-syntax">count</span><span class="plain-syntax">: </span><span class="identifier-syntax">n</span><span class="plain-syntax">++)</span>
+<span class="plain-syntax">                    </span><span class="identifier-syntax">DirectorWriteChoiceState</span><span class="plain-syntax">(</span><span class="identifier-syntax">LIST_OF_TY_GetItem</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">), </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">count</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            }</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">m</span><span class="plain-syntax"> = </span><span class="reserved-syntax">random</span><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">n</span><span class="plain-syntax">--; </span><span class="identifier-syntax">state</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">=1: </span><span class="identifier-syntax">n</span><span class="plain-syntax">&lt;=</span><span class="identifier-syntax">count</span><span class="plain-syntax">: </span><span class="identifier-syntax">n</span><span class="plain-syntax">++) {</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">dc</span><span class="plain-syntax"> = </span><span class="identifier-syntax">LIST_OF_TY_GetItem</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">DirectorReadChoiceState</span><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">) == </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
+<span class="plain-syntax">                    </span><span class="identifier-syntax">m</span><span class="plain-syntax">--;</span>
+<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">m</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
+<span class="plain-syntax">                        </span><span class="identifier-syntax">DirectorWriteChoiceState</span><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">                        </span><span class="identifier-syntax">LIST_OF_TY_SetLength</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">                        </span><span class="identifier-syntax">DirectorExerciseChoice</span><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">                        </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">state</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">                    }</span>
+<span class="plain-syntax">                }</span>
+<span class="plain-syntax">            }</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">LIST_OF_TY_SetLength</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">CYCLE_CONTROL_DDT</span><span class="plain-syntax">:</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">state</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">count</span><span class="plain-syntax">) </span><span class="identifier-syntax">n</span><span class="plain-syntax">++; </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">state</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">dc</span><span class="plain-syntax"> = </span><span class="identifier-syntax">LIST_OF_TY_GetItem</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">LIST_OF_TY_SetLength</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">DirectorExerciseChoice</span><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">STEP_CONTROL_DDT</span><span class="plain-syntax">:</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">state</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">count</span><span class="plain-syntax">) {</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">n</span><span class="plain-syntax">++; </span><span class="identifier-syntax">state</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">dc</span><span class="plain-syntax"> = </span><span class="identifier-syntax">LIST_OF_TY_GetItem</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">LIST_OF_TY_SetLength</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">DirectorExerciseChoice</span><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">LIST_OF_TY_SetLength</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            }</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">STEP_STOP_CONTROL_DDT</span><span class="plain-syntax">:</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">state</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">count</span><span class="plain-syntax">) { </span><span class="identifier-syntax">n</span><span class="plain-syntax">++; </span><span class="identifier-syntax">state</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; }</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">dc</span><span class="plain-syntax"> = </span><span class="identifier-syntax">LIST_OF_TY_GetItem</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">LIST_OF_TY_SetLength</span><span class="plain-syntax">(</span><span class="identifier-syntax">list</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">DirectorExerciseChoice</span><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">default</span><span class="plain-syntax">:</span>
-<span class="plain-syntax">            </span><span class="string-syntax">"*** unimplemented dtd ***"</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"*** unimplemented dtd "</span><span class="plain-syntax">, </span><span class="identifier-syntax">decision</span><span class="plain-syntax">, </span><span class="string-syntax">" ***^"</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    }</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">state</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">];</span>
 </pre>
 <p class="commentary firstcommentary"><a id="SP12" class="paragraph-anchor"></a><b>&#167;12. Listing choices for a decision. </b>This finds all of the unperformed or recurring choices which are currently

docs/if-module/6-dc.html

@@ -292,6 +292,12 @@ of the following possibilities:
 <span class="definition-keyword">enum</span> <span class="constant-syntax">INSTEAD_OF_DSEL</span><span class="plain-syntax">                  </span><span class="comment-syntax"> &mdash; instead of taking something</span>
 <span class="definition-keyword">enum</span> <span class="constant-syntax">AFTER_DSEL</span><span class="plain-syntax">                       </span><span class="comment-syntax"> &mdash; after examining the rabbit hole</span>
 <span class="definition-keyword">enum</span> <span class="constant-syntax">OTHERWISE_DSEL</span><span class="plain-syntax">                   </span><span class="comment-syntax"> &mdash; otherwise</span>
+<span class="definition-keyword">enum</span> <span class="constant-syntax">CHOOSE_RANDOMLY_DSEL</span><span class="plain-syntax">             </span><span class="comment-syntax"> &mdash; choose randomly</span>
+<span class="definition-keyword">enum</span> <span class="constant-syntax">SHUFFLE_THROUGH_DSEL</span><span class="plain-syntax">             </span><span class="comment-syntax"> &mdash; shuffle through</span>
+<span class="definition-keyword">enum</span> <span class="constant-syntax">CYCLE_THROUGH_DSEL</span><span class="plain-syntax">               </span><span class="comment-syntax"> &mdash; cycle through</span>
+<span class="definition-keyword">enum</span> <span class="constant-syntax">STEP_THROUGH_DSEL</span><span class="plain-syntax">                </span><span class="comment-syntax"> &mdash; step through</span>
+<span class="definition-keyword">enum</span> <span class="constant-syntax">STEP_THROUGH_AND_STOP_DSEL</span><span class="plain-syntax">       </span><span class="comment-syntax"> &mdash; step through and stop</span>
+<span class="definition-keyword">enum</span> <span class="constant-syntax">OR_DSEL</span><span class="plain-syntax">                          </span><span class="comment-syntax"> &mdash; or</span>
 </pre>
 <pre class="Preform-displayed-code all-displayed-code code-font">
 <span class="Preform-function-syntax">&lt;dialogue-selection&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
@@ -308,7 +314,13 @@ of the following possibilities:
 <span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">after</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">...</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax">                                       </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { AFTER_DSEL, - }</span>
 <span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">before</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">...</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax">                                      </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { BEFORE_DSEL, - }</span>
 <span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">perform</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;definite-article&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">...</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax">                  </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { PERFORM_DSEL, - }</span>
-<span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">perform</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">...</span><span class="Preform-plain-syntax">                                       </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { PERFORM_DSEL, - }</span>
+<span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">perform</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">...</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax">                                     </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { PERFORM_DSEL, - }</span>
+<span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">choose</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">randomly</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax">                                 </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { CHOOSE_RANDOMLY_DSEL, - }</span>
+<span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">shuffle</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">through</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax">                                 </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { SHUFFLE_THROUGH_DSEL, - }</span>
+<span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">cycle</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">through</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax">                                   </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { CYCLE_THROUGH_DSEL, - }</span>
+<span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">step</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">through</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax">                                    </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { STEP_THROUGH_DSEL, - }</span>
+<span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">step</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">through</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">and</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">stop</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax">                           </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { STEP_THROUGH_AND_STOP_DSEL, - }</span>
+<span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">or</span><span class="Preform-plain-syntax">                                                </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { OR_DSEL, - }</span>
 </pre>
 <ul class="endnotetexts"><li>This is <a href="../words-module/4-ap.html" class="internal">Preform grammar</a>, not regular C code.</li></ul>
 <p class="commentary firstcommentary"><a id="SP2_8" class="paragraph-anchor"></a><b>&#167;2.8.  </b>Each choice produces an instance of the kind <span class="extract"><span class="Preform-extract-syntax">dialogue choice</span></span>, using the name
@@ -345,6 +357,19 @@ is one.
 <span class="plain-syntax">    </span><span class="reserved-syntax">dialogue_choice</span><span class="plain-syntax"> *</span><span class="identifier-syntax">dc</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">LOOP_OVER</span><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">, </span><span class="reserved-syntax">dialogue_choice</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax"> = </span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">choice_at</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">selection_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CHOOSE_RANDOMLY_DSEL</span><span class="plain-syntax">) ||</span>
+<span class="plain-syntax">            (</span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">selection_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">SHUFFLE_THROUGH_DSEL</span><span class="plain-syntax">) ||</span>
+<span class="plain-syntax">            (</span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">selection_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CYCLE_THROUGH_DSEL</span><span class="plain-syntax">) ||</span>
+<span class="plain-syntax">            (</span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">selection_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">STEP_THROUGH_DSEL</span><span class="plain-syntax">) ||</span>
+<span class="plain-syntax">            (</span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">selection_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">STEP_THROUGH_AND_STOP_DSEL</span><span class="plain-syntax">) ||</span>
+<span class="plain-syntax">            (</span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">selection_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OR_DSEL</span><span class="plain-syntax">)) {</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">AdjectivalPredicates::new_atom_on_x</span><span class="plain-syntax">(</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">EitherOrProperties::as_adjective</span><span class="plain-syntax">(</span><span class="identifier-syntax">P_recurring</span><span class="plain-syntax">), </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::concatenate</span><span class="plain-syntax">(</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">Propositions::Abstract::prop_to_set_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">K_dialogue_choice</span><span class="plain-syntax">), </span><span class="identifier-syntax">prop</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subj</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Instances::as_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">as_instance</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">subj</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">        }</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">clause</span><span class="plain-syntax"> = </span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">choice_at</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">down</span><span class="plain-syntax">; </span><span class="identifier-syntax">clause</span><span class="plain-syntax">; </span><span class="identifier-syntax">clause</span><span class="plain-syntax"> = </span><span class="identifier-syntax">clause</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::is</span><span class="plain-syntax">(</span><span class="identifier-syntax">clause</span><span class="plain-syntax">, </span><span class="identifier-syntax">DIALOGUE_CLAUSE_NT</span><span class="plain-syntax">)) {</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">CW</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">clause</span><span class="plain-syntax">);</span>

docs/if-module/6-dn.html

@@ -205,6 +205,11 @@ impossible to hit.
 <span class="definition-keyword">enum</span> <span class="constant-syntax">TEXTUAL_DDT</span>
 <span class="definition-keyword">enum</span> <span class="constant-syntax">PARSED_COMMAND_DDT</span>
 <span class="definition-keyword">enum</span> <span class="constant-syntax">FLOW_CONTROL_DDT</span>
+<span class="definition-keyword">enum</span> <span class="constant-syntax">RANDOMISED_CONTROL_DDT</span>
+<span class="definition-keyword">enum</span> <span class="constant-syntax">SHUFFLE_CONTROL_DDT</span>
+<span class="definition-keyword">enum</span> <span class="constant-syntax">CYCLE_CONTROL_DDT</span>
+<span class="definition-keyword">enum</span> <span class="constant-syntax">STEP_CONTROL_DDT</span>
+<span class="definition-keyword">enum</span> <span class="constant-syntax">STEP_STOP_CONTROL_DDT</span>
 </pre>
 <pre class="displayed-code all-displayed-code code-font">
 <span class="reserved-syntax">typedef</span><span class="plain-syntax"> </span><span class="reserved-syntax">struct</span><span class="plain-syntax"> </span><span class="reserved-syntax">dialogue_decision</span><span class="plain-syntax"> {</span>
@@ -280,57 +285,92 @@ impossible to hit.
 <span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">dialogue_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">dn</span><span class="plain-syntax">, *</span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">c</span><span class="plain-syntax">; </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">c</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_decision</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">t</span><span class="plain-syntax"> = -1;</span>
-<span class="plain-syntax">            </span><span class="reserved-syntax">dialogue_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bad_otherwise</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, *</span><span class="identifier-syntax">mixed_choices</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">            </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">dialogue_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">d</span><span class="plain-syntax"> = </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">; </span><span class="identifier-syntax">d</span><span class="plain-syntax">; </span><span class="identifier-syntax">d</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
-<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">d</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">selection_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OTHERWISE_DSEL</span><span class="plain-syntax">) {</span>
-<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">t</span><span class="plain-syntax"> != </span><span class="constant-syntax">PARSED_COMMAND_DDT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bad_otherwise</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">d</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) </span><span class="identifier-syntax">bad_otherwise</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">                } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
-<span class="plain-syntax">                    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">ddt</span><span class="plain-syntax"> = </span><a href="6-dn.html#SP5" class="function-link"><span class="function-syntax">DialogueNodes::decision_type</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">d</span><span class="plain-syntax">);</span>
-<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">t</span><span class="plain-syntax"> == -1) </span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">ddt</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">                    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">t</span><span class="plain-syntax"> != </span><span class="identifier-syntax">ddt</span><span class="plain-syntax">) </span><span class="identifier-syntax">mixed_choices</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">                }</span>
-<span class="plain-syntax">            }</span>
-<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bad_otherwise</span><span class="plain-syntax">) {</span>
-<span class="plain-syntax">                </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax"> = </span><span class="identifier-syntax">bad_otherwise</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">choice_at</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">                </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(),</span>
-<span class="plain-syntax">                    </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ChoiceOtherwiseUnexpected</span><span class="plain-syntax">),</span>
-<span class="plain-syntax">                    </span><span class="string-syntax">"this run of choices uses 'otherwise' unexpectedly"</span><span class="plain-syntax">,</span>
-<span class="plain-syntax">                    </span><span class="string-syntax">"since 'otherwise' can only be used as the last option, and "</span>
-<span class="plain-syntax">                    </span><span class="string-syntax">"only where the options are written in terms of actions."</span><span class="plain-syntax">);</span>
-<span class="plain-syntax">            }</span>
-<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">mixed_choices</span><span class="plain-syntax">) {</span>
-<span class="plain-syntax">                </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax"> = </span><span class="identifier-syntax">mixed_choices</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">choice_at</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">                </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ChoicesMixed</span><span class="plain-syntax">),</span>
-<span class="plain-syntax">                    </span><span class="string-syntax">"this run of choices mixes up the possible sorts of choice"</span><span class="plain-syntax">,</span>
-<span class="plain-syntax">                    </span><span class="string-syntax">"and should either all be action-dependent choices (perhaps "</span>
-<span class="plain-syntax">                    </span><span class="string-syntax">"finishing with an 'otherwise'), or else all textual choices."</span><span class="plain-syntax">);</span>
-<span class="plain-syntax">            }</span>
-<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">selection_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">ANOTHER_CHOICE_DSEL</span><span class="plain-syntax">)) {</span>
-<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">prev</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">prev</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_line</span><span class="plain-syntax">) ||</span>
-<span class="plain-syntax">                    (</span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_line</span><span class="plain-syntax">)) {</span>
-<span class="plain-syntax">                    </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax"> = </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">choice_at</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">                    </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(),</span>
-<span class="plain-syntax">                        </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ChoiceBlankRedundant</span><span class="plain-syntax">),</span>
-<span class="plain-syntax">                        </span><span class="string-syntax">"this use of '-&gt; another choice' looks redundant"</span><span class="plain-syntax">,</span>
-<span class="plain-syntax">                        </span><span class="string-syntax">"occurring at the start or end of a set of options. "</span>
-<span class="plain-syntax">                        </span><span class="string-syntax">"'-&gt; another choice' should be used only where there's "</span>
-<span class="plain-syntax">                        </span><span class="string-syntax">"a need to mark a division point between two sets "</span>
-<span class="plain-syntax">                        </span><span class="string-syntax">"of options running on from one to the other."</span><span class="plain-syntax">);</span>
-<span class="plain-syntax">                }</span>
-<span class="plain-syntax">            }</span>
-<span class="plain-syntax">            </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_decision</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">decision_type</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">) </span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><a href="6-dn.html#SP6" class="function-link"><span class="function-syntax">DialogueNodes::decision_type</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">t</span><span class="plain-syntax"> == </span><span class="constant-syntax">RANDOMISED_CONTROL_DDT</span><span class="plain-syntax">) ||</span>
+<span class="plain-syntax">                (</span><span class="identifier-syntax">t</span><span class="plain-syntax"> == </span><span class="constant-syntax">SHUFFLE_CONTROL_DDT</span><span class="plain-syntax">) ||</span>
+<span class="plain-syntax">                (</span><span class="identifier-syntax">t</span><span class="plain-syntax"> == </span><span class="constant-syntax">CYCLE_CONTROL_DDT</span><span class="plain-syntax">) ||</span>
+<span class="plain-syntax">                (</span><span class="identifier-syntax">t</span><span class="plain-syntax"> == </span><span class="constant-syntax">STEP_CONTROL_DDT</span><span class="plain-syntax">) ||</span>
+<span class="plain-syntax">                (</span><span class="identifier-syntax">t</span><span class="plain-syntax"> == </span><span class="constant-syntax">STEP_STOP_CONTROL_DDT</span><span class="plain-syntax">))</span>
+<span class="plain-syntax">                </span><span class="named-paragraph-container code-font"><a href="6-dn.html#SP5_1" class="named-paragraph-link"><span class="named-paragraph">Apply the rules for an or-list</span><span class="named-paragraph-number">5.1</span></a></span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">else</span>
+<span class="plain-syntax">                </span><span class="named-paragraph-container code-font"><a href="6-dn.html#SP5_2" class="named-paragraph-link"><span class="named-paragraph">Apply the mixture rules</span><span class="named-paragraph-number">5.2</span></a></span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        }</span>
 <span class="plain-syntax">        </span><a href="6-dn.html#SP5" class="function-link"><span class="function-syntax">DialogueNodes::examine_decisions_in_beat_r</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">db</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">    }</span>
 <span class="plain-syntax">}</span>
+</pre>
+<p class="commentary firstcommentary"><a id="SP5_1" class="paragraph-anchor"></a><b>&#167;5.1.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Apply the rules for an or-list</span><span class="named-paragraph-number">5.1</span></span><span class="comment-syntax"> =</span>
+</p>
 
+<pre class="displayed-code all-displayed-code code-font">
+<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">dialogue_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">d</span><span class="plain-syntax"> = </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">; </span><span class="identifier-syntax">d</span><span class="plain-syntax">; </span><span class="identifier-syntax">d</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">)</span>
+<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">d</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">selection_type</span><span class="plain-syntax"> != </span><span class="constant-syntax">OR_DSEL</span><span class="plain-syntax">) {</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">choice_at</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(),</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(...),</span>
+<span class="plain-syntax">                </span><span class="string-syntax">"this is a run of choices where all choices other than the"</span>
+<span class="plain-syntax">                </span><span class="string-syntax">"first must be just '-- or'"</span><span class="plain-syntax">,</span>
+<span class="plain-syntax">                </span><span class="string-syntax">"since it is a list of alternatives."</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">        }</span>
+<span class="plain-syntax">    </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_decision</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">decision_type</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">;</span>
+</pre>
+<ul class="endnotetexts"><li>This code is used in <a href="6-dn.html#SP5">&#167;5</a>.</li></ul>
+<p class="commentary firstcommentary"><a id="SP5_2" class="paragraph-anchor"></a><b>&#167;5.2.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Apply the mixture rules</span><span class="named-paragraph-number">5.2</span></span><span class="comment-syntax"> =</span>
+</p>
+
+<pre class="displayed-code all-displayed-code code-font">
+<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">t</span><span class="plain-syntax"> = -1;</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">dialogue_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bad_otherwise</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, *</span><span class="identifier-syntax">mixed_choices</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">dialogue_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">d</span><span class="plain-syntax"> = </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">; </span><span class="identifier-syntax">d</span><span class="plain-syntax">; </span><span class="identifier-syntax">d</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
+<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">d</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">selection_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OTHERWISE_DSEL</span><span class="plain-syntax">) {</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">t</span><span class="plain-syntax"> != </span><span class="constant-syntax">PARSED_COMMAND_DDT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bad_otherwise</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">d</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) </span><span class="identifier-syntax">bad_otherwise</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">ddt</span><span class="plain-syntax"> = </span><a href="6-dn.html#SP6" class="function-link"><span class="function-syntax">DialogueNodes::decision_type</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">d</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">t</span><span class="plain-syntax"> == -1) </span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">ddt</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">t</span><span class="plain-syntax"> != </span><span class="identifier-syntax">ddt</span><span class="plain-syntax">) </span><span class="identifier-syntax">mixed_choices</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        }</span>
+<span class="plain-syntax">    }</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bad_otherwise</span><span class="plain-syntax">) {</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax"> = </span><span class="identifier-syntax">bad_otherwise</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">choice_at</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(),</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ChoiceOtherwiseUnexpected</span><span class="plain-syntax">),</span>
+<span class="plain-syntax">            </span><span class="string-syntax">"this run of choices uses 'otherwise' unexpectedly"</span><span class="plain-syntax">,</span>
+<span class="plain-syntax">            </span><span class="string-syntax">"since 'otherwise' can only be used as the last option, and "</span>
+<span class="plain-syntax">            </span><span class="string-syntax">"only where the options are written in terms of actions."</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">    }</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">mixed_choices</span><span class="plain-syntax">) {</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax"> = </span><span class="identifier-syntax">mixed_choices</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">choice_at</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ChoicesMixed</span><span class="plain-syntax">),</span>
+<span class="plain-syntax">            </span><span class="string-syntax">"this run of choices mixes up the possible sorts of choice"</span><span class="plain-syntax">,</span>
+<span class="plain-syntax">            </span><span class="string-syntax">"and should either all be action-dependent choices (perhaps "</span>
+<span class="plain-syntax">            </span><span class="string-syntax">"finishing with an 'otherwise'), or else all textual choices."</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">    }</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">selection_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">ANOTHER_CHOICE_DSEL</span><span class="plain-syntax">)) {</span>
+<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">prev</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">prev</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_line</span><span class="plain-syntax">) ||</span>
+<span class="plain-syntax">            (</span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_line</span><span class="plain-syntax">)) {</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax"> = </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">choice_at</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(),</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_ChoiceBlankRedundant</span><span class="plain-syntax">),</span>
+<span class="plain-syntax">                </span><span class="string-syntax">"this use of '-&gt; another choice' looks redundant"</span><span class="plain-syntax">,</span>
+<span class="plain-syntax">                </span><span class="string-syntax">"occurring at the start or end of a set of options. "</span>
+<span class="plain-syntax">                </span><span class="string-syntax">"'-&gt; another choice' should be used only where there's "</span>
+<span class="plain-syntax">                </span><span class="string-syntax">"a need to mark a division point between two sets "</span>
+<span class="plain-syntax">                </span><span class="string-syntax">"of options running on from one to the other."</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">        }</span>
+<span class="plain-syntax">    }</span>
+<span class="plain-syntax">    </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_decision</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">decision_type</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">;</span>
+</pre>
+<ul class="endnotetexts"><li>This code is used in <a href="6-dn.html#SP5">&#167;5</a>.</li></ul>
+<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6.  </b></p>
+
+<pre class="displayed-code all-displayed-code code-font">
 <span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">DialogueNodes::log_node_tree</span><span class="plain-syntax">(</span><span class="reserved-syntax">dialogue_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">dn</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">dn</span><span class="plain-syntax">; </span><span class="identifier-syntax">dn</span><span class="plain-syntax">=</span><span class="identifier-syntax">dn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
-<span class="plain-syntax">        </span><a href="6-dn.html#SP5" class="function-link"><span class="function-syntax">DialogueNodes::log_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">dn</span><span class="plain-syntax">); </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"\n"</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">        </span><a href="6-dn.html#SP6" class="function-link"><span class="function-syntax">DialogueNodes::log_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">dn</span><span class="plain-syntax">); </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"\n"</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">dn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">            </span><span class="identifier-syntax">LOG_INDENT</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">            </span><a href="6-dn.html#SP5" class="function-link"><span class="function-syntax">DialogueNodes::log_node_tree</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">dn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">            </span><a href="6-dn.html#SP6" class="function-link"><span class="function-syntax">DialogueNodes::log_node_tree</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">dn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">            </span><span class="identifier-syntax">LOG_OUTDENT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        }</span>
 <span class="plain-syntax">    }</span>
@@ -343,7 +383,7 @@ impossible to hit.
 <span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">dn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_decision</span><span class="plain-syntax">) </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"decision %d"</span><span class="plain-syntax">, </span><span class="identifier-syntax">dn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_decision</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">allocation_id</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">}</span>
 
-<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">DialogueNodes::decision_type</span><span class="plain-syntax">(</span><span class="reserved-syntax">dialogue_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">dn</span><span class="plain-syntax">) {</span>
+<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">DialogueNodes::decision_type</span><button class="popup" onclick="togglePopup('usagePopup4')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup4">Usage of <span class="code-font"><span class="function-syntax">DialogueNodes::decision_type</span></span>:<br/><a href="6-dn.html#SP5">&#167;5</a>, <a href="6-dn.html#SP5_2">&#167;5.2</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">dialogue_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">dn</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">dn</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">dn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> -1;</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">dn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">if_choice</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">selection_type</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">ANOTHER_CHOICE_DSEL:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">PARSED_COMMAND_DDT</span><span class="plain-syntax">;</span>
@@ -359,6 +399,12 @@ impossible to hit.
 <span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">AFTER_DSEL:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">PARSED_COMMAND_DDT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">BEFORE_DSEL:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">PARSED_COMMAND_DDT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PERFORM_DSEL:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">FLOW_CONTROL_DDT</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">CHOOSE_RANDOMLY_DSEL:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">RANDOMISED_CONTROL_DDT</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">SHUFFLE_THROUGH_DSEL:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">SHUFFLE_CONTROL_DDT</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">CYCLE_THROUGH_DSEL:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">CYCLE_CONTROL_DDT</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">STEP_THROUGH_DSEL:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">STEP_CONTROL_DDT</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">STEP_THROUGH_AND_STOP_DSEL:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">STEP_STOP_CONTROL_DDT</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">OR_DSEL:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">RANDOMISED_CONTROL_DDT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">default:</span><span class="plain-syntax"> </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"unimplemented DSEL"</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">    }</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> -1;</span>

docs/lexicon-module/P-wtmd.html

@@ -181,7 +181,7 @@ number of successes.
 </li></ul>
 <pre class="undisplayed-code all-displayed-code code-font">
 <span class="plain-syntax">Size of lexicon: 3165 excerpt meanings</span>
-<span class="plain-syntax">  Stored among 855 words out of total vocabulary of 10638</span>
+<span class="plain-syntax">  Stored among 855 words out of total vocabulary of 10642</span>
 <span class="plain-syntax">  719 words have a start list: longest belongs to report (with 293 meanings)</span>
 <span class="plain-syntax">  21 words have an end list: longest belongs to digits (with 7 meanings)</span>
 <span class="plain-syntax">  29 words have a middle list: longest belongs to to (with 4 meanings)</span>

docs/runtime-module/2-ea.html

@@ -150,7 +150,7 @@ which would be a typesafe list in I7, so they can be absolutely any data.
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
-<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">EmitArrays::numeric_entry</span><button class="popup" onclick="togglePopup('usagePopup10')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup10">Usage of <span class="code-font"><span class="function-syntax">EmitArrays::numeric_entry</span></span>:<br/>The Heap - <a href="2-th.html#SP6">&#167;6</a><br/>Default Values - <a href="2-dv.html#SP2_8">&#167;2.8</a>, <a href="2-dv.html#SP2_8_1">&#167;2.8.1</a><br/>List Literals - <a href="4-ll.html#SP1">&#167;1</a>, <a href="4-ll.html#SP2">&#167;2</a><br/>Box Quotations - <a href="4-bq.html#SP2">&#167;2</a><br/>Relation Literals - <a href="4-rl.html#SP1">&#167;1</a><br/>Stored Action Literals - <a href="4-sal.html#SP1">&#167;1</a><br/>Instances - <a href="5-ins.html#SP4">&#167;4</a><br/>Multimedia - <a href="5-mlt.html#SP2_1">&#167;2.1</a>, <a href="5-mlt.html#SP2_2">&#167;2.2</a>, <a href="5-mlt.html#SP3_2">&#167;3.2</a><br/>Tables - <a href="5-tbl.html#SP2_1_1_1_4">&#167;2.1.1.1.4</a>, <a href="5-tbl.html#SP2_2_3">&#167;2.2.3</a><br/>Dialogue Beat Instances - <a href="5-dbi.html#SP2">&#167;2</a>, <a href="5-dbi.html#SP2_1">&#167;2.1</a>, <a href="5-dbi.html#SP2_2">&#167;2.2</a>, <a href="5-dbi.html#SP2_4">&#167;2.4</a>, <a href="5-dbi.html#SP2_5">&#167;2.5</a>, <a href="5-dbi.html#SP2_6">&#167;2.6</a>, <a href="5-dbi.html#SP2_9">&#167;2.9</a>, <a href="5-dbi.html#SP3">&#167;3</a><br/>Dialogue - <a href="5-dli.html#SP3_2">&#167;3.2</a>, <a href="5-dli.html#SP3_3">&#167;3.3</a>, <a href="5-dli.html#SP3_4">&#167;3.4</a>, <a href="5-dli.html#SP3_6">&#167;3.6</a>, <a href="5-dli.html#SP3_7">&#167;3.7</a>, <a href="5-dli.html#SP3_8">&#167;3.8</a>, <a href="5-dli.html#SP3_9">&#167;3.9</a><br/>Dialogue Choice Instances - <a href="5-dci.html#SP3_2">&#167;3.2</a>, <a href="5-dci.html#SP3_3">&#167;3.3</a>, <a href="5-dci.html#SP3_4">&#167;3.4</a><br/>Relations - <a href="5-rlt.html#SP6_3">&#167;6.3</a>, <a href="5-rlt.html#SP6_3_3">&#167;6.3.3</a>, <a href="5-rlt.html#SP7">&#167;7</a>, <a href="5-rlt.html#SP9">&#167;9</a>, <a href="5-rlt.html#SP10_2">&#167;10.2</a>, <a href="5-rlt.html#SP10_3">&#167;10.3</a><br/>Kind Constructors - <a href="5-kc.html#SP28">&#167;28</a>, <a href="5-kc.html#SP32_3_2">&#167;32.3.2</a><br/>Kind IDs - <a href="5-ki.html#SP9_1_1_1">&#167;9.1.1.1</a>, <a href="5-ki.html#SP9_1_1_2">&#167;9.1.1.2</a><br/>Test Scripts - <a href="5-ts.html#SP4">&#167;4</a><br/>The Player - <a href="6-tp.html#SP1">&#167;1</a><br/>The Map - <a href="6-tm.html#SP1">&#167;1</a><br/>Action Bitmap Property - <a href="6-abp.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">inter_ti</span><span class="plain-syntax"> </span><span class="identifier-syntax">N</span><span class="plain-syntax">) {</span>
+<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">EmitArrays::numeric_entry</span><button class="popup" onclick="togglePopup('usagePopup10')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup10">Usage of <span class="code-font"><span class="function-syntax">EmitArrays::numeric_entry</span></span>:<br/>The Heap - <a href="2-th.html#SP6">&#167;6</a><br/>Default Values - <a href="2-dv.html#SP2_8">&#167;2.8</a>, <a href="2-dv.html#SP2_8_1">&#167;2.8.1</a><br/>List Literals - <a href="4-ll.html#SP1">&#167;1</a>, <a href="4-ll.html#SP2">&#167;2</a><br/>Box Quotations - <a href="4-bq.html#SP2">&#167;2</a><br/>Relation Literals - <a href="4-rl.html#SP1">&#167;1</a><br/>Stored Action Literals - <a href="4-sal.html#SP1">&#167;1</a><br/>Instances - <a href="5-ins.html#SP4">&#167;4</a><br/>Multimedia - <a href="5-mlt.html#SP2_1">&#167;2.1</a>, <a href="5-mlt.html#SP2_2">&#167;2.2</a>, <a href="5-mlt.html#SP3_2">&#167;3.2</a><br/>Tables - <a href="5-tbl.html#SP2_1_1_1_4">&#167;2.1.1.1.4</a>, <a href="5-tbl.html#SP2_2_3">&#167;2.2.3</a><br/>Dialogue Beat Instances - <a href="5-dbi.html#SP2">&#167;2</a>, <a href="5-dbi.html#SP2_1">&#167;2.1</a>, <a href="5-dbi.html#SP2_2">&#167;2.2</a>, <a href="5-dbi.html#SP2_4">&#167;2.4</a>, <a href="5-dbi.html#SP2_5">&#167;2.5</a>, <a href="5-dbi.html#SP2_6">&#167;2.6</a>, <a href="5-dbi.html#SP2_9">&#167;2.9</a>, <a href="5-dbi.html#SP3">&#167;3</a><br/>Dialogue - <a href="5-dli.html#SP3_2">&#167;3.2</a>, <a href="5-dli.html#SP3_3">&#167;3.3</a>, <a href="5-dli.html#SP3_4">&#167;3.4</a>, <a href="5-dli.html#SP3_6">&#167;3.6</a>, <a href="5-dli.html#SP3_7">&#167;3.7</a>, <a href="5-dli.html#SP3_8">&#167;3.8</a>, <a href="5-dli.html#SP3_9">&#167;3.9</a><br/>Dialogue Choice Instances - <a href="5-dci.html#SP3_2">&#167;3.2</a>, <a href="5-dci.html#SP3_3">&#167;3.3</a>, <a href="5-dci.html#SP3_4">&#167;3.4</a>, <a href="5-dci.html#SP3_5">&#167;3.5</a><br/>Relations - <a href="5-rlt.html#SP6_3">&#167;6.3</a>, <a href="5-rlt.html#SP6_3_3">&#167;6.3.3</a>, <a href="5-rlt.html#SP7">&#167;7</a>, <a href="5-rlt.html#SP9">&#167;9</a>, <a href="5-rlt.html#SP10_2">&#167;10.2</a>, <a href="5-rlt.html#SP10_3">&#167;10.3</a><br/>Kind Constructors - <a href="5-kc.html#SP28">&#167;28</a>, <a href="5-kc.html#SP32_3_2">&#167;32.3.2</a><br/>Kind IDs - <a href="5-ki.html#SP9_1_1_1">&#167;9.1.1.1</a>, <a href="5-ki.html#SP9_1_1_2">&#167;9.1.1.2</a><br/>Test Scripts - <a href="5-ts.html#SP4">&#167;4</a><br/>The Player - <a href="6-tp.html#SP1">&#167;1</a><br/>The Map - <a href="6-tm.html#SP1">&#167;1</a><br/>Action Bitmap Property - <a href="6-abp.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">inter_ti</span><span class="plain-syntax"> </span><span class="identifier-syntax">N</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">    </span><a href="2-ea.html#SP9" class="function-link"><span class="function-syntax">EmitArrays::entry_inner</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">InterValuePairs::number</span><span class="plain-syntax">(</span><span class="identifier-syntax">N</span><span class="plain-syntax">));</span>
 <span class="plain-syntax">}</span>
 

docs/runtime-module/5-dci.html

@@ -92,14 +92,14 @@ function togglePopup(material_id) {
 <span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">compilation_data</span><span class="plain-syntax">.</span><span class="element-syntax">choice_array_iname</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
 
-<span class="identifier-syntax">inter_name</span><span class="plain-syntax"> *</span><span class="function-syntax">RTDialogueChoices::available_fn_iname</span><button class="popup" onclick="togglePopup('usagePopup3')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup3">Usage of <span class="code-font"><span class="function-syntax">RTDialogueChoices::available_fn_iname</span></span>:<br/><a href="5-dci.html#SP3_3">&#167;3.3</a>, <a href="5-dci.html#SP3_5">&#167;3.5</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">dialogue_choice</span><span class="plain-syntax"> *</span><span class="identifier-syntax">dc</span><span class="plain-syntax">) {</span>
+<span class="identifier-syntax">inter_name</span><span class="plain-syntax"> *</span><span class="function-syntax">RTDialogueChoices::available_fn_iname</span><button class="popup" onclick="togglePopup('usagePopup3')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup3">Usage of <span class="code-font"><span class="function-syntax">RTDialogueChoices::available_fn_iname</span></span>:<br/><a href="5-dci.html#SP3_3">&#167;3.3</a>, <a href="5-dci.html#SP3_6">&#167;3.6</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">dialogue_choice</span><span class="plain-syntax"> *</span><span class="identifier-syntax">dc</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">compilation_data</span><span class="plain-syntax">.</span><span class="element-syntax">available_fn_iname</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">)</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">compilation_data</span><span class="plain-syntax">.</span><span class="element-syntax">available_fn_iname</span><span class="plain-syntax"> =</span>
 <span class="plain-syntax">            </span><a href="2-hrr.html#SP12" class="function-link"><span class="function-syntax">Hierarchy::make_iname_in</span></a><span class="plain-syntax">(</span><span class="constant-syntax">CHOICE_AVAILABLE_FN_HL</span><span class="plain-syntax">, </span><a href="5-dci.html#SP1" class="function-link"><span class="function-syntax">RTDialogueChoices::package</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">));</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">compilation_data</span><span class="plain-syntax">.</span><span class="element-syntax">available_fn_iname</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
 
-<span class="identifier-syntax">inter_name</span><span class="plain-syntax"> *</span><span class="function-syntax">RTDialogueChoices::action_match_fn_iname</span><button class="popup" onclick="togglePopup('usagePopup4')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup4">Usage of <span class="code-font"><span class="function-syntax">RTDialogueChoices::action_match_fn_iname</span></span>:<br/><a href="5-dci.html#SP3_4">&#167;3.4</a>, <a href="5-dci.html#SP3_6">&#167;3.6</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">dialogue_choice</span><span class="plain-syntax"> *</span><span class="identifier-syntax">dc</span><span class="plain-syntax">) {</span>
+<span class="identifier-syntax">inter_name</span><span class="plain-syntax"> *</span><span class="function-syntax">RTDialogueChoices::action_match_fn_iname</span><button class="popup" onclick="togglePopup('usagePopup4')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup4">Usage of <span class="code-font"><span class="function-syntax">RTDialogueChoices::action_match_fn_iname</span></span>:<br/><a href="5-dci.html#SP3_4">&#167;3.4</a>, <a href="5-dci.html#SP3_7">&#167;3.7</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">dialogue_choice</span><span class="plain-syntax"> *</span><span class="identifier-syntax">dc</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">compilation_data</span><span class="plain-syntax">.</span><span class="element-syntax">action_match_fn_iname</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">)</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">dc</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">compilation_data</span><span class="plain-syntax">.</span><span class="element-syntax">action_match_fn_iname</span><span class="plain-syntax"> =</span>
 <span class="plain-syntax">            </span><a href="2-hrr.html#SP12" class="function-link"><span class="function-syntax">Hierarchy::make_iname_in</span></a><span class="plain-syntax">(</span><span class="constant-syntax">CHOICE_ACTION_MATCH_FN_HL</span><span class="plain-syntax">, </span><a href="5-dci.html#SP1" class="function-link"><span class="function-syntax">RTDialogueChoices::package</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">));</span>
@@ -137,10 +137,11 @@ function togglePopup(material_id) {
 <span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="5-dci.html#SP3_2" class="named-paragraph-link"><span class="named-paragraph">Write the type entry</span><span class="named-paragraph-number">3.2</span></a></span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="5-dci.html#SP3_3" class="named-paragraph-link"><span class="named-paragraph">Write the availability entry</span><span class="named-paragraph-number">3.3</span></a></span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="5-dci.html#SP3_4" class="named-paragraph-link"><span class="named-paragraph">Write the details entry</span><span class="named-paragraph-number">3.4</span></a></span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="5-dci.html#SP3_5" class="named-paragraph-link"><span class="named-paragraph">Write the state word</span><span class="named-paragraph-number">3.5</span></a></span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><a href="2-ea.html#SP5" class="function-link"><span class="function-syntax">EmitArrays::end</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">save</span><span class="plain-syntax">);</span>
 
-<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">make_availability_function</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="5-dci.html#SP3_5" class="named-paragraph-link"><span class="named-paragraph">Compile the available function</span><span class="named-paragraph-number">3.5</span></a></span><span class="plain-syntax">;</span>
-<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Wordings::nonempty</span><span class="plain-syntax">(</span><span class="identifier-syntax">APW</span><span class="plain-syntax">)) </span><span class="named-paragraph-container code-font"><a href="5-dci.html#SP3_6" class="named-paragraph-link"><span class="named-paragraph">Compile the action-matching function</span><span class="named-paragraph-number">3.6</span></a></span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">make_availability_function</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="5-dci.html#SP3_6" class="named-paragraph-link"><span class="named-paragraph">Compile the available function</span><span class="named-paragraph-number">3.6</span></a></span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Wordings::nonempty</span><span class="plain-syntax">(</span><span class="identifier-syntax">APW</span><span class="plain-syntax">)) </span><span class="named-paragraph-container code-font"><a href="5-dci.html#SP3_7" class="named-paragraph-link"><span class="named-paragraph">Compile the action-matching function</span><span class="named-paragraph-number">3.7</span></a></span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
 </pre>
 <p class="commentary firstcommentary"><a id="SP3_1" class="paragraph-anchor"></a><b>&#167;3.1.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Scan the clauses further</span><span class="named-paragraph-number">3.1</span></span><span class="comment-syntax"> =</span>
@@ -226,17 +227,24 @@ function togglePopup(material_id) {
 <span class="plain-syntax">    }</span>
 </pre>
 <ul class="endnotetexts"><li>This code is used in <a href="5-dci.html#SP3">&#167;3</a>.</li></ul>
-<p class="commentary firstcommentary"><a id="SP3_5" class="paragraph-anchor"></a><b>&#167;3.5.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Compile the available function</span><span class="named-paragraph-number">3.5</span></span><span class="comment-syntax"> =</span>
+<p class="commentary firstcommentary"><a id="SP3_5" class="paragraph-anchor"></a><b>&#167;3.5.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Write the state word</span><span class="named-paragraph-number">3.5</span></span><span class="comment-syntax"> =</span>
+</p>
+
+<pre class="displayed-code all-displayed-code code-font">
+<span class="plain-syntax">    </span><a href="2-ea.html#SP4" class="function-link"><span class="function-syntax">EmitArrays::numeric_entry</span></a><span class="plain-syntax">(0);</span>
+</pre>
+<ul class="endnotetexts"><li>This code is used in <a href="5-dci.html#SP3">&#167;3</a>.</li></ul>
+<p class="commentary firstcommentary"><a id="SP3_6" class="paragraph-anchor"></a><b>&#167;3.6.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Compile the available function</span><span class="named-paragraph-number">3.6</span></span><span class="comment-syntax"> =</span>
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
 <span class="plain-syntax">    </span><span class="identifier-syntax">packaging_state</span><span class="plain-syntax"> </span><span class="identifier-syntax">save</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Functions::begin</span><span class="plain-syntax">(</span><a href="5-dci.html#SP1" class="function-link"><span class="function-syntax">RTDialogueChoices::available_fn_iname</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">dc</span><span class="plain-syntax">));</span>
-<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="5-dci.html#SP3_5_1" class="named-paragraph-link"><span class="named-paragraph">Check the if and unless conditions</span><span class="named-paragraph-number">3.5.1</span></a></span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="5-dci.html#SP3_6_1" class="named-paragraph-link"><span class="named-paragraph">Check the if and unless conditions</span><span class="named-paragraph-number">3.6.1</span></a></span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><a href="2-ec.html#SP15" class="function-link"><span class="function-syntax">EmitCode::rtrue</span></a><span class="plain-syntax">();</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">Functions::end</span><span class="plain-syntax">(</span><span class="identifier-syntax">save</span><span class="plain-syntax">);</span>
 </pre>
 <ul class="endnotetexts"><li>This code is used in <a href="5-dci.html#SP3">&#167;3</a>.</li></ul>
-<p class="commentary firstcommentary"><a id="SP3_5_1" class="paragraph-anchor"></a><b>&#167;3.5.1.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Check the if and unless conditions</span><span class="named-paragraph-number">3.5.1</span></span><span class="comment-syntax"> =</span>
+<p class="commentary firstcommentary"><a id="SP3_6_1" class="paragraph-anchor"></a><b>&#167;3.6.1.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Check the if and unless conditions</span><span class="named-paragraph-number">3.6.1</span></span><span class="comment-syntax"> =</span>
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
@@ -283,8 +291,8 @@ function togglePopup(material_id) {
 <span class="plain-syntax">        }</span>
 <span class="plain-syntax">    }</span>
 </pre>
-<ul class="endnotetexts"><li>This code is used in <a href="5-dci.html#SP3_5">&#167;3.5</a>.</li></ul>
-<p class="commentary firstcommentary"><a id="SP3_6" class="paragraph-anchor"></a><b>&#167;3.6.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Compile the action-matching function</span><span class="named-paragraph-number">3.6</span></span><span class="comment-syntax"> =</span>
+<ul class="endnotetexts"><li>This code is used in <a href="5-dci.html#SP3_6">&#167;3.6</a>.</li></ul>
+<p class="commentary firstcommentary"><a id="SP3_7" class="paragraph-anchor"></a><b>&#167;3.7.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Compile the action-matching function</span><span class="named-paragraph-number">3.7</span></span><span class="comment-syntax"> =</span>
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">

docs/standard_rules/S-act2.html

@@ -3404,10 +3404,12 @@ where lines are spoken more into the room than at any one person.
 <span class="plain-syntax">    (</span><span class="identifier-syntax">this</span><span class="plain-syntax"> </span><span class="identifier-syntax">is</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">first</span><span class="plain-syntax">-</span><span class="identifier-syntax">declared</span><span class="plain-syntax"> </span><span class="identifier-syntax">beat</span><span class="plain-syntax"> </span><span class="identifier-syntax">rule</span><span class="plain-syntax">):</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">if</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">leading</span><span class="plain-syntax"> </span><span class="identifier-syntax">beats</span><span class="plain-syntax"> </span><span class="identifier-syntax">is</span><span class="plain-syntax"> </span><span class="identifier-syntax">not</span><span class="plain-syntax"> </span><span class="identifier-syntax">empty</span><span class="plain-syntax">:</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">perform</span><span class="plain-syntax"> </span><span class="identifier-syntax">entry</span><span class="plain-syntax"> </span><span class="constant-syntax">1</span><span class="plain-syntax"> </span><span class="identifier-syntax">of</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">leading</span><span class="plain-syntax"> </span><span class="identifier-syntax">beats</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">        </span><span class="identifier-syntax">continue</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">action</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">if</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">dialogue</span><span class="plain-syntax"> </span><span class="identifier-syntax">line</span><span class="plain-syntax"> </span><span class="identifier-syntax">performance</span><span class="plain-syntax"> </span><span class="identifier-syntax">count</span><span class="plain-syntax"> </span><span class="identifier-syntax">is</span><span class="plain-syntax"> </span><span class="identifier-syntax">greater</span><span class="plain-syntax"> </span><span class="identifier-syntax">than</span><span class="plain-syntax"> </span><span class="identifier-syntax">zero</span><span class="plain-syntax">:</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">continue</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">action</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">if</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">other</span><span class="plain-syntax"> </span><span class="identifier-syntax">beats</span><span class="plain-syntax"> </span><span class="identifier-syntax">is</span><span class="plain-syntax"> </span><span class="identifier-syntax">not</span><span class="plain-syntax"> </span><span class="identifier-syntax">empty</span><span class="plain-syntax">:</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">perform</span><span class="plain-syntax"> </span><span class="identifier-syntax">entry</span><span class="plain-syntax"> </span><span class="constant-syntax">1</span><span class="plain-syntax"> </span><span class="identifier-syntax">of</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">other</span><span class="plain-syntax"> </span><span class="identifier-syntax">beats</span><span class="plain-syntax">;</span>
-<span class="plain-syntax">        </span><span class="identifier-syntax">continue</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">action</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">        </span><span class="identifier-syntax">if</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">dialogue</span><span class="plain-syntax"> </span><span class="identifier-syntax">line</span><span class="plain-syntax"> </span><span class="identifier-syntax">performance</span><span class="plain-syntax"> </span><span class="identifier-syntax">count</span><span class="plain-syntax"> </span><span class="identifier-syntax">is</span><span class="plain-syntax"> </span><span class="identifier-syntax">greater</span><span class="plain-syntax"> </span><span class="identifier-syntax">than</span><span class="plain-syntax"> </span><span class="identifier-syntax">zero</span><span class="plain-syntax">:</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">continue</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">action</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">if</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">player</span><span class="plain-syntax"> </span><span class="identifier-syntax">is</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">actor</span><span class="plain-syntax">:</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">say</span><span class="plain-syntax"> </span><span class="string-syntax">"There is no reply."</span><span class="plain-syntax"> (</span><span class="identifier-syntax">A</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">stop</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">action</span><span class="plain-syntax">;</span>

docs/standard_rules/S-var.html

@@ -1410,6 +1410,9 @@ some response texts can be hung.
 <span class="identifier-syntax">To</span><span class="plain-syntax"> </span><span class="identifier-syntax">decide</span><span class="plain-syntax"> </span><span class="identifier-syntax">what</span><span class="plain-syntax"> </span><span class="identifier-syntax">number</span><span class="plain-syntax"> </span><span class="identifier-syntax">is</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">chosen</span><span class="plain-syntax"> </span><span class="identifier-syntax">dialogue</span><span class="plain-syntax"> </span><span class="identifier-syntax">number</span><span class="plain-syntax"> </span><span class="identifier-syntax">up</span><span class="plain-syntax"> </span><span class="identifier-syntax">to</span><span class="plain-syntax"> (</span><span class="identifier-syntax">N</span><span class="plain-syntax"> - </span><span class="identifier-syntax">number</span><span class="plain-syntax">):</span>
 <span class="plain-syntax">    (- </span><span class="identifier-syntax">DirectorPickANumber</span><span class="plain-syntax">({</span><span class="identifier-syntax">N</span><span class="plain-syntax">}) -).</span>
 
+<span class="identifier-syntax">To</span><span class="plain-syntax"> </span><span class="identifier-syntax">decide</span><span class="plain-syntax"> </span><span class="identifier-syntax">what</span><span class="plain-syntax"> </span><span class="identifier-syntax">number</span><span class="plain-syntax"> </span><span class="identifier-syntax">is</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">dialogue</span><span class="plain-syntax"> </span><span class="identifier-syntax">line</span><span class="plain-syntax"> </span><span class="identifier-syntax">performance</span><span class="plain-syntax"> </span><span class="identifier-syntax">count</span><span class="plain-syntax">:</span>
+<span class="plain-syntax">    (- </span><span class="identifier-syntax">line_performance_count</span><span class="plain-syntax"> -).</span>
+
 <span class="identifier-syntax">To</span><span class="plain-syntax"> </span><span class="identifier-syntax">perform</span><span class="plain-syntax"> (</span><span class="identifier-syntax">B</span><span class="plain-syntax"> - </span><span class="identifier-syntax">a</span><span class="plain-syntax"> </span><span class="identifier-syntax">dialogue</span><span class="plain-syntax"> </span><span class="identifier-syntax">beat</span><span class="plain-syntax">):</span>
 <span class="plain-syntax">    (- </span><span class="identifier-syntax">DirectorPerformBeat</span><span class="plain-syntax">({</span><span class="identifier-syntax">B</span><span class="plain-syntax">}); -).</span>
 

inform7/Downloads/excerpts-diagnostics.txt

@@ -1,5 +1,5 @@
 Size of lexicon: 3165 excerpt meanings
-  Stored among 855 words out of total vocabulary of 10638
+  Stored among 855 words out of total vocabulary of 10642
   719 words have a start list: longest belongs to report (with 293 meanings)
   21 words have an end list: longest belongs to digits (with 7 meanings)
   29 words have a middle list: longest belongs to to (with 4 meanings)

inform7/Downloads/preform-diagnostics.txt

@@ -1,6 +1,6 @@
 <preform-nonterminal> internal nti 28 constraint (none) extremes [1, 1]
 
-<if-start-of-paragraph> internal hits 1320/8652 nti 29 constraint (none) extremes [0, 0]
+<if-start-of-paragraph> internal hits 1321/8688 nti 29 constraint (none) extremes [0, 0]
 
 <if-not-cap> internal hits 4036/8296 nti 30 constraint (none) extremes [0, 0]
 
@@ -24,7 +24,7 @@
 
 <empty-text> internal nti 11 constraint (none) extremes [1, 1]
 
-<if-start-of-source-text> internal hits 2/13900 nti 12 constraint (none) extremes [0, 0]
+<if-start-of-source-text> internal hits 2/13908 nti 12 constraint (none) extremes [0, 0]
 
 <list-or-division> hits 0/18 nti 16 constraint DS = {16} extremes [3, infinity)
     English:
@@ -5446,59 +5446,59 @@
 
 <natural-language> internal nti 18 constraint (none) extremes [1, infinity)
 
-<dividing-sentence> hits 214/10978 nti 19 constraint DW = {12, 13} extremes [2, infinity)
+<dividing-sentence> hits 214/10986 nti 19 constraint DW = {12, 13} extremes [2, infinity)
     English:
         <if-start-of-paragraph> <heading> 
-          (hits 206/4312) (matched long text) constraint DS = {12} extremes [2, infinity)
+          (hits 206/4330) (matched long text) constraint DS = {12} extremes [2, infinity)
         <extension-end-marker-sentence> 
-          (hits 8/3637) (matched long text) constraint DS = {13} extremes [3, infinity)
+          (hits 8/3640) (matched long text) constraint DS = {13} extremes [3, infinity)
 
-<heading> hits 206/2612 nti 12 constraint DS = {12} extremes [2, infinity)
+<heading> hits 206/2614 nti 12 constraint DS = {12} extremes [2, infinity)
     English:
         volume {...} 
-          (hits 6/1306) (matched long text) constraint DS = {12} extremes [2, infinity)
+          (hits 6/1307) (matched long text) constraint DS = {12} extremes [2, infinity)
         book {...} 
-          (hits 0/1300) constraint DS = {12} extremes [2, infinity)
+          (hits 0/1301) constraint DS = {12} extremes [2, infinity)
         part {...} 
-          (hits 14/1300) (matched: 'part two - the physical world model') constraint DS = {12} extremes [2, infinity)
+          (hits 14/1301) (matched: 'part two - the physical world model') constraint DS = {12} extremes [2, infinity)
         chapter {...} 
-          (hits 24/1286) (matched long text) constraint DS = {12} extremes [2, infinity)
+          (hits 24/1287) (matched long text) constraint DS = {12} extremes [2, infinity)
         section {...} ( dialog ) 
-          (hits 0/1178) constraint DS = {12} extremes [5, infinity)
+          (hits 0/1179) constraint DS = {12} extremes [5, infinity)
         section {...} ( dialogue ) 
-          (hits 0/1178) constraint DS = {12} extremes [5, infinity)
+          (hits 0/1179) constraint DS = {12} extremes [5, infinity)
         section {...} 
-          (hits 162/1262) (matched long text) constraint DS = {12} extremes [2, infinity)
+          (hits 162/1263) (matched long text) constraint DS = {12} extremes [2, infinity)
 
-<extension-end-marker-sentence> hits 8/7274 nti 13 constraint DS = {13} extremes [3, infinity)
+<extension-end-marker-sentence> hits 8/7280 nti 13 constraint DS = {13} extremes [3, infinity)
     English:
         {...} begin/begins here 
-          (hits 4/3637) (matched long text) constraint DS = {13} extremes [3, infinity)
+          (hits 4/3640) (matched long text) constraint DS = {13} extremes [3, infinity)
         {...} end/ends here 
-          (hits 4/3633) (matched: 'the standard rules end here') constraint DS = {13} extremes [3, infinity)
+          (hits 4/3636) (matched: 'the standard rules end here') constraint DS = {13} extremes [3, infinity)
 
-<structural-sentence> hits 32/13900 nti 15 constraint (none) extremes [1, infinity)
+<structural-sentence> hits 32/13908 nti 15 constraint (none) extremes [1, infinity)
     English:
         <if-start-of-source-text> <quoted-text> 
           (hits 0/20) constraint (none) extremes [1, 1]
         <if-start-of-source-text> <quoted-text> {...} 
-          (hits 0/6930) constraint (none) extremes [2, infinity)
+          (hits 0/6934) constraint (none) extremes [2, infinity)
         <language-modifying-sentence> 
-          (hits 0/6760) constraint DS = {14} extremes [4, infinity)
+          (hits 0/6764) constraint DS = {14} extremes [4, infinity)
         * 
           constraint CS = {15} extremes [1, 1]
         * <quoted-text-without-subs> 
           constraint DS = {15} extremes [2, 2]
         <if-start-of-paragraph> table {...} 
-          (hits 14/6771) (matched long text) constraint DS = {15} extremes [2, infinity)
+          (hits 14/6775) (matched long text) constraint DS = {15} extremes [2, infinity)
         <if-start-of-paragraph> equation {...} 
-          (hits 0/6757) constraint DS = {15} extremes [2, infinity)
+          (hits 0/6761) constraint DS = {15} extremes [2, infinity)
         include the {...} by {...} 
-          (hits 0/6745) constraint DS = {15} extremes [5, infinity)
+          (hits 0/6749) constraint DS = {15} extremes [5, infinity)
         include {...} by {...} 
-          (hits 18/6757) (matched long text) constraint DS = {15} extremes [4, infinity)
+          (hits 18/6761) (matched long text) constraint DS = {15} extremes [4, infinity)
         include (- {...} 
-          (hits 0/6739) constraint DS = {15} extremes [3, infinity)
+          (hits 0/6743) constraint DS = {15} extremes [3, infinity)
 
 <comma-divisible-sentence> hits 9/2942 nti 16 constraint DS = {16} extremes [2, infinity)
     English:
@@ -5513,12 +5513,12 @@
         when {...} 
           (hits 4/1285) (matched: 'when scene begins is a scene based rulebook') constraint DS = {16} extremes [2, infinity)
 
-<language-modifying-sentence> hits 0/13520 nti 14 constraint DS = {14} extremes [4, infinity)
+<language-modifying-sentence> hits 0/13528 nti 14 constraint DS = {14} extremes [4, infinity)
     English:
         include (- {###} in the preform grammar 
           (hits 0/106) constraint DS = {14} extremes [7, 7]
         use {...} language element/elements 
-          (hits 0/6760) constraint DS = {14} extremes [4, infinity)
+          (hits 0/6764) constraint DS = {14} extremes [4, infinity)
 
 <heading-qualifier> hits 39/490 nti 22 constraint DS = {22} extremes [2, infinity)
     English:
@@ -10006,6 +10006,18 @@
           constraint DS = {12} extremes [3, infinity)
         perform {...} 
           constraint DS = {12} extremes [2, infinity)
+        choose randomly 
+          constraint CS = {12} extremes [2, 2]
+        shuffle through 
+          constraint CS = {12} extremes [2, 2]
+        cycle through 
+          constraint CS = {12} extremes [2, 2]
+        step through 
+          constraint CS = {12} extremes [2, 2]
+        step through and stop 
+          constraint CS = {12} extremes [4, 4]
+        or 
+          constraint CS = {12} extremes [1, 1]
 
 <performance-style-name-convention> nti 13 constraint DS = {13} extremes [2, infinity)
     English:

inform7/Figures/memory-diagnostics.txt

@@ -1,6 +1,6 @@
 Total memory consumption was 139587K = 136 MB
 
- ---- was used for 2127358 objects, in 374813 frames in 0 x 800K = 0K = 0 MB:
+ ---- was used for 2127377 objects, in 374832 frames in 0 x 800K = 0K = 0 MB:
 
     30.2%  inter_tree_node_array                    60 x 8192 = 491520 objects, 43255680 bytes
     19.4%  text_stream_array                        4926 x 100 = 492600 objects, 27743232 bytes
@@ -28,8 +28,8 @@ Total memory consumption was 139587K = 136 MB
      0.7%  adjective_meaning                        208 objects, 1030016 bytes
      0.7%  inter_schema_node                        9062 objects, 1014944 bytes
      0.6%  excerpt_meaning                          3165 objects, 987480 bytes
-     0.6%  production                               3986 objects, 924752 bytes
-     0.6%  ptoken                                   8653 objects, 899912 bytes
+     0.6%  production                               3992 objects, 926144 bytes
+     0.6%  ptoken                                   8666 objects, 901264 bytes
      0.6%  grammatical_usage                        3648 objects, 875520 bytes
      0.6%  individual_form                          2581 objects, 867216 bytes
      0.4%  unary_predicate_array                    17 x 1000 = 17000 objects, 680544 bytes
@@ -282,5 +282,5 @@ Total memory consumption was 139587K = 136 MB
      ----  code generation workspace for objects    3528 bytes in 19 claims
      0.1%  emitter array storage                    281184 bytes in 2006 claims
 
--136.-6% was overhead - -195276728 bytes = -190699K = -186 MB
+-136.-6% was overhead - -195279472 bytes = -190702K = -186 MB
 

inform7/Figures/timings-diagnostics.txt

@@ -1,29 +1,29 @@
 100.0% in inform7 run
-     67.2% in compilation to Inter
-         45.8% in //Sequence::undertake_queued_tasks//
-          4.1% in //MajorNodes::pre_pass//
-          3.7% in //MajorNodes::pass_1//
+     67.8% in compilation to Inter
+         46.1% in //Sequence::undertake_queued_tasks//
+          4.4% in //MajorNodes::pre_pass//
+          3.6% in //MajorNodes::pass_1//
           1.8% in //ImperativeDefinitions::assess_all//
-          1.5% in //RTKindConstructors::compile//
-          1.5% in //RTPhrasebook::compile_entries//
+          1.4% in //RTKindConstructors::compile//
+          1.4% in //RTPhrasebook::compile_entries//
           1.1% in //Sequence::lint_inter//
-          0.7% in //ImperativeDefinitions::compile_first_block//
-          0.7% in //MajorNodes::pass_2//
           0.7% in //Sequence::undertake_queued_tasks//
           0.3% in //CompletionModule::compile//
+          0.3% in //ImperativeDefinitions::compile_first_block//
+          0.3% in //MajorNodes::pass_2//
           0.3% in //Sequence::undertake_queued_tasks//
           0.3% in //World::stage_V//
-          4.1% not specifically accounted for
-     27.8% in running Inter pipeline
-          9.3% in step 14/15: generate inform6 -> auto.inf
-          6.7% in step 5/15: load-binary-kits
-          6.0% in step 6/15: make-synoptic-module
+          5.1% not specifically accounted for
+     27.6% in running Inter pipeline
+          8.8% in step 14/15: generate inform6 -> auto.inf
+          7.0% in step 5/15: load-binary-kits
+          5.9% in step 6/15: make-synoptic-module
           1.8% in step 9/15: make-identifiers-unique
           0.3% in step 11/15: eliminate-redundant-labels
           0.3% in step 12/15: eliminate-redundant-operations
           0.3% in step 4/15: compile-splats
           0.3% in step 7/15: shorten-wiring
           0.3% in step 8/15: detect-indirect-calls
-          1.9% not specifically accounted for
-      3.7% in supervisor
-      1.2% not specifically accounted for
+          2.2% not specifically accounted for
+      3.6% in supervisor
+      0.8% not specifically accounted for

inform7/Internal/Inter/Architecture16Kit/kit_metadata.json

@@ -2,7 +2,7 @@
     "is": {
         "type": "kit",
         "title": "Architecture16Kit",
-        "version": "10.2.0-beta+6X28"
+        "version": "10.2.0-beta+6X29"
     },
     "compatibility": "16-bit",
     "kit-details": {

inform7/Internal/Inter/Architecture32Kit/kit_metadata.json

@@ -2,7 +2,7 @@
     "is": {
         "type": "kit",
         "title": "Architecture32Kit",
-        "version": "10.2.0-beta+6X28"
+        "version": "10.2.0-beta+6X29"
     },
     "compatibility": "32-bit",
     "kit-details": {

inform7/Internal/Inter/BasicInformKit/kit_metadata.json

@@ -2,7 +2,7 @@
     "is": {
         "type": "kit",
         "title": "BasicInformKit",
-        "version": "10.2.0-beta+6X28"
+        "version": "10.2.0-beta+6X29"
     },
     "needs": [ {
         "need": {

inform7/Internal/Inter/CommandParserKit/kit_metadata.json

@@ -2,7 +2,7 @@
     "is": {
         "type": "kit",
         "title": "CommandParserKit",
-        "version": "10.2.0-beta+6X28"
+        "version": "10.2.0-beta+6X29"
     },
     "needs": [ {
         "need": {

inform7/Internal/Inter/DialogueKit/Sections/Choices.i6t

@@ -45,6 +45,7 @@ All of this must of course match what is compiled in //runtime: Dialogue Choice
 Constant TYPE_DCMETADATA = 0;
 Constant AVAILABILITY_DCMETADATA = 1;
 Constant CONTENT_DCMETADATA = 2;
+Constant STATE_DCMETADATA = 3;
 
                                          ! Flow markers:
 Constant AGAIN_DSEL = 1;                 ! <-
@@ -62,6 +63,12 @@ Constant BEFORE_DSEL = 10;               ! -- before taking the pocket watch
 Constant INSTEAD_OF_DSEL = 11;           ! -- instead of taking something
 Constant AFTER_DSEL = 12;                ! -- after examining the rabbit hole
 Constant OTHERWISE_DSEL = 13;            ! -- otherwise
+Constant CHOOSE_RANDOMLY_DSEL = 14;      ! -- choose randomly
+Constant SHUFFLE_THROUGH_DSEL = 15;      ! -- shuffle through
+Constant CYCLE_THROUGH_DSEL = 16;        ! -- cycle through
+Constant STEP_THROUGH_DSEL = 17;         ! -- step through
+Constant STEP_THROUGH_AND_STOP_DSEL = 18; ! -- step through and stop
+Constant OR_DSEL = 19;                   ! -- or
 
 @h Extracting choice data.
 
@@ -88,6 +95,18 @@ Constant OTHERWISE_DSEL = 13;            ! -- otherwise
 	return chdata-->TYPE_DCMETADATA;
 ];
 
+[ DirectorReadChoiceState dc chdata;
+	if ((dc <= 0) || (dc > NO_DIALOGUE_CHOICES)) return 0;
+	chdata = TableOfDialogueChoices-->dc;
+	return chdata-->STATE_DCMETADATA;
+];
+
+[ DirectorWriteChoiceState dc val chdata;
+	if ((dc <= 0) || (dc > NO_DIALOGUE_CHOICES)) return;
+	chdata = TableOfDialogueChoices-->dc;
+	chdata-->STATE_DCMETADATA = val;
+];
+
 [ DirectorChoiceRawContent dc chdata;
 	if ((dc <= 0) || (dc > NO_DIALOGUE_CHOICES)) return 0;
 	chdata = TableOfDialogueChoices-->dc;

inform7/Internal/Inter/DialogueKit/Sections/Programs.i6t

@@ -58,6 +58,11 @@ Constant BLANK_DCODEDT = 1;
 Constant TEXTUAL_DCODEDT = 2;
 Constant PARSED_COMMAND_DCODEDT = 3;
 Constant FLOW_DCODEDT = 4;
+Constant RANDOMISED_CONTROL_DDT = 5;
+Constant SHUFFLE_CONTROL_DDT = 6;
+Constant CYCLE_CONTROL_DDT = 7;
+Constant STEP_CONTROL_DDT = 8;
+Constant STEP_STOP_CONTROL_DDT = 9;
 
 @h Containment.
 This enables us to implement the test for whether a given line or choice
@@ -149,6 +154,11 @@ Purely for debugging purposes:
 				TEXTUAL_DCODEDT: print "TEXTUAL";
 				PARSED_COMMAND_DCODEDT: print "PARSED";
 				FLOW_DCODEDT: print "FLOW";
+				RANDOMISED_CONTROL_DDT: print "RANDOMISED";
+				SHUFFLE_CONTROL_DDT: print "SHUFFLE";
+				CYCLE_CONTROL_DDT: print "CYCLE";
+				STEP_CONTROL_DDT: print "STEP";
+				STEP_STOP_CONTROL_DDT: print "STEP_STOP";
 				default: print "*** Unknown ***";
 			}
 		default: print "*** Unimplemented ***";
@@ -339,7 +349,7 @@ Note that this loop should never hit a |CHOICE_DCODEI| instruction, because
 those are always underneath |DECISION_DCODEI| instructions -- which it does hit.
 
 =
-[ DirectorRun program pc last_pc instruction operand depth next_instruction sc;
+[ DirectorRun program pc last_pc instruction operand operand_at depth next_instruction sc;
 	while (true) {
 		if (director_is_paused_for_command) return;
 
@@ -367,7 +377,8 @@ those are always underneath |DECISION_DCODEI| instructions -- which it does hit.
 		program = DirectorBeatGetProgram(DirectorStackBeat-->(director_sp-1));
 		instruction = (program-->pc)/100;
 		depth = (program-->pc)%100;
-		operand = program-->(pc+1);
+		operand_at = pc+1;
+		operand = program-->operand_at;
 
 		if (instruction == 0) { DirectorPop(); return; }
 		if (depth < DirectorStackMin-->(director_sp-1)) { DirectorPop(); return; }
@@ -394,7 +405,8 @@ those are always underneath |DECISION_DCODEI| instructions -- which it does hit.
 				DirectorExecuteLine(operand);
 			DECISION_DCODEI:
 				DirectorStackDecisionPC-->(director_sp-1) = last_pc;
-				DirectorExecuteDecision(operand);
+				program-->operand_at = (program-->operand_at)%100 + 
+					100*(DirectorExecuteDecision(operand%100, operand/100));
 			CHOICE_DCODEI:
 				print "*** Encountered CHOICE_DCODEI ***^";
 			default: "*** Bad D-code instruction ***";
@@ -431,14 +443,16 @@ and we silently return.
 
 We deal with |TEXTUAL_DCODEDT| and |FLOW_DCODEDT| decisions immediately, and
 empty the choices list as soon as we can. Perhaps surprisingly, we do nothing
-at all about a |PARSED_COMMAND_DCODEDT|. This function call nevertheless has
-an effect because it leaves the choices list on the stack, where it will cause
-the D-code interpreter to halt waiting for a command, to be re-entered later
-on when actions are processed.
+at all about a |PARSED_COMMAND_DCODEDT| except to signal a sort of exception.
+This function call nevertheless has an effect because it leaves the choices list
+on the stack, where it will cause the D-code interpreter to halt waiting for a
+command, to be re-entered later on when actions are processed.
+
+This function is passed a state value, and must return it (even if unchanged).
 
 =
-[ DirectorExecuteDecision decision dc count n spc list;
-	if (director_sp == 0) return;
+[ DirectorExecuteDecision decision state dc count n m spc list k;
+	if (director_sp == 0) return state;
 	list = DirectorStackChoices-->(director_sp-1);
 	DirectorListChoices(list);
 	count = LIST_OF_TY_GetLength(list);
@@ -449,7 +463,7 @@ on when actions are processed.
 			print "-- available options: "; LIST_OF_TY_Say(list); print "^";
 		}
 	}
-	if (count == 0) return;
+	if (count == 0) return state;
 
 	switch (decision) {
 		TEXTUAL_DCODEDT: 
@@ -458,7 +472,7 @@ on when actions are processed.
 			else {
 				BeginActivity(OFFERING_A_DIALOGUE_CHOICE, list);
 				if ((ForActivity(OFFERING_A_DIALOGUE_CHOICE, list)) &&
-					(RulebookFailed())) rfalse;
+					(RulebookFailed())) return state;
 				EndActivity(OFFERING_A_DIALOGUE_CHOICE, list);
 			}
 			DivideParagraphPoint();
@@ -478,9 +492,60 @@ on when actions are processed.
 			dc = LIST_OF_TY_GetItem(list, 1);
 			LIST_OF_TY_SetLength(list, 0);
 			DirectorFollowFlowMarker(dc);
+		RANDOMISED_CONTROL_DDT:
+			n = random(count);
+			dc = LIST_OF_TY_GetItem(list, n);
+			LIST_OF_TY_SetLength(list, 0);
+			DirectorExerciseChoice(dc);
+		SHUFFLE_CONTROL_DDT:
+			n = state;
+			if (n == 0) {
+				for (n=1: n<=count: n++)
+					DirectorWriteChoiceState(LIST_OF_TY_GetItem(list, n), 0);
+				n = count;
+			}
+			m = random(n);
+			n--; state = n;
+			for (n=1: n<=count: n++) {
+				dc = LIST_OF_TY_GetItem(list, n);
+				if (DirectorReadChoiceState(dc) == 0) {
+					m--;
+					if (m == 0) {
+						DirectorWriteChoiceState(dc, 1);
+						LIST_OF_TY_SetLength(list, 0);
+						DirectorExerciseChoice(dc);
+						return state;
+					}
+				}
+			}
+			LIST_OF_TY_SetLength(list, 0);
+		CYCLE_CONTROL_DDT:
+			n = state;
+			if (n < count) n++; else n = 1;
+			state = n;
+			dc = LIST_OF_TY_GetItem(list, n);
+			LIST_OF_TY_SetLength(list, 0);
+			DirectorExerciseChoice(dc);
+		STEP_CONTROL_DDT:
+			n = state;
+			if (n < count) {
+				n++; state = n;
+				dc = LIST_OF_TY_GetItem(list, n);
+				LIST_OF_TY_SetLength(list, 0);
+				DirectorExerciseChoice(dc);
+			} else {
+				LIST_OF_TY_SetLength(list, 0);
+			}
+		STEP_STOP_CONTROL_DDT:
+			n = state;
+			if (n < count) { n++; state = n; }
+			dc = LIST_OF_TY_GetItem(list, n);
+			LIST_OF_TY_SetLength(list, 0);
+			DirectorExerciseChoice(dc);
 		default:
-			"*** unimplemented dtd ***";
+			print "*** unimplemented dtd ", decision, " ***^";
 	}
+	return state;
 ];
 
 @h Listing choices for a decision.

inform7/Internal/Inter/EnglishLanguageKit/kit_metadata.json

@@ -2,7 +2,7 @@
     "is": {
         "type": "kit",
         "title": "EnglishLanguageKit",
-        "version": "10.2.0-beta+6X28"
+        "version": "10.2.0-beta+6X29"
     },
     "needs": [ {
         "need": {

inform7/Internal/Inter/WorldModelKit/kit_metadata.json

@@ -2,7 +2,7 @@
     "is": {
         "type": "kit",
         "title": "WorldModelKit",
-        "version": "10.2.0-beta+6X28"
+        "version": "10.2.0-beta+6X29"
     },
     "needs": [ {
         "need": {

inform7/Tests/Groups/dialogue.testgroup

@@ -41,5 +41,6 @@ DialogueBeats
 BeatRelevance
 DialogueParserException
 VariableSpeaker
+CyclingDialogue
 LBW
 TalkingAbout

inform7/Tests/Test Cases/CyclingDialogue--I.txt

@@ -0,0 +1,135 @@
+   Cocktail Bar
+  Welcome
+  An Interactive Fiction
+  Release 1 / Serial number 160428 / Inform 7 v10.2.0 / D
+  
+  Cocktail Bar
+  You can see a server, Loretta, a bartender, Patrick and Gareth here.
+  
+> >   Cocktail Bar
+  (Testing.)
+  
+  >[1] talk about negroni
+  The server: "One."
+  
+  >[2] g
+  The server: "Two."
+  
+  >[3] g
+  The server: "Three."
+  
+  >[4] g
+  There is no reply.
+  
+  >[5] g
+  There is no reply.
+  
+  >[6] g
+  There is no reply.
+  
+  >[7] g
+  There is no reply.
+  
+  >[8] talk about martini
+  The server: "One."
+  
+  >[9] g
+  The server: "Two."
+  
+  >[10] g
+  The server: "Three."
+  
+  >[11] g
+  The server: "Three."
+  
+  >[12] g
+  The server: "Three."
+  
+  >[13] g
+  The server: "Three."
+  
+  >[14] g
+  The server: "Three."
+  
+  >[15] talk about scotch
+  The server: "One."
+  
+  >[16] g
+  The server: "Two."
+  
+  >[17] g
+  The server: "Three."
+  
+  >[18] g
+  The server: "One."
+  
+  >[19] g
+  The server: "Two."
+  
+  >[20] g
+  The server: "Three."
+  
+  >[21] g
+  The server: "One."
+  
+  >[22] talk about mojito
+  The server: "Two."
+  
+  >[23] g
+  The server: "Three."
+  
+  >[24] g
+  The server: "One."
+  
+  >[25] g
+  The server: "Two."
+  
+  >[26] g
+  The server: "Three."
+  
+  >[27] g
+  The server: "One."
+  
+  >[28] g
+  The server: "Three."
+  
+  >[29] g
+  The server: "One."
+  
+  >[30] g
+  The server: "Two."
+  
+  >[31] g
+  The server: "One."
+  
+  >[32] talk about gimlet
+  The server: "Two."
+  
+  >[33] g
+  The server: "Three."
+  
+  >[34] g
+  The server: "Three."
+  
+  >[35] g
+  The server: "Two."
+  
+  >[36] g
+  The server: "Three."
+  
+  >[37] g
+  The server: "One."
+  
+  >[38] g
+  The server: "Two."
+  
+  >[39] g
+  The server: "Two."
+  
+  >[40] g
+  The server: "One."
+  
+  >[41] g
+  The server: "Two."
+  
+> >

inform7/Tests/Test Cases/CyclingDialogue.txt

@@ -0,0 +1,111 @@
+Test: CyclingDialogue
+For: Z-Machine
+
+The Cocktail Bar is a room. Cocktails are a concept. Party is a concept. The server and Loretta are women in the Cocktail Bar. The bartender, Patrick and Gareth are men in the Cocktail Bar. 
+
+A drink is a kind of thing. A drink can be full or empty. Loretta carries an empty drink called a mai tai. Patrick carries a full drink called the old-fashioned.
+
+A flavour is a kind of value. The flavours are mock, bitter, dry, semi-sweet, and sweet. A drink has a flavour. 
+
+The last-named drink is a drink that varies. The chosen guest is a person that varies. The chosen guest is Loretta.
+
+Test me with "talk about negroni / g / g / g / g / g / g / talk about martini / g / g / g / g / g / g / talk about scotch / g / g / g / g / g / g / talk about mojito / g / g / g / g / g / g / g / g / g / talk about gimlet / g / g / g / g / g / g / g / g / g".
+
+Some drinks are defined by the Table of Available Beverages.
+
+Table of Available Beverages
+drink	flavour
+a negroni	bitter
+a boulevardier	bitter
+a manhattan	semi-sweet
+a martini	dry
+a gimlet	semi-sweet
+a kamikaze	sweet
+a mojito	semi-sweet
+a cosmopolitan	sweet
+an appletini	sweet
+a whisky on the rocks	dry
+a Scotch	dry
+an aperol spritz	bitter
+a white russian	sweet
+a grasshopper	sweet
+a gin and tonic	semi-sweet	
+a last word	semi-sweet
+
+Understand "talk about [any drink]" as talking about.
+
+Carry out talking about a drink:
+	make the noun a live conversational subject.
+
+Section 1 - Bar talk (dialogue)
+
+(About a negroni. Recurring.)
+
+-- step through
+
+	Server (recurring): "One."
+
+-- or
+
+	Server (recurring): "Two."
+	
+-- or
+
+	Server (recurring): "Three."
+
+(About a martini. Recurring.)
+
+-- step through and stop
+
+	Server (recurring): "One."
+
+-- or
+
+	Server (recurring): "Two."
+	
+-- or
+
+	Server (recurring): "Three."
+
+(About a scotch. Recurring.)
+
+-- cycle through
+
+	Server (recurring): "One."
+
+-- or
+
+	Server (recurring): "Two."
+	
+-- or
+
+	Server (recurring): "Three."
+
+(About a mojito. Recurring.)
+
+-- shuffle through
+
+	Server (recurring): "One."
+
+-- or
+
+	Server (recurring): "Two."
+	
+-- or
+
+	Server (recurring): "Three."
+
+(About a gimlet. Recurring.)
+
+-- choose randomly
+
+	Server (recurring): "One."
+
+-- or
+
+	Server (recurring): "Two."
+	
+-- or
+
+	Server (recurring): "Three."
+

inform7/extensions/standard_rules/Sections/Actions.w

@@ -3236,10 +3236,12 @@ Carry out an actor talking about an object (called T)
 	(this is the first-declared beat rule):
 	if the leading beats is not empty:
 		perform entry 1 of the leading beats;
-		continue the action;
+		if the dialogue line performance count is greater than zero:
+			continue the action;
 	if the other beats is not empty:
 		perform entry 1 of the other beats;
-		continue the action;
+		if the dialogue line performance count is greater than zero:
+			continue the action;
 	if the player is the actor:
 		say "There is no reply." (A);
 		stop the action;

inform7/extensions/standard_rules/Sections/Variables and Rulebooks.w

@@ -1316,6 +1316,9 @@ To decide what performance style is the current dialogue line style:
 To decide what number is the chosen dialogue number up to (N - number):
 	(- DirectorPickANumber({N}) -).
 
+To decide what number is the dialogue line performance count:
+	(- line_performance_count -).
+
 To perform (B - a dialogue beat):
 	(- DirectorPerformBeat({B}); -).
 

inform7/if-module/Chapter 6/Dialogue Choices.w

@@ -211,6 +211,12 @@ void DialogueChoices::write_dcc(OUTPUT_STREAM, int c) {
 @e INSTEAD_OF_DSEL                  /* -- instead of taking something */
 @e AFTER_DSEL                       /* -- after examining the rabbit hole */
 @e OTHERWISE_DSEL                   /* -- otherwise */
+@e CHOOSE_RANDOMLY_DSEL             /* -- choose randomly */
+@e SHUFFLE_THROUGH_DSEL             /* -- shuffle through */
+@e CYCLE_THROUGH_DSEL               /* -- cycle through */
+@e STEP_THROUGH_DSEL                /* -- step through */
+@e STEP_THROUGH_AND_STOP_DSEL       /* -- step through and stop */
+@e OR_DSEL                          /* -- or */
 
 =
 <dialogue-selection> ::=
@@ -227,7 +233,13 @@ void DialogueChoices::write_dcc(OUTPUT_STREAM, int c) {
 	after ... |                                       ==> { AFTER_DSEL, - }
 	before ... |                                      ==> { BEFORE_DSEL, - }
 	perform <definite-article> ... |                  ==> { PERFORM_DSEL, - }
-	perform ...                                       ==> { PERFORM_DSEL, - }
+	perform ... |                                     ==> { PERFORM_DSEL, - }
+	choose randomly |                                 ==> { CHOOSE_RANDOMLY_DSEL, - }
+	shuffle through |                                 ==> { SHUFFLE_THROUGH_DSEL, - }
+	cycle through |                                   ==> { CYCLE_THROUGH_DSEL, - }
+	step through |                                    ==> { STEP_THROUGH_DSEL, - }
+	step through and stop |                           ==> { STEP_THROUGH_AND_STOP_DSEL, - }
+	or                                                ==> { OR_DSEL, - }
 
 @ Each choice produces an instance of the kind |dialogue choice|, using the name
 given in its clauses if one was.
@@ -258,6 +270,19 @@ void DialogueChoices::decide_choice_performs(void) {
 	dialogue_choice *dc;
 	LOOP_OVER(dc, dialogue_choice) {
 		current_sentence = dc->choice_at;
+		if ((dc->selection_type == CHOOSE_RANDOMLY_DSEL) ||
+		    (dc->selection_type == SHUFFLE_THROUGH_DSEL) ||
+		    (dc->selection_type == CYCLE_THROUGH_DSEL) ||
+		    (dc->selection_type == STEP_THROUGH_DSEL) ||
+		    (dc->selection_type == STEP_THROUGH_AND_STOP_DSEL) ||
+		    (dc->selection_type == OR_DSEL)) {
+			pcalc_prop *prop = AdjectivalPredicates::new_atom_on_x(
+				EitherOrProperties::as_adjective(P_recurring), FALSE);
+			prop = Propositions::concatenate(
+				Propositions::Abstract::prop_to_set_kind(K_dialogue_choice), prop);
+			inference_subject *subj = Instances::as_subject(dc->as_instance);
+			Assert::true_about(prop, subj, CERTAIN_CE);
+		}
 		for (parse_node *clause = dc->choice_at->down; clause; clause = clause->next) {
 			if (Node::is(clause, DIALOGUE_CLAUSE_NT)) {
 				wording CW = Node::get_text(clause);

inform7/if-module/Chapter 6/Dialogue Nodes.w

@@ -122,6 +122,11 @@ impossible to hit.
 @e TEXTUAL_DDT
 @e PARSED_COMMAND_DDT
 @e FLOW_CONTROL_DDT
+@e RANDOMISED_CONTROL_DDT
+@e SHUFFLE_CONTROL_DDT
+@e CYCLE_CONTROL_DDT
+@e STEP_CONTROL_DDT
+@e STEP_STOP_CONTROL_DDT
 
 =
 typedef struct dialogue_decision {
@@ -196,51 +201,78 @@ void DialogueNodes::examine_decisions_in_beat_r(dialogue_beat *db, dialogue_node
 	for (dialogue_node *c = dn, *prev = NULL; c; prev = c, c = c->next_node) {
 		if (c->if_decision) {
 			int t = -1;
-			dialogue_node *bad_otherwise = NULL, *mixed_choices = NULL;
-			for (dialogue_node *d = c->child_node; d; d = d->next_node) {
-				if (d->if_choice->selection_type == OTHERWISE_DSEL) {
-					if (t != PARSED_COMMAND_DDT) bad_otherwise = d;
-					if (d->next_node) bad_otherwise = d;
-				} else {
-					int ddt = DialogueNodes::decision_type(d);
-					if (t == -1) t = ddt;
-					else if (t != ddt) mixed_choices = d;
-				}
-			}
-			if (bad_otherwise) {
-				current_sentence = bad_otherwise->if_choice->choice_at;
-				StandardProblems::sentence_problem(Task::syntax_tree(),
-					_p_(PM_ChoiceOtherwiseUnexpected),
-					"this run of choices uses 'otherwise' unexpectedly",
-					"since 'otherwise' can only be used as the last option, and "
-					"only where the options are written in terms of actions.");
-			}
-			if (mixed_choices) {
-				current_sentence = mixed_choices->if_choice->choice_at;
-				StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_ChoicesMixed),
-					"this run of choices mixes up the possible sorts of choice",
-					"and should either all be action-dependent choices (perhaps "
-					"finishing with an 'otherwise'), or else all textual choices.");
-			}
-			if ((c->child_node) && (c->child_node->if_choice->selection_type == ANOTHER_CHOICE_DSEL)) {
-				if ((prev == NULL) || (prev->if_line) ||
-					(c->next_node == NULL) || (c->next_node->if_line)) {
-					current_sentence = c->child_node->if_choice->choice_at;
-					StandardProblems::sentence_problem(Task::syntax_tree(),
-						_p_(PM_ChoiceBlankRedundant),
-						"this use of '-> another choice' looks redundant",
-						"occurring at the start or end of a set of options. "
-						"'-> another choice' should be used only where there's "
-						"a need to mark a division point between two sets "
-						"of options running on from one to the other.");
-				}
-			}
-			c->if_decision->decision_type = t;
+			if (c->child_node) t = DialogueNodes::decision_type(c->child_node);
+			if ((t == RANDOMISED_CONTROL_DDT) ||
+				(t == SHUFFLE_CONTROL_DDT) ||
+				(t == CYCLE_CONTROL_DDT) ||
+				(t == STEP_CONTROL_DDT) ||
+				(t == STEP_STOP_CONTROL_DDT))
+				@<Apply the rules for an or-list@>
+			else
+				@<Apply the mixture rules@>;
 		}
 		DialogueNodes::examine_decisions_in_beat_r(db, c->child_node, c);
 	}
 }
 
+@<Apply the rules for an or-list@> =
+	for (dialogue_node *d = c->child_node->next_node; d; d = d->next_node)
+		if (d->if_choice->selection_type != OR_DSEL) {
+			current_sentence = d->if_choice->choice_at;
+			StandardProblems::sentence_problem(Task::syntax_tree(),
+				_p_(...),
+				"this is a run of choices where all choices other than the"
+				"first must be just '-- or'",
+				"since it is a list of alternatives.");
+		}
+	c->if_decision->decision_type = t;
+
+@<Apply the mixture rules@> =
+	int t = -1;
+	dialogue_node *bad_otherwise = NULL, *mixed_choices = NULL;
+	for (dialogue_node *d = c->child_node; d; d = d->next_node) {
+		if (d->if_choice->selection_type == OTHERWISE_DSEL) {
+			if (t != PARSED_COMMAND_DDT) bad_otherwise = d;
+			if (d->next_node) bad_otherwise = d;
+		} else {
+			int ddt = DialogueNodes::decision_type(d);
+			if (t == -1) t = ddt;
+			else if (t != ddt) mixed_choices = d;
+		}
+	}
+	if (bad_otherwise) {
+		current_sentence = bad_otherwise->if_choice->choice_at;
+		StandardProblems::sentence_problem(Task::syntax_tree(),
+			_p_(PM_ChoiceOtherwiseUnexpected),
+			"this run of choices uses 'otherwise' unexpectedly",
+			"since 'otherwise' can only be used as the last option, and "
+			"only where the options are written in terms of actions.");
+	}
+	if (mixed_choices) {
+		current_sentence = mixed_choices->if_choice->choice_at;
+		StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_ChoicesMixed),
+			"this run of choices mixes up the possible sorts of choice",
+			"and should either all be action-dependent choices (perhaps "
+			"finishing with an 'otherwise'), or else all textual choices.");
+	}
+	if ((c->child_node) && (c->child_node->if_choice->selection_type == ANOTHER_CHOICE_DSEL)) {
+		if ((prev == NULL) || (prev->if_line) ||
+			(c->next_node == NULL) || (c->next_node->if_line)) {
+			current_sentence = c->child_node->if_choice->choice_at;
+			StandardProblems::sentence_problem(Task::syntax_tree(),
+				_p_(PM_ChoiceBlankRedundant),
+				"this use of '-> another choice' looks redundant",
+				"occurring at the start or end of a set of options. "
+				"'-> another choice' should be used only where there's "
+				"a need to mark a division point between two sets "
+				"of options running on from one to the other.");
+		}
+	}
+	c->if_decision->decision_type = t;
+
+@
+
+=
 void DialogueNodes::log_node_tree(dialogue_node *dn) {
 	for (; dn; dn=dn->next_node) {
 		DialogueNodes::log_node(dn); LOG("\n");
@@ -275,6 +307,12 @@ int DialogueNodes::decision_type(dialogue_node *dn) {
 		case AFTER_DSEL: return PARSED_COMMAND_DDT;
 		case BEFORE_DSEL: return PARSED_COMMAND_DDT;
 		case PERFORM_DSEL: return FLOW_CONTROL_DDT;
+		case CHOOSE_RANDOMLY_DSEL: return RANDOMISED_CONTROL_DDT;
+		case SHUFFLE_THROUGH_DSEL: return SHUFFLE_CONTROL_DDT;
+		case CYCLE_THROUGH_DSEL: return CYCLE_CONTROL_DDT;
+		case STEP_THROUGH_DSEL: return STEP_CONTROL_DDT;
+		case STEP_THROUGH_AND_STOP_DSEL: return STEP_STOP_CONTROL_DDT;
+		case OR_DSEL: return RANDOMISED_CONTROL_DDT;
 		default: internal_error("unimplemented DSEL");
 	}
 	return -1;

inform7/runtime-module/Chapter 5/Dialogue Choice Instances.w

@@ -76,6 +76,7 @@ void RTDialogueChoices::choice_compilation_agent(compilation_subtask *ct) {
 	@<Write the type entry@>;
 	@<Write the availability entry@>;
 	@<Write the details entry@>;
+	@<Write the state word@>;
 	EmitArrays::end(save);
 
 	if (make_availability_function) @<Compile the available function@>;
@@ -149,6 +150,9 @@ void RTDialogueChoices::choice_compilation_agent(compilation_subtask *ct) {
 			break;
 	}
 
+@<Write the state word@> =
+	EmitArrays::numeric_entry(0);
+
 @<Compile the available function@> =
 	packaging_state save = Functions::begin(RTDialogueChoices::available_fn_iname(dc));
 	@<Check the if and unless conditions@>;

services/lexicon-module/Figures/excerpts-diagnostics.txt

@@ -1,5 +1,5 @@
 Size of lexicon: 3165 excerpt meanings
-  Stored among 855 words out of total vocabulary of 10638
+  Stored among 855 words out of total vocabulary of 10642
   719 words have a start list: longest belongs to report (with 293 meanings)
   21 words have an end list: longest belongs to digits (with 7 meanings)
   29 words have a middle list: longest belongs to to (with 4 meanings)