@turnipxenon/pineapple 2.1.1 → 2.3.1

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/GreaterThanOperator.js

@@ -0,0 +1,12 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+export class GreaterThanOperator extends OperatorLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        nodeArgs.initState.operandStack.push(String(Number(currentOperands[0]) > Number(currentOperands[1])));
+    };
+    getOperatorType = () => {
+        return OperatorType.Binary;
+    };
+    getToken = () => {
+        return ">";
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/InequalityOperator.d.ts

@@ -0,0 +1,7 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+import type { ExpressionArguments } from "../ExpressionArguments";
+export declare class InequalityOperator extends OperatorLogicNode {
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getOperatorType: () => OperatorType;
+    getToken: () => string;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/InequalityOperator.js

@@ -0,0 +1,12 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+export class InequalityOperator extends OperatorLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        nodeArgs.initState.operandStack.push(String(currentOperands[0] !== currentOperands[1]));
+    };
+    getOperatorType = () => {
+        return OperatorType.Binary;
+    };
+    getToken = () => {
+        return "!=";
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/LessThanEqualOperator.d.ts

@@ -0,0 +1,7 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+import type { ExpressionArguments } from "../ExpressionArguments";
+export declare class LessThanEqualOperator extends OperatorLogicNode {
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getOperatorType: () => OperatorType;
+    getToken: () => string;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/LessThanEqualOperator.js

@@ -0,0 +1,12 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+export class LessThanEqualOperator extends OperatorLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        nodeArgs.initState.operandStack.push(String(Number(currentOperands[0]) <= Number(currentOperands[1])));
+    };
+    getOperatorType = () => {
+        return OperatorType.Binary;
+    };
+    getToken = () => {
+        return "<=";
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/LessThanOperator.d.ts

@@ -0,0 +1,7 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+import type { ExpressionArguments } from "../ExpressionArguments";
+export declare class LessThanOperator extends OperatorLogicNode {
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getOperatorType: () => OperatorType;
+    getToken: () => string;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/LessThanOperator.js

@@ -0,0 +1,12 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+export class LessThanOperator extends OperatorLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        nodeArgs.initState.operandStack.push(String(Number(currentOperands[0]) < Number(currentOperands[1])));
+    };
+    getOperatorType = () => {
+        return OperatorType.Binary;
+    };
+    getToken = () => {
+        return "<";
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/NegationOperator.d.ts

@@ -0,0 +1,7 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+import type { ExpressionArguments } from "../ExpressionArguments";
+export declare class NegationOperator extends OperatorLogicNode {
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getOperatorType: () => OperatorType;
+    getToken: () => string;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/NegationOperator.js

@@ -0,0 +1,13 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+import { btreeUtils } from "../../core/BTreeUtils";
+export class NegationOperator extends OperatorLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        nodeArgs.initState.operandStack.push(String(!btreeUtils.isTrue(currentOperands[0])));
+    };
+    getOperatorType = () => {
+        return OperatorType.Unary;
+    };
+    getToken = () => {
+        return "!";
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode.d.ts

@@ -0,0 +1,17 @@
+import type { ExpressionBehaviorNode } from "../ExpressionBehaviorNode";
+import type { ExpressionArguments } from "../ExpressionArguments";
+import type { ExpressionResult } from "../ExpressionResult";
+export declare enum OperatorType {
+    Unary = 0,
+    Binary = 1
+}
+/**
+ * a leaf node that will always run success
+ * do the processing outside comparing with getToken
+ */
+export declare abstract class OperatorLogicNode implements ExpressionBehaviorNode {
+    abstract getToken: () => string;
+    abstract getOperatorType: () => OperatorType;
+    abstract doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    process(nodeArgs: ExpressionArguments): ExpressionResult;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/OperatorLogicNode.js

@@ -0,0 +1,32 @@
+import { BehaviorStatus } from "../../core/BehaviorStatus";
+export var OperatorType;
+(function (OperatorType) {
+    OperatorType[OperatorType["Unary"] = 0] = "Unary";
+    OperatorType[OperatorType["Binary"] = 1] = "Binary";
+})(OperatorType || (OperatorType = {}));
+/**
+ * a leaf node that will always run success
+ * do the processing outside comparing with getToken
+ */
+export class OperatorLogicNode {
+    process(nodeArgs) {
+        const currentOperands = [];
+        switch (this.getOperatorType()) {
+            case OperatorType.Unary:
+                currentOperands.unshift(nodeArgs.initState.operandStack.pop());
+                break;
+            case OperatorType.Binary:
+                currentOperands.unshift(nodeArgs.initState.operandStack.pop());
+                currentOperands.unshift(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/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/OperatorMap.d.ts

@@ -0,0 +1,9 @@
+import type { OperatorLogicNode } from "./OperatorLogicNode";
+declare class OperatorMap {
+    _operatorLogicMap: Map<string, OperatorLogicNode>;
+    constructor();
+    get: (operator: string) => OperatorLogicNode | undefined;
+    exists: (operator: string) => boolean;
+}
+export declare const operatorMap: OperatorMap;
+export {};

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/OperatorMap.js

@@ -0,0 +1,47 @@
+import { EqualityOperator } from "./EqualityOperator";
+import { InequalityOperator } from "./InequalityOperator";
+import { GreaterThanOperator } from "./GreaterThanOperator";
+import { GreaterThanEqualOperator } from "./GreaterThanEqualOperator";
+import { LessThanOperator } from "./LessThanOperator";
+import { LessThanEqualOperator } from "./LessThanEqualOperator";
+import { NegationOperator } from "./NegationOperator";
+import { AndOperator } from "./AndOperator";
+import { OrOperator } from "./OrOperator";
+import { XorOperator } from "./XorOperator";
+import { AddOperator } from "./arithmetic/PlusOperator";
+import { MinusOperator } from "./arithmetic/MinusOperator";
+import { MultiplicationOperator } from "./arithmetic/MultiplicationOperator";
+import { DivisionOperator } from "./arithmetic/DivisionOperator";
+import { RemainderDivisionOperator } from "./arithmetic/RemainderDivisionOperator";
+class OperatorMap {
+    _operatorLogicMap = 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) => {
+        return this._operatorLogicMap.get(operator);
+    };
+    exists = (operator) => {
+        return this.get(operator) !== undefined;
+    };
+}
+export const operatorMap = new OperatorMap();

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/OrOperator.d.ts

@@ -0,0 +1,7 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+import type { ExpressionArguments } from "../ExpressionArguments";
+export declare class OrOperator extends OperatorLogicNode {
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getOperatorType: () => OperatorType;
+    getToken: () => string;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/OrOperator.js

@@ -0,0 +1,13 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+import { btreeUtils } from "../../core/BTreeUtils";
+export class OrOperator extends OperatorLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        nodeArgs.initState.operandStack.push(String(btreeUtils.isTrue(currentOperands[0]) || btreeUtils.isTrue(currentOperands[1])));
+    };
+    getOperatorType = () => {
+        return OperatorType.Binary;
+    };
+    getToken = () => {
+        return "||";
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/XorOperator.d.ts

@@ -0,0 +1,7 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+import type { ExpressionArguments } from "../ExpressionArguments";
+export declare class XorOperator extends OperatorLogicNode {
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getOperatorType: () => OperatorType;
+    getToken: () => string;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/XorOperator.js

@@ -0,0 +1,17 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+import { btreeUtils } from "../../core/BTreeUtils";
+export class XorOperator extends OperatorLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        // 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 = () => {
+        return OperatorType.Binary;
+    };
+    getToken = () => {
+        return "^";
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/arithmetic/DivisionOperator.d.ts

@@ -0,0 +1,7 @@
+import { OperatorLogicNode, OperatorType } from "../OperatorLogicNode";
+import type { ExpressionArguments } from "../../ExpressionArguments";
+export declare class DivisionOperator extends OperatorLogicNode {
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getOperatorType: () => OperatorType;
+    getToken: () => string;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/arithmetic/DivisionOperator.js

@@ -0,0 +1,14 @@
+import { OperatorLogicNode, OperatorType } from "../OperatorLogicNode";
+export class DivisionOperator extends OperatorLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        // 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 = () => {
+        return OperatorType.Binary;
+    };
+    getToken = () => {
+        return "/";
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/arithmetic/MinusOperator.d.ts

@@ -0,0 +1,7 @@
+import { OperatorLogicNode, OperatorType } from "../OperatorLogicNode";
+import type { ExpressionArguments } from "../../ExpressionArguments";
+export declare class MinusOperator extends OperatorLogicNode {
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getOperatorType: () => OperatorType;
+    getToken: () => string;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/arithmetic/MinusOperator.js

@@ -0,0 +1,14 @@
+import { OperatorLogicNode, OperatorType } from "../OperatorLogicNode";
+export class MinusOperator extends OperatorLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        // 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 = () => {
+        return OperatorType.Binary;
+    };
+    getToken = () => {
+        return "-";
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/arithmetic/MultiplicationOperator.d.ts

@@ -0,0 +1,7 @@
+import { OperatorLogicNode, OperatorType } from "../OperatorLogicNode";
+import type { ExpressionArguments } from "../../ExpressionArguments";
+export declare class MultiplicationOperator extends OperatorLogicNode {
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getOperatorType: () => OperatorType;
+    getToken: () => string;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/arithmetic/MultiplicationOperator.js

@@ -0,0 +1,12 @@
+import { OperatorLogicNode, OperatorType } from "../OperatorLogicNode";
+export class MultiplicationOperator extends OperatorLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        nodeArgs.initState.operandStack.push(String(Number(currentOperands[0]) * Number(currentOperands[1])));
+    };
+    getOperatorType = () => {
+        return OperatorType.Binary;
+    };
+    getToken = () => {
+        return "*";
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/arithmetic/PlusOperator.d.ts

@@ -0,0 +1,7 @@
+import { OperatorLogicNode, OperatorType } from "../OperatorLogicNode";
+import type { ExpressionArguments } from "../../ExpressionArguments";
+export declare class AddOperator extends OperatorLogicNode {
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getOperatorType: () => OperatorType;
+    getToken: () => string;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/arithmetic/PlusOperator.js

@@ -0,0 +1,14 @@
+import { OperatorLogicNode, OperatorType } from "../OperatorLogicNode";
+export class AddOperator extends OperatorLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        // 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 = () => {
+        return OperatorType.Binary;
+    };
+    getToken = () => {
+        return "+";
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/arithmetic/RemainderDivisionOperator.d.ts

@@ -0,0 +1,7 @@
+import { OperatorLogicNode, OperatorType } from "../OperatorLogicNode";
+import type { ExpressionArguments } from "../../ExpressionArguments";
+export declare class RemainderDivisionOperator extends OperatorLogicNode {
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getOperatorType: () => OperatorType;
+    getToken: () => string;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/expression/operators/arithmetic/RemainderDivisionOperator.js

@@ -0,0 +1,14 @@
+import { OperatorLogicNode, OperatorType } from "../OperatorLogicNode";
+export class RemainderDivisionOperator extends OperatorLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        // 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 = () => {
+        return OperatorType.Binary;
+    };
+    getToken = () => {
+        return "%";
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_core/LineBehaviorNode.d.ts

@@ -0,0 +1,4 @@
+import type { BehaviorNode } from "../core/BehaviorNode";
+import type { LineNodeArguments } from "./LineNodeArguments";
+import type { LineBehaviorResult } from "./LineBehaviorResult";
+export type LineBehaviorNode = BehaviorNode<LineNodeArguments, LineBehaviorResult>;

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_core/LineBehaviorNode.js

@@ -0,0 +1 @@
+export {};

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_core/LineBehaviorResult.d.ts

@@ -0,0 +1,6 @@
+import type { BehaviorState } from "../line_processors/BehaviorState";
+import type { BaseBehaviorResult } from "../core/BaseBehaviorResult";
+export interface LineBehaviorResult extends BaseBehaviorResult {
+    renderedLine: string;
+    nextState: BehaviorState;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_core/LineBehaviorResult.js

@@ -0,0 +1 @@
+export {};

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_core/LineNodeArguments.d.ts

@@ -0,0 +1,6 @@
+import type { BehaviorState } from "../line_processors/BehaviorState";
+export interface LineNodeArguments {
+    line: string;
+    lineIndex: number;
+    initState: BehaviorState;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_core/LineNodeArguments.js

@@ -0,0 +1 @@
+export {};

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_core/LineSelectorNode.d.ts

@@ -0,0 +1,8 @@
+import { SelectorNode } from "../core/SelectorNode";
+import type { LineNodeArguments } from "./LineNodeArguments";
+import type { LineBehaviorResult } from "./LineBehaviorResult";
+import type { LineBehaviorNode } from "./LineBehaviorNode";
+export declare class LineSelectorNode extends SelectorNode<LineNodeArguments, LineBehaviorResult> {
+    constructor(nodeList: LineBehaviorNode[]);
+    defaultResult: () => LineBehaviorResult;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_core/LineSelectorNode.js

@@ -0,0 +1,15 @@
+import { SelectorNode } from "../core/SelectorNode";
+import { BehaviorState } from "../line_processors/BehaviorState";
+import { BehaviorStatus } from "../core/BehaviorStatus";
+export class LineSelectorNode extends SelectorNode {
+    constructor(nodeList) {
+        super(nodeList);
+    }
+    defaultResult = () => {
+        return {
+            nextState: new BehaviorState(),
+            renderedLine: "",
+            status: BehaviorStatus.Failure
+        };
+    };
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_processors/BehaviorState.d.ts

@@ -0,0 +1,5 @@
+import { IfMode } from "./IfMode";
+export declare class BehaviorState {
+    ifModeStack: IfMode[];
+    ignoreJumps: boolean;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_processors/BehaviorState.js

@@ -0,0 +1,5 @@
+import { IfMode } from "./IfMode";
+export class BehaviorState {
+    ifModeStack = [IfMode.Search];
+    ignoreJumps = false;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_processors/ElseIfNode.d.ts

@@ -0,0 +1,11 @@
+import type { LineNodeArguments } from "../line_core/LineNodeArguments";
+import type { LineBehaviorResult } from "../line_core/LineBehaviorResult";
+import type { LineBehaviorNode } from "../line_core/LineBehaviorNode";
+/**
+ * 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 declare class ElseIfNode implements LineBehaviorNode {
+    process(nodeArgs: LineNodeArguments): LineBehaviorResult;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_processors/ElseIfNode.js

@@ -0,0 +1,53 @@
+import { BehaviorStatus } from "../core/BehaviorStatus";
+import { btreeUtils } from "../core/BTreeUtils";
+import { IfMode } from "./IfMode";
+import { expressionEvaluator } from "../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 {
+    process(nodeArgs) {
+        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
+        };
+    }
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_processors/ElseNode.d.ts

@@ -0,0 +1,11 @@
+import type { LineNodeArguments } from "../line_core/LineNodeArguments";
+import type { LineBehaviorResult } from "../line_core/LineBehaviorResult";
+import type { LineBehaviorNode } from "../line_core/LineBehaviorNode";
+/**
+ * ElseNode is a leaf node that returns:
+ * - Success if it is an else node, and updates the behaviorState
+ * - Failure if it is not an else node
+ */
+export declare class ElseNode implements LineBehaviorNode {
+    process(nodeArgs: LineNodeArguments): LineBehaviorResult;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_processors/ElseNode.js

@@ -0,0 +1,49 @@
+import { BehaviorStatus } from "../core/BehaviorStatus";
+import { btreeUtils } from "../core/BTreeUtils";
+import { IfMode } from "./IfMode";
+/**
+ * ElseNode is a leaf node that returns:
+ * - Success if it is an else node, and updates the behaviorState
+ * - Failure if it is not an else node
+ */
+export class ElseNode {
+    process(nodeArgs) {
+        if (!nodeArgs.line.startsWith("<<else>>")) {
+            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, now let's do everything inside!
+                nodeArgs.initState.ifModeStack.pop();
+                nodeArgs.initState.ifModeStack.push(IfMode.Evaluated);
+                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
+        };
+    }
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_processors/EndIfNode.d.ts

@@ -0,0 +1,11 @@
+import type { LineNodeArguments } from "../line_core/LineNodeArguments";
+import type { LineBehaviorResult } from "../line_core/LineBehaviorResult";
+import type { LineBehaviorNode } from "../line_core/LineBehaviorNode";
+/**
+ * EndIfNode is a leaf node returns the following results:
+ * - Success: if it is an endif node, and updates the behaviorState
+ * - Failure: if it is not an endif node
+ */
+export declare class EndIfNode implements LineBehaviorNode {
+    process(nodeArgs: LineNodeArguments): LineBehaviorResult;
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_processors/EndIfNode.js

@@ -0,0 +1,23 @@
+import { BehaviorStatus } from "../core/BehaviorStatus";
+/**
+ * EndIfNode is a leaf node returns the following results:
+ * - Success: if it is an endif node, and updates the behaviorState
+ * - Failure: if it is not an endif node
+ */
+export class EndIfNode {
+    process(nodeArgs) {
+        if (!nodeArgs.line.startsWith("<<endif>>")) {
+            return {
+                nextState: nodeArgs.initState,
+                renderedLine: "",
+                status: BehaviorStatus.Failure
+            };
+        }
+        nodeArgs.initState.ifModeStack.pop();
+        return {
+            nextState: nodeArgs.initState,
+            renderedLine: "",
+            status: BehaviorStatus.Success
+        };
+    }
+}

package/.svelte-kit/__package__/components/dialog_manager/behavior_tree/line_processors/IfMode.d.ts

@@ -0,0 +1,6 @@
+export declare enum IfMode {
+    Search = 0,// search for the next if statement
+    Ignore = 1,// ignore everything until we find endif
+    Evaluated = 2,// do normal search until we find elseif, else, or endif, then ignore
+    EvaluateNext = 3
+}