@vyr/engine 0.0.1

package/src/index.ts

@@ -0,0 +1,26 @@
+declare global {
+  interface SnowAssets { }
+}
+
+export * from './locale'
+export * from './math'
+export * from './Color'
+export * from './Serialization'
+export { Category } from './Category'
+export { ArrayUtils } from './ArrayUtils'
+export { ObjectUtils } from './ObjectUtils'
+export { Generate } from './Generate'
+export { Traverser } from './Traverser'
+export { Listener } from './Listener'
+export { InputSystem } from './InputSystem'
+export { destroyInstance } from './ObjectPool'
+export * from './AsyncTask'
+export * from './Scriptable'
+export * from './descriptor'
+export * from './interpreter'
+export * from './utils'
+export * from './actor'
+export * from './graphics'
+export * from './asset'
+export * from './preset'
+export * from './Engine'

package/src/interpreter/AnimationUnitInterpreter.ts

@@ -0,0 +1,53 @@
+import { AnimationUnitDescriptor, Descriptor, UpdateArgs } from '../descriptor';
+import { ArrayUtils } from '../ArrayUtils';
+import { Interpreter } from './Interpreter'
+import { AnimationUnitActor } from "../actor";
+
+const privateState = {
+    collection: [] as AnimationUnitActor[],
+}
+
+class AnimationUnitInterpreter extends Interpreter {
+    static type = AnimationUnitDescriptor.type
+    static enabled = true
+    static reset(time = 0) {
+        const enabled = AnimationUnitInterpreter.enabled
+        AnimationUnitInterpreter.enabled = true
+        for (const animationUnit of privateState.collection) {
+            animationUnit.reset(time)
+        }
+        AnimationUnitInterpreter.enabled = enabled
+    }
+
+    animationUnit: AnimationUnitActor | null = null
+
+    freeUnit() {
+        if (this.animationUnit === null) return
+        ArrayUtils.remove(privateState.collection, this.animationUnit)
+        this.animationUnit.unlisten()
+        this.animationUnit = null
+    }
+
+
+    update(descriptor: AnimationUnitDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+
+        this.freeUnit()
+
+        const parentDescriptor = AnimationUnitDescriptor.get<AnimationUnitDescriptor>(this.unit.parent)
+        if (parentDescriptor === null) return
+
+        this.animationUnit = AnimationUnitActor.parse(descriptor)
+        ArrayUtils.insert(privateState.collection, this.animationUnit)
+        this.animationUnit.setTarget(parentDescriptor)
+        this.animationUnit.listen(this.graphics)
+    }
+
+    unmount(descriptor: AnimationUnitDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        this.freeUnit()
+        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+    }
+}
+Interpreter.register(AnimationUnitInterpreter)
+
+export { AnimationUnitInterpreter }

package/src/interpreter/DatasetInterpreter.ts

@@ -0,0 +1,11 @@
+import { DatasetDescriptor } from "../descriptor";
+import { Interpreter } from "./Interpreter";
+
+class DatasetInterpreter extends Interpreter {
+    static type = DatasetDescriptor.type
+}
+Interpreter.register(DatasetInterpreter)
+
+export {
+    DatasetInterpreter
+}

package/src/interpreter/DivInterpreter.ts

@@ -0,0 +1,44 @@
+import { Descriptor, DivDescriptor, UpdateArgs } from "../descriptor"
+import { Interpreter } from "./Interpreter"
+import { DivActor, HTMLActor } from "../actor"
+import { PickupObject } from "../graphics"
+
+class DivInterpreter extends Interpreter {
+    static type = DivDescriptor.type
+
+    protected createActor(descriptor: DivDescriptor, args: UpdateArgs) {
+        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)
+    }
+
+    mount(descriptor: DivDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
+        const actor = this.getActor<DivActor>(descriptor, args)
+
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor, args)
+        parenActor.add(actor)
+    }
+
+    unmount(descriptor: DivDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const actor = this.getActor<DivActor>(descriptor, args)
+        actor.clearStyleClass(actor.DOM)
+        actor.cleanInteraction()
+
+        const parenActor = parentInterpreter.getActor<HTMLActor>(parentDescriptor, args)
+        parenActor.remove(actor)
+
+        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+    }
+
+    pickup(descriptor: DivDescriptor, args: UpdateArgs, result: PickupObject[]) {
+        result.push({ uuid: descriptor.uuid, generatedBy: descriptor.generatedBy })
+    }
+}
+Interpreter.register(DivInterpreter)
+
+export { DivInterpreter }

package/src/interpreter/DynamicInterpreter.ts

@@ -0,0 +1,207 @@
+import { ArrayUtils } from "../ArrayUtils"
+import { Asset } from "../asset"
+import { DynamicDescriptor, Descriptor, UpdateArgs, Data, DatasetDescriptor, PrefabeDescriptor } from "../descriptor"
+import { observer, UpdateWatcherArgs, WatcherArgs } from "../graphics"
+import { Category } from "../Category"
+import { FragmentInterpreter, Interpreter } from "."
+
+class DynamicInterpreter extends FragmentInterpreter {
+    static type = DynamicDescriptor.type
+
+    private _currentDepth = 0
+    private _datasetCloneCollection = new Map<string, DatasetDescriptor>()
+    private _rawToCloneCollection = new Map<string, Descriptor[]>()
+    private _cloneCollection = new Map<number, Descriptor>()
+
+    private _getDataset(descriptor: Descriptor, dataCollection: Data, i: number) {
+        const url = Asset.createVirtualUrl(`dynamic/dataset/${descriptor.uuid}-${i}-${this._currentDepth}${Category.datasetSuffix}`)
+        if (this._datasetCloneCollection.has(url)) return url
+        const data = dataCollection[i]
+        const dataset = new DatasetDescriptor()
+        dataset.setExtraData({ index: i })
+        dataset.setData(data)
+        Asset.set(url, dataset)
+        this._datasetCloneCollection.set(url, dataset)
+        return url
+    }
+    private _getDataByDataset<T extends Data | null = Data | null>(url: string) {
+        const dataset = this._datasetCloneCollection.get(url)
+
+        return (dataset?.getData() ?? null) as T
+    }
+
+    private _setCache(raw: Descriptor, clone: Descriptor) {
+        let clones = this._rawToCloneCollection.get(raw.uuid)
+        if (clones === undefined) {
+            clones = []
+            this._rawToCloneCollection.set(raw.uuid, clones)
+        }
+        clones.push(clone)
+    }
+
+    private _markSubDynamic(raw: DynamicDescriptor, parent: Descriptor, generatedBy: string, map: Map<string, Descriptor>, childs: Descriptor[]) {
+        this._currentDepth += 1
+        const template = Asset.get<Descriptor>(raw.url)
+        if (raw.dataConfig === 2) {
+            const parentData = this._getDataByDataset(parent.dataset)
+            if (parentData === null || typeof parentData !== 'object') return
+            //TODO 使用路径解析工具，实现更强大属性支持
+            const pathData = parentData[raw.dataPath]
+            if (Array.isArray(pathData) === false || pathData.length === 0) return
+
+            for (let i = 0; i < pathData.length; i++) {
+                const dataset = this._getDataset(raw, pathData, i)
+                const clone = this._markAndClone(template, dataset, generatedBy, map, childs)
+                parent.add(clone)
+            }
+        } else {
+            const selfData = this._getDataByDataset(raw.dataset)
+            if (Array.isArray(selfData) === false || selfData.length === 0) return
+
+            for (let i = 0; i < selfData.length; i++) {
+                const dataset = this._getDataset(raw, selfData, i)
+                const clone = this._markAndClone(template, dataset, generatedBy, map, childs)
+                parent.add(clone)
+            }
+        }
+    }
+
+    private _markAndClone(raw: Descriptor, dataset: string, generatedBy: string, map: Map<string, Descriptor>, childs: Descriptor[]) {
+        let clone
+        if (raw instanceof DynamicDescriptor) {
+            clone = new Descriptor({ dataset })
+            if (raw.url) this._markSubDynamic(raw, clone, generatedBy, map, childs)
+        } else if (raw instanceof PrefabeDescriptor) {
+            clone = new Descriptor({ dataset })
+        } else {
+            clone = raw.clone(false)
+            clone.dataset = dataset
+            map.set(raw.uuid, clone)
+            if (clone.interactions.length > 0) childs.push(clone)
+        }
+
+        clone.generatedBy = generatedBy
+
+        for (const subRaw of raw.children) {
+            const subClone = this._markAndClone(subRaw, dataset, generatedBy, map, childs)
+            clone.add(subClone)
+        }
+
+        this._setCache(raw, clone)
+
+        return clone
+    }
+
+    private _onAdd = (args: WatcherArgs) => {
+        const clones = this._rawToCloneCollection.get(args.puid)
+        if (clones === undefined) return
+
+        const max = clones.length
+        const descriptor = Descriptor.get<Descriptor>(args.self)
+        for (let i = 0; i < max; i++) {
+            const clone = clones[i]
+            const map = new Map<string, Descriptor>()
+            const childs: Descriptor[] = []
+            const subClone = this._markAndClone(descriptor, clone.dataset, clone.generatedBy, map, childs)
+            Descriptor.fixReferences(childs, map)
+            clone.add(subClone)
+        }
+    }
+
+    private _onRemove = (args: WatcherArgs) => {
+        const clones = this._rawToCloneCollection.get(args.self)
+        if (clones === undefined) return
+
+        while (clones.length > 0) {
+            const clone = clones.pop()
+            if (clone === undefined) continue
+            const parent = this.graphics.getParent(clone.uuid)
+            if (parent === null) continue
+            parent.remove(clone)
+            ArrayUtils.remove(clones, clone)
+        }
+        const descriptor = Descriptor.get<Descriptor>(args.self)
+        descriptor.traverse(sub => {
+            this._rawToCloneCollection.delete(sub.uuid)
+        })
+    }
+
+    private _onUpdate = (args: UpdateWatcherArgs) => {
+        const clones = this._rawToCloneCollection.get(args.self)
+        if (clones === undefined) return
+
+        const raw = Descriptor.get<Descriptor>(args.self)
+        if (raw instanceof DynamicDescriptor) {
+            const ancestor = raw.traceAncestor()
+            if (ancestor.parent === null) return
+            const watcher = { self: args.self, puid: ancestor.parent.uuid }
+            this._onRemove(watcher)
+            this._onAdd(watcher)
+        } else {
+            for (const clone of clones) {
+                clone.syncWith(raw)
+                clone.setNeedsUpdate()
+            }
+        }
+    }
+
+    private _clearByOnUpdate = (args: WatcherArgs) => {
+        if (args.self !== this.unit.uuid) return
+
+        this._rawToCloneCollection.clear()
+        this._datasetCloneCollection.clear()
+
+        const clones = this._cloneCollection.values()
+        for (const clone of clones) {
+            observer.trigger('remove', { self: clone.uuid, puid: this.unit.uuid })
+        }
+        this._cloneCollection.clear()
+    }
+
+    mount(descriptor: Descriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor): void {
+        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
+        observer.listen('update', this._clearByOnUpdate)
+    }
+
+    unmount(descriptor: Descriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        observer.unlisten('update', this._clearByOnUpdate)
+        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+    }
+
+    update(descriptor: DynamicDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+
+        observer.unlisten('add', this._onAdd)
+        observer.unlisten('remove', this._onRemove)
+        observer.unlisten('update', this._onUpdate)
+
+        if (descriptor.dataset && descriptor.url) {
+            const rootData = DatasetDescriptor.getCollection(descriptor.dataset)
+            if (rootData.length > 0) {
+                const template = Asset.get<Descriptor>(descriptor.url)
+                for (let i = 0; i < rootData.length; i++) {
+                    this._currentDepth = 0
+                    const dataset = this._getDataset(descriptor, rootData, i)
+                    const map = new Map<string, Descriptor>()
+                    const childs: Descriptor[] = []
+                    const clone = this._markAndClone(template, dataset, descriptor.uuid, map, childs)
+                    Descriptor.fixReferences(childs, map)
+                    this._cloneCollection.set(i, clone)
+                    observer.trigger('add', { self: clone.uuid, puid: descriptor.uuid })
+                }
+            }
+        }
+
+        observer.listen('add', this._onAdd)
+        observer.listen('remove', this._onRemove)
+        observer.listen('update', this._onUpdate)
+    }
+
+    free(descriptor: Descriptor, args: UpdateArgs) {
+        observer.unlisten('add', this._onAdd)
+        observer.unlisten('remove', this._onRemove)
+        observer.unlisten('update', this._onUpdate)
+        super.free(descriptor, args)
+    }
+}
+FragmentInterpreter.register(DynamicInterpreter)

package/src/interpreter/FragmentInterpreter.ts

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

package/src/interpreter/HTMLServiceInterpreter.ts

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

package/src/interpreter/HTMLTransformControllerInterpreter.ts

@@ -0,0 +1,40 @@
+import { Descriptor, HTMLTransformControllerDescriptor, UpdateArgs } from "../descriptor"
+import { HTMLTransformControllerActor } from "../actor"
+import { Interpreter } from "./Interpreter"
+
+class HTMLTransformControllerInterpreter extends Interpreter {
+    static type = HTMLTransformControllerDescriptor.type
+
+    protected createActor(descriptor: HTMLTransformControllerDescriptor, args: UpdateArgs) {
+        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)
+    }
+
+    mount(descriptor: HTMLTransformControllerDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        super.mount(descriptor, args, parentInterpreter, parentDescriptor)
+        this.getActor<HTMLTransformControllerActor>(descriptor, args)
+    }
+
+    unmount(descriptor: HTMLTransformControllerDescriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) {
+        const actor = this.getActor<HTMLTransformControllerActor>(descriptor, args)
+        actor.unlisten()
+
+        super.unmount(descriptor, args, parentInterpreter, parentDescriptor)
+    }
+
+    free(descriptor: HTMLTransformControllerDescriptor, args: UpdateArgs) {
+        const actor = this.getActor<HTMLTransformControllerActor>(descriptor, args)
+        actor.dispose()
+        super.free(descriptor, args)
+    }
+}
+Interpreter.register(HTMLTransformControllerInterpreter)
+
+
+export { HTMLTransformControllerInterpreter }

package/src/interpreter/Interpreter.ts

@@ -0,0 +1,69 @@
+import { language } from '../locale'
+import { Actor } from '../actor'
+import { Unit, PickupObject, Graphics } from "../graphics"
+import { Descriptor, UpdateArgs } from "../descriptor"
+
+const privateState = {
+    factory: false,
+    classCollection: new Map<string, typeof Interpreter>(),
+    actorCollection: new Map<Interpreter, Actor>(),
+}
+
+/**
+ * 对描述进行解释，不同的扩展对每个描述都有不同的解释器
+ * 
+ * 警告：解释器在实现时不能对自身的描述器直接进行引用，从而导致描述器始终存在引用而无法被垃圾回收机制回收。
+ */
+class Interpreter {
+    static type = 'Interpreter'
+    static register(DerivedClass: typeof Interpreter) {
+        privateState.classCollection.set(DerivedClass.type, DerivedClass)
+    }
+    /**获取注册的派生类 */
+    static getClass<T extends typeof Interpreter>(type: string) {
+        return (privateState.classCollection.get(type) ?? null) as T | null
+    }
+
+    readonly unit
+    readonly graphics
+
+    constructor(unit: Unit, graphics: Graphics) {
+        if (privateState.factory === false) throw language.get('interpreter.new.fail')
+        this.unit = unit
+        this.graphics = graphics
+    }
+
+    protected createActor(descriptor: Descriptor, args: UpdateArgs) {
+        return new Actor()
+    }
+
+    /**使用描述器获取代理对象，若代理对象不存在则会使用描述器创建一个代理对象 */
+    getActor<T extends Actor = Actor>(descriptor: Descriptor, args: UpdateArgs): T {
+        let actor = privateState.actorCollection.get(this)
+        if (actor !== undefined) return actor as T
+        actor = this.createActor(descriptor, args)
+        Actor.seGraphics(actor, this.graphics)
+        privateState.actorCollection.set(this, actor)
+        return actor as T
+    }
+
+    /**使用描述更新节点 */
+    update(descriptor: Descriptor, args: UpdateArgs) { }
+
+    /**将节点挂载到场景 */
+    mount(descriptor: Descriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) { }
+
+    /**将节点从场景中卸载 */
+    unmount(descriptor: Descriptor, args: UpdateArgs, parentInterpreter: Interpreter, parentDescriptor: Descriptor) { }
+
+    free(descriptor: Descriptor, args: UpdateArgs) {
+        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[]) { }
+}
+
+export { Interpreter, privateState }

package/src/interpreter/PrefaInterpreter.ts

@@ -0,0 +1,11 @@
+import { PrefabeDescriptor } from "../descriptor";
+import { FragmentInterpreter } from "./FragmentInterpreter";
+
+class PrefaInterpreter extends FragmentInterpreter {
+    static type = PrefabeDescriptor.type
+}
+FragmentInterpreter.register(PrefaInterpreter)
+
+export {
+    PrefaInterpreter
+}

package/src/interpreter/PrefabInstanceInterpreter.ts

@@ -0,0 +1,12 @@
+import { PrefabInstanceDescriptor } from "../descriptor";
+import { FragmentInterpreter } from "./FragmentInterpreter";
+
+class PrefabInstanceInterpreter extends FragmentInterpreter {
+    static type = PrefabInstanceDescriptor.type
+
+}
+FragmentInterpreter.register(PrefabInstanceInterpreter)
+
+export {
+    PrefabInstanceInterpreter
+}

package/src/interpreter/RoutineInterpreter.ts

@@ -0,0 +1,88 @@
+import { Asset } from "../asset";
+import { Scriptable } from "../Scriptable";
+import { RoutineDescriptor, RoutineNode, UpdateArgs, InteractionInputCollection } from "../descriptor";
+import { Interpreter } from "./Interpreter";
+
+type ExecuteResult = { [k: string]: any } | null
+
+class RoutineInterpreter extends Interpreter {
+    static type = RoutineDescriptor.type
+    readonly collection = new Map<string, RoutineNode>()
+    readonly linkCollection = new Map<string, string[]>()
+
+    update(descriptor: RoutineDescriptor, args: UpdateArgs) {
+        super.update(descriptor, args)
+
+        this.collection.clear()
+        this.linkCollection.clear()
+
+        for (const node of descriptor.nodes) {
+            this.collection.set(node.id, node)
+        }
+
+        for (const mapper of descriptor.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, descriptor: RoutineDescriptor, args: UpdateArgs, result: Map<string, ExecuteResult>) {
+        this.doExecute(branch, previous, customInputs, descriptor, args, result)
+    }
+
+    async doCondition(condition: string, previous: string, customInputs: InteractionInputCollection, descriptor: RoutineDescriptor, args: UpdateArgs, result: Map<string, ExecuteResult>) {
+        const preResult = result.get(previous)
+        const conditionResult = result.get(condition)
+        if (preResult !== conditionResult?.condition.value) return
+
+        this.doExecute(condition, previous, customInputs, descriptor, args, result)
+    }
+
+    async doExecute(execute: string, previous: string, customInputs: InteractionInputCollection, descriptor: RoutineDescriptor, args: UpdateArgs, result: Map<string, ExecuteResult>) {
+        const nexts = this.linkCollection.get(execute)
+        if (nexts === undefined) return
+
+        for (const next of nexts) {
+            await this.doNext(next, execute, customInputs, descriptor, args, result)
+        }
+    }
+
+    async doNext(current: string, previous: string, customInputs: InteractionInputCollection, descriptor: RoutineDescriptor, args: UpdateArgs, result: Map<string, ExecuteResult>) {
+        const active = this.collection.get(current)
+        if (active === undefined) return
+
+        const currentInput = customInputs[current] ?? {}
+        const script = Asset.get<Scriptable>(active.url)
+        if (script) {
+            const event = { ...args, input: { previous, default: active.input, user: currentInput }, result }
+            const executeResult = await script.execute(descriptor, this.graphics, event)
+            result.set(current, executeResult)
+        }
+
+        if (active.routine === 'Branch') {
+            this.doBranch(current, previous, customInputs, descriptor, args, result)
+        } else if (active.routine === 'Condition') {
+            if (result.has(current) === false) result.set(current, active.input)
+            this.doCondition(current, previous, customInputs, descriptor, args, result)
+        } else {
+            this.doExecute(current, previous, customInputs, descriptor, args, result)
+        }
+    }
+
+    do(customInputs: InteractionInputCollection, descriptor: RoutineDescriptor, args: UpdateArgs) {
+        for (const root of descriptor.roots) {
+            const resultCollection = new Map()
+            this.doNext(root, '', customInputs, descriptor, args, resultCollection)
+        }
+    }
+
+}
+Interpreter.register(RoutineInterpreter)
+
+export {
+    RoutineInterpreter
+}

package/src/interpreter/ServiceInterpreter.ts

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