To give an example of a solution(-ish) to the I-to-T action remapping thing:
First, modify Action to implement a createForRetry() workalike. We can’t use createForRetry() itself because we’re actually swapping underlying Action instances/classes, instead of cloning one action as a template for the replacement:
modify Action
// Analog for createForRetry(), only instead of just copying the
// original action (first arg) we copy things from the original
// action to an instance of the given action class (second arg).
createForReplace(orig, cls) {
local action;
action = cls.createActionInstance();
action.tokenList = orig.tokenList;
action.firstTokenIndex = orig.firstTokenIndex;
action.lastTokenIndex = orig.lastTokenIndex;
action.includeInUndo = nil;
action.setNested();
action.implicitMsg = nil;
return(action);
}
;
Then we create a global function kinda like _replaceAction():
// Args are the issuing actor (probably gIssuingActor), the actor taking
// the action (probably gActor), and the class for the new action.
_remapToTAction(srcActor, dstActor, cls) {
local action, matchList, str, toks;
// Use our new Action method to create the replacement action.
action = gAction.createForReplace(gAction, cls);
// Display the "What do you want to [action]?" prompt.
dstActor.getParserMessageObj().askMissingObject(dstActor, action,
DirectObject);
// Read input.
str = readMainCommandTokens(rmcAskObject);
if(gTranscript)
gTranscript.activate();
// Got an empty-ish input, bail.
if(str == nil)
throw new ReplacementCommandStringException(nil, nil, nil);
toks = str[2]; // The input tokens.
str = str[1]; // The input string.
// See if the input looks like a noun phrase.
matchList = nounList.parseTokens(toks, cmdDict);
// Nope, treat it like a new command.
if(!matchList.length)
throw new ReplacementCommandStringException(str, nil, nil);
// The input looks like a noun phrase, so we'll try tacking it onto
// the end of the original command and re-executing. The heavy
// wizarding in this line is just the ritual for summoning the
// original command text (by getting the original token list,
// converting it back into text form, adding the input string
// obtained above, then re-tokenizing the resulting string).
executeCommand(dstActor, srcActor, Tokenizer.tokenize(
cmdTokenizer.buildOrigText(gAction.getPredicate()
.getOrigTokenList()) + ' ' + str), true);
// To avoid having this action double counted (advancing the
// turn counter and so on for both the original command and the
// command executed above) we replace the original command with
// a zero-length action.
replaceAction(_Blank);
}
This uses a NOP Action that we also have to define:
DefineIAction(_Blank) actionTime = 0 execAction() {};
And then we add a macro that works like replaceAction:
#define remapToTAction(cls) (_remapToTAction(gIssuingActor, gActor, cls##Action))
Then if we have a transitive/intransitive action pair we can handle the remapping in the IAction’s execAction() via:
DefineTAction(Shuffle);
VerbRule(Shuffle)
'shuffle' singleDobj
: ShuffleAction
verbPhrase = 'shuffle/shuffling (what)'
;
DefineIAction(ShuffleI);
VerbRule(ShuffleI)
'shuffle'
: ShuffleIAction
verbPhrase = 'shuffle/shuffling'
execAction() {
remapToTAction(Shuffle);
}
;
In practice I want additional logic in ShuffleIAction.execAction(), but the fallback of mapping to ShuffleAction would work exactly the same way.