@turnipxenon/pineapple 1.1.2

package/dist/components/dialog_manager/DialogManagerStore.d.ts

@@ -0,0 +1,41 @@
+/**
+ * DialogManagerStore is for variables that will be used as a Svelte store
+ * or is saved in local storage
+ */
+/// <reference types="svelte" />
+import type { DialogMapStore } from "../../types/pineapple_fiber/DialogVariableStore";
+import type { DialogDetail } from "../../types/pineapple_fiber/DialogDetail";
+import { DialogManager } from "./DialogManager";
+/**
+ * Enables the dialogue overlay
+ *
+ * @example
+ * When updating to false, remember to restore the value to true, our default value, onDestroy.
+ * Avoid async to prevent weird flashes of updates!
+ * ```
+ * import {enableDialogueOverlay} from "../../store.ts";
+ * enableDialogueOverlay.update(() => false);
+ *
+ * onDestroy(() => {
+ *     enableDialogueOverlay.update(() =>  true);
+ * });
+ * ```
+ */
+export declare const enableDialogueOverlay: import("svelte/store").Writable<boolean>;
+export declare const dialogVariableStore: DialogMapStore;
+export declare const updateRate: number;
+export declare const defaultDialogMessage: DialogDetail[];
+/**
+ * strictly must be declared last! or you might receive a weird error that looks like:
+ *
+ * 2:04:21 AM [vite] Error when evaluating SSR module /src/lib/components/dialog_manager/DialogManagerStore.ts:
+ * |- TypeError: Cannot read properties of undefined (reading '0')
+ *     at <instance_members_initializer> (/src/lib/components/dialog_manager/DialogManager.ts:38:67)
+ *     at new DialogManager (/src/lib/components/dialog_manager/DialogManager.ts:53:14)
+ *     at eval (/src/lib/components/dialog_manager/DialogManagerStore.ts:15:23)
+ *     at async instantiateModule (file:///C:/Users/Pumpkin/Projects/Web/pineapple/node_modules/vite/dist/node/chunks/dep-934dbc7c.js:54360:9)
+ *
+ * what this means is that one member of dialogManager cannot be initialized. in our case, it was the
+ * defaultDialogMessage not yet being initialized
+ */
+export declare const dialogManager: DialogManager;

package/dist/components/dialog_manager/DialogManagerStore.js

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

package/dist/components/dialog_manager/DialogProcessor.d.ts

@@ -0,0 +1,13 @@
+import type { DialogDetail } from "../../types/pineapple_fiber/DialogDetail";
+import { LineSelectorNode } from "./behavior_tree/line_core/LineSelectorNode";
+/**
+ * DialogProcessor processes dialogs
+ */
+export declare class DialogProcessor {
+    processingTree: LineSelectorNode;
+    /**
+     * process the dialog line by line and return a presentable string
+     * @param dialogDetail
+     */
+    processDialog: (dialogDetail: DialogDetail) => string;
+}

package/dist/components/dialog_manager/DialogProcessor.js

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

package/dist/components/dialog_manager/DialogUtils.d.ts

@@ -0,0 +1,5 @@
+declare class _DialogUtils {
+    isNodeVisited: (dialogId: string) => boolean;
+}
+export declare const DialogUtils: _DialogUtils;
+export {};

package/dist/components/dialog_manager/DialogUtils.js

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

package/dist/components/dialog_manager/behavior_tree/core/BTreeUtils.d.ts

@@ -0,0 +1,15 @@
+declare class BTreeUtils {
+    /**
+     * peek the top of a stack object with the assumption it's not an empty stack
+     * todo: add possible protection like an assertion
+     * @param stack
+     * @return top of the stack
+     */
+    peek: <T>(stack: T[]) => T;
+    removeQuotes: (value: string) => string;
+    simplifyToken: (oldToken: string) => string;
+    isTrue: (value: string) => boolean;
+    isFalse: (value: string) => boolean;
+}
+export declare const btreeUtils: BTreeUtils;
+export {};

package/dist/components/dialog_manager/behavior_tree/core/BTreeUtils.js

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

package/dist/components/dialog_manager/behavior_tree/core/BaseBehaviorResult.d.ts

@@ -0,0 +1,4 @@
+import type { BehaviorStatus } from "./BehaviorStatus";
+export interface BaseBehaviorResult {
+    status: BehaviorStatus;
+}

package/dist/components/dialog_manager/behavior_tree/core/BaseBehaviorResult.js

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

package/dist/components/dialog_manager/behavior_tree/core/BehaviorNode.d.ts

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

package/dist/components/dialog_manager/behavior_tree/core/BehaviorNode.js

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

package/dist/components/dialog_manager/behavior_tree/core/BehaviorStatus.d.ts

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

package/dist/components/dialog_manager/behavior_tree/core/BehaviorStatus.js

@@ -0,0 +1,6 @@
+export var BehaviorStatus;
+(function (BehaviorStatus) {
+    BehaviorStatus[BehaviorStatus["Running"] = 0] = "Running";
+    BehaviorStatus[BehaviorStatus["Success"] = 1] = "Success";
+    BehaviorStatus[BehaviorStatus["Failure"] = 2] = "Failure";
+})(BehaviorStatus || (BehaviorStatus = {}));

package/dist/components/dialog_manager/behavior_tree/core/SelectorNode.d.ts

@@ -0,0 +1,12 @@
+import type { BehaviorNode } from "./BehaviorNode";
+import type { BaseBehaviorResult } from "./BaseBehaviorResult";
+/**
+ * Selector is a composite behavior node where it tries to process everything until it
+ * finds a non-failing node
+ */
+export declare abstract class SelectorNode<Argument, Result extends BaseBehaviorResult> implements BehaviorNode<Argument, Result> {
+    nodeList: BehaviorNode<Argument, Result>[];
+    abstract defaultResult: () => Result;
+    protected constructor(nodeList: BehaviorNode<Argument, Result>[]);
+    process(nodeArgs: Argument): Result;
+}

package/dist/components/dialog_manager/behavior_tree/core/SelectorNode.js

@@ -0,0 +1,22 @@
+import { BehaviorStatus } from "./BehaviorStatus";
+/**
+ * Selector is a composite behavior node where it tries to process everything until it
+ * finds a non-failing node
+ */
+export class SelectorNode {
+    nodeList;
+    constructor(nodeList) {
+        this.nodeList = nodeList;
+    }
+    process(nodeArgs) {
+        let finalResult = this.defaultResult();
+        for (const node of this.nodeList) {
+            const currentResult = node.process(nodeArgs);
+            if (currentResult.status !== BehaviorStatus.Failure) {
+                finalResult = currentResult;
+                break;
+            }
+        }
+        return finalResult;
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { ExpressionState } from "./ExpressionState";
+export interface ExpressionArguments {
+    token: string;
+    initState: ExpressionState;
+}

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

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

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

@@ -0,0 +1,4 @@
+import type { BehaviorNode } from "../core/BehaviorNode";
+import type { ExpressionArguments } from "./ExpressionArguments";
+import type { ExpressionResult } from "./ExpressionResult";
+export type ExpressionBehaviorNode = BehaviorNode<ExpressionArguments, ExpressionResult>;

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

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

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

@@ -0,0 +1,15 @@
+import { ExpressionSelectorNode } from "./ExpressionSelectorNode";
+declare class ExpressionEvaluator {
+    evaluatorTree: ExpressionSelectorNode;
+    isNumeric: (str: string) => boolean;
+    getPrecedence: (token: string) => number;
+    evaluateFreeform: (line: string, prefix: string) => string[];
+    /**
+     * evaluates a yarn if or elseif statement
+     * @param line is the current line being evaluated
+     * @param prefix is either "<<if" or "<<elseif"
+     */
+    evaluate: (line: string, prefix: string) => boolean;
+}
+export declare const expressionEvaluator: ExpressionEvaluator;
+export {};

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