Warning: Following treatise contains the word ‘disambiguation’ disgusting times.
In Dialog's disambiguation the following scenario always bothered me.
> take fish
Did you want to take the fish or the red fish?
>
Did you want to take the fish or the red fish?
>
Did you want to take the fish or the red fish?
>
Did you want to take the fish or the red fish?
>
Did you want to take the fish or the red fish?
>
Did you want to take the fish or the red fish?
>
Did you want to take the fish or the red fish?
>
Did you want to take the fish or the red fish?
>
Did you want to take the fish or the red fish?
>
Did you want to take
(Technical trouble: Heap space exhausted. Attempting to recover with UNDO.)
Undoing the last turn (take fish).
If the player answers a single sentence disambiguation question in such a way that the disambiguation goes for another round, after several times heap space gets exhausted. It depends on the length of the candidate action list how fast the heap will get busted (nine rounds above are from an actual scenario, not imaginary). The really bothering part is that empty input (like in the example given above) always prompts for another round. This is due to (words [] sufficiently specify $Obj) always succeeding in conjunction with how (determine object $) statements matches successfully with an empty word list for matching.
While I was working on another tweak with the disambiguation mechanism, I have accidentally circumvented this issue. What I wanted was turning this:
> take pot
Did you want to take the plant pot or the pot plant?
> pot
Did you want to take the plant pot or the pot plant?
into this:
> take pot
Did you want to take the plant pot or the pot plant?
> pot
Did you want to:
1. take the plant pot, or
2. take the pot plant?
(Type the corresponding number)
Basically, I wanted the disambiguation mechanish branch into enumerated disambiguation instead of single sentence one if the player’s input failed to reduce the candidate list, to help with scenarios where one of the objects can’t be distinguished by any words over the other one. N.B. The ‘plant pot’ vs ‘pot plant’ issue can be solved by (heads $) quite easily and conveniently, but the ‘fish’ vs ‘red fish’ can’t be solved without declaring ‘red’ as head, thereby angering language purists.
Since the empty input matches all of the candidates, this behaviour also works for just pressing the enter without any text.
> take pot
Did you want to take the plant pot or the pot plant?
>
Did you want to:
1. take the plant pot, or
2. take the pot plant?
(Type the corresponding number)
While I was happy with the resulting change, I have noticed that the enumerated disambiguation doesn’t recurse like the single sentence one. If the player enters a text that is not a number on the list (inluding an empty string), this type of disambiguation question just fails and gives up. No recursion → no heap space issues. And that’s two dodos for the same stone.
The following code with an example scenario are presented as library overrides (5 of them) with comments used as diff to original library (can't use colors in the preformatted text).
%% Library overrides
%%+
%% Modified for new signature of (disambiguate action ...) rule
(consider action candidates $List $Words)
%%+
(just)
(if) ($List = [$Single]) (then)
%% Optimize the common case.
(try-complex $Single)
(else)
%% Eliminate options where the head noun is missing.
(now) (head noun is required)
(collect $A)
*(understand $Words as $A)
($A is one of $List)
(into $ShortListWithDup)
(remove duplicates $ShortListWithDup $ShortList)
(if) ($ShortList = [$Single]) (then)
(try-complex $Single)
(else)
(if) (empty $ShortList) (then)
%%+
(disambiguate action $List $ComplexAction 0)
%%- (disambiguate action $List $ComplexAction)
(else)
%%+
(disambiguate action $ShortList $ComplexAction 0)
%%- (disambiguate action $ShortList $ComplexAction)
(endif)
(try-complex $ComplexAction)
(endif)
(endif)
%%+++
%% Now proceeds to enumerated disambiguation if the candidate list
%% remains the same after a disambiguation round
(disambiguate action $List $Result $PrevNumObjects)
%%-(disambiguate action $List $Result)
(collect $Action)
*($Action is one of $List)
~{
*($Action recursively contains $Obj)
($Obj is hidden)
}
(into $NonSpoilery)
(if) (empty $NonSpoilery) (then)
($AskList = $List)
(else)
($AskList = $NonSpoilery)
(endif)
(if) ($AskList = [$Single]) (then)
($Result = $Single)
(elseif)
(rephrase as object disambiguation
$AskList
$ComplexAction
$Template
$ObjList)
%%++
%% Branch to enumeration if the object list remains same
~(length of $ObjList into $PrevNumObjects)
(then)
Did you want to (describe action $ComplexAction)?
(par)
(prompt and input $Words)
{
(now) (head noun is required)
(disambiguate by object name $Words $Template $ObjList $Result)
(or)
(now) ~(head noun is required)
(disambiguate by object name $Words $Template $ObjList $Result)
(or)
(now) (deferred commandline $Words)
(stop)
}
(else)
Did you want to: (line)
(enumerate actions $AskList 1 $)
(if) ~{ (library links enabled) (interpreter supports links) } (then)
\( Type the corresponding number \)
(endif)
(par)
(prompt and input $Words)
{
(understand $Words as number $N)
($N > 0)
(nth $AskList $N $Result)
(or)
(now) (deferred commandline $Words)
(stop)
}
(endif)
%%+
%% This one is not modified, here for proper fallback sequence
(disambiguate by object name [me/myself] $Template $ObjList $Result)
(current player $Player)
($Player is one of $ObjList)
(recover implicit action $Template $Player into $Result)
(disambiguate by object name $Words $Template $ObjList $Result)
%% Since the player was given an explicit list of '(the full $)'
%% descriptions, we have to match against those, in addition to the
%% normal dict rules.
(collect $A)
(determine object $Obj)
*($Obj is one of $ObjList)
~(direction $Obj)
~(relation $Obj)
(words $Words sufficiently specify $Obj)
(from words)
(the full $Obj)
(matching all of $Words)
(recover implicit action $Template $Obj into $A)
(into $Candidates)
(nonempty $Candidates) %% otherwise fail into the next rule
{
($Candidates = [$Result])
(or)
%%+++
%% Supporting branch to enumeration if the object list remains same
(length of $ObjList into $NumObjects)
(disambiguate action $Candidates $Result $NumObjects)
%%- (disambiguate action $Candidates $Result)
}
(disambiguate by object name $Words $Template $ObjList $Result)
%%+
(just)
(collect $A)
(determine object $Obj)
*($Obj is one of $ObjList)
~(direction $Obj)
~(relation $Obj)
(words $Words sufficiently specify $Obj)
(from words)
*(dict $Obj)
(matching all of $Words)
(recover implicit action $Template $Obj into $A)
(into $Candidates)
(nonempty $Candidates)
{
($Candidates = [$Result])
(or)
%%+++
%% Supporting branch to enumeration if the object list remains same
(length of $ObjList into $NumObjects)
(disambiguate action $Candidates $Result $NumObjects)
%%- (disambiguate action $Candidates $Result)
}
%% Example scenario
#player
(current player *)
(* is #in #office)
#office
(name *) the office
(room *)
(look *) It's an office.
#fish
(name *) fish
(item *)
#redfish
(name *) red fish
(item *)
(#fish/#redfish is #in #office)
((item $) is handled)