@turnipxenon/pineapple 1.1.2

package/src/lib/components/dialog_manager/DialogManagerStore.ts

@@ -0,0 +1,52 @@
+/**
+ * DialogManagerStore is for variables that will be used as a Svelte store
+ * or is saved in local storage
+ */
+
+import type { DialogMapStore } from "$lib/types/pineapple_fiber/DialogVariableStore";
+import { createNewMapStore } from "$lib/types/pineapple_fiber/DialogVariableStore";
+import { writable } from "svelte/store";
+import type { DialogDetail } from "$lib/types/pineapple_fiber/DialogDetail";
+import { DialogManager } from "$lib/components/dialog_manager/DialogManager";
+
+/**
+ * Enables the dialogue overlay
+ *
+ * @example
+ * When updating to false, remember to restore the value to true, our default value, onDestroy.
+ * Avoid async to prevent weird flashes of updates!
+ * ```
+ * import {enableDialogueOverlay} from "$lib/store.ts";
+ * enableDialogueOverlay.update(() => false);
+ *
+ * onDestroy(() => {
+ *     enableDialogueOverlay.update(() =>  true);
+ * });
+ * ```
+ */
+export const enableDialogueOverlay = writable(true);
+
+export const dialogVariableStore: DialogMapStore = createNewMapStore();
+export const updateRate: number = 40 / 1000; // *at least* 40ms per letter
+
+// todo: if we go through doing yarn to typescript, move this!
+export const defaultDialogMessage: DialogDetail[] = [
+	{
+		textContent: `<p>Have you drank water? Or perhaps, you've checked out <a target="_blank" class="external-link" href="http://crouton.net">one of the best webpages</a> out there?`
+	}
+];
+
+/**
+ * strictly must be declared last! or you might receive a weird error that looks like:
+ *
+ * 2:04:21 AM [vite] Error when evaluating SSR module /src/lib/components/dialog_manager/DialogManagerStore.ts:
+ * |- TypeError: Cannot read properties of undefined (reading '0')
+ *     at <instance_members_initializer> (/src/lib/components/dialog_manager/DialogManager.ts:38:67)
+ *     at new DialogManager (/src/lib/components/dialog_manager/DialogManager.ts:53:14)
+ *     at eval (/src/lib/components/dialog_manager/DialogManagerStore.ts:15:23)
+ *     at async instantiateModule (file:///C:/Users/Pumpkin/Projects/Web/pineapple/node_modules/vite/dist/node/chunks/dep-934dbc7c.js:54360:9)
+ *
+ * what this means is that one member of dialogManager cannot be initialized. in our case, it was the
+ * defaultDialogMessage not yet being initialized
+ */
+export const dialogManager = new DialogManager();

package/src/lib/components/dialog_manager/DialogProcessor.ts

@@ -0,0 +1,68 @@
+import type { DialogDetail } from "$lib/types/pineapple_fiber/DialogDetail";
+import { BehaviorState } from "$lib/components/dialog_manager/behavior_tree/line_processors/BehaviorState";
+import { IfNode } from "$lib/components/dialog_manager/behavior_tree/line_processors/IfNode";
+import { EndIfNode } from "$lib/components/dialog_manager/behavior_tree/line_processors/EndIfNode";
+import { ElseNode } from "$lib/components/dialog_manager/behavior_tree/line_processors/ElseNode";
+import { ElseIfNode } from "$lib/components/dialog_manager/behavior_tree/line_processors/ElseIfNode";
+import { SetVariableNode } from "$lib/components/dialog_manager/behavior_tree/line_processors/SetVariableNode";
+import { IgnoreGuardNode } from "$lib/components/dialog_manager/behavior_tree/line_processors/IgnoreGuardNode";
+import { NormalLineProcessorNode } from "$lib/components/dialog_manager/behavior_tree/line_processors/NormalLineProcessorNode";
+import { LineSelectorNode } from "$lib/components/dialog_manager/behavior_tree/line_core/LineSelectorNode";
+import { browser } from "$app/environment";
+import { LineCommentNode } from "$lib/components/dialog_manager/behavior_tree/line_processors/LineCommentNode";
+import { DeclareCommand } from "$lib/components/dialog_manager/behavior_tree/line_processors/commands/DeclareCommand";
+import { JumpCommand } from "$lib/components/dialog_manager/behavior_tree/line_processors/commands/JumpCommand";
+import { IgnoreJumpNode } from "$lib/components/dialog_manager/behavior_tree/line_processors/IgnoreJumpNode";
+import { UnvisitCommand } from "$lib/components/dialog_manager/behavior_tree/line_processors/commands/UnvisitCommand";
+
+/**
+ * DialogProcessor processes dialogs
+ */
+export class DialogProcessor {
+	processingTree = new LineSelectorNode([
+		/*region comment based formats*/
+		new IgnoreJumpNode(), // must be prioritized above line comment node
+		new LineCommentNode(),
+		/*endregion commend based formats*/
+		new EndIfNode(),
+		new ElseIfNode(),
+		new ElseNode(),
+		new IfNode(),
+		new IgnoreGuardNode(),
+		/*region commands*/
+		new SetVariableNode(),
+		new DeclareCommand(),
+		new JumpCommand(),
+		new UnvisitCommand(),
+		/*endregion commands*/
+		new NormalLineProcessorNode()
+	]);
+
+	/**
+	 * process the dialog line by line and return a presentable string
+	 * @param dialogDetail
+	 */
+	processDialog = (dialogDetail: DialogDetail): string => {
+		if (!browser) {
+			return ""; // don't process any line in the server
+		}
+
+		let currentState = new BehaviorState();
+
+		// split each yarn line
+		return dialogDetail.textContent
+			.trim()
+			.split("\n")
+			.map((line_, index) => {
+				const result = this.processingTree.process({
+					initState: currentState,
+					line: line_.trim(),
+					lineIndex: index
+				});
+				currentState = result.nextState;
+
+				return result.renderedLine;
+			})
+			.join("\n"); // combine all processed lines
+	};
+}

package/src/lib/components/dialog_manager/DialogUtils.ts

@@ -0,0 +1,10 @@
+import { dialogVariableStore } from "$lib/components/dialog_manager/DialogManagerStore";
+
+class _DialogUtils {
+	isNodeVisited = (dialogId: string): boolean => {
+		const value = Number(dialogVariableStore.getItem(`+${dialogId}`));
+		return !isNaN(value) && value > 0;
+	};
+}
+
+export const DialogUtils = new _DialogUtils();

package/src/lib/components/dialog_manager/behavior_tree/core/BTreeUtils.ts

@@ -0,0 +1,40 @@
+class BTreeUtils {
+	/**
+	 * peek the top of a stack object with the assumption it's not an empty stack
+	 * todo: add possible protection like an assertion
+	 * @param stack
+	 * @return top of the stack
+	 */
+	peek = <T>(stack: T[]): T => {
+		return stack[stack.length - 1];
+	};
+
+	removeQuotes = (value: string): string => {
+		return value
+			.replace(/^"/, "") // remove possible " at the start: https://stackoverflow.com/a/2182602
+			.replace(/"$/, ""); // remove possible " at the end: https://stackoverflow.com/a/12249011
+	};
+
+	simplifyToken = (oldToken: string): string => {
+		if (oldToken[0] == "$") {
+			const value = localStorage.getItem(oldToken);
+			if (value) {
+				return value;
+			}
+			console.error(`Value obtained in local storage false: ${oldToken}`);
+			return "";
+		}
+
+		return btreeUtils.removeQuotes(oldToken);
+	};
+
+	isTrue = (value: string): boolean => {
+		return value.trim().toLowerCase() === "true";
+	};
+
+	isFalse = (value: string): boolean => {
+		return value.trim().toLowerCase() === "false";
+	};
+}
+
+export const btreeUtils = new BTreeUtils();

package/src/lib/components/dialog_manager/behavior_tree/core/BaseBehaviorResult.ts

@@ -0,0 +1,5 @@
+import type { BehaviorStatus } from "$lib/components/dialog_manager/behavior_tree/core/BehaviorStatus";
+
+export interface BaseBehaviorResult {
+	status: BehaviorStatus;
+}

package/src/lib/components/dialog_manager/behavior_tree/core/BehaviorNode.ts

@@ -0,0 +1,3 @@
+export interface BehaviorNode<Argument, Result> {
+	process: (nodeArgs: Argument) => Result;
+}

package/src/lib/components/dialog_manager/behavior_tree/core/BehaviorStatus.ts

@@ -0,0 +1,5 @@
+export enum BehaviorStatus {
+	Running,
+	Success,
+	Failure
+}

package/src/lib/components/dialog_manager/behavior_tree/core/SelectorNode.ts

@@ -0,0 +1,32 @@
+import type { BehaviorNode } from "$lib/components/dialog_manager/behavior_tree/core/BehaviorNode";
+import { BehaviorStatus } from "$lib/components/dialog_manager/behavior_tree/core/BehaviorStatus";
+import type { BaseBehaviorResult } from "$lib/components/dialog_manager/behavior_tree/core/BaseBehaviorResult";
+
+/**
+ * Selector is a composite behavior node where it tries to process everything until it
+ * finds a non-failing node
+ */
+export abstract class SelectorNode<Argument, Result extends BaseBehaviorResult>
+	implements BehaviorNode<Argument, Result>
+{
+	nodeList: BehaviorNode<Argument, Result>[];
+	abstract defaultResult: () => Result;
+
+	protected constructor(nodeList: BehaviorNode<Argument, Result>[]) {
+		this.nodeList = nodeList;
+	}
+
+	process(nodeArgs: Argument): Result {
+		let finalResult: Result = this.defaultResult();
+
+		for (const node of this.nodeList) {
+			const currentResult = node.process(nodeArgs);
+			if (currentResult.status !== BehaviorStatus.Failure) {
+				finalResult = currentResult;
+				break;
+			}
+		}
+
+		return finalResult;
+	}
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments.ts

@@ -0,0 +1,6 @@
+import type { ExpressionState } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionState";
+
+export interface ExpressionArguments {
+	token: string;
+	initState: ExpressionState;
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/ExpressionBehaviorNode.ts

@@ -0,0 +1,5 @@
+import type { BehaviorNode } from "$lib/components/dialog_manager/behavior_tree/core/BehaviorNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+import type { ExpressionResult } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionResult";
+
+export type ExpressionBehaviorNode = BehaviorNode<ExpressionArguments, ExpressionResult>;

package/src/lib/components/dialog_manager/behavior_tree/expression/ExpressionEvaluator.ts

@@ -0,0 +1,236 @@
+import { browser } from "$app/environment";
+import { OperatorNode } from "$lib/components/dialog_manager/behavior_tree/expression/OperatorNode";
+import { OperandNode } from "$lib/components/dialog_manager/behavior_tree/expression/OperandNode";
+import { ExpressionSelectorNode } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionSelectorNode";
+import type { ExpressionState } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionState";
+import { btreeUtils } from "$lib/components/dialog_manager/behavior_tree/core/BTreeUtils";
+import { CommandExpressionNode } from "$lib/components/dialog_manager/behavior_tree/expression/commands/CommandExpressionNode";
+
+class ExpressionEvaluator {
+	evaluatorTree = new ExpressionSelectorNode([
+		new OperatorNode(),
+		new CommandExpressionNode(),
+		new OperandNode()
+	]);
+
+	// from https://stackoverflow.com/a/175787/17836168
+	isNumeric = (str: string): boolean => {
+		return (
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore
+			!isNaN(str) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+			!isNaN(parseFloat(str))
+		); // ...and ensure strings of whitespace fail
+	};
+
+	getPrecedence = (token: string): number => {
+		switch (token) {
+			case "&&":
+			case "||":
+			case "^":
+				return 1;
+			case "==":
+			case "!=":
+				return 2;
+			case "<":
+			case ">":
+			case ">=":
+			case "<=":
+				return 3;
+			case "+":
+			case "-":
+				return 4;
+			case "*":
+			case "/":
+			case "%":
+				return 3;
+			case "!":
+				return 4;
+			case "(":
+			case ")":
+				return 0; // hack lol
+			default:
+				// usable to test if operator lol
+				// console.error(`Unknown token: ${token}`);
+				return -1;
+		}
+	};
+
+	evaluateFreeform = (line: string, prefix: string): string[] => {
+		if (!browser) {
+			return []; // do not process when not in browser
+		}
+
+		// tokenize first!
+		const infixTokens: string[] = [];
+		const expression = line
+			.split("//")[0]
+			.trim()
+			.slice(prefix === "" ? 0 : prefix.trim().length + 1, line.length - 2);
+
+		// region tokenizer
+		// console.log("Tokenizing:", expression);
+		const operators = "+-*/%!<>=&|^";
+		let currentToken = "";
+		let escapeToggle = false;
+		let quoteToggle = false;
+		let operatorFound = false;
+		for (const character of expression) {
+			if (escapeToggle) {
+				currentToken += character;
+				escapeToggle = false;
+			} else if (quoteToggle) {
+				currentToken += character;
+				if (character === '"') {
+					infixTokens.push(currentToken);
+					currentToken = "";
+					quoteToggle = false;
+				}
+			} else if (operatorFound) {
+				if (operators.includes(character)) {
+					currentToken += character;
+				} else if ("()".includes(character)) {
+					if (currentToken !== "") {
+						infixTokens.push(currentToken);
+					}
+					infixTokens.push(character);
+					currentToken = "";
+					operatorFound = false;
+				} else {
+					operatorFound = false;
+					infixTokens.push(currentToken);
+					if (character !== " ") {
+						currentToken = character;
+					} else {
+						currentToken = "";
+					}
+				}
+			} else if (character === "," || character === " ") {
+				if (currentToken !== "") {
+					infixTokens.push(currentToken);
+					currentToken = "";
+				}
+			} else if (character === '"') {
+				// do quote stuff unless we had an escape toggle
+				currentToken += character;
+				quoteToggle = true;
+			} else if (operators.includes(character)) {
+				if (currentToken !== "") {
+					infixTokens.push(currentToken);
+				}
+				currentToken = character;
+				operatorFound = true;
+			} else if ("()".includes(character)) {
+				if (currentToken !== "") {
+					// determine if function
+					if (
+						currentToken[0] !== "$" && // should not be a variable stand-in
+						currentToken[0] !== '"' && // should not be a string literal
+						!this.isNumeric(currentToken[0]) // should not be a number literal
+					) {
+						currentToken = `#${currentToken}`;
+					}
+
+					infixTokens.push(currentToken);
+				}
+				infixTokens.push(character);
+				currentToken = "";
+			} else {
+				currentToken += character;
+			}
+		}
+
+		if (currentToken !== "") {
+			infixTokens.push(currentToken);
+		}
+
+		// console.log(infixTokens);
+		// endregion tokenizer
+
+		// region infix to postfix
+
+		// convert from infix to postfix
+		// algo from https://www.geeksforgeeks.org/convert-infix-expression-to-postfix-expression/
+		// console.log(infixTokens);
+		const postfixTokens: string[] = [];
+		const stack: string[] = [];
+
+		infixTokens.forEach((token) => {
+			if (token.startsWith("#")) {
+				stack.push(token);
+			} else if (token === "(") {
+				stack.push("(");
+			} else if (token === ")") {
+				while (btreeUtils.peek(stack) !== "(") {
+					// just for safety
+					if (stack.length === 0) {
+						console.error(
+							"Assumption was made in postfix conversion that stack will not be empty! It was wrong!"
+						);
+						throw new Error("Wrong postfix conversion!");
+					}
+
+					postfixTokens.push(<string>stack.pop());
+				}
+
+				stack.pop(); // remove "("
+
+				if (stack.length > 0 && btreeUtils.peek(stack).startsWith("#")) {
+					postfixTokens.push(<string>stack.pop());
+				}
+			} else if (![-1, 5].includes(this.getPrecedence(token))) {
+				while (
+					stack.length > 0 &&
+					this.getPrecedence(btreeUtils.peek(stack)) >= this.getPrecedence(token)
+				) {
+					postfixTokens.push(<string>stack.pop());
+				}
+				stack.push(token);
+			} else {
+				// operand
+				postfixTokens.push(token);
+			}
+		});
+
+		// pop all remaining elements from the stack
+		while (stack.length > 0) {
+			postfixTokens.push(<string>stack.pop());
+		}
+
+		// console.log("Finished postfix", postfixTokens);
+		// endregion infix to postfix
+
+		// evaluate
+		let currentState: ExpressionState = {
+			operandStack: []
+		};
+
+		postfixTokens.forEach((token) => {
+			// console.log("Current token", token);
+			const result = this.evaluatorTree.process({
+				initState: currentState,
+				token: token
+			});
+			// console.log("Token evaluated with result", result.nextState.operandStack.toString());
+			currentState = result.nextState;
+		});
+
+		// console.log("Result", currentState.operandStack);
+		return currentState.operandStack;
+	};
+
+	/**
+	 * evaluates a yarn if or elseif statement
+	 * @param line is the current line being evaluated
+	 * @param prefix is either "<<if" or "<<elseif"
+	 */
+	evaluate = (line: string, prefix: string): boolean => {
+		if (!browser) {
+			return false; // do not process when not in browser
+		}
+
+		return String(btreeUtils.peek(this.evaluateFreeform(line, prefix))) === "true";
+	};
+}
+
+export const expressionEvaluator = new ExpressionEvaluator();

package/src/lib/components/dialog_manager/behavior_tree/expression/ExpressionResult.ts

@@ -0,0 +1,6 @@
+import type { BaseBehaviorResult } from "$lib/components/dialog_manager/behavior_tree/core/BaseBehaviorResult";
+import type { ExpressionState } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionState";
+
+export interface ExpressionResult extends BaseBehaviorResult {
+	nextState: ExpressionState;
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/ExpressionSelectorNode.ts

@@ -0,0 +1,20 @@
+import { SelectorNode } from "$lib/components/dialog_manager/behavior_tree/core/SelectorNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+import type { ExpressionResult } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionResult";
+import { BehaviorStatus } from "$lib/components/dialog_manager/behavior_tree/core/BehaviorStatus";
+import type { ExpressionBehaviorNode } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionBehaviorNode";
+
+export class ExpressionSelectorNode extends SelectorNode<ExpressionArguments, ExpressionResult> {
+	constructor(nodeList: ExpressionBehaviorNode[]) {
+		super(nodeList);
+	}
+
+	defaultResult = (): ExpressionResult => {
+		return {
+			nextState: {
+				operandStack: []
+			},
+			status: BehaviorStatus.Failure
+		};
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/ExpressionState.ts

@@ -0,0 +1,3 @@
+export interface ExpressionState {
+	operandStack: string[];
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/OperandNode.ts

@@ -0,0 +1,19 @@
+import type { ExpressionBehaviorNode } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionBehaviorNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+import type { ExpressionResult } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionResult";
+import { BehaviorStatus } from "$lib/components/dialog_manager/behavior_tree/core/BehaviorStatus";
+import { btreeUtils } from "$lib/components/dialog_manager/behavior_tree/core/BTreeUtils";
+
+/**
+ * Puts the token as an operand
+ * It's always successful
+ */
+export class OperandNode implements ExpressionBehaviorNode {
+	process(nodeArgs: ExpressionArguments): ExpressionResult {
+		nodeArgs.initState.operandStack.push(btreeUtils.simplifyToken(nodeArgs.token));
+		return {
+			nextState: nodeArgs.initState,
+			status: BehaviorStatus.Success
+		};
+	}
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/OperatorNode.ts

@@ -0,0 +1,37 @@
+import type { ExpressionBehaviorNode } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionBehaviorNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+import type { ExpressionResult } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionResult";
+import { BehaviorStatus } from "$lib/components/dialog_manager/behavior_tree/core/BehaviorStatus";
+import { operatorMap } from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorMap";
+
+/**
+ * A leaf node that returns:
+ * - Success if the current token is an operator, and does its associated logic
+ * - Failure if it is not an operator
+ */
+export class OperatorNode implements ExpressionBehaviorNode {
+	process(nodeArgs: ExpressionArguments): ExpressionResult {
+		if (!operatorMap.exists(nodeArgs.token)) {
+			return {
+				nextState: nodeArgs.initState,
+				status: BehaviorStatus.Failure
+			};
+		}
+
+		const logic = operatorMap.get(nodeArgs.token);
+		if (logic === undefined) {
+			console.error(`Unimplemented operator: ${nodeArgs.token}`);
+			return {
+				nextState: nodeArgs.initState,
+				status: BehaviorStatus.Failure
+			};
+		}
+
+		logic.process(nodeArgs);
+
+		return {
+			nextState: nodeArgs.initState,
+			status: BehaviorStatus.Success
+		};
+	}
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/commands/CommandExpressionNode.ts

@@ -0,0 +1,28 @@
+import type { ExpressionBehaviorNode } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionBehaviorNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+import type { ExpressionResult } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionResult";
+import { commandMap } from "$lib/components/dialog_manager/behavior_tree/expression/commands/CommandMap";
+import { BehaviorStatus } from "$lib/components/dialog_manager/behavior_tree/core/BehaviorStatus";
+
+export class CommandExpressionNode implements ExpressionBehaviorNode {
+	process(nodeArgs: ExpressionArguments): ExpressionResult {
+		const commandNode = commandMap.get(nodeArgs.token);
+		if (commandNode === undefined) {
+			if (nodeArgs.token.startsWith("#")) {
+				console.error(`Unimplemented command: ${nodeArgs.token}`);
+			}
+
+			return {
+				nextState: nodeArgs.initState,
+				status: BehaviorStatus.Failure
+			};
+		}
+
+		commandNode.process(nodeArgs);
+
+		return {
+			nextState: nodeArgs.initState,
+			status: BehaviorStatus.Success
+		};
+	}
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/commands/CommandLogicNode.ts

@@ -0,0 +1,34 @@
+import type { ExpressionBehaviorNode } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionBehaviorNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+import type { ExpressionResult } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionResult";
+import { BehaviorStatus } from "$lib/components/dialog_manager/behavior_tree/core/BehaviorStatus";
+
+export abstract class CommandLogicNode implements ExpressionBehaviorNode {
+	abstract getToken: () => string;
+	abstract getArgumentCount: () => number;
+	abstract doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void; // do side effects on to the result instead
+
+	process(nodeArgs: ExpressionArguments): ExpressionResult {
+		const currentOperands = nodeArgs.initState.operandStack.slice(
+			nodeArgs.initState.operandStack.length - this.getArgumentCount(),
+			nodeArgs.initState.operandStack.length
+		);
+		nodeArgs.initState.operandStack = nodeArgs.initState.operandStack.slice(
+			0,
+			nodeArgs.initState.operandStack.length - this.getArgumentCount()
+		);
+
+		if (currentOperands.length !== this.getArgumentCount()) {
+			console.error(`Insufficient operands/arguments found for command ${this.getToken()}`);
+			console.error(`Arguments found instead: ${currentOperands}`);
+			console.error(`Error occurred at token: ${nodeArgs.token}`);
+		} else {
+			this.doOperation(currentOperands, nodeArgs);
+		}
+
+		return {
+			nextState: nodeArgs.initState,
+			status: BehaviorStatus.Success
+		};
+	}
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/commands/CommandMap.ts

@@ -0,0 +1,26 @@
+import type { CommandLogicNode } from "$lib/components/dialog_manager/behavior_tree/expression/commands/CommandLogicNode";
+import { RandomRangeCommand } from "$lib/components/dialog_manager/behavior_tree/expression/commands/RandomRangeCommand";
+import { VisitedCountCommand } from "$lib/components/dialog_manager/behavior_tree/expression/commands/VisitedCountCommand";
+import { VisitedCommand } from "$lib/components/dialog_manager/behavior_tree/expression/commands/VisitedCommand";
+
+class CommandMap {
+	_commandMap: Map<string, CommandLogicNode> = new Map();
+
+	constructor() {
+		[new RandomRangeCommand(), new VisitedCountCommand(), new VisitedCommand()].forEach(
+			(commandLogic) => {
+				this._commandMap.set(commandLogic.getToken(), commandLogic);
+			}
+		);
+	}
+
+	get = (command: string): CommandLogicNode | undefined => {
+		return this._commandMap.get(command);
+	};
+
+	exists = (command: string): boolean => {
+		return this.get(command) !== undefined;
+	};
+}
+
+export const commandMap = new CommandMap();