@turnipxenon/pineapple 1.1.2

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

@@ -0,0 +1,31 @@
+import { CommandLogicNode } from "$lib/components/dialog_manager/behavior_tree/expression/commands/CommandLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+
+/**
+ * Used for command like
+ * random_range(1, 2);
+ */
+export class RandomRangeCommand extends CommandLogicNode {
+	/**
+	 * From: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random#getting_a_random_integer_between_two_values
+	 */
+	getRandomInt = (min: number, max: number): number => {
+		min = Math.ceil(min);
+		max = Math.floor(max);
+		return Math.floor(Math.random() * (max - min + 1)) + min;
+	};
+
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		nodeArgs.initState.operandStack.push(
+			String(this.getRandomInt(Number(currentOperands[0]), Number(currentOperands[1])))
+		);
+	};
+
+	getArgumentCount = (): number => {
+		return 2;
+	};
+
+	getToken = (): string => {
+		return "#random_range";
+	};
+}

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

@@ -0,0 +1,38 @@
+import { CommandLogicNode } from "$lib/components/dialog_manager/behavior_tree/expression/commands/CommandLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+import { VisitedCountCommand } from "$lib/components/dialog_manager/behavior_tree/expression/commands/VisitedCountCommand";
+
+/**
+ * Used for command like
+ * visited("node name here");
+ *
+ * Pushes a boolean in the operand stack
+ *
+ * Some design decision note:
+ * I opted for composition over inheritance.
+ * This may look like a good case for composition but my philosophy is if they both are equally
+ * viable, always prefer composition. It will help in the long run if we do refactoring
+ */
+export class VisitedCommand extends CommandLogicNode {
+	visitedCountCommand = new VisitedCountCommand();
+
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		this.visitedCountCommand.process(nodeArgs);
+
+		const value = Number(nodeArgs.initState.operandStack.pop());
+
+		if (isNaN(value) || value === 0) {
+			nodeArgs.initState.operandStack.push("false");
+		} else {
+			nodeArgs.initState.operandStack.push("true");
+		}
+	};
+
+	getArgumentCount = (): number => {
+		return 0; // let the child work; this is only a decorator
+	};
+
+	getToken = (): string => {
+		return "#visited";
+	};
+}

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

@@ -0,0 +1,28 @@
+import { CommandLogicNode } from "$lib/components/dialog_manager/behavior_tree/expression/commands/CommandLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+import { dialogVariableStore } from "$lib/components/dialog_manager/DialogManagerStore";
+
+/**
+ * Used for command like
+ * visited_count("node name here");
+ *
+ * Pushed a number in the operand stack
+ */
+export class VisitedCountCommand extends CommandLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		const value = Number(dialogVariableStore.getItem(`+${currentOperands[0]}`));
+		if (isNaN(value) || value === 0) {
+			nodeArgs.initState.operandStack.push("0");
+		} else {
+			nodeArgs.initState.operandStack.push(String(value));
+		}
+	};
+
+	getArgumentCount = (): number => {
+		return 1;
+	};
+
+	getToken = (): string => {
+		return "#visited_count";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/AndOperator.ts

@@ -0,0 +1,24 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+import { btreeUtils } from "$lib/components/dialog_manager/behavior_tree/core/BTreeUtils";
+
+export class AndOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		// todo: evaluate possible weird cases when doing number comparisons
+		// ISSUE #88 https://github.com/TurnipXenon/pineapple/issues/88
+		nodeArgs.initState.operandStack.push(
+			String(btreeUtils.isTrue(currentOperands[0]) && btreeUtils.isTrue(currentOperands[1]))
+		);
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return "&&";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/EqualityOperator.ts

@@ -0,0 +1,21 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+
+export class EqualityOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		// todo: evaluate possible weird cases when doing number comparisons
+		// ISSUE #88 https://github.com/TurnipXenon/pineapple/issues/88
+		nodeArgs.initState.operandStack.push(String(currentOperands[0] === currentOperands[1]));
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return "==";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/GreaterThanEqualOperator.ts

@@ -0,0 +1,21 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+
+export class GreaterThanEqualOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		nodeArgs.initState.operandStack.push(
+			String(Number(currentOperands[0]) >= Number(currentOperands[1]))
+		);
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return ">=";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/GreaterThanOperator.ts

@@ -0,0 +1,21 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+
+export class GreaterThanOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		nodeArgs.initState.operandStack.push(
+			String(Number(currentOperands[0]) > Number(currentOperands[1]))
+		);
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return ">";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/InequalityOperator.ts

@@ -0,0 +1,19 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+
+export class InequalityOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		nodeArgs.initState.operandStack.push(String(currentOperands[0] !== currentOperands[1]));
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return "!=";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/LessThanEqualOperator.ts

@@ -0,0 +1,21 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+
+export class LessThanEqualOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		nodeArgs.initState.operandStack.push(
+			String(Number(currentOperands[0]) <= Number(currentOperands[1]))
+		);
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return "<=";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/LessThanOperator.ts

@@ -0,0 +1,21 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+
+export class LessThanOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		nodeArgs.initState.operandStack.push(
+			String(Number(currentOperands[0]) < Number(currentOperands[1]))
+		);
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return "<";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/NegationOperator.ts

@@ -0,0 +1,20 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+import { btreeUtils } from "$lib/components/dialog_manager/behavior_tree/core/BTreeUtils";
+
+export class NegationOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		nodeArgs.initState.operandStack.push(String(!btreeUtils.isTrue(currentOperands[0])));
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Unary;
+	};
+
+	getToken = (): string => {
+		return "!";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode.ts

@@ -0,0 +1,42 @@
+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 enum OperatorType {
+	Unary,
+	Binary
+}
+
+/**
+ * a leaf node that will always run success
+ * do the processing outside comparing with getToken
+ */
+export abstract class OperatorLogicNode implements ExpressionBehaviorNode {
+	abstract getToken: () => string;
+	abstract getOperatorType: () => OperatorType;
+	abstract doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+
+	process(nodeArgs: ExpressionArguments): ExpressionResult {
+		const currentOperands: string[] = [];
+		switch (this.getOperatorType()) {
+			case OperatorType.Unary:
+				currentOperands.unshift(<string>nodeArgs.initState.operandStack.pop());
+				break;
+			case OperatorType.Binary:
+				currentOperands.unshift(<string>nodeArgs.initState.operandStack.pop());
+				currentOperands.unshift(<string>nodeArgs.initState.operandStack.pop());
+				break;
+			default:
+				console.error(`Unimplemented operator type: ${this.getOperatorType()}`);
+				break;
+		}
+
+		this.doOperation(currentOperands, nodeArgs);
+
+		return {
+			nextState: nodeArgs.initState,
+			status: BehaviorStatus.Success
+		};
+	}
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/OperatorMap.ts

@@ -0,0 +1,53 @@
+import type { OperatorLogicNode } from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import { EqualityOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/EqualityOperator";
+import { InequalityOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/InequalityOperator";
+import { GreaterThanOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/GreaterThanOperator";
+import { GreaterThanEqualOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/GreaterThanEqualOperator";
+import { LessThanOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/LessThanOperator";
+import { LessThanEqualOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/LessThanEqualOperator";
+import { NegationOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/NegationOperator";
+import { AndOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/AndOperator";
+import { OrOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/OrOperator";
+import { XorOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/XorOperator";
+import { AddOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/arithmetic/PlusOperator";
+import { MinusOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/arithmetic/MinusOperator";
+import { MultiplicationOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/arithmetic/MultiplicationOperator";
+import { DivisionOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/arithmetic/DivisionOperator";
+import { RemainderDivisionOperator } from "$lib/components/dialog_manager/behavior_tree/expression/operators/arithmetic/RemainderDivisionOperator";
+
+class OperatorMap {
+	_operatorLogicMap: Map<string, OperatorLogicNode> = new Map();
+
+	constructor() {
+		// set up operator logic
+		[
+			new EqualityOperator(),
+			new InequalityOperator(),
+			new GreaterThanOperator(),
+			new GreaterThanEqualOperator(),
+			new LessThanOperator(),
+			new LessThanEqualOperator(),
+			new NegationOperator(),
+			new AndOperator(),
+			new OrOperator(),
+			new XorOperator(),
+			new AddOperator(),
+			new MinusOperator(),
+			new MultiplicationOperator(),
+			new DivisionOperator(),
+			new RemainderDivisionOperator()
+		].forEach((operatorLogic) => {
+			this._operatorLogicMap.set(operatorLogic.getToken(), operatorLogic);
+		});
+	}
+
+	get = (operator: string): OperatorLogicNode | undefined => {
+		return this._operatorLogicMap.get(operator);
+	};
+
+	exists = (operator: string): boolean => {
+		return this.get(operator) !== undefined;
+	};
+}
+
+export const operatorMap = new OperatorMap();

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/OrOperator.ts

@@ -0,0 +1,22 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+import { btreeUtils } from "$lib/components/dialog_manager/behavior_tree/core/BTreeUtils";
+
+export class OrOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		nodeArgs.initState.operandStack.push(
+			String(btreeUtils.isTrue(currentOperands[0]) || btreeUtils.isTrue(currentOperands[1]))
+		);
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return "||";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/XorOperator.ts

@@ -0,0 +1,24 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+import { btreeUtils } from "$lib/components/dialog_manager/behavior_tree/core/BTreeUtils";
+
+export class XorOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		// todo: evaluate possible weird cases when doing number comparisons
+		// ISSUE #88 https://github.com/TurnipXenon/pineapple/issues/88
+		const A = btreeUtils.isTrue(currentOperands[0]);
+		const B = btreeUtils.isTrue(currentOperands[1]);
+		nodeArgs.initState.operandStack.push(String(!((A && B) || A || B)));
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return "^";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/arithmetic/DivisionOperator.ts

@@ -0,0 +1,23 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+
+export class DivisionOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		// todo: Add division protection
+		// ISSUE #96 https://github.com/TurnipXenon/pineapple/issues/96
+		nodeArgs.initState.operandStack.push(
+			String(Number(currentOperands[0]) / Number(currentOperands[1]))
+		);
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return "/";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/arithmetic/MinusOperator.ts

@@ -0,0 +1,23 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+
+export class MinusOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		// todo: evaluate possible weird cases when doing number comparisons
+		// ISSUE #88 https://github.com/TurnipXenon/pineapple/issues/88
+		nodeArgs.initState.operandStack.push(
+			String(Number(currentOperands[0]) - Number(currentOperands[1]))
+		);
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return "-";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/arithmetic/MultiplicationOperator.ts

@@ -0,0 +1,21 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+
+export class MultiplicationOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		nodeArgs.initState.operandStack.push(
+			String(Number(currentOperands[0]) * Number(currentOperands[1]))
+		);
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return "*";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/arithmetic/PlusOperator.ts

@@ -0,0 +1,23 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+
+export class AddOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		// todo: evaluate possible weird cases when doing number comparisons
+		// ISSUE #88 https://github.com/TurnipXenon/pineapple/issues/88
+		nodeArgs.initState.operandStack.push(
+			String(Number(currentOperands[0]) + Number(currentOperands[1]))
+		);
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return "+";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/expression/operators/arithmetic/RemainderDivisionOperator.ts

@@ -0,0 +1,23 @@
+import {
+	OperatorLogicNode,
+	OperatorType
+} from "$lib/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode";
+import type { ExpressionArguments } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionArguments";
+
+export class RemainderDivisionOperator extends OperatorLogicNode {
+	doOperation = (currentOperands: string[], nodeArgs: ExpressionArguments) => {
+		// todo: Add division protection
+		// ISSUE #96 https://github.com/TurnipXenon/pineapple/issues/96
+		nodeArgs.initState.operandStack.push(
+			String(Number(currentOperands[0]) % Number(currentOperands[1]))
+		);
+	};
+
+	getOperatorType = (): OperatorType => {
+		return OperatorType.Binary;
+	};
+
+	getToken = (): string => {
+		return "%";
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/line_core/LineBehaviorNode.ts

@@ -0,0 +1,5 @@
+import type { BehaviorNode } from "$lib/components/dialog_manager/behavior_tree/core/BehaviorNode";
+import type { LineNodeArguments } from "$lib/components/dialog_manager/behavior_tree/line_core/LineNodeArguments";
+import type { LineBehaviorResult } from "$lib/components/dialog_manager/behavior_tree/line_core/LineBehaviorResult";
+
+export type LineBehaviorNode = BehaviorNode<LineNodeArguments, LineBehaviorResult>;

package/src/lib/components/dialog_manager/behavior_tree/line_core/LineBehaviorResult.ts

@@ -0,0 +1,7 @@
+import type { BehaviorState } from "$lib/components/dialog_manager/behavior_tree/line_processors/BehaviorState";
+import type { BaseBehaviorResult } from "$lib/components/dialog_manager/behavior_tree/core/BaseBehaviorResult";
+
+export interface LineBehaviorResult extends BaseBehaviorResult {
+	renderedLine: string;
+	nextState: BehaviorState;
+}

package/src/lib/components/dialog_manager/behavior_tree/line_core/LineNodeArguments.ts

@@ -0,0 +1,7 @@
+import type { BehaviorState } from "$lib/components/dialog_manager/behavior_tree/line_processors/BehaviorState";
+
+export interface LineNodeArguments {
+	line: string;
+	lineIndex: number;
+	initState: BehaviorState;
+}

package/src/lib/components/dialog_manager/behavior_tree/line_core/LineSelectorNode.ts

@@ -0,0 +1,20 @@
+import { SelectorNode } from "$lib/components/dialog_manager/behavior_tree/core/SelectorNode";
+import type { LineNodeArguments } from "$lib/components/dialog_manager/behavior_tree/line_core/LineNodeArguments";
+import type { LineBehaviorResult } from "$lib/components/dialog_manager/behavior_tree/line_core/LineBehaviorResult";
+import { BehaviorState } from "$lib/components/dialog_manager/behavior_tree/line_processors/BehaviorState";
+import { BehaviorStatus } from "$lib/components/dialog_manager/behavior_tree/core/BehaviorStatus";
+import type { LineBehaviorNode } from "$lib/components/dialog_manager/behavior_tree/line_core/LineBehaviorNode";
+
+export class LineSelectorNode extends SelectorNode<LineNodeArguments, LineBehaviorResult> {
+	constructor(nodeList: LineBehaviorNode[]) {
+		super(nodeList);
+	}
+
+	defaultResult = (): LineBehaviorResult => {
+		return {
+			nextState: new BehaviorState(),
+			renderedLine: "",
+			status: BehaviorStatus.Failure
+		};
+	};
+}

package/src/lib/components/dialog_manager/behavior_tree/line_processors/BehaviorState.ts

@@ -0,0 +1,6 @@
+import { IfMode } from "$lib/components/dialog_manager/behavior_tree/line_processors/IfMode";
+
+export class BehaviorState {
+	ifModeStack: IfMode[] = [IfMode.Search];
+	ignoreJumps = false;
+}

package/src/lib/components/dialog_manager/behavior_tree/line_processors/ElseIfNode.ts

@@ -0,0 +1,59 @@
+import type { LineNodeArguments } from "$lib/components/dialog_manager/behavior_tree/line_core/LineNodeArguments";
+import type { LineBehaviorResult } from "$lib/components/dialog_manager/behavior_tree/line_core/LineBehaviorResult";
+import { BehaviorStatus } from "$lib/components/dialog_manager/behavior_tree/core/BehaviorStatus";
+import { btreeUtils } from "$lib/components/dialog_manager/behavior_tree/core/BTreeUtils";
+import { IfMode } from "$lib/components/dialog_manager/behavior_tree/line_processors/IfMode";
+import type { LineBehaviorNode } from "$lib/components/dialog_manager/behavior_tree/line_core/LineBehaviorNode";
+import { expressionEvaluator } from "$lib/components/dialog_manager/behavior_tree/expression/ExpressionEvaluator";
+
+/**
+ * ElseIfNode is a leaf node that returns:
+ * - Success if it is an elseif node, and updates the behaviorState
+ * - Failure if it is not an elseif node
+ */
+export class ElseIfNode implements LineBehaviorNode {
+	process(nodeArgs: LineNodeArguments): LineBehaviorResult {
+		if (!nodeArgs.line.startsWith("<<elseif")) {
+			return {
+				nextState: nodeArgs.initState,
+				renderedLine: "",
+				status: BehaviorStatus.Failure
+			};
+		}
+
+		const currentIfMode = btreeUtils.peek(nodeArgs.initState.ifModeStack);
+		switch (currentIfMode) {
+			case IfMode.Search:
+				// probably a syntax error
+				console.error("Syntax error found in yarn dialog!");
+				console.error(`Check out line ${nodeArgs.lineIndex + 1}: ${nodeArgs.line}`);
+				break;
+			case IfMode.Ignore:
+				// just move on
+				break;
+			case IfMode.Evaluated:
+				// previous case was true therefore ignore
+				nodeArgs.initState.ifModeStack.pop();
+				nodeArgs.initState.ifModeStack.push(IfMode.Ignore);
+				break;
+			case IfMode.EvaluateNext:
+				// since all the previous evaluations were false,
+				// let's try evaluating this like the if statement
+				if (expressionEvaluator.evaluate(nodeArgs.line, "<<elseif")) {
+					nodeArgs.initState.ifModeStack.pop();
+					nodeArgs.initState.ifModeStack.push(IfMode.Evaluated);
+				} // else: retain the EvaluateNext status
+				break;
+			default:
+				console.error("Unimplemented if state!");
+				console.error(`Check out line ${nodeArgs.lineIndex + 1}: ${nodeArgs.line}`);
+				break;
+		}
+
+		return {
+			nextState: nodeArgs.initState,
+			renderedLine: "",
+			status: BehaviorStatus.Success
+		};
+	}
+}