@turnipxenon/pineapple 1.1.2

package/dist/components/dialog_manager/behavior_tree/expression/OperatorNode.js

@@ -0,0 +1,30 @@
+import { BehaviorStatus } from "../core/BehaviorStatus";
+import { operatorMap } from "./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 {
+    process(nodeArgs) {
+        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/dist/components/dialog_manager/behavior_tree/expression/commands/CommandExpressionNode.d.ts

@@ -0,0 +1,6 @@
+import type { ExpressionBehaviorNode } from "../ExpressionBehaviorNode";
+import type { ExpressionArguments } from "../ExpressionArguments";
+import type { ExpressionResult } from "../ExpressionResult";
+export declare class CommandExpressionNode implements ExpressionBehaviorNode {
+    process(nodeArgs: ExpressionArguments): ExpressionResult;
+}

package/dist/components/dialog_manager/behavior_tree/expression/commands/CommandExpressionNode.js

@@ -0,0 +1,21 @@
+import { commandMap } from "./CommandMap";
+import { BehaviorStatus } from "../../core/BehaviorStatus";
+export class CommandExpressionNode {
+    process(nodeArgs) {
+        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/dist/components/dialog_manager/behavior_tree/expression/commands/CommandLogicNode.d.ts

@@ -0,0 +1,9 @@
+import type { ExpressionBehaviorNode } from "../ExpressionBehaviorNode";
+import type { ExpressionArguments } from "../ExpressionArguments";
+import type { ExpressionResult } from "../ExpressionResult";
+export declare abstract class CommandLogicNode implements ExpressionBehaviorNode {
+    abstract getToken: () => string;
+    abstract getArgumentCount: () => number;
+    abstract doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    process(nodeArgs: ExpressionArguments): ExpressionResult;
+}

package/dist/components/dialog_manager/behavior_tree/expression/commands/CommandLogicNode.js

@@ -0,0 +1,19 @@
+import { BehaviorStatus } from "../../core/BehaviorStatus";
+export class CommandLogicNode {
+    process(nodeArgs) {
+        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/dist/components/dialog_manager/behavior_tree/expression/commands/CommandMap.d.ts

@@ -0,0 +1,9 @@
+import type { CommandLogicNode } from "./CommandLogicNode";
+declare class CommandMap {
+    _commandMap: Map<string, CommandLogicNode>;
+    constructor();
+    get: (command: string) => CommandLogicNode | undefined;
+    exists: (command: string) => boolean;
+}
+export declare const commandMap: CommandMap;
+export {};

package/dist/components/dialog_manager/behavior_tree/expression/commands/CommandMap.js

@@ -0,0 +1,18 @@
+import { RandomRangeCommand } from "./RandomRangeCommand";
+import { VisitedCountCommand } from "./VisitedCountCommand";
+import { VisitedCommand } from "./VisitedCommand";
+class CommandMap {
+    _commandMap = new Map();
+    constructor() {
+        [new RandomRangeCommand(), new VisitedCountCommand(), new VisitedCommand()].forEach((commandLogic) => {
+            this._commandMap.set(commandLogic.getToken(), commandLogic);
+        });
+    }
+    get = (command) => {
+        return this._commandMap.get(command);
+    };
+    exists = (command) => {
+        return this.get(command) !== undefined;
+    };
+}
+export const commandMap = new CommandMap();

package/dist/components/dialog_manager/behavior_tree/expression/commands/RandomRangeCommand.d.ts

@@ -0,0 +1,15 @@
+import { CommandLogicNode } from "./CommandLogicNode";
+import type { ExpressionArguments } from "../ExpressionArguments";
+/**
+ * Used for command like
+ * random_range(1, 2);
+ */
+export declare 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;
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getArgumentCount: () => number;
+    getToken: () => string;
+}

package/dist/components/dialog_manager/behavior_tree/expression/commands/RandomRangeCommand.js

@@ -0,0 +1,24 @@
+import { CommandLogicNode } from "./CommandLogicNode";
+/**
+ * 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, max) => {
+        min = Math.ceil(min);
+        max = Math.floor(max);
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    };
+    doOperation = (currentOperands, nodeArgs) => {
+        nodeArgs.initState.operandStack.push(String(this.getRandomInt(Number(currentOperands[0]), Number(currentOperands[1]))));
+    };
+    getArgumentCount = () => {
+        return 2;
+    };
+    getToken = () => {
+        return "#random_range";
+    };
+}

package/dist/components/dialog_manager/behavior_tree/expression/commands/VisitedCommand.d.ts

@@ -0,0 +1,20 @@
+import { CommandLogicNode } from "./CommandLogicNode";
+import type { ExpressionArguments } from "../ExpressionArguments";
+import { VisitedCountCommand } from "./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 declare class VisitedCommand extends CommandLogicNode {
+    visitedCountCommand: VisitedCountCommand;
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getArgumentCount: () => number;
+    getToken: () => string;
+}

package/dist/components/dialog_manager/behavior_tree/expression/commands/VisitedCommand.js

@@ -0,0 +1,32 @@
+import { CommandLogicNode } from "./CommandLogicNode";
+import { VisitedCountCommand } from "./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, nodeArgs) => {
+        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 = () => {
+        return 0; // let the child work; this is only a decorator
+    };
+    getToken = () => {
+        return "#visited";
+    };
+}

package/dist/components/dialog_manager/behavior_tree/expression/commands/VisitedCountCommand.d.ts

@@ -0,0 +1,13 @@
+import { CommandLogicNode } from "./CommandLogicNode";
+import type { ExpressionArguments } from "../ExpressionArguments";
+/**
+ * Used for command like
+ * visited_count("node name here");
+ *
+ * Pushed a number in the operand stack
+ */
+export declare class VisitedCountCommand extends CommandLogicNode {
+    doOperation: (currentOperands: string[], nodeArgs: ExpressionArguments) => void;
+    getArgumentCount: () => number;
+    getToken: () => string;
+}

package/dist/components/dialog_manager/behavior_tree/expression/commands/VisitedCountCommand.js

@@ -0,0 +1,25 @@
+import { CommandLogicNode } from "./CommandLogicNode";
+import { dialogVariableStore } from "../../../DialogManagerStore";
+/**
+ * Used for command like
+ * visited_count("node name here");
+ *
+ * Pushed a number in the operand stack
+ */
+export class VisitedCountCommand extends CommandLogicNode {
+    doOperation = (currentOperands, nodeArgs) => {
+        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 = () => {
+        return 1;
+    };
+    getToken = () => {
+        return "#visited_count";
+    };
+}

package/dist/components/dialog_manager/behavior_tree/expression/operators/AndOperator.d.ts

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

package/dist/components/dialog_manager/behavior_tree/expression/operators/AndOperator.js

@@ -0,0 +1,15 @@
+import { OperatorLogicNode, OperatorType } from "./OperatorLogicNode";
+import { btreeUtils } from "../../core/BTreeUtils";
+export class AndOperator 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(btreeUtils.isTrue(currentOperands[0]) && btreeUtils.isTrue(currentOperands[1])));
+    };
+    getOperatorType = () => {
+        return OperatorType.Binary;
+    };
+    getToken = () => {
+        return "&&";
+    };
+}

package/dist/components/dialog_manager/behavior_tree/expression/operators/EqualityOperator.d.ts

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

package/dist/components/dialog_manager/behavior_tree/expression/operators/EqualityOperator.js

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

package/dist/components/dialog_manager/behavior_tree/expression/operators/GreaterThanEqualOperator.d.ts

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

package/dist/components/dialog_manager/behavior_tree/expression/operators/GreaterThanEqualOperator.js

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

package/dist/components/dialog_manager/behavior_tree/expression/operators/GreaterThanOperator.d.ts

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

package/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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;
+}