// parseSentence.js
(function () {
/*global adventurejs A*/
var p = adventurejs.Parser.prototype;
/**
* Parse each word in a sentence.
* @memberOf adventurejs.Parser
* @method adventurejs.Parser#parseSentence
*/
p.parseSentence = function Parser_parseSentence() {
var this_turn = this.input_history[0];
this.game.log(
"L1265",
"log",
"high",
"parseSentence.js > " + this_turn.parsed_input_array,
"Parser"
);
let last_word_type;
let last_word;
let firstverb;
let count = {
noun: 0,
prep: 0,
verb: 0,
adverb: 0,
adjective: 0,
direction: 0,
exclusion: 0,
unknown: 0,
string: 0,
phrase: 0,
};
for (
let position = 0;
position < this_turn.parsed_input_array.length;
position++
) {
let word = this_turn.parsed_input_array[position];
let verb = this.parseVerb(word);
let adverb = this.game.dictionary.getAdverb(word);
let direction = this.game.dictionary.getDirection(word);
let compass_direction =
direction && this.game.dictionary.verbs[direction].is_compass_direction;
let relative_direction =
direction &&
this.game.dictionary.verbs[direction].is_relative_direction;
let parsed_direction = direction && this.parseNoun(direction);
let preposition = this.game.dictionary.getPreposition(word);
let string = word === "global_string" ? word : false;
let noun =
"undefined" !== typeof this.game.world[word] ||
this.parseNoun(word).matches.all.length > 0 ||
word.includes("&") ||
word.includes("=") ||
"undefined" !== typeof adventurejs[A.propercase(word)];
let exclusion = word.charAt(0) === "-";
let number = !isNaN(Number(word)) ? word : false;
let adjective = this.game.dictionary.getAdjective(word);
let properties = {
word: word,
verb: verb,
direction: direction,
compass_direction: compass_direction,
relative_direction: relative_direction,
parsed_direction: parsed_direction,
preposition: preposition,
string: string,
noun: noun,
exclusion: exclusion,
number: number,
adjective: adjective,
};
// console.warn("parseSentence properties", properties);
// this.game.print(
// `D1191 | parseSentence.js | \n<br/> - word/ ${word}\n<br/> - verb/ ${verb}\n<br/> - direction/ ${direction}\n<br/> - preposition/ ${preposition}\n<br/> - adverb/ ${adverb}\n<br/> - number/ ${number}\n<br/> - string/ ${string}\n<br/> - noun/ ${noun}`
// );
if (noun && exclusion) {
// both have & in them, get caught by noun check
// but only exclusion has the leading -
noun = false;
}
// Handle type-of-word ambiguities.
// Any direction can be a verb.
// Check position in sentence:
// - if it's the first word, it's a verb
// - if it's the second word...
// - if first word was an adverb, it's a verb
// - otherwise it's a direction
// Directions that are not verbs can be treated like nouns.
// Later during verification we'll check if direction is a preposition.
if (verb && direction && preposition) {
// this catches 'in' and 'out', which are defined as direction
// verbs in addition to being prepositions
// @TODO 2/4/24 it can be used to catch 'up' and 'down'
// if 'up' and 'down' are added to dictionary.prepositions
// currently evaluating that
if (position === 0 || (position === 1 && count.adverb > 0)) {
// almost certainly a verb
direction = false;
preposition = false;
} else if (position === 1) {
// could be "go in" - direction and preposition
// could be "look in" or "put in" - prepositions
// treat it like a preposition and let verbs handle it
verb = false;
direction = false;
} else {
// probably preposition
verb = false;
direction = false;
}
}
if (verb && direction && adverb) {
// this catches 'up' and 'down', which are
// defined as direction verbs and are also adverbs
// 2024.05.26 for now, removed directions from adverbs list
if (position === 0) {
// almost certainly a verb
direction = false;
adverb = false;
noun = false;
} else if (
position === 1 ||
position === this_turn.parsed_input_array.length - 1 ||
last_word_type === "verb"
) {
// could be "go up" - direction and adverb
// could be "look up" or "put up" - adverbs
// treat it like an adverb and let verbs handle it
verb = false;
direction = false;
noun = false;
} else {
// in the case of a phrase like "throw ball up",
// up would be an adverb
// in the case of a phrase like "throw ball up the stairs",
// up would be a preposition
// at this moment we don't know which, so treat it like a direction
// which is to say, a noun
verb = false;
adverb = false;
}
}
if (verb && noun && direction) {
// this catches most directions
if (position === 0 || (position === 1 && count.adverb > 0)) {
// almost certainly a verb
direction = false;
noun = false;
} else {
// if it's a verb and a direction, but not an adverb
// or a preposition, treat it as a noun
// as in "go north" or "look north"
direction = false;
verb = false;
}
}
if (verb && noun) {
// consider the verb plug and the noun plug
if (position === 0 || (position === 1 && count.adverb > 0)) {
noun = false;
} else {
verb = false;
}
}
if (verb && direction) {
if (position === 0 || (position === 1 && count.adverb > 0)) {
direction = false;
} else {
verb = false;
}
}
if (verb && preposition) {
if (position === 0 || (position === 1 && count.adverb > 0)) {
preposition = false;
} else {
verb = false;
}
}
/* verb ---------------------------------------- OK */
if (verb) {
this.game.log(
"L1266",
"log",
"high",
"parseSentence.js > verb: " + verb,
"Parser"
);
if (count.verb === 0) firstverb = verb;
count.verb++;
this_turn.pushParsedWord({
type: "verb",
word: verb,
properties: properties,
});
last_word_type = "verb";
last_word = word;
continue;
}
/* adverb ---------------------------------------- */
// not parsing adverbs for now but keep this for later
if (adverb) {
this.game.log(
"L1267",
"log",
"high",
"parseSentence.js > adverb: " + adverb,
"Parser"
);
count.adverb++;
this_turn.pushParsedWord({
type: "adverb",
word: adverb,
properties: properties,
});
last_word_type = "adverb";
last_word = word;
continue;
}
// distinguish directions from nouns,
// but also allow directions to be used as nouns
/* direction ---------------------------------------- */
if (direction) {
this.game.log(
"L1268",
"log",
"high",
"parseSentence.js > direction: " + direction,
"Parser"
);
count.direction++;
count.phrase++;
this_turn.pushParsedWord({
type: "direction",
word: direction,
properties: properties,
});
last_word_type = "direction";
last_word = word;
continue;
}
/* preposition ---------------------------------------- OK */
if (preposition) {
// it's recognized as a preposition
this.game.log(
"L1269",
"log",
"high",
"parseSentence.js > preposition: " + word,
"Parser"
);
count.prep++;
count.phrase++;
// store the typed words in their original order
this_turn.pushParsedWord({
type: "preposition",
word: word,
phrase: count.phrase,
properties: properties,
});
last_word_type = "preposition";
last_word = word;
continue;
}
/* string ---------------------------------------- */
// if( string )
// {
// // it's a string, but we're not handling them that way yet
// this_turn.pushParsedWord( { type:'string',this_turn.parsed_input_array[position] } );
// // save it as a string or continue to save it as a noun?
// }
/* noun ---------------------------------------- */
if (noun) {
// Treat it like a noun. We do more checks later to see
// if it's unknown, and if it's not we want to soft prompt
// for "oops"
this.game.log(
"L1270",
"log",
"high",
"parseSentence.js > noun: " + word,
"Parser"
);
count.noun++;
this_turn.pushParsedWord({
type: "noun",
word: word,
preposition: null,
properties: properties,
adjective: adjective,
});
last_word_type = "noun";
last_word = word;
continue;
}
/* exclusion ---------------------------------------- */
if (exclusion) {
// it's an exclusionary noun, like "take all but thing"
// the last noun will be the one we want to exclude from
this.game.log(
"L1271",
"log",
"high",
"parseSentence.js > exclude noun: " + word,
"Parser"
);
// remove the leading '-' which has done its job
word = word.slice(1);
if (last_word_type === "noun") {
let l = this_turn.parsed_sentence.length - 1;
this_turn.parsed_sentence[l].exclusion = word;
} else {
// this should not happen
this_turn.pushParsedWord({
type: "exclusion",
word: word,
properties: properties,
});
}
// END BLOCK
last_word_type = "exclusion";
last_word = word;
continue;
}
/* number ---------------------------------------- */
if (number) {
// it's a number
this.game.log(
"L1272",
"log",
"high",
"parseSentence.js > number: " + word,
"Parser"
);
count.number++;
count.phrase++;
// store the typed words in their original order
this_turn.pushParsedWord({
type: "number",
word: word,
properties: properties,
});
last_word_type = "number";
last_word = word;
continue;
}
/* adjective ---------------------------------------- */
if (adjective) {
// it's an adjective
this.game.log(
"L1273",
"log",
"high",
"parseSentence.js > adjective: " + word,
"Parser"
);
count.adjective++;
this_turn.pushParsedWord({
type: "adjective",
word: word,
properties: properties,
});
last_word_type = "adjective";
last_word = word;
continue;
}
/* unknown ---------------------------------------- */
// it's unknown
this.game.log(
"L1274",
"log",
"high",
"parseSentence.js > unknown: " + word,
"Parser"
);
last_word_type = "unknown";
this_turn.pushParsedWord({
type: "unknown",
word: word,
properties: properties,
});
last_word = word;
} // for position loop
return true;
}; // parseSentence
})();