@vyr/engine 0.0.32 → 0.0.34

package/src/ObjectPool.ts

@@ -1,84 +1,83 @@
-import { Generate } from "./Generate"
-
-const privateState = {
-  instances: new Map<string, WeakRef<ObjectPool>>(),
-  freeWatcher: [] as Array<(uuid: string) => void>,
-  monitoring: () => {
-    let currentIndex = 0
-
-    const loop = () => {
-      setTimeout(loop, 5000)
-
-      const uuids = [...privateState.instances.keys()]
-      const total = uuids.length
-
-      if (currentIndex >= total) currentIndex = 0
-
-      let count = 0
-      let startIndex = currentIndex
-      const startTime = performance.now()
-
-      while (count < 500 && performance.now() - startTime < 5) {
-        if (startIndex >= total) break
-        count++
-        const uuid = uuids[startIndex++]
-        ObjectPool.get(uuid) === null ? destroyInstance(uuid) : currentIndex++
-      }
-    }
-
-    loop()
-  },
-}
-
-const listenInstance = (type: 'free', watcher: (uuid: string) => void) => {
-  switch (type) {
-    case 'free':
-      privateState.freeWatcher.push(watcher)
-      break;
-    default:
-      break;
-  }
-}
-
-/**将实例销毁并回收相关资源 */
-const destroyInstance = (uuid: string) => {
-  const instance = privateState.instances.get(uuid)
-  if (instance === undefined) return
-  for (const free of privateState.freeWatcher) free(uuid)
-  privateState.instances.delete(uuid)
-}
-
-/**对象池
- * 
- * 以`uuid`为标识，同一个`uuid`只会存在一个实例
- */
-class ObjectPool {
-  /**获取缓存实例 */
-  static get<T extends ObjectPool | null = ObjectPool | null>(uuid: string) {
-    const instance = privateState.instances.get(uuid)
-    if (instance === undefined) return null as T
-    return (instance.deref() ?? null) as T
-  }
-
-  readonly uuid!: string
-  /**
-   * @param uuid 实例的唯一标识
-   */
-  constructor(uuid = Generate.uuid()) {
-    const instance = ObjectPool.get(uuid)
-    if (instance !== null) {
-      instance.beenInstantiated(instance)
-      return instance
-    }
-    this.uuid = uuid
-
-    privateState.instances.set(uuid, new WeakRef(this))
-  }
-
-  /**若在初始化时发现已存在相同uuid的实例，则会调用该方法 */
-  protected beenInstantiated(instance: ObjectPool) { }
-}
-
-privateState.monitoring()
-
-export { listenInstance, destroyInstance, ObjectPool }
+import { Generate } from "./Generate"
+
+const privateState = {
+  instances: new Map<string, WeakRef<ObjectPool>>(),
+  freeWatcher: [] as Array<(uuid: string) => void>,
+  monitoring: () => {
+    let currentIndex = 0
+
+    const loop = () => {
+      setTimeout(loop, 5000)
+
+      const uuids = [...privateState.instances.keys()]
+      const total = uuids.length
+
+      if (currentIndex >= total) currentIndex = 0
+
+      let count = 0
+      let startIndex = currentIndex
+      const startTime = performance.now()
+
+      while (count < 500 && performance.now() - startTime < 5) {
+        if (startIndex >= total) break
+        count++
+        const uuid = uuids[startIndex++]
+        ObjectPool.get(uuid) === null ? destroyInstance(uuid) : currentIndex++
+      }
+    }
+
+    loop()
+  },
+}
+
+export const listenInstance = (type: 'free', watcher: (uuid: string) => void) => {
+  switch (type) {
+    case 'free':
+      privateState.freeWatcher.push(watcher)
+      break;
+    default:
+      break;
+  }
+}
+
+/**将实例销毁并回收相关资源 */
+export const destroyInstance = (uuid: string) => {
+  const instance = privateState.instances.get(uuid)
+  if (instance === undefined) return
+  for (const free of privateState.freeWatcher) free(uuid)
+  privateState.instances.delete(uuid)
+}
+
+/**对象池
+ * 
+ */
+export class ObjectPool {
+  /**获取缓存实例 */
+  static get<T extends ObjectPool | null = ObjectPool | null>(uuid: string) {
+    const instance = privateState.instances.get(uuid)
+    if (instance === undefined) return null as T
+    return (instance.deref() ?? null) as T
+  }
+
+  /**节点标识
+   * 
+   * `uuid` 必须保证全局唯一，使用标准的 uuid v4 算法
+   */
+  readonly uuid!: string
+
+  constructor(uuid = Generate.uuid()) {
+    const instance = ObjectPool.get(uuid)
+    if (instance !== null) {
+      instance.beenInstantiated(instance)
+      return instance
+    }
+    this.uuid = uuid
+
+    privateState.instances.set(uuid, new WeakRef(this))
+  }
+
+  /**若在初始化时发现已存在相同uuid的实例，则会调用该方法 */
+  protected beenInstantiated(instance: ObjectPool) { }
+}
+
+privateState.monitoring()

package/src/ObjectUtils.ts

@@ -1,49 +1,97 @@
-import { ArrayUtils } from "./ArrayUtils"
-class ObjectUtils {
-
-    static equals(left: { [k: string]: any }, right: { [k: string]: any }, ignore: string[] = []) {
-        const keys = Object.keys(left)
-        const rkeys = Object.keys(right)
-        if (keys.length !== rkeys.length) return false
-        const rset = new Set(rkeys)
-        for (const key of keys) {
-            if (rset.has(key) === false) return false
-            if (ignore.includes(key)) continue
-
-            const value = left[key]
-            const t = typeof value
-
-            if (t === 'string' || t === 'boolean' || t === 'number' || t === 'bigint' || t === 'undefined' || t === 'symbol' || t === null) {
-                if (value !== right[key]) return false
-            }
-
-            if (Array.isArray(value)) {
-                if (ArrayUtils.equals(value, right[key], ignore) == false) return false
-                continue
-            }
-
-            if (t === 'object') {
-                if (ObjectUtils.equals(value, right[key], ignore) === false) return false
-                continue
-            }
-        }
-
-        return true
-    }
-
-    static parseKey(key: string) {
-        return key.split('.').filter(clip => clip !== '')
-    }
-    
-    static getValueByKey(target: { [k: string]: any }, key: string) {
-        if (!target) return
-        const keys = this.parseKey(key)
-        for (const key of keys) {
-            target = target[key]
-            if (target === undefined) return
-        }
-        return target
-    }
-}
-
-export { ObjectUtils }
+import { ArrayUtils } from "./ArrayUtils"
+
+interface BaseObject {
+    [k: string]: any
+}
+
+export class ObjectUtils {
+
+    static equals(left: BaseObject, right: BaseObject, ignore: string[] = []) {
+        const keys = Object.keys(left)
+        const rkeys = Object.keys(right)
+        if (keys.length !== rkeys.length) return false
+        const rset = new Set(rkeys)
+        for (const key of keys) {
+            if (rset.has(key) === false) return false
+            if (ignore.includes(key)) continue
+
+            const value = left[key]
+            const t = typeof value
+
+            if (t === 'string' || t === 'boolean' || t === 'number' || t === 'bigint' || t === 'undefined' || t === 'symbol' || t === null) {
+                if (value !== right[key]) return false
+            }
+
+            if (Array.isArray(value)) {
+                if (ArrayUtils.equals(value, right[key], ignore) == false) return false
+                continue
+            }
+
+            if (t === 'object') {
+                if (ObjectUtils.equals(value, right[key], ignore) === false) return false
+                continue
+            }
+        }
+
+        return true
+    }
+
+    static isObject(obj?: BaseObject | null) {
+        return obj !== null && typeof obj === 'object'
+    }
+
+    static getValueByKey(target: BaseObject, propertyPath: string) {
+        let value
+        this.nextByPropertyPath(target, propertyPath, (property, key) => {
+            value = property[key]
+        })
+        return value
+    }
+
+    static doArrayKey(target: BaseObject, propertyPath: string) {
+        const [name, ...indexClips] = propertyPath.split('[')
+        const max = indexClips.length - 1
+
+        target = target[name]
+        let key = ''
+        for (let i = 0; i <= max; i++) {
+            key = indexClips[i].slice(0, -1)
+            if (i === max) break
+            target[key]
+        }
+
+        return {
+            target,
+            key,
+        }
+    }
+
+    static nextByPropertyPath(target: BaseObject, propertyPath: string, end: (property: BaseObject, key: string) => void) {
+        const keys = propertyPath.split('.')
+        const max = keys.length - 1
+        let property = target
+
+        for (let i = 0; i <= max; i++) {
+            const key = keys[i]
+
+            if (ObjectUtils.isObject(property) === false) break
+
+            if (key.endsWith(']')) {
+                const result = this.doArrayKey(property, key)
+                if (i === max) {
+                    end(result.target, result.key)
+                    break
+                }
+                property = result.target[result.key]
+
+            } else {
+                if (i === max) {
+                    end(property, key)
+                    break
+                }
+                property = property[key]
+            }
+            if (property === undefined) break
+        }
+    }
+}

package/src/Scriptable.ts

@@ -0,0 +1,82 @@
+import z from 'zod'
+import { ObjectUtils } from './ObjectUtils'
+import { Graphics } from "./graphics/Graphics"
+
+export const scriptableInputSchame = z.object().catchall(z.any())
+
+export type ScriptableInput = z.infer<typeof scriptableInputSchame>
+
+export interface ScriptableArgs {
+    result: Map<string, any>,
+    previous: string
+}
+
+/**
+ * 可编程脚本(脚本不会在服务端实例化)
+ */
+export class Scriptable {
+    private static defineCollection = new Map<string, typeof Scriptable>()
+    private static instanceCollection = new Map<string, Scriptable>()
+    static register(Define: typeof Scriptable) {
+        this.defineCollection.set(Define.id, Define)
+    }
+    static use(id: string) {
+        let instance = this.instanceCollection.get(id)
+        if (instance === undefined) {
+            const Define = this.defineCollection.get(id)
+            if (Define === undefined) return null
+            instance = new Define()
+            this.instanceCollection.set(id, instance)
+        }
+        return instance
+    }
+    static list() {
+        const values = this.defineCollection.values()
+        const options: { id: string, name: string }[] = []
+        for (const Define of values) {
+            options.push({ id: Define.id, name: Define.name })
+        }
+        return options
+    }
+    static get(id: string) {
+        return this.defineCollection.get(id) ?? null
+    }
+    static id = ''
+    static name = ''
+    static inputSchame: z.ZodObject | z.ZodUnion<readonly z.ZodType<any>[]> = scriptableInputSchame
+    static outputSchame?: z.ZodType | z.ZodUnion
+
+    readonly id: string
+    readonly name: string
+    readonly inputSchame
+    readonly outputSchame
+
+    constructor() {
+        this.id = (this.constructor as typeof Scriptable).id
+        this.name = (this.constructor as typeof Scriptable).name
+        this.inputSchame = (this.constructor as typeof Scriptable).inputSchame
+        this.outputSchame = (this.constructor as typeof Scriptable).outputSchame
+    }
+
+    /**脚本的准备事件，该方法在脚本被实例化后立即执行
+     * 
+     * 一般在该事件中进行脚本的准备工作，如从服务端获取资源或数据
+     */
+    async ready() { }
+
+    aggregateResults(defaultValue: { [k: string]: any }, ids: string, args?: ScriptableArgs) {
+        const idClips = ids.split(',')
+
+        if (args === undefined) return defaultValue
+        for (const id of idClips) {
+            const value = args.result.get(id)
+            if (ObjectUtils.isObject(value)) {
+                Object.assign(defaultValue, value)
+            }
+        }
+
+        return defaultValue
+    }
+
+    execute(graphics: Graphics, trigger: string, input: ScriptableInput, args?: ScriptableArgs): any { }
+}

package/src/Serialization.ts

@@ -1,8 +1,8 @@
-interface SerializationObject {
+export interface SerializationObject {
   [k: string]: any
 }
 
-type DeserializationObject<T extends { [k: string]: any } = { [k: string]: any }> = {
+export type DeserializationObject<T extends { [k: string]: any } = { [k: string]: any }> = {
   -readonly [K in keyof T as T[K] extends Function ? never : K]:
   T[K] extends Array<infer U>
   ? U extends { [k: string]: any }
@@ -31,7 +31,7 @@ const privateToJson = (key: string, value: any) => {
   return value
 }
 
-class Serialization {
+export class Serialization {
 
   static stringify(obj: SerializationObject) {
     return JSON.stringify(obj, privateToStringify)
@@ -44,6 +44,4 @@ class Serialization {
   static deepClone<T extends any = any>(obj: SerializationObject) {
     return this.parse(this.stringify(obj)) as T
   }
-}
-
-export { SerializationObject, DeserializationObject, Serialization }
+}

package/src/Traverser.ts

@@ -1,39 +1,41 @@
-interface TraverseNode {
-    children: TraverseNode[]
-}
-interface PreItem<T extends TraverseNode = TraverseNode> {
-    parent: T | null
-    des: T
-}
-
-/**遍历器 */
-class Traverser {
-
-    /**前序遍历 */
-    static pre<T extends TraverseNode = TraverseNode, D extends T | null = null>(descriptor: T, cb: (sub: T, parent: D) => void, defaultParent: D = null as D) {
-        const whileQuaua: PreItem<T>[] = [{ parent: defaultParent, des: descriptor }]
-
-        while (whileQuaua.length > 0) {
-            const item = whileQuaua.pop() as PreItem<T>
-            cb(item.des, item.parent as D)
-            for (let i = item.des.children.length - 1; i >= 0; i--) {
-                whileQuaua.push({ parent: item.des, des: item.des.children[i] as T })
-            }
-        }
-    }
-
-    /**前序遍历且可以终止 */
-    static preTerminated<T extends TraverseNode = TraverseNode, D extends T | null = null>(descriptor: T, cb: (sub: T, parent: D) => true | void, defaultParent: D = null as D) {
-        const whileQuaua: PreItem<T>[] = [{ parent: defaultParent, des: descriptor }]
-
-        while (whileQuaua.length > 0) {
-            const item = whileQuaua.pop() as PreItem<T>
-            if (cb(item.des, item.parent as D) === true) continue
-            for (let i = item.des.children.length - 1; i >= 0; i--) {
-                whileQuaua.push({ parent: item.des, des: item.des.children[i] as T })
-            }
-        }
-    }
-}
-
-export { Traverser }
+export interface TraverseNode {
+    children: TraverseNode[]
+}
+export interface PreItem<T extends TraverseNode = TraverseNode> {
+    parent: T | null
+    des: T
+}
+
+/**遍历器 */
+export class Traverser {
+
+    /**前序遍历 */
+    static pre<T extends TraverseNode = TraverseNode, D extends T | null = null>(descriptor: T, cb: (sub: T, parent: D) => void, defaultParent: D = null as D) {
+        const whileQuaua: PreItem<T>[] = [{ parent: defaultParent, des: descriptor }]
+
+        while (whileQuaua.length > 0) {
+            const item = whileQuaua.pop() as PreItem<T>
+            cb(item.des, item.parent as D)
+            const children = item.des.children
+            if (Array.isArray(children) === false) continue
+            for (let i = children.length - 1; i >= 0; i--) {
+                whileQuaua.push({ parent: item.des, des: children[i] as T })
+            }
+        }
+    }
+
+    /**前序遍历且可以终止 */
+    static preTerminated<T extends TraverseNode = TraverseNode, D extends T | null = null>(descriptor: T, cb: (sub: T, parent: D) => true | void, defaultParent: D = null as D) {
+        const whileQuaua: PreItem<T>[] = [{ parent: defaultParent, des: descriptor }]
+
+        while (whileQuaua.length > 0) {
+            const item = whileQuaua.pop() as PreItem<T>
+            if (cb(item.des, item.parent as D) === true) continue
+            const children = item.des.children
+            if (Array.isArray(children) === false) continue
+            for (let i = children.length - 1; i >= 0; i--) {
+                whileQuaua.push({ parent: item.des, des: children[i] as T })
+            }
+        }
+    }
+}

package/src/actor/Actor.ts

@@ -1,28 +1,24 @@
-import { Graphics } from '../graphics/Graphics'
-
-const privateState = {
-    idBuilder: 0,
-    collection: new Map<number, Graphics>()
-}
-
-class Actor {
-    static seGraphics(actor: Actor, graphics: Graphics) {
-        privateState.collection.set(actor.id, graphics)
-    }
-    static getGraphics<T extends Graphics = Graphics>(actor: Actor) {
-        return (privateState.collection.get(actor.id) ?? null) as T
-    }
-    static deleteGraphics(actor: Actor) {
-        privateState.collection.delete(actor.id)
-    }
-    readonly id = privateState.idBuilder++
-    object?: any
-
-    add(actor: Actor) { }
-
-    remove(actor: Actor) { }
-}
-
-export {
-    Actor,
+import { Graphics } from '../graphics/Graphics'
+
+const privateState = {
+    idBuilder: 0,
+    collection: new Map<number, Graphics>()
+}
+
+export class Actor {
+    static seGraphics(actor: Actor, graphics: Graphics) {
+        privateState.collection.set(actor.id, graphics)
+    }
+    static getGraphics<T extends Graphics = Graphics>(actor: Actor) {
+        return (privateState.collection.get(actor.id) ?? null) as T
+    }
+    static deleteGraphics(actor: Actor) {
+        privateState.collection.delete(actor.id)
+    }
+    readonly id = privateState.idBuilder++
+    object?: any
+
+    add(actor: Actor) { }
+
+    remove(actor: Actor) { }
 }