@vyr/engine 0.0.1 → 0.0.3

package/src/descriptor/Descriptor.ts

@@ -5,7 +5,7 @@ import { Generate } from '../Generate'
 import { Traverser } from '../Traverser'
 import { ObjectUtils } from '../ObjectUtils'
 import { DeserializationObject, Serialization, SerializationObject } from '../Serialization'
-import { AssetProperty, AssetPropertyCollection } from '../asset'
+import { InteractionPropertyCollection } from '../interaction'
 import { observer } from '../graphics/Observer'
 
 /**描述器祖先节点 */
@@ -30,10 +30,6 @@ interface DescriptorPrefab {
     uuid: string
 }
 
-interface UpdateArgs {
-    delta: number
-}
-
 interface VariabConfig {
     type: 'key' | 'custom'
     enabled: boolean
@@ -43,24 +39,6 @@ interface VariabConfig {
 interface DescriptorVariables {
     [k: string]: VariabConfig
 }
-interface InteractionInput {
-    [param: string]: {
-        type?: 'data' | string
-        value: any
-    }
-}
-
-interface InteractionInputCollection {
-    [id: string]: InteractionInput
-}
-
-interface InteractionProperty extends AssetProperty {
-    uuid: string
-    type: string
-    inputs: InteractionInputCollection
-}
-
-interface InteractionPropertyCollection extends AssetPropertyCollection<InteractionProperty> { }
 
 const privateState = {
     classCollection: new Map<string, typeof Descriptor>(),
@@ -402,14 +380,9 @@ listenInstance('free', (uuid: string) => {
 
 export {
     Descriptor,
-    UpdateArgs,
     DescriptorAdjacency,
     DescriptorAncestor,
     DescriptorPrefab,
     VariabConfig,
     DescriptorVariables,
-    InteractionInput,
-    InteractionInputCollection,
-    InteractionProperty,
-    InteractionPropertyCollection,
 }

package/src/descriptor/HTMLTransformControllerDescriptor.ts

@@ -1,8 +1,8 @@
 import { DeserializationObject } from "../Serialization"
 import { ControllerDescriptor } from "./ControllerDescriptor"
-import { UpdateArgs } from "./Descriptor"
+import { ScriptableArgs } from "../interaction"
 
-interface HTMLTransformControllerChangeArgs extends UpdateArgs {
+interface HTMLTransformControllerChangeArgs extends ScriptableArgs<undefined, undefined, undefined> {
     event: {
         type: string
         target: string

package/src/descriptor/index.ts

@@ -2,7 +2,6 @@ export * from './Descriptor'
 export * from './DatasetDescriptor'
 export * from './StyleDescriptor'
 export * from './PrefabDescriptor'
-export * from './RoutineDescriptor'
 export * from './PrefabInstanceDescriptor'
 export * from './DynamicDescriptor'
 export * from './HTMLDescriptor'

package/src/graphics/Compilation.ts

@@ -1,7 +1,7 @@
 import { Engine } from "../Engine";
-import { Graphics } from "./Graphics";
+import { Graphics, TickArgs } from "./Graphics";
 import { Asset } from "../asset";
-import { AnimationUnitDescriptor, ServiceSchedulerDescriptor, UpdateArgs } from "../descriptor";
+import { AnimationUnitDescriptor, ServiceSchedulerDescriptor } from "../descriptor";
 
 class Compilation {
     private collection = new Map<string, Graphics>()
@@ -10,69 +10,61 @@ class Compilation {
         return (this.collection.get(scheduler.uuid) ?? null) as Graphics
     }
 
-    listen(scheduler: ServiceSchedulerDescriptor, engine: Engine) {
-        const url = Asset.getUrlByUuid(scheduler.uuid)
-        if (url) {
-            let graphics = this.collection.get(scheduler.uuid)
-            if (graphics === undefined) {
-                graphics = new Graphics(url, scheduler, engine)
-                this.collection.set(scheduler.uuid, graphics)
-            }
-            graphics.listen({ delta: 0 })
-
-            return graphics
-        }
-    }
-
-    unlisten(scheduler: ServiceSchedulerDescriptor, engine: Engine) {
+    delete(scheduler: ServiceSchedulerDescriptor) {
         const graphics = this.collection.get(scheduler.uuid)
         if (graphics === undefined) return
-        graphics.unlisten({ delta: 0 })
+        graphics.unlisten()
         this.collection.delete(scheduler.uuid)
     }
 
-    process(engine: Engine, args: UpdateArgs) {
-        Asset.free()
+    ensureExists(url: string, scheduler: ServiceSchedulerDescriptor, engine: Engine) {
+        let graphics = this.collection.get(scheduler.uuid)
+        if (graphics === undefined) {
+            graphics = new Graphics(url, scheduler, engine)
+            this.collection.set(scheduler.uuid, graphics)
+        }
+        return graphics
+    }
 
-        const collection = this.collection.values()
+    listen(graphics: Graphics) {
+        graphics.listen()
+    }
 
-        for (const graphics of collection) {
+    unlisten(scheduler: ServiceSchedulerDescriptor) {
+        this.delete(scheduler)
+    }
 
-            graphics.process(args)
+    foreach(executor: (graphics: Graphics) => void) {
+        const collection = this.collection.values()
 
-            graphics.clear(args)
+        for (const graphics of collection) {
+            executor(graphics)
+        }
+    }
 
-            engine.trigger(AnimationUnitDescriptor.type, args)
+    process(engine: Engine, args: TickArgs) {
+        Asset.free()
 
-            this.beforeRender(args)
-            engine.trigger('beforeRender', args)
+        this.foreach((graphics) => {
+            graphics.process()
+            graphics.clear()
+        })
 
-            this.render(args)
+        engine.trigger(AnimationUnitDescriptor.type, args)
 
-            this.afterRender(args)
-            engine.trigger('afterRender', args)
-        }
-    }
+        this.foreach((graphics) => graphics.beforeRender())
 
-    beforeRender(args: UpdateArgs) {
-        const collection = this.collection.values()
-        for (const graphics of collection) graphics.beforeRender(args)
-    }
+        engine.trigger('beforeRender', args)
 
-    render(args: UpdateArgs) {
-        const collection = this.collection.values()
-        for (const graphics of collection) graphics.render(args)
-    }
+        this.foreach((graphics) => graphics.render())
 
-    afterRender(args: UpdateArgs) {
-        const collection = this.collection.values()
-        for (const graphics of collection) graphics.afterRender(args)
+        engine.trigger('afterRender', args)
     }
 
-    clear(engine: Engine) {
+    clear() {
         const collection = this.collection.values()
         for (const graphics of collection) {
-            this.unlisten(graphics.scheduler, engine)
+            this.unlisten(graphics.scheduler)
         }
     }
 }

package/src/graphics/Graphics.ts

@@ -1,15 +1,20 @@
 import { language } from '../locale'
 import { ArrayUtils } from "../ArrayUtils";
 import { Asset, Dependencide } from "../asset";
-import { Descriptor, HTMLDescriptor, HTMLServiceDescriptor, RoutineDescriptor, ServiceDescriptor, ServiceSchedulerDescriptor, UpdateArgs } from "../descriptor";
+import { DatasetDescriptor, Descriptor, HTMLDescriptor, HTMLServiceDescriptor, ServiceDescriptor, ServiceSchedulerDescriptor } from "../descriptor";
 import { privateState } from "../interpreter/Interpreter";
-import { Interpreter, RoutineInterpreter, ServiceInterpreter, ServiceSchedulerInterpreter } from "../interpreter";
+import { Interpreter, ServiceInterpreter, ServiceSchedulerInterpreter } from "../interpreter";
 import { observer, UpdateDepsWatcherArgs, UpdateWatcherArgs, WatcherArgs } from "./Observer";
 import { Operation, Queue, Unit } from "./Unit";
 import { Actor } from '../actor/Actor';
 import { UnitCollection } from "./Collection";
 import { VariableProxy } from "./VariableProxy";
 import { Engine } from '../Engine';
+import { InteractionDescriptor } from '../interaction';
+
+interface TickArgs {
+    delta: number
+}
 
 interface PickupObject {
     [k: string]: any
@@ -17,7 +22,7 @@ interface PickupObject {
     generatedBy: string
 }
 
-type OverrideUpdate = (descriptor: Descriptor, interpreter: Interpreter, args: UpdateArgs) => void
+type OverrideUpdate = (descriptor: Descriptor, interpreter: Interpreter) => void
 
 class Graphics {
     static createInterpreter<T extends Interpreter = Interpreter>(descriptor: Descriptor, graphics: Graphics) {
@@ -41,6 +46,13 @@ class Graphics {
     private readonly _services: ServiceDescriptor[] = []
     private readonly _freeQueue: Unit[] = []
     private _currentCamera = ''
+    private _currentArgs: TickArgs = { delta: 0 }
+    get args() {
+        return this._currentArgs
+    }
+    set args(args: TickArgs) {
+        this._currentArgs = args
+    }
     readonly unitCollection = new UnitCollection()
     readonly variableProxy = new VariableProxy()
     readonly scheduler: ServiceSchedulerDescriptor
@@ -53,7 +65,7 @@ class Graphics {
         this.url = url
     }
 
-    listen(args: UpdateArgs) {
+    listen() {
         observer.listen('add', this.addWatcher)
         observer.listen('remove', this.removeWatcher)
         observer.listen('update', this.updateWatcher)
@@ -64,22 +76,22 @@ class Graphics {
         if (root instanceof Descriptor) this.addRoot(this.url, root)
 
         Asset.graph.getDependencide(this.url, this._dependencide)
-        this._dependencide.foreach(asset => {
+        this._dependencide.forEachForGraphics(asset => {
             const root = Asset.get<Descriptor>(asset)
             if (root instanceof Descriptor) {
                 this._assetCollection.set(asset, this.addRoot(asset, root))
             }
         })
 
-        const descriptor = this.variableProxy.get<ServiceSchedulerDescriptor>(this.scheduler.uuid, this, args)
+        const descriptor = this.variableProxy.get<ServiceSchedulerDescriptor>(this.scheduler.uuid, this)
         const interpreter = this.getInterpreter<ServiceSchedulerInterpreter>(descriptor)
-        interpreter.install(descriptor, args)
+        interpreter.install(descriptor)
     }
 
-    unlisten(args: UpdateArgs) {
-        const descriptor = this.variableProxy.get<ServiceSchedulerDescriptor>(this.scheduler.uuid, this, args)
+    unlisten() {
+        const descriptor = this.variableProxy.get<ServiceSchedulerDescriptor>(this.scheduler.uuid, this)
         const interpreter = this.getInterpreter<ServiceSchedulerInterpreter>(descriptor)
-        interpreter.uninstall(descriptor, args)
+        interpreter.uninstall(descriptor)
 
         const master = this.unitCollection.get(this.scheduler.uuid) as Unit
         const assets = [...this._assetCollection.values(), master]
@@ -87,12 +99,12 @@ class Graphics {
         for (const asset of assets) {
             const unit = this.removeRoot(asset.queue.url)
             if (unit === null) continue
-            unit.queue.iterator(operation => this.do(operation, args))
+            unit.queue.iterator(operation => this.do(operation))
             this._assetCollection.delete(asset.queue.url)
         }
 
         const _freeQueue = this._freeCollection.values()
-        for (const unit of _freeQueue) this.doFree(unit, args)
+        for (const unit of _freeQueue) this.doFree(unit)
 
         observer.unlisten('add', this.addWatcher)
         observer.unlisten('remove', this.removeWatcher)
@@ -103,11 +115,11 @@ class Graphics {
         this._dependencide.clear()
     }
 
-    process(args: UpdateArgs) {
-        for (const unit of this._freeQueue) this.doFree(unit, args)
+    process() {
+        for (const unit of this._freeQueue) this.doFree(unit)
         this._freeQueue.length = 0
 
-        this.updateStaticAsset(args)
+        this.updateStaticAsset()
 
         this._dependencide.clear()
         Asset.graph.getDependencide(this.url, this._dependencide)
@@ -116,7 +128,7 @@ class Graphics {
 
         for (const removeAsset of patch.removeQueue) {
             const unit = this.removeRoot(removeAsset)
-            if (unit !== null) unit.queue.iterator(operation => this.do(operation, args))
+            if (unit !== null) unit.queue.iterator(operation => this.do(operation))
             this._assetCollection.delete(removeAsset)
         }
         for (const addAsset of patch.addQueue) {
@@ -127,7 +139,7 @@ class Graphics {
         }
 
         const assets: Unit[] = []
-        this._dependencide.foreach(asset => {
+        this._dependencide.forEachForGraphics(asset => {
             const descriptor = Asset.get<Descriptor>(asset)
             const unit = this.unitCollection.get(descriptor.uuid)
             if (unit === undefined) return console.warn(asset, descriptor)
@@ -136,18 +148,19 @@ class Graphics {
         assets.push(...this._staticAssetQueue)
 
         for (const asset of assets) {
-            asset.queue.iterator(operation => this.do(operation, args))
+            asset.queue.iterator(operation => this.do(operation))
         }
 
-        const master = this.unitCollection.get(this.scheduler.uuid) as Unit
+        const master = this.unitCollection.get(this.scheduler.uuid)
+        if (master === undefined) return
 
-        master.queue.iterator(operation => this.do(operation, args))
+        master.queue.iterator(operation => this.do(operation))
 
         for (const asset of assets) {
-            asset.queue.iterator(unit => this.doUpdate(unit, args), Queue.Update)
+            asset.queue.iterator(unit => this.doUpdate(unit), Queue.Update)
         }
 
-        const invokeQueue = master.queue.iterator(unit => this.doUpdate(unit, args), Queue.Update)
+        const invokeQueue = master.queue.iterator(unit => this.doUpdate(unit), Queue.Update)
         for (const unit of invokeQueue) {
             const descriptor = Descriptor.get<Descriptor>(unit.uuid)
             this.invoke('mount', descriptor)
@@ -157,35 +170,35 @@ class Graphics {
         this._freeCollection.clear()
     }
 
-    clear(args: UpdateArgs) {
+    clear() {
         for (const service of this._services) {
-            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this, args)
+            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this)
             const interpreter = this.getInterpreter<ServiceInterpreter>(descriptor)
-            interpreter.clear(descriptor, args)
+            interpreter.clear(descriptor)
         }
     }
 
-    beforeRender(args: UpdateArgs) {
+    beforeRender() {
         for (const service of this._services) {
-            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this, args)
+            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this)
             const interpreter = this.getInterpreter<ServiceInterpreter>(descriptor)
-            interpreter.beforeRender(descriptor, args)
+            interpreter.beforeRender(descriptor)
         }
     }
 
-    render(args: UpdateArgs) {
+    render() {
         for (const service of this._services) {
-            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this, args)
+            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this)
             const interpreter = this.getInterpreter<ServiceInterpreter>(descriptor)
-            interpreter.render(descriptor, args)
+            interpreter.render(descriptor)
         }
     }
 
-    afterRender(args: UpdateArgs) {
+    afterRender() {
         for (const service of this._services) {
-            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this, args)
+            const descriptor = this.variableProxy.get<ServiceDescriptor>(service.uuid, this)
             const interpreter = this.getInterpreter<ServiceInterpreter>(descriptor)
-            interpreter.afterRender(descriptor, args)
+            interpreter.afterRender(descriptor)
         }
     }
 
@@ -281,7 +294,7 @@ class Graphics {
         })
     }
 
-    private updateStaticAsset(args: UpdateArgs) {
+    private updateStaticAsset() {
         if (this.scheduler.camera !== this._currentCamera) {
             const descriptor = Descriptor.get<Descriptor>(this.scheduler.camera)
             if (descriptor === null) return
@@ -302,7 +315,7 @@ class Graphics {
         const temp = new Map(this._assetCollection)
         const addQueue: string[] = [], removeQueue: string[] = []
 
-        this._dependencide.foreach(asset => {
+        this._dependencide.forEachForGraphics(asset => {
             temp.has(asset) ? temp.delete(asset) : addQueue.push(asset)
         })
         removeQueue.push(...temp.keys())
@@ -310,41 +323,41 @@ class Graphics {
         return { addQueue, removeQueue }
     }
 
-    private onMount(unit: Unit, args: UpdateArgs) {
-        const parentDescriptor = this.variableProxy.get<Descriptor>(unit.parent, this, args)
+    private onMount(unit: Unit) {
+        const parentDescriptor = this.variableProxy.get<Descriptor>(unit.parent, this)
         const parentInterpreter = this.getInterpreter(parentDescriptor)
 
-        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this, args)
+        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this)
         const interpreter = this.getInterpreter(descriptor)
 
         if (descriptor instanceof ServiceDescriptor) ArrayUtils.insert(this._services, descriptor)
 
-        interpreter.mount(descriptor, args, parentInterpreter, parentDescriptor)
+        interpreter.mount(descriptor, parentInterpreter, parentDescriptor)
     }
 
-    private onUnmount(unit: Unit, args: UpdateArgs) {
-        const parentDescriptor = this.variableProxy.get<Descriptor>(unit.parent, this, args)
+    private onUnmount(unit: Unit) {
+        const parentDescriptor = this.variableProxy.get<Descriptor>(unit.parent, this)
         const parentInterpreter = this.getInterpreter(parentDescriptor)
 
-        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this, args)
+        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this)
         const interpreter = this.getInterpreter(descriptor)
 
         if (descriptor instanceof ServiceDescriptor) ArrayUtils.remove(this._services, descriptor)
 
-        interpreter.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+        interpreter.unmount(descriptor, parentInterpreter, parentDescriptor)
     }
 
     getUnit<T extends Unit | null = Unit>(uuid: string) {
         return (this.unitCollection.get(uuid) ?? null) as T
     }
 
-    do(operation: Operation, args: UpdateArgs) {
+    do(operation: Operation) {
         switch (operation.type) {
             case Queue.Add:
-                this.onMount(operation.unit, args)
+                this.onMount(operation.unit)
                 break;
             case Queue.Remove:
-                this.onUnmount(operation.unit, args)
+                this.onUnmount(operation.unit)
                 break;
             default:
                 console.log('do', operation.type)
@@ -352,18 +365,18 @@ class Graphics {
         }
     }
 
-    doUpdate(unit: Unit, args: UpdateArgs) {
-        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this, args)
+    doUpdate(unit: Unit) {
+        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this)
         const interpreter = this.getInterpreter(descriptor)
         const override = this._overwriteUpdate.get(descriptor.uuid)
-        override === undefined ? interpreter.update(descriptor, args) : override(descriptor, interpreter, args)
+        override === undefined ? interpreter.update(descriptor) : override(descriptor, interpreter)
     }
 
-    doFree(unit: Unit, args: UpdateArgs) {
+    doFree(unit: Unit) {
         const interpreter = this._interpreterCollection.get(unit.uuid)
         if (interpreter === undefined) return
-        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this, args)
-        interpreter.free(descriptor, args)
+        const descriptor = this.variableProxy.get<Descriptor>(unit.uuid, this)
+        interpreter.free(descriptor)
         this._interpreterCollection.delete(unit.uuid)
     }
 
@@ -382,18 +395,18 @@ class Graphics {
         return Descriptor.get<T>(unit.parent)
     }
 
-    getActor<T extends Actor = Actor>(descriptor: Descriptor, args: UpdateArgs) {
+    getActor<T extends Actor = Actor>(descriptor: Descriptor) {
         const interpreter = this.getInterpreter(descriptor)
-        return interpreter.getActor<T>(descriptor, args)
+        return interpreter.getActor<T>(descriptor)
     }
 
-    private _pickupItem(target: Descriptor, args: UpdateArgs, result: PickupObject[]) {
+    private _pickupItem(target: Descriptor, result: PickupObject[]) {
         if (target.selectable === false) return
         const interpreter = this._interpreterCollection.get(target.uuid)
         if (interpreter === undefined) return
-        interpreter.pickup(target, args, result)
+        interpreter.pickup(target, result)
     }
-    private _pickupScene(args: UpdateArgs, result: PickupObject[]) {
+    private _pickupScene(result: PickupObject[]) {
         const master = this.unitCollection.get(this.scheduler.uuid)
         if (master === undefined) return result
 
@@ -401,7 +414,7 @@ class Graphics {
         for (const unit of units) {
             const descriptor = Descriptor.get<Descriptor>(unit.uuid)
             if (descriptor instanceof HTMLDescriptor) continue
-            this._pickupItem(descriptor, args, result)
+            this._pickupItem(descriptor, result)
         }
     }
 
@@ -434,28 +447,26 @@ class Graphics {
         const args = { delta: 0 }
         if (target instanceof ServiceDescriptor) {
             if (target instanceof HTMLServiceDescriptor) {
-                this._pickupItem(target, args, result)
+                this._pickupItem(target, result)
             } else {
                 const interpreter = this.getInterpreter<ServiceInterpreter>(target)
-                interpreter.beforePickup(mouse, rect, args)
-                this._pickupScene(args, result)
+                interpreter.beforePickup(mouse, rect)
+                this._pickupScene(result)
                 interpreter.orderBy(result)
             }
         } else {
-            this._pickupItem(target, args, result)
+            this._pickupItem(target, result)
         }
 
         return result
     }
 
-    invoke(interaction: string, descriptor: Descriptor) {
+    async invoke(interaction: string, descriptor: Descriptor) {
         if (descriptor.interactions.length === 0) return
-        const eventArgs = { delta: 0, trigger: descriptor }
         for (const inter of descriptor.interactions) {
             if (inter.type === interaction) {
-                const routine = Asset.get<RoutineDescriptor>(inter.url)
-                const interpreter = this.getInterpreter<RoutineInterpreter>(routine)
-                interpreter.do(inter.inputs, routine, eventArgs)
+                const current = Asset.get<InteractionDescriptor>(inter.url)
+                if (current !== null) await current.execute(inter.inputs, this, descriptor)
                 break
             }
         }
@@ -471,5 +482,6 @@ class Graphics {
 
 export {
     PickupObject,
+    TickArgs,
     Graphics,
 }

package/src/graphics/VariableProxy.ts

@@ -1,7 +1,7 @@
 import { ObjectUtils } from "../ObjectUtils";
 import { Asset } from "../asset";
-import { Scriptable } from "../Scriptable";
-import { Data, DatasetDescriptor, Descriptor, UpdateArgs, VariabConfig } from "../descriptor";
+import { Scriptable, ScriptableArgs } from "../interaction/Scriptable";
+import { Data, DatasetDescriptor, Descriptor, VariabConfig } from "../descriptor";
 import { Graphics } from "./Graphics";
 
 interface ActorCollection { [k: string]: any }
@@ -34,18 +34,18 @@ class VariableProxy {
             }
         });
     }
-    private getVariableValue = (descriptor: Descriptor, data: Data, key: string, config: VariabConfig, graphics: Graphics, args: UpdateArgs) => {
+    private getVariableValue = (descriptor: Descriptor, data: Data, key: string, config: VariabConfig, graphics: Graphics) => {
         if (config.type === 'key') {
             return ObjectUtils.getValueByKey(data, config.value)
         } else if (config.type === 'custom') {
-            const scriptable = Asset.get<Scriptable>(config.value)
+            const scriptable = Asset.get<Scriptable<ScriptableArgs<undefined, undefined, undefined>>>(config.value)
             if (scriptable === null) return
-            const currentArgs = { ...args, key, config, data }
-            return scriptable.execute(descriptor, graphics, currentArgs)
+            const currentArgs = { key, config, data, input: undefined, result: undefined, trigger: descriptor }
+            return scriptable.execute(graphics, currentArgs)
         }
     }
 
-    get<T extends Descriptor | null = Descriptor | null>(uuid: string, graphics: Graphics, args: UpdateArgs) {
+    get<T extends Descriptor | null = Descriptor | null>(uuid: string, graphics: Graphics) {
         const descriptor = Descriptor.get<Descriptor>(uuid)
         if (descriptor === null) return null as unknown as T
 
@@ -63,7 +63,7 @@ class VariableProxy {
                 for (const key of keys) {
                     const variable = descriptor.variables[key]
                     if (variable.enabled === false) continue
-                    const value = this.getVariableValue(descriptor, data, key, variable, graphics, args)
+                    const value = this.getVariableValue(descriptor, data, key, variable, graphics)
                     if (value === undefined) continue
                     variables[key] = value
                 }

package/src/index.ts

@@ -15,7 +15,8 @@ export { Listener } from './Listener'
 export { InputSystem } from './InputSystem'
 export { destroyInstance } from './ObjectPool'
 export * from './AsyncTask'
-export * from './Scriptable'
+export * from './interaction/Scriptable'
+export * from './interaction'
 export * from './descriptor'
 export * from './interpreter'
 export * from './utils'