@turnipxenon/pineapple 2.2.1 → 2.3.1

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

@@ -0,0 +1,220 @@
+import { browser } from "$app/environment";
+import { OperatorNode } from "./OperatorNode";
+import { OperandNode } from "./OperandNode";
+import { ExpressionSelectorNode } from "./ExpressionSelectorNode";
+import { btreeUtils } from "../core/BTreeUtils";
+import { CommandExpressionNode } from "./commands/CommandExpressionNode";
+class ExpressionEvaluator {
+    evaluatorTree = new ExpressionSelectorNode([
+        new OperatorNode(),
+        new CommandExpressionNode(),
+        new OperandNode()
+    ]);
+    // from https://stackoverflow.com/a/175787/17836168
+    isNumeric = (str) => {
+        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) => {
+        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, prefix) => {
+        if (!browser) {
+            return []; // do not process when not in browser
+        }
+        // tokenize first!
+        const infixTokens = [];
+        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 = [];
+        const stack = [];
+        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(stack.pop());
+                }
+                stack.pop(); // remove "("
+                if (stack.length > 0 && btreeUtils.peek(stack).startsWith("#")) {
+                    postfixTokens.push(stack.pop());
+                }
+            }
+            else if (![-1, 5].includes(this.getPrecedence(token))) {
+                while (stack.length > 0 &&
+                    this.getPrecedence(btreeUtils.peek(stack)) >= this.getPrecedence(token)) {
+                    postfixTokens.push(stack.pop());
+                }
+                stack.push(token);
+            }
+            else {
+                // operand
+                postfixTokens.push(token);
+            }
+        });
+        // pop all remaining elements from the stack
+        while (stack.length > 0) {
+            postfixTokens.push(stack.pop());
+        }
+        // console.log("Finished postfix", postfixTokens);
+        // endregion infix to postfix
+        // evaluate
+        let currentState = {
+            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, prefix) => {
+        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/dist/components/dialog_manager/behavior_tree/expression/ExpressionResult.d.ts

@@ -0,0 +1,5 @@
+import type { BaseBehaviorResult } from "../core/BaseBehaviorResult";
+import type { ExpressionState } from "./ExpressionState";
+export interface ExpressionResult extends BaseBehaviorResult {
+    nextState: ExpressionState;
+}

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

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

package/dist/components/dialog_manager/behavior_tree/expression/ExpressionSelectorNode.d.ts

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

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

@@ -0,0 +1,15 @@
+import { SelectorNode } from "../core/SelectorNode";
+import { BehaviorStatus } from "../core/BehaviorStatus";
+export class ExpressionSelectorNode extends SelectorNode {
+    constructor(nodeList) {
+        super(nodeList);
+    }
+    defaultResult = () => {
+        return {
+            nextState: {
+                operandStack: []
+            },
+            status: BehaviorStatus.Failure
+        };
+    };
+}

package/dist/components/dialog_manager/behavior_tree/expression/ExpressionState.d.ts

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

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

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

package/dist/components/dialog_manager/behavior_tree/expression/OperandNode.d.ts

@@ -0,0 +1,10 @@
+import type { ExpressionBehaviorNode } from "./ExpressionBehaviorNode";
+import type { ExpressionArguments } from "./ExpressionArguments";
+import type { ExpressionResult } from "./ExpressionResult";
+/**
+ * Puts the token as an operand
+ * It's always successful
+ */
+export declare class OperandNode implements ExpressionBehaviorNode {
+    process(nodeArgs: ExpressionArguments): ExpressionResult;
+}

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

@@ -0,0 +1,15 @@
+import { BehaviorStatus } from "../core/BehaviorStatus";
+import { btreeUtils } from "../core/BTreeUtils";
+/**
+ * Puts the token as an operand
+ * It's always successful
+ */
+export class OperandNode {
+    process(nodeArgs) {
+        nodeArgs.initState.operandStack.push(btreeUtils.simplifyToken(nodeArgs.token));
+        return {
+            nextState: nodeArgs.initState,
+            status: BehaviorStatus.Success
+        };
+    }
+}

package/dist/components/dialog_manager/behavior_tree/expression/OperatorNode.d.ts

@@ -0,0 +1,11 @@
+import type { ExpressionBehaviorNode } from "./ExpressionBehaviorNode";
+import type { ExpressionArguments } from "./ExpressionArguments";
+import type { ExpressionResult } from "./ExpressionResult";
+/**
+ * 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 declare class OperatorNode implements ExpressionBehaviorNode {
+    process(nodeArgs: ExpressionArguments): ExpressionResult;
+}

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;
+}