Merge pull request #103 from NarraLeaf/dev_nomen

narraleaf-react-0.8.4

Author: helloyork

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.8.4]
+
+### _Feature_
+
+- `Persistent.equals`, `Persistent.notEquals` now support lambda or lambda handler as argument
+- Added `ScriptCtx.$` to get the namespace
+- Added `Script.execute` to execute a script
+
+### Fixed
+
+- Script element is not executed correctly
+
 ## [0.8.3]
 
 ### _Feature_

package.json

@@ -1,6 +1,6 @@
 {
   "name": "narraleaf-react",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "A React visual novel player framework",
   "main": "./dist/main.js",
   "types": "./dist/index.d.ts",

src/game/nlcore/elements/built-in/Gallery.ts

@@ -203,6 +203,7 @@ export class Gallery<Metadata extends Record<string, any>> extends Service<Galle
                 game: ctx.game,
                 liveGame: ctx.liveGame,
                 storable: ctx.storable,
+                $: ctx.$,
             };
             const parsedMetadata = typeof metadata === "function" ? metadata(context) : metadata;
             this.unlocked[name] = parsedMetadata;

src/game/nlcore/elements/condition.ts

@@ -15,6 +15,11 @@ export class Lambda<T = any> {
         return value instanceof Lambda && "handler" in value;
     }
 
+    /**@internal */
+    public static isLambdaHandler(value: any): value is LambdaHandler {
+        return typeof value === "function";
+    }
+
     /**@internal */
     public static from<T>(obj: Lambda<T> | LambdaHandler<T>): Lambda<T> {
         return Lambda.isLambda(obj) ? obj : new Lambda(obj);
@@ -40,11 +45,14 @@ export class Lambda<T = any> {
 
     /**@internal */
     getCtx({ gameState }: { gameState: GameState }): LambdaCtx {
+        const liveGame = gameState.game.getLiveGame();
+        const storable = liveGame.getStorable();
         return {
             gameState,
             game: gameState.game,
-            liveGame: gameState.game.getLiveGame(),
-            storable: gameState.game.getLiveGame().getStorable(),
+            liveGame,
+            storable,
+            $: (namespace: string) => storable.getNamespace(namespace),
         };
     }
 

src/game/nlcore/elements/persistent.ts

@@ -84,23 +84,43 @@ export class Persistent<T extends PersistentContent>
 
     /**
      * Determine whether the values are equal, can be used in {@link Condition}
+     * @example
+     * ```typescript
+     * persis.equals("id", persis.get("player_id"));
+     * 
+     * // or
+     * 
+     * persis.equals("id", (ctx) => ctx.storable.getNamespace("player").get("player_id"));
+     * ```
      */
-    public equals<K extends StringKeyOf<T>>(key: K, value: T[K] | ((value: T[K]) => T[K])): Lambda<boolean> {
-        return new Lambda(({ storable }) => {
-            const namespace = storable.getNamespace<T>(this.namespace);
-            const evaluatedValue = typeof value === "function" ? value(namespace.get<K>(key)) : value;
+    public equals<K extends StringKeyOf<T>>(key: K, value: T[K] | Lambda<T[K]> | LambdaHandler<T[K]>): Lambda<boolean> {
+        return new Lambda((ctx) => {
+            const namespace = ctx.storable.getNamespace<T>(this.namespace);
+            const evaluatedValue = (
+                Lambda.isLambda(value) || Lambda.isLambdaHandler(value)
+            ) ? Lambda.from(value).evaluate(ctx).value : value;
 
             return namespace.equals<K>(key, evaluatedValue);
         });
     }
 
     /**
      * Determine whether the values aren't equal, can be used in {@link Condition}
+     * @example
+     * ```typescript
+     * persis.notEquals("id", persis.get("player_id"));
+     * 
+     * // or
+     * 
+     * persis.notEquals("id", (ctx) => ctx.storable.getNamespace("player").get("player_id"));
+     * ```
      */
-    public notEquals<K extends StringKeyOf<T>>(key: K, value: T[K] | ((value: T[K]) => T[K])): Lambda<boolean> {
-        return new Lambda(({ storable }) => {
-            const namespace = storable.getNamespace<T>(this.namespace);
-            const evaluatedValue = typeof value === "function" ? value(namespace.get<K>(key)) : value;
+    public notEquals<K extends StringKeyOf<T>>(key: K, value: T[K] | Lambda<T[K]> | LambdaHandler<T[K]>): Lambda<boolean> {
+        return new Lambda((ctx) => {
+            const namespace = ctx.storable.getNamespace<T>(this.namespace);
+            const evaluatedValue = (
+                Lambda.isLambda(value) || Lambda.isLambdaHandler(value)
+            ) ? Lambda.from(value).evaluate(ctx).value : value;
 
             return !namespace.equals<K>(key, evaluatedValue);
         });

src/game/nlcore/elements/script.ts

@@ -4,15 +4,19 @@ import {LogicAction} from "@core/action/logicAction";
 import {Actionable} from "@core/action/actionable";
 import {GameState} from "@player/gameState";
 import {Chained, Proxied} from "@core/action/chain";
-import type {Storable} from "@core/elements/persistent/storable";
+import type {Namespace, Storable} from "@core/elements/persistent/storable";
 import {ScriptAction} from "@core/action/actions/scriptAction";
 import {LiveGame} from "@core/game/liveGame";
+import { NameSpaceContent } from "./persistent/type";
+
+export type NamespaceGetter = <T extends NameSpaceContent<keyof T>>(namespace: string) => Namespace<T>;
 
 export interface ScriptCtx {
     gameState: GameState;
     game: Game;
     liveGame: LiveGame;
     storable: Storable;
+    $: NamespaceGetter;
 }
 
 type ScriptRun = (ctx: ScriptCtx) => ScriptCleaner | void;
@@ -22,21 +26,35 @@ export type ScriptCleaner = () => void;
 export class Script extends Actionable<object> {
     /**@internal */
     static getCtx({gameState}: { gameState: GameState }): ScriptCtx {
+        const liveGame = gameState.game.getLiveGame();
+        const storable = liveGame.getStorable();
         return {
             gameState,
             game: gameState.game,
-            liveGame: gameState.game.getLiveGame(),
-            storable: gameState.game.getLiveGame().getStorable(),
+            liveGame,
+            storable,
+            $: (namespace: string) => storable.getNamespace(namespace),
         };
     }
 
+    public static execute(handler: ScriptRun): Proxied<Script, Chained<LogicAction.Actions>> {
+        return new Script(handler) as Proxied<Script, Chained<LogicAction.Actions>>;
+    }
+
     /**@internal */
     readonly handler: ScriptRun;
 
     constructor(handler: ScriptRun) {
         super();
         this.handler = handler;
-        return this.chain() satisfies Proxied<Script, Chained<LogicAction.Actions>>;
+        
+        const chain = this.chain();
+        const action = new ScriptAction(
+            chain,
+            ScriptAction.ActionTypes.action,
+            new ContentNode<Script>().setContent(this)
+        );
+        return this.chain(action) satisfies Proxied<Script, Chained<LogicAction.Actions>>;
     }
 
     /**@internal */