fix: Script element is not executed correctly

Author: helloyork

CHANGELOG.md

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

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

@@ -45,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/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 */