// handleWord.js
(function () {
/*global adventurejs A*/
var p = adventurejs.Parser.prototype;
/**
* Handle single-word input.
* @memberOf adventurejs.Parser
* @method adventurejs.Parser#handleWord
*/
p.handleWord = function Parser_handleWord() {
this.game.log(
"L1211",
"log",
"high",
"handleWord.js > Begin parse.",
"Parser"
);
var this_turn = this.input_history[0];
var one_word = this_turn.found_word;
var parsed_noun, verb_name;
var last_turn = this.input_history[1];
var number = Number(one_word);
var msg = "";
var found_match = false;
if (last_turn.soft_prompt.noun) parsed_noun = this.parseNoun(one_word);
/* *
* Did the last turn prompt for a preposition?
* See if this turn's input satisfies that.
* This ran after the verb check until 3/8/23
* when I noticed an example that needed this
* to run before the verb check.
* Example: "put pen table" where? "in"
* "in" gets parsed as direction verb but should be preposition
* @TODO keep an eye on this in case it results in verbs failing to parse
*/
for (let i = 1; i <= 3; i++) {
if (
last_turn.soft_prompt["preposition" + i] &&
this.game.dictionary.isPreposition(one_word)
) {
// was sentence structure explicitly set with soft prompt? use that. otherwise use last turn's structure
this_turn.verified_sentence_structure =
last_turn.soft_prompt.structure ||
last_turn.verified_sentence_structure;
this_turn.input_verb =
last_turn.soft_prompt.input_verb || last_turn.input_verb;
this_turn.verb_phrase =
last_turn.soft_prompt.verb_phrase || last_turn.verb_phrase;
this_turn.soft_prompt.satisfied = true;
this_turn.setOneWord({ ["preposition" + i]: one_word });
this.game.log(
"L1212",
"log",
"high",
`handleWord.js > last turn soft prompted for preposition${i} and ${one_word} recognized as preposition`,
"Parser"
);
return this.handleSentence();
}
} // preposition
/**
* is it a verb that is also a noun that satisfies
* a travel verb like "go" as in "go east"?
*/
verb_name = this.parseVerb(one_word);
this.game.log(
"L1213",
"log",
"high",
`handleWord.js > ${verb_name} `,
"Parser"
);
if (
verb_name &&
last_turn.soft_prompt.noun1 &&
this.game.dictionary.verbs[verb_name].type.direction
) {
this.game.log(
"L1214",
"log",
"high",
`handleWord.js > soft_prompt received ${one_word} which is direction+noun and satisfies ${last_turn.input_verb}`,
"Parser"
);
this_turn.setOneWord({ noun1: verb_name });
this_turn.input_verb =
last_turn.soft_prompt.input_verb || last_turn.input_verb;
this_turn.verb_phrase =
last_turn.soft_prompt.verb_phrase || last_turn.verb_phrase;
if (last_turn.soft_prompt.verb) {
this_turn.setOneWord({ verb: last_turn.soft_prompt.verb });
// this_turn.input_verb =
// this.game.dictionary.verbs[last_turn.soft_prompt.verb].prettyname;
// this_turn.verb_phrase = last_turn.verb_phrase;
}
this.game.log(
"L1215",
"log",
"high",
`handleWord.js > handle soft prompt for noun1`,
"Parser"
);
// was sentence structure explicitly set with soft prompt? use that.
// otherwise use last turn's structure
this_turn.verified_sentence_structure =
last_turn.soft_prompt.structure ||
last_turn.verified_sentence_structure;
this_turn.soft_prompt.satisfied = true;
return this.handleSentence();
}
/**
* Is it a verb?
* Check our one word input against dictionary verbs.
* parseVerb returns either the base form of the verb,
* or false if no matching verb.
* (Unless last turn was a soft prompt,
* which is almost always looking for a noun. )
*/
if (verb_name && !(parsed_noun && parsed_noun.matches.all.length)) {
//let verb = this.dictionary.verbs[verb_name];
let verb = this.qualifyParsedVerb({
parsed_verb_name: verb_name,
});
if (!verb) return false;
if (-1 === verb.accepts_structures.indexOf("verb")) {
this.game.debug(
`D1052 | handleWord.js | ${verb_name} doesn't accept structure > verb `
);
msg += `${verb.type.travel ? "Where" : "What"} did $(we) want to ${
verb.prettyname
}? `;
msg = msg || verb.msgNoObject;
this_turn.setSoftPrompt({
index: 1,
type: "noun",
verb: verb.name,
noun1: true,
structure: "verb noun",
});
this.game.print(msg, this_turn.output_class);
return false;
}
this_turn.setVerb(1, verb_name);
this_turn.setStructure("verb");
this.game.log(
"L1216",
"log",
"high",
`handleWord.js > ${verb_name} recognized as verb`,
"Parser"
);
this.game.dictionary.doVerb(verb_name);
return true;
} // verb_name
// Is it a number?
// One way or another, let's find a noun.
if (Number.isInteger(number) && last_turn.disambiguate.index) {
// add "integer" class to input line
this.game.display.appendClassesToLastInput("integer");
one_word = last_turn.getParsedNoun(last_turn.disambiguate.index).matches
.qualified[number - 1];
// this can be asset:aspect:substance
// if so we want to get the asset and this is an ID
// so we should be able to get the asset
// without doing another lookup
// getAsset returns the container not the substance
// @TODO We don't have any other context for numbers
// though we might in future handle something like:
// "Which key did you want to press? > 1"
if (!one_word) {
this.game.debug(
`D1555 | handleWord.js | ${number} is not a valid choice`
);
msg += number + " doesn't seem to make sense. ";
if (msg) this.game.print(msg, this_turn.output_class);
return false;
}
found_match = one_word;
parsed_noun = new adventurejs.ParsedNoun(this.game.getAsset(one_word));
} else {
parsed_noun = this.parseNoun(one_word);
}
//No matching key found in world_lookup
//so we can't do anything with it.
if (!parsed_noun.matches.all.length) {
this.game.log(
"L1217",
"log",
"high",
`handleWord.js > no matching key found in world_lookup `,
"Parser"
);
msg += this.getUnparsedMessage(one_word);
this.game.print(msg, this_turn.output_class);
return false;
}
/**
* Did the last turn prompt for noun disambiguation?
* See if this turn's input satisfies that.
*/
if (last_turn.disambiguate.enabled) {
this.game.log(
"L1218",
"log",
"high",
`handleWord.js > handle noun disambiguation`,
"Parser"
);
if (!found_match) {
found_match = this.findMatchIn(
parsed_noun.matches.qualified,
last_turn["parsedNoun" + last_turn.disambiguate.index].matches
.qualified
);
}
if (found_match) {
this_turn.verified_sentence_structure =
last_turn.verified_sentence_structure;
// what other properties should carry through?
this_turn.strings = last_turn.strings;
// @TODO revise this for mo'bettah substance handling
// that uses asset:aspect:substance
let type = last_turn.disambiguate.container ? "container" : "noun";
// set this turn's noun and parsed_noun to what we just found
this_turn.setOneWord({
[type + last_turn.disambiguate.index]: found_match,
[`parsedNoun${last_turn.disambiguate.index}`]: parsed_noun,
});
this_turn.input_verb = last_turn.input_verb;
this_turn.verb_phrase = last_turn.verb_phrase;
this.game.log(
"L1219",
"log",
"high",
`handleWord.js > disambiguate found_match ${found_match} `,
"Parser"
);
return this.handleSentence();
} else {
// last turn called for disambiguation but no match was found
this.game.debug(`D1556 | handleWord.js | disambiguation failed`);
msg += `${number} doesn't seem to make sense. `;
if (msg) this.game.print(msg, this_turn.output_class);
return false;
}
}
/**
* Did the last turn soft prompt for anything?
* See if this turn's input satisfies that.
*/
if (last_turn.soft_prompt.enabled) {
this.game.log(
"L1220",
"log",
"high",
`handleWord.js > soft_prompt received ${one_word}`,
"Parser"
);
let p = last_turn.soft_prompt;
let found = p.noun1
? "noun1"
: p.noun2
? "noun2"
: p.noun3
? "noun3"
: p.container1
? "container1"
: p.container2
? "container2"
: p.container3
? "container3"
: p.preposition1
? "preposition1"
: p.preposition2
? "preposition2"
: p.preposition3
? "preposition3"
: false;
if (found) this_turn.setOneWord({ [found]: one_word });
this_turn.input_verb =
last_turn.soft_prompt.input_verb || last_turn.input_verb;
this_turn.verb_phrase =
last_turn.soft_prompt.verb_phrase || last_turn.verb_phrase;
if (last_turn.soft_prompt.verb) {
this_turn.setOneWord({ verb: last_turn.soft_prompt.verb });
// this_turn.input_verb =
// this.game.dictionary.verbs[last_turn.soft_prompt.verb].prettyname;
// this_turn.verb_phrase = last_turn.verb_phrase;
}
this.game.log(
"L1221",
"log",
"high",
"handleWord.js > handle soft prompt for " + found,
"Parser"
);
// was sentence structure explicitly set with soft prompt? use that.
// otherwise use last turn's structure
this_turn.verified_sentence_structure =
last_turn.soft_prompt.structure ||
last_turn.verified_sentence_structure;
this_turn.soft_prompt.satisfied = true;
return this.handleSentence();
}
/**
* Did we receive a string that hasn't satisfied any prompts?
*/
if (parsed_noun.object_id === "global_string") {
this.game.log(
"L1222",
"log",
"high",
`handleWord.js > received string`,
"Parser"
);
msg += this_turn.strings.toString() + "...?";
this.game.print(msg, this_turn.output_class);
return;
}
/**
* Is settings.if_input_is_an_asset_name_examine_it true?
*
* If so, naming a noun with no verb is
* treated as if player had said "examine x"
*/
if (this.game.settings.if_input_is_an_asset_name_examine_it) {
this.game.log(
"L1223",
"log",
"high",
"handleWord.js > if_input_is_an_asset_name_examine_it",
"Parser"
);
parsed_noun = this.qualifyParsedNoun({
parsedNoun: parsed_noun,
parsedVerb: "examine",
nounIndex: "1",
});
if (false === parsed_noun) {
// if qualifyParsedNoun returned false, it also
// printed an error message, so we can just...
return false;
} else {
// unambiguous object, print default description
if (1 === parsed_noun.matches.qualified.length) {
this_turn.setParsedNoun(1, parsed_noun);
this.game.dictionary.doVerb("examine");
return;
}
}
} // if( this.game.settings.if_input_is_an_asset_name_examine_it )
// default
msg += this.getUnparsedMessage(one_word);
this.game.print(msg, this_turn.output_class);
return false;
};
})();