@vyr/engine 0.0.1 → 0.0.3

package/src/interaction/InteractionDescriptor.ts

@@ -0,0 +1,96 @@
+import { DeserializationObject, Serialization } from "../Serialization";
+import { Descriptor } from "../descriptor";
+import { AssetProperty, AssetPropertyCollection } from "../asset";
+import { Graphics } from "../graphics";
+import { InteractionExecutor } from "./InteractionExecutor";
+
+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> { }
+
+interface InteractionNode {
+    id: string
+    label: string
+    position: { x: number; y: number }
+    interaction: string
+    url: string
+    input: InteractionInput
+}
+
+interface InteractionMapper {
+    source: string
+    target: string
+}
+
+const privateState = {
+    executorPool: new WeakMap<Descriptor, InteractionExecutor>()
+}
+
+class InteractionDescriptor extends Descriptor {
+    static type = 'Interaction'
+    roots: string[]
+    nodes: InteractionNode[]
+    mappers: InteractionMapper[]
+
+    constructor(descriptor: Partial<DeserializationObject<InteractionDescriptor>> = {}) {
+        super(descriptor)
+        this.roots = descriptor.roots ? Serialization.deepClone(descriptor.roots) : []
+        this.nodes = descriptor.nodes ? Serialization.deepClone(descriptor.nodes) : []
+        this.mappers = descriptor.mappers ? Serialization.deepClone(descriptor.mappers) : []
+    }
+
+    addNode(nodes: InteractionNode[]) {
+        const count = nodes.length
+        const max = count - 1
+        for (let i = 0; i < count; i++) {
+            const node = nodes[i]
+            this.nodes.push(node)
+            if (i < max) {
+                this.mappers.push({ source: node.id, target: nodes[i + 1].id })
+            }
+        }
+    }
+
+    async execute(customInputs: InteractionInputCollection, graphics: Graphics, trigger: Descriptor, otherArgs?: { [k: string]: any }) {
+        let executor = privateState.executorPool.get(this)
+        if (executor === undefined) {
+            executor = new InteractionExecutor()
+            executor.update(this)
+            privateState.executorPool.set(this, executor)
+        }
+        await executor.execute(customInputs, this, graphics, trigger,otherArgs)
+    }
+
+    setNeedsUpdate() {
+        const executor = privateState.executorPool.get(this)
+        if (executor === undefined) return
+        executor.update(this)
+    }
+}
+
+Descriptor.register(InteractionDescriptor)
+
+export {
+    InteractionInput,
+    InteractionInputCollection,
+    InteractionProperty,
+    InteractionPropertyCollection,
+    InteractionNode,
+    InteractionMapper,
+    InteractionDescriptor,
+}

package/src/interaction/InteractionExecutor.ts

@@ -0,0 +1,84 @@
+import { Asset } from "../asset"
+import { Scriptable } from "./Scriptable"
+import { InteractionDescriptor, InteractionInputCollection, InteractionNode } from "./InteractionDescriptor"
+import { Graphics } from "../graphics/Graphics"
+
+type ExecuteResult = { [k: string]: any } | null
+
+class InteractionExecutor {
+    readonly collection = new Map<string, InteractionNode>()
+    readonly linkCollection = new Map<string, string[]>()
+
+    update(interaction: InteractionDescriptor) {
+        this.collection.clear()
+        this.linkCollection.clear()
+
+        for (const node of interaction.nodes) {
+            this.collection.set(node.id, node)
+        }
+
+        for (const mapper of interaction.mappers) {
+            let link = this.linkCollection.get(mapper.source)
+            if (link === undefined) {
+                link = []
+                this.linkCollection.set(mapper.source, link)
+            }
+            link.push(mapper.target)
+        }
+    }
+
+    async doBranch(branch: string, previous: string, customInputs: InteractionInputCollection, interaction: InteractionDescriptor, graphics: Graphics, result: Map<string, ExecuteResult>, trigger: any, otherArgs?: any) {
+        await this.doExecute(branch, previous, customInputs, interaction, graphics, result, trigger, otherArgs)
+    }
+
+    async doCondition(condition: string, previous: string, customInputs: InteractionInputCollection, interaction: InteractionDescriptor, graphics: Graphics, result: Map<string, ExecuteResult>, trigger: any, otherArgs?: any) {
+        const preResult = result.get(previous)
+        const conditionResult = result.get(condition)
+        if (preResult !== conditionResult?.condition.value) return
+
+        await this.doExecute(condition, previous, customInputs, interaction, graphics, result, trigger, otherArgs)
+    }
+
+    async doExecute(execute: string, previous: string, customInputs: InteractionInputCollection, interaction: InteractionDescriptor, graphics: Graphics, result: Map<string, ExecuteResult>, trigger: any, otherArgs?: any) {
+        const nexts = this.linkCollection.get(execute)
+        if (nexts === undefined) return
+
+        for (const next of nexts) {
+            await this.doNext(next, execute, customInputs, interaction, graphics, result, trigger, otherArgs)
+        }
+    }
+
+    async doNext(current: string, previous: string, customInputs: InteractionInputCollection, interaction: InteractionDescriptor, graphics: Graphics, result: Map<string, ExecuteResult>, trigger: any, otherArgs?: any) {
+        const active = this.collection.get(current)
+        if (active === undefined) return
+
+        const currentInput = customInputs[current] ?? {}
+        const script = Asset.get<Scriptable>(active.url)
+        if (script) {
+            const args = { input: { previous, default: active.input, user: currentInput }, result, trigger }
+            if (otherArgs) Object.assign(args, otherArgs)
+            const executeResult = await script.execute(graphics, args)
+            result.set(current, executeResult)
+        }
+
+        if (active.interaction === 'Branch') {
+            await this.doBranch(current, previous, customInputs, interaction, graphics, result, trigger, otherArgs)
+        } else if (active.interaction === 'Condition') {
+            if (result.has(current) === false) result.set(current, active.input)
+            await this.doCondition(current, previous, customInputs, interaction, graphics, result, trigger, otherArgs)
+        } else {
+            await this.doExecute(current, previous, customInputs, interaction, graphics, result, trigger, otherArgs)
+        }
+    }
+
+    async execute(customInputs: InteractionInputCollection, interaction: InteractionDescriptor, graphics: Graphics, trigger: any, otherArgs?: any) {
+        for (const root of interaction.roots) {
+            const resultCollection = new Map()
+            await this.doNext(root, '', customInputs, interaction, graphics, resultCollection, trigger, otherArgs)
+        }
+    }
+}
+
+export {
+    InteractionExecutor
+}

package/src/interaction/Scriptable.ts

@@ -0,0 +1,40 @@
+import { Descriptor } from "../descriptor"
+import { Graphics } from "../graphics/Graphics"
+import { InteractionInput } from "./InteractionDescriptor";
+
+interface ScriptableInput<T = InteractionInput> {
+    previous: string;
+    default: T,
+    user: T
+}
+
+interface ScriptableArgs<T = InteractionInput, R = Map<string, any>, I = ScriptableInput<T>> {
+    input: I,
+    result: R,
+    trigger: Descriptor
+}
+
+/**
+ * 可编程脚本(脚本不会在服务端实例化)
+ */
+class Scriptable<T extends ScriptableArgs<any, any, any> = ScriptableArgs> {
+    readonly uuid
+    /**脚本文件的url路径 */
+    get url() {
+        return this.uuid
+    }
+
+    constructor(url: string) {
+        this.uuid = url
+    }
+
+    /**脚本的准备事件，该方法在脚本被实例化后立即执行
+     * 
+     * 一般在该事件中进行脚本的准备工作，如从服务端获取资源或数据
+     */
+    async ready() { }
+
+    execute(graphics: Graphics, args: T): any { }
+}
+
+export { ScriptableArgs, Scriptable }

package/src/interaction/index.ts

@@ -0,0 +1,3 @@
+export * from './InteractionDescriptor'
+export * from './InteractionExecutor'
+export * from './Scriptable'

package/src/interpreter/AnimationUnitInterpreter.ts

@@ -1,4 +1,4 @@
-import { AnimationUnitDescriptor, Descriptor, UpdateArgs } from '../descriptor';
+import { AnimationUnitDescriptor, Descriptor } from '../descriptor';
 import { ArrayUtils } from '../ArrayUtils';
 import { Interpreter } from './Interpreter'
 import { AnimationUnitActor } from "../actor";
@@ -29,8 +29,8 @@ class AnimationUnitInterpreter extends Interpreter {
     }
 
 
-    update(descriptor: AnimationUnitDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
+    update(descriptor: AnimationUnitDescriptor) {
+        super.update(descriptor)
 
         this.freeUnit()
 
@@ -43,9 +43,9 @@ class AnimationUnitInterpreter extends Interpreter {
         this.animationUnit.listen(this.graphics)
     }
 
-    unmount(descriptor: AnimationUnitDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+    unmount(descriptor: AnimationUnitDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
         this.freeUnit()
-        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
     }
 }
 Interpreter.register(AnimationUnitInterpreter)

package/src/interpreter/DivInterpreter.ts

@@ -1,4 +1,4 @@
-import { Descriptor, DivDescriptor, UpdateArgs } from "../descriptor"
+import { Descriptor, DivDescriptor } from "../descriptor"
 import { Interpreter } from "./Interpreter"
 import { DivActor, HTMLActor } from "../actor"
 import { PickupObject } from "../graphics"
@@ -6,36 +6,36 @@ import { PickupObject } from "../graphics"
 class DivInterpreter extends Interpreter {
     static type = DivDescriptor.type
 
-    protected createActor(descriptor: DivDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: DivDescriptor) {
         return new DivActor(descriptor.uuid)
     }
 
-    update(descriptor: DivDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<DivActor>(descriptor, args)
-        actor.update(descriptor, args)
+    update(descriptor: DivDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<DivActor>(descriptor)
+        actor.update(descriptor)
     }
 
-    mount(descriptor: DivDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
-        const actor = this.getActor<DivActor>(descriptor, args)
+    mount(descriptor: DivDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, parentInterpreter, parentDescriptor)
+        const actor = this.getActor<DivActor>(descriptor)
 
-        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor, args)
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor)
         parenActor.add(actor)
     }
 
-    unmount(descriptor: DivDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        const actor = this.getActor<DivActor>(descriptor, args)
+    unmount(descriptor: DivDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const actor = this.getActor<DivActor>(descriptor)
         actor.clearStyleClass(actor.DOM)
         actor.cleanInteraction()
 
-        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor, args)
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor)
         parenActor.remove(actor)
 
-        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
     }
 
-    pickup(descriptor: DivDescriptor, args: UpdateArgs, result: PickupObject[]) {
+    pickup(descriptor: DivDescriptor, result: PickupObject[]) {
         result.push({ uuid: descriptor.uuid, generatedBy: descriptor.generatedBy })
     }
 }

package/src/interpreter/DynamicInterpreter.ts

@@ -1,6 +1,6 @@
 import { ArrayUtils } from "../ArrayUtils"
 import { Asset } from "../asset"
-import { DynamicDescriptor, Descriptor, UpdateArgs, Data, DatasetDescriptor, PrefabeDescriptor } from "../descriptor"
+import { DynamicDescriptor, Descriptor, Data, DatasetDescriptor, PrefabeDescriptor } from "../descriptor"
 import { observer, UpdateWatcherArgs, WatcherArgs } from "../graphics"
 import { Category } from "../Category"
 import { FragmentInterpreter, Interpreter } from "."
@@ -158,18 +158,18 @@ class DynamicInterpreter extends FragmentInterpreter {
         this._cloneCollection.clear()
     }
 
-    mount(descriptor: Descriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor): void {
-        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
+    mount(descriptor: Descriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor): void {
+        super.mount(descriptor, parentInterpreter, parentDescriptor)
         observer.listen('update', this._clearByOnUpdate)
     }
 
-    unmount(descriptor: Descriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+    unmount(descriptor: Descriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
         observer.unlisten('update', this._clearByOnUpdate)
-        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
     }
 
-    update(descriptor: DynamicDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
+    update(descriptor: DynamicDescriptor) {
+        super.update(descriptor)
 
         observer.unlisten('add', this._onAdd)
         observer.unlisten('remove', this._onRemove)
@@ -197,11 +197,11 @@ class DynamicInterpreter extends FragmentInterpreter {
         observer.listen('update', this._onUpdate)
     }
 
-    free(descriptor: Descriptor, args: UpdateArgs) {
+    free(descriptor: Descriptor) {
         observer.unlisten('add', this._onAdd)
         observer.unlisten('remove', this._onRemove)
         observer.unlisten('update', this._onUpdate)
-        super.free(descriptor, args)
+        super.free(descriptor)
     }
 }
 FragmentInterpreter.register(DynamicInterpreter)

package/src/interpreter/FragmentInterpreter.ts

@@ -1,30 +1,30 @@
 import { FragmentActor } from "../actor";
-import { Descriptor, UpdateArgs } from "../descriptor";
+import { Descriptor } from "../descriptor";
 import { Interpreter } from "./Interpreter";
 
 class FragmentInterpreter extends Interpreter {
     static type = Descriptor.type
 
-    protected createActor(descriptor: Descriptor, args: UpdateArgs) {
+    protected createActor(descriptor: Descriptor) {
         return new FragmentActor()
     }
 
     /**将节点挂载到场景 */
-    mount(descriptor: Descriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
-        const actor = this.getActor<FragmentActor>(descriptor, args)
+    mount(descriptor: Descriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, parentInterpreter, parentDescriptor)
+        const actor = this.getActor<FragmentActor>(descriptor)
         actor.bind(parentDescriptor.uuid)
     }
 
     /**将节点从场景中卸载 */
-    unmount(descriptor: Descriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+    unmount(descriptor: Descriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
     }
 
-    free(descriptor: Descriptor, args: UpdateArgs): void {
-        const actor = this.getActor<FragmentActor>(descriptor, args)
+    free(descriptor: Descriptor): void {
+        const actor = this.getActor<FragmentActor>(descriptor)
         actor.unbind()
-        super.free(descriptor, args)
+        super.free(descriptor)
     }
 }
 Interpreter.register(FragmentInterpreter)

package/src/interpreter/HTMLServiceInterpreter.ts

@@ -1,4 +1,4 @@
-import { Descriptor, HTMLServiceDescriptor, UpdateArgs } from "../descriptor"
+import { Descriptor, HTMLServiceDescriptor } from "../descriptor"
 import { Interpreter, ServiceInterpreter } from "."
 import { HTMLActor, HTMLServiceActor } from "../actor"
 import { PickupObject } from "../graphics"
@@ -6,39 +6,39 @@ import { PickupObject } from "../graphics"
 class HTMLServiceInterpreter extends ServiceInterpreter {
     static type = HTMLServiceDescriptor.type
 
-    protected createActor(descriptor: HTMLServiceDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: HTMLServiceDescriptor) {
         const actor = new HTMLServiceActor(descriptor.uuid)
         actor.DOM.addEventListener('pointerdown', e => e.stopPropagation())
         return actor
     }
 
-    update(descriptor: HTMLServiceDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
+    update(descriptor: HTMLServiceDescriptor) {
+        super.update(descriptor)
 
-        const actor = this.getActor<HTMLServiceActor>(descriptor, args)
-        actor.update(descriptor, args)
+        const actor = this.getActor<HTMLServiceActor>(descriptor)
+        actor.update(descriptor)
     }
 
-    mount(descriptor: HTMLServiceDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
-        const actor = this.getActor<HTMLServiceActor>(descriptor, args)
+    mount(descriptor: HTMLServiceDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, parentInterpreter, parentDescriptor)
+        const actor = this.getActor<HTMLServiceActor>(descriptor)
 
-        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor, args)
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor)
         parenActor.add(actor)
     }
 
-    unmount(descriptor: HTMLServiceDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        const actor = this.getActor<HTMLServiceActor>(descriptor, args)
+    unmount(descriptor: HTMLServiceDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const actor = this.getActor<HTMLServiceActor>(descriptor)
         actor.clearStyleClass(actor.DOM)
         actor.cleanInteraction()
 
-        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor, args)
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor)
         parenActor.remove(actor)
 
-        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
     }
 
-    pickup(descriptor: HTMLServiceDescriptor, args: UpdateArgs, result: PickupObject[]) {
+    pickup(descriptor: HTMLServiceDescriptor, result: PickupObject[]) {
         result.push({ uuid: descriptor.uuid, generatedBy: descriptor.generatedBy })
     }
 }

package/src/interpreter/HTMLTransformControllerInterpreter.ts

@@ -1,37 +1,37 @@
-import { Descriptor, HTMLTransformControllerDescriptor, UpdateArgs } from "../descriptor"
+import { Descriptor, HTMLTransformControllerDescriptor } from "../descriptor"
 import { HTMLTransformControllerActor } from "../actor"
 import { Interpreter } from "./Interpreter"
 
 class HTMLTransformControllerInterpreter extends Interpreter {
     static type = HTMLTransformControllerDescriptor.type
 
-    protected createActor(descriptor: HTMLTransformControllerDescriptor, args: UpdateArgs) {
+    protected createActor(descriptor: HTMLTransformControllerDescriptor) {
         const actor = new HTMLTransformControllerActor()
         return actor
     }
 
-    update(descriptor: HTMLTransformControllerDescriptor, args: UpdateArgs) {
-        super.update(descriptor, args)
-        const actor = this.getActor<HTMLTransformControllerActor>(descriptor, args)
-        actor.update(descriptor, args)
+    update(descriptor: HTMLTransformControllerDescriptor) {
+        super.update(descriptor)
+        const actor = this.getActor<HTMLTransformControllerActor>(descriptor)
+        actor.update(descriptor)
     }
 
-    mount(descriptor: HTMLTransformControllerDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
-        this.getActor<HTMLTransformControllerActor>(descriptor, args)
+    mount(descriptor: HTMLTransformControllerDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, parentInterpreter, parentDescriptor)
+        this.getActor<HTMLTransformControllerActor>(descriptor)
     }
 
-    unmount(descriptor: HTMLTransformControllerDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
-        const actor = this.getActor<HTMLTransformControllerActor>(descriptor, args)
+    unmount(descriptor: HTMLTransformControllerDescriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const actor = this.getActor<HTMLTransformControllerActor>(descriptor)
         actor.unlisten()
 
-        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+        super.unmount(descriptor, parentInterpreter, parentDescriptor)
     }
 
-    free(descriptor: HTMLTransformControllerDescriptor, args: UpdateArgs) {
-        const actor = this.getActor<HTMLTransformControllerActor>(descriptor, args)
+    free(descriptor: HTMLTransformControllerDescriptor) {
+        const actor = this.getActor<HTMLTransformControllerActor>(descriptor)
         actor.dispose()
-        super.free(descriptor, args)
+        super.free(descriptor)
     }
 }
 Interpreter.register(HTMLTransformControllerInterpreter)

package/src/interpreter/Interpreter.ts

@@ -1,7 +1,7 @@
 import { language } from '../locale'
 import { Actor } from '../actor'
 import { Unit, PickupObject, Graphics } from "../graphics"
-import { Descriptor, UpdateArgs } from "../descriptor"
+import { Descriptor } from "../descriptor"
 
 const privateState = {
     factory: false,
@@ -33,37 +33,37 @@ class Interpreter {
         this.graphics = graphics
     }
 
-    protected createActor(descriptor: Descriptor, args: UpdateArgs) {
+    protected createActor(descriptor: Descriptor) {
         return new Actor()
     }
 
     /**使用描述器获取代理对象，若代理对象不存在则会使用描述器创建一个代理对象 */
-    getActor<T extends Actor = Actor>(descriptor: Descriptor, args: UpdateArgs): T {
+    getActor<T extends Actor = Actor>(descriptor: Descriptor): T {
         let actor = privateState.actorCollection.get(this)
         if (actor !== undefined) return actor as T
-        actor = this.createActor(descriptor, args)
+        actor = this.createActor(descriptor)
         Actor.seGraphics(actor, this.graphics)
         privateState.actorCollection.set(this, actor)
         return actor as T
     }
 
     /**使用描述更新节点 */
-    update(descriptor: Descriptor, args: UpdateArgs) { }
+    update(descriptor: Descriptor,) { }
 
     /**将节点挂载到场景 */
-    mount(descriptor: Descriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) { }
+    mount(descriptor: Descriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) { }
 
     /**将节点从场景中卸载 */
-    unmount(descriptor: Descriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) { }
+    unmount(descriptor: Descriptor, parentInterpreter: Interpreter, parentDescriptor: Descriptor) { }
 
-    free(descriptor: Descriptor, args: UpdateArgs) {
+    free(descriptor: Descriptor) {
         const actor = privateState.actorCollection.get(this)
         if (actor === undefined) return
         Actor.seGraphics(actor, this.graphics)
         privateState.actorCollection.delete(this)
     }
 
-    pickup(descriptor: Descriptor, args: UpdateArgs, result: PickupObject[]) { }
+    pickup(descriptor: Descriptor, result: PickupObject[]) { }
 }
 
 export { Interpreter, privateState }

package/src/interpreter/ServiceInterpreter.ts

@@ -1,19 +1,19 @@
-import { ServiceDescriptor, UpdateArgs } from "../descriptor";
+import { ServiceDescriptor } from "../descriptor";
 import { PickupObject } from "../graphics";
 import { Interpreter } from "./Interpreter";
 
 class ServiceInterpreter extends Interpreter {
   static type = ServiceDescriptor.type
 
-  clear(service: ServiceDescriptor, args: UpdateArgs) { }
+  clear(service: ServiceDescriptor) { }
 
-  beforeRender(service: ServiceDescriptor, args: UpdateArgs) { }
+  beforeRender(service: ServiceDescriptor) { }
 
-  render(service: ServiceDescriptor, args: UpdateArgs) { }
+  render(service: ServiceDescriptor) { }
 
-  afterRender(service: ServiceDescriptor, args: UpdateArgs) { }
+  afterRender(service: ServiceDescriptor) { }
 
-  beforePickup(mouse: { x: number; y: number }, rect: DOMRect, args: UpdateArgs) { }
+  beforePickup(mouse: { x: number; y: number }, rect: DOMRect) { }
 
   orderBy(result: PickupObject[]) { }
 }

package/src/interpreter/ServiceSchedulerInterpreter.ts

@@ -1,11 +1,11 @@
-import { Descriptor, ServiceSchedulerDescriptor, UpdateArgs } from "../descriptor"
+import { Descriptor, ServiceSchedulerDescriptor } from "../descriptor"
 import { DivActor } from "../actor"
 import { Interpreter } from "./Interpreter"
 
 class ServiceSchedulerInterpreter extends Interpreter {
   static type = ServiceSchedulerDescriptor.type
 
-  protected createActor(descriptor: Descriptor, args: UpdateArgs) {
+  protected createActor(descriptor: Descriptor) {
     const actor = new DivActor(descriptor.uuid)
     return actor
   }
@@ -13,8 +13,8 @@ class ServiceSchedulerInterpreter extends Interpreter {
   private resize = () => { }
   private unresize = () => { }
 
-  install(descriptor: ServiceSchedulerDescriptor, args: UpdateArgs) {
-    const actor = this.getActor<DivActor>(descriptor, args)
+  install(descriptor: ServiceSchedulerDescriptor) {
+    const actor = this.getActor<DivActor>(descriptor)
     const wrapper = actor.getWrapper()
 
     this.graphics.engine.DOM.appendChild(wrapper)
@@ -30,9 +30,9 @@ class ServiceSchedulerInterpreter extends Interpreter {
     this.resize()
   }
 
-  uninstall(descriptor: ServiceSchedulerDescriptor, args: UpdateArgs) {
+  uninstall(descriptor: ServiceSchedulerDescriptor) {
     this.unresize()
-    const actor = this.getActor<DivActor>(descriptor, args)
+    const actor = this.getActor<DivActor>(descriptor)
     const wrapper = actor.getWrapper()
     wrapper.remove()
   }